vrack2-core 1.0.5 → 1.1.0

package/lib/ImportManager.js

@@ -22,15 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -61,23 +52,21 @@ class ImportManager {
      *
      * @param {string} path Full or relative path to file
     */
-    static importPath(raPath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // IF we have absolute path
-            if (path_1.default.isAbsolute(raPath)) {
-                const ti = yield ImportManager.tryImport(raPath);
-                if (ti !== false)
-                    return ti;
-            }
-            const mbfp = path_1.default.join(ImportManager.systemPath(), raPath);
-            if ((0, fs_1.existsSync)(mbfp)) {
-                const ti = yield ImportManager.tryImport(raPath);
-                if (ti !== false)
-                    return ti;
-            }
-            const ti = yield Promise.resolve(`${raPath}`).then(s => __importStar(require(s)));
-            return ti;
-        });
+    static async importPath(raPath) {
+        // IF we have absolute path
+        if (path_1.default.isAbsolute(raPath)) {
+            const ti = await ImportManager.tryImport(raPath);
+            if (ti !== false)
+                return ti;
+        }
+        const mbfp = path_1.default.join(ImportManager.systemPath(), raPath);
+        if ((0, fs_1.existsSync)(mbfp)) {
+            const ti = await ImportManager.tryImport(raPath);
+            if (ti !== false)
+                return ti;
+        }
+        const ti = await Promise.resolve(`${raPath}`).then(s => __importStar(require(s)));
+        return ti;
     }
     /**
      * Import class like a vrack2 device style
@@ -87,22 +76,20 @@ class ImportManager {
      *
      * @example ImportManager.importClass('vrack2-core.Container')
     */
-    static importClass(cs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const acts = cs.split('.');
-            const vendor = acts.shift();
-            if (typeof vendor !== 'string')
-                throw ErrorManager_1.default.make('IM_CLASS_PATH_ERROR', { path: cs });
-            let ret = yield ImportManager.tryImport(vendor);
-            if (ret === false)
-                throw ErrorManager_1.default.make('IM_CLASS_VENDOR_ERROR', { path: cs });
-            for (const act of acts) {
-                ret = ret[act];
-                if (ret === undefined)
-                    throw ErrorManager_1.default.make('IM_CLASS_ACT_ERROR', { path: cs });
-            }
-            return ret;
-        });
+    static async importClass(cs) {
+        const acts = cs.split('.');
+        const vendor = acts.shift();
+        if (typeof vendor !== 'string')
+            throw ErrorManager_1.default.make('IM_CLASS_PATH_ERROR', { path: cs });
+        let ret = await ImportManager.tryImport(vendor);
+        if (ret === false)
+            throw ErrorManager_1.default.make('IM_CLASS_VENDOR_ERROR', { path: cs });
+        for (const act of acts) {
+            ret = ret[act];
+            if (ret === undefined)
+                throw ErrorManager_1.default.make('IM_CLASS_ACT_ERROR', { path: cs });
+        }
+        return ret;
     }
     /**
      * Attempts to open a file and use its contents as json
@@ -237,15 +224,13 @@ class ImportManager {
     /**
      * Try import method
     */
-    static tryImport(p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield Promise.resolve(`${p}`).then(s => __importStar(require(s)));
-            }
-            catch (error) {
-                return false;
-            }
-        });
+    static async tryImport(p) {
+        try {
+            return await Promise.resolve(`${p}`).then(s => __importStar(require(s)));
+        }
+        catch (error) {
+            return false;
+        }
     }
 }
 exports.default = ImportManager;

package/lib/MainProcess.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -34,17 +25,13 @@ class MainProcess {
         this.Bootstrap = new Bootstrap_1.default(this.options.bootstrap);
         this.Container = new this.options.ContainerClass(this.options.id, this.options.service, this.Bootstrap, this.options.confFile);
     }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.check();
-            yield this.Container.runProcess();
-        });
+    async run() {
+        await this.check();
+        await this.Container.runProcess();
     }
-    check() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.Bootstrap.loadBootList(this.Container);
-            yield this.Container.init();
-        });
+    async check() {
+        await this.Bootstrap.loadBootList(this.Container);
+        await this.Container.init();
     }
 }
 exports.default = MainProcess;

package/lib/ReactiveRef.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Простой реактивный ref-аналог (как в Vue 3), но только для объектов.
+ * Поддерживает глубокую реактивность вложенных plain-объектов.
+ * Массивы НЕ отслеживаются внутри — только при переприсвоении свойства целиком.
+ *
+ * @example
+ * ```ts
+ * const state = new ReactiveRef({ user: { name: 'Alice' }, items: [1, 2] });
+ *
+ * state.watch(() => console.log('изменилось!'));
+ *
+ * state.value.user.name = 'Bob';        // вызовет callback
+ * state.value.items = [1, 2, 3];        // вызовет callback
+ * state.value.items.push(4);            // НЕ вызовет (мутация массива)
+ * ```
+ */
+export default class ReactiveRef<T extends object> {
+    /**
+     * Хранимое значение
+    */
+    private _value;
+    /**
+     * Калбек для обработки при измении значения
+    */
+    private watcher;
+    /**
+     * При создании иницируем объектом
+    */
+    constructor(initialValue: T);
+    /**
+     * Getter value
+    */
+    get value(): T;
+    /**
+     * Назначает обработчик который будет вызван при изменении объекта
+    */
+    watch(callback: () => void): void;
+    /**
+     * Возвращает true если это простой объект не являющийся массивом или null
+     * Null кстати тоже объект внутри JS из-за чего эта проверка очень актуальна
+    */
+    private isPlainObject;
+    /**
+     * Делает переданный объект (если он объект) реактивным
+     * Причем делает свойства объекта тоже реактивными рекурсивно
+    */
+    private makeReactive;
+}

package/lib/ReactiveRef.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Простой реактивный ref-аналог (как в Vue 3), но только для объектов.
+ * Поддерживает глубокую реактивность вложенных plain-объектов.
+ * Массивы НЕ отслеживаются внутри — только при переприсвоении свойства целиком.
+ *
+ * @example
+ * ```ts
+ * const state = new ReactiveRef({ user: { name: 'Alice' }, items: [1, 2] });
+ *
+ * state.watch(() => console.log('изменилось!'));
+ *
+ * state.value.user.name = 'Bob';        // вызовет callback
+ * state.value.items = [1, 2, 3];        // вызовет callback
+ * state.value.items.push(4);            // НЕ вызовет (мутация массива)
+ * ```
+ */
+class ReactiveRef {
+    /**
+     * При создании иницируем объектом
+    */
+    constructor(initialValue) {
+        /**
+         * Калбек для обработки при измении значения
+        */
+        this.watcher = () => { };
+        this._value = this.makeReactive(initialValue);
+    }
+    /**
+     * Getter value
+    */
+    get value() {
+        return this._value;
+    }
+    /**
+     * Назначает обработчик который будет вызван при изменении объекта
+    */
+    watch(callback) {
+        this.watcher = callback;
+    }
+    /**
+     * Возвращает true если это простой объект не являющийся массивом или null
+     * Null кстати тоже объект внутри JS из-за чего эта проверка очень актуальна
+    */
+    isPlainObject(val) {
+        return val !== null && typeof val === 'object' && !Array.isArray(val);
+    }
+    /**
+     * Делает переданный объект (если он объект) реактивным
+     * Причем делает свойства объекта тоже реактивными рекурсивно
+    */
+    makeReactive(obj) {
+        if (obj.__isReactive)
+            return obj;
+        const handler = {
+            set: (target, key, value) => {
+                const oldValue = target[key];
+                const isOwn = Object.prototype.hasOwnProperty.call(target, key);
+                // Рекурсивно реактивизируем только обычные объекты (не массивы!)
+                const nextValue = this.isPlainObject(value) ? this.makeReactive(value) : value;
+                target[key] = nextValue;
+                // Уведомляем только при изменении значения
+                if (!isOwn || oldValue !== nextValue)
+                    this.watcher();
+                return true;
+            },
+        };
+        const proxy = new Proxy(obj, handler);
+        proxy.__isReactive = true;
+        return proxy;
+    }
+}
+exports.default = ReactiveRef;

package/lib/UniversalWorkers.d.ts

@@ -0,0 +1,59 @@
+type UniversalWorkerOptions = {
+    isolated?: boolean;
+    scriptPath: string;
+    workerData?: any;
+};
+export default class UniversalWorker {
+    private impl;
+    /**
+     * Создает новые воркер
+     *
+     * Если параметр isolated = true будет создан форк
+     * иначе будет использоваться WorkerThread
+    */
+    constructor(options: UniversalWorkerOptions);
+    /**
+     * Отправляет внутрь воркера обхект способный к сериализации
+    */
+    send(msg: any): void;
+    /**
+     * Подписывает на события воркера
+     *
+     * Доступно только message exit error
+    */
+    on(event: 'message' | 'exit' | 'error', handler: (...args: any[]) => void): void;
+    /**
+     * Убивает процесс
+    */
+    kill(): void;
+    /**
+     * @see kill
+    */
+    terminate(): void;
+}
+export type WorkerMessageHandler = (message: any) => void;
+/**
+ * Определяет - является ли процесс форкнутым
+ * Основанно на проверке метода process.send которая есть только у фокрнутого процесса
+*/
+export declare const isForked: boolean;
+/**
+ * Определяет - является ли данный инстанс дочерним - не важно используя worker_threads или fork
+ * Проверяет !isMainThread || isForked
+*/
+export declare const isChild: boolean;
+/**
+ * Получение данных сверху, которые были переданны при создании воркера
+ * В случае использования worker_threads - workerData
+ * Если же это форк - парсит устаноленнюу переменную окружения VRACK2_WORKER_DATA
+*/
+export declare function getWorkerData(): any;
+/**
+ * Отправка данных наверх в родительский процесс
+*/
+export declare function sendMessage(message: any): void;
+/**
+ * Позволяет подписаться на данные которые приходят сверху
+*/
+export declare function onMessage(handler: WorkerMessageHandler): void;
+export {};

package/lib/UniversalWorkers.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onMessage = exports.sendMessage = exports.getWorkerData = exports.isChild = exports.isForked = void 0;
+// UniversalWorker.ts
+const child_process_1 = require("child_process");
+const worker_threads_1 = require("worker_threads");
+class UniversalWorker {
+    /**
+     * Создает новые воркер
+     *
+     * Если параметр isolated = true будет создан форк
+     * иначе будет использоваться WorkerThread
+    */
+    constructor(options) {
+        const { isolated = true, scriptPath, workerData } = options;
+        if (isolated) {
+            // child_process
+            const proc = (0, child_process_1.fork)(scriptPath, [], {
+                env: { ...process.env, VRACK2_WORKER_DATA: JSON.stringify(workerData) }
+            });
+            this.impl = {
+                send: (msg) => proc.send(msg),
+                on: (ev, handler) => proc.on(ev, handler),
+                kill: () => proc.kill()
+            };
+        }
+        else {
+            // worker_threads
+            const wt = new worker_threads_1.Worker(scriptPath, { workerData });
+            this.impl = {
+                send: (msg) => wt.postMessage(msg),
+                on: (ev, handler) => {
+                    if (ev === 'message')
+                        wt.on('message', handler);
+                    else if (ev === 'error')
+                        wt.on('error', handler);
+                    else if (ev === 'exit')
+                        wt.on('exit', handler);
+                },
+                kill: () => wt.terminate()
+            };
+        }
+    }
+    /**
+     * Отправляет внутрь воркера обхект способный к сериализации
+    */
+    send(msg) {
+        this.impl.send(msg);
+    }
+    /**
+     * Подписывает на события воркера
+     *
+     * Доступно только message exit error
+    */
+    on(event, handler) {
+        this.impl.on(event, handler);
+    }
+    /**
+     * Убивает процесс
+    */
+    kill() {
+        this.impl.kill();
+    }
+    /**
+     * @see kill
+    */
+    terminate() {
+        this.impl.kill();
+    }
+}
+exports.default = UniversalWorker;
+/**
+ * Определяет - является ли процесс форкнутым
+ * Основанно на проверке метода process.send которая есть только у фокрнутого процесса
+*/
+exports.isForked = typeof process.send === 'function';
+/**
+ * Определяет - является ли данный инстанс дочерним - не важно используя worker_threads или fork
+ * Проверяет !isMainThread || isForked
+*/
+exports.isChild = !worker_threads_1.isMainThread || exports.isForked;
+/**
+ * Получение данных сверху, которые были переданны при создании воркера
+ * В случае использования worker_threads - workerData
+ * Если же это форк - парсит устаноленнюу переменную окружения VRACK2_WORKER_DATA
+*/
+function getWorkerData() {
+    if (!worker_threads_1.isMainThread)
+        return worker_threads_1.workerData;
+    if (exports.isForked)
+        return JSON.parse(process.env.VRACK2_WORKER_DATA || '{}');
+    throw new Error('getWorkerData() called in main process');
+}
+exports.getWorkerData = getWorkerData;
+/**
+ * Отправка данных наверх в родительский процесс
+*/
+function sendMessage(message) {
+    if (!worker_threads_1.isMainThread)
+        return worker_threads_1.parentPort?.postMessage(message);
+    if (exports.isForked) {
+        process.send?.(message);
+        return;
+    }
+    throw new Error('sendMessage() called in main process');
+}
+exports.sendMessage = sendMessage;
+/**
+ * Позволяет подписаться на данные которые приходят сверху
+*/
+function onMessage(handler) {
+    if (!worker_threads_1.isMainThread)
+        worker_threads_1.parentPort?.on('message', handler);
+    else if (exports.isForked)
+        process.on('message', handler);
+    else
+        throw new Error('onMessage() called in main process');
+}
+exports.onMessage = onMessage;

package/lib/Utility.js

@@ -3,15 +3,6 @@
  * Copyright © 2025 Boris Bobylev. All rights reserved.
  * Licensed under the Apache License, Version 2.0
 */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -21,10 +12,8 @@ class Utility {
     /**
      * Check device name (device ID)
      * */
-    static isDeviceName(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return /^[a-zA-Z0-9_*-:]+$/.test(name);
-        });
+    static async isDeviceName(name) {
+        return /^[a-zA-Z0-9_*-:]+$/.test(name);
     }
     /**
      * Форматирует любое значение в красивую строку (с отступами, подсветкой и т. д.).
@@ -35,8 +24,15 @@ class Utility {
      * @returns {string} Отформатированная строка
      */
     static prettyFormat(value, options = {}) {
-        const defaultOptions = Object.assign({ depth: null, colors: true, compact: false, breakLength: 80, sorted: false, showHidden: false }, options // Переопределение дефолтных опций
-        );
+        const defaultOptions = {
+            depth: null,
+            colors: true,
+            compact: false,
+            breakLength: 80,
+            sorted: false,
+            showHidden: false,
+            ...options // Переопределение дефолтных опций
+        };
         // Особые случаи (если нужно обработать их по-особому)
         if (value instanceof Error) {
             return value.stack; // Стек ошибки

package/lib/boot/BootClass.js

@@ -3,15 +3,6 @@
  * Copyright © 2024 Boris Bobylev. All rights reserved.
  * Licensed under the Apache License, Version 2.0
 */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -88,9 +79,7 @@ class BootClass {
      * the bootstrap loader will wait for the execution of all
      * the  `processPromise` methods of all bootstrap classes.
     */
-    processPromise() {
-        return __awaiter(this, void 0, void 0, function* () { return; });
-    }
+    async processPromise() { return; }
     /**
      * Method for calling container system errors
      */

package/lib/boot/DeviceFileStorage.js

@@ -3,15 +3,6 @@
  * Copyright © 2024 Boris Bobylev. All rights reserved.
  * Licensed under the Apache License, Version 2.0
 */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -65,17 +56,15 @@ class DeviceFileStorage extends BootClass_1.default {
      * @param deviceId Device ID
      * @returns {any} Imported JSON
     */
-    loadDeviceStorage(deviceId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fp = this.makeDeviceStoragePath(deviceId);
-            const fptmp = this.makeDeviceStoragePath(deviceId, '-tmp');
-            if (!fs_1.default.existsSync(fp)) {
-                if (!fs_1.default.existsSync(fptmp))
-                    return {};
-                fs_1.default.renameSync(fptmp, fp);
-            }
-            return ImportManager_1.default.importJSON(fp);
-        });
+    async loadDeviceStorage(deviceId) {
+        const fp = this.makeDeviceStoragePath(deviceId);
+        const fptmp = this.makeDeviceStoragePath(deviceId, '-tmp');
+        if (!fs_1.default.existsSync(fp)) {
+            if (!fs_1.default.existsSync(fptmp))
+                return {};
+            fs_1.default.renameSync(fptmp, fp);
+        }
+        return ImportManager_1.default.importJSON(fp);
     }
     /**
      * Save data device to storage
@@ -85,19 +74,17 @@ class DeviceFileStorage extends BootClass_1.default {
      * @param deviceId Device ID
      * @param trace Data object for storage
     */
-    saveDeviceStorage(deviceId, trace) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fp = this.makeDeviceStoragePath(deviceId);
-            const dp = path_1.default.join(this.options.storageDir, this.Container.id);
-            const fptmp = this.makeDeviceStoragePath(deviceId, '-tmp');
-            if (!fs_1.default.existsSync(dp)) {
-                fs_1.default.mkdirSync(dp, { recursive: true });
-            }
-            fs_1.default.writeFileSync(fptmp, JSON.stringify(trace));
-            if (fs_1.default.existsSync(fp))
-                fs_1.default.rmSync(fp);
-            fs_1.default.renameSync(fptmp, fp);
-        });
+    async saveDeviceStorage(deviceId, trace) {
+        const fp = this.makeDeviceStoragePath(deviceId);
+        const dp = path_1.default.join(this.options.storageDir, this.Container.id);
+        const fptmp = this.makeDeviceStoragePath(deviceId, '-tmp');
+        if (!fs_1.default.existsSync(dp)) {
+            fs_1.default.mkdirSync(dp, { recursive: true });
+        }
+        fs_1.default.writeFileSync(fptmp, JSON.stringify(trace));
+        if (fs_1.default.existsSync(fp))
+            fs_1.default.rmSync(fp);
+        fs_1.default.renameSync(fptmp, fp);
     }
     /**
      * Forms the path to the storage file