typia 8.0.0 → 8.0.1

package/lib/factories/ExpressionFactory.mjs

@@ -0,0 +1,101 @@
+import ts from 'typescript';
+import { _randomFormatUuid } from '../internal/_randomFormatUuid.mjs';
+
+var ExpressionFactory;
+(function (ExpressionFactory) {
+    ExpressionFactory.number = (value) => value < 0
+        ? ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, ts.factory.createNumericLiteral(Math.abs(value)))
+        : ts.factory.createNumericLiteral(value);
+    ExpressionFactory.bigint = (value) => ts.factory.createCallExpression(ts.factory.createIdentifier("BigInt"), undefined, [ts.factory.createIdentifier(value.toString())]);
+    ExpressionFactory.isRequired = (input) => ts.factory.createStrictInequality(ts.factory.createIdentifier("undefined"), input);
+    ExpressionFactory.isArray = (input) => ts.factory.createCallExpression(ts.factory.createIdentifier("Array.isArray"), undefined, [input]);
+    ExpressionFactory.isObject = (props) => {
+        const conditions = [
+            ts.factory.createStrictEquality(ts.factory.createStringLiteral("object"), ts.factory.createTypeOfExpression(props.input)),
+        ];
+        if (props.checkNull === true)
+            conditions.push(ts.factory.createStrictInequality(ts.factory.createNull(), props.input));
+        if (props.checkArray === true)
+            conditions.push(ts.factory.createStrictEquality(ts.factory.createFalse(), ts.factory.createCallExpression(ts.factory.createIdentifier("Array.isArray"), undefined, [props.input])));
+        return conditions.length === 1
+            ? conditions[0]
+            : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+    };
+    ExpressionFactory.isInstanceOf = (type, input) => {
+        return ts.factory.createBinaryExpression(input, ts.factory.createToken(ts.SyntaxKind.InstanceOfKeyword), ts.factory.createIdentifier(type));
+    };
+    ExpressionFactory.coalesce = (x, y) => ts.factory.createBinaryExpression(x, ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken), y);
+    ExpressionFactory.currying = (props) => {
+        if (props.arguments.length === 0)
+            return ts.factory.createCallExpression(props.function, undefined, undefined);
+        let prev = ts.factory.createCallExpression(props.function, undefined, [props.arguments[0]]);
+        for (const param of props.arguments.slice(1))
+            prev = ts.factory.createCallExpression(prev, undefined, [param]);
+        return prev;
+    };
+    ExpressionFactory.selfCall = (body) => ts.isCallExpression(body)
+        ? body
+        : ts.factory.createCallExpression(ts.factory.createParenthesizedExpression(ts.factory.createArrowFunction(undefined, undefined, [], undefined, undefined, body)), undefined, undefined);
+    ExpressionFactory.getEscapedText = (props) => props.printer.printNode(ts.EmitHint.Expression, props.input, props.input.getSourceFile());
+    ExpressionFactory.transpile = (props) => {
+        const file = ts.createSourceFile(`${_randomFormatUuid()}.ts`, props.script, ts.ScriptTarget.ESNext, true, ts.ScriptKind.TS);
+        const statement = file.statements[0];
+        if (statement === undefined)
+            throw new ReferenceError("Error on ExpressionFactory.transpile(): no statement exists.");
+        else if (!ts.isExpressionStatement(statement))
+            throw new TypeError("Error on ExpressionFactory.transpile(): statement is not an expression statement.");
+        return (input) => {
+            const visitor = (node) => {
+                if (ts.isIdentifier(node) && node.text === "$input")
+                    return input;
+                else if (props.importer !== undefined && ts.isCallExpression(node))
+                    if (node.expression.getText() === "$importInternal" &&
+                        node.arguments.length === 1 &&
+                        ts.isStringLiteralLike(node.arguments[0])) {
+                        const name = node.arguments[0].text;
+                        return props.importer.internal(name);
+                    }
+                    else if (node.expression.getText() === "$importInstance" &&
+                        node.arguments.length === 2 &&
+                        ts.isStringLiteralLike(node.arguments[0]) &&
+                        ts.isStringLiteralLike(node.arguments[1])) {
+                        const name = node.arguments[0].text;
+                        const file = node.arguments[1].text;
+                        return props.importer.instance({
+                            file,
+                            name,
+                            alias: null,
+                        });
+                    }
+                    else if (node.expression.getText() === "$importNamespace" &&
+                        node.arguments.length === 2 &&
+                        ts.isStringLiteralLike(node.arguments[0]) &&
+                        ts.isStringLiteralLike(node.arguments[1])) {
+                        const name = node.arguments[0].text;
+                        const file = node.arguments[1].text;
+                        return props.importer.namespace({
+                            file,
+                            name,
+                        });
+                    }
+                    else if (node.expression.getText() === "$importDefault" &&
+                        node.arguments.length === 3 &&
+                        ts.isStringLiteralLike(node.arguments[0]) &&
+                        ts.isStringLiteralLike(node.arguments[1])) {
+                        const name = node.arguments[0].text;
+                        const file = node.arguments[1].text;
+                        return props.importer.default({
+                            file,
+                            name,
+                            type: false,
+                        });
+                    }
+                return ts.visitEachChild(ts.factory.cloneNode(node), visitor, props.transformer);
+            };
+            return visitor(ts.factory.cloneNode(statement.expression));
+        };
+    };
+})(ExpressionFactory || (ExpressionFactory = {}));
+
+export { ExpressionFactory };
+//# sourceMappingURL=ExpressionFactory.mjs.map

package/lib/factories/ExpressionFactory.mjs.map

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

package/lib/factories/IdentifierFactory.mjs

@@ -0,0 +1,47 @@
+import ts from 'typescript';
+import { Escaper } from '../utils/Escaper.mjs';
+import { TypeFactory } from './TypeFactory.mjs';
+
+var IdentifierFactory;
+(function (IdentifierFactory) {
+    IdentifierFactory.identifier = (name) => Escaper.variable(name)
+        ? ts.factory.createIdentifier(name)
+        : ts.factory.createStringLiteral(name);
+    IdentifierFactory.access = (input, key, chain) => {
+        const postfix = IdentifierFactory.identifier(key);
+        return ts.isStringLiteral(postfix)
+            ? chain === true
+                ? ts.factory.createElementAccessChain(input, ts.factory.createToken(ts.SyntaxKind.QuestionDotToken), postfix)
+                : ts.factory.createElementAccessExpression(input, postfix)
+            : chain === true
+                ? ts.factory.createPropertyAccessChain(input, ts.factory.createToken(ts.SyntaxKind.QuestionDotToken), postfix)
+                : ts.factory.createPropertyAccessExpression(input, postfix);
+    };
+    IdentifierFactory.getName = (input) => {
+        const value = input.escapedText?.toString();
+        if (typeof value === "string")
+            return value;
+        if (ts.isPropertyAccessExpression(input))
+            return `${IdentifierFactory.getName(input.expression)}.${input.name.escapedText.toString()}`;
+        else if (ts.isElementAccessExpression(input))
+            return `${IdentifierFactory.getName(input.expression)}[${IdentifierFactory.getName(input.argumentExpression)}]`;
+        return "unknown";
+    };
+    IdentifierFactory.postfix = (str) => Escaper.variable(str)
+        ? `".${str}"`
+        : `"[${JSON.stringify(str).split('"').join('\\"')}]"`;
+    IdentifierFactory.parameter = (name, type, init) => {
+        // instead of ts.version >= "4.8"
+        if (ts.getDecorators !== undefined)
+            return ts.factory.createParameterDeclaration(undefined, undefined, name, init?.kind === ts.SyntaxKind.QuestionToken
+                ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+                : undefined, type ?? TypeFactory.keyword("any"), init && init.kind !== ts.SyntaxKind.QuestionToken ? init : undefined);
+        // eslint-disable-next-line
+        return ts.factory.createParameterDeclaration(undefined, undefined, undefined, name, init?.kind === ts.SyntaxKind.QuestionToken
+            ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+            : undefined, type, init && init.kind !== ts.SyntaxKind.QuestionToken ? init : undefined);
+    };
+})(IdentifierFactory || (IdentifierFactory = {}));
+
+export { IdentifierFactory };
+//# sourceMappingURL=IdentifierFactory.mjs.map

package/lib/factories/IdentifierFactory.mjs.map

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

package/lib/factories/JsonMetadataFactory.mjs

@@ -0,0 +1,59 @@
+import { AtomicPredicator } from '../programmers/helpers/AtomicPredicator.mjs';
+import { TransformerError } from '../transformers/TransformerError.mjs';
+import { MetadataCollection } from './MetadataCollection.mjs';
+import { MetadataFactory } from './MetadataFactory.mjs';
+
+var JsonMetadataFactory;
+(function (JsonMetadataFactory) {
+    JsonMetadataFactory.analyze = (props) => {
+        const collection = new MetadataCollection();
+        const result = MetadataFactory.analyze({
+            checker: props.checker,
+            transformer: props.transformer,
+            options: {
+                absorb: true,
+                escape: true,
+                constant: true,
+                validate: props.validate
+                    ? (meta, explore) => {
+                        const errors = JsonMetadataFactory.validate(meta);
+                        errors.push(...props.validate(meta, explore));
+                        return errors;
+                    }
+                    : JsonMetadataFactory.validate,
+            },
+            collection,
+            type: props.type,
+        });
+        if (result.success === false)
+            throw TransformerError.from({
+                code: props.method,
+                errors: result.errors,
+            });
+        return {
+            collection,
+            metadata: result.data,
+        };
+    };
+    JsonMetadataFactory.validate = (meta) => {
+        const output = [];
+        if (meta.atomics.some((a) => a.type === "bigint") ||
+            meta.constants.some((c) => c.type === "bigint"))
+            output.push("JSON does not support bigint type.");
+        if (meta.tuples.some((t) => t.type.elements.some((e) => e.isRequired() === false)) ||
+            meta.arrays.some((a) => a.type.value.isRequired() === false))
+            output.push("JSON does not support undefined type in array.");
+        if (meta.maps.length)
+            output.push("JSON does not support Map type.");
+        if (meta.sets.length)
+            output.push("JSON does not support Set type.");
+        for (const native of meta.natives)
+            if (AtomicPredicator.native(native.name) === false &&
+                native.name !== "Date")
+                output.push(`JSON does not support ${native.name} type.`);
+        return output;
+    };
+})(JsonMetadataFactory || (JsonMetadataFactory = {}));
+
+export { JsonMetadataFactory };
+//# sourceMappingURL=JsonMetadataFactory.mjs.map

package/lib/factories/JsonMetadataFactory.mjs.map

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

package/lib/factories/LiteralFactory.mjs

@@ -0,0 +1,45 @@
+import ts from 'typescript';
+import { ExpressionFactory } from './ExpressionFactory.mjs';
+import { IdentifierFactory } from './IdentifierFactory.mjs';
+
+var LiteralFactory;
+(function (LiteralFactory) {
+    LiteralFactory.write = (input) => {
+        if (input === null)
+            return ts.factory.createNull();
+        else if (ts.isArrowFunction(input))
+            return input;
+        else if (ts.isCallExpression(input))
+            return input;
+        else if (ts.isIdentifier(input))
+            return input;
+        else if (input instanceof Array)
+            return writeArray(input);
+        else if (typeof input === "object")
+            return writeObject(input);
+        else if (typeof input === "boolean")
+            return writeBoolean(input);
+        else if (typeof input === "bigint")
+            return writeBigint(input);
+        else if (typeof input === "number")
+            return writeNumber(input);
+        else if (typeof input === "string")
+            return writeStrinng(input);
+        // unreachable code
+        else if (typeof input === "function")
+            return ts.factory.createIdentifier("undefined");
+        else
+            throw new TypeError("Error on LiteralFactory.generate(): unknown type.");
+    };
+    const writeObject = (obj) => ts.factory.createObjectLiteralExpression(Object.entries(obj)
+        .filter((tuple) => tuple[1] !== undefined)
+        .map(([key, value]) => ts.factory.createPropertyAssignment(IdentifierFactory.identifier(key), LiteralFactory.write(value))), true);
+    const writeArray = (array) => ts.factory.createArrayLiteralExpression(array.map(LiteralFactory.write), true);
+    const writeBoolean = (value) => value ? ts.factory.createTrue() : ts.factory.createFalse();
+    const writeNumber = (value) => ExpressionFactory.number(value);
+    const writeBigint = (value) => ExpressionFactory.bigint(value);
+    const writeStrinng = (value) => ts.factory.createStringLiteral(value);
+})(LiteralFactory || (LiteralFactory = {}));
+
+export { LiteralFactory };
+//# sourceMappingURL=LiteralFactory.mjs.map

package/lib/factories/LiteralFactory.mjs.map

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

package/lib/factories/MetadataCollection.mjs

@@ -0,0 +1,232 @@
+import { MetadataAliasType } from '../schemas/metadata/MetadataAliasType.mjs';
+import { MetadataArrayType } from '../schemas/metadata/MetadataArrayType.mjs';
+import { MetadataObjectType } from '../schemas/metadata/MetadataObjectType.mjs';
+import { MetadataTupleType } from '../schemas/metadata/MetadataTupleType.mjs';
+import { Writable } from '../typings/Writable.mjs';
+import { MapUtil } from '../utils/MapUtil.mjs';
+import { CommentFactory } from './CommentFactory.mjs';
+import { TypeFactory } from './TypeFactory.mjs';
+
+class MetadataCollection {
+    options;
+    objects_;
+    object_unions_;
+    aliases_;
+    arrays_;
+    tuples_;
+    names_;
+    object_index_;
+    recursive_array_index_;
+    recursive_tuple_index_;
+    constructor(options) {
+        this.options = options;
+        this.objects_ = new Map();
+        this.object_unions_ = new Map();
+        this.aliases_ = new Map();
+        this.arrays_ = new Map();
+        this.tuples_ = new Map();
+        this.names_ = new Map();
+        this.object_index_ = 0;
+        this.recursive_array_index_ = 0;
+        this.recursive_tuple_index_ = 0;
+    }
+    clone() {
+        const output = new MetadataCollection(this.options);
+        output.objects_ = new Map(this.objects_);
+        output.object_unions_ = new Map(this.object_unions_);
+        output.aliases_ = new Map(this.aliases_);
+        output.arrays_ = new Map(this.arrays_);
+        output.tuples_ = new Map(this.tuples_);
+        output.names_ = new Map(this.names_);
+        output.object_index_ = this.object_index_;
+        output.recursive_array_index_ = this.recursive_array_index_;
+        output.recursive_tuple_index_ = this.recursive_tuple_index_;
+        return output;
+    }
+    /* -----------------------------------------------------------
+          ACCESSORS
+      ----------------------------------------------------------- */
+    aliases() {
+        return [...this.aliases_.values()];
+    }
+    objects() {
+        return [...this.objects_.values()];
+    }
+    unions() {
+        return [...this.object_unions_.values()];
+    }
+    arrays() {
+        return [...this.arrays_.values()];
+    }
+    tuples() {
+        return [...this.tuples_.values()];
+    }
+    getName(checker, type) {
+        const name = (() => {
+            const str = TypeFactory.getFullName({
+                checker,
+                type,
+            });
+            return this.options?.replace ? this.options.replace(str) : str;
+        })();
+        const duplicates = MapUtil.take(this.names_, name, () => new Map());
+        const oldbie = duplicates.get(type);
+        if (oldbie !== undefined)
+            return oldbie;
+        const addicted = duplicates.size
+            ? `${name}.o${duplicates.size}`
+            : name;
+        duplicates.set(type, addicted);
+        return addicted;
+    }
+    /**
+     * @internal
+     */
+    getUnionIndex(meta) {
+        const key = meta.objects.map((obj) => obj.type.name).join(" | ");
+        MapUtil.take(this.object_unions_, key, () => meta.objects.map((o) => o.type));
+        return [...this.object_unions_.keys()].indexOf(key);
+    }
+    /* -----------------------------------------------------------
+          INSTANCES
+      ----------------------------------------------------------- */
+    emplace(checker, type) {
+        const oldbie = this.objects_.get(type);
+        if (oldbie !== undefined)
+            return [oldbie, false];
+        const id = this.getName(checker, type);
+        const obj = MetadataObjectType.create({
+            name: id,
+            properties: [],
+            description: (type.aliasSymbol && CommentFactory.description(type.aliasSymbol)) ??
+                (type.symbol && CommentFactory.description(type.symbol)) ??
+                undefined,
+            jsDocTags: type.aliasSymbol?.getJsDocTags() ?? type.symbol?.getJsDocTags() ?? [],
+            validated: false,
+            index: this.object_index_++,
+            recursive: null,
+            nullables: [],
+        });
+        this.objects_.set(type, obj);
+        return [obj, true];
+    }
+    emplaceAlias(checker, type, symbol) {
+        const oldbie = this.aliases_.get(type);
+        if (oldbie !== undefined)
+            return [oldbie, false, () => { }];
+        const id = this.getName(checker, type);
+        const alias = MetadataAliasType.create({
+            name: id,
+            value: null,
+            description: CommentFactory.description(symbol) ?? null,
+            recursive: null,
+            nullables: [],
+            jsDocTags: symbol.getJsDocTags() ?? [],
+        });
+        this.aliases_.set(type, alias);
+        return [alias, true, (meta) => (Writable(alias).value = meta)];
+    }
+    emplaceArray(checker, type) {
+        const oldbie = this.arrays_.get(type);
+        if (oldbie !== undefined)
+            return [oldbie, false, () => { }];
+        const id = this.getName(checker, type);
+        const array = MetadataArrayType.create({
+            name: id,
+            value: null,
+            index: null,
+            recursive: null,
+            nullables: [],
+        });
+        this.arrays_.set(type, array);
+        return [array, true, (meta) => (Writable(array).value = meta)];
+    }
+    emplaceTuple(checker, type) {
+        const oldbie = this.tuples_.get(type);
+        if (oldbie !== undefined)
+            return [oldbie, false, () => { }];
+        const id = this.getName(checker, type);
+        const tuple = MetadataTupleType.create({
+            name: id,
+            elements: null,
+            index: null,
+            recursive: null,
+            nullables: [],
+        });
+        this.tuples_.set(type, tuple);
+        return [tuple, true, (elements) => (Writable(tuple).elements = elements)];
+    }
+    /**
+     * @internal
+     */
+    setObjectRecursive(obj, recursive) {
+        Writable(obj).recursive = recursive;
+    }
+    /**
+     * @internal
+     */
+    setAliasRecursive(alias, recursive) {
+        Writable(alias).recursive = recursive;
+    }
+    /**
+     * @internal
+     */
+    setArrayRecursive(array, recursive) {
+        Writable(array).recursive = recursive;
+        if (recursive)
+            Writable(array).index = this.recursive_array_index_++;
+    }
+    setTupleRecursive(tuple, recursive) {
+        Writable(tuple).recursive = recursive;
+        if (recursive)
+            Writable(tuple).index = this.recursive_tuple_index_++;
+    }
+    toJSON() {
+        return {
+            objects: this.objects().map((o) => o.toJSON()),
+            aliases: this.aliases().map((d) => d.toJSON()),
+            arrays: [...this.arrays_.values()].map((a) => a.toJSON()),
+            tuples: [...this.tuples_.values()].map((t) => t.toJSON()),
+        };
+    }
+}
+(function (MetadataCollection) {
+    MetadataCollection.replace = (str) => {
+        let replaced = str;
+        for (const [before] of REPLACERS)
+            replaced = replaced.split(before).join("");
+        if (replaced.length !== 0)
+            return replaced;
+        for (const [before, after] of REPLACERS)
+            str = str.split(before).join(after);
+        return str;
+    };
+    MetadataCollection.escape = (str) => {
+        for (const [before, after] of REPLACERS)
+            if (after !== "")
+                str = str.split(after).join(before);
+        return str;
+    };
+})(MetadataCollection || (MetadataCollection = {}));
+const REPLACERS = [
+    ["$", "_dollar_"],
+    ["&", "_and_"],
+    ["|", "_or_"],
+    ["{", "_blt_"],
+    ["}", "_bgt_"],
+    ["<", "_lt_"],
+    [">", "_gt_"],
+    ["[", "_alt_"],
+    ["]", "_agt_"],
+    [",", "_comma_"],
+    ["`", "_backquote_"],
+    ["'", "_singlequote_"],
+    ['"', "_doublequote_"],
+    [" ", "_space_"],
+    ["?", "_question_"],
+    [":", "_colon_"],
+    [";", "_semicolon_"],
+];
+
+export { MetadataCollection };
+//# sourceMappingURL=MetadataCollection.mjs.map

package/lib/factories/MetadataCollection.mjs.map

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