@duplojs/data-parser-tools 0.2.9 → 0.4.0

package/dist/index.cjs

@@ -2,6 +2,7 @@
 
 var index = require('./toTypescript/index.cjs');
 var index$1 = require('./toJsonSchema/index.cjs');
+var index$2 = require('./toDataParser/index.cjs');
 require('./utils/index.cjs');
 var getRecursiveDataParser = require('./utils/getRecursiveDataParser.cjs');
 
@@ -9,4 +10,5 @@ var getRecursiveDataParser = require('./utils/getRecursiveDataParser.cjs');
 
 exports.DataParserToTypescript = index;
 exports.DataParserToJsonSchema = index$1;
+exports.DataParserToDataParser = index$2;
 exports.getRecursiveDataParser = getRecursiveDataParser.getRecursiveDataParser;

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * as DataParserToTypescript from "./toTypescript";
 export * as DataParserToJsonSchema from "./toJsonSchema";
+export * as DataParserToDataParser from "./toDataParser";
 export * from "./utils";

package/dist/index.mjs

@@ -2,5 +2,7 @@ import * as index from './toTypescript/index.mjs';
 export { index as DataParserToTypescript };
 import * as index$1 from './toJsonSchema/index.mjs';
 export { index$1 as DataParserToJsonSchema };
+import * as index$2 from './toDataParser/index.mjs';
+export { index$2 as DataParserToDataParser };
 import './utils/index.mjs';
 export { getRecursiveDataParser } from './utils/getRecursiveDataParser.mjs';

package/dist/toDataParser/buildContext.cjs

@@ -0,0 +1,63 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+require('./dataParserTransformer/index.cjs');
+require('../utils/index.cjs');
+var typescript = require('typescript');
+var transformer = require('./dataParserTransformer/transformer.cjs');
+var getRecursiveDataParser = require('../utils/getRecursiveDataParser.cjs');
+var createIdentifier = require('./dataParserTransformer/createIdentifier.cjs');
+
+function buildContext(schema, params) {
+    const context = params.context ?? new Map();
+    const typescriptContext = params.typescriptContext ?? new Map();
+    const importContext = params.importContext ?? new Map();
+    const dependenciesContext = new Set();
+    const importMode = params.importMode ?? "lite";
+    importContext.set("@duplojs/utils/dataParser", {
+        namespace: ["DP"],
+    });
+    if (importMode === "extended") {
+        importContext.set("@duplojs/utils/dataParserExtended", {
+            namespace: ["DPE"],
+        });
+    }
+    const result = transformer.transformer(schema, {
+        ...params,
+        context,
+        typescriptContext,
+        importContext: importContext,
+        hooks: params.hooks ?? [],
+        recursiveDataParsers: getRecursiveDataParser.getRecursiveDataParser(schema),
+        dependencyIdentifier: typescript.factory.createIdentifier(importMode === "extended" ? "DPE" : "DP"),
+        dependenciesContext,
+    });
+    if (utils.E.isLeft(result)) {
+        return result;
+    }
+    if (!schema.definition.identifier) {
+        context.set(utils.DP.empty(), {
+            identifier: typescript.factory.createIdentifier(createIdentifier.createIdentifier(params.identifier)),
+            expression: utils.unwrap(result),
+            typeIdentifier: null,
+            dependencies: dependenciesContext,
+        });
+    }
+    else if (schema.definition.identifier !== params.identifier) {
+        dependenciesContext.add(schema);
+        context.set(utils.DP.empty(), {
+            identifier: typescript.factory.createIdentifier(createIdentifier.createIdentifier(params.identifier)),
+            expression: typescript.factory.createIdentifier(createIdentifier.createIdentifier(schema.definition.identifier)),
+            typeIdentifier: null,
+            dependencies: dependenciesContext,
+        });
+    }
+    return utils.E.success({
+        context,
+        importContext: importContext,
+        typescriptContext,
+        importMode,
+    });
+}
+
+exports.buildContext = buildContext;

package/dist/toDataParser/buildContext.d.ts

@@ -0,0 +1,27 @@
+import { DP, E } from "@duplojs/utils";
+import { type createTransformer, type MapContext, type TransformerHook, type DataParserErrorEither, type DataParserNotSupportedEither, type DataParserGetDefinitionErrorEither, type ToTypescriptDataParserErrorEither, type ToTypescriptDataParserNotSupportedEither } from "./dataParserTransformer";
+import type * as TST from "../toTypescript";
+import { type createCheckerTransformer } from "./checkerTransformer";
+export type ImportMode = "lite" | "extended";
+export interface BuildedContext {
+    readonly context: MapContext;
+    readonly typescriptContext: TST.MapContext;
+    readonly importContext: TST.MapImportContext;
+    readonly importMode: ImportMode;
+}
+export interface BuildContextParams {
+    readonly identifier: string;
+    readonly dataParserTransformers: readonly ReturnType<typeof createTransformer>[];
+    readonly checkerTransformers: readonly ReturnType<typeof createCheckerTransformer>[];
+    readonly typescriptTransformers: readonly ReturnType<typeof TST.createTransformer>[];
+    readonly context?: MapContext;
+    readonly typescriptContext?: TST.MapContext;
+    readonly importContext?: TST.MapImportContext;
+    readonly importMode?: ImportMode;
+    readonly hooks?: readonly TransformerHook[];
+    readonly toTypescript?: {
+        readonly mode?: TST.TransformerMode;
+        readonly hooks?: readonly TST.TransformerHook[];
+    };
+}
+export declare function buildContext(schema: DP.DataParser, params: BuildContextParams): (E.Success<BuildedContext> | DataParserNotSupportedEither | DataParserErrorEither | DataParserGetDefinitionErrorEither | ToTypescriptDataParserNotSupportedEither | ToTypescriptDataParserErrorEither);

package/dist/toDataParser/buildContext.mjs

@@ -0,0 +1,61 @@
+import { E, DP, unwrap } from '@duplojs/utils';
+import './dataParserTransformer/index.mjs';
+import '../utils/index.mjs';
+import { factory } from 'typescript';
+import { transformer } from './dataParserTransformer/transformer.mjs';
+import { getRecursiveDataParser } from '../utils/getRecursiveDataParser.mjs';
+import { createIdentifier } from './dataParserTransformer/createIdentifier.mjs';
+
+function buildContext(schema, params) {
+    const context = params.context ?? new Map();
+    const typescriptContext = params.typescriptContext ?? new Map();
+    const importContext = params.importContext ?? new Map();
+    const dependenciesContext = new Set();
+    const importMode = params.importMode ?? "lite";
+    importContext.set("@duplojs/utils/dataParser", {
+        namespace: ["DP"],
+    });
+    if (importMode === "extended") {
+        importContext.set("@duplojs/utils/dataParserExtended", {
+            namespace: ["DPE"],
+        });
+    }
+    const result = transformer(schema, {
+        ...params,
+        context,
+        typescriptContext,
+        importContext: importContext,
+        hooks: params.hooks ?? [],
+        recursiveDataParsers: getRecursiveDataParser(schema),
+        dependencyIdentifier: factory.createIdentifier(importMode === "extended" ? "DPE" : "DP"),
+        dependenciesContext,
+    });
+    if (E.isLeft(result)) {
+        return result;
+    }
+    if (!schema.definition.identifier) {
+        context.set(DP.empty(), {
+            identifier: factory.createIdentifier(createIdentifier(params.identifier)),
+            expression: unwrap(result),
+            typeIdentifier: null,
+            dependencies: dependenciesContext,
+        });
+    }
+    else if (schema.definition.identifier !== params.identifier) {
+        dependenciesContext.add(schema);
+        context.set(DP.empty(), {
+            identifier: factory.createIdentifier(createIdentifier(params.identifier)),
+            expression: factory.createIdentifier(createIdentifier(schema.definition.identifier)),
+            typeIdentifier: null,
+            dependencies: dependenciesContext,
+        });
+    }
+    return E.success({
+        context,
+        importContext: importContext,
+        typescriptContext,
+        importMode,
+    });
+}
+
+export { buildContext };

package/dist/toDataParser/checkerTransformer/create.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+
+function createCheckerTransformer(support, builder) {
+    return (checker, params) => support(checker)
+        ? builder(checker, params)
+        : utils.E.left("checkerNotSupport", checker);
+}
+
+exports.createCheckerTransformer = createCheckerTransformer;

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

@@ -0,0 +1,20 @@
+import type { CallExpression, ObjectLiteralExpression, PropertyAssignment } from "typescript";
+import { type DP, E } from "@duplojs/utils";
+import type * as TST from "../../toTypescript";
+export type CheckerTransformerSuccessEither = E.Right<"buildSuccess", CallExpression>;
+export type CheckerTransformerCheckerNotSupportedEither = E.Left<"checkerNotSupport", DP.DataParserChecker>;
+export type CheckerTransformerBuildErrorEither = E.Left<"buildCheckerError", DP.DataParserChecker>;
+export type CheckerTransformerEither = CheckerTransformerSuccessEither | CheckerTransformerCheckerNotSupportedEither | CheckerTransformerBuildErrorEither;
+export interface CheckerTransformerParams {
+    readonly importContext: TST.MapImportContext;
+    success(result: CallExpression): CheckerTransformerSuccessEither;
+    buildError(): CheckerTransformerBuildErrorEither;
+    addImport(path: string, typeName: string, type?: "default" | "namespace" | "direct"): void;
+    getDefinition(customProperties?: readonly PropertyAssignment[]): readonly [ObjectLiteralExpression] | readonly [];
+}
+/**
+ * @deprecated
+ */
+export type DataParserCheckers = (DP.DataParserChecker | DP.DataParserCheckerArrayMax | DP.DataParserCheckerArrayMin | DP.DataParserCheckerBigIntMax | DP.DataParserCheckerBigIntMin | DP.DataParserCheckerNumberMax | DP.DataParserCheckerNumberMin | DP.DataParserCheckerInt | DP.DataParserCheckerStringMax | DP.DataParserCheckerStringMin | DP.DataParserCheckerEmail | DP.DataParserCheckerRegex | DP.DataParserCheckerUrl | DP.DataParserCheckerUuid | DP.DataParserCheckerRefine | DP.DataParserCheckerTimeMin | DP.DataParserCheckerTimeMax);
+export type CheckerTransformerBuildFunction<GenericChecker extends DataParserCheckers = DataParserCheckers> = (checker: GenericChecker, params: CheckerTransformerParams) => CheckerTransformerEither;
+export declare function createCheckerTransformer<GenericChecker extends DataParserCheckers>(support: (checker: DataParserCheckers) => checker is GenericChecker, builder: CheckerTransformerBuildFunction<GenericChecker>): (checker: DataParserCheckers, params: CheckerTransformerParams) => CheckerTransformerEither;

package/dist/toDataParser/checkerTransformer/create.mjs

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

package/dist/toDataParser/checkerTransformer/defaults/array/index.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var max = require('./max.cjs');
+var min = require('./min.cjs');
+
+
+
+exports.checkerArrayMaxTransformer = max.checkerArrayMaxTransformer;
+exports.checkerArrayMinTransformer = min.checkerArrayMinTransformer;

package/dist/toDataParser/checkerTransformer/defaults/array/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./max";
+export * from "./min";

package/dist/toDataParser/checkerTransformer/defaults/array/index.mjs

@@ -0,0 +1,2 @@
+export { checkerArrayMaxTransformer } from './max.mjs';
+export { checkerArrayMinTransformer } from './min.mjs';

package/dist/toDataParser/checkerTransformer/defaults/array/max.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../../create.cjs');
+var typescript = require('typescript');
+
+const checkerArrayMaxTransformer = create.createCheckerTransformer(utils.DP.checkerArrayMaxKind.has, (checker, { success, getDefinition, }) => {
+    const expression = typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(typescript.factory.createIdentifier("DP"), typescript.factory.createIdentifier("checkerArrayMax")), undefined, [
+        typescript.factory.createNumericLiteral(checker.definition.max),
+        ...getDefinition(),
+    ]);
+    return success(expression);
+});
+
+exports.checkerArrayMaxTransformer = checkerArrayMaxTransformer;

package/dist/toDataParser/checkerTransformer/defaults/array/max.d.ts

@@ -0,0 +1 @@
+export declare const checkerArrayMaxTransformer: (checker: import("../..").DataParserCheckers, params: import("../..").CheckerTransformerParams) => import("../..").CheckerTransformerEither;

package/dist/toDataParser/checkerTransformer/defaults/array/max.mjs

@@ -0,0 +1,13 @@
+import { DP } from '@duplojs/utils';
+import { createCheckerTransformer } from '../../create.mjs';
+import { factory } from 'typescript';
+
+const checkerArrayMaxTransformer = createCheckerTransformer(DP.checkerArrayMaxKind.has, (checker, { success, getDefinition, }) => {
+    const expression = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("DP"), factory.createIdentifier("checkerArrayMax")), undefined, [
+        factory.createNumericLiteral(checker.definition.max),
+        ...getDefinition(),
+    ]);
+    return success(expression);
+});
+
+export { checkerArrayMaxTransformer };

package/dist/toDataParser/checkerTransformer/defaults/array/min.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../../create.cjs');
+var typescript = require('typescript');
+
+const checkerArrayMinTransformer = create.createCheckerTransformer(utils.DP.checkerArrayMinKind.has, (checker, { success, getDefinition, }) => {
+    const expression = typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(typescript.factory.createIdentifier("DP"), typescript.factory.createIdentifier("checkerArrayMin")), undefined, [
+        typescript.factory.createNumericLiteral(checker.definition.min),
+        ...getDefinition(),
+    ]);
+    return success(expression);
+});
+
+exports.checkerArrayMinTransformer = checkerArrayMinTransformer;

package/dist/toDataParser/checkerTransformer/defaults/array/min.d.ts

@@ -0,0 +1 @@
+export declare const checkerArrayMinTransformer: (checker: import("../..").DataParserCheckers, params: import("../..").CheckerTransformerParams) => import("../..").CheckerTransformerEither;

package/dist/toDataParser/checkerTransformer/defaults/array/min.mjs

@@ -0,0 +1,13 @@
+import { DP } from '@duplojs/utils';
+import { createCheckerTransformer } from '../../create.mjs';
+import { factory } from 'typescript';
+
+const checkerArrayMinTransformer = createCheckerTransformer(DP.checkerArrayMinKind.has, (checker, { success, getDefinition, }) => {
+    const expression = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("DP"), factory.createIdentifier("checkerArrayMin")), undefined, [
+        factory.createNumericLiteral(checker.definition.min),
+        ...getDefinition(),
+    ]);
+    return success(expression);
+});
+
+export { checkerArrayMinTransformer };

package/dist/toDataParser/checkerTransformer/defaults/bigint/index.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var max = require('./max.cjs');
+var min = require('./min.cjs');
+
+
+
+exports.checkerBigIntMaxTransformer = max.checkerBigIntMaxTransformer;
+exports.checkerBigIntMinTransformer = min.checkerBigIntMinTransformer;

package/dist/toDataParser/checkerTransformer/defaults/bigint/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./max";
+export * from "./min";

package/dist/toDataParser/checkerTransformer/defaults/bigint/index.mjs

@@ -0,0 +1,2 @@
+export { checkerBigIntMaxTransformer } from './max.mjs';
+export { checkerBigIntMinTransformer } from './min.mjs';

package/dist/toDataParser/checkerTransformer/defaults/bigint/max.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../../create.cjs');
+var typescript = require('typescript');
+
+const checkerBigIntMaxTransformer = create.createCheckerTransformer(utils.DP.checkerBigIntMaxKind.has, (checker, { success, getDefinition, }) => {
+    const expression = typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(typescript.factory.createIdentifier("DP"), typescript.factory.createIdentifier("checkerBigIntMax")), undefined, [
+        typescript.factory.createBigIntLiteral(`${checker.definition.max.toString()}n`),
+        ...getDefinition(),
+    ]);
+    return success(expression);
+});
+
+exports.checkerBigIntMaxTransformer = checkerBigIntMaxTransformer;

package/dist/toDataParser/checkerTransformer/defaults/bigint/max.d.ts

@@ -0,0 +1 @@
+export declare const checkerBigIntMaxTransformer: (checker: import("../..").DataParserCheckers, params: import("../..").CheckerTransformerParams) => import("../..").CheckerTransformerEither;

package/dist/toDataParser/checkerTransformer/defaults/bigint/max.mjs

@@ -0,0 +1,13 @@
+import { DP } from '@duplojs/utils';
+import { createCheckerTransformer } from '../../create.mjs';
+import { factory } from 'typescript';
+
+const checkerBigIntMaxTransformer = createCheckerTransformer(DP.checkerBigIntMaxKind.has, (checker, { success, getDefinition, }) => {
+    const expression = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("DP"), factory.createIdentifier("checkerBigIntMax")), undefined, [
+        factory.createBigIntLiteral(`${checker.definition.max.toString()}n`),
+        ...getDefinition(),
+    ]);
+    return success(expression);
+});
+
+export { checkerBigIntMaxTransformer };

package/dist/toDataParser/checkerTransformer/defaults/bigint/min.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../../create.cjs');
+var typescript = require('typescript');
+
+const checkerBigIntMinTransformer = create.createCheckerTransformer(utils.DP.checkerBigIntMinKind.has, (checker, { success, getDefinition, }) => {
+    const expression = typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(typescript.factory.createIdentifier("DP"), typescript.factory.createIdentifier("checkerBigIntMin")), undefined, [
+        typescript.factory.createBigIntLiteral(`${checker.definition.min.toString()}n`),
+        ...getDefinition(),
+    ]);
+    return success(expression);
+});
+
+exports.checkerBigIntMinTransformer = checkerBigIntMinTransformer;

package/dist/toDataParser/checkerTransformer/defaults/bigint/min.d.ts

@@ -0,0 +1 @@
+export declare const checkerBigIntMinTransformer: (checker: import("../..").DataParserCheckers, params: import("../..").CheckerTransformerParams) => import("../..").CheckerTransformerEither;

package/dist/toDataParser/checkerTransformer/defaults/bigint/min.mjs

@@ -0,0 +1,13 @@
+import { DP } from '@duplojs/utils';
+import { createCheckerTransformer } from '../../create.mjs';
+import { factory } from 'typescript';
+
+const checkerBigIntMinTransformer = createCheckerTransformer(DP.checkerBigIntMinKind.has, (checker, { success, getDefinition, }) => {
+    const expression = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("DP"), factory.createIdentifier("checkerBigIntMin")), undefined, [
+        factory.createBigIntLiteral(`${checker.definition.min.toString()}n`),
+        ...getDefinition(),
+    ]);
+    return success(expression);
+});
+
+export { checkerBigIntMinTransformer };

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

@@ -0,0 +1,60 @@
+'use strict';
+
+require('./number/index.cjs');
+require('./string/index.cjs');
+require('./array/index.cjs');
+require('./bigint/index.cjs');
+require('./time/index.cjs');
+var refine = require('./refine.cjs');
+var max = require('./number/max.cjs');
+var min = require('./number/min.cjs');
+var int = require('./number/int.cjs');
+var max$1 = require('./string/max.cjs');
+var min$1 = require('./string/min.cjs');
+var email = require('./string/email.cjs');
+var regex = require('./string/regex.cjs');
+var uuid = require('./string/uuid.cjs');
+var url = require('./string/url.cjs');
+var max$2 = require('./array/max.cjs');
+var min$2 = require('./array/min.cjs');
+var max$3 = require('./bigint/max.cjs');
+var min$3 = require('./bigint/min.cjs');
+var max$4 = require('./time/max.cjs');
+var min$4 = require('./time/min.cjs');
+
+const defaultCheckerTransformers = [
+    refine.checkerRefineTransformer,
+    // number
+    max.checkerNumberMaxTransformer,
+    min.checkerNumberMinTransformer,
+    int.checkerIntTransformer,
+    // string
+    max$1.checkerStringMaxTransformer,
+    min$1.checkerStringMinTransformer,
+    email.checkerEmailTransformer,
+    regex.checkerRegexTransformer,
+    uuid.checkerUuidTransformer,
+    url.checkerUrlTransformer,
+    // array
+    max$2.checkerArrayMaxTransformer,
+    min$2.checkerArrayMinTransformer,
+    // bigint
+    max$3.checkerBigIntMaxTransformer,
+    min$3.checkerBigIntMinTransformer,
+    // time
+    max$4.checkerTimeMaxTransformer,
+    min$4.checkerTimeMinTransformer,
+];
+
+exports.checkerNumberMaxTransformer = max.checkerNumberMaxTransformer;
+exports.checkerNumberMinTransformer = min.checkerNumberMinTransformer;
+exports.checkerIntTransformer = int.checkerIntTransformer;
+exports.checkerStringMaxTransformer = max$1.checkerStringMaxTransformer;
+exports.checkerStringMinTransformer = min$1.checkerStringMinTransformer;
+exports.checkerEmailTransformer = email.checkerEmailTransformer;
+exports.checkerRegexTransformer = regex.checkerRegexTransformer;
+exports.checkerUuidTransformer = uuid.checkerUuidTransformer;
+exports.checkerUrlTransformer = url.checkerUrlTransformer;
+exports.checkerArrayMaxTransformer = max$2.checkerArrayMaxTransformer;
+exports.checkerArrayMinTransformer = min$2.checkerArrayMinTransformer;
+exports.defaultCheckerTransformers = defaultCheckerTransformers;

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

@@ -0,0 +1,4 @@
+export * from "./number";
+export * from "./string";
+export * from "./array";
+export declare const defaultCheckerTransformers: readonly [(checker: import("..").DataParserCheckers, params: import("..").CheckerTransformerParams) => import("..").CheckerTransformerEither, (checker: import("..").DataParserCheckers, params: import("..").CheckerTransformerParams) => import("..").CheckerTransformerEither, (checker: import("..").DataParserCheckers, params: import("..").CheckerTransformerParams) => import("..").CheckerTransformerEither, (checker: import("..").DataParserCheckers, params: import("..").CheckerTransformerParams) => import("..").CheckerTransformerEither, (checker: import("..").DataParserCheckers, params: import("..").CheckerTransformerParams) => import("..").CheckerTransformerEither, (checker: import("..").DataParserCheckers, params: import("..").CheckerTransformerParams) => import("..").CheckerTransformerEither, (checker: import("..").DataParserCheckers, params: import("..").CheckerTransformerParams) => import("..").CheckerTransformerEither, (checker: import("..").DataParserCheckers, params: import("..").CheckerTransformerParams) => import("..").CheckerTransformerEither, (checker: import("..").DataParserCheckers, params: import("..").CheckerTransformerParams) => import("..").CheckerTransformerEither, (checker: import("..").DataParserCheckers, params: import("..").CheckerTransformerParams) => import("..").CheckerTransformerEither, (checker: import("..").DataParserCheckers, params: import("..").CheckerTransformerParams) => import("..").CheckerTransformerEither, (checker: import("..").DataParserCheckers, params: import("..").CheckerTransformerParams) => import("..").CheckerTransformerEither, (checker: import("..").DataParserCheckers, params: import("..").CheckerTransformerParams) => import("..").CheckerTransformerEither, (checker: import("..").DataParserCheckers, params: import("..").CheckerTransformerParams) => import("..").CheckerTransformerEither, (checker: import("..").DataParserCheckers, params: import("..").CheckerTransformerParams) => import("..").CheckerTransformerEither, (checker: import("..").DataParserCheckers, params: import("..").CheckerTransformerParams) => import("..").CheckerTransformerEither];

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

@@ -0,0 +1,47 @@
+import './number/index.mjs';
+import './string/index.mjs';
+import './array/index.mjs';
+import './bigint/index.mjs';
+import './time/index.mjs';
+import { checkerRefineTransformer } from './refine.mjs';
+import { checkerNumberMaxTransformer } from './number/max.mjs';
+import { checkerNumberMinTransformer } from './number/min.mjs';
+import { checkerIntTransformer } from './number/int.mjs';
+import { checkerStringMaxTransformer } from './string/max.mjs';
+import { checkerStringMinTransformer } from './string/min.mjs';
+import { checkerEmailTransformer } from './string/email.mjs';
+import { checkerRegexTransformer } from './string/regex.mjs';
+import { checkerUuidTransformer } from './string/uuid.mjs';
+import { checkerUrlTransformer } from './string/url.mjs';
+import { checkerArrayMaxTransformer } from './array/max.mjs';
+import { checkerArrayMinTransformer } from './array/min.mjs';
+import { checkerBigIntMaxTransformer } from './bigint/max.mjs';
+import { checkerBigIntMinTransformer } from './bigint/min.mjs';
+import { checkerTimeMaxTransformer } from './time/max.mjs';
+import { checkerTimeMinTransformer } from './time/min.mjs';
+
+const defaultCheckerTransformers = [
+    checkerRefineTransformer,
+    // number
+    checkerNumberMaxTransformer,
+    checkerNumberMinTransformer,
+    checkerIntTransformer,
+    // string
+    checkerStringMaxTransformer,
+    checkerStringMinTransformer,
+    checkerEmailTransformer,
+    checkerRegexTransformer,
+    checkerUuidTransformer,
+    checkerUrlTransformer,
+    // array
+    checkerArrayMaxTransformer,
+    checkerArrayMinTransformer,
+    // bigint
+    checkerBigIntMaxTransformer,
+    checkerBigIntMinTransformer,
+    // time
+    checkerTimeMaxTransformer,
+    checkerTimeMinTransformer,
+];
+
+export { checkerArrayMaxTransformer, checkerArrayMinTransformer, checkerEmailTransformer, checkerIntTransformer, checkerNumberMaxTransformer, checkerNumberMinTransformer, checkerRegexTransformer, checkerStringMaxTransformer, checkerStringMinTransformer, checkerUrlTransformer, checkerUuidTransformer, defaultCheckerTransformers };

package/dist/toDataParser/checkerTransformer/defaults/number/index.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var int = require('./int.cjs');
+var min = require('./min.cjs');
+var max = require('./max.cjs');
+
+
+
+exports.checkerIntTransformer = int.checkerIntTransformer;
+exports.checkerNumberMinTransformer = min.checkerNumberMinTransformer;
+exports.checkerNumberMaxTransformer = max.checkerNumberMaxTransformer;

package/dist/toDataParser/checkerTransformer/defaults/number/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./int";
+export * from "./min";
+export * from "./max";

package/dist/toDataParser/checkerTransformer/defaults/number/index.mjs

@@ -0,0 +1,3 @@
+export { checkerIntTransformer } from './int.mjs';
+export { checkerNumberMinTransformer } from './min.mjs';
+export { checkerNumberMaxTransformer } from './max.mjs';

package/dist/toDataParser/checkerTransformer/defaults/number/int.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../../create.cjs');
+var typescript = require('typescript');
+
+const checkerIntTransformer = create.createCheckerTransformer(utils.DP.checkerIntKind.has, (checker, { success, getDefinition, }) => {
+    const expression = typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(typescript.factory.createIdentifier("DP"), typescript.factory.createIdentifier("checkerInt")), undefined, getDefinition());
+    return success(expression);
+});
+
+exports.checkerIntTransformer = checkerIntTransformer;

package/dist/toDataParser/checkerTransformer/defaults/number/int.d.ts

@@ -0,0 +1 @@
+export declare const checkerIntTransformer: (checker: import("../..").DataParserCheckers, params: import("../..").CheckerTransformerParams) => import("../..").CheckerTransformerEither;

package/dist/toDataParser/checkerTransformer/defaults/number/int.mjs

@@ -0,0 +1,10 @@
+import { DP } from '@duplojs/utils';
+import { createCheckerTransformer } from '../../create.mjs';
+import { factory } from 'typescript';
+
+const checkerIntTransformer = createCheckerTransformer(DP.checkerIntKind.has, (checker, { success, getDefinition, }) => {
+    const expression = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("DP"), factory.createIdentifier("checkerInt")), undefined, getDefinition());
+    return success(expression);
+});
+
+export { checkerIntTransformer };

package/dist/toDataParser/checkerTransformer/defaults/number/max.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../../create.cjs');
+var typescript = require('typescript');
+
+const checkerNumberMaxTransformer = create.createCheckerTransformer(utils.DP.checkerNumberMaxKind.has, (checker, { success, getDefinition, }) => {
+    const checkerDefinition = [];
+    if (checker.definition.exclusive) {
+        checkerDefinition.push(typescript.factory.createPropertyAssignment(typescript.factory.createIdentifier("exclusive"), typescript.factory.createTrue()));
+    }
+    const expression = typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(typescript.factory.createIdentifier("DP"), typescript.factory.createIdentifier("checkerNumberMax")), undefined, [
+        typescript.factory.createNumericLiteral(checker.definition.max),
+        ...getDefinition(checkerDefinition),
+    ]);
+    return success(expression);
+});
+
+exports.checkerNumberMaxTransformer = checkerNumberMaxTransformer;

package/dist/toDataParser/checkerTransformer/defaults/number/max.d.ts

@@ -0,0 +1 @@
+export declare const checkerNumberMaxTransformer: (checker: import("../..").DataParserCheckers, params: import("../..").CheckerTransformerParams) => import("../..").CheckerTransformerEither;

package/dist/toDataParser/checkerTransformer/defaults/number/max.mjs

@@ -0,0 +1,17 @@
+import { DP } from '@duplojs/utils';
+import { createCheckerTransformer } from '../../create.mjs';
+import { factory } from 'typescript';
+
+const checkerNumberMaxTransformer = createCheckerTransformer(DP.checkerNumberMaxKind.has, (checker, { success, getDefinition, }) => {
+    const checkerDefinition = [];
+    if (checker.definition.exclusive) {
+        checkerDefinition.push(factory.createPropertyAssignment(factory.createIdentifier("exclusive"), factory.createTrue()));
+    }
+    const expression = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("DP"), factory.createIdentifier("checkerNumberMax")), undefined, [
+        factory.createNumericLiteral(checker.definition.max),
+        ...getDefinition(checkerDefinition),
+    ]);
+    return success(expression);
+});
+
+export { checkerNumberMaxTransformer };