typia 8.0.0 → 8.0.1

package/lib/transformers/features/reflect/ReflectNameTransformer.mjs

@@ -0,0 +1,66 @@
+import ts from 'typescript';
+import { MetadataCollection } from '../../../factories/MetadataCollection.mjs';
+import { MetadataFactory } from '../../../factories/MetadataFactory.mjs';
+import { TransformerError } from '../../TransformerError.mjs';
+
+var ReflectNameTransformer;
+(function (ReflectNameTransformer) {
+    ReflectNameTransformer.transform = (props) => {
+        if (!props.expression.typeArguments?.length)
+            throw new TransformerError({
+                code: "typia.reflect.metadata",
+                message: "no generic argument.",
+            });
+        const top = props.expression.typeArguments[0];
+        const regular = (() => {
+            // CHECK SECOND ARGUMENT EXISTENCE
+            const second = props.expression.typeArguments[1];
+            if (second === undefined)
+                return false;
+            // GET BOOLEAN VALUE
+            const value = getMetadata({
+                context: props.context,
+                node: second,
+            });
+            return value.size() === 1 &&
+                value.constants.length === 1 &&
+                value.constants[0].type === "boolean" &&
+                value.constants[0].values.length === 1
+                ? value.constants[0].values[0].value
+                : false;
+        })();
+        // RETURNS NAME
+        return ts.factory.createStringLiteral(regular
+            ? getMetadata({
+                context: props.context,
+                node: top,
+            }).getName()
+            : top.getFullText());
+    };
+})(ReflectNameTransformer || (ReflectNameTransformer = {}));
+const getMetadata = (props) => {
+    const type = props.context.checker.getTypeFromTypeNode(props.node);
+    const collection = new MetadataCollection({
+        replace: MetadataCollection.replace,
+    });
+    const result = MetadataFactory.analyze({
+        checker: props.context.checker,
+        transformer: props.context.transformer,
+        options: {
+            absorb: false,
+            constant: true,
+            escape: false,
+        },
+        collection,
+        type,
+    });
+    if (result.success === false)
+        throw TransformerError.from({
+            code: "typia.reflect.name",
+            errors: result.errors,
+        });
+    return result.data;
+};
+
+export { ReflectNameTransformer };
+//# sourceMappingURL=ReflectNameTransformer.mjs.map

package/lib/transformers/features/reflect/ReflectNameTransformer.mjs.map

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

package/lib/transformers/internal/GenericTransformer.mjs

@@ -0,0 +1,72 @@
+import ts from 'typescript';
+import { TransformerError } from '../TransformerError.mjs';
+
+var GenericTransformer;
+(function (GenericTransformer) {
+    GenericTransformer.scalar = (props) => {
+        // CHECK PARAMETER
+        if (props.expression.arguments.length === 0)
+            throw new TransformerError({
+                code: `typia.${props.method}`,
+                message: `no input value.`,
+            });
+        // GET TYPE INFO
+        const [type, node, generic] = props.expression.typeArguments && props.expression.typeArguments[0]
+            ? [
+                props.context.checker.getTypeFromTypeNode(props.expression.typeArguments[0]),
+                props.expression.typeArguments[0],
+                true,
+            ]
+            : [
+                props.context.checker.getTypeAtLocation(props.expression.arguments[0]),
+                props.expression.arguments[0],
+                false,
+            ];
+        if (type.isTypeParameter())
+            throw new TransformerError({
+                code: `typia.${props.method}`,
+                message: `non-specified generic argument.`,
+            });
+        // DO TRANSFORM
+        return ts.factory.createCallExpression(props.write({
+            context: props.context,
+            modulo: props.modulo,
+            type,
+            name: generic
+                ? node.getFullText().trim()
+                : getTypeName({
+                    checker: props.context.checker,
+                    type,
+                    node,
+                }),
+        }), undefined, props.expression.arguments);
+    };
+    GenericTransformer.factory = (props) => {
+        // CHECK GENERIC ARGUMENT EXISTENCE
+        if (!props.expression.typeArguments?.[0])
+            throw new TransformerError({
+                code: `typia.${props.method}`,
+                message: `generic argument is not specified.`,
+            });
+        // GET TYPE INFO
+        const node = props.expression.typeArguments[0];
+        const type = props.context.checker.getTypeFromTypeNode(node);
+        if (type.isTypeParameter())
+            throw new TransformerError({
+                code: `typia.${props.method}`,
+                message: `non-specified generic argument.`,
+            });
+        // DO TRANSFORM
+        return props.write({
+            context: props.context,
+            modulo: props.modulo,
+            type,
+            name: node.getFullText().trim(),
+            init: props.expression.arguments[0],
+        });
+    };
+    const getTypeName = (props) => props.checker.typeToString(props.type, props.node, ts.TypeFormatFlags.NodeBuilderFlagsMask);
+})(GenericTransformer || (GenericTransformer = {}));
+
+export { GenericTransformer };
+//# sourceMappingURL=GenericTransformer.mjs.map

package/lib/transformers/internal/GenericTransformer.mjs.map

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

package/lib/typings/Atomic.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=Atomic.mjs.map

package/lib/typings/Atomic.mjs.map

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

package/lib/typings/ClassProperties.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=ClassProperties.mjs.map

package/lib/typings/ClassProperties.mjs.map

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

package/lib/typings/Customizable.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=Customizable.mjs.map

package/lib/typings/Customizable.mjs.map

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

package/lib/typings/Equal.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=Equal.mjs.map

package/lib/typings/Equal.mjs.map

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

package/lib/typings/IsTuple.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=IsTuple.mjs.map

package/lib/typings/IsTuple.mjs.map

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

package/lib/typings/NativeClass.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=NativeClass.mjs.map

package/lib/typings/NativeClass.mjs.map

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

package/lib/typings/OmitNever.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=OmitNever.mjs.map

package/lib/typings/OmitNever.mjs.map

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

package/lib/typings/ProtobufAtomic.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=ProtobufAtomic.mjs.map

package/lib/typings/ProtobufAtomic.mjs.map

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

package/lib/typings/SpecialFields.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=SpecialFields.mjs.map

package/lib/typings/SpecialFields.mjs.map

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

package/lib/typings/ValidationPipe.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=ValidationPipe.mjs.map

package/lib/typings/ValidationPipe.mjs.map

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

package/lib/typings/ValueOf.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=ValueOf.mjs.map

package/lib/typings/ValueOf.mjs.map

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

package/lib/typings/Writable.mjs

@@ -0,0 +1,6 @@
+function Writable(elem) {
+    return elem;
+}
+
+export { Writable };
+//# sourceMappingURL=Writable.mjs.map

package/lib/typings/Writable.mjs.map

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

package/lib/utils/ArrayUtil.mjs

@@ -0,0 +1,27 @@
+var ArrayUtil;
+(function (ArrayUtil) {
+    ArrayUtil.has = (array, pred) => array.some(pred);
+    ArrayUtil.add = (array, value, pred = (x, y) => x === y) => {
+        if (array.some((elem) => pred(elem, value)))
+            return false;
+        array.push(value);
+        return true;
+    };
+    ArrayUtil.set = (array, value, key) => {
+        if (array.some((elem) => key(elem) === key(value)))
+            return;
+        array.push(value);
+    };
+    ArrayUtil.take = (array, pred, init) => {
+        const index = array.findIndex(pred);
+        if (index !== -1)
+            return array[index];
+        const elem = init();
+        array.push(elem);
+        return elem;
+    };
+    ArrayUtil.repeat = (count, closure) => new Array(count).fill("").map((_, index) => closure(index, count));
+})(ArrayUtil || (ArrayUtil = {}));
+
+export { ArrayUtil };
+//# sourceMappingURL=ArrayUtil.mjs.map

package/lib/utils/ArrayUtil.mjs.map

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

package/lib/utils/Escaper.mjs

@@ -0,0 +1,51 @@
+var Escaper;
+(function (Escaper) {
+    Escaper.variable = (str) => Escaper.reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str);
+    Escaper.reserved = (str) => RESERVED.has(str);
+})(Escaper || (Escaper = {}));
+const RESERVED = new Set([
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "enum",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "import",
+    "in",
+    "instanceof",
+    "module",
+    "new",
+    "null",
+    "package",
+    "public",
+    "private",
+    "protected",
+    "return",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+]);
+
+export { Escaper };
+//# sourceMappingURL=Escaper.mjs.map

package/lib/utils/Escaper.mjs.map

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

package/lib/utils/MapUtil.mjs

@@ -0,0 +1,14 @@
+var MapUtil;
+(function (MapUtil) {
+    MapUtil.take = (dict, key, generator) => {
+        const oldbie = dict.get(key);
+        if (oldbie)
+            return oldbie;
+        const value = generator();
+        dict.set(key, value);
+        return value;
+    };
+})(MapUtil || (MapUtil = {}));
+
+export { MapUtil };
+//# sourceMappingURL=MapUtil.mjs.map

package/lib/utils/MapUtil.mjs.map

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

package/lib/utils/NamingConvention.mjs

@@ -0,0 +1,94 @@
+import { StringUtil } from './StringUtil.mjs';
+
+var NamingConvention;
+(function (NamingConvention) {
+    const unsnake = (props) => (str) => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        let prefix = "";
+        for (let i = 0; i < str.length; i++) {
+            if (str[i] === "_")
+                prefix += "_";
+            else
+                break;
+        }
+        if (prefix.length !== 0)
+            str = str.substring(prefix.length);
+        const out = (s) => `${prefix}${s}`;
+        if (str.length === 0)
+            return out("");
+        const items = str.split("_").filter((s) => s.length !== 0);
+        return items.length === 0
+            ? out("")
+            : items.length === 1
+                ? out(props.plain(items[0]))
+                : out(items.map(props.snake).join(""));
+    };
+    function snake(str) {
+        if (str.length === 0)
+            return str;
+        // PREFIX
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        let prefix = "";
+        for (let i = 0; i < str.length; i++) {
+            if (str[i] === "_")
+                prefix += "_";
+            else
+                break;
+        }
+        if (prefix.length !== 0)
+            str = str.substring(prefix.length);
+        const out = (s) => `${prefix}${s}`;
+        // SNAKE CASE
+        const items = str.split("_");
+        if (items.length > 1)
+            return out(items.map((s) => s.toLowerCase()).join("_"));
+        // CAMEL OR PASCAL CASE
+        const indexes = [];
+        for (let i = 0; i < str.length; i++) {
+            const code = str.charCodeAt(i);
+            if (65 <= code && code <= 90)
+                indexes.push(i);
+        }
+        for (let i = indexes.length - 1; i > 0; --i) {
+            const now = indexes[i];
+            const prev = indexes[i - 1];
+            if (now - prev === 1)
+                indexes.splice(i, 1);
+        }
+        if (indexes.length !== 0 && indexes[0] === 0)
+            indexes.splice(0, 1);
+        if (indexes.length === 0)
+            return str.toLowerCase();
+        let ret = "";
+        for (let i = 0; i < indexes.length; i++) {
+            const first = i === 0 ? 0 : indexes[i - 1];
+            const last = indexes[i];
+            ret += str.substring(first, last).toLowerCase();
+            ret += "_";
+        }
+        ret += str.substring(indexes[indexes.length - 1]).toLowerCase();
+        return out(ret);
+    }
+    NamingConvention.snake = snake;
+    function camel(str) {
+        return unsnake({
+            plain: (str) => str.length
+                ? str === str.toUpperCase()
+                    ? str.toLocaleLowerCase()
+                    : `${str[0].toLowerCase()}${str.substring(1)}`
+                : str,
+            snake: (str, i) => i === 0 ? str.toLowerCase() : StringUtil.capitalize(str.toLowerCase()),
+        })(str);
+    }
+    NamingConvention.camel = camel;
+    function pascal(str) {
+        return unsnake({
+            plain: (str) => str.length ? `${str[0].toUpperCase()}${str.substring(1)}` : str,
+            snake: StringUtil.capitalize,
+        })(str);
+    }
+    NamingConvention.pascal = pascal;
+})(NamingConvention || (NamingConvention = {}));
+
+export { NamingConvention };
+//# sourceMappingURL=NamingConvention.mjs.map

package/lib/utils/NamingConvention.mjs.map

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

package/lib/utils/PatternUtil.mjs

@@ -0,0 +1,29 @@
+var PatternUtil;
+(function (PatternUtil) {
+    PatternUtil.fix = (str) => {
+        const first = str.indexOf(PatternUtil.STRING);
+        const last = str.lastIndexOf(PatternUtil.STRING);
+        return [
+            first === -1 || none("(")(str.slice(0, first)) ? "^" : "",
+            str,
+            last === -1 || none(")")(str.slice(last + PatternUtil.STRING.length)) ? "$" : "",
+        ].join("");
+    };
+    PatternUtil.escape = (str) => {
+        return str.replace(/[|\\/{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+    };
+    PatternUtil.NUMBER = "[+-]?" + // optional sign
+        "\\d+(?:\\.\\d+)?" + // integer or decimal
+        "(?:[eE][+-]?\\d+)?"; // optional exponent
+    PatternUtil.BOOLEAN = "true|false";
+    PatternUtil.STRING = "(.*)";
+})(PatternUtil || (PatternUtil = {}));
+const none = (parenthesis) => (str) => {
+    for (const ch of str)
+        if (ch !== parenthesis)
+            return true;
+    return false;
+};
+
+export { PatternUtil };
+//# sourceMappingURL=PatternUtil.mjs.map

package/lib/utils/PatternUtil.mjs.map

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

package/lib/utils/ProtobufNameEncoder.mjs

@@ -0,0 +1,35 @@
+var ProtobufNameEncoder;
+(function (ProtobufNameEncoder) {
+    ProtobufNameEncoder.encode = (str) => {
+        for (const [before, after] of REPLACERS)
+            str = str.split(before).join(after);
+        return str;
+    };
+    ProtobufNameEncoder.decode = (str) => {
+        for (const [before, after] of REPLACERS)
+            if (after !== "")
+                str = str.split(after).join(before);
+        return str;
+    };
+})(ProtobufNameEncoder || (ProtobufNameEncoder = {}));
+const REPLACERS = [
+    ["$", "_dollar_"],
+    ["&", "_and_"],
+    ["|", "_or_"],
+    ["{", "_blt_"],
+    ["}", "_bgt_"],
+    ["<", "_lt_"],
+    [">", "_gt_"],
+    ["(", "_lp_"],
+    [")", "_rp_"],
+    ["[", "_alt_"],
+    ["]", "_agt_"],
+    [",", "_comma_"],
+    ["`", "_backquote_"],
+    ["'", "_singlequote_"],
+    ['"', "_doublequote_"],
+    [" ", "_space_"],
+];
+
+export { ProtobufNameEncoder };
+//# sourceMappingURL=ProtobufNameEncoder.mjs.map

package/lib/utils/ProtobufNameEncoder.mjs.map

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

package/lib/utils/Singleton.mjs

@@ -0,0 +1,17 @@
+class Singleton {
+    closure_;
+    value_;
+    constructor(closure) {
+        this.closure_ = closure;
+        this.value_ = NOT_MOUNTED_YET;
+    }
+    get(...args) {
+        if (this.value_ === NOT_MOUNTED_YET)
+            this.value_ = this.closure_(...args);
+        return this.value_;
+    }
+}
+const NOT_MOUNTED_YET = {};
+
+export { Singleton };
+//# sourceMappingURL=Singleton.mjs.map

package/lib/utils/Singleton.mjs.map

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

package/lib/utils/StringUtil.mjs

@@ -0,0 +1,13 @@
+var StringUtil;
+(function (StringUtil) {
+    StringUtil.capitalize = (str) => str.length ? str[0].toUpperCase() + str.slice(1).toLowerCase() : str;
+    StringUtil.escapeDuplicate = (props) => props.keep.includes(props.input)
+        ? StringUtil.escapeDuplicate({
+            keep: props.keep,
+            input: (props.escape ?? ((str) => `_${str}`))(props.input),
+        })
+        : props.input;
+})(StringUtil || (StringUtil = {}));
+
+export { StringUtil };
+//# sourceMappingURL=StringUtil.mjs.map

package/lib/utils/StringUtil.mjs.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "8.0.0",
+  "version": "8.0.1",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -27,7 +27,8 @@
     "------------------------------------------------": "",
     "package:latest": "ts-node deploy --tag latest",
     "package:next": "ts-node deploy --tag next",
-    "package:patch": "ts-node deploy --tag patch"
+    "package:patch": "ts-node deploy --tag patch",
+    "preinstall": "npx only-allow pnpm"
   },
   "repository": {
     "type": "git",
@@ -66,7 +67,10 @@
     "prettier": "^3.2.5",
     "rimraf": "^5.0.5",
     "rollup": "^4.18.0",
+    "rollup-plugin-auto-external": "^2.0.0",
+    "rollup-plugin-node-externals": "^8.0.0",
     "suppress-warnings": "^1.0.2",
+    "tinyglobby": "^0.2.12",
     "ts-node": "^10.9.2",
     "typescript": "~5.8.2"
   },

package/src/factories/internal/metadata/emplace_metadata_object.ts

@@ -32,14 +32,18 @@ export const emplace_metadata_object = (
   const isProperty = significant(!!props.options.functional);
   const pred: (node: ts.Declaration) => boolean = isClass
     ? (node) => {
-        const kind: ts.SyntaxKind | undefined = node
-          .getChildren()[0]
-          ?.getChildren()[0]?.kind;
-        return (
-          kind !== ts.SyntaxKind.PrivateKeyword &&
-          kind !== ts.SyntaxKind.ProtectedKeyword &&
-          isProperty(node)
-        );
+        const capsuled: boolean = node
+          .getChildren()
+          .some((c) =>
+            c
+              .getChildren()
+              .some(
+                (n) =>
+                  n.kind === ts.SyntaxKind.PrivateKeyword ||
+                  n.kind === ts.SyntaxKind.ProtectedKeyword,
+              ),
+          );
+        return capsuled === false && isProperty(node);
       }
     : (node) => isProperty(node);