@invariant-ui/cli 0.0.0-stage → 0.1.0

package/dist/compiler-vue/script.js

@@ -0,0 +1,472 @@
+import { classifyKind, collapse, describeMember, externalBases, literalDomain, literalValue, ownProperties, unwrap } from "../compiler-core/index.js";
+import ts from "typescript";
+const RENDERABLE = /^(?:VNode|VNodeChild|VNodeArrayChildren|Component|DefineComponent)(?:<.*>)?$/;
+const RUNTIME_KINDS = {
+    String: { text: "string", kind: "string" },
+    Number: { text: "number", kind: "number" },
+    Boolean: { text: "boolean", kind: "boolean" },
+    Array: { text: "unknown[]", kind: "array" },
+    Object: { text: "object", kind: "object" },
+    Function: { text: "Function", kind: "function" },
+    Symbol: { text: "symbol", kind: "unknown" },
+    Date: { text: "Date", kind: "object" }
+};
+/** Reads the component declaration of a (virtual) script module. Never evaluates or runs anything. */
+export function analyzeScript(analysis, sf) {
+    const info = {
+        props: [],
+        emits: [],
+        slots: [],
+        exposed: [],
+        options: {},
+        inheritsFrom: [],
+        complete: true,
+        notes: [],
+        optionsApi: false,
+        imports: readImports(sf)
+    };
+    const state = { analysis, info };
+    for (const statement of sf.statements) {
+        if (ts.isVariableStatement(statement)) {
+            for (const d of statement.declarationList.declarations)
+                if (d.initializer)
+                    macro(state, unwrap(d.initializer), d);
+        }
+        else if (ts.isExpressionStatement(statement))
+            macro(state, unwrap(statement.expression), undefined);
+        else if (ts.isExportAssignment(statement) && !statement.isExportEquals) {
+            const options = optionsObject(unwrap(statement.expression));
+            if (options)
+                readOptions(state, options);
+        }
+    }
+    return info;
+}
+/** Analyzes `defineComponent({...})`/options-object declarations in a TS file (for non-SFC components). */
+export function analyzeOptionsDeclaration(analysis, declaration) {
+    if (!declaration.initializer)
+        return undefined;
+    const options = optionsObject(unwrap(declaration.initializer));
+    if (!options)
+        return undefined;
+    const info = {
+        props: [],
+        emits: [],
+        slots: [],
+        exposed: [],
+        options: {},
+        inheritsFrom: [],
+        complete: true,
+        notes: [],
+        optionsApi: true,
+        imports: readImports(declaration.getSourceFile())
+    };
+    readOptions({ analysis, info }, options);
+    return info;
+}
+function macro(state, call, declaration) {
+    if (!ts.isCallExpression(call) || !ts.isIdentifier(call.expression))
+        return;
+    const name = call.expression.text;
+    const { info } = state;
+    if (name === "withDefaults") {
+        const inner = call.arguments[0] ? unwrap(call.arguments[0]) : undefined;
+        if (inner &&
+            ts.isCallExpression(inner) &&
+            ts.isIdentifier(inner.expression) &&
+            inner.expression.text === "defineProps") {
+            definePropsMacro(state, inner, defaultsFromObject(call.arguments[1]), declaration);
+        }
+    }
+    else if (name === "defineProps")
+        definePropsMacro(state, call, new Map(), declaration);
+    else if (name === "defineEmits")
+        defineEmitsMacro(state, call);
+    else if (name === "defineSlots")
+        defineSlotsMacro(state, call);
+    else if (name === "defineModel")
+        defineModelMacro(state, call);
+    else if (name === "defineExpose") {
+        const arg = call.arguments[0] ? unwrap(call.arguments[0]) : undefined;
+        if (arg && ts.isObjectLiteralExpression(arg))
+            info.exposed = arg.properties
+                .flatMap((p) => p.name && (ts.isIdentifier(p.name) || ts.isStringLiteralLike(p.name)) ? [p.name.text] : [])
+                .sort();
+        else if (arg)
+            info.notes.push("defineExpose argument is not an object literal");
+    }
+    else if (name === "defineOptions") {
+        const arg = call.arguments[0] ? unwrap(call.arguments[0]) : undefined;
+        if (arg && ts.isObjectLiteralExpression(arg))
+            readOptionMetadata(info, arg);
+    }
+}
+function definePropsMacro(state, call, withDefaults, declaration) {
+    const { analysis, info } = state;
+    const defaults = new Map(withDefaults);
+    // Reactive props destructure (Vue 3.5+): `const { size = "md" } = defineProps<…>()`.
+    if (declaration && ts.isObjectBindingPattern(declaration.name)) {
+        for (const element of declaration.name.elements) {
+            if (!element.initializer || element.dotDotDotToken)
+                continue;
+            const key = element.propertyName ?? element.name;
+            if (ts.isIdentifier(key) || ts.isStringLiteralLike(key))
+                defaults.set(key.text, specOf(element.initializer));
+        }
+    }
+    const typeArgument = call.typeArguments?.[0];
+    if (typeArgument) {
+        const type = analysis.checker.getTypeFromTypeNode(typeArgument);
+        if (type.flags & ts.TypeFlags.Any) {
+            info.complete = false;
+            info.notes.push("defineProps type did not resolve");
+        }
+        info.inheritsFrom.push(...externalBases(analysis, typeArgument));
+        for (const { symbol, declaration: decl } of ownProperties(analysis, type)) {
+            const member = describeMember(analysis, symbol, decl, { renderable: RENDERABLE });
+            const fallback = defaults.get(member.name);
+            info.props.push({
+                name: member.name,
+                typeText: member.typeText,
+                kind: member.kind,
+                required: member.required,
+                ...(fallback?.value !== undefined ? { default: fallback.value } : {}),
+                ...(fallback && fallback.value === undefined ? { defaultExpression: fallback.expression } : {}),
+                ...(member.allowedValues ? { allowedValues: member.allowedValues } : {}),
+                ...(member.description ? { description: member.description } : {}),
+                ...(member.deprecated ? { deprecated: member.deprecated } : {}),
+                source: "type",
+                node: decl
+            });
+        }
+        if (info.inheritsFrom.length > 0)
+            info.complete = false;
+        return;
+    }
+    const arg = call.arguments[0] ? unwrap(call.arguments[0]) : undefined;
+    if (arg)
+        readRuntimeProps(state, arg);
+}
+function specOf(expression) {
+    const value = literalValue(expression);
+    return {
+        ...(value !== undefined ? { value } : {}),
+        expression: collapse(expression.getText()).slice(0, 200)
+    };
+}
+function defaultsFromObject(node) {
+    const out = new Map();
+    const object = node ? unwrap(node) : undefined;
+    if (!object || !ts.isObjectLiteralExpression(object))
+        return out;
+    for (const p of object.properties) {
+        if (!p.name || !(ts.isIdentifier(p.name) || ts.isStringLiteralLike(p.name)))
+            continue;
+        if (ts.isPropertyAssignment(p))
+            out.set(p.name.text, specOf(p.initializer));
+        else if (ts.isMethodDeclaration(p))
+            out.set(p.name.text, { expression: collapse(p.getText()).slice(0, 200) });
+    }
+    return out;
+}
+/** `props: ['a', 'b']` and `props: { a: String, b: { type: Number, default: 1 } }` (also the `defineProps(...)` argument). */
+function readRuntimeProps(state, node) {
+    const { analysis, info } = state;
+    if (ts.isArrayLiteralExpression(node)) {
+        for (const element of node.elements) {
+            if (ts.isStringLiteralLike(element))
+                info.props.push({
+                    name: element.text,
+                    typeText: "unknown",
+                    kind: "unknown",
+                    required: false,
+                    source: "array",
+                    node: element
+                });
+            else
+                info.complete = false;
+        }
+        return;
+    }
+    if (!ts.isObjectLiteralExpression(node)) {
+        info.complete = false;
+        info.notes.push("props declaration is not an object or array literal");
+        return;
+    }
+    for (const property of node.properties) {
+        if (!property.name ||
+            !(ts.isIdentifier(property.name) || ts.isStringLiteralLike(property.name)) ||
+            ts.isSpreadAssignment(property)) {
+            info.complete = false;
+            continue;
+        }
+        const name = property.name.text;
+        // Keep `as PropType<…>` casts: they carry the type. Only parentheses are stripped.
+        const value = ts.isPropertyAssignment(property) ? withoutParens(property.initializer) : undefined;
+        const spec = value
+            ? runtimeSpec(analysis, value)
+            : { typeText: "unknown", kind: "unknown", required: false };
+        info.props.push({ name, ...spec, source: "runtime", node: property });
+    }
+}
+function withoutParens(node) {
+    let current = node;
+    while (ts.isParenthesizedExpression(current))
+        current = current.expression;
+    return current;
+}
+function runtimeSpec(analysis, value) {
+    const base = { typeText: "unknown", kind: "unknown", required: false };
+    if (ts.isIdentifier(value))
+        return {
+            ...base,
+            ...(RUNTIME_KINDS[value.text]
+                ? {
+                    typeText: RUNTIME_KINDS[value.text].text,
+                    kind: RUNTIME_KINDS[value.text].kind
+                }
+                : {})
+        };
+    if (ts.isAsExpression(value))
+        return typeFromCast(analysis, value, base);
+    if (ts.isArrayLiteralExpression(value)) {
+        const names = value.elements.flatMap((e) => ts.isIdentifier(e) && RUNTIME_KINDS[e.text] ? [RUNTIME_KINDS[e.text].text] : []);
+        return {
+            ...base,
+            typeText: names.join(" | ") || "unknown",
+            kind: names.length > 1
+                ? "union"
+                : names.length === 1
+                    ? RUNTIME_KINDS[value.elements[0].text].kind
+                    : "unknown"
+        };
+    }
+    if (!ts.isObjectLiteralExpression(value))
+        return base;
+    const get = (key) => {
+        const p = value.properties.find((x) => ts.isPropertyAssignment(x) && x.name.getText() === key);
+        return p && ts.isPropertyAssignment(p) ? unwrap(p.initializer) : undefined;
+    };
+    // `type: String as PropType<…>`: the cast carries the type, so it must not be unwrapped.
+    const typeProperty = value.properties.find((x) => ts.isPropertyAssignment(x) && x.name.getText() === "type");
+    const typeExpression = typeProperty && ts.isPropertyAssignment(typeProperty) ? typeProperty.initializer : undefined;
+    const typed = typeExpression ? runtimeSpec(analysis, typeExpression) : base;
+    const requiredNode = get("required");
+    const defaultNode = get("default");
+    const fallback = defaultNode ? specOf(defaultNode) : undefined;
+    return {
+        ...typed,
+        required: requiredNode?.kind === ts.SyntaxKind.TrueKeyword,
+        ...(fallback?.value !== undefined ? { default: fallback.value } : {}),
+        ...(fallback && fallback.value === undefined ? { defaultExpression: fallback.expression } : {})
+    };
+}
+/** `String as PropType<"a" | "b">`. */
+function typeFromCast(analysis, cast, base) {
+    const target = cast.type;
+    if (ts.isTypeReferenceNode(target) &&
+        target.typeName.getText().endsWith("PropType") &&
+        target.typeArguments?.[0]) {
+        const inner = target.typeArguments[0];
+        const text = collapse(inner.getText());
+        const checker = analysis.checker;
+        const type = checker.getTypeFromTypeNode(inner);
+        const allowed = literalDomain(checker, inner);
+        const kind = allowed && allowed.length > 0 && !allowed.every((v) => typeof v === "boolean")
+            ? "enum"
+            : classifyKind(checker, type, text, RENDERABLE);
+        return {
+            ...base,
+            typeText: text,
+            kind,
+            ...(kind === "enum" && allowed && allowed.length > 0 ? { allowedValues: allowed } : {})
+        };
+    }
+    return base;
+}
+function defineEmitsMacro(state, call) {
+    const { analysis, info } = state;
+    const typeArgument = call.typeArguments?.[0];
+    if (typeArgument) {
+        const checker = analysis.checker;
+        const type = checker.getTypeFromTypeNode(typeArgument);
+        // Call-signature form: (e: 'change', id: number): void
+        for (const signature of type.getCallSignatures()) {
+            const [first, ...rest] = signature.getParameters();
+            const eventType = first ? checker.getTypeOfSymbolAtLocation(first, typeArgument) : undefined;
+            if (!eventType?.isStringLiteral())
+                continue;
+            const payload = rest
+                .map((p) => `${p.name}: ${checker.typeToString(checker.getTypeOfSymbolAtLocation(p, typeArgument))}`)
+                .join(", ");
+            info.emits.push({
+                name: eventType.value,
+                ...(payload ? { payloadText: payload } : {}),
+                source: "type",
+                node: typeArgument
+            });
+        }
+        // Named-tuple form (Vue 3.3+): change: [id: number]
+        for (const property of type.getProperties()) {
+            const propType = checker.getTypeOfSymbolAtLocation(property, typeArgument);
+            if (!checker.isTupleType(propType) && !checker.isArrayType(propType))
+                continue;
+            const text = checker.typeToString(propType);
+            info.emits.push({
+                name: property.name,
+                ...(text !== "[]" ? { payloadText: text } : {}),
+                source: "type",
+                node: property.valueDeclaration ?? typeArgument
+            });
+        }
+        return;
+    }
+    const arg = call.arguments[0] ? unwrap(call.arguments[0]) : undefined;
+    if (arg)
+        readRuntimeEmits(info, arg);
+}
+function readRuntimeEmits(info, node) {
+    if (ts.isArrayLiteralExpression(node)) {
+        for (const e of node.elements) {
+            if (ts.isStringLiteralLike(e))
+                info.emits.push({ name: e.text, source: "array", node: e });
+            else
+                info.complete = false;
+        }
+    }
+    else if (ts.isObjectLiteralExpression(node)) {
+        for (const p of node.properties) {
+            if (p.name && (ts.isIdentifier(p.name) || ts.isStringLiteralLike(p.name)))
+                info.emits.push({ name: p.name.text, source: "runtime", node: p });
+        }
+    }
+    else
+        info.notes.push("emits declaration is not an array or object literal");
+}
+function defineSlotsMacro(state, call) {
+    const { analysis, info } = state;
+    const typeArgument = call.typeArguments?.[0];
+    if (!typeArgument)
+        return;
+    const checker = analysis.checker;
+    const type = checker.getTypeFromTypeNode(typeArgument);
+    for (const property of type.getProperties()) {
+        const propType = checker.getTypeOfSymbolAtLocation(property, typeArgument);
+        const parameter = propType.getCallSignatures()[0]?.getParameters()[0];
+        const propsText = parameter
+            ? checker.typeToString(checker.getTypeOfSymbolAtLocation(parameter, typeArgument))
+            : undefined;
+        info.slots.push({
+            name: property.name,
+            ...(propsText ? { propsText } : {}),
+            node: property.valueDeclaration ?? typeArgument
+        });
+    }
+}
+/** `defineModel()` is a prop named `modelValue` (or the given name) plus an `update:<name>` event. */
+function defineModelMacro(state, call) {
+    const { analysis, info } = state;
+    const first = call.arguments[0] ? unwrap(call.arguments[0]) : undefined;
+    const named = first && ts.isStringLiteralLike(first);
+    const name = named ? first.text : "modelValue";
+    const options = (named ? call.arguments[1] : call.arguments[0]);
+    const object = options ? unwrap(options) : undefined;
+    const checker = analysis.checker;
+    const typeArgument = call.typeArguments?.[0];
+    const typeText = typeArgument ? collapse(typeArgument.getText()) : "unknown";
+    let kind = "unknown";
+    let allowedValues;
+    if (typeArgument) {
+        const allowed = literalDomain(checker, typeArgument);
+        kind =
+            allowed && allowed.length > 0 && !allowed.every((v) => typeof v === "boolean")
+                ? "enum"
+                : classifyKind(checker, checker.getTypeFromTypeNode(typeArgument), typeText, RENDERABLE);
+        if (kind === "enum")
+            allowedValues = allowed;
+    }
+    else if (object && ts.isObjectLiteralExpression(object)) {
+        const type = object.properties.find((p) => ts.isPropertyAssignment(p) && p.name.getText() === "type");
+        if (type && ts.isPropertyAssignment(type))
+            kind = runtimeSpec(analysis, unwrap(type.initializer)).kind;
+    }
+    let required = false;
+    let fallback;
+    if (object && ts.isObjectLiteralExpression(object)) {
+        for (const p of object.properties) {
+            if (!ts.isPropertyAssignment(p))
+                continue;
+            if (p.name.getText() === "required")
+                required = unwrap(p.initializer).kind === ts.SyntaxKind.TrueKeyword;
+            if (p.name.getText() === "default")
+                fallback = specOf(p.initializer);
+        }
+    }
+    info.props.push({
+        name,
+        typeText,
+        kind,
+        required,
+        ...(fallback?.value !== undefined ? { default: fallback.value } : {}),
+        ...(fallback && fallback.value === undefined ? { defaultExpression: fallback.expression } : {}),
+        ...(allowedValues ? { allowedValues } : {}),
+        source: "model",
+        node: call
+    });
+    info.emits.push({ name: `update:${name}`, payloadText: typeText, source: "model", node: call });
+}
+/** `export default { … }` and `defineComponent({ … })`. */
+function optionsObject(node) {
+    if (ts.isObjectLiteralExpression(node))
+        return node;
+    if (ts.isCallExpression(node) &&
+        ts.isIdentifier(node.expression) &&
+        node.expression.text === "defineComponent" &&
+        node.arguments[0]) {
+        const arg = unwrap(node.arguments[0]);
+        return ts.isObjectLiteralExpression(arg) ? arg : undefined;
+    }
+    return undefined;
+}
+function readOptions(state, options) {
+    const { info } = state;
+    info.optionsApi = true;
+    readOptionMetadata(info, options);
+    for (const p of options.properties) {
+        if (!ts.isPropertyAssignment(p) || !p.name)
+            continue;
+        const key = p.name.getText().replace(/^["']|["']$/g, "");
+        if (key === "props")
+            readRuntimeProps(state, unwrap(p.initializer));
+        else if (key === "emits")
+            readRuntimeEmits(info, unwrap(p.initializer));
+    }
+}
+function readOptionMetadata(info, options) {
+    for (const p of options.properties) {
+        if (!ts.isPropertyAssignment(p) || !p.name)
+            continue;
+        const key = p.name.getText().replace(/^["']|["']$/g, "");
+        const value = unwrap(p.initializer);
+        if (key === "name" && ts.isStringLiteralLike(value))
+            info.options.name = value.text;
+        if (key === "inheritAttrs")
+            info.options.inheritAttrs = value.kind === ts.SyntaxKind.TrueKeyword;
+    }
+}
+function readImports(sf) {
+    const imports = new Map();
+    for (const statement of sf.statements) {
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const clause = statement.importClause;
+        if (clause?.name)
+            imports.set(clause.name.text, statement.moduleSpecifier.text);
+        if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+            for (const e of clause.namedBindings.elements)
+                imports.set(e.name.text, `${statement.moduleSpecifier.text}#${(e.propertyName ?? e.name).text}`);
+        }
+    }
+    return imports;
+}
+//# sourceMappingURL=script.js.map

package/dist/compiler-vue/sfc.js

@@ -0,0 +1,44 @@
+import { componentNameFromFile } from "../compiler-core/index.js";
+import { parse } from "@vue/compiler-sfc";
+export function parseSfc(path, text) {
+    const { descriptor, errors } = parse(text, { filename: path, sourceMap: false });
+    const script = buildScript(path, descriptor);
+    return {
+        path,
+        descriptor,
+        errors: errors.map((e) => ("message" in e ? e.message : String(e))),
+        ...(script ? { script } : {})
+    };
+}
+function buildScript(path, descriptor) {
+    const blocks = [descriptor.script, descriptor.scriptSetup].filter((b) => b !== null);
+    // Blocks that load their content from another file (`<script src>`) are not read here.
+    const readable = blocks.filter((b) => !b.src);
+    if (readable.length === 0)
+        return undefined;
+    const segments = [];
+    let text = "";
+    let line = 1;
+    for (const block of readable) {
+        const lines = block.content.split("\n").length;
+        segments.push({ virtualStart: line, sfcStart: block.loc.start.line, lines });
+        text += `${block.content}\n`;
+        line += lines;
+    }
+    const lang = readable.map((b) => b.lang).find((l) => l === "tsx" || l === "jsx");
+    const ext = lang ? ".tsx" : ".ts";
+    return {
+        path: `${path}${ext}`,
+        text,
+        tsx: lang !== undefined,
+        lineOf(virtualLine) {
+            const segment = [...segments].reverse().find((s) => virtualLine >= s.virtualStart) ?? segments[0];
+            return segment ? segment.sfcStart + (virtualLine - segment.virtualStart) : virtualLine;
+        }
+    };
+}
+/** Display and link name of an SFC component: the PascalCase file name (`button-group.vue` is `ButtonGroup`). */
+export function sfcLocalName(path) {
+    return componentNameFromFile(path);
+}
+//# sourceMappingURL=sfc.js.map

package/dist/compiler-vue/template.js

@@ -0,0 +1,73 @@
+// Numeric node and element kinds of the Vue template AST (stable constants of the compiler).
+const ELEMENT = 1;
+const ATTRIBUTE = 6;
+const DIRECTIVE = 7;
+const TAG_ELEMENT = 0;
+const TAG_SLOT = 2;
+/** Reads slot outlets, component tags and static accessibility attributes from the parsed template. */
+export function analyzeTemplate(descriptor) {
+    const info = { slots: [], components: [], accessibility: { roles: [], attributes: [] } };
+    const template = descriptor.template;
+    if (!template)
+        return info;
+    if (template.src)
+        return { ...info, skipped: "template loaded from an external file (src)" };
+    if (template.lang && template.lang !== "html")
+        return { ...info, skipped: `template language ${template.lang} is not analyzed` };
+    const root = template.ast;
+    if (!root)
+        return { ...info, skipped: "template did not parse" };
+    const components = new Map();
+    const roles = new Set();
+    const attributes = new Set();
+    const visit = (node) => {
+        if (node.type === ELEMENT && node.tag !== undefined) {
+            const props = node.props ?? [];
+            if (node.tagType === TAG_SLOT) {
+                const named = props.find((p) => p.type === ATTRIBUTE && p.name === "name");
+                const bound = props.find((p) => p.type === DIRECTIVE && p.name === "bind" && p.arg?.content === "name");
+                const slotProps = props
+                    .flatMap((p) => p.type === ATTRIBUTE
+                    ? [p.name]
+                    : p.type === DIRECTIVE && p.name === "bind" && p.arg?.isStatic
+                        ? [p.arg.content]
+                        : [])
+                    .filter((n) => n !== "name");
+                info.slots.push({
+                    ...(named?.value ? { name: named.value.content } : bound ? {} : { name: "default" }),
+                    dynamic: bound !== undefined,
+                    line: node.loc.start.line,
+                    props: [...new Set(slotProps)].sort()
+                });
+            }
+            else if (node.tagType === TAG_ELEMENT) {
+                for (const p of props) {
+                    if (p.type === ATTRIBUTE && p.name === "role" && p.value)
+                        roles.add(p.value.content);
+                    const name = p.type === ATTRIBUTE
+                        ? p.name
+                        : p.type === DIRECTIVE && p.name === "bind" && p.arg?.isStatic
+                            ? p.arg.content
+                            : undefined;
+                    if (name?.startsWith("aria-"))
+                        attributes.add(name);
+                }
+            }
+            else if (node.tagType !== undefined && node.tagType !== 3) {
+                const entry = components.get(node.tag) ?? { count: 0, line: node.loc.start.line };
+                entry.count++;
+                components.set(node.tag, entry);
+            }
+        }
+        for (const child of node.children ?? [])
+            if (typeof child === "object" && child !== null)
+                visit(child);
+    };
+    visit(root);
+    info.components = [...components]
+        .map(([tag, v]) => ({ tag, ...v }))
+        .sort((a, b) => (a.tag < b.tag ? -1 : 1));
+    info.accessibility = { roles: [...roles].sort(), attributes: [...attributes].sort() };
+    return info;
+}
+//# sourceMappingURL=template.js.map