@duplojs/data-parser-tools 0.2.9 → 0.4.0

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

@@ -0,0 +1,19 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../../create.cjs');
+var typescript = require('typescript');
+
+const checkerNumberMinTransformer = create.createCheckerTransformer(utils.DP.checkerNumberMinKind.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("checkerNumberMin")), undefined, [
+        typescript.factory.createNumericLiteral(checker.definition.min),
+        ...getDefinition(checkerDefinition),
+    ]);
+    return success(expression);
+});
+
+exports.checkerNumberMinTransformer = checkerNumberMinTransformer;

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

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

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

@@ -0,0 +1,17 @@
+import { DP } from '@duplojs/utils';
+import { createCheckerTransformer } from '../../create.mjs';
+import { factory } from 'typescript';
+
+const checkerNumberMinTransformer = createCheckerTransformer(DP.checkerNumberMinKind.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("checkerNumberMin")), undefined, [
+        factory.createNumericLiteral(checker.definition.min),
+        ...getDefinition(checkerDefinition),
+    ]);
+    return success(expression);
+});
+
+export { checkerNumberMinTransformer };

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

@@ -0,0 +1,32 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../create.cjs');
+var typescript = require('typescript');
+
+const checkerRefineTransformer = create.createCheckerTransformer(utils.DP.dataParserCheckerRefineKind.has, (checker, { success, buildError, getDefinition, }) => {
+    const functionSource = checker.definition.theFunction.toString();
+    if (functionSource.includes("[native code]")) {
+        return buildError();
+    }
+    const sourceFile = typescript.createSourceFile("refine-function.ts", `(${functionSource})`, 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 expression = typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(typescript.factory.createIdentifier("DP"), typescript.factory.createIdentifier("checkerRefine")), undefined, [
+        functionExpression,
+        ...getDefinition(),
+    ]);
+    return success(expression);
+});
+
+exports.checkerRefineTransformer = checkerRefineTransformer;

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

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

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

@@ -0,0 +1,30 @@
+import { DP } from '@duplojs/utils';
+import { createCheckerTransformer } from '../create.mjs';
+import { createSourceFile, ScriptTarget, isExpressionStatement, isParenthesizedExpression, isFunctionExpression, isArrowFunction, factory } from 'typescript';
+
+const checkerRefineTransformer = createCheckerTransformer(DP.dataParserCheckerRefineKind.has, (checker, { success, buildError, getDefinition, }) => {
+    const functionSource = checker.definition.theFunction.toString();
+    if (functionSource.includes("[native code]")) {
+        return buildError();
+    }
+    const sourceFile = createSourceFile("refine-function.ts", `(${functionSource})`, ScriptTarget.Latest, false);
+    const statement = sourceFile.statements[0];
+    if (!statement || !isExpressionStatement(statement)) {
+        return buildError();
+    }
+    const functionExpression = isParenthesizedExpression(statement.expression)
+        ? statement.expression.expression
+        : undefined;
+    if (!functionExpression
+        || (!isFunctionExpression(functionExpression)
+            && !isArrowFunction(functionExpression))) {
+        return buildError();
+    }
+    const expression = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("DP"), factory.createIdentifier("checkerRefine")), undefined, [
+        functionExpression,
+        ...getDefinition(),
+    ]);
+    return success(expression);
+});
+
+export { checkerRefineTransformer };

package/dist/toDataParser/checkerTransformer/defaults/string/email.cjs

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

package/dist/toDataParser/checkerTransformer/defaults/string/email.d.ts

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

package/dist/toDataParser/checkerTransformer/defaults/string/email.mjs

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

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

@@ -0,0 +1,17 @@
+'use strict';
+
+var email = require('./email.cjs');
+var max = require('./max.cjs');
+var min = require('./min.cjs');
+var regex = require('./regex.cjs');
+var url = require('./url.cjs');
+var uuid = require('./uuid.cjs');
+
+
+
+exports.checkerEmailTransformer = email.checkerEmailTransformer;
+exports.checkerStringMaxTransformer = max.checkerStringMaxTransformer;
+exports.checkerStringMinTransformer = min.checkerStringMinTransformer;
+exports.checkerRegexTransformer = regex.checkerRegexTransformer;
+exports.checkerUrlTransformer = url.checkerUrlTransformer;
+exports.checkerUuidTransformer = uuid.checkerUuidTransformer;

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

@@ -0,0 +1,6 @@
+export * from "./email";
+export * from "./max";
+export * from "./min";
+export * from "./regex";
+export * from "./url";
+export * from "./uuid";

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

@@ -0,0 +1,6 @@
+export { checkerEmailTransformer } from './email.mjs';
+export { checkerStringMaxTransformer } from './max.mjs';
+export { checkerStringMinTransformer } from './min.mjs';
+export { checkerRegexTransformer } from './regex.mjs';
+export { checkerUrlTransformer } from './url.mjs';
+export { checkerUuidTransformer } from './uuid.mjs';

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/toDataParser/checkerTransformer/defaults/string/regex.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../../create.cjs');
+var typescript = require('typescript');
+
+const checkerRegexTransformer = create.createCheckerTransformer(utils.DP.checkerRegexKind.has, (checker, { success, getDefinition, }) => {
+    const expression = typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(typescript.factory.createIdentifier("DP"), typescript.factory.createIdentifier("checkerRegex")), undefined, [
+        typescript.factory.createRegularExpressionLiteral(`/${checker.definition.regex.source}/${checker.definition.regex.flags}`),
+        ...getDefinition(),
+    ]);
+    return success(expression);
+});
+utils.DP.checkerRegex(/^/);
+
+exports.checkerRegexTransformer = checkerRegexTransformer;

package/dist/toDataParser/checkerTransformer/defaults/string/regex.d.ts

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

package/dist/toDataParser/checkerTransformer/defaults/string/regex.mjs

@@ -0,0 +1,14 @@
+import { DP } from '@duplojs/utils';
+import { createCheckerTransformer } from '../../create.mjs';
+import { factory } from 'typescript';
+
+const checkerRegexTransformer = createCheckerTransformer(DP.checkerRegexKind.has, (checker, { success, getDefinition, }) => {
+    const expression = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("DP"), factory.createIdentifier("checkerRegex")), undefined, [
+        factory.createRegularExpressionLiteral(`/${checker.definition.regex.source}/${checker.definition.regex.flags}`),
+        ...getDefinition(),
+    ]);
+    return success(expression);
+});
+DP.checkerRegex(/^/);
+
+export { checkerRegexTransformer };

package/dist/toDataParser/checkerTransformer/defaults/string/url.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../../create.cjs');
+var typescript = require('typescript');
+
+const checkerUrlTransformer = create.createCheckerTransformer(utils.DP.checkerUrlKind.has, (checker, { success, getDefinition, }) => {
+    const checkerDefinition = [];
+    if (checker.definition.hostname) {
+        checkerDefinition.push(typescript.factory.createPropertyAssignment(typescript.factory.createIdentifier("hostname"), typescript.factory.createRegularExpressionLiteral(`/${checker.definition.hostname.source}/${checker.definition.hostname.flags}`)));
+    }
+    if (checker.definition.normalize) {
+        checkerDefinition.push(typescript.factory.createPropertyAssignment(typescript.factory.createIdentifier("normalize"), typescript.factory.createTrue()));
+    }
+    if (checker.definition.protocol) {
+        checkerDefinition.push(typescript.factory.createPropertyAssignment(typescript.factory.createIdentifier("protocol"), typescript.factory.createRegularExpressionLiteral(`/${checker.definition.protocol.source}/${checker.definition.protocol.flags}`)));
+    }
+    const expression = typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(typescript.factory.createIdentifier("DP"), typescript.factory.createIdentifier("checkerUrl")), undefined, getDefinition(checkerDefinition));
+    return success(expression);
+});
+
+exports.checkerUrlTransformer = checkerUrlTransformer;

package/dist/toDataParser/checkerTransformer/defaults/string/url.d.ts

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

package/dist/toDataParser/checkerTransformer/defaults/string/url.mjs

@@ -0,0 +1,20 @@
+import { DP } from '@duplojs/utils';
+import { createCheckerTransformer } from '../../create.mjs';
+import { factory } from 'typescript';
+
+const checkerUrlTransformer = createCheckerTransformer(DP.checkerUrlKind.has, (checker, { success, getDefinition, }) => {
+    const checkerDefinition = [];
+    if (checker.definition.hostname) {
+        checkerDefinition.push(factory.createPropertyAssignment(factory.createIdentifier("hostname"), factory.createRegularExpressionLiteral(`/${checker.definition.hostname.source}/${checker.definition.hostname.flags}`)));
+    }
+    if (checker.definition.normalize) {
+        checkerDefinition.push(factory.createPropertyAssignment(factory.createIdentifier("normalize"), factory.createTrue()));
+    }
+    if (checker.definition.protocol) {
+        checkerDefinition.push(factory.createPropertyAssignment(factory.createIdentifier("protocol"), factory.createRegularExpressionLiteral(`/${checker.definition.protocol.source}/${checker.definition.protocol.flags}`)));
+    }
+    const expression = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("DP"), factory.createIdentifier("checkerUrl")), undefined, getDefinition(checkerDefinition));
+    return success(expression);
+});
+
+export { checkerUrlTransformer };

package/dist/toDataParser/checkerTransformer/defaults/string/uuid.cjs

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

package/dist/toDataParser/checkerTransformer/defaults/string/uuid.d.ts

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

package/dist/toDataParser/checkerTransformer/defaults/string/uuid.mjs

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

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

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

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

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

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

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

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

@@ -0,0 +1,19 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../../create.cjs');
+var typescript = require('typescript');
+
+const checkerTimeMaxTransformer = create.createCheckerTransformer(utils.DP.checkerTimeMaxKind.has, (checker, { success, getDefinition, addImport, }) => {
+    addImport("@duplojs/utils/date", "D", "namespace");
+    const expression = typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(typescript.factory.createIdentifier("DP"), typescript.factory.createIdentifier("checkerTimeMax")), undefined, [
+        typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(typescript.factory.createIdentifier("D"), typescript.factory.createIdentifier("createTime")), undefined, [
+            typescript.factory.createNumericLiteral(checker.definition.max.toNative()),
+            typescript.factory.createStringLiteral("millisecond"),
+        ]),
+        ...getDefinition(),
+    ]);
+    return success(expression);
+});
+
+exports.checkerTimeMaxTransformer = checkerTimeMaxTransformer;

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

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

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

@@ -0,0 +1,17 @@
+import { DP } from '@duplojs/utils';
+import { createCheckerTransformer } from '../../create.mjs';
+import { factory } from 'typescript';
+
+const checkerTimeMaxTransformer = createCheckerTransformer(DP.checkerTimeMaxKind.has, (checker, { success, getDefinition, addImport, }) => {
+    addImport("@duplojs/utils/date", "D", "namespace");
+    const expression = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("DP"), factory.createIdentifier("checkerTimeMax")), undefined, [
+        factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("D"), factory.createIdentifier("createTime")), undefined, [
+            factory.createNumericLiteral(checker.definition.max.toNative()),
+            factory.createStringLiteral("millisecond"),
+        ]),
+        ...getDefinition(),
+    ]);
+    return success(expression);
+});
+
+export { checkerTimeMaxTransformer };

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

@@ -0,0 +1,19 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../../create.cjs');
+var typescript = require('typescript');
+
+const checkerTimeMinTransformer = create.createCheckerTransformer(utils.DP.checkerTimeMinKind.has, (checker, { success, getDefinition, addImport, }) => {
+    addImport("@duplojs/utils/date", "D", "namespace");
+    const expression = typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(typescript.factory.createIdentifier("DP"), typescript.factory.createIdentifier("checkerTimeMin")), undefined, [
+        typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(typescript.factory.createIdentifier("D"), typescript.factory.createIdentifier("createTime")), undefined, [
+            typescript.factory.createNumericLiteral(checker.definition.min.toNative()),
+            typescript.factory.createStringLiteral("millisecond"),
+        ]),
+        ...getDefinition(),
+    ]);
+    return success(expression);
+});
+
+exports.checkerTimeMinTransformer = checkerTimeMinTransformer;

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

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

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

@@ -0,0 +1,17 @@
+import { DP } from '@duplojs/utils';
+import { createCheckerTransformer } from '../../create.mjs';
+import { factory } from 'typescript';
+
+const checkerTimeMinTransformer = createCheckerTransformer(DP.checkerTimeMinKind.has, (checker, { success, getDefinition, addImport, }) => {
+    addImport("@duplojs/utils/date", "D", "namespace");
+    const expression = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("DP"), factory.createIdentifier("checkerTimeMin")), undefined, [
+        factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("D"), factory.createIdentifier("createTime")), undefined, [
+            factory.createNumericLiteral(checker.definition.min.toNative()),
+            factory.createStringLiteral("millisecond"),
+        ]),
+        ...getDefinition(),
+    ]);
+    return success(expression);
+});
+
+export { checkerTimeMinTransformer };

package/dist/toDataParser/checkerTransformer/index.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var create = require('./create.cjs');
+var transformer = require('./transformer.cjs');
+var index = require('./defaults/index.cjs');
+
+
+
+exports.createCheckerTransformer = create.createCheckerTransformer;
+exports.checkerTransformer = transformer.checkerTransformer;
+exports.getCheckerDefinition = transformer.getCheckerDefinition;
+exports.defaultCheckerTransformers = index.defaultCheckerTransformers;

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

@@ -0,0 +1,3 @@
+export * from "./create";
+export * from "./transformer";
+export * from "./defaults";

package/dist/toDataParser/checkerTransformer/index.mjs

@@ -0,0 +1,3 @@
+export { createCheckerTransformer } from './create.mjs';
+export { checkerTransformer, getCheckerDefinition } from './transformer.mjs';
+export { defaultCheckerTransformers } from './defaults/index.mjs';

package/dist/toDataParser/checkerTransformer/transformer.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var typescript = require('typescript');
+require('../../toTypescript/index.cjs');
+var addImport = require('../../toTypescript/transformer/addImport.cjs');
+
+function getCheckerDefinition(checker, customProperties) {
+    const propertyAssignments = [];
+    if (checker.definition.errorMessage) {
+        propertyAssignments.push(typescript.factory.createPropertyAssignment(typescript.factory.createIdentifier("errorMessage"), typescript.factory.createStringLiteral(checker.definition.errorMessage)));
+    }
+    if (customProperties) {
+        propertyAssignments.push(...customProperties);
+    }
+    return utils.A.minElements(propertyAssignments, 1)
+        ? [typescript.factory.createObjectLiteralExpression(propertyAssignments)]
+        : [];
+}
+function checkerTransformer(checker, params) {
+    const functionParams = {
+        importContext: params.importContext,
+        success(result) {
+            return utils.E.right("buildSuccess", result);
+        },
+        buildError() {
+            return utils.E.left("buildCheckerError", checker);
+        },
+        addImport: addImport.createAddImport(params.importContext),
+        getDefinition(customProperties) {
+            return getCheckerDefinition(checker, customProperties);
+        },
+    };
+    return utils.A.reduce(params.transformers, utils.A.reduceFrom(utils.E.left("checkerNotSupport", checker)), ({ element: functionBuilder, lastValue, next, exit, }) => {
+        const result = functionBuilder(checker, functionParams);
+        if (utils.E.isLeft(result)) {
+            if (!utils.E.hasInformation(result, "checkerNotSupport")) {
+                return exit(result);
+            }
+            return next(lastValue);
+        }
+        return exit(result);
+    });
+}
+
+exports.checkerTransformer = checkerTransformer;
+exports.getCheckerDefinition = getCheckerDefinition;

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

@@ -0,0 +1,10 @@
+import { type DP } from "@duplojs/utils";
+import type { createCheckerTransformer, CheckerTransformerEither } from "./create";
+import { type PropertyAssignment } from "typescript";
+import * as TST from "../../toTypescript";
+export interface CheckerTransformerFunctionParams {
+    readonly transformers: readonly ReturnType<typeof createCheckerTransformer>[];
+    readonly importContext: TST.MapImportContext;
+}
+export declare function getCheckerDefinition(checker: DP.DataParserChecker, customProperties?: readonly PropertyAssignment[]): readonly [] | readonly [import("typescript").ObjectLiteralExpression];
+export declare function checkerTransformer(checker: DP.DataParserChecker, params: CheckerTransformerFunctionParams): CheckerTransformerEither;

package/dist/toDataParser/checkerTransformer/transformer.mjs

@@ -0,0 +1,44 @@
+import { A, E } from '@duplojs/utils';
+import { factory } from 'typescript';
+import '../../toTypescript/index.mjs';
+import { createAddImport } from '../../toTypescript/transformer/addImport.mjs';
+
+function getCheckerDefinition(checker, customProperties) {
+    const propertyAssignments = [];
+    if (checker.definition.errorMessage) {
+        propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("errorMessage"), factory.createStringLiteral(checker.definition.errorMessage)));
+    }
+    if (customProperties) {
+        propertyAssignments.push(...customProperties);
+    }
+    return A.minElements(propertyAssignments, 1)
+        ? [factory.createObjectLiteralExpression(propertyAssignments)]
+        : [];
+}
+function checkerTransformer(checker, params) {
+    const functionParams = {
+        importContext: params.importContext,
+        success(result) {
+            return E.right("buildSuccess", result);
+        },
+        buildError() {
+            return E.left("buildCheckerError", checker);
+        },
+        addImport: createAddImport(params.importContext),
+        getDefinition(customProperties) {
+            return getCheckerDefinition(checker, customProperties);
+        },
+    };
+    return A.reduce(params.transformers, A.reduceFrom(E.left("checkerNotSupport", checker)), ({ element: functionBuilder, lastValue, next, exit, }) => {
+        const result = functionBuilder(checker, functionParams);
+        if (E.isLeft(result)) {
+            if (!E.hasInformation(result, "checkerNotSupport")) {
+                return exit(result);
+            }
+            return next(lastValue);
+        }
+        return exit(result);
+    });
+}
+
+export { checkerTransformer, getCheckerDefinition };

package/dist/toDataParser/dataParserTransformer/create.cjs

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