@duplojs/data-parser-tools 0.2.9 → 0.4.0

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

@@ -0,0 +1,38 @@
+import { DP, E, pipe, unwrap } from '@duplojs/utils';
+import { createTransformer } from '../create.mjs';
+import { createSourceFile, ScriptTarget, isExpressionStatement, isParenthesizedExpression, isFunctionExpression, isArrowFunction, factory } from 'typescript';
+
+const transformTransformer = createTransformer(DP.transformKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, transformer, buildError, }) => {
+    const inner = transformer(dataParser.definition.inner);
+    if (E.isLeft(inner)) {
+        return inner;
+    }
+    const theFunction = dataParser.definition.theFunction.toString();
+    if (theFunction.includes("[native code]")) {
+        return buildError();
+    }
+    const sourceFile = createSourceFile("refine-function.ts", `(${theFunction})`, 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 definition = getDefinition();
+    if (E.isLeft(definition)) {
+        return definition;
+    }
+    return pipe(factory.createCallExpression(factory.createPropertyAccessExpression(dependencyIdentifier, factory.createIdentifier("transform")), undefined, [
+        unwrap(inner),
+        functionExpression,
+        ...definition,
+    ]), success);
+});
+
+export { transformTransformer };

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

@@ -0,0 +1,36 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../create.cjs');
+var typescript = require('typescript');
+
+const tupleTransformer = create.createTransformer(utils.DP.tupleKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, transformer, }) => {
+    const shape = utils.A.reduce(dataParser.definition.shape, utils.A.reduceFrom([]), ({ element, lastValue, nextPush, exit }) => {
+        const result = transformer(element);
+        if (utils.E.isLeft(result)) {
+            return exit(result);
+        }
+        return nextPush(lastValue, utils.unwrap(result));
+    });
+    if (utils.E.isLeft(shape)) {
+        return shape;
+    }
+    const rest = dataParser.definition.rest
+        ? utils.pipe(dataParser.definition.rest, transformer, utils.E.whenIsRight((expression) => [
+            typescript.factory.createPropertyAssignment(typescript.factory.createIdentifier("rest"), expression),
+        ]))
+        : undefined;
+    if (utils.E.isLeft(rest)) {
+        return rest;
+    }
+    const definition = getDefinition(rest);
+    if (utils.E.isLeft(definition)) {
+        return definition;
+    }
+    return utils.pipe(typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(dependencyIdentifier, typescript.factory.createIdentifier("tuple")), undefined, [
+        typescript.factory.createArrayLiteralExpression(shape, utils.A.minElements(shape, 3)),
+        ...definition,
+    ]), success);
+});
+
+exports.tupleTransformer = tupleTransformer;

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

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

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

@@ -0,0 +1,34 @@
+import { DP, A, E, unwrap, pipe } from '@duplojs/utils';
+import { createTransformer } from '../create.mjs';
+import { factory } from 'typescript';
+
+const tupleTransformer = createTransformer(DP.tupleKind.has, (dataParser, { success, dependencyIdentifier, getDefinition, transformer, }) => {
+    const shape = A.reduce(dataParser.definition.shape, A.reduceFrom([]), ({ element, lastValue, nextPush, exit }) => {
+        const result = transformer(element);
+        if (E.isLeft(result)) {
+            return exit(result);
+        }
+        return nextPush(lastValue, unwrap(result));
+    });
+    if (E.isLeft(shape)) {
+        return shape;
+    }
+    const rest = dataParser.definition.rest
+        ? pipe(dataParser.definition.rest, transformer, E.whenIsRight((expression) => [
+            factory.createPropertyAssignment(factory.createIdentifier("rest"), expression),
+        ]))
+        : undefined;
+    if (E.isLeft(rest)) {
+        return rest;
+    }
+    const definition = getDefinition(rest);
+    if (E.isLeft(definition)) {
+        return definition;
+    }
+    return pipe(factory.createCallExpression(factory.createPropertyAccessExpression(dependencyIdentifier, factory.createIdentifier("tuple")), undefined, [
+        factory.createArrayLiteralExpression(shape, A.minElements(shape, 3)),
+        ...definition,
+    ]), success);
+});
+
+export { tupleTransformer };

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

@@ -0,0 +1,28 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var create = require('../create.cjs');
+var typescript = require('typescript');
+
+const unionTransformer = create.createTransformer(utils.DP.unionKind.has, (dataParser, { dependencyIdentifier, getDefinition, success, transformer, }) => {
+    const options = utils.A.reduce(dataParser.definition.options, utils.A.reduceFrom([]), ({ element, lastValue, nextPush, exit }) => {
+        const result = transformer(element);
+        if (utils.E.isLeft(result)) {
+            return exit(result);
+        }
+        return nextPush(lastValue, utils.unwrap(result));
+    });
+    if (utils.E.isLeft(options)) {
+        return options;
+    }
+    const definition = getDefinition();
+    if (utils.E.isLeft(definition)) {
+        return definition;
+    }
+    return utils.pipe(typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(dependencyIdentifier, typescript.factory.createIdentifier("union")), undefined, [
+        typescript.factory.createArrayLiteralExpression(options, true),
+        ...definition,
+    ]), success);
+});
+
+exports.unionTransformer = unionTransformer;

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

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

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

@@ -0,0 +1,26 @@
+import { DP, A, E, unwrap, pipe } from '@duplojs/utils';
+import { createTransformer } from '../create.mjs';
+import { factory } from 'typescript';
+
+const unionTransformer = createTransformer(DP.unionKind.has, (dataParser, { dependencyIdentifier, getDefinition, success, transformer, }) => {
+    const options = A.reduce(dataParser.definition.options, A.reduceFrom([]), ({ element, lastValue, nextPush, exit }) => {
+        const result = transformer(element);
+        if (E.isLeft(result)) {
+            return exit(result);
+        }
+        return nextPush(lastValue, unwrap(result));
+    });
+    if (E.isLeft(options)) {
+        return options;
+    }
+    const definition = getDefinition();
+    if (E.isLeft(definition)) {
+        return definition;
+    }
+    return pipe(factory.createCallExpression(factory.createPropertyAccessExpression(dependencyIdentifier, factory.createIdentifier("union")), undefined, [
+        factory.createArrayLiteralExpression(options, true),
+        ...definition,
+    ]), success);
+});
+
+export { unionTransformer };

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

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

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

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

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

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

package/dist/toDataParser/dataParserTransformer/getDefinitionDataParser.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+require('../checkerTransformer/index.cjs');
+var typescript = require('typescript');
+var transformer = require('../checkerTransformer/transformer.cjs');
+
+function getDefinitionDataParser(params) {
+    const propertyAssignments = [];
+    if (params.dataParser.definition.errorMessage) {
+        propertyAssignments.push(typescript.factory.createPropertyAssignment(typescript.factory.createIdentifier("errorMessage"), typescript.factory.createStringLiteral(params.dataParser.definition.errorMessage)));
+    }
+    if (utils.A.minElements(params.customProperties, 1)) {
+        propertyAssignments.push(...params.customProperties);
+    }
+    if (utils.A.minElements(params.dataParser.definition.checkers, 1)) {
+        const checkers = utils.A.reduce(params.dataParser.definition.checkers, utils.A.reduceFrom([]), ({ element, lastValue, nextPush, exit }) => utils.pipe(transformer.checkerTransformer(element, {
+            transformers: params.checkerTransformers,
+            importContext: params.importContext,
+        }), utils.E.whenIsRight((value) => nextPush(lastValue, value)), utils.when(utils.E.isLeft, exit)));
+        if (utils.E.isLeft(checkers)) {
+            return utils.E.left("buildDataParserGetDefinitionError", {
+                dataParser: params.dataParser,
+                error: checkers,
+            });
+        }
+        propertyAssignments.push(typescript.factory.createPropertyAssignment(typescript.factory.createIdentifier("checkers"), typescript.factory.createArrayLiteralExpression(checkers, utils.A.minElements(checkers, 2))));
+    }
+    return utils.A.minElements(propertyAssignments, 1)
+        ? [
+            typescript.factory.createObjectLiteralExpression(propertyAssignments, utils.A.minElements(propertyAssignments, 2)),
+        ]
+        : [];
+}
+
+exports.getDefinitionDataParser = getDefinitionDataParser;

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

@@ -0,0 +1,14 @@
+import { type DP, E } from "@duplojs/utils";
+import { type createCheckerTransformer } from "../checkerTransformer";
+import { type PropertyAssignment } from "typescript";
+import type * as TST from "../../toTypescript";
+export interface getDefinitionDataParserParams {
+    readonly dataParser: DP.DataParser;
+    readonly checkerTransformers: readonly ReturnType<typeof createCheckerTransformer>[];
+    readonly importContext: TST.MapImportContext;
+    readonly customProperties: readonly PropertyAssignment[];
+}
+export declare function getDefinitionDataParser(params: getDefinitionDataParserParams): readonly [] | readonly [import("typescript").ObjectLiteralExpression] | E.Left<"buildDataParserGetDefinitionError", {
+    readonly dataParser: DP.DataParser<unknown, unknown>;
+    readonly error: import("..").CheckerTransformerCheckerNotSupportedEither | import("..").CheckerTransformerBuildErrorEither;
+}>;

package/dist/toDataParser/dataParserTransformer/getDefinitionDataParser.mjs

@@ -0,0 +1,34 @@
+import { A, pipe, E, when } from '@duplojs/utils';
+import '../checkerTransformer/index.mjs';
+import { factory } from 'typescript';
+import { checkerTransformer } from '../checkerTransformer/transformer.mjs';
+
+function getDefinitionDataParser(params) {
+    const propertyAssignments = [];
+    if (params.dataParser.definition.errorMessage) {
+        propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("errorMessage"), factory.createStringLiteral(params.dataParser.definition.errorMessage)));
+    }
+    if (A.minElements(params.customProperties, 1)) {
+        propertyAssignments.push(...params.customProperties);
+    }
+    if (A.minElements(params.dataParser.definition.checkers, 1)) {
+        const checkers = A.reduce(params.dataParser.definition.checkers, A.reduceFrom([]), ({ element, lastValue, nextPush, exit }) => pipe(checkerTransformer(element, {
+            transformers: params.checkerTransformers,
+            importContext: params.importContext,
+        }), E.whenIsRight((value) => nextPush(lastValue, value)), when(E.isLeft, exit)));
+        if (E.isLeft(checkers)) {
+            return E.left("buildDataParserGetDefinitionError", {
+                dataParser: params.dataParser,
+                error: checkers,
+            });
+        }
+        propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("checkers"), factory.createArrayLiteralExpression(checkers, A.minElements(checkers, 2))));
+    }
+    return A.minElements(propertyAssignments, 1)
+        ? [
+            factory.createObjectLiteralExpression(propertyAssignments, A.minElements(propertyAssignments, 2)),
+        ]
+        : [];
+}
+
+export { getDefinitionDataParser };

package/dist/toDataParser/dataParserTransformer/hook.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

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

@@ -0,0 +1,15 @@
+import type { DP } from "@duplojs/utils";
+import type * as TST from "../../toTypescript";
+import type { MapContext } from "./create";
+export type TransformerHookAction = "stop" | "next";
+export interface TransformerHookOutput {
+    dataParser: DP.DataParsers;
+    action: TransformerHookAction;
+}
+export interface TransformerHookParams {
+    dataParser: DP.DataParsers;
+    context: MapContext;
+    importContext: TST.MapImportContext;
+    output(action: TransformerHookAction, dataParser: DP.DataParsers): TransformerHookOutput;
+}
+export type TransformerHook = (params: TransformerHookParams) => TransformerHookOutput;

package/dist/toDataParser/dataParserTransformer/hook.mjs

@@ -0,0 +1 @@
+

package/dist/toDataParser/dataParserTransformer/index.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var create = require('./create.cjs');
+var transformer = require('./transformer.cjs');
+require('./hook.cjs');
+var index = require('./defaults/index.cjs');
+var getDefinitionDataParser = require('./getDefinitionDataParser.cjs');
+var createIdentifier = require('./createIdentifier.cjs');
+
+
+
+exports.createTransformer = create.createTransformer;
+exports.transformer = transformer.transformer;
+exports.defaultTransformers = index.defaultTransformers;
+exports.getDefinitionDataParser = getDefinitionDataParser.getDefinitionDataParser;
+exports.createIdentifier = createIdentifier.createIdentifier;

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

@@ -0,0 +1,6 @@
+export * from "./create";
+export * from "./transformer";
+export * from "./hook";
+export * from "./defaults";
+export * from "./getDefinitionDataParser";
+export * from "./createIdentifier";

package/dist/toDataParser/dataParserTransformer/index.mjs

@@ -0,0 +1,6 @@
+export { createTransformer } from './create.mjs';
+export { transformer } from './transformer.mjs';
+import './hook.mjs';
+export { defaultTransformers } from './defaults/index.mjs';
+export { getDefinitionDataParser } from './getDefinitionDataParser.mjs';
+export { createIdentifier } from './createIdentifier.mjs';

package/dist/toDataParser/dataParserTransformer/transformer.cjs

@@ -0,0 +1,129 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+require('../../toTypescript/index.cjs');
+var typescript = require('typescript');
+var getDefinitionDataParser = require('./getDefinitionDataParser.cjs');
+var createIdentifier = require('./createIdentifier.cjs');
+var addImport = require('../../toTypescript/transformer/addImport.cjs');
+var buildContext = require('../../toTypescript/buildContext.cjs');
+
+function transformer(dataParser, params) {
+    const currentDataParser = utils.A.reduce(params.hooks, utils.A.reduceFrom(dataParser), ({ element: hook, lastValue, next, exit }) => {
+        const result = hook({
+            dataParser: lastValue,
+            context: params.context,
+            importContext: params.importContext,
+            output: (action, dataParser) => ({
+                dataParser,
+                action,
+            }),
+        });
+        if (result.action === "stop") {
+            return exit(result.dataParser);
+        }
+        else {
+            return next(result.dataParser);
+        }
+    });
+    if (currentDataParser.definition.identifier) {
+        params.dependenciesContext.add(currentDataParser);
+    }
+    const identifiedDataParser = params.context.get(currentDataParser);
+    if (identifiedDataParser) {
+        return utils.E.right("buildSuccess", identifiedDataParser.identifier);
+    }
+    const newIdentifiedDataParser = utils.justExec(() => {
+        const currentIdentifier = utils.A.includes(params.recursiveDataParsers, currentDataParser)
+            || !!currentDataParser.definition.identifier
+            ? typescript.factory.createIdentifier(currentDataParser.definition.identifier !== undefined
+                ? createIdentifier.createIdentifier(currentDataParser.definition.identifier)
+                : `recursive${params.context.size}DataParser`)
+            : undefined;
+        if (!currentIdentifier) {
+            return null;
+        }
+        const contextValue = {
+            identifier: currentIdentifier,
+            expression: typescript.factory.createIdentifier("undefined"),
+            typeIdentifier: null,
+            dependencies: new Set(),
+        };
+        params.context.set(currentDataParser, contextValue);
+        return contextValue;
+    });
+    const functionParams = {
+        success(result) {
+            return utils.E.right("buildSuccess", result);
+        },
+        transformer(dataParser) {
+            return transformer(dataParser, {
+                ...params,
+                dependenciesContext: newIdentifiedDataParser?.dependencies
+                    ?? params.dependenciesContext,
+            });
+        },
+        context: params.context,
+        dependencyIdentifier: params.dependencyIdentifier,
+        buildError() {
+            return utils.E.left("buildDataParserError", currentDataParser);
+        },
+        importContext: params.importContext,
+        getDefinition(customProperties = []) {
+            return getDefinitionDataParser.getDefinitionDataParser({
+                dataParser: currentDataParser,
+                checkerTransformers: params.checkerTransformers,
+                importContext: params.importContext,
+                customProperties,
+            });
+        },
+        addImport: addImport.createAddImport(params.importContext),
+    };
+    const result = currentDataParser.definition.overrideDataParserTransformer
+        ? currentDataParser.definition.overrideDataParserTransformer(currentDataParser.addOverrideDataParserTransformer(null), functionParams)
+        : utils.A.reduce(params.dataParserTransformers, utils.A.reduceFrom(utils.E.left("dataParserNotSupport", currentDataParser)), ({ element: functionBuilder, lastValue, next, exit, }) => {
+            const result = functionBuilder(currentDataParser, functionParams);
+            if (utils.E.isLeft(result)) {
+                if (!utils.E.hasInformation(result, "dataParserNotSupport")) {
+                    return exit(result);
+                }
+                return next(lastValue);
+            }
+            return exit(result);
+        });
+    if (utils.E.isLeft(result)) {
+        return result;
+    }
+    if (newIdentifiedDataParser) {
+        const typeIdentifier = utils.justExec(() => {
+            if (!utils.A.includes(params.recursiveDataParsers, currentDataParser)) {
+                return null;
+            }
+            const identifier = `$${newIdentifiedDataParser.identifier.text}`;
+            const result = buildContext.buildContext(currentDataParser, {
+                identifier,
+                transformers: params.typescriptTransformers,
+                context: params.typescriptContext,
+                importContext: params.importContext,
+                ...params.toTypescript,
+            });
+            return utils.E.matchInformationOtherwise(result, {
+                buildDataParserError: (dataParser) => utils.E.left("toTypescriptBuildDataParserError", dataParser),
+                dataParserNotSupport: (dataParser) => utils.E.left("toTypescriptDataParserNotSupport", dataParser),
+            }, () => typescript.factory.createIdentifier(identifier));
+        });
+        if (utils.E.isLeft(typeIdentifier)) {
+            return typeIdentifier;
+        }
+        params.context.delete(currentDataParser);
+        params.context.set(currentDataParser, {
+            ...newIdentifiedDataParser,
+            expression: utils.unwrap(result),
+            typeIdentifier: typeIdentifier,
+        });
+        return utils.E.right("buildSuccess", newIdentifiedDataParser.identifier);
+    }
+    return utils.E.right("buildSuccess", utils.unwrap(result));
+}
+
+exports.transformer = transformer;

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

@@ -0,0 +1,23 @@
+import { E, type DP } from "@duplojs/utils";
+import * as TST from "../../toTypescript";
+import type { MapContext, createTransformer, DependenciesContext } from "./create";
+import { type Identifier } from "typescript";
+import type { TransformerHook } from "./hook";
+import type { createCheckerTransformer } from "../checkerTransformer";
+export interface TransformerFunctionParams {
+    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 dependenciesContext: DependenciesContext;
+    readonly dependencyIdentifier: Identifier;
+    readonly hooks: readonly TransformerHook[];
+    readonly recursiveDataParsers: DP.DataParser[];
+    readonly toTypescript?: {
+        readonly mode?: TST.TransformerMode;
+        readonly hooks?: readonly TST.TransformerHook[];
+    };
+}
+export declare function transformer(dataParser: DP.DataParser, params: TransformerFunctionParams): import("./create").DataParserNotSupportedEither | import("./create").DataParserErrorEither | import("./create").DataParserGetDefinitionErrorEither | import("./create").ToTypescriptDataParserNotSupportedEither | import("./create").ToTypescriptDataParserErrorEither | E.Right<"buildSuccess", import("typescript").CallExpression | Identifier>;

package/dist/toDataParser/dataParserTransformer/transformer.mjs

@@ -0,0 +1,127 @@
+import { A, E, justExec, unwrap } from '@duplojs/utils';
+import '../../toTypescript/index.mjs';
+import { factory } from 'typescript';
+import { getDefinitionDataParser } from './getDefinitionDataParser.mjs';
+import { createIdentifier } from './createIdentifier.mjs';
+import { createAddImport } from '../../toTypescript/transformer/addImport.mjs';
+import { buildContext } from '../../toTypescript/buildContext.mjs';
+
+function transformer(dataParser, params) {
+    const currentDataParser = A.reduce(params.hooks, A.reduceFrom(dataParser), ({ element: hook, lastValue, next, exit }) => {
+        const result = hook({
+            dataParser: lastValue,
+            context: params.context,
+            importContext: params.importContext,
+            output: (action, dataParser) => ({
+                dataParser,
+                action,
+            }),
+        });
+        if (result.action === "stop") {
+            return exit(result.dataParser);
+        }
+        else {
+            return next(result.dataParser);
+        }
+    });
+    if (currentDataParser.definition.identifier) {
+        params.dependenciesContext.add(currentDataParser);
+    }
+    const identifiedDataParser = params.context.get(currentDataParser);
+    if (identifiedDataParser) {
+        return E.right("buildSuccess", identifiedDataParser.identifier);
+    }
+    const newIdentifiedDataParser = justExec(() => {
+        const currentIdentifier = A.includes(params.recursiveDataParsers, currentDataParser)
+            || !!currentDataParser.definition.identifier
+            ? factory.createIdentifier(currentDataParser.definition.identifier !== undefined
+                ? createIdentifier(currentDataParser.definition.identifier)
+                : `recursive${params.context.size}DataParser`)
+            : undefined;
+        if (!currentIdentifier) {
+            return null;
+        }
+        const contextValue = {
+            identifier: currentIdentifier,
+            expression: factory.createIdentifier("undefined"),
+            typeIdentifier: null,
+            dependencies: new Set(),
+        };
+        params.context.set(currentDataParser, contextValue);
+        return contextValue;
+    });
+    const functionParams = {
+        success(result) {
+            return E.right("buildSuccess", result);
+        },
+        transformer(dataParser) {
+            return transformer(dataParser, {
+                ...params,
+                dependenciesContext: newIdentifiedDataParser?.dependencies
+                    ?? params.dependenciesContext,
+            });
+        },
+        context: params.context,
+        dependencyIdentifier: params.dependencyIdentifier,
+        buildError() {
+            return E.left("buildDataParserError", currentDataParser);
+        },
+        importContext: params.importContext,
+        getDefinition(customProperties = []) {
+            return getDefinitionDataParser({
+                dataParser: currentDataParser,
+                checkerTransformers: params.checkerTransformers,
+                importContext: params.importContext,
+                customProperties,
+            });
+        },
+        addImport: createAddImport(params.importContext),
+    };
+    const result = currentDataParser.definition.overrideDataParserTransformer
+        ? currentDataParser.definition.overrideDataParserTransformer(currentDataParser.addOverrideDataParserTransformer(null), functionParams)
+        : A.reduce(params.dataParserTransformers, A.reduceFrom(E.left("dataParserNotSupport", currentDataParser)), ({ element: functionBuilder, lastValue, next, exit, }) => {
+            const result = functionBuilder(currentDataParser, functionParams);
+            if (E.isLeft(result)) {
+                if (!E.hasInformation(result, "dataParserNotSupport")) {
+                    return exit(result);
+                }
+                return next(lastValue);
+            }
+            return exit(result);
+        });
+    if (E.isLeft(result)) {
+        return result;
+    }
+    if (newIdentifiedDataParser) {
+        const typeIdentifier = justExec(() => {
+            if (!A.includes(params.recursiveDataParsers, currentDataParser)) {
+                return null;
+            }
+            const identifier = `$${newIdentifiedDataParser.identifier.text}`;
+            const result = buildContext(currentDataParser, {
+                identifier,
+                transformers: params.typescriptTransformers,
+                context: params.typescriptContext,
+                importContext: params.importContext,
+                ...params.toTypescript,
+            });
+            return E.matchInformationOtherwise(result, {
+                buildDataParserError: (dataParser) => E.left("toTypescriptBuildDataParserError", dataParser),
+                dataParserNotSupport: (dataParser) => E.left("toTypescriptDataParserNotSupport", dataParser),
+            }, () => factory.createIdentifier(identifier));
+        });
+        if (E.isLeft(typeIdentifier)) {
+            return typeIdentifier;
+        }
+        params.context.delete(currentDataParser);
+        params.context.set(currentDataParser, {
+            ...newIdentifiedDataParser,
+            expression: unwrap(result),
+            typeIdentifier: typeIdentifier,
+        });
+        return E.right("buildSuccess", newIdentifiedDataParser.identifier);
+    }
+    return E.right("buildSuccess", unwrap(result));
+}
+
+export { transformer };