@duplojs/data-parser-tools 0.2.9 → 0.4.0

package/dist/toDataParser/dataParserTransformer/defaults/literal.mjs

@@ -0,0 +1,26 @@
+import { DP, E, A, P, isType, pipeCall, pipe } from '@duplojs/utils';
+import { createTransformer } from '../create.mjs';
+import { factory } from 'typescript';
+
+const literalTransformer = createTransformer(DP.literalKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, }) => {
+    const definition = getDefinition();
+    if (E.isLeft(definition)) {
+        return definition;
+    }
+    const values = A.map(dataParser.definition.value, (element) => P.match(element)
+        .when(isType("string"), factory.createStringLiteral)
+        .when(isType("bigint"), (value) => factory.createBigIntLiteral(`${value.toString()}n`))
+        .when(isType("number"), pipeCall(factory.createNumericLiteral))
+        .when(isType("boolean"), (value) => value
+        ? factory.createTrue()
+        : factory.createFalse())
+        .when(isType("null"), () => factory.createNull())
+        .when(isType("undefined"), () => factory.createIdentifier("undefined"))
+        .exhaustive());
+    return pipe(factory.createCallExpression(factory.createPropertyAccessExpression(dependencyIdentifier, factory.createIdentifier("literal")), undefined, [
+        factory.createArrayLiteralExpression(values, A.minElements(values, 4)),
+        ...definition,
+    ]), success);
+});
+
+export { literalTransformer };

package/dist/toDataParser/dataParserTransformer/defaults/nil.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../create.cjs');
+var typescript = require('typescript');
+
+const nilTransformer = create.createTransformer(utils.DP.nilKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, }) => {
+    const definition = getDefinition(dataParser.definition.coerce
+        ? [
+            typescript.factory.createPropertyAssignment(typescript.factory.createIdentifier("coerce"), typescript.factory.createTrue()),
+        ]
+        : undefined);
+    if (utils.E.isLeft(definition)) {
+        return definition;
+    }
+    return utils.pipe(typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(dependencyIdentifier, typescript.factory.createIdentifier("nil")), undefined, definition), success);
+});
+
+exports.nilTransformer = nilTransformer;

package/dist/toDataParser/dataParserTransformer/defaults/nil.d.ts

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

package/dist/toDataParser/dataParserTransformer/defaults/nil.mjs

@@ -0,0 +1,17 @@
+import { DP, E, pipe } from '@duplojs/utils';
+import { createTransformer } from '../create.mjs';
+import { factory } from 'typescript';
+
+const nilTransformer = createTransformer(DP.nilKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, }) => {
+    const definition = getDefinition(dataParser.definition.coerce
+        ? [
+            factory.createPropertyAssignment(factory.createIdentifier("coerce"), factory.createTrue()),
+        ]
+        : undefined);
+    if (E.isLeft(definition)) {
+        return definition;
+    }
+    return pipe(factory.createCallExpression(factory.createPropertyAccessExpression(dependencyIdentifier, factory.createIdentifier("nil")), undefined, definition), success);
+});
+
+export { nilTransformer };

package/dist/toDataParser/dataParserTransformer/defaults/nullable.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../create.cjs');
+var typescript = require('typescript');
+
+const nullableTransformer = create.createTransformer(utils.DP.nullableKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, transformer, }) => {
+    const inner = transformer(dataParser.definition.inner);
+    if (utils.E.isLeft(inner)) {
+        return inner;
+    }
+    const definition = getDefinition();
+    if (utils.E.isLeft(definition)) {
+        return definition;
+    }
+    return utils.pipe(typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(dependencyIdentifier, typescript.factory.createIdentifier("nullable")), undefined, [
+        utils.unwrap(inner),
+        ...definition,
+    ]), success);
+});
+
+exports.nullableTransformer = nullableTransformer;

package/dist/toDataParser/dataParserTransformer/defaults/nullable.d.ts

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

package/dist/toDataParser/dataParserTransformer/defaults/nullable.mjs

@@ -0,0 +1,20 @@
+import { DP, E, pipe, unwrap } from '@duplojs/utils';
+import { createTransformer } from '../create.mjs';
+import { factory } from 'typescript';
+
+const nullableTransformer = createTransformer(DP.nullableKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, transformer, }) => {
+    const inner = transformer(dataParser.definition.inner);
+    if (E.isLeft(inner)) {
+        return inner;
+    }
+    const definition = getDefinition();
+    if (E.isLeft(definition)) {
+        return definition;
+    }
+    return pipe(factory.createCallExpression(factory.createPropertyAccessExpression(dependencyIdentifier, factory.createIdentifier("nullable")), undefined, [
+        unwrap(inner),
+        ...definition,
+    ]), success);
+});
+
+export { nullableTransformer };

package/dist/toDataParser/dataParserTransformer/defaults/number.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../create.cjs');
+var typescript = require('typescript');
+
+const numberTransformer = create.createTransformer(utils.DP.numberKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, }) => {
+    const definition = getDefinition(dataParser.definition.coerce
+        ? [
+            typescript.factory.createPropertyAssignment(typescript.factory.createIdentifier("coerce"), typescript.factory.createTrue()),
+        ]
+        : undefined);
+    if (utils.E.isLeft(definition)) {
+        return definition;
+    }
+    return utils.pipe(typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(dependencyIdentifier, typescript.factory.createIdentifier("number")), undefined, definition), success);
+});
+
+exports.numberTransformer = numberTransformer;

package/dist/toDataParser/dataParserTransformer/defaults/number.d.ts

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

package/dist/toDataParser/dataParserTransformer/defaults/number.mjs

@@ -0,0 +1,17 @@
+import { DP, E, pipe } from '@duplojs/utils';
+import { createTransformer } from '../create.mjs';
+import { factory } from 'typescript';
+
+const numberTransformer = createTransformer(DP.numberKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, }) => {
+    const definition = getDefinition(dataParser.definition.coerce
+        ? [
+            factory.createPropertyAssignment(factory.createIdentifier("coerce"), factory.createTrue()),
+        ]
+        : undefined);
+    if (E.isLeft(definition)) {
+        return definition;
+    }
+    return pipe(factory.createCallExpression(factory.createPropertyAccessExpression(dependencyIdentifier, factory.createIdentifier("number")), undefined, definition), success);
+});
+
+export { numberTransformer };

package/dist/toDataParser/dataParserTransformer/defaults/object.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../create.cjs');
+var typescript = require('typescript');
+
+const objectTransformer = create.createTransformer(utils.DP.objectKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, transformer, }) => {
+    const shape = utils.pipe(dataParser.definition.shape, utils.O.entries, utils.A.reduce(utils.A.reduceFrom([]), ({ element: [identifier, parser], lastValue, nextPush, exit }) => utils.pipe(parser, transformer, utils.when(utils.E.isLeft, exit), utils.E.whenIsRight((result) => nextPush(lastValue, typescript.factory.createPropertyAssignment(typescript.factory.createIdentifier(identifier), result))))));
+    if (utils.E.isLeft(shape)) {
+        return shape;
+    }
+    const definition = getDefinition();
+    if (utils.E.isLeft(definition)) {
+        return definition;
+    }
+    return utils.pipe(typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(dependencyIdentifier, typescript.factory.createIdentifier("object")), undefined, [
+        typescript.factory.createObjectLiteralExpression(shape, true),
+        ...definition,
+    ]), success);
+});
+
+exports.objectTransformer = objectTransformer;

package/dist/toDataParser/dataParserTransformer/defaults/object.d.ts

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

package/dist/toDataParser/dataParserTransformer/defaults/object.mjs

@@ -0,0 +1,20 @@
+import { DP, pipe, O, A, when, E } from '@duplojs/utils';
+import { createTransformer } from '../create.mjs';
+import { factory } from 'typescript';
+
+const objectTransformer = createTransformer(DP.objectKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, transformer, }) => {
+    const shape = pipe(dataParser.definition.shape, O.entries, A.reduce(A.reduceFrom([]), ({ element: [identifier, parser], lastValue, nextPush, exit }) => pipe(parser, transformer, when(E.isLeft, exit), E.whenIsRight((result) => nextPush(lastValue, factory.createPropertyAssignment(factory.createIdentifier(identifier), result))))));
+    if (E.isLeft(shape)) {
+        return shape;
+    }
+    const definition = getDefinition();
+    if (E.isLeft(definition)) {
+        return definition;
+    }
+    return pipe(factory.createCallExpression(factory.createPropertyAccessExpression(dependencyIdentifier, factory.createIdentifier("object")), undefined, [
+        factory.createObjectLiteralExpression(shape, true),
+        ...definition,
+    ]), success);
+});
+
+export { objectTransformer };

package/dist/toDataParser/dataParserTransformer/defaults/optional.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../create.cjs');
+var typescript = require('typescript');
+
+const optionalTransformer = create.createTransformer(utils.DP.optionalKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, transformer, }) => {
+    const inner = transformer(dataParser.definition.inner);
+    if (utils.E.isLeft(inner)) {
+        return inner;
+    }
+    const definition = getDefinition();
+    if (utils.E.isLeft(definition)) {
+        return definition;
+    }
+    return utils.pipe(typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(dependencyIdentifier, typescript.factory.createIdentifier("optional")), undefined, [
+        utils.unwrap(inner),
+        ...definition,
+    ]), success);
+});
+
+exports.optionalTransformer = optionalTransformer;

package/dist/toDataParser/dataParserTransformer/defaults/optional.d.ts

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

package/dist/toDataParser/dataParserTransformer/defaults/optional.mjs

@@ -0,0 +1,20 @@
+import { DP, E, pipe, unwrap } from '@duplojs/utils';
+import { createTransformer } from '../create.mjs';
+import { factory } from 'typescript';
+
+const optionalTransformer = createTransformer(DP.optionalKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, transformer, }) => {
+    const inner = transformer(dataParser.definition.inner);
+    if (E.isLeft(inner)) {
+        return inner;
+    }
+    const definition = getDefinition();
+    if (E.isLeft(definition)) {
+        return definition;
+    }
+    return pipe(factory.createCallExpression(factory.createPropertyAccessExpression(dependencyIdentifier, factory.createIdentifier("optional")), undefined, [
+        unwrap(inner),
+        ...definition,
+    ]), success);
+});
+
+export { optionalTransformer };

package/dist/toDataParser/dataParserTransformer/defaults/pipe.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../create.cjs');
+var typescript = require('typescript');
+
+const pipeTransformer = create.createTransformer(utils.DP.pipeKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, transformer, }) => {
+    const input = transformer(dataParser.definition.input);
+    if (utils.E.isLeft(input)) {
+        return input;
+    }
+    const output = transformer(dataParser.definition.output);
+    if (utils.E.isLeft(output)) {
+        return output;
+    }
+    const definition = getDefinition();
+    if (utils.E.isLeft(definition)) {
+        return definition;
+    }
+    return utils.pipe(typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(dependencyIdentifier, typescript.factory.createIdentifier("pipe")), undefined, [
+        utils.unwrap(input),
+        utils.unwrap(output),
+        ...definition,
+    ]), success);
+});
+
+exports.pipeTransformer = pipeTransformer;

package/dist/toDataParser/dataParserTransformer/defaults/pipe.d.ts

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

package/dist/toDataParser/dataParserTransformer/defaults/pipe.mjs

@@ -0,0 +1,25 @@
+import { DP, E, pipe, unwrap } from '@duplojs/utils';
+import { createTransformer } from '../create.mjs';
+import { factory } from 'typescript';
+
+const pipeTransformer = createTransformer(DP.pipeKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, transformer, }) => {
+    const input = transformer(dataParser.definition.input);
+    if (E.isLeft(input)) {
+        return input;
+    }
+    const output = transformer(dataParser.definition.output);
+    if (E.isLeft(output)) {
+        return output;
+    }
+    const definition = getDefinition();
+    if (E.isLeft(definition)) {
+        return definition;
+    }
+    return pipe(factory.createCallExpression(factory.createPropertyAccessExpression(dependencyIdentifier, factory.createIdentifier("pipe")), undefined, [
+        unwrap(input),
+        unwrap(output),
+        ...definition,
+    ]), success);
+});
+
+export { pipeTransformer };

package/dist/toDataParser/dataParserTransformer/defaults/record.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../create.cjs');
+var typescript = require('typescript');
+
+const recordTransformer = create.createTransformer(utils.DP.recordKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, transformer, }) => {
+    const key = transformer(dataParser.definition.key);
+    if (utils.E.isLeft(key)) {
+        return key;
+    }
+    const value = transformer(dataParser.definition.value);
+    if (utils.E.isLeft(value)) {
+        return value;
+    }
+    const definition = getDefinition();
+    if (utils.E.isLeft(definition)) {
+        return definition;
+    }
+    return utils.pipe(typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(dependencyIdentifier, typescript.factory.createIdentifier("record")), undefined, [
+        utils.unwrap(key),
+        utils.unwrap(value),
+        ...definition,
+    ]), success);
+});
+
+exports.recordTransformer = recordTransformer;

package/dist/toDataParser/dataParserTransformer/defaults/record.d.ts

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

package/dist/toDataParser/dataParserTransformer/defaults/record.mjs

@@ -0,0 +1,25 @@
+import { DP, E, pipe, unwrap } from '@duplojs/utils';
+import { createTransformer } from '../create.mjs';
+import { factory } from 'typescript';
+
+const recordTransformer = createTransformer(DP.recordKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, transformer, }) => {
+    const key = transformer(dataParser.definition.key);
+    if (E.isLeft(key)) {
+        return key;
+    }
+    const value = transformer(dataParser.definition.value);
+    if (E.isLeft(value)) {
+        return value;
+    }
+    const definition = getDefinition();
+    if (E.isLeft(definition)) {
+        return definition;
+    }
+    return pipe(factory.createCallExpression(factory.createPropertyAccessExpression(dependencyIdentifier, factory.createIdentifier("record")), undefined, [
+        unwrap(key),
+        unwrap(value),
+        ...definition,
+    ]), success);
+});
+
+export { recordTransformer };

package/dist/toDataParser/dataParserTransformer/defaults/recover.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../create.cjs');
+
+const recoverTransformer = create.createTransformer(utils.DP.recoverKind.has, (dataParser, { transformer, }) => transformer(dataParser.definition.inner));
+
+exports.recoverTransformer = recoverTransformer;

package/dist/toDataParser/dataParserTransformer/defaults/recover.d.ts

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

package/dist/toDataParser/dataParserTransformer/defaults/recover.mjs

@@ -0,0 +1,6 @@
+import { DP } from '@duplojs/utils';
+import { createTransformer } from '../create.mjs';
+
+const recoverTransformer = createTransformer(DP.recoverKind.has, (dataParser, { transformer, }) => transformer(dataParser.definition.inner));
+
+export { recoverTransformer };

package/dist/toDataParser/dataParserTransformer/defaults/string.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../create.cjs');
+var typescript = require('typescript');
+
+const stringTransformer = create.createTransformer(utils.DP.stringKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, }) => {
+    const definition = getDefinition();
+    if (utils.E.isLeft(definition)) {
+        return definition;
+    }
+    return utils.pipe(typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(dependencyIdentifier, typescript.factory.createIdentifier("string")), undefined, definition), success);
+});
+
+exports.stringTransformer = stringTransformer;

package/dist/toDataParser/dataParserTransformer/defaults/string.d.ts

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

package/dist/toDataParser/dataParserTransformer/defaults/string.mjs

@@ -0,0 +1,13 @@
+import { DP, E, pipe } from '@duplojs/utils';
+import { createTransformer } from '../create.mjs';
+import { factory } from 'typescript';
+
+const stringTransformer = createTransformer(DP.stringKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, }) => {
+    const definition = getDefinition();
+    if (E.isLeft(definition)) {
+        return definition;
+    }
+    return pipe(factory.createCallExpression(factory.createPropertyAccessExpression(dependencyIdentifier, factory.createIdentifier("string")), undefined, definition), success);
+});
+
+export { stringTransformer };

package/dist/toDataParser/dataParserTransformer/defaults/templateLiteral.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../create.cjs');
+var typescript = require('typescript');
+
+const templateLiteralTransformer = create.createTransformer(utils.DP.templateLiteralKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, transformer, }) => {
+    const parts = utils.A.reduce(dataParser.definition.template, utils.A.reduceFrom([]), ({ element, lastValue, nextPush, exit }) => {
+        if (utils.DP.dataParserKind.has(element)) {
+            const transformResult = transformer(element);
+            if (utils.E.isLeft(transformResult)) {
+                return exit(transformResult);
+            }
+            return nextPush(lastValue, utils.unwrap(transformResult));
+        }
+        const result = utils.P.match(element)
+            .when(utils.isType("bigint"), (value) => typescript.factory.createBigIntLiteral(`${value.toString()}n`))
+            .when(utils.isType("boolean"), (value) => value
+            ? typescript.factory.createTrue()
+            : typescript.factory.createFalse())
+            .when(utils.isType("string"), utils.pipeCall(typescript.factory.createStringLiteral))
+            .when(utils.isType("number"), utils.pipeCall(typescript.factory.createNumericLiteral))
+            .when(utils.isType("null"), () => typescript.factory.createNull())
+            .when(utils.isType("undefined"), () => typescript.factory.createIdentifier("undefined"))
+            .exhaustive();
+        return nextPush(lastValue, result);
+    });
+    if (utils.E.isLeft(parts)) {
+        return parts;
+    }
+    const definition = getDefinition();
+    if (utils.E.isLeft(definition)) {
+        return definition;
+    }
+    return utils.pipe(typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(dependencyIdentifier, typescript.factory.createIdentifier("templateLiteral")), undefined, [
+        typescript.factory.createArrayLiteralExpression(parts, utils.A.minElements(parts, 4)),
+        ...definition,
+    ]), success);
+});
+
+exports.templateLiteralTransformer = templateLiteralTransformer;

package/dist/toDataParser/dataParserTransformer/defaults/templateLiteral.d.ts

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

package/dist/toDataParser/dataParserTransformer/defaults/templateLiteral.mjs

@@ -0,0 +1,39 @@
+import { DP, A, E, unwrap, P, isType, pipeCall, pipe } from '@duplojs/utils';
+import { createTransformer } from '../create.mjs';
+import { factory } from 'typescript';
+
+const templateLiteralTransformer = createTransformer(DP.templateLiteralKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, transformer, }) => {
+    const parts = A.reduce(dataParser.definition.template, A.reduceFrom([]), ({ element, lastValue, nextPush, exit }) => {
+        if (DP.dataParserKind.has(element)) {
+            const transformResult = transformer(element);
+            if (E.isLeft(transformResult)) {
+                return exit(transformResult);
+            }
+            return nextPush(lastValue, unwrap(transformResult));
+        }
+        const result = P.match(element)
+            .when(isType("bigint"), (value) => factory.createBigIntLiteral(`${value.toString()}n`))
+            .when(isType("boolean"), (value) => value
+            ? factory.createTrue()
+            : factory.createFalse())
+            .when(isType("string"), pipeCall(factory.createStringLiteral))
+            .when(isType("number"), pipeCall(factory.createNumericLiteral))
+            .when(isType("null"), () => factory.createNull())
+            .when(isType("undefined"), () => factory.createIdentifier("undefined"))
+            .exhaustive();
+        return nextPush(lastValue, result);
+    });
+    if (E.isLeft(parts)) {
+        return parts;
+    }
+    const definition = getDefinition();
+    if (E.isLeft(definition)) {
+        return definition;
+    }
+    return pipe(factory.createCallExpression(factory.createPropertyAccessExpression(dependencyIdentifier, factory.createIdentifier("templateLiteral")), undefined, [
+        factory.createArrayLiteralExpression(parts, A.minElements(parts, 4)),
+        ...definition,
+    ]), success);
+});
+
+export { templateLiteralTransformer };

package/dist/toDataParser/dataParserTransformer/defaults/time.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../create.cjs');
+var typescript = require('typescript');
+
+const timeTransformer = create.createTransformer(utils.DP.timeKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, }) => {
+    const definition = getDefinition(dataParser.definition.coerce
+        ? [
+            typescript.factory.createPropertyAssignment(typescript.factory.createIdentifier("coerce"), typescript.factory.createTrue()),
+        ]
+        : undefined);
+    if (utils.E.isLeft(definition)) {
+        return definition;
+    }
+    return utils.pipe(typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(dependencyIdentifier, typescript.factory.createIdentifier("time")), undefined, definition), success);
+});
+
+exports.timeTransformer = timeTransformer;

package/dist/toDataParser/dataParserTransformer/defaults/time.d.ts

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

package/dist/toDataParser/dataParserTransformer/defaults/time.mjs

@@ -0,0 +1,17 @@
+import { DP, E, pipe } from '@duplojs/utils';
+import { createTransformer } from '../create.mjs';
+import { factory } from 'typescript';
+
+const timeTransformer = createTransformer(DP.timeKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, }) => {
+    const definition = getDefinition(dataParser.definition.coerce
+        ? [
+            factory.createPropertyAssignment(factory.createIdentifier("coerce"), factory.createTrue()),
+        ]
+        : undefined);
+    if (E.isLeft(definition)) {
+        return definition;
+    }
+    return pipe(factory.createCallExpression(factory.createPropertyAccessExpression(dependencyIdentifier, factory.createIdentifier("time")), undefined, definition), success);
+});
+
+export { timeTransformer };

package/dist/toDataParser/dataParserTransformer/defaults/transform.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../create.cjs');
+var typescript = require('typescript');
+
+const transformTransformer = create.createTransformer(utils.DP.transformKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, transformer, buildError, }) => {
+    const inner = transformer(dataParser.definition.inner);
+    if (utils.E.isLeft(inner)) {
+        return inner;
+    }
+    const theFunction = dataParser.definition.theFunction.toString();
+    if (theFunction.includes("[native code]")) {
+        return buildError();
+    }
+    const sourceFile = typescript.createSourceFile("refine-function.ts", `(${theFunction})`, typescript.ScriptTarget.Latest, false);
+    const statement = sourceFile.statements[0];
+    if (!statement || !typescript.isExpressionStatement(statement)) {
+        return buildError();
+    }
+    const functionExpression = typescript.isParenthesizedExpression(statement.expression)
+        ? statement.expression.expression
+        : undefined;
+    if (!functionExpression
+        || (!typescript.isFunctionExpression(functionExpression)
+            && !typescript.isArrowFunction(functionExpression))) {
+        return buildError();
+    }
+    const definition = getDefinition();
+    if (utils.E.isLeft(definition)) {
+        return definition;
+    }
+    return utils.pipe(typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(dependencyIdentifier, typescript.factory.createIdentifier("transform")), undefined, [
+        utils.unwrap(inner),
+        functionExpression,
+        ...definition,
+    ]), success);
+});
+
+exports.transformTransformer = transformTransformer;

package/dist/toDataParser/dataParserTransformer/defaults/transform.d.ts

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