xjs-common 13.0.0-alpha.2 → 13.0.0-alpha.3

package/README.md

@@ -93,32 +93,7 @@ import { UString } from "xjs-common";
     console.log(UString.simpleTime({ date: getJSTDate(), unit: TimeUnit.Day }));
 })();
 ```
-### Mark method as transaction.  
-**NOTE**: this feature uses decorator, so requires `"experimentalDecorators": true` in tsconfig.
-```ts
-import { transaction, delay } from "xjs-common";
-
-class Cls {
-    constructor() { }
-    // default timeout sec is 30.
-    @transaction()
-    async exe1(): Promise<void> {
-    }
-    @transaction({ timeoutSec: 3 })
-    async exe2(): Promise<void> {
-        await delay(10);
-    }
-}
-(async () => {
-    const cls = new Cls();
-    await Promise.all([cls.exe2(), cls.exe2()]);
-})().catch(e => {
-    // reach here after 3 sec from second call for Cls#exe2().
-    // XjsErr [Error]: [XJS] An exclusive process to execute was already running by other request.
-    console.log(e);
-});
-```
-### Validate and crop class fields.  
+### Validate and crop object properties with annotation.  
 **NOTE**: this feature uses decorator, so requires `"experimentalDecorators": true` in tsconfig.  
 **NOTE**: some functionalities  in this feature are based on `"useDefineForClassFields": true` in tsconfig.  
 this flag is true by default at the target higher than `ES2022`, [here is for more](https://www.typescriptlang.org/tsconfig/#useDefineForClassFields).
@@ -181,6 +156,31 @@ class Cls_A implements If_A {
     console.log(UType.validate(invalid5, Cls_A)); // [ 'objA.aryB.0' ]
 })();
 ```
+### Mark method as transaction.  
+**NOTE**: this feature uses decorator, so requires `"experimentalDecorators": true` in tsconfig.
+```ts
+import { transaction, delay } from "xjs-common";
+
+class Cls {
+    constructor() { }
+    // default timeout sec is 30.
+    @transaction()
+    async exe1(): Promise<void> {
+    }
+    @transaction({ timeoutSec: 3 })
+    async exe2(): Promise<void> {
+        await delay(10);
+    }
+}
+(async () => {
+    const cls = new Cls();
+    await Promise.all([cls.exe2(), cls.exe2()]);
+})().catch(e => {
+    // reach here after 3 sec from second call for Cls#exe2().
+    // XjsErr [Error]: [XJS] An exclusive process to execute was already running by other request.
+    console.log(e);
+});
+```
 # Error definition
 XJS throws error with `code` property which has one of the following numbers.
 |code|thrown by|

package/build/cjs/const/http-method.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpMethod = void 0;
+var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["Get"] = "GET";
+    HttpMethod["Put"] = "PUT";
+    HttpMethod["Post"] = "POST";
+    HttpMethod["Delete"] = "DELETE";
+    HttpMethod["Patch"] = "PATCH";
+    HttpMethod["Connect"] = "CONNECT";
+})(HttpMethod || (exports.HttpMethod = HttpMethod = {}));

package/build/cjs/const/time-unit.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeUnit = void 0;
+var TimeUnit;
+(function (TimeUnit) {
+    TimeUnit[TimeUnit["Year"] = 1] = "Year";
+    TimeUnit[TimeUnit["Month"] = 2] = "Month";
+    TimeUnit[TimeUnit["Day"] = 3] = "Day";
+    TimeUnit[TimeUnit["Hour"] = 4] = "Hour";
+    TimeUnit[TimeUnit["Min"] = 5] = "Min";
+    TimeUnit[TimeUnit["Sec"] = 6] = "Sec";
+    TimeUnit[TimeUnit["Msec"] = 7] = "Msec";
+})(TimeUnit || (exports.TimeUnit = TimeUnit = {}));

package/build/cjs/const/types.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Type = void 0;
+var Type;
+(function (Type) {
+    Type["string"] = "string";
+    Type["number"] = "number";
+    Type["bigint"] = "bigint";
+    Type["boolean"] = "boolean";
+    Type["symbol"] = "symbol";
+    Type["object"] = "object";
+    Type["undefined"] = "undefined";
+    Type["null"] = "null";
+})(Type || (exports.Type = Type = {}));

package/build/cjs/func/decorator/d-type.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DType = exports.smbl_tm = void 0;
+const types_1 = require("../../const/types");
+const xjs_err_1 = require("../../obj/xjs-err");
+const u_type_1 = require("../u-type");
+const s_errCode = 30;
+exports.smbl_tm = Symbol.for("xjs:typeMap");
+/**
+ * decorators to be validated by {@link UType.validate},
+ * and to be cropped by {@link UObj.crop}.
+ */
+var DType;
+(function (DType) {
+    /** express `string` property. */
+    function string(target, propKey) {
+        setTypeDesc(target, propKey, types_1.Type.string);
+    }
+    DType.string = string;
+    /** express `number` property. */
+    function number(target, propKey) {
+        setTypeDesc(target, propKey, types_1.Type.number);
+    }
+    DType.number = number;
+    /** express `boolean` property. */
+    function boolean(target, propKey) {
+        setTypeDesc(target, propKey, types_1.Type.boolean);
+    }
+    DType.boolean = boolean;
+    function setTypeDesc(target, propKey, t) {
+        setDesc(target, propKey, (td) => {
+            if (td.t)
+                throw new xjs_err_1.XjsErr(s_errCode, "decorator to express type is duplicate.");
+            td.t = t;
+        });
+    }
+    /** express required property. */
+    function required(target, propKey) {
+        setDesc(target, propKey, (td) => td.req = true);
+    }
+    DType.required = required;
+    /**
+     * express array.
+     * @param elmDesc {@link TypeDesc} or class constructor type.
+     */
+    function array(elmDesc = {}) {
+        return (target, propKey) => setDesc(target, propKey, (td) => u_type_1.UType.isFunction(elmDesc) ? td.ary = { cls: elmDesc } : td.ary = elmDesc);
+    }
+    DType.array = array;
+    /**
+     * express record object. note that this may allow array type because array is essentialy object type has properties.
+     * @param elmDesc {@link TypeDesc} or class constructor type.
+     */
+    function record(elmDesc = {}) {
+        return (target, propKey) => setDesc(target, propKey, (td) => u_type_1.UType.isFunction(elmDesc) ? td.rcd = { cls: elmDesc } : td.rcd = elmDesc);
+    }
+    DType.record = record;
+    /**
+     * express an object which has properties that specified class express with {@link DType}.
+     * @param ctor class constructor type.
+     */
+    function object(ctor) {
+        return (target, propKey) => setDesc(target, propKey, (td) => td.cls = ctor);
+    }
+    DType.object = object;
+    function keep(target, propKey) {
+        setDesc(target, propKey, (_) => { });
+    }
+    DType.keep = keep;
+    function setDesc(target, propKey, setter) {
+        const map = target[exports.smbl_tm] ? Object.assign({}, target[exports.smbl_tm]) : {};
+        map[propKey] ??= { t: null, req: false, cls: null, ary: null, rcd: null };
+        const td = map[propKey];
+        setter(td);
+        const structualDescs = [[td.ary, "array"], [td.cls, "class"], [td.rcd, "record"]].filter(e => e[0]);
+        if (structualDescs.length > 0) {
+            let ex1 = null, ex2 = null;
+            if (td.t) {
+                ex1 = "type";
+                ex2 = structualDescs[0][1];
+            }
+            if (structualDescs.length > 1) {
+                ex1 = structualDescs[0][1];
+                ex2 = structualDescs[1][1];
+            }
+            if (ex1 && ex2)
+                throw new xjs_err_1.XjsErr(s_errCode, `decorator to express ${ex1} and ${ex2} are exclusive.`);
+        }
+        Object.defineProperty(target, exports.smbl_tm, { value: map, configurable: true });
+    }
+})(DType || (exports.DType = DType = {}));

package/build/cjs/func/decorator/transaction.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transaction = transaction;
+const xjs_err_1 = require("../../obj/xjs-err");
+const u_1 = require("../u");
+const s_errCode = 100;
+/**
+ * applies transation to the method. note that the method must return a Promise.
+ * @param op.timeoutSec default is `30`.
+ */
+function transaction(op) {
+    let lock = 0;
+    const timeoutSec = op?.timeoutSec ?? 30;
+    return (target, propertyKey, descriptor) => {
+        const method = descriptor.value;
+        async function exe(...p) {
+            const timelimit = Date.now() + timeoutSec * 1000;
+            while (lock > 0) {
+                if (timelimit <= Date.now())
+                    throw new xjs_err_1.XjsErr(s_errCode, "An exclusive process to execute was already running by other request.");
+                await (0, u_1.delay)(1);
+            }
+            try {
+                lock++;
+                const ret = method.apply(this, p);
+                return ret instanceof Promise ? await ret : ret;
+            }
+            finally {
+                lock--;
+            }
+        }
+        ;
+        descriptor.value = exe;
+    };
+}

package/build/cjs/func/u-array.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UArray = void 0;
+const u_1 = require("./u");
+var UArray;
+(function (UArray) {
+    /**
+     * compares two arrays to valuate equality.
+     * if one side is null or undefined, it returns true when other side is the same.
+     * this function has compatibility {@link AlmostArray} like {@link Uint8Array} etc.
+     * @param v1 it uses equal operator for comparing elements, so applying object element is not recommended.
+     * @param v2 same as v1.
+     * @param sort it uses {@link Array.sort()} on v1 and v2 if true. default is true.
+     * @param useStrictEqual check equality whether {@link Array} or not and it uses `===` operator for compareing elements if true, otherwise using `==` operator. default is true.
+     */
+    function eq(v1, v2, op = {}) {
+        const { sort, useStrictEqual } = Object.assign({ sort: true, useStrictEqual: true }, op);
+        if (v1 && !v2 || !v1 && v2)
+            return false;
+        if (!v1)
+            return true;
+        if (v1.length !== v2.length)
+            return false;
+        if (useStrictEqual && v1 instanceof Array !== v2 instanceof Array)
+            return false;
+        const a = sort ? v1.slice().sort() : v1, b = sort ? v2.slice().sort() : v2;
+        return a.every((v, i) => useStrictEqual ? v === b[i] : v == b[i]);
+    }
+    UArray.eq = eq;
+    function distinct(array, op) {
+        if (!array || array.length === 0)
+            return [];
+        if (op?.k)
+            return Array.from((0, u_1.array2map)(array, e => e[op.k]).values()).map(a => op?.takeLast ? a.pop() : a.shift());
+        const a = op?.takeLast ? [...array].reverse() : [...array];
+        const p = op?.predicate ?? ((v1, v2) => v1 == v2);
+        const result = [a.shift()];
+        a.forEach(v => result.some(v2 => p(v, v2)) ? {} : result.push(v));
+        return result;
+    }
+    UArray.distinct = distinct;
+    function chop(array, len) {
+        return [...Array(Math.ceil(array.length / len)).keys()]
+            .map(i => {
+            let endIdx = (i + 1) * len;
+            if (endIdx > array.length)
+                endIdx = array.length;
+            return array.slice(i * len, endIdx);
+        });
+    }
+    UArray.chop = chop;
+    function remove(array, v) {
+        const idx = array.indexOf(v);
+        if (idx !== -1)
+            array.splice(idx, 1);
+    }
+    UArray.remove = remove;
+    function randomPick(array, takeout = true) {
+        const i = Math.floor(array.length * Math.random());
+        const r = array[i];
+        if (takeout)
+            array.splice(i, 1);
+        return r;
+    }
+    UArray.randomPick = randomPick;
+    function shuffle(array) {
+        const cp = [...array];
+        return (0, u_1.int2array)(array.length).map(_ => randomPick(cp));
+    }
+    UArray.shuffle = shuffle;
+    function takeOut(array, filter) {
+        const result = [];
+        for (let i = array.length - 1; i >= 0; i--)
+            if (filter(array[i], i)) {
+                result.unshift(array[i]);
+                array.splice(i, 1);
+            }
+        return result;
+    }
+    UArray.takeOut = takeOut;
+})(UArray || (exports.UArray = UArray = {}));

package/build/cjs/func/u-http.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UHttp = void 0;
+var UHttp;
+(function (UHttp) {
+    function isHttpSuccess(statusCode) {
+        return statusCategoryOf(statusCode) === 2;
+    }
+    UHttp.isHttpSuccess = isHttpSuccess;
+    function statusCategoryOf(statusCode) {
+        return Math.floor(statusCode / 100);
+    }
+    UHttp.statusCategoryOf = statusCategoryOf;
+    function concatParamsWithEncoding(end, params) {
+        if (!params || Object.keys(params).length === 0)
+            return end;
+        const paramsFlatten = Object.entries(params)
+            .flatMap(kv => Array.isArray(kv[1]) ? kv[1].map(v => [kv[0], v]) : [kv]);
+        let result = end ? end + "?" : "";
+        for (var kv of paramsFlatten)
+            result += kv[0] + "=" + encodeURIComponent(kv[1]) + "&";
+        return result.substring(0, result.length - 1);
+    }
+    UHttp.concatParamsWithEncoding = concatParamsWithEncoding;
+    /** normalize object keys to lower case. */
+    function normalizeHeaders(headers) {
+        if (!headers)
+            return {};
+        return Object.entries(headers).reduce((a, b) => { a[b[0].toLowerCase()] = b[1]; return a; }, {});
+    }
+    UHttp.normalizeHeaders = normalizeHeaders;
+})(UHttp || (exports.UHttp = UHttp = {}));

package/build/cjs/func/u-obj.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UObj = void 0;
+const d_type_1 = require("./decorator/d-type");
+const u_type_1 = require("./u-type");
+var UObj;
+(function (UObj) {
+    /**
+     * assign properties to the object with specified property keys.
+     * @param t target object.
+     * @param s source object.
+     * @param keys property keys which are copied from source object. if omit this, all keys in source object is applied.
+     * @param keepDtypeClass if true, class which has properties decorated with {@link DType} in target object is kept and that is assigned properties recursively.
+     */
+    function assignProperties(t, s, keys, keepDtypeClass) {
+        for (const k of keys ?? Object.keys(s))
+            if (u_type_1.UType.isDefined(s[k]))
+                if (keepDtypeClass && u_type_1.UType.isObject(t[k]) && u_type_1.UType.isObject(s[k]) && t[k]?.[d_type_1.smbl_tm]) {
+                    assignProperties(t[k], s[k], null, true);
+                }
+                else
+                    t[k] = s[k];
+        return t;
+    }
+    UObj.assignProperties = assignProperties;
+    function crop(o, keys_or_ctor, removeKeys) {
+        const tm = Array.isArray(keys_or_ctor) ? null
+            : (!keys_or_ctor || o instanceof keys_or_ctor ? o[d_type_1.smbl_tm] : new keys_or_ctor()[d_type_1.smbl_tm]);
+        const _keys = tm ? Object.keys(tm) : (keys_or_ctor ?? []);
+        if (_keys.length === 0)
+            return removeKeys ? o : {};
+        Object.keys(o).filter(k => {
+            if (tm && tm[k] && o[k]) {
+                if (tm[k].cls)
+                    crop(o[k], tm[k]?.cls);
+                else {
+                    const vCtor = tm[k].ary?.cls ?? tm[k].rcd?.cls;
+                    Object.values(o[k]).forEach(v => crop(v, vCtor));
+                }
+            }
+            return !!removeKeys === _keys.includes(k);
+        }).forEach(k => delete o[k]);
+        return o;
+    }
+    UObj.crop = crop;
+    /**
+     * manipulate properties of an object.
+     * as default if the properties contains object, it also manipulates properties of that recursively.
+     * @param o object whose properties the process applies to.
+     * @param process process to be applied to properties of the object. note that function property is not included in the properties.
+     * @param op.ignoreEmpty skip null or undefined properties to manipuldate. default is true.
+     * @param op.recursive whether it manipulate properties of an object recursively. default is true.
+     * @param op.targetType primitive types which filter the properties to be processed.
+     */
+    function manipulateProperties(o, process, op) {
+        const target = op?.targetType && u_type_1.UType.takeAsArray(op?.targetType);
+        const _ignoreEmpty = !u_type_1.UType.isDefined(op?.ignoreEmpty) || op?.ignoreEmpty;
+        const _recursive = !u_type_1.UType.isDefined(op?.recursive) || op?.recursive;
+        const rec = (_o) => {
+            for (const k in _o) {
+                const prop = _o[k];
+                if (_ignoreEmpty && u_type_1.UType.isEmpty(prop))
+                    continue;
+                if (u_type_1.UType.isObject(prop) && _recursive)
+                    rec(prop);
+                else if (!u_type_1.UType.isFunction(prop) && (!target || target.some(t => typeof prop === t)))
+                    _o[k] = process(prop);
+            }
+        };
+        rec(o);
+        return o;
+    }
+    UObj.manipulateProperties = manipulateProperties;
+})(UObj || (exports.UObj = UObj = {}));

package/build/cjs/func/u-string.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UString = void 0;
+const time_unit_1 = require("../const/time-unit");
+const xjs_err_1 = require("../obj/xjs-err");
+const u_1 = require("./u");
+const u_type_1 = require("./u-type");
+const s_errCode = 20;
+var UString;
+(function (UString) {
+    function eq(s1, s2) {
+        return !u_type_1.UType.isString(s1) || !u_type_1.UType.isString(s2) ? s1 === s2 : s1.trim() === s2.trim();
+    }
+    UString.eq = eq;
+    function repeat(token, mlt) {
+        return (0, u_1.int2array)(mlt).map(_ => token).join("");
+    }
+    UString.repeat = repeat;
+    /**
+     * generate date time number as fixed length (depends on `unit`) string without separator charactor.
+     * For example, `2025-06-08T10:15:06.366Z` is to be `20250608101506366`.
+     * @param op.date Date object refered by this. default is `new Date()`.
+     * @param op.unit time unit. default is secound.
+     */
+    function simpleTime(op) {
+        const t = (op?.date ?? new Date()).toISOString().split(".")[0].replace(/[-T:]/g, "");
+        if (op?.unit === time_unit_1.TimeUnit.Msec)
+            return t;
+        return t.substring(0, 14 - (6 - (op?.unit ?? time_unit_1.TimeUnit.Sec)) * 2);
+    }
+    UString.simpleTime = simpleTime;
+    function generateRandomString(len) {
+        return (0, u_1.int2array)(len).map(_ => {
+            let rnd = Math.floor(62 * Math.random());
+            const remain = rnd - 52;
+            if (remain >= 0)
+                return remain.toString();
+            if (rnd > 26)
+                rnd += 6;
+            return String.fromCharCode(rnd + 65);
+        }).join("");
+    }
+    UString.generateRandomString = generateRandomString;
+    function idx2az(idx) {
+        let az = "", num = idx;
+        while (num >= 0) {
+            az = String.fromCharCode(num % 26 + 97) + az;
+            num = Math.floor(num / 26) - 1;
+        }
+        return az.toUpperCase();
+    }
+    UString.idx2az = idx2az;
+    function az2idx(az) {
+        if (!az?.match(/^[a-zA-Z]+$/))
+            throw new xjs_err_1.XjsErr(s_errCode, "the parameter isn't az(AZ) format.");
+        return az.toLowerCase().split("").map(c => c.charCodeAt(0) - 97).reverse()
+            .map((idx, i) => (idx + 1) * (26 ** i)).reduce((v1, v2) => v1 + v2) - 1;
+    }
+    UString.az2idx = az2idx;
+    function asAmount(amount, unit) {
+        const int2dec = amount.toString().split(".");
+        const etni = int2dec[0].split("").reverse().join("");
+        let fetni = "";
+        const max = Math.ceil(etni.length / 3);
+        for (let i = 0; i < max; i++) {
+            if (i === max - 1)
+                fetni += etni.substring(i * 3);
+            else
+                fetni += (etni.substring(i * 3, (i + 1) * 3) + ",");
+        }
+        const finte = unit + fetni.split("").reverse().join("");
+        if (int2dec.length === 1)
+            return finte;
+        else
+            return finte + "." + int2dec[1];
+    }
+    function asJpy(amount) {
+        return u_type_1.UType.isEmpty(amount) ? "" : asAmount(Math.floor(amount), "¥");
+    }
+    UString.asJpy = asJpy;
+    function asUsd(amount) {
+        return u_type_1.UType.isEmpty(amount) ? "" : asAmount(Number(amount.toFixed(2)), "$");
+    }
+    UString.asUsd = asUsd;
+    function asPercentage(amount) {
+        if (u_type_1.UType.isEmpty(amount))
+            return "";
+        let percent = (amount * 100).toFixed(2);
+        while (percent.endsWith("0"))
+            percent = percent.substring(0, percent.length - 1);
+        if (percent.endsWith("."))
+            percent = percent.substring(0, percent.length - 1);
+        return percent + "%";
+    }
+    UString.asPercentage = asPercentage;
+    function is_yyyy(v) {
+        return !!v?.match(/^[1-9]\d{3}$/);
+    }
+    UString.is_yyyy = is_yyyy;
+    function is_yyyyMM(v) {
+        return !!v?.match(/^[1-9]\d{3}(0[1-9]|1[0-2])$/);
+    }
+    UString.is_yyyyMM = is_yyyyMM;
+    function is_yyyyMMdd(v) {
+        return !!v?.match(/^[1-9]\d{3}(0[1-9]|1[0-2])(0[1-9]|[1-2][0-9]|[3][0-1])$/);
+    }
+    UString.is_yyyyMMdd = is_yyyyMMdd;
+    function is_yyyyMMddhh(v) {
+        return !!v?.match(/^[1-9]\d{3}(0[1-9]|1[0-2])(0[1-9]|[1-2][0-9]|[3][0-1])([01]\d|2[0-3])$/);
+    }
+    UString.is_yyyyMMddhh = is_yyyyMMddhh;
+    function is_yyyyMMddhhmm(v) {
+        return !!v?.match(/^[1-9]\d{3}(0[1-9]|1[0-2])(0[1-9]|[1-2][0-9]|[3][0-1])([01]\d|2[0-3])[0-5]\d$/);
+    }
+    UString.is_yyyyMMddhhmm = is_yyyyMMddhhmm;
+    function is_yyyyMMddhhmmss(v) {
+        return !!v?.match(/^[1-9]\d{3}(0[1-9]|1[0-2])(0[1-9]|[1-2][0-9]|[3][0-1])([01]\d|2[0-3])[0-5]\d[0-5]\d$/);
+    }
+    UString.is_yyyyMMddhhmmss = is_yyyyMMddhhmmss;
+})(UString || (exports.UString = UString = {}));

package/build/cjs/func/u-type.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UType = void 0;
+const types_1 = require("../const/types");
+const d_type_1 = require("./decorator/d-type");
+var UType;
+(function (UType) {
+    function isDefined(v) {
+        return typeof v !== types_1.Type.undefined;
+    }
+    UType.isDefined = isDefined;
+    function isEmpty(v) {
+        return v === null || typeof v === types_1.Type.undefined;
+    }
+    UType.isEmpty = isEmpty;
+    function isString(v) { return typeof v === types_1.Type.string; }
+    UType.isString = isString;
+    function isNumber(v) { return typeof v === types_1.Type.number; }
+    UType.isNumber = isNumber;
+    function isBigint(v) { return typeof v === types_1.Type.bigint; }
+    UType.isBigint = isBigint;
+    function isBoolean(v) { return typeof v === types_1.Type.boolean; }
+    UType.isBoolean = isBoolean;
+    function isSymbol(v) { return typeof v === types_1.Type.symbol; }
+    UType.isSymbol = isSymbol;
+    function isObject(v) { return typeof v === types_1.Type.object; }
+    UType.isObject = isObject;
+    function isFunction(v) { return typeof v === "function"; }
+    UType.isFunction = isFunction;
+    function isArray(v, t) {
+        return Array.isArray(v) && (!t || v.every(e => typeof e === t));
+    }
+    UType.isArray = isArray;
+    /**
+     * validate properties decorated with {@link DType}.
+     * @param o object to be validated. if this is class object decorated with {@link DType}, it can omits `ctor` parameter.
+     * @param ctor class constructor type whose properties are decorated. **NOTE** that need to have public constructor without any parameter.
+     * @returns invalid property keys. returns an empty array if `o` is valid.
+     */
+    function validate(o, ctor) {
+        const _o = (!ctor || o instanceof ctor) ? o : Object.assign(new ctor(), o);
+        if (!_o[d_type_1.smbl_tm])
+            return [];
+        return Object.entries(_o[d_type_1.smbl_tm]).flatMap(e => validateProp(e[0], _o[e[0]], e[1]));
+    }
+    UType.validate = validate;
+    function validateProp(k, prop, td) {
+        if (isEmpty(prop))
+            return td.req ? [k] : [];
+        if (td.t && typeof prop !== td.t)
+            return [k];
+        const joinKey = (k2) => `${k}.${k2}`;
+        if (td.ary)
+            return Array.isArray(prop)
+                ? prop.flatMap((e, i) => validateProp(i.toString(), e, td.ary)).map(joinKey) : [k];
+        if (td.rcd)
+            return UType.isObject(prop)
+                ? Object.entries(prop).flatMap(e => validateProp(e[0], e[1], td.rcd)).map(joinKey) : [k];
+        if (td.cls)
+            return validate(prop, td.cls).flatMap(joinKey);
+        return [];
+    }
+    function takeAsArray(v) {
+        return Array.isArray(v) ? v : [v];
+    }
+    UType.takeAsArray = takeAsArray;
+})(UType || (exports.UType = UType = {}));

package/build/cjs/func/u.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJSTDate = getJSTDate;
+exports.delay = delay;
+exports.int2array = int2array;
+exports.array2map = array2map;
+exports.bitor = bitor;
+exports.retry = retry;
+const xjs_err_1 = require("../obj/xjs-err");
+const s_errCode = 10;
+function getJSTDate(d) {
+    return new Date((d ? d.getTime() : Date.now()) + 9 * 60 * 60 * 1000);
+}
+function delay(sec) {
+    return new Promise(resolve => setTimeout(resolve, 1000 * sec));
+}
+function int2array(size) {
+    const s = Number(size);
+    if (Number.isNaN(s))
+        throw new xjs_err_1.XjsErr(s_errCode, "size of the argument is not number.");
+    return Array.from(Array(s).keys());
+}
+function array2map(array, keyGen) {
+    const map = new Map();
+    for (const e of array) {
+        const k = keyGen(e);
+        if (map.has(k))
+            map.get(k).push(e);
+        else
+            map.set(k, [e]);
+    }
+    return map;
+}
+function bitor(...bit) {
+    return bit.reduce((a, b) => a | b);
+}
+;
+;
+;
+function retry(cb, op) {
+    const l = op?.logger ?? console;
+    const initialCount = op?.count ?? 1;
+    const handleError = (e) => {
+        if (op?.errorCriterion && !op.errorCriterion(e))
+            return false;
+        l.warn(e);
+        return true;
+    };
+    const prcs = (c) => {
+        if (c < 0)
+            throw new xjs_err_1.XjsErr(s_errCode, "failure exceeds retryable count.");
+        let ret = null;
+        const innerPrcs = () => {
+            try {
+                ret = cb();
+            }
+            catch (e) {
+                if (handleError(e))
+                    ret = prcs(c - 1);
+                else
+                    throw e;
+            }
+            if (ret instanceof Promise) {
+                return new Promise((resolve, reject) => ret.then(resolve).catch((e) => { if (handleError(e))
+                    resolve(prcs(c - 1));
+                else
+                    reject(e); }));
+            }
+            else
+                return ret;
+        };
+        const chain = (c) => ret instanceof Promise ? ret.then(() => c()) : c();
+        if (c < initialCount) {
+            if (op?.intervalPredicate)
+                ret = op?.intervalPredicate();
+            const intervalSec = op?.intervalSec;
+            if (intervalSec)
+                ret = chain(() => delay(intervalSec));
+        }
+        return chain(innerPrcs);
+    };
+    return prcs(initialCount);
+}

package/build/cjs/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DType = void 0;
+__exportStar(require("./const/types"), exports);
+__exportStar(require("./const/time-unit"), exports);
+__exportStar(require("./const/http-method"), exports);
+__exportStar(require("./func/u"), exports);
+__exportStar(require("./func/u-obj"), exports);
+__exportStar(require("./func/u-string"), exports);
+__exportStar(require("./func/u-array"), exports);
+__exportStar(require("./func/u-http"), exports);
+__exportStar(require("./func/u-type"), exports);
+__exportStar(require("./func/decorator/transaction"), exports);
+var d_type_1 = require("./func/decorator/d-type");
+Object.defineProperty(exports, "DType", { enumerable: true, get: function () { return d_type_1.DType; } });
+__exportStar(require("./obj/xjs-err"), exports);

package/build/cjs/obj/xjs-err.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XjsErr = void 0;
+class XjsErr extends Error {
+    code;
+    origin;
+    constructor(code, msg, origin) {
+        super(`[XJS] ${msg}`);
+        this.code = code;
+        this.origin = origin;
+    }
+}
+exports.XjsErr = XjsErr;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xjs-common",
-  "version": "13.0.0-alpha.2",
+  "version": "13.0.0-alpha.3",
   "description": "library modules for typescript that bundled general-purpose implementations.",
   "repository": {
     "type": "git",
@@ -12,22 +12,28 @@
     "utility"
   ],
   "scripts": {
-    "build": "rm -rdf ./build && tsc",
+    "build": "rm -rdf ./build && tsc && tsc -p ./tsconfig.cjs.json",
     "test": "tsx ./src/test/test.ts"
   },
   "author": "begyyal",
   "license": "Apache-2.0",
   "files": [
     "build",
-    "!/build/test*"
+    "!/build/**/test*"
   ],
-  "main": "./build/index",
-  "types": "./build/index.d.ts",
+  "main": "./build/esm/index.js",
+  "types": "./build/esm/index.d.ts",
   "exports": {
-    ".": [
-      "./build/index.js",
-      "./build/index.d.ts"
-    ]
+    ".": {
+      "import": {
+        "types": "./build/esm/index.ts",
+        "default": "./build/esm/index.js"
+      },
+      "require": {
+        "types": "./build/esm/index.ts",
+        "default": "./build/cjs/index.js"
+      }
+    }
   },
   "devDependencies": {
     "@types/node": "^24.2.1",