jopi-toolkit 3.0.12 → 3.0.24

package/src/jk_fs/jBundler_ifServer.ts

@@ -181,13 +181,34 @@ 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 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 fs.readFile(filePath, 'utf8');
+        return JSON.parse(txt) as T;
+    } else {
+        try {
+            let txt = await fs.readFile(filePath, 'utf8');
+            return JSON.parse(txt) as T;
+        }
+        catch {
+            // @ts-ignore
+            return undefined;
+        }
+    }
 }
 
 export function readTextFromFileSync(filePath: string): string {

package/src/jk_logs/index.js

@@ -0,0 +1,371 @@
+// noinspection JSUnusedGlobalSymbols
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import * as jk_terms from "jopi-toolkit/jk_term";
+import { init } from "./jBundler_ifServer.ts";
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["SPAM"] = 1] = "SPAM";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["WARN"] = 3] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 4] = "ERROR";
+    LogLevel[LogLevel["NONE"] = 10] = "NONE";
+})(LogLevel || (LogLevel = {}));
+//endregion
+//region Formater
+var RED = jk_terms.C_RED;
+var ORANGE = jk_terms.C_ORANGE;
+var GREY = jk_terms.C_GREY;
+var LIGHT_BLUE = jk_terms.C_LIGHT_BLUE;
+var RESET = jk_terms.T_RESET;
+export function formatDate1(timeStamp) {
+    var date = new Date(timeStamp);
+    return date.toISOString();
+}
+export var formater_simpleJson = function (entry) {
+    return JSON.stringify(entry);
+};
+export var formater_dateTypeTitleSourceData = function (entry) {
+    var date = formatDate1(entry.date);
+    var json = entry.data ? JSON.stringify(entry.data) : "";
+    var title = (entry.title || "").padEnd(50, " ");
+    json = entry.logger + " |>" + json;
+    switch (entry.level) {
+        case LogLevel.ERROR:
+            return "".concat(date, " - ERROR - ").concat(title).concat(json);
+        case LogLevel.WARN:
+            return "".concat(date, " - WARN  - ").concat(title).concat(json);
+        case LogLevel.INFO:
+            return "".concat(date, " - INFO  - ").concat(title).concat(json);
+        case LogLevel.SPAM:
+            return "".concat(date, " - SPAM  - ").concat(title).concat(json);
+        default:
+            return "";
+    }
+};
+export var formater_typeTitleSourceData_colored = function (entry) {
+    var json = entry.data ? JSON.stringify(entry.data) : "";
+    var title = (entry.title || "").padEnd(50, " ");
+    json = entry.timeDif === undefined
+        ? "".concat(entry.logger, " ").concat(json) : "".concat(entry.logger, " (").concat(entry.timeDif, " ms) ").concat(json);
+    switch (entry.level) {
+        case LogLevel.ERROR:
+            return "".concat(RED, "error").concat(RESET, " - ").concat(title).concat(GREY).concat(json).concat(RESET);
+        case LogLevel.WARN:
+            return "".concat(ORANGE, "warn ").concat(RESET, " - ").concat(title).concat(GREY).concat(json).concat(RESET);
+        case LogLevel.INFO:
+            return "".concat(LIGHT_BLUE, "info ").concat(RESET, " - ").concat(title).concat(GREY).concat(json).concat(RESET);
+        case LogLevel.SPAM:
+            return "".concat(GREY, "spam ").concat(RESET, " - ").concat(title).concat(GREY).concat(json).concat(RESET);
+        default:
+            return "";
+    }
+};
+var ConsoleLogWriter = /** @class */ (function () {
+    function ConsoleLogWriter(formater) {
+        if (formater === void 0) { formater = gDefaultFormater; }
+        this.formater = formater;
+    }
+    ConsoleLogWriter.prototype.addEntry = function (entry) {
+        console.log(this.formater(entry));
+    };
+    ConsoleLogWriter.prototype.addBatch = function (entries) {
+        var _this = this;
+        entries.forEach(function (e) { return _this.addEntry(e); });
+    };
+    return ConsoleLogWriter;
+}());
+var VoidLogWriter = /** @class */ (function () {
+    function VoidLogWriter() {
+    }
+    VoidLogWriter.prototype.addBatch = function (_entries) {
+    };
+    VoidLogWriter.prototype.addEntry = function (_entry) {
+    };
+    return VoidLogWriter;
+}());
+export { VoidLogWriter };
+export function setDefaultWriter(writer) {
+    gDefaultWriter = writer;
+}
+export function getDefaultWriter() {
+    return gDefaultWriter;
+}
+export function setDefaultFormater(formater) {
+    gDefaultFormater = formater;
+}
+export function getDefaultFormater() {
+    return gDefaultFormater;
+}
+var gDefaultFormater = formater_typeTitleSourceData_colored;
+var gDefaultWriter = new ConsoleLogWriter();
+export function getLogger(name, parent) {
+    var fullName = name;
+    if (parent)
+        fullName = parent.fullName + '.' + name;
+    var level = getLogLevelFor(fullName);
+    switch (level) {
+        case LogLevel.SPAM:
+            return new Logger_Spam(parent, name);
+        case LogLevel.INFO:
+            return new Logger_Info(parent, name);
+        case LogLevel.WARN:
+            return new Logger_Warn(parent, name);
+        case LogLevel.ERROR:
+            return new Logger_Error(parent, name);
+    }
+    return new Logger_None(parent, name);
+}
+var JopiLogger = /** @class */ (function () {
+    function JopiLogger(parent, name) {
+        var _this = this;
+        this.name = name;
+        this._onLog = gDefaultWriter;
+        this.fullName = parent ? parent.fullName + '.' + name : name;
+        if (parent) {
+            this._onLog = parent._onLog;
+        }
+        var me = this;
+        this.hSpam = function (title, data) {
+            var td = _this.timeDif;
+            _this.timeDif = undefined;
+            data = _this.mergeData(data);
+            me._onLog.addEntry({
+                level: LogLevel.SPAM,
+                logger: me.fullName, date: Date.now(),
+                title: title,
+                data: data,
+                timeDif: td
+            });
+        };
+        this.hInfo = function (title, data) {
+            var td = _this.timeDif;
+            _this.timeDif = undefined;
+            data = _this.mergeData(data);
+            me._onLog.addEntry({
+                level: LogLevel.INFO,
+                logger: me.fullName, date: Date.now(),
+                title: title,
+                data: data,
+                timeDif: td
+            });
+        };
+        this.hWarn = function (title, data) {
+            var td = _this.timeDif;
+            _this.timeDif = undefined;
+            data = _this.mergeData(data);
+            me._onLog.addEntry({
+                level: LogLevel.WARN,
+                logger: me.fullName, date: Date.now(),
+                title: title,
+                data: data,
+                timeDif: td
+            });
+        };
+        this.hError = function (title, data) {
+            var td = _this.timeDif;
+            _this.timeDif = undefined;
+            data = _this.mergeData(data);
+            me._onLog.addEntry({
+                level: LogLevel.ERROR,
+                logger: me.fullName, date: Date.now(),
+                title: title,
+                data: data,
+                timeDif: td
+            });
+        };
+    }
+    JopiLogger.prototype.mergeData = function (data) {
+        if (!this.extraData)
+            return data;
+        var extraData = this.extraData;
+        this.extraData = undefined;
+        if (!data)
+            return extraData;
+        for (var p in extraData)
+            data[p] = extraData[p];
+        return data;
+    };
+    JopiLogger.prototype.setLogWriter = function (callback) {
+        if (!callback)
+            callback = gDefaultWriter;
+        this._onLog = callback;
+    };
+    JopiLogger.prototype.spam = function (_l) {
+        return false;
+    };
+    JopiLogger.prototype.info = function (_l) {
+        return false;
+    };
+    JopiLogger.prototype.warn = function (_l) {
+        return false;
+    };
+    JopiLogger.prototype.error = function (_l) {
+        return false;
+    };
+    JopiLogger.prototype.beginSpam = function (l) {
+        return gVoidLoggerGroupCallback;
+    };
+    JopiLogger.prototype.beginInfo = function (l) {
+        return gVoidLoggerGroupCallback;
+    };
+    JopiLogger.prototype.doBegin = function (l, w) {
+        var _this = this;
+        var startTime = Date.now();
+        return function (data) {
+            _this.timeDif = Date.now() - startTime;
+            _this.doCall(l, w, data);
+        };
+    };
+    JopiLogger.prototype.doCall = function (l, w, data) {
+        this.extraData = data;
+        if (l) {
+            if (l instanceof Function) {
+                l(w);
+            }
+            else {
+                w(l);
+            }
+        }
+        return true;
+    };
+    return JopiLogger;
+}());
+var Logger_None = /** @class */ (function (_super) {
+    __extends(Logger_None, _super);
+    function Logger_None() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return Logger_None;
+}(JopiLogger));
+var Logger_Spam = /** @class */ (function (_super) {
+    __extends(Logger_Spam, _super);
+    function Logger_Spam() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Logger_Spam.prototype.spam = function (l) {
+        return this.doCall(l, this.hSpam);
+    };
+    Logger_Spam.prototype.info = function (l) {
+        return this.doCall(l, this.hInfo);
+    };
+    Logger_Spam.prototype.warn = function (l) {
+        return this.doCall(l, this.hWarn);
+    };
+    Logger_Spam.prototype.error = function (l) {
+        return this.doCall(l, this.hError);
+    };
+    Logger_Spam.prototype.beginSpam = function (l) {
+        return this.doBegin(l, this.hSpam);
+    };
+    Logger_Spam.prototype.beginInfo = function (l) {
+        return this.doBegin(l, this.hInfo);
+    };
+    return Logger_Spam;
+}(JopiLogger));
+var Logger_Info = /** @class */ (function (_super) {
+    __extends(Logger_Info, _super);
+    function Logger_Info() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Logger_Info.prototype.info = function (l) {
+        return this.doCall(l, this.hInfo);
+    };
+    Logger_Info.prototype.warn = function (l) {
+        return this.doCall(l, this.hWarn);
+    };
+    Logger_Info.prototype.error = function (l) {
+        return this.doCall(l, this.hError);
+    };
+    Logger_Info.prototype.beginInfo = function (l) {
+        return this.doBegin(l, this.hInfo);
+    };
+    return Logger_Info;
+}(JopiLogger));
+var Logger_Warn = /** @class */ (function (_super) {
+    __extends(Logger_Warn, _super);
+    function Logger_Warn() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Logger_Warn.prototype.warn = function (l) {
+        return this.doCall(l, this.hWarn);
+    };
+    Logger_Warn.prototype.error = function (l) {
+        return this.doCall(l, this.hError);
+    };
+    return Logger_Warn;
+}(JopiLogger));
+var Logger_Error = /** @class */ (function (_super) {
+    __extends(Logger_Error, _super);
+    function Logger_Error() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Logger_Error.prototype.error = function (l) {
+        return this.doCall(l, this.hError);
+    };
+    return Logger_Error;
+}(JopiLogger));
+var gVoidLoggerGroupCallback = function () { };
+function getLogLevelName(level) {
+    switch (level) {
+        case LogLevel.SPAM:
+            return "SPAM";
+        case LogLevel.ERROR:
+            return "ERROR";
+        case LogLevel.INFO:
+            return "INFO";
+        case LogLevel.WARN:
+            return "WARN";
+        case LogLevel.NONE:
+            return "NONE";
+    }
+}
+function getLogLevelByName(name) {
+    switch (name) {
+        case "NONE": return LogLevel.NONE;
+        case "SPAM": return LogLevel.SPAM;
+        case "INFO": return LogLevel.INFO;
+        case "WARN": return LogLevel.WARN;
+        case "ERROR": return LogLevel.ERROR;
+    }
+    return undefined;
+}
+var Initializer = /** @class */ (function () {
+    function Initializer() {
+    }
+    Initializer.prototype.setLogLevel = function (name, config) {
+        var logLevel = getLogLevelByName(config.level || "NONE");
+        if (!logLevel)
+            logLevel = LogLevel.NONE;
+        gRegistry[name] = logLevel;
+    };
+    return Initializer;
+}());
+function getLogLevelFor(name) {
+    var entry = gRegistry[name];
+    if (entry !== undefined)
+        return entry;
+    for (var prefix in gRegistry) {
+        if (name.startsWith(prefix + ".")) {
+            return gRegistry[prefix];
+        }
+    }
+    return gDefaultLogLevel;
+}
+var gDefaultLogLevel = LogLevel.WARN;
+var gRegistry = {};
+//endregion
+init(new Initializer());

package/src/jk_logs/jBundler_ifServer.js

@@ -0,0 +1,24 @@
+import * as jk_app from "jopi-toolkit/jk_app";
+import * as jk_fs from "jopi-toolkit/jk_fs";
+export function init(init) {
+    var mainDir = jk_app.findPackageJsonDir();
+    var filePath = jk_fs.join(mainDir, "logConfig.json");
+    if (!jk_fs.isFileSync(filePath))
+        return;
+    var text = jk_fs.readTextFromFileSync(jk_fs.join(mainDir, "logConfig.json"));
+    if (!text)
+        return;
+    var logJson = JSON.parse(text);
+    if (!logJson.config)
+        return;
+    for (var logName in logJson.config) {
+        var logConfig = logJson.config[logName];
+        if (typeof (logConfig) === "string") {
+            logConfig = { level: logConfig.toUpperCase().trim() };
+        }
+        else if (!logConfig) {
+            logConfig = { level: "none" };
+        }
+        init.setLogLevel(logName, logConfig);
+    }
+}

package/src/jk_schemas/index.js

@@ -48,57 +48,13 @@ var SchemaError = /** @class */ (function (_super) {
 export function declareError(message, errorCode) {
     throw new SchemaError(message, errorCode);
 }
-var byTypeValidator = {
-    "string": function (v, f) {
-        if (typeof v !== "string") {
-            declareError(f.errorMessage_theValueIsInvalid || "Value must be a string", "INVALID_TYPE");
-            return;
-        }
-        var sf = f;
-        if ((sf.minLength !== undefined) && (v.length < sf.minLength)) {
-            declareError(sf.errorMessage_minLength || "Value must be at least ".concat(sf.minLength, " characters long"), "INVALID_LENGTH");
-            return;
-        }
-        if ((sf.maxLength !== undefined) && (v.length > sf.maxLength)) {
-            declareError(sf.errorMessage_maxLength || "Value must be less than ".concat(sf.maxLength, " characters long"), "INVALID_LENGTH");
-            return;
-        }
-    },
-    "number": function (v, f) {
-        if (typeof v !== "number") {
-            declareError(f.errorMessage_theValueIsInvalid || "Value must be a number", "INVALID_TYPE");
-        }
-        var sf = f;
-        if ((sf.minValue !== undefined) && (v < sf.minValue)) {
-            declareError(sf.errorMessage_minValue || "Value must be at least ".concat(sf.minValue), "INVALID_LENGTH");
-            return;
-        }
-        if ((sf.maxValue !== undefined) && (v > sf.maxValue)) {
-            declareError(sf.errorMessage_maxValue || "Value must be less than ".concat(sf.maxValue), "INVALID_LENGTH");
-            return;
-        }
-    },
-    "boolean": function (v, f) {
-        if (typeof v !== "boolean") {
-            declareError(f.errorMessage_theValueIsInvalid || "Value must be a boolean", "INVALID_TYPE");
-        }
-        var sf = f;
-        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, schema) {
+    // 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) {
             if (e instanceof SchemaError) {
@@ -112,6 +68,11 @@ export function validateSchema(data, schema) {
             }
         }
     }
+    // >>> Check each field individually.
+    // Each time it will:
+    // - Normalize the value.
+    // - Check if optional + undefined.
+    // - Apply validator for the field type.
     var fieldErrors;
     for (var fieldName in schema.desc) {
         var defaultErrorMessage = void 0;
@@ -120,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) {
@@ -141,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) {
@@ -159,9 +120,11 @@ export function validateSchema(data, schema) {
             }
         }
     }
+    // >>> 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) {
             if (e instanceof SchemaError) {
@@ -176,10 +139,27 @@ export function validateSchema(data, schema) {
             }
         }
     }
+    // No error ? --> undefined.
+    // Otherwise returns the errors.
+    //
     if (!fieldErrors)
         return undefined;
     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());
@@ -209,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;
 }
@@ -223,12 +235,82 @@ export function string(title, optional, infos) {
     }
     return __assign(__assign({}, infos), { title: title, optional: optional, type: "string" });
 }
+byTypeValidator["string"] = function (v, f) {
+    if (typeof v !== "string") {
+        declareError(f.errorMessage_theValueIsInvalid || "Value must be a string", "INVALID_TYPE");
+        return;
+    }
+    var sf = f;
+    if ((sf.minLength !== undefined) && (v.length < sf.minLength)) {
+        declareError(sf.errorMessage_minLength || "Value must be at least ".concat(sf.minLength, " characters long"), "INVALID_LENGTH");
+        return;
+    }
+    if ((sf.maxLength !== undefined) && (v.length > sf.maxLength)) {
+        declareError(sf.errorMessage_maxLength || "Value must be less than ".concat(sf.maxLength, " characters long"), "INVALID_LENGTH");
+        return;
+    }
+};
 export function boolean(title, optional, infos) {
     return __assign(__assign({}, infos), { title: title, optional: optional, type: "boolean" });
 }
+byTypeValidator["boolean"] = function (v, f) {
+    if (typeof v !== "boolean") {
+        declareError(f.errorMessage_theValueIsInvalid || "Value must be a boolean", "INVALID_TYPE");
+    }
+    var sf = f;
+    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 number(title, optional, infos) {
     return __assign(__assign({}, infos), { title: title, optional: optional, type: "number" });
 }
+export function formatNumber(value, fieldNumber, defaultLocalFormat, defaultCurrency) {
+    if (defaultLocalFormat === void 0) { defaultLocalFormat = "en-US"; }
+    if (defaultCurrency === void 0) { defaultCurrency = "USD"; }
+    var amount = parseFloat(value);
+    var 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"] = function (v, f) {
+    if (typeof v !== "number") {
+        declareError(f.errorMessage_theValueIsInvalid || "Value must be a number", "INVALID_TYPE");
+    }
+    var sf = f;
+    if ((sf.minValue !== undefined) && (v < sf.minValue)) {
+        declareError(sf.errorMessage_minValue || "Value must be at least ".concat(sf.minValue), "INVALID_LENGTH");
+        return;
+    }
+    if ((sf.maxValue !== undefined) && (v > sf.maxValue)) {
+        declareError(sf.errorMessage_maxValue || "Value must be less than ".concat(sf.maxValue), "INVALID_LENGTH");
+        return;
+    }
+};
+//endregion
+//region Currency
+export function currency(title, optional, infos) {
+    return number(title, optional, __assign(__assign({}, infos), { displayType: "currency" }));
+}
+//endregion
+//region Percent
+export function percent(title, optional, infos) {
+    return number(title, optional, __assign(__assign({}, infos), { displayType: "percent" }));
+}
 export function file(title, optional, infos) {
     return __assign(__assign({}, infos), { title: title, optional: optional, type: "file" });
 }