xjs-common 8.1.0 → 8.3.0

package/README.md

@@ -13,7 +13,7 @@ npm i xjs-common
 # Code example (only part)
  - Miscellaneous utilities.
 ```ts
-import { checkPortAvailability, delay, int2array, UFile, UHttp } from "xjs-common";
+import { checkPortAvailability, delay, int2array, UFile, UHttp, retry } from "xjs-common";
 
 (async () => {
     // await 3 seconds.
@@ -33,13 +33,12 @@ import { checkPortAvailability, delay, int2array, UFile, UHttp } from "xjs-commo
     // p1=a&p2=1&p2=2
     console.log(UHttp.concatParamsWithEncoding(null, { p1: "a", p2: ["1", "2"] }));
 
+    // runs callback with customizable retry.
+    retry(async () => { }, { count: 2 });
+
     // concatenate file path and make directory if doesn't already exist.
     UFile.mkdir("path/to/dir");
     UFile.mkdir(["path", "to", "dir"]);
-
-    // ignore if f1 is not file or doesn't exist.
-    UFile.mv("path/to/f1", "path/to/f2");
-    UFile.mv(["path", "to", "f1"], ["path", "to", "f2"]);
 })();
 ```
  - Array utilities.
@@ -76,8 +75,6 @@ import { UArray } from "xjs-common";
 import { UString } from "xjs-common";
 
 (() => {
-    // true
-    console.log(UString.eq("", "   "));
     // false
     console.log(UString.eq("", null));
     // true
@@ -91,9 +88,10 @@ import { UString } from "xjs-common";
     // AA
     console.log(UString.idx2az(26));
 
-    // e.g. 20250310
-    console.log(UString.simpleDate2day());
-    console.log(UString.simpleDate2day(new Date()));
+    // e.g. 20250615053513
+    console.log(UString.simpleTime());
+    // e.g. 20250615
+    console.log(UString.simpleTime({ date: getJSTDate(), unit: TimeUnit.Day }));
 })();
 ```
  - Http client enhanced for web scraping.
@@ -215,6 +213,7 @@ XJS throws error with `code` property which has one of the following numbers.
 |10|`func/u`|
 |20|`func/u-string`|
 |30|`func/u-type` (include `func/decorator/d-type`) |
+|40|`func/u-file` |
 |100|`func/decorator/transaction`|
 |200|`prcs/http/http-resolver`|
 

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

@@ -5,7 +5,7 @@ export declare namespace UArray {
      * @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.
+     * @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;

package/dist/func/u-array.js

@@ -21,7 +21,7 @@ var UArray;
             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 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));

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

@@ -3,9 +3,11 @@ import { MaybeArray } from "../const/types";
 export declare namespace UFile {
     function mkdir(p: MaybeArray<string>): boolean;
     function write(p: MaybeArray<string>, c: string): void;
-    function exists(...p: string[]): boolean;
+    function rm(p: MaybeArray<string>): void;
+    function exists(p: MaybeArray<string>): boolean;
     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 joinPath(p: MaybeArray<string>): string;
 }

package/dist/func/u-file.js

@@ -27,43 +27,55 @@ exports.UFile = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const u_type_1 = require("./u-type");
+const xjs_err_1 = require("../obj/xjs-err");
+const s_errCode = 40;
 var UFile;
 (function (UFile) {
     function mkdir(p) {
-        const dirPath = join(p);
+        const dirPath = joinPath(p);
         const e = fs.existsSync(dirPath);
-        if (!e || !fs.statSync(dirPath).isDirectory())
+        if (!e)
             fs.mkdirSync(dirPath, { recursive: true });
+        else if (!fs.statSync(dirPath).isDirectory())
+            throw new xjs_err_1.XjsErr(s_errCode, "Already exists a file (not directory) on the path.");
         return !e;
     }
     UFile.mkdir = mkdir;
     function write(p, c) {
-        fs.writeFileSync(join(p), c);
+        fs.writeFileSync(joinPath(p), c);
     }
     UFile.write = write;
-    function exists(...p) {
-        return !!p && fs.existsSync(path.join(...p));
+    function rm(p) {
+        fs.rmSync(joinPath(p), { recursive: true });
+    }
+    UFile.rm = rm;
+    function exists(p) {
+        return fs.existsSync(joinPath(p));
     }
     UFile.exists = exists;
     function read(p, encoding) {
-        return fs.readFileSync(join(p), encoding);
+        const f = joinPath(p);
+        if (!fs.existsSync(f))
+            throw new xjs_err_1.XjsErr(s_errCode, `No file found => ${f}`);
+        return fs.readFileSync(f, encoding);
     }
     UFile.read = read;
     function cp(from, to) {
-        const f = join(from), t = join(to);
-        if (fs.existsSync(f))
-            fs.writeFileSync(t, fs.readFileSync(f));
+        const f = joinPath(from), t = joinPath(to);
+        if (!fs.existsSync(f))
+            throw new xjs_err_1.XjsErr(s_errCode, `No file found => ${f}`);
+        fs.copyFileSync(f, t);
     }
     UFile.cp = cp;
     function mv(from, to) {
-        const f = join(from), t = join(to);
-        if (fs.existsSync(f) && fs.statSync(f).isFile()) {
-            fs.writeFileSync(t, fs.readFileSync(f));
-            fs.rmSync(f, { force: true });
-        }
+        const f = joinPath(from), t = joinPath(to);
+        if (!fs.existsSync(f))
+            throw new xjs_err_1.XjsErr(s_errCode, `No file found => ${f}`);
+        fs.renameSync(f, t);
     }
     UFile.mv = mv;
-    function join(p) {
+    function joinPath(p) {
         return u_type_1.UType.isString(p) ? p : path.join(...p);
     }
+    UFile.joinPath = joinPath;
 })(UFile = exports.UFile || (exports.UFile = {}));

package/dist/func/u.d.ts

@@ -1,6 +1,26 @@
+import { Loggable } from "../const/types";
 export declare function getJSTDate(d?: Date): Date;
 export declare function delay(sec: number): Promise<void>;
 export declare function int2array(size: number): number[];
 export declare function array2map<K, T>(array: T[], keyGen: (e: T) => K): Map<K, T[]>;
 export declare function bitor(...bit: number[]): number;
 export declare function checkPortAvailability(port: number): Promise<boolean>;
+interface RetryOption<T = void | Promise<void>> {
+    count?: number;
+    logger?: Loggable;
+    errorCriterion?: (e: any) => boolean;
+    intervalPredicate?: () => T;
+}
+/**
+ * runs callback with customizable retry.
+ * @param cb callback to be retried.
+ * @param op.count number of retries. default is 1.
+ * @param op.logger logger used for exceptions while retrying the process. default is `console` object.
+ * @param op.errorCriterion distinguish whether retry is required form exceptions. default is none. (i.e. allways required.)
+ * @param op.intervalPredicate predicate that runs between callbacks when retrying.
+ */
+export declare function retry<T>(cb: () => T, op?: RetryOption<void>): T;
+export declare function retry<T>(cb: () => T, op?: RetryOption<Promise<void>>): Promise<T>;
+export declare function retry<T>(cb: () => Promise<T>, op?: RetryOption<void>): Promise<T>;
+export declare function retry<T>(cb: () => Promise<T>, op?: RetryOption<Promise<void>>): Promise<T>;
+export {};

package/dist/func/u.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkPortAvailability = exports.bitor = exports.array2map = exports.int2array = exports.delay = exports.getJSTDate = void 0;
+exports.retry = exports.checkPortAvailability = exports.bitor = exports.array2map = exports.int2array = exports.delay = exports.getJSTDate = void 0;
 const xjs_err_1 = require("../obj/xjs-err");
 const s_errCode = 10;
 function getJSTDate(d) {
@@ -43,3 +43,43 @@ function checkPortAvailability(port) {
     });
 }
 exports.checkPortAvailability = checkPortAvailability;
+;
+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;
+        };
+        if (c < initialCount && op?.intervalPredicate)
+            ret = op?.intervalPredicate();
+        return ret instanceof Promise ? ret.then(() => innerPrcs()) : innerPrcs();
+    };
+    return prcs(initialCount);
+}
+exports.retry = retry;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xjs-common",
-  "version": "8.1.0",
+  "version": "8.3.0",
   "description": "library modules for nodejs + typescript that bundled general-purpose implementations.",
   "repository": {
     "type": "git",