jopi-toolkit 3.0.12 → 3.0.24

package/src/jk_data/index.js

@@ -0,0 +1,155 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+/**
+ * Filter the row content according to rules.
+ */
+export function simpleRowArrayFilter(rows, params) {
+    // > Apply filter.
+    if (params.filter) {
+        var f_1 = params.filter;
+        rows = rows.filter(function (r) {
+            if (f_1.field) {
+                var v = r[f_1.field];
+                if (v === undefined)
+                    return false;
+                return String(v).includes(f_1.value);
+            }
+            else {
+                for (var _i = 0, _a = Object.values(r); _i < _a.length; _i++) {
+                    var v = _a[_i];
+                    if (v === undefined)
+                        continue;
+                    if (String(v).includes(f_1.value))
+                        return true;
+                }
+                return false;
+            }
+        });
+    }
+    // > Apply sorting.
+    if (params.sorting && params.sorting.length) {
+        var sorting = params.sorting[0];
+        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];
+            if (av === undefined)
+                av = "";
+            if (bv === undefined)
+                bv = "";
+            var avIsNumber = typeof av === "number";
+            var bvIsNumber = typeof bv === "number";
+            if (avIsNumber && bvIsNumber) {
+                if (sortDesc_1) {
+                    return bv - av;
+                }
+                else {
+                    return av - bv;
+                }
+            }
+            else {
+                var avStr = String(av);
+                var bvStr = String(bv);
+                if (sortDesc_1) {
+                    return bvStr.localeCompare(avStr);
+                }
+                else {
+                    return avStr.localeCompare(bvStr);
+                }
+            }
+        });
+    }
+    var totalWithoutPagination = rows.length;
+    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

@@ -0,0 +1,166 @@
+import {type Schema} from "jopi-toolkit/jk_schema";
+
+//region Rows Arrays
+
+export interface JFieldSorting {
+    id: string;
+    desc: boolean;
+}
+
+export interface JFieldFilter {
+    value?: string | number | boolean;
+    constraint: JFieldConstraintType;
+    caseSensitive?: boolean;
+}
+
+export type JFieldConstraintType =
+    | "$eq"    // Equals
+    | "$ne"    // Not equals
+    | "$gt"    // Greater than
+    | "$gte"   // Greater than or equals
+    | "$lt"    // Less than
+    | "$lte"   // Less than or equals
+    | "$in"    // In an array of values
+    | "$nin"   // Not in an array of values
+    | "$like"  // Like search %endsWith or startsWith%
+
+export interface JRowsFilter {
+    field?: string;
+    value: string;
+}
+
+export interface JPageExtraction {
+    pageIndex: number;
+    pageSize: number;
+}
+
+export interface JRowArrayFilter {
+    page?: JPageExtraction;
+    filter?: JRowsFilter;
+    sorting?: JFieldSorting[];
+    fieldFilters?: Record<string, JFieldFilter[]>;
+}
+
+/**
+ * Filter the row content according to rules.
+ */
+export function simpleRowArrayFilter(rows: any[], params: JRowArrayFilter): JTableDs_ReadResult {
+    // > Apply filter.
+
+    if (params.filter) {
+        const f = params.filter;
+
+        rows = rows.filter(r => {
+            if (f.field) {
+                let v = r[f.field];
+                if (v===undefined) return false;
+                return String(v).includes(f.value);
+            } else {
+                for (let v of Object.values(r)) {
+                    if (v===undefined) continue;
+                    if (String(v).includes(f.value)) return true;
+                }
+
+                return false;
+            }
+        });
+    }
+
+    // > Apply sorting.
+
+    if (params.sorting && params.sorting.length) {
+        const sorting = params.sorting[0];
+        const sortField = sorting.id;
+        const sortDesc = sorting.desc;
+
+        rows = rows.sort((a, b) => {
+            let av = a[sortField];
+            let bv = b[sortField];
+
+            if (av === undefined) av = "";
+            if (bv === undefined) bv = "";
+
+            const avIsNumber = typeof av === "number";
+            const bvIsNumber = typeof bv === "number";
+
+            if (avIsNumber && bvIsNumber) {
+                if (sortDesc) {
+                    return bv - av;
+                } else {
+                    return av - bv;
+                }
+            } else {
+                const avStr = String(av);
+                const bvStr = String(bv);
+
+                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
+
+//region JTableDs
+
+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

package/src/jk_events/index.js

@@ -0,0 +1,221 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { PriorityLevel as EventPriority } from "jopi-toolkit/jk_tools";
+// Warning: it's export.
+export { PriorityLevel as EventPriority } from "jopi-toolkit/jk_tools";
+var EventGroup = /** @class */ (function () {
+    function EventGroup() {
+        this.listenersFor = {};
+        this.providers = {};
+    }
+    EventGroup.prototype.newEventGroup = function () {
+        return new EventGroup();
+    };
+    EventGroup.prototype.enableEventSpying = function (spy) {
+        this.evenSpy = spy;
+    };
+    EventGroup.prototype.removeListener = function (eventName, listener) {
+        var events = this.listenersFor[eventName];
+        if (events)
+            events.remove(listener);
+    };
+    EventGroup.prototype.sendEvent = function (eventName, e) {
+        if (this.evenSpy)
+            this.evenSpy(eventName, e);
+        var events = this.listenersFor[eventName];
+        //
+        if (events) {
+            if (events.value) {
+                var values = events.value;
+                for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {
+                    var listener = values_1[_i];
+                    listener(e, eventName);
+                }
+            }
+        }
+        var staticEvent = gStaticEvents[eventName];
+        //
+        if (staticEvent) {
+            staticEvent.send(e);
+        }
+    };
+    EventGroup.prototype.sendAsyncEvent = function (eventName, e) {
+        return __awaiter(this, void 0, void 0, function () {
+            var events, provider, listeners, _i, listeners_1, listener, values, _a, values_2, listener, r;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (eventName[0] !== '@') {
+                            throw new Error("Async events ".concat(eventName, " must start with @"));
+                        }
+                        if (this.evenSpy)
+                            this.evenSpy(eventName, e);
+                        events = this.listenersFor[eventName];
+                        if (!!events) return [3 /*break*/, 3];
+                        provider = this.providers[eventName];
+                        events = new PriorityArray();
+                        if (!provider) return [3 /*break*/, 2];
+                        return [4 /*yield*/, provider()];
+                    case 1:
+                        listeners = _b.sent();
+                        for (_i = 0, listeners_1 = listeners; _i < listeners_1.length; _i++) {
+                            listener = listeners_1[_i];
+                            events.add(EventPriority.default, listener);
+                        }
+                        _b.label = 2;
+                    case 2:
+                        this.listenersFor[eventName] = events;
+                        _b.label = 3;
+                    case 3:
+                        if (!events.value) return [3 /*break*/, 7];
+                        values = events.value;
+                        _a = 0, values_2 = values;
+                        _b.label = 4;
+                    case 4:
+                        if (!(_a < values_2.length)) return [3 /*break*/, 7];
+                        listener = values_2[_a];
+                        r = listener(e, eventName);
+                        if (!(r instanceof Promise)) return [3 /*break*/, 6];
+                        return [4 /*yield*/, r];
+                    case 5:
+                        _b.sent();
+                        _b.label = 6;
+                    case 6:
+                        _a++;
+                        return [3 /*break*/, 4];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    EventGroup.prototype.addListener = function (eventName, priorityOrListener, listener) {
+        var priority;
+        var actualListener;
+        if (typeof priorityOrListener === 'function') {
+            // Cas où priority n'est pas fournie, priorityOrListener est le listener
+            priority = EventPriority.default;
+            actualListener = priorityOrListener;
+        }
+        else {
+            // Cas où priority est fournie
+            priority = priorityOrListener;
+            actualListener = listener;
+        }
+        var events = this.listenersFor[eventName];
+        if (!events)
+            this.listenersFor[eventName] = events = new PriorityArray();
+        events.add(priority, actualListener);
+    };
+    /**
+     * For async events, allow loading some elements (import)
+     * only when the event is emitted for the time.
+     */
+    EventGroup.prototype.addProvider = function (eventName, provider) {
+        this.providers[eventName] = provider;
+    };
+    return EventGroup;
+}());
+export { EventGroup };
+//region PriorityArray
+/**
+ * Allows building an array which entries are sorted by priority.
+ */
+var PriorityArray = /** @class */ (function () {
+    function PriorityArray() {
+        this.entries = [];
+    }
+    PriorityArray.prototype.add = function (priority, value) {
+        this.build = undefined;
+        this.entries.push({ priority: priority, value: value });
+    };
+    PriorityArray.prototype.remove = function (value) {
+        this.build = undefined;
+        this.entries = this.entries.filter(function (e) { return e.value !== value; });
+    };
+    Object.defineProperty(PriorityArray.prototype, "value", {
+        get: function () {
+            if (this.build) {
+                return this.build;
+            }
+            return this.build = this.entries
+                .sort(function (a, b) { return Number(a.priority) - Number(b.priority); })
+                .map(function (e) { return e.value; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return PriorityArray;
+}());
+var StaticEventImpl = /** @class */ (function () {
+    function StaticEventImpl(eventName, eventItems) {
+        this.eventName = eventName;
+        this.eventItems = eventItems;
+        gStaticEvents[eventName] = this;
+    }
+    StaticEventImpl.prototype.send = function (data) {
+        for (var _i = 0, _a = this.eventItems; _i < _a.length; _i++) {
+            var listener = _a[_i];
+            listener(data, this.eventName);
+        }
+        return data;
+    };
+    StaticEventImpl.prototype.addListener = function (listener) {
+        var _this = this;
+        this.eventItems.push(listener);
+        return function () {
+            var idx = _this.eventItems.indexOf(listener);
+            if (idx >= 0)
+                _this.eventItems.splice(idx, 1);
+        };
+    };
+    return StaticEventImpl;
+}());
+export function createStaticEvent(eventName, eventItems) {
+    return new StaticEventImpl(eventName, eventItems);
+}
+export var defaultEventGroup = new EventGroup();
+export function newEventGroup() {
+    return new EventGroup();
+}
+export var enableEventSpying = defaultEventGroup.enableEventSpying.bind(defaultEventGroup);
+export var removeListener = defaultEventGroup.removeListener.bind(defaultEventGroup);
+export var sendEvent = defaultEventGroup.sendEvent.bind(defaultEventGroup);
+export var sendAsyncEvent = defaultEventGroup.sendAsyncEvent.bind(defaultEventGroup);
+export function addListener(eventName, priorityOrListener, listener) {
+    defaultEventGroup.addListener(eventName, priorityOrListener, listener);
+}
+var gStaticEvents = {};

package/src/jk_events/index.ts

@@ -1,4 +1,5 @@
 import {PriorityLevel as EventPriority} from "jopi-toolkit/jk_tools";
+
 // Warning: it's export.
 export {PriorityLevel as EventPriority} from "jopi-toolkit/jk_tools";
 
@@ -31,15 +32,22 @@ export class EventGroup {
         if (this.evenSpy) this.evenSpy(eventName, e);
 
         const events = this.listenersFor[eventName];
-        if (!events) return;
-
-        if (events.value) {
-            const values = events.value;
-
-            for (const listener of values) {
-                listener(e, eventName);
+        //
+        if (events) {
+            if (events.value) {
+                const values = events.value;
+
+                for (const listener of values) {
+                    listener(e, eventName);
+                }
             }
         }
+
+        let staticEvent = gStaticEvents[eventName];
+        //
+        if (staticEvent) {
+            staticEvent.send(e);
+        }
     }
 
     async sendAsyncEvent(eventName: string, e?: any|undefined): Promise<void> {
@@ -149,6 +157,7 @@ export interface SEventController {
 
 class StaticEventImpl implements StaticEvent, SEventController {
     constructor(public readonly eventName: string, private readonly eventItems: SyncEventListener[]) {
+        gStaticEvents[eventName] = this;
     }
 
     send<T>(data: T): T {
@@ -187,3 +196,5 @@ export const sendAsyncEvent = defaultEventGroup.sendAsyncEvent.bind(defaultEvent
 export function addListener<T = any|undefined>(eventName: string, priorityOrListener: EventPriority | EventListener<T>, listener?: EventListener<T>): void {
     defaultEventGroup.addListener(eventName, priorityOrListener as EventPriority, listener as EventListener<T>);
 }
+
+let gStaticEvents: Record<string, StaticEventImpl> = {};

package/src/jk_fs/index.js

@@ -0,0 +1,2 @@
+export * from "./jBundler_ifServer.ts";
+export * from "./common.ts";