@duplojs/data-parser-tools 0.2.4 → 0.2.6

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

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

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

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

package/dist/toTypescript/transformer/importTypesTransformer.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var typescript = require('typescript');
+
+function importTypesTransformer(importTypes) {
+    return utils.pipe(importTypes, utils.G.map(([path, types]) => typescript.factory.createImportDeclaration(undefined, typescript.factory.createImportClause(typescript.SyntaxKind.TypeKeyword, undefined, typescript.factory.createNamedImports(utils.A.map(types, (type) => typescript.factory.createImportSpecifier(false, undefined, typescript.factory.createIdentifier(type))))), typescript.factory.createStringLiteral(path), undefined)));
+}
+
+exports.importTypesTransformer = importTypesTransformer;

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

@@ -0,0 +1,2 @@
+import type { MapImportType } from "./create";
+export declare function importTypesTransformer(importTypes: MapImportType): Generator<import("typescript").ImportDeclaration, unknown, unknown>;

package/dist/toTypescript/transformer/importTypesTransformer.mjs

@@ -0,0 +1,8 @@
+import { pipe, G, A } from '@duplojs/utils';
+import { factory, SyntaxKind } from 'typescript';
+
+function importTypesTransformer(importTypes) {
+    return pipe(importTypes, G.map(([path, types]) => factory.createImportDeclaration(undefined, factory.createImportClause(SyntaxKind.TypeKeyword, undefined, factory.createNamedImports(A.map(types, (type) => factory.createImportSpecifier(false, undefined, factory.createIdentifier(type))))), factory.createStringLiteral(path), undefined)));
+}
+
+export { importTypesTransformer };

package/dist/toTypescript/transformer/transformer.cjs

@@ -4,10 +4,14 @@ 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,
             context: params.context,
+            importType: params.importType,
             output: (action, schema) => ({
                 schema,
                 action,
@@ -41,6 +45,13 @@ 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));
+            }
+        },
     };
     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);

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

@@ -1,11 +1,12 @@
 import { type DP } from "@duplojs/utils";
-import { type MapContext, type DataParserNotSupportedEither, type createTransformer, type TransformerMode, type DataParserErrorEither } from "./create";
-import { type TransformerHook } from "./hook";
+import type { MapContext, DataParserNotSupportedEither, createTransformer, TransformerMode, DataParserErrorEither, MapImportType, SupportedDataParsers } 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: DP.DataParser[];
+    readonly recursiveDataParsers: SupportedDataParsers[];
+    readonly importType: MapImportType;
 }
 export declare function transformer(schema: DP.DataParser, params: TransformerFunctionParams): import("./create").TransformerSuccessEither | DataParserNotSupportedEither | DataParserErrorEither;

package/dist/toTypescript/transformer/transformer.mjs

@@ -1,11 +1,15 @@
-import { A, E, whenElse, justReturn, unwrap } from '@duplojs/utils';
+import { E, A, whenElse, justReturn, 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,
             context: params.context,
+            importType: params.importType,
             output: (action, schema) => ({
                 schema,
                 action,
@@ -39,6 +43,13 @@ 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));
+            }
+        },
     };
     const result = A.reduce(params.transformers, A.reduceFrom(E.left("dataParserNotSupport", currentSchema)), ({ element: functionBuilder, lastValue, next, exit, }) => {
         const result = functionBuilder(currentSchema, functionParams);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/data-parser-tools",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "license": "MIT",
   "author": "duplojs",
   "contributors": [
@@ -71,7 +71,8 @@
     "vitest": "3.2.4"
   },
   "peerDependencies": {
-    "@duplojs/utils": ">=1.4.36 <2.0.0"
+    "@duplojs/utils": ">=1.5.1 <2.0.0",
+    "@duplojs/server-utils": ">=0.1.4 < 1.0.0"
   },
   "dependencies": {
     "typescript": "5.9.2"