@duplojs/data-parser-tools 0.2.3 → 0.2.5

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

@@ -4,12 +4,22 @@ var utils = require('@duplojs/utils');
 var typescript = require('typescript');
 var create = require('../create.cjs');
 
-const dateTransformer = create.createTransformer(utils.DP.dateKind.has, (__schema, { success }) => success(typescript.factory.createTemplateLiteralType(typescript.factory.createTemplateHead("date", "date"), [
-    typescript.factory.createTemplateLiteralTypeSpan(typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.NumberKeyword), typescript.factory.createTemplateMiddle("", "")),
-    typescript.factory.createTemplateLiteralTypeSpan(typescript.factory.createUnionTypeNode([
-        typescript.factory.createLiteralTypeNode(typescript.factory.createStringLiteral("-")),
-        typescript.factory.createLiteralTypeNode(typescript.factory.createStringLiteral("+")),
-    ]), typescript.factory.createTemplateTail("", "")),
-])));
+const theDate = typescript.factory.createTypeReferenceNode(typescript.factory.createIdentifier("TheDate"));
+const serializedTheDate = typescript.factory.createTypeReferenceNode(typescript.factory.createIdentifier("SerializedTheDate"));
+const nativeDate = typescript.factory.createTypeReferenceNode(typescript.factory.createIdentifier("Date"), undefined);
+const dateTransformer = create.createTransformer(utils.DP.dateKind.has, (__schema, { mode, success, addImport, }) => {
+    addImport("@duplojs/utils/date", "TheDate");
+    return utils.P.match(mode)
+        .with("out", () => success(theDate))
+        .with("in", () => {
+        addImport("@duplojs/utils/date", "SerializedTheDate");
+        return success(typescript.factory.createUnionTypeNode([
+            theDate,
+            nativeDate,
+            serializedTheDate,
+        ]));
+    })
+        .exhaustive();
+});
 
 exports.dateTransformer = dateTransformer;

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

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

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

@@ -1,13 +1,23 @@
-import { DP } from '@duplojs/utils';
-import { factory, SyntaxKind } from 'typescript';
+import { DP, P } from '@duplojs/utils';
+import { factory } from 'typescript';
 import { createTransformer } from '../create.mjs';
 
-const dateTransformer = createTransformer(DP.dateKind.has, (__schema, { success }) => success(factory.createTemplateLiteralType(factory.createTemplateHead("date", "date"), [
-    factory.createTemplateLiteralTypeSpan(factory.createKeywordTypeNode(SyntaxKind.NumberKeyword), factory.createTemplateMiddle("", "")),
-    factory.createTemplateLiteralTypeSpan(factory.createUnionTypeNode([
-        factory.createLiteralTypeNode(factory.createStringLiteral("-")),
-        factory.createLiteralTypeNode(factory.createStringLiteral("+")),
-    ]), factory.createTemplateTail("", "")),
-])));
+const theDate = factory.createTypeReferenceNode(factory.createIdentifier("TheDate"));
+const serializedTheDate = factory.createTypeReferenceNode(factory.createIdentifier("SerializedTheDate"));
+const nativeDate = factory.createTypeReferenceNode(factory.createIdentifier("Date"), undefined);
+const dateTransformer = createTransformer(DP.dateKind.has, (__schema, { mode, success, addImport, }) => {
+    addImport("@duplojs/utils/date", "TheDate");
+    return P.match(mode)
+        .with("out", () => success(theDate))
+        .with("in", () => {
+        addImport("@duplojs/utils/date", "SerializedTheDate");
+        return success(factory.createUnionTypeNode([
+            theDate,
+            nativeDate,
+            serializedTheDate,
+        ]));
+    })
+        .exhaustive();
+});
 
 export { dateTransformer };

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

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

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

@@ -0,0 +1,13 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var serverUtils = require('@duplojs/server-utils');
+var typescript = require('typescript');
+var create = require('../create.cjs');
+
+const fileTransformer = create.createTransformer(serverUtils.SDP.fileKind.has, (schema, { success, addImport, }) => {
+    addImport("@duplojs/server-utils/file", "FileInterface");
+    return utils.pipe("FileInterface", typescript.factory.createIdentifier, typescript.factory.createTypeReferenceNode, success);
+});
+
+exports.fileTransformer = fileTransformer;

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

@@ -0,0 +1 @@
+export declare const fileTransformer: (schema: import("..").SupportedDataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

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

@@ -0,0 +1,11 @@
+import { pipe } from '@duplojs/utils';
+import { SDP } from '@duplojs/server-utils';
+import { factory } from 'typescript';
+import { createTransformer } from '../create.mjs';
+
+const fileTransformer = createTransformer(SDP.fileKind.has, (schema, { success, addImport, }) => {
+    addImport("@duplojs/server-utils/file", "FileInterface");
+    return pipe("FileInterface", factory.createIdentifier, factory.createTypeReferenceNode, success);
+});
+
+export { fileTransformer };

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

@@ -22,6 +22,7 @@ var union = require('./union.cjs');
 var unknown = require('./unknown.cjs');
 var date = require('./date.cjs');
 var time = require('./time.cjs');
+var file = require('./file.cjs');
 
 const defaultTransformers = [
     array.arrayTransformer,
@@ -46,6 +47,7 @@ const defaultTransformers = [
     unknown.unknownTransformer,
     date.dateTransformer,
     time.timeTransformer,
+    file.fileTransformer,
 ];
 
 exports.arrayTransformer = array.arrayTransformer;

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

@@ -20,4 +20,4 @@ export * from "./union";
 export * from "./unknown";
 export * from "./date";
 export * from "./time";
-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];
+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];

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

@@ -20,6 +20,7 @@ import { unionTransformer } from './union.mjs';
 import { unknownTransformer } from './unknown.mjs';
 import { dateTransformer } from './date.mjs';
 import { timeTransformer } from './time.mjs';
+import { fileTransformer } from './file.mjs';
 
 const defaultTransformers = [
     arrayTransformer,
@@ -44,6 +45,7 @@ const defaultTransformers = [
     unknownTransformer,
     dateTransformer,
     timeTransformer,
+    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 };

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

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

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

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

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

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

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

@@ -10,10 +10,19 @@ const nullableTransformer = create.createTransformer(utils.DP.nullableKind.has,
         return innerResult;
     }
     const innerType = utils.unwrap(innerResult);
-    return utils.pipe(mode, utils.P.match("in", () => utils.pipe(typescript.factory.createNull(), typescript.factory.createLiteralTypeNode, (value) => typescript.factory.createUnionTypeNode([
+    return utils.pipe({
+        mode,
+        coalescingValue: schema.definition.coalescingValue,
+    }, (value) => utils.P.match(value)
+        .with(utils.P.union({ mode: "in" }, {
+        mode: "out",
+        coalescingValue: undefined,
+    }), () => utils.pipe(typescript.factory.createNull(), typescript.factory.createLiteralTypeNode, (value) => typescript.factory.createUnionTypeNode([
         innerType,
         value,
-    ]))), utils.P.match("out", () => innerType), utils.P.exhaustive, success);
+    ])))
+        .with({ mode: "out" }, () => innerType)
+        .exhaustive(), success);
 });
 
 exports.nullableTransformer = nullableTransformer;

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

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

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

@@ -8,10 +8,19 @@ const nullableTransformer = createTransformer(DP.nullableKind.has, (schema, { tr
         return innerResult;
     }
     const innerType = unwrap(innerResult);
-    return pipe(mode, P.match("in", () => pipe(factory.createNull(), factory.createLiteralTypeNode, (value) => factory.createUnionTypeNode([
+    return pipe({
+        mode,
+        coalescingValue: schema.definition.coalescingValue,
+    }, (value) => P.match(value)
+        .with(P.union({ mode: "in" }, {
+        mode: "out",
+        coalescingValue: undefined,
+    }), () => pipe(factory.createNull(), factory.createLiteralTypeNode, (value) => factory.createUnionTypeNode([
         innerType,
         value,
-    ]))), P.match("out", () => innerType), P.exhaustive, success);
+    ])))
+        .with({ mode: "out" }, () => innerType)
+        .exhaustive(), success);
 });
 
 export { nullableTransformer };

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

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

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

@@ -3,17 +3,9 @@
 var utils = require('@duplojs/utils');
 var typescript = require('typescript');
 var create = require('../create.cjs');
+var includesUndefinedTypeNode = require('../includesUndefinedTypeNode.cjs');
 
-function includesUndefinedTypeNode(typeNode) {
-    if (typeNode.kind === typescript.SyntaxKind.UndefinedKeyword) {
-        return true;
-    }
-    if (typescript.isUnionTypeNode(typeNode)) {
-        return typeNode.types.some((subTypeNode) => includesUndefinedTypeNode(subTypeNode));
-    }
-    return false;
-}
 const regexIdentifier = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-const objectTransformer = create.createTransformer(utils.DP.objectKind.has, (schema, { transformer, success, }) => utils.pipe(schema.definition.shape, utils.O.entries, utils.A.reduce(utils.A.reduceFrom([]), ({ element: [key, value], lastValue, next, exit }) => utils.pipe(transformer(value), utils.when(utils.E.isLeft, exit), utils.E.whenIsRight((typeNode) => utils.pipe(includesUndefinedTypeNode(typeNode), utils.P.match(true, () => typescript.factory.createToken(typescript.SyntaxKind.QuestionToken)), utils.P.match(false, () => undefined), utils.P.exhaustive, (optional) => utils.pipe(key, utils.whenElse(utils.S.test(regexIdentifier), typescript.factory.createIdentifier, typescript.factory.createStringLiteral), (propertyName) => typescript.factory.createPropertySignature(undefined, propertyName, optional, typeNode), (typeElement) => utils.A.push(lastValue, typeElement), next))))), utils.when(utils.isType("array"), utils.innerPipe(typescript.factory.createTypeLiteralNode, success))));
+const objectTransformer = create.createTransformer(utils.DP.objectKind.has, (schema, { transformer, success, }) => utils.pipe(schema.definition.shape, utils.O.entries, utils.A.reduce(utils.A.reduceFrom([]), ({ element: [key, value], lastValue, next, exit }) => utils.pipe(transformer(value), utils.when(utils.E.isLeft, exit), utils.E.whenIsRight((typeNode) => utils.pipe(includesUndefinedTypeNode.includesUndefinedTypeNode(typeNode), utils.P.match(true, () => typescript.factory.createToken(typescript.SyntaxKind.QuestionToken)), utils.P.match(false, () => undefined), utils.P.exhaustive, (optional) => utils.pipe(key, utils.whenElse(utils.S.test(regexIdentifier), typescript.factory.createIdentifier, typescript.factory.createStringLiteral), (propertyName) => typescript.factory.createPropertySignature(undefined, propertyName, optional, typeNode), (typeElement) => utils.A.push(lastValue, typeElement), next))))), utils.when(utils.isType("array"), utils.innerPipe(typescript.factory.createTypeLiteralNode, success))));
 
 exports.objectTransformer = objectTransformer;

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

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

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

@@ -1,16 +1,8 @@
 import { DP, pipe, O, A, when, E, P, whenElse, S, isType, innerPipe } from '@duplojs/utils';
-import { SyntaxKind, isUnionTypeNode, factory } from 'typescript';
+import { factory, SyntaxKind } from 'typescript';
 import { createTransformer } from '../create.mjs';
+import { includesUndefinedTypeNode } from '../includesUndefinedTypeNode.mjs';
 
-function includesUndefinedTypeNode(typeNode) {
-    if (typeNode.kind === SyntaxKind.UndefinedKeyword) {
-        return true;
-    }
-    if (isUnionTypeNode(typeNode)) {
-        return typeNode.types.some((subTypeNode) => includesUndefinedTypeNode(subTypeNode));
-    }
-    return false;
-}
 const regexIdentifier = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 const objectTransformer = createTransformer(DP.objectKind.has, (schema, { transformer, success, }) => pipe(schema.definition.shape, O.entries, A.reduce(A.reduceFrom([]), ({ element: [key, value], lastValue, next, exit }) => pipe(transformer(value), when(E.isLeft, exit), E.whenIsRight((typeNode) => pipe(includesUndefinedTypeNode(typeNode), P.match(true, () => factory.createToken(SyntaxKind.QuestionToken)), P.match(false, () => undefined), P.exhaustive, (optional) => pipe(key, whenElse(S.test(regexIdentifier), factory.createIdentifier, factory.createStringLiteral), (propertyName) => factory.createPropertySignature(undefined, propertyName, optional, typeNode), (typeElement) => A.push(lastValue, typeElement), next))))), when(isType("array"), innerPipe(factory.createTypeLiteralNode, success))));
 

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

@@ -4,9 +4,18 @@ var utils = require('@duplojs/utils');
 var typescript = require('typescript');
 var create = require('../create.cjs');
 
-const optionalTransformer = create.createTransformer(utils.DP.optionalKind.has, (schema, { transformer, mode, success, }) => utils.pipe(schema.definition.inner, transformer, utils.E.whenIsRight((innerType) => utils.pipe(mode, utils.P.match("in", () => typescript.factory.createUnionTypeNode([
+const optionalTransformer = create.createTransformer(utils.DP.optionalKind.has, (schema, { transformer, mode, success, }) => utils.pipe(schema.definition.inner, transformer, utils.E.whenIsRight((innerType) => utils.pipe({
+    mode,
+    coalescingValue: schema.definition.coalescingValue,
+}, (value) => utils.P.match(value)
+    .with(utils.P.union({ mode: "in" }, {
+    mode: "out",
+    coalescingValue: undefined,
+}), () => typescript.factory.createUnionTypeNode([
     innerType,
     typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.UndefinedKeyword),
-])), utils.P.match("out", () => innerType), utils.P.exhaustive, success))));
+]))
+    .with({ mode: "out" }, () => innerType)
+    .exhaustive(), success))));
 
 exports.optionalTransformer = optionalTransformer;

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

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

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

@@ -2,9 +2,18 @@ import { DP, pipe, E, P } from '@duplojs/utils';
 import { factory, SyntaxKind } from 'typescript';
 import { createTransformer } from '../create.mjs';
 
-const optionalTransformer = createTransformer(DP.optionalKind.has, (schema, { transformer, mode, success, }) => pipe(schema.definition.inner, transformer, E.whenIsRight((innerType) => pipe(mode, P.match("in", () => factory.createUnionTypeNode([
+const optionalTransformer = createTransformer(DP.optionalKind.has, (schema, { transformer, mode, success, }) => pipe(schema.definition.inner, transformer, E.whenIsRight((innerType) => pipe({
+    mode,
+    coalescingValue: schema.definition.coalescingValue,
+}, (value) => P.match(value)
+    .with(P.union({ mode: "in" }, {
+    mode: "out",
+    coalescingValue: undefined,
+}), () => factory.createUnionTypeNode([
     innerType,
     factory.createKeywordTypeNode(SyntaxKind.UndefinedKeyword),
-])), P.match("out", () => innerType), P.exhaustive, success))));
+]))
+    .with({ mode: "out" }, () => innerType)
+    .exhaustive(), success))));
 
 export { optionalTransformer };

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

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

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

@@ -3,6 +3,7 @@
 var utils = require('@duplojs/utils');
 var typescript = require('typescript');
 var create = require('../create.cjs');
+var includesUndefinedTypeNode = require('../includesUndefinedTypeNode.cjs');
 
 const recordTransformer = create.createTransformer(utils.DP.recordKind.has, ({ definition: { key, value } }, { transformer, success, }) => {
     const keyResult = transformer(key);
@@ -15,7 +16,7 @@ const recordTransformer = create.createTransformer(utils.DP.recordKind.has, ({ d
     }
     const keyType = utils.unwrap(keyResult);
     const valueType = utils.unwrap(valueResult);
-    const recordType = typescript.factory.createTypeReferenceNode("Record", [keyType, valueType]);
+    const recordType = utils.pipe(typescript.factory.createTypeReferenceNode("Record", [keyType, valueType]), utils.when(() => includesUndefinedTypeNode.includesUndefinedTypeNode(valueType), (recodeTypeNode) => typescript.factory.createTypeReferenceNode("Partial", [recodeTypeNode])));
     return success(recordType);
 });
 

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

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

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

@@ -1,6 +1,7 @@
-import { DP, E, unwrap } from '@duplojs/utils';
+import { DP, E, unwrap, pipe, when } from '@duplojs/utils';
 import { factory } from 'typescript';
 import { createTransformer } from '../create.mjs';
+import { includesUndefinedTypeNode } from '../includesUndefinedTypeNode.mjs';
 
 const recordTransformer = createTransformer(DP.recordKind.has, ({ definition: { key, value } }, { transformer, success, }) => {
     const keyResult = transformer(key);
@@ -13,7 +14,7 @@ const recordTransformer = createTransformer(DP.recordKind.has, ({ definition: {
     }
     const keyType = unwrap(keyResult);
     const valueType = unwrap(valueResult);
-    const recordType = factory.createTypeReferenceNode("Record", [keyType, valueType]);
+    const recordType = pipe(factory.createTypeReferenceNode("Record", [keyType, valueType]), when(() => includesUndefinedTypeNode(valueType), (recodeTypeNode) => factory.createTypeReferenceNode("Partial", [recodeTypeNode])));
     return success(recordType);
 });
 

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

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

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

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

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

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

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

@@ -4,12 +4,22 @@ var utils = require('@duplojs/utils');
 var typescript = require('typescript');
 var create = require('../create.cjs');
 
-const timeTransformer = create.createTransformer(utils.DP.timeKind.has, (__schema, { success }) => success(typescript.factory.createTemplateLiteralType(typescript.factory.createTemplateHead("time", "time"), [
-    typescript.factory.createTemplateLiteralTypeSpan(typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.NumberKeyword), typescript.factory.createTemplateMiddle("", "")),
-    typescript.factory.createTemplateLiteralTypeSpan(typescript.factory.createUnionTypeNode([
-        typescript.factory.createLiteralTypeNode(typescript.factory.createStringLiteral("-")),
-        typescript.factory.createLiteralTypeNode(typescript.factory.createStringLiteral("+")),
-    ]), typescript.factory.createTemplateTail("", "")),
-])));
+const theTime = typescript.factory.createTypeReferenceNode(typescript.factory.createIdentifier("TheTime"));
+const serializedTheTime = typescript.factory.createTypeReferenceNode(typescript.factory.createIdentifier("SerializedTheTime"));
+const number = typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.NumberKeyword);
+const timeTransformer = create.createTransformer(utils.DP.timeKind.has, (__schema, { mode, success, addImport, }) => {
+    addImport("@duplojs/utils/date", "TheTime");
+    return utils.P.match(mode)
+        .with("out", () => success(theTime))
+        .with("in", () => {
+        addImport("@duplojs/utils/date", "SerializedTheTime");
+        return success(typescript.factory.createUnionTypeNode([
+            serializedTheTime,
+            number,
+            theTime,
+        ]));
+    })
+        .exhaustive();
+});
 
 exports.timeTransformer = timeTransformer;

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

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

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

@@ -1,13 +1,23 @@
-import { DP } from '@duplojs/utils';
+import { DP, P } from '@duplojs/utils';
 import { factory, SyntaxKind } from 'typescript';
 import { createTransformer } from '../create.mjs';
 
-const timeTransformer = createTransformer(DP.timeKind.has, (__schema, { success }) => success(factory.createTemplateLiteralType(factory.createTemplateHead("time", "time"), [
-    factory.createTemplateLiteralTypeSpan(factory.createKeywordTypeNode(SyntaxKind.NumberKeyword), factory.createTemplateMiddle("", "")),
-    factory.createTemplateLiteralTypeSpan(factory.createUnionTypeNode([
-        factory.createLiteralTypeNode(factory.createStringLiteral("-")),
-        factory.createLiteralTypeNode(factory.createStringLiteral("+")),
-    ]), factory.createTemplateTail("", "")),
-])));
+const theTime = factory.createTypeReferenceNode(factory.createIdentifier("TheTime"));
+const serializedTheTime = factory.createTypeReferenceNode(factory.createIdentifier("SerializedTheTime"));
+const number = factory.createKeywordTypeNode(SyntaxKind.NumberKeyword);
+const timeTransformer = createTransformer(DP.timeKind.has, (__schema, { mode, success, addImport, }) => {
+    addImport("@duplojs/utils/date", "TheTime");
+    return P.match(mode)
+        .with("out", () => success(theTime))
+        .with("in", () => {
+        addImport("@duplojs/utils/date", "SerializedTheTime");
+        return success(factory.createUnionTypeNode([
+            serializedTheTime,
+            number,
+            theTime,
+        ]));
+    })
+        .exhaustive();
+});
 
 export { timeTransformer };

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var typescript = require('typescript');
+
+function includesUndefinedTypeNode(typeNode) {
+    if (typeNode.kind === typescript.SyntaxKind.UndefinedKeyword) {
+        return true;
+    }
+    if (typescript.isUnionTypeNode(typeNode)) {
+        return utils.A.some(typeNode.types, (subTypeNode) => includesUndefinedTypeNode(subTypeNode));
+    }
+    return false;
+}
+
+exports.includesUndefinedTypeNode = includesUndefinedTypeNode;

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

@@ -0,0 +1,2 @@
+import { type TypeNode } from "typescript";
+export declare function includesUndefinedTypeNode(typeNode: TypeNode): boolean;

package/dist/toTypescript/transformer/includesUndefinedTypeNode.mjs

@@ -0,0 +1,14 @@
+import { A } from '@duplojs/utils';
+import { SyntaxKind, isUnionTypeNode } from 'typescript';
+
+function includesUndefinedTypeNode(typeNode) {
+    if (typeNode.kind === SyntaxKind.UndefinedKeyword) {
+        return true;
+    }
+    if (isUnionTypeNode(typeNode)) {
+        return A.some(typeNode.types, (subTypeNode) => includesUndefinedTypeNode(subTypeNode));
+    }
+    return false;
+}
+
+export { includesUndefinedTypeNode };

package/dist/toTypescript/transformer/index.cjs

@@ -4,9 +4,11 @@ var create = require('./create.cjs');
 var transformer = require('./transformer.cjs');
 require('./hook.cjs');
 var index = require('./defaults/index.cjs');
+var includesUndefinedTypeNode = require('./includesUndefinedTypeNode.cjs');
 
 
 
 exports.createTransformer = create.createTransformer;
 exports.transformer = transformer.transformer;
 exports.defaultTransformers = index.defaultTransformers;
+exports.includesUndefinedTypeNode = includesUndefinedTypeNode.includesUndefinedTypeNode;

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

@@ -2,4 +2,5 @@ export * from "./create";
 export * from "./transformer";
 export * from "./hook";
 export * from "./defaults";
+export * from "./includesUndefinedTypeNode";
 export { defaultTransformers } from "./defaults";