@leyyo/common 1.3.16 → 1.3.18

package/dist/base/leyyo.js

@@ -1,7 +1,7 @@
 import { DeployCommon, EnumPool, ErrorCommon, ErrorPool, EventCommon, LifecycleCommon, LiteralPool, LogCommon, RepoCommon } from "../common/index.js";
 import { DeveloperError, LeyyoError } from "../error/index.js";
 import { LoggerInstance } from "../class/logger.instance.js";
-import { KEY_SECURE_1 } from "../const/index.js";
+import { KEY_LEYYO_SECURE } from "../const/index.js";
 import { $$set_leyyo_fn } from "../function/leyyo-fn.js";
 class Leyyo {
     _developerError;
@@ -21,11 +21,11 @@ class Leyyo {
         // region binding
         $$set_leyyo_fn(this);
         this._developerError = DeveloperError;
-        this._developerError[KEY_SECURE_1](this);
+        this._developerError[KEY_LEYYO_SECURE](this);
         this._leyyoError = LeyyoError;
-        this._leyyoError[KEY_SECURE_1](this);
+        this._leyyoError[KEY_LEYYO_SECURE](this);
         this._loggerInstance = LoggerInstance;
-        this._loggerInstance[KEY_SECURE_1](this);
+        this._loggerInstance[KEY_LEYYO_SECURE](this);
         // endregion binding
         // region instances
         this._repoCommon = new RepoCommon(this); // none

package/dist/class/logger.instance.d.ts

@@ -1,12 +1,12 @@
 import { LeyyoLike } from "../base/index.js";
 import { LogLevel } from "../enum/index.js";
 import { Opt } from "../function/index.js";
-import { KEY_SECURE_1 } from "../const/index.js";
+import { KEY_LEYYO_SECURE } from "../const/index.js";
 import { Logger, LoggerSecure } from "../common/index.js";
 export declare class LoggerInstance implements Logger, LoggerSecure {
     private _name;
     constructor(name: string);
-    static [KEY_SECURE_1](leyyo: LeyyoLike): void;
+    static [KEY_LEYYO_SECURE](leyyo: LeyyoLike): void;
     debug(message: any, params?: any | Opt): void;
     trace(message: any, params?: any | Opt): void;
     info(message: any, params?: any | Opt): void;

package/dist/class/logger.instance.js

@@ -1,5 +1,5 @@
 import { isText } from "../function/index.js";
-import { KEY_SECURE_1 } from "../const/index.js";
+import { KEY_LEYYO_SECURE } from "../const/index.js";
 // region property
 let _leyyo;
 // endregion property
@@ -13,7 +13,7 @@ export class LoggerInstance {
         this._name = name;
     }
     // region static
-    static [KEY_SECURE_1](leyyo) {
+    static [KEY_LEYYO_SECURE](leyyo) {
         if (!_leyyo) {
             _leyyo = leyyo;
         }

package/dist/common/repo.common.js

@@ -2,10 +2,12 @@ import { FQN } from "../internal.js";
 import { isText, testCase } from "../function/index.js";
 import { DeveloperError } from "../error/index.js";
 import { List } from "../class/index.js";
+import { getRootStorage } from "../sys/index.js";
 /**
  * Identifier of file
  * */
 const where = `${FQN}.Repo`;
+const _NAME = '$$leyyo.repo';
 // noinspection JSUnusedGlobalSymbols
 export class RepoCommon {
     leyyo;
@@ -14,35 +16,35 @@ export class RepoCommon {
     /**
      * Internal items which stores arrays
      * */
-    _arrayItems = new Map();
+    _arrayItems = getRootStorage(_NAME, new Map());
     /**
      * Internal array volatile repo which could be cleared after lifecycle run
      * */
-    _arrayVolatiles = new Set();
+    _arrayVolatiles = getRootStorage(_NAME, new Set());
     /**
      * Internal items which stores lists
      * */
-    _listItems = new Map();
+    _listItems = getRootStorage(_NAME, new Map());
     /**
      * Internal list volatiles repo which could be cleared after lifecycle run
      * */
-    _listVolatiles = new Set();
+    _listVolatiles = getRootStorage(_NAME, new Set());
     /**
      * Internal items which stores maps
      * */
-    _mapItems = new Map();
+    _mapItems = getRootStorage(_NAME, new Map());
     /**
      * Internal map volatile repo which could be cleared after lifecycle run
      * */
-    _mapVolatiles = new Set();
+    _mapVolatiles = getRootStorage(_NAME, new Set());
     /**
      * Internal items which stores sets
      * */
-    _setItems = new Map();
+    _setItems = getRootStorage(_NAME, new Map());
     /**
      * Internal set volatiles repo which could be cleared after lifecycle run
      * */
-    _setVolatiles = new Set();
+    _setVolatiles = getRootStorage(_NAME, new Set());
     // endregion property
     constructor(leyyo) {
         this.leyyo = leyyo;

package/dist/const/index.d.ts

@@ -1,5 +1,3 @@
-export declare const KEY_FQN_NAME: unique symbol;
-export declare const KEY_FQN_ON_SET: unique symbol;
 export declare const VAL_FQN_ANONYMOUS = "#Fqn";
 /**
  * Normal empty values
@@ -8,12 +6,14 @@ export declare const EMPTY_VALUES: any[];
 /**
  * Empty values with empty string
  * */
-export declare const EMPTY_VALUES_STR: string[];
-export declare const VAL_NAME_ANONYMOUS = "~";
-export declare const KEY_SECURE_1: unique symbol;
-export declare const KEY_ERROR_HTTP_STATUS: unique symbol;
+export declare const EMPTY_VALUES_STR: Array<unknown>;
+export declare const VAL_NAME_ANONYMOUS: string;
 export declare const VAL_ERROR_UNKNOWN_NAME: string;
 export declare const VAL_ERROR_UNKNOWN_MESSAGE: string;
+export declare const KEY_FQN_NAME: unique symbol;
+export declare const KEY_FQN_ON_SET: unique symbol;
+export declare const KEY_LEYYO_SECURE: unique symbol;
+export declare const KEY_ERROR_HTTP_STATUS: unique symbol;
 export declare const KEY_ERROR_DEFAULT_MESSAGE: unique symbol;
 export declare const KEY_ERROR_I18N: unique symbol;
 export declare const KEY_ERROR_EMIT: unique symbol;
@@ -31,3 +31,6 @@ export declare const KEY_ENUM_I18N: unique symbol;
 export declare const KEY_LITERAL_NAME: unique symbol;
 export declare const KEY_LITERAL_ALT: unique symbol;
 export declare const KEY_LITERAL_I18N: unique symbol;
+export declare const KEY_DEVELOPER_MESSAGE: unique symbol;
+export declare const KEY_DEVELOPER_CASE: unique symbol;
+export declare const KEY_DEVELOPER_WHERE: unique symbol;

package/dist/const/index.js

@@ -1,5 +1,3 @@
-export const KEY_FQN_NAME = Symbol.for('leyyo:fqn:basic');
-export const KEY_FQN_ON_SET = Symbol.for('leyyo:fqn:on-set');
 export const VAL_FQN_ANONYMOUS = '#Fqn';
 /**
  * Normal empty values
@@ -11,10 +9,12 @@ export const EMPTY_VALUES = [null, undefined];
  * */
 export const EMPTY_VALUES_STR = [null, undefined, ''];
 export const VAL_NAME_ANONYMOUS = '~';
-export const KEY_SECURE_1 = Symbol.for('leyyo:secure:1');
-export const KEY_ERROR_HTTP_STATUS = Symbol.for('leyyo:http:status');
 export const VAL_ERROR_UNKNOWN_NAME = 'UnknownError';
 export const VAL_ERROR_UNKNOWN_MESSAGE = 'Unknown error';
+export const KEY_FQN_NAME = Symbol.for('leyyo:fqn:basic');
+export const KEY_FQN_ON_SET = Symbol.for('leyyo:fqn:on-set');
+export const KEY_LEYYO_SECURE = Symbol.for('leyyo:secure');
+export const KEY_ERROR_HTTP_STATUS = Symbol.for('leyyo:error:http-status');
 export const KEY_ERROR_DEFAULT_MESSAGE = Symbol.for('leyyo:error:message');
 export const KEY_ERROR_I18N = Symbol.for('leyyo:error:i18n');
 export const KEY_ERROR_EMIT = Symbol.for('leyyo:error:emit');
@@ -26,9 +26,12 @@ export const KEY_LOADER_NAME = Symbol.for('leyyo:loader:name');
 export const KEY_LOADER_STAMP = Symbol.for('leyyo:loader:stamp');
 export const KEY_LOADER_EMPTY = Symbol.for('leyyo:loader:empty');
 export const KEY_LOG_ALREADY = Symbol.for('leyyo:log:already');
-export const KEY_ENUM_NAME = Symbol.for('leyyo::enum:name');
+export const KEY_ENUM_NAME = Symbol.for('leyyo:enum:name');
 export const KEY_ENUM_ALT = Symbol.for('leyyo:enum:alt');
 export const KEY_ENUM_I18N = Symbol.for('leyyo:enum:i18n');
-export const KEY_LITERAL_NAME = Symbol.for('leyyo::literal:name');
+export const KEY_LITERAL_NAME = Symbol.for('leyyo:literal:name');
 export const KEY_LITERAL_ALT = Symbol.for('leyyo:literal:alt');
 export const KEY_LITERAL_I18N = Symbol.for('leyyo:literal:i18n');
+export const KEY_DEVELOPER_MESSAGE = Symbol.for('leyyo:developer:message');
+export const KEY_DEVELOPER_CASE = Symbol.for('leyyo:developer:case');
+export const KEY_DEVELOPER_WHERE = Symbol.for('leyyo:developer:where');

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

@@ -1,14 +1,11 @@
-import { KEY_SECURE_1 } from "../const/index.js";
+import { KEY_DEVELOPER_CASE, KEY_DEVELOPER_MESSAGE, KEY_DEVELOPER_WHERE, KEY_LEYYO_SECURE } from "../const/index.js";
 import { LeyyoLike } from "../base/index.js";
 import { DeveloperErrorLike, ErrorStackLine } from "./index.types.js";
-declare const LY_DEVELOPER_MESSAGE: unique symbol;
-declare const LY_DEVELOPER_CASE: unique symbol;
-declare const LY_DEVELOPER_WHERE: unique symbol;
 /** Developer error */
 export declare class DeveloperError extends Error implements DeveloperErrorLike {
-    protected [LY_DEVELOPER_MESSAGE]: string;
-    protected [LY_DEVELOPER_CASE]: string;
-    protected [LY_DEVELOPER_WHERE]: string;
+    protected [KEY_DEVELOPER_MESSAGE]: string;
+    protected [KEY_DEVELOPER_CASE]: string;
+    protected [KEY_DEVELOPER_WHERE]: string;
     /** @inheritDoc */
     stackTrace?: Array<ErrorStackLine>;
     /**
@@ -17,8 +14,7 @@ export declare class DeveloperError extends Error implements DeveloperErrorLike
      * @param {string} where - where
      * */
     constructor(message: string, issue?: string, where?: string);
-    static [KEY_SECURE_1](leyyo: LeyyoLike): void;
+    static [KEY_LEYYO_SECURE](leyyo: LeyyoLike): void;
     /** @inheritDoc */
     log(err?: Error): void;
 }
-export {};

package/dist/error/developer.error.js

@@ -1,15 +1,12 @@
-import { KEY_SECURE_1 } from "../const/index.js";
+import { KEY_DEVELOPER_CASE, KEY_DEVELOPER_MESSAGE, KEY_DEVELOPER_WHERE, KEY_LEYYO_SECURE } from "../const/index.js";
 // region properties
-const LY_DEVELOPER_MESSAGE = Symbol.for('leyyo/developer.message');
-const LY_DEVELOPER_CASE = Symbol.for('leyyo/developer.case');
-const LY_DEVELOPER_WHERE = Symbol.for('leyyo/developer.where');
 let _leyyo;
 // endregion properties
 /** Developer error */
 export class DeveloperError extends Error {
-    [LY_DEVELOPER_MESSAGE];
-    [LY_DEVELOPER_CASE];
-    [LY_DEVELOPER_WHERE];
+    [KEY_DEVELOPER_MESSAGE];
+    [KEY_DEVELOPER_CASE];
+    [KEY_DEVELOPER_WHERE];
     /** @inheritDoc */
     stackTrace;
     /**
@@ -27,16 +24,16 @@ export class DeveloperError extends Error {
             message += ` [w:${where}]`;
         }
         super(message);
-        this[LY_DEVELOPER_MESSAGE] = pureMessage;
+        this[KEY_DEVELOPER_MESSAGE] = pureMessage;
         if (typeof issue === 'string') {
-            this[LY_DEVELOPER_CASE] = issue;
+            this[KEY_DEVELOPER_CASE] = issue;
         }
         if (typeof where === 'string') {
-            this[LY_DEVELOPER_WHERE] = where;
+            this[KEY_DEVELOPER_WHERE] = where;
         }
         _leyyo.errorCommon.buildStack(this);
     }
-    static [KEY_SECURE_1](leyyo) {
+    static [KEY_LEYYO_SECURE](leyyo) {
         if (!_leyyo) {
             _leyyo = leyyo;
         }
@@ -46,6 +43,6 @@ export class DeveloperError extends Error {
         if (err instanceof Error) {
             this['causedBy'] = err;
         }
-        _leyyo.logCommon.emitLog('fatal', this[LY_DEVELOPER_WHERE], this, _leyyo.errorCommon.toJsonBasic(this, { testCase: this[LY_DEVELOPER_CASE] }));
+        _leyyo.logCommon.emitLog('fatal', this[KEY_DEVELOPER_WHERE], this, _leyyo.errorCommon.toJsonBasic(this, { testCase: this[KEY_DEVELOPER_CASE] }));
     }
 }

package/dist/error/leyyo.error.d.ts

@@ -2,7 +2,7 @@ import { Logger } from "../common/index.js";
 import { ErrorStackLine, LeyyoErrorLike, LeyyoErrorSecure, LeyyoErrorTag } from "./index.types.js";
 import { ClassLike, LeyyoLike, Obj, OneOrMore } from "../base/index.js";
 import { Opt } from "../function/index.js";
-import { KEY_ERROR_FLAGS, KEY_SECURE_1 } from "../const/index.js";
+import { KEY_ERROR_FLAGS, KEY_LEYYO_SECURE } from "../const/index.js";
 type T2 = LeyyoErrorTag;
 /**
  * Leyyo base error
@@ -40,7 +40,7 @@ export declare class LeyyoError extends Error implements LeyyoErrorLike, LeyyoEr
      * @param {Opt} params - error parameters
      * */
     constructor(message: string, params: Opt);
-    static [KEY_SECURE_1](leyyo: LeyyoLike): void;
+    static [KEY_LEYYO_SECURE](leyyo: LeyyoLike): void;
     causes(err: Error): this;
     where(p1: ClassLike | Obj | string, fqn?: string): this;
     private _log;

package/dist/error/leyyo.error.js

@@ -1,5 +1,5 @@
 import { getFqn, getSymbol, isFilledObj, isObj, optAdd, optAppend, setSymbol } from "../function/index.js";
-import { KEY_ERROR_FLAGS, KEY_ERROR_WHERE, KEY_SECURE_1, VAL_ERROR_UNKNOWN_MESSAGE } from "../const/index.js";
+import { KEY_ERROR_FLAGS, KEY_ERROR_WHERE, KEY_LEYYO_SECURE, VAL_ERROR_UNKNOWN_MESSAGE } from "../const/index.js";
 let _leyyo;
 // region property
 const _errorField = ['name', 'message', 'stack'];
@@ -54,7 +54,7 @@ export class LeyyoError extends Error {
         _leyyo.errorCommon.buildStack(this);
         _leyyo.errorCommon.emit(this);
     }
-    static [KEY_SECURE_1](leyyo) {
+    static [KEY_LEYYO_SECURE](leyyo) {
         if (!_leyyo) {
             _leyyo = leyyo;
         }

package/dist/{sys/sys-stat.d.ts → function/get-stat.d.ts}

@@ -1,44 +1,44 @@
-export declare function sysStat(): SysStat;
-export interface SysStat {
-    cpu: SysStatCpu;
-    memory: SysStatMemory;
-    time: SysStatTime;
-    npm: SysStatNpm;
-    node: SysStatNode;
-    project: SysStatProject;
-    os: SysStatOs;
+export declare function getStat(): Statistics;
+export interface Statistics {
+    cpu: StatisticsCpu;
+    memory: StatisticsMemory;
+    time: StatisticsTime;
+    npm: StatisticsNpm;
+    node: StatisticsNode;
+    project: StatisticsProject;
+    os: StatisticsOs;
 }
-export interface SysStatCpu {
+export interface StatisticsCpu {
     user: number;
     system: number;
 }
-export interface SysStatTime {
+export interface StatisticsTime {
     uptime: number;
     startedAt: number;
 }
-export interface SysStatNpm {
+export interface StatisticsNpm {
     pwd: string;
     version: string;
 }
-export interface SysStatNode {
+export interface StatisticsNode {
     type: string;
     version: string;
 }
-export interface SysStatProject {
+export interface StatisticsProject {
     name: string;
     version: string;
     environment: string;
     log: string;
 }
-export interface SysStatOs {
+export interface StatisticsOs {
     version: string;
     arch: string;
     platform: string;
     machineType: string;
     network: Record<string, unknown>;
-    cpu: Array<SysStatCpuInfo>;
+    cpu: Array<StatisticsCpuInfo>;
 }
-export interface SysStatMemory {
+export interface StatisticsMemory {
     /**
      * Resident Set Size, is the amount of space occupied in the main memory device (that is a subset of the total allocated memory) for the
      * process, including all C++ and JavaScript objects and code.
@@ -60,7 +60,7 @@ export interface SysStatMemory {
      */
     arrayBuffers: number;
 }
-export interface SysStatCpuInfo {
+export interface StatisticsCpuInfo {
     model: string;
     speed: number;
     times: {

package/dist/{sys/sys-stat.js → function/get-stat.js}

@@ -1,5 +1,5 @@
 import os from "node:os";
-export function sysStat() {
+export function getStat() {
     const uptime = Math.round(process.uptime() * 1_000);
     return {
         cpu: process.cpuUsage(),

package/dist/function/index.d.ts

@@ -5,6 +5,7 @@ export * from './delete-prop.js';
 export * from './empty-fn.js';
 export * from './extended-type.js';
 export * from './get-fqn.js';
+export * from './get-stat.js';
 export * from './set-fqn.js';
 export * from './remove-fqn.js';
 export * from './on-fqn-set.js';
@@ -19,6 +20,7 @@ export * from './is-obj.js';
 export * from './is-text.js';
 export * from './is-anonymous-name.js';
 export * from './jitter-interval.js';
+export * from './load-config.js';
 export * from './stamp-loader.js';
 export * from './one-or-more.js';
 export * from './opt-add.js';

package/dist/function/index.js

@@ -5,6 +5,7 @@ export * from './delete-prop.js';
 export * from './empty-fn.js';
 export * from './extended-type.js';
 export * from './get-fqn.js';
+export * from './get-stat.js';
 export * from './set-fqn.js';
 export * from './remove-fqn.js';
 export * from './on-fqn-set.js';
@@ -19,6 +20,7 @@ export * from './is-obj.js';
 export * from './is-text.js';
 export * from './is-anonymous-name.js';
 export * from './jitter-interval.js';
+export * from './load-config.js';
 export * from './stamp-loader.js';
 export * from './one-or-more.js';
 export * from './opt-add.js';

package/dist/function/index.types.d.ts

@@ -33,3 +33,6 @@ export type ExporterValue = Record<string, unknown>;
 export interface ExporterDepot {
     add(name: string, value: ExporterValue): void;
 }
+export interface LeyyoConfig {
+    [fqn: string]: Record<string, unknown>;
+}

package/dist/function/index.types.js

@@ -1,2 +1 @@
 export {};
-// endregion exporter

package/dist/function/load-config.d.ts

@@ -0,0 +1,22 @@
+import { LeyyoConfig } from "./index.types.js";
+export declare const leyyoConfig: LeyyoConfig;
+/**
+ * Load config from `.leyyo.yaml` file
+ *
+ * `OBJECT` postfixes:
+ * - !: only override (`don't merge`)
+ * - ?: only merge (`don't override`)
+ * - <empty>: only set if key is absent
+ *
+ * `ARRAY` postfixes:
+ * - !: only override (`don't merge`)
+ * - ?: only merge (`don't override`)
+ * - <empty>: only set if key is absent
+ *
+ * Generics:
+ * - `C`- config model
+ *
+ * @param {string} url
+ * @return {LeyyoConfig}
+ * */
+export declare function loadConfig(url: string): LeyyoConfig;

package/dist/function/load-config.js

@@ -0,0 +1,242 @@
+import * as fs from "node:fs";
+import path from "node:path";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import * as yaml from 'js-yaml';
+import { isObj } from "./is-obj.js";
+import { getRootStorage } from "../sys/index.js";
+import { isText } from "./is-text.js";
+import { isEmpty } from "./is-empty.js";
+import { secureJson, secureObject } from "./secure-json.js";
+const _NAME = '$$leyyo.config';
+export const leyyoConfig = getRootStorage(_NAME, {});
+/**
+ * Load config from `.leyyo.yaml` file
+ *
+ * `OBJECT` postfixes:
+ * - !: only override (`don't merge`)
+ * - ?: only merge (`don't override`)
+ * - <empty>: only set if key is absent
+ *
+ * `ARRAY` postfixes:
+ * - !: only override (`don't merge`)
+ * - ?: only merge (`don't override`)
+ * - <empty>: only set if key is absent
+ *
+ * Generics:
+ * - `C`- config model
+ *
+ * @param {string} url
+ * @return {LeyyoConfig}
+ * */
+export function loadConfig(url) {
+    try {
+        const __dirname = dirname(dirname(fileURLToPath(url)));
+        const yamlPath = path.normalize(__dirname + '/.leyyo.yaml');
+        if (fs.existsSync(yamlPath)) {
+            const input = fs.readFileSync(yamlPath, 'utf8');
+            const data = yaml.load(input);
+            if (isObj(data)) {
+                for (const [k, v] of Object.entries(data)) {
+                    _object(leyyoConfig, k, v);
+                }
+            }
+            return leyyoConfig;
+        }
+    }
+    catch (e) {
+        console.error(`[leyyoConfig] ${e.name} => ${e.message}`);
+        return undefined;
+    }
+}
+/**
+ * Get key behaviour
+ * @param {string} keyFull - key
+ * @return {Array} - tuple as `[behaviour, key]`
+ * */
+function _behaviour(keyFull) {
+    if (!isText(keyFull)) {
+        return [undefined, undefined];
+    }
+    if (keyFull.endsWith('!')) {
+        keyFull = keyFull.substring(keyFull.length - 1).trim();
+        if (!isText(keyFull)) {
+            return [undefined, undefined];
+        }
+        return ['override', keyFull];
+    }
+    else if (keyFull.endsWith('?')) {
+        keyFull = keyFull.substring(keyFull.length - 1).trim();
+        if (!isText(keyFull)) {
+            return [undefined, undefined];
+        }
+        return ['merge', keyFull];
+    }
+    return [undefined, keyFull];
+}
+/**
+ * Merge array
+ *
+ * @param {Array} source
+ * @param {string} key
+ * @param {Array} value
+ * */
+function _array(source, key, value) {
+    value.forEach((item, index) => {
+        if (isEmpty(item)) {
+            console.warn(`[leyyoConfig] value empty at (${key}#${index})`);
+            return;
+        }
+        const clonedSource = source.map(item => JSON.stringify(item));
+        switch (typeof item) {
+            case "string":
+            case "number":
+            case "boolean":
+                if (!clonedSource.includes(JSON.stringify(item))) {
+                    source.push(item);
+                }
+                break;
+            case "object":
+                if (!clonedSource.includes(secureJson(item))) {
+                    source.push(secureObject(item));
+                }
+                break;
+            case "undefined":
+            case "bigint":
+            case "symbol":
+            case "function":
+                console.warn(`[leyyoConfig] type is not allowed at (${key}#${index})`);
+                break;
+        }
+    });
+}
+/**
+ * Merge object
+ *
+ * @param {object} source
+ * @param {string} keyFull - key
+ * @param {any} value
+ * */
+function _object(source, keyFull, value) {
+    if (isEmpty(value)) {
+        return;
+    }
+    const [behaviour, key] = _behaviour(keyFull);
+    if (!key) {
+        console.warn(`[leyyoConfig] key empty at (${keyFull})`);
+        return;
+    }
+    if (!source) {
+        source = {};
+    }
+    // old is empty
+    if (isEmpty(source[key])) {
+        switch (typeof value) {
+            case "string":
+            case "number":
+            case "boolean":
+                source[key] = value;
+                break;
+            case "object":
+                source[key] = secureObject(value);
+                break;
+            case "function":
+            case "symbol":
+            case "bigint":
+            case "undefined":
+                console.warn(`[leyyoConfig] type is not allowed at (${key})`);
+                break;
+        }
+        return;
+    }
+    switch (typeof value) {
+        case "string":
+        case "number":
+        case "boolean":
+            switch (behaviour) {
+                case "override":
+                    source[key] = value;
+                    break;
+                default: // merge
+                    if (isEmpty(source[key])) {
+                        source[key] = value;
+                    }
+                    break;
+            }
+            break;
+        case "object":
+            // new is an array
+            if (Array.isArray(value)) {
+                // old is an array (BOTH)
+                if (Array.isArray(source[key])) {
+                    switch (behaviour) {
+                        case "override":
+                            source[key] = secureObject(value);
+                            break;
+                        case "merge":
+                            _array(source[key], key, value);
+                            break;
+                        default:
+                            // old exists, ignore
+                            break;
+                    }
+                }
+                // CONFLICT: old is not array
+                else {
+                    switch (behaviour) {
+                        case "override":
+                            source[key] = secureObject(value);
+                            break;
+                        case "merge":
+                            // old is different, conflict
+                            console.warn(`[leyyoConfig] type is conflicted at (${key})`);
+                            break;
+                        default:
+                            // old exists, ignore
+                            break;
+                    }
+                }
+            }
+            // new is an object
+            else {
+                // CONFLICT: old is not object
+                if (Array.isArray(source[key])) {
+                    switch (behaviour) {
+                        case "override":
+                            source[key] = value;
+                            break;
+                        case "merge":
+                            // old is different, conflict
+                            console.warn(`[leyyoConfig] type is conflicted at (${key})`);
+                            break;
+                        default:
+                            // old exists, ignore
+                            break;
+                    }
+                }
+                // old is an object (BOTH)
+                else {
+                    switch (behaviour) {
+                        case "override":
+                            source[key] = value;
+                            break;
+                        case "merge":
+                            for (const [k, v] of Object.entries(value)) {
+                                _object(source[key], k, v);
+                            }
+                            break;
+                        default:
+                            // old exists, ignore
+                            break;
+                    }
+                }
+            }
+            break;
+        case "function":
+        case "symbol":
+        case "bigint":
+        case "undefined":
+            console.warn(`[leyyoConfig] type is not allowed at (${key})`);
+            break;
+    }
+}

package/dist/internal.d.ts

@@ -1 +1 @@
-export declare const NME: string, FQN: string, VER: string, CNF: import("./sys/index.types.js").LeyyoConfig;
+export declare const NME: string, FQN: string, VER: string;

package/dist/internal.js

@@ -1,2 +1,2 @@
-import { sysAll } from "./sys/index.js";
-export const { pck: { name: NME, fqn: FQN, version: VER }, config: CNF } = sysAll(import.meta.url);
+import { packageJson } from "./sys/index.js";
+export const { name: NME, fqn: FQN, version: VER } = packageJson(import.meta.url);

package/dist/sys/index.d.ts

@@ -1,4 +1,2 @@
-export * from './index.types.js';
-export * from './leyyo-config.js';
 export * from './package-json.js';
-export * from './sys-all.js';
+export * from './leyyo-storage.js';

package/dist/sys/index.js

@@ -1,4 +1,2 @@
-export * from './index.types.js';
-export * from './leyyo-config.js';
 export * from './package-json.js';
-export * from './sys-all.js';
+export * from './leyyo-storage.js';

package/dist/sys/leyyo-storage.d.ts

@@ -0,0 +1,11 @@
+type LeyyoStorage = Map<string, unknown>;
+/**
+ * Local storage for leyyo platform
+ * */
+export declare const leyyoStorage: LeyyoStorage;
+/**
+ * @param {string} name - name of storage
+ * @param {any} def - initial value
+ * */
+export declare function getRootStorage<T>(name: string, def: T): T;
+export {};

package/dist/sys/leyyo-storage.js

@@ -0,0 +1,59 @@
+const _NAME = '$$leyyo.packages';
+/**
+ * Create a standalone storage
+ *
+ * @return {LeyyoStorage}
+ * */
+function _new() {
+    return new Map();
+}
+/**
+ * Get a global storage
+ *
+ * @param {any} source - `global` or `globalThis`
+ * @return {LeyyoStorage}
+ * */
+function _get(source) {
+    if (!source) {
+        return undefined;
+    }
+    if (source[_NAME] && source[_NAME] instanceof Map) {
+        return source[_NAME];
+    }
+    source[_NAME] = _new();
+    return source[_NAME];
+}
+/**
+ * Build storage
+ *
+ * @return {LeyyoStorage}
+ * */
+function _build() {
+    try {
+        return _get(globalThis) ?? _get(global) ?? _new();
+    }
+    catch (e) {
+        return _new();
+    }
+}
+/**
+ * Local storage for leyyo platform
+ * */
+export const leyyoStorage = _build();
+/**
+ * @param {string} name - name of storage
+ * @param {any} def - initial value
+ * */
+export function getRootStorage(name, def) {
+    if (typeof name !== 'string') {
+        throw new Error('Invalid storage name', name);
+    }
+    if (leyyoStorage.has(name)) {
+        return leyyoStorage.get(name);
+    }
+    if (!def || typeof def !== 'object') {
+        throw new Error('Invalid storage value', def);
+    }
+    leyyoStorage.set(name, def);
+    return def;
+}

package/dist/sys/package-json.d.ts

@@ -1,3 +1,8 @@
-import { PackageJson } from "./index.types.js";
+export interface PackageJson {
+    fqn: string;
+    name: string;
+    version: string;
+    [k: string]: unknown;
+}
 export declare function packageJson<P extends PackageJson = PackageJson>(url: string): P;
 export declare function packageJson<P extends PackageJson = PackageJson>(url: string, full: true): P;

package/dist/sys/package-json.js

@@ -2,8 +2,10 @@ import * as fs from "node:fs";
 import path from "node:path";
 import { dirname } from "path";
 import { fileURLToPath } from "url";
+import { getRootStorage } from "./leyyo-storage.js";
+const _NAME = '$$leyyo.packages';
 const _empty = { fqn: 'leyyo.unknown', name: '@leyyo/unknown', version: '0.0.0' };
-const _map = new Map();
+const _map = getRootStorage(_NAME, new Map());
 export function packageJson(url, full) {
     try {
         const __dirname = dirname(dirname(fileURLToPath(url)));
@@ -17,9 +19,17 @@ export function packageJson(url, full) {
                 const name = jsonData.name;
                 const version = jsonData.version;
                 if (_map.has(name)) {
-                    console.error(`Same package[${name}] duplicated, versions: ['${_map.get(name)}', '${version}']`);
+                    if (Array.isArray(_map.get(name))) {
+                        console.warn(`Same package[${name}] duplicated, current: ${version}, previous versions: ${JSON.stringify(_map.get(name))}`);
+                    }
+                    else {
+                        _map.set(name, []);
+                    }
                 }
-                _map.set(name, version);
+                else {
+                    _map.set(name, []);
+                }
+                _map.get(name).push(version);
                 const fqn = jsonData?.name.split('/').join('.').split('@').join('');
                 if (full) {
                     return { ...jsonData, fqn };
@@ -33,7 +43,7 @@ export function packageJson(url, full) {
         }
     }
     catch (e) {
-        console.log(`[packageJson] ${e.name} => ${e.message}`);
+        console.error(`[packageJson] ${e.name} => ${e.message}`);
         return _empty;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leyyo/common",
-  "version": "1.3.16",
+  "version": "1.3.18",
   "description": "Leyyo common library",
   "keywords": [
     "common"
@@ -39,6 +39,7 @@
     "@types/jest": "^30.0.0",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^24.2.1",
+    "@types/node-localstorage": "^1.3.3",
     "@typescript-eslint/eslint-plugin": "^8.39.1",
     "@typescript-eslint/parser": "^8.39.1",
     "eslint": "^9.33.0",
@@ -64,6 +65,7 @@
   },
   "dependencies": {
     "js-yaml": "^4.1.1",
+    "node-localstorage": "^3.0.5",
     "stacktrace-parser": "^0.1.11"
   }
 }

package/dist/sys/index.types.d.ts

@@ -1,13 +0,0 @@
-export interface PackageJson {
-    fqn: string;
-    name: string;
-    version: string;
-    [k: string]: unknown;
-}
-export interface LeyyoConfig {
-    [fqn: string]: Record<string, unknown>;
-}
-export interface LeyyoSysAll<C extends LeyyoConfig = LeyyoConfig, P extends PackageJson = PackageJson> {
-    config: C;
-    pck: P;
-}

package/dist/sys/index.types.js

@@ -1 +0,0 @@
-export {};

package/dist/sys/leyyo-config.d.ts

@@ -1,2 +0,0 @@
-import { LeyyoConfig } from "./index.types.js";
-export declare function leyyoConfig<C extends LeyyoConfig = LeyyoConfig>(url: string): C;

package/dist/sys/leyyo-config.js

@@ -1,19 +0,0 @@
-import * as fs from "node:fs";
-import path from "node:path";
-import { dirname } from "path";
-import { fileURLToPath } from "url";
-import * as yaml from 'js-yaml';
-export function leyyoConfig(url) {
-    try {
-        const __dirname = dirname(dirname(fileURLToPath(url)));
-        const yamlPath = path.normalize(__dirname + '/.leyyo.yaml');
-        if (fs.existsSync(yamlPath)) {
-            const input = fs.readFileSync(yamlPath, 'utf8');
-            return yaml.load(input);
-        }
-    }
-    catch (e) {
-        console.log(`[leyyoConfig] ${e.name} => ${e.message}`);
-        return undefined;
-    }
-}

package/dist/sys/sys-all.d.ts

@@ -1,2 +0,0 @@
-import { LeyyoConfig, LeyyoSysAll, PackageJson } from "./index.types.js";
-export declare function sysAll<C extends LeyyoConfig = LeyyoConfig, P extends PackageJson = PackageJson>(url: string): LeyyoSysAll<C, P>;

package/dist/sys/sys-all.js

@@ -1,8 +0,0 @@
-import { leyyoConfig } from "./leyyo-config.js";
-import { packageJson } from "./package-json.js";
-export function sysAll(url) {
-    return {
-        config: leyyoConfig(url),
-        pck: packageJson(url),
-    };
-}