jopi-toolkit 3.0.12 → 3.0.15

package/src/jk_schemas/index.ts

@@ -41,64 +41,10 @@ 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);
@@ -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) {
@@ -168,6 +121,9 @@ 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);
@@ -186,10 +142,15 @@ 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> = {};
+
 //endregion
 
 //region Registry
@@ -275,18 +236,75 @@ 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 ScField<T, Opt extends boolean> {
+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";
+}
+
+interface ScField<T, Opt extends boolean> {
     title: string;
     type: string;
 
@@ -302,11 +320,14 @@ export interface ScField<T, Opt extends boolean> {
     validator?: (value: T, allValues: any) => void;
 
     metas?: Record<string, string>;
+
+    onTableRendering?: ScOnTableRenderingInfo;
 }
 
-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 +335,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 +354,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 +389,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_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 };

package/src/jk_tools/index.js

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