@duplojs/data-parser-tools 0.3.0 → 0.4.0

package/dist/toDataParser/index.cjs

@@ -0,0 +1,103 @@
+'use strict';
+
+var kind = require('./kind.cjs');
+require('./override.cjs');
+require('./checkerTransformer/index.cjs');
+require('./dataParserTransformer/index.cjs');
+var render = require('./render.cjs');
+var buildContext = require('./buildContext.cjs');
+var printer = require('./printer.cjs');
+var create = require('./checkerTransformer/create.cjs');
+var transformer = require('./checkerTransformer/transformer.cjs');
+var int = require('./checkerTransformer/defaults/number/int.cjs');
+var min = require('./checkerTransformer/defaults/number/min.cjs');
+var max = require('./checkerTransformer/defaults/number/max.cjs');
+var email = require('./checkerTransformer/defaults/string/email.cjs');
+var max$1 = require('./checkerTransformer/defaults/string/max.cjs');
+var min$1 = require('./checkerTransformer/defaults/string/min.cjs');
+var regex = require('./checkerTransformer/defaults/string/regex.cjs');
+var url = require('./checkerTransformer/defaults/string/url.cjs');
+var uuid = require('./checkerTransformer/defaults/string/uuid.cjs');
+var max$2 = require('./checkerTransformer/defaults/array/max.cjs');
+var min$2 = require('./checkerTransformer/defaults/array/min.cjs');
+var index = require('./checkerTransformer/defaults/index.cjs');
+var create$1 = require('./dataParserTransformer/create.cjs');
+var transformer$1 = require('./dataParserTransformer/transformer.cjs');
+var array = require('./dataParserTransformer/defaults/array.cjs');
+var bigint = require('./dataParserTransformer/defaults/bigint.cjs');
+var boolean = require('./dataParserTransformer/defaults/boolean.cjs');
+var date = require('./dataParserTransformer/defaults/date.cjs');
+var empty = require('./dataParserTransformer/defaults/empty.cjs');
+var file = require('./dataParserTransformer/defaults/file.cjs');
+var lazy = require('./dataParserTransformer/defaults/lazy.cjs');
+var literal = require('./dataParserTransformer/defaults/literal.cjs');
+var nil = require('./dataParserTransformer/defaults/nil.cjs');
+var nullable = require('./dataParserTransformer/defaults/nullable.cjs');
+var number = require('./dataParserTransformer/defaults/number.cjs');
+var object = require('./dataParserTransformer/defaults/object.cjs');
+var optional = require('./dataParserTransformer/defaults/optional.cjs');
+var pipe = require('./dataParserTransformer/defaults/pipe.cjs');
+var record = require('./dataParserTransformer/defaults/record.cjs');
+var recover = require('./dataParserTransformer/defaults/recover.cjs');
+var string = require('./dataParserTransformer/defaults/string.cjs');
+var templateLiteral = require('./dataParserTransformer/defaults/templateLiteral.cjs');
+var time = require('./dataParserTransformer/defaults/time.cjs');
+var transform = require('./dataParserTransformer/defaults/transform.cjs');
+var tuple = require('./dataParserTransformer/defaults/tuple.cjs');
+var union = require('./dataParserTransformer/defaults/union.cjs');
+var unknown = require('./dataParserTransformer/defaults/unknown.cjs');
+var index$1 = require('./dataParserTransformer/defaults/index.cjs');
+var getDefinitionDataParser = require('./dataParserTransformer/getDefinitionDataParser.cjs');
+var createIdentifier = require('./dataParserTransformer/createIdentifier.cjs');
+
+
+
+exports.createToDataParserKind = kind.createToDataParserKind;
+exports.DataParserToDataParserRenderError = render.DataParserToDataParserRenderError;
+exports.DataParserToDataParserTypeRenderError = render.DataParserToDataParserTypeRenderError;
+exports.render = render.render;
+exports.buildContext = buildContext.buildContext;
+exports.printer = printer.printer;
+exports.createCheckerTransformer = create.createCheckerTransformer;
+exports.checkerTransformer = transformer.checkerTransformer;
+exports.getCheckerDefinition = transformer.getCheckerDefinition;
+exports.checkerIntTransformer = int.checkerIntTransformer;
+exports.checkerNumberMinTransformer = min.checkerNumberMinTransformer;
+exports.checkerNumberMaxTransformer = max.checkerNumberMaxTransformer;
+exports.checkerEmailTransformer = email.checkerEmailTransformer;
+exports.checkerStringMaxTransformer = max$1.checkerStringMaxTransformer;
+exports.checkerStringMinTransformer = min$1.checkerStringMinTransformer;
+exports.checkerRegexTransformer = regex.checkerRegexTransformer;
+exports.checkerUrlTransformer = url.checkerUrlTransformer;
+exports.checkerUuidTransformer = uuid.checkerUuidTransformer;
+exports.checkerArrayMaxTransformer = max$2.checkerArrayMaxTransformer;
+exports.checkerArrayMinTransformer = min$2.checkerArrayMinTransformer;
+exports.defaultCheckerTransformers = index.defaultCheckerTransformers;
+exports.createTransformer = create$1.createTransformer;
+exports.transformer = transformer$1.transformer;
+exports.arrayTransformer = array.arrayTransformer;
+exports.bigIntTransformer = bigint.bigIntTransformer;
+exports.booleanTransformer = boolean.booleanTransformer;
+exports.dateTransformer = date.dateTransformer;
+exports.emptyTransformer = empty.emptyTransformer;
+exports.fileTransformer = file.fileTransformer;
+exports.lazyTransformer = lazy.lazyTransformer;
+exports.literalTransformer = literal.literalTransformer;
+exports.nilTransformer = nil.nilTransformer;
+exports.nullableTransformer = nullable.nullableTransformer;
+exports.numberTransformer = number.numberTransformer;
+exports.objectTransformer = object.objectTransformer;
+exports.optionalTransformer = optional.optionalTransformer;
+exports.pipeTransformer = pipe.pipeTransformer;
+exports.recordTransformer = record.recordTransformer;
+exports.recoverTransformer = recover.recoverTransformer;
+exports.stringTransformer = string.stringTransformer;
+exports.templateLiteralTransformer = templateLiteral.templateLiteralTransformer;
+exports.timeTransformer = time.timeTransformer;
+exports.transformTransformer = transform.transformTransformer;
+exports.tupleTransformer = tuple.tupleTransformer;
+exports.unionTransformer = union.unionTransformer;
+exports.unknownTransformer = unknown.unknownTransformer;
+exports.defaultTransformers = index$1.defaultTransformers;
+exports.getDefinitionDataParser = getDefinitionDataParser.getDefinitionDataParser;
+exports.createIdentifier = createIdentifier.createIdentifier;

package/dist/toDataParser/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./kind";
+export * from "./override";
+export * from "./checkerTransformer";
+export * from "./dataParserTransformer";
+export * from "./render";
+export * from "./buildContext";
+export * from "./printer";

package/dist/toDataParser/index.mjs

@@ -0,0 +1,49 @@
+export { createToDataParserKind } from './kind.mjs';
+import './override.mjs';
+import './checkerTransformer/index.mjs';
+import './dataParserTransformer/index.mjs';
+export { DataParserToDataParserRenderError, DataParserToDataParserTypeRenderError, render } from './render.mjs';
+export { buildContext } from './buildContext.mjs';
+export { printer } from './printer.mjs';
+export { createCheckerTransformer } from './checkerTransformer/create.mjs';
+export { checkerTransformer, getCheckerDefinition } from './checkerTransformer/transformer.mjs';
+export { checkerIntTransformer } from './checkerTransformer/defaults/number/int.mjs';
+export { checkerNumberMinTransformer } from './checkerTransformer/defaults/number/min.mjs';
+export { checkerNumberMaxTransformer } from './checkerTransformer/defaults/number/max.mjs';
+export { checkerEmailTransformer } from './checkerTransformer/defaults/string/email.mjs';
+export { checkerStringMaxTransformer } from './checkerTransformer/defaults/string/max.mjs';
+export { checkerStringMinTransformer } from './checkerTransformer/defaults/string/min.mjs';
+export { checkerRegexTransformer } from './checkerTransformer/defaults/string/regex.mjs';
+export { checkerUrlTransformer } from './checkerTransformer/defaults/string/url.mjs';
+export { checkerUuidTransformer } from './checkerTransformer/defaults/string/uuid.mjs';
+export { checkerArrayMaxTransformer } from './checkerTransformer/defaults/array/max.mjs';
+export { checkerArrayMinTransformer } from './checkerTransformer/defaults/array/min.mjs';
+export { defaultCheckerTransformers } from './checkerTransformer/defaults/index.mjs';
+export { createTransformer } from './dataParserTransformer/create.mjs';
+export { transformer } from './dataParserTransformer/transformer.mjs';
+export { arrayTransformer } from './dataParserTransformer/defaults/array.mjs';
+export { bigIntTransformer } from './dataParserTransformer/defaults/bigint.mjs';
+export { booleanTransformer } from './dataParserTransformer/defaults/boolean.mjs';
+export { dateTransformer } from './dataParserTransformer/defaults/date.mjs';
+export { emptyTransformer } from './dataParserTransformer/defaults/empty.mjs';
+export { fileTransformer } from './dataParserTransformer/defaults/file.mjs';
+export { lazyTransformer } from './dataParserTransformer/defaults/lazy.mjs';
+export { literalTransformer } from './dataParserTransformer/defaults/literal.mjs';
+export { nilTransformer } from './dataParserTransformer/defaults/nil.mjs';
+export { nullableTransformer } from './dataParserTransformer/defaults/nullable.mjs';
+export { numberTransformer } from './dataParserTransformer/defaults/number.mjs';
+export { objectTransformer } from './dataParserTransformer/defaults/object.mjs';
+export { optionalTransformer } from './dataParserTransformer/defaults/optional.mjs';
+export { pipeTransformer } from './dataParserTransformer/defaults/pipe.mjs';
+export { recordTransformer } from './dataParserTransformer/defaults/record.mjs';
+export { recoverTransformer } from './dataParserTransformer/defaults/recover.mjs';
+export { stringTransformer } from './dataParserTransformer/defaults/string.mjs';
+export { templateLiteralTransformer } from './dataParserTransformer/defaults/templateLiteral.mjs';
+export { timeTransformer } from './dataParserTransformer/defaults/time.mjs';
+export { transformTransformer } from './dataParserTransformer/defaults/transform.mjs';
+export { tupleTransformer } from './dataParserTransformer/defaults/tuple.mjs';
+export { unionTransformer } from './dataParserTransformer/defaults/union.mjs';
+export { unknownTransformer } from './dataParserTransformer/defaults/unknown.mjs';
+export { defaultTransformers } from './dataParserTransformer/defaults/index.mjs';
+export { getDefinitionDataParser } from './dataParserTransformer/getDefinitionDataParser.mjs';
+export { createIdentifier } from './dataParserTransformer/createIdentifier.mjs';

package/dist/toDataParser/kind.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+
+const createToDataParserKind = utils.createKindNamespace(
+// @ts-expect-error reserved kind namespace
+"DuplojsDataParserToolsToDataParser");
+
+exports.createToDataParserKind = createToDataParserKind;

package/dist/toDataParser/kind.d.ts

@@ -0,0 +1,6 @@
+declare module "@duplojs/utils" {
+    interface ReservedKindNamespace {
+        DuplojsDataParserToolsToDataParser: true;
+    }
+}
+export declare const createToDataParserKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import("@duplojs/utils/string").ForbiddenString<GenericName, "@" | "/">) => import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<`@DuplojsDataParserToolsToDataParser/${GenericName}`, GenericKindValue>>;

package/dist/toDataParser/kind.mjs

@@ -0,0 +1,7 @@
+import { createKindNamespace } from '@duplojs/utils';
+
+const createToDataParserKind = createKindNamespace(
+// @ts-expect-error reserved kind namespace
+"DuplojsDataParserToolsToDataParser");
+
+export { createToDataParserKind };

package/dist/toDataParser/override.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var dataParser = require('@duplojs/utils/dataParser');
+
+dataParser.dataParserBaseInit.overrideHandler.setMethod("setIdentifier", (schema, identifier) => {
+    schema.definition.identifier = identifier;
+    return schema;
+});
+dataParser.dataParserBaseInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => {
+    const newSchema = schema.clone();
+    newSchema.setIdentifier(identifier);
+    return newSchema;
+});
+dataParser.dataParserBaseInit.overrideHandler.setMethod("setOverrideDataParserTransformer", (schema, overrideTransformer) => {
+    if (overrideTransformer) {
+        schema.definition.overrideDataParserTransformer = typeof overrideTransformer === "function"
+            ? overrideTransformer
+            : (__, { success }) => success(overrideTransformer);
+    }
+    else {
+        schema.definition.overrideDataParserTransformer = undefined;
+    }
+    return schema;
+});
+dataParser.dataParserBaseInit.overrideHandler.setMethod("addOverrideDataParserTransformer", (schema, overrideTransformer) => {
+    const newSchema = schema.clone();
+    newSchema.setOverrideDataParserTransformer(overrideTransformer);
+    return newSchema;
+});

package/dist/toDataParser/override.d.ts

@@ -0,0 +1,20 @@
+import type { CallExpression, Identifier } from "typescript";
+import type { TransformerBuildFunction } from "./dataParserTransformer";
+declare module "@duplojs/utils/dataParser" {
+    interface DataParserBase {
+        /**
+         * @deprecated this method mutated the dataParser by adding an identifier
+         */
+        setIdentifier(input: string): this;
+        addIdentifier(input: string): this;
+        /**
+         * @deprecated this method mutated the dataParser by adding an override transformer
+         */
+        setOverrideDataParserTransformer(transformer: CallExpression | Identifier | TransformerBuildFunction<this> | null): this;
+        addOverrideDataParserTransformer(transformer: CallExpression | Identifier | TransformerBuildFunction<this> | null): this;
+    }
+    interface DataParserDefinition {
+        identifier?: string;
+        overrideDataParserTransformer?: TransformerBuildFunction;
+    }
+}

package/dist/toDataParser/override.mjs

@@ -0,0 +1,27 @@
+import { dataParserBaseInit } from '@duplojs/utils/dataParser';
+
+dataParserBaseInit.overrideHandler.setMethod("setIdentifier", (schema, identifier) => {
+    schema.definition.identifier = identifier;
+    return schema;
+});
+dataParserBaseInit.overrideHandler.setMethod("addIdentifier", (schema, identifier) => {
+    const newSchema = schema.clone();
+    newSchema.setIdentifier(identifier);
+    return newSchema;
+});
+dataParserBaseInit.overrideHandler.setMethod("setOverrideDataParserTransformer", (schema, overrideTransformer) => {
+    if (overrideTransformer) {
+        schema.definition.overrideDataParserTransformer = typeof overrideTransformer === "function"
+            ? overrideTransformer
+            : (__, { success }) => success(overrideTransformer);
+    }
+    else {
+        schema.definition.overrideDataParserTransformer = undefined;
+    }
+    return schema;
+});
+dataParserBaseInit.overrideHandler.setMethod("addOverrideDataParserTransformer", (schema, overrideTransformer) => {
+    const newSchema = schema.clone();
+    newSchema.setOverrideDataParserTransformer(overrideTransformer);
+    return newSchema;
+});

package/dist/toDataParser/printer.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var typescript = require('typescript');
+var utils = require('@duplojs/utils');
+require('../toTypescript/index.cjs');
+var createImportDeclaration = require('../toTypescript/transformer/createImportDeclaration.cjs');
+
+function printer(params) {
+    const sourceFile = typescript.createSourceFile("print.ts", "", typescript.ScriptTarget.Latest, false, typescript.ScriptKind.TS);
+    const printer = typescript.createPrinter();
+    const dataParserStatements = utils.G.reduce(params.context.values(), utils.G.reduceFrom([]), ({ element: contextValue, lastValue, nextPush }) => nextPush(lastValue, typescript.factory.createVariableStatement([typescript.factory.createToken(typescript.SyntaxKind.ExportKeyword)], typescript.factory.createVariableDeclarationList([
+        typescript.factory.createVariableDeclaration(contextValue.identifier, undefined, contextValue.typeIdentifier
+            ? typescript.factory.createTypeReferenceNode(typescript.factory.createQualifiedName(typescript.factory.createIdentifier(params.importMode === "extended" ? "DPE" : "DP"), typescript.factory.createIdentifier(params.importMode === "extended" ? "DataParserExtended" : "DataParser")), [typescript.factory.createTypeReferenceNode(contextValue.typeIdentifier)])
+            : undefined, contextValue.expression),
+    ], typescript.NodeFlags.Const))));
+    return utils.pipe([
+        ...createImportDeclaration.createImportDeclaration(params.importContext),
+        ...params.typescriptContext.values(),
+        ...dataParserStatements,
+    ], utils.A.map((value) => printer.printNode(typescript.EmitHint.Unspecified, value, sourceFile)), utils.A.join("\n\n"), utils.S.trim);
+}
+
+exports.printer = printer;

package/dist/toDataParser/printer.d.ts

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

package/dist/toDataParser/printer.mjs

@@ -0,0 +1,21 @@
+import { createSourceFile, ScriptTarget, ScriptKind, createPrinter, factory, SyntaxKind, NodeFlags, EmitHint } from 'typescript';
+import { G, pipe, A, S } from '@duplojs/utils';
+import '../toTypescript/index.mjs';
+import { createImportDeclaration } from '../toTypescript/transformer/createImportDeclaration.mjs';
+
+function printer(params) {
+    const sourceFile = createSourceFile("print.ts", "", ScriptTarget.Latest, false, ScriptKind.TS);
+    const printer = createPrinter();
+    const dataParserStatements = G.reduce(params.context.values(), G.reduceFrom([]), ({ element: contextValue, lastValue, nextPush }) => nextPush(lastValue, factory.createVariableStatement([factory.createToken(SyntaxKind.ExportKeyword)], factory.createVariableDeclarationList([
+        factory.createVariableDeclaration(contextValue.identifier, undefined, contextValue.typeIdentifier
+            ? factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(params.importMode === "extended" ? "DPE" : "DP"), factory.createIdentifier(params.importMode === "extended" ? "DataParserExtended" : "DataParser")), [factory.createTypeReferenceNode(contextValue.typeIdentifier)])
+            : undefined, contextValue.expression),
+    ], NodeFlags.Const))));
+    return pipe([
+        ...createImportDeclaration(params.importContext),
+        ...params.typescriptContext.values(),
+        ...dataParserStatements,
+    ], A.map((value) => printer.printNode(EmitHint.Unspecified, value, sourceFile)), A.join("\n\n"), S.trim);
+}
+
+export { printer };

package/dist/toDataParser/render.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+var kind = require('./kind.cjs');
+var buildContext = require('./buildContext.cjs');
+var utils = require('@duplojs/utils');
+var printer = require('./printer.cjs');
+
+class DataParserToDataParserRenderError extends utils.kindClass(kind.createToDataParserKind("data-parser-to-data-parser-render-error"), Error) {
+    dataParser;
+    error;
+    constructor(dataParser, error) {
+        super({}, "Error during the render of dataParser in dataParser.");
+        this.dataParser = dataParser;
+        this.error = error;
+    }
+}
+class DataParserToDataParserTypeRenderError extends utils.kindClass(kind.createToDataParserKind("data-parser-to-data-parser-type-render-error"), Error) {
+    dataParser;
+    error;
+    constructor(dataParser, error) {
+        super({}, "Error during the render of recursive dataParser type.");
+        this.dataParser = dataParser;
+        this.error = error;
+    }
+}
+function render(dataParser, params) {
+    const context = new Map(params.context);
+    const typescriptContext = new Map(params.typescriptContext);
+    const importContext = new Map(params.importContext);
+    const result = buildContext.buildContext(dataParser, {
+        ...params,
+        context,
+        typescriptContext,
+        importContext,
+    });
+    if (utils.E.hasInformation(result, "buildDataParserError")
+        || utils.E.hasInformation(result, "dataParserNotSupport")
+        || utils.E.hasInformation(result, "buildDataParserGetDefinitionError")) {
+        throw new DataParserToDataParserRenderError(dataParser, result);
+    }
+    else if (utils.E.hasInformation(result, "toTypescriptBuildDataParserError")
+        || utils.E.hasInformation(result, "toTypescriptDataParserNotSupport")) {
+        throw new DataParserToDataParserTypeRenderError(dataParser, result);
+    }
+    return printer.printer(utils.unwrap(result));
+}
+
+exports.DataParserToDataParserRenderError = DataParserToDataParserRenderError;
+exports.DataParserToDataParserTypeRenderError = DataParserToDataParserTypeRenderError;
+exports.render = render;

package/dist/toDataParser/render.d.ts

@@ -0,0 +1,19 @@
+import { type DataParserNotSupportedEither, type DataParserGetDefinitionErrorEither, type DataParserErrorEither, type ToTypescriptDataParserErrorEither, type ToTypescriptDataParserNotSupportedEither } from "./dataParserTransformer";
+import { type BuildContextParams } from "./buildContext";
+import { type DP } from "@duplojs/utils";
+declare const DataParserToDataParserRenderError_base: import("@duplojs/utils").KindClass<import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsDataParserToolsToDataParser/data-parser-to-data-parser-render-error", unknown>>, ErrorConstructor>;
+export declare class DataParserToDataParserRenderError extends DataParserToDataParserRenderError_base {
+    dataParser: DP.DataParser;
+    error: DataParserNotSupportedEither | DataParserErrorEither | DataParserGetDefinitionErrorEither;
+    constructor(dataParser: DP.DataParser, error: DataParserNotSupportedEither | DataParserErrorEither | DataParserGetDefinitionErrorEither);
+}
+declare const DataParserToDataParserTypeRenderError_base: import("@duplojs/utils").KindClass<import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsDataParserToolsToDataParser/data-parser-to-data-parser-type-render-error", unknown>>, ErrorConstructor>;
+export declare class DataParserToDataParserTypeRenderError extends DataParserToDataParserTypeRenderError_base {
+    dataParser: DP.DataParser;
+    error: ToTypescriptDataParserNotSupportedEither | ToTypescriptDataParserErrorEither;
+    constructor(dataParser: DP.DataParser, error: ToTypescriptDataParserNotSupportedEither | ToTypescriptDataParserErrorEither);
+}
+export interface RenderParams extends BuildContextParams {
+}
+export declare function render(dataParser: DP.DataParser, params: RenderParams): string;
+export {};

package/dist/toDataParser/render.mjs

@@ -0,0 +1,46 @@
+import { createToDataParserKind } from './kind.mjs';
+import { buildContext } from './buildContext.mjs';
+import { kindClass, E, unwrap } from '@duplojs/utils';
+import { printer } from './printer.mjs';
+
+class DataParserToDataParserRenderError extends kindClass(createToDataParserKind("data-parser-to-data-parser-render-error"), Error) {
+    dataParser;
+    error;
+    constructor(dataParser, error) {
+        super({}, "Error during the render of dataParser in dataParser.");
+        this.dataParser = dataParser;
+        this.error = error;
+    }
+}
+class DataParserToDataParserTypeRenderError extends kindClass(createToDataParserKind("data-parser-to-data-parser-type-render-error"), Error) {
+    dataParser;
+    error;
+    constructor(dataParser, error) {
+        super({}, "Error during the render of recursive dataParser type.");
+        this.dataParser = dataParser;
+        this.error = error;
+    }
+}
+function render(dataParser, params) {
+    const context = new Map(params.context);
+    const typescriptContext = new Map(params.typescriptContext);
+    const importContext = new Map(params.importContext);
+    const result = buildContext(dataParser, {
+        ...params,
+        context,
+        typescriptContext,
+        importContext,
+    });
+    if (E.hasInformation(result, "buildDataParserError")
+        || E.hasInformation(result, "dataParserNotSupport")
+        || E.hasInformation(result, "buildDataParserGetDefinitionError")) {
+        throw new DataParserToDataParserRenderError(dataParser, result);
+    }
+    else if (E.hasInformation(result, "toTypescriptBuildDataParserError")
+        || E.hasInformation(result, "toTypescriptDataParserNotSupport")) {
+        throw new DataParserToDataParserTypeRenderError(dataParser, result);
+    }
+    return printer(unwrap(result));
+}
+
+export { DataParserToDataParserRenderError, DataParserToDataParserTypeRenderError, render };

package/dist/toTypescript/buildContext.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+require('./transformer/index.cjs');
+require('../utils/index.cjs');
+var typescript = require('typescript');
+var transformer = require('./transformer/transformer.cjs');
+var getRecursiveDataParser = require('../utils/getRecursiveDataParser.cjs');
+var createIdentifier = require('./transformer/createIdentifier.cjs');
+
+function buildContext(schema, params) {
+    const context = params.context ?? new Map();
+    const importContext = params.importContext ?? new Map();
+    const result = transformer.transformer(schema, {
+        ...params,
+        context,
+        importContext,
+        mode: params.mode ?? "out",
+        hooks: params.hooks ?? [],
+        recursiveDataParsers: getRecursiveDataParser.getRecursiveDataParser(schema),
+    });
+    if (utils.E.isLeft(result)) {
+        return result;
+    }
+    if (!schema.definition.identifier) {
+        context.set(utils.DP.empty(), typescript.factory.createTypeAliasDeclaration([typescript.factory.createToken(typescript.SyntaxKind.ExportKeyword)], typescript.factory.createIdentifier(createIdentifier.createIdentifier(params.identifier)), undefined, utils.unwrap(result)));
+    }
+    else if (schema.definition.identifier !== params.identifier) {
+        context.set(utils.DP.empty(), typescript.factory.createTypeAliasDeclaration([typescript.factory.createToken(typescript.SyntaxKind.ExportKeyword)], typescript.factory.createIdentifier(createIdentifier.createIdentifier(params.identifier)), undefined, typescript.factory.createTypeReferenceNode(createIdentifier.createIdentifier(schema.definition.identifier))));
+    }
+    return utils.E.success({
+        context,
+        importContext,
+    });
+}
+
+exports.buildContext = buildContext;

package/dist/toTypescript/buildContext.d.ts

@@ -0,0 +1,15 @@
+import { DP, E } from "@duplojs/utils";
+import { type createTransformer, type MapContext, type MapImportContext, type TransformerHook, type TransformerMode, type DataParserErrorEither, type DataParserNotSupportedEither } from "./transformer";
+export interface BuildedContext {
+    readonly context: MapContext;
+    readonly importContext: MapImportContext;
+}
+export interface BuildContextParams {
+    readonly identifier: string;
+    readonly transformers: readonly ReturnType<typeof createTransformer>[];
+    readonly context?: MapContext;
+    readonly mode?: TransformerMode;
+    readonly hooks?: readonly TransformerHook[];
+    readonly importContext?: MapImportContext;
+}
+export declare function buildContext(schema: DP.DataParser, params: BuildContextParams): (E.Success<BuildedContext> | DataParserNotSupportedEither | DataParserErrorEither);

package/dist/toTypescript/buildContext.mjs

@@ -0,0 +1,35 @@
+import { E, DP, unwrap } from '@duplojs/utils';
+import './transformer/index.mjs';
+import '../utils/index.mjs';
+import { factory, SyntaxKind } from 'typescript';
+import { transformer } from './transformer/transformer.mjs';
+import { getRecursiveDataParser } from '../utils/getRecursiveDataParser.mjs';
+import { createIdentifier } from './transformer/createIdentifier.mjs';
+
+function buildContext(schema, params) {
+    const context = params.context ?? new Map();
+    const importContext = params.importContext ?? new Map();
+    const result = transformer(schema, {
+        ...params,
+        context,
+        importContext,
+        mode: params.mode ?? "out",
+        hooks: params.hooks ?? [],
+        recursiveDataParsers: getRecursiveDataParser(schema),
+    });
+    if (E.isLeft(result)) {
+        return result;
+    }
+    if (!schema.definition.identifier) {
+        context.set(DP.empty(), factory.createTypeAliasDeclaration([factory.createToken(SyntaxKind.ExportKeyword)], factory.createIdentifier(createIdentifier(params.identifier)), undefined, unwrap(result)));
+    }
+    else if (schema.definition.identifier !== params.identifier) {
+        context.set(DP.empty(), factory.createTypeAliasDeclaration([factory.createToken(SyntaxKind.ExportKeyword)], factory.createIdentifier(createIdentifier(params.identifier)), undefined, factory.createTypeReferenceNode(createIdentifier(schema.definition.identifier))));
+    }
+    return E.success({
+        context,
+        importContext,
+    });
+}
+
+export { buildContext };

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/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 };