@duplojs/data-parser-tools 0.3.0 → 0.4.0

package/dist/toDataParser/dataParserTransformer/create.d.ts

@@ -0,0 +1,34 @@
+import { type DP, E } from "@duplojs/utils";
+import type * as TST from "../../toTypescript";
+import type { CallExpression, Identifier, ObjectLiteralExpression, PropertyAssignment } from "typescript";
+import type { CheckerTransformerBuildErrorEither, CheckerTransformerCheckerNotSupportedEither } from "../checkerTransformer";
+export type TransformerSuccessEither = E.Right<"buildSuccess", CallExpression | Identifier>;
+export type DataParserNotSupportedEither = E.Left<"dataParserNotSupport", DP.DataParser>;
+export type DataParserErrorEither = E.Left<"buildDataParserError", DP.DataParser>;
+export type ToTypescriptDataParserNotSupportedEither = E.Left<"toTypescriptDataParserNotSupport", DP.DataParser>;
+export type ToTypescriptDataParserErrorEither = E.Left<"toTypescriptBuildDataParserError", DP.DataParser>;
+export type DataParserGetDefinitionErrorEither = E.Left<"buildDataParserGetDefinitionError", {
+    dataParser: DP.DataParser;
+    error: CheckerTransformerCheckerNotSupportedEither | CheckerTransformerBuildErrorEither;
+}>;
+export type DependenciesContext = Set<DP.DataParser>;
+export interface MapContextValue {
+    readonly identifier: Identifier;
+    readonly expression: CallExpression | Identifier;
+    readonly typeIdentifier: Identifier | null;
+    readonly dependencies: DependenciesContext;
+}
+export type MapContext = Map<DP.DataParsers, MapContextValue>;
+export type MaybeTransformerEither = TransformerSuccessEither | DataParserNotSupportedEither | DataParserErrorEither | DataParserGetDefinitionErrorEither | ToTypescriptDataParserNotSupportedEither | ToTypescriptDataParserErrorEither;
+export interface TransformerParams {
+    readonly dependencyIdentifier: Identifier;
+    readonly context: MapContext;
+    readonly importContext: TST.MapImportContext;
+    transformer(dataParser: DP.DataParser): MaybeTransformerEither;
+    success(result: CallExpression | Identifier): TransformerSuccessEither;
+    buildError(): DataParserErrorEither;
+    addImport(path: string, typeName: string, type?: "default" | "namespace" | "direct"): void;
+    getDefinition(customProperties?: readonly PropertyAssignment[]): readonly [ObjectLiteralExpression] | readonly [] | DataParserGetDefinitionErrorEither;
+}
+export type TransformerBuildFunction<GenericDataParser extends DP.DataParsers = DP.DataParsers> = (dataParser: GenericDataParser, params: TransformerParams) => MaybeTransformerEither;
+export declare function createTransformer<GenericDataParser extends DP.DataParsers>(support: (dataParser: DP.DataParsers) => dataParser is GenericDataParser, builder: TransformerBuildFunction<GenericDataParser>): (dataParser: DP.DataParsers, params: TransformerParams) => MaybeTransformerEither;

package/dist/toDataParser/dataParserTransformer/create.mjs

@@ -0,0 +1,9 @@
+import { E } from '@duplojs/utils';
+
+function createTransformer(support, builder) {
+    return (dataParser, params) => support(dataParser)
+        ? builder(dataParser, params)
+        : E.left("dataParserNotSupport", dataParser);
+}
+
+export { createTransformer };

package/dist/toDataParser/dataParserTransformer/createIdentifier.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+
+function createIdentifier(identifier) {
+    return `${utils.S.uncapitalize(identifier)}DataParser`;
+}
+
+exports.createIdentifier = createIdentifier;

package/dist/toDataParser/dataParserTransformer/createIdentifier.d.ts

@@ -0,0 +1 @@
+export declare function createIdentifier(identifier: string): string;

package/dist/toDataParser/dataParserTransformer/createIdentifier.mjs

@@ -0,0 +1,7 @@
+import { S } from '@duplojs/utils';
+
+function createIdentifier(identifier) {
+    return `${S.uncapitalize(identifier)}DataParser`;
+}
+
+export { createIdentifier };

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

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

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

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

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

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

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

@@ -0,0 +1,19 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../create.cjs');
+var typescript = require('typescript');
+
+const bigIntTransformer = create.createTransformer(utils.DP.bigIntKind.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("bigint")), undefined, definition), success);
+});
+
+exports.bigIntTransformer = bigIntTransformer;

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

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

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

@@ -0,0 +1,17 @@
+import { DP, E, pipe } from '@duplojs/utils';
+import { createTransformer } from '../create.mjs';
+import { factory } from 'typescript';
+
+const bigIntTransformer = createTransformer(DP.bigIntKind.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("bigint")), undefined, definition), success);
+});
+
+export { bigIntTransformer };

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

@@ -0,0 +1,19 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../create.cjs');
+var typescript = require('typescript');
+
+const booleanTransformer = create.createTransformer(utils.DP.booleanKind.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("boolean")), undefined, definition), success);
+});
+
+exports.booleanTransformer = booleanTransformer;

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

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

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

@@ -0,0 +1,17 @@
+import { DP, E, pipe } from '@duplojs/utils';
+import { createTransformer } from '../create.mjs';
+import { factory } from 'typescript';
+
+const booleanTransformer = createTransformer(DP.booleanKind.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("boolean")), undefined, definition), success);
+});
+
+export { booleanTransformer };

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

@@ -0,0 +1,19 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../create.cjs');
+var typescript = require('typescript');
+
+const dateTransformer = create.createTransformer(utils.DP.dateKind.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("date")), undefined, definition), success);
+});
+
+exports.dateTransformer = dateTransformer;

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

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

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

@@ -0,0 +1,17 @@
+import { DP, E, pipe } from '@duplojs/utils';
+import { createTransformer } from '../create.mjs';
+import { factory } from 'typescript';
+
+const dateTransformer = createTransformer(DP.dateKind.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("date")), undefined, definition), success);
+});
+
+export { dateTransformer };

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

@@ -0,0 +1,19 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../create.cjs');
+var typescript = require('typescript');
+
+const emptyTransformer = create.createTransformer(utils.DP.emptyKind.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("empty")), undefined, definition), success);
+});
+
+exports.emptyTransformer = emptyTransformer;

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

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

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

@@ -0,0 +1,17 @@
+import { DP, E, pipe } from '@duplojs/utils';
+import { createTransformer } from '../create.mjs';
+import { factory } from 'typescript';
+
+const emptyTransformer = createTransformer(DP.emptyKind.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("empty")), undefined, definition), success);
+});
+
+export { emptyTransformer };

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

@@ -0,0 +1,44 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../create.cjs');
+var typescript = require('typescript');
+var serverUtils = require('@duplojs/server-utils');
+
+const fileTransformer = create.createTransformer(serverUtils.SDP.fileKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, addImport, }) => {
+    const definition = getDefinition();
+    if (utils.E.isLeft(definition)) {
+        return definition;
+    }
+    const dataParserFileParams = [];
+    if (dataParser.definition.coerce) {
+        dataParserFileParams.push(typescript.factory.createPropertyAssignment(typescript.factory.createIdentifier("coerce"), typescript.factory.createTrue()));
+    }
+    if (dataParser.definition.checkExist) {
+        dataParserFileParams.push(typescript.factory.createPropertyAssignment(typescript.factory.createIdentifier("checkExist"), typescript.factory.createTrue()));
+    }
+    if (dataParser.definition.maxSize) {
+        dataParserFileParams.push(typescript.factory.createPropertyAssignment(typescript.factory.createIdentifier("maxSize"), typescript.factory.createNumericLiteral(dataParser.definition.maxSize)));
+    }
+    if (dataParser.definition.minSize) {
+        dataParserFileParams.push(typescript.factory.createPropertyAssignment(typescript.factory.createIdentifier("minSize"), typescript.factory.createNumericLiteral(dataParser.definition.minSize)));
+    }
+    if (dataParser.definition.mimeType) {
+        dataParserFileParams.push(typescript.factory.createPropertyAssignment(typescript.factory.createIdentifier("mimeType"), typescript.factory.createRegularExpressionLiteral(dataParser.definition.mimeType.toString())));
+    }
+    const namespace = dependencyIdentifier.text === "DP"
+        ? utils.justExec(() => {
+            addImport("@duplojs/server-utils/dataParser", "SDP", "namespace");
+            return "SDP";
+        })
+        : utils.justExec(() => {
+            addImport("@duplojs/server-utils/dataParserExtended", "SDPE", "namespace");
+            return "SDPE";
+        });
+    return utils.pipe(typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(typescript.factory.createIdentifier(namespace), typescript.factory.createIdentifier("file")), undefined, [
+        typescript.factory.createObjectLiteralExpression(dataParserFileParams, utils.A.minElements(dataParserFileParams, 2)),
+        ...definition,
+    ]), success);
+});
+
+exports.fileTransformer = fileTransformer;

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

@@ -0,0 +1 @@
+export declare const fileTransformer: (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither;

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

@@ -0,0 +1,42 @@
+import { E, justExec, pipe, A } from '@duplojs/utils';
+import { createTransformer } from '../create.mjs';
+import { factory } from 'typescript';
+import { SDP } from '@duplojs/server-utils';
+
+const fileTransformer = createTransformer(SDP.fileKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, addImport, }) => {
+    const definition = getDefinition();
+    if (E.isLeft(definition)) {
+        return definition;
+    }
+    const dataParserFileParams = [];
+    if (dataParser.definition.coerce) {
+        dataParserFileParams.push(factory.createPropertyAssignment(factory.createIdentifier("coerce"), factory.createTrue()));
+    }
+    if (dataParser.definition.checkExist) {
+        dataParserFileParams.push(factory.createPropertyAssignment(factory.createIdentifier("checkExist"), factory.createTrue()));
+    }
+    if (dataParser.definition.maxSize) {
+        dataParserFileParams.push(factory.createPropertyAssignment(factory.createIdentifier("maxSize"), factory.createNumericLiteral(dataParser.definition.maxSize)));
+    }
+    if (dataParser.definition.minSize) {
+        dataParserFileParams.push(factory.createPropertyAssignment(factory.createIdentifier("minSize"), factory.createNumericLiteral(dataParser.definition.minSize)));
+    }
+    if (dataParser.definition.mimeType) {
+        dataParserFileParams.push(factory.createPropertyAssignment(factory.createIdentifier("mimeType"), factory.createRegularExpressionLiteral(dataParser.definition.mimeType.toString())));
+    }
+    const namespace = dependencyIdentifier.text === "DP"
+        ? justExec(() => {
+            addImport("@duplojs/server-utils/dataParser", "SDP", "namespace");
+            return "SDP";
+        })
+        : justExec(() => {
+            addImport("@duplojs/server-utils/dataParserExtended", "SDPE", "namespace");
+            return "SDPE";
+        });
+    return pipe(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(namespace), factory.createIdentifier("file")), undefined, [
+        factory.createObjectLiteralExpression(dataParserFileParams, A.minElements(dataParserFileParams, 2)),
+        ...definition,
+    ]), success);
+});
+
+export { fileTransformer };

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

@@ -0,0 +1,76 @@
+'use strict';
+
+var array = require('./array.cjs');
+var bigint = require('./bigint.cjs');
+var boolean = require('./boolean.cjs');
+var date = require('./date.cjs');
+var empty = require('./empty.cjs');
+var file = require('./file.cjs');
+var lazy = require('./lazy.cjs');
+var literal = require('./literal.cjs');
+var nil = require('./nil.cjs');
+var nullable = require('./nullable.cjs');
+var number = require('./number.cjs');
+var object = require('./object.cjs');
+var optional = require('./optional.cjs');
+var pipe = require('./pipe.cjs');
+var record = require('./record.cjs');
+var recover = require('./recover.cjs');
+var string = require('./string.cjs');
+var templateLiteral = require('./templateLiteral.cjs');
+var time = require('./time.cjs');
+var transform = require('./transform.cjs');
+var tuple = require('./tuple.cjs');
+var union = require('./union.cjs');
+var unknown = require('./unknown.cjs');
+
+const defaultTransformers = [
+    array.arrayTransformer,
+    bigint.bigIntTransformer,
+    boolean.booleanTransformer,
+    date.dateTransformer,
+    empty.emptyTransformer,
+    file.fileTransformer,
+    lazy.lazyTransformer,
+    literal.literalTransformer,
+    nil.nilTransformer,
+    nullable.nullableTransformer,
+    number.numberTransformer,
+    object.objectTransformer,
+    optional.optionalTransformer,
+    pipe.pipeTransformer,
+    record.recordTransformer,
+    recover.recoverTransformer,
+    string.stringTransformer,
+    templateLiteral.templateLiteralTransformer,
+    time.timeTransformer,
+    transform.transformTransformer,
+    tuple.tupleTransformer,
+    union.unionTransformer,
+    unknown.unknownTransformer,
+];
+
+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 = defaultTransformers;

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

@@ -0,0 +1,24 @@
+export * from "./array";
+export * from "./bigint";
+export * from "./boolean";
+export * from "./date";
+export * from "./empty";
+export * from "./file";
+export * from "./lazy";
+export * from "./literal";
+export * from "./nil";
+export * from "./nullable";
+export * from "./number";
+export * from "./object";
+export * from "./optional";
+export * from "./pipe";
+export * from "./record";
+export * from "./recover";
+export * from "./string";
+export * from "./templateLiteral";
+export * from "./time";
+export * from "./transform";
+export * from "./tuple";
+export * from "./union";
+export * from "./unknown";
+export declare const defaultTransformers: readonly [(dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither, (dataParser: import("@duplojs/utils/dataParser").DataParsers, params: import("..").TransformerParams) => import("..").MaybeTransformerEither];

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

@@ -0,0 +1,51 @@
+import { arrayTransformer } from './array.mjs';
+import { bigIntTransformer } from './bigint.mjs';
+import { booleanTransformer } from './boolean.mjs';
+import { dateTransformer } from './date.mjs';
+import { emptyTransformer } from './empty.mjs';
+import { fileTransformer } from './file.mjs';
+import { lazyTransformer } from './lazy.mjs';
+import { literalTransformer } from './literal.mjs';
+import { nilTransformer } from './nil.mjs';
+import { nullableTransformer } from './nullable.mjs';
+import { numberTransformer } from './number.mjs';
+import { objectTransformer } from './object.mjs';
+import { optionalTransformer } from './optional.mjs';
+import { pipeTransformer } from './pipe.mjs';
+import { recordTransformer } from './record.mjs';
+import { recoverTransformer } from './recover.mjs';
+import { stringTransformer } from './string.mjs';
+import { templateLiteralTransformer } from './templateLiteral.mjs';
+import { timeTransformer } from './time.mjs';
+import { transformTransformer } from './transform.mjs';
+import { tupleTransformer } from './tuple.mjs';
+import { unionTransformer } from './union.mjs';
+import { unknownTransformer } from './unknown.mjs';
+
+const defaultTransformers = [
+    arrayTransformer,
+    bigIntTransformer,
+    booleanTransformer,
+    dateTransformer,
+    emptyTransformer,
+    fileTransformer,
+    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/toDataParser/dataParserTransformer/defaults/lazy.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../create.cjs');
+var typescript = require('typescript');
+
+const lazyTransformer = create.createTransformer(utils.DP.lazyKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, transformer, }) => {
+    const getter = transformer(dataParser.definition.getter.value);
+    if (utils.E.isLeft(getter)) {
+        return getter;
+    }
+    const definition = getDefinition();
+    if (utils.E.isLeft(definition)) {
+        return definition;
+    }
+    return utils.pipe(typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(dependencyIdentifier, typescript.factory.createIdentifier("lazy")), undefined, [
+        typescript.factory.createArrowFunction(undefined, undefined, [], undefined, typescript.factory.createToken(typescript.SyntaxKind.EqualsGreaterThanToken), utils.unwrap(getter)),
+        ...definition,
+    ]), success);
+});
+
+exports.lazyTransformer = lazyTransformer;

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

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

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

@@ -0,0 +1,20 @@
+import { DP, E, pipe, unwrap } from '@duplojs/utils';
+import { createTransformer } from '../create.mjs';
+import { factory, SyntaxKind } from 'typescript';
+
+const lazyTransformer = createTransformer(DP.lazyKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, transformer, }) => {
+    const getter = transformer(dataParser.definition.getter.value);
+    if (E.isLeft(getter)) {
+        return getter;
+    }
+    const definition = getDefinition();
+    if (E.isLeft(definition)) {
+        return definition;
+    }
+    return pipe(factory.createCallExpression(factory.createPropertyAccessExpression(dependencyIdentifier, factory.createIdentifier("lazy")), undefined, [
+        factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(SyntaxKind.EqualsGreaterThanToken), unwrap(getter)),
+        ...definition,
+    ]), success);
+});
+
+export { lazyTransformer };

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

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

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

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