jopi-toolkit 3.0.15 → 3.1.22

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.0.15",
+  "version": "3.1.22",
   "name": "jopi-toolkit",
   "license": "MIT",
   "homepage": "https://github.com/johanpiquet/jopi-toolkit",
@@ -17,96 +17,104 @@
     "src"
   ],
   "scripts": {
-    "build:priority:1": "npx tsc",
-    "clean": "rm -rf ./dist .turbo tsconfig.tsbuildinfo",
-    "tsc": "tsc",
-    "bun-publish": "npx tsc && bun publish",
-    "untrack": "git rm -r --cached -- ./dist/**;",
     "jopiLink": "npx jopi-mono link-add",
-    "dev:tsc": "npx tsc --watch"
+    "bunLink": "bun link",
+    "dev:build": "tsc",
+    "dev:tsc-watch": "tsc --watch",
+    "dev:tsc-check": "tsc --noEmit"
   },
-  "devDependencies": {
+  "dependencies": {
     "@types/adm-zip": "^0.5.7",
     "@types/bun": "latest",
     "@types/mime-types": "latest",
-    "@types/node": "latest"
-  },
-  "dependencies": {
+    "@types/node": "latest",
     "@types/ws": "^8.18.1",
     "adm-zip": "^0.5.9",
     "mime-types": "^3.0.1",
     "ws": "^8.18.3"
   },
-  "publishedDate": "12/11/2025",
-  "publicPublishedDate": "12/11/2025",
+  "publishedDate": "1/12/2026",
+  "publicPublishedDate": "1/12/2026",
   "exports": {
     "./jk_schema": {
+      "types": "./src/jk_schemas/index.ts",
       "bun": "./src/jk_schemas/index.ts",
       "default": "./dist/jk_schemas/index.js"
     },
     "./jk_tools": {
+      "types": "./src/jk_tools/index.ts",
       "bun": "./src/jk_tools/index.ts",
       "default": "./dist/jk_tools/index.js"
     },
-    "./jk_translate": {
-      "bun": "./src/jk_translate/index.ts",
-      "default": "./dist/jk_translate/index.js"
-    },
     "./jk_process": {
+      "types": "./src/jk_process/index.ts",
       "bun": "./src/jk_process/index.ts",
       "default": "./dist/jk_process/index.js"
     },
     "./jk_data": {
+      "types": "./src/jk_data/index.ts",
       "bun": "./src/jk_data/index.ts",
       "default": "./dist/jk_data/index.js"
     },
     "./jk_what": {
+      "types": "./src/jk_what/index.ts",
       "bun": "./src/jk_what/index.ts",
       "default": "./dist/jk_what/index.js"
     },
     "./jk_os": {
+      "types": "./src/jk_os/index.ts",
       "bun": "./src/jk_os/index.ts",
       "default": "./dist/jk_os/index.js"
     },
     "./jk_crypto": {
+      "types": "./src/jk_crypto/index.ts",
       "bun": "./src/jk_crypto/index.ts",
       "default": "./dist/jk_crypto/index.js"
     },
     "./jk_thread": {
+      "types": "./src/jk_thread/index.ts",
       "bun": "./src/jk_thread/index.ts",
       "default": "./dist/jk_thread/index.js"
     },
     "./jk_events": {
+      "types": "./src/jk_events/index.ts",
       "bun": "./src/jk_events/index.ts",
       "default": "./dist/jk_events/index.js"
     },
     "./jk_fs": {
+      "types": "./src/jk_fs/index.ts",
       "bun": "./src/jk_fs/index.ts",
       "default": "./dist/jk_fs/index.js"
     },
     "./jk_timer": {
+      "types": "./src/jk_timer/index.ts",
       "bun": "./src/jk_timer/index.ts",
       "default": "./dist/jk_timer/index.js"
     },
     "./jk_term": {
+      "types": "./src/jk_term/index.ts",
       "bun": "./src/jk_term/index.ts",
       "default": "./dist/jk_term/index.js"
     },
     "./jk_app": {
+      "types": "./src/jk_app/index.ts",
       "bun": "./src/jk_app/index.ts",
       "default": "./dist/jk_app/index.js"
     },
     "./jk_compress": {
+      "types": "./src/jk_compress/index.ts",
       "bun": "./src/jk_compress/index.ts",
       "default": "./dist/jk_compress/index.js"
     },
     "./jk_webSocket": {
+      "types": "./src/jk_webSocket/index.ts",
       "bun": "./src/jk_webSocket/index.ts",
       "default": "./dist/jk_webSocket/index.js"
     },
     "./jk_logs": {
+      "types": "./src/jk_logs/index.ts",
       "bun": "./src/jk_logs/index.ts",
       "default": "./dist/jk_logs/index.js"
     }
   }
-}
+}

package/src/jk_app/common.js

@@ -258,31 +258,47 @@ var gIsExited = false;
 var gTempDir;
 //endregion
 //region Resolving
-export function findNodePackageDir(packageName, useLinuxPathFormat) {
-    if (useLinuxPathFormat === void 0) { useLinuxPathFormat = true; }
-    var currentDir = jk_fs.dirname(findPackageJson());
-    while (true) {
-        var packagePath = jk_fs.join(currentDir, 'node_modules', packageName);
-        if (jk_fs.isDirectorySync(packagePath)) {
-            if (useLinuxPathFormat)
-                return jk_fs.win32ToLinuxPath(packagePath);
-            return packagePath;
-        }
-        var parentDir = jk_fs.dirname(currentDir);
-        // Reached root directory
-        if (parentDir === currentDir) {
-            break;
-        }
-        currentDir = parentDir;
-    }
-    return undefined;
+export function findNodePackageDir(packageName_1) {
+    return __awaiter(this, arguments, void 0, function (packageName, searchFromDir) {
+        var currentDir, packagePath, parentDir;
+        if (searchFromDir === void 0) { searchFromDir = getCodeSourceDirHint(); }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    currentDir = jk_fs.resolve(searchFromDir);
+                    _a.label = 1;
+                case 1:
+                    if (!true) return [3 /*break*/, 3];
+                    packagePath = jk_fs.join(currentDir, 'node_modules', packageName);
+                    return [4 /*yield*/, jk_fs.isDirectory(packagePath)];
+                case 2:
+                    if (_a.sent())
+                        return [2 /*return*/, packagePath];
+                    parentDir = jk_fs.dirname(currentDir);
+                    if (parentDir === currentDir)
+                        return [3 /*break*/, 3];
+                    currentDir = parentDir;
+                    return [3 /*break*/, 1];
+                case 3: return [2 /*return*/, undefined];
+            }
+        });
+    });
 }
-export function requireNodePackageDir(packageName, useLinuxPathFormat) {
-    if (useLinuxPathFormat === void 0) { useLinuxPathFormat = true; }
-    var pkgDir = findNodePackageDir(packageName, useLinuxPathFormat);
-    if (!pkgDir)
-        throw new Error("Package '" + packageName + "' not found");
-    return pkgDir;
+export function requireNodePackageDir(packageName_1) {
+    return __awaiter(this, arguments, void 0, function (packageName, searchFromDir) {
+        var pkgDir;
+        if (searchFromDir === void 0) { searchFromDir = getCodeSourceDirHint(); }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, findNodePackageDir(packageName, searchFromDir)];
+                case 1:
+                    pkgDir = _a.sent();
+                    if (!pkgDir)
+                        throw new Error("Package '" + packageName + "' not found");
+                    return [2 /*return*/, pkgDir];
+            }
+        });
+    });
 }
 export function findPackageJsonDir(searchFromDir) {
     if (searchFromDir === void 0) { searchFromDir = getCodeSourceDirHint(); }

package/src/jk_app/common.ts

@@ -164,6 +164,10 @@ export function getTempDir(): string {
     return gTempDir;
 }
 
+export function setTempDir(dir: string) {
+    gTempDir = dir;
+}
+
 let gIsExited = false;
 let gTempDir: string|undefined;
 
@@ -171,43 +175,47 @@ let gTempDir: string|undefined;
 
 //region Resolving
 
-export function findNodePackageDir(packageName: string, useLinuxPathFormat: boolean = true): string|undefined {
-    let currentDir = jk_fs.dirname(findPackageJson());
+export async function findNodePackageDir(packageName: string, searchFromDir = getCodeSourceDirHint()): Promise<string | undefined> {
+    let currentDir = jk_fs.resolve(searchFromDir);
 
     while (true) {
-        const packagePath = jk_fs.join(currentDir, 'node_modules', packageName);
-
-        if (jk_fs.isDirectorySync(packagePath)) {
-            if (useLinuxPathFormat) return jk_fs.win32ToLinuxPath(packagePath);
-            return packagePath;
-        }
-
+        let packagePath = jk_fs.join(currentDir, 'node_modules', packageName);
+        if (await jk_fs.isDirectory(packagePath)) return packagePath;
         const parentDir = jk_fs.dirname(currentDir);
-
-        // Reached root directory
-        if (parentDir === currentDir) {
-            break;
-        }
-
+        if (parentDir === currentDir) break;
         currentDir = parentDir;
     }
 
     return undefined;
 }
 
-export function requireNodePackageDir(packageName: string, useLinuxPathFormat: boolean = true): string {
-    let pkgDir = findNodePackageDir(packageName, useLinuxPathFormat);
+export async function requireNodePackageDir(packageName: string, searchFromDir = getCodeSourceDirHint()): Promise<string> {
+    let pkgDir = await findNodePackageDir(packageName, searchFromDir);
     if (!pkgDir) throw new Error("Package '" + packageName + "' not found");
     return pkgDir;
 }
 
-export function findPackageJsonDir(searchFromDir = getCodeSourceDirHint()): string {
+export function findRequiredPackageJsonDir(searchFromDir = getCodeSourceDirHint()): string {
+    let pkgJsonPath = findRequiredPackageJson(searchFromDir);
+    return jk_fs.dirname(pkgJsonPath);
+}
+
+export function findPackageJsonDir(searchFromDir = getCodeSourceDirHint()): string|undefined {
     let pkgJsonPath = findPackageJson(searchFromDir);
+    if (!pkgJsonPath) return undefined;
     return jk_fs.dirname(pkgJsonPath);
 }
 
-export function findPackageJson(searchFromDir = getCodeSourceDirHint()): string {
-    if (!searchFromDir && (gPackageJsonPath!==undefined)) return gPackageJsonPath;
+export function findRequiredPackageJson(searchFromDir = getCodeSourceDirHint()): string {
+    let res = findPackageJson(searchFromDir);
+    if (!res) throw new Error("No package.json found.");
+    return res;
+}
+
+export function findPackageJson(searchFromDir = getCodeSourceDirHint()): string|undefined {
+    if (!searchFromDir && (gPackageJsonPath!==undefined)) {
+        return gPackageJsonPath;
+    }
 
     let currentDir = searchFromDir;
 
@@ -224,7 +232,7 @@ export function findPackageJson(searchFromDir = getCodeSourceDirHint()): string
         currentDir = parentDir;
     }
 
-    throw "No package.json found."
+    return undefined;
 }
 //
 let gPackageJsonPath: string|undefined;
@@ -246,7 +254,7 @@ export function getCodeSourceDirHint() {
 export function getSourceCodeDir(): string {
     if (gSourceCodeDir) return gSourceCodeDir;
 
-    let pkgJsonPath = findPackageJson();
+    let pkgJsonPath = findRequiredPackageJson();
     let dirName = jk_fs.join(jk_fs.dirname(pkgJsonPath), "src");
 
     if (jk_fs.isDirectorySync(dirName)) {
@@ -269,7 +277,7 @@ export function getCompiledCodeDir(): string {
         return gCompiledSourcesDir = sourceCodeDir;
     }
 
-    let pkgJsonPath = findPackageJson();
+    let pkgJsonPath = findRequiredPackageJson();
 
     let rootDir = jk_fs.dirname(pkgJsonPath);
 
@@ -283,7 +291,7 @@ export function getCompiledCodeDir(): string {
     return rootDir;
 }
 
-export function getCompiledFilePathFor(sourceFilePath: string): string {
+export function getCompiledFilePathFor(sourceFilePath: string, replaceExtension = true): string {
     const compiledCodeDir = getCompiledCodeDir();
     const sourceCodeDir = getSourceCodeDir();
 
@@ -293,9 +301,16 @@ export function getCompiledFilePathFor(sourceFilePath: string): string {
 
     let filePath = sourceFilePath.substring(sourceCodeDir.length);
 
-    if (isNodeJS && !filePath.endsWith(".js")) {
+    if (replaceExtension && !filePath.endsWith(".js")) {
         let idx = filePath.lastIndexOf(".");
-        if (idx !== -1) filePath = filePath.substring(0, idx) + ".js";
+        let ext = filePath.substring(idx);
+
+        // This avoid case where there is no extension but a punct in the name.
+        // Ex: importing "@/lib/jopijs.menu.getManager"
+        //
+        if ((ext === ".ts") || (ext === ".tsx")) {
+            filePath = filePath.substring(0, idx) + ".js";
+        }
     }
 
     return jk_fs.join(compiledCodeDir, filePath);

package/src/jk_data/index.js

@@ -34,21 +34,9 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-var JDataRowSource_UseArray = /** @class */ (function () {
-    function JDataRowSource_UseArray(schema, rows) {
-        this.schema = schema;
-        this.rows = rows;
-    }
-    JDataRowSource_UseArray.prototype.read = function (params) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, simpleRowArrayFilter(this.rows, params)];
-            });
-        });
-    };
-    return JDataRowSource_UseArray;
-}());
-export { JDataRowSource_UseArray };
+/**
+ * Filter the row content according to rules.
+ */
 export function simpleRowArrayFilter(rows, params) {
     // > Apply filter.
     if (params.filter) {
@@ -74,10 +62,9 @@ export function simpleRowArrayFilter(rows, params) {
     }
     // > Apply sorting.
     if (params.sorting && params.sorting.length) {
-        debugger;
         var sorting = params.sorting[0];
-        var sortField_1 = sorting.field;
-        var sortDir_1 = sorting.direction;
+        var sortField_1 = sorting.id;
+        var sortDesc_1 = sorting.desc;
         rows = rows.sort(function (a, b) {
             var av = a[sortField_1];
             var bv = b[sortField_1];
@@ -88,30 +75,81 @@ export function simpleRowArrayFilter(rows, params) {
             var avIsNumber = typeof av === "number";
             var bvIsNumber = typeof bv === "number";
             if (avIsNumber && bvIsNumber) {
-                if (sortDir_1 === "asc") {
-                    return av - bv;
+                if (sortDesc_1) {
+                    return bv - av;
                 }
                 else {
-                    return bv - av;
+                    return av - bv;
                 }
             }
             else {
                 var avStr = String(av);
                 var bvStr = String(bv);
-                if (sortDir_1 === "asc") {
-                    return avStr.localeCompare(bvStr);
+                if (sortDesc_1) {
+                    return bvStr.localeCompare(avStr);
                 }
                 else {
-                    return bvStr.localeCompare(avStr);
+                    return avStr.localeCompare(bvStr);
                 }
             }
         });
     }
     var totalWithoutPagination = rows.length;
-    rows = rows.slice(params.offset, params.offset + params.count);
-    return {
-        rows: rows,
-        total: totalWithoutPagination,
-        offset: params.offset
-    };
+    var offset = 0;
+    if (params.page) {
+        offset = params.page.pageIndex * params.page.pageSize;
+        rows = rows.slice(offset, offset + params.page.pageSize);
+    }
+    return { rows: rows, total: totalWithoutPagination, offset: offset };
 }
+var JTableDs_UseArray = /** @class */ (function () {
+    function JTableDs_UseArray(name, schema, rows) {
+        this.name = name;
+        this.schema = schema;
+        this.rows = rows;
+    }
+    JTableDs_UseArray.prototype.read = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, simpleRowArrayFilter(this.rows, params)];
+            });
+        });
+    };
+    return JTableDs_UseArray;
+}());
+export { JTableDs_UseArray };
+var JTableDs_HttpProxy = /** @class */ (function () {
+    function JTableDs_HttpProxy(name, url, schema) {
+        this.name = name;
+        this.url = url;
+        this.schema = schema;
+    }
+    JTableDs_HttpProxy.prototype.read = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var toSend, res, asJson;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        toSend = { dsName: this.name, read: params };
+                        return [4 /*yield*/, fetch(this.url, {
+                                method: "POST",
+                                headers: { "Content-Type": "application/json" },
+                                body: JSON.stringify(toSend)
+                            })];
+                    case 1:
+                        res = _a.sent();
+                        if (res.status !== 200) {
+                            throw new Error("Error while reading data source \"".concat(this.name, "\""));
+                        }
+                        return [4 /*yield*/, res.json()];
+                    case 2:
+                        asJson = _a.sent();
+                        return [2 /*return*/, asJson];
+                }
+            });
+        });
+    };
+    return JTableDs_HttpProxy;
+}());
+export { JTableDs_HttpProxy };
+//endregion

package/src/jk_data/index.ts

@@ -1,13 +1,10 @@
-import type {Schema} from "jopi-toolkit/jk_schema";
+import {type Schema} from "jopi-toolkit/jk_schema";
 
-export interface JFieldSorting {
-    field: string;
-    direction: "asc" | "desc";
-}
+//region Rows Arrays
 
-export interface JRowsFilter {
-    field?: string;
-    value: string;
+export interface JFieldSorting {
+    id: string;
+    desc: boolean;
 }
 
 export interface JFieldFilter {
@@ -27,39 +24,27 @@ export type JFieldConstraintType =
     | "$nin"   // Not in an array of values
     | "$like"  // Like search %endsWith or startsWith%
 
-export interface JRowArrayFilter {
-    offset: number;
-    count: number;
-
-    filter?: JRowsFilter;
-    sorting?: JFieldSorting[];
-    fieldFilters?: Record<string, JFieldFilter[]>;
-}
-
-export interface JDataRowSource_ReadParams extends JRowArrayFilter {
-}
-
-export interface JDataRowSource_ReadResult {
-    rows: any[];
-    total?: number;
-    offset?: number;
+export interface JRowsFilter {
+    field?: string;
+    value: string;
 }
 
-export interface JDataRowSource {
-    get schema(): Schema;
-    read(params: JDataRowSource_ReadParams): Promise<JDataRowSource_ReadResult>;
+export interface JPageExtraction {
+    pageIndex: number;
+    pageSize: number;
 }
 
-export class JDataRowSource_UseArray implements JDataRowSource {
-    public constructor(public readonly schema: Schema, private readonly rows: any[]) {
-    }
-
-    async read(params: JDataRowSource_ReadParams): Promise<JDataRowSource_ReadResult> {
-        return simpleRowArrayFilter(this.rows, params);
-    }
+export interface JRowArrayFilter {
+    page?: JPageExtraction;
+    filter?: JRowsFilter;
+    sorting?: JFieldSorting[];
+    fieldFilters?: Record<string, JFieldFilter[]>;
 }
 
-export function simpleRowArrayFilter(rows: any[], params: JRowArrayFilter): JDataRowSource_ReadResult {
+/**
+ * Filter the row content according to rules.
+ */
+export function simpleRowArrayFilter(rows: any[], params: JRowArrayFilter): JTableDs_ReadResult {
     // > Apply filter.
 
     if (params.filter) {
@@ -84,10 +69,9 @@ export function simpleRowArrayFilter(rows: any[], params: JRowArrayFilter): JDat
     // > Apply sorting.
 
     if (params.sorting && params.sorting.length) {
-        debugger;
         const sorting = params.sorting[0];
-        const sortField = sorting.field;
-        const sortDir = sorting.direction;
+        const sortField = sorting.id;
+        const sortDesc = sorting.desc;
 
         rows = rows.sort((a, b) => {
             let av = a[sortField];
@@ -100,30 +84,83 @@ export function simpleRowArrayFilter(rows: any[], params: JRowArrayFilter): JDat
             const bvIsNumber = typeof bv === "number";
 
             if (avIsNumber && bvIsNumber) {
-                if (sortDir === "asc") {
-                    return av - bv;
-                } else {
+                if (sortDesc) {
                     return bv - av;
+                } else {
+                    return av - bv;
                 }
             } else {
                 const avStr = String(av);
                 const bvStr = String(bv);
 
-                if (sortDir === "asc") {
-                    return avStr.localeCompare(bvStr);
-                } else {
+                if (sortDesc) {
                     return bvStr.localeCompare(avStr);
+                } else {
+                    return avStr.localeCompare(bvStr);
                 }
             }
         });
     }
 
     const totalWithoutPagination = rows.length;
+    let offset = 0;
+
+    if (params.page) {
+        offset = params.page.pageIndex * params.page.pageSize;
+        rows = rows.slice(offset, offset + params.page.pageSize);
+    }
+
+    return {rows, total: totalWithoutPagination, offset};
+}
+
+//endregion
 
-    rows = rows.slice(params.offset, params.offset + params.count);
+//region JTableDs
 
-    return {
-        rows, total: totalWithoutPagination,
-        offset: params.offset
+export interface JTableDs_ReadParams extends JRowArrayFilter {
+}
+
+export interface JTableDs_ReadResult {
+    rows: any[];
+    total?: number;
+    offset?: number;
+}
+
+export interface JTableDs {
+    get name(): string;
+    get schema(): Schema;
+    read(params: JTableDs_ReadParams): Promise<JTableDs_ReadResult>;
+}
+
+export class JTableDs_UseArray implements JTableDs {
+    public constructor(public readonly name: string, public readonly schema: Schema, private readonly rows: any[]) {
+    }
+
+    async read(params: JTableDs_ReadParams): Promise<JTableDs_ReadResult> {
+        return simpleRowArrayFilter(this.rows, params);
+    }
+}
+
+export class JTableDs_HttpProxy implements JTableDs {
+    public constructor(public readonly name: string, private readonly url: string, public readonly schema: Schema) {
     }
-}
+
+    async read(params: JTableDs_ReadParams): Promise<JTableDs_ReadResult> {
+        let toSend = {dsName: this.name, read: params};
+
+        let res = await fetch(this.url, {
+            method: "POST",
+            headers: {"Content-Type": "application/json"},
+            body: JSON.stringify(toSend)
+        });
+
+        if (res.status !== 200) {
+            throw new Error(`Error while reading data source "${this.name}"`);
+        }
+
+        let asJson = await res.json();
+        return asJson as JTableDs_ReadResult;
+    }
+}
+
+//endregion