@invariant-ui/cli 0.0.0-stage → 0.1.0

package/dist/compiler-core/discovery/packages.js

@@ -0,0 +1,148 @@
+import { globToRegExp, matchesAny } from "../glob.js";
+import { cmp, hashText, lineOfJsonMember, posix, readBounded } from "./support.js";
+const DEP_KINDS = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
+export async function discoverPackages(env) {
+    const workspaces = await discoverWorkspaces(env);
+    const manifestPaths = env.files.filter((f) => posix.basename(f) === "package.json");
+    const positive = workspaces.patterns
+        .filter((p) => !p.startsWith("!"))
+        .map((p) => globToRegExp(trimSlashes(p)));
+    const negative = workspaces.patterns
+        .filter((p) => p.startsWith("!"))
+        .map((p) => globToRegExp(trimSlashes(p.slice(1))));
+    const selected = manifestPaths.filter((manifest) => {
+        const dir = posix.dirname(manifest);
+        if (dir === ".")
+            return true;
+        if (env.declarationRoots?.has(dir))
+            return true;
+        // An ng-packagr library root (a package.json next to an ng-package.json) is a package even when the
+        // repository declares no workspaces: its source lives in a subfolder such as `src/`.
+        if (env.fileSet.has(posix.join(dir, "ng-package.json")))
+            return true;
+        if (workspaces.kind === "none")
+            return false;
+        return matchesAny(dir, positive) && !matchesAny(dir, negative);
+    });
+    // Without workspace config and without a root manifest, fall back to every manifest found.
+    const chosen = selected.length === 0 && workspaces.kind === "none" ? manifestPaths : selected;
+    const packages = [];
+    for (const manifestPath of chosen) {
+        const text = await readBounded(env, manifestPath);
+        if (text === undefined)
+            continue;
+        let manifest;
+        try {
+            const parsed = JSON.parse(text);
+            if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+                throw new Error("not an object");
+            manifest = parsed;
+        }
+        catch (error) {
+            env.diagnostics.error("discovery.invalid-manifest", `Invalid ${manifestPath}: ${error.message}`, {
+                location: { path: manifestPath }
+            });
+            continue;
+        }
+        packages.push({ info: toPackageInfo(manifestPath, manifest, text), manifest, manifestText: text });
+    }
+    if (packages.length === 0) {
+        env.diagnostics.warning("discovery.no-package", "No package.json was found; package, framework and entry-point discovery are empty");
+    }
+    packages.sort((a, b) => cmp(a.info.dir, b.info.dir));
+    // Two packages can share a name (a repository root and the library it contains): ids stay unique.
+    const seenIds = new Set();
+    for (const raw of packages) {
+        if (seenIds.has(raw.info.id))
+            raw.info.id = `package:${raw.info.name ?? ""}@${raw.info.dir}`;
+        seenIds.add(raw.info.id);
+    }
+    return { packages, workspaces };
+}
+async function discoverWorkspaces(env) {
+    if (env.fileSet.has("pnpm-workspace.yaml")) {
+        const text = await readBounded(env, "pnpm-workspace.yaml");
+        if (text !== undefined)
+            return {
+                kind: "pnpm-workspace",
+                patterns: parsePnpmWorkspacePackages(text),
+                source: "pnpm-workspace.yaml"
+            };
+    }
+    if (env.fileSet.has("package.json")) {
+        const text = await readBounded(env, "package.json");
+        try {
+            const manifest = JSON.parse(text ?? "{}");
+            const raw = manifest.workspaces;
+            const list = Array.isArray(raw)
+                ? raw
+                : isRecord(raw) && Array.isArray(raw.packages)
+                    ? raw.packages
+                    : undefined;
+            if (list)
+                return {
+                    kind: "package-json",
+                    patterns: list.filter((p) => typeof p === "string"),
+                    source: "package.json"
+                };
+        }
+        catch {
+            // Reported when the manifest itself is parsed.
+        }
+    }
+    return { kind: "none", patterns: [] };
+}
+/** Reads the `packages:` list from pnpm-workspace.yaml without a YAML dependency (block lists only). */
+export function parsePnpmWorkspacePackages(text) {
+    const patterns = [];
+    let inPackages = false;
+    for (const raw of text.split("\n")) {
+        const line = raw.replace(/\s+#.*$/, "").replace(/\r$/, "");
+        if (/^packages\s*:/.test(line)) {
+            inPackages = true;
+            continue;
+        }
+        if (inPackages) {
+            const item = /^\s*-\s*(.+?)\s*$/.exec(line);
+            if (item)
+                patterns.push(item[1].replace(/^["']|["']$/g, ""));
+            else if (/^\S/.test(line))
+                inPackages = false;
+        }
+    }
+    return patterns;
+}
+function toPackageInfo(manifestPath, manifest, text) {
+    const dir = posix.dirname(manifestPath);
+    const name = typeof manifest.name === "string" && manifest.name ? manifest.name : undefined;
+    const version = typeof manifest.version === "string" && manifest.version ? manifest.version : undefined;
+    const dependencies = DEP_KINDS.flatMap((kind) => {
+        const group = manifest[kind];
+        if (!isRecord(group))
+            return [];
+        return Object.entries(group).map(([depName, range]) => ({ name: depName, range: String(range), kind }));
+    }).sort((a, b) => cmp(a.name, b.name) || cmp(a.kind, b.kind));
+    return {
+        id: `package:${name ?? dir}`,
+        ...(name ? { name } : {}),
+        ...(version ? { version } : {}),
+        dir,
+        private: manifest.private === true,
+        manifest: { path: manifestPath, contentHash: hashText(text) },
+        dependencies,
+        scripts: isRecord(manifest.scripts) ? Object.keys(manifest.scripts).sort() : [],
+        frameworks: [],
+        buildTools: [],
+        entryPoints: []
+    };
+}
+export function dependencyLine(raw, group, name) {
+    return lineOfJsonMember(raw.manifestText, group, name);
+}
+function trimSlashes(p) {
+    return p.replace(/^\.\//, "").replace(/\/+$/, "");
+}
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=packages.js.map

package/dist/compiler-core/discovery/schema.js

@@ -0,0 +1,144 @@
+import { relativePathSchema } from "../../contract/index.js";
+import { diagnosticSchema } from "../../shared/index.js";
+import { z } from "zod";
+export const DISCOVERY_VERSION = "1.0.0";
+const hash = z.string().regex(/^[0-9a-f]{64}$/);
+const fileRef = z.strictObject({ path: relativePathSchema, contentHash: hash });
+const dependencyKind = z.enum(["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]);
+export const exportInfoSchema = z.strictObject({
+    name: z.string().min(1),
+    kind: z.enum(["value", "type", "namespace", "default", "unknown"]),
+    /** True when the export has no runtime value: `export type`, interfaces and type aliases. */
+    typeOnly: z.boolean(),
+    file: relativePathSchema,
+    line: z.number().int().positive(),
+    reexportOf: z.strictObject({ module: z.string().min(1), external: z.boolean() }).optional()
+});
+export const entryPointSchema = z.strictObject({
+    subpath: z.string().min(1),
+    condition: z.string().min(1),
+    target: z.string().min(1),
+    resolution: z.enum(["declared", "mapped", "conventional", "unresolved"]),
+    file: relativePathSchema.optional(),
+    exports: z.array(exportInfoSchema),
+    /** False when exports could not be fully enumerated (external `export *`, parse failure, or limits). */
+    exportsComplete: z.boolean(),
+    parsedFiles: z.array(fileRef)
+});
+export const frameworkUseSchema = z.strictObject({
+    name: z.enum(["react", "angular", "vue"]),
+    package: z.string().min(1),
+    dependencyKind,
+    declaredRange: z.string().min(1),
+    installedVersion: z.string().min(1).optional(),
+    line: z.number().int().positive().optional()
+});
+export const buildToolSchema = z.strictObject({
+    name: z.string().min(1),
+    evidence: z.array(z.strictObject({ type: z.enum(["dependency", "config-file"]), ref: z.string().min(1) }))
+});
+export const packageSchema = z.strictObject({
+    id: z.string().min(1),
+    name: z.string().min(1).optional(),
+    version: z.string().min(1).optional(),
+    dir: relativePathSchema,
+    private: z.boolean(),
+    manifest: fileRef,
+    dependencies: z.array(z.strictObject({ name: z.string().min(1), range: z.string(), kind: dependencyKind })),
+    scripts: z.array(z.string()),
+    frameworks: z.array(frameworkUseSchema),
+    buildTools: z.array(buildToolSchema),
+    entryPoints: z.array(entryPointSchema)
+});
+export const packageManagerSchema = z.strictObject({
+    name: z.enum(["npm", "pnpm", "yarn", "bun", "unknown"]),
+    version: z.string().min(1).optional(),
+    evidence: z.array(z.string().min(1))
+});
+export const workspacesSchema = z.strictObject({
+    kind: z.enum(["pnpm-workspace", "package-json", "none"]),
+    patterns: z.array(z.string()),
+    source: relativePathSchema.optional()
+});
+export const storybookSchema = z.strictObject({
+    id: z.string().min(1),
+    configPath: relativePathSchema,
+    configHash: hash,
+    directory: relativePathSchema,
+    package: z.string().min(1).optional(),
+    framework: z.string().min(1).optional(),
+    addons: z.array(z.string()),
+    stories: z.array(z.strictObject({
+        pattern: z.string().optional(),
+        directory: z.string().optional(),
+        files: z.string().optional(),
+        titlePrefix: z.string().optional()
+    })),
+    staticDirs: z.array(z.string()),
+    /** Config properties whose value could not be determined statically. */
+    dynamicProperties: z.array(z.string()),
+    version: z
+        .strictObject({ package: z.string(), declaredRange: z.string(), installedVersion: z.string().optional() })
+        .optional(),
+    builtOutput: z.strictObject({ path: relativePathSchema, hasIndexJson: z.boolean() }).optional(),
+    storyFiles: z.array(relativePathSchema),
+    storyFileCount: z.number().int().nonnegative(),
+    storyFilesTruncated: z.boolean()
+});
+export const cssVariableSchema = z.strictObject({
+    name: z.string().min(1),
+    scope: z.string(),
+    line: z.number().int().positive(),
+    value: z.string().max(200),
+    aliasOf: z.string().optional()
+});
+export const tokenFileSchema = z.strictObject({
+    path: relativePathSchema,
+    kind: z.enum(["css-custom-properties", "json-tokens", "style-dictionary-config", "tailwind-config"]),
+    /** Shape heuristic only: it says what the file looks like, not that it conforms to a spec. */
+    format: z.enum(["dtcg-like", "style-dictionary-like", "unknown"]).optional(),
+    contentHash: hash,
+    package: z.string().min(1).optional(),
+    cssVariables: z.array(cssVariableSchema).optional(),
+    cssVariablesTruncated: z.boolean().optional(),
+    tokenCount: z.number().int().nonnegative().optional()
+});
+export const docFileSchema = z.strictObject({
+    path: relativePathSchema,
+    kind: z.enum(["readme", "changelog", "mdx", "markdown"]),
+    title: z.string().optional(),
+    headings: z.array(z.strictObject({
+        level: z.number().int().min(1).max(6),
+        text: z.string(),
+        line: z.number().int().positive()
+    })),
+    lineCount: z.number().int().nonnegative(),
+    contentHash: hash,
+    package: z.string().min(1).optional()
+});
+export const graphSchema = z.strictObject({
+    nodes: z.array(z.strictObject({
+        id: z.string().min(1),
+        type: z.enum(["package", "framework", "build-tool", "storybook-config", "token-file", "doc-file"]),
+        label: z.string().min(1)
+    })),
+    edges: z.array(z.strictObject({
+        from: z.string().min(1),
+        to: z.string().min(1),
+        type: z.enum(["depends-on", "uses-framework", "built-with", "contains", "configured-by", "documents"]),
+        weight: z.number().int().positive().optional()
+    }))
+});
+export const projectDiscoverySchema = z.strictObject({
+    discoveryVersion: z.literal(DISCOVERY_VERSION),
+    packageManager: packageManagerSchema,
+    workspaces: workspacesSchema,
+    packages: z.array(packageSchema),
+    storybooks: z.array(storybookSchema),
+    tokenFiles: z.array(tokenFileSchema),
+    docFiles: z.array(docFileSchema),
+    graph: graphSchema,
+    stats: z.strictObject({ filesScanned: z.number().int().nonnegative(), truncated: z.boolean() }),
+    diagnostics: z.array(diagnosticSchema)
+});
+//# sourceMappingURL=schema.js.map

package/dist/compiler-core/discovery/storybook.js

@@ -0,0 +1,232 @@
+import ts from "typescript";
+import { globToRegExp, matchesAny } from "../glob.js";
+import { isRecord } from "./packages.js";
+import { cmp, hashText, owningPackage, posix, readBounded } from "./support.js";
+const CONFIG_NAME = /^main\.[cm]?[jt]s$/;
+/** Storybook configs found under any `.storybook` directory, parsed statically (the config is never executed). */
+export async function discoverStorybooks(env, packages) {
+    const configs = env.files.filter((f) => posix.basename(posix.dirname(f)) === ".storybook" && CONFIG_NAME.test(posix.basename(f)));
+    const out = [];
+    for (const configPath of configs) {
+        const text = await readBounded(env, configPath);
+        if (text === undefined)
+            continue;
+        const configDir = posix.dirname(configPath);
+        const directory = posix.dirname(configDir);
+        const evaluated = evaluateConfig(configPath, text);
+        if (!evaluated) {
+            env.diagnostics.warning("discovery.storybook-unparsed", `No static config object found in ${configPath}`, { location: { path: configPath } });
+        }
+        const config = evaluated ?? { values: {}, dynamic: ["<config>"] };
+        for (const property of config.dynamic) {
+            env.diagnostics.warning("discovery.storybook-dynamic-config", `Storybook '${property}' in ${configPath} is not statically determinable`, {
+                location: { path: configPath }
+            });
+        }
+        const stories = toStories(config.values.stories);
+        const pkg = owningPackage(packages.map((p) => ({ dir: p.info.dir, raw: p })), configPath)?.raw;
+        const { files, total } = expandStories(env, configDir, stories);
+        out.push({
+            id: `storybook:${directory}`,
+            configPath,
+            configHash: hashText(text),
+            directory,
+            ...(pkg ? { package: pkg.info.id } : {}),
+            ...frameworkOf(config.values.framework),
+            addons: toStrings(config.values.addons).sort(),
+            stories,
+            staticDirs: toStrings(config.values.staticDirs).sort(),
+            dynamicProperties: [...config.dynamic].sort(),
+            ...(pkg ? await storybookVersion(env, pkg) : {}),
+            ...(await builtOutput(env, directory)),
+            storyFiles: files.slice(0, env.limits.maxStoryFiles),
+            storyFileCount: total,
+            storyFilesTruncated: total > env.limits.maxStoryFiles
+        });
+    }
+    return out.sort((a, b) => cmp(a.configPath, b.configPath));
+}
+function evaluateConfig(file, text) {
+    const sf = ts.createSourceFile(file, text, ts.ScriptTarget.ES2022, true, /\.[cm]?js$/.test(file) ? ts.ScriptKind.JS : ts.ScriptKind.TS);
+    const bindings = new Map();
+    let exported;
+    for (const statement of sf.statements) {
+        if (ts.isVariableStatement(statement)) {
+            for (const d of statement.declarationList.declarations)
+                if (ts.isIdentifier(d.name) && d.initializer)
+                    bindings.set(d.name.text, d.initializer);
+        }
+        else if (ts.isExportAssignment(statement) && !statement.isExportEquals)
+            exported = statement.expression;
+        else if (ts.isExpressionStatement(statement) &&
+            ts.isBinaryExpression(statement.expression) &&
+            statement.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+            statement.expression.left.getText(sf) === "module.exports") {
+            exported = statement.expression.right;
+        }
+    }
+    const object = unwrap(exported ?? bindings.get("config"), bindings);
+    if (!object || !ts.isObjectLiteralExpression(object))
+        return undefined;
+    const values = {};
+    const dynamic = [];
+    for (const property of object.properties) {
+        if (!ts.isPropertyAssignment(property) ||
+            !(ts.isIdentifier(property.name) || ts.isStringLiteral(property.name))) {
+            dynamic.push(property.name?.getText(sf) ?? "<spread>");
+            continue;
+        }
+        const name = property.name.text;
+        const result = evaluate(property.initializer, bindings);
+        values[name] = result.value;
+        if (result.dynamic)
+            dynamic.push(name);
+    }
+    return { values, dynamic };
+}
+function unwrap(node, bindings, depth = 0) {
+    if (!node || depth > 8)
+        return undefined;
+    if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isSatisfiesExpression(node))
+        return unwrap(node.expression, bindings, depth + 1);
+    if (ts.isIdentifier(node))
+        return unwrap(bindings.get(node.text), bindings, depth + 1);
+    // defineMain({...}) and similar single-argument wrappers
+    if (ts.isCallExpression(node) && node.arguments.length === 1)
+        return unwrap(node.arguments[0], bindings, depth + 1);
+    return node;
+}
+function evaluate(node, bindings, depth = 0) {
+    if (depth > 8)
+        return { value: undefined, dynamic: true };
+    if (ts.isStringLiteralLike(node))
+        return { value: node.text, dynamic: false };
+    if (ts.isNumericLiteral(node))
+        return { value: Number(node.text), dynamic: false };
+    if (node.kind === ts.SyntaxKind.TrueKeyword)
+        return { value: true, dynamic: false };
+    if (node.kind === ts.SyntaxKind.FalseKeyword)
+        return { value: false, dynamic: false };
+    if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isSatisfiesExpression(node))
+        return evaluate(node.expression, bindings, depth + 1);
+    if (ts.isIdentifier(node) && bindings.has(node.text))
+        return evaluate(bindings.get(node.text), bindings, depth + 1);
+    // getAbsolutePath("@storybook/addon-docs") is the documented monorepo idiom; its argument is the package name.
+    if (ts.isCallExpression(node) &&
+        ts.isIdentifier(node.expression) &&
+        node.expression.text === "getAbsolutePath") {
+        const arg = node.arguments[0];
+        if (arg && ts.isStringLiteralLike(arg))
+            return { value: arg.text, dynamic: false };
+    }
+    if (ts.isArrayLiteralExpression(node)) {
+        let dynamic = false;
+        const value = node.elements.map((element) => {
+            const inner = evaluate(element, bindings, depth + 1);
+            dynamic ||= inner.dynamic;
+            return inner.value;
+        });
+        return { value: value.filter((v) => v !== undefined), dynamic };
+    }
+    if (ts.isObjectLiteralExpression(node)) {
+        let dynamic = false;
+        const value = {};
+        for (const property of node.properties) {
+            if (ts.isPropertyAssignment(property) &&
+                (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name))) {
+                const inner = evaluate(property.initializer, bindings, depth + 1);
+                dynamic ||= inner.dynamic;
+                if (inner.value !== undefined)
+                    value[property.name.text] = inner.value;
+            }
+            else
+                dynamic = true;
+        }
+        return { value, dynamic };
+    }
+    return { value: undefined, dynamic: true };
+}
+function toStrings(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => typeof item === "string" ? [item] : isRecord(item) && typeof item.name === "string" ? [item.name] : []);
+}
+function toStories(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => {
+        if (typeof item === "string")
+            return [{ pattern: item }];
+        if (isRecord(item)) {
+            return [
+                {
+                    ...(typeof item.directory === "string" ? { directory: item.directory } : {}),
+                    ...(typeof item.files === "string" ? { files: item.files } : {}),
+                    ...(typeof item.titlePrefix === "string" ? { titlePrefix: item.titlePrefix } : {})
+                }
+            ];
+        }
+        return [];
+    });
+}
+function frameworkOf(value) {
+    if (typeof value === "string")
+        return { framework: value };
+    if (isRecord(value) && typeof value.name === "string")
+        return { framework: value.name };
+    return {};
+}
+function expandStories(env, configDir, stories) {
+    const matchers = [];
+    for (const story of stories) {
+        const pattern = story.pattern ??
+            (story.directory
+                ? `${story.directory.replace(/\/$/, "")}/${story.files ?? "**/*.stories.@(js|jsx|mjs|ts|tsx)"}`
+                : undefined);
+        if (!pattern)
+            continue;
+        const resolved = posix.normalize(posix.join(configDir, pattern));
+        if (resolved.startsWith(".."))
+            continue;
+        matchers.push(globToRegExp(resolved));
+    }
+    const files = env.files.filter((f) => matchesAny(f, matchers));
+    return { files, total: files.length };
+}
+async function storybookVersion(env, pkg) {
+    const dep = pkg.info.dependencies.find((d) => d.name === "storybook") ??
+        pkg.info.dependencies.find((d) => /^@storybook\/(react|vue3|angular|nextjs|web-components)(-|$)/.test(d.name));
+    if (!dep)
+        return {};
+    let installed;
+    for (let dir = pkg.info.dir;; dir = posix.dirname(dir)) {
+        const candidate = posix.join(dir, "node_modules", dep.name, "package.json");
+        if (await env.fs.exists(candidate)) {
+            try {
+                const version = JSON.parse(await env.fs.readFile(candidate)).version;
+                if (typeof version === "string")
+                    installed = version;
+            }
+            catch {
+                // Unreadable installed manifest: leave installedVersion unknown.
+            }
+            break;
+        }
+        if (dir === ".")
+            break;
+    }
+    return {
+        version: {
+            package: dep.name,
+            declaredRange: dep.range,
+            ...(installed ? { installedVersion: installed } : {})
+        }
+    };
+}
+async function builtOutput(env, directory) {
+    const dir = posix.join(directory, "storybook-static");
+    if (!(await env.fs.exists(dir)))
+        return {};
+    return { builtOutput: { path: dir, hasIndexJson: await env.fs.exists(posix.join(dir, "index.json")) } };
+}
+//# sourceMappingURL=storybook.js.map

package/dist/compiler-core/discovery/support.js

@@ -0,0 +1,82 @@
+import path from "node:path";
+import { sha256Hex } from "../../shared/index.js";
+export const DEFAULT_LIMITS = {
+    maxFiles: 50_000,
+    maxFileBytes: 1_000_000,
+    maxParsedFilesPerEntry: 5000,
+    maxCssVariablesPerFile: 5000,
+    maxStoryFiles: 1000,
+    maxHeadings: 100
+};
+export const posix = path.posix;
+export function hashText(text) {
+    return sha256Hex(text);
+}
+export function cmp(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+const SOURCE_FILE = /\.(?:[cm]?[jt]sx?|vue|svelte|s?css|less)$/;
+/** Reads a file; returns undefined (with a diagnostic) when unreadable or over the size limit. */
+export async function readBounded(env, file) {
+    try {
+        const text = await env.fs.readFile(file);
+        if (text.length > env.limits.maxFileBytes) {
+            // Data files (web-types.json, source maps) are not read for components, so skipping them is not a finding.
+            if (!SOURCE_FILE.test(file))
+                return undefined;
+            // An installed package ships prebuilt bundles (`dist/vuetify.js`, aggregate `.d.ts`) far over the limit; the same
+            // components are in its smaller per-component files, so skipping them is information, not a warning.
+            const installed = [...(env.declarationRoots ?? [])].some((root) => file.startsWith(`${root}/`));
+            env.diagnostics[installed ? "info" : "warning"]("discovery.file-too-large", `Skipped ${file}: larger than ${env.limits.maxFileBytes} bytes`, {
+                location: { path: file }
+            });
+            return undefined;
+        }
+        return text;
+    }
+    catch (error) {
+        env.diagnostics.warning("discovery.file-unreadable", `Could not read ${file}: ${error.message}`, { location: { path: file } });
+        return undefined;
+    }
+}
+/** 1-based line of the first line at or after `fromLine` containing the quoted JSON key. */
+export function lineOfJsonKey(text, key, fromLine = 1) {
+    const lines = text.split("\n");
+    const needle = `"${key}"`;
+    for (let i = fromLine - 1; i < lines.length; i++) {
+        if (lines[i].includes(needle))
+            return i + 1;
+    }
+    return undefined;
+}
+/** Line of `key` inside the top-level `group` object, e.g. a dependency inside "dependencies". */
+export function lineOfJsonMember(text, group, key) {
+    const start = lineOfJsonKey(text, group);
+    return start === undefined ? undefined : lineOfJsonKey(text, key, start);
+}
+/** Directory of `file` is inside (or equal to) `dir`. */
+export function isInside(dir, file) {
+    return dir === "." || file === dir || file.startsWith(`${dir}/`);
+}
+/** Owning package: the package whose directory is the longest prefix of `file`. */
+export function owningPackage(packages, file) {
+    let best;
+    for (const pkg of packages) {
+        if (isInside(pkg.dir, file) && (!best || pkg.dir.length > best.dir.length))
+            best = pkg;
+    }
+    return best;
+}
+/**
+ * Case-exact existence. Walked files are authoritative (the real filesystem may be case-insensitive,
+ * so `exists("Button.ts")` can be true when only `button.ts` is present). Only paths inside ignored
+ * directories such as `dist/`, which the walk skips on purpose, fall back to the filesystem.
+ */
+export async function fileExists(env, file) {
+    if (env.fileSet.has(file))
+        return true;
+    if (!file.split("/").some((segment) => env.ignoreDirs.has(segment)))
+        return false;
+    return env.fs.exists(file);
+}
+//# sourceMappingURL=support.js.map