@leyyo/common 1.0.0 → 1.0.2

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/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,58 +1,5 @@
-import { Leyyo } from "../leyyo";
-import { Severity } from "../literals";
-import { Dict, 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> {
-    $init(leyyo: Leyyo): 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 type LogMethod = 'error' | 'warn' | 'info' | 'log' | 'trace' | 'debug';
-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: LogMethod, 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,9 +1,10 @@
-import { Logger, LoggerLambda, LoggerSecure, LogMethod } from "./index-types";
 import { Leyyo } from "../leyyo";
+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,6 +19,6 @@ export declare class LoggerImpl implements Logger, LoggerSecure {
     get $name(): string;
     static $setLeyyo(leyyo: Leyyo): void;
     $setName(name: string): void;
-    $setMethod(method: LogMethod, lambda?: LoggerLambda): void;
+    $setMethod(method: Severity, lambda?: LoggerLambda): void;
     $assert(error: Error, indicator: string, params?: unknown): void;
 }

package/dist/log/logger-impl.js

@@ -1,24 +1,24 @@
 "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 });
         }
     }
     debug(message, params) {
@@ -53,7 +53,7 @@ class LoggerImpl {
         return this._name;
     }
     static $setLeyyo(leyyo) {
-        this._callback = leyyo.callback;
+        this._fqn = leyyo.fqn;
         this._log = leyyo.log;
     }
     $setName(name) {
@@ -64,7 +64,8 @@ class LoggerImpl {
             this[method] = lambda;
         }
         else {
-            this[method] = () => { };
+            this[method] = () => {
+            };
         }
     }
     $assert(error, indicator, params) {

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>;
@@ -91,16 +91,44 @@ type OneOfByKey<T> = {
 type XorIn<T> = {
     [K in keyof T]: T[K];
 } & unknown;
+/**
+ * An interface which contains secure mode members and provides to shift to main mode
+ * */
 export interface ShiftSecure<S extends ShiftMain<any>> {
+    /**
+     * Shifts to secure mode
+     * */
     get $secure(): S;
 }
-export interface ShiftFlat<D> {
-    get $flat(): D;
-}
+/**
+ * An interface which contains main mode members and provides to shift to secure mode
+ *
+ * IT's so useful to hide some public members
+ * - to see clean auto-completed members in IDE
+ * - to indicated that secure mode members should be used in special cases
+ * */
 export interface ShiftMain<M extends ShiftSecure<any>> {
+    /**
+     * Shifts to main mode
+     * */
     get $back(): M;
 }
+/**
+ * An interface which provides to flat generic interfaces/classes to prevent verbose casting commands
+ * */
+export interface ShiftFlat<D> {
+    /**
+     * Flats current classes, or eliminate generic parameters
+     * */
+    get $flat(): D;
+}
+/**
+ * Useful interface which provides initialization state for instances
+ * */
 export interface InitLike {
+    /**
+     * Initializes the instance
+     * */
     $init(...args: Arr): void;
 }
 /**

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

@@ -0,0 +1,141 @@
+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 {
+    name(value: any): string;
+    register(value: any, type: FqnStereoType, pckName: string): void;
+}
+export type FqnStereoType = 'class' | 'function' | 'enum' | 'literal';
+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;
+    $setName(name: string): 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';

package/dist/shared/index.js

@@ -0,0 +1,21 @@
+"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-aliases"), exports);
+__exportStar(require("./index-constants"), exports);
+__exportStar(require("./index-types"), exports);
+__exportStar(require("./assert"), exports);
+__exportStar(require("./list"), exports);

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

@@ -1,6 +1,7 @@
-import { List } from "./list";
-import { CommonStorage, CommonStorageSecure, StorageDetail, StorageItem, StorageType } from "./index-types";
+import { List, StorageDetail, StorageItem } from "../shared";
+import { CommonStorage, CommonStorageSecure } from "./index-types";
 import { Leyyo } from "../leyyo";
+import { StorageType } from "../literal";
 /** @inheritDoc */
 export declare class CommonStorageImpl implements CommonStorage, CommonStorageSecure {
     private readonly _lists;

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonStorageImpl = void 0;
-const list_1 = require("./list");
-// noinspection JSUnusedLocalSymbols
+const shared_1 = require("../shared");
+// noinspection JSUnusedLocalSymbols,JSUnusedGlobalSymbols
 /** @inheritDoc */
 class CommonStorageImpl {
     /**
@@ -80,7 +80,7 @@ class CommonStorageImpl {
     // region list
     /** @inheritDoc */
     newList(name) {
-        const list = new list_1.List();
+        const list = new shared_1.List();
         this._lists.set(name, list);
         return list;
     }

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

@@ -1,6 +1,5 @@
-import { List } from "./list";
-import { Dict, ShiftMain, ShiftSecure } from "../aliases";
-import { Leyyo } from "../leyyo";
+import { InitLike, List, ShiftMain, ShiftSecure, StorageDetail } from "../shared";
+import { StorageType } from "../literal";
 /**
  * Storage factory
  *
@@ -85,18 +84,4 @@ export interface CommonStorage extends ShiftSecure<CommonStorageSecure> {
      * */
     details(type?: StorageType, name?: string): StorageDetail;
 }
-export interface CommonStorageSecure extends ShiftMain<CommonStorage> {
-    $init(leyyo: Leyyo): void;
-}
-/**
- * Storage type literal, as an enum
- * */
-export type StorageType = 'array' | 'list' | 'map' | 'set';
-/**
- * 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 type CommonStorageSecure = ShiftMain<CommonStorage> & InitLike;

package/dist/storage/index.d.ts

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

package/dist/storage/index.js

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