android2harmony 0.1.6 → 0.1.8

package/skills/a2h-app-req-gen/scripts/reqgen/src/analysis/graph/component-variants.js

@@ -0,0 +1,725 @@
+import {
+  codeNameCandidate,
+  literalNameCandidate,
+  resolveNameCandidates,
+  semanticIdentifierName,
+} from "../names/policy.js";
+function uniqueSorted(values) {
+  return [...new Set(values)].sort((left, right) =>
+    left.localeCompare(right, "en"),
+  );
+}
+function leafStateName(stateKey) {
+  return stateKey.slice(
+    Math.max(
+      stateKey.lastIndexOf("#"),
+      stateKey.lastIndexOf("."),
+      stateKey.lastIndexOf("/"),
+    ) + 1,
+  );
+}
+function compactExpression(value) {
+  return value.replace(/\s+/gu, "").replace(/^\((.*)\)$/u, "$1");
+}
+/** Returns false only for a condition that provably contradicts the variant. */
+function expressionCompatible(expression, stateName, value) {
+  if (typeof value !== "boolean") return true;
+  const normalized = compactExpression(expression);
+  const state = compactExpression(stateName);
+  if (normalized === state) return value;
+  if (normalized === `!${state}` || normalized === `!(${state})`) return !value;
+  const equality = new RegExp(
+    `^${state.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}(?:==|=)(true|false)$`,
+    "u",
+  ).exec(normalized);
+  if (equality) return (equality[1] === "true") === value;
+  return true;
+}
+function refsCompatible(refs, stateName, value, conditionById) {
+  return refs.every((ref) => {
+    const expression = conditionById.get(ref)?.data.expressionAnchor;
+    return !expression || expressionCompatible(expression, stateName, value);
+  });
+}
+function alternativesCompatible(alternatives, stateName, value, conditionById) {
+  return (
+    !alternatives ||
+    alternatives.length === 0 ||
+    compatibleAlternatives(alternatives, stateName, value, conditionById)
+      .length > 0
+  );
+}
+function compatibleAlternatives(alternatives, stateName, value, conditionById) {
+  return alternatives.filter((alternative) =>
+    refsCompatible(alternative.conditionRefs, stateName, value, conditionById),
+  );
+}
+function conditionsOutsideAlternatives(refs, alternatives) {
+  const alternativeRefs = new Set(
+    alternatives?.flatMap((alternative) => alternative.conditionRefs) ?? [],
+  );
+  return refs.filter((ref) => !alternativeRefs.has(ref));
+}
+function commonAlternativeConditions(alternatives) {
+  if (alternatives.length === 0) return [];
+  return uniqueSorted(
+    alternatives[0].conditionRefs.filter((conditionRef) =>
+      alternatives.every((alternative) =>
+        alternative.conditionRefs.includes(conditionRef),
+      ),
+    ),
+  );
+}
+function actionCompatible(
+  action,
+  effectById,
+  edgesByAction,
+  stateName,
+  value,
+  conditionById,
+  replacedAreaConditionRefs,
+) {
+  if (!refsCompatible(action.preconditionRefs, stateName, value, conditionById))
+    return false;
+  if (
+    !alternativesCompatible(
+      action.preconditionAlternatives,
+      stateName,
+      value,
+      conditionById,
+    )
+  )
+    return false;
+  const effectCompatible = action.effectRefs.some((effectRef) => {
+    const effect = effectById.get(effectRef);
+    return (
+      !effect ||
+      alternativesCompatible(
+        effect.conditionAlternatives,
+        stateName,
+        value,
+        conditionById,
+      )
+    );
+  });
+  if (action.effectRefs.length > 0 && !effectCompatible) return false;
+  const edges = edgesByAction.get(action.id) ?? [];
+  return (
+    edges.length === 0 ||
+    edges.some(
+      (edge) =>
+        refsCompatible(
+          conditionsOutsideAlternatives(
+            edge.conditions,
+            edge.conditionAlternatives,
+          ).filter(
+            (conditionRef) => !replacedAreaConditionRefs.has(conditionRef),
+          ),
+          stateName,
+          value,
+          conditionById,
+        ) &&
+        alternativesCompatible(
+          edge.conditionAlternatives,
+          stateName,
+          value,
+          conditionById,
+        ),
+    )
+  );
+}
+function fallbackVariantName(base, variant) {
+  const stateName = semanticIdentifierName(
+    leafStateName(variant.data.stateKey),
+  );
+  const value = String(variant.data.value);
+  if (base.name.status === "resolved") {
+    return stateName
+      ? `${base.name.value} (${stateName} = ${value})`
+      : `${base.name.value} (${value})`;
+  }
+  return stateName ? `${stateName} = ${value}` : value;
+}
+function targetVariantForAction(action, variants, bindingById) {
+  const callbacks = new Set(
+    action.sourceFactRefs.flatMap((sourceRef) => {
+      const binding = bindingById.get(sourceRef);
+      return binding ? [binding.data.callbackKey] : [];
+    }),
+  );
+  const matches = variants.filter((variant) =>
+    variant.data.entryCallbackKeys.some((callbackRef) =>
+      callbacks.has(callbackRef),
+    ),
+  );
+  return matches.length === 1 ? matches[0] : undefined;
+}
+/**
+ * Expands explicit component-variant facts into Area graph entities. The
+ * source normalizer has already proved the scalar values and entry callbacks;
+ * this pass only rewrites graph ownership and references.
+ */
+export function applyComponentVariants(input) {
+  if (input.variants.length === 0) return;
+  const unresolvedById = new Map(
+    input.unresolved.map((item) => [item.id, item]),
+  );
+  const bindingById = new Map(input.bindings.map((fact) => [fact.id, fact]));
+  const conditionById = new Map(
+    input.conditions.map((fact) => [fact.id, fact]),
+  );
+  const variantsByBaseArea = new Map();
+  for (const variant of input.variants) {
+    const baseAreaRef = input.areaByComponent.get(variant.data.componentKey);
+    if (!baseAreaRef) continue;
+    const facts = variantsByBaseArea.get(baseAreaRef) ?? [];
+    facts.push(variant);
+    variantsByBaseArea.set(baseAreaRef, facts);
+  }
+  for (const [baseAreaRef, unsortedVariants] of variantsByBaseArea) {
+    const baseArea = input.areasById.get(baseAreaRef);
+    if (!baseArea || unsortedVariants.length < 2) continue;
+    const variants = [...unsortedVariants].sort((left, right) =>
+      left.id.localeCompare(right.id, "en"),
+    );
+    const allVariantConditionRefs = new Set(
+      variants.flatMap((variant) => variant.data.conditionKeys),
+    );
+    const variantAreaByFact = new Map();
+    for (const variant of variants) {
+      const areaId = input.id(
+        "area",
+        input.caseId,
+        "component-variant",
+        variant.id,
+      );
+      const nameDecision = resolveNameCandidates([
+        literalNameCandidate(
+          "variant-display-name",
+          variant.data.displayName,
+          [variant.id],
+          variant.confidence,
+        ),
+        codeNameCandidate(
+          "variant-state",
+          variant.data.stateKey,
+          [
+            variant.id,
+            ...(baseArea.name.status === "resolved"
+              ? baseArea.name.supportRefs
+              : []),
+          ],
+          () => fallbackVariantName(baseArea, variant),
+        ),
+      ]);
+      const area = {
+        ...baseArea,
+        id: areaId,
+        identityAnchors: uniqueSorted([
+          ...baseArea.identityAnchors,
+          variant.id,
+          `${variant.data.stateKey}=${JSON.stringify(variant.data.value)}`,
+        ]),
+        name:
+          nameDecision.value !== undefined &&
+          nameDecision.confidence !== undefined
+            ? {
+                status: "resolved",
+                value: nameDecision.value,
+                confidence: nameDecision.confidence,
+                supportRefs: nameDecision.supportRefs,
+              }
+            : baseArea.name,
+        controlRefs: [],
+        conditions: uniqueSorted([
+          ...baseArea.conditions.filter(
+            (conditionRef) => !allVariantConditionRefs.has(conditionRef),
+          ),
+          ...variant.data.conditionKeys,
+        ]),
+        sourceFactRefs: uniqueSorted([
+          ...baseArea.sourceFactRefs,
+          variant.id,
+          ...variant.data.conditionKeys,
+          ...variant.data.entryCallbackKeys,
+        ]),
+      };
+      variantAreaByFact.set(variant.id, area);
+      input.areasById.set(area.id, area);
+    }
+    const baseControls = input.controls.filter(
+      (control) => control.areaRef === baseAreaRef,
+    );
+    const baseControlIds = new Set(baseControls.map((control) => control.id));
+    const baseActions = input.actions.filter((action) =>
+      baseControlIds.has(action.controlRef),
+    );
+    const baseActionIds = new Set(baseActions.map((action) => action.id));
+    const baseEffects = input.effects.filter((effect) =>
+      baseActionIds.has(effect.actionRef),
+    );
+    const baseEffectById = new Map(
+      baseEffects.map((effect) => [effect.id, effect]),
+    );
+    const baseEdges = input.edges.filter(
+      (edge) =>
+        baseActionIds.has(edge.actionRef) && edge.sourceAreaRef === baseAreaRef,
+    );
+    const removedOwnerIds = new Set([
+      baseAreaRef,
+      ...baseControlIds,
+      ...baseActionIds,
+      ...baseEffects.map((effect) => effect.id),
+      ...baseEdges.map((edge) => edge.id),
+    ]);
+    const mutableEdgesByAction = new Map();
+    for (const edge of baseEdges) {
+      const values = mutableEdgesByAction.get(edge.actionRef) ?? [];
+      values.push(edge);
+      mutableEdgesByAction.set(edge.actionRef, values);
+    }
+    for (const variant of variants) {
+      const area = variantAreaByFact.get(variant.id);
+      const stateName = leafStateName(variant.data.stateKey);
+      const cloneRefByBase = new Map([[baseAreaRef, area.id]]);
+      const controlPlans = [];
+      for (const control of baseControls) {
+        if (
+          variant.data.visibleElementKeys &&
+          !variant.data.visibleElementKeys.some((sourceRef) =>
+            control.sourceFactRefs.includes(sourceRef),
+          )
+        )
+          continue;
+        if (
+          !refsCompatible(
+            control.visibilityConditions,
+            stateName,
+            variant.data.value,
+            conditionById,
+          )
+        )
+          continue;
+        const actions = baseActions.filter(
+          (action) =>
+            action.controlRef === control.id &&
+            actionCompatible(
+              action,
+              baseEffectById,
+              mutableEdgesByAction,
+              stateName,
+              variant.data.value,
+              conditionById,
+              allVariantConditionRefs,
+            ),
+        );
+        if (control.actionRefs.length > 0 && actions.length === 0) continue;
+        const controlId = input.id(
+          "control",
+          input.caseId,
+          control.kind,
+          `${control.id}:${variant.id}`,
+        );
+        cloneRefByBase.set(control.id, controlId);
+        const actionPlans = [];
+        for (const action of actions) {
+          const actionId = input.id(
+            "action",
+            input.caseId,
+            action.trigger,
+            `${action.id}:${variant.id}`,
+          );
+          cloneRefByBase.set(action.id, actionId);
+          const effectPlans = [];
+          for (const effectRef of action.effectRefs) {
+            const effect = baseEffectById.get(effectRef);
+            if (
+              !effect ||
+              !alternativesCompatible(
+                effect.conditionAlternatives,
+                stateName,
+                variant.data.value,
+                conditionById,
+              )
+            )
+              continue;
+            const effectId = input.id(
+              "effect",
+              input.caseId,
+              effect.kind,
+              `${effect.id}:${variant.id}`,
+            );
+            cloneRefByBase.set(effect.id, effectId);
+            effectPlans.push({
+              effect,
+              id: effectId,
+              conditionAlternatives: effect.conditionAlternatives
+                ? compatibleAlternatives(
+                    effect.conditionAlternatives,
+                    stateName,
+                    variant.data.value,
+                    conditionById,
+                  )
+                : undefined,
+            });
+          }
+          const edgePlans = [];
+          for (const edge of mutableEdgesByAction.get(action.id) ?? []) {
+            const conditionAlternatives = edge.conditionAlternatives
+              ? compatibleAlternatives(
+                  edge.conditionAlternatives,
+                  stateName,
+                  variant.data.value,
+                  conditionById,
+                )
+              : undefined;
+            const retainedConditions = conditionsOutsideAlternatives(
+              edge.conditions,
+              edge.conditionAlternatives,
+            ).filter(
+              (conditionRef) => !allVariantConditionRefs.has(conditionRef),
+            );
+            if (
+              !refsCompatible(
+                retainedConditions,
+                stateName,
+                variant.data.value,
+                conditionById,
+              ) ||
+              !alternativesCompatible(
+                edge.conditionAlternatives,
+                stateName,
+                variant.data.value,
+                conditionById,
+              )
+            )
+              continue;
+            const edgeId = input.id(
+              "edge",
+              input.caseId,
+              "component-variant",
+              `${edge.id}:${variant.id}`,
+            );
+            cloneRefByBase.set(edge.id, edgeId);
+            edgePlans.push({
+              edge,
+              id: edgeId,
+              conditions: uniqueSorted([
+                ...retainedConditions,
+                ...(conditionAlternatives?.flatMap(
+                  (alternative) => alternative.conditionRefs,
+                ) ?? []),
+                ...variant.data.conditionKeys,
+              ]),
+              conditionAlternatives,
+            });
+          }
+          const preconditionAlternatives = action.preconditionAlternatives
+            ? compatibleAlternatives(
+                action.preconditionAlternatives,
+                stateName,
+                variant.data.value,
+                conditionById,
+              )
+            : undefined;
+          actionPlans.push({
+            action,
+            id: actionId,
+            preconditionRefs: preconditionAlternatives
+              ? commonAlternativeConditions(preconditionAlternatives)
+              : action.preconditionRefs,
+            preconditionAlternatives,
+            effects: effectPlans,
+            edges: edgePlans,
+          });
+        }
+        controlPlans.push({ control, id: controlId, actions: actionPlans });
+      }
+      /*
+       * A graph-owned unresolved item is part of the entity being cloned, not
+       * immutable source evidence. Give every variant its own stable item and
+       * move ownership to the corresponding cloned graph entity. Source-fact
+       * owned unresolved items remain shared because their owner survives this
+       * rewrite and they still describe the same source uncertainty.
+       */
+      const clonedUnresolvedByOwner = new Map();
+      const cloneUnresolvedRef = (ref, fallbackOwnerRef) => {
+        const item = unresolvedById.get(ref);
+        if (!item || !removedOwnerIds.has(item.ownerRef)) return ref;
+        const ownerRef = cloneRefByBase.get(item.ownerRef) ?? fallbackOwnerRef;
+        if (!ownerRef) return undefined;
+        const key = `${ref}\u0000${ownerRef}`;
+        const existing = clonedUnresolvedByOwner.get(key);
+        if (existing) return existing;
+        const id = input.id(
+          "unresolved",
+          input.caseId,
+          "component-variant-clone",
+          JSON.stringify([ref, ownerRef]),
+        );
+        const clone = {
+          ...item,
+          id,
+          ownerRef,
+          candidates: item.candidates.map((candidate) => ({
+            ...candidate,
+            value:
+              typeof candidate.value === "string"
+                ? (cloneRefByBase.get(candidate.value) ?? candidate.value)
+                : candidate.value,
+          })),
+          ...(item.originRef
+            ? {
+                originRef: cloneRefByBase.get(item.originRef) ?? item.originRef,
+              }
+            : {}),
+        };
+        input.unresolved.push(clone);
+        unresolvedById.set(id, clone);
+        clonedUnresolvedByOwner.set(key, id);
+        return id;
+      };
+      const cloneUnresolvedRefs = (refs) =>
+        uniqueSorted(
+          refs.flatMap((ref) => {
+            const cloned = cloneUnresolvedRef(ref);
+            return cloned ? [cloned] : [];
+          }),
+        );
+      const cloneSupportedValue = (value, fallbackOwnerRef) => {
+        if (value.status === "resolved") return value;
+        const unresolvedRef = cloneUnresolvedRef(
+          value.unresolvedRef,
+          fallbackOwnerRef,
+        );
+        return unresolvedRef ? { ...value, unresolvedRef } : value;
+      };
+      const cloneUnresolvedValue = (value, fallbackOwnerRef) => {
+        const unresolvedRef = cloneUnresolvedRef(
+          value.unresolvedRef,
+          fallbackOwnerRef,
+        );
+        return unresolvedRef ? { ...value, unresolvedRef } : value;
+      };
+      for (const plan of controlPlans) {
+        const clonedActionRefs = [];
+        for (const actionPlan of plan.actions) {
+          const clonedEffectRefs = actionPlan.effects.map(
+            (effectPlan) => effectPlan.id,
+          );
+          for (const effectPlan of actionPlan.effects) {
+            const { effect, id: effectId } = effectPlan;
+            input.effects.push({
+              ...effect,
+              id: effectId,
+              actionRef: actionPlan.id,
+              conditionAlternatives: effectPlan.conditionAlternatives,
+              description: cloneSupportedValue(effect.description, effectId),
+              ...(effect.stateKey
+                ? {
+                    stateKey: cloneSupportedValue(effect.stateKey, effectId),
+                  }
+                : {}),
+              ...(effect.value
+                ? { value: cloneSupportedValue(effect.value, effectId) }
+                : {}),
+              sourceFactRefs: uniqueSorted([
+                ...effect.sourceFactRefs,
+                variant.id,
+              ]),
+              ...(effect.unresolvedRefs
+                ? {
+                    unresolvedRefs: cloneUnresolvedRefs(effect.unresolvedRefs),
+                  }
+                : {}),
+            });
+          }
+          input.actions.push({
+            ...actionPlan.action,
+            id: actionPlan.id,
+            controlRef: plan.id,
+            effectRefs: clonedEffectRefs,
+            preconditionRefs: actionPlan.preconditionRefs,
+            preconditionAlternatives: actionPlan.preconditionAlternatives,
+            sourceFactRefs: uniqueSorted([
+              ...actionPlan.action.sourceFactRefs,
+              variant.id,
+            ]),
+          });
+          clonedActionRefs.push(actionPlan.id);
+          for (const edgePlan of actionPlan.edges) {
+            const { edge, id: edgeId } = edgePlan;
+            const effectRef = actionPlan.action.effectRefs.find((candidate) =>
+              baseEffectById.has(candidate),
+            );
+            const clonedEffectRef = effectRef
+              ? cloneRefByBase.get(effectRef)
+              : undefined;
+            input.edges.push({
+              ...edge,
+              id: edgeId,
+              sourceAreaRef: area.id,
+              controlRef: plan.id,
+              actionRef: actionPlan.id,
+              target:
+                "status" in edge.target
+                  ? cloneUnresolvedValue(edge.target, edgeId)
+                  : edge.target.kind === "area" &&
+                      edge.target.ref === baseAreaRef
+                    ? { kind: "area", ref: area.id }
+                    : edge.target,
+              conditions: edgePlan.conditions,
+              conditionAlternatives: edgePlan.conditionAlternatives,
+              sourceFactRefs: uniqueSorted([
+                ...edge.sourceFactRefs,
+                variant.id,
+                ...(clonedEffectRef ? [clonedEffectRef] : []),
+              ]),
+            });
+          }
+        }
+        input.controls.push({
+          ...plan.control,
+          id: plan.id,
+          areaRef: area.id,
+          name: cloneSupportedValue(plan.control.name, plan.id),
+          ...(plan.control.enabled
+            ? {
+                enabled: cloneSupportedValue(plan.control.enabled, plan.id),
+              }
+            : {}),
+          actionRefs: uniqueSorted(clonedActionRefs),
+          visibilityConditions: uniqueSorted([
+            ...plan.control.visibilityConditions,
+            ...variant.data.conditionKeys,
+          ]),
+          sourceFactRefs: uniqueSorted([
+            ...plan.control.sourceFactRefs,
+            variant.id,
+          ]),
+          unresolvedRefs: cloneUnresolvedRefs(plan.control.unresolvedRefs),
+        });
+        const currentArea = input.areasById.get(area.id);
+        input.areasById.set(area.id, {
+          ...currentArea,
+          controlRefs: uniqueSorted([...currentArea.controlRefs, plan.id]),
+        });
+      }
+      const currentArea = input.areasById.get(area.id);
+      input.areasById.set(area.id, {
+        ...currentArea,
+        name: cloneSupportedValue(currentArea.name, area.id),
+        descriptionFacts: currentArea.descriptionFacts.map((description) => ({
+          ...description,
+          value: cloneSupportedValue(description.value, area.id),
+        })),
+        unresolvedRefs: cloneUnresolvedRefs(currentArea.unresolvedRefs),
+      });
+    }
+    const incoming = input.edges.filter(
+      (edge) =>
+        !baseActionIds.has(edge.actionRef) &&
+        !("status" in edge.target) &&
+        edge.target.kind === "area" &&
+        edge.target.ref === baseAreaRef,
+    );
+    const actionById = new Map(
+      input.actions.map((action) => [action.id, action]),
+    );
+    const effectById = new Map(
+      input.effects.map((effect) => [effect.id, effect]),
+    );
+    for (const edge of incoming) {
+      const action = actionById.get(edge.actionRef);
+      const variant = action
+        ? targetVariantForAction(action, variants, bindingById)
+        : undefined;
+      const targetArea = variant
+        ? variantAreaByFact.get(variant.id)
+        : undefined;
+      if (!action || !variant || !targetArea) {
+        const unresolvedId = input.id(
+          "unresolved",
+          input.caseId,
+          "component-variant-target",
+          edge.id,
+        );
+        input.unresolved.push({
+          id: unresolvedId,
+          ownerRef: edge.id,
+          fieldPath: "target",
+          reasonCode: "INTRINSIC_COMPONENT_VARIANT_TARGET_UNKNOWN",
+          message:
+            "导航进入具有多个静态页面变体的组件，但入口回调不能唯一确定状态值。",
+          evidenceRefs: [],
+          candidates: variants.map((candidate) => ({
+            value: variantAreaByFact.get(candidate.id).id,
+            supportRefs: candidate.support.map((item) => item.evidenceRef),
+          })),
+          impact: ["area-path"],
+          originRef: edge.id,
+        });
+        const index = input.edges.findIndex(
+          (candidate) => candidate.id === edge.id,
+        );
+        input.edges[index] = {
+          ...edge,
+          target: { status: "unresolved", unresolvedRef: unresolvedId },
+        };
+        continue;
+      }
+      const edgeIndex = input.edges.findIndex(
+        (candidate) => candidate.id === edge.id,
+      );
+      input.edges[edgeIndex] = {
+        ...edge,
+        target: { kind: "area", ref: targetArea.id },
+        sourceFactRefs: uniqueSorted([...edge.sourceFactRefs, variant.id]),
+      };
+      for (const effectRef of action.effectRefs) {
+        const effect = effectById.get(effectRef);
+        if (!effect || effect.kind !== "navigate-area") continue;
+        const effectIndex = input.effects.findIndex(
+          (candidate) => candidate.id === effect.id,
+        );
+        input.effects[effectIndex] = {
+          ...effect,
+          description: {
+            status: "resolved",
+            value: `进入 ${
+              targetArea.name.status === "resolved"
+                ? targetArea.name.value
+                : "目标区域"
+            }`,
+            confidence:
+              effect.description.status === "resolved"
+                ? effect.description.confidence
+                : variant.confidence,
+            supportRefs: uniqueSorted([
+              ...(effect.description.status === "resolved"
+                ? effect.description.supportRefs
+                : []),
+              variant.id,
+            ]),
+          },
+          sourceFactRefs: uniqueSorted([...effect.sourceFactRefs, variant.id]),
+        };
+      }
+    }
+    input.areasById.delete(baseAreaRef);
+    const removeById = (values, ids) => {
+      for (let index = values.length - 1; index >= 0; index -= 1) {
+        if (ids.has(values[index].id)) values.splice(index, 1);
+      }
+    };
+    removeById(input.controls, baseControlIds);
+    removeById(input.actions, baseActionIds);
+    removeById(input.effects, new Set(baseEffects.map((effect) => effect.id)));
+    removeById(input.edges, new Set(baseEdges.map((edge) => edge.id)));
+    for (let index = input.unresolved.length - 1; index >= 0; index -= 1) {
+      if (!removedOwnerIds.has(input.unresolved[index].ownerRef)) continue;
+      unresolvedById.delete(input.unresolved[index].id);
+      input.unresolved.splice(index, 1);
+    }
+  }
+}