@leyyo/common 1.0.0

package/dist/error/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./index-types"), exports);
+__exportStar(require("./common-error-impl"), exports);
+__exportStar(require("./exception"), exports);
+__exportStar(require("./caused-exception"), exports);
+__exportStar(require("./developer-exception"), exports);
+__exportStar(require("./assertion-exception"), exports);
+__exportStar(require("./multiple-exception"), exports);

package/dist/error/multiple-exception.d.ts

@@ -0,0 +1,8 @@
+import { ExceptionLike } from "./index-types";
+import { Exception } from "./exception";
+export declare class MultipleException extends Exception {
+    protected _errors: Array<ExceptionLike>;
+    constructor(...errors: Array<Error>);
+    push(...errors: Array<Error>): this;
+    get errors(): Array<ExceptionLike>;
+}

package/dist/error/multiple-exception.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultipleException = void 0;
+const exception_1 = require("./exception");
+// noinspection Annotator
+class MultipleException extends exception_1.Exception {
+    constructor(...errors) {
+        var _a;
+        const first = errors[0];
+        super((_a = first === null || first === void 0 ? void 0 : first.name) !== null && _a !== void 0 ? _a : "Multiple exceptions are occurred", {});
+        this._errors = [];
+        this.push(...errors);
+    }
+    push(...errors) {
+        errors.forEach(e => {
+            if (e instanceof MultipleException) {
+                this._errors.push(...e._errors);
+            }
+            else if (e instanceof exception_1.Exception) {
+                this._errors.push(e);
+            }
+            else {
+                this._errors.push(exception_1.Exception.$error.build(e));
+            }
+        });
+        return this;
+    }
+    // noinspection JSUnusedGlobalSymbols
+    get errors() {
+        return [...this._errors]; // cloned response
+    }
+}
+exports.MultipleException = MultipleException;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { leyyo } from "./leyyo";
+export * from './aliases';
+export * from './constants';
+export * from './literals';
+declare const is: import("./is").CommonIs;
+declare const callback: import("./callback").CommonCallback;
+export { leyyo, is, callback };

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callback = exports.is = exports.leyyo = void 0;
+const leyyo_1 = require("./leyyo");
+Object.defineProperty(exports, "leyyo", { enumerable: true, get: function () { return leyyo_1.leyyo; } });
+__exportStar(require("./aliases"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./literals"), exports);
+const is = leyyo_1.leyyo.is;
+exports.is = is;
+const callback = leyyo_1.leyyo.callback;
+exports.callback = callback;

package/dist/internal.d.ts

@@ -0,0 +1 @@
+export declare const FQN_PCK = "leyyo.common";

package/dist/internal.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FQN_PCK = void 0;
+exports.FQN_PCK = 'leyyo.common';

package/dist/is/common-is-impl.d.ts

@@ -0,0 +1,22 @@
+import { CommonIs, CommonIsSecure } from "./index-types";
+import { Leyyo } from "../leyyo";
+export declare class CommonIsImpl implements CommonIs, CommonIsSecure {
+    $init(leyyo: Leyyo): void;
+    empty(value: unknown): boolean;
+    primitive(value: unknown): boolean;
+    value(value: unknown): boolean;
+    key(value: unknown): boolean;
+    object(value: unknown): boolean;
+    array(value: unknown): boolean;
+    func(value: unknown): boolean;
+    number(value: unknown): boolean;
+    integer(value: unknown): boolean;
+    string(value: unknown): boolean;
+    text(value: unknown): boolean;
+    clazz(value: unknown): boolean;
+    boolean(value: unknown): boolean;
+    true(value: unknown): boolean;
+    false(value: unknown): boolean;
+    get $back(): CommonIs;
+    get $secure(): CommonIsSecure;
+}

package/dist/is/common-is-impl.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonIsImpl = void 0;
+const literals_1 = require("../literals");
+// noinspection JSUnusedGlobalSymbols, JSUnusedLocalSymbols
+class CommonIsImpl {
+    $init(leyyo) {
+    }
+    // region is
+    empty(value) {
+        return (value === undefined || value === null);
+    }
+    primitive(value) {
+        return literals_1.PrimitiveItems.includes((typeof value));
+    }
+    value(value) {
+        return literals_1.RealValueItems.includes((typeof value));
+    }
+    key(value) {
+        return literals_1.KeyValueItems.includes((typeof value));
+    }
+    object(value) {
+        return value && typeof value === 'object' && !Array.isArray(value);
+    }
+    array(value) {
+        return value && typeof value === 'object' && Array.isArray(value);
+    }
+    func(value) {
+        return typeof value === 'function';
+    }
+    number(value) {
+        return (typeof value === 'number') && !isNaN(value) && isFinite(value);
+    }
+    integer(value) {
+        return this.number(value) && Number.isSafeInteger(value);
+    }
+    string(value) {
+        return typeof value === 'string';
+    }
+    text(value) {
+        return this.string(value) && value.trim() !== '';
+    }
+    clazz(value) {
+        return this.text(value) || this.func(value) || this.object(value);
+    }
+    boolean(value) {
+        return (typeof value === 'boolean');
+    }
+    true(value) {
+        return (value === true) ||
+            (this.text(value) && literals_1.WeakTrueItems.includes(value.toLowerCase())) ||
+            (this.number(value) && value > 0);
+    }
+    false(value) {
+        return (value === false) ||
+            (this.text(value) && literals_1.WeakFalseItems.includes(value.toLowerCase())) ||
+            (this.number(value) && value <= 0);
+    }
+    get $back() {
+        return this;
+    }
+    get $secure() {
+        return this;
+    }
+}
+exports.CommonIsImpl = CommonIsImpl;

package/dist/is/index-types.d.ts

@@ -0,0 +1,22 @@
+import { ShiftMain, ShiftSecure } from "../aliases";
+import { Leyyo } from "../leyyo";
+export interface CommonIs extends ShiftSecure<CommonIsSecure> {
+    empty(value: unknown): boolean;
+    primitive(value: unknown): boolean;
+    value(value: unknown): boolean;
+    key(value: unknown): boolean;
+    object(value: unknown): boolean;
+    array(value: unknown): boolean;
+    func(value: unknown): boolean;
+    number(value: unknown): boolean;
+    integer(value: unknown): boolean;
+    string(value: unknown): boolean;
+    text(value: unknown): boolean;
+    clazz(value: unknown): boolean;
+    boolean(value: unknown): boolean;
+    true(value: unknown): boolean;
+    false(value: unknown): boolean;
+}
+export interface CommonIsSecure extends ShiftMain<CommonIs> {
+    $init(leyyo: Leyyo): void;
+}

package/dist/is/index-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/is/index.d.ts

@@ -0,0 +1,2 @@
+export * from './index-types';
+export * from './common-is-impl';

package/dist/is/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./index-types"), exports);
+__exportStar(require("./common-is-impl"), exports);

package/dist/leyyo/index-types.d.ts

@@ -0,0 +1,16 @@
+import { CommonCallback } from "../callback";
+import { CommonIs } from "../is";
+import { CommonAssertion } from "../assertion";
+import { CommonError } from "../error";
+import { CommonLog } from "../log";
+import { CommonStorage } from "../storage";
+import { CommonTo } from "../to";
+export interface Leyyo {
+    readonly is: CommonIs;
+    readonly callback: CommonCallback;
+    readonly assertion: CommonAssertion;
+    readonly error: CommonError;
+    readonly log: CommonLog;
+    readonly storage: CommonStorage;
+    readonly to: CommonTo;
+}

package/dist/leyyo/index-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/leyyo/index.d.ts

@@ -0,0 +1,2 @@
+export * from './index-types';
+export * from './leyyo-impl';

package/dist/leyyo/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./index-types"), exports);
+__exportStar(require("./leyyo-impl"), exports);

package/dist/leyyo/leyyo-impl.d.ts

@@ -0,0 +1,24 @@
+import { CommonCallback } from "../callback";
+import { Leyyo } from "./index-types";
+import { CommonIs } from "../is";
+import { CommonAssertion } from "../assertion";
+import { CommonError } from "../error";
+import { CommonLog } from "../log";
+import { CommonStorage } from "../storage";
+import { CommonTo } from "../to";
+export declare class LeyyoImpl implements Leyyo {
+    readonly callback: CommonCallback;
+    readonly is: CommonIs;
+    readonly assertion: CommonAssertion;
+    readonly error: CommonError;
+    readonly log: CommonLog;
+    readonly storage: CommonStorage;
+    readonly to: CommonTo;
+    constructor();
+    private init;
+    private postInit;
+    private initFqnRegister;
+    private initErrorRegister;
+    private initEnumRegister;
+}
+export declare const leyyo: Leyyo;

package/dist/leyyo/leyyo-impl.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.leyyo = exports.LeyyoImpl = void 0;
+const callback_1 = require("../callback");
+const is_1 = require("../is");
+const assertion_1 = require("../assertion");
+const error_1 = require("../error");
+const log_1 = require("../log");
+const storage_1 = require("../storage");
+const to_1 = require("../to");
+const constants_1 = require("../constants");
+const internal_1 = require("../internal");
+const literals_1 = require("../literals");
+class LeyyoImpl {
+    constructor() {
+        this.is = new is_1.CommonIsImpl();
+        this.storage = new storage_1.CommonStorageImpl();
+        this.callback = new callback_1.CommonCallbackImpl(); // storage
+        this.log = new log_1.CommonLogImpl(); // callback
+        this.error = new error_1.CommonErrorImpl(); // callback
+        this.assertion = new assertion_1.CommonAssertionImpl(); // is, callback
+        this.to = new to_1.CommonToImpl(); // is, callback, assertion
+        this.init();
+        this.postInit();
+        this.initFqnRegister();
+        this.initErrorRegister();
+        this.initEnumRegister();
+    }
+    init() {
+        this.is.$secure.$init(this);
+        this.storage.$secure.$init(this);
+        this.callback.$secure.$init(this);
+        this.log.$secure.$init(this);
+        this.error.$secure.$init(this);
+        this.assertion.$secure.$init(this);
+        this.to.$secure.$init(this);
+    }
+    postInit() {
+        (0, assertion_1.$$setLeyyo)(this);
+        log_1.LoggerImpl.$setLeyyo(this);
+        error_1.Exception.$setLeyyo(this);
+    }
+    initFqnRegister() {
+        this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, is_1.CommonIsImpl, 'class', internal_1.FQN_PCK);
+        this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, storage_1.CommonStorageImpl, 'class', internal_1.FQN_PCK);
+        this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, callback_1.CommonCallbackImpl, 'class', internal_1.FQN_PCK);
+        this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, log_1.CommonLogImpl, 'class', internal_1.FQN_PCK);
+        this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, error_1.CommonErrorImpl, 'class', internal_1.FQN_PCK);
+        this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, assertion_1.CommonAssertionImpl, 'class', internal_1.FQN_PCK);
+        this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, to_1.CommonToImpl, 'class', internal_1.FQN_PCK);
+        this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, storage_1.List, 'class', internal_1.FQN_PCK);
+        this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, log_1.LoggerImpl, 'class', internal_1.FQN_PCK);
+        this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, assertion_1.assert, 'function', internal_1.FQN_PCK);
+    }
+    initErrorRegister() {
+        [error_1.Exception, error_1.AssertionException, error_1.CausedException, error_1.DeveloperException, error_1.MultipleException].forEach(cls => {
+            this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, cls, 'class', internal_1.FQN_PCK);
+            this.callback.queueForCallback(constants_1.LY_PENDING_ERROR_REGISTER, cls);
+        });
+    }
+    initEnumRegister() {
+        [literals_1.PrimitiveItems, literals_1.RealValueItems, literals_1.KeyValueItems, literals_1.WeakTrueItems, literals_1.WeakFalseItems,
+            literals_1.HttpMethodItems, literals_1.HttpPlaceItems, literals_1.SeverityItems, literals_1.EnvironmentItems,
+            literals_1.CountryCodeItems, literals_1.LanguageCodeItems, literals_1.LocaleCodeItems].forEach(enm => {
+            this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, enm, 'enum', internal_1.FQN_PCK);
+            this.callback.queueForCallback(constants_1.LY_PENDING_ENUM_REGISTER, enm);
+        });
+    }
+}
+exports.LeyyoImpl = LeyyoImpl;
+exports.leyyo = new LeyyoImpl();

package/dist/literals.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Weak True items
+ * */
+export declare const PrimitiveItems: readonly ["string", "number", "bigint", "boolean"];
+/**
+ * Weak True
+ * */
+export type Primitive = typeof PrimitiveItems[number];
+/**
+ * Weak True items
+ * */
+export declare const RealValueItems: readonly ["string", "number", "bigint", "boolean", "object", "function"];
+/**
+ * Weak True
+ * */
+export type RealValue = typeof RealValueItems[number];
+/**
+ * Weak True items
+ * */
+export declare const KeyValueItems: readonly ["string", "number"];
+/**
+ * Weak True items
+ * */
+export declare const WeakTrueItems: readonly ["1", "true", "t", "yes", "y", "on"];
+/**
+ * Weak True
+ * */
+export type WeakTrue = typeof WeakTrueItems[number];
+/**
+ * Weak False items
+ * */
+export declare const WeakFalseItems: readonly ["0", "-1", "false", "f", "no", "n", "off"];
+/**
+ * Weak False
+ * */
+export type WeakFalse = typeof WeakFalseItems[number];
+/**
+ * Weak Boolean
+ * */
+export type WeakBoolean = WeakTrue & WeakFalse;
+/**
+ * Http Method items
+ * */
+export declare const HttpMethodItems: readonly ["delete", "get", "head", "link", "options", "patch", "post", "purge", "put", "unlink"];
+/**
+ * Http Method
+ * */
+export type HttpMethod = typeof HttpMethodItems[number];
+/**
+ * Http Place items
+ * */
+export declare const HttpPlaceItems: readonly ["query", "body", "header", "path"];
+/**
+ * Http Place
+ * */
+export type HttpPlace = typeof HttpPlaceItems[number];
+/**
+ * Severity items
+ * */
+export declare const SeverityItems: readonly ["debug", "error", "fatal", "info", "log", "trace", "warn"];
+/**
+ * Severity for log and errors
+ * */
+export type Severity = typeof SeverityItems[number];
+/**
+ * Environment items
+ * */
+export declare const EnvironmentItems: readonly ["automation", "development", "local", "production", "staging", "test"];
+/**
+ * Environment
+ * */
+export type Environment = typeof EnvironmentItems[number];
+/**
+ * Country code items
+ * */
+export declare const CountryCodeItems: readonly ["AD", "AE", "AF", "AG", "AI", "AL", "AM", "AN", "AO", "AQ", "AR", "AS", "AT", "AU", "AW", "AX", "AZ", "BA", "BB", "BD", "BE", "BF", "BG", "BH", "BI", "BJ", "BM", "BN", "BO", "BR", "BS", "BT", "BV", "BW", "BY", "BZ", "CA", "CC", "CD", "CF", "CG", "CH", "CI", "CK", "CL", "CM", "CN", "CO", "CR", "CS", "CU", "CV", "CX", "CY", "CZ", "DE", "DJ", "DK", "DM", "DO", "DZ", "EC", "EE", "EG", "EH", "ER", "ES", "ET", "FI", "FJ", "FK", "FM", "FO", "FR", "GA", "GB", "GD", "GE", "GF", "GG", "GH", "GI", "GL", "GM", "GN", "GP", "GQ", "GR", "GS", "GT", "GU", "GW", "GY", "HK", "HM", "HN", "HR", "HT", "HU", "ID", "IE", "IL", "IM", "IN", "IO", "IQ", "IR", "IS", "IT", "JE", "JM", "JO", "JP", "KE", "KG", "KH", "KI", "KM", "KN", "KP", "KR", "KW", "KY", "KZ", "LA", "LB", "LC", "LI", "LK", "LR", "LS", "LT", "LU", "LV", "LY", "MA", "MC", "MD", "MG", "MH", "MK", "ML", "MM", "MN", "MO", "MP", "MQ", "MR", "MS", "MT", "MU", "MV", "MW", "MX", "MY", "MZ", "NA", "NC", "NE", "NF", "NG", "NI", "NL", "NO", "NP", "NR", "NU", "NZ", "OM", "PA", "PE", "PF", "PG", "PH", "PK", "PL", "PM", "PN", "PR", "PS", "PT", "PW", "PY", "QA", "RE", "RO", "RU", "RW", "SA", "SB", "SC", "SD", "SE", "SG", "SH", "SI", "SJ", "SK", "SL", "SM", "SN", "SO", "SR", "ST", "SV", "SY", "SZ", "TC", "TD", "TF", "TG", "TH", "TJ", "TK", "TL", "TM", "TN", "TO", "TR", "TT", "TV", "TW", "TZ", "UA", "UG", "UM", "US", "UY", "UZ", "VA", "VC", "VE", "VG", "VI", "VN", "VU", "WF", "WS", "YE", "YT", "ZA", "ZM", "ZW"];
+/**
+ * Country code
+ * */
+export type CountryCode = typeof CountryCodeItems[number];
+/**
+ * Language code items
+ * */
+export declare const LanguageCodeItems: readonly ["af", "an", "ar", "as", "ast", "az", "be", "bg", "bn", "br", "bs", "ca", "ce", "ch", "co", "cr", "cs", "cv", "cy", "da", "de", "el", "en", "eo", "es", "et", "eu", "fa", "fi", "fj", "fo", "fr", "fur", "fy", "ga", "gd", "gl", "gu", "he", "hi", "hr", "hsb", "ht", "hu", "hy", "id", "is", "it", "iu", "ja", "ji", "ka", "kk", "km", "kn", "ko", "ks", "ky", "la", "lb", "lt", "lv", "mi", "mk", "ml", "mo", "mr", "ms", "mt", "my", "nb", "ne", "ng", "nl", "nn", "no", "nv", "oc", "om", "or", "pa", "pl", "pt", "qu", "rm", "ro", "ru", "sa", "sb", "sc", "sd", "sg", "si", "sk", "sl", "so", "sq", "sr", "sv", "sw", "sx", "sz", "ta", "te", "th", "tig", "tk", "tlh", "tn", "tr", "ts", "tt", "uk", "ur", "ve", "vi", "vo", "wa", "xh", "zh", "zu"];
+/**
+ * Language codes
+ * */
+export type LanguageCode = typeof LanguageCodeItems[number];
+/**
+ * Locale code items
+ * */
+export declare const LocaleCodeItems: readonly ["af", "an", "ar", "ar-ae", "ar-bh", "ar-dz", "ar-eg", "ar-iq", "ar-jo", "ar-kw", "ar-lb", "ar-ly", "ar-ma", "ar-om", "ar-qa", "ar-sa", "ar-sy", "ar-tn", "ar-ye", "as", "ast", "az", "be", "bg", "bn", "br", "bs", "ca", "ce", "ch", "co", "cr", "cs", "cv", "cy", "da", "de", "de-at", "de-ch", "de-de", "de-li", "de-lu", "el", "en", "en-au", "en-bz", "en-ca", "en-gb", "en-ie", "en-jm", "en-nz", "en-ph", "en-tt", "en-us", "en-za", "en-zw", "eo", "es", "es-ar", "es-bo", "es-cl", "es-co", "es-cr", "es-do", "es-ec", "es-es", "es-gt", "es-hn", "es-mx", "es-ni", "es-pa", "es-pe", "es-pr", "es-py", "es-sv", "es-uy", "es-ve", "et", "eu", "fa", "fa-ir", "fi", "fj", "fo", "fr", "fr-be", "fr-ca", "fr-ch", "fr-fr", "fr-lu", "fr-mc", "fur", "fy", "ga", "gd", "gd-ie", "gl", "gu", "he", "hi", "hr", "hsb", "ht", "hu", "hy", "id", "is", "it", "it-ch", "iu", "ja", "ji", "ka", "kk", "km", "kn", "ko", "ko-kp", "ko-kr", "ks", "ky", "la", "lb", "lt", "lv", "mi", "mk", "ml", "mo", "mr", "ms", "mt", "my", "nb", "ne", "ng", "nl", "nl-be", "nn", "no", "nv", "oc", "om", "or", "pa", "pa-in", "pa-pk", "pl", "pt", "pt-br", "qu", "rm", "ro", "ro-mo", "ru", "ru-mo", "sa", "sb", "sc", "sd", "sg", "si", "sk", "sl", "so", "sq", "sr", "sv", "sv-fi", "sv-sv", "sw", "sx", "sz", "ta", "te", "th", "tig", "tk", "tlh", "tn", "tr", "ts", "tt", "uk", "ur", "ve", "vi", "vo", "wa", "xh", "zh", "zh-cn", "zh-hk", "zh-sg", "zh-tw", "zu"];
+/**
+ * Locale codes
+ *
+ * Pattern: [Language Code]-[Country Code]
+ * */
+export type LocaleCode = typeof LocaleCodeItems[number];

package/dist/literals.js

@@ -0,0 +1,77 @@
+"use strict";
+// noinspection JSUnusedGlobalSymbols
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocaleCodeItems = exports.LanguageCodeItems = exports.CountryCodeItems = exports.EnvironmentItems = exports.SeverityItems = exports.HttpPlaceItems = exports.HttpMethodItems = exports.WeakFalseItems = exports.WeakTrueItems = exports.KeyValueItems = exports.RealValueItems = exports.PrimitiveItems = void 0;
+/**
+ * Weak True items
+ * */
+exports.PrimitiveItems = ['string', 'number', 'bigint', 'boolean'];
+/**
+ * Weak True items
+ * */
+exports.RealValueItems = ['string', 'number', 'bigint', 'boolean', 'object', 'function'];
+/**
+ * Weak True items
+ * */
+exports.KeyValueItems = ['string', 'number'];
+/**
+ * Weak True items
+ * */
+exports.WeakTrueItems = ['1', 'true', 't', 'yes', 'y', 'on'];
+/**
+ * Weak False items
+ * */
+exports.WeakFalseItems = ['0', '-1', 'false', 'f', 'no', 'n', 'off'];
+/**
+ * Http Method items
+ * */
+exports.HttpMethodItems = ['delete', 'get', 'head', 'link', 'options', 'patch', 'post', 'purge', 'put', 'unlink'];
+/**
+ * Http Place items
+ * */
+exports.HttpPlaceItems = ['query', 'body', 'header', 'path'];
+/**
+ * Severity items
+ * */
+exports.SeverityItems = ['debug', 'error', 'fatal', 'info', 'log', 'trace', 'warn'];
+/**
+ * Environment items
+ * */
+exports.EnvironmentItems = ['automation', 'development', 'local', 'production', 'staging', 'test'];
+/**
+ * Country code items
+ * */
+exports.CountryCodeItems = ['AD', 'AE', 'AF', 'AG', 'AI', 'AL', 'AM', 'AN', 'AO', 'AQ', 'AR', 'AS', 'AT', 'AU', 'AW', 'AX',
+    'AZ', 'BA', 'BB', 'BD', 'BE', 'BF', 'BG', 'BH', 'BI', 'BJ', 'BM', 'BN', 'BO', 'BR', 'BS', 'BT', 'BV', 'BW', 'BY', 'BZ', 'CA', 'CC', 'CD',
+    'CF', 'CG', 'CH', 'CI', 'CK', 'CL', 'CM', 'CN', 'CO', 'CR', 'CS', 'CU', 'CV', 'CX', 'CY', 'CZ', 'DE', 'DJ', 'DK', 'DM', 'DO', 'DZ', 'EC',
+    'EE', 'EG', 'EH', 'ER', 'ES', 'ET', 'FI', 'FJ', 'FK', 'FM', 'FO', 'FR', 'GA', 'GB', 'GD', 'GE', 'GF', 'GG', 'GH', 'GI', 'GL', 'GM', 'GN',
+    'GP', 'GQ', 'GR', 'GS', 'GT', 'GU', 'GW', 'GY', 'HK', 'HM', 'HN', 'HR', 'HT', 'HU', 'ID', 'IE', 'IL', 'IM', 'IN', 'IO', 'IQ', 'IR', 'IS',
+    'IT', 'JE', 'JM', 'JO', 'JP', 'KE', 'KG', 'KH', 'KI', 'KM', 'KN', 'KP', 'KR', 'KW', 'KY', 'KZ', 'LA', 'LB', 'LC', 'LI', 'LK', 'LR', 'LS',
+    'LT', 'LU', 'LV', 'LY', 'MA', 'MC', 'MD', 'MG', 'MH', 'MK', 'ML', 'MM', 'MN', 'MO', 'MP', 'MQ', 'MR', 'MS', 'MT', 'MU', 'MV', 'MW', 'MX',
+    'MY', 'MZ', 'NA', 'NC', 'NE', 'NF', 'NG', 'NI', 'NL', 'NO', 'NP', 'NR', 'NU', 'NZ', 'OM', 'PA', 'PE', 'PF', 'PG', 'PH', 'PK', 'PL', 'PM',
+    'PN', 'PR', 'PS', 'PT', 'PW', 'PY', 'QA', 'RE', 'RO', 'RU', 'RW', 'SA', 'SB', 'SC', 'SD', 'SE', 'SG', 'SH', 'SI', 'SJ', 'SK', 'SL', 'SM',
+    'SN', 'SO', 'SR', 'ST', 'SV', 'SY', 'SZ', 'TC', 'TD', 'TF', 'TG', 'TH', 'TJ', 'TK', 'TL', 'TM', 'TN', 'TO', 'TR', 'TT', 'TV', 'TW', 'TZ',
+    'UA', 'UG', 'UM', 'US', 'UY', 'UZ', 'VA', 'VC', 'VE', 'VG', 'VI', 'VN', 'VU', 'WF', 'WS', 'YE', 'YT', 'ZA', 'ZM', 'ZW'];
+/**
+ * Language code items
+ * */
+exports.LanguageCodeItems = ['af', 'an', 'ar', 'as', 'ast', 'az', 'be', 'bg', 'bn', 'br', 'bs', 'ca', 'ce', 'ch', 'co', 'cr', 'cs',
+    'cv', 'cy', 'da', 'de', 'el', 'en', 'eo', 'es', 'et', 'eu', 'fa', 'fi', 'fj', 'fo', 'fr', 'fur', 'fy', 'ga', 'gd', 'gl', 'gu', 'he', 'hi',
+    'hr', 'hsb', 'ht', 'hu', 'hy', 'id', 'is', 'it', 'iu', 'ja', 'ji', 'ka', 'kk', 'km', 'kn', 'ko', 'ks', 'ky', 'la', 'lb', 'lt', 'lv', 'mi',
+    'mk', 'ml', 'mo', 'mr', 'ms', 'mt', 'my', 'nb', 'ne', 'ng', 'nl', 'nn', 'no', 'nv', 'oc', 'om', 'or', 'pa', 'pl', 'pt', 'qu', 'rm', 'ro',
+    'ru', 'sa', 'sb', 'sc', 'sd', 'sg', 'si', 'sk', 'sl', 'so', 'sq', 'sr', 'sv', 'sw', 'sx', 'sz', 'ta', 'te', 'th', 'tig', 'tk', 'tlh',
+    'tn', 'tr', 'ts', 'tt', 'uk', 'ur', 've', 'vi', 'vo', 'wa', 'xh', 'zh', 'zu'];
+/**
+ * Locale code items
+ * */
+exports.LocaleCodeItems = ['af', 'an', 'ar', 'ar-ae', 'ar-bh', 'ar-dz', 'ar-eg', 'ar-iq', 'ar-jo', 'ar-kw', 'ar-lb', 'ar-ly',
+    'ar-ma', 'ar-om', 'ar-qa', 'ar-sa', 'ar-sy', 'ar-tn', 'ar-ye', 'as', 'ast', 'az', 'be', 'bg', 'bn', 'br', 'bs', 'ca', 'ce', 'ch',
+    'co', 'cr', 'cs', 'cv', 'cy', 'da', 'de', 'de-at', 'de-ch', 'de-de', 'de-li', 'de-lu', 'el', 'en', 'en-au', 'en-bz', 'en-ca',
+    'en-gb', 'en-ie', 'en-jm', 'en-nz', 'en-ph', 'en-tt', 'en-us', 'en-za', 'en-zw', 'eo', 'es', 'es-ar', 'es-bo', 'es-cl', 'es-co',
+    'es-cr', 'es-do', 'es-ec', 'es-es', 'es-gt', 'es-hn', 'es-mx', 'es-ni', 'es-pa', 'es-pe', 'es-pr', 'es-py', 'es-sv', 'es-uy',
+    'es-ve', 'et', 'eu', 'fa', 'fa-ir', 'fi', 'fj', 'fo', 'fr', 'fr-be', 'fr-ca', 'fr-ch', 'fr-fr', 'fr-lu', 'fr-mc', 'fur', 'fy', 'ga',
+    'gd', 'gd-ie', 'gl', 'gu', 'he', 'hi', 'hr', 'hsb', 'ht', 'hu', 'hy', 'id', 'is', 'it', 'it-ch', 'iu', 'ja', 'ji', 'ka', 'kk', 'km',
+    'kn', 'ko', 'ko-kp', 'ko-kr', 'ks', 'ky', 'la', 'lb', 'lt', 'lv', 'mi', 'mk', 'ml', 'mo', 'mr', 'ms', 'mt', 'my', 'nb', 'ne', 'ng', 'nl',
+    'nl-be', 'nn', 'no', 'nv', 'oc', 'om', 'or', 'pa', 'pa-in', 'pa-pk', 'pl', 'pt', 'pt-br', 'qu', 'rm', 'ro', 'ro-mo', 'ru', 'ru-mo',
+    'sa', 'sb', 'sc', 'sd', 'sg', 'si', 'sk', 'sl', 'so', 'sq', 'sr', 'sv', 'sv-fi', 'sv-sv', 'sw', 'sx', 'sz', 'ta', 'te', 'th', 'tig',
+    'tk', 'tlh', 'tn', 'tr', 'ts', 'tt', 'uk', 'ur', 've', 'vi', 'vo', 'wa', 'xh', 'zh', 'zh-cn', 'zh-hk', 'zh-sg', 'zh-tw', 'zu'];

package/dist/log/common-log-impl.d.ts

@@ -0,0 +1,13 @@
+import { Leyyo } from "../leyyo";
+import { CommonLog, CommonLogSecure, Logger, LogLine } from "./index-types";
+export declare class CommonLogImpl implements CommonLog, CommonLogSecure {
+    private callback;
+    constructor();
+    get $secure(): CommonLogSecure;
+    $init(leyyo: Leyyo): void;
+    create(clazz: Object | Function | string): Logger;
+    apply(line: LogLine): void;
+    private check;
+    private print;
+    get $back(): CommonLog;
+}