vitral 0.4.0 → 0.5.0

package/dist/chunk-PY7P5BF4.js

@@ -0,0 +1,404 @@
+// src/vite/types.ts
+import { createRequire as createRequire2 } from "module";
+import { join as join2 } from "path";
+
+// src/vite/oxc.ts
+import { existsSync, readFileSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join, resolve } from "path";
+import { pathToFileURL } from "url";
+async function loadOxc(root) {
+  const req = createRequire(join(root, "package.json"));
+  const ids = [() => req.resolve("oxc-transform"), () => createRequire(req.resolve("vite/package.json")).resolve("rolldown/experimental")];
+  for (const id of ids) {
+    try {
+      const mod = await import(pathToFileURL(id()).href);
+      if (typeof mod.isolatedDeclarationSync === "function") return mod;
+    } catch {
+    }
+  }
+  return null;
+}
+var GLOBAL = /^(Date|RegExp|Error|Map|Set|WeakMap|WeakSet|Promise|PromiseLike|Record|Partial|Required|Readonly|Pick|Omit|URL|URLSearchParams|Blob|File|FormData|Headers|AbortSignal|EventTarget|Node|Element|Document|DocumentFragment|ShadowRoot|Window|(HTML|SVG)\w*Element|\w*Event)$/;
+var IDENT = /^[A-Za-z_$][\w$]*$/;
+var Unsupported = class extends Error {
+};
+var unsupported = () => {
+  throw new Unsupported();
+};
+function propsFromOxc(ts, oxc, file) {
+  try {
+    const reader = new Reader(ts, oxc);
+    const scope = reader.scope(file);
+    const props = reader.defaultProps(scope);
+    return props ? reader.print(props.node, props.scope, 0, { top: true }) : "Record<string, unknown>";
+  } catch {
+    return null;
+  }
+}
+var Reader = class {
+  constructor(ts, oxc) {
+    this.ts = ts;
+    this.oxc = oxc;
+    this.scopes = /* @__PURE__ */ new Map();
+    this.seen = /* @__PURE__ */ new Set();
+  }
+  /** Declarações de um arquivo: `.d.ts` como está, o resto pelo Oxc. */
+  scope(file) {
+    const cached = this.scopes.get(file);
+    if (cached) return cached;
+    const { ts } = this;
+    let code = readFileSync(file, "utf8");
+    if (!/\.d\.[cm]?ts$/.test(file)) {
+      const out = this.oxc.isolatedDeclarationSync(file, code, {});
+      if (out.errors.length) unsupported();
+      code = out.code;
+    }
+    const source = ts.createSourceFile(file + ".d.ts", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const scope = { file, types: /* @__PURE__ */ new Map(), values: /* @__PURE__ */ new Map(), imports: /* @__PURE__ */ new Map() };
+    const isDefault = (n) => ts.canHaveModifiers(n) && !!ts.getModifiers(n)?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
+    let defaultName;
+    for (const st of source.statements) {
+      if (ts.isInterfaceDeclaration(st) || ts.isTypeAliasDeclaration(st)) {
+        if (scope.types.has(st.name.text)) unsupported();
+        scope.types.set(st.name.text, st);
+      } else if (ts.isImportDeclaration(st) && ts.isStringLiteral(st.moduleSpecifier)) {
+        const from = st.moduleSpecifier.text;
+        const clause = st.importClause;
+        if (clause?.name) scope.imports.set(clause.name.text, { from, name: "default" });
+        const bindings = clause?.namedBindings;
+        if (bindings && ts.isNamespaceImport(bindings)) scope.imports.set(bindings.name.text, { from, name: "*" });
+        if (bindings && ts.isNamedImports(bindings)) for (const el of bindings.elements) scope.imports.set(el.name.text, { from, name: (el.propertyName ?? el.name).text });
+      } else if (ts.isFunctionDeclaration(st) || ts.isClassDeclaration(st)) {
+        if (isDefault(st)) scope.default ??= st;
+        else if (st.name && !scope.values.has(st.name.text)) scope.values.set(st.name.text, st);
+      } else if (ts.isVariableStatement(st)) {
+        for (const d of st.declarationList.declarations) if (ts.isIdentifier(d.name)) scope.values.set(d.name.text, d);
+      } else if (ts.isExportAssignment(st) && !st.isExportEquals) {
+        defaultName = ts.isIdentifier(st.expression) ? st.expression.text : unsupported();
+      } else if (ts.isExportDeclaration(st) && !st.moduleSpecifier && st.exportClause && ts.isNamedExports(st.exportClause)) {
+        const el = st.exportClause.elements.find((e) => e.name.text === "default");
+        if (el) defaultName = (el.propertyName ?? el.name).text;
+      }
+    }
+    if (defaultName) scope.default = scope.values.get(defaultName);
+    this.scopes.set(file, scope);
+    return scope;
+  }
+  /** `mount(el, props)`, componente-função `(props)` ou classe com `props`. `undefined`: sem props. */
+  defaultProps(scope) {
+    const { ts } = this;
+    const node = scope.default ?? unsupported();
+    const param = (params, i) => {
+      const p = params[i];
+      return p && { node: p.type ?? unsupported(), scope };
+    };
+    if (ts.isFunctionDeclaration(node)) return param(node.parameters, 0);
+    if (ts.isClassDeclaration(node)) {
+      if (node.heritageClauses?.length) unsupported();
+      const props = node.members.find((m) => ts.isPropertyDeclaration(m) && m.name.getText() === "props");
+      return props && { node: props.type ?? unsupported(), scope };
+    }
+    if (ts.isVariableDeclaration(node)) return this.propsOfType(node.type ?? unsupported(), scope);
+    return unsupported();
+  }
+  propsOfType(node, scope) {
+    const { ts } = this;
+    const param = (params, i, at2) => {
+      const p = params[i];
+      return p && { node: p.type ?? unsupported(), scope: at2 };
+    };
+    if (ts.isParenthesizedTypeNode(node)) return this.propsOfType(node.type, scope);
+    if (ts.isFunctionTypeNode(node)) return param(node.parameters, 0, scope);
+    let members;
+    let at = scope;
+    if (ts.isTypeLiteralNode(node)) members = node.members;
+    else if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && !node.typeArguments) {
+      const found = this.lookup(node.typeName.text, scope);
+      if (!found || found === "package" || found.decl.typeParameters) return unsupported();
+      if (ts.isTypeAliasDeclaration(found.decl)) return this.propsOfType(found.decl.type, found.scope);
+      if (found.decl.heritageClauses?.length) unsupported();
+      members = found.decl.members;
+      at = found.scope;
+    } else return unsupported();
+    const mount = members.find((m) => m.name?.getText() === "mount");
+    if (mount) {
+      if (ts.isMethodSignature(mount)) return param(mount.parameters, 1, at);
+      if (ts.isPropertySignature(mount) && mount.type) return this.mountProps(mount.type, at);
+      return unsupported();
+    }
+    const call = members.find(ts.isCallSignatureDeclaration);
+    if (call) return param(call.parameters, 0, at);
+    if (members.some(ts.isConstructSignatureDeclaration)) unsupported();
+    return void 0;
+  }
+  mountProps(node, scope) {
+    const { ts } = this;
+    if (ts.isParenthesizedTypeNode(node)) return this.mountProps(node.type, scope);
+    if (!ts.isFunctionTypeNode(node)) return unsupported();
+    const p = node.parameters[1];
+    return p && { node: p.type ?? unsupported(), scope };
+  }
+  /** Acha um tipo pelo nome: no arquivo, num import relativo ou num pacote. */
+  lookup(name, scope) {
+    const decl = scope.types.get(name);
+    if (decl) return { decl, scope };
+    const imp = scope.imports.get(name);
+    if (!imp) return void 0;
+    if (!imp.from.startsWith(".")) return "package";
+    if (imp.name === "default" || imp.name === "*") return unsupported();
+    const found = this.lookup(imp.name, this.scope(resolveFile(scope.file, imp.from)));
+    return found ?? unsupported();
+  }
+  print(node, scope, depth, opts = {}) {
+    const { ts } = this;
+    const K = ts.SyntaxKind;
+    switch (node.kind) {
+      case K.AnyKeyword:
+      case K.UnknownKeyword:
+        return "unknown";
+      case K.StringKeyword:
+      case K.NumberKeyword:
+      case K.BooleanKeyword:
+      case K.BigIntKeyword:
+      case K.SymbolKeyword:
+      case K.UndefinedKeyword:
+      case K.VoidKeyword:
+      case K.NeverKeyword:
+        return node.getText();
+    }
+    if (ts.isLiteralTypeNode(node)) {
+      const lit = node.literal;
+      if (ts.isStringLiteral(lit)) return JSON.stringify(lit.text);
+      if (lit.kind === K.NullKeyword || lit.kind === K.TrueKeyword || lit.kind === K.FalseKeyword || ts.isNumericLiteral(lit) || ts.isPrefixUnaryExpression(lit)) return lit.getText();
+      return unsupported();
+    }
+    if (ts.isParenthesizedTypeNode(node)) return this.print(node.type, scope, depth, opts);
+    if (ts.isUnionTypeNode(node)) {
+      const types = opts.nonNull ? node.types.filter((t) => t.kind !== K.UndefinedKeyword && !(ts.isLiteralTypeNode(t) && t.literal.kind === K.NullKeyword)) : node.types;
+      const parts = [...new Set(types.map((t) => this.print(t, scope, depth)))];
+      if (parts.includes("true") && parts.includes("false")) parts.splice(parts.indexOf("true"), 1, "boolean"), parts.splice(parts.indexOf("false"), 1);
+      return parts.join(" | ");
+    }
+    if (ts.isIntersectionTypeNode(node)) {
+      return node.types.map((t) => {
+        const s = this.print(t, scope, depth);
+        return ts.isUnionTypeNode(t) ? `(${s})` : s;
+      }).join(" & ");
+    }
+    if (depth > 6) return "unknown";
+    if (ts.isArrayTypeNode(node)) return `Array<${this.print(node.elementType, scope, depth + 1)}>`;
+    if (ts.isTypeOperatorNode(node) && node.operator === K.ReadonlyKeyword && (ts.isArrayTypeNode(node.type) || ts.isTupleTypeNode(node.type))) return this.print(node.type, scope, depth);
+    if (ts.isTupleTypeNode(node)) {
+      if (node.elements.some((e) => ts.isNamedTupleMember(e) || ts.isOptionalTypeNode(e) || ts.isRestTypeNode(e))) unsupported();
+      return `[${node.elements.map((e) => this.print(e, scope, depth + 1)).join(", ")}]`;
+    }
+    if (ts.isTypeLiteralNode(node)) return this.object(node.members, scope, depth, !!opts.top);
+    if (ts.isFunctionTypeNode(node)) return this.signature(node, scope, depth);
+    if (ts.isTypeReferenceNode(node)) return this.reference(node, scope, depth, opts);
+    return unsupported();
+  }
+  reference(node, scope, depth, opts) {
+    const { ts } = this;
+    if (!ts.isIdentifier(node.typeName)) return unsupported();
+    const name = node.typeName.text;
+    const args = node.typeArguments ?? [];
+    const found = this.lookup(name, scope);
+    if (found === "package") return "unknown";
+    if (found) {
+      if (args.length || found.decl.typeParameters) unsupported();
+      if (this.seen.has(found.decl)) return "unknown";
+      this.seen.add(found.decl);
+      try {
+        const decl = found.decl;
+        if (ts.isTypeAliasDeclaration(decl)) return this.print(decl.type, found.scope, depth, opts);
+        if (decl.heritageClauses?.length) unsupported();
+        return this.object(decl.members, found.scope, depth, !!opts.top);
+      } finally {
+        this.seen.delete(found.decl);
+      }
+    }
+    if ((name === "Array" || name === "ReadonlyArray") && args.length === 1) return `Array<${this.print(args[0], scope, depth + 1)}>`;
+    if (!GLOBAL.test(name)) return unsupported();
+    return args.length ? `${name}<${args.map((t) => this.print(t, scope, depth + 1)).join(", ")}>` : name;
+  }
+  object(members, scope, depth, top) {
+    const { ts } = this;
+    const fields = [];
+    const calls = [];
+    let index;
+    for (const m of members) {
+      if (ts.isPropertySignature(m) || ts.isMethodSignature(m)) {
+        const name = ts.isIdentifier(m.name) || ts.isStringLiteral(m.name) || ts.isNumericLiteral(m.name) ? m.name.text : unsupported();
+        if (top && name === "vitral") continue;
+        const optional = m.questionToken ? "?" : "";
+        const key = IDENT.test(name) ? name : JSON.stringify(name);
+        const type = ts.isMethodSignature(m) ? this.signature(m, scope, depth + 1) : m.type ? this.print(m.type, scope, depth + 1, { nonNull: !!optional }) : "unknown";
+        fields.push(`${key}${optional}: ${type}`);
+      } else if (ts.isIndexSignatureDeclaration(m)) {
+        const key = m.parameters[0]?.type;
+        if (!key || key.kind !== ts.SyntaxKind.StringKeyword) unsupported();
+        index = `[key: string]: ${this.print(m.type, scope, depth + 1)}`;
+      } else if (ts.isCallSignatureDeclaration(m)) {
+        calls.push(this.signature(m, scope, depth));
+      } else unsupported();
+    }
+    if (calls.length && !fields.length) return calls[0];
+    if (index) fields.push(index);
+    for (const c of calls) fields.push(c.replace(" =>", ":"));
+    return fields.length ? `{ ${fields.join("; ")} }` : "{}";
+  }
+  signature(sig, scope, depth) {
+    const { ts } = this;
+    if (sig.typeParameters?.length || !sig.type) unsupported();
+    const params = sig.parameters.map((p, i) => {
+      if (p.dotDotDotToken || ts.isIdentifier(p.name) && p.name.text === "this") unsupported();
+      const name = ts.isIdentifier(p.name) && IDENT.test(p.name.text) ? p.name.text : `a${i}`;
+      const type = p.type ? this.print(p.type, scope, depth + 1) : "unknown";
+      return `${name}: ${p.questionToken || p.initializer ? `${type} | undefined` : type}`;
+    });
+    return `(${params.join(", ")}) => ${this.print(sig.type, scope, depth + 1)}`;
+  }
+};
+function resolveFile(from, spec) {
+  const base = resolve(dirname(from), spec);
+  const stem = base.replace(/\.[cm]?jsx?$/, "");
+  const candidates = [base, ...[".ts", ".tsx", ".mts", ".cts", ".d.ts"].map((ext) => stem + ext), ...["index.ts", "index.tsx", "index.d.ts"].map((f) => join(base, f))];
+  const file = candidates.find((f) => /\.[cm]?tsx?$/.test(f) && existsSync(f));
+  return file ?? unsupported();
+}
+
+// src/vite/types.ts
+function typesFile(name, props) {
+  return `// Props do remote ${JSON.stringify(name)}, geradas pelo vitral. N\xE3o edite.
+export type Props = ${props}
+`;
+}
+async function loadTs(root) {
+  const api = (ts) => typeof ts?.createProgram === "function" ? ts : null;
+  try {
+    const ts = api(createRequire2(join2(root, "package.json"))("typescript"));
+    if (ts) return ts;
+  } catch {
+  }
+  try {
+    return api((await import("typescript")).default);
+  } catch {
+    return null;
+  }
+}
+async function extractProps(root, file) {
+  if (!/\.[cm]?[jt]sx?$/.test(file)) return null;
+  const ts = await loadTs(root);
+  if (!ts) return null;
+  const oxc = /\.[cm]?tsx?$/.test(file) ? await loadOxc(root) : null;
+  const fast = oxc && propsFromOxc(ts, oxc, file);
+  if (fast) return fast;
+  const configPath = ts.findConfigFile(root, ts.sys.fileExists);
+  const base = configPath ? ts.parseJsonConfigFileContent(ts.readConfigFile(configPath, ts.sys.readFile).config, ts.sys, root).options : {};
+  const options = {
+    target: ts.ScriptTarget.ES2022,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    jsx: ts.JsxEmit.Preserve,
+    strict: true,
+    ...base,
+    allowJs: true,
+    skipLibCheck: true,
+    noEmit: true
+  };
+  const program = ts.createProgram([file], options);
+  const checker = program.getTypeChecker();
+  const source = program.getSourceFile(file);
+  const moduleSymbol = source && checker.getSymbolAtLocation(source);
+  let symbol = moduleSymbol && checker.getExportsOfModule(moduleSymbol).find((s) => s.escapedName === "default");
+  if (!source || !symbol) return null;
+  if (symbol.flags & ts.SymbolFlags.Alias) symbol = checker.getAliasedSymbol(symbol);
+  const type = checker.getTypeOfSymbolAtLocation(symbol, source);
+  const props = propsOf(checker, type, source);
+  return props ? new Printer(ts, checker, program).print(props, 0, true) : "Record<string, unknown>";
+}
+function propsOf(checker, type, at) {
+  const param = (t, i) => {
+    const p = t.getCallSignatures()[0]?.parameters[i];
+    return p && checker.getTypeOfSymbolAtLocation(p, at);
+  };
+  const mount = type.getProperty("mount");
+  if (mount) return param(checker.getTypeOfSymbolAtLocation(mount, at), 1);
+  if (type.getCallSignatures().length) return param(type, 0);
+  const ctor = type.getConstructSignatures()[0];
+  const props = ctor?.getReturnType().getProperty("props");
+  return props && checker.getTypeOfSymbolAtLocation(props, at);
+}
+var Printer = class {
+  constructor(ts, checker, program) {
+    this.ts = ts;
+    this.checker = checker;
+    this.program = program;
+    this.seen = /* @__PURE__ */ new Set();
+  }
+  /** Declarado na lib padrão (Date, Map…): vale em qualquer projeto pelo nome. */
+  fromLib(type) {
+    const decl = (type.aliasSymbol ?? type.getSymbol())?.declarations?.[0];
+    return !!decl && this.program.isSourceFileDefaultLibrary(decl.getSourceFile());
+  }
+  fromPackage(type) {
+    const decl = (type.aliasSymbol ?? type.getSymbol())?.declarations?.[0];
+    return !!decl && /[/\\]node_modules[/\\]/.test(decl.getSourceFile().fileName);
+  }
+  print(type, depth, top = false) {
+    const { ts, checker } = this;
+    const f = type.flags;
+    if (f & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) return "unknown";
+    if (f & (ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike | ts.TypeFlags.BooleanLike | ts.TypeFlags.BigIntLike | ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void | ts.TypeFlags.Never | ts.TypeFlags.ESSymbolLike)) {
+      return checker.typeToString(type);
+    }
+    if (type.isUnion()) {
+      const parts = [...new Set(type.types.map((t) => this.print(t, depth)))];
+      if (parts.includes("true") && parts.includes("false")) parts.splice(parts.indexOf("true"), 1, "boolean"), parts.splice(parts.indexOf("false"), 1);
+      return parts.join(" | ");
+    }
+    if (type.isIntersection()) return type.types.map((t) => this.wrap(t, depth)).join(" & ");
+    if (depth > 6 || this.seen.has(type)) return "unknown";
+    if (checker.isArrayType(type)) return `Array<${this.print(checker.getTypeArguments(type)[0], depth + 1)}>`;
+    if (checker.isTupleType(type)) return `[${checker.getTypeArguments(type).map((t) => this.print(t, depth + 1)).join(", ")}]`;
+    if (this.fromLib(type)) {
+      const args = type.aliasTypeArguments ?? (type.objectFlags & ts.ObjectFlags.Reference ? checker.getTypeArguments(type) : []);
+      const name = (type.aliasSymbol ?? type.getSymbol()).name;
+      return args.length ? `${name}<${args.map((t) => this.print(t, depth + 1)).join(", ")}>` : checker.typeToString(type);
+    }
+    if (this.fromPackage(type)) return "unknown";
+    this.seen.add(type);
+    try {
+      const calls = type.getCallSignatures();
+      const props = checker.getPropertiesOfType(type).filter((p) => !(top && p.name === "vitral"));
+      if (calls.length && !props.length) return this.signature(calls[0], depth);
+      const fields = props.map((p) => {
+        const optional = p.flags & ts.SymbolFlags.Optional ? "?" : "";
+        const key = /^[A-Za-z_$][\w$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
+        const t = checker.getTypeOfSymbol(p);
+        return `${key}${optional}: ${this.print(optional ? checker.getNonNullableType(t) : t, depth + 1)}`;
+      });
+      const index = type.getStringIndexType();
+      if (index) fields.push(`[key: string]: ${this.print(index, depth + 1)}`);
+      for (const c of calls) fields.push(this.signature(c, depth).replace(" =>", ":"));
+      return fields.length ? `{ ${fields.join("; ")} }` : "{}";
+    } finally {
+      this.seen.delete(type);
+    }
+  }
+  wrap(type, depth) {
+    const s = this.print(type, depth);
+    return type.isUnion() ? `(${s})` : s;
+  }
+  signature(sig, depth) {
+    const params = sig.parameters.map((p, i) => `${/^[A-Za-z_$][\w$]*$/.test(p.name) ? p.name : `a${i}`}: ${this.print(this.checker.getTypeOfSymbol(p), depth + 1)}`);
+    return `(${params.join(", ")}) => ${this.print(sig.getReturnType(), depth + 1)}`;
+  }
+};
+
+export {
+  typesFile,
+  loadTs,
+  extractProps
+};