android2harmony 0.1.6 → 0.1.8

package/skills/a2h-app-req-gen/scripts/reqgen/src/analysis/gap-audit/index.js

@@ -0,0 +1 @@
+export { buildGapAudit, diagnosticsForGapAudit } from "./build.js";

package/skills/a2h-app-req-gen/scripts/reqgen/src/analysis/graph/area-ownership.js

@@ -0,0 +1,392 @@
+const surfaceTypes = new Set([
+  "dialog",
+  "drawer",
+  "bottom-sheet",
+  "overlay",
+  "pager",
+  "pager-page",
+  "inline-detail-surface",
+  "popup",
+  "widget",
+]);
+function isFrameworkNavigationContainer(name) {
+  return (
+    name === "androidx.navigation.fragment.NavHostFragment" ||
+    (name.startsWith("androidx.navigation.") &&
+      name.endsWith(".NavHostFragment"))
+  );
+}
+function isSurrogate(name) {
+  return (
+    name.startsWith("@layout/") ||
+    name.startsWith("@navigation/") ||
+    name.startsWith("@compose/unresolved-owner/")
+  );
+}
+function isPotentialAreaAnchor(component) {
+  if (
+    isSurrogate(component.data.qualifiedName) ||
+    isFrameworkNavigationContainer(component.data.qualifiedName) ||
+    component.data.analysisRole === "declaration-template" ||
+    component.data.declarationStatus === "abstract" ||
+    component.data.declarationKind === "interface" ||
+    component.data.declarationKind === "annotation"
+  )
+    return false;
+  return (
+    component.data.componentType === "activity" ||
+    component.data.componentType === "fragment" ||
+    component.data.componentType === "compose-destination" ||
+    surfaceTypes.has(component.data.componentType)
+  );
+}
+function isExternalManifestOnly(component) {
+  return component.data.manifestProvenance?.ownership === "external-dependency";
+}
+function isAreaAnchor(component, explicitAppEntryComponentRefs) {
+  return (
+    isPotentialAreaAnchor(component) &&
+    (!isExternalManifestOnly(component) ||
+      explicitAppEntryComponentRefs.has(component.id))
+  );
+}
+function areaKind(componentType) {
+  switch (componentType) {
+    case "activity":
+      return "activity-content";
+    case "fragment":
+      return "fragment-content";
+    case "widget":
+      return "app-widget";
+    default:
+      return componentType;
+  }
+}
+function append(map, key, value) {
+  const values = map.get(key) ?? [];
+  values.push(value);
+  map.set(key, values);
+}
+function uniqueSorted(values) {
+  return [...new Set(values)].sort((left, right) =>
+    left.localeCompare(right, "en"),
+  );
+}
+function nearest(start, parentsByContent, accepts, includeStart) {
+  let frontier = includeStart
+    ? [start]
+    : [...(parentsByContent.get(start) ?? [])];
+  const visited = new Set();
+  while (frontier.length > 0) {
+    const matches = uniqueSorted(
+      frontier.filter((item) => !visited.has(item) && accepts(item)),
+    );
+    if (matches.length > 0) {
+      return matches.length === 1 ? matches[0] : undefined;
+    }
+    const next = [];
+    for (const item of uniqueSorted(frontier)) {
+      if (visited.has(item)) continue;
+      visited.add(item);
+      next.push(...(parentsByContent.get(item) ?? []));
+    }
+    frontier = uniqueSorted(next);
+  }
+  return undefined;
+}
+function declaredRoute(component) {
+  if (component.data.componentType !== "compose-destination") {
+    return undefined;
+  }
+  const marker = "#route:";
+  const index = component.data.qualifiedName.lastIndexOf(marker);
+  if (index < 0) return undefined;
+  const route = component.data.qualifiedName.slice(index + marker.length);
+  return route.length > 0 ? route : undefined;
+}
+function escapeRoutePatternLiteral(value) {
+  return value.replace(/[\\^$.*+?()[\]{}|]/gu, "\\$&");
+}
+function routePartMatches(pattern, route, wildcard) {
+  const placeholder = /\{[^/{}?&#=]+\}/gu;
+  let cursor = 0;
+  let expression = "^";
+  for (const match of pattern.matchAll(placeholder)) {
+    const offset = match.index;
+    expression += escapeRoutePatternLiteral(pattern.slice(cursor, offset));
+    expression += wildcard;
+    cursor = offset + match[0].length;
+  }
+  expression += escapeRoutePatternLiteral(pattern.slice(cursor));
+  expression += "$";
+  return new RegExp(expression, "u").test(route);
+}
+function parseRoutePattern(value) {
+  const hash = value.indexOf("#");
+  const fragment = hash >= 0 ? value.slice(hash + 1) : undefined;
+  const withoutFragment = hash >= 0 ? value.slice(0, hash) : value;
+  const question = withoutFragment.indexOf("?");
+  const path =
+    question >= 0 ? withoutFragment.slice(0, question) : withoutFragment;
+  const querySource = question >= 0 ? withoutFragment.slice(question + 1) : "";
+  const query =
+    querySource.length === 0
+      ? []
+      : querySource.split("&").flatMap((part) => {
+          if (part.length === 0) return [];
+          const equals = part.indexOf("=");
+          return [
+            {
+              key: equals >= 0 ? part.slice(0, equals) : part,
+              value: equals >= 0 ? part.slice(equals + 1) : "",
+            },
+          ];
+        });
+  if (querySource.length > 0 && query.length === 0) return undefined;
+  return {
+    path,
+    query,
+    ...(fragment === undefined ? {} : { fragment }),
+  };
+}
+function queryPatternsMatch(patterns, routes) {
+  if (patterns.length !== routes.length) return false;
+  const used = new Set();
+  const matchAt = (index) => {
+    if (index === patterns.length) return true;
+    const pattern = patterns[index];
+    for (let candidate = 0; candidate < routes.length; candidate += 1) {
+      if (used.has(candidate)) continue;
+      const route = routes[candidate];
+      if (
+        !routePartMatches(pattern.key, route.key, "[^=&#]+") ||
+        !routePartMatches(pattern.value, route.value, "[^&#]*")
+      )
+        continue;
+      used.add(candidate);
+      if (matchAt(index + 1)) return true;
+      used.delete(candidate);
+    }
+    return false;
+  };
+  return matchAt(0);
+}
+/** Unifies a declared Compose route pattern with a concrete or symbolic call. */
+function routePatternMatches(pattern, route) {
+  const declared = parseRoutePattern(pattern);
+  const actual = parseRoutePattern(route);
+  if (!declared || !actual) return false;
+  if (!routePartMatches(declared.path, actual.path, "[^/?#]+")) return false;
+  if (!queryPatternsMatch(declared.query, actual.query)) return false;
+  if (declared.fragment === undefined || actual.fragment === undefined) {
+    return declared.fragment === actual.fragment;
+  }
+  return routePartMatches(declared.fragment, actual.fragment, "[^#]*");
+}
+/**
+ * Resolves a Navigation Compose route without guessing. Literal routes win
+ * only when unique; otherwise a `{parameter}` segment matches exactly one
+ * source `$value` or concrete path segment.
+ */
+export function resolveComposeRouteArea(route, components, areaByComponent) {
+  const candidates = components
+    .map((component) => ({
+      component,
+      route: declaredRoute(component),
+      areaRef: areaByComponent.get(component.id),
+    }))
+    .filter((candidate) => Boolean(candidate.route && candidate.areaRef));
+  const exact = uniqueSorted(
+    candidates
+      .filter((candidate) => candidate.route === route)
+      .map((candidate) => candidate.areaRef),
+  );
+  if (exact.length > 0) {
+    return {
+      ...(exact.length === 1 ? { areaRef: exact[0] } : {}),
+      candidateAreaRefs: exact,
+    };
+  }
+  const patterned = uniqueSorted(
+    candidates
+      .filter((candidate) => routePatternMatches(candidate.route, route))
+      .map((candidate) => candidate.areaRef),
+  );
+  return {
+    ...(patterned.length === 1 ? { areaRef: patterned[0] } : {}),
+    candidateAreaRefs: patterned,
+  };
+}
+/**
+ * Collapses implementation-only Compose containment into user-perceived Area
+ * anchors while preserving navigation destinations and real surfaces.
+ */
+export function resolveAreaOwnership(components, containers, options = {}) {
+  const componentById = new Map(
+    components.map((component) => [component.id, component]),
+  );
+  const explicitAppEntryComponentRefs =
+    options.explicitAppEntryComponentRefs ?? new Set();
+  const anchors = new Set(
+    components
+      .filter((component) =>
+        isAreaAnchor(component, explicitAppEntryComponentRefs),
+      )
+      .map((component) => component.id),
+  );
+  const exclusions = components
+    .filter(
+      (component) =>
+        isPotentialAreaAnchor(component) &&
+        isExternalManifestOnly(component) &&
+        !explicitAppEntryComponentRefs.has(component.id),
+    )
+    .map((component) => ({
+      componentRef: component.id,
+      status: "excluded-with-reason",
+      reasonCode: "EXTERNAL_MANIFEST_COMPONENT_WITHOUT_APP_ENTRY",
+      reason:
+        "The component is injected only by an external dependency and no " +
+        "selected app/local source explicitly enters it.",
+    }))
+    .sort((left, right) =>
+      left.componentRef.localeCompare(right.componentRef, "en"),
+    );
+  const parentsByContent = new Map();
+  for (const binding of containers) {
+    if (
+      binding.data.bindingKind !== "compose-content" ||
+      !componentById.has(binding.data.hostKey)
+    )
+      continue;
+    for (const contentRef of binding.data.contentKeys) {
+      if (!componentById.has(contentRef)) continue;
+      append(parentsByContent, contentRef, binding.data.hostKey);
+    }
+  }
+  for (const [content, parents] of parentsByContent) {
+    parentsByContent.set(content, uniqueSorted(parents));
+  }
+  const baseAnchor = new Map();
+  for (const component of components) {
+    const owner = nearest(
+      component.id,
+      parentsByContent,
+      (candidate) => anchors.has(candidate),
+      true,
+    );
+    if (owner) baseAnchor.set(component.id, owner);
+  }
+  const navigationBindings = containers
+    .filter(
+      (binding) =>
+        (binding.data.bindingKind === "navigation" ||
+          (binding.data.bindingKind === "pager" &&
+            binding.data.initialContentKey !== undefined) ||
+          (binding.data.bindingKind === "fragment" &&
+            binding.data.initialContentKey !== undefined)) &&
+        componentById.has(binding.data.hostKey),
+    )
+    .sort((left, right) => left.id.localeCompare(right.id, "en"));
+  const navigationHosts = new Set(
+    navigationBindings.map((binding) => binding.data.hostKey),
+  );
+  const redirects = new Map();
+  const redirectTargets = new Map();
+  const indeterminateRedirectSources = new Set();
+  const suppressedAnchors = new Set();
+  for (const binding of navigationBindings) {
+    const source = baseAnchor.get(binding.data.hostKey) ?? binding.data.hostKey;
+    const initial = binding.data.initialContentKey;
+    if (!initial || !componentById.has(initial)) {
+      indeterminateRedirectSources.add(source);
+      continue;
+    }
+    const target = baseAnchor.get(initial) ?? initial;
+    if (anchors.has(target) && source !== target) {
+      const targets = redirectTargets.get(source) ?? new Set();
+      targets.add(target);
+      redirectTargets.set(source, targets);
+    } else {
+      indeterminateRedirectSources.add(source);
+    }
+  }
+  for (const [source, targets] of redirectTargets) {
+    if (targets.size === 1 && !indeterminateRedirectSources.has(source)) {
+      redirects.set(source, [...targets][0]);
+      /*
+       * A navigation host is implementation-only only after one initial
+       * user-perceived surface has been proved. Dynamic start destinations,
+       * invalid references, or disagreeing bindings must retain the host as
+       * a real graph root; suppressing it earlier silently discards launcher
+       * entries and makes every destination appear unreachable.
+       */
+      if (anchors.has(source)) suppressedAnchors.add(source);
+    }
+  }
+  const resolveRedirect = (start) => {
+    const visited = new Set();
+    let current = start;
+    while (!visited.has(current)) {
+      visited.add(current);
+      const redirect = redirects.get(current);
+      if (!redirect) {
+        return anchors.has(current) && !suppressedAnchors.has(current)
+          ? current
+          : undefined;
+      }
+      current = redirect;
+    }
+    return undefined;
+  };
+  const areaAnchorByComponent = new Map();
+  for (const component of components) {
+    const base = baseAnchor.get(component.id);
+    let owner = base ? resolveRedirect(base) : undefined;
+    if (!owner) {
+      const navigationHost = nearest(
+        component.id,
+        parentsByContent,
+        (candidate) => navigationHosts.has(candidate),
+        true,
+      );
+      if (navigationHost) {
+        owner = resolveRedirect(navigationHost);
+      }
+    }
+    if (owner) areaAnchorByComponent.set(component.id, owner);
+  }
+  const groupByAnchor = new Map();
+  for (const [componentRef, anchorRef] of areaAnchorByComponent) {
+    append(groupByAnchor, anchorRef, componentRef);
+  }
+  const groups = [...groupByAnchor]
+    .map(([anchorRef, componentRefs]) => {
+      const anchor = componentById.get(anchorRef);
+      if (!anchor) return undefined;
+      const members = uniqueSorted(componentRefs);
+      const containerBindingRefs = containers
+        .filter(
+          (binding) =>
+            members.includes(binding.data.hostKey) ||
+            binding.data.contentKeys.some((contentRef) =>
+              members.includes(contentRef),
+            ),
+        )
+        .map((binding) => binding.id)
+        .sort((left, right) => left.localeCompare(right, "en"));
+      return {
+        anchor,
+        kind: areaKind(anchor.data.componentType),
+        componentRefs: members,
+        containerBindingRefs,
+      };
+    })
+    .filter((group) => group !== undefined)
+    .sort((left, right) => left.anchor.id.localeCompare(right.anchor.id, "en"));
+  return {
+    groups,
+    areaAnchorByComponent,
+    exclusions,
+  };
+}