jopi-toolkit 3.0.15 → 3.1.22

package/src/jk_events/index.js

@@ -57,15 +57,21 @@ var EventGroup = /** @class */ (function () {
         if (this.evenSpy)
             this.evenSpy(eventName, e);
         var events = this.listenersFor[eventName];
-        if (!events)
-            return;
-        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);
+        //
+        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 () {
@@ -178,6 +184,7 @@ 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++) {
@@ -211,3 +218,4 @@ export var sendAsyncEvent = defaultEventGroup.sendAsyncEvent.bind(defaultEventGr
 export function addListener(eventName, priorityOrListener, listener) {
     defaultEventGroup.addListener(eventName, priorityOrListener, listener);
 }
+var gStaticEvents = {};

package/src/jk_events/index.ts

@@ -1,14 +1,19 @@
-import {PriorityLevel as EventPriority} from "jopi-toolkit/jk_tools";
+import { PriorityLevel as EventPriority } from "jopi-toolkit/jk_tools";
+import { isBrowser } from "jopi-toolkit/jk_what";
+
 // Warning: it's export.
-export {PriorityLevel as EventPriority} from "jopi-toolkit/jk_tools";
+export { PriorityLevel as EventPriority } from "jopi-toolkit/jk_tools";
 
 // noinspection JSUnusedGlobalSymbols
 
-export type EventListener<T = any> = (e: T, eventName: string) => void|Promise<void>;
+export type EventListener<T = any> = (e: T, eventName: string) => void | Promise<void>;
 export type SyncEventListener<T = any> = (e: T, eventName: string) => void;
 
 export type EventListenerProvider = () => Promise<EventListener[]>;
 
+let gStaticEvents: Record<string, any> = {};
+let gStaticEventsThisValue: any;
+
 export class EventGroup {
     private readonly listenersFor: Record<string, PriorityArray<EventListener>> = {};
     private evenSpy: undefined | ((eventName: string, data?: any) => void);
@@ -27,23 +32,30 @@ export class EventGroup {
         if (events) events.remove(listener);
     }
 
-    sendEvent(eventName: string, e?: any|undefined): void {
+    sendEvent(eventName: string, e?: any | undefined): void {
         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> {
-        if (eventName[0]!=='@') {
+    async sendAsyncEvent(eventName: string, e?: any | undefined): Promise<void> {
+        if (eventName[0] !== '@') {
             throw new Error(`Async events ${eventName} must start with @`);
         }
 
@@ -74,7 +86,7 @@ export class EventGroup {
         }
     }
 
-    addListener<T = any|undefined>(eventName: string, priorityOrListener: EventPriority | EventListener<T>, listener?: EventListener<T>): void {
+    addListener<T = any | undefined>(eventName: string, priorityOrListener: EventPriority | EventListener<T>, listener?: EventListener<T>): void {
         let priority: EventPriority;
         let actualListener: EventListener;
 
@@ -109,11 +121,11 @@ export class EventGroup {
  */
 class PriorityArray<T> {
     private entries: PriorityArrayEntry<T>[] = [];
-    private build: T[]|undefined;
+    private build: T[] | undefined;
 
     add(priority: EventPriority, value: T) {
         this.build = undefined;
-        this.entries.push({priority, value});
+        this.entries.push({ priority, value });
     }
 
     remove(value: T) {
@@ -127,7 +139,7 @@ class PriorityArray<T> {
         }
 
         return this.build = this.entries
-            .sort((a,b) => Number(a.priority) - Number(b.priority))
+            .sort((a, b) => Number(a.priority) - Number(b.priority))
             .map(e => e.value);
     }
 }
@@ -141,6 +153,7 @@ interface PriorityArrayEntry<T> {
 
 export interface StaticEvent {
     send<T>(data: T): T;
+    setThisValue(value: any): void;
 }
 
 export interface SEventController {
@@ -148,12 +161,17 @@ export interface SEventController {
 }
 
 class StaticEventImpl implements StaticEvent, SEventController {
+    private thisValue: any;
+
     constructor(public readonly eventName: string, private readonly eventItems: SyncEventListener[]) {
+        gStaticEvents[eventName] = this;
     }
 
     send<T>(data: T): T {
+        let thisValue = this.thisValue ?? gStaticEventsThisValue;
+
         for (const listener of this.eventItems) {
-            listener(data, this.eventName);
+            listener.call(thisValue, data, this.eventName);
         }
 
         return data;
@@ -167,12 +185,25 @@ class StaticEventImpl implements StaticEvent, SEventController {
             if (idx >= 0) this.eventItems.splice(idx, 1);
         };
     }
+
+    setThisValue(thisValue: any): void {
+        if (isBrowser) {
+            this.thisValue = thisValue;
+        }
+    }
 }
 
 export function createStaticEvent(eventName: string, eventItems: SyncEventListener[]): StaticEvent {
     return new StaticEventImpl(eventName, eventItems);
 }
 
+export function setStaticEventsThisValue(thisValue: any) {
+    if (isBrowser) {
+        gStaticEventsThisValue = thisValue;
+    }
+}
+
+
 export const defaultEventGroup = new EventGroup();
 
 export function newEventGroup(): EventGroup {
@@ -184,6 +215,6 @@ export const removeListener = defaultEventGroup.removeListener.bind(defaultEvent
 export const sendEvent = defaultEventGroup.sendEvent.bind(defaultEventGroup);
 export const sendAsyncEvent = defaultEventGroup.sendAsyncEvent.bind(defaultEventGroup);
 
-export function addListener<T = any|undefined>(eventName: string, priorityOrListener: EventPriority | EventListener<T>, listener?: EventListener<T>): void {
+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>);
 }

package/src/jk_fs/jBundler_ifBrowser.ts

@@ -68,6 +68,14 @@ export function readTextFromFileSync(filePath: string): string {
     throw new Error("Not implemented");
 }
 
+export async function readJsonFromFile<T = any>(filePath: string, throwError: boolean = false): Promise<T> {
+    throw new Error("Not implemented");
+}
+
+export function readJsonFromFileSync<T = any>(filePath: string, throwError: boolean = false): T {
+    throw new Error("Not implemented");
+}
+
 export async function isFile(filePath: string): Promise<boolean> {
     throw new Error("Not implemented");
 }

package/src/jk_fs/jBundler_ifServer.ts

@@ -181,17 +181,64 @@ export function writeTextToFileSync(filePath: string, text: string, createDir: b
     fss.writeFileSync(filePath, text, {encoding: 'utf8', flag: 'w'});
 }
 
-export function readTextFromFile(filePath: string): Promise<string> {
-    return fs.readFile(filePath, 'utf8');
+export async function readTextFromFile(filePath: string, throwError: boolean = false): Promise<string> {
+    if (throwError) {
+        return fs.readFile(filePath, 'utf8');
+    }
+
+    try {
+        return await fs.readFile(filePath, 'utf8');
+    }
+    catch {
+        // @ts-ignore
+        return undefined;
+    }
+}
+
+export function readTextFromFileSync(filePath: string, throwError: boolean = false): string {
+    if (throwError) {
+        return fss.readFileSync(filePath, 'utf8');
+    }
+
+    try {
+        return fss.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        // @ts-ignore
+        return undefined;
+    }
 }
 
-export async function readJsonFromFile<T = any>(filePath: string): Promise<T> {
-    let txt = await fs.readFile(filePath, 'utf8');
-    return JSON.parse(txt) as T;
+export async function readJsonFromFile<T = any>(filePath: string, throwError: boolean = false): Promise<T> {
+    if (throwError) {
+        let txt = await readTextFromFile(filePath, true);
+        return JSON.parse(txt) as T;
+    } else {
+        try {
+            let txt = await readTextFromFile(filePath);
+            return JSON.parse(txt) as T;
+        }
+        catch {
+            // @ts-ignore
+            return undefined;
+        }
+    }
 }
 
-export function readTextFromFileSync(filePath: string): string {
-    return fss.readFileSync(filePath, 'utf8');
+export function readJsonFromFileSync<T = any>(filePath: string, throwError: boolean = false): T {
+    if (throwError) {
+        let txt = readTextFromFileSync(filePath);
+        return JSON.parse(txt) as T;
+    } else {
+        try {
+            let txt = readTextFromFileSync(filePath);
+            return JSON.parse(txt) as T;
+        }
+        catch {
+            // @ts-ignore
+            return undefined;
+        }
+    }
 }
 
 export async function isFile(filePath: string): Promise<boolean> {

package/src/jk_logs/jBundler_ifServer.ts

@@ -4,6 +4,12 @@ import type {LogInitializer} from "./index.ts";
 
 export function init(init: LogInitializer) {
     const mainDir = jk_app.findPackageJsonDir();
+    
+    // Possible that no package.json is found.
+    // For exemple, when using a command line tool (ex: jopi init).
+    //
+    if (!mainDir) return;
+
     const filePath = jk_fs.join(mainDir, "logConfig.json");
 
     if (!jk_fs.isFileSync(filePath)) return;

package/src/{jk_fs → jk_process}/index.js

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

package/src/jk_process/jBundler_ifServer.ts

@@ -1,4 +1,38 @@
+import * as inspector from "node:inspector";
+
 export const argv = process.argv;
 export const env = process.env as Record<string, string>;
 export const isProduction = process.env.NODE_ENV === 'production';
-export const isDevelopment: boolean = !isProduction;
+export const isDevelopment: boolean = !isProduction;
+
+/**
+ * Detect if Node.js or Bun.js is running with the debugger launcher.
+ */
+export function isLaunchedWithDebugger(): boolean {
+    const args = process.execArgv;
+    if (args.some((arg) => arg.includes("--inspect") || arg.includes("--debug") || arg.includes("bootloader.js"))) return true;
+
+    // Check environment variables
+    if (process.env.VSCODE_INSPECTOR_OPTIONS) return true;
+    
+    if (process.env.NODE_OPTIONS) {
+        const nodeOptions = process.env.NODE_OPTIONS;
+        if (nodeOptions.includes("--inspect") || 
+            nodeOptions.includes("--debug") || 
+            nodeOptions.includes("bootloader.js") || 
+            nodeOptions.includes("js-debug")) {
+            return true;
+        }
+    }
+
+    // Check Bun environment variables
+    if (process.env.BUN_INSPECT || process.env.BUN_INSPECT_BRK || process.env.BUN_INSPECT_WAIT) return true;
+
+
+    // Check inspector url. This is the most reliable way to detect if a debugger is attached.
+    try {
+        if (inspector.url()) return true;
+    } catch { /* ignore */ }
+
+    return false;
+}

package/src/jk_schemas/index.js

@@ -54,7 +54,7 @@ export function validateSchema(data, schema) {
     //
     if (schema.schemaMeta.normalize) {
         try {
-            schema.schemaMeta.normalize(data);
+            schema.schemaMeta.normalize(data, gValueCheckingHelper);
         }
         catch (e) {
             if (e instanceof SchemaError) {
@@ -81,7 +81,7 @@ export function validateSchema(data, schema) {
             var value = data[fieldName];
             if (field.normalize) {
                 defaultErrorMessage = field.errorMessage_theValueIsInvalid;
-                field.normalize(value, data);
+                field.normalize(value, data, gValueCheckingHelper);
             }
             if (!field.optional) {
                 if (value === undefined) {
@@ -102,7 +102,7 @@ export function validateSchema(data, schema) {
             }
             if (field.validator) {
                 defaultErrorMessage = field.errorMessage_theValueIsInvalid;
-                field.validator(value, data);
+                field.validator(value, data, gValueCheckingHelper);
             }
         }
         catch (e) {
@@ -124,7 +124,7 @@ export function validateSchema(data, schema) {
     //     Allow validating if values are ok with each others.
     if (schema.schemaMeta.validate) {
         try {
-            schema.schemaMeta.validate(data);
+            schema.schemaMeta.validate(data, gValueCheckingHelper);
         }
         catch (e) {
             if (e instanceof SchemaError) {
@@ -147,6 +147,19 @@ export function validateSchema(data, schema) {
     return { fields: fieldErrors };
 }
 var byTypeValidator = {};
+/**
+ * A helper allowing to make field validation easier.
+ * Is sent to normalize and validate functions.
+ */
+var ValueCheckingHelper = /** @class */ (function () {
+    function ValueCheckingHelper() {
+    }
+    ValueCheckingHelper.prototype.declareError = function (message, errorCode) {
+        throw new SchemaError(message, errorCode);
+    };
+    return ValueCheckingHelper;
+}());
+var gValueCheckingHelper = new ValueCheckingHelper();
 export function registerSchema(schemaId, schema, meta) {
     if (!schemaId) {
         throw new Error("jk_schemas - Schema id required. If you need an uid you can use: " + generateUUIDv4());
@@ -176,8 +189,40 @@ var gRegistry = {};
 //endregion
 //region Schema
 export function schema(descriptor, meta) {
-    return { desc: descriptor, schemaMeta: meta || {} };
+    return new SchemaImpl(descriptor, meta || {});
 }
+var SchemaImpl = /** @class */ (function () {
+    function SchemaImpl(desc, schemaMeta) {
+        this.desc = desc;
+        this.schemaMeta = schemaMeta;
+    }
+    SchemaImpl.prototype.toJson = function () {
+        return toJson(this);
+    };
+    SchemaImpl.prototype.addDataNormalizer = function (f) {
+        if (!this.schemaMeta.normalize) {
+            this.schemaMeta.normalize = f;
+        }
+        var f1 = this.schemaMeta.normalize;
+        this.schemaMeta.normalize = function (values, helper) {
+            f1(values, helper);
+            f(values, helper);
+        };
+        return this;
+    };
+    SchemaImpl.prototype.addDataValidator = function (f) {
+        if (!this.schemaMeta.validate) {
+            this.schemaMeta.validate = f;
+        }
+        var f1 = this.schemaMeta.validate;
+        this.schemaMeta.validate = function (values, helper) {
+            f1(values, helper);
+            f(values, helper);
+        };
+        return this;
+    };
+    return SchemaImpl;
+}());
 export function toJson(schema) {
     return schema;
 }

package/src/jk_schemas/index.ts

@@ -47,7 +47,7 @@ export function validateSchema(data: any, schema: Schema): ValidationErrors|unde
     //
     if (schema.schemaMeta.normalize) {
         try {
-            schema.schemaMeta.normalize(data);
+            schema.schemaMeta.normalize(data, gValueCheckingHelper);
         }
         catch (e: any) {
             if (e instanceof SchemaError) {
@@ -80,7 +80,7 @@ export function validateSchema(data: any, schema: Schema): ValidationErrors|unde
 
             if (field.normalize) {
                 defaultErrorMessage = field.errorMessage_theValueIsInvalid;
-                field.normalize(value, data);
+                field.normalize(value, data, gValueCheckingHelper);
             }
 
             if (!field.optional) {
@@ -103,7 +103,7 @@ export function validateSchema(data: any, schema: Schema): ValidationErrors|unde
 
             if (field.validator) {
                 defaultErrorMessage = field.errorMessage_theValueIsInvalid;
-                field.validator(value, data);
+                field.validator(value, data, gValueCheckingHelper);
             }
         }
         catch (e: any) {
@@ -126,7 +126,7 @@ export function validateSchema(data: any, schema: Schema): ValidationErrors|unde
 
     if (schema.schemaMeta.validate) {
         try {
-            schema.schemaMeta.validate(data);
+            schema.schemaMeta.validate(data, gValueCheckingHelper);
         }
         catch (e: any) {
             if (e instanceof SchemaError) {
@@ -151,6 +151,18 @@ export function validateSchema(data: any, schema: Schema): ValidationErrors|unde
 
 const byTypeValidator: Record<string, (v: any, fieldInfos: SchemaFieldInfos) => void> = {};
 
+/**
+ * A helper allowing to make field validation easier.
+ * Is sent to normalize and validate functions.
+ */
+class ValueCheckingHelper {
+    declareError(message?: string, errorCode?: string) {
+        throw new SchemaError(message, errorCode);
+    }
+}
+
+const gValueCheckingHelper = new ValueCheckingHelper();
+
 //endregion
 
 //region Registry
@@ -197,11 +209,50 @@ const gRegistry: Record<string, RegistryEntry> = {};
 //region Schema
 
 export function schema<T extends SchemaDescriptor>(descriptor: T, meta?: SchemaMeta): Schema & { desc: T } {
-    return { desc: descriptor, schemaMeta: meta || {} };
+    return new SchemaImpl(descriptor, meta || {});
+}
+
+class SchemaImpl<T extends SchemaDescriptor> implements Schema {
+    constructor(public readonly desc: T, public readonly schemaMeta: SchemaMeta) {
+    }
+
+    toJson(): SchemaInfo {
+        return toJson(this);
+    }
+
+    addDataNormalizer(f: (allValues: any, checkHelper: ValueCheckingHelper) => void): this {
+        if (!this.schemaMeta.normalize) {
+            this.schemaMeta.normalize = f;
+        }
+
+        const f1 = this.schemaMeta.normalize;
+
+        this.schemaMeta.normalize = function (values, helper) {
+            f1(values, helper);
+            f(values, helper);
+        }
+        
+        return this;
+    }
+
+    addDataValidator(f: (allValues: any, checkHelper: ValueCheckingHelper) => void): this {
+        if (!this.schemaMeta.validate) {
+            this.schemaMeta.validate = f;
+        }
+
+        const f1 = this.schemaMeta.validate;
+
+        this.schemaMeta.validate = function (values, helper) {
+            f1(values, helper);
+            f(values, helper);
+        }
+        
+        return this;
+    }
 }
 
 export interface SchemaDescriptor  {
-    [field: string]: ScField<any, any>;
+    [field: string]: Field;
 }
 
 export interface SchemaMeta {
@@ -209,8 +260,8 @@ export interface SchemaMeta {
     description?: string;
     [key: string]: any;
     
-    normalize?: (allValues: any) => void;
-    validate?: (allValues: any) => void;
+    normalize?: (allValues: any, checkHelper: ValueCheckingHelper) => void;
+    validate?: (allValues: any, checkHelper: ValueCheckingHelper) => void;
 }
 
 export interface SchemaInfo {
@@ -219,6 +270,26 @@ export interface SchemaInfo {
 }
 
 export interface Schema extends SchemaInfo {
+    /**
+     * Get serializable data describing this schema.
+     */
+    toJson(): SchemaInfo;
+
+    /**
+     * Add a function whose role is to normalize the data.
+     *
+     * Cumulating: if a normalize function has already been added,
+     * then the previous function will be called before this one.
+     */
+    addDataNormalizer(f: (allValues: any, checkHelper: ValueCheckingHelper) => void): this;
+
+    /**
+     * Add a function whose role is to validate the data.
+     *
+     * Cumulating: if a validate function has already been added,
+     * then the previous function will be called before this one.
+     */
+    addDataValidator(f: (allValues: any, checkHelper: ValueCheckingHelper) => void): this;
 }
 
 export function toJson(schema: Schema): SchemaInfo {
@@ -304,7 +375,46 @@ export interface ScOnTableRenderingInfo {
     textAlign?: "left" | "center" | "right";
 }
 
-interface ScField<T, Opt extends boolean> {
+/**
+ * Get information about how storing this field.
+ */
+export interface ScFieldStore {
+    /**
+     * Allow knowing if a BDD index must be created for this field.
+     * The default is true.
+     */
+    mustIndex?: boolean;
+
+    /**
+     * Allow knowing if this field is the primary key.
+     * If more than one primary is set, then a composed key will be created.
+     * The default is false.
+     */
+    isPrimaryKey?: boolean;
+
+    /**
+     * The column name to use when storing this field in a database.
+     * The default is the field name.
+     */
+    colName?: string;
+
+    /**
+     * An indication on the size of the data to store.
+     * The default is "default".
+     *
+     * - big: for storing large strings / binary.
+     * - medium: for storing item with a common size.
+     * - tiny: for storing small strings / binary.
+     */
+    dataSize?: "tiny" | "medium" | "big";
+
+    /**
+     * Allow forcing the type name for the BDD.
+     */
+    databaseType?: string;
+}
+
+export interface ScField<T, Opt extends boolean> {
     title: string;
     type: string;
 
@@ -316,12 +426,31 @@ interface ScField<T, Opt extends boolean> {
     errorMessage_theDataTypeIsInvalid?: string;
     errorMessage_theValueIsInvalid?: string;
 
-    normalize?: (value: T, allValues: any) => void;
-    validator?: (value: T, allValues: any) => void;
+    /**
+     * A function used to normalize the field value.
+     */
+    normalize?: (value: T, allValues: any, valueCheckingHelp: ValueCheckingHelper) => void;
+
+    /**
+     * A function used to validate the field.
+     */
+    validator?: (value: T, allValues: any, valueCheckingHelp: ValueCheckingHelper) => void;
 
+    /**
+     * Meta-data associated with this field.
+     * The usage is free, you can use it for whatever you want.
+     */
     metas?: Record<string, string>;
 
+    /**
+     * Get information about how to render this field in a data table.
+     */
     onTableRendering?: ScOnTableRenderingInfo;
+
+    /**
+     * Get information about how storing this field.
+     */
+    store?: ScFieldStore;
 }
 
 export type Field = ScField<any, any>;

package/src/jk_term/index.js

@@ -114,6 +114,8 @@ export var logBgRed = buildLogger(B_RED);
 export var textBgRed = buildWriter(B_RED);
 export var logBlue = buildLogger(C_BLUE);
 export var textBlue = buildWriter(C_BLUE);
+export var logGrey = buildLogger(C_GREY);
+export var textGrey = buildWriter(C_GREY);
 export var logBgBlue = buildLogger(B_BLUE, C_WHITE);
 export var textBgBlue = buildWriter(B_BLUE, C_WHITE);
 export var logGreen = buildLogger(C_GREEN);

package/src/jk_term/index.ts

@@ -105,6 +105,9 @@ export const textBgRed = buildWriter(B_RED);
 export const logBlue = buildLogger(C_BLUE);
 export const textBlue = buildWriter(C_BLUE);
 
+export const logGrey = buildLogger(C_GREY);
+export const textGrey = buildWriter(C_GREY);
+
 export const logBgBlue = buildLogger(B_BLUE, C_WHITE);
 export const textBgBlue = buildWriter(B_BLUE, C_WHITE);