@duplojs/data-parser-tools 0.2.7 → 0.2.8

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/render.cjs

@@ -43,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.mjs

@@ -1,4 +1,4 @@
-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';
@@ -41,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/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 * 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/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.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/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.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/transformer.cjs

@@ -25,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);

package/dist/toTypescript/transformer/transformer.mjs

@@ -1,4 +1,4 @@
-import { A, E, whenElse, justReturn, unwrap } from '@duplojs/utils';
+import { A, E, justExec, unwrap } from '@duplojs/utils';
 import { factory, SyntaxKind } from 'typescript';
 
 function transformer(schema, params) {
@@ -23,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);

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/data-parser-tools",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "license": "MIT",
   "author": "duplojs",
   "contributors": [
@@ -71,7 +71,7 @@
     "vitest": "3.2.4"
   },
   "peerDependencies": {
-    "@duplojs/utils": ">=1.5.3 <2.0.0",
+    "@duplojs/utils": ">=1.5.6 <2.0.0",
     "@duplojs/server-utils": ">=0.1.4 < 1.0.0"
   },
   "dependencies": {