typia 8.0.0 → 8.0.1

package/lib/programmers/CheckerProgrammer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CheckerProgrammer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/programmers/FeatureProgrammer.mjs

@@ -0,0 +1,231 @@
+import ts from 'typescript';
+import { IdentifierFactory } from '../factories/IdentifierFactory.mjs';
+import { StatementFactory } from '../factories/StatementFactory.mjs';
+import { TypeFactory } from '../factories/TypeFactory.mjs';
+import { ValueFactory } from '../factories/ValueFactory.mjs';
+import { UnionExplorer } from './helpers/UnionExplorer.mjs';
+import { feature_object_entries } from './internal/feature_object_entries.mjs';
+
+var FeatureProgrammer;
+(function (FeatureProgrammer) {
+    FeatureProgrammer.compose = (props) => {
+        const { collection, metadata } = props.config.initializer(props);
+        return {
+            body: props.config.decoder({
+                input: ValueFactory.INPUT(),
+                metadata,
+                explore: {
+                    tracable: props.config.path || props.config.trace,
+                    source: "top",
+                    from: "top",
+                    postfix: '""',
+                },
+            }),
+            statements: props.config.addition
+                ? props.config.addition(collection)
+                : [],
+            functions: {
+                ...Object.fromEntries((props.config.generator.objects?.(collection) ??
+                    FeatureProgrammer.write_object_functions({
+                        ...props,
+                        collection,
+                    })).map((v, i) => [`${props.config.prefix}o${i}`, v])),
+                ...Object.fromEntries((props.config.generator.unions?.(collection) ??
+                    FeatureProgrammer.write_union_functions({
+                        config: props.config,
+                        collection,
+                    })).map((v, i) => [`${props.config.prefix}u${i}`, v])),
+                ...Object.fromEntries(props.config.generator
+                    .arrays(collection)
+                    .map((v, i) => [`${props.config.prefix}a${i}`, v])),
+                ...Object.fromEntries(props.config.generator
+                    .tuples(collection)
+                    .map((v, i) => [`${props.config.prefix}t${i}`, v])),
+            },
+            parameters: FeatureProgrammer.parameterDeclarations({
+                config: props.config,
+                type: props.config.types.input(props.type, props.name),
+                input: ValueFactory.INPUT(),
+            }),
+            response: props.config.types.output(props.type, props.name),
+        };
+    };
+    FeatureProgrammer.writeDecomposed = (props) => ts.factory.createCallExpression(ts.factory.createArrowFunction(undefined, undefined, [], undefined, undefined, ts.factory.createBlock([
+        ...props.functor.declare(),
+        ...Object.entries(props.result.functions)
+            .filter(([k]) => props.functor.hasLocal(k))
+            .map(([_k, v]) => v),
+        ...props.result.statements,
+        ts.factory.createReturnStatement(props.result.arrow),
+    ])), undefined, undefined);
+    FeatureProgrammer.write = (props) => {
+        // ITERATE OVER ALL METADATA
+        const { collection, metadata } = props.config.initializer(props);
+        const output = props.config.decoder({
+            metadata,
+            input: ValueFactory.INPUT(),
+            explore: {
+                tracable: props.config.path || props.config.trace,
+                source: "top",
+                from: "top",
+                postfix: '""',
+            },
+        });
+        // RETURNS THE OPTIMAL ARROW FUNCTION
+        const functions = {
+            objects: props.config.generator.objects?.(collection) ??
+                FeatureProgrammer.write_object_functions({
+                    config: props.config,
+                    context: props.context,
+                    collection,
+                }),
+            unions: props.config.generator.unions?.(collection) ??
+                FeatureProgrammer.write_union_functions({
+                    config: props.config,
+                    collection,
+                }),
+            arrays: props.config.generator.arrays(collection),
+            tuples: props.config.generator.tuples(collection),
+        };
+        const added = (props.config.addition ?? (() => []))(collection);
+        return ts.factory.createArrowFunction(undefined, undefined, FeatureProgrammer.parameterDeclarations({
+            config: props.config,
+            type: props.config.types.input(props.type, props.name),
+            input: ValueFactory.INPUT(),
+        }), props.config.types.output(props.type, props.name), undefined, ts.factory.createBlock([
+            ...added,
+            ...functions.objects.filter((_, i) => props.functor.hasLocal(`${props.config.prefix}o${i}`)),
+            ...functions.unions.filter((_, i) => props.functor.hasLocal(`${props.config.prefix}u${i}`)),
+            ...functions.arrays.filter((_, i) => props.functor.hasLocal(`${props.config.prefix}a${i}`)),
+            ...functions.tuples.filter((_, i) => props.functor.hasLocal(`${props.config.prefix}t${i}`)),
+            ...(ts.isBlock(output)
+                ? output.statements
+                : [ts.factory.createReturnStatement(output)]),
+        ], true));
+    };
+    FeatureProgrammer.write_object_functions = (props) => props.collection.objects().map((object) => StatementFactory.constant({
+        name: `${props.config.prefix}o${object.index}`,
+        value: ts.factory.createArrowFunction(undefined, undefined, FeatureProgrammer.parameterDeclarations({
+            config: props.config,
+            type: TypeFactory.keyword("any"),
+            input: ValueFactory.INPUT(),
+        }), props.config.objector.type ?? TypeFactory.keyword("any"), undefined, props.config.objector.joiner({
+            input: ts.factory.createIdentifier("input"),
+            entries: feature_object_entries({
+                config: props.config,
+                context: props.context,
+                input: ts.factory.createIdentifier("input"),
+                object,
+            }),
+            object,
+        })),
+    }));
+    FeatureProgrammer.write_union_functions = (props) => props.collection.unions().map((union, i) => StatementFactory.constant({
+        name: `${props.config.prefix}u${i}`,
+        value: write_union({
+            config: props.config,
+            objects: union,
+        }),
+    }));
+    const write_union = (props) => ts.factory.createArrowFunction(undefined, undefined, FeatureProgrammer.parameterDeclarations({
+        config: props.config,
+        type: TypeFactory.keyword("any"),
+        input: ValueFactory.INPUT(),
+    }), TypeFactory.keyword("any"), undefined, UnionExplorer.object({
+        config: props.config,
+        objects: props.objects,
+        input: ValueFactory.INPUT(),
+        explore: {
+            tracable: props.config.path || props.config.trace,
+            source: "function",
+            from: "object",
+            postfix: "",
+        },
+    }));
+    /* -----------------------------------------------------------
+          DECODERS
+      ----------------------------------------------------------- */
+    FeatureProgrammer.decode_array = (props) => {
+        const rand = props.functor.increment().toString();
+        const tail = props.config.path || props.config.trace
+            ? [
+                IdentifierFactory.parameter("_index" + rand, TypeFactory.keyword("number")),
+            ]
+            : [];
+        const arrow = ts.factory.createArrowFunction(undefined, undefined, [
+            IdentifierFactory.parameter("elem", TypeFactory.keyword("any")),
+            ...tail,
+        ], undefined, undefined, props.config.decoder({
+            input: ValueFactory.INPUT("elem"),
+            metadata: props.array.type.value,
+            explore: {
+                tracable: props.explore.tracable,
+                source: props.explore.source,
+                from: "array",
+                postfix: FeatureProgrammer.index({
+                    start: props.explore.start ?? null,
+                    postfix: props.explore.postfix,
+                    rand,
+                }),
+            },
+        }));
+        return props.combiner({
+            input: props.input,
+            arrow,
+        });
+    };
+    FeatureProgrammer.decode_object = (props) => ts.factory.createCallExpression(ts.factory.createIdentifier(props.functor.useLocal(`${props.config.prefix}o${props.object.index}`)), undefined, FeatureProgrammer.argumentsArray(props));
+    /* -----------------------------------------------------------
+          UTILITIES FOR INTERNAL FUNCTIONS
+      ----------------------------------------------------------- */
+    FeatureProgrammer.index = (props) => {
+        const tail = props.start !== null
+            ? `"[" + (${props.start} + _index${props.rand}) + "]"`
+            : `"[" + _index${props.rand} + "]"`;
+        if (props.postfix === "")
+            return tail;
+        else if (props.postfix[props.postfix.length - 1] === `"`)
+            return (props.postfix.substring(0, props.postfix.length - 1) + tail.substring(1));
+        return props.postfix + ` + ${tail}`;
+    };
+    FeatureProgrammer.argumentsArray = (props) => {
+        const tail = props.config.path === false && props.config.trace === false
+            ? []
+            : props.config.path === true && props.config.trace === true
+                ? [
+                    ts.factory.createIdentifier(props.explore.postfix
+                        ? `_path + ${props.explore.postfix}`
+                        : "_path"),
+                    props.explore.source === "function"
+                        ? ts.factory.createIdentifier(`${props.explore.tracable} && _exceptionable`)
+                        : props.explore.tracable
+                            ? ts.factory.createTrue()
+                            : ts.factory.createFalse(),
+                ]
+                : props.config.path === true
+                    ? [
+                        ts.factory.createIdentifier(props.explore.postfix
+                            ? `_path + ${props.explore.postfix}`
+                            : "_path"),
+                    ]
+                    : [
+                        props.explore.source === "function"
+                            ? ts.factory.createIdentifier(`${props.explore.tracable} && _exceptionable`)
+                            : props.explore.tracable
+                                ? ts.factory.createTrue()
+                                : ts.factory.createFalse(),
+                    ];
+        return [props.input, ...tail];
+    };
+    FeatureProgrammer.parameterDeclarations = (props) => {
+        const tail = [];
+        if (props.config.path)
+            tail.push(IdentifierFactory.parameter("_path", TypeFactory.keyword("string")));
+        if (props.config.trace)
+            tail.push(IdentifierFactory.parameter("_exceptionable", TypeFactory.keyword("boolean"), ts.factory.createTrue()));
+        return [IdentifierFactory.parameter(props.input, props.type), ...tail];
+    };
+})(FeatureProgrammer || (FeatureProgrammer = {}));
+
+export { FeatureProgrammer };
+//# sourceMappingURL=FeatureProgrammer.mjs.map

package/lib/programmers/FeatureProgrammer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FeatureProgrammer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/programmers/ImportProgrammer.mjs

@@ -0,0 +1,95 @@
+import ts from 'typescript';
+import { MapUtil } from '../utils/MapUtil.mjs';
+
+class ImportProgrammer {
+    assets_ = new Map();
+    options_;
+    constructor(options) {
+        this.options_ = {
+            internalPrefix: options?.internalPrefix ?? "",
+        };
+    }
+    /* -----------------------------------------------------------
+      ENROLLMENTS
+    ----------------------------------------------------------- */
+    default(props) {
+        const asset = this.take(props.file);
+        asset.default ??= props;
+        asset.default.type ||= props.type;
+        return ts.factory.createIdentifier(asset.default.name);
+    }
+    instance(props) {
+        const alias = props.alias ?? props.name;
+        const asset = this.take(props.file);
+        MapUtil.take(asset.instances, alias, () => props);
+        return ts.factory.createIdentifier(alias);
+    }
+    namespace(props) {
+        const asset = this.take(props.file);
+        asset.namespace ??= props;
+        return ts.factory.createIdentifier(asset.namespace.name);
+    }
+    type(props) {
+        return ts.factory.createImportTypeNode(ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(props.file)), undefined, typeof props.name === "string"
+            ? ts.factory.createIdentifier(props.name)
+            : props.name, props.arguments);
+    }
+    /**
+     * @internal
+     */
+    internal(name) {
+        if (name.startsWith("_") === false)
+            name = `_${name}`;
+        return ts.factory.createPropertyAccessExpression(this.namespace({
+            file: `typia/lib/internal/${name}.js`,
+            name: this.alias(name),
+        }), name);
+    }
+    /**
+     * @internal
+     */
+    getInternalText(name) {
+        if (name.startsWith("_") === false)
+            name = `_${name}`;
+        const asset = this.take(`typia/lib/internal/${name}.js`);
+        if (!asset?.namespace)
+            throw new Error(`Internal asset not found: ${name}`);
+        return `${asset.namespace.name}.${name}`;
+    }
+    /**
+     * @internal
+     */
+    take(file) {
+        return MapUtil.take(this.assets_, file, () => ({
+            file,
+            default: null,
+            namespace: null,
+            instances: new Map(),
+        }));
+    }
+    alias(name) {
+        return `__${this.options_.internalPrefix}${name}`;
+    }
+    /* -----------------------------------------------------------
+      PROGRAM STATEMENTS
+    ----------------------------------------------------------- */
+    toStatements() {
+        const statements = [];
+        for (const asset of this.assets_.values()) {
+            if (asset.namespace !== null)
+                statements.push(ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamespaceImport(ts.factory.createIdentifier(asset.namespace.name))), ts.factory.createStringLiteral(asset.file)));
+            if (asset.default !== null)
+                statements.push(ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(asset.default.type, ts.factory.createIdentifier(asset.default.name), undefined), ts.factory.createStringLiteral(asset.file)));
+            if (asset.instances.size > 0)
+                statements.push(ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, asset.instances.size > 0
+                    ? ts.factory.createNamedImports([...asset.instances.values()].map((ins) => ts.factory.createImportSpecifier(false, ins.alias || ins.alias === ins.name
+                        ? ts.factory.createIdentifier(ins.name)
+                        : undefined, ts.factory.createIdentifier(ins.alias ?? ins.name))))
+                    : undefined), ts.factory.createStringLiteral(asset.file), undefined));
+        }
+        return statements;
+    }
+}
+
+export { ImportProgrammer };
+//# sourceMappingURL=ImportProgrammer.mjs.map

package/lib/programmers/ImportProgrammer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImportProgrammer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/programmers/IsProgrammer.mjs

@@ -0,0 +1,162 @@
+import ts from 'typescript';
+import { ExpressionFactory } from '../factories/ExpressionFactory.mjs';
+import { IdentifierFactory } from '../factories/IdentifierFactory.mjs';
+import { ValueFactory } from '../factories/ValueFactory.mjs';
+import { CheckerProgrammer } from './CheckerProgrammer.mjs';
+import { FeatureProgrammer } from './FeatureProgrammer.mjs';
+import { FunctionProgrammer } from './helpers/FunctionProgrammer.mjs';
+import { OptionPredicator } from './helpers/OptionPredicator.mjs';
+import { check_object } from './internal/check_object.mjs';
+
+var IsProgrammer;
+(function (IsProgrammer) {
+    IsProgrammer.configure = (props) => ({
+        prefix: "_i",
+        equals: !!props.options?.object,
+        trace: false,
+        path: false,
+        numeric: OptionPredicator.numeric({
+            numeric: props.options?.numeric,
+        }),
+        atomist: ({ entry }) => [
+            ...(entry.expression ? [entry.expression] : []),
+            ...(entry.conditions.length === 0
+                ? []
+                : [
+                    entry.conditions
+                        .map((set) => set
+                        .map((s) => s.expression)
+                        .reduce((a, b) => ts.factory.createLogicalAnd(a, b)))
+                        .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
+                ]),
+        ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
+        combiner: (next) => {
+            const initial = next.logic === "and"
+                ? ts.factory.createTrue()
+                : ts.factory.createFalse();
+            const binder = next.logic === "and"
+                ? ts.factory.createLogicalAnd
+                : ts.factory.createLogicalOr;
+            return next.binaries.length
+                ? next.binaries.map((binary) => binary.expression).reduce(binder)
+                : initial;
+        },
+        joiner: {
+            object: props.options?.object
+                ? (v) => props.options.object(v)
+                : (v) => check_object({
+                    config: {
+                        equals: !!props.options?.object,
+                        undefined: OptionPredicator.undefined({
+                            undefined: props.options?.undefined,
+                        }),
+                        assert: true,
+                        reduce: ts.factory.createLogicalAnd,
+                        positive: ts.factory.createTrue(),
+                        superfluous: () => ts.factory.createFalse(),
+                    },
+                    context: props.context,
+                    entries: v.entries,
+                    input: v.input,
+                }),
+            array: (props) => ts.factory.createCallExpression(IdentifierFactory.access(props.input, "every"), undefined, [props.arrow]),
+            failure: () => ts.factory.createFalse(),
+        },
+        success: ts.factory.createTrue(),
+    });
+    IsProgrammer.decompose = (props) => {
+        // CONFIGURATION
+        const config = {
+            ...IsProgrammer.configure({
+                options: {
+                    object: (v) => check_object({
+                        config: {
+                            equals: props.config.equals,
+                            undefined: OptionPredicator.undefined(props.context.options),
+                            assert: true,
+                            reduce: ts.factory.createLogicalAnd,
+                            positive: ts.factory.createTrue(),
+                            superfluous: () => ts.factory.createFalse(),
+                        },
+                        context: props.context,
+                        entries: v.entries,
+                        input: v.input,
+                    }),
+                    numeric: OptionPredicator.numeric(props.context.options),
+                },
+                context: props.context,
+                functor: props.functor,
+            }),
+            trace: props.config.equals,
+        };
+        // COMPOSITION
+        const composed = CheckerProgrammer.compose({
+            ...props,
+            config,
+        });
+        return {
+            functions: composed.functions,
+            statements: composed.statements,
+            arrow: ts.factory.createArrowFunction(undefined, undefined, composed.parameters, composed.response, undefined, composed.body),
+        };
+    };
+    IsProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer(props.modulo.getText());
+        const result = IsProgrammer.decompose({
+            config: props.config,
+            context: props.context,
+            functor,
+            type: props.type,
+            name: props.name,
+        });
+        return FeatureProgrammer.writeDecomposed({
+            modulo: props.modulo,
+            functor,
+            result,
+        });
+    };
+    IsProgrammer.write_function_statements = (props) => {
+        const config = IsProgrammer.configure(props);
+        const next = {
+            ...props,
+            config,
+        };
+        const objects = CheckerProgrammer.write_object_functions(next);
+        const unions = CheckerProgrammer.write_union_functions(next);
+        const arrays = CheckerProgrammer.write_array_functions(next);
+        const tuples = CheckerProgrammer.write_tuple_functions(next);
+        return [
+            ...objects.filter((_, i) => props.functor.hasLocal(`${config.prefix}o${i}`)),
+            ...unions.filter((_, i) => props.functor.hasLocal(`${config.prefix}u${i}`)),
+            ...arrays.filter((_, i) => props.functor.hasLocal(`${config.prefix}a${i}`)),
+            ...tuples.filter((_, i) => props.functor.hasLocal(`${config.prefix}t${i}`)),
+        ];
+    };
+    /* -----------------------------------------------------------
+      DECODERS
+    ----------------------------------------------------------- */
+    IsProgrammer.decode = (props) => CheckerProgrammer.decode({
+        context: props.context,
+        config: IsProgrammer.configure(props),
+        functor: props.functor,
+        metadata: props.metadata,
+        input: props.input,
+        explore: props.explore,
+    });
+    IsProgrammer.decode_object = (props) => CheckerProgrammer.decode_object({
+        config: IsProgrammer.configure(props),
+        functor: props.functor,
+        object: props.object,
+        input: props.input,
+        explore: props.explore,
+    });
+    IsProgrammer.decode_to_json = (props) => ts.factory.createLogicalAnd(ExpressionFactory.isObject({
+        checkArray: false,
+        checkNull: props.checkNull,
+        input: props.input,
+    }), ts.factory.createStrictEquality(ts.factory.createStringLiteral("function"), ValueFactory.TYPEOF(IdentifierFactory.access(props.input, "toJSON"))));
+    IsProgrammer.decode_functional = (input) => ts.factory.createStrictEquality(ts.factory.createStringLiteral("function"), ValueFactory.TYPEOF(input));
+})(IsProgrammer || (IsProgrammer = {}));
+
+export { IsProgrammer };
+//# sourceMappingURL=IsProgrammer.mjs.map

package/lib/programmers/IsProgrammer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsProgrammer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}