@wener/utils 1.1.27 → 1.1.30

package/lib/schema/typebox/gen/codegen/model/model-to-io-ts.js

@@ -1,316 +1,253 @@
 import * as Types from '@sinclair/typebox';
-import { PropertyEncoder } from '../common/encoder.js';
-import { Formatter } from '../common/formatter.js';
-import '../common/jsdoc.js';
-import { ModelToTypeScript } from './model-to-typescript.js';
-
-var ModelToIoTs;
-((ModelToIoTs2) => {
-  function IsDefined(value) {
-    return value !== void 0;
-  }
-  function Type(schema, type) {
-    return type;
-  }
-  function Any(schema) {
-    return Type(schema, `t.any`);
-  }
-  function Array(schema) {
-    const items = Visit(schema.items);
-    const type = `t.array(${items})`;
-    const refinements = [];
-    if (IsDefined(schema.minItems))
-      refinements.push(`value.length >= ${schema.minItems}`);
-    if (IsDefined(schema.maxItems))
-      refinements.push(`value.length <= ${schema.maxItems}`);
-    return refinements.length === 0 ? type : `t.refinement(${type}, value => ${refinements.join("&&")})`;
-  }
-  function BigInt(schema) {
-    return `t.bigint`;
-  }
-  function Boolean(schema) {
-    return `t.boolean`;
-  }
-  const support_types = /* @__PURE__ */ new Map();
-  function Date(schema) {
-    support_types.set(
-      "Date",
-      ` const t_Date = new t.Type<Date, Date, unknown>(
+import { Formatter, PropertyEncoder } from '../common/index';
+import { ModelToTypeScript } from './model-to-typescript';
+// --------------------------------------------------------------------------
+// ModelToIoTs
+// --------------------------------------------------------------------------
+export var ModelToIoTs;
+(function(ModelToIoTs) {
+    function IsDefined(value) {
+        return value !== undefined;
+    }
+    function Type(schema, type) {
+        return type;
+    }
+    function Any(schema) {
+        return Type(schema, `t.any`);
+    }
+    function Array(schema) {
+        const items = Visit(schema.items);
+        const type = `t.array(${items})`;
+        const refinements = [];
+        if (IsDefined(schema.minItems)) refinements.push(`value.length >= ${schema.minItems}`);
+        if (IsDefined(schema.maxItems)) refinements.push(`value.length <= ${schema.maxItems}`);
+        return refinements.length === 0 ? type : `t.refinement(${type}, value => ${refinements.join('&&')})`;
+    }
+    function BigInt(schema) {
+        return `t.bigint`;
+    }
+    function Boolean(schema) {
+        return `t.boolean`;
+    }
+    const support_types = new Map();
+    function Date(schema) {
+        support_types.set('Date', ` const t_Date = new t.Type<Date, Date, unknown>(
       'Date',
       (value: unknown): value is Date => value instanceof Date,
       (value, context) => (value instanceof Date ? t.success(value) : t.failure(value, context)),
       t.identity
-    )`
-    );
-    return `t_Date`;
-  }
-  function Constructor(schema) {
-    support_types.set(
-      "Constructor",
-      `const t_Constructor = new t.Type<Function, Function, unknown>(
+    )`);
+        return `t_Date`;
+    }
+    function Constructor(schema) {
+        support_types.set('Constructor', `const t_Constructor = new t.Type<Function, Function, unknown>(
       'Constructor',
       (value: unknown): value is Function => typeof value === 'function',
       (value, context) => (typeof value === 'function' ? t.success(value) : t.failure(value, context)),
       t.identity
-    )`
-    );
-    return `t_Constructor`;
-  }
-  function Function(schema) {
-    support_types.set(
-      "Function",
-      `const t_Function = new t.Type<Function, Function, unknown>(
+    )`);
+        return `t_Constructor`;
+    }
+    function Function(schema) {
+        support_types.set('Function', `const t_Function = new t.Type<Function, Function, unknown>(
       'Function',
       (value: unknown): value is Function => typeof value === 'function',
       (value, context) => (typeof value === 'function' ? t.success(value) : t.failure(value, context)),
       t.identity
-    )`
-    );
-    return `t_Function`;
-  }
-  function Integer(schema) {
-    const type = `t.number`;
-    const refinements = [];
-    refinements.push(`value => Number.isInteger(value)`);
-    if (IsDefined(schema.minimum))
-      refinements.push(`value >= ${schema.minimum}`);
-    if (IsDefined(schema.maximum))
-      refinements.push(`value <= ${schema.maximum}`);
-    if (IsDefined(schema.exclusiveMaximum))
-      refinements.push(`value > ${schema.exclusiveMinimum}`);
-    if (IsDefined(schema.exclusiveMinimum))
-      refinements.push(`value < ${schema.exclusiveMaximum}`);
-    if (IsDefined(schema.multipleOf))
-      refinements.push(`value % ${schema.multipleOf} === 0`);
-    return `t.refinement(${type}, value => ${refinements.join("&&")})`;
-  }
-  function Intersect(schema) {
-    const types = schema.allOf.map((type) => Visit(type));
-    return `t.intersection([${types.join(", ")}])`;
-  }
-  function Literal(schema) {
-    return typeof schema.const === `string` ? Type(schema, `t.literal('${schema.const}')`) : Type(schema, `t.literal(${schema.const})`);
-  }
-  function Never(schema) {
-    return Type(schema, `t.never`);
-  }
-  function Null(schema) {
-    return Type(schema, `t.null`);
-  }
-  function String(schema) {
-    const type = `t.string`;
-    const refinements = [];
-    if (IsDefined(schema.minLength))
-      refinements.push(`value.length >= ${schema.minLength}`);
-    if (IsDefined(schema.maxLength))
-      refinements.push(`value.length <= ${schema.maxLength}`);
-    return refinements.length === 0 ? type : `t.refinement(${type}, value => ${refinements.join("&&")})`;
-  }
-  function Number(schema) {
-    const type = `t.number`;
-    const refinements = [];
-    if (IsDefined(schema.minimum))
-      refinements.push(`value >= ${schema.minimum}`);
-    if (IsDefined(schema.maximum))
-      refinements.push(`value <= ${schema.maximum}`);
-    if (IsDefined(schema.exclusiveMaximum))
-      refinements.push(`value > ${schema.exclusiveMinimum}`);
-    if (IsDefined(schema.exclusiveMinimum))
-      refinements.push(`value < ${schema.exclusiveMaximum}`);
-    if (IsDefined(schema.multipleOf))
-      refinements.push(`value % ${schema.multipleOf} === 0`);
-    return refinements.length === 0 ? type : `t.refinement(${type}, value => ${refinements.join("&&")})`;
-  }
-  function Object(schema) {
-    const properties = globalThis.Object.entries(schema.properties).map(([key, value]) => {
-      const optional = Types.TypeGuard.IsOptional(value);
-      const readonly = Types.TypeGuard.IsReadonly(value);
-      const property = PropertyEncoder.Encode(key);
-      const resolved = optional ? `t.union([t.undefined, ${Visit(value)}])` : Visit(value);
-      return readonly ? `${property} : t.readonly(${resolved})` : `${property} : ${resolved}`;
-    }).join(`,`);
-    const buffer = [];
-    if (schema.additionalProperties === false) {
-      buffer.push(`t.strict({
-${properties}
-})`);
-    } else {
-      buffer.push(`t.type({
-${properties}
-})`);
-    }
-    return Type(schema, buffer.join(``));
-  }
-  function Promise(schema) {
-    support_types.set(
-      "Promise",
-      `const t_Promise = new t.Type<Promise<any>, Promise<any>, unknown>(
+    )`);
+        return `t_Function`;
+    }
+    function Integer(schema) {
+        const type = `t.number`;
+        const refinements = [];
+        refinements.push(`value => Number.isInteger(value)`);
+        if (IsDefined(schema.minimum)) refinements.push(`value >= ${schema.minimum}`);
+        if (IsDefined(schema.maximum)) refinements.push(`value <= ${schema.maximum}`);
+        if (IsDefined(schema.exclusiveMaximum)) refinements.push(`value > ${schema.exclusiveMinimum}`);
+        if (IsDefined(schema.exclusiveMinimum)) refinements.push(`value < ${schema.exclusiveMaximum}`);
+        if (IsDefined(schema.multipleOf)) refinements.push(`value % ${schema.multipleOf} === 0`);
+        return `t.refinement(${type}, value => ${refinements.join('&&')})`;
+    }
+    function Intersect(schema) {
+        const types = schema.allOf.map((type)=>Visit(type));
+        return `t.intersection([${types.join(', ')}])`;
+    }
+    function Literal(schema) {
+        return typeof schema.const === `string` ? Type(schema, `t.literal('${schema.const}')`) : Type(schema, `t.literal(${schema.const})`);
+    }
+    function Never(schema) {
+        return Type(schema, `t.never`);
+    }
+    function Null(schema) {
+        return Type(schema, `t.null`);
+    }
+    function String(schema) {
+        const type = `t.string`;
+        const refinements = [];
+        if (IsDefined(schema.minLength)) refinements.push(`value.length >= ${schema.minLength}`);
+        if (IsDefined(schema.maxLength)) refinements.push(`value.length <= ${schema.maxLength}`);
+        return refinements.length === 0 ? type : `t.refinement(${type}, value => ${refinements.join('&&')})`;
+    }
+    function Number(schema) {
+        const type = `t.number`;
+        const refinements = [];
+        if (IsDefined(schema.minimum)) refinements.push(`value >= ${schema.minimum}`);
+        if (IsDefined(schema.maximum)) refinements.push(`value <= ${schema.maximum}`);
+        if (IsDefined(schema.exclusiveMaximum)) refinements.push(`value > ${schema.exclusiveMinimum}`);
+        if (IsDefined(schema.exclusiveMinimum)) refinements.push(`value < ${schema.exclusiveMaximum}`);
+        if (IsDefined(schema.multipleOf)) refinements.push(`value % ${schema.multipleOf} === 0`);
+        return refinements.length === 0 ? type : `t.refinement(${type}, value => ${refinements.join('&&')})`;
+    }
+    function Object(schema) {
+        // prettier-ignore
+        const properties = globalThis.Object.entries(schema.properties).map(([key, value])=>{
+            const optional = Types.TypeGuard.IsOptional(value);
+            const readonly = Types.TypeGuard.IsReadonly(value);
+            const property = PropertyEncoder.Encode(key);
+            const resolved = optional ? `t.union([t.undefined, ${Visit(value)}])` : Visit(value);
+            return readonly ? `${property} : t.readonly(${resolved})` : `${property} : ${resolved}`;
+        }).join(`,`);
+        const buffer = [];
+        if (schema.additionalProperties === false) {
+            buffer.push(`t.strict({\n${properties}\n})`);
+        } else {
+            buffer.push(`t.type({\n${properties}\n})`);
+        }
+        return Type(schema, buffer.join(``));
+    }
+    function Promise(schema) {
+        support_types.set('Promise', `const t_Promise = new t.Type<Promise<any>, Promise<any>, unknown>(
       'Promise',
       (value: unknown): value is Promise<unknown> => value instanceof Promise,
       (value, context) => (value instanceof Promise<unknown> ? t.success(value) : t.failure(value, context)),
       t.identity
-    )`
-    );
-    return `t_Promise`;
-  }
-  function Record(schema) {
-    for (const [key, value] of globalThis.Object.entries(schema.patternProperties)) {
-      const type = Visit(value);
-      if (key === `^(0|[1-9][0-9]*)$`) {
-        return `t.record(t.number, ${type})`;
-      } else {
-        return `t.record(t.string, ${type})`;
-      }
-    }
-    throw Error(`Unreachable`);
-  }
-  function Ref(schema) {
-    if (!reference_map.has(schema.$ref))
-      return UnsupportedType(schema);
-    return schema.$ref;
-  }
-  function This(schema) {
-    if (!reference_map.has(schema.$ref))
-      return UnsupportedType(schema);
-    recursive_set.add(schema.$ref);
-    return schema.$ref;
-  }
-  function Tuple(schema) {
-    if (schema.items === void 0)
-      return `[]`;
-    const items = schema.items.map((schema2) => Visit(schema2)).join(`, `);
-    return Type(schema, `t.tuple([${items}])`);
-  }
-  function TemplateLiteral(schema) {
-    return Type(schema, `t.refinement(t.string, value => /${schema.pattern}/.test(value))`);
-  }
-  function UInt8Array(schema) {
-    support_types.set(
-      "Uint8Array",
-      `const t_Uint8Array = new t.Type<Uint8Array, Uint8Array, unknown>(
+    )`);
+        return `t_Promise`;
+    }
+    function Record(schema) {
+        for (const [key, value] of globalThis.Object.entries(schema.patternProperties)){
+            const type = Visit(value);
+            if (key === `^(0|[1-9][0-9]*)$`) {
+                return `t.record(t.number, ${type})`;
+            } else {
+                return `t.record(t.string, ${type})`;
+            }
+        }
+        throw Error(`Unreachable`);
+    }
+    function Ref(schema) {
+        if (!reference_map.has(schema.$ref)) return UnsupportedType(schema); // throw new ModelToZodNonReferentialType(schema.$ref!)
+        return schema.$ref;
+    }
+    function This(schema) {
+        if (!reference_map.has(schema.$ref)) return UnsupportedType(schema); //throw new ModelToZodNonReferentialType(schema.$ref!)
+        recursive_set.add(schema.$ref);
+        return schema.$ref;
+    }
+    function Tuple(schema) {
+        if (schema.items === undefined) return `[]`;
+        const items = schema.items.map((schema)=>Visit(schema)).join(`, `);
+        return Type(schema, `t.tuple([${items}])`);
+    }
+    function TemplateLiteral(schema) {
+        return Type(schema, `t.refinement(t.string, value => /${schema.pattern}/.test(value))`);
+    }
+    function UInt8Array(schema) {
+        support_types.set('Uint8Array', `const t_Uint8Array = new t.Type<Uint8Array, Uint8Array, unknown>(
       'Uint8Array',
       (value: unknown): value is Uint8Array => value instanceof Uint8Array,
       (value, context) => (value instanceof Uint8Array ? t.success(value) : t.failure(value, context)),
       t.identity
-    )`
-    );
-    return `t_Uint8Array`;
-  }
-  function Undefined(schema) {
-    return Type(schema, `t.undefined`);
-  }
-  function Union(schema) {
-    return Type(schema, `t.union([${schema.anyOf.map((schema2) => Visit(schema2)).join(`, `)}])`);
-  }
-  function Unknown(schema) {
-    return Type(schema, `t.unknown`);
-  }
-  function Void(schema) {
-    return Type(schema, `t.void`);
-  }
-  function UnsupportedType(schema) {
-    return Type(schema, `t.any /* unresolved */`);
-  }
-  function Visit(schema) {
-    if (schema.$id !== void 0)
-      reference_map.set(schema.$id, schema);
-    if (schema.$id !== void 0 && 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();
-    if (Types.TypeGuard.IsBoolean(schema))
-      return Boolean();
-    if (Types.TypeGuard.IsDate(schema))
-      return Date();
-    if (Types.TypeGuard.IsConstructor(schema))
-      return Constructor();
-    if (Types.TypeGuard.IsFunction(schema))
-      return Function();
-    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();
-    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();
-    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) {
-    return [...Visit(schema)].join(``);
-  }
-  function GenerateType(model, schema, references) {
-    const output = [];
-    for (const reference of references) {
-      if (reference.$id === void 0)
+    )`);
+        return `t_Uint8Array`;
+    }
+    function Undefined(schema) {
+        return Type(schema, `t.undefined`);
+    }
+    function Union(schema) {
+        return Type(schema, `t.union([${schema.anyOf.map((schema)=>Visit(schema)).join(`, `)}])`);
+    }
+    function Unknown(schema) {
+        return Type(schema, `t.unknown`);
+    }
+    function Void(schema) {
+        return Type(schema, `t.void`);
+    }
+    function UnsupportedType(schema) {
+        return Type(schema, `t.any /* unresolved */`);
+    }
+    function Visit(schema) {
+        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);
-      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`}: t.Type<${schema.$id}> = t.recursion('${schema.$id}', () => ${Formatter.Format(type)})`
-      );
-    } else {
-      output.push(`export type ${schema.$id} = t.TypeOf<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 = /* @__PURE__ */ new Map();
-  const recursive_set = /* @__PURE__ */ new Set();
-  const emitted_set = /* @__PURE__ */ new Set();
-  function Generate(model) {
-    support_types.clear();
-    reference_map.clear();
-    recursive_set.clear();
-    emitted_set.clear();
-    const buffer = [`import t from 'io-ts'`, ""];
-    const types = model.types.filter((type) => Types.TypeGuard.IsSchema(type)).map((type) => GenerateType(model, type, model.types));
-    buffer.push(...support_types.values());
-    buffer.push("\n");
-    buffer.push(...types);
-    return Formatter.Format(buffer.join("\n"));
-  }
-  ModelToIoTs2.Generate = Generate;
+    }
+    function Collect(schema) {
+        return [
+            ...Visit(schema)
+        ].join(``);
+    }
+    function GenerateType(model, schema, references) {
+        const output = [];
+        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`}: t.Type<${schema.$id}> = t.recursion('${schema.$id}', () => ${Formatter.Format(type)})`);
+        } else {
+            output.push(`export type ${schema.$id} = t.TypeOf<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();
+    const recursive_set = new Set();
+    const emitted_set = new Set();
+    function Generate(model) {
+        support_types.clear();
+        reference_map.clear();
+        recursive_set.clear();
+        emitted_set.clear();
+        const buffer = [
+            `import t from 'io-ts'`,
+            ''
+        ];
+        const types = model.types.filter((type)=>Types.TypeGuard.IsSchema(type)).map((type)=>GenerateType(model, type, model.types));
+        buffer.push(...support_types.values());
+        buffer.push('\n');
+        buffer.push(...types);
+        return Formatter.Format(buffer.join('\n'));
+    }
+    ModelToIoTs.Generate = Generate;
 })(ModelToIoTs || (ModelToIoTs = {}));
 
-export { ModelToIoTs };
-//# sourceMappingURL=model-to-io-ts.js.map
+//# sourceMappingURL=model-to-io-ts.js.map