@duplojs/data-parser-tools 0.2.9 → 0.4.0

package/dist/toTypescript/index.cjs

@@ -4,6 +4,8 @@ require('./transformer/index.cjs');
 require('./override.cjs');
 var render = require('./render.cjs');
 var kind = require('./kind.cjs');
+var buildContext = require('./buildContext.cjs');
+var printer = require('./printer.cjs');
 var index = require('./transformer/defaults/index.cjs');
 var create = require('./transformer/create.cjs');
 var transformer = require('./transformer/transformer.cjs');
@@ -31,12 +33,17 @@ 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');
+var createImportDeclaration = require('./transformer/createImportDeclaration.cjs');
+var addImport = require('./transformer/addImport.cjs');
+var createIdentifier = require('./transformer/createIdentifier.cjs');
 
 
 
 exports.DataParserToTypescriptRenderError = render.DataParserToTypescriptRenderError;
 exports.render = render.render;
 exports.createToTypescriptKind = kind.createToTypescriptKind;
+exports.buildContext = buildContext.buildContext;
+exports.printer = printer.printer;
 exports.defaultTransformers = index.defaultTransformers;
 exports.createTransformer = create.createTransformer;
 exports.transformer = transformer.transformer;
@@ -64,3 +71,6 @@ exports.dateTransformer = date.dateTransformer;
 exports.timeTransformer = time.timeTransformer;
 exports.fileTransformer = file.fileTransformer;
 exports.includesUndefinedTypeNode = includesUndefinedTypeNode.includesUndefinedTypeNode;
+exports.createImportDeclaration = createImportDeclaration.createImportDeclaration;
+exports.createAddImport = addImport.createAddImport;
+exports.createIdentifier = createIdentifier.createIdentifier;

package/dist/toTypescript/index.d.ts

@@ -2,3 +2,5 @@ export * from "./transformer";
 export * from "./override";
 export * from "./render";
 export * from "./kind";
+export * from "./buildContext";
+export * from "./printer";

package/dist/toTypescript/index.mjs

@@ -2,6 +2,8 @@ import './transformer/index.mjs';
 import './override.mjs';
 export { DataParserToTypescriptRenderError, render } from './render.mjs';
 export { createToTypescriptKind } from './kind.mjs';
+export { buildContext } from './buildContext.mjs';
+export { printer } from './printer.mjs';
 export { defaultTransformers } from './transformer/defaults/index.mjs';
 export { createTransformer } from './transformer/create.mjs';
 export { transformer } from './transformer/transformer.mjs';
@@ -29,3 +31,6 @@ 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';
+export { createImportDeclaration } from './transformer/createImportDeclaration.mjs';
+export { createAddImport } from './transformer/addImport.mjs';
+export { createIdentifier } from './transformer/createIdentifier.mjs';

package/dist/toTypescript/override.cjs

@@ -2,16 +2,16 @@
 
 var dataParser = require('@duplojs/utils/dataParser');
 
-dataParser.dataParserInit.overrideHandler.setMethod("setIdentifier", (schema, identifier) => {
+dataParser.dataParserBaseInit.overrideHandler.setMethod("setIdentifier", (schema, identifier) => {
     schema.definition.identifier = identifier;
     return schema;
 });
-dataParser.dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => {
+dataParser.dataParserBaseInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => {
     const newSchema = schema.clone();
     newSchema.setIdentifier(identifier);
     return newSchema;
 });
-dataParser.dataParserInit.overrideHandler.setMethod("setOverrideTypescriptTransformer", (schema, overrideTransformer) => {
+dataParser.dataParserBaseInit.overrideHandler.setMethod("setOverrideTypescriptTransformer", (schema, overrideTransformer) => {
     if (overrideTransformer) {
         schema.definition.overrideTypescriptTransformer = typeof overrideTransformer === "function"
             ? overrideTransformer
@@ -22,7 +22,7 @@ dataParser.dataParserInit.overrideHandler.setMethod("setOverrideTypescriptTransf
     }
     return schema;
 });
-dataParser.dataParserInit.overrideHandler.setMethod("addOverrideTypescriptTransformer", (schema, overrideTypeNode) => {
+dataParser.dataParserBaseInit.overrideHandler.setMethod("addOverrideTypescriptTransformer", (schema, overrideTypeNode) => {
     const newSchema = schema.clone();
     newSchema.setOverrideTypescriptTransformer(overrideTypeNode);
     return newSchema;

package/dist/toTypescript/override.d.ts

@@ -1,7 +1,7 @@
 import { type TypeNode } from "typescript";
 import { type TransformerBuildFunction } from "./transformer";
 declare module "@duplojs/utils/dataParser" {
-    interface DataParser {
+    interface DataParserBase {
         /**
          * @deprecated this method mutated the dataParser by adding an identifier
          */

package/dist/toTypescript/override.mjs

@@ -1,15 +1,15 @@
-import { dataParserInit } from '@duplojs/utils/dataParser';
+import { dataParserBaseInit } from '@duplojs/utils/dataParser';
 
-dataParserInit.overrideHandler.setMethod("setIdentifier", (schema, identifier) => {
+dataParserBaseInit.overrideHandler.setMethod("setIdentifier", (schema, identifier) => {
     schema.definition.identifier = identifier;
     return schema;
 });
-dataParserInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => {
+dataParserBaseInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => {
     const newSchema = schema.clone();
     newSchema.setIdentifier(identifier);
     return newSchema;
 });
-dataParserInit.overrideHandler.setMethod("setOverrideTypescriptTransformer", (schema, overrideTransformer) => {
+dataParserBaseInit.overrideHandler.setMethod("setOverrideTypescriptTransformer", (schema, overrideTransformer) => {
     if (overrideTransformer) {
         schema.definition.overrideTypescriptTransformer = typeof overrideTransformer === "function"
             ? overrideTransformer
@@ -20,7 +20,7 @@ dataParserInit.overrideHandler.setMethod("setOverrideTypescriptTransformer", (sc
     }
     return schema;
 });
-dataParserInit.overrideHandler.setMethod("addOverrideTypescriptTransformer", (schema, overrideTypeNode) => {
+dataParserBaseInit.overrideHandler.setMethod("addOverrideTypescriptTransformer", (schema, overrideTypeNode) => {
     const newSchema = schema.clone();
     newSchema.setOverrideTypescriptTransformer(overrideTypeNode);
     return newSchema;

package/dist/toTypescript/printer.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var typescript = require('typescript');
+var utils = require('@duplojs/utils');
+require('./transformer/index.cjs');
+var createImportDeclaration = require('./transformer/createImportDeclaration.cjs');
+
+function printer(params) {
+    const sourceFile = typescript.createSourceFile("print.ts", "", typescript.ScriptTarget.Latest, false, typescript.ScriptKind.TS);
+    const printer = typescript.createPrinter();
+    return utils.pipe([
+        ...createImportDeclaration.createImportDeclaration(params.importContext),
+        ...params.context.values(),
+    ], utils.A.map((value) => printer.printNode(typescript.EmitHint.Unspecified, value, sourceFile)), utils.A.join("\n\n"), utils.S.trim);
+}
+
+exports.printer = printer;

package/dist/toTypescript/printer.d.ts

@@ -0,0 +1,2 @@
+import { type BuildedContext } from "./buildContext";
+export declare function printer(params: BuildedContext): string;

package/dist/toTypescript/printer.mjs

@@ -0,0 +1,15 @@
+import { createSourceFile, ScriptTarget, ScriptKind, createPrinter, EmitHint } from 'typescript';
+import { pipe, A, S } from '@duplojs/utils';
+import './transformer/index.mjs';
+import { createImportDeclaration } from './transformer/createImportDeclaration.mjs';
+
+function printer(params) {
+    const sourceFile = createSourceFile("print.ts", "", ScriptTarget.Latest, false, ScriptKind.TS);
+    const printer = createPrinter();
+    return pipe([
+        ...createImportDeclaration(params.importContext),
+        ...params.context.values(),
+    ], A.map((value) => printer.printNode(EmitHint.Unspecified, value, sourceFile)), A.join("\n\n"), S.trim);
+}
+
+export { printer };

package/dist/toTypescript/render.cjs

@@ -1,49 +1,31 @@
 'use strict';
 
 var utils = require('@duplojs/utils');
-require('./transformer/index.cjs');
-var typescript = require('typescript');
 var kind = require('./kind.cjs');
-require('../utils/index.cjs');
-var importTypesTransformer = require('./transformer/importTypesTransformer.cjs');
-var transformer = require('./transformer/transformer.cjs');
-var getRecursiveDataParser = require('../utils/getRecursiveDataParser.cjs');
+var buildContext = require('./buildContext.cjs');
+var printer = require('./printer.cjs');
 
-class DataParserToTypescriptRenderError extends utils.kindHeritage("data-parser-to-typescript-render-error", kind.createToTypescriptKind("data-parser-to-typescript-render-error"), Error) {
+class DataParserToTypescriptRenderError extends utils.kindClass(kind.createToTypescriptKind("data-parser-to-typescript-render-error"), Error) {
     schema;
     error;
     constructor(schema, error) {
-        super({}, ["Error during the render of dataParser in typescript type."]);
+        super({}, "Error during the render of dataParser in typescript type.");
         this.schema = schema;
         this.error = error;
     }
 }
 function render(schema, params) {
     const context = new Map(params.context);
-    const importType = new Map(params.importType);
-    const result = transformer.transformer(schema, {
+    const importContext = new Map(params.importContext);
+    const result = buildContext.buildContext(schema, {
         ...params,
         context,
-        mode: params.mode ?? "out",
-        hooks: params.hooks ?? [],
-        recursiveDataParsers: getRecursiveDataParser.getRecursiveDataParser(schema),
-        importType,
+        importContext,
     });
     if (utils.E.isLeft(result)) {
         throw new DataParserToTypescriptRenderError(schema, result);
     }
-    if (schema.definition.identifier && schema.definition.identifier !== params.identifier) {
-        context.set(utils.DP.empty(), typescript.factory.createTypeAliasDeclaration([typescript.factory.createToken(typescript.SyntaxKind.ExportKeyword)], typescript.factory.createIdentifier(params.identifier), undefined, typescript.factory.createTypeReferenceNode(schema.definition.identifier)));
-    }
-    else if (schema.definition.identifier !== params.identifier) {
-        context.set(utils.DP.empty(), typescript.factory.createTypeAliasDeclaration([typescript.factory.createToken(typescript.SyntaxKind.ExportKeyword)], typescript.factory.createIdentifier(params.identifier), undefined, utils.unwrap(result)));
-    }
-    const sourceFile = typescript.createSourceFile("print.ts", "", typescript.ScriptTarget.Latest, false, typescript.ScriptKind.TS);
-    const printer = typescript.createPrinter();
-    return utils.pipe([
-        ...importTypesTransformer.importTypesTransformer(importType),
-        ...context.values(),
-    ], utils.A.map((value) => printer.printNode(typescript.EmitHint.Unspecified, value, sourceFile)), utils.A.join("\n\n"), utils.S.trim);
+    return printer.printer(utils.unwrap(result));
 }
 
 exports.DataParserToTypescriptRenderError = DataParserToTypescriptRenderError;

package/dist/toTypescript/render.d.ts

@@ -1,16 +1,9 @@
-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>[];
-    readonly context?: MapContext;
-    readonly mode?: TransformerMode;
-    readonly hooks?: readonly TransformerHook[];
-    readonly importType?: MapImportType;
+import { type DP } from "@duplojs/utils";
+import { type DataParserErrorEither, type DataParserNotSupportedEither } from "./transformer";
+import { type BuildContextParams } from "./buildContext";
+export interface RenderParams extends BuildContextParams {
 }
-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;
+declare const DataParserToTypescriptRenderError_base: import("@duplojs/utils").KindClass<import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsDataParserToolsToTypescript/data-parser-to-typescript-render-error", unknown>>, ErrorConstructor>;
 export declare class DataParserToTypescriptRenderError extends DataParserToTypescriptRenderError_base {
     schema: DP.DataParser;
     error: DataParserNotSupportedEither | DataParserErrorEither;

package/dist/toTypescript/render.mjs

@@ -1,47 +1,29 @@
-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 { kindClass, E, unwrap } from '@duplojs/utils';
 import { createToTypescriptKind } from './kind.mjs';
-import '../utils/index.mjs';
-import { importTypesTransformer } from './transformer/importTypesTransformer.mjs';
-import { transformer } from './transformer/transformer.mjs';
-import { getRecursiveDataParser } from '../utils/getRecursiveDataParser.mjs';
+import { buildContext } from './buildContext.mjs';
+import { printer } from './printer.mjs';
 
-class DataParserToTypescriptRenderError extends kindHeritage("data-parser-to-typescript-render-error", createToTypescriptKind("data-parser-to-typescript-render-error"), Error) {
+class DataParserToTypescriptRenderError extends kindClass(createToTypescriptKind("data-parser-to-typescript-render-error"), Error) {
     schema;
     error;
     constructor(schema, error) {
-        super({}, ["Error during the render of dataParser in typescript type."]);
+        super({}, "Error during the render of dataParser in typescript type.");
         this.schema = schema;
         this.error = error;
     }
 }
 function render(schema, params) {
     const context = new Map(params.context);
-    const importType = new Map(params.importType);
-    const result = transformer(schema, {
+    const importContext = new Map(params.importContext);
+    const result = buildContext(schema, {
         ...params,
         context,
-        mode: params.mode ?? "out",
-        hooks: params.hooks ?? [],
-        recursiveDataParsers: getRecursiveDataParser(schema),
-        importType,
+        importContext,
     });
     if (E.isLeft(result)) {
         throw new DataParserToTypescriptRenderError(schema, result);
     }
-    if (schema.definition.identifier && schema.definition.identifier !== params.identifier) {
-        context.set(DP.empty(), factory.createTypeAliasDeclaration([factory.createToken(SyntaxKind.ExportKeyword)], factory.createIdentifier(params.identifier), undefined, factory.createTypeReferenceNode(schema.definition.identifier)));
-    }
-    else if (schema.definition.identifier !== params.identifier) {
-        context.set(DP.empty(), factory.createTypeAliasDeclaration([factory.createToken(SyntaxKind.ExportKeyword)], factory.createIdentifier(params.identifier), undefined, unwrap(result)));
-    }
-    const sourceFile = createSourceFile("print.ts", "", ScriptTarget.Latest, false, ScriptKind.TS);
-    const printer = createPrinter();
-    return pipe([
-        ...importTypesTransformer(importType),
-        ...context.values(),
-    ], A.map((value) => printer.printNode(EmitHint.Unspecified, value, sourceFile)), A.join("\n\n"), S.trim);
+    return printer(unwrap(result));
 }
 
 export { DataParserToTypescriptRenderError, render };

package/dist/toTypescript/transformer/addImport.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+
+function createAddImport(importContext) {
+    return (path, typeName, type) => {
+        const importKind = type === undefined
+            ? "direct"
+            : type;
+        const imports = importContext.get(path) ?? {};
+        const identifiers = imports[importKind] ?? [];
+        if (!utils.A.includes(identifiers, typeName)) {
+            importContext.set(path, {
+                ...imports,
+                [importKind]: utils.A.push(identifiers, typeName),
+            });
+        }
+    };
+}
+
+exports.createAddImport = createAddImport;

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

@@ -0,0 +1,2 @@
+import type { MapImportContext } from "./create";
+export declare function createAddImport(importContext: MapImportContext): (path: string, typeName: string, type?: "default" | "namespace" | "direct") => void;

package/dist/toTypescript/transformer/addImport.mjs

@@ -0,0 +1,19 @@
+import { A } from '@duplojs/utils';
+
+function createAddImport(importContext) {
+    return (path, typeName, type) => {
+        const importKind = type === undefined
+            ? "direct"
+            : type;
+        const imports = importContext.get(path) ?? {};
+        const identifiers = imports[importKind] ?? [];
+        if (!A.includes(identifiers, typeName)) {
+            importContext.set(path, {
+                ...imports,
+                [importKind]: A.push(identifiers, typeName),
+            });
+        }
+    };
+}
+
+export { createAddImport };

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

@@ -4,17 +4,21 @@ 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 MapContext = Map<DP.DataParsers, TypeAliasDeclaration>;
-export type MapImportType = Map<string, string[]>;
+export type MapImportContext = Map<string, {
+    namespace?: string[];
+    default?: string[];
+    direct?: string[];
+}>;
 export type MaybeTransformerEither = TransformerSuccessEither | DataParserNotSupportedEither | DataParserErrorEither;
 export type TransformerMode = "in" | "out";
 export interface TransformerParams {
     readonly mode: TransformerMode;
     readonly context: MapContext;
-    readonly importType: MapImportType;
+    readonly importContext: MapImportContext;
     transformer(schema: DP.DataParser): MaybeTransformerEither;
     success(result: TypeNode): TransformerSuccessEither;
     buildError(): DataParserErrorEither;
-    addImport(path: string, typeName: string): void;
+    addImport(path: string, typeName: string, type?: "default" | "namespace" | "direct"): void;
 }
 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/createIdentifier.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+
+function createIdentifier(identifier) {
+    return utils.S.capitalize(identifier);
+}
+
+exports.createIdentifier = createIdentifier;

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

@@ -0,0 +1 @@
+export declare function createIdentifier(identifier: string): Capitalize<string>;

package/dist/toTypescript/transformer/createIdentifier.mjs

@@ -0,0 +1,7 @@
+import { S } from '@duplojs/utils';
+
+function createIdentifier(identifier) {
+    return S.capitalize(identifier);
+}
+
+export { createIdentifier };

package/dist/toTypescript/transformer/createImportDeclaration.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var typescript = require('typescript');
+
+function createImportDeclaration(importContext) {
+    return utils.A.reduce(utils.A.from(importContext), utils.A.reduceFrom([]), ({ element: [path, imports], lastValue, next }) => {
+        const declarations = utils.A.concat(lastValue, utils.A.map(imports.namespace ?? [], (identifier) => typescript.factory.createImportDeclaration(undefined, typescript.factory.createImportClause(undefined, undefined, typescript.factory.createNamespaceImport(typescript.factory.createIdentifier(identifier))), typescript.factory.createStringLiteral(path), undefined)), utils.A.map(imports.default ?? [], (identifier) => typescript.factory.createImportDeclaration(undefined, typescript.factory.createImportClause(undefined, typescript.factory.createIdentifier(identifier), undefined), typescript.factory.createStringLiteral(path), undefined)), imports.direct?.length
+            ? [
+                typescript.factory.createImportDeclaration(undefined, typescript.factory.createImportClause(undefined, undefined, typescript.factory.createNamedImports(utils.A.map(imports.direct, (identifier) => typescript.factory.createImportSpecifier(false, undefined, typescript.factory.createIdentifier(identifier))))), typescript.factory.createStringLiteral(path), undefined),
+            ]
+            : []);
+        return next(declarations);
+    });
+}
+
+exports.createImportDeclaration = createImportDeclaration;

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

@@ -0,0 +1,3 @@
+import type { MapImportContext } from "./create";
+import { type ImportDeclaration } from "typescript";
+export declare function createImportDeclaration(importContext: MapImportContext): ImportDeclaration[];

package/dist/toTypescript/transformer/createImportDeclaration.mjs

@@ -0,0 +1,15 @@
+import { A } from '@duplojs/utils';
+import { factory } from 'typescript';
+
+function createImportDeclaration(importContext) {
+    return A.reduce(A.from(importContext), A.reduceFrom([]), ({ element: [path, imports], lastValue, next }) => {
+        const declarations = A.concat(lastValue, A.map(imports.namespace ?? [], (identifier) => factory.createImportDeclaration(undefined, factory.createImportClause(undefined, undefined, factory.createNamespaceImport(factory.createIdentifier(identifier))), factory.createStringLiteral(path), undefined)), A.map(imports.default ?? [], (identifier) => factory.createImportDeclaration(undefined, factory.createImportClause(undefined, factory.createIdentifier(identifier), undefined), factory.createStringLiteral(path), undefined)), imports.direct?.length
+            ? [
+                factory.createImportDeclaration(undefined, factory.createImportClause(undefined, undefined, factory.createNamedImports(A.map(imports.direct, (identifier) => factory.createImportSpecifier(false, undefined, factory.createIdentifier(identifier))))), factory.createStringLiteral(path), undefined),
+            ]
+            : []);
+        return next(declarations);
+    });
+}
+
+export { createImportDeclaration };

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

@@ -1,5 +1,5 @@
 import type { DP } from "@duplojs/utils";
-import type { MapContext, MapImportType } from "./create";
+import type { MapContext, MapImportContext } from "./create";
 export type TransformerHookAction = "stop" | "next";
 export interface TransformerHookOutput {
     schema: DP.DataParsers;
@@ -8,7 +8,7 @@ export interface TransformerHookOutput {
 export interface TransformerHookParams {
     schema: DP.DataParsers;
     context: MapContext;
-    importType: MapImportType;
+    importContext: MapImportContext;
     output(action: TransformerHookAction, schema: DP.DataParsers): TransformerHookOutput;
 }
 export type TransformerHook = (params: TransformerHookParams) => TransformerHookOutput;

package/dist/toTypescript/transformer/index.cjs

@@ -5,6 +5,9 @@ var transformer = require('./transformer.cjs');
 require('./hook.cjs');
 var index = require('./defaults/index.cjs');
 var includesUndefinedTypeNode = require('./includesUndefinedTypeNode.cjs');
+var createImportDeclaration = require('./createImportDeclaration.cjs');
+var addImport = require('./addImport.cjs');
+var createIdentifier = require('./createIdentifier.cjs');
 
 
 
@@ -12,3 +15,6 @@ exports.createTransformer = create.createTransformer;
 exports.transformer = transformer.transformer;
 exports.defaultTransformers = index.defaultTransformers;
 exports.includesUndefinedTypeNode = includesUndefinedTypeNode.includesUndefinedTypeNode;
+exports.createImportDeclaration = createImportDeclaration.createImportDeclaration;
+exports.createAddImport = addImport.createAddImport;
+exports.createIdentifier = createIdentifier.createIdentifier;

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

@@ -3,4 +3,7 @@ export * from "./transformer";
 export * from "./hook";
 export * from "./defaults";
 export * from "./includesUndefinedTypeNode";
+export * from "./createImportDeclaration";
+export * from "./addImport";
+export * from "./createIdentifier";
 export { defaultTransformers } from "./defaults";

package/dist/toTypescript/transformer/index.mjs

@@ -3,3 +3,6 @@ export { transformer } from './transformer.mjs';
 import './hook.mjs';
 export { defaultTransformers } from './defaults/index.mjs';
 export { includesUndefinedTypeNode } from './includesUndefinedTypeNode.mjs';
+export { createImportDeclaration } from './createImportDeclaration.mjs';
+export { createAddImport } from './addImport.mjs';
+export { createIdentifier } from './createIdentifier.mjs';

package/dist/toTypescript/transformer/transformer.cjs

@@ -2,13 +2,15 @@
 
 var utils = require('@duplojs/utils');
 var typescript = require('typescript');
+var addImport = require('./addImport.cjs');
+var createIdentifier = require('./createIdentifier.cjs');
 
 function transformer(schema, params) {
     const currentSchema = utils.A.reduce(params.hooks, utils.A.reduceFrom(schema), ({ element: hook, lastValue, next, exit }) => {
         const result = hook({
             schema: lastValue,
             context: params.context,
-            importType: params.importType,
+            importContext: params.importContext,
             output: (action, schema) => ({
                 schema,
                 action,
@@ -30,7 +32,9 @@ function transformer(schema, params) {
             && !currentSchema.definition.identifier) {
             return undefined;
         }
-        const identifier = currentSchema.definition.identifier ?? `RecursiveType${params.context.size}`;
+        const identifier = currentSchema.definition.identifier !== undefined
+            ? createIdentifier.createIdentifier(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;
     });
@@ -46,13 +50,8 @@ function transformer(schema, params) {
         buildError() {
             return utils.E.left("buildDataParserError");
         },
-        importType: params.importType,
-        addImport(path, typeName) {
-            const types = params.importType.get(path) ?? [];
-            if (!utils.A.includes(types, typeName)) {
-                params.importType.set(path, utils.A.push(types, typeName));
-            }
-        },
+        importContext: params.importContext,
+        addImport: addImport.createAddImport(params.importContext),
     };
     const result = currentSchema.definition.overrideTypescriptTransformer
         ? currentSchema.definition.overrideTypescriptTransformer(currentSchema.addOverrideTypescriptTransformer(null), functionParams)

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

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

package/dist/toTypescript/transformer/transformer.mjs

@@ -1,12 +1,14 @@
 import { A, E, justExec, unwrap } from '@duplojs/utils';
 import { factory, SyntaxKind } from 'typescript';
+import { createAddImport } from './addImport.mjs';
+import { createIdentifier } from './createIdentifier.mjs';
 
 function transformer(schema, params) {
     const currentSchema = A.reduce(params.hooks, A.reduceFrom(schema), ({ element: hook, lastValue, next, exit }) => {
         const result = hook({
             schema: lastValue,
             context: params.context,
-            importType: params.importType,
+            importContext: params.importContext,
             output: (action, schema) => ({
                 schema,
                 action,
@@ -28,7 +30,9 @@ function transformer(schema, params) {
             && !currentSchema.definition.identifier) {
             return undefined;
         }
-        const identifier = currentSchema.definition.identifier ?? `RecursiveType${params.context.size}`;
+        const identifier = currentSchema.definition.identifier !== undefined
+            ? createIdentifier(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;
     });
@@ -44,13 +48,8 @@ function transformer(schema, params) {
         buildError() {
             return E.left("buildDataParserError");
         },
-        importType: params.importType,
-        addImport(path, typeName) {
-            const types = params.importType.get(path) ?? [];
-            if (!A.includes(types, typeName)) {
-                params.importType.set(path, A.push(types, typeName));
-            }
-        },
+        importContext: params.importContext,
+        addImport: createAddImport(params.importContext),
     };
     const result = currentSchema.definition.overrideTypescriptTransformer
         ? currentSchema.definition.overrideTypescriptTransformer(currentSchema.addOverrideTypescriptTransformer(null), functionParams)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/data-parser-tools",
-  "version": "0.2.9",
+  "version": "0.4.0",
   "license": "MIT",
   "author": "duplojs",
   "contributors": [
@@ -45,6 +45,11 @@
       "import": "./dist/toJsonSchema/index.mjs",
       "require": "./dist/toJsonSchema/index.cjs",
       "types": "./dist/toJsonSchema/index.d.ts"
+    },
+    "./toDataParser": {
+      "import": "./dist/toDataParser/index.mjs",
+      "require": "./dist/toDataParser/index.cjs",
+      "types": "./dist/toDataParser/index.d.ts"
     }
   },
   "files": [
@@ -71,8 +76,8 @@
     "vitest": "3.2.4"
   },
   "peerDependencies": {
-    "@duplojs/utils": ">=1.5.12 <2.0.0",
-    "@duplojs/server-utils": ">=0.1.4 < 1.0.0"
+    "@duplojs/utils": ">=1.8.4 <2.0.0",
+    "@duplojs/server-utils": ">=0.3.0 < 1.0.0"
   },
   "dependencies": {
     "typescript": "5.9.2"