@leyyo/common 1.0.2 → 1.0.3

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

@@ -1,11 +1,18 @@
 import { CommonFqn, CommonFqnSecure } from "./index-types";
 import { Leyyo } from "../leyyo";
-import { FqnStereoType } from "../shared";
+import { CommonFqnHook, FqnStereoType } from "../shared";
 export declare class CommonFqnImpl implements CommonFqn, CommonFqnSecure {
     private hook;
+    private proper;
+    constructor();
     get $back(): CommonFqn;
     $init(leyyo: Leyyo): void;
     get $secure(): CommonFqnSecure;
     name(value: any): string;
-    register(value: any, type: FqnStereoType, pckName: string): void;
+    exists(target: any): boolean;
+    register(name: string, value: any, type: FqnStereoType, pckName: string): void;
+    get isProper(): boolean;
+    addHook(target: Function | Object, callback: CommonFqnHook): boolean;
+    isSysFunction(method: string): boolean;
+    isSysClass(clazz: string | Function): boolean;
 }

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

@@ -2,27 +2,35 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonFqnImpl = void 0;
 const shared_1 = require("../shared");
-// noinspection JSUnusedLocalSymbols
+const literal_1 = require("../literal");
+// noinspection JSUnusedLocalSymbols,JSUnusedGlobalSymbols
 class CommonFqnImpl {
+    constructor() {
+        this.name.bind(this);
+        this.exists.bind(this);
+        this.register.bind(this);
+    }
     get $back() {
         return this;
     }
     $init(leyyo) {
         this.hook = leyyo.hook;
-        const fields = ['name', 'register'];
-        const rec = { proper: false };
-        fields.forEach(field => {
-            rec[field] = this[field];
-        });
+        const rec = {
+            proper: false,
+            exists: this.exists,
+            name: this.name,
+            register: this.register,
+        };
         // define itself temporarily for fqn operations
         leyyo.hook.defineProvider(shared_1.LY_ATTACHED_FQN, CommonFqnImpl, rec);
         // when new fqn provider is defined, replace all common methods
         leyyo.hook.whenProviderDefined(shared_1.LY_ATTACHED_FQN, CommonFqnImpl, (ins) => {
-            fields.forEach(field => {
-                if (typeof ins[field] === 'function') {
-                    this[field] = ins[field];
-                }
-            });
+            if (ins.proper) {
+                this.proper = true;
+            }
+            this.exists = ins.exists;
+            this.name = ins.name;
+            this.register = ins.register;
         });
     }
     get $secure() {
@@ -40,8 +48,74 @@ class CommonFqnImpl {
                 return null;
         }
     }
-    register(value, type, pckName) {
-        this.hook.queueForCallback(shared_1.LY_PENDING_FQN_REGISTER, value, type, pckName);
+    exists(target) {
+        return false;
+    }
+    register(name, value, type, pckName) {
+        this.hook.queueForCallback(shared_1.LY_PENDING_FQN_REGISTER, name, value, type, pckName);
+    }
+    get isProper() {
+        return this.proper;
+    }
+    addHook(target, callback) {
+        var _a;
+        if (typeof target === 'object') {
+            try {
+                target = target.constructor;
+            }
+            catch (e) {
+            }
+        }
+        if (typeof target !== 'function' || typeof callback !== 'function') {
+            return false;
+        }
+        if (this.proper) {
+            callback(this.name(target));
+            return true;
+        }
+        let callbacks;
+        try {
+            callbacks = (_a = Object.getOwnPropertyDescriptor(target, shared_1.LY_SIGN_FQN_HOOK)) !== null && _a !== void 0 ? _a : [];
+        }
+        catch (e) {
+            console.log(`CommonFqnImpl.hook.get`, e.message);
+        }
+        if (!Array.isArray(callbacks)) {
+            callbacks = [];
+        }
+        callbacks.push(callback);
+        try {
+            Object.defineProperty(target, shared_1.LY_SIGN_FQN_HOOK, {
+                value: callbacks,
+                configurable: false,
+                writable: false,
+                enumerable: false
+            });
+        }
+        catch (e) {
+            console.log(`CommonFqnImpl.hook.set`, e.message);
+            return false;
+        }
+        return true;
+    }
+    isSysFunction(method) {
+        if (typeof method !== 'string') {
+            return false;
+        }
+        return literal_1.SysFunctionItems.includes(method);
+    }
+    isSysClass(clazz) {
+        let name;
+        if (typeof clazz === 'function') {
+            name = clazz.name;
+        }
+        else if (typeof clazz === 'string') {
+            name = clazz;
+        }
+        if (!name) {
+            return false;
+        }
+        return literal_1.SysClassItems.includes(name);
     }
 }
 exports.CommonFqnImpl = CommonFqnImpl;

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

@@ -1,6 +1,9 @@
-import { FqnStereoType, InitLike, ShiftMain, ShiftSecure } from "../shared";
+import { CommonFqnHook, FqnStereoType, InitLike, ShiftMain, ShiftSecure } from "../shared";
 export interface CommonFqn extends ShiftSecure<CommonFqnSecure> {
-    name(value: any): string;
-    register(value: any, type: FqnStereoType, pckName: string): void;
+    name(target: any): string;
+    exists(target: any): boolean;
+    register(name: string, target: any, type: FqnStereoType, pckName: string): void;
+    addHook(target: Function | Object, callback: CommonFqnHook): boolean;
+    get isProper(): boolean;
 }
 export type CommonFqnSecure = ShiftMain<CommonFqn> & InitLike;

package/dist/leyyo/leyyo-impl.js

@@ -48,31 +48,46 @@ class LeyyoImpl {
         exception_1.Exception.$setLeyyo(this);
     }
     initFqnRegister() {
-        this.fqn.register(is_1.CommonIsImpl, 'class', internal_1.FQN_PCK);
-        this.fqn.register(storage_1.CommonStorageImpl, 'class', internal_1.FQN_PCK);
-        this.fqn.register(hook_1.CommonHookImpl, 'class', internal_1.FQN_PCK);
-        this.fqn.register(fqn_1.CommonFqnImpl, 'class', internal_1.FQN_PCK);
-        this.fqn.register(log_1.CommonLogImpl, 'class', internal_1.FQN_PCK);
-        this.fqn.register(error_1.CommonErrorImpl, 'class', internal_1.FQN_PCK);
-        this.fqn.register(assertion_1.CommonAssertionImpl, 'class', internal_1.FQN_PCK);
-        this.fqn.register(to_1.CommonToImpl, 'class', internal_1.FQN_PCK);
-        this.fqn.register(shared_1.List, 'class', internal_1.FQN_PCK);
-        this.fqn.register(log_1.LoggerImpl, 'class', internal_1.FQN_PCK);
-        this.fqn.register(node_assert_1.default, 'function', internal_1.FQN_PCK);
+        this.fqn.register(null, is_1.CommonIsImpl, 'class', internal_1.FQN_PCK);
+        this.fqn.register(null, storage_1.CommonStorageImpl, 'class', internal_1.FQN_PCK);
+        this.fqn.register(null, hook_1.CommonHookImpl, 'class', internal_1.FQN_PCK);
+        this.fqn.register(null, fqn_1.CommonFqnImpl, 'class', internal_1.FQN_PCK);
+        this.fqn.register(null, log_1.CommonLogImpl, 'class', internal_1.FQN_PCK);
+        this.fqn.register(null, error_1.CommonErrorImpl, 'class', internal_1.FQN_PCK);
+        this.fqn.register(null, assertion_1.CommonAssertionImpl, 'class', internal_1.FQN_PCK);
+        this.fqn.register(null, to_1.CommonToImpl, 'class', internal_1.FQN_PCK);
+        this.fqn.register(null, shared_1.List, 'class', internal_1.FQN_PCK);
+        this.fqn.register(null, log_1.LoggerImpl, 'class', internal_1.FQN_PCK);
+        this.fqn.register(null, node_assert_1.default, 'function', internal_1.FQN_PCK);
     }
     initErrorRegister() {
         [exception_1.Exception, exception_1.AssertionException, exception_1.CausedException, exception_1.DeveloperException, exception_1.MultipleException].forEach(cls => {
-            this.fqn.register(cls, 'class', internal_1.FQN_PCK);
+            this.fqn.register(null, cls, 'class', internal_1.FQN_PCK);
             this.error.register(cls);
         });
     }
     initEnumRegister() {
-        [literal_1.PrimitiveItems, literal_1.StorageTypeItems, literal_1.RealValueItems, literal_1.KeyValueItems, literal_1.WeakTrueItems, literal_1.WeakFalseItems,
-            literal_1.HttpMethodItems, literal_1.HttpPlaceItems, literal_1.SeverityItems, literal_1.EnvironmentItems,
-            literal_1.CountryCodeItems, literal_1.LanguageCodeItems, literal_1.LocaleCodeItems].forEach(enm => {
-            this.fqn.register(enm, 'enum', internal_1.FQN_PCK);
-            this.hook.queueForCallback(shared_1.LY_PENDING_ENUM_REGISTER, enm);
-        });
+        const enumMap = {
+            Primitive: literal_1.PrimitiveItems,
+            StorageType: literal_1.StorageTypeItems,
+            RealValue: literal_1.RealValueItems,
+            KeyValue: literal_1.KeyValueItems,
+            WeakTrue: literal_1.WeakTrueItems,
+            WeakFalse: literal_1.WeakFalseItems,
+            HttpMethod: literal_1.HttpMethodItems,
+            HttpPlace: literal_1.HttpPlaceItems,
+            Severity: literal_1.SeverityItems,
+            Environment: literal_1.EnvironmentItems,
+            CountryCode: literal_1.CountryCodeItems,
+            LanguageCode: literal_1.LanguageCodeItems,
+            LocaleCode: literal_1.LocaleCodeItems,
+            SysClass: literal_1.SysClassItems,
+            SysFunction: literal_1.SysFunctionItems,
+        };
+        for (const [name, value] of Object.entries(enumMap)) {
+            this.fqn.register(name, value, 'enum', internal_1.FQN_PCK);
+            this.hook.queueForCallback(shared_1.LY_PENDING_ENUM_REGISTER, value);
+        }
     }
 }
 exports.LeyyoImpl = LeyyoImpl;

package/dist/literal/index.d.ts

@@ -9,6 +9,8 @@ export * from './primitive';
 export * from './real-value';
 export * from './severity';
 export * from './storage-type';
+export * from './sys-class';
+export * from './sys-function';
 export * from './weak-false';
 export * from './weak-true';
 export * from './index-types';

package/dist/literal/index.js

@@ -25,6 +25,8 @@ __exportStar(require("./primitive"), exports);
 __exportStar(require("./real-value"), exports);
 __exportStar(require("./severity"), exports);
 __exportStar(require("./storage-type"), exports);
+__exportStar(require("./sys-class"), exports);
+__exportStar(require("./sys-function"), exports);
 __exportStar(require("./weak-false"), exports);
 __exportStar(require("./weak-true"), exports);
 __exportStar(require("./index-types"), exports);

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/log/logger-impl.d.ts

@@ -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

@@ -20,6 +20,12 @@ class LoggerImpl {
             default:
                 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) {
         LoggerImpl._log.apply({ severity: 'debug', message: message, holder: this._name, params: params });
@@ -56,9 +62,6 @@ class LoggerImpl {
         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/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/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

@@ -33,10 +33,12 @@ export interface HookWaitingProviderItem {
 }
 export type HookDefinedProviderLambda<T extends HookDefinedProvider = HookDefinedProvider> = (instance: T) => void;
 export interface FqnDefinedProvider extends HookDefinedProvider {
-    name(value: any): string;
-    register(value: any, type: FqnStereoType, pckName: string): void;
+    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;
@@ -98,7 +100,6 @@ 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leyyo/common",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Common library",
   "keywords": [
     "common"