@leyyo/common 1.0.1 → 1.0.3

package/dist/literal/key-value.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyValueItems = void 0;
+/**
+ * Key Value items
+ * */
+exports.KeyValueItems = ['string', 'number'];

package/dist/literal/language-code.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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];

package/dist/literal/language-code.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LanguageCodeItems = void 0;
+/**
+ * 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'];

package/dist/literal/locale-code.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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/literal/locale-code.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocaleCodeItems = void 0;
+/**
+ * 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/literal/primitive.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Primitive items
+ * */
+export declare const PrimitiveItems: readonly ["string", "number", "boolean"];
+/**
+ * Primitive
+ * */
+export type Primitive = typeof PrimitiveItems[number];

package/dist/literal/primitive.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrimitiveItems = void 0;
+/**
+ * Primitive items
+ * */
+exports.PrimitiveItems = ['string', 'number', 'boolean'];

package/dist/literal/real-value.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Real Value items
+ * */
+export declare const RealValueItems: readonly ["string", "number", "bigint", "boolean", "object", "function"];
+/**
+ * Real Value
+ * */
+export type RealValue = typeof RealValueItems[number];

package/dist/literal/real-value.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealValueItems = void 0;
+/**
+ * Real Value items
+ * */
+exports.RealValueItems = ['string', 'number', 'bigint', 'boolean', 'object', 'function'];

package/dist/literal/severity.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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];

package/dist/literal/severity.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeverityItems = void 0;
+/**
+ * Severity items
+ * */
+exports.SeverityItems = ['debug', 'error', 'fatal', 'info', 'log', 'trace', 'warn'];

package/dist/literal/storage-type.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Weak True items
+ * */
+export declare const StorageTypeItems: readonly ["array", "list", "map", "set"];
+/**
+ * Storage type literal, as an enum
+ * */
+export type StorageType = typeof StorageTypeItems[number];

package/dist/literal/storage-type.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageTypeItems = void 0;
+/**
+ * Weak True items
+ * */
+exports.StorageTypeItems = ['array', 'list', 'map', 'set'];

package/dist/literal/sys-class.d.ts

@@ -0,0 +1,2 @@
+export declare const SysClassItems: readonly ["Function", "Object", "Boolean", "Symbol", "Error", "AggregateError", "EvalError", "InternalError", "RangeError", "ReferenceError", "SyntaxError", "TypeError", "URIError", "Number", "BigInt", "Math", "Date", "String", "RegExp", "Array", "Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Uint16Array", "Int32Array", "Uint32Array", "Float32Array", "Float64Array", "BigInt64Array", "BigUint64Array", "Map", "Set", "WeakMap", "WeakSet", "ArrayBuffer", "SharedArrayBuffer", "Atomics", "DataView", "JSON", "Promise", "Generator", "GeneratorFunction", "AsyncFunction", "AsyncGenerator", "AsyncGeneratorFunction", "Reflect", "Proxy", "Intl", "Intl.Collator", "Intl.DateTimeFormat", "Intl.ListFormat", "Intl.NumberFormat", "Intl.PluralRules", "Intl.RelativeTimeFormat", "Intl.Locale", "WebAssembly", "WebAssembly.Module", "WebAssembly.Instance", "WebAssembly.Memory", "WebAssembly.Table", "WebAssembly.CompileError", "WebAssembly.LinkError", "WebAssembly.RuntimeError"];
+export type SysClass = typeof SysClassItems[number];

package/dist/literal/sys-class.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SysClassItems = void 0;
+exports.SysClassItems = [
+    'Function', 'Object', 'Boolean', 'Symbol',
+    'Error', 'AggregateError', 'EvalError', 'InternalError', 'RangeError', 'ReferenceError', 'SyntaxError', 'TypeError', 'URIError',
+    `Number`, `BigInt`, `Math`, `Date`,
+    'String', 'RegExp',
+    'Array', 'Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array',
+    'Uint16Array', 'Int32Array', 'Uint32Array', 'Float32Array', 'Float64Array', 'BigInt64Array', 'BigUint64Array',
+    'Map', 'Set', 'WeakMap', 'WeakSet',
+    'ArrayBuffer', 'SharedArrayBuffer', 'Atomics', 'DataView', 'JSON',
+    'Promise', 'Generator', 'GeneratorFunction', 'AsyncFunction', 'AsyncGenerator', 'AsyncGeneratorFunction',
+    'Reflect', 'Proxy',
+    'Intl', 'Intl.Collator', 'Intl.DateTimeFormat', 'Intl.ListFormat', 'Intl.NumberFormat',
+    'Intl.PluralRules', 'Intl.RelativeTimeFormat', 'Intl.Locale',
+    'WebAssembly', 'WebAssembly.Module', 'WebAssembly.Instance', 'WebAssembly.Memory', 'WebAssembly.Table',
+    'WebAssembly.CompileError', 'WebAssembly.LinkError', 'WebAssembly.RuntimeError'
+];

package/dist/literal/sys-function.d.ts

@@ -0,0 +1,2 @@
+export declare const SysFunctionItems: readonly ["constructor", "__defineGetter__", "__defineSetter__", "hasOwnProperty", "__lookupGetter__", "__lookupSetter__", "isPrototypeOf", "propertyIsEnumerable", "toString", "valueOf", "__proto__", "toLocaleString", "toJSON", "__esModule"];
+export type SysFunction = typeof SysFunctionItems[number];

package/dist/literal/sys-function.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SysFunctionItems = void 0;
+exports.SysFunctionItems = ['constructor', '__defineGetter__', '__defineSetter__', 'hasOwnProperty',
+    '__lookupGetter__', '__lookupSetter__', 'isPrototypeOf', 'propertyIsEnumerable',
+    'toString', 'valueOf', '__proto__', 'toLocaleString', 'toJSON', '__esModule'];

package/dist/literal/weak-false.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Weak False items
+ * */
+export declare const WeakFalseItems: readonly ["0", "-1", "false", "f", "no", "n", "off"];
+/**
+ * Weak False
+ * */
+export type WeakFalse = typeof WeakFalseItems[number];

package/dist/literal/weak-false.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WeakFalseItems = void 0;
+/**
+ * Weak False items
+ * */
+exports.WeakFalseItems = ['0', '-1', 'false', 'f', 'no', 'n', 'off'];

package/dist/literal/weak-true.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Weak True items
+ * */
+export declare const WeakTrueItems: readonly ["1", "true", "t", "yes", "y", "on"];
+/**
+ * Weak True
+ * */
+export type WeakTrue = typeof WeakTrueItems[number];

package/dist/literal/weak-true.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WeakTrueItems = void 0;
+/**
+ * Weak True items
+ * */
+exports.WeakTrueItems = ['1', 'true', 't', 'yes', 'y', 'on'];

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

@@ -1,7 +1,8 @@
 import { Leyyo } from "../leyyo";
-import { CommonLog, CommonLogSecure, Logger, LogLine } from "./index-types";
+import { CommonLog, CommonLogSecure } from "./index-types";
+import { Logger, LogLine } from "../shared";
 export declare class CommonLogImpl implements CommonLog, CommonLogSecure {
-    private callback;
+    private hook;
     constructor();
     get $secure(): CommonLogSecure;
     $init(leyyo: Leyyo): void;

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

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonLogImpl = void 0;
 const logger_impl_1 = require("./logger-impl");
-const constants_1 = require("../constants");
-// noinspection JSUnusedLocalSymbols
+const shared_1 = require("../shared");
+// noinspection JSUnusedLocalSymbols,JSUnusedGlobalSymbols
 class CommonLogImpl {
     constructor() {
         this.create.bind(this);
@@ -15,16 +15,16 @@ class CommonLogImpl {
         throw this;
     }
     $init(leyyo) {
-        this.callback = leyyo.callback;
+        this.hook = leyyo.hook;
         const fields = ['create', 'apply', 'check', 'print'];
         const rec = { proper: false };
         fields.forEach(field => {
             rec[field] = this[field];
         });
         // define itself temporarily for log operations
-        this.callback.defineProvider(constants_1.LY_ATTACHED_LOG, CommonLogImpl, rec);
+        this.hook.defineProvider(shared_1.LY_ATTACHED_LOG, CommonLogImpl, rec);
         // when new log provider is defined, replace all common methods
-        this.callback.whenProviderDefined(constants_1.LY_ATTACHED_LOG, CommonLogImpl, (ins) => {
+        this.hook.whenProviderDefined(shared_1.LY_ATTACHED_LOG, CommonLogImpl, (ins) => {
             fields.forEach(field => {
                 if (typeof ins[field] === 'function') {
                     this[field] = ins[field];
@@ -34,7 +34,7 @@ class CommonLogImpl {
     }
     create(clazz) {
         const ins = new logger_impl_1.LoggerImpl(clazz);
-        this.callback.queueForCallback(constants_1.LY_PENDING_LOG_REGISTER, ins, clazz);
+        this.hook.queueForCallback(shared_1.LY_PENDING_LOG_REGISTER, ins, clazz);
         return ins;
     }
     apply(line) {

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

@@ -1,55 +1,5 @@
-import { Severity } from "../literals";
-import { Dict, InitLike, ShiftMain, ShiftSecure } from "../aliases";
-import { CommonCallbackDefined } from "../callback";
+import { InitLike, LogConsumer, Logger, ShiftMain, ShiftSecure } from "../shared";
 export interface CommonLog extends ShiftSecure<CommonLogSecure>, LogConsumer {
     create(clazz: Object | Function | string): Logger;
 }
-export interface CommonLogCb extends CommonCallbackDefined {
-    create?(clazz: Object | Function | string): Logger;
-    apply?(line: LogLine): void;
-    check?<T>(line: LogLineEnhanced<T>): void;
-    print<T>(line: LogLineEnhanced<T>): void;
-}
-export interface CommonLogSecure extends ShiftMain<CommonLog>, InitLike {
-}
-export interface LogConsumer {
-    apply(line: LogLine): void;
-}
-export interface LogLine {
-    severity: Severity;
-    message: string | Error;
-    holder?: string;
-    params?: Dict;
-}
-export interface LogLineEnhanced<L = Dict> extends LogLine {
-    time?: Date;
-    locals?: L;
-}
-export interface Logger extends ShiftSecure<LoggerSecure> {
-    error(message: string, params?: any): void;
-    error(error: Error, params?: any): void;
-    error(whatever: any, params?: any): void;
-    warn(message: string, params?: any): void;
-    warn(error: Error, params?: any): void;
-    warn(whatever: any, params?: any): void;
-    info(message: string, params?: any): void;
-    info(error: Error, params?: any): void;
-    info(whatever: any, params?: any): void;
-    log(message: string, params?: any): void;
-    log(error: Error, params?: any): void;
-    log(whatever: any, params?: any): void;
-    trace(message: string, params?: any): void;
-    trace(error: Error, params?: any): void;
-    trace(whatever: any, params?: any): void;
-    debug(message: string, params?: any): void;
-    debug(error: Error, params?: any): void;
-    debug(whatever: any, params?: any): void;
-}
-export interface LoggerSecure extends ShiftMain<Logger> {
-    get $clazz(): Function;
-    get $name(): string;
-    $assert(error: Error, indicator: string, params?: unknown): void;
-    $setName(name: string): void;
-    $setMethod(method: Severity, lambda?: LoggerLambda): void;
-}
-export type LoggerLambda = (whatever: any, params?: any) => void;
+export type CommonLogSecure = ShiftMain<CommonLog> & InitLike;

package/dist/log/index-types.js

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

package/dist/log/index.d.ts

@@ -1,3 +1,3 @@
 export * from './index-types';
-export * from './logger-impl';
 export * from './common-log-impl';
+export * from './logger-impl';

package/dist/log/index.js

@@ -15,5 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./index-types"), exports);
-__exportStar(require("./logger-impl"), exports);
 __exportStar(require("./common-log-impl"), exports);
+__exportStar(require("./logger-impl"), exports);

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

@@ -1,10 +1,10 @@
-import { Logger, LoggerLambda, LoggerSecure } from "./index-types";
 import { Leyyo } from "../leyyo";
-import { Severity } from "../literals";
+import { Severity } from "../literal";
+import { Logger, LoggerLambda, LoggerSecure } from "../shared";
 export declare class LoggerImpl implements Logger, LoggerSecure {
     private readonly _clazz;
     private _name;
-    private static _callback;
+    private static _fqn;
     private static _log;
     constructor(value: Object | Function | string);
     debug(message: any, params?: any): void;
@@ -18,7 +18,6 @@ export declare class LoggerImpl implements Logger, LoggerSecure {
     get $clazz(): Function;
     get $name(): string;
     static $setLeyyo(leyyo: Leyyo): void;
-    $setName(name: string): void;
     $setMethod(method: Severity, lambda?: LoggerLambda): void;
     $assert(error: Error, indicator: string, params?: unknown): void;
 }

package/dist/log/logger-impl.js

@@ -1,24 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LoggerImpl = void 0;
-const error_1 = require("../error");
+const exception_1 = require("../exception");
 // noinspection JSUnusedLocalSymbols
 class LoggerImpl {
     constructor(value) {
         switch (typeof value) {
             case "function":
                 this._clazz = value;
-                this._name = LoggerImpl._callback.fqnName(value);
+                this._name = LoggerImpl._fqn.name(value);
                 break;
             case "object":
                 this._clazz = value.constructor;
-                this._name = LoggerImpl._callback.fqnName(value);
+                this._name = LoggerImpl._fqn.name(value);
                 break;
             case "string":
                 this._name = value;
                 break;
             default:
-                throw new error_1.DeveloperException('invalid.logger.name', { type: typeof value });
+                throw new exception_1.DeveloperException('invalid.logger.name', { type: typeof value });
+        }
+        // when this object is signed by FQN, then refresh logger name
+        if (!LoggerImpl._fqn.exists(value)) {
+            LoggerImpl._fqn.addHook(value, (name) => {
+                this._name = name;
+            });
         }
     }
     debug(message, params) {
@@ -53,12 +59,9 @@ class LoggerImpl {
         return this._name;
     }
     static $setLeyyo(leyyo) {
-        this._callback = leyyo.callback;
+        this._fqn = leyyo.fqn;
         this._log = leyyo.log;
     }
-    $setName(name) {
-        this._name = name;
-    }
     $setMethod(method, lambda) {
         if (typeof lambda === 'function') {
             this[method] = lambda;

package/dist/{assertion → shared}/assert.js

@@ -1,4 +1,5 @@
 "use strict";
+// noinspection JSUnusedGlobalSymbols
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assert = assert;
 exports.$$setLeyyo = $$setLeyyo;

package/dist/{aliases.d.ts → shared/index-aliases.d.ts}

@@ -1,4 +1,4 @@
-import { LanguageCode, LocaleCode } from "./literals";
+import { LanguageCode, LocaleCode } from "../literal";
 export type BasicType = 'undefined' | 'string' | 'object' | 'number' | 'boolean' | 'function' | 'symbol' | 'bigint';
 export type Dict<T = any> = Record<KeyValue, T>;
 export type Arr<T = any> = Array<T>;

package/dist/{constants.d.ts → shared/index-constants.d.ts}

@@ -1,6 +1,7 @@
 export declare const LY_ATTACHED_ERROR = "#lyy.attached.error";
 export declare const LY_PENDING_ERROR_REGISTER = "#lyy.pending.error.register";
 export declare const LY_PENDING_ENUM_REGISTER = "#lyy.pending.enum.register";
+export declare const LY_SIGN_FQN_HOOK: unique symbol;
 export declare const LY_ATTACHED_FQN = "#lyy.attached.fqn";
 export declare const LY_PENDING_FQN_REGISTER = "#lyy.pending.fqn.register";
 export declare const LY_ATTACHED_LOG = "#lyy.attached.log";

package/dist/{constants.js → shared/index-constants.js}

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LY_PENDING_LOG_REGISTER = exports.LY_ATTACHED_LOG = exports.LY_PENDING_FQN_REGISTER = exports.LY_ATTACHED_FQN = exports.LY_PENDING_ENUM_REGISTER = exports.LY_PENDING_ERROR_REGISTER = exports.LY_ATTACHED_ERROR = void 0;
+exports.LY_PENDING_LOG_REGISTER = exports.LY_ATTACHED_LOG = exports.LY_PENDING_FQN_REGISTER = exports.LY_ATTACHED_FQN = exports.LY_SIGN_FQN_HOOK = exports.LY_PENDING_ENUM_REGISTER = exports.LY_PENDING_ERROR_REGISTER = exports.LY_ATTACHED_ERROR = void 0;
 exports.LY_ATTACHED_ERROR = '#lyy.attached.error';
 exports.LY_PENDING_ERROR_REGISTER = '#lyy.pending.error.register';
 exports.LY_PENDING_ENUM_REGISTER = '#lyy.pending.enum.register';
+exports.LY_SIGN_FQN_HOOK = Symbol.for(`#lyy.fqn.h`);
 exports.LY_ATTACHED_FQN = '#lyy.attached.fqn';
 exports.LY_PENDING_FQN_REGISTER = '#lyy.pending.fqn.register';
 exports.LY_ATTACHED_LOG = '#lyy.attached.log';

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

@@ -0,0 +1,142 @@
+import { Dict, KeyValue, OneOrMore, ShiftMain, ShiftSecure } from "./index-aliases";
+import { Exception, ExceptionLike } from "../exception";
+import { Severity, StorageType } from "../literal";
+export interface AssertionOpt {
+    indicator?: AssertionReason | string;
+    param?: string;
+    where?: string;
+    value?: any;
+    expected?: OneOrMore<string>;
+    current?: string;
+    type?: string;
+    [k: string]: any;
+}
+type AssertionReason = 'invalid.type' | 'not.found' | 'duplicated' | 'empty';
+export type AssertionCallback = () => string | AssertionOpt;
+export interface AssertionBuiltResult {
+    message?: string;
+    params: AssertionOpt;
+}
+export interface HookAttachedCallback {
+    initialization?: true;
+    fn: Function;
+}
+export interface $HookDefinedProvider extends HookDefinedProvider {
+    producer: Function;
+}
+export interface HookDefinedProvider {
+    proper: boolean;
+}
+export interface HookWaitingProviderItem {
+    consumer: Function;
+    callback: HookDefinedProviderLambda;
+}
+export type HookDefinedProviderLambda<T extends HookDefinedProvider = HookDefinedProvider> = (instance: T) => void;
+export interface FqnDefinedProvider extends HookDefinedProvider {
+    exists(target: any): boolean;
+    name(target: any): string;
+    register(name: string, target: any, type: FqnStereoType, pckName: string): void;
+}
+export type FqnStereoType = 'class' | 'function' | 'enum' | 'literal';
+export type CommonFqnHook = (name: string) => void;
+export interface ErrorDefinedProvider extends HookDefinedProvider {
+    register(exception: ExceptionLike): void;
+    build?(e: Error | string): ExceptionLike;
+    afterCreate?(e: ExceptionLike): void;
+    causedBy?(e: Error | string): ExceptionLike;
+    initSign?(err: Error): boolean;
+    addSign?(err: Error, ...keys: Array<string>): boolean;
+    getSign?(err: Error): Array<string>;
+    removeSign?(err: Error, ...keys: Array<string>): boolean;
+    hasSign?(err: Error, key: string): boolean;
+    toObject?(e: Error, ...omittedFields: Array<string>): Dict;
+    buildStack?(e: Error): void;
+    copyStack?(exception: Exception, error: Error): void;
+    initOmit?(clz: Function): boolean;
+    addOmit?(clz: Function, ...properties: Array<string>): boolean;
+    getOmit?(clz: Function): Array<string>;
+    inheritOmit?(clz: Function): Array<string>;
+}
+export interface LogDefinedProvider extends HookDefinedProvider {
+    create?(clazz: Object | Function | string): Logger;
+    apply?(line: LogLine): void;
+    check?<T>(line: LogLineEnhanced<T>): void;
+    print<T>(line: LogLineEnhanced<T>): void;
+}
+export interface LogConsumer {
+    apply(line: LogLine): void;
+}
+export interface LogLine {
+    severity: Severity;
+    message: string | Error;
+    holder?: string;
+    params?: Dict;
+}
+export interface LogLineEnhanced<L = Dict> extends LogLine {
+    time?: Date;
+    locals?: L;
+}
+export interface Logger extends ShiftSecure<LoggerSecure> {
+    error(message: string, params?: any): void;
+    error(error: Error, params?: any): void;
+    error(whatever: any, params?: any): void;
+    warn(message: string, params?: any): void;
+    warn(error: Error, params?: any): void;
+    warn(whatever: any, params?: any): void;
+    info(message: string, params?: any): void;
+    info(error: Error, params?: any): void;
+    info(whatever: any, params?: any): void;
+    log(message: string, params?: any): void;
+    log(error: Error, params?: any): void;
+    log(whatever: any, params?: any): void;
+    trace(message: string, params?: any): void;
+    trace(error: Error, params?: any): void;
+    trace(whatever: any, params?: any): void;
+    debug(message: string, params?: any): void;
+    debug(error: Error, params?: any): void;
+    debug(whatever: any, params?: any): void;
+}
+export interface LoggerSecure extends ShiftMain<Logger> {
+    get $clazz(): Function;
+    get $name(): string;
+    $assert(error: Error, indicator: string, params?: unknown): void;
+    $setMethod(method: Severity, lambda?: LoggerLambda): void;
+}
+export type LoggerLambda = (whatever: any, params?: any) => void;
+/**
+ * Storage size dictionary which in corresponding type
+ * */
+export type StorageItem = Dict<number>;
+/**
+ * Storage export dictionary which includes items
+ * */
+export type StorageDetail = Record<StorageType, StorageItem>;
+export interface ToTypeOpt extends AssertionOpt {
+    silent?: true;
+    children?: unknown;
+}
+export type ToTypeFnLambda<T = unknown, O extends ToTypeOpt = ToTypeOpt> = (value: unknown, opt?: O) => T;
+export interface ToTypeChildOpt<T = unknown> extends ToTypeOpt {
+    fn?: ToTypeFnLambda<T>;
+}
+export interface ToTypeArrayChildOpt<V extends ToTypeChildOpt = ToTypeChildOpt> extends Dict<ToTypeChildOpt> {
+    value?: V;
+}
+export interface ToTypeArrayOpt<V extends ToTypeChildOpt = ToTypeChildOpt> extends ToTypeOpt {
+    children?: ToTypeArrayChildOpt<V>;
+}
+export interface ToTypeDictChildOpt<K extends ToTypeChildOpt = ToTypeChildOpt, V extends ToTypeChildOpt = ToTypeChildOpt> extends Record<string, ToTypeChildOpt> {
+    key?: K;
+    value?: V;
+}
+export interface ToTypeObjectOpt<K extends ToTypeChildOpt = ToTypeChildOpt, V extends ToTypeChildOpt = ToTypeChildOpt> extends ToTypeOpt {
+    children?: ToTypeDictChildOpt<K, V>;
+}
+export interface ToTypeEnumOpt<E extends KeyValue = KeyValue> extends ToTypeOpt {
+    map: EnumerationMap<E> | EnumerationArray<E>;
+    alt?: EnumerationAlt<E>;
+}
+export type EnumerationMap<E extends KeyValue = KeyValue> = Dict<E>;
+export type EnumerationAlt<E extends KeyValue = KeyValue> = Dict<E>;
+export type EnumerationArray<E extends KeyValue = KeyValue> = Array<E>;
+export {};

package/dist/shared/index-types.js

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

package/dist/shared/index.d.ts

@@ -0,0 +1,5 @@
+export * from './index-aliases';
+export * from './index-constants';
+export * from './index-types';
+export * from './assert';
+export * from './list';