refactor flows into canonical runtime architecture

2026-05-21 07:21:34 +08:00
parent e2485d2e64
commit a7b35ee11a
167 changed files with 9034 additions and 3032 deletions
@@ -0,0 +1,300 @@
+(function attachMultiPageFlowRegistry(root, factory) {
+  root.MultiPageFlowRegistry = factory();
+})(typeof self !== 'undefined' ? self : globalThis, function createFlowRegistryModule() {
+  const rootScope = typeof self !== 'undefined' ? self : globalThis;
+  const flowsIndexApi = rootScope.MultiPageFlowsIndex || {};
+
+  const DEFAULT_FLOW_ID = 'openai';
+  const SHARED_SERVICE_IDS = Object.freeze(['account', 'email', 'proxy']);
+
+  const DEFAULT_FLOW_CAPABILITIES = Object.freeze({
+    supportsEmailSignup: true,
+    supportsPhoneSignup: false,
+    supportsPhoneVerificationSettings: false,
+    supportsPlusMode: false,
+    supportsContributionMode: false,
+    supportsAccountContribution: false,
+    supportsOpenAiOAuthContribution: false,
+    contributionAdapterIds: [],
+    supportedTargetIds: [],
+    supportsLuckmail: false,
+    supportsOauthTimeoutBudget: false,
+    canSwitchFlow: true,
+    stepDefinitionMode: 'default',
+    targetSelectorLabel: '\u6765\u6e90',
+  });
+
+  function freezeDeep(value) {
+    if (!value || typeof value !== 'object' || Object.isFrozen(value)) {
+      return value;
+    }
+    Object.getOwnPropertyNames(value).forEach((key) => {
+      freezeDeep(value[key]);
+    });
+    return Object.freeze(value);
+  }
+
+  const SHARED_SETTINGS_GROUP_DEFINITIONS = freezeDeep({
+    'service-account': {
+      id: 'service-account',
+      label: '\u8d26\u6237',
+      rowIds: ['row-custom-password'],
+    },
+    'service-email': {
+      id: 'service-email',
+      label: '\u90ae\u7bb1\u670d\u52a1',
+    },
+    'service-proxy': {
+      id: 'service-proxy',
+      label: 'IP \u4ee3\u7406',
+      sectionIds: ['ip-proxy-section'],
+    },
+  });
+
+  function buildFlowDefinitions() {
+    if (typeof flowsIndexApi.getFlowDefinitions !== 'function') {
+      return {};
+    }
+    return flowsIndexApi.getFlowDefinitions() || {};
+  }
+
+  const FLOW_DEFINITIONS = freezeDeep(buildFlowDefinitions());
+  const REGISTERED_FLOW_IDS = Object.freeze(Object.keys(FLOW_DEFINITIONS));
+
+  function buildSettingsGroupDefinitions() {
+    const next = {
+      ...SHARED_SETTINGS_GROUP_DEFINITIONS,
+    };
+    Object.values(FLOW_DEFINITIONS).forEach((flowDefinition) => {
+      Object.assign(next, flowDefinition?.settingsGroups || {});
+    });
+    return next;
+  }
+
+  const SETTINGS_GROUP_DEFINITIONS = freezeDeep(buildSettingsGroupDefinitions());
+
+  function normalizeFlowId(value = '', fallback = DEFAULT_FLOW_ID) {
+    const normalized = String(value || '').trim().toLowerCase();
+    if (normalized && Object.prototype.hasOwnProperty.call(FLOW_DEFINITIONS, normalized)) {
+      return normalized;
+    }
+    const fallbackValue = String(fallback || '').trim().toLowerCase();
+    if (fallbackValue && Object.prototype.hasOwnProperty.call(FLOW_DEFINITIONS, fallbackValue)) {
+      return fallbackValue;
+    }
+    if (Object.prototype.hasOwnProperty.call(FLOW_DEFINITIONS, DEFAULT_FLOW_ID)) {
+      return DEFAULT_FLOW_ID;
+    }
+    return REGISTERED_FLOW_IDS[0] || DEFAULT_FLOW_ID;
+  }
+
+  function getRegisteredFlowIds() {
+    return REGISTERED_FLOW_IDS.slice();
+  }
+
+  function getFlowDefinition(flowId) {
+    const normalizedFlowId = normalizeFlowId(flowId);
+    return FLOW_DEFINITIONS[normalizedFlowId] || null;
+  }
+
+  function getFlowLabel(flowId) {
+    return getFlowDefinition(flowId)?.label || normalizeFlowId(flowId);
+  }
+
+  function getDefaultTargetId(flowId) {
+    const flowDefinition = getFlowDefinition(flowId);
+    return String(flowDefinition?.defaultTargetId || '').trim().toLowerCase();
+  }
+
+  function normalizeTargetId(flowId, targetId = '', fallback = undefined) {
+    const normalizedFlowId = normalizeFlowId(flowId);
+    const targetDefinitions = getFlowDefinition(normalizedFlowId)?.targets || {};
+    const targetKeys = Object.keys(targetDefinitions);
+    if (!targetKeys.length) {
+      return String(targetId || fallback || '').trim().toLowerCase();
+    }
+
+    const normalizedTargetId = String(targetId || '').trim().toLowerCase();
+    if (normalizedTargetId && Object.prototype.hasOwnProperty.call(targetDefinitions, normalizedTargetId)) {
+      return normalizedTargetId;
+    }
+
+    const fallbackValue = String(fallback || '').trim().toLowerCase();
+    if (fallbackValue && Object.prototype.hasOwnProperty.call(targetDefinitions, fallbackValue)) {
+      return fallbackValue;
+    }
+
+    const defaultTargetId = getDefaultTargetId(normalizedFlowId);
+    if (defaultTargetId && Object.prototype.hasOwnProperty.call(targetDefinitions, defaultTargetId)) {
+      return defaultTargetId;
+    }
+
+    return targetKeys[0];
+  }
+
+  function normalizeOpenAiTargetId(value = '', fallback = undefined) {
+    return normalizeTargetId('openai', value, fallback);
+  }
+
+  function normalizeKiroTargetId(value = '', fallback = undefined) {
+    return normalizeTargetId('kiro', value, fallback);
+  }
+
+  function getTargetDefinitions(flowId) {
+    return getFlowDefinition(flowId)?.targets || {};
+  }
+
+  function getTargetDefinition(flowId, targetId) {
+    const normalizedFlowId = normalizeFlowId(flowId);
+    const normalizedTargetId = normalizeTargetId(
+      normalizedFlowId,
+      targetId,
+      getDefaultTargetId(normalizedFlowId)
+    );
+    return getTargetDefinitions(normalizedFlowId)[normalizedTargetId] || null;
+  }
+
+  function getTargetOptions(flowId) {
+    return Object.values(getTargetDefinitions(flowId));
+  }
+
+  function getTargetLabel(flowId, targetId) {
+    return getTargetDefinition(flowId, targetId)?.label
+      || normalizeTargetId(flowId, targetId);
+  }
+
+  function getPublicationTargetDefinitions(flowId) {
+    return getFlowDefinition(flowId)?.publicationTargets || {};
+  }
+
+  function getPublicationTargetDefinition(flowId, publicationTargetId) {
+    const normalizedFlowId = normalizeFlowId(flowId);
+    const flowDefinition = getFlowDefinition(normalizedFlowId);
+    const normalizedPublicationTargetId = String(
+      publicationTargetId || flowDefinition?.defaultPublicationTargetId || ''
+    ).trim().toLowerCase();
+    return getPublicationTargetDefinitions(normalizedFlowId)[normalizedPublicationTargetId] || null;
+  }
+
+  function getFlowCapabilities(flowId) {
+    return {
+      ...DEFAULT_FLOW_CAPABILITIES,
+      ...(getFlowDefinition(flowId)?.capabilities || {}),
+    };
+  }
+
+  function getTargetCapabilityDefinitions(flowId) {
+    return getFlowDefinition(flowId)?.targetCapabilities || {};
+  }
+
+  function getTargetCapabilities(flowId, targetId) {
+    const normalizedFlowId = normalizeFlowId(flowId);
+    const normalizedTargetId = normalizeTargetId(
+      normalizedFlowId,
+      targetId,
+      getDefaultTargetId(normalizedFlowId)
+    );
+    return getTargetCapabilityDefinitions(normalizedFlowId)[normalizedTargetId] || null;
+  }
+
+  function getVisibleGroupIds(flowId, targetId, options = {}) {
+    const normalizedFlowId = normalizeFlowId(flowId);
+    const flowDefinition = getFlowDefinition(normalizedFlowId);
+    const normalizedTargetId = normalizeTargetId(
+      normalizedFlowId,
+      targetId,
+      getDefaultTargetId(normalizedFlowId)
+    );
+    const targetDefinition = getTargetDefinition(normalizedFlowId, normalizedTargetId);
+    const includeSharedServices = options?.includeSharedServices !== false;
+    const serviceGroups = includeSharedServices
+      ? (Array.isArray(flowDefinition?.services)
+        ? flowDefinition.services.map((serviceId) => `service-${serviceId}`)
+        : [])
+      : [];
+    return Array.from(new Set([
+      ...(Array.isArray(flowDefinition?.baseGroups) ? flowDefinition.baseGroups : []),
+      ...(Array.isArray(targetDefinition?.groups) ? targetDefinition.groups : []),
+      ...serviceGroups,
+    ]));
+  }
+
+  function getSettingsGroupDefinition(groupId) {
+    const normalizedGroupId = String(groupId || '').trim();
+    return SETTINGS_GROUP_DEFINITIONS[normalizedGroupId] || null;
+  }
+
+  function getSettingsGroupDefinitions() {
+    return SETTINGS_GROUP_DEFINITIONS;
+  }
+
+  function getRuntimeSourceDefinitions() {
+    const next = {};
+    Object.values(FLOW_DEFINITIONS).forEach((flowDefinition) => {
+      Object.assign(next, flowDefinition?.runtimeSources || {});
+    });
+    return next;
+  }
+
+  function getDriverDefinitions() {
+    const next = {};
+    Object.values(FLOW_DEFINITIONS).forEach((flowDefinition) => {
+      Object.assign(next, flowDefinition?.driverDefinitions || {});
+    });
+    return next;
+  }
+
+  function getSourceAliases() {
+    const next = {};
+    Object.values(FLOW_DEFINITIONS).forEach((flowDefinition) => {
+      Object.assign(next, flowDefinition?.sourceAliases || {});
+    });
+    return next;
+  }
+
+  const OPENAI_TARGET_IDS = Object.freeze(Object.keys(getTargetDefinitions('openai')));
+  const DEFAULT_OPENAI_TARGET_ID = String(getDefaultTargetId('openai') || OPENAI_TARGET_IDS[0] || 'cpa');
+  const DEFAULT_KIRO_TARGET_ID = String(getDefaultTargetId('kiro') || 'kiro-rs');
+  const DEFAULT_KIRO_PUBLICATION_TARGET_ID = String(
+    getFlowDefinition('kiro')?.defaultPublicationTargetId || DEFAULT_KIRO_TARGET_ID
+  );
+  const DEFAULT_KIRO_RS_URL = String(
+    getFlowDefinition('kiro')?.defaultTargetState?.baseUrl || ''
+  ).trim();
+
+  return {
+    DEFAULT_FLOW_CAPABILITIES,
+    DEFAULT_FLOW_ID,
+    DEFAULT_KIRO_PUBLICATION_TARGET_ID,
+    DEFAULT_KIRO_RS_URL,
+    DEFAULT_KIRO_TARGET_ID,
+    DEFAULT_OPENAI_TARGET_ID,
+    FLOW_DEFINITIONS,
+    OPENAI_TARGET_IDS,
+    SETTINGS_GROUP_DEFINITIONS,
+    SHARED_SERVICE_IDS,
+    getDriverDefinitions,
+    getDefaultTargetId,
+    getFlowCapabilities,
+    getFlowDefinition,
+    getFlowLabel,
+    getPublicationTargetDefinition,
+    getPublicationTargetDefinitions,
+    getRegisteredFlowIds,
+    getRuntimeSourceDefinitions,
+    getSettingsGroupDefinition,
+    getSettingsGroupDefinitions,
+    getSourceAliases,
+    getTargetCapabilities,
+    getTargetCapabilityDefinitions,
+    getTargetDefinition,
+    getTargetDefinitions,
+    getTargetLabel,
+    getTargetOptions,
+    getVisibleGroupIds,
+    normalizeFlowId,
+    normalizeKiroTargetId,
+    normalizeOpenAiTargetId,
+    normalizeTargetId,
+  };
+});