@invariant-ui/cli 0.0.0-stage → 0.2.0

package/dist/compiler-tokens/json-lines.js

@@ -0,0 +1,106 @@
+/** Minimal JSON parser that keeps key line numbers, for evidence locations. Throws on invalid JSON. */
+export function parseJsonWithLines(text) {
+    let i = 0;
+    let line = 1;
+    const fail = (message) => {
+        throw new SyntaxError(`${message} at line ${line}`);
+    };
+    const skip = () => {
+        while (i < text.length) {
+            const c = text[i];
+            if (c === "\n")
+                line++;
+            else if (c !== " " && c !== "\t" && c !== "\r")
+                return;
+            i++;
+        }
+    };
+    const string = () => {
+        const start = i;
+        i++;
+        while (i < text.length && text[i] !== '"')
+            i += text[i] === "\\" ? 2 : 1;
+        if (i >= text.length)
+            fail("Unterminated string");
+        i++;
+        return JSON.parse(text.slice(start, i));
+    };
+    const value = () => {
+        skip();
+        const startLine = line;
+        const c = text[i];
+        if (c === "{") {
+            i++;
+            const members = [];
+            skip();
+            if (text[i] === "}") {
+                i++;
+                return { type: "object", members, line: startLine };
+            }
+            for (;;) {
+                skip();
+                if (text[i] !== '"')
+                    fail("Expected a string key");
+                const keyLine = line;
+                const key = string();
+                skip();
+                if (text[i] !== ":")
+                    fail("Expected ':'");
+                i++;
+                members.push({ key, line: keyLine, value: value() });
+                skip();
+                if (text[i] === ",") {
+                    i++;
+                    continue;
+                }
+                if (text[i] === "}") {
+                    i++;
+                    return { type: "object", members, line: startLine };
+                }
+                fail("Expected ',' or '}'");
+            }
+        }
+        if (c === "[") {
+            i++;
+            const items = [];
+            skip();
+            if (text[i] === "]") {
+                i++;
+                return { type: "array", items, line: startLine };
+            }
+            for (;;) {
+                items.push(value());
+                skip();
+                if (text[i] === ",") {
+                    i++;
+                    continue;
+                }
+                if (text[i] === "]") {
+                    i++;
+                    return { type: "array", items, line: startLine };
+                }
+                fail("Expected ',' or ']'");
+            }
+        }
+        if (c === '"')
+            return { type: "scalar", value: string(), line: startLine };
+        const literal = /^(?:true|false|null|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)/.exec(text.slice(i));
+        if (!literal)
+            return fail("Unexpected token");
+        i += literal[0].length;
+        return { type: "scalar", value: JSON.parse(literal[0]), line: startLine };
+    };
+    const root = value();
+    skip();
+    if (i < text.length)
+        fail("Unexpected trailing content");
+    return root;
+}
+export function toJson(node) {
+    if (node.type === "scalar")
+        return node.value;
+    if (node.type === "array")
+        return node.items.map(toJson);
+    return Object.fromEntries(node.members.map((m) => [m.key, toJson(m.value)]));
+}
+//# sourceMappingURL=json-lines.js.map

package/dist/compiler-tokens/json-tokens.js

@@ -0,0 +1,52 @@
+import { toJson } from "./json-lines.js";
+const REFERENCE = /^\{([^{}]+)\}$/;
+/**
+ * Walks a token tree. A node is a token when it has `$value` (W3C Design Tokens shape; `$type` is
+ * inherited from enclosing groups) or a scalar/composite `value` (Style Dictionary shape).
+ */
+export function extractJsonTokens(root) {
+    const out = [];
+    const visit = (members, path, inheritedType) => {
+        const find = (key) => members.find((m) => m.key === key);
+        const groupType = scalarString(find("$type")?.value) ?? inheritedType;
+        for (const member of members) {
+            if (member.key.startsWith("$") || member.value.type !== "object")
+                continue;
+            const child = member.value.members;
+            const childPath = [...path, member.key];
+            const dtcgValue = child.find((m) => m.key === "$value");
+            const sdValue = dtcgValue ? undefined : child.find((m) => m.key === "value");
+            const valueMember = dtcgValue ?? sdValue;
+            if (!valueMember) {
+                visit(child, childPath, groupType);
+                continue;
+            }
+            const raw = toJson(valueMember.value);
+            const alias = typeof raw === "string" ? REFERENCE.exec(raw.trim())?.[1] : undefined;
+            const type = dtcgValue
+                ? (scalarString(child.find((m) => m.key === "$type")?.value) ?? groupType)
+                : scalarString(child.find((m) => m.key === "type")?.value);
+            const description = scalarString(child.find((m) => m.key === (dtcgValue ? "$description" : "comment"))?.value) ??
+                scalarString(child.find((m) => m.key === "description")?.value);
+            const deprecated = child.find((m) => m.key === "$deprecated")?.value;
+            out.push({
+                name: childPath.join("."),
+                line: member.line,
+                format: dtcgValue ? "dtcg" : "style-dictionary",
+                ...(alias ? { aliasOf: alias } : { value: raw }),
+                ...(type ? { type } : {}),
+                ...(description ? { description } : {}),
+                ...(deprecated?.type === "scalar" && deprecated.value !== false
+                    ? { deprecated: typeof deprecated.value === "string" ? { reason: deprecated.value } : {} }
+                    : {})
+            });
+        }
+    };
+    if (root.type === "object")
+        visit(root.members, [], undefined);
+    return out;
+}
+function scalarString(node) {
+    return node?.type === "scalar" && typeof node.value === "string" ? node.value : undefined;
+}
+//# sourceMappingURL=json-tokens.js.map

package/dist/compiler-vue/adapter.js

@@ -0,0 +1,107 @@
+import { DEFAULT_IGNORED_DIRS, hashText, IrBuilder, walk } from "../compiler-core/index.js";
+import { hashJson } from "../shared/index.js";
+import { analyzePackage } from "./analyze.js";
+import { CAPABILITIES, emitComponent } from "./emit.js";
+export const ADAPTER_ID = "vue";
+export const ADAPTER_VERSION = "0.1.0";
+const SOURCE_FILE = /\.(?:[cm]?[jt]sx?|vue)$|(?:^|\/)tsconfig[^/]*\.json$/;
+const MAX_FILE_BYTES = 1_000_000;
+/**
+ * Vue adapter. For every workspace package that declares Vue it reads single-file components with the
+ * official SFC parser and analyzes their script with the TypeScript API (compile-time macros, options
+ * objects, `defineComponent`), plus the template for slots, accessibility and composition. Nothing is
+ * executed and `node_modules` is not read.
+ */
+export const vueAdapter = {
+    id: ADAPTER_ID,
+    version: ADAPTER_VERSION,
+    type: "vue",
+    async discover({ fs, project }) {
+        const sources = [];
+        const used = new Set();
+        for (const pkg of project.packages.filter((p) => p.frameworks.some((f) => f.name === "vue"))) {
+            const others = project.packages.filter((p) => p.id !== pkg.id && p.dir !== "." && (pkg.dir === "." || p.dir.startsWith(`${pkg.dir}/`)));
+            const { files, hashes } = await readPackageFiles(fs, pkg, others);
+            const slug = (pkg.name ?? pkg.dir)
+                .toLowerCase()
+                .replace(/[^a-z0-9._-]+/g, "-")
+                .replace(/^[^a-z0-9]+|[-.]+$/g, "") || "root";
+            let id = `vue-${slug}`;
+            for (let n = 2; used.has(id); n++)
+                id = `vue-${slug}-${n}`;
+            used.add(id);
+            sources.push({
+                id,
+                type: "vue",
+                location: pkg.dir,
+                config: { packageId: pkg.id, files: [...files.keys()] },
+                ...(pkg.version ? { version: { kind: "package-version", value: pkg.version } } : {}),
+                inputHash: hashJson(hashes)
+            });
+        }
+        return { sources, diagnostics: [] };
+    },
+    async extract({ fs, project, source, clock }, config) {
+        const pkg = project.packages.find((p) => p.id === config.packageId);
+        if (!pkg)
+            throw new Error(`Package ${config.packageId} is not in the project discovery`);
+        const files = new Map();
+        for (const path of config.files)
+            files.set(path, await fs.readFile(path));
+        const analysis = analyzePackage({ packageDir: pkg.dir, entryPoints: pkg.entryPoints, files });
+        const builder = new IrBuilder({
+            source: {
+                id: source.id,
+                type: source.type,
+                location: source.location,
+                ...(source.version ? { version: source.version } : {}),
+                inputHash: source.inputHash,
+                adapter: { name: ADAPTER_ID, version: ADAPTER_VERSION }
+            },
+            extractor: { name: "vue-sfc", version: ADAPTER_VERSION },
+            capabilities: CAPABILITIES,
+            clock
+        });
+        for (const component of analysis.components)
+            emitComponent(builder, component, pkg);
+        for (const d of analysis.diagnostics)
+            builder.diagnostic(d);
+        return { ir: builder.build(analysis.components.some((c) => !c.propsComplete) ? "partial" : "complete") };
+    },
+    async validate({ ir }) {
+        return ir.entities.length === 0
+            ? [
+                {
+                    code: "vue.no-components",
+                    severity: "info",
+                    message: `No Vue components were found in the entry points of ${ir.source.id}`,
+                    sourceId: ir.source.id
+                }
+            ]
+            : [];
+    }
+};
+async function readPackageFiles(fs, pkg, nested) {
+    // An installed package (opted in through a declaration root) keeps its declaration files in build output.
+    const installed = pkg.dir.split("/").includes("node_modules");
+    const walked = await walk(fs, {
+        ignoreDirs: new Set(installed
+            ? DEFAULT_IGNORED_DIRS.filter((d) => !["dist", "build", "out"].includes(d))
+            : DEFAULT_IGNORED_DIRS),
+        maxFiles: 20_000,
+        start: pkg.dir
+    });
+    const files = new Map();
+    const hashes = [];
+    for (const path of walked.files) {
+        if (!SOURCE_FILE.test(path) || nested.some((n) => path === n.dir || path.startsWith(`${n.dir}/`)))
+            continue;
+        const text = await fs.readFile(path);
+        if (text.length > MAX_FILE_BYTES)
+            continue;
+        files.set(path, text);
+        hashes.push([path, hashText(text)]);
+    }
+    return { files, hashes };
+}
+//# sourceMappingURL=adapter.js.map

package/dist/compiler-vue/analyze.js

@@ -0,0 +1,344 @@
+import { createAnalysis, cssVariableReferences, declarationOf, isProjectNode, lineOf, posix, relativeFileOf, resolveSymbol, tsconfigPaths, unwrap, variantsFromProps } from "../compiler-core/index.js";
+import ts from "typescript";
+import { analyzeDeclaredComponent } from "./declared.js";
+import { analyzeOptionsDeclaration, analyzeScript } from "./script.js";
+import { parseSfc, sfcLocalName } from "./sfc.js";
+import { analyzeTemplate } from "./template.js";
+const NON_SOURCE = /\.(?:test|spec|stories)\.[cm]?[jt]sx?$|(?:^|\/)__(?:tests|mocks)__\//;
+/**
+ * Finds the package's public Vue components (what its entry points export that is a `.vue` file or a
+ * `defineComponent(...)` declaration) and analyzes each. Nothing is executed or built.
+ */
+export function analyzePackage(input) {
+    const diagnostics = [];
+    const note = (severity, code, message, location) => {
+        diagnostics.push({ code, severity, message, ...(location ? { location } : {}) });
+    };
+    // 1. Public SFCs, from what the entry points re-export.
+    const publicSfcs = new Map();
+    const importCache = new Map();
+    for (const entry of input.entryPoints) {
+        for (const exported of entry.exports) {
+            const target = sfcTargetOf(exported, input.files, importCache);
+            if (target)
+                publicSfcs.set(target, [
+                    ...(publicSfcs.get(target) ?? []),
+                    { subpath: entry.subpath, name: exported.name }
+                ]);
+        }
+    }
+    // 2. Parse each SFC and give its script to the type checker as a virtual module.
+    const sfcs = new Map();
+    const files = new Map();
+    for (const [path, text] of input.files)
+        if (/\.[cm]?[jt]sx?$/.test(path) && !NON_SOURCE.test(path))
+            files.set(path, text);
+    // Every SFC gets a virtual module, public or not: a component's props type is often an interface exported
+    // from another SFC's `<script>` block (`import type { XProps } from "../X"`, re-exported from `X.vue`).
+    const moduleAliases = {};
+    for (const path of [...input.files.keys()].filter((f) => f.endsWith(".vue")).sort()) {
+        const sfc = parseSfc(path, input.files.get(path));
+        if (publicSfcs.has(path)) {
+            sfcs.set(path, sfc);
+            for (const message of sfc.errors)
+                note("warning", "vue.sfc-parse-error", `${path}: ${message}`, { path });
+        }
+        if (sfc.script) {
+            files.set(sfc.script.path, sfc.script.text);
+            moduleAliases[path] = sfc.script.path;
+        }
+    }
+    const analysis = createAnalysis(files, {
+        moduleAliases,
+        paths: tsconfigPaths(input.files, input.packageDir)
+    });
+    const components = [];
+    const refOf = new Map();
+    for (const path of [...publicSfcs.keys()].sort())
+        refOf.set(path, `vue:${path}#${sfcLocalName(path)}`);
+    for (const [path, sfc] of sfcs) {
+        components.push(buildSfcComponent({
+            analysis,
+            sfc,
+            exports: publicSfcs.get(path) ?? [],
+            ref: refOf.get(path),
+            refOf,
+            note,
+            files: input.files
+        }));
+    }
+    // 3. Components declared in TypeScript with defineComponent(...).
+    for (const entry of input.entryPoints) {
+        const sf = entry.file ? analysis.sourceFile(entry.file) : undefined;
+        const moduleSymbol = sf ? analysis.checker.getSymbolAtLocation(sf) : undefined;
+        if (!sf || !moduleSymbol)
+            continue;
+        for (const exported of analysis.checker.getExportsOfModule(moduleSymbol)) {
+            const decl = declarationOf(resolveSymbol(analysis.checker, exported));
+            if (!decl ||
+                !ts.isVariableDeclaration(decl) ||
+                !ts.isIdentifier(decl.name) ||
+                !isProjectNode(analysis, decl))
+                continue;
+            const init = decl.initializer ? unwrap(decl.initializer) : undefined;
+            if (!init) {
+                // A declaration file's `declare const X: DefineComponent<…>`.
+                const file = relativeFileOf(analysis, decl);
+                const localName = declaredLocalName(decl.name.text, exported.name, file);
+                const ref = `vue:${file}#${localName}`;
+                const existing = components.find((c) => c.ref === ref);
+                if (existing)
+                    existing.exports.push({ subpath: entry.subpath, name: exported.name });
+                else {
+                    const script = analyzeDeclaredComponent(analysis, decl);
+                    if (script)
+                        components.push(buildTsComponent({
+                            analysis,
+                            decl,
+                            script,
+                            ref,
+                            localName,
+                            kind: "declaration",
+                            exported: { subpath: entry.subpath, name: exported.name }
+                        }));
+                }
+                continue;
+            }
+            if (!init ||
+                !ts.isCallExpression(init) ||
+                !ts.isIdentifier(init.expression) ||
+                init.expression.text !== "defineComponent")
+                continue;
+            const file = relativeFileOf(analysis, decl);
+            const ref = `vue:${file}#${decl.name.text}`;
+            const existing = components.find((c) => c.ref === ref);
+            if (existing)
+                existing.exports.push({ subpath: entry.subpath, name: exported.name });
+            else {
+                const script = analyzeOptionsDeclaration(analysis, decl);
+                if (script)
+                    components.push(buildTsComponent({
+                        analysis,
+                        decl,
+                        script,
+                        ref,
+                        exported: { subpath: entry.subpath, name: exported.name }
+                    }));
+            }
+        }
+    }
+    if (components.some((c) => c.kind === "declaration"))
+        note("info", "vue.declaration-defaults-unavailable", "Components were read from declaration files, which carry types but no default values: prop defaults are not reported");
+    for (const c of components) {
+        if (!c.propsComplete)
+            note("info", "vue.props-incomplete", `${c.localName}: props could not be fully enumerated${c.script.inheritsFrom.length ? ` (${c.script.inheritsFrom.join(", ")})` : c.script.notes[0] ? ` (${c.script.notes[0]})` : ""}`, { path: c.file, line: c.line });
+        if (c.template?.skipped)
+            note("info", "vue.template-skipped", `${c.localName}: ${c.template.skipped}`, {
+                path: c.file,
+                line: c.templateLine ?? c.line
+            });
+        for (const s of c.template?.slots ?? [])
+            if (s.dynamic)
+                note("info", "vue.dynamic-slot-name", `${c.localName}: a <slot> with a dynamic name was found and is not listed`, { path: c.file, line: s.line });
+    }
+    components.sort((a, b) => (a.ref < b.ref ? -1 : a.ref > b.ref ? 1 : 0));
+    for (const c of components)
+        c.exports.sort((a, b) => a.subpath < b.subpath ? -1 : a.subpath > b.subpath ? 1 : a.name < b.name ? -1 : 1);
+    return { components, diagnostics };
+}
+/** `declare const _default` (vue-tsc output for one `.vue` file) is named after its file; other names are kept. */
+function declaredLocalName(declName, exportName, file) {
+    if (!declName.startsWith("_"))
+        return declName;
+    if (exportName !== "default")
+        return exportName;
+    return sfcLocalName(file.replace(/(?:\.vue)?\.d\.[cm]?ts$/, ".vue"));
+}
+function sfcTargetOf(exported, files, cache) {
+    const resolve = (spec, from) => {
+        if (!spec.startsWith("."))
+            return undefined;
+        const path = posix.normalize(posix.join(posix.dirname(from), spec));
+        return path.endsWith(".vue") && files.has(path) ? path : undefined;
+    };
+    if (exported.reexportOf)
+        return resolve(exported.reexportOf.module, exported.file);
+    // `import Button from "./Button.vue"; export { Button }`
+    let imports = cache.get(exported.file);
+    if (!imports) {
+        imports = new Map();
+        const text = files.get(exported.file);
+        if (text) {
+            const sf = ts.createSourceFile(exported.file, text, ts.ScriptTarget.ES2022, false);
+            for (const statement of sf.statements) {
+                if (ts.isImportDeclaration(statement) &&
+                    ts.isStringLiteral(statement.moduleSpecifier) &&
+                    statement.importClause?.name) {
+                    imports.set(statement.importClause.name.text, statement.moduleSpecifier.text);
+                }
+            }
+        }
+        cache.set(exported.file, imports);
+    }
+    const spec = imports.get(exported.name);
+    return spec ? resolve(spec, exported.file) : undefined;
+}
+function buildSfcComponent(input) {
+    const { analysis, sfc, note } = input;
+    const { descriptor } = sfc;
+    const sf = sfc.script ? analysis.sourceFile(sfc.script.path) : undefined;
+    const script = sf
+        ? analyzeScript(analysis, sf)
+        : {
+            props: [],
+            emits: [],
+            slots: [],
+            exposed: [],
+            options: {},
+            inheritsFrom: [],
+            complete: true,
+            notes: [],
+            optionsApi: false,
+            imports: new Map()
+        };
+    const external = [descriptor.script, descriptor.scriptSetup].some((b) => b?.src);
+    if (external) {
+        script.complete = false;
+        script.notes.push("a script block loads its content from another file (src), which is not read");
+        note("info", "vue.external-block", `${sfc.path}: a <script src> block is not read`, { path: sfc.path });
+    }
+    const template = analyzeTemplate(descriptor);
+    const generic = descriptor.scriptSetup?.attrs.generic;
+    if (typeof generic === "string")
+        script.notes.push(`generic component <${generic}>`);
+    const localName = sfcLocalName(sfc.path);
+    const slots = mergeSlots(script.slots, template);
+    const variants = variantsFromProps(script.props.map(toSpec));
+    return {
+        ref: input.ref,
+        localName,
+        file: sfc.path,
+        line: firstBlockLine(descriptor),
+        kind: "sfc",
+        exports: [...input.exports],
+        sfc,
+        script,
+        template,
+        ...(descriptor.template ? { templateLine: descriptor.template.loc.start.line } : {}),
+        styling: stylingOf(descriptor),
+        variants,
+        slots,
+        renders: rendersOf({ template, script, sfcPath: sfc.path, refOf: input.refOf }),
+        propsComplete: script.complete && typeof generic !== "string",
+        ...(typeof generic === "string" ? { generic } : {}),
+        locate: (node) => {
+            const virtual = relativeFileOf(analysis, node);
+            const line = lineOf(node);
+            const script = sfc.script;
+            return script && virtual === script.path
+                ? { file: sfc.path, line: script.lineOf(line) }
+                : { file: virtual ?? sfc.path, line };
+        }
+    };
+}
+function buildTsComponent(input) {
+    const { analysis, decl, script } = input;
+    const file = relativeFileOf(analysis, decl);
+    return {
+        ref: input.ref,
+        localName: input.localName ?? decl.name.text,
+        file,
+        line: lineOf(decl),
+        kind: input.kind ?? "defineComponent",
+        exports: [input.exported],
+        script,
+        styling: { variables: [], scoped: false, module: false, preprocessors: [], blocks: 0 },
+        variants: variantsFromProps(script.props.map(toSpec)),
+        slots: mergeSlots(script.slots, { slots: [] }),
+        renders: [],
+        propsComplete: script.complete,
+        locate: (node) => ({ file: relativeFileOf(analysis, node) ?? file, line: lineOf(node) })
+    };
+}
+function firstBlockLine(descriptor) {
+    const lines = [descriptor.script, descriptor.scriptSetup, descriptor.template].flatMap((b) => b ? [b.loc.start.line] : []);
+    return lines.length > 0 ? Math.min(...lines) : 1;
+}
+function toSpec(p) {
+    return {
+        name: p.name,
+        typeText: p.typeText,
+        kind: p.kind,
+        required: p.required,
+        ...(p.default !== undefined ? { default: p.default } : {}),
+        ...(p.allowedValues ? { allowedValues: p.allowedValues } : {})
+    };
+}
+function mergeSlots(declared, template) {
+    const byName = new Map();
+    for (const s of declared)
+        byName.set(s.name, {
+            name: s.name,
+            ...(s.propsText ? { propsText: s.propsText } : {}),
+            templateProps: [],
+            sources: ["defineSlots"],
+            node: s.node
+        });
+    for (const s of template.slots) {
+        if (s.dynamic || !s.name)
+            continue;
+        const existing = byName.get(s.name);
+        if (existing) {
+            existing.sources.push("template");
+            existing.templateProps = [...new Set([...existing.templateProps, ...s.props])].sort();
+            existing.line ??= s.line;
+        }
+        else
+            byName.set(s.name, { name: s.name, templateProps: s.props, sources: ["template"], line: s.line });
+    }
+    return [...byName.values()].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+}
+function stylingOf(descriptor) {
+    const variables = new Map();
+    for (const block of descriptor.styles) {
+        for (const ref of cssVariableReferences(block.content))
+            if (!variables.has(ref.name))
+                variables.set(ref.name, block.loc.start.line + ref.line - 1);
+    }
+    return {
+        variables: [...variables]
+            .map(([name, line]) => ({ name, line }))
+            .sort((a, b) => (a.name < b.name ? -1 : 1)),
+        scoped: descriptor.styles.some((s) => s.scoped),
+        module: descriptor.styles.some((s) => s.module),
+        preprocessors: [...new Set(descriptor.styles.flatMap((s) => (s.lang ? [s.lang] : [])))].sort(),
+        blocks: descriptor.styles.length
+    };
+}
+/** Component tags used in the template, resolved through the script's imports to other public components. */
+function rendersOf(input) {
+    const { template, script, sfcPath, refOf } = input;
+    const byLocal = new Map();
+    for (const [local, spec] of script.imports) {
+        if (!spec.startsWith(".") || !spec.endsWith(".vue"))
+            continue;
+        byLocal.set(local, posix.normalize(posix.join(posix.dirname(sfcPath), spec)));
+    }
+    const counts = new Map();
+    for (const { tag, count } of template.components) {
+        const pascal = tag.includes("-")
+            ? tag
+                .split("-")
+                .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+                .join("")
+            : tag;
+        const file = byLocal.get(pascal) ?? byLocal.get(tag);
+        const target = file ? refOf.get(file) : undefined;
+        if (target && target !== refOf.get(sfcPath))
+            counts.set(target, (counts.get(target) ?? 0) + count);
+    }
+    return [...counts]
+        .map(([target, count]) => ({ target, count }))
+        .sort((a, b) => (a.target < b.target ? -1 : 1));
+}
+//# sourceMappingURL=analyze.js.map