jopi-toolkit 3.0.12 → 3.0.24

package/src/jk_schemas/index.ts

@@ -41,67 +41,13 @@ export interface ValidationErrors {
     fields?: Record<string, FieldError>;
 }
 
-const byTypeValidator: Record<string, (v: any, fieldInfos: SchemaFieldInfos) => void> = {
-    "string": (v, f) => {
-        if (typeof v !== "string") {
-            declareError(f.errorMessage_theValueIsInvalid || `Value must be a string`, "INVALID_TYPE");
-            return;
-        }
-
-        let sf = f as ScString<any>;
-
-        if ((sf.minLength!==undefined) && (v.length < sf.minLength)) {
-            declareError(sf.errorMessage_minLength || `Value must be at least ${sf.minLength} characters long`, "INVALID_LENGTH");
-            return;
-        }
-
-        if ((sf.maxLength!==undefined) && (v.length > sf.maxLength)) {
-            declareError(sf.errorMessage_maxLength || `Value must be less than ${sf.maxLength} characters long`, "INVALID_LENGTH");
-            return;
-        }
-    },
-
-    "number": (v, f) => {
-        if (typeof v !== "number") {
-            declareError(f.errorMessage_theValueIsInvalid || `Value must be a number`, "INVALID_TYPE");
-        }
-
-        let sf = f as ScNumber<any>;
-
-        if ((sf.minValue!==undefined) && (v < sf.minValue)) {
-            declareError(sf.errorMessage_minValue || `Value must be at least ${sf.minValue}`, "INVALID_LENGTH");
-            return;
-        }
-
-        if ((sf.maxValue!==undefined) && (v > sf.maxValue)) {
-            declareError(sf.errorMessage_maxValue || `Value must be less than ${sf.maxValue}`, "INVALID_LENGTH");
-            return;
-        }
-    },
-
-    "boolean": (v, f) => {
-        if (typeof v !== "boolean") {
-            declareError(f.errorMessage_theValueIsInvalid || `Value must be a boolean`, "INVALID_TYPE");
-        }
-
-        let sf = f as ScBoolean<any>;
-        
-        if (sf.requireTrue) {
-            if (v!==true) {
-                declareError(sf.errorMessage_requireTrue || `Value must be true`, "INVALID_VALUE");
-            }
-        } else if (sf.requireFalse) {
-            if (v!==false) {
-                declareError(sf.errorMessage_requireFalse || `Value must be false`, "INVALID_VALUE");
-            }
-        }
-    }
-}
-
 export function validateSchema(data: any, schema: Schema): ValidationErrors|undefined {
+    // Normalize the data.
+    // It's a step where we apply automatic corrections.
+    //
     if (schema.schemaMeta.normalize) {
         try {
-            schema.schemaMeta.normalize(data);
+            schema.schemaMeta.normalize(data, gValueCheckingHelper);
         }
         catch (e: any) {
             if (e instanceof SchemaError) {
@@ -116,6 +62,13 @@ export function validateSchema(data: any, schema: Schema): ValidationErrors|unde
         }
     }
 
+    // >>> Check each field individually.
+
+    // Each time it will:
+    // - Normalize the value.
+    // - Check if optional + undefined.
+    // - Apply validator for the field type.
+
     let fieldErrors: Record<string, FieldError>|undefined;
 
     for (let fieldName in schema.desc) {
@@ -127,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) {
@@ -150,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) {
@@ -168,9 +121,12 @@ export function validateSchema(data: any, schema: Schema): ValidationErrors|unde
         }
     }
 
+    // >>> Validate the whole fields.
+    //     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: any) {
             if (e instanceof SchemaError) {
@@ -186,10 +142,27 @@ export function validateSchema(data: any, schema: Schema): ValidationErrors|unde
         }
     }
 
+    // No error ? --> undefined.
+    // Otherwise returns the errors.
+    //
     if (!fieldErrors) return undefined;
     return {fields: fieldErrors};
 }
 
+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
@@ -236,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 {
@@ -248,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 {
@@ -258,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 {
@@ -275,17 +307,113 @@ export function toJson(schema: Schema): SchemaInfo {
  * ```
  */
 export type SchemaToType<S extends Schema> =
-// 1. On accède au descripteur de schéma S['desc']
-// 2. On itère sur ses clés K
-// 3. On filtre les champs obligatoires (Opt = false)
     { [K in keyof S['desc'] as S['desc'][K] extends ScField<any, false> ? K : never]:
-        // 4. On infère le type T du champ
         S['desc'][K] extends ScField<infer T, any> ? T : never }
 
-    // 5. On fusionne avec les champs optionnels (Opt = true)
     & { [K in keyof S['desc'] as S['desc'][K] extends ScField<any, true> ? K : never] ?:
     S['desc'][K] extends ScField<infer T, any> ? T : never };
 
+export interface ScOnTableRenderingInfo {
+    /**
+     * The title to use if rendering with a Table.
+     */
+    title?: string;
+
+    /**
+     * If true, then allows hiding the column
+     * when rendering into a UI table component.
+     */
+    enableHiding?: boolean;
+
+    /**
+     * If true, then the table column is hidden by default.
+     */
+    defaultHidden?: boolean;
+
+    /**
+     * If true, then the table column is hidden and remain hidden.
+     */
+    alwaysHidden?: boolean;
+
+    /**
+     * If true, then allows sorting the column
+     * when rendering into a UI table component.
+     */
+    enableSorting?: boolean;
+
+    /**
+     * If true, then allows editing the column
+     * when rendering into a UI table component.
+     */
+    enableEditing?: boolean;
+
+    /**
+     * Contains the name of the renderer to user for the header.
+     */
+    rendererForHeader?: string;
+
+    /**
+     * Contains the name of the renderer to user for the cell.
+     */
+    rendererForCell?: string;
+
+    /**
+     * Allows setting the column grow rule.
+     */
+    columnGrow?: "takeAllPlace" | "takeMinPlace";
+
+    /**
+     * Allows defining extra-css class for rendering the cells.
+     */
+    cellCssClass?: string;
+
+    /**
+     * Allows defining extra-css class for rendering the header.
+     */
+    headerCssClass?: string;
+
+    textAlign?: "left" | "center" | "right";
+}
+
+/**
+ * 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;
@@ -298,15 +426,37 @@ export 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 SchemaFieldInfos = ScField<any, any>;
+export type Field = ScField<any, any>;
+export type SchemaFieldInfos = Field;
 
-type OnlyInfos<T> = Omit<Omit<Omit<T, "title">, "optional">, "type">;
+type OnlyInfos<T> = Omit<T, "title" | "optional" | "type">;
 
 //endregion
 
@@ -314,7 +464,7 @@ type OnlyInfos<T> = Omit<Omit<Omit<T, "title">, "optional">, "type">;
 
 //region String
 
-export interface ScString<Opt extends boolean> extends ScField<string, Opt> {
+export interface ScString<Opt extends boolean = boolean> extends ScField<string, Opt> {
     minLength?: number;
     errorMessage_minLength?: string;
 
@@ -333,11 +483,30 @@ export function string<Opt extends boolean>(title: string, optional: Opt, infos?
     return {...infos, title, optional, type: "string"};
 }
 
+byTypeValidator["string"] = (v,f) => {
+    if (typeof v !== "string") {
+        declareError(f.errorMessage_theValueIsInvalid || `Value must be a string`, "INVALID_TYPE");
+        return;
+    }
+
+    let sf = f as ScString<any>;
+
+    if ((sf.minLength !== undefined) && (v.length < sf.minLength)) {
+        declareError(sf.errorMessage_minLength || `Value must be at least ${sf.minLength} characters long`, "INVALID_LENGTH");
+        return;
+    }
+
+    if ((sf.maxLength !== undefined) && (v.length > sf.maxLength)) {
+        declareError(sf.errorMessage_maxLength || `Value must be less than ${sf.maxLength} characters long`, "INVALID_LENGTH");
+        return;
+    }
+};
+
 //endregion
 
 //region Boolean
 
-export interface ScBoolean<Opt extends boolean> extends ScField<boolean, Opt> {
+export interface ScBoolean<Opt extends boolean = boolean> extends ScField<boolean, Opt> {
     requireTrue?: boolean;
     errorMessage_requireTrue?: string;
     
@@ -349,30 +518,117 @@ export function boolean<Opt extends boolean>(title: string, optional: Opt, infos
     return {...infos, title, optional, type: "boolean"};
 }
 
+byTypeValidator["boolean"] = (v, f) => {
+    if (typeof v !== "boolean") {
+        declareError(f.errorMessage_theValueIsInvalid || `Value must be a boolean`, "INVALID_TYPE");
+    }
+
+    let sf = f as ScBoolean<any>;
+
+    if (sf.requireTrue) {
+        if (v !== true) {
+            declareError(sf.errorMessage_requireTrue || `Value must be true`, "INVALID_VALUE");
+        }
+    } else if (sf.requireFalse) {
+        if (v !== false) {
+            declareError(sf.errorMessage_requireFalse || `Value must be false`, "INVALID_VALUE");
+        }
+    }
+};
+
 //endregion
 
 //region Number
 
-export interface ScNumber<Opt extends boolean> extends ScField<number, Opt> {
+export interface ScNumber<Opt extends boolean = boolean> extends ScField<number, Opt> {
     minValue?: number;
     errorMessage_minValue?: string;
 
     maxValue?: number;
     errorMessage_maxValue?: string;
 
-    // TODO: allowDecimal
     allowDecimal?: boolean;
+
     roundMethod?: "round" | "floor" | "ceil";
     errorMessage_dontAllowDecimal?: string;
 
     incrStep?: number;
     placeholder?: string;
+
+    /**
+     * Allows displaying this value as a simple
+     * number, or a current, or a percent.
+     */
+    displayType?: "decimal" | "currency" | "percent";
+
+    /**
+     * The regional currency format to use for formating.
+     * Ex: "en-US", "fr-FR".
+     */
+    localFormat?: string;
+
+    /**
+     * The type of currency.
+     * Ex: "USD".
+     */
+    currency?: string;
 }
 
 export function number<Opt extends boolean>(title: string, optional: Opt, infos?: OnlyInfos<ScNumber<Opt>>): ScNumber<Opt> {
     return {...infos, title, optional, type: "number"};
 }
 
+export function formatNumber(value: string, fieldNumber: ScNumber, defaultLocalFormat: string = "en-US", defaultCurrency: string = "USD") {
+    const amount = parseFloat(value);
+
+    let localFormat = fieldNumber.localFormat || defaultLocalFormat;
+
+    switch (fieldNumber.displayType) {
+        case "currency":
+            return new Intl.NumberFormat(localFormat, {
+                style: "currency",
+                currency: fieldNumber.currency || defaultCurrency,
+            }).format(amount);
+        default:
+            return new Intl.NumberFormat(localFormat, {style: fieldNumber.displayType || "decimal"}).format(amount);
+    }
+}
+
+byTypeValidator["number"] = (v,f) => {
+    if (typeof v !== "number") {
+        declareError(f.errorMessage_theValueIsInvalid || `Value must be a number`, "INVALID_TYPE");
+    }
+
+    let sf = f as ScNumber<any>;
+
+    if ((sf.minValue!==undefined) && (v < sf.minValue)) {
+        declareError(sf.errorMessage_minValue || `Value must be at least ${sf.minValue}`, "INVALID_LENGTH");
+        return;
+    }
+
+    if ((sf.maxValue!==undefined) && (v > sf.maxValue)) {
+        declareError(sf.errorMessage_maxValue || `Value must be less than ${sf.maxValue}`, "INVALID_LENGTH");
+        return;
+    }
+}
+
+//endregion
+
+//region Currency
+
+export function currency<Opt extends boolean>(title: string, optional: Opt, infos?: OnlyInfos<ScNumber<Opt>>): ScNumber<Opt> {
+    return number(title, optional, {...infos, displayType: "currency"})
+}
+
+//endregion
+
+//region Percent
+
+export function percent<Opt extends boolean>(title: string, optional: Opt, infos?: OnlyInfos<ScNumber<Opt>>): ScNumber<Opt> {
+    return number(title, optional, {...infos, displayType: "percent"})
+}
+
+
 //endregion
 
 //region File

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);
 

package/src/jk_thread/common.js

@@ -0,0 +1,7 @@
+export var gIsUsingWorkers = false;
+export function declareUsingWorker() {
+    gIsUsingWorkers = true;
+}
+export function isUsingWorker() {
+    return gIsUsingWorkers;
+}

package/src/jk_timer/index.js

@@ -95,6 +95,8 @@ export function deferred(callback) {
 export function tick(timeInMs) {
     return new Promise(function (resolve) { return setTimeout(resolve, timeInMs); });
 }
+export var sleep = tick;
+export var pause = tick;
 export function chrono(mustSaveMeasures) {
     return new ChronoImpl(mustSaveMeasures);
 }

package/src/jk_timer/index.ts

@@ -78,6 +78,9 @@ export function tick(timeInMs: number): Promise<void> {
     return new Promise(resolve => setTimeout(resolve, timeInMs));
 }
 
+export const sleep = tick;
+export const pause = tick;
+
 export function chrono(mustSaveMeasures: boolean): Chrono {
     return new ChronoImpl(mustSaveMeasures)
 }

package/src/jk_tools/common.js

@@ -0,0 +1,101 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+export function generateUUIDv4() {
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        var r = Math.random() * 16 | 0;
+        var v = c === 'x' ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+    });
+}
+export function isUUIDv4(text) {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(text);
+}
+export function getErrorMessage(e) {
+    if (e instanceof Error)
+        return e.message;
+    return "" + e;
+}
+export function applyDefaults(source, defaults) {
+    if (!source)
+        source = {};
+    return __assign(__assign({}, defaults), source);
+}
+/**
+ * Allow knowing the file path of the function calling us.
+ */
+export function getCallerFilePath() {
+    try {
+        throw new Error("");
+    }
+    catch (e) {
+        var error = e;
+        if (!error.stack)
+            return undefined;
+        var stackLines = error.stack.split('\n');
+        if (stackLines.length < 4)
+            return undefined;
+        // Here we have something like:
+        // at file:///Users/johan/Projets/jopijs-workspace/__tests/jopi-ui-sample/dist/mod_sample/routes/tests/test3.page.js:4:1
+        //
+        var fileUrl = stackLines[3].trim();
+        var idx = fileUrl.indexOf("file://");
+        fileUrl = fileUrl.substring(idx);
+        idx = fileUrl.lastIndexOf(":");
+        fileUrl = fileUrl.substring(0, idx);
+        idx = fileUrl.lastIndexOf(":");
+        if (idx !== -1)
+            fileUrl = fileUrl.substring(0, idx);
+        return fileUrl;
+    }
+}
+export var PriorityLevel;
+(function (PriorityLevel) {
+    PriorityLevel[PriorityLevel["veryLow"] = -200] = "veryLow";
+    PriorityLevel[PriorityLevel["low"] = -100] = "low";
+    PriorityLevel[PriorityLevel["default"] = 0] = "default";
+    PriorityLevel[PriorityLevel["high"] = 100] = "high";
+    PriorityLevel[PriorityLevel["veryHigh"] = 200] = "veryHigh";
+})(PriorityLevel || (PriorityLevel = {}));
+export function sortByPriority(values) {
+    if (values === undefined)
+        return undefined;
+    values.sort(function (a, b) {
+        if (a.priority < b.priority)
+            return -1;
+        if (a.priority > b.priority)
+            return 1;
+        return 0;
+    });
+    return values.map(function (v) { return v.value; });
+}
+/**
+ * Allows avoiding calling a function before n-milliseconds is elapsed.
+ */
+var DontCallBeforeElapsed = /** @class */ (function () {
+    function DontCallBeforeElapsed(requireMs) {
+        if (requireMs === void 0) { requireMs = 1000; }
+        this.requireMs = requireMs;
+        this.lastTime = 0;
+    }
+    DontCallBeforeElapsed.prototype.check = function () {
+        var now = Date.now();
+        if (now - this.lastTime < this.requireMs)
+            return false;
+        this.lastTime = now;
+        return true;
+    };
+    return DontCallBeforeElapsed;
+}());
+export { DontCallBeforeElapsed };