@invariant-ui/cli 0.0.0-stage → 0.1.0

package/dist/compiler-core/ts/ast.js

@@ -0,0 +1,166 @@
+import ts from "typescript";
+export function unwrap(node) {
+    let current = node;
+    while (ts.isParenthesizedExpression(current) ||
+        ts.isAsExpression(current) ||
+        ts.isSatisfiesExpression(current) ||
+        ts.isNonNullExpression(current) ||
+        ts.isTypeAssertionExpression(current)) {
+        current = current.expression;
+    }
+    return current;
+}
+export function collapse(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+/** JSON value of a static literal expression, or undefined when the expression is not a plain literal. */
+export function literalValue(expression) {
+    const node = unwrap(expression);
+    if (ts.isStringLiteralLike(node))
+        return node.text;
+    if (ts.isNumericLiteral(node))
+        return Number(node.text);
+    if (node.kind === ts.SyntaxKind.TrueKeyword)
+        return true;
+    if (node.kind === ts.SyntaxKind.FalseKeyword)
+        return false;
+    if (node.kind === ts.SyntaxKind.NullKeyword)
+        return null;
+    if (ts.isPrefixUnaryExpression(node) &&
+        node.operator === ts.SyntaxKind.MinusToken &&
+        ts.isNumericLiteral(node.operand)) {
+        return -Number(node.operand.text);
+    }
+    if (ts.isArrayLiteralExpression(node)) {
+        const items = node.elements.map((e) => literalValue(e));
+        return items.every((i) => i !== undefined) ? items : undefined;
+    }
+    if (ts.isObjectLiteralExpression(node)) {
+        const out = {};
+        for (const p of node.properties) {
+            if (!ts.isPropertyAssignment(p) || !(ts.isIdentifier(p.name) || ts.isStringLiteralLike(p.name)))
+                return undefined;
+            const v = literalValue(p.initializer);
+            if (v === undefined)
+                return undefined;
+            out[p.name.text] = v;
+        }
+        return out;
+    }
+    return undefined;
+}
+export function lineOf(node) {
+    const sf = node.getSourceFile();
+    return sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
+}
+/** First source line of a node, trimmed and bounded, for use as an evidence excerpt. */
+export function excerpt(node) {
+    const text = node.getText(node.getSourceFile());
+    return collapse(text.split("\n")[0] ?? "").slice(0, 200);
+}
+export function relativeFileOf(analysis, node) {
+    return analysis.relativePath(node.getSourceFile().fileName);
+}
+export function isProjectNode(analysis, node) {
+    return relativeFileOf(analysis, node) !== undefined;
+}
+export function hasModifier(node, kind) {
+    return ts.canHaveModifiers(node) && !!ts.getModifiers(node)?.some((m) => m.kind === kind);
+}
+/** Resolves aliases (imports and re-exports) to the symbol that declares the value. */
+export function resolveSymbol(checker, symbol) {
+    if (!symbol)
+        return undefined;
+    return symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+}
+export function declarationOf(symbol) {
+    return symbol?.valueDeclaration ?? symbol?.declarations?.[0];
+}
+/** `Foo.bar = value` assignments at the top level of a file, keyed `Foo.bar`. */
+export function topLevelAssignments(sf) {
+    const out = new Map();
+    for (const statement of sf.statements) {
+        if (!ts.isExpressionStatement(statement))
+            continue;
+        const e = statement.expression;
+        if (ts.isBinaryExpression(e) &&
+            e.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+            ts.isPropertyAccessExpression(e.left) &&
+            ts.isIdentifier(e.left.expression)) {
+            out.set(`${e.left.expression.text}.${e.left.name.text}`, e.right);
+        }
+    }
+    return out;
+}
+/** Walks `node` without descending into nested function-like bodies (other than `node` itself). */
+export function walkSameFunction(node, visit) {
+    const go = (n) => {
+        if (n !== node && ts.isFunctionLike(n))
+            return;
+        visit(n);
+        ts.forEachChild(n, go);
+    };
+    ts.forEachChild(node, go);
+}
+export function subTarget(checker, node) {
+    if (ts.isShorthandPropertyAssignment(node))
+        return declarationOf(resolveSymbol(checker, checker.getShorthandAssignmentValueSymbol(node)));
+    const expression = ts.isPropertyAssignment(node)
+        ? unwrap(node.initializer)
+        : ts.isExpression(node)
+            ? unwrap(node)
+            : undefined;
+    if (expression && ts.isIdentifier(expression))
+        return declarationOf(resolveSymbol(checker, checker.getSymbolAtLocation(expression)));
+    return undefined;
+}
+/** Declaration a JSX tag refers to, following imports, `export default X`, and `Root.Child` properties. */
+export function jsxTargetDeclaration(checker, tag) {
+    const symbol = ts.isPropertyAccessExpression(tag)
+        ? checker.getSymbolAtLocation(tag.name)
+        : checker.getSymbolAtLocation(tag);
+    let decl = declarationOf(resolveSymbol(checker, symbol));
+    for (let hops = 0; decl && hops < 4; hops++) {
+        if (ts.isExportAssignment(decl)) {
+            const e = unwrap(decl.expression);
+            decl = ts.isIdentifier(e) ? declarationOf(resolveSymbol(checker, checker.getSymbolAtLocation(e))) : decl;
+            if (!ts.isExportAssignment(decl))
+                continue;
+            return decl;
+        }
+        if (ts.isPropertyAssignment(decl) || ts.isShorthandPropertyAssignment(decl)) {
+            decl = subTarget(checker, decl);
+            continue;
+        }
+        if (ts.isPropertyAccessExpression(decl) &&
+            ts.isBinaryExpression(decl.parent) &&
+            decl.parent.left === decl) {
+            decl = subTarget(checker, decl.parent.right);
+            continue;
+        }
+        return decl;
+    }
+    return decl;
+}
+/**
+ * Component name for a single-file component path: the PascalCase file name (`button-group.vue` is
+ * `ButtonGroup`). This is the convention both the Vue adapter and Storybook linking use.
+ */
+export function componentNameFromFile(path) {
+    const base = path.replace(/^.*\//, "").replace(/\.[^.]+$/, "");
+    return base
+        .split(/[-_.\s]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join("");
+}
+/** The name and type arguments of `Foo<P>`, `ns.Foo<P>` and `import("pkg").Foo<P>`: the written form, nothing resolved. */
+export function typeReferenceInfo(type) {
+    const lastName = (n) => (ts.isQualifiedName(n) ? n.right.text : n.text);
+    if (ts.isTypeReferenceNode(type))
+        return { name: lastName(type.typeName), typeArguments: type.typeArguments ?? [] };
+    if (ts.isImportTypeNode(type) && type.qualifier)
+        return { name: lastName(type.qualifier), typeArguments: type.typeArguments ?? [] };
+    return undefined;
+}
+//# sourceMappingURL=ast.js.map

package/dist/compiler-core/ts/members.js

@@ -0,0 +1,163 @@
+import ts from "typescript";
+import { collapse, declarationOf, isProjectNode, lineOf, resolveSymbol } from "./ast.js";
+const UTILITY_TYPES = new Set(["Omit", "Pick", "Partial", "Required", "Readonly"]);
+/**
+ * Properties of `type` declared inside the analyzed project. Members inherited from types outside the
+ * project (or unresolved) are not returned; use `externalBases` to report them.
+ */
+export function ownProperties(analysis, type) {
+    const out = [];
+    for (const symbol of analysis.checker.getPropertiesOfType(type)) {
+        const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+        if (declaration && isProjectNode(analysis, declaration))
+            out.push({ symbol, declaration });
+    }
+    return out;
+}
+/**
+ * Describes one property: its declared type text, a framework-neutral kind, whether it is required,
+ * its literal domain in declaration order, and its JSDoc description and deprecation. `renderable`
+ * marks a framework's "renderable content" types (for example React's ReactNode) as kind `component`.
+ */
+export function describeMember(analysis, symbol, declaration, options = {}) {
+    const { checker } = analysis;
+    const typeNode = ts.isPropertySignature(declaration) || ts.isPropertyDeclaration(declaration)
+        ? declaration.type
+        : undefined;
+    const type = checker.getTypeOfSymbolAtLocation(symbol, declaration);
+    const typeText = collapse(typeNode ? typeNode.getText() : checker.typeToString(type));
+    const kind = classifyKind(checker, type, typeText, options.renderable);
+    const allowedValues = allowedValuesOf(checker, typeNode, type, kind);
+    const doc = ts.displayPartsToString(symbol.getDocumentationComment(checker)).trim();
+    const deprecatedTag = symbol.getJsDocTags(checker).find((t) => t.name === "deprecated");
+    const deprecatedText = deprecatedTag ? ts.displayPartsToString(deprecatedTag.text).trim() : undefined;
+    const parentName = declarationParentName(declaration);
+    return {
+        name: symbol.name,
+        typeText,
+        kind,
+        required: (symbol.flags & ts.SymbolFlags.Optional) === 0,
+        ...(allowedValues ? { allowedValues } : {}),
+        ...(doc ? { description: doc } : {}),
+        ...(deprecatedTag ? { deprecated: deprecatedText ? { reason: deprecatedText } : {} } : {}),
+        ...(parentName ? { parentName } : {}),
+        node: declaration,
+        line: lineOf(declaration)
+    };
+}
+export function classifyKind(checker, type, typeText, renderable) {
+    if (renderable?.test(typeText.replace(/\s*\|\s*(?:undefined|null)/g, "")))
+        return "component";
+    const nonNull = checker.getNonNullableType(type);
+    if (nonNull.getCallSignatures().length > 0)
+        return "function";
+    if (nonNull.flags & ts.TypeFlags.BooleanLike)
+        return "boolean";
+    if (nonNull.isUnion()) {
+        const parts = nonNull.types;
+        if (parts.every((t) => t.flags & ts.TypeFlags.BooleanLiteral))
+            return "boolean";
+        if (parts.every((t) => t.flags & (ts.TypeFlags.StringLiteral | ts.TypeFlags.NumberLiteral | ts.TypeFlags.BooleanLiteral)))
+            return "enum";
+        return "union";
+    }
+    if (nonNull.flags & ts.TypeFlags.StringLike)
+        return nonNull.flags & ts.TypeFlags.StringLiteral ? "enum" : "string";
+    if (nonNull.flags & ts.TypeFlags.NumberLike)
+        return nonNull.flags & ts.TypeFlags.NumberLiteral ? "enum" : "number";
+    if (checker.isArrayType(nonNull) || checker.isTupleType(nonNull))
+        return "array";
+    if (nonNull.flags & ts.TypeFlags.Object)
+        return "object";
+    return "unknown";
+}
+/** Finite literal domain in declaration order when the declared type is a union of literals (through aliases). */
+export function allowedValuesOf(checker, typeNode, type, kind) {
+    if (kind !== "enum")
+        return undefined;
+    const ordered = typeNode ? literalDomain(checker, typeNode, 0) : undefined;
+    if (ordered && ordered.length > 0)
+        return ordered;
+    const nonNull = checker.getNonNullableType(type);
+    const parts = nonNull.isUnion() ? nonNull.types : [nonNull];
+    const values = parts.flatMap((t) => (t.isStringLiteral() || t.isNumberLiteral() ? [t.value] : []));
+    return values.length > 0 ? values.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0)) : undefined;
+}
+/** Ordered literal values of a union-of-literals type node, or undefined when any member is not a literal. */
+export function literalDomain(checker, node, depth = 0) {
+    if (depth > 5)
+        return undefined;
+    if (ts.isParenthesizedTypeNode(node))
+        return literalDomain(checker, node.type, depth + 1);
+    if (ts.isUnionTypeNode(node)) {
+        const parts = node.types.map((t) => literalDomain(checker, t, depth + 1));
+        return parts.every((p) => p !== undefined)
+            ? parts.flat()
+            : undefined;
+    }
+    if (ts.isLiteralTypeNode(node)) {
+        const literal = node.literal;
+        if (ts.isStringLiteral(literal))
+            return [literal.text];
+        if (ts.isNumericLiteral(literal))
+            return [Number(literal.text)];
+        if (literal.kind === ts.SyntaxKind.NullKeyword)
+            return [];
+        if (literal.kind === ts.SyntaxKind.TrueKeyword)
+            return [true];
+        if (literal.kind === ts.SyntaxKind.FalseKeyword)
+            return [false];
+        return undefined;
+    }
+    if (node.kind === ts.SyntaxKind.UndefinedKeyword)
+        return [];
+    if (ts.isTypeReferenceNode(node)) {
+        const target = declarationOf(resolveSymbol(checker, checker.getSymbolAtLocation(node.typeName)));
+        if (target && ts.isTypeAliasDeclaration(target))
+            return literalDomain(checker, target.type, depth + 1);
+    }
+    return undefined;
+}
+export function declarationParentName(declaration) {
+    const parent = declaration.parent;
+    if (ts.isInterfaceDeclaration(parent) || ts.isClassDeclaration(parent))
+        return parent.name?.text;
+    if (ts.isTypeLiteralNode(parent) && ts.isTypeAliasDeclaration(parent.parent))
+        return parent.parent.name.text;
+    return undefined;
+}
+/** Types in the heritage of a props type that are external to the project or unresolved. */
+export function externalBases(analysis, node, depth = 0) {
+    if (!node || depth > 6)
+        return [];
+    const { checker } = analysis;
+    if (ts.isIntersectionTypeNode(node) || ts.isUnionTypeNode(node))
+        return node.types.flatMap((t) => externalBases(analysis, t, depth + 1));
+    if (ts.isParenthesizedTypeNode(node))
+        return externalBases(analysis, node.type, depth + 1);
+    // `import("pkg").Type` always refers to something outside the analyzed project.
+    if (ts.isImportTypeNode(node))
+        return [collapse(node.getText())];
+    const reference = ts.isTypeReferenceNode(node)
+        ? { name: node.typeName, args: node.typeArguments }
+        : ts.isExpressionWithTypeArguments(node)
+            ? { name: node.expression, args: node.typeArguments }
+            : undefined;
+    if (!reference)
+        return [];
+    const text = collapse(node.getText());
+    if (UTILITY_TYPES.has(reference.name.getText()) && reference.args?.[0])
+        return externalBases(analysis, reference.args[0], depth + 1);
+    const symbol = resolveSymbol(checker, checker.getSymbolAtLocation(reference.name));
+    const local = (symbol?.declarations ?? []).filter((d) => isProjectNode(analysis, d));
+    if (local.length === 0)
+        return [text];
+    return local.flatMap((d) => {
+        if (ts.isInterfaceDeclaration(d))
+            return (d.heritageClauses ?? []).flatMap((h) => h.types.flatMap((t) => externalBases(analysis, t, depth + 1)));
+        if (ts.isTypeAliasDeclaration(d))
+            return externalBases(analysis, d.type, depth + 1);
+        return [];
+    });
+}
+//# sourceMappingURL=members.js.map

package/dist/compiler-core/ts/program.js

@@ -0,0 +1,81 @@
+import { existsSync, readFileSync } from "node:fs";
+import { posix } from "node:path";
+import ts from "typescript";
+/**
+ * Builds a type-checking program over the supplied project files only. Nothing is read from
+ * `node_modules` and no customer code runs: third-party types (including `@types/react`) are not
+ * loaded, so references to them stay unresolved and are reported as such rather than guessed.
+ * TypeScript's own `lib.es2022.d.ts` is read so built-in utility types like `Omit` resolve.
+ */
+export function createAnalysis(files, extra = {}) {
+    const virtual = new Map([...files].map(([rel, text]) => [`/${rel}`, text]));
+    const external = new Map([...(extra.externalFiles ?? [])].map(([rel, text]) => [`/${rel}`, text]));
+    const options = {
+        target: ts.ScriptTarget.ES2022,
+        module: ts.ModuleKind.ESNext,
+        moduleResolution: ts.ModuleResolutionKind.Bundler,
+        jsx: ts.JsxEmit.ReactJSX,
+        lib: ["lib.es2022.d.ts"],
+        types: [],
+        strict: true,
+        allowJs: true,
+        checkJs: false,
+        noEmit: true,
+        skipLibCheck: true,
+        resolveJsonModule: true,
+        allowArbitraryExtensions: true,
+        // Workspace package names resolved to project-relative entry files (supplied by the caller).
+        ...(extra.paths
+            ? {
+                baseUrl: "/",
+                paths: Object.fromEntries(Object.entries(extra.paths).map(([name, targets]) => [name, targets.map((t) => `/${t}`)]))
+            }
+            : {})
+    };
+    const libDir = ts.getDefaultLibFilePath(options).replace(/[^/\\]+$/, "");
+    const isLib = (file) => file.startsWith(libDir);
+    const read = (file) => {
+        const text = virtual.get(file) ?? external.get(file);
+        if (text !== undefined)
+            return text;
+        return isLib(file) && existsSync(file) ? readFileSync(file, "utf8") : undefined;
+    };
+    const host = {
+        getSourceFile: (file, languageVersion) => {
+            const text = read(file);
+            return text === undefined ? undefined : ts.createSourceFile(file, text, languageVersion, true);
+        },
+        getDefaultLibFileName: (o) => ts.getDefaultLibFilePath(o),
+        writeFile: () => { },
+        getCurrentDirectory: () => "/",
+        getDirectories: () => [],
+        fileExists: (file) => read(file) !== undefined,
+        readFile: read,
+        getCanonicalFileName: (file) => file,
+        useCaseSensitiveFileNames: () => true,
+        getNewLine: () => "\n",
+        ...(extra.moduleAliases
+            ? {
+                resolveModuleNames: (names, containingFile) => names.map((name) => {
+                    const aliases = extra.moduleAliases;
+                    if (name.startsWith(".")) {
+                        const target = aliases[posix.normalize(posix.join(posix.dirname(containingFile.slice(1)), name))];
+                        if (target)
+                            return { resolvedFileName: `/${target}`, extension: ts.Extension.Ts };
+                    }
+                    return ts.resolveModuleName(name, containingFile, options, host).resolvedModule;
+                })
+            }
+            : {})
+    };
+    const roots = [...virtual.keys()].filter((f) => /\.(?:[cm]?[jt]sx?)$/.test(f));
+    const program = ts.createProgram({ rootNames: roots, options, host });
+    return {
+        program,
+        checker: program.getTypeChecker(),
+        relativePath: (fileName) => (virtual.has(fileName) ? fileName.slice(1) : undefined),
+        sourceFile: (rel) => program.getSourceFile(`/${rel}`),
+        hasFile: (rel) => virtual.has(`/${rel}`)
+    };
+}
+//# sourceMappingURL=program.js.map

package/dist/compiler-core/ts/static-eval.js

@@ -0,0 +1,145 @@
+import { declarationOf, resolveSymbol, unwrap } from "../index.js";
+import ts from "typescript";
+const MAX_DEPTH = 8;
+const SPY_CALLEES = new Set(["fn", "action"]);
+export function evaluate(checker, expression, depth = 0) {
+    const node = unwrap(expression);
+    if (depth > MAX_DEPTH)
+        return dynamic();
+    if (ts.isStringLiteralLike(node))
+        return resolved(node.text);
+    if (ts.isNumericLiteral(node))
+        return resolved(Number(node.text));
+    if (node.kind === ts.SyntaxKind.TrueKeyword)
+        return resolved(true);
+    if (node.kind === ts.SyntaxKind.FalseKeyword)
+        return resolved(false);
+    if (node.kind === ts.SyntaxKind.NullKeyword)
+        return resolved(null);
+    if (ts.isIdentifier(node) && node.text === "undefined")
+        return { unresolved: [], spies: [] };
+    if (ts.isPrefixUnaryExpression(node) &&
+        node.operator === ts.SyntaxKind.MinusToken &&
+        ts.isNumericLiteral(node.operand)) {
+        return resolved(-Number(node.operand.text));
+    }
+    if (ts.isObjectLiteralExpression(node))
+        return evaluateObject(checker, node, depth);
+    if (ts.isArrayLiteralExpression(node)) {
+        const items = [];
+        const unresolved = [];
+        for (const element of node.elements) {
+            const inner = evaluate(checker, element, depth + 1);
+            if (inner.value === undefined || inner.unresolved.length > 0)
+                unresolved.push("[]");
+            else
+                items.push(inner.value);
+        }
+        // An array with any unresolvable element is not partially trusted.
+        return unresolved.length > 0 ? dynamic() : resolved(items);
+    }
+    if (ts.isIdentifier(node)) {
+        const decl = declarationOf(resolveSymbol(checker, checker.getSymbolAtLocation(node)));
+        if (decl && ts.isVariableDeclaration(decl) && decl.initializer && decl !== node.parent)
+            return evaluate(checker, decl.initializer, depth + 1);
+        return dynamic();
+    }
+    if (ts.isPropertyAccessExpression(node) ||
+        (ts.isElementAccessExpression(node) &&
+            node.argumentExpression &&
+            ts.isStringLiteralLike(node.argumentExpression))) {
+        const key = ts.isPropertyAccessExpression(node)
+            ? node.name.text
+            : node.argumentExpression.text;
+        const base = evaluate(checker, node.expression, depth + 1);
+        if (base.value !== null &&
+            typeof base.value === "object" &&
+            !Array.isArray(base.value) &&
+            key in base.value) {
+            const picked = base.value[key];
+            return {
+                ...(picked === undefined ? {} : { value: picked }),
+                unresolved: base.unresolved
+                    .filter((p) => p === key || p.startsWith(`${key}.`))
+                    .map((p) => (p === key ? "" : p.slice(key.length + 1))),
+                spies: base.spies
+                    .filter((p) => p === key || p.startsWith(`${key}.`))
+                    .map((p) => (p === key ? "" : p.slice(key.length + 1)))
+            };
+        }
+        return dynamic();
+    }
+    if (ts.isCallExpression(node) && SPY_CALLEES.has(node.expression.getText().replace(/^.*\./, ""))) {
+        return { unresolved: [""], spies: [""] };
+    }
+    return dynamic();
+}
+function evaluateObject(checker, node, depth) {
+    const value = {};
+    const unresolved = [];
+    const spies = [];
+    const keys = new Set();
+    const mark = (key, inner) => {
+        for (const p of inner.unresolved)
+            unresolved.push(p === "" ? key : `${key}.${p}`);
+        for (const p of inner.spies)
+            spies.push(p === "" ? key : `${key}.${p}`);
+    };
+    for (const property of node.properties) {
+        if (ts.isSpreadAssignment(property)) {
+            const inner = evaluate(checker, property.expression, depth + 1);
+            if (inner.value !== null && typeof inner.value === "object" && !Array.isArray(inner.value)) {
+                for (const [k, v] of Object.entries(inner.value))
+                    value[k] = v;
+                for (const k of inner.keys ?? Object.keys(inner.value))
+                    keys.add(k);
+                unresolved.push(...inner.unresolved);
+                spies.push(...inner.spies);
+            }
+            else
+                unresolved.push("...");
+            continue;
+        }
+        const name = propertyName(property);
+        if (name === undefined) {
+            unresolved.push("<computed>");
+            continue;
+        }
+        keys.add(name);
+        if (ts.isPropertyAssignment(property)) {
+            const inner = evaluate(checker, property.initializer, depth + 1);
+            if (inner.value !== undefined)
+                value[name] = inner.value;
+            mark(name, inner);
+        }
+        else if (ts.isShorthandPropertyAssignment(property)) {
+            const target = declarationOf(resolveSymbol(checker, checker.getShorthandAssignmentValueSymbol(property)));
+            const inner = target && ts.isVariableDeclaration(target) && target.initializer
+                ? evaluate(checker, target.initializer, depth + 1)
+                : dynamic();
+            if (inner.value !== undefined)
+                value[name] = inner.value;
+            mark(name, inner);
+        }
+        else {
+            // Methods and accessors: present, but not statically evaluable.
+            unresolved.push(name);
+        }
+    }
+    return { value, unresolved, spies, keys: [...keys].sort() };
+}
+function propertyName(property) {
+    const name = property.name;
+    if (!name)
+        return undefined;
+    if (ts.isIdentifier(name) || ts.isStringLiteralLike(name) || ts.isNumericLiteral(name))
+        return name.text;
+    return undefined;
+}
+function resolved(value) {
+    return { value, unresolved: [], spies: [] };
+}
+function dynamic() {
+    return { unresolved: [""], spies: [] };
+}
+//# sourceMappingURL=static-eval.js.map

package/dist/compiler-core/ts/tsconfig-paths.js

@@ -0,0 +1,60 @@
+import { posix } from "node:path";
+import ts from "typescript";
+/** True for files that tsconfigPaths reads (`tsconfig.json`, `tsconfig.app.json`, ...). */
+export const TSCONFIG_FILE = /(?:^|\/)tsconfig[^/]*\.json$/;
+/**
+ * `compilerOptions.paths` for a package, as project-relative targets, so import aliases such as
+ * `@/Primitive` resolve in the analysis program. Follows relative `extends` and `references` (a common
+ * layout is a solution-style `tsconfig.json` whose real options live in `tsconfig.app.json`). Later
+ * configs override earlier ones; targets are resolved against `baseUrl` when set, else the config's
+ * directory. Nothing is executed and `node_modules` configs (`extends` from packages) are not read.
+ */
+export function tsconfigPaths(files, packageDir) {
+    const out = {};
+    const seen = new Set();
+    const visit = (file, depth) => {
+        if (depth > 6 || seen.has(file))
+            return;
+        seen.add(file);
+        const text = files.get(file);
+        if (text === undefined)
+            return;
+        const config = ts.parseConfigFileTextToJson(file, text).config;
+        if (!isRecord(config))
+            return;
+        const here = posix.dirname(file);
+        for (const parent of toArray(config.extends)) {
+            if (typeof parent === "string" && parent.startsWith("."))
+                visit(withJson(files, posix.normalize(posix.join(here, parent))), depth + 1);
+        }
+        const options = config.compilerOptions;
+        if (isRecord(options) && isRecord(options.paths)) {
+            const base = typeof options.baseUrl === "string" ? posix.normalize(posix.join(here, options.baseUrl)) : here;
+            for (const [pattern, targets] of Object.entries(options.paths)) {
+                const resolved = toArray(targets).flatMap((t) => typeof t === "string" ? [posix.normalize(posix.join(base, t))] : []);
+                if (resolved.length > 0)
+                    out[pattern] = resolved;
+            }
+        }
+        for (const reference of toArray(config.references)) {
+            if (isRecord(reference) && typeof reference.path === "string") {
+                visit(configFile(files, posix.normalize(posix.join(here, reference.path))), depth + 1);
+            }
+        }
+    };
+    visit(posix.join(packageDir, "tsconfig.json"), 0);
+    return out;
+}
+function withJson(files, path) {
+    return files.has(path) ? path : `${path}.json`;
+}
+function configFile(files, path) {
+    return files.has(path) ? path : posix.join(path, "tsconfig.json");
+}
+function toArray(value) {
+    return Array.isArray(value) ? value : value === undefined ? [] : [value];
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=tsconfig-paths.js.map

package/dist/compiler-core/walk.js

@@ -0,0 +1,46 @@
+export const DEFAULT_IGNORED_DIRS = [
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    "out",
+    "coverage",
+    ".next",
+    ".nuxt",
+    ".turbo",
+    ".cache",
+    ".angular",
+    ".svelte-kit",
+    ".output",
+    ".pnpm-store",
+    "storybook-static"
+];
+/**
+ * Deterministic walk: sorted traversal, ignored directories skipped, symlinks never followed.
+ * Stops at `maxFiles` and reports truncation rather than silently returning a partial list.
+ */
+export async function walk(fs, options) {
+    const files = [];
+    let truncated = false;
+    const visit = async (dir) => {
+        for (const entry of await fs.readDir(dir)) {
+            if (truncated)
+                return;
+            const child = dir === "." ? entry.name : `${dir}/${entry.name}`;
+            if (entry.kind === "dir") {
+                if (!options.ignoreDirs.has(entry.name))
+                    await visit(child);
+            }
+            else if (entry.kind === "file") {
+                if (files.length >= options.maxFiles) {
+                    truncated = true;
+                    return;
+                }
+                files.push(child);
+            }
+        }
+    };
+    await visit(options.start ?? ".");
+    return { files: files.sort(), truncated };
+}
+//# sourceMappingURL=walk.js.map

package/dist/compiler-ir/index.js

@@ -0,0 +1,4 @@
+export { IR_VERSION, irDocumentSchema, irEntitySchema, irFactSchema } from "./ir.js";
+export { irJsonSchemas } from "./json-schema.js";
+export { canonicalizeIrDocument, computeIrContentHash, matchesCapability, parseIrDocument, serializeIrDocument, verifyIrDocument } from "./validate.js";
+//# sourceMappingURL=index.js.map