@leyyo/common 1.3.16 → 1.3.17

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/{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.17",
   "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),
-    };
-}