QLHazyCoder
500 lines
21 KiB
JavaScript
500 lines
21 KiB
JavaScript
(function attachMultiPageSettingsSchema(root, factory) {
|
|
root.MultiPageSettingsSchema = factory();
|
|
})(typeof self !== 'undefined' ? self : globalThis, function createSettingsSchemaModule() {
|
|
function isPlainObject(value) {
|
|
return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
|
|
}
|
|
|
|
function cloneValue(value) {
|
|
if (Array.isArray(value)) {
|
|
return value.map((entry) => cloneValue(entry));
|
|
}
|
|
if (isPlainObject(value)) {
|
|
return Object.fromEntries(
|
|
Object.entries(value).map(([key, entryValue]) => [key, cloneValue(entryValue)])
|
|
);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
function normalizeStepExecutionRangeEntry(value = {}, fallback = {}) {
|
|
const source = isPlainObject(value) ? value : {};
|
|
const fallbackSource = isPlainObject(fallback) ? fallback : {};
|
|
const fromStep = Math.max(1, Number(source.fromStep ?? fallbackSource.fromStep ?? 1) || 1);
|
|
const toStep = Math.max(fromStep, Number(source.toStep ?? fallbackSource.toStep ?? fromStep) || fromStep);
|
|
return {
|
|
enabled: Boolean(source.enabled ?? fallbackSource.enabled),
|
|
fromStep,
|
|
toStep,
|
|
};
|
|
}
|
|
|
|
function createSettingsSchema(deps = {}) {
|
|
const rootScope = typeof self !== 'undefined' ? self : globalThis;
|
|
const flowRegistry = deps.flowRegistry || rootScope.MultiPageFlowRegistry || {};
|
|
const defaultFlowId = String(
|
|
deps.defaultFlowId || flowRegistry.DEFAULT_FLOW_ID || 'openai'
|
|
).trim().toLowerCase() || 'openai';
|
|
const defaultOpenAiTargetId = flowRegistry.DEFAULT_OPENAI_TARGET_ID || 'cpa';
|
|
const defaultKiroTargetId = flowRegistry.DEFAULT_KIRO_TARGET_ID || 'kiro-rs';
|
|
const defaultKiroRsUrl = String(flowRegistry.DEFAULT_KIRO_RS_URL || '').trim();
|
|
const normalizeFlowId = typeof flowRegistry.normalizeFlowId === 'function'
|
|
? flowRegistry.normalizeFlowId
|
|
: ((value = '', fallback = defaultFlowId) => {
|
|
const normalized = String(value || '').trim().toLowerCase();
|
|
return normalized || String(fallback || '').trim().toLowerCase() || defaultFlowId;
|
|
});
|
|
const normalizeTargetId = typeof flowRegistry.normalizeTargetId === 'function'
|
|
? flowRegistry.normalizeTargetId
|
|
: ((_flowId, value = '', fallback = '') => String(value || fallback || '').trim().toLowerCase());
|
|
const normalizePlusAccountAccessStrategy = (value = '') => (
|
|
String(value || '').trim().toLowerCase() === 'sub2api_codex_session'
|
|
? 'sub2api_codex_session'
|
|
: 'oauth'
|
|
);
|
|
|
|
function buildDefaultSettingsState() {
|
|
return {
|
|
schemaVersion: 4,
|
|
activeFlowId: defaultFlowId,
|
|
services: {
|
|
account: {
|
|
customPassword: '',
|
|
},
|
|
email: {
|
|
provider: '163',
|
|
},
|
|
proxy: {
|
|
enabled: false,
|
|
provider: '711proxy',
|
|
mode: 'account',
|
|
},
|
|
},
|
|
flows: {
|
|
openai: {
|
|
integrationTargetId: defaultOpenAiTargetId,
|
|
integrationTargets: {
|
|
cpa: {
|
|
vpsUrl: '',
|
|
vpsPassword: '',
|
|
localCpaStep9Mode: 'submit',
|
|
},
|
|
sub2api: {
|
|
sub2apiUrl: '',
|
|
sub2apiEmail: '',
|
|
sub2apiPassword: '',
|
|
sub2apiGroupName: 'codex',
|
|
sub2apiGroupNames: ['codex', 'openai-plus'],
|
|
sub2apiAccountPriority: 1,
|
|
sub2apiDefaultProxyName: '',
|
|
},
|
|
codex2api: {
|
|
codex2apiUrl: '',
|
|
codex2apiAdminKey: '',
|
|
},
|
|
},
|
|
signup: {
|
|
signupMethod: 'email',
|
|
phoneVerificationEnabled: false,
|
|
phoneSignupReloginAfterBindEmailEnabled: false,
|
|
},
|
|
plus: {
|
|
plusModeEnabled: false,
|
|
plusPaymentMethod: 'paypal',
|
|
plusAccountAccessStrategy: 'oauth',
|
|
},
|
|
autoRun: {
|
|
stepExecutionRange: {
|
|
enabled: false,
|
|
fromStep: 1,
|
|
toStep: 11,
|
|
},
|
|
},
|
|
},
|
|
kiro: {
|
|
targetId: defaultKiroTargetId,
|
|
targets: {
|
|
'kiro-rs': {
|
|
baseUrl: defaultKiroRsUrl,
|
|
apiKey: '',
|
|
},
|
|
},
|
|
autoRun: {
|
|
stepExecutionRange: {
|
|
enabled: false,
|
|
fromStep: 1,
|
|
toStep: 9,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
function getIntegrationTargetValue(settingsState, pathGetter, fallback = {}) {
|
|
return cloneValue(pathGetter(isPlainObject(settingsState) ? settingsState : {}) || fallback);
|
|
}
|
|
|
|
function normalizeSettingsState(input = {}, options = {}) {
|
|
const defaults = buildDefaultSettingsState();
|
|
const nested = isPlainObject(input?.settingsState)
|
|
? input.settingsState
|
|
: (isPlainObject(input) && isPlainObject(input.flows) && isPlainObject(input.services) ? input : {});
|
|
const activeFlowId = normalizeFlowId(
|
|
input?.activeFlowId
|
|
?? nested?.activeFlowId
|
|
?? options?.activeFlowId
|
|
?? defaults.activeFlowId,
|
|
defaults.activeFlowId
|
|
);
|
|
const openaiIntegrationTargetId = normalizeTargetId(
|
|
'openai',
|
|
nested?.flows?.openai?.integrationTargetId
|
|
?? input?.openaiIntegrationTargetId
|
|
?? input?.panelMode
|
|
?? defaults.flows.openai.integrationTargetId,
|
|
defaults.flows.openai.integrationTargetId
|
|
);
|
|
const kiroTargetId = normalizeTargetId(
|
|
'kiro',
|
|
nested?.flows?.kiro?.targetId
|
|
?? input?.kiroTargetId
|
|
?? defaults.flows.kiro.targetId,
|
|
defaults.flows.kiro.targetId
|
|
);
|
|
const stepExecutionRangeByFlow = isPlainObject(input?.stepExecutionRangeByFlow)
|
|
? input.stepExecutionRangeByFlow
|
|
: {};
|
|
|
|
return {
|
|
schemaVersion: Number(input?.settingsSchemaVersion || nested?.schemaVersion || defaults.schemaVersion) || defaults.schemaVersion,
|
|
activeFlowId,
|
|
services: {
|
|
email: {
|
|
provider: String(
|
|
nested?.services?.email?.provider
|
|
?? input?.mailProvider
|
|
?? defaults.services.email.provider
|
|
).trim() || defaults.services.email.provider,
|
|
},
|
|
proxy: {
|
|
enabled: Boolean(
|
|
nested?.services?.proxy?.enabled
|
|
?? input?.ipProxyEnabled
|
|
?? defaults.services.proxy.enabled
|
|
),
|
|
provider: String(
|
|
nested?.services?.proxy?.provider
|
|
?? input?.ipProxyService
|
|
?? defaults.services.proxy.provider
|
|
).trim() || defaults.services.proxy.provider,
|
|
mode: String(
|
|
nested?.services?.proxy?.mode
|
|
?? input?.ipProxyMode
|
|
?? defaults.services.proxy.mode
|
|
).trim() || defaults.services.proxy.mode,
|
|
},
|
|
account: {
|
|
customPassword: String(
|
|
input?.customPassword
|
|
?? nested?.services?.account?.customPassword
|
|
?? defaults.services.account.customPassword
|
|
).trim(),
|
|
},
|
|
},
|
|
flows: {
|
|
openai: {
|
|
integrationTargetId: openaiIntegrationTargetId,
|
|
integrationTargets: {
|
|
cpa: {
|
|
...defaults.flows.openai.integrationTargets.cpa,
|
|
...getIntegrationTargetValue(nested, (state) => state.flows?.openai?.integrationTargets?.cpa),
|
|
vpsUrl: String(
|
|
input?.vpsUrl
|
|
?? nested?.flows?.openai?.integrationTargets?.cpa?.vpsUrl
|
|
?? ''
|
|
).trim(),
|
|
vpsPassword: String(
|
|
input?.vpsPassword
|
|
?? nested?.flows?.openai?.integrationTargets?.cpa?.vpsPassword
|
|
?? ''
|
|
),
|
|
localCpaStep9Mode: String(
|
|
input?.localCpaStep9Mode
|
|
?? nested?.flows?.openai?.integrationTargets?.cpa?.localCpaStep9Mode
|
|
?? defaults.flows.openai.integrationTargets.cpa.localCpaStep9Mode
|
|
).trim() || defaults.flows.openai.integrationTargets.cpa.localCpaStep9Mode,
|
|
},
|
|
sub2api: {
|
|
...defaults.flows.openai.integrationTargets.sub2api,
|
|
...getIntegrationTargetValue(nested, (state) => state.flows?.openai?.integrationTargets?.sub2api),
|
|
sub2apiUrl: String(
|
|
input?.sub2apiUrl
|
|
?? nested?.flows?.openai?.integrationTargets?.sub2api?.sub2apiUrl
|
|
?? ''
|
|
).trim(),
|
|
sub2apiEmail: String(
|
|
input?.sub2apiEmail
|
|
?? nested?.flows?.openai?.integrationTargets?.sub2api?.sub2apiEmail
|
|
?? ''
|
|
).trim(),
|
|
sub2apiPassword: String(
|
|
input?.sub2apiPassword
|
|
?? nested?.flows?.openai?.integrationTargets?.sub2api?.sub2apiPassword
|
|
?? ''
|
|
),
|
|
sub2apiGroupName: String(
|
|
input?.sub2apiGroupName
|
|
?? nested?.flows?.openai?.integrationTargets?.sub2api?.sub2apiGroupName
|
|
?? defaults.flows.openai.integrationTargets.sub2api.sub2apiGroupName
|
|
).trim() || defaults.flows.openai.integrationTargets.sub2api.sub2apiGroupName,
|
|
sub2apiGroupNames: Array.isArray(input?.sub2apiGroupNames)
|
|
? input.sub2apiGroupNames.map((entry) => String(entry || '').trim()).filter(Boolean)
|
|
: (Array.isArray(nested?.flows?.openai?.integrationTargets?.sub2api?.sub2apiGroupNames)
|
|
? nested.flows.openai.integrationTargets.sub2api.sub2apiGroupNames.map((entry) => String(entry || '').trim()).filter(Boolean)
|
|
: [...defaults.flows.openai.integrationTargets.sub2api.sub2apiGroupNames]),
|
|
sub2apiAccountPriority: Math.max(1, Number(
|
|
input?.sub2apiAccountPriority
|
|
?? nested?.flows?.openai?.integrationTargets?.sub2api?.sub2apiAccountPriority
|
|
?? defaults.flows.openai.integrationTargets.sub2api.sub2apiAccountPriority
|
|
) || defaults.flows.openai.integrationTargets.sub2api.sub2apiAccountPriority),
|
|
sub2apiDefaultProxyName: String(
|
|
input?.sub2apiDefaultProxyName
|
|
?? nested?.flows?.openai?.integrationTargets?.sub2api?.sub2apiDefaultProxyName
|
|
?? ''
|
|
).trim(),
|
|
},
|
|
codex2api: {
|
|
...defaults.flows.openai.integrationTargets.codex2api,
|
|
...getIntegrationTargetValue(nested, (state) => state.flows?.openai?.integrationTargets?.codex2api),
|
|
codex2apiUrl: String(
|
|
input?.codex2apiUrl
|
|
?? nested?.flows?.openai?.integrationTargets?.codex2api?.codex2apiUrl
|
|
?? ''
|
|
).trim(),
|
|
codex2apiAdminKey: String(
|
|
input?.codex2apiAdminKey
|
|
?? nested?.flows?.openai?.integrationTargets?.codex2api?.codex2apiAdminKey
|
|
?? ''
|
|
).trim(),
|
|
},
|
|
},
|
|
signup: {
|
|
signupMethod: String(
|
|
input?.signupMethod
|
|
?? nested?.flows?.openai?.signup?.signupMethod
|
|
?? defaults.flows.openai.signup.signupMethod
|
|
).trim().toLowerCase() === 'phone' ? 'phone' : 'email',
|
|
phoneVerificationEnabled: Boolean(
|
|
input?.phoneVerificationEnabled
|
|
?? nested?.flows?.openai?.signup?.phoneVerificationEnabled
|
|
?? defaults.flows.openai.signup.phoneVerificationEnabled
|
|
),
|
|
phoneSignupReloginAfterBindEmailEnabled: Boolean(
|
|
input?.phoneSignupReloginAfterBindEmailEnabled
|
|
?? nested?.flows?.openai?.signup?.phoneSignupReloginAfterBindEmailEnabled
|
|
?? defaults.flows.openai.signup.phoneSignupReloginAfterBindEmailEnabled
|
|
),
|
|
},
|
|
plus: {
|
|
plusModeEnabled: Boolean(
|
|
input?.plusModeEnabled
|
|
?? nested?.flows?.openai?.plus?.plusModeEnabled
|
|
?? defaults.flows.openai.plus.plusModeEnabled
|
|
),
|
|
plusPaymentMethod: String(
|
|
input?.plusPaymentMethod
|
|
?? nested?.flows?.openai?.plus?.plusPaymentMethod
|
|
?? defaults.flows.openai.plus.plusPaymentMethod
|
|
).trim() || defaults.flows.openai.plus.plusPaymentMethod,
|
|
plusAccountAccessStrategy: normalizePlusAccountAccessStrategy(
|
|
input?.plusAccountAccessStrategy
|
|
?? nested?.flows?.openai?.plus?.plusAccountAccessStrategy
|
|
?? defaults.flows.openai.plus.plusAccountAccessStrategy
|
|
),
|
|
},
|
|
autoRun: {
|
|
stepExecutionRange: normalizeStepExecutionRangeEntry(
|
|
nested?.flows?.openai?.autoRun?.stepExecutionRange
|
|
?? stepExecutionRangeByFlow.openai
|
|
?? {},
|
|
defaults.flows.openai.autoRun.stepExecutionRange
|
|
),
|
|
},
|
|
},
|
|
kiro: {
|
|
targetId: kiroTargetId,
|
|
targets: {
|
|
'kiro-rs': {
|
|
...defaults.flows.kiro.targets['kiro-rs'],
|
|
...getIntegrationTargetValue(nested, (state) => state.flows?.kiro?.targets?.['kiro-rs']),
|
|
baseUrl: String(
|
|
input?.kiroRsUrl
|
|
?? input?.kiroRsBaseUrl
|
|
?? nested?.flows?.kiro?.targets?.['kiro-rs']?.baseUrl
|
|
?? defaults.flows.kiro.targets['kiro-rs'].baseUrl
|
|
).trim() || defaults.flows.kiro.targets['kiro-rs'].baseUrl,
|
|
apiKey: String(
|
|
input?.kiroRsKey
|
|
?? input?.kiroRsApiKey
|
|
?? nested?.flows?.kiro?.targets?.['kiro-rs']?.apiKey
|
|
?? defaults.flows.kiro.targets['kiro-rs'].apiKey
|
|
),
|
|
},
|
|
},
|
|
autoRun: {
|
|
stepExecutionRange: normalizeStepExecutionRangeEntry(
|
|
nested?.flows?.kiro?.autoRun?.stepExecutionRange
|
|
?? stepExecutionRangeByFlow.kiro
|
|
?? {},
|
|
defaults.flows.kiro.autoRun.stepExecutionRange
|
|
),
|
|
},
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
function mergeSettingsState(baseValue = {}, patchValue = {}) {
|
|
const baseSettingsState = normalizeSettingsState(baseValue);
|
|
const patchSettingsState = normalizeSettingsState({
|
|
settingsState: patchValue,
|
|
activeFlowId: patchValue?.activeFlowId ?? baseSettingsState.activeFlowId,
|
|
});
|
|
|
|
function mergeRecursive(baseNode, patchNode) {
|
|
if (Array.isArray(patchNode)) {
|
|
return patchNode.map((entry) => cloneValue(entry));
|
|
}
|
|
if (!isPlainObject(patchNode)) {
|
|
return patchNode === undefined ? cloneValue(baseNode) : patchNode;
|
|
}
|
|
const next = {
|
|
...cloneValue(isPlainObject(baseNode) ? baseNode : {}),
|
|
};
|
|
Object.entries(patchNode).forEach(([key, value]) => {
|
|
next[key] = mergeRecursive(baseNode?.[key], value);
|
|
});
|
|
return next;
|
|
}
|
|
|
|
return normalizeSettingsState({
|
|
settingsState: mergeRecursive(baseSettingsState, patchSettingsState),
|
|
});
|
|
}
|
|
|
|
function getFlowSettings(settingsState = {}, flowId) {
|
|
const normalizedState = normalizeSettingsState(settingsState);
|
|
const normalizedFlowId = normalizeFlowId(flowId, normalizedState.activeFlowId);
|
|
return cloneValue(normalizedState?.flows?.[normalizedFlowId] || {});
|
|
}
|
|
|
|
function getSelectedTargetId(settingsState = {}, flowId) {
|
|
const normalizedState = normalizeSettingsState(settingsState);
|
|
const normalizedFlowId = normalizeFlowId(flowId, normalizedState.activeFlowId);
|
|
const flowSettings = normalizedState?.flows?.[normalizedFlowId] || {};
|
|
if (normalizedFlowId === 'kiro') {
|
|
return normalizeTargetId(
|
|
normalizedFlowId,
|
|
flowSettings?.targetId,
|
|
defaultKiroTargetId
|
|
);
|
|
}
|
|
return normalizeTargetId(
|
|
normalizedFlowId,
|
|
flowSettings?.integrationTargetId,
|
|
defaultOpenAiTargetId
|
|
);
|
|
}
|
|
|
|
function buildStepExecutionRangeByFlow(settingsState = {}) {
|
|
const normalizedState = normalizeSettingsState(settingsState);
|
|
return {
|
|
openai: normalizeStepExecutionRangeEntry(
|
|
normalizedState?.flows?.openai?.autoRun?.stepExecutionRange,
|
|
buildDefaultSettingsState().flows.openai.autoRun.stepExecutionRange
|
|
),
|
|
kiro: normalizeStepExecutionRangeEntry(
|
|
normalizedState?.flows?.kiro?.autoRun?.stepExecutionRange,
|
|
buildDefaultSettingsState().flows.kiro.autoRun.stepExecutionRange
|
|
),
|
|
};
|
|
}
|
|
|
|
function buildSettingsView(settingsState = {}, baseInput = {}) {
|
|
const normalizedState = normalizeSettingsState(settingsState);
|
|
const next = {
|
|
...(isPlainObject(baseInput) ? cloneValue(baseInput) : {}),
|
|
};
|
|
const openaiState = normalizedState.flows.openai;
|
|
const kiroState = normalizedState.flows.kiro;
|
|
next.activeFlowId = normalizedState.activeFlowId;
|
|
next.openaiIntegrationTargetId = getSelectedTargetId(normalizedState, 'openai');
|
|
next.kiroTargetId = getSelectedTargetId(normalizedState, 'kiro');
|
|
next.panelMode = next.openaiIntegrationTargetId;
|
|
next.vpsUrl = openaiState.integrationTargets.cpa.vpsUrl;
|
|
next.vpsPassword = openaiState.integrationTargets.cpa.vpsPassword;
|
|
next.localCpaStep9Mode = openaiState.integrationTargets.cpa.localCpaStep9Mode;
|
|
next.sub2apiUrl = openaiState.integrationTargets.sub2api.sub2apiUrl;
|
|
next.sub2apiEmail = openaiState.integrationTargets.sub2api.sub2apiEmail;
|
|
next.sub2apiPassword = openaiState.integrationTargets.sub2api.sub2apiPassword;
|
|
next.sub2apiGroupName = openaiState.integrationTargets.sub2api.sub2apiGroupName;
|
|
next.sub2apiGroupNames = cloneValue(openaiState.integrationTargets.sub2api.sub2apiGroupNames);
|
|
next.sub2apiAccountPriority = openaiState.integrationTargets.sub2api.sub2apiAccountPriority;
|
|
next.sub2apiDefaultProxyName = openaiState.integrationTargets.sub2api.sub2apiDefaultProxyName;
|
|
next.codex2apiUrl = openaiState.integrationTargets.codex2api.codex2apiUrl;
|
|
next.codex2apiAdminKey = openaiState.integrationTargets.codex2api.codex2apiAdminKey;
|
|
next.customPassword = normalizedState.services.account.customPassword;
|
|
next.signupMethod = openaiState.signup.signupMethod;
|
|
next.phoneVerificationEnabled = openaiState.signup.phoneVerificationEnabled;
|
|
next.phoneSignupReloginAfterBindEmailEnabled = openaiState.signup.phoneSignupReloginAfterBindEmailEnabled;
|
|
next.plusModeEnabled = openaiState.plus.plusModeEnabled;
|
|
next.plusPaymentMethod = openaiState.plus.plusPaymentMethod;
|
|
next.plusAccountAccessStrategy = openaiState.plus.plusAccountAccessStrategy;
|
|
next.mailProvider = normalizedState.services.email.provider;
|
|
next.ipProxyEnabled = normalizedState.services.proxy.enabled;
|
|
next.ipProxyService = normalizedState.services.proxy.provider;
|
|
next.ipProxyMode = normalizedState.services.proxy.mode;
|
|
next.kiroRsUrl = kiroState.targets['kiro-rs'].baseUrl;
|
|
next.kiroRsKey = kiroState.targets['kiro-rs'].apiKey;
|
|
next.stepExecutionRangeByFlow = buildStepExecutionRangeByFlow(normalizedState);
|
|
next.settingsSchemaVersion = normalizedState.schemaVersion;
|
|
next.settingsState = cloneValue(normalizedState);
|
|
return next;
|
|
}
|
|
|
|
function getFlowInputState(settingsState = {}, flowId) {
|
|
const normalizedState = normalizeSettingsState(settingsState);
|
|
const normalizedFlowId = normalizeFlowId(flowId, normalizedState.activeFlowId);
|
|
const targetId = getSelectedTargetId(normalizedState, normalizedFlowId);
|
|
if (normalizedFlowId === 'kiro') {
|
|
return {
|
|
activeFlowId: normalizedFlowId,
|
|
targetId,
|
|
kiroRsUrl: normalizedState.flows.kiro.targets['kiro-rs'].baseUrl,
|
|
kiroRsKey: normalizedState.flows.kiro.targets['kiro-rs'].apiKey,
|
|
};
|
|
}
|
|
return {
|
|
activeFlowId: normalizedFlowId,
|
|
targetId,
|
|
};
|
|
}
|
|
|
|
return {
|
|
buildDefaultSettingsState,
|
|
buildSettingsView,
|
|
buildStepExecutionRangeByFlow,
|
|
getFlowInputState,
|
|
getFlowSettings,
|
|
getSelectedTargetId,
|
|
mergeSettingsState,
|
|
normalizeSettingsState,
|
|
};
|
|
}
|
|
|
|
return {
|
|
createSettingsSchema,
|
|
};
|
|
});
|