@lariocpt/flawless-react 0.0.0-stage → 0.3.1

package/src/analyse/compoundFamily.ts

@@ -0,0 +1,100 @@
+import ts from "typescript";
+import type { ComponentInfo } from "../types.ts";
+import type { ImportBinding, ParsedComponentUnit } from "./parseFile.ts";
+import { emptyEnv, initialRenderExpression } from "./renderPath.ts";
+
+/**
+ * The compound family a part's OWN file exports, if it does: shadcn-style
+ * wrappers put Dialog (rendering DialogPrimitive.Root), DialogContent and
+ * every part in one module, so the wrapper a spec needs is a same-file
+ * import away. Derivation is same-file only — a cross-file family would
+ * need the child tree, and chasing it is exactly the guessing v1 avoids.
+ *
+ * The caller decides WHEN to derive (only for compound-part units) and the
+ * emitters decide whether the family is wrappable at all (open-state Roots
+ * only) — this module just reports what the file says.
+ */
+
+/** Headless-UI packages whose parts require a Root ancestor (extractRenderMode's list). */
+const COMPOUND_PACKAGES = /^@(base-ui|radix-ui|ariakit)(\/|$)/;
+
+const CONTENT_MEMBERS = new Set(["Content", "Popup"]);
+const ROOT_MEMBERS = new Set(["Root", "Provider"]);
+
+export function deriveCompoundFamily(
+  unit: ParsedComponentUnit,
+  siblings: ParsedComponentUnit[],
+  imports: Map<string, ImportBinding>,
+): ComponentInfo["compoundFamily"] {
+  const ownAll = compoundMembers(unit, imports);
+  // A package whose Root the unit renders itself is already provided for —
+  // only the UNROOTED members are what made this a compound part, and the
+  // family must be theirs (mirroring extractRenderMode's rootsProvided).
+  const selfRooted = new Set(
+    ownAll.filter((m) => ROOT_MEMBERS.has(m.member)).map((m) => m.specifier),
+  );
+  const unrooted = ownAll.filter((m) => !selfRooted.has(m.specifier));
+  const specifiers = new Set(unrooted.map((m) => m.specifier));
+  // Zero: a local-hop part with no direct member of its own — v2 territory.
+  // Two+: one wrap cannot fix both packages, and wrapping one leaves the
+  // other throwing — the honest skip was the right output.
+  if (specifiers.size !== 1) return undefined;
+  const specifier = [...specifiers][0] as string;
+  const own = unrooted.filter((m) => m.specifier === specifier);
+  // Sub-family members (SubTrigger, SubContent, Sub itself) additionally
+  // need a <Sub> ancestor that Root+Content cannot supply — confirmed red
+  // against real radix dropdown-menu. They stay honest skips.
+  if (own.some((m) => m.member.startsWith("Sub"))) return undefined;
+
+  let root: string | undefined;
+  let content: string | undefined;
+  for (const sibling of siblings) {
+    // Named exports only: both emitters import the wrappers by name, and a
+    // named import of a default-only export is TS2305 — in the host registry
+    // it takes the whole bundle down. The unit is never its own wrapper.
+    if (sibling.exportKind !== "named") continue;
+    if (sibling.componentName === unit.componentName) continue;
+    const members = compoundMembers(sibling, imports).filter((m) => m.specifier === specifier);
+    if (members.length === 0) continue;
+    if (members.some((m) => ROOT_MEMBERS.has(m.member))) {
+      root ??= sibling.componentName;
+    } else if (members.some((m) => CONTENT_MEMBERS.has(m.member))) {
+      content ??= sibling.componentName;
+    }
+  }
+  if (!root) return undefined;
+
+  const part = own.some((m) => m.member === "Trigger")
+    ? ("trigger" as const)
+    : own.some((m) => CONTENT_MEMBERS.has(m.member))
+      ? ("content" as const)
+      : ("other" as const);
+  return { root, ...(content !== undefined ? { content } : {}), part, specifier };
+}
+
+/** Every `<X.Member>` in the unit's initial render where X is a compound package. */
+function compoundMembers(
+  unit: ParsedComponentUnit,
+  imports: Map<string, ImportBinding>,
+): Array<{ member: string; specifier: string }> {
+  const expr = initialRenderExpression(unit.bodyNode, emptyEnv())?.expr;
+  if (!expr) return [];
+  const out: Array<{ member: string; specifier: string }> = [];
+  const visit = (n: ts.Node): void => {
+    let tagName: ts.JsxTagNameExpression | undefined;
+    if (ts.isJsxOpeningElement(n) || ts.isJsxSelfClosingElement(n)) tagName = n.tagName;
+    if (tagName && ts.isPropertyAccessExpression(tagName)) {
+      let rootExpr: ts.Expression = tagName.expression;
+      while (ts.isPropertyAccessExpression(rootExpr)) rootExpr = rootExpr.expression;
+      if (ts.isIdentifier(rootExpr)) {
+        const binding = imports.get(rootExpr.text);
+        if (binding && COMPOUND_PACKAGES.test(binding.specifier)) {
+          out.push({ member: tagName.name.text, specifier: binding.specifier });
+        }
+      }
+    }
+    ts.forEachChild(n, visit);
+  };
+  visit(expr);
+  return out;
+}

package/src/analyse/dataExports.ts

@@ -0,0 +1,200 @@
+import ts from "typescript";
+import type { ModuleResolver } from "./resolveModule.ts";
+import type { SourceFileCache } from "./sourceCache.ts";
+import { findExportedDecl } from "./sourceCache.ts";
+
+/**
+ * Module-side exports whose declarations are DATA constants — the evidence
+ * the mock emitter needs to leave a config-style module real in RSC mode.
+ *
+ * When EVERYTHING a component imports from a module is one of these, the
+ * module must not be mocked at all. A mock factory replaces the module for
+ * the whole graph, and a wholesale replacement only ever enumerates the one
+ * component's import list: stubbing `@/config/site` to satisfy a component's
+ * `SOURCE_CODE_GITHUB_REPO` left json-ld.ts's `SITE_INFO` undefined, and the
+ * chanhdai dogfood buried 150+ specs at collection under
+ * `No "SITE_INFO" export is defined on the "@/config/site" mock`.
+ *
+ * Conservative on purpose — "declared" STOPS the barrel walk, so a module can
+ * never be unmocked on the strength of a name that is not really its data
+ * export. Two verdicts per name found:
+ *
+ *   data     — initializers that cannot compute at module scope: literals,
+ *              substitution-free templates, property-access chains
+ *              (`USER.bio`, `process.env.X || "https://…"`), object/array
+ *              literals built only of those, and logical/binary/ternary
+ *              compositions of those.
+ *   declared — anything else that declares the name: a function, class or
+ *              enum, an initializer containing a call, `new`, `await`, or a
+ *              bare identifier whose binding the scan cannot see. An env
+ *              module exporting `envSchema.parse(…)` lands here — those
+ *              stay mocked, exactly as before.
+ *
+ * A name never located at all yields nothing: the mock's normal honest {}
+ * fallback covers it, and unmocking on an absence would import blind.
+ *
+ * "default" names the default export (`export default { … }`), same
+ * convention as importedReturns/serverActionReturns.
+ */
+export function dataConstantExports(
+  mi: { names: string[]; importedNames?: string[]; isTypeOnly: boolean; hasDefault: boolean },
+  resolvedPath: string,
+  resolver: ModuleResolver,
+  cache: SourceFileCache,
+): string[] {
+  if (mi.isTypeOnly) return [];
+  const out: string[] = [];
+  for (const [i, local] of mi.names.entries()) {
+    const exported = mi.hasDefault && i === 0 ? "default" : (mi.importedNames?.[i] ?? local);
+    if (!exported) continue;
+    const located = findExportedDecl(
+      resolvedPath,
+      exported,
+      cache,
+      resolver,
+      selectDeclaration,
+      true,
+    );
+    if (located?.decl === "data") out.push(exported);
+  }
+  return out;
+}
+
+type DeclHit = "data" | "declared";
+
+/**
+ * Verdict for one statement list: "data" for an exported data constant,
+ * "declared" for any other executable declaration of the name, undefined to
+ * keep walking (not here — a barrel arm may hold it; type-only declarations
+ * are erased at runtime and never claim a value binding).
+ */
+function selectDeclaration(
+  sf: ts.SourceFile,
+  name: string,
+  viaReexport: boolean,
+): DeclHit | undefined {
+  for (const stmt of sf.statements) {
+    if (ts.isVariableStatement(stmt)) {
+      const exported =
+        ts.canHaveModifiers(stmt) &&
+        (ts.getModifiers(stmt)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false);
+      // Reached through a re-export chain, only an exported declaration can
+      // vouch for the name; a local `export { X as Y }` clause re-queries
+      // this file with viaReexport=false and binds the private one.
+      if (viaReexport && !exported) continue;
+      for (const d of stmt.declarationList.declarations) {
+        if (!ts.isIdentifier(d.name) || d.name.text !== name) continue;
+        return d.initializer !== undefined && isDataExpr(d.initializer) ? "data" : "declared";
+      }
+      continue;
+    }
+    if (ts.isExportAssignment(stmt)) {
+      if (name === "default" && !stmt.isExportEquals) {
+        return isDataExpr(stmt.expression) ? "data" : "declared";
+      }
+      continue;
+    }
+    if (ts.isFunctionDeclaration(stmt) && stmt.name?.text === name) return "declared";
+    if (ts.isClassDeclaration(stmt) && stmt.name?.text === name) return "declared";
+    if (ts.isEnumDeclaration(stmt) && stmt.name.text === name) return "declared";
+  }
+  return undefined;
+}
+
+/** Depth bound on literal nesting — config files stop at 2-3; beyond this, bail. */
+const MAX_DATA_DEPTH = 8;
+
+/**
+ * Is this initializer shaped as data — read-only composition of literals and
+ * property reads, never a call, a construction, or a function value?
+ *
+ * `export const fn = obj.method` passes: the chain is a read, and on the
+ * skip path the module loads REAL, so even a function-valued constant keeps
+ * its real shape. The question the answer feeds is only whether the module
+ * SCOPE can compute or throw — calls, `new`, `await` and function literals
+ * disqualify precisely because they do.
+ */
+function isDataExpr(e: ts.Expression, depth = 0): boolean {
+  if (depth > MAX_DATA_DEPTH) return false;
+  for (;;) {
+    if (
+      ts.isParenthesizedExpression(e) ||
+      ts.isAsExpression(e) ||
+      ts.isSatisfiesExpression(e) ||
+      ts.isTypeAssertionExpression(e) ||
+      ts.isNonNullExpression(e)
+    ) {
+      e = e.expression;
+      continue;
+    }
+    break;
+  }
+  if (
+    ts.isStringLiteral(e) ||
+    ts.isNumericLiteral(e) ||
+    ts.isBigIntLiteral(e) ||
+    ts.isNoSubstitutionTemplateLiteral(e)
+  ) {
+    return true;
+  }
+  if (
+    e.kind === ts.SyntaxKind.TrueKeyword ||
+    e.kind === ts.SyntaxKind.FalseKeyword ||
+    e.kind === ts.SyntaxKind.NullKeyword
+  ) {
+    return true;
+  }
+  if (ts.isIdentifier(e)) {
+    // Only `export const X = undefined` — a bare identifier could be bound
+    // to a call result two statements up.
+    return e.text === "undefined";
+  }
+  if (ts.isPropertyAccessExpression(e)) {
+    // Chain root is an opaque read — an import (USER, process) or a file
+    // const. Property access itself cannot compute.
+    return ts.isIdentifier(e.expression) || isDataExpr(e.expression, depth + 1);
+  }
+  if (ts.isElementAccessExpression(e)) {
+    return (
+      (ts.isIdentifier(e.expression) || isDataExpr(e.expression, depth + 1)) &&
+      isDataExpr(e.argumentExpression, depth + 1)
+    );
+  }
+  if (ts.isTemplateExpression(e)) {
+    return e.head.text === "" && e.templateSpans.every((s) => s.literal.text === "");
+  }
+  if (ts.isObjectLiteralExpression(e)) {
+    return e.properties.every((p) => {
+      if (ts.isPropertyAssignment(p)) {
+        if (p.name !== undefined && ts.isComputedPropertyName(p.name)) return false;
+        return isDataExpr(p.initializer, depth + 1);
+      }
+      if (ts.isSpreadAssignment(p)) return isDataExpr(p.expression, depth + 1);
+      // Shorthand binds an unknown local; methods and accessors are functions.
+      return false;
+    });
+  }
+  if (ts.isArrayLiteralExpression(e)) {
+    return e.elements.every(
+      (el) => el.kind === ts.SyntaxKind.OmittedExpression || isDataExpr(el, depth + 1),
+    );
+  }
+  // isBinaryExpression covers the logical forms (&&, ||, ??) too.
+  if (ts.isBinaryExpression(e)) {
+    return isDataExpr(e.left, depth + 1) && isDataExpr(e.right, depth + 1);
+  }
+  if (ts.isConditionalExpression(e)) {
+    return (
+      isDataExpr(e.condition, depth + 1) &&
+      isDataExpr(e.whenTrue, depth + 1) &&
+      isDataExpr(e.whenFalse, depth + 1)
+    );
+  }
+  if (ts.isPrefixUnaryExpression(e)) {
+    return (
+      (e.operator === ts.SyntaxKind.MinusToken || e.operator === ts.SyntaxKind.PlusToken) &&
+      isDataExpr(e.operand, depth + 1)
+    );
+  }
+  return false;
+}

package/src/analyse/extractChildAttrs.ts

@@ -0,0 +1,112 @@
+import ts from "typescript";
+import type { AttrValueKind, ChildAttrInfo } from "../types.ts";
+import { posOf } from "./pos.ts";
+
+interface ClassifiedValue {
+  valueKind: AttrValueKind;
+  /** Root identifier for identifier / member kinds. */
+  identifier?: string;
+}
+
+/**
+ * Attribute shapes passed to uppercase (component) JSX children under
+ * `bodyNode`. Lowercase host elements (div, button…) are skipped entirely.
+ */
+export function extractChildAttrs(bodyNode: ts.Node, sourceFile: ts.SourceFile): ChildAttrInfo[] {
+  const out: ChildAttrInfo[] = [];
+
+  const visit = (n: ts.Node): void => {
+    if (ts.isJsxOpeningElement(n) || ts.isJsxSelfClosingElement(n)) {
+      const tag = componentTagName(n.tagName);
+      if (tag !== undefined) {
+        for (const attr of n.attributes.properties) {
+          if (ts.isJsxSpreadAttribute(attr)) {
+            out.push({
+              tag,
+              attr: "...spread",
+              valueKind: "spread",
+              pos: posOf(attr, sourceFile),
+            });
+            continue;
+          }
+          if (!ts.isJsxAttribute(attr)) continue;
+          const name = ts.isIdentifier(attr.name)
+            ? attr.name.text
+            : `${attr.name.namespace.text}:${attr.name.name.text}`;
+          const classified = classifyInitializer(attr.initializer);
+          const entry: ChildAttrInfo = {
+            tag,
+            attr: name,
+            valueKind: classified.valueKind,
+            pos: posOf(attr, sourceFile),
+          };
+          if (classified.identifier !== undefined) entry.identifier = classified.identifier;
+          out.push(entry);
+        }
+      }
+    }
+    ts.forEachChild(n, visit);
+  };
+  ts.forEachChild(bodyNode, visit);
+
+  return out;
+}
+
+/** Full dotted tag text ("Card", "Menu.Item") when the root identifier is uppercase. */
+function componentTagName(tag: ts.JsxTagNameExpression): string | undefined {
+  if (ts.isIdentifier(tag)) {
+    return /^[A-Z]/.test(tag.text) ? tag.text : undefined;
+  }
+  if (ts.isPropertyAccessExpression(tag)) {
+    let root: ts.Expression = tag.expression;
+    while (ts.isPropertyAccessExpression(root)) root = root.expression;
+    if (ts.isIdentifier(root) && /^[A-Z]/.test(root.text)) return readPropertyAccess(tag);
+  }
+  return undefined;
+}
+
+function readPropertyAccess(p: ts.PropertyAccessExpression): string {
+  const head = ts.isIdentifier(p.expression)
+    ? p.expression.text
+    : ts.isPropertyAccessExpression(p.expression)
+      ? readPropertyAccess(p.expression)
+      : "<dynamic>";
+  return `${head}.${p.name.text}`;
+}
+
+function classifyInitializer(init: ts.JsxAttribute["initializer"]): ClassifiedValue {
+  if (!init) return { valueKind: "boolean-true" };
+  if (ts.isStringLiteral(init)) return { valueKind: "string" };
+  if (ts.isJsxExpression(init)) {
+    return init.expression ? classifyExpression(init.expression) : { valueKind: "other" };
+  }
+  // TS 5.x also allows JsxElement/JsxFragment attribute values directly.
+  return { valueKind: "jsx" };
+}
+
+function classifyExpression(expr: ts.Expression): ClassifiedValue {
+  if (ts.isStringLiteral(expr)) return { valueKind: "string" };
+  if (ts.isNumericLiteral(expr)) return { valueKind: "number" };
+  if (expr.kind === ts.SyntaxKind.TrueKeyword || expr.kind === ts.SyntaxKind.FalseKeyword) {
+    // The approved AttrValueKind union has no "boolean-false"; a literal
+    // `false` value is deliberately reported as "boolean-true" too.
+    return { valueKind: "boolean-true" };
+  }
+  if (expr.kind === ts.SyntaxKind.NullKeyword) return { valueKind: "null" };
+  if (ts.isIdentifier(expr)) return { valueKind: "identifier", identifier: expr.text };
+  if (ts.isPropertyAccessExpression(expr)) {
+    let root: ts.Expression = expr.expression;
+    while (ts.isPropertyAccessExpression(root)) root = root.expression;
+    if (ts.isIdentifier(root)) return { valueKind: "member", identifier: root.text };
+    return { valueKind: "member" };
+  }
+  if (ts.isObjectLiteralExpression(expr)) return { valueKind: "object-literal" };
+  if (ts.isArrayLiteralExpression(expr)) return { valueKind: "array-literal" };
+  if (ts.isArrowFunction(expr)) return { valueKind: "arrow" };
+  if (ts.isFunctionExpression(expr)) return { valueKind: "function" };
+  if (ts.isCallExpression(expr)) return { valueKind: "call" };
+  if (ts.isJsxElement(expr) || ts.isJsxSelfClosingElement(expr) || ts.isJsxFragment(expr)) {
+    return { valueKind: "jsx" };
+  }
+  return { valueKind: "other" };
+}