@wener/utils 1.1.26 → 1.1.27

package/lib/schema/typebox/gen/codegen/typescript/typescript-to-model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript-to-model.js","sources":["../../../../../../src/schema/typebox/gen/codegen/typescript/typescript-to-model.ts"],"sourcesContent":["/*--------------------------------------------------------------------------\n\n@sinclair/typebox-codegen\n\nThe MIT License (MIT)\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\n---------------------------------------------------------------------------*/\nimport { Type, Kind, CloneType, type TSchema } from '@sinclair/typebox';\nimport * as ts from 'typescript';\nimport { TypeBoxModel } from '../model/model';\nimport { TypeScriptToTypeBox } from './typescript-to-typebox';\n\nexport namespace TypeScriptToModel {\n  const compilerOptions: ts.CompilerOptions = {\n    module: ts.ModuleKind.CommonJS, // used for exports\n    target: ts.ScriptTarget.ES2015, // evaluation target\n  };\n  export function Exports(code: string): Map<string, TSchema | Function> {\n    const exports = {};\n    const evaluate = new Function('exports', 'Type', 'Kind', 'CloneType', code);\n    evaluate(exports, Type, Kind, CloneType);\n    return new Map(globalThis.Object.entries(exports));\n  }\n  export function Types(exports: Map<string, TSchema | Function>): TSchema[] {\n    const types: TSchema[] = [];\n    for (const [key, schema] of exports) {\n      if (typeof schema === 'function') continue;\n      types.push({ ...schema, $id: key });\n    }\n    return types;\n  }\n  export function Generate(typescriptCode: string): TypeBoxModel {\n    const typescript = TypeScriptToTypeBox.Generate(typescriptCode, {\n      useExportEverything: false,\n      useTypeBoxImport: false,\n      useIdentifiers: true,\n    });\n    const javascript = ts.transpileModule(typescript, { compilerOptions });\n    const exports = Exports(javascript.outputText);\n    const types = Types(exports);\n    return { exports, types };\n  }\n}\n"],"names":["TypeScriptToModel"],"mappings":";;;;AA8BiB,IAAA,kBAAA;AAAA,CAAV,CAAUA,kBAAV,KAAA;AACL,EAAA,MAAM,eAAsC,GAAA;AAAA,IAC1C,MAAA,EAAQ,GAAG,UAAW,CAAA,QAAA;AAAA;AAAA,IACtB,MAAA,EAAQ,GAAG,YAAa,CAAA,MAAA;AAAA;AAAA,GAC1B,CAAA;AACO,EAAA,SAAS,QAAQ,IAA+C,EAAA;AACrE,IAAA,MAAM,UAAU,EAAC,CAAA;AACjB,IAAA,MAAM,WAAW,IAAI,QAAA,CAAS,WAAW,MAAQ,EAAA,MAAA,EAAQ,aAAa,IAAI,CAAA,CAAA;AAC1E,IAAS,QAAA,CAAA,OAAA,EAAS,IAAM,EAAA,IAAA,EAAM,SAAS,CAAA,CAAA;AACvC,IAAA,OAAO,IAAI,GAAI,CAAA,UAAA,CAAW,MAAO,CAAA,OAAA,CAAQ,OAAO,CAAC,CAAA,CAAA;AAAA,GACnD;AALO,EAAAA,kBAAS,CAAA,OAAA,GAAA,OAAA,CAAA;AAMT,EAAA,SAAS,MAAM,OAAqD,EAAA;AACzE,IAAA,MAAM,QAAmB,EAAC,CAAA;AAC1B,IAAA,KAAA,MAAW,CAAC,GAAA,EAAK,MAAM,CAAA,IAAK,OAAS,EAAA;AACnC,MAAA,IAAI,OAAO,MAAW,KAAA,UAAA;AAAY,QAAA,SAAA;AAClC,MAAA,KAAA,CAAM,KAAK,EAAE,GAAG,MAAQ,EAAA,GAAA,EAAK,KAAK,CAAA,CAAA;AAAA,KACpC;AACA,IAAO,OAAA,KAAA,CAAA;AAAA,GACT;AAPO,EAAAA,kBAAS,CAAA,KAAA,GAAA,KAAA,CAAA;AAQT,EAAA,SAAS,SAAS,cAAsC,EAAA;AAC7D,IAAM,MAAA,UAAA,GAAa,mBAAoB,CAAA,QAAA,CAAS,cAAgB,EAAA;AAAA,MAC9D,mBAAqB,EAAA,KAAA;AAAA,MACrB,gBAAkB,EAAA,KAAA;AAAA,MAClB,cAAgB,EAAA,IAAA;AAAA,KACjB,CAAA,CAAA;AACD,IAAA,MAAM,aAAa,EAAG,CAAA,eAAA,CAAgB,UAAY,EAAA,EAAE,iBAAiB,CAAA,CAAA;AACrE,IAAM,MAAA,OAAA,GAAU,OAAQ,CAAA,UAAA,CAAW,UAAU,CAAA,CAAA;AAC7C,IAAM,MAAA,KAAA,GAAQ,MAAM,OAAO,CAAA,CAAA;AAC3B,IAAO,OAAA,EAAE,SAAS,KAAM,EAAA,CAAA;AAAA,GAC1B;AAVO,EAAAA,kBAAS,CAAA,QAAA,GAAA,QAAA,CAAA;AAAA,CAnBD,EAAA,iBAAA,KAAA,iBAAA,GAAA,EAAA,CAAA,CAAA;;;;"}

package/lib/schema/typebox/gen/codegen/typescript/typescript-to-typebox.js

@@ -0,0 +1,620 @@
+import * as ts from 'typescript';
+import { JsDoc } from '../common/jsdoc.js';
+
+class TypeScriptToTypeBoxError extends Error {
+  constructor(diagnostics) {
+    super("");
+    this.diagnostics = diagnostics;
+  }
+}
+var TypeScriptToTypeBox;
+((TypeScriptToTypeBox2) => {
+  const transpilerOptions = {
+    compilerOptions: {
+      strict: true,
+      target: ts.ScriptTarget.ES2022
+    }
+  };
+  const typenames = /* @__PURE__ */ new Set();
+  let recursiveDeclaration = null;
+  let blockLevel = 0;
+  let useImports = false;
+  let useOptions = false;
+  let useGenerics = false;
+  let useCloneType = false;
+  let useExportsEverything = false;
+  let useIdentifiers = false;
+  let useTypeBoxImport = true;
+  function FindRecursiveParent(decl, node) {
+    return ts.isTypeReferenceNode(node) && decl.name.getText() === node.typeName.getText() || node.getChildren().some((node2) => FindRecursiveParent(decl, node2));
+  }
+  function FindRecursiveThis(node) {
+    return node.getChildren().some((node2) => ts.isThisTypeNode(node2) || FindRecursiveThis(node2));
+  }
+  function FindTypeName(node, name) {
+    const found = typenames.has(name) || node.getChildren().some((node2) => {
+      return (ts.isInterfaceDeclaration(node2) || ts.isTypeAliasDeclaration(node2)) && node2.name.getText() === name || FindTypeName(node2, name);
+    });
+    if (found)
+      typenames.add(name);
+    return found;
+  }
+  function IsRecursiveType(decl) {
+    const check1 = ts.isTypeAliasDeclaration(decl) ? [decl.type].some((node) => FindRecursiveParent(decl, node)) : decl.members.some((node) => FindRecursiveParent(decl, node));
+    const check2 = ts.isInterfaceDeclaration(decl) && FindRecursiveThis(decl);
+    return check1 || check2;
+  }
+  function IsReadonlyProperty(node) {
+    return node.modifiers !== void 0 && node.modifiers.find((modifier) => modifier.getText() === "readonly") !== void 0;
+  }
+  function IsOptionalProperty(node) {
+    return node.questionToken !== void 0;
+  }
+  function IsExport(node) {
+    return blockLevel === 0 && (useExportsEverything || node.modifiers !== void 0 && node.modifiers.find((modifier) => modifier.getText() === "export") !== void 0);
+  }
+  function IsNamespace(node) {
+    return node.flags === ts.NodeFlags.Namespace;
+  }
+  function ResolveJsDocComment(node) {
+    const content = node.getFullText().trim();
+    if (node.kind === ts.SyntaxKind.LiteralType) {
+      if (content.startsWith("/**")) {
+        return content.slice(0, content.lastIndexOf("*/") + 2).replace(/\*+\/$/, "\n$0");
+      } else {
+        return "";
+      }
+    }
+    const indices = [content.indexOf("/**"), content.indexOf("type"), content.indexOf("interface")].map(
+      (n) => n === -1 ? Infinity : n
+    );
+    if (indices[0] === -1 || indices[1] < indices[0] || indices[2] < indices[0])
+      return "";
+    for (let i = indices[0]; i < content.length; i++) {
+      if (content[i] === "*" && content[i + 1] === "/")
+        return content.slice(0, i + 2);
+    }
+    return "";
+  }
+  function ResolveOptions(node) {
+    const content = ResolveJsDocComment(node);
+    return JsDoc.Parse(content);
+  }
+  function ResolveIdentifier(node) {
+    function* resolve(node2) {
+      if (node2.parent)
+        yield* resolve(node2.parent);
+      if (ts.isModuleDeclaration(node2))
+        yield node2.name.getText();
+    }
+    return [...resolve(node), node.name.getText()].join(".");
+  }
+  function UnwrapModifier(type) {
+    for (let i = 0; i < type.length; i++)
+      if (type[i] === "(")
+        return type.slice(i + 1, type.length - 1);
+    return type;
+  }
+  function InjectOptions(type, options) {
+    if (globalThis.Object.keys(options).length === 0)
+      return type;
+    if (type.indexOf("Type.ReadonlyOptional") === 0)
+      return `Type.ReadonlyOptional( ${InjectOptions(UnwrapModifier(type), options)} )`;
+    if (type.indexOf("Type.Readonly") === 0)
+      return `Type.Readonly( ${InjectOptions(UnwrapModifier(type), options)} )`;
+    if (type.indexOf("Type.Optional") === 0)
+      return `Type.Optional( ${InjectOptions(UnwrapModifier(type), options)} )`;
+    const encoded = JSON.stringify(options);
+    if (type.lastIndexOf("]") === type.length - 1)
+      useCloneType = true;
+    if (type.lastIndexOf("]") === type.length - 1)
+      return `CloneType(${type}, ${encoded})`;
+    if (type.indexOf("(") === -1) {
+      useCloneType = true;
+      return `CloneType(${type}, ${encoded})`;
+    }
+    if (type.lastIndexOf("()") === type.length - 2)
+      return type.slice(0, type.length - 1) + `${encoded})`;
+    if (type.lastIndexOf("})") === type.length - 2)
+      return type.slice(0, type.length - 1) + `, ${encoded})`;
+    if (type.lastIndexOf("])") === type.length - 2)
+      return type.slice(0, type.length - 1) + `, ${encoded})`;
+    if (type.lastIndexOf(")") === type.length - 1)
+      return type.slice(0, type.length - 1) + `, ${encoded})`;
+    return type;
+  }
+  function* SourceFile(node) {
+    for (const next of node.getChildren()) {
+      yield* Visit(next);
+    }
+  }
+  function* PropertySignature(node) {
+    const [readonly, optional] = [IsReadonlyProperty(node), IsOptionalProperty(node)];
+    const options = ResolveOptions(node);
+    const type_0 = Collect(node.type);
+    const type_1 = InjectOptions(type_0, options);
+    if (readonly && optional) {
+      return yield `${node.name.getText()}: Type.ReadonlyOptional(${type_1})`;
+    } else if (readonly) {
+      return yield `${node.name.getText()}: Type.Readonly(${type_1})`;
+    } else if (optional) {
+      return yield `${node.name.getText()}: Type.Optional(${type_1})`;
+    } else {
+      return yield `${node.name.getText()}: ${type_1}`;
+    }
+  }
+  function* ArrayTypeNode(node) {
+    const type = Collect(node.elementType);
+    yield `Type.Array(${type})`;
+  }
+  function* Block(node) {
+    blockLevel += 1;
+    const statments = node.statements.map((statement) => Collect(statement)).join("\n\n");
+    blockLevel -= 1;
+    yield `{
+${statments}
+}`;
+  }
+  function* TupleTypeNode(node) {
+    const types = node.elements.map((type) => Collect(type)).join(",\n");
+    yield `Type.Tuple([
+${types}
+])`;
+  }
+  function* UnionTypeNode(node) {
+    const types = node.types.map((type) => Collect(type)).join(",\n");
+    yield `Type.Union([
+${types}
+])`;
+  }
+  function* MappedTypeNode(node) {
+    const K = Collect(node.typeParameter);
+    const T = Collect(node.type);
+    const C = Collect(node.typeParameter.constraint);
+    const readonly = node.readonlyToken !== void 0;
+    const optional = node.questionToken !== void 0;
+    const readonly_subtractive = readonly && ts.isMinusToken(node.readonlyToken);
+    const optional_subtractive = optional && ts.isMinusToken(node.questionToken);
+    return yield readonly && optional ? readonly_subtractive && optional_subtractive ? `Type.Mapped(${C}, ${K} => Type.Readonly(Type.Optional(${T}, false), false))` : readonly_subtractive ? `Type.Mapped(${C}, ${K} => Type.Readonly(Type.Optional(${T}), false))` : optional_subtractive ? `Type.Mapped(${C}, ${K} => Type.Readonly(Type.Optional(${T}, false)))` : `Type.Mapped(${C}, ${K} => Type.Readonly(Type.Optional(${T})))` : readonly ? readonly_subtractive ? `Type.Mapped(${C}, ${K} => Type.Readonly(${T}, false))` : `Type.Mapped(${C}, ${K} => Type.Readonly(${T}))` : optional ? optional_subtractive ? `Type.Mapped(${C}, ${K} => Type.Optional(${T}, false))` : `Type.Mapped(${C}, ${K} => Type.Optional(${T}))` : `Type.Mapped(${C}, ${K} => ${T})`;
+  }
+  function* MethodSignature(node) {
+    const parameters = node.parameters.map(
+      (parameter) => parameter.dotDotDotToken !== void 0 ? `...Type.Rest(${Collect(parameter)})` : Collect(parameter)
+    ).join(", ");
+    const returnType = node.type === void 0 ? `Type.Unknown()` : Collect(node.type);
+    yield `${node.name.getText()}: Type.Function([${parameters}], ${returnType})`;
+  }
+  function* TemplateLiteralTypeNode(node) {
+    const collect = node.getChildren().map((node2) => Collect(node2)).join("");
+    yield `Type.TemplateLiteral([${collect.slice(0, collect.length - 2)}])`;
+  }
+  function* TemplateLiteralTypeSpan(node) {
+    const collect = node.getChildren().map((node2) => Collect(node2)).join(", ");
+    if (collect.length > 0)
+      yield `${collect}`;
+  }
+  function* TemplateHead(node) {
+    if (node.text.length > 0)
+      yield `Type.Literal('${node.text}'), `;
+  }
+  function* TemplateMiddle(node) {
+    if (node.text.length > 0)
+      yield `Type.Literal('${node.text}'), `;
+  }
+  function* TemplateTail(node) {
+    if (node.text.length > 0)
+      yield `Type.Literal('${node.text}'), `;
+  }
+  function* ThisTypeNode(node) {
+    yield `This`;
+  }
+  function* IntersectionTypeNode(node) {
+    const types = node.types.map((type) => Collect(type)).join(",\n");
+    yield `Type.Intersect([
+${types}
+])`;
+  }
+  function* TypeOperatorNode(node) {
+    if (node.operator === ts.SyntaxKind.KeyOfKeyword) {
+      const type = Collect(node.type);
+      yield `Type.KeyOf(${type})`;
+    }
+    if (node.operator === ts.SyntaxKind.ReadonlyKeyword) {
+      yield `Type.Readonly(${Collect(node.type)})`;
+    }
+  }
+  function* Parameter(node) {
+    yield Collect(node.type);
+  }
+  function* FunctionTypeNode(node) {
+    const parameters = node.parameters.map(
+      (parameter) => parameter.dotDotDotToken !== void 0 ? `...Type.Rest(${Collect(parameter)})` : Collect(parameter)
+    ).join(", ");
+    const returns = Collect(node.type);
+    yield `Type.Function([${parameters}], ${returns})`;
+  }
+  function* ConstructorTypeNode(node) {
+    const parameters = node.parameters.map((param) => Collect(param)).join(", ");
+    const returns = Collect(node.type);
+    yield `Type.Constructor([${parameters}], ${returns})`;
+  }
+  function* EnumDeclaration(node) {
+    useImports = true;
+    const exports = IsExport(node) ? "export " : "";
+    const members = node.members.map((member) => member.getText()).join(", ");
+    const enumType = `${exports}enum Enum${node.name.getText()} { ${members} }`;
+    const staticType = `${exports}type ${node.name.getText()} = Static<typeof ${node.name.getText()}>`;
+    const type = `${exports}const ${node.name.getText()} = Type.Enum(Enum${node.name.getText()})`;
+    yield [enumType, "", staticType, type].join("\n");
+  }
+  function PropertiesFromTypeElementArray(members) {
+    const properties = members.filter((member) => !ts.isIndexSignatureDeclaration(member));
+    const indexers = members.filter((member) => ts.isIndexSignatureDeclaration(member));
+    const propertyCollect = properties.map((property) => Collect(property)).join(",\n");
+    const indexer = indexers.length > 0 ? Collect(indexers[indexers.length - 1]) : "";
+    if (properties.length === 0 && indexer.length > 0) {
+      return `{},
+{
+additionalProperties: ${indexer}
+ }`;
+    } else if (properties.length > 0 && indexer.length > 0) {
+      return `{
+${propertyCollect}
+},
+{
+additionalProperties: ${indexer}
+ }`;
+    } else {
+      return `{
+${propertyCollect}
+}`;
+    }
+  }
+  function* TypeLiteralNode(node) {
+    const members = PropertiesFromTypeElementArray(node.members);
+    yield* `Type.Object(${members})`;
+  }
+  function* InterfaceDeclaration(node) {
+    useImports = true;
+    const isRecursiveType = IsRecursiveType(node);
+    if (isRecursiveType)
+      recursiveDeclaration = node;
+    const heritage = node.heritageClauses !== void 0 ? node.heritageClauses.flatMap((node2) => Collect(node2)) : [];
+    if (node.typeParameters) {
+      useGenerics = true;
+      const exports = IsExport(node) ? "export " : "";
+      const identifier = ResolveIdentifier(node);
+      const options = useIdentifiers ? { ...ResolveOptions(node), $id: identifier } : { ...ResolveOptions(node) };
+      const constraints = node.typeParameters.map((param) => `${Collect(param)} extends TSchema`).join(", ");
+      const parameters = node.typeParameters.map((param) => `${Collect(param)}: ${Collect(param)}`).join(", ");
+      const members = PropertiesFromTypeElementArray(node.members);
+      const rawTypeExpression = IsRecursiveType(node) ? `Type.Recursive(This => Type.Object(${members}))` : `Type.Object(${members})`;
+      const typeExpression = heritage.length === 0 ? rawTypeExpression : `Type.Composite([${heritage.join(", ")}, ${rawTypeExpression}])`;
+      const type = InjectOptions(typeExpression, options);
+      const typeDeclaration = `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => ${type}`;
+      yield `${typeDeclaration}`;
+    } else {
+      const exports = IsExport(node) ? "export " : "";
+      const identifier = ResolveIdentifier(node);
+      const options = useIdentifiers ? { ...ResolveOptions(node), $id: identifier } : { ...ResolveOptions(node) };
+      const members = PropertiesFromTypeElementArray(node.members);
+      const staticDeclaration = `${exports}type ${node.name.getText()} = Static<typeof ${node.name.getText()}>`;
+      const rawTypeExpression = IsRecursiveType(node) ? `Type.Recursive(This => Type.Object(${members}))` : `Type.Object(${members})`;
+      const typeExpression = heritage.length === 0 ? rawTypeExpression : `Type.Composite([${heritage.join(", ")}, ${rawTypeExpression}])`;
+      const type = InjectOptions(typeExpression, options);
+      const typeDeclaration = `${exports}const ${node.name.getText()} = ${type}`;
+      yield `${staticDeclaration}
+${typeDeclaration}`;
+    }
+    recursiveDeclaration = null;
+  }
+  function* TypeAliasDeclaration(node) {
+    useImports = true;
+    const isRecursiveType = IsRecursiveType(node);
+    if (isRecursiveType)
+      recursiveDeclaration = node;
+    if (node.typeParameters) {
+      useGenerics = true;
+      const exports = IsExport(node) ? "export " : "";
+      const options = useIdentifiers ? { $id: ResolveIdentifier(node) } : {};
+      const constraints = node.typeParameters.map((param) => `${Collect(param)} extends TSchema`).join(", ");
+      const parameters = node.typeParameters.map((param) => `${Collect(param)}: ${Collect(param)}`).join(", ");
+      const type_0 = Collect(node.type);
+      const type_1 = isRecursiveType ? `Type.Recursive(This => ${type_0})` : type_0;
+      const type_2 = InjectOptions(type_1, options);
+      const typeDeclaration = `${exports}const ${node.name.getText()} = <${constraints}>(${parameters}) => ${type_2}`;
+      yield `${typeDeclaration}`;
+    } else {
+      const exports = IsExport(node) ? "export " : "";
+      const options = useIdentifiers ? { $id: ResolveIdentifier(node), ...ResolveOptions(node) } : { ...ResolveOptions(node) };
+      const type_0 = Collect(node.type);
+      const type_1 = isRecursiveType ? `Type.Recursive(This => ${type_0})` : type_0;
+      const type_2 = InjectOptions(type_1, options);
+      const staticDeclaration = `${exports}type ${node.name.getText()} = Static<typeof ${node.name.getText()}>`;
+      const typeDeclaration = `${exports}const ${node.name.getText()} = ${type_2}`;
+      yield `${staticDeclaration}
+${typeDeclaration}`;
+    }
+    recursiveDeclaration = null;
+  }
+  function* HeritageClause(node) {
+    const types = node.types.map((node2) => Collect(node2));
+    if (types.length === 1)
+      return yield types[0];
+    yield types.join(", ");
+  }
+  function* IndexedAccessType(node) {
+    const obj = node.objectType.getText();
+    const key = Collect(node.indexType);
+    yield `Type.Index(${obj}, ${key})`;
+  }
+  function* ExpressionWithTypeArguments(node) {
+    const name = Collect(node.expression);
+    const typeArguments = node.typeArguments === void 0 ? [] : node.typeArguments.map((node2) => Collect(node2));
+    return yield typeArguments.length === 0 ? `${name}` : `${name}(${typeArguments.join(", ")})`;
+  }
+  function* TypeParameterDeclaration(node) {
+    yield node.name.getText();
+  }
+  function* ParenthesizedTypeNode(node) {
+    yield Collect(node.type);
+  }
+  function* RestTypeNode(node) {
+    yield `...Type.Rest(${node.type.getText()})`;
+  }
+  function* ConditionalTypeNode(node) {
+    const checkType = Collect(node.checkType);
+    const extendsType = Collect(node.extendsType);
+    const trueType = Collect(node.trueType);
+    const falseType = Collect(node.falseType);
+    yield `Type.Extends(${checkType}, ${extendsType}, ${trueType}, ${falseType})`;
+  }
+  function* isIndexSignatureDeclaration(node) {
+    yield Collect(node.type);
+  }
+  function* TypeReferenceNode(node) {
+    const name = node.typeName.getText();
+    const args = node.typeArguments ? `(${node.typeArguments.map((type) => Collect(type)).join(", ")})` : "";
+    if (name === "Date")
+      return yield `Type.Date()`;
+    if (name === "Uint8Array")
+      return yield `Type.Uint8Array()`;
+    if (name === "String")
+      return yield `Type.String()`;
+    if (name === "Number")
+      return yield `Type.Number()`;
+    if (name === "Boolean")
+      return yield `Type.Boolean()`;
+    if (name === "Function")
+      return yield `Type.Function([], Type.Unknown())`;
+    if (name === "Array")
+      return yield `Type.Array${args}`;
+    if (name === "Record")
+      return yield `Type.Record${args}`;
+    if (name === "Partial")
+      return yield `Type.Partial${args}`;
+    if (name === "Required")
+      return yield `Type.Required${args}`;
+    if (name === "Omit")
+      return yield `Type.Omit${args}`;
+    if (name === "Pick")
+      return yield `Type.Pick${args}`;
+    if (name === "Promise")
+      return yield `Type.Promise${args}`;
+    if (name === "ReturnType")
+      return yield `Type.ReturnType${args}`;
+    if (name === "InstanceType")
+      return yield `Type.InstanceType${args}`;
+    if (name === "Parameters")
+      return yield `Type.Parameters${args}`;
+    if (name === "AsyncIterableIterator")
+      return yield `Type.AsyncIterator${args}`;
+    if (name === "IterableIterator")
+      return yield `Type.Iterator${args}`;
+    if (name === "ConstructorParameters")
+      return yield `Type.ConstructorParameters${args}`;
+    if (name === "Exclude")
+      return yield `Type.Exclude${args}`;
+    if (name === "Extract")
+      return yield `Type.Extract${args}`;
+    if (name === "Awaited")
+      return yield `Type.Awaited${args}`;
+    if (name === "Uppercase")
+      return yield `Type.Uppercase${args}`;
+    if (name === "Lowercase")
+      return yield `Type.Lowercase${args}`;
+    if (name === "Capitalize")
+      return yield `Type.Capitalize${args}`;
+    if (name === "Uncapitalize")
+      return yield `Type.Uncapitalize${args}`;
+    if (recursiveDeclaration !== null && FindRecursiveParent(recursiveDeclaration, node))
+      return yield `This`;
+    if (FindTypeName(node.getSourceFile(), name) && args.length === 0) {
+      return yield `${name}${args}`;
+    }
+    if (name in globalThis)
+      return yield `Type.Never()`;
+    return yield `${name}${args}`;
+  }
+  function* LiteralTypeNode(node) {
+    const text = node.getText();
+    if (text === "null")
+      return yield `Type.Null()`;
+    yield InjectOptions(`Type.Literal(${node.getText()})`, ResolveOptions(node));
+  }
+  function* ModuleDeclaration(node) {
+    const export_specifier = IsExport(node) ? "export " : "";
+    const module_specifier = IsNamespace(node) ? "namespace" : "module";
+    yield `${export_specifier}${module_specifier} ${node.name.getText()} {`;
+    yield* Visit(node.body);
+    yield `}`;
+  }
+  function* ModuleBlock(node) {
+    for (const statement of node.statements) {
+      yield* Visit(statement);
+    }
+  }
+  function* FunctionDeclaration(node) {
+  }
+  function* ClassDeclaration(node) {
+  }
+  function Collect(node) {
+    return `${[...Visit(node)].join("")}`;
+  }
+  function* Visit(node) {
+    if (node === void 0)
+      return;
+    if (ts.isArrayTypeNode(node))
+      return yield* ArrayTypeNode(node);
+    if (ts.isBlock(node))
+      return yield* Block(node);
+    if (ts.isClassDeclaration(node))
+      return yield* ClassDeclaration();
+    if (ts.isConditionalTypeNode(node))
+      return yield* ConditionalTypeNode(node);
+    if (ts.isConstructorTypeNode(node))
+      return yield* ConstructorTypeNode(node);
+    if (ts.isEnumDeclaration(node))
+      return yield* EnumDeclaration(node);
+    if (ts.isExpressionWithTypeArguments(node))
+      return yield* ExpressionWithTypeArguments(node);
+    if (ts.isFunctionDeclaration(node))
+      return yield* FunctionDeclaration();
+    if (ts.isFunctionTypeNode(node))
+      return yield* FunctionTypeNode(node);
+    if (ts.isHeritageClause(node))
+      return yield* HeritageClause(node);
+    if (ts.isIndexedAccessTypeNode(node))
+      return yield* IndexedAccessType(node);
+    if (ts.isIndexSignatureDeclaration(node))
+      return yield* isIndexSignatureDeclaration(node);
+    if (ts.isInterfaceDeclaration(node))
+      return yield* InterfaceDeclaration(node);
+    if (ts.isLiteralTypeNode(node))
+      return yield* LiteralTypeNode(node);
+    if (ts.isPropertySignature(node))
+      return yield* PropertySignature(node);
+    if (ts.isModuleDeclaration(node))
+      return yield* ModuleDeclaration(node);
+    if (ts.isIdentifier(node))
+      return yield node.getText();
+    if (ts.isIntersectionTypeNode(node))
+      return yield* IntersectionTypeNode(node);
+    if (ts.isUnionTypeNode(node))
+      return yield* UnionTypeNode(node);
+    if (ts.isMappedTypeNode(node))
+      return yield* MappedTypeNode(node);
+    if (ts.isMethodSignature(node))
+      return yield* MethodSignature(node);
+    if (ts.isModuleBlock(node))
+      return yield* ModuleBlock(node);
+    if (ts.isParameter(node))
+      return yield* Parameter(node);
+    if (ts.isParenthesizedTypeNode(node))
+      return yield* ParenthesizedTypeNode(node);
+    if (ts.isRestTypeNode(node))
+      return yield* RestTypeNode(node);
+    if (ts.isTupleTypeNode(node))
+      return yield* TupleTypeNode(node);
+    if (ts.isTemplateLiteralTypeNode(node))
+      return yield* TemplateLiteralTypeNode(node);
+    if (ts.isTemplateLiteralTypeSpan(node))
+      return yield* TemplateLiteralTypeSpan(node);
+    if (ts.isTemplateHead(node))
+      return yield* TemplateHead(node);
+    if (ts.isTemplateMiddle(node))
+      return yield* TemplateMiddle(node);
+    if (ts.isTemplateTail(node))
+      return yield* TemplateTail(node);
+    if (ts.isThisTypeNode(node))
+      return yield* ThisTypeNode();
+    if (ts.isTypeAliasDeclaration(node))
+      return yield* TypeAliasDeclaration(node);
+    if (ts.isTypeLiteralNode(node))
+      return yield* TypeLiteralNode(node);
+    if (ts.isTypeOperatorNode(node))
+      return yield* TypeOperatorNode(node);
+    if (ts.isTypeParameterDeclaration(node))
+      return yield* TypeParameterDeclaration(node);
+    if (ts.isTypeReferenceNode(node))
+      return yield* TypeReferenceNode(node);
+    if (ts.isSourceFile(node))
+      return yield* SourceFile(node);
+    if (node.kind === ts.SyntaxKind.ExportKeyword)
+      return yield `export`;
+    if (node.kind === ts.SyntaxKind.KeyOfKeyword)
+      return yield `Type.KeyOf()`;
+    if (node.kind === ts.SyntaxKind.NumberKeyword)
+      return yield `Type.Number()`;
+    if (node.kind === ts.SyntaxKind.BigIntKeyword)
+      return yield `Type.BigInt()`;
+    if (node.kind === ts.SyntaxKind.StringKeyword)
+      return yield `Type.String()`;
+    if (node.kind === ts.SyntaxKind.SymbolKeyword)
+      return yield `Type.Symbol()`;
+    if (node.kind === ts.SyntaxKind.BooleanKeyword)
+      return yield `Type.Boolean()`;
+    if (node.kind === ts.SyntaxKind.UndefinedKeyword)
+      return yield `Type.Undefined()`;
+    if (node.kind === ts.SyntaxKind.UnknownKeyword)
+      return yield `Type.Unknown()`;
+    if (node.kind === ts.SyntaxKind.AnyKeyword)
+      return yield `Type.Any()`;
+    if (node.kind === ts.SyntaxKind.NeverKeyword)
+      return yield `Type.Never()`;
+    if (node.kind === ts.SyntaxKind.NullKeyword)
+      return yield `Type.Null()`;
+    if (node.kind === ts.SyntaxKind.VoidKeyword)
+      return yield `Type.Void()`;
+    if (node.kind === ts.SyntaxKind.EndOfFileToken)
+      return;
+    if (node.kind === ts.SyntaxKind.SyntaxList) {
+      for (const child of node.getChildren()) {
+        yield* Visit(child);
+      }
+      return;
+    }
+    console.warn("Unhandled:", ts.SyntaxKind[node.kind], node.getText());
+  }
+  function ImportStatement() {
+    if (!(useImports && useTypeBoxImport))
+      return "";
+    const set = /* @__PURE__ */ new Set(["Type", "Static"]);
+    if (useGenerics) {
+      set.add("TSchema");
+    }
+    if (useOptions) {
+      set.add("SchemaOptions");
+    }
+    if (useCloneType) {
+      set.add("CloneType");
+    }
+    const imports = [...set].join(", ");
+    return `import { ${imports} } from '@sinclair/typebox'`;
+  }
+  function Generate(typescriptCode, options) {
+    var _a, _b, _c;
+    useExportsEverything = (_a = options == null ? void 0 : options.useExportEverything) != null ? _a : false;
+    useIdentifiers = (_b = options == null ? void 0 : options.useIdentifiers) != null ? _b : false;
+    useTypeBoxImport = (_c = options == null ? void 0 : options.useTypeBoxImport) != null ? _c : true;
+    typenames.clear();
+    useImports = false;
+    useOptions = false;
+    useGenerics = false;
+    useCloneType = false;
+    blockLevel = 0;
+    const source = ts.createSourceFile("types.ts", typescriptCode, ts.ScriptTarget.ESNext, true);
+    const declarations = [...Visit(source)].join("\n\n");
+    const imports = ImportStatement();
+    const typescript = [imports, "", "", declarations].join("\n");
+    const assertion = ts.transpileModule(typescript, transpilerOptions);
+    if (assertion.diagnostics && assertion.diagnostics.length > 0) {
+      throw new TypeScriptToTypeBoxError(assertion.diagnostics);
+    }
+    return typescript;
+  }
+  TypeScriptToTypeBox2.Generate = Generate;
+})(TypeScriptToTypeBox || (TypeScriptToTypeBox = {}));
+
+export { TypeScriptToTypeBox, TypeScriptToTypeBoxError };
+//# sourceMappingURL=typescript-to-typebox.js.map