@leyyo/common 1.0.0

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonLogImpl = void 0;
+const logger_impl_1 = require("./logger-impl");
+const constants_1 = require("../constants");
+// noinspection JSUnusedLocalSymbols
+class CommonLogImpl {
+    constructor() {
+        this.create.bind(this);
+        this.apply.bind(this);
+        this.check.bind(this);
+        this.print.bind(this);
+    }
+    get $secure() {
+        throw this;
+    }
+    $init(leyyo) {
+        this.callback = leyyo.callback;
+        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);
+        // when new log provider is defined, replace all common methods
+        this.callback.whenProviderDefined(constants_1.LY_ATTACHED_LOG, CommonLogImpl, (ins) => {
+            fields.forEach(field => {
+                if (typeof ins[field] === 'function') {
+                    this[field] = ins[field];
+                }
+            });
+        });
+    }
+    create(clazz) {
+        const ins = new logger_impl_1.LoggerImpl(clazz);
+        this.callback.queueForCallback(constants_1.LY_PENDING_LOG_REGISTER, ins, clazz);
+        return ins;
+    }
+    apply(line) {
+        if ((global === null || global === void 0 ? void 0 : global.leyyo_is_testing) || !line) {
+            return;
+        }
+        const lineEnhanced = line;
+        lineEnhanced.time = new Date();
+        this.check(lineEnhanced);
+        this.print(lineEnhanced);
+    }
+    check(line) {
+        // nothing
+    }
+    print(line) {
+        console[line.severity](`[${line.time}] ${line.severity} ${line.holder} ${line.message}`, line.params);
+    }
+    get $back() {
+        return this;
+    }
+}
+exports.CommonLogImpl = CommonLogImpl;

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

@@ -0,0 +1,58 @@
+import { Leyyo } from "../leyyo";
+import { Severity } from "../literals";
+import { Dict, ShiftMain, ShiftSecure } from "../aliases";
+import { CommonCallbackDefined } from "../callback";
+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;

package/dist/log/index-types.js

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

package/dist/log/index.d.ts

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

package/dist/log/index.js

@@ -0,0 +1,19 @@
+"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("./logger-impl"), exports);
+__exportStar(require("./common-log-impl"), exports);

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

@@ -0,0 +1,23 @@
+import { Logger, LoggerLambda, LoggerSecure, LogMethod } from "./index-types";
+import { Leyyo } from "../leyyo";
+export declare class LoggerImpl implements Logger, LoggerSecure {
+    private readonly _clazz;
+    private _name;
+    private static _callback;
+    private static _log;
+    constructor(value: Object | Function | string);
+    debug(message: any, params?: any): void;
+    error(message: any, params?: any): void;
+    info(message: any, params?: any): void;
+    log(message: any, params?: any): void;
+    trace(message: any, params?: any): void;
+    warn(message: any, params?: any): void;
+    get $back(): Logger;
+    get $secure(): LoggerSecure;
+    get $clazz(): Function;
+    get $name(): string;
+    static $setLeyyo(leyyo: Leyyo): void;
+    $setName(name: string): void;
+    $setMethod(method: LogMethod, lambda?: LoggerLambda): void;
+    $assert(error: Error, indicator: string, params?: unknown): void;
+}

package/dist/log/logger-impl.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerImpl = void 0;
+const error_1 = require("../error");
+// noinspection JSUnusedLocalSymbols
+class LoggerImpl {
+    constructor(value) {
+        switch (typeof value) {
+            case "function":
+                this._clazz = value;
+                this._name = LoggerImpl._callback.fqnName(value);
+                break;
+            case "object":
+                this._clazz = value.constructor;
+                this._name = LoggerImpl._callback.fqnName(value);
+                break;
+            case "string":
+                this._name = value;
+                break;
+            default:
+                throw new error_1.DeveloperException('invalid.logger.name', { type: typeof value });
+        }
+    }
+    debug(message, params) {
+        LoggerImpl._log.apply({ severity: 'debug', message: message, holder: this._name, params: params });
+    }
+    error(message, params) {
+        LoggerImpl._log.apply({ severity: 'error', message: message, holder: this._name, params: params });
+    }
+    info(message, params) {
+        LoggerImpl._log.apply({ severity: 'info', message: message, holder: this._name, params: params });
+    }
+    log(message, params) {
+        LoggerImpl._log.apply({ severity: 'log', message: message, holder: this._name, params: params });
+    }
+    trace(message, params) {
+        LoggerImpl._log.apply({ severity: 'trace', message: message, holder: this._name, params: params });
+    }
+    warn(message, params) {
+        LoggerImpl._log.apply({ severity: 'warn', message: message, holder: this._name, params: params });
+    }
+    // region secure
+    get $back() {
+        return this;
+    }
+    get $secure() {
+        return this;
+    }
+    get $clazz() {
+        return this._clazz;
+    }
+    get $name() {
+        return this._name;
+    }
+    static $setLeyyo(leyyo) {
+        this._callback = leyyo.callback;
+        this._log = leyyo.log;
+    }
+    $setName(name) {
+        this._name = name;
+    }
+    $setMethod(method, lambda) {
+        if (typeof lambda === 'function') {
+            this[method] = lambda;
+        }
+        else {
+            this[method] = () => { };
+        }
+    }
+    $assert(error, indicator, params) {
+    }
+}
+exports.LoggerImpl = LoggerImpl;

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

@@ -0,0 +1,46 @@
+import { List } from "./list";
+import { CommonStorage, CommonStorageSecure, StorageDetail, StorageItem, StorageType } from "./index-types";
+import { Leyyo } from "../leyyo";
+/** @inheritDoc */
+export declare class CommonStorageImpl implements CommonStorage, CommonStorageSecure {
+    private readonly _lists;
+    private readonly _arrays;
+    private readonly _maps;
+    private readonly _sets;
+    /**
+     * Default constructor
+     *
+     * Responsibilities
+     * - Create repositories => ie: lists, arrays, maps, sets
+     * */
+    constructor();
+    $init(leyyo: Leyyo): void;
+    /**
+     * Get sizes of each repository by given type and name (optional)
+     *
+     * @param {StorageType} type
+     * @param {string?} name
+     * @return {StorageItem}
+     * */
+    protected detailItem(type: StorageType, name?: string): StorageItem;
+    /** @inheritDoc */
+    newList<V>(name: string): List<V>;
+    /** @inheritDoc */
+    getList<V>(name: string): List<V>;
+    /** @inheritDoc */
+    newArray<V>(name: string): Array<V>;
+    /** @inheritDoc */
+    getArray<V>(name: string): Array<V>;
+    /** @inheritDoc */
+    newMap<V>(name: string): Map<string, V>;
+    /** @inheritDoc */
+    getMap<V>(name: string): Map<string, V>;
+    /** @inheritDoc */
+    newSet<V>(name: string): Set<V>;
+    /** @inheritDoc */
+    getSet<V>(name: string): Set<V>;
+    /** @inheritDoc */
+    details(type?: StorageType, name?: string): StorageDetail;
+    get $back(): CommonStorage;
+    get $secure(): CommonStorageSecure;
+}

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

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonStorageImpl = void 0;
+const list_1 = require("./list");
+// noinspection JSUnusedLocalSymbols
+/** @inheritDoc */
+class CommonStorageImpl {
+    /**
+     * Default constructor
+     *
+     * Responsibilities
+     * - Create repositories => ie: lists, arrays, maps, sets
+     * */
+    constructor() {
+        this._lists = new Map();
+        this._arrays = new Map();
+        this._maps = new Map();
+        this._sets = new Map();
+    }
+    $init(leyyo) {
+    }
+    /**
+     * Get sizes of each repository by given type and name (optional)
+     *
+     * @param {StorageType} type
+     * @param {string?} name
+     * @return {StorageItem}
+     * */
+    detailItem(type, name) {
+        const result = {};
+        switch (type) {
+            case "array":
+                if (name) {
+                    if (this._arrays.has(name)) {
+                        return { [name]: this._arrays.get(name).length };
+                    }
+                    return { [name]: -1 };
+                }
+                for (const [key, list] of this._arrays.entries()) {
+                    result[key] = list.length;
+                }
+                return result;
+            case "list":
+                if (name) {
+                    if (this._lists.has(name)) {
+                        return { [name]: this._lists.get(name).length };
+                    }
+                    return { [name]: -1 };
+                }
+                for (const [key, list] of this._lists.entries()) {
+                    result[key] = list.length;
+                }
+                return result;
+            case "map":
+                if (name) {
+                    if (this._maps.has(name)) {
+                        return { [name]: this._maps.get(name).size };
+                    }
+                    return { [name]: -1 };
+                }
+                for (const [key, map] of this._maps.entries()) {
+                    result[key] = map.size;
+                }
+                return result;
+            case "set":
+                if (name) {
+                    if (this._sets.has(name)) {
+                        return { [name]: this._sets.get(name).size };
+                    }
+                    return { [name]: -1 };
+                }
+                for (const [key, set] of this._sets.entries()) {
+                    result[key] = set.size;
+                }
+                return result;
+            default:
+                return { [name]: -1 };
+        }
+    }
+    // region list
+    /** @inheritDoc */
+    newList(name) {
+        const list = new list_1.List();
+        this._lists.set(name, list);
+        return list;
+    }
+    /** @inheritDoc */
+    getList(name) {
+        return this._lists.get(name);
+    }
+    // endregion list
+    // region array
+    /** @inheritDoc */
+    newArray(name) {
+        const arr = [];
+        this._arrays.set(name, arr);
+        return arr;
+    }
+    /** @inheritDoc */
+    getArray(name) {
+        return this._arrays.get(name);
+    }
+    // endregion array
+    // region map
+    /** @inheritDoc */
+    newMap(name) {
+        const map = new Map;
+        this._maps.set(name, map);
+        return map;
+    }
+    /** @inheritDoc */
+    getMap(name) {
+        return this._maps.get(name);
+    }
+    // endregion map
+    // region set
+    /** @inheritDoc */
+    newSet(name) {
+        const set = new Set;
+        this._sets.set(name, set);
+        return set;
+    }
+    /** @inheritDoc */
+    getSet(name) {
+        return this._sets.get(name);
+    }
+    // endregion set
+    /** @inheritDoc */
+    details(type, name) {
+        const result = {};
+        if (type) {
+            result[type] = this.detailItem(type, name);
+            return result;
+        }
+        else {
+            result['array'] = this.detailItem('array', name);
+            result['list'] = this.detailItem('list', name);
+            result['map'] = this.detailItem('map', name);
+            result['set'] = this.detailItem('set', name);
+            return result;
+        }
+    }
+    get $back() {
+        return this;
+    }
+    get $secure() {
+        return this;
+    }
+}
+exports.CommonStorageImpl = CommonStorageImpl;

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

@@ -0,0 +1,102 @@
+import { List } from "./list";
+import { Dict, ShiftMain, ShiftSecure } from "../aliases";
+import { Leyyo } from "../leyyo";
+/**
+ * Storage factory
+ *
+ * Purpose, unify all iteration based data in some place to track memory usage in your applications
+ * */
+export interface CommonStorage extends ShiftSecure<CommonStorageSecure> {
+    /**
+     * Creates new array
+     *
+     * @param {string} name
+     * @return {Array<any>}
+     * */
+    newArray<V>(name: string): Array<V>;
+    /**
+     * Returns an array by given name
+     *
+     * @param {string} name
+     * @return {Array<any>}
+     *
+     * Note:
+     * If the array does not exist than it returns null
+     * */
+    getArray<V>(name: string): Array<V>;
+    /**
+     * Creates new list
+     *
+     * @param {string} name
+     * @return {List<any>}
+     * */
+    newList<V>(name: string): List<V>;
+    /**
+     * Returns a list by given name
+     *
+     * @param {string} name
+     * @return {List<any>}
+     *
+     * Note:
+     * If the list does not exist than it returns null
+     * */
+    getList<V>(name: string): List<V>;
+    /**
+     * Creates new map
+     *
+     * @param {string} name
+     * @return {Map<string, any>}
+     * */
+    newMap<V>(name: string): Map<string, V>;
+    /**
+     * Returns a map by given name
+     *
+     * @param {string} name
+     * @return {Map<string, any>}
+     *
+     * Note:
+     * If the map does not exist than it returns null
+     * */
+    getMap<V>(name: string): Map<string, V>;
+    /**
+     * Creates new set
+     *
+     * @param {string} name
+     * @return {Set<any>}
+     * */
+    newSet<V>(name: string): Set<V>;
+    /**
+     * Returns a set by given name
+     *
+     * @param {string} name
+     * @return {Set<any>}
+     *
+     * Note:
+     * If the set does not exist than it returns null
+     * */
+    getSet<V>(name: string): Set<V>;
+    /**
+     * Exports sizes of repositories by given type and name
+     *
+     *
+     * @param {StorageType?} type
+     * @param {string?} name
+     * @return {StorageDetail}
+     * */
+    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>;

package/dist/storage/index-types.js

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

package/dist/storage/index.d.ts

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

package/dist/storage/index.js

@@ -0,0 +1,19 @@
+"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("./list"), exports);
+__exportStar(require("./common-storage-impl"), exports);

package/dist/storage/list.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Extended array class, ie: Clearable arrays
+ * */
+export declare class List<T> extends Array<T> {
+    /**
+     * Clears array items, to align all iteration repositories, like Set, Map etc
+     * */
+    clear(): void;
+}

package/dist/storage/list.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.List = void 0;
+// noinspection JSUnusedGlobalSymbols
+/**
+ * Extended array class, ie: Clearable arrays
+ * */
+class List extends Array {
+    /**
+     * Clears array items, to align all iteration repositories, like Set, Map etc
+     * */
+    clear() {
+        this.splice(0, this.length);
+    }
+}
+exports.List = List;

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

@@ -0,0 +1,38 @@
+import { CommonTo, CommonToSecure, TypeArrayOpt, TypeEnumOpt, TypeObjectOpt, TypeOpt } from "./index-types";
+import { Dict, KeyValue, OneOrMore } from "../aliases";
+import { Leyyo } from "../leyyo";
+export declare class CommonToImpl implements CommonTo, CommonToSecure {
+    private readonly _EXPECTED_ANY;
+    private readonly _EXPECTED_ARRAY;
+    private readonly _EXPECTED_BOOL;
+    private readonly _EXPECTED_CLASS;
+    private readonly _EXPECTED_DATE;
+    private readonly _EXPECTED_ENUM;
+    private readonly _EXPECTED_NUMBER;
+    private readonly _EXPECTED_STRING;
+    private is;
+    private callback;
+    private assertion;
+    private _enumInMap;
+    private _enumInArray;
+    private _enumInAlteration;
+    runFn<T = unknown>(fn: Function, value: Function, opt?: TypeOpt): T;
+    runSave<T = unknown>(fn: Function, value: unknown, opt?: TypeOpt): T;
+    raiseInvalidValue<T = unknown>(value: unknown, expected: OneOrMore<string>, opt?: TypeOpt, params?: Dict): T;
+    any(value: unknown, opt?: TypeOpt): unknown;
+    array<T = unknown>(value: unknown, opt?: TypeArrayOpt): Array<T>;
+    boolean(value: unknown, opt?: TypeOpt): boolean;
+    clazz(value: unknown, opt?: TypeOpt): string;
+    date(value: unknown, opt?: TypeOpt): Date;
+    enumeration<T extends KeyValue = KeyValue>(value: unknown, opt?: TypeEnumOpt<T>): T;
+    float(value: unknown, opt?: TypeOpt): number | null;
+    func<T = Function>(value: unknown, opt?: TypeOpt): T | null;
+    integer(value: unknown, opt?: TypeOpt): number | null;
+    object<T = unknown>(value: unknown, opt?: TypeObjectOpt): Dict<T>;
+    dict<T = unknown>(value: unknown, opt?: TypeObjectOpt): Dict<T>;
+    string(value: unknown, opt?: TypeOpt): string;
+    text(value: unknown, opt?: TypeOpt): string;
+    $init(leyyo: Leyyo): void;
+    get $back(): CommonTo;
+    get $secure(): CommonToSecure;
+}