@wener/utils 1.1.47 → 1.1.49

package/src/schema/typebox/gen/codegen/model/model-to-json-schema.ts

@@ -1,166 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox-codegen
-
-The MIT License (MIT)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-import * as Types from '@sinclair/typebox';
-import { Formatter } from '../common/index';
-import { TypeBoxModel } from './model';
-
-// --------------------------------------------------------------------------
-// ModelToJsonSchema
-// --------------------------------------------------------------------------
-export namespace ModelToJsonSchema {
-  function Any(schema: Types.TAny): Types.TSchema {
-    return schema;
-  }
-  function Array(schema: Types.TArray): Types.TSchema {
-    return schema;
-  }
-  function BigInt(schema: Types.TBigInt): Types.TSchema {
-    return schema;
-  }
-  function Boolean(schema: Types.TBoolean): Types.TSchema {
-    return schema;
-  }
-  function Date(schema: Types.TDate): Types.TSchema {
-    return schema;
-  }
-  function Constructor(schema: Types.TConstructor): Types.TSchema {
-    return schema;
-  }
-  function Function(schema: Types.TFunction): Types.TSchema {
-    const parameters = schema.parameters.map((schema) => Visit(schema));
-    const returns = Visit(schema.returns);
-    return { ...schema, parameters, returns };
-  }
-  function Integer(schema: Types.TInteger): Types.TSchema {
-    return schema;
-  }
-  function Intersect(schema: Types.TIntersect): Types.TSchema {
-    const allOf = schema.allOf.map((schema) => Visit(schema));
-    return { ...schema, allOf };
-  }
-  function Literal(schema: Types.TLiteral): Types.TSchema {
-    return schema;
-  }
-  function Never(schema: Types.TNever): Types.TSchema {
-    return schema;
-  }
-  function Null(schema: Types.TNull): Types.TSchema {
-    return schema;
-  }
-  function String(schema: Types.TString): Types.TSchema {
-    return schema;
-  }
-  function Number(schema: Types.TNumber): Types.TSchema {
-    return schema;
-  }
-  function Object(schema: Types.TObject): Types.TSchema {
-    const properties = globalThis.Object.keys(schema.properties).reduce((acc, key) => {
-      return { ...acc, [key]: Visit(schema.properties[key]) };
-    }, {});
-    return { ...schema, properties };
-  }
-  function Promise(schema: Types.TPromise): Types.TSchema {
-    const item = Visit(schema.item);
-    return { ...schema, item };
-  }
-  function Record(schema: Types.TRecord): Types.TSchema {
-    const patternProperties = globalThis.Object.keys(schema.patternProperties).reduce((acc, key) => {
-      return { ...acc, [key]: Visit(schema.patternProperties[key]) };
-    }, {});
-    return { ...schema, patternProperties };
-  }
-  function Ref(schema: Types.TRef): Types.TSchema {
-    return schema;
-  }
-  function This(schema: Types.TThis): Types.TSchema {
-    return schema;
-  }
-  function Tuple(schema: Types.TTuple): Types.TSchema {
-    if (schema.items === undefined) return schema;
-    const items = schema.items.map((schema) => Visit(schema));
-    return { ...schema, items };
-  }
-  function TemplateLiteral(schema: Types.TTemplateLiteral): Types.TSchema {
-    return schema;
-  }
-  function UInt8Array(schema: Types.TUint8Array): Types.TSchema {
-    return schema;
-  }
-  function Undefined(schema: Types.TUndefined): Types.TSchema {
-    return schema;
-  }
-  function Union(schema: Types.TUnion): Types.TSchema {
-    const anyOf = schema.anyOf.map((schema) => Visit(schema));
-    return { ...schema, anyOf };
-  }
-  function Unknown(schema: Types.TUnknown): Types.TSchema {
-    return schema;
-  }
-  function Void(schema: Types.TVoid) {
-    return schema;
-  }
-  function UnsupportedType(schema: Types.TSchema) {
-    return schema;
-  }
-  function Visit(schema: Types.TSchema): Types.TSchema {
-    if (Types.TypeGuard.IsAny(schema)) return Any(schema);
-    if (Types.TypeGuard.IsArray(schema)) return Array(schema);
-    if (Types.TypeGuard.IsBigInt(schema)) return BigInt(schema);
-    if (Types.TypeGuard.IsBoolean(schema)) return Boolean(schema);
-    if (Types.TypeGuard.IsDate(schema)) return Date(schema);
-    if (Types.TypeGuard.IsConstructor(schema)) return Constructor(schema);
-    if (Types.TypeGuard.IsFunction(schema)) return Function(schema);
-    if (Types.TypeGuard.IsInteger(schema)) return Integer(schema);
-    if (Types.TypeGuard.IsIntersect(schema)) return Intersect(schema);
-    if (Types.TypeGuard.IsLiteral(schema)) return Literal(schema);
-    if (Types.TypeGuard.IsNever(schema)) return Never(schema);
-    if (Types.TypeGuard.IsNull(schema)) return Null(schema);
-    if (Types.TypeGuard.IsNumber(schema)) return Number(schema);
-    if (Types.TypeGuard.IsObject(schema)) return Object(schema);
-    if (Types.TypeGuard.IsPromise(schema)) return Promise(schema);
-    if (Types.TypeGuard.IsRecord(schema)) return Record(schema);
-    if (Types.TypeGuard.IsRef(schema)) return Ref(schema);
-    if (Types.TypeGuard.IsString(schema)) return String(schema);
-    if (Types.TypeGuard.IsTemplateLiteral(schema)) return TemplateLiteral(schema);
-    if (Types.TypeGuard.IsThis(schema)) return This(schema);
-    if (Types.TypeGuard.IsTuple(schema)) return Tuple(schema);
-    if (Types.TypeGuard.IsUint8Array(schema)) return UInt8Array(schema);
-    if (Types.TypeGuard.IsUndefined(schema)) return Undefined(schema);
-    if (Types.TypeGuard.IsUnion(schema)) return Union(schema);
-    if (Types.TypeGuard.IsUnknown(schema)) return Unknown(schema);
-    if (Types.TypeGuard.IsVoid(schema)) return Void(schema);
-    return UnsupportedType(schema);
-  }
-  export function Generate(model: TypeBoxModel): string {
-    const buffer: string[] = [];
-    for (const type of model.types.filter((type) => Types.TypeGuard.IsSchema(type))) {
-      const schema = Visit(type);
-      const encode = JSON.stringify(schema, null, 2);
-      buffer.push(`export const ${type.$id} = ${encode}`);
-    }
-    return Formatter.Format(buffer.join('\n'));
-  }
-}

package/src/schema/typebox/gen/codegen/model/model-to-typebox.ts

@@ -1,32 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox-codegen
-
-The MIT License (MIT)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-import { TypeBoxModel } from './model';
-
-export namespace ModelToTypeBox {
-  export function Generate(model: TypeBoxModel) {
-    return '// todo';
-  }
-}

package/src/schema/typebox/gen/codegen/model/model-to-typescript.ts

@@ -1,189 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox-codegen
-
-The MIT License (MIT)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-import * as Types from '@sinclair/typebox';
-import { TypeCompiler } from '@sinclair/typebox/compiler';
-import { Formatter } from '../common/formatter';
-import { TypeBoxModel } from './model';
-
-export namespace ModelToTypeScript {
-  function Any(schema: Types.TAny) {
-    return 'any';
-  }
-  function Array(schema: Types.TArray) {
-    const items = Visit(schema.items);
-    return `Array<${items}>`;
-  }
-  function Boolean(schema: Types.TBoolean) {
-    return 'boolean';
-  }
-  function BigInt(schema: Types.TBigInt) {
-    return 'bigint';
-  }
-  function Constructor(schema: Types.TConstructor) {
-    const params = schema.parameters.map((param) => Visit(param)).join(', ');
-    const returns = Visit(schema.returns);
-    return `(new (${params}) => ${returns})`;
-  }
-  function Date(schema: Types.TDate) {
-    return 'Date';
-  }
-  function Function(schema: Types.TFunction) {
-    const params = schema.parameters.map((param) => Visit(param)).join(', ');
-    const returns = Visit(schema.returns);
-    return `((${params}) => ${returns})`;
-  }
-  function Integer(schema: Types.TInteger) {
-    return 'number';
-  }
-  function Intersect(schema: Types.TIntersect) {
-    return schema.allOf.map((schema) => Visit(schema)).join(' & ');
-  }
-  function Literal(schema: Types.TLiteral) {
-    if (typeof schema.const === 'string') {
-      return `'${schema.const}'`;
-    } else {
-      return `${schema.const}`;
-    }
-  }
-  function Never(schema: Types.TNever) {
-    return 'never';
-  }
-  function Null(schema: Types.TNull) {
-    return 'null';
-  }
-  function String(schema: Types.TString) {
-    return 'string';
-  }
-  function Number(schema: Types.TNumber) {
-    return 'number';
-  }
-  function Object(schema: Types.TObject) {
-    const properties: string = globalThis.Object.entries(schema.properties)
-      .map(([key, value]) => {
-        return `${key}: ${Visit(value)}`;
-      })
-      .join(',\n');
-    return `{\n${properties}\n}`;
-  }
-  function Promise(schema: Types.TPromise) {
-    const item = Visit(schema.item);
-    return `Promise<${item}>`;
-  }
-  function Record(schema: Types.TRecord) {
-    for (const [key, value] of globalThis.Object.entries(schema.patternProperties)) {
-      const type = Visit(value);
-      if (key === '^(0|[1-9][0-9]*)$') {
-        return `Record<number, ${type}>`;
-      } else {
-        return `Record<string, ${type}>`;
-      }
-    }
-    throw Error('TypeBoxToTypeScript: Unreachable');
-  }
-  function Ref(schema: Types.TRef) {
-    return schema.$ref;
-  }
-  function This(schema: Types.TThis) {
-    return schema.$ref;
-  }
-  function Tuple(schema: Types.TTuple) {
-    if (schema.items === undefined) return `[]`;
-    const items = schema.items.map((schema) => Visit(schema)).join(', ');
-    return `[${items}]`;
-  }
-  function UInt8Array(schema: Types.TUint8Array) {
-    return `Uint8Array`;
-  }
-  function Undefined(schema: Types.TUndefined) {
-    return `undefined`;
-  }
-  function Union(schema: Types.TUnion) {
-    return schema.anyOf.map((schema) => Visit(schema)).join(' | ');
-  }
-  function Unknown(schema: Types.TUnknown) {
-    return `unknown`;
-  }
-  function Void(schema: Types.TVoid) {
-    return `void`;
-  }
-  function Visit(schema: Types.TSchema): string {
-    if (reference_map.has(schema.$id!)) return schema.$id!;
-    if (schema.$id !== undefined) reference_map.set(schema.$id, schema);
-    if (Types.TypeGuard.IsAny(schema)) return Any(schema);
-    if (Types.TypeGuard.IsArray(schema)) return Array(schema);
-    if (Types.TypeGuard.IsBoolean(schema)) return Boolean(schema);
-    if (Types.TypeGuard.IsBigInt(schema)) return BigInt(schema);
-    if (Types.TypeGuard.IsConstructor(schema)) return Constructor(schema);
-    if (Types.TypeGuard.IsDate(schema)) return Date(schema);
-    if (Types.TypeGuard.IsFunction(schema)) return Function(schema);
-    if (Types.TypeGuard.IsInteger(schema)) return Integer(schema);
-    if (Types.TypeGuard.IsIntersect(schema)) return Intersect(schema);
-    if (Types.TypeGuard.IsLiteral(schema)) return Literal(schema);
-    if (Types.TypeGuard.IsNever(schema)) return Never(schema);
-    if (Types.TypeGuard.IsNull(schema)) return Null(schema);
-    if (Types.TypeGuard.IsNumber(schema)) return Number(schema);
-    if (Types.TypeGuard.IsObject(schema)) return Object(schema);
-    if (Types.TypeGuard.IsPromise(schema)) return Promise(schema);
-    if (Types.TypeGuard.IsRecord(schema)) return Record(schema);
-    if (Types.TypeGuard.IsRef(schema)) return Ref(schema);
-    if (Types.TypeGuard.IsThis(schema)) return This(schema);
-    if (Types.TypeGuard.IsString(schema)) return String(schema);
-    if (Types.TypeGuard.IsTuple(schema)) return Tuple(schema);
-    if (Types.TypeGuard.IsUint8Array(schema)) return UInt8Array(schema);
-    if (Types.TypeGuard.IsUndefined(schema)) return Undefined(schema);
-    if (Types.TypeGuard.IsUnion(schema)) return Union(schema);
-    if (Types.TypeGuard.IsUnknown(schema)) return Unknown(schema);
-    if (Types.TypeGuard.IsVoid(schema)) return Void(schema);
-    return 'unknown';
-  }
-  export function GenerateType(model: TypeBoxModel, $id: string) {
-    reference_map.clear();
-    const type = model.types.find((type) => type.$id === $id);
-    if (type === undefined) return `export type ${$id} = unknown`;
-    return `export type ${type.$id!} = ${Visit(type)}`;
-  }
-  const reference_map = new Map<string, Types.TSchema>();
-  export function Generate(model: TypeBoxModel): string {
-    reference_map.clear();
-    const definitions: string[] = [];
-    for (const type of model.types) {
-      const definition = `export type ${type.$id!} = ${Visit(type)}`;
-      const assertion = `export const ${type.$id!} = (() => { ${TypeCompiler.Code(type, model.types, {
-        language: 'typescript',
-      })} })();`;
-      const rewritten = assertion.replaceAll(
-        `return function check(value: any): boolean`,
-        `return function check(value: any): value is ${type.$id!}`,
-      );
-      definitions.push(`
-      ${definition}
-      ${rewritten}
-      `);
-    }
-    const output = [...definitions];
-    return Formatter.Format(output.join('\n\n'));
-  }
-}

package/src/schema/typebox/gen/codegen/model/model-to-valibot.ts

@@ -1,236 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox-codegen
-
-The MIT License (MIT)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-import * as Types from '@sinclair/typebox';
-import { Formatter, PropertyEncoder } from '../common/index';
-import { TypeBoxModel } from './model';
-import { ModelToTypeScript } from './model-to-typescript';
-
-// --------------------------------------------------------------------------
-// ModelToValibot
-// --------------------------------------------------------------------------
-export namespace ModelToValibot {
-  function IsDefined<T = any>(value: unknown): value is T {
-    return value !== undefined;
-  }
-  function Type(type: string, parameter: string | null, constraints: string[]) {
-    if (constraints.length > 0) {
-      if (typeof parameter === 'string') {
-        return `${type}(${parameter}, [${constraints.join(', ')}])`;
-      } else {
-        return `${type}([${constraints.join(', ')}])`;
-      }
-    } else {
-      if (typeof parameter === 'string') {
-        return `${type}(${parameter})`;
-      } else {
-        return `${type}()`;
-      }
-    }
-  }
-  function Any(schema: Types.TAny) {
-    return Type(`v.any`, null, []);
-  }
-  function Array(schema: Types.TArray) {
-    const items = Visit(schema.items);
-    const constraints: string[] = [];
-    if (IsDefined<number>(schema.minItems)) constraints.push(`v.minLength(${schema.minItems})`);
-    if (IsDefined<number>(schema.maxItems)) constraints.push(`v.maxLength(${schema.maxItems})`);
-    return Type(`v.array`, items, constraints);
-  }
-  function BigInt(schema: Types.TBigInt) {
-    return Type(`v.bigint`, null, []);
-  }
-  function Boolean(schema: Types.TBoolean) {
-    return Type(`v.boolean`, null, []);
-  }
-  function Date(schema: Types.TDate) {
-    return Type(`v.date`, null, []);
-  }
-  function Constructor(schema: Types.TConstructor): string {
-    return UnsupportedType(schema);
-  }
-  function Function(schema: Types.TFunction) {
-    return UnsupportedType(schema);
-  }
-  function Integer(schema: Types.TInteger) {
-    return Type(`v.number`, null, [`v.integer()`]);
-  }
-  function Intersect(schema: Types.TIntersect) {
-    const inner = schema.allOf.map((inner) => Visit(inner));
-    return Type(`v.merge`, `[${inner.join(', ')}]`, []);
-  }
-  function Literal(schema: Types.TLiteral) {
-    // prettier-ignore
-    return typeof schema.const === `string` 
-      ? Type(`v.literal`, `'${schema.const}'`, []) 
-      : Type(`v.literal`, `${schema.const}`, [])
-  }
-  function Never(schema: Types.TNever) {
-    return Type(`v.never`, null, []);
-  }
-  function Null(schema: Types.TNull) {
-    return Type(`v.nullType`, null, []);
-  }
-  function String(schema: Types.TString) {
-    const constraints: string[] = [];
-    if (IsDefined<number>(schema.maxLength)) constraints.push(`v.maxLength(${schema.maxLength})`);
-    if (IsDefined<number>(schema.minLength)) constraints.push(`v.minLength(${schema.minLength})`);
-    return Type(`v.string`, null, constraints);
-  }
-  function Number(schema: Types.TNumber) {
-    const constraints: string[] = [];
-    if (IsDefined<number>(schema.minimum)) constraints.push(`v.minValue(${schema.minimum})`);
-    if (IsDefined<number>(schema.maximum)) constraints.push(`v.maxValue(${schema.maximum})`);
-    if (IsDefined<number>(schema.exclusiveMinimum)) constraints.push(`v.minValue(${schema.exclusiveMinimum + 1})`);
-    if (IsDefined<number>(schema.exclusiveMaximum)) constraints.push(`v.maxValue(${schema.exclusiveMaximum - 1})`);
-    return Type('v.number', null, constraints);
-  }
-  function Object(schema: Types.TObject) {
-    // prettier-ignore
-    const properties = globalThis.Object.entries(schema.properties).map(([key, value]) => {
-      const optional = Types.TypeGuard.IsOptional(value)
-      const property = PropertyEncoder.Encode(key)
-      return optional ? `${property}: v.optional(${Visit(value)})` : `${property}: ${Visit(value)}`
-    }).join(`,`)
-    const constraints: string[] = [];
-    return Type(`v.object`, `{\n${properties}\n}`, constraints);
-  }
-  function Promise(schema: Types.TPromise) {
-    return UnsupportedType(schema);
-  }
-  function Record(schema: Types.TRecord) {
-    for (const [key, value] of globalThis.Object.entries(schema.patternProperties)) {
-      const type = Visit(value);
-      if (key === `^(0|[1-9][0-9]*)$`) {
-        return UnsupportedType(schema);
-      } else {
-        return Type(`v.record`, type, []);
-      }
-    }
-    throw Error(`Unreachable`);
-  }
-  function Ref(schema: Types.TRef) {
-    if (!reference_map.has(schema.$ref!)) return UnsupportedType(schema);
-    return schema.$ref;
-  }
-  function This(schema: Types.TThis) {
-    return UnsupportedType(schema);
-  }
-  function Tuple(schema: Types.TTuple) {
-    if (schema.items === undefined) return `[]`;
-    const items = schema.items.map((schema) => Visit(schema)).join(`, `);
-    return Type(`v.tuple`, `[${items}]`, []);
-  }
-  function TemplateLiteral(schema: Types.TTemplateLiteral) {
-    const constaint = Type(`v.regex`, `/${schema.pattern}/`, []);
-    return Type(`v.string`, null, [constaint]);
-  }
-  function UInt8Array(schema: Types.TUint8Array): string {
-    return UnsupportedType(schema);
-  }
-  function Undefined(schema: Types.TUndefined) {
-    return Type(`v.undefinedType`, null, []);
-  }
-  function Union(schema: Types.TUnion) {
-    const inner = schema.anyOf.map((schema) => Visit(schema)).join(`, `);
-    return Type(`v.union`, `[${inner}]`, []);
-  }
-  function Unknown(schema: Types.TUnknown) {
-    return Type(`v.unknown`, null, []);
-  }
-  function Void(schema: Types.TVoid) {
-    return Type(`v.voidType`, null, []);
-  }
-  function UnsupportedType(schema: Types.TSchema) {
-    return `v.any(/* unsupported */)`;
-  }
-  function Visit(schema: Types.TSchema): string {
-    if (schema.$id !== undefined) reference_map.set(schema.$id, schema);
-    if (schema.$id !== undefined && emitted_set.has(schema.$id!)) return schema.$id!;
-    if (Types.TypeGuard.IsAny(schema)) return Any(schema);
-    if (Types.TypeGuard.IsArray(schema)) return Array(schema);
-    if (Types.TypeGuard.IsBigInt(schema)) return BigInt(schema);
-    if (Types.TypeGuard.IsBoolean(schema)) return Boolean(schema);
-    if (Types.TypeGuard.IsDate(schema)) return Date(schema);
-    if (Types.TypeGuard.IsConstructor(schema)) return Constructor(schema);
-    if (Types.TypeGuard.IsFunction(schema)) return Function(schema);
-    if (Types.TypeGuard.IsInteger(schema)) return Integer(schema);
-    if (Types.TypeGuard.IsIntersect(schema)) return Intersect(schema);
-    if (Types.TypeGuard.IsLiteral(schema)) return Literal(schema);
-    if (Types.TypeGuard.IsNever(schema)) return Never(schema);
-    if (Types.TypeGuard.IsNull(schema)) return Null(schema);
-    if (Types.TypeGuard.IsNumber(schema)) return Number(schema);
-    if (Types.TypeGuard.IsObject(schema)) return Object(schema);
-    if (Types.TypeGuard.IsPromise(schema)) return Promise(schema);
-    if (Types.TypeGuard.IsRecord(schema)) return Record(schema);
-    if (Types.TypeGuard.IsRef(schema)) return Ref(schema);
-    if (Types.TypeGuard.IsString(schema)) return String(schema);
-    if (Types.TypeGuard.IsTemplateLiteral(schema)) return TemplateLiteral(schema);
-    if (Types.TypeGuard.IsThis(schema)) return This(schema);
-    if (Types.TypeGuard.IsTuple(schema)) return Tuple(schema);
-    if (Types.TypeGuard.IsUint8Array(schema)) return UInt8Array(schema);
-    if (Types.TypeGuard.IsUndefined(schema)) return Undefined(schema);
-    if (Types.TypeGuard.IsUnion(schema)) return Union(schema);
-    if (Types.TypeGuard.IsUnknown(schema)) return Unknown(schema);
-    if (Types.TypeGuard.IsVoid(schema)) return Void(schema);
-    return UnsupportedType(schema);
-  }
-  function Collect(schema: Types.TSchema) {
-    return [...Visit(schema)].join(``);
-  }
-  function GenerateType(model: TypeBoxModel, schema: Types.TSchema, references: Types.TSchema[]) {
-    const output: string[] = [];
-    for (const reference of references) {
-      if (reference.$id === undefined) return UnsupportedType(schema);
-      reference_map.set(reference.$id, reference);
-    }
-    const type = Collect(schema);
-    if (recursive_set.has(schema.$id!)) {
-      output.push(`export ${ModelToTypeScript.GenerateType(model, schema.$id!)}`);
-      output.push(
-        `export const ${schema.$id || `T`}: v.Output<${schema.$id}> = v.lazy(() => ${Formatter.Format(type)})`,
-      );
-    } else {
-      output.push(`export type ${schema.$id} = v.Output<typeof ${schema.$id}>`);
-      output.push(`export const ${schema.$id || `T`} = ${Formatter.Format(type)}`);
-    }
-    if (schema.$id) emitted_set.add(schema.$id);
-    return output.join('\n');
-  }
-  const reference_map = new Map<string, Types.TSchema>();
-  const recursive_set = new Set<string>();
-  const emitted_set = new Set<string>();
-  export function Generate(model: TypeBoxModel): string {
-    reference_map.clear();
-    recursive_set.clear();
-    emitted_set.clear();
-    const buffer: string[] = [`import * as v from 'valibot'`, ''];
-    for (const type of model.types.filter((type) => Types.TypeGuard.IsSchema(type))) {
-      buffer.push(GenerateType(model, type, model.types));
-    }
-    return Formatter.Format(buffer.join('\n'));
-  }
-}

package/src/schema/typebox/gen/codegen/model/model-to-value.ts

@@ -1,42 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox-codegen
-
-The MIT License (MIT)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-import { Value } from '@sinclair/typebox/value';
-import { Formatter } from '../common/formatter';
-import { TypeBoxModel } from './model';
-
-export namespace ModelToValue {
-  export function Generate(model: TypeBoxModel): string {
-    const definitions: string[] = [];
-
-    for (const type of model.types) {
-      definitions.push(`
-      export const ${type.$id!} = ${JSON.stringify(Value.Create(type, model.types))};
-      `);
-    }
-    const output = [...definitions];
-    return output.join('\n\n');
-  }
-}