@luna-park/plugin 1.2.0 → 1.2.1

package/dist/extractor.js

@@ -1,577 +1,512 @@
-import M from "node:fs";
-import { i as m, o as F, F as d, u as x, a as I, m as U } from "./index-Dv9uuje9.js";
-import * as y from "typescript";
-import p from "typescript";
-import * as j from "path";
-import * as J from "fs";
-function S(t, e = {}) {
-  if (typeof t != "object" || t === null)
-    return JSON.stringify(t);
-  const o = {};
-  for (const n of ["default", "description", "name", "target", "promise", "optional", "example", "enum"])
-    t[n] && (o[n] = t[n]);
-  if (t.type === m.array)
-    return b(`LogicType.${t.type}`, [
-      S(t.items, e),
-      h(o)
-    ]);
-  if (t.type === m.interface)
-    return b(`LogicType.${t.type}`, [
-      JSON.stringify(t.className),
-      h(o)
-    ]);
-  if (t.type === m.union)
-    return b(`LogicType.${t.type}`, [
-      `[${t.elements.map((n) => S(n, e)).join(", ")}]`,
-      h(o)
-    ]);
-  if (t.type === m.function)
-    return b(`LogicType.${t.type}`, [
-      S(t.inputs, e),
-      S(t.output, e),
-      h(o)
-    ]);
-  if (t.type === m.object)
-    return b(`LogicType.${t.type}`, [
-      h(
-        F(
-          t.properties,
-          ({ value: n }) => S(n, e)
-        ),
-        !0
-      ),
-      h(o)
-    ]);
-  if (t.type === m.type) {
-    const n = t.target.at(-1), i = h(o);
-    return i !== "{}" ? n : `{ ...${n}, ${i.slice(1, -1)} }`;
-  }
-  return b(`LogicType.${t.type}`, [h(o)]);
+import { c as typeToSchema, d as objectMap, i as LogicType, l as cleanObject, r as EVarType, s as schemaLoop } from "./dist-BUZt4gnZ.js";
+import fs from "node:fs";
+import * as ts$1 from "typescript";
+import ts from "typescript";
+import * as path from "path";
+import * as fs$1 from "fs";
+function generateCode(c, k = {}) {
+	if (typeof c != "object" || !c) return JSON.stringify(c);
+	let A = {};
+	for (let O of [
+		"default",
+		"description",
+		"name",
+		"target",
+		"promise",
+		"optional",
+		"example",
+		"enum"
+	]) c[O] && (A[O] = c[O]);
+	if (c.type === EVarType.array) return buildFunctionCall(`LogicType.${c.type}`, [generateCode(c.items, k), getCodeFromObject(A)]);
+	if (c.type === EVarType.interface) return buildFunctionCall(`LogicType.${c.type}`, [JSON.stringify(c.className), getCodeFromObject(A)]);
+	if (c.type === EVarType.union) return buildFunctionCall(`LogicType.${c.type}`, [`[${c.elements.map((c) => generateCode(c, k)).join(", ")}]`, getCodeFromObject(A)]);
+	if (c.type === EVarType.function) return buildFunctionCall(`LogicType.${c.type}`, [
+		generateCode(c.inputs, k),
+		generateCode(c.output, k),
+		getCodeFromObject(A)
+	]);
+	if (c.type === EVarType.object) return buildFunctionCall(`LogicType.${c.type}`, [getCodeFromObject(objectMap(c.properties, ({ value: c }) => generateCode(c, k)), !0), getCodeFromObject(A)]);
+	if (c.type === EVarType.type) {
+		let O = c.target.at(-1), k = getCodeFromObject(A);
+		return k === "{}" ? `{ ...${O}, ${k.slice(1, -1)} }` : O;
+	}
+	return buildFunctionCall(`LogicType.${c.type}`, [getCodeFromObject(A)]);
 }
-function b(t, e) {
-  const o = e.findLastIndex((n) => n !== "{}");
-  return `${t}(${e.slice(0, o + 1).join(", ")})`;
+function buildFunctionCall(c, O) {
+	let k = O.findLastIndex((c) => c !== "{}");
+	return `${c}(${O.slice(0, k + 1).join(", ")})`;
 }
-function h(t, e) {
-  return `{${Object.entries(t).map(([o, n]) => `${_(o)}: ${e ? n : JSON.stringify(n)}`).join(", ")}}`;
+function getCodeFromObject(c, O) {
+	return `{${Object.entries(c).map(([c, k]) => `${getSafeKey(c)}: ${O ? k : JSON.stringify(k)}`).join(", ")}}`;
 }
-function _(t) {
-  return /^[a-zA-Z]+$/.test(t) ? t : JSON.stringify(t);
+function getSafeKey(c) {
+	return /^[a-zA-Z]+$/.test(c) ? c : JSON.stringify(c);
 }
-function V(t, e) {
-  const o = [], n = t.components.default;
-  Object.keys(t.types);
-  for (const r of ["properties", "slots", "models", "emits"])
-    n[r] && Object.keys(n[r]).length && o.push({
-      key: r,
-      value: Object.entries(n[r]).map(([l, s]) => `${_(l)}: ${S(s, {})}`).join(`,
-        `)
-    });
-  const i = Object.entries(t.types).map(([r, l]) => `const ${r} = ${S(l, {})};`).join(`
+function getComponentCode(c, O) {
+	let k = [], A = c.components.default, j = Object.keys(c.types);
+	for (let c of [
+		"properties",
+		"slots",
+		"models",
+		"emits"
+	]) A[c] && Object.keys(A[c]).length && k.push({
+		key: c,
+		value: Object.entries(A[c]).map(([c, O]) => `${getSafeKey(c)}: ${generateCode(O, { lib: j })}`).join(",\n        ")
+	});
+	let M = Object.entries(c.types).map(([c, O]) => `const ${c} = ${generateCode(O, { lib: j })};`).join("\n\n");
+	return `import { LogicType, type TComponent } from "@luna-park/plugin";
+import ${O.name} from "${O.path}";
 
-`);
-  return `import { LogicType, type TComponent } from "@luna-park/plugin";
-import ${e.name} from "${e.path}";
+${M}
 
-${i}
-
-export const ${e.name.toLocaleLowerCase()}: TComponent = {
-    name: "${e.name}",
-    component: ${e.name},
-    ${o.map(({ key: r, value: l }) => `${r}: {
-        ${l}
-    }`).join(`,
-    `)}
+export const ${O.name.toLocaleLowerCase()}: TComponent = {
+    name: "${O.name}",
+    component: ${O.name},
+    ${k.map(({ key: c, value: O }) => `${c}: {\n        ${O}\n    }`).join(",\n    ")}
 }`;
 }
-function T(t, e) {
-  const o = {
-    description: C(t.getDocumentationComment(e)) || void 0
-  };
-  for (const n of t.getJsDocTags()) {
-    if (n.name === "param") {
-      o.params || (o.params = {});
-      let i = C(n.text?.slice(1)).trim();
-      i.startsWith("- ") && (i = i.slice(2));
-      const r = n.text[0]?.text;
-      o.params[r] = i;
-      continue;
-    }
-    o[n.name] = C(n.text);
-  }
-  return d(o);
-}
-function C(t = []) {
-  return t.map((e) => e.text).join("");
+function getDocumentationFromSymbol(c, O) {
+	let k = { description: mergeSymbolDisplayParts(c.getDocumentationComment(O)) || void 0 };
+	for (let O of c.getJsDocTags()) {
+		if (O.name === "param") {
+			k.params ||= {};
+			let c = mergeSymbolDisplayParts(O.text?.slice(1)).trim();
+			c.startsWith("- ") && (c = c.slice(2));
+			let A = O.text[0]?.text;
+			k.params[A] = c;
+			continue;
+		}
+		k[O.name] = mergeSymbolDisplayParts(O.text);
+	}
+	return cleanObject(k);
 }
-function v(t, e) {
-  const o = e.checker.getPropertiesOfType(t), n = {};
-  return o.forEach((i) => {
-    const r = z(e.checker.getTypeOfSymbol(i)).type, s = e.checker.getSignaturesOfType(r, y.SignatureKind.Call)[0]?.parameters?.[0];
-    if (s) {
-      const c = e.checker.getTypeOfSymbol(s);
-      n[i.name] = {
-        type: e.typeToString(c)
-      }, e.extractType(c);
-    } else
-      n[i.name] = {
-        type: "{}"
-      };
-  }), n;
+function mergeSymbolDisplayParts(c = []) {
+	return c.map((c) => c.text).join("");
 }
-function L(t, e) {
-  const o = e.checker.getPropertiesOfType(t), n = {}, i = {};
-  return o.forEach((r) => {
-    if (["onVnode", "ref_"].some((s) => r.name.startsWith(s)) || ["ref", "class", "style", "key"].includes(r.name))
-      return;
-    const l = e.checker.getTypeOfSymbol(r);
-    if (e.extractType(l), W(r.name)) {
-      i[H(r.name)] = A(l, r, e);
-      return;
-    }
-    n[r.name] = A(l, r, e);
-  }), { emits: i, props: n };
+function getSlots(c, O) {
+	let k = O.checker.getPropertiesOfType(c), A = {};
+	return k.forEach((c) => {
+		let k = getDefinedType(O.checker.getTypeOfSymbol(c)).type, j = O.checker.getSignaturesOfType(k, ts$1.SignatureKind.Call)[0]?.parameters?.[0];
+		if (j) {
+			let k = O.checker.getTypeOfSymbol(j);
+			A[c.name] = { type: O.typeToString(k) }, O.extractType(k);
+		} else A[c.name] = { type: "{}" };
+	}), A;
 }
-function E(t) {
-  return t.models = Object.keys(t.properties ?? {}).reduce((e, o) => (t.emits?.[`update:${o}`] && (e[o] = t.properties[o], delete t.properties[o], delete t.emits[`update:${o}`]), e), {}), t;
+function getProps(c, O) {
+	let k = O.checker.getPropertiesOfType(c), A = {}, j = {};
+	return k.forEach((c) => {
+		if (["onVnode", "ref_"].some((O) => c.name.startsWith(O)) || [
+			"ref",
+			"class",
+			"style",
+			"key"
+		].includes(c.name)) return;
+		let k = O.checker.getTypeOfSymbol(c);
+		if (O.extractType(k), isEmits(c.name)) {
+			j[emitName(c.name)] = getExportType(k, c, O);
+			return;
+		}
+		A[c.name] = getExportType(k, c, O);
+	}), {
+		emits: j,
+		props: A
+	};
 }
-function z(t) {
-  if (t.isUnion()) {
-    const e = t.types.filter((o) => o.flags !== y.TypeFlags.Undefined);
-    if (e.length === 1)
-      return { optional: !0, type: e[0] };
-  }
-  return { type: t };
+function computeModels(c) {
+	return c.models = Object.keys(c.properties ?? {}).reduce((O, k) => (c.emits?.[`update:${k}`] && (O[k] = c.properties[k], delete c.properties[k], delete c.emits[`update:${k}`]), O), {}), c;
 }
-function A(t, e, o) {
-  const n = z(t);
-  return d({
-    description: T(e, o.checker).description,
-    optional: n.optional,
-    type: o.typeToString(n.type)
-  });
+function getDefinedType(c) {
+	if (c.isUnion()) {
+		let O = c.types.filter((c) => c.flags !== ts$1.TypeFlags.Undefined);
+		if (O.length === 1) return {
+			optional: !0,
+			type: O[0]
+		};
+	}
+	return { type: c };
 }
-function W(t) {
-  return /^on[A-Z]/.test(t);
+function getExportType(c, O, k) {
+	let j = getDefinedType(c);
+	return cleanObject({
+		description: getDocumentationFromSymbol(O, k.checker).description,
+		optional: j.optional,
+		type: k.typeToString(j.type)
+	});
 }
-function H(t) {
-  return t = t.slice(2), t.charAt(0).toLowerCase() + t.slice(1);
+function isEmits(c) {
+	return /^on[A-Z]/.test(c);
 }
-function K(t, e) {
-  return Object.fromEntries((t.getTypeParameters() ?? []).map((o) => {
-    let n = "unknown";
-    const i = o.getDefault();
-    i && (n = e.typeToString(i));
-    const r = o.getConstraint();
-    return r && (n = e.typeToString(r)), [o.symbol.name, n];
-  }));
+function emitName(c) {
+	return c = c.slice(2), c.charAt(0).toLowerCase() + c.slice(1);
 }
-function Q(t, e) {
-  const o = /* @__PURE__ */ new Map(), n = t.getExportsOfModule(e);
-  for (const i of n) {
-    let r = i;
-    for (; r.flags & y.SymbolFlags.Alias; )
-      r = t.getAliasedSymbol(r);
-    o.set(i.name, r);
-  }
-  return o;
+function getTemplateTypeParameters(c, O) {
+	return Object.fromEntries((c.getTypeParameters() ?? []).map((c) => {
+		let k = "unknown", A = c.getDefault();
+		A && (k = O.typeToString(A));
+		let j = c.getConstraint();
+		return j && (k = O.typeToString(j)), [c.symbol.name, k];
+	}));
 }
-function $(t, e) {
-  let o = t.getFullyQualifiedName(e);
-  return o.includes('".') && (o = o.split('".').pop()), o.includes(").") && (o = o.split(").").pop()), o;
+function getResolvedExports(c, O) {
+	let k = /* @__PURE__ */ new Map(), A = c.getExportsOfModule(O);
+	for (let O of A) {
+		let A = O;
+		for (; A.flags & ts$1.SymbolFlags.Alias;) A = c.getAliasedSymbol(A);
+		k.set(O.name, A);
+	}
+	return k;
 }
-function O(t, e) {
-  for (const [o, n] of Object.entries(e))
-    t = t.replace(new RegExp(`\\b${o}\\b`, "g"), n);
-  return t;
+function getFullName(c, O) {
+	let k = c.getFullyQualifiedName(O);
+	return k.includes("\".") && (k = k.split("\".").pop()), k.includes(").") && (k = k.split(").").pop()), k;
 }
-function R(t) {
-  const e = [];
-  return t.members.forEach((n) => {
-    const i = n.name.getText();
-    if (n.initializer) {
-      let r;
-      y.isStringLiteral(n.initializer) ? r = `"${n.initializer.text}"` : y.isNumericLiteral(n.initializer) ? r = n.initializer.text : r = n.initializer.getText(), e.push(`${i} = ${r}`);
-    } else
-      e.push(i);
-  }), `{ ${e.join(", ")} }`;
+function swapType(c, O) {
+	for (let [k, A] of Object.entries(O)) c = c.replace(RegExp(`\\b${k}\\b`, "g"), A);
+	return c;
 }
-function w(t) {
-  if (t.getFlags() & (p.TypeFlags.StringLike | p.TypeFlags.NumberLike | p.TypeFlags.BooleanLike | p.TypeFlags.ESSymbolLike | p.TypeFlags.Void | p.TypeFlags.Undefined | p.TypeFlags.Null | p.TypeFlags.Any | p.TypeFlags.Unknown | p.TypeFlags.Never))
-    return !1;
-  const o = t.getSymbol();
-  if (!o)
-    return !0;
-  const n = o.declarations?.[0];
-  if (!n)
-    return !0;
-  const i = n.getSourceFile();
-  return !(/lib\..*\.d\.ts$/.test(i.fileName) || i.fileName.startsWith("/@vue/"));
+function extractEnumDefinition(c) {
+	let O = [];
+	return c.members.forEach((c) => {
+		let k = c.name.getText();
+		if (c.initializer) {
+			let A;
+			A = ts$1.isStringLiteral(c.initializer) ? `"${c.initializer.text}"` : ts$1.isNumericLiteral(c.initializer) ? c.initializer.text : c.initializer.getText(), O.push(`${k} = ${A}`);
+		} else O.push(k);
+	}), `{ ${O.join(", ")} }`;
 }
-const D = p.TypeFormatFlags.WriteArrowStyleSignature | p.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | p.TypeFormatFlags.NoTruncation | p.TypeFormatFlags.UseFullyQualifiedType;
-class q {
-  constructor(e) {
-    this.program = e, this.checker = e.getTypeChecker();
-  }
-  checker;
-  index;
-  cache = /* @__PURE__ */ new Set();
-  result;
-  get(e) {
-    if (this.index = this.program.getSourceFile(e), !this.index)
-      throw new Error(`Cannot find file ${e}`);
-    const o = this.checker.getSymbolAtLocation(this.index);
-    if (!o)
-      throw new Error(`Cannot find module ${e}`);
-    this.result = {
-      components: {},
-      functions: {},
-      types: {}
-    };
-    const n = this.index.statements.find((i) => p.isExportAssignment(i));
-    if (n) {
-      const r = this.checker.getTypeAtLocation(n.expression).getCallSignatures()[0];
-      r && this.exportFunction("default", r);
-    }
-    return this.exportModule(o), this.result;
-  }
-  exportModule(e) {
-    const o = Q(this.checker, e);
-    for (const [n, i] of o.entries()) {
-      let r = this.checker.getTypeOfSymbol(i);
-      if (r.symbol && r.symbol.flags & p.SymbolFlags.Module) {
-        const s = r.symbol.exports?.get("default");
-        s && (r = this.checker.getTypeOfSymbol(s));
-      }
-      const l = r.symbol || r.aliasSymbol;
-      if (l?.flags & p.SymbolFlags.Function) {
-        const s = this.checker.getTypeOfSymbol(l), c = this.checker.getSignaturesOfType(s, p.SignatureKind.Call)[0];
-        if (c) {
-          const a = $(this.checker, l);
-          this.exportFunction(a, c);
-        }
-      } else if (this.typeToString(r).includes("DefineComponent<"))
-        try {
-          this.exportComponent(n, r);
-        } catch (c) {
-          console.error(`Fail to export component ${n}`), console.error(c);
-        }
-    }
-  }
-  exportComponent(e, o) {
-    const n = o.getConstructSignatures()[0];
-    if (!n)
-      return;
-    const i = this.checker.getReturnTypeOfSignature(n), r = {}, l = this.checker.getPropertyOfType(i, "$props");
-    if (l) {
-      const c = this.checker.getTypeOfSymbol(l), a = L(c, this);
-      r.properties = a.props, r.emits = a.emits;
-    }
-    const s = this.checker.getPropertyOfType(i, "$slots");
-    if (s) {
-      const c = this.checker.getTypeOfSymbol(s);
-      r.slots = v(c, this);
-    }
-    this.result.components[e] = E(r);
-  }
-  exportFunction(e, o) {
-    const n = T(o, this.checker), i = K(o, this), r = o.getParameters().map((s) => {
-      const c = s.valueDeclaration ?? this.index, a = this.checker.getTypeOfSymbol(s);
-      this.extractType(a, c);
-      const f = s.valueDeclaration?.initializer?.getText();
-      return d({
-        default: f,
-        description: n.params?.[s.name],
-        name: s.name,
-        optional: !!c.questionToken || f !== void 0 || void 0,
-        type: O(this.typeToString(a), i)
-      });
-    });
-    if (r.some((s) => s.name?.startsWith("__VLS_"))) {
-      const s = {}, c = r.findIndex((u) => u.name === "__VLS_props"), a = o.getParameters()[c];
-      if (a) {
-        const u = this.checker.getTypeOfSymbol(a), k = L(u, this);
-        s.properties = k.props, s.emits = k.emits, Object.values(s.properties).forEach((N) => {
-          N.type = O(N.type, i);
-        });
-      }
-      const f = r.findIndex((u) => u.name === "__VLS_slots"), g = o.getParameters()[f];
-      if (g) {
-        const u = this.checker.getTypeOfSymbol(g);
-        s.slots = v(u, this), Object.values(s.slots).forEach((k) => {
-          k.type = O(k.type, i);
-        });
-      }
-      this.result.components[e] = E(s);
-      return;
-    }
-    const l = this.checker.getReturnTypeOfSignature(o);
-    this.extractType(l), this.result.functions[e] = d({
-      description: n.description,
-      parameters: r,
-      return: {
-        description: n.returns,
-        type: O(this.typeToString(l), i)
-      }
-    });
-  }
-  extractType(e, o = this.index) {
-    if (this.cache.has(e))
-      return;
-    this.cache.add(e);
-    const n = e.symbol || e.aliasSymbol;
-    if ((e.isUnion() || e.isIntersection()) && !(n?.flags & p.SymbolFlags.Enum) && e.types.forEach((i) => {
-      this.extractType(i, o);
-    }), n) {
-      if (this.checker.getFullyQualifiedName(n).includes("/@vue/"))
-        return;
-      const i = $(this.checker, n);
-      if (n.flags & p.SymbolFlags.Enum) {
-        const r = n.valueDeclaration || n.declarations?.[0];
-        if (r && p.isEnumDeclaration(r)) {
-          const l = $(this.checker, n);
-          this.result.types[l] = d({
-            ...T(n, this.checker),
-            type: R(r)
-          });
-        }
-        return;
-      }
-      if (n.flags & p.SymbolFlags.Namespace) {
-        const r = n;
-        this.exportModule(r);
-      }
-      if (n.flags & p.SymbolFlags.TypeAlias) {
-        const r = n.valueDeclaration || n.declarations?.[0];
-        if (!r)
-          return;
-        const l = Object.fromEntries((r?.typeParameters ?? []).map((s) => {
-          let c = "unknown";
-          const a = s.default;
-          if (a) {
-            const g = this.checker.getTypeFromTypeNode(a);
-            c = this.typeToString(g);
-          }
-          const f = s.constraint;
-          if (f) {
-            const g = this.checker.getTypeFromTypeNode(f);
-            c = this.typeToString(g);
-          }
-          return [s.symbol.name, c];
-        }));
-        this.result.types[i] = {
-          ...T(n, this.checker),
-          type: O(this.typeToString(e, D | p.TypeFormatFlags.InTypeAlias), l)
-        };
-      }
-      if (n.flags & p.SymbolFlags.Interface && w(e)) {
-        const r = n.getDeclarations()[0];
-        if (r) {
-          const l = this.checker.getPropertiesOfType(e), s = {};
-          l.forEach((c) => {
-            const a = this.checker.getTypeOfSymbol(c);
-            this.extractType(a, r), s[c.name] = {
-              ...T(c, this.checker),
-              optional: !!(c.flags & p.SymbolFlags.Optional) || void 0,
-              type: this.typeToString(a)
-            };
-          }), this.result.types[i] = {
-            ...T(n, this.checker),
-            type: s
-          };
-        }
-      }
-      if (n.flags & p.SymbolFlags.TypeLiteral) {
-        const r = $(this.checker, e.aliasSymbol || e.symbol), l = this.checker.getPropertiesOfType(e), s = {};
-        if (["Promise", "Partial", "Pick", "Omit", "Required"].includes(r)) {
-          this.cache.delete(e), this.extractType(e.aliasTypeArguments[0]);
-          return;
-        }
-        if (e.aliasTypeArguments?.some((c) => !w(c)))
-          return;
-        l.forEach((c) => {
-          const a = this.checker.getTypeOfSymbol(c);
-          s[c.name] = {
-            ...T(c, this.checker),
-            optional: !!(c.flags & p.SymbolFlags.Optional),
-            type: this.typeToString(a)
-          };
-        }), r !== "__type" && (this.result.types[r] = {
-          ...T(n, this.checker),
-          type: s
-        });
-      }
-    }
-    if (e.flags & p.TypeFlags.Object) {
-      const i = e;
-      if (w(e) && this.checker.getPropertiesOfType(e).forEach((l) => {
-        const s = this.checker.getTypeOfSymbol(l);
-        this.extractType(s, o);
-      }), i.objectFlags & p.ObjectFlags.Reference) {
-        const r = i;
-        this.checker.getTypeArguments(r).forEach((s) => {
-          this.extractType(s, o);
-        });
-      }
-    }
-  }
-  typeToString(e, o = D) {
-    return this.checker.typeToString(e, void 0, o);
-  }
+function isUserType(c) {
+	if (c.getFlags() & (ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike | ts.TypeFlags.BooleanLike | ts.TypeFlags.ESSymbolLike | ts.TypeFlags.Void | ts.TypeFlags.Undefined | ts.TypeFlags.Null | ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never)) return !1;
+	let O = c.getSymbol();
+	if (!O) return !0;
+	let k = O.declarations?.[0];
+	if (!k) return !0;
+	let A = k.getSourceFile();
+	return !(/lib\..*\.d\.ts$/.test(A.fileName) || A.fileName.startsWith("/@vue/"));
 }
-function Z(t, e = "unknown") {
-  const o = {
-    components: {},
-    functions: {},
-    types: {}
-  };
-  for (const [s, c] of Object.entries(t.types))
-    o.types[s] = n(c, s);
-  for (const [s, c] of Object.entries(t.functions))
-    o.functions[s] = i(c, s);
-  for (const [s, c] of Object.entries(t.components))
-    o.components[s] = r(c, s);
-  return o;
-  function n(s, c = "") {
-    if (typeof s.type == "string") {
-      if (s.type === "{}")
-        return x.void();
-      const a = {
-        ...l(I(s.type)),
-        ...d({
-          description: s.description,
-          name: c?.split(".").pop() || void 0,
-          optional: s.optional
-        })
-      };
-      if (s.default)
-        switch (a.type) {
-          case m.boolean:
-            a.default = s.default === "true";
-            break;
-          case m.number:
-            a.default = Number(s.default);
-            break;
-          case m.string:
-            a.default = s.default;
-            break;
-        }
-      return a.type === m.object && !Object.keys(a.properties).length && (a.customizable = !0), a;
-    } else {
-      const a = x.object(
-        F(
-          s.type,
-          ({ key: f, value: g }) => n(g, f)
-        ),
-        d({
-          description: s.description,
-          name: c?.split(".").pop(),
-          optional: s.optional
-        })
-      );
-      return Object.keys(a.properties).length || (a.customizable = !0), a;
-    }
-  }
-  function i(s, c = "") {
-    return {
-      ...d({
-        description: s.description,
-        name: c?.split(".").pop()
-      }),
-      parameters: (s.parameters ?? []).map((a) => n(a, a.name)),
-      return: n(s.return, "result")
-    };
-  }
-  function r(s, c = "") {
-    return {
-      ...d({
-        name: c?.split(".").pop()
-      }),
-      emits: F(s.emits, ({ value: a }) => n(a)),
-      models: F(s.models, ({ value: a }) => n(a)),
-      properties: F(s.properties, ({ key: a, value: f }) => n(f, a)),
-      slots: F(s.slots, ({ value: a }) => n(a))
-    };
-  }
-  function l(s, c = "") {
-    return U(s, (f) => {
-      if (f.type === m.interface)
-        return {
-          ...a(f.className, c),
-          description: f.description,
-          name: f.name,
-          optional: f.optional
-        };
-    });
-    function a(f, g = "") {
-      let u = `${g}${f}`;
-      for (; !t.types[u] && u.indexOf(".") !== -1; )
-        u = u.substring(u.indexOf(".") + 1);
-      return t.types[u] ? x.type([
-        "packages",
-        e,
-        ...u.split(".")
-      ]) : x.interface(f);
-    }
-  }
+var FLAGS = ts.TypeFormatFlags.WriteArrowStyleSignature | ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseFullyQualifiedType, CTypeExport = class {
+	checker;
+	index;
+	cache = /* @__PURE__ */ new Set();
+	result;
+	constructor(c) {
+		this.program = c, this.checker = c.getTypeChecker();
+	}
+	get(c) {
+		if (this.index = this.program.getSourceFile(c), !this.index) throw Error(`Cannot find file ${c}`);
+		let O = this.checker.getSymbolAtLocation(this.index);
+		if (!O) throw Error(`Cannot find module ${c}`);
+		this.result = {
+			components: {},
+			functions: {},
+			types: {}
+		};
+		let k = this.index.statements.find((c) => ts.isExportAssignment(c));
+		if (k) {
+			let c = this.checker.getTypeAtLocation(k.expression).getCallSignatures()[0];
+			c && this.exportFunction("default", c);
+		}
+		return this.exportModule(O), this.result;
+	}
+	exportModule(c) {
+		let O = getResolvedExports(this.checker, c);
+		for (let [c, k] of O.entries()) {
+			let O = this.checker.getTypeOfSymbol(k);
+			if (O.symbol && O.symbol.flags & ts.SymbolFlags.Module) {
+				let c = O.symbol.exports?.get("default");
+				c && (O = this.checker.getTypeOfSymbol(c));
+			}
+			let A = O.symbol || O.aliasSymbol;
+			if (A?.flags & ts.SymbolFlags.Function) {
+				let c = this.checker.getTypeOfSymbol(A), O = this.checker.getSignaturesOfType(c, ts.SignatureKind.Call)[0];
+				if (O) {
+					let c = getFullName(this.checker, A);
+					this.exportFunction(c, O);
+				}
+			} else if (this.typeToString(O).includes("DefineComponent<")) try {
+				this.exportComponent(c, O);
+			} catch (O) {
+				console.error(`Fail to export component ${c}`), console.error(O);
+			}
+		}
+	}
+	exportComponent(c, O) {
+		let k = O.getConstructSignatures()[0];
+		if (!k) return;
+		let A = this.checker.getReturnTypeOfSignature(k), j = {}, M = this.checker.getPropertyOfType(A, "$props");
+		if (M) {
+			let c = getProps(this.checker.getTypeOfSymbol(M), this);
+			j.properties = c.props, j.emits = c.emits;
+		}
+		let N = this.checker.getPropertyOfType(A, "$slots");
+		N && (j.slots = getSlots(this.checker.getTypeOfSymbol(N), this)), this.result.components[c] = computeModels(j);
+	}
+	exportFunction(c, O) {
+		let k = getDocumentationFromSymbol(O, this.checker), j = getTemplateTypeParameters(O, this), M = O.getParameters().map((c) => {
+			let O = c.valueDeclaration ?? this.index, M = this.checker.getTypeOfSymbol(c);
+			this.extractType(M, O);
+			let N = c.valueDeclaration?.initializer?.getText();
+			return cleanObject({
+				default: N,
+				description: k.params?.[c.name],
+				name: c.name,
+				optional: !!O.questionToken || N !== void 0 || void 0,
+				type: swapType(this.typeToString(M), j)
+			});
+		});
+		if (M.some((c) => c.name?.startsWith("__VLS_"))) {
+			let k = {}, A = M.findIndex((c) => c.name === "__VLS_props"), N = O.getParameters()[A];
+			if (N) {
+				let c = getProps(this.checker.getTypeOfSymbol(N), this);
+				k.properties = c.props, k.emits = c.emits, Object.values(k.properties).forEach((c) => {
+					c.type = swapType(c.type, j);
+				});
+			}
+			let P = M.findIndex((c) => c.name === "__VLS_slots"), F = O.getParameters()[P];
+			F && (k.slots = getSlots(this.checker.getTypeOfSymbol(F), this), Object.values(k.slots).forEach((c) => {
+				c.type = swapType(c.type, j);
+			})), this.result.components[c] = computeModels(k);
+			return;
+		}
+		let N = this.checker.getReturnTypeOfSignature(O);
+		this.extractType(N), this.result.functions[c] = cleanObject({
+			description: k.description,
+			parameters: M,
+			return: {
+				description: k.returns,
+				type: swapType(this.typeToString(N), j)
+			}
+		});
+	}
+	extractType(c, O = this.index) {
+		if (this.cache.has(c)) return;
+		this.cache.add(c);
+		let k = c.symbol || c.aliasSymbol;
+		if ((c.isUnion() || c.isIntersection()) && !(k?.flags & ts.SymbolFlags.Enum) && c.types.forEach((c) => {
+			this.extractType(c, O);
+		}), k) {
+			if (this.checker.getFullyQualifiedName(k).includes("/@vue/")) return;
+			let O = getFullName(this.checker, k);
+			if (k.flags & ts.SymbolFlags.Enum) {
+				let c = k.valueDeclaration || k.declarations?.[0];
+				if (c && ts.isEnumDeclaration(c)) {
+					let O = getFullName(this.checker, k);
+					this.result.types[O] = cleanObject({
+						...getDocumentationFromSymbol(k, this.checker),
+						type: extractEnumDefinition(c)
+					});
+				}
+				return;
+			}
+			if (k.flags & ts.SymbolFlags.Namespace) {
+				let c = k;
+				this.exportModule(c);
+			}
+			if (k.flags & ts.SymbolFlags.TypeAlias) {
+				let A = k.valueDeclaration || k.declarations?.[0];
+				if (!A) return;
+				let j = Object.fromEntries((A?.typeParameters ?? []).map((c) => {
+					let O = "unknown", k = c.default;
+					if (k) {
+						let c = this.checker.getTypeFromTypeNode(k);
+						O = this.typeToString(c);
+					}
+					let A = c.constraint;
+					if (A) {
+						let c = this.checker.getTypeFromTypeNode(A);
+						O = this.typeToString(c);
+					}
+					return [c.symbol.name, O];
+				}));
+				this.result.types[O] = {
+					...getDocumentationFromSymbol(k, this.checker),
+					type: swapType(this.typeToString(c, FLAGS | ts.TypeFormatFlags.InTypeAlias), j)
+				};
+			}
+			if (k.flags & ts.SymbolFlags.Interface && isUserType(c)) {
+				let A = k.getDeclarations()[0];
+				if (A) {
+					let j = this.checker.getPropertiesOfType(c), M = {};
+					j.forEach((c) => {
+						let O = this.checker.getTypeOfSymbol(c);
+						this.extractType(O, A), M[c.name] = {
+							...getDocumentationFromSymbol(c, this.checker),
+							optional: !!(c.flags & ts.SymbolFlags.Optional) || void 0,
+							type: this.typeToString(O)
+						};
+					}), this.result.types[O] = {
+						...getDocumentationFromSymbol(k, this.checker),
+						type: M
+					};
+				}
+			}
+			if (k.flags & ts.SymbolFlags.TypeLiteral) {
+				let O = getFullName(this.checker, c.aliasSymbol || c.symbol), A = this.checker.getPropertiesOfType(c), j = {};
+				if ([
+					"Promise",
+					"Partial",
+					"Pick",
+					"Omit",
+					"Required"
+				].includes(O)) {
+					this.cache.delete(c), this.extractType(c.aliasTypeArguments[0]);
+					return;
+				}
+				if (c.aliasTypeArguments?.some((c) => !isUserType(c))) return;
+				A.forEach((c) => {
+					let O = this.checker.getTypeOfSymbol(c);
+					j[c.name] = {
+						...getDocumentationFromSymbol(c, this.checker),
+						optional: !!(c.flags & ts.SymbolFlags.Optional),
+						type: this.typeToString(O)
+					};
+				}), O !== "__type" && (this.result.types[O] = {
+					...getDocumentationFromSymbol(k, this.checker),
+					type: j
+				});
+			}
+		}
+		if (c.flags & ts.TypeFlags.Object) {
+			let k = c;
+			if (isUserType(c) && this.checker.getPropertiesOfType(c).forEach((c) => {
+				let k = this.checker.getTypeOfSymbol(c);
+				this.extractType(k, O);
+			}), k.objectFlags & ts.ObjectFlags.Reference) {
+				let c = k;
+				this.checker.getTypeArguments(c).forEach((c) => {
+					this.extractType(c, O);
+				});
+			}
+		}
+	}
+	typeToString(c, O = FLAGS) {
+		return this.checker.typeToString(c, void 0, O);
+	}
+};
+function generateNodes(N, P = "unknown") {
+	let F = {
+		components: {},
+		functions: {},
+		types: {}
+	};
+	for (let [c, O] of Object.entries(N.types)) F.types[c] = I(O, c);
+	for (let [c, O] of Object.entries(N.functions)) F.functions[c] = L(O, c);
+	for (let [c, O] of Object.entries(N.components)) F.components[c] = R(O, c);
+	return F;
+	function I(M, N = "") {
+		if (typeof M.type == "string") {
+			if (M.type === "{}") return LogicType.void();
+			let O = {
+				...z(typeToSchema(M.type)),
+				...cleanObject({
+					description: M.description,
+					name: N?.split(".").pop() || void 0,
+					optional: M.optional
+				})
+			};
+			if (M.default) switch (O.type) {
+				case EVarType.boolean:
+					O.default = M.default === "true";
+					break;
+				case EVarType.number:
+					O.default = Number(M.default);
+					break;
+				case EVarType.string:
+					O.default = M.default;
+					break;
+			}
+			return O.type === EVarType.object && !Object.keys(O.properties).length && (O.customizable = !0), O;
+		} else {
+			let c = LogicType.object(objectMap(M.type, ({ key: c, value: O }) => I(O, c)), cleanObject({
+				description: M.description,
+				name: N?.split(".").pop(),
+				optional: M.optional
+			}));
+			return Object.keys(c.properties).length || (c.customizable = !0), c;
+		}
+	}
+	function L(c, O = "") {
+		return {
+			...cleanObject({
+				description: c.description,
+				name: O?.split(".").pop()
+			}),
+			parameters: (c.parameters ?? []).map((c) => I(c, c.name)),
+			return: I(c.return, "result")
+		};
+	}
+	function R(c, k = "") {
+		return {
+			...cleanObject({ name: k?.split(".").pop() }),
+			emits: objectMap(c.emits, ({ value: c }) => I(c)),
+			models: objectMap(c.models, ({ value: c }) => I(c)),
+			properties: objectMap(c.properties, ({ key: c, value: O }) => I(O, c)),
+			slots: objectMap(c.slots, ({ value: c }) => I(c))
+		};
+	}
+	function z(c, O = "") {
+		return schemaLoop(c, ({ schema: c }) => {
+			if (c.type === EVarType.interface) return {
+				...A(c.className, O),
+				description: c.description,
+				name: c.name,
+				optional: c.optional
+			};
+		});
+		function A(c, O = "") {
+			let A = `${O}${c}`;
+			for (; !N.types[A] && A.indexOf(".") !== -1;) A = A.substring(A.indexOf(".") + 1);
+			return N.types[A] ? LogicType.type([
+				"packages",
+				P,
+				...A.split(".")
+			]) : LogicType.interface(c);
+		}
+	}
 }
-function B(t) {
-  for (; ; ) {
-    const e = j.join(t, "tsconfig.json");
-    if (J.existsSync(e))
-      return e;
-    const o = j.dirname(t);
-    if (o === t)
-      return;
-    t = o;
-  }
+function findNearestTsConfig(c) {
+	for (;;) {
+		let O = path.join(c, "tsconfig.json");
+		if (fs$1.existsSync(O)) return O;
+		let k = path.dirname(c);
+		if (k === c) return;
+		c = k;
+	}
 }
-function G(t) {
-  const e = y.readConfigFile(t, y.sys.readFile);
-  if (e.error)
-    throw new Error(`Failed to read tsconfig.json: ${e.error.messageText}`);
-  return y.parseJsonConfigFileContent(e.config, y.sys, j.dirname(t));
+function getTsConfig(c) {
+	let O = ts$1.readConfigFile(c, ts$1.sys.readFile);
+	if (O.error) throw Error(`Failed to read tsconfig.json: ${O.error.messageText}`);
+	return ts$1.parseJsonConfigFileContent(O.config, ts$1.sys, path.dirname(c));
 }
-function X(t, e) {
-  const o = j.join(process.cwd(), "__temp__.ts"), n = y.createCompilerHost(e), i = y.resolveModuleName(
-    t,
-    o,
-    e,
-    n
-  );
-  if (i.resolvedModule)
-    return i.resolvedModule.resolvedFileName;
+function resolveModulePath(c, O) {
+	let k = path.join(process.cwd(), "__temp__.ts"), A = ts$1.createCompilerHost(O), j = ts$1.resolveModuleName(c, k, O, A);
+	if (j.resolvedModule) return j.resolvedModule.resolvedFileName;
 }
-function Y(t) {
-  const e = B(t);
-  if (!e)
-    throw new Error(`Could not find tsconfig.json for: ${t}`);
-  const n = G(e).options, i = X(t, n);
-  if (!i)
-    throw new Error(`Could not resolve module: ${t}`);
-  const r = y.createCompilerHost(n), l = y.createProgram({
-    host: r,
-    options: n,
-    rootNames: [i]
-  }), s = l.getSourceFile(i);
-  if (!s)
-    throw new Error(`Could not get source file for: ${i}`);
-  return {
-    program: l,
-    sourceFile: s
-  };
+function getSourceFile(c) {
+	let O = findNearestTsConfig(c);
+	if (!O) throw Error(`Could not find tsconfig.json for: ${c}`);
+	let k = getTsConfig(O).options, A = resolveModulePath(c, k);
+	if (!A) throw Error(`Could not resolve module: ${c}`);
+	let j = ts$1.createCompilerHost(k), M = ts$1.createProgram({
+		host: j,
+		options: k,
+		rootNames: [A]
+	}), N = M.getSourceFile(A);
+	if (!N) throw Error(`Could not get source file for: ${A}`);
+	return {
+		program: M,
+		sourceFile: N
+	};
 }
-const P = M.promises;
-async function oe(t, e) {
-  const o = t.split("/").pop().split(".")[0], { program: n, sourceFile: i } = Y(t), l = new q(n).get(i.fileName), s = Z(l, o);
-  if (s.components.default) {
-    const c = V(s, { name: o, path: t });
-    await P.mkdir(e.split("/").slice(0, -1).join("/"), { recursive: !0 }), await P.writeFile(e, c);
-  }
+var fsp = fs.promises;
+async function extractFile(c, O) {
+	let k = c.split("/").pop().split(".")[0], { program: A, sourceFile: j } = getSourceFile(c), M = generateNodes(new CTypeExport(A).get(j.fileName), k);
+	if (M.components.default) {
+		let A = getComponentCode(M, {
+			name: k,
+			path: c
+		});
+		await fsp.mkdir(O.split("/").slice(0, -1).join("/"), { recursive: !0 }), await fsp.writeFile(O, A);
+	}
 }
-export {
-  q as CTypeExport,
-  oe as extractFile,
-  Z as generateNodes,
-  Y as getSourceFile
-};
+export { CTypeExport, extractFile, generateNodes, getSourceFile };