@luna-park/plugin 1.0.1 → 1.0.3

package/dist/extractor.js

@@ -0,0 +1,577 @@
+import M from "node:fs";
+import { i as m, o as F, F as d, u as x, a as I, d as U } from "./index-CxGB_fZK.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)]);
+}
+function b(t, e) {
+  const o = e.findLastIndex((n) => n !== "{}");
+  return `${t}(${e.slice(0, o + 1).join(", ")})`;
+}
+function h(t, e) {
+  return `{${Object.entries(t).map(([o, n]) => `${_(o)}: ${e ? n : JSON.stringify(n)}`).join(", ")}}`;
+}
+function _(t) {
+  return /^[a-zA-Z]+$/.test(t) ? t : JSON.stringify(t);
+}
+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(`
+
+`);
+  return `import { LogicType, type TComponent } from "@luna-park/plugin";
+import ${e.name} from "${e.path}";
+
+${i}
+
+export const ${e.name.toLocaleLowerCase()}: TComponent = {
+    name: "${e.name}",
+    component: ${e.name},
+    ${o.map(({ key: r, value: l }) => `${r}: {
+        ${l}
+    }`).join(`,
+    `)}
+}`;
+}
+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 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 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 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 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 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 W(t) {
+  return /^on[A-Z]/.test(t);
+}
+function H(t) {
+  return t = t.slice(2), t.charAt(0).toLowerCase() + t.slice(1);
+}
+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 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 $(t, e) {
+  let o = t.getFullyQualifiedName(e);
+  return o.includes('".') && (o = o.split('".').pop()), o.includes(").") && (o = o.split(").").pop()), o;
+}
+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 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 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/"));
+}
+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 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);
+    }
+  }
+}
+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 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 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 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
+  };
+}
+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);
+  }
+}
+export {
+  q as CTypeExport,
+  oe as extractFile,
+  Z as generateNodes,
+  Y as getSourceFile
+};