@duplojs/data-parser-tools 0.2.6 → 0.2.8

package/dist/index.cjs

@@ -2,8 +2,11 @@
 
 var index = require('./toTypescript/index.cjs');
 var index$1 = require('./toJsonSchema/index.cjs');
+require('./utils/index.cjs');
+var getRecursiveDataParser = require('./utils/getRecursiveDataParser.cjs');
 
 
 
 exports.DataParserToTypescript = index;
 exports.DataParserToJsonSchema = index$1;
+exports.getRecursiveDataParser = getRecursiveDataParser.getRecursiveDataParser;

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export * as DataParserToTypescript from "./toTypescript";
 export * as DataParserToJsonSchema from "./toJsonSchema";
+export * from "./utils";

package/dist/index.mjs

@@ -2,3 +2,5 @@ import * as index from './toTypescript/index.mjs';
 export { index as DataParserToTypescript };
 import * as index$1 from './toJsonSchema/index.mjs';
 export { index$1 as DataParserToJsonSchema };
+import './utils/index.mjs';
+export { getRecursiveDataParser } from './utils/getRecursiveDataParser.mjs';

package/dist/toJsonSchema/override.cjs

@@ -11,17 +11,19 @@ dataParser.dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, id
     newSchema.setIdentifier(identifier);
     return newSchema;
 });
-dataParser.dataParserInit.overrideHandler.setMethod("setOverrideJsonSchema", (schema, overrideJsonSchema) => {
-    schema.definition.overrideJsonSchema = "schema" in overrideJsonSchema
-        ? {
-            in: overrideJsonSchema,
-            out: overrideJsonSchema,
-        }
-        : overrideJsonSchema;
+dataParser.dataParserInit.overrideHandler.setMethod("setOverrideJsonSchemaTransformer", (schema, overrideTransformer) => {
+    if (overrideTransformer) {
+        schema.definition.overrideJsonSchemaTransformer = typeof overrideTransformer === "function"
+            ? overrideTransformer
+            : (__, { success }) => success(overrideTransformer.schema, overrideTransformer.isOptional);
+    }
+    else {
+        schema.definition.overrideJsonSchemaTransformer = undefined;
+    }
     return schema;
 });
-dataParser.dataParserInit.overrideHandler.setMethod("addOverrideJsonSchema", (schema, overrideJsonSchema) => {
+dataParser.dataParserInit.overrideHandler.setMethod("addOverrideJsonSchemaTransformer", (schema, overrideTransformer) => {
     const newSchema = schema.clone();
-    newSchema.setOverrideJsonSchema(overrideJsonSchema);
+    newSchema.setOverrideJsonSchemaTransformer(overrideTransformer);
     return newSchema;
 });

package/dist/toJsonSchema/override.d.ts

@@ -1,5 +1,4 @@
-import { type TransformerMode, type TransformerSuccess } from "./transformer/create";
-export type OverrideJsonSchemaDataParser = Partial<Record<TransformerMode, TransformerSuccess>>;
+import { type TransformerBuildFunction, type TransformerSuccess } from "./transformer/create";
 declare module "@duplojs/utils/dataParser" {
     interface DataParser {
         /**
@@ -8,13 +7,13 @@ declare module "@duplojs/utils/dataParser" {
         setIdentifier(input: string): this;
         addIdentifier(input: string): this;
         /**
-         * @deprecated this method mutated the dataParser by adding an override json schema
+         * @deprecated this method mutated the dataParser by adding an override transformer
          */
-        setOverrideJsonSchema(schema: TransformerSuccess | OverrideJsonSchemaDataParser): this;
-        addOverrideJsonSchema(schema: TransformerSuccess | OverrideJsonSchemaDataParser): this;
+        setOverrideJsonSchemaTransformer(transformer: TransformerSuccess | TransformerBuildFunction<this> | null): this;
+        addOverrideJsonSchemaTransformer(transformer: TransformerSuccess | TransformerBuildFunction<this> | null): this;
     }
     interface DataParserDefinition {
         identifier?: string;
-        overrideJsonSchema?: OverrideJsonSchemaDataParser;
+        overrideJsonSchemaTransformer?: TransformerBuildFunction;
     }
 }

package/dist/toJsonSchema/override.mjs

@@ -9,17 +9,19 @@ dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) =
     newSchema.setIdentifier(identifier);
     return newSchema;
 });
-dataParserInit.overrideHandler.setMethod("setOverrideJsonSchema", (schema, overrideJsonSchema) => {
-    schema.definition.overrideJsonSchema = "schema" in overrideJsonSchema
-        ? {
-            in: overrideJsonSchema,
-            out: overrideJsonSchema,
-        }
-        : overrideJsonSchema;
+dataParserInit.overrideHandler.setMethod("setOverrideJsonSchemaTransformer", (schema, overrideTransformer) => {
+    if (overrideTransformer) {
+        schema.definition.overrideJsonSchemaTransformer = typeof overrideTransformer === "function"
+            ? overrideTransformer
+            : (__, { success }) => success(overrideTransformer.schema, overrideTransformer.isOptional);
+    }
+    else {
+        schema.definition.overrideJsonSchemaTransformer = undefined;
+    }
     return schema;
 });
-dataParserInit.overrideHandler.setMethod("addOverrideJsonSchema", (schema, overrideJsonSchema) => {
+dataParserInit.overrideHandler.setMethod("addOverrideJsonSchemaTransformer", (schema, overrideTransformer) => {
     const newSchema = schema.clone();
-    newSchema.setOverrideJsonSchema(overrideJsonSchema);
+    newSchema.setOverrideJsonSchemaTransformer(overrideTransformer);
     return newSchema;
 });

package/dist/toJsonSchema/render.cjs

@@ -3,8 +3,9 @@
 var utils = require('@duplojs/utils');
 require('./transformer/index.cjs');
 var kind = require('./kind.cjs');
-var getRecursiveDataParser = require('../utils/getRecursiveDataParser.cjs');
+require('../utils/index.cjs');
 var transformer = require('./transformer/transformer.cjs');
+var getRecursiveDataParser = require('../utils/getRecursiveDataParser.cjs');
 var create = require('./transformer/create.cjs');
 
 class DataParserToJsonSchemaRenderError extends utils.kindHeritage("data-parser-to-json-schema-render-error", kind.createToJsonSchemaKind("data-parser-to-json-schema-render-error"), Error) {

package/dist/toJsonSchema/render.mjs

@@ -1,8 +1,9 @@
 import { kindHeritage, E, unwrap, G } from '@duplojs/utils';
 import './transformer/index.mjs';
 import { createToJsonSchemaKind } from './kind.mjs';
-import { getRecursiveDataParser } from '../utils/getRecursiveDataParser.mjs';
+import '../utils/index.mjs';
 import { transformer, buildRef } from './transformer/transformer.mjs';
+import { getRecursiveDataParser } from '../utils/getRecursiveDataParser.mjs';
 import { supportedVersions } from './transformer/create.mjs';
 
 class DataParserToJsonSchemaRenderError extends kindHeritage("data-parser-to-json-schema-render-error", createToJsonSchemaKind("data-parser-to-json-schema-render-error"), Error) {

package/dist/toJsonSchema/transformer/create.d.ts

@@ -41,4 +41,5 @@ export interface TransformerParams {
     success(result: JsonSchema, isOptional?: boolean): TransformerSuccessEither;
     buildError(): DataParserErrorEither;
 }
-export declare function createTransformer<GenericDataParser extends DP.DataParsers>(support: (schema: DP.DataParsers) => schema is GenericDataParser, builder: (schema: GenericDataParser, params: TransformerParams) => MaybeTransformerEither): (schema: DP.DataParsers, params: TransformerParams) => MaybeTransformerEither;
+export type TransformerBuildFunction<GenericDataParser extends DP.DataParsers = DP.DataParsers> = (schema: GenericDataParser, params: TransformerParams) => MaybeTransformerEither;
+export declare function createTransformer<GenericDataParser extends DP.DataParsers>(support: (schema: DP.DataParsers) => schema is GenericDataParser, builder: TransformerBuildFunction<GenericDataParser>): (schema: DP.DataParsers, params: TransformerParams) => MaybeTransformerEither;

package/dist/toJsonSchema/transformer/transformer.cjs

@@ -13,9 +13,6 @@ function buildRef(name, version) {
     return `#/definitions/${name}`;
 }
 function transformer(schema, params) {
-    if (schema.definition.overrideJsonSchema?.[params.mode]) {
-        return utils.E.right("buildSuccess", schema.definition.overrideJsonSchema[params.mode]);
-    }
     const currentSchema = utils.A.reduce(params.hooks, utils.A.reduceFrom(schema), ({ element: hook, lastValue, next, exit }) => {
         const result = hook({
             schema: lastValue,
@@ -64,16 +61,18 @@ function transformer(schema, params) {
             return utils.E.left("buildDataParserError", currentSchema);
         },
     };
-    const result = utils.A.reduce(params.transformers, utils.A.reduceFrom(utils.E.left("dataParserNotSupport", currentSchema)), ({ element: functionBuilder, lastValue, next, exit, }) => {
-        const result = functionBuilder(currentSchema, functionParams);
-        if (utils.E.isLeft(result)) {
-            if (utils.unwrap(result) !== currentSchema) {
-                return exit(result);
+    const result = currentSchema.definition.overrideJsonSchemaTransformer
+        ? currentSchema.definition.overrideJsonSchemaTransformer(currentSchema.addOverrideJsonSchemaTransformer(null), functionParams)
+        : utils.A.reduce(params.transformers, utils.A.reduceFrom(utils.E.left("dataParserNotSupport", currentSchema)), ({ element: functionBuilder, lastValue, next, exit, }) => {
+            const result = functionBuilder(currentSchema, functionParams);
+            if (utils.E.isLeft(result)) {
+                if (utils.unwrap(result) !== currentSchema) {
+                    return exit(result);
+                }
+                return next(lastValue);
             }
-            return next(lastValue);
-        }
-        return exit(result);
-    });
+            return exit(result);
+        });
     if (utils.E.isLeft(result)) {
         return result;
     }

package/dist/toJsonSchema/transformer/transformer.mjs

@@ -1,4 +1,4 @@
-import { E, A, whenElse, justReturn, unwrap } from '@duplojs/utils';
+import { A, E, whenElse, justReturn, unwrap } from '@duplojs/utils';
 
 function buildRef(name, version) {
     if (version === "openApi3"
@@ -11,9 +11,6 @@ function buildRef(name, version) {
     return `#/definitions/${name}`;
 }
 function transformer(schema, params) {
-    if (schema.definition.overrideJsonSchema?.[params.mode]) {
-        return E.right("buildSuccess", schema.definition.overrideJsonSchema[params.mode]);
-    }
     const currentSchema = A.reduce(params.hooks, A.reduceFrom(schema), ({ element: hook, lastValue, next, exit }) => {
         const result = hook({
             schema: lastValue,
@@ -62,16 +59,18 @@ function transformer(schema, params) {
             return E.left("buildDataParserError", currentSchema);
         },
     };
-    const result = A.reduce(params.transformers, A.reduceFrom(E.left("dataParserNotSupport", currentSchema)), ({ element: functionBuilder, lastValue, next, exit, }) => {
-        const result = functionBuilder(currentSchema, functionParams);
-        if (E.isLeft(result)) {
-            if (unwrap(result) !== currentSchema) {
-                return exit(result);
+    const result = currentSchema.definition.overrideJsonSchemaTransformer
+        ? currentSchema.definition.overrideJsonSchemaTransformer(currentSchema.addOverrideJsonSchemaTransformer(null), functionParams)
+        : A.reduce(params.transformers, A.reduceFrom(E.left("dataParserNotSupport", currentSchema)), ({ element: functionBuilder, lastValue, next, exit, }) => {
+            const result = functionBuilder(currentSchema, functionParams);
+            if (E.isLeft(result)) {
+                if (unwrap(result) !== currentSchema) {
+                    return exit(result);
+                }
+                return next(lastValue);
             }
-            return next(lastValue);
-        }
-        return exit(result);
-    });
+            return exit(result);
+        });
     if (E.isLeft(result)) {
         return result;
     }

package/dist/toTypescript/index.cjs

@@ -29,6 +29,7 @@ var union = require('./transformer/defaults/union.cjs');
 var unknown = require('./transformer/defaults/unknown.cjs');
 var date = require('./transformer/defaults/date.cjs');
 var time = require('./transformer/defaults/time.cjs');
+var file = require('./transformer/defaults/file.cjs');
 var includesUndefinedTypeNode = require('./transformer/includesUndefinedTypeNode.cjs');
 
 
@@ -61,4 +62,5 @@ exports.unionTransformer = union.unionTransformer;
 exports.unknownTransformer = unknown.unknownTransformer;
 exports.dateTransformer = date.dateTransformer;
 exports.timeTransformer = time.timeTransformer;
+exports.fileTransformer = file.fileTransformer;
 exports.includesUndefinedTypeNode = includesUndefinedTypeNode.includesUndefinedTypeNode;

package/dist/toTypescript/index.mjs

@@ -27,4 +27,5 @@ export { unionTransformer } from './transformer/defaults/union.mjs';
 export { unknownTransformer } from './transformer/defaults/unknown.mjs';
 export { dateTransformer } from './transformer/defaults/date.mjs';
 export { timeTransformer } from './transformer/defaults/time.mjs';
+export { fileTransformer } from './transformer/defaults/file.mjs';
 export { includesUndefinedTypeNode } from './transformer/includesUndefinedTypeNode.mjs';

package/dist/toTypescript/override.cjs

@@ -11,17 +11,19 @@ dataParser.dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, id
     newSchema.setIdentifier(identifier);
     return newSchema;
 });
-dataParser.dataParserInit.overrideHandler.setMethod("setOverrideTypeNode", (schema, overrideTypeNode) => {
-    schema.definition.overrideTypeNode = "kind" in overrideTypeNode
-        ? {
-            in: overrideTypeNode,
-            out: overrideTypeNode,
-        }
-        : overrideTypeNode;
+dataParser.dataParserInit.overrideHandler.setMethod("setOverrideTypescriptTransformer", (schema, overrideTransformer) => {
+    if (overrideTransformer) {
+        schema.definition.overrideTypescriptTransformer = typeof overrideTransformer === "function"
+            ? overrideTransformer
+            : (__, { success }) => success(overrideTransformer);
+    }
+    else {
+        schema.definition.overrideTypescriptTransformer = undefined;
+    }
     return schema;
 });
-dataParser.dataParserInit.overrideHandler.setMethod("addOverrideTypeNode", (schema, overrideTypeNode) => {
+dataParser.dataParserInit.overrideHandler.setMethod("addOverrideTypescriptTransformer", (schema, overrideTypeNode) => {
     const newSchema = schema.clone();
-    newSchema.setOverrideTypeNode(overrideTypeNode);
+    newSchema.setOverrideTypescriptTransformer(overrideTypeNode);
     return newSchema;
 });

package/dist/toTypescript/override.d.ts

@@ -1,6 +1,5 @@
 import { type TypeNode } from "typescript";
-import { type TransformerMode } from "./transformer";
-export type OverrideTypeNodeDataParser = Partial<Record<TransformerMode, TypeNode>>;
+import { type TransformerBuildFunction } from "./transformer";
 declare module "@duplojs/utils/dataParser" {
     interface DataParser {
         /**
@@ -9,13 +8,13 @@ declare module "@duplojs/utils/dataParser" {
         setIdentifier(input: string): this;
         addIdentifier(input: string): this;
         /**
-         * @deprecated this method mutated the dataParser by adding an override type node
+         * @deprecated this method mutated the dataParser by adding an override transformer
          */
-        setOverrideTypeNode(typeNode: TypeNode | OverrideTypeNodeDataParser): this;
-        addOverrideTypeNode(typeNode: TypeNode | OverrideTypeNodeDataParser): this;
+        setOverrideTypescriptTransformer(typeNode: TypeNode | TransformerBuildFunction<this> | null): this;
+        addOverrideTypescriptTransformer(typeNode: TypeNode | TransformerBuildFunction<this> | null): this;
     }
     interface DataParserDefinition {
         identifier?: string;
-        overrideTypeNode?: OverrideTypeNodeDataParser;
+        overrideTypescriptTransformer?: TransformerBuildFunction;
     }
 }

package/dist/toTypescript/override.mjs

@@ -9,17 +9,19 @@ dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) =
     newSchema.setIdentifier(identifier);
     return newSchema;
 });
-dataParserInit.overrideHandler.setMethod("setOverrideTypeNode", (schema, overrideTypeNode) => {
-    schema.definition.overrideTypeNode = "kind" in overrideTypeNode
-        ? {
-            in: overrideTypeNode,
-            out: overrideTypeNode,
-        }
-        : overrideTypeNode;
+dataParserInit.overrideHandler.setMethod("setOverrideTypescriptTransformer", (schema, overrideTransformer) => {
+    if (overrideTransformer) {
+        schema.definition.overrideTypescriptTransformer = typeof overrideTransformer === "function"
+            ? overrideTransformer
+            : (__, { success }) => success(overrideTransformer);
+    }
+    else {
+        schema.definition.overrideTypescriptTransformer = undefined;
+    }
     return schema;
 });
-dataParserInit.overrideHandler.setMethod("addOverrideTypeNode", (schema, overrideTypeNode) => {
+dataParserInit.overrideHandler.setMethod("addOverrideTypescriptTransformer", (schema, overrideTypeNode) => {
     const newSchema = schema.clone();
-    newSchema.setOverrideTypeNode(overrideTypeNode);
+    newSchema.setOverrideTypescriptTransformer(overrideTypeNode);
     return newSchema;
 });

package/dist/toTypescript/render.cjs

@@ -4,9 +4,10 @@ var utils = require('@duplojs/utils');
 require('./transformer/index.cjs');
 var typescript = require('typescript');
 var kind = require('./kind.cjs');
-var getRecursiveDataParser = require('../utils/getRecursiveDataParser.cjs');
+require('../utils/index.cjs');
 var importTypesTransformer = require('./transformer/importTypesTransformer.cjs');
 var transformer = require('./transformer/transformer.cjs');
+var getRecursiveDataParser = require('../utils/getRecursiveDataParser.cjs');
 
 class DataParserToTypescriptRenderError extends utils.kindHeritage("data-parser-to-typescript-render-error", kind.createToTypescriptKind("data-parser-to-typescript-render-error"), Error) {
     schema;
@@ -42,7 +43,7 @@ function render(schema, params) {
     return utils.pipe([
         ...importTypesTransformer.importTypesTransformer(importType),
         ...context.values(),
-    ], utils.G.map((value) => printer.printNode(typescript.EmitHint.Unspecified, value, sourceFile)), utils.A.from, utils.A.join("\n\n"), utils.S.trim);
+    ], utils.A.map((value) => printer.printNode(typescript.EmitHint.Unspecified, value, sourceFile)), utils.A.join("\n\n"), utils.S.trim);
 }
 
 exports.DataParserToTypescriptRenderError = DataParserToTypescriptRenderError;

package/dist/toTypescript/render.d.ts

@@ -1,4 +1,5 @@
-import { type DataParserErrorEither, type DataParserNotSupportedEither, type MapContext, type TransformerMode, type TransformerHook, type createTransformer, type SupportedDataParsers, type MapImportType } from "./transformer";
+import { DP } from "@duplojs/utils";
+import { type DataParserErrorEither, type DataParserNotSupportedEither, type MapContext, type TransformerMode, type TransformerHook, type createTransformer, type MapImportType } from "./transformer";
 export interface RenderParams {
     readonly identifier: string;
     readonly transformers: readonly ReturnType<typeof createTransformer>[];
@@ -11,9 +12,9 @@ declare const DataParserToTypescriptRenderError_base: new (params: {
     "@DuplojsDataParserToolsToTypescript/data-parser-to-typescript-render-error"?: unknown;
 }, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsDataParserToolsToTypescript/data-parser-to-typescript-render-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"data-parser-to-typescript-render-error", unknown>, unknown> & Error;
 export declare class DataParserToTypescriptRenderError extends DataParserToTypescriptRenderError_base {
-    schema: SupportedDataParsers;
+    schema: DP.DataParser;
     error: DataParserNotSupportedEither | DataParserErrorEither;
-    constructor(schema: SupportedDataParsers, error: DataParserNotSupportedEither | DataParserErrorEither);
+    constructor(schema: DP.DataParser, error: DataParserNotSupportedEither | DataParserErrorEither);
 }
-export declare function render(schema: SupportedDataParsers, params: RenderParams): string;
+export declare function render(schema: DP.DataParser, params: RenderParams): string;
 export {};

package/dist/toTypescript/render.mjs

@@ -1,10 +1,11 @@
-import { kindHeritage, E, DP, unwrap, pipe, G, A, S } from '@duplojs/utils';
+import { kindHeritage, E, DP, unwrap, pipe, A, S } from '@duplojs/utils';
 import './transformer/index.mjs';
 import { factory, SyntaxKind, createSourceFile, ScriptTarget, ScriptKind, createPrinter, EmitHint } from 'typescript';
 import { createToTypescriptKind } from './kind.mjs';
-import { getRecursiveDataParser } from '../utils/getRecursiveDataParser.mjs';
+import '../utils/index.mjs';
 import { importTypesTransformer } from './transformer/importTypesTransformer.mjs';
 import { transformer } from './transformer/transformer.mjs';
+import { getRecursiveDataParser } from '../utils/getRecursiveDataParser.mjs';
 
 class DataParserToTypescriptRenderError extends kindHeritage("data-parser-to-typescript-render-error", createToTypescriptKind("data-parser-to-typescript-render-error"), Error) {
     schema;
@@ -40,7 +41,7 @@ function render(schema, params) {
     return pipe([
         ...importTypesTransformer(importType),
         ...context.values(),
-    ], G.map((value) => printer.printNode(EmitHint.Unspecified, value, sourceFile)), A.from, A.join("\n\n"), S.trim);
+    ], A.map((value) => printer.printNode(EmitHint.Unspecified, value, sourceFile)), A.join("\n\n"), S.trim);
 }
 
 export { DataParserToTypescriptRenderError, render };

package/dist/toTypescript/transformer/create.d.ts

@@ -1,11 +1,9 @@
 import { type TypeAliasDeclaration, type TypeNode } from "typescript";
 import { type DP, E } from "@duplojs/utils";
-import { type SDP } from "@duplojs/server-utils";
 export type TransformerSuccessEither = E.Right<"buildSuccess", TypeNode>;
 export type DataParserNotSupportedEither = E.Left<"dataParserNotSupport", DP.DataParser>;
 export type DataParserErrorEither = E.Left<"buildDataParserError", DP.DataParser>;
-export type SupportedDataParsers = DP.DataParsers | SDP.DataParserFile;
-export type MapContext = Map<SupportedDataParsers, TypeAliasDeclaration>;
+export type MapContext = Map<DP.DataParsers, TypeAliasDeclaration>;
 export type MapImportType = Map<string, string[]>;
 export type MaybeTransformerEither = TransformerSuccessEither | DataParserNotSupportedEither | DataParserErrorEither;
 export type TransformerMode = "in" | "out";
@@ -18,4 +16,5 @@ export interface TransformerParams {
     buildError(): DataParserErrorEither;
     addImport(path: string, typeName: string): void;
 }
-export declare function createTransformer<GenericDataParser extends SupportedDataParsers>(support: (schema: SupportedDataParsers) => schema is GenericDataParser, builder: (schema: GenericDataParser, params: TransformerParams) => MaybeTransformerEither): (schema: SupportedDataParsers, params: TransformerParams) => MaybeTransformerEither;
+export type TransformerBuildFunction<GenericDataParser extends DP.DataParsers = DP.DataParsers> = (schema: GenericDataParser, params: TransformerParams) => MaybeTransformerEither;
+export declare function createTransformer<GenericDataParser extends DP.DataParsers>(support: (schema: DP.DataParsers) => schema is GenericDataParser, builder: TransformerBuildFunction<GenericDataParser>): (schema: DP.DataParsers, params: TransformerParams) => MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/array.d.ts

@@ -1 +1,2 @@
-export declare const arrayTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const arrayTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/bigint.d.ts

@@ -1 +1,2 @@
-export declare const bigIntTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const bigIntTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/boolean.d.ts

@@ -1 +1,2 @@
-export declare const booleanTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const booleanTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/date.d.ts

@@ -1 +1,2 @@
-export declare const dateTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const dateTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/empty.d.ts

@@ -1 +1,2 @@
-export declare const emptyTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const emptyTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/file.d.ts

@@ -1 +1 @@
-export declare const fileTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+export declare const fileTransformer: (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/index.cjs

@@ -72,4 +72,5 @@ exports.unionTransformer = union.unionTransformer;
 exports.unknownTransformer = unknown.unknownTransformer;
 exports.dateTransformer = date.dateTransformer;
 exports.timeTransformer = time.timeTransformer;
+exports.fileTransformer = file.fileTransformer;
 exports.defaultTransformers = defaultTransformers;

package/dist/toTypescript/transformer/defaults/index.d.ts

@@ -20,4 +20,5 @@ export * from "./union";
 export * from "./unknown";
 export * from "./date";
 export * from "./time";
-export declare const defaultTransformers: readonly [(schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither];
+export * from "./file";
+export declare const defaultTransformers: readonly [(schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (schema: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither];

package/dist/toTypescript/transformer/defaults/index.mjs

@@ -48,4 +48,4 @@ const defaultTransformers = [
     fileTransformer,
 ];
 
-export { arrayTransformer, bigIntTransformer, booleanTransformer, dateTransformer, defaultTransformers, emptyTransformer, lazyTransformer, literalTransformer, nilTransformer, nullableTransformer, numberTransformer, objectTransformer, optionalTransformer, pipeTransformer, recordTransformer, recoverTransformer, stringTransformer, templateLiteralTransformer, timeTransformer, transformTransformer, tupleTransformer, unionTransformer, unknownTransformer };
+export { arrayTransformer, bigIntTransformer, booleanTransformer, dateTransformer, defaultTransformers, emptyTransformer, fileTransformer, lazyTransformer, literalTransformer, nilTransformer, nullableTransformer, numberTransformer, objectTransformer, optionalTransformer, pipeTransformer, recordTransformer, recoverTransformer, stringTransformer, templateLiteralTransformer, timeTransformer, transformTransformer, tupleTransformer, unionTransformer, unknownTransformer };

package/dist/toTypescript/transformer/defaults/lazy.d.ts

@@ -1 +1,2 @@
-export declare const lazyTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const lazyTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/literal.cjs

@@ -11,6 +11,6 @@ const literalTransformer = create.createTransformer(utils.DP.literalKind.has, (s
     .when(utils.isType("bigint"), (value) => typescript.factory.createLiteralTypeNode(typescript.factory.createBigIntLiteral(`${value}n`)))
     .when(utils.isType("undefined"), () => typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.UndefinedKeyword))
     .when(utils.isType("null"), () => typescript.factory.createLiteralTypeNode(typescript.factory.createNull()))
-    .exhaustive()), typescript.factory.createUnionTypeNode, success));
+    .exhaustive()), utils.P.when(utils.A.lengthEqual(1), utils.A.at(0)), utils.P.otherwise(typescript.factory.createUnionTypeNode), success));
 
 exports.literalTransformer = literalTransformer;

package/dist/toTypescript/transformer/defaults/literal.d.ts

@@ -1 +1,2 @@
-export declare const literalTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const literalTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/literal.mjs

@@ -9,6 +9,6 @@ const literalTransformer = createTransformer(DP.literalKind.has, (schema, { succ
     .when(isType("bigint"), (value) => factory.createLiteralTypeNode(factory.createBigIntLiteral(`${value}n`)))
     .when(isType("undefined"), () => factory.createKeywordTypeNode(SyntaxKind.UndefinedKeyword))
     .when(isType("null"), () => factory.createLiteralTypeNode(factory.createNull()))
-    .exhaustive()), factory.createUnionTypeNode, success));
+    .exhaustive()), P.when(A.lengthEqual(1), A.at(0)), P.otherwise(factory.createUnionTypeNode), success));
 
 export { literalTransformer };

package/dist/toTypescript/transformer/defaults/nil.d.ts

@@ -1 +1,2 @@
-export declare const nilTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const nilTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/nullable.cjs

@@ -16,7 +16,7 @@ const nullableTransformer = create.createTransformer(utils.DP.nullableKind.has,
     }, (value) => utils.P.match(value)
         .with(utils.P.union({ mode: "in" }, {
         mode: "out",
-        coalescingValue: undefined,
+        coalescingValue: null,
     }), () => utils.pipe(typescript.factory.createNull(), typescript.factory.createLiteralTypeNode, (value) => typescript.factory.createUnionTypeNode([
         innerType,
         value,

package/dist/toTypescript/transformer/defaults/nullable.d.ts

@@ -1 +1,2 @@
-export declare const nullableTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const nullableTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/nullable.mjs

@@ -14,7 +14,7 @@ const nullableTransformer = createTransformer(DP.nullableKind.has, (schema, { tr
     }, (value) => P.match(value)
         .with(P.union({ mode: "in" }, {
         mode: "out",
-        coalescingValue: undefined,
+        coalescingValue: null,
     }), () => pipe(factory.createNull(), factory.createLiteralTypeNode, (value) => factory.createUnionTypeNode([
         innerType,
         value,

package/dist/toTypescript/transformer/defaults/number.d.ts

@@ -1 +1,2 @@
-export declare const numberTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const numberTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/object.d.ts

@@ -1 +1,2 @@
-export declare const objectTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const objectTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/optional.d.ts

@@ -1 +1,2 @@
-export declare const optionalTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const optionalTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/pipe.d.ts

@@ -1 +1,2 @@
-export declare const pipeTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const pipeTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/record.d.ts

@@ -1 +1,2 @@
-export declare const recordTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const recordTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/recover.d.ts

@@ -1 +1,2 @@
-export declare const recoverTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const recoverTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/string.d.ts

@@ -1 +1,2 @@
-export declare const stringTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const stringTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/templateLiteral.d.ts

@@ -1 +1,2 @@
-export declare const templateLiteralTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const templateLiteralTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/time.d.ts

@@ -1 +1,2 @@
-export declare const timeTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const timeTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/transform.d.ts

@@ -1 +1,2 @@
-export declare const transformTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const transformTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/tuple.d.ts

@@ -1 +1,2 @@
-export declare const tupleTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const tupleTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/union.d.ts

@@ -1 +1,2 @@
-export declare const unionTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const unionTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/defaults/unknown.d.ts

@@ -1 +1,2 @@
-export declare const unknownTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;
+import { DP } from "@duplojs/utils";
+export declare const unknownTransformer: (schema: DP.DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

package/dist/toTypescript/transformer/transformer.cjs

@@ -4,9 +4,6 @@ var utils = require('@duplojs/utils');
 var typescript = require('typescript');
 
 function transformer(schema, params) {
-    if (schema.definition.overrideTypeNode?.[params.mode]) {
-        return utils.E.right("buildSuccess", schema.definition.overrideTypeNode[params.mode]);
-    }
     const currentSchema = utils.A.reduce(params.hooks, utils.A.reduceFrom(schema), ({ element: hook, lastValue, next, exit }) => {
         const result = hook({
             schema: lastValue,
@@ -28,11 +25,15 @@ function transformer(schema, params) {
     if (currentDeclaration) {
         return utils.E.right("buildSuccess", typescript.factory.createTypeReferenceNode(currentDeclaration.name));
     }
-    const currentIdentifier = utils.whenElse(params.recursiveDataParsers, utils.A.includes(currentSchema), () => {
+    const currentIdentifier = utils.justExec(() => {
+        if (!utils.A.includes(params.recursiveDataParsers, currentSchema)
+            && !currentSchema.definition.identifier) {
+            return undefined;
+        }
         const identifier = currentSchema.definition.identifier ?? `RecursiveType${params.context.size}`;
         params.context.set(currentSchema, typescript.factory.createTypeAliasDeclaration([typescript.factory.createToken(typescript.SyntaxKind.ExportKeyword)], typescript.factory.createIdentifier(identifier), undefined, typescript.factory.createTypeReferenceNode(identifier)));
         return identifier;
-    }, utils.justReturn(currentSchema.definition.identifier));
+    });
     const functionParams = {
         success(result) {
             return utils.E.right("buildSuccess", result);
@@ -53,16 +54,18 @@ function transformer(schema, params) {
             }
         },
     };
-    const result = utils.A.reduce(params.transformers, utils.A.reduceFrom(utils.E.left("dataParserNotSupport", currentSchema)), ({ element: functionBuilder, lastValue, next, exit, }) => {
-        const result = functionBuilder(currentSchema, functionParams);
-        if (utils.E.isLeft(result)) {
-            if (utils.unwrap(result) !== currentSchema) {
-                return exit(result);
+    const result = currentSchema.definition.overrideTypescriptTransformer
+        ? currentSchema.definition.overrideTypescriptTransformer(currentSchema.addOverrideTypescriptTransformer(null), functionParams)
+        : utils.A.reduce(params.transformers, utils.A.reduceFrom(utils.E.left("dataParserNotSupport", currentSchema)), ({ element: functionBuilder, lastValue, next, exit, }) => {
+            const result = functionBuilder(currentSchema, functionParams);
+            if (utils.E.isLeft(result)) {
+                if (utils.unwrap(result) !== currentSchema) {
+                    return exit(result);
+                }
+                return next(lastValue);
             }
-            return next(lastValue);
-        }
-        return exit(result);
-    });
+            return exit(result);
+        });
     if (utils.E.isLeft(result)) {
         return result;
     }

package/dist/toTypescript/transformer/transformer.d.ts

@@ -1,12 +1,12 @@
-import { type DP } from "@duplojs/utils";
-import type { MapContext, DataParserNotSupportedEither, createTransformer, TransformerMode, DataParserErrorEither, MapImportType, SupportedDataParsers } from "./create";
+import { type DDataParser, type DP } from "@duplojs/utils";
+import type { MapContext, DataParserNotSupportedEither, createTransformer, TransformerMode, DataParserErrorEither, MapImportType } from "./create";
 import type { TransformerHook } from "./hook";
 export interface TransformerFunctionParams {
     readonly transformers: readonly ReturnType<typeof createTransformer>[];
     readonly context: MapContext;
     readonly mode: TransformerMode;
     readonly hooks: readonly TransformerHook[];
-    readonly recursiveDataParsers: SupportedDataParsers[];
+    readonly recursiveDataParsers: DDataParser.DataParser[];
     readonly importType: MapImportType;
 }
 export declare function transformer(schema: DP.DataParser, params: TransformerFunctionParams): import("./create").TransformerSuccessEither | DataParserNotSupportedEither | DataParserErrorEither;

package/dist/toTypescript/transformer/transformer.mjs

@@ -1,10 +1,7 @@
-import { E, A, whenElse, justReturn, unwrap } from '@duplojs/utils';
+import { A, E, justExec, unwrap } from '@duplojs/utils';
 import { factory, SyntaxKind } from 'typescript';
 
 function transformer(schema, params) {
-    if (schema.definition.overrideTypeNode?.[params.mode]) {
-        return E.right("buildSuccess", schema.definition.overrideTypeNode[params.mode]);
-    }
     const currentSchema = A.reduce(params.hooks, A.reduceFrom(schema), ({ element: hook, lastValue, next, exit }) => {
         const result = hook({
             schema: lastValue,
@@ -26,11 +23,15 @@ function transformer(schema, params) {
     if (currentDeclaration) {
         return E.right("buildSuccess", factory.createTypeReferenceNode(currentDeclaration.name));
     }
-    const currentIdentifier = whenElse(params.recursiveDataParsers, A.includes(currentSchema), () => {
+    const currentIdentifier = justExec(() => {
+        if (!A.includes(params.recursiveDataParsers, currentSchema)
+            && !currentSchema.definition.identifier) {
+            return undefined;
+        }
         const identifier = currentSchema.definition.identifier ?? `RecursiveType${params.context.size}`;
         params.context.set(currentSchema, factory.createTypeAliasDeclaration([factory.createToken(SyntaxKind.ExportKeyword)], factory.createIdentifier(identifier), undefined, factory.createTypeReferenceNode(identifier)));
         return identifier;
-    }, justReturn(currentSchema.definition.identifier));
+    });
     const functionParams = {
         success(result) {
             return E.right("buildSuccess", result);
@@ -51,16 +52,18 @@ function transformer(schema, params) {
             }
         },
     };
-    const result = A.reduce(params.transformers, A.reduceFrom(E.left("dataParserNotSupport", currentSchema)), ({ element: functionBuilder, lastValue, next, exit, }) => {
-        const result = functionBuilder(currentSchema, functionParams);
-        if (E.isLeft(result)) {
-            if (unwrap(result) !== currentSchema) {
-                return exit(result);
+    const result = currentSchema.definition.overrideTypescriptTransformer
+        ? currentSchema.definition.overrideTypescriptTransformer(currentSchema.addOverrideTypescriptTransformer(null), functionParams)
+        : A.reduce(params.transformers, A.reduceFrom(E.left("dataParserNotSupport", currentSchema)), ({ element: functionBuilder, lastValue, next, exit, }) => {
+            const result = functionBuilder(currentSchema, functionParams);
+            if (E.isLeft(result)) {
+                if (unwrap(result) !== currentSchema) {
+                    return exit(result);
+                }
+                return next(lastValue);
             }
-            return next(lastValue);
-        }
-        return exit(result);
-    });
+            return exit(result);
+        });
     if (E.isLeft(result)) {
         return result;
     }

package/dist/utils/getRecursiveDataParser.cjs

@@ -26,7 +26,17 @@ function getRecursiveDataParser(schema) {
             utils.DP.recoverKind,
             utils.DP.transformKind,
         ]), (dataParser) => void countDataParser(dataParser.definition.inner))
-            .when(utils.DP.lazyKind.has, (dataParser) => void countDataParser(dataParser.definition.getter.value))
+            .when(utils.DP.lazyKind.has, (dataParser) => {
+            const count = (countMap.get(dataParser) ?? 0) + 1;
+            countMap.set(dataParser, count);
+            if (count > 1) {
+                return;
+            }
+            countDataParser(dataParser.definition.getter.value);
+            if (countMap.get(dataParser) === 1) {
+                countMap.delete(dataParser);
+            }
+        })
             .when(utils.DP.pipeKind.has, (dataParser) => {
             countDataParser(dataParser.definition.input);
             countDataParser(dataParser.definition.output);

package/dist/utils/getRecursiveDataParser.mjs

@@ -24,7 +24,17 @@ function getRecursiveDataParser(schema) {
             DP.recoverKind,
             DP.transformKind,
         ]), (dataParser) => void countDataParser(dataParser.definition.inner))
-            .when(DP.lazyKind.has, (dataParser) => void countDataParser(dataParser.definition.getter.value))
+            .when(DP.lazyKind.has, (dataParser) => {
+            const count = (countMap.get(dataParser) ?? 0) + 1;
+            countMap.set(dataParser, count);
+            if (count > 1) {
+                return;
+            }
+            countDataParser(dataParser.definition.getter.value);
+            if (countMap.get(dataParser) === 1) {
+                countMap.delete(dataParser);
+            }
+        })
             .when(DP.pipeKind.has, (dataParser) => {
             countDataParser(dataParser.definition.input);
             countDataParser(dataParser.definition.output);

package/dist/utils/index.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var getRecursiveDataParser = require('./getRecursiveDataParser.cjs');
+
+
+
+exports.getRecursiveDataParser = getRecursiveDataParser.getRecursiveDataParser;

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export * from "./getRecursiveDataParser";

package/dist/utils/index.mjs

@@ -0,0 +1 @@
+export { getRecursiveDataParser } from './getRecursiveDataParser.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/data-parser-tools",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "license": "MIT",
   "author": "duplojs",
   "contributors": [
@@ -24,7 +24,7 @@
     "test:tu:bench": "vitest bench",
     "test:tu:watch": "vitest --coverage --watch",
     "test:tu:update": "vitest --coverage --update",
-    "test:types": "tsc -p tsconfig.test.json",
+    "test:types": "tsc -p tsconfig.test.json && npm -w integration run test:types",
     "test:lint": "eslint",
     "test:lint:fix": "eslint --fix",
     "prepare": "husky"
@@ -71,7 +71,7 @@
     "vitest": "3.2.4"
   },
   "peerDependencies": {
-    "@duplojs/utils": ">=1.5.1 <2.0.0",
+    "@duplojs/utils": ">=1.5.6 <2.0.0",
     "@duplojs/server-utils": ">=0.1.4 < 1.0.0"
   },
   "dependencies": {