@leyyo/common 1.0.0

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

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonCallbackImpl = void 0;
+const constants_1 = require("../constants");
+const error_1 = require("../error");
+const internal_1 = require("../internal");
+class CommonCallbackImpl {
+    fqnName(value) {
+        switch (typeof value) {
+            case "function":
+                return value.name;
+            case "object":
+                return value.constructor.name;
+            case "string":
+                return value;
+            default:
+                return null;
+        }
+    }
+    /**
+     * 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`);
+        // define itself temporarily for fqn name
+        this.defineProvider(constants_1.LY_ATTACHED_FQN, CommonCallbackImpl, {
+            proper: false,
+            name: this.fqnName,
+        });
+        // when new fqn provider is defined, replace temporary name method
+        this.whenProviderDefined(constants_1.LY_ATTACHED_FQN, CommonCallbackImpl, (ins) => {
+            if (typeof ins.name === 'function') {
+                this.fqnName = ins.name;
+            }
+        });
+    }
+    /**
+     * Clear jobs in the queue which named as pending
+     *
+     * Because the expected callback may not be defined
+     * */
+    _clearPending() {
+        for (const [name,] of this._waitingForCallbacks.entries()) {
+            const rec = this._attachedCallbacks.get(name);
+            if (rec && !rec.initialization) {
+                continue;
+            }
+            this._waitingForCallbacks.delete(name);
+            console.log(`callback.cleared.pending => {name: ${name}}`);
+        }
+    }
+    get $secure() {
+        return this;
+    }
+    attachCallback(name, fn) {
+        if (!name || typeof name !== 'string') {
+            throw new Error(`callback.invalid.name => {type: ${typeof name}}`);
+        }
+        // callback attached
+        this._attachedCallbacks.set(name, { fn });
+        // check waiting records, to be called
+        if (this._waitingForCallbacks.has(name)) {
+            this._waitingForCallbacks.get(name).forEach(item => {
+                fn(...item);
+            });
+            this._waitingForCallbacks.delete(name);
+        }
+    }
+    queueForCallback(name, ...args) {
+        if (!name || typeof name !== 'string') {
+            throw new Error(`callback.invalid.name => {type: ${typeof name}}`);
+        }
+        // callback already exists
+        if (this._attachedCallbacks.has(name)) {
+            const rec = this._attachedCallbacks.get(name);
+            rec.fn(...args);
+            return true;
+        }
+        // callback does not exist yet, so wait to be attached
+        if (this._waitingForCallbacks.has(name)) {
+            this._waitingForCallbacks.get(name).push(args);
+        }
+        else {
+            this._waitingForCallbacks.set(name, [args]);
+        }
+        return false;
+    }
+    get $back() {
+        return undefined;
+    }
+    whenProviderDefined(name, consumer, callback) {
+        if (!name || typeof name !== 'string') {
+            throw new error_1.DeveloperException(`callback.invalid.name`, { type: typeof name });
+        }
+        if (!this._waitingForProviders.has(name)) {
+            this._waitingForProviders.set(name, []);
+        }
+        if (this._definedProviders.has(name)) {
+            const ins = this._definedProviders.get(name);
+            if (ins.producer !== consumer) {
+                callback(ins);
+            }
+        }
+        this._waitingForProviders.get(name).push({ consumer, callback });
+    }
+    defineProvider(name, producer, instance) {
+        if (!name || typeof name !== 'string') {
+            throw new error_1.DeveloperException(`callback.invalid.name`, { type: typeof name });
+        }
+        const ins = Object.assign(Object.assign({}, instance), { producer });
+        this._definedProviders.set(name, ins);
+        if (instance.proper) {
+            if (this._waitingForProviders.has(name)) {
+                this._waitingForProviders.get(name).forEach(item => {
+                    if (item.consumer !== producer) {
+                        item.callback(instance);
+                    }
+                });
+            }
+        }
+    }
+}
+exports.CommonCallbackImpl = CommonCallbackImpl;

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

@@ -0,0 +1,75 @@
+import { Arr, ShiftMain, ShiftSecure } from "../aliases";
+import { Leyyo } from "../leyyo";
+/**
+ * Callback repository, it collects all jobs and fire them when callback is defined
+ * */
+export interface CommonCallback extends ShiftSecure<CommonCallbackSecure> {
+    /**
+     * Attach a callback
+     *
+     * @param {string} name
+     * @param {Function} fn
+     *
+     * Notes:
+     * - name should be regular string
+     * - After attached, it should call all waiting calls in the queue
+     * */
+    attachCallback(name: string, fn: Function): void;
+    /**
+     * Add a call into queue, which to be executed by appropriate callback
+     *
+     * @param {string} name
+     * @param {Array<any>} args
+     * @returns {boolean} - callback exists?
+     *
+     * Notes:
+     * - name should be regular string
+     * */
+    queueForCallback(name: string, ...args: Arr): boolean;
+    fqnName(value: any): string;
+    /**
+     * Informs when callback is changed
+     *
+     * @param {string} name
+     * @param {Function} consumer
+     * @param {CallbackWhenDefinedLambda} callback
+     *
+     * Notes:
+     * - name should be regular string
+     * - callback should be regular function
+     * - name should not be already defined
+     * */
+    whenProviderDefined<T extends CommonCallbackDefined = CommonCallbackDefined>(name: string, consumer: Function, callback: CallbackWhenDefinedLambda<T>): void;
+    /**
+     * Defines a provider to replace temporary providers
+     *
+     * @param {string} name
+     * @param {Function} producer
+     * @param {Object} instance
+     *
+     * Notes:
+     * - name should be regular string
+     * */
+    defineProvider<T extends CommonCallbackDefined = CommonCallbackDefined>(name: string, producer: Function, instance: T): void;
+}
+export interface CommonCallbackSecure extends ShiftMain<CommonCallback> {
+    $init(leyyo: Leyyo): void;
+}
+export interface CallbackRec {
+    initialization?: true;
+    fn: Function;
+}
+export interface CommonCallbackDefinedInternal extends CommonCallbackDefined {
+    producer: Function;
+}
+export interface CommonCallbackDefined {
+    proper: boolean;
+}
+export interface CommonCallbackDefinedItem {
+    consumer: Function;
+    callback: CallbackWhenDefinedLambda;
+}
+export interface CommonFqnCb extends CommonCallbackDefined {
+    name(value: any): string;
+}
+export type CallbackWhenDefinedLambda<T extends CommonCallbackDefined = CommonCallbackDefined> = (instance: T) => void;

package/dist/callback/index-types.js

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

package/dist/callback/index.d.ts

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

package/dist/callback/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-callback-impl"), exports);

package/dist/constants.d.ts

@@ -0,0 +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_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";
+export declare const LY_PENDING_LOG_REGISTER = "#lyy.pending.log.register";

package/dist/constants.js

@@ -0,0 +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_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_ATTACHED_FQN = '#lyy.attached.fqn';
+exports.LY_PENDING_FQN_REGISTER = '#lyy.pending.fqn.register';
+exports.LY_ATTACHED_LOG = '#lyy.attached.log';
+exports.LY_PENDING_LOG_REGISTER = '#lyy.pending.log.register';

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

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

package/dist/error/assertion-exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssertionException = void 0;
+const exception_1 = require("./exception");
+// noinspection Annotator
+class AssertionException extends exception_1.Exception {
+    constructor(indicator, params) {
+        super(indicator, Object.assign(Object.assign({}, params), { indicator }));
+    }
+}
+exports.AssertionException = AssertionException;

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

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

package/dist/error/caused-exception.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CausedException = void 0;
+const exception_1 = require("./exception");
+// noinspection Annotator
+class CausedException extends exception_1.Exception {
+    constructor(e, indicator, params) {
+        super(e.message, Object.assign(Object.assign({}, params), { indicator }));
+        this.causedBy(e);
+    }
+}
+exports.CausedException = CausedException;

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

@@ -0,0 +1,24 @@
+import { CommonError, CommonErrorSecure, ExceptionLike } from "./index-types";
+import { Leyyo } from "../leyyo";
+import { Dict } from "../aliases";
+import { Exception } from "./exception";
+export declare class CommonErrorImpl implements CommonError, CommonErrorSecure {
+    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;
+    build(e: Error | string): ExceptionLike;
+    buildStack(e: Error): void;
+    copyStack(exception: Exception, error: Error): void;
+    causedBy(e: Error | string): ExceptionLike;
+    getOmit(clz: Function): Array<string>;
+    getSign(err: Error): Array<string>;
+    hasSign(err: Error, key: string): boolean;
+    inheritOmit(clz: Function): Array<string>;
+    initOmit(clz: Function): boolean;
+    initSign(err: Error): boolean;
+    removeSign(err: Error, ...keys: Array<string>): boolean;
+    toObject(e: Error, ...omittedFields: Array<string>): Dict;
+}

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

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonErrorImpl = void 0;
+const exception_1 = require("./exception");
+const constants_1 = require("../constants");
+// noinspection JSUnusedLocalSymbols
+class CommonErrorImpl {
+    get $back() {
+        return this;
+    }
+    $init(leyyo) {
+        const fields = ['build', 'afterCreate', 'causedBy', 'toObject', 'buildStack', 'copyStack',
+            'initSign', 'addSign', 'getSign', 'removeSign', 'hasSign',
+            'initOmit', 'addOmit', 'getOmit', 'inheritOmit'];
+        const rec = { proper: false };
+        fields.forEach(field => {
+            rec[field] = this[field];
+        });
+        // define itself temporarily for error operations
+        leyyo.callback.defineProvider(constants_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) => {
+            fields.forEach(field => {
+                if (typeof ins[field] === 'function') {
+                    this[field] = ins[field];
+                }
+            });
+        });
+    }
+    get $secure() {
+        return this;
+    }
+    addOmit(clz, ...properties) {
+        return false;
+    }
+    addSign(err, ...keys) {
+        return false;
+    }
+    afterCreate(e) {
+        e.$secure.$setName(e.constructor.name);
+    }
+    build(e) {
+        if (e instanceof exception_1.Exception) {
+            return e;
+        }
+        else if (e instanceof Error) {
+            const err = new exception_1.Exception(e.message, this.toObject(e, 'message', 'stack'));
+            this.copyStack(err, e);
+            return err;
+        }
+        else if (typeof e === 'string') {
+            return new exception_1.Exception(e);
+        }
+        return new exception_1.Exception(`Unknown error`, Object.assign(Object.assign({}, this.toObject(e)), { type: typeof e }));
+    }
+    buildStack(e) {
+    }
+    copyStack(exception, error) {
+    }
+    causedBy(e) {
+        return undefined;
+    }
+    getOmit(clz) {
+        return undefined;
+    }
+    getSign(err) {
+        return undefined;
+    }
+    hasSign(err, key) {
+        return false;
+    }
+    inheritOmit(clz) {
+        return undefined;
+    }
+    initOmit(clz) {
+        return false;
+    }
+    initSign(err) {
+        return false;
+    }
+    removeSign(err, ...keys) {
+        return false;
+    }
+    toObject(e, ...omittedFields) {
+        return undefined;
+    }
+}
+exports.CommonErrorImpl = CommonErrorImpl;

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

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

package/dist/error/developer-exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeveloperException = void 0;
+const exception_1 = require("./exception");
+// noinspection Annotator
+class DeveloperException extends exception_1.Exception {
+    constructor(indicator, params) {
+        super(indicator, Object.assign(Object.assign({}, params), { indicator }));
+    }
+}
+exports.DeveloperException = DeveloperException;

package/dist/error/exception.d.ts

@@ -0,0 +1,33 @@
+import { CommonError, ExceptionLike, ExceptionParamsAppend, ExceptionSecure, ExceptionStackLine } from "./index-types";
+import { Abstract, ClassLike, ClassOrName, Dict } from "../aliases";
+import { Leyyo } from "../leyyo";
+export declare class Exception extends Error implements ExceptionLike, ExceptionSecure {
+    private static _callback;
+    private static _error;
+    private static _log;
+    private static _assertion;
+    protected _params: Dict;
+    protected _parsed: Array<ExceptionStackLine>;
+    protected _holder?: ClassOrName;
+    protected _cause?: ExceptionLike;
+    protected _req?: unknown;
+    constructor(message: string, params?: Dict);
+    get params(): Dict;
+    $setName(name: string): this;
+    causedBy(e: Error | string): this;
+    with(value: ClassLike | Abstract<any> | string | 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;
+    static cast(e: string | Error): ExceptionLike;
+    $hasSign(key: string): boolean;
+    $listSigns(): Array<string>;
+    $addSign(...keys: Array<string>): boolean;
+    $removeSign(...keys: Array<string>): boolean;
+    static $setLeyyo(leyyo: Leyyo): void;
+    static get $error(): CommonError;
+    get $back(): ExceptionLike;
+    get $secure(): ExceptionSecure;
+}

package/dist/error/exception.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Exception = void 0;
+class Exception extends Error {
+    constructor(message, params) {
+        if (global === null || global === void 0 ? void 0 : global.leyyo_is_testing) {
+            message += ` => ${JSON.stringify(Exception._assertion.secureJson(params))}`;
+        }
+        super(message);
+        this.name = Exception._callback.fqnName(this);
+        this._params = params !== null && params !== void 0 ? params : {};
+        this._parsed = [];
+        Exception._error.afterCreate(this);
+    }
+    get params() {
+        return this._params;
+    }
+    $setName(name) {
+        if (typeof name === 'string') {
+            this.name = name;
+        }
+        return this;
+    }
+    // noinspection JSUnusedLocalSymbols
+    causedBy(e) {
+        this._cause = Exception._error.causedBy(e);
+        return this;
+    }
+    with(value) {
+        this._holder = Exception._callback.fqnName(value);
+        return this;
+    }
+    appendParams(params, ignoreExisting) {
+        var _a;
+        this._params = (_a = this._params) !== null && _a !== void 0 ? _a : {};
+        try {
+            for (const [k, v] of Object.entries(params)) {
+                if (!(ignoreExisting && this._params[k] !== undefined)) {
+                    this._params[k] = v;
+                }
+            }
+        }
+        catch (e) {
+        }
+        return this;
+    }
+    log(req) {
+        if (this.$hasSign('printed')) {
+            return this;
+        }
+        if (req) {
+            this._req = req;
+        }
+        const params = {};
+        if (this._req) {
+            params['req'] = this._req;
+        }
+        // todo collect properties
+        const line = { severity: 'error', message: this, params, holder: this._holder };
+        this.$addSign('printed');
+        Exception._log.apply(line);
+        return this;
+    }
+    raise(throwable = true, req) {
+        if (!throwable) {
+            if (req) {
+                this._req = req;
+            }
+            this.log();
+            return undefined;
+        }
+        throw this;
+    }
+    toObject(...omittedFields) {
+        return Exception._error.toObject(this, ...omittedFields);
+    }
+    toJSON() {
+        try {
+            return this.toObject();
+        }
+        catch (e) {
+            return { name: this.name, message: this.message, params: this._params };
+        }
+    }
+    static cast(e) {
+        return Exception._error.build(e);
+    }
+    $hasSign(key) {
+        return Exception._error.hasSign(this, key);
+    }
+    $listSigns() {
+        return Exception._error.getSign(this);
+    }
+    $addSign(...keys) {
+        return Exception._error.addSign(this, ...keys);
+    }
+    $removeSign(...keys) {
+        return Exception._error.removeSign(this, ...keys);
+    }
+    static $setLeyyo(leyyo) {
+        if (!this._callback) {
+            this._callback = leyyo.callback;
+        }
+        if (!this._error) {
+            this._error = leyyo.error;
+        }
+        if (!this._log) {
+            this._log = leyyo.log;
+        }
+        if (!this._assertion) {
+            this._assertion = leyyo.assertion;
+        }
+    }
+    static get $error() {
+        return this._error;
+    }
+    get $back() {
+        return this;
+    }
+    get $secure() {
+        return this;
+    }
+}
+exports.Exception = Exception;

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

@@ -0,0 +1,70 @@
+import { Leyyo } from "../leyyo";
+import { Abstract, ClassLike, Dict, ShiftMain, ShiftSecure } from "../aliases";
+import { Exception } from "./exception";
+import { CommonCallbackDefined } from "../callback";
+export interface CommonError extends ShiftSecure<CommonErrorSecure> {
+    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 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> {
+    $init(leyyo: Leyyo): void;
+}
+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/error/index-types.js

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

package/dist/error/index.d.ts

@@ -0,0 +1,7 @@
+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';