xjs-node 1.0.0

package/dist/func/u-array.d.ts

@@ -0,0 +1,40 @@
+export declare namespace UArray {
+    /**
+     * compares two arrays to valuate equality.
+     * if one side is null or undefined, it returns true when other side is the same.
+     * @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 it uses `===` operator for compareing elements if true, otherwise using `==` operator. default is true.
+     */
+    function eq(v1: any[], v2: any[], op: {
+        sort?: boolean;
+        useStrictEqual: false;
+    }): boolean;
+    function eq<T>(v1: T[], v2: T[], op: {
+        sort?: boolean;
+        useStrictEqual: true;
+    }): boolean;
+    function eq<T>(v1: T[], v2: T[], op: {
+        sort?: boolean;
+    }): boolean;
+    function eq<T>(v1: T[], v2: T[]): boolean;
+    /**
+     * returns array which is removed duplicate of elements.
+     * this doesn't mutate the param.
+     */
+    function distinct<T>(array: T[]): T[];
+    function distinct<T>(array: T[], op: {
+        k: keyof T;
+        takeLast?: boolean;
+    }): T[];
+    function distinct<T>(array: T[], op: {
+        predicate: (v1: T, v2: T) => boolean;
+        takeLast?: boolean;
+    }): T[];
+    function chop<T>(array: T[], len: number): T[][];
+    function remove<T>(array: T[], v: T): void;
+    function randomPick<T>(array: T[], takeout?: boolean): T;
+    function shuffle<T>(array: T[]): T[];
+    function takeOut<T>(array: T[], filter: (v: T, i?: number) => boolean): T[];
+}

package/dist/func/u-array.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UArray = void 0;
+const u_1 = require("./u");
+var UArray;
+(function (UArray) {
+    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;
+        const a = sort ? [...v1].sort() : v1, b = sort ? [...v2].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 || (exports.UArray = {}));

package/dist/func/u-file.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="node" />
+import { MaybeArray } from "xjs-common";
+interface FileStatus {
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isSymbolicLink(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+}
+export declare namespace UFile {
+    function mkdir(p: MaybeArray<string>): boolean;
+    function write(p: MaybeArray<string>, c: string): void;
+    /**
+     * remove a file. no error if the file to be removed doesn't exist.
+     */
+    function rm(p: MaybeArray<string>): void;
+    function exists(p: MaybeArray<string>): boolean;
+    /**
+     * return a file status. if the file of the status doesn't exist, this returns `null`.
+     */
+    function status(p: MaybeArray<string>): FileStatus;
+    function read(p: MaybeArray<string>): Buffer;
+    function read(p: MaybeArray<string>, encoding: BufferEncoding): string;
+    function cp(from: MaybeArray<string>, to: MaybeArray<string>): void;
+    function mv(from: MaybeArray<string>, to: MaybeArray<string>): void;
+    function ls(p: MaybeArray<string>): string[];
+    /**
+     * check availability to export a file with specified directory and file name.
+     * if it doesn't, retry to check after appending incremental number (e.g. `.1`) to the filename.
+     * @param dir destination directory path.
+     * @param fname file name wanna export to.
+     * @returns exportable file path.
+     */
+    function reserveFilePath(dir: MaybeArray<string>, fname: string): string;
+    /**
+     * decompress zip file. this depends on os enviroment due to using the os command.
+     * currently this supports only windows (installed `tar` or `unzip` in gnu compiler) and linux systems (installed `unzip`).
+     * @param zipPath zip file to be unzipped.
+     * @param destDir directory that the decompress files export to.
+     */
+    function unzip(zipPath: MaybeArray<string>, destDir?: MaybeArray<string>): void;
+}
+export {};

package/dist/func/u-file.js

@@ -0,0 +1,161 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UFile = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const xjs_common_1 = require("xjs-common");
+const u_1 = require("./u");
+const s_errCode = 1040;
+var UFile;
+(function (UFile) {
+    function mkdir(p) {
+        const dirPath = (0, u_1.joinPath)(p);
+        const e = fs.existsSync(dirPath);
+        if (!e)
+            fs.mkdirSync(dirPath, { recursive: true });
+        else if (!fs.statSync(dirPath).isDirectory())
+            throw new xjs_common_1.XjsErr(s_errCode, "Already exists a file (not directory) on the path.");
+        return !e;
+    }
+    UFile.mkdir = mkdir;
+    function write(p, c) {
+        fs.writeFileSync((0, u_1.joinPath)(p), c);
+    }
+    UFile.write = write;
+    /**
+     * remove a file. no error if the file to be removed doesn't exist.
+     */
+    function rm(p) {
+        const pt = (0, u_1.joinPath)(p);
+        if (fs.existsSync(pt))
+            fs.rmSync(pt, { recursive: true });
+    }
+    UFile.rm = rm;
+    function exists(p) {
+        return !!p && fs.existsSync((0, u_1.joinPath)(p));
+    }
+    UFile.exists = exists;
+    /**
+     * return a file status. if the file of the status doesn't exist, this returns `null`.
+     */
+    function status(p) {
+        const pt = (0, u_1.joinPath)(p);
+        return fs.existsSync(pt) ? fs.statSync(pt) : null;
+    }
+    UFile.status = status;
+    function read(p, encoding) {
+        const f = (0, u_1.joinPath)(p);
+        if (!fs.existsSync(f))
+            throw new xjs_common_1.XjsErr(s_errCode, `No file found => ${f}`);
+        return fs.readFileSync(f, encoding);
+    }
+    UFile.read = read;
+    function cp(from, to) {
+        const f = (0, u_1.joinPath)(from), t = (0, u_1.joinPath)(to);
+        if (!fs.existsSync(f))
+            throw new xjs_common_1.XjsErr(s_errCode, `No file found => ${f}`);
+        fs.copyFileSync(f, t);
+    }
+    UFile.cp = cp;
+    function mv(from, to) {
+        const f = (0, u_1.joinPath)(from), t = (0, u_1.joinPath)(to);
+        if (!fs.existsSync(f))
+            throw new xjs_common_1.XjsErr(s_errCode, `No file found => ${f}`);
+        fs.renameSync(f, t);
+    }
+    UFile.mv = mv;
+    function ls(p) {
+        const pt = (0, u_1.joinPath)(p);
+        if (!pt || !fs.statSync(pt).isDirectory())
+            throw new xjs_common_1.XjsErr(s_errCode, "Specified path for ls is not directory.");
+        return fs.readdirSync(pt);
+    }
+    UFile.ls = ls;
+    /**
+     * check availability to export a file with specified directory and file name.
+     * if it doesn't, retry to check after appending incremental number (e.g. `.1`) to the filename.
+     * @param dir destination directory path.
+     * @param fname file name wanna export to.
+     * @returns exportable file path.
+     */
+    function reserveFilePath(dir, fname) {
+        const pt = (0, u_1.joinPath)(dir);
+        if (!pt || !fs.statSync(pt).isDirectory())
+            throw new xjs_common_1.XjsErr(s_errCode, "Specified directory path is not directory.");
+        if (!fname || fname.match(/[\\/:*?"<>|]/))
+            throw new xjs_common_1.XjsErr(s_errCode, "Specified filename is invalid due to empty or including disallowed characters.");
+        let dest = (0, u_1.joinPath)(pt, fname), i = 1;
+        while (fs.existsSync(dest))
+            dest = (0, u_1.joinPath)(pt, `${fname}.${i++}`);
+        return dest;
+    }
+    UFile.reserveFilePath = reserveFilePath;
+    /**
+     * decompress zip file. this depends on os enviroment due to using the os command.
+     * currently this supports only windows (installed `tar` or `unzip` in gnu compiler) and linux systems (installed `unzip`).
+     * @param zipPath zip file to be unzipped.
+     * @param destDir directory that the decompress files export to.
+     */
+    function unzip(zipPath, destDir) {
+        if (!exists(zipPath))
+            throw new xjs_common_1.XjsErr(s_errCode, "There is no file on the zip path.");
+        if (!!destDir && !exists(destDir))
+            throw new xjs_common_1.XjsErr(s_errCode, "The destination directory is not found.");
+        let cmd = "unzip", options = null, availableCmd = true;
+        if (destDir)
+            options = `-d "${destDir}"`;
+        const check = () => { try {
+            (0, child_process_1.execSync)(`${cmd} --help`, { stdio: "ignore" });
+        }
+        catch {
+            availableCmd = false;
+        } };
+        check();
+        if (process.platform === "win32") {
+            if (!availableCmd) {
+                cmd = "tar";
+                options = "-xf";
+                availableCmd = true;
+                if (destDir)
+                    options = `-C "${destDir}" ${options}`;
+                check();
+            }
+        }
+        else if (process.platform === "linux") {
+        }
+        else
+            throw new xjs_common_1.XjsErr(s_errCode, "The os running on is not supported for xjs unzip.");
+        if (!availableCmd)
+            throw new xjs_common_1.XjsErr(s_errCode, `"${cmd}" command is not installed.`);
+        try {
+            (0, child_process_1.execSync)([cmd, options, `"${zipPath}"`].filter(e => e).join(" "), { stdio: "ignore" });
+        }
+        catch (e) {
+            throw new xjs_common_1.XjsErr(s_errCode, "Something went wrong at unzip.", e);
+        }
+    }
+    UFile.unzip = unzip;
+})(UFile = exports.UFile || (exports.UFile = {}));

package/dist/func/u-http.d.ts

@@ -0,0 +1,7 @@
+export declare namespace UHttp {
+    function isHttpSuccess(statusCode: number): boolean;
+    function statusCategoryOf(statusCode: number): number;
+    function concatParamsWithEncoding(end: string, params: {
+        [k: string]: string | string[];
+    }): string;
+}

package/dist/func/u-http.js

@@ -0,0 +1,25 @@
+"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;
+})(UHttp = exports.UHttp || (exports.UHttp = {}));

package/dist/func/u-obj.d.ts

@@ -0,0 +1,18 @@
+import { NormalRecord } from "../const/types";
+export declare namespace 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 extends NormalRecord, S extends NormalRecord>(t: T, s: S, keys?: (keyof S)[], keepDtypeClass?: boolean): T & Partial<S>;
+    /**
+     * crop properties of the object. the properties is removed with `delete` operator.
+     * @param o object which properties is removed.
+     * @param keys property names to be remained. if omit this, it removes the properties other than properties decorated {@link DType}.
+     * @param exclusive if true, it removes `keys` instead of remaining it.
+     */
+    function crop<T extends NormalRecord>(o: T, keys?: (keyof T)[], exclusive?: boolean): Partial<T>;
+}

package/dist/func/u-obj.js

@@ -0,0 +1,44 @@
+"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;
+    /**
+     * crop properties of the object. the properties is removed with `delete` operator.
+     * @param o object which properties is removed.
+     * @param keys property names to be remained. if omit this, it removes the properties other than properties decorated {@link DType}.
+     * @param exclusive if true, it removes `keys` instead of remaining it.
+     */
+    function crop(o, keys, exclusive) {
+        if (!keys && !o[d_type_1.smbl_tm])
+            return {};
+        const _keys = keys ?? Object.keys(o[d_type_1.smbl_tm]);
+        Object.keys(o).filter(k => {
+            if (!keys && o[d_type_1.smbl_tm]?.[k]?.rec && o[k])
+                crop(o[k]);
+            return !!exclusive === _keys.includes(k);
+        }).forEach(k => delete o[k]);
+        return o;
+    }
+    UObj.crop = crop;
+})(UObj = exports.UObj || (exports.UObj = {}));

package/dist/func/u-string.d.ts

@@ -0,0 +1,24 @@
+import { TimeUnit } from "../const/time-unit";
+export declare namespace UString {
+    function eq(s1: string, s2: string): boolean;
+    /**
+     * 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?: {
+        date?: Date;
+        unit?: TimeUnit;
+    }): string;
+    function trimProps(obj: any): void;
+    function generateRandomString(len: number): string;
+    function idx2az(idx: number): string;
+    function az2idx(az: string): number;
+    function is_yyyy(v: string): boolean;
+    function is_yyyyMM(v: string): boolean;
+    function is_yyyyMMdd(v: string): boolean;
+    function is_yyyyMMddhh(v: string): boolean;
+    function is_yyyyMMddhhmm(v: string): boolean;
+    function is_yyyyMMddhhmmss(v: string): boolean;
+}

package/dist/func/u-string.js

@@ -0,0 +1,86 @@
+"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;
+    /**
+     * 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 trimProps(obj) {
+        Object.keys(obj)
+            .filter(k => typeof obj[k] === "string")
+            .forEach(k => obj[k] = obj[k]?.trim());
+    }
+    UString.trimProps = trimProps;
+    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 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 || (exports.UString = {}));

package/dist/func/u-type.d.ts

@@ -0,0 +1,25 @@
+import { MaybeArray, Type } from "../const/types";
+export declare namespace UType {
+    function isDefined(v: any): boolean;
+    function isEmpty(v: any): boolean;
+    function isString(v: any): v is string;
+    function isNumber(v: any): v is number;
+    function isBigint(v: any): v is bigint;
+    function isBoolean(v: any): v is boolean;
+    function isSymbol(v: any): v is symbol;
+    function isObject(v: any): v is object;
+    function isArray(v: any, t: Type.string): v is string[];
+    function isArray(v: any, t: Type.number): v is number[];
+    function isArray(v: any, t: Type.bigint): v is bigint[];
+    function isArray(v: any, t: Type.boolean): v is boolean[];
+    function isArray(v: any, t: Type.symbol): v is symbol[];
+    function isArray(v: any, t: Type.object): v is object[];
+    function isArray(v: any): v is any[];
+    /**
+     * validate properties which attached decorators in {@link DType}.
+     * @param o object to be validated.
+     * @returns invalid property keys. returns an empty array if `o` is valid.
+     */
+    function validate(o: any): string[];
+    function takeAsArray<T>(v: MaybeArray<T>): T[];
+}

package/dist/func/u-type.js

@@ -0,0 +1,58 @@
+"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 isArray(v, t) {
+        return Array.isArray(v) && (!t || v.every(e => typeof e === t));
+    }
+    UType.isArray = isArray;
+    /**
+     * validate properties which attached decorators in {@link DType}.
+     * @param o object to be validated.
+     * @returns invalid property keys. returns an empty array if `o` is valid.
+     */
+    function validate(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];
+        if (td.ary)
+            return Array.isArray(prop) ? prop.flatMap(e => validateProp(k, e, td.ary)) : [k];
+        if (td.rec)
+            return validate(prop).flatMap(k2 => `${k}.${k2}`);
+        return [];
+    }
+    function takeAsArray(v) {
+        return Array.isArray(v) ? v : [v];
+    }
+    UType.takeAsArray = takeAsArray;
+})(UType = exports.UType || (exports.UType = {}));

package/dist/func/u.d.ts

@@ -0,0 +1,3 @@
+import { MaybeArray } from "xjs-common";
+export declare function checkPortAvailability(port: number): Promise<boolean>;
+export declare function joinPath(...p: MaybeArray<string>[]): string;

package/dist/func/u.js

@@ -0,0 +1,42 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.joinPath = exports.checkPortAvailability = void 0;
+const path = __importStar(require("path"));
+const xjs_common_1 = require("xjs-common");
+const s_errCode = 1010;
+function checkPortAvailability(port) {
+    return new Promise(resolve => {
+        const server = require('net').createServer();
+        server.once('error', () => resolve(false))
+            .once('listening', () => { server.close(); resolve(true); })
+            .listen(port);
+    });
+}
+exports.checkPortAvailability = checkPortAvailability;
+function joinPath(...p) {
+    return path.join(...p.flatMap(xjs_common_1.UType.takeAsArray));
+}
+exports.joinPath = joinPath;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./func/u";
+export * from "./func/u-file";
+export { HttpResolver } from "./prcs/http/http-resolver";
+export { s_clientMode } from "./prcs/http/http-resolver-context";
+export { IHttpClient } from "./prcs/http/i-http-client";