@invariant-ui/cli 0.0.0-stage → 0.1.0

package/dist/compiler-vue/declared.js

@@ -0,0 +1,343 @@
+import { declarationOf, describeMember, literalDomain, ownProperties, resolveSymbol, typeReferenceInfo } from "../compiler-core/index.js";
+import ts from "typescript";
+const RENDERABLE = /^(?:VNode|VNodeChild|VNodeArrayChildren|Component|DefineComponent)(?:<.*>)?$/;
+const INSTANCE_TYPES = /^(?:CreateComponentPublicInstance(?:WithMixins)?|ComponentPublicInstance)$/;
+const CONSTRUCTORS = {
+    StringConstructor: { text: "string", kind: "string" },
+    NumberConstructor: { text: "number", kind: "number" },
+    BooleanConstructor: { text: "boolean", kind: "boolean" },
+    ArrayConstructor: { text: "unknown[]", kind: "array" },
+    ObjectConstructor: { text: "object", kind: "object" },
+    FunctionConstructor: { text: "Function", kind: "function" },
+    DateConstructor: { text: "Date", kind: "object" }
+};
+/** Positions of `DefineComponent<Props, RawBindings, D, C, M, Mixin, Extends, Emits, …>`. */
+const PROPS = 0;
+const EMITS = 7;
+/** Helpers that vue-tsc writes around the props type of a `<script setup lang="ts">` component. */
+const PROPS_WRAPPERS = /^__VLS_(?:TypePropsToRuntimeProps|TypePropsToOption|WithDefaults|Prettify)$/;
+const SLOTS_WRAPPER = /^__VLS_WithTemplateSlots$/;
+/**
+ * A component a declaration file declares by type: `declare const _default: DefineComponent<Props, …, Emits, …>`
+ * (what vue-tsc and vite-plugin-dts write for a `.vue` file or a `defineComponent` call). There is no script
+ * to read, so props, events and slots come from the written type arguments. Default values are not part of
+ * a declaration file and are not reported.
+ */
+export function analyzeDeclaredComponent(analysis, declaration) {
+    if (declaration.initializer || !declaration.type)
+        return undefined;
+    const found = findDefineComponent(analysis, declaration.type, 0);
+    if (!found)
+        return undefined;
+    const info = {
+        props: [],
+        emits: [],
+        slots: [],
+        exposed: [],
+        options: {},
+        inheritsFrom: [],
+        complete: true,
+        notes: [],
+        optionsApi: false,
+        imports: new Map()
+    };
+    const props = found.args[PROPS];
+    if (props)
+        readProps(analysis, props, info, 0);
+    const emits = found.args[EMITS];
+    if (emits)
+        readEmits(analysis, emits, info);
+    if (found.slots)
+        readSlots(analysis, found.slots, info);
+    return info;
+}
+function unparen(type) {
+    return ts.isParenthesizedTypeNode(type) ? unparen(type.type) : type;
+}
+function targetOf(analysis, name) {
+    return declarationOf(resolveSymbol(analysis.checker, analysis.checker.getSymbolAtLocation(name)));
+}
+function findDefineComponent(analysis, type, depth) {
+    if (depth > 5)
+        return undefined;
+    const t = unparen(type);
+    if (ts.isIntersectionTypeNode(t)) {
+        let found;
+        let slots;
+        for (const part of t.types) {
+            found ??= findDefineComponent(analysis, part, depth + 1);
+            slots ??= slotsOfConstructor(part);
+        }
+        const slot = found?.slots ?? slots;
+        return found ? { args: found.args, ...(slot ? { slots: slot } : {}) } : undefined;
+    }
+    if (ts.isTypeQueryNode(t)) {
+        const target = targetOf(analysis, t.exprName);
+        return target && ts.isVariableDeclaration(target) && target.type
+            ? findDefineComponent(analysis, target.type, depth + 1)
+            : undefined;
+    }
+    // `{ new (...args: any[]): CreateComponentPublicInstanceWithMixins<Props, …, Emits, …> }`: what Vuetify and other
+    // `defineComponent` libraries write, with the same type-argument positions as `DefineComponent`.
+    if (ts.isTypeLiteralNode(t)) {
+        for (const member of t.members) {
+            if (!ts.isConstructSignatureDeclaration(member) || !member.type)
+                continue;
+            const instance = typeReferenceInfo(member.type);
+            if (instance && INSTANCE_TYPES.test(instance.name))
+                return { args: instance.typeArguments };
+        }
+        return undefined;
+    }
+    const ref = typeReferenceInfo(t);
+    if (!ref)
+        return undefined;
+    if (ref.name === "DefineComponent")
+        return { args: ref.typeArguments };
+    if (SLOTS_WRAPPER.test(ref.name) && ref.typeArguments[0]) {
+        const inner = findDefineComponent(analysis, ref.typeArguments[0], depth + 1);
+        return inner ? { ...inner, ...(ref.typeArguments[1] ? { slots: ref.typeArguments[1] } : {}) } : undefined;
+    }
+    // `type ButtonComponent = DefineComponent<…>`
+    if (ts.isTypeReferenceNode(t)) {
+        const target = targetOf(analysis, t.typeName);
+        if (target && ts.isTypeAliasDeclaration(target) && !target.typeParameters)
+            return findDefineComponent(analysis, target.type, depth + 1);
+        // `type SFCWithInstall<T> = T & Plugin` (Element Plus): the component is the argument passed for `T`.
+        if (target && ts.isTypeAliasDeclaration(target) && target.typeParameters && t.typeArguments) {
+            const body = unparen(target.type);
+            const members = ts.isIntersectionTypeNode(body) ? body.types : [body];
+            for (const member of members) {
+                const param = ts.isTypeReferenceNode(member)
+                    ? target.typeParameters.findIndex((p) => p.name.text === member.typeName.getText())
+                    : -1;
+                const arg = param >= 0 ? t.typeArguments[param] : undefined;
+                const found = arg ? findDefineComponent(analysis, arg, depth + 1) : undefined;
+                if (found)
+                    return found;
+            }
+        }
+    }
+    return undefined;
+}
+/** `{ new (): { $slots: S } }`, the way a declaration file attaches slot types to a component. */
+function slotsOfConstructor(type) {
+    const t = unparen(type);
+    if (!ts.isTypeLiteralNode(t))
+        return undefined;
+    for (const member of t.members) {
+        if (!ts.isConstructSignatureDeclaration(member) || !member.type || !ts.isTypeLiteralNode(member.type))
+            continue;
+        for (const inner of member.type.members)
+            if (ts.isPropertySignature(inner) && inner.name.getText() === "$slots")
+                return inner.type;
+    }
+    return undefined;
+}
+function readProps(analysis, type, info, depth) {
+    const t = unparen(type);
+    const ref = typeReferenceInfo(t);
+    if (depth < 4 && ref && PROPS_WRAPPERS.test(ref.name) && ref.typeArguments[0]) {
+        readProps(analysis, ref.typeArguments[0], info, depth + 1);
+        return;
+    }
+    // `ExtractPropTypes<{ size: { type: PropType<"a" | "b">; default: string } }>`: the runtime options, as a type.
+    if (ref?.name === "ExtractPropTypes" && ref.typeArguments[0]) {
+        readRuntimeProps(analysis, ref.typeArguments[0], info, 0);
+        return;
+    }
+    // `("size" | "tone")[]`: props declared as an array of names.
+    if (ts.isArrayTypeNode(t) || ts.isTupleTypeNode(t)) {
+        const names = ts.isArrayTypeNode(t)
+            ? literalDomain(analysis.checker, t.elementType)
+            : t.elements.flatMap((e) => literalDomain(analysis.checker, e) ?? []);
+        for (const name of names ?? [])
+            info.props.push({
+                name: String(name),
+                typeText: "unknown",
+                kind: "unknown",
+                required: false,
+                source: "array",
+                node: t
+            });
+        if (!names)
+            info.complete = false;
+        return;
+    }
+    const type_ = analysis.checker.getTypeFromTypeNode(t);
+    if (type_.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
+        info.complete = false;
+        info.notes.push("the props type did not resolve");
+        return;
+    }
+    for (const { symbol, declaration } of ownProperties(analysis, type_)) {
+        const member = describeMember(analysis, symbol, declaration, { renderable: RENDERABLE });
+        info.props.push({
+            name: member.name,
+            typeText: member.typeText,
+            kind: member.kind,
+            required: member.required,
+            ...(member.allowedValues ? { allowedValues: member.allowedValues } : {}),
+            ...(member.description ? { description: member.description } : {}),
+            ...(member.deprecated ? { deprecated: member.deprecated } : {}),
+            source: "type",
+            node: declaration
+        });
+    }
+}
+function readRuntimeProps(analysis, type, info, depth) {
+    let t = unparen(type);
+    // `typeof props`: follow to the declared type of the constant.
+    if (ts.isTypeQueryNode(t) && depth < 3) {
+        const target = targetOf(analysis, t.exprName);
+        if (target && ts.isVariableDeclaration(target) && target.type) {
+            readRuntimeProps(analysis, target.type, info, depth + 1);
+            return;
+        }
+    }
+    if (!ts.isTypeLiteralNode(t)) {
+        info.complete = false;
+        info.notes.push("the runtime props type is not an object type");
+        return;
+    }
+    for (const member of t.members) {
+        if (!ts.isPropertySignature(member) || !member.name || !member.type)
+            continue;
+        if (!(ts.isIdentifier(member.name) || ts.isStringLiteralLike(member.name)))
+            continue;
+        t = unparen(member.type);
+        const spec = ts.isTypeLiteralNode(t) ? t : undefined;
+        const field = (key) => spec?.members.find((m) => ts.isPropertySignature(m) && m.name.getText() === key);
+        // A bare constructor (`name: StringConstructor`) or a list of them is the shorthand for `{ type }`.
+        const typeNode = spec ? field("type")?.type : t;
+        const required = field("required")?.type?.getText() === "true";
+        const described = typeNode ? describeRuntimeType(analysis, typeNode) : undefined;
+        info.props.push({
+            name: member.name.text,
+            typeText: described?.text ?? "unknown",
+            kind: described?.kind ?? "unknown",
+            required,
+            ...(described?.allowedValues ? { allowedValues: described.allowedValues } : {}),
+            source: "runtime",
+            node: member
+        });
+    }
+}
+function describeRuntimeType(analysis, node) {
+    const t = unparen(node);
+    const ref = typeReferenceInfo(t);
+    if (ref?.name === "PropType" && ref.typeArguments[0]) {
+        const inner = ref.typeArguments[0];
+        const checkerType = analysis.checker.getTypeFromTypeNode(inner);
+        const text = inner.getText().replace(/\s+/g, " ");
+        const kind = kindOf(analysis, checkerType);
+        const allowedValues = kind === "enum" ? literalDomain(analysis.checker, inner) : undefined;
+        return { text, kind, ...(allowedValues ? { allowedValues } : {}) };
+    }
+    if (ref && CONSTRUCTORS[ref.name])
+        return CONSTRUCTORS[ref.name];
+    if (ts.isUnionTypeNode(t)) {
+        const parts = t.types.map((p) => describeRuntimeType(analysis, p));
+        if (parts.every((p) => p))
+            return { text: parts.map((p) => p?.text).join(" | "), kind: "union" };
+    }
+    return undefined;
+}
+function kindOf(analysis, type) {
+    const text = analysis.checker.typeToString(type);
+    if (type.flags & ts.TypeFlags.Any)
+        return "unknown";
+    if (type.getCallSignatures().length > 0)
+        return "function";
+    if (type.isUnion()) {
+        return type.types.every((x) => x.flags & (ts.TypeFlags.StringLiteral | ts.TypeFlags.NumberLiteral))
+            ? "enum"
+            : "union";
+    }
+    if (type.flags & ts.TypeFlags.StringLike)
+        return "string";
+    if (type.flags & ts.TypeFlags.NumberLike)
+        return "number";
+    if (type.flags & ts.TypeFlags.BooleanLike)
+        return "boolean";
+    if (analysis.checker.isArrayType(type))
+        return "array";
+    return text === "unknown" ? "unknown" : "object";
+}
+function readEmits(analysis, type, info) {
+    const t = unparen(type);
+    // `{}` and `string[]`-like placeholders: Vue's own default for a component with no emits.
+    if (ts.isTypeLiteralNode(t) && t.members.length === 0)
+        return;
+    if (ts.isArrayTypeNode(t) || ts.isTupleTypeNode(t)) {
+        const names = ts.isArrayTypeNode(t)
+            ? literalDomain(analysis.checker, t.elementType)
+            : t.elements.flatMap((e) => literalDomain(analysis.checker, e) ?? []);
+        for (const name of names ?? [])
+            info.emits.push({ name: String(name), source: "array", node: t });
+        return;
+    }
+    const checker = analysis.checker;
+    const resolved = checker.getTypeFromTypeNode(t);
+    // Call-signature form: `(e: "change", id: number): void`
+    for (const signature of resolved.getCallSignatures()) {
+        const [first, ...rest] = signature.getParameters();
+        const eventType = first ? checker.getTypeOfSymbolAtLocation(first, t) : undefined;
+        if (!eventType?.isStringLiteral())
+            continue;
+        const payload = rest
+            .map((p) => `${p.name}: ${checker.typeToString(checker.getTypeOfSymbolAtLocation(p, t))}`)
+            .join(", ");
+        info.emits.push({
+            name: eventType.value,
+            ...(payload ? { payloadText: payload } : {}),
+            source: "type",
+            node: t
+        });
+    }
+    // Object form: `change: (id: number) => void` or the named-tuple form `change: [id: number]`.
+    for (const property of resolved.getProperties()) {
+        const propType = checker.getNonNullableType(checker.getTypeOfSymbolAtLocation(property, t));
+        const node = property.valueDeclaration ?? t;
+        const signature = propType.getCallSignatures()[0];
+        if (signature) {
+            const payload = signature
+                .getParameters()
+                .map((p) => `${p.name}: ${checker.typeToString(checker.getTypeOfSymbolAtLocation(p, t))}`)
+                .join(", ");
+            info.emits.push({
+                name: property.name,
+                ...(payload ? { payloadText: payload } : {}),
+                source: "type",
+                node
+            });
+        }
+        else if (checker.isTupleType(propType) || checker.isArrayType(propType)) {
+            const text = checker.typeToString(propType);
+            info.emits.push({
+                name: property.name,
+                ...(text !== "[]" ? { payloadText: text } : {}),
+                source: "type",
+                node
+            });
+        }
+        else
+            info.emits.push({ name: property.name, source: "type", node });
+    }
+}
+function readSlots(analysis, type, info) {
+    const checker = analysis.checker;
+    for (const property of checker.getTypeFromTypeNode(type).getProperties()) {
+        const propType = checker.getNonNullableType(checker.getTypeOfSymbolAtLocation(property, type));
+        const parameter = propType.getCallSignatures()[0]?.getParameters()[0];
+        const propsText = parameter
+            ? checker.typeToString(checker.getTypeOfSymbolAtLocation(parameter, type))
+            : undefined;
+        info.slots.push({
+            name: property.name,
+            ...(propsText && propsText !== "{}" ? { propsText } : {}),
+            node: property.valueDeclaration ?? type
+        });
+    }
+}
+//# sourceMappingURL=declared.js.map

package/dist/compiler-vue/emit.js

@@ -0,0 +1,129 @@
+import { ComponentFacts, excerpt } from "../compiler-core/index.js";
+export const CAPABILITIES = [
+    "name",
+    "implementations.*",
+    "props.*",
+    "events.*",
+    "slots.*",
+    "variants.*",
+    "accessibility.*",
+    "styling.*",
+    "composition.*"
+];
+/** Writes one component with the neutral fact paths shared with the other framework adapters. */
+export function emitComponent(builder, c, pkg) {
+    const ref = builder.entity(c.ref, "component", c.localName);
+    const facts = new ComponentFacts(builder, ref, "vue");
+    const at = (node, method = "compiler-api") => {
+        const location = c.locate(node);
+        return builder.evidence({
+            sourceRef: `${location.file}#${c.localName}`,
+            location: { type: "file", path: location.file, line: location.line },
+            method,
+            original: excerpt(node)
+        });
+    };
+    const block = (line, method = "ast", original) => builder.evidence({
+        sourceRef: `${c.file}#${c.localName}`,
+        location: { type: "file", path: c.file, line },
+        method,
+        ...(original ? { original } : {})
+    });
+    const decl = block(c.line);
+    facts.put("name", c.localName, decl);
+    facts.link(c.file, c.localName, decl);
+    if (pkg.name)
+        facts.put("implementations.vue.packageName", pkg.name, decl);
+    const primary = [...c.exports].sort((a, b) => (a.subpath === "." ? 0 : 1) - (b.subpath === "." ? 0 : 1) ||
+        (a.name === "default" ? 1 : 0) - (b.name === "default" ? 1 : 0) ||
+        (a.name < b.name ? -1 : 1))[0];
+    if (primary) {
+        facts.put("implementations.vue.exportName", primary.name, decl);
+        if (pkg.name)
+            facts.put("implementations.vue.importPath", primary.subpath === "." ? pkg.name : `${pkg.name}/${primary.subpath.replace(/^\.\//, "")}`, decl);
+    }
+    facts.ext("kind", c.kind, decl);
+    facts.ext("exports", c.exports, decl);
+    facts.ext("propsComplete", c.propsComplete, decl);
+    if (c.sfc) {
+        const d = c.sfc.descriptor;
+        facts.ext("scriptSetup", d.scriptSetup !== null, decl);
+        facts.ext("optionsApi", c.script.optionsApi, decl);
+        const lang = d.scriptSetup?.lang ?? d.script?.lang;
+        if (lang)
+            facts.ext("scriptLang", lang, decl);
+        if (d.template?.lang)
+            facts.ext("templateLang", d.template.lang, decl);
+    }
+    if (c.generic)
+        facts.ext("generic", c.generic, decl);
+    if (c.script.inheritsFrom.length > 0)
+        facts.ext("inheritedPropsFrom", [...new Set(c.script.inheritsFrom)].sort(), decl);
+    if (c.script.exposed.length > 0)
+        facts.ext("exposed", c.script.exposed, decl);
+    if (c.script.options.name)
+        facts.ext("options.name", c.script.options.name, decl);
+    if (c.script.options.inheritAttrs !== undefined)
+        facts.ext("options.inheritAttrs", c.script.options.inheritAttrs, decl);
+    const dynamicSlots = (c.template?.slots ?? []).filter((s) => s.dynamic).length;
+    if (dynamicSlots > 0)
+        facts.ext("dynamicSlots", dynamicSlots, decl);
+    for (const p of [...c.script.props].sort((a, b) => (a.name < b.name ? -1 : 1))) {
+        const evidence = at(p.node, p.source === "type" ? "compiler-api" : "ast");
+        facts.prop({
+            name: p.name,
+            typeText: p.typeText,
+            kind: p.kind,
+            required: p.required,
+            ...(p.default !== undefined ? { default: p.default } : {}),
+            ...(p.defaultExpression !== undefined ? { defaultExpression: p.defaultExpression } : {}),
+            ...(p.allowedValues ? { allowedValues: p.allowedValues } : {}),
+            ...(p.description ? { description: p.description } : {}),
+            ...(p.deprecated ? { deprecated: p.deprecated } : {}),
+            extensions: { kind: p.source === "model" ? "model" : "prop", source: p.source }
+        }, evidence);
+    }
+    for (const e of [...c.script.emits].sort((a, b) => (a.name < b.name ? -1 : 1))) {
+        facts.event({
+            name: e.name,
+            ...(e.payloadText ? { payloadText: e.payloadText } : {}),
+            extensions: { kind: e.source === "model" ? "model" : "emit", source: e.source, emit: e.name }
+        }, at(e.node, e.source === "type" ? "compiler-api" : "ast"));
+    }
+    for (const s of c.slots) {
+        const evidence = s.node ? at(s.node) : block(s.line ?? c.templateLine ?? c.line);
+        facts.slot({
+            name: s.name,
+            extensions: {
+                source: s.sources.length === 2 ? "both" : s.sources[0],
+                ...(s.propsText ? { props: s.propsText } : {}),
+                ...(s.templateProps.length > 0 ? { propNames: s.templateProps } : {})
+            }
+        }, evidence);
+    }
+    for (const v of c.variants) {
+        const prop = c.script.props.find((p) => p.name === v.name);
+        facts.variant({ ...v, extensions: { source: "prop-union" } }, prop ? at(prop.node) : decl);
+    }
+    const a11y = c.template?.accessibility;
+    if (a11y && (a11y.roles.length > 0 || a11y.attributes.length > 0)) {
+        const evidence = block(c.templateLine ?? c.line);
+        facts.accessibility({ ...(a11y.roles.length === 1 ? { role: a11y.roles[0] } : {}), attributes: a11y.attributes }, evidence);
+    }
+    const s = c.styling;
+    if (s.blocks > 0) {
+        const evidence = block(c.line);
+        if (s.variables.length > 0) {
+            const refs = s.variables.map((v) => block(v.line, "structured-parse", `var(${v.name})`));
+            facts.put("styling.cssVariables", s.variables.map((v) => v.name), refs);
+        }
+        facts.put("styling.scoped", s.scoped, evidence);
+        if (s.module)
+            facts.put("styling.cssModules", [c.file], evidence);
+        if (s.preprocessors.length > 0)
+            facts.put("styling.preprocessors", s.preprocessors, evidence);
+    }
+    if (c.renders.length > 0)
+        facts.put("composition.renders", c.renders, block(c.templateLine ?? c.line));
+}
+//# sourceMappingURL=emit.js.map

package/dist/compiler-vue/index.js

@@ -0,0 +1,5 @@
+export { ADAPTER_ID, ADAPTER_VERSION, vueAdapter } from "./adapter.js";
+export { analyzeScript } from "./script.js";
+export { parseSfc, sfcLocalName } from "./sfc.js";
+export { analyzeTemplate } from "./template.js";
+//# sourceMappingURL=index.js.map