@leyyo/common 1.0.1 → 1.0.2

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

@@ -1,11 +1,10 @@
-import { AssertionCallback, AssertionOpt, CommonAssertion, CommonAssertionSecure } from "./index-types";
+import { CommonAssertion, CommonAssertionSecure } from "./index-types";
 import { Leyyo } from "../leyyo";
-import { ToTypeOpt } from "../to";
-import { Arr, Obj } from "../aliases";
+import { Arr, AssertionCallback, AssertionOpt, Obj, ToTypeOpt } from "../shared";
 /** @inheritDoc */
 export declare class CommonAssertionImpl implements CommonAssertion, CommonAssertionSecure {
     private is;
-    private callback;
+    private fqn;
     constructor();
     /**
      * Build error parameters as message and params

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

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonAssertionImpl = void 0;
-const error_1 = require("../error");
+const exception_1 = require("../exception");
+// noinspection JSUnusedGlobalSymbols
 /** @inheritDoc */
 class CommonAssertionImpl {
     // endregion properties
@@ -50,10 +51,10 @@ class CommonAssertionImpl {
         switch (typeof value) {
             case 'object':
                 if (set.has(value)) {
-                    return `<circular>${this.callback.fqnName(value === null || value === void 0 ? void 0 : value.constructor)}`;
+                    return `<circular>${this.fqn.name(value === null || value === void 0 ? void 0 : value.constructor)}`;
                 }
                 if (level >= 10) {
-                    return `<max-depth>${this.callback.fqnName(value === null || value === void 0 ? void 0 : value.constructor)}`;
+                    return `<max-depth>${this.fqn.name(value === null || value === void 0 ? void 0 : value.constructor)}`;
                 }
                 set.add(value);
                 if (Array.isArray(value)) {
@@ -75,7 +76,7 @@ class CommonAssertionImpl {
                 }
                 return obj;
             case 'function':
-                return `<function>${this.callback.fqnName(value)}`;
+                return `<function>${this.fqn.name(value)}`;
             case 'symbol':
                 return `<symbol>${value.toString()}`;
         }
@@ -89,17 +90,17 @@ class CommonAssertionImpl {
         const type = typeof value;
         switch (type) {
             case "object":
-                params.type = `object(${this.callback.fqnName(value.constructor)})`;
+                params.type = `object(${this.fqn.name(value.constructor)})`;
                 break;
             case "function":
-                params.type = `function(${this.callback.fqnName(value)})`;
+                params.type = `function(${this.fqn.name(value)})`;
                 break;
             default:
                 params.type = type;
                 break;
         }
         def = def !== null && def !== void 0 ? def : 'Assertion error';
-        throw new error_1.AssertionException(message !== null && message !== void 0 ? message : def, params);
+        throw new exception_1.AssertionException(message !== null && message !== void 0 ? message : def, params);
     }
     /** @inheritDoc */
     // noinspection JSUnusedLocalSymbols
@@ -237,7 +238,7 @@ class CommonAssertionImpl {
     /** @inheritDoc */
     $init(leyyo) {
         this.is = leyyo.is;
-        this.callback = leyyo.callback;
+        this.fqn = leyyo.fqn;
     }
     /** @inheritDoc */
     get $secure() {

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

@@ -1,7 +1,6 @@
-import { Arr, InitLike, OneOrMore, ShiftMain, ShiftSecure } from "../aliases";
-import { ToTypeOpt } from "../to";
+import { Arr, AssertionCallback, AssertionOpt, InitLike, ShiftMain, ShiftSecure, ToTypeOpt } from "../shared";
 /**
- * Basic is assertions to easy use
+ * Basic assertions to easy use
  * */
 export interface CommonAssertion extends ShiftSecure<CommonAssertionSecure> {
     /**
@@ -465,22 +464,7 @@ export interface CommonAssertion extends ShiftSecure<CommonAssertionSecure> {
      * */
     boolean(value: any, opt?: AssertionOpt): void;
 }
-export interface CommonAssertionSecure extends ShiftMain<CommonAssertion>, InitLike {
-}
-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 {};
+/**
+ * Secure assertion methods
+ * */
+export type CommonAssertionSecure = ShiftMain<CommonAssertion> & InitLike;

package/dist/assertion/index.d.ts

@@ -1,3 +1,2 @@
 export * from './index-types';
 export * from './common-assertion-impl';
-export * from './assert';

package/dist/assertion/index.js

@@ -16,4 +16,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./index-types"), exports);
 __exportStar(require("./common-assertion-impl"), exports);
-__exportStar(require("./assert"), exports);

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

@@ -1,17 +1,19 @@
-import { CommonError, CommonErrorSecure, ExceptionLike } from "./index-types";
+import { CommonError, CommonErrorSecure } from "./index-types";
 import { Leyyo } from "../leyyo";
-import { Dict } from "../aliases";
-import { Exception } from "./exception";
+import { Dict } from "../shared";
+import { ExceptionLike } from "../exception";
 export declare class CommonErrorImpl implements CommonError, CommonErrorSecure {
+    private hook;
     get $back(): CommonError;
     $init(leyyo: Leyyo): void;
     get $secure(): CommonErrorSecure;
     addOmit(clz: Function, ...properties: Array<string>): boolean;
     addSign(err: Error, ...keys: Array<string>): boolean;
     afterCreate(e: ExceptionLike): void;
+    register(cls: Function): void;
     build(e: Error | string): ExceptionLike;
     buildStack(e: Error): void;
-    copyStack(exception: Exception, error: Error): void;
+    copyStack(exception: ExceptionLike, error: Error): void;
     causedBy(e: Error | string): ExceptionLike;
     getOmit(clz: Function): Array<string>;
     getSign(err: Error): Array<string>;

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

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonErrorImpl = void 0;
-const exception_1 = require("./exception");
-const constants_1 = require("../constants");
+const shared_1 = require("../shared");
+const exception_1 = require("../exception");
 // noinspection JSUnusedLocalSymbols
 class CommonErrorImpl {
     get $back() {
         return this;
     }
     $init(leyyo) {
+        this.hook = leyyo.hook;
         const fields = ['build', 'afterCreate', 'causedBy', 'toObject', 'buildStack', 'copyStack',
             'initSign', 'addSign', 'getSign', 'removeSign', 'hasSign',
             'initOmit', 'addOmit', 'getOmit', 'inheritOmit'];
@@ -17,9 +18,9 @@ class CommonErrorImpl {
             rec[field] = this[field];
         });
         // define itself temporarily for error operations
-        leyyo.callback.defineProvider(constants_1.LY_ATTACHED_ERROR, CommonErrorImpl, rec);
+        this.hook.defineProvider(shared_1.LY_ATTACHED_ERROR, CommonErrorImpl, rec);
         // when new error provider is defined, replace all common methods
-        leyyo.callback.whenProviderDefined(constants_1.LY_ATTACHED_ERROR, CommonErrorImpl, (ins) => {
+        this.hook.whenProviderDefined(shared_1.LY_ATTACHED_ERROR, CommonErrorImpl, (ins) => {
             fields.forEach(field => {
                 if (typeof ins[field] === 'function') {
                     this[field] = ins[field];
@@ -39,6 +40,9 @@ class CommonErrorImpl {
     afterCreate(e) {
         e.$secure.$setName(e.constructor.name);
     }
+    register(cls) {
+        this.hook.queueForCallback(shared_1.LY_PENDING_ERROR_REGISTER, cls);
+    }
     build(e) {
         if (e instanceof exception_1.Exception) {
             return e;

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

@@ -1,7 +1,7 @@
-import { Abstract, ClassLike, Dict, InitLike, ShiftMain, ShiftSecure } from "../aliases";
-import { Exception } from "./exception";
-import { CommonCallbackDefined } from "../callback";
+import { Dict, InitLike, ShiftMain, ShiftSecure } from "../shared";
+import { ExceptionLike } from "../exception";
 export interface CommonError extends ShiftSecure<CommonErrorSecure> {
+    register(cls: Function): void;
     build(e: Error | string): ExceptionLike;
     afterCreate(e: ExceptionLike): void;
     causedBy(e: Error | string): ExceptionLike;
@@ -12,57 +12,10 @@ export interface CommonError extends ShiftSecure<CommonErrorSecure> {
     hasSign(err: Error, key: string): boolean;
     toObject(e: Error, ...omittedFields: Array<string>): Dict;
     buildStack(e: Error): void;
-    copyStack(exception: Exception, error: Error): void;
+    copyStack(exception: ExceptionLike, 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 CommonErrorCb extends CommonCallbackDefined {
-    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 CommonErrorSecure extends ShiftMain<CommonError>, InitLike {
-}
-export interface ExceptionStackLine {
-    file?: string;
-    method?: string;
-    line?: number;
-    column?: number;
-}
-export interface ExceptionParamsAppend extends Dict {
-    indicator?: string;
-}
-export interface ExceptionLike extends Error, ShiftSecure<ExceptionSecure> {
-    get params(): Dict;
-    causedBy(e: Error | string): this;
-    with(clazz: ClassLike): this;
-    with(instance: Abstract<any>): this;
-    with(name: string): this;
-    with(value: any): this;
-    appendParams(params: ExceptionParamsAppend, ignoreExisting?: boolean): this;
-    log(req?: unknown): this;
-    raise(throwable?: boolean, req?: unknown): this;
-    toObject(...omittedFields: Array<string>): Dict;
-    toJSON(): Dict;
-}
-export interface ExceptionSecure extends ShiftMain<ExceptionLike> {
-    $setName(name: string): this;
-    $hasSign(key: string): boolean;
-    $listSigns(): Array<string>;
-    $addSign(...keys: Array<string>): boolean;
-    $removeSign(...keys: Array<string>): boolean;
-}
+export type CommonErrorSecure = ShiftMain<CommonError> & InitLike;

package/dist/error/index.d.ts

@@ -1,7 +1,2 @@
 export * from './index-types';
 export * from './common-error-impl';
-export * from './exception';
-export * from './caused-exception';
-export * from './developer-exception';
-export * from './assertion-exception';
-export * from './multiple-exception';

package/dist/error/index.js

@@ -16,8 +16,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 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 → exception}/assertion-exception.d.ts

@@ -1,5 +1,5 @@
 import { Exception } from "./exception";
-import { AssertionOpt } from "../assertion";
+import { AssertionOpt } from "../shared";
 export declare class AssertionException extends Exception {
     constructor(indicator?: string, params?: AssertionOpt);
 }

package/dist/{error → exception}/caused-exception.d.ts

@@ -1,5 +1,5 @@
 import { Exception } from "./exception";
-import { Dict } from "../aliases";
+import { Dict } from "../shared";
 export declare class CausedException extends Exception {
     constructor(e: Error, indicator?: string, params?: Dict);
 }

package/dist/{error → exception}/developer-exception.d.ts

@@ -1,5 +1,5 @@
 import { Exception } from "./exception";
-import { AssertionOpt } from "../assertion";
+import { AssertionOpt } from "../shared";
 export declare class DeveloperException extends Exception {
     constructor(indicator?: string, params?: AssertionOpt);
 }

package/dist/{error → exception}/exception.d.ts

@@ -1,8 +1,9 @@
-import { CommonError, ExceptionLike, ExceptionParamsAppend, ExceptionSecure, ExceptionStackLine } from "./index-types";
-import { Abstract, ClassLike, ClassOrName, Dict } from "../aliases";
+import { CommonError } from "../error";
+import { Abstract, ClassLike, ClassOrName, Dict } from "../shared";
 import { Leyyo } from "../leyyo";
+import { ExceptionLike, ExceptionParamsAppend, ExceptionSecure, ExceptionStackLine } from "./index-types";
 export declare class Exception extends Error implements ExceptionLike, ExceptionSecure {
-    private static _callback;
+    private static _fqn;
     private static _error;
     private static _log;
     private static _assertion;

package/dist/{error → exception}/exception.js

@@ -7,7 +7,7 @@ class Exception extends Error {
             message += ` => ${JSON.stringify(Exception._assertion.secureJson(params))}`;
         }
         super(message);
-        this.name = Exception._callback.fqnName(this);
+        this.name = Exception._fqn.name(this);
         this._params = params !== null && params !== void 0 ? params : {};
         this._parsed = [];
         Exception._error.afterCreate(this);
@@ -27,7 +27,7 @@ class Exception extends Error {
         return this;
     }
     with(value) {
-        this._holder = Exception._callback.fqnName(value);
+        this._holder = Exception._fqn.name(value);
         return this;
     }
     appendParams(params, ignoreExisting) {
@@ -98,8 +98,8 @@ class Exception extends Error {
         return Exception._error.removeSign(this, ...keys);
     }
     static $setLeyyo(leyyo) {
-        if (!this._callback) {
-            this._callback = leyyo.callback;
+        if (!this._fqn) {
+            this._fqn = leyyo.fqn;
         }
         if (!this._error) {
             this._error = leyyo.error;

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

@@ -0,0 +1,30 @@
+import { Abstract, ClassLike, Dict, ShiftMain, ShiftSecure } from "../shared";
+export interface ExceptionStackLine {
+    file?: string;
+    method?: string;
+    line?: number;
+    column?: number;
+}
+export interface ExceptionParamsAppend extends Dict {
+    indicator?: string;
+}
+export interface ExceptionLike extends Error, ShiftSecure<ExceptionSecure> {
+    get params(): Dict;
+    causedBy(e: Error | string): this;
+    with(clazz: ClassLike): this;
+    with(instance: Abstract<any>): this;
+    with(name: string): this;
+    with(value: any): this;
+    appendParams(params: ExceptionParamsAppend, ignoreExisting?: boolean): this;
+    log(req?: unknown): this;
+    raise(throwable?: boolean, req?: unknown): this;
+    toObject(...omittedFields: Array<string>): Dict;
+    toJSON(): Dict;
+}
+export interface ExceptionSecure extends ShiftMain<ExceptionLike> {
+    $setName(name: string): this;
+    $hasSign(key: string): boolean;
+    $listSigns(): Array<string>;
+    $addSign(...keys: Array<string>): boolean;
+    $removeSign(...keys: Array<string>): boolean;
+}

package/dist/exception/index.d.ts

@@ -0,0 +1,6 @@
+export * from './index-types';
+export * from './exception';
+export * from './caused-exception';
+export * from './developer-exception';
+export * from './assertion-exception';
+export * from './multiple-exception';

package/dist/exception/index.js

@@ -0,0 +1,22 @@
+"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("./exception"), exports);
+__exportStar(require("./caused-exception"), exports);
+__exportStar(require("./developer-exception"), exports);
+__exportStar(require("./assertion-exception"), exports);
+__exportStar(require("./multiple-exception"), exports);

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

@@ -0,0 +1,11 @@
+import { CommonFqn, CommonFqnSecure } from "./index-types";
+import { Leyyo } from "../leyyo";
+import { FqnStereoType } from "../shared";
+export declare class CommonFqnImpl implements CommonFqn, CommonFqnSecure {
+    private hook;
+    get $back(): CommonFqn;
+    $init(leyyo: Leyyo): void;
+    get $secure(): CommonFqnSecure;
+    name(value: any): string;
+    register(value: any, type: FqnStereoType, pckName: string): void;
+}

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonFqnImpl = void 0;
+const shared_1 = require("../shared");
+// noinspection JSUnusedLocalSymbols
+class CommonFqnImpl {
+    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];
+        });
+        // 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];
+                }
+            });
+        });
+    }
+    get $secure() {
+        return this;
+    }
+    name(value) {
+        switch (typeof value) {
+            case "function":
+                return value.name;
+            case "object":
+                return value.constructor.name;
+            case "string":
+                return value;
+            default:
+                return null;
+        }
+    }
+    register(value, type, pckName) {
+        this.hook.queueForCallback(shared_1.LY_PENDING_FQN_REGISTER, value, type, pckName);
+    }
+}
+exports.CommonFqnImpl = CommonFqnImpl;

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

@@ -0,0 +1,6 @@
+import { FqnStereoType, InitLike, ShiftMain, ShiftSecure } from "../shared";
+export interface CommonFqn extends ShiftSecure<CommonFqnSecure> {
+    name(value: any): string;
+    register(value: any, type: FqnStereoType, pckName: string): void;
+}
+export type CommonFqnSecure = ShiftMain<CommonFqn> & InitLike;

package/dist/fqn/index-types.js

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

package/dist/fqn/index.d.ts

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

package/dist/{callback → fqn}/index.js

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

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

@@ -0,0 +1,30 @@
+import { Arr, HookDefinedProvider, HookDefinedProviderLambda } from "../shared";
+import { Leyyo } from "../leyyo";
+import { CommonHook, CommonHookSecure } from "./index-types";
+export declare class CommonHookImpl implements CommonHook, CommonHookSecure {
+    private _waitingForCallbacks;
+    private _attachedCallbacks;
+    private _waitingForProviders;
+    private _definedProviders;
+    /**
+     * Default constructor
+     *
+     * Responsibilities
+     * - Create repositories => ie: callbacks
+     * - Trigger clear pending operation
+     * */
+    constructor();
+    $init(leyyo: Leyyo): void;
+    /**
+     * Clear jobs in the queue which channel as pending
+     *
+     * Because the expected callback may not be defined
+     * */
+    private _clearPending;
+    get $secure(): CommonHookSecure;
+    attachCallback(channel: string, fn: Function): void;
+    queueForCallback(channel: string, ...args: Arr): boolean;
+    get $back(): CommonHook;
+    whenProviderDefined<T extends HookDefinedProvider = HookDefinedProvider>(channel: string, consumer: Function, callback: HookDefinedProviderLambda<T>): void;
+    defineProvider<T extends HookDefinedProvider = HookDefinedProvider>(channel: string, producer: Function, instance: T): void;
+}

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

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonHookImpl = void 0;
+const internal_1 = require("../internal");
+const exception_1 = require("../exception");
+// noinspection JSUnusedGlobalSymbols
+class CommonHookImpl {
+    /**
+     * Default constructor
+     *
+     * Responsibilities
+     * - Create repositories => ie: callbacks
+     * - Trigger clear pending operation
+     * */
+    constructor() {
+        // clear after 1 minute
+        setTimeout(() => this._clearPending(), 60000);
+    }
+    $init(leyyo) {
+        this._waitingForCallbacks = leyyo.storage.newMap(`${internal_1.FQN_PCK}/waitingForCallbacks`);
+        this._attachedCallbacks = leyyo.storage.newMap(`${internal_1.FQN_PCK}/attachedCallbacks`);
+        this._waitingForProviders = leyyo.storage.newMap(`${internal_1.FQN_PCK}/waitingForProviders`);
+        this._definedProviders = leyyo.storage.newMap(`${internal_1.FQN_PCK}/definedProviders`);
+    }
+    /**
+     * Clear jobs in the queue which channel as pending
+     *
+     * Because the expected callback may not be defined
+     * */
+    _clearPending() {
+        for (const [channel,] of this._waitingForCallbacks.entries()) {
+            const rec = this._attachedCallbacks.get(channel);
+            if (rec && !rec.initialization) {
+                continue;
+            }
+            this._waitingForCallbacks.delete(channel);
+            console.log(`hook.cleared.pending => {channel: ${channel}}`);
+        }
+    }
+    get $secure() {
+        return this;
+    }
+    attachCallback(channel, fn) {
+        if (!channel || typeof channel !== 'string') {
+            throw new Error(`hook.invalid.channel => {type: ${typeof channel}}`);
+        }
+        // callback attached
+        this._attachedCallbacks.set(channel, { fn });
+        // check waiting records, to be called
+        if (this._waitingForCallbacks.has(channel)) {
+            this._waitingForCallbacks.get(channel).forEach(item => {
+                fn(...item);
+            });
+            this._waitingForCallbacks.delete(channel);
+        }
+    }
+    queueForCallback(channel, ...args) {
+        if (!channel || typeof channel !== 'string') {
+            throw new Error(`hook.invalid.channel => {type: ${typeof channel}}`);
+        }
+        // callback already exists
+        if (this._attachedCallbacks.has(channel)) {
+            const rec = this._attachedCallbacks.get(channel);
+            rec.fn(...args);
+            return true;
+        }
+        // callback does not exist yet, so wait to be attached
+        if (this._waitingForCallbacks.has(channel)) {
+            this._waitingForCallbacks.get(channel).push(args);
+        }
+        else {
+            this._waitingForCallbacks.set(channel, [args]);
+        }
+        return false;
+    }
+    get $back() {
+        return undefined;
+    }
+    whenProviderDefined(channel, consumer, callback) {
+        if (!channel || typeof channel !== 'string') {
+            throw new exception_1.DeveloperException(`hook.invalid.channel`, { type: typeof channel });
+        }
+        if (!this._waitingForProviders.has(channel)) {
+            this._waitingForProviders.set(channel, []);
+        }
+        if (this._definedProviders.has(channel)) {
+            const ins = this._definedProviders.get(channel);
+            if (ins.producer !== consumer) {
+                callback(ins);
+            }
+        }
+        this._waitingForProviders.get(channel).push({ consumer, callback });
+    }
+    defineProvider(channel, producer, instance) {
+        if (!channel || typeof channel !== 'string') {
+            throw new exception_1.DeveloperException(`hook.invalid.channel`, { type: typeof channel });
+        }
+        const ins = Object.assign(Object.assign({}, instance), { producer });
+        this._definedProviders.set(channel, ins);
+        if (instance.proper) {
+            if (this._waitingForProviders.has(channel)) {
+                this._waitingForProviders.get(channel).forEach(item => {
+                    if (item.consumer !== producer) {
+                        item.callback(instance);
+                    }
+                });
+            }
+        }
+    }
+}
+exports.CommonHookImpl = CommonHookImpl;