@tramvai/core 5.49.1 → 5.53.74

package/lib/createApp.es.js

@@ -34,6 +34,8 @@ function appProviders(name, bundles, actions, modules) {
     ];
 }
 class App {
+    di;
+    modulesToResolve;
     constructor({ name, modules = [], bundles = {}, actions = [], providers }) {
         this.di = createContainer();
         this.modulesToResolve = new Set();

package/lib/createApp.js

@@ -38,6 +38,8 @@ function appProviders(name, bundles, actions, modules) {
     ];
 }
 class App {
+    di;
+    modulesToResolve;
     constructor({ name, modules = [], bundles = {}, actions = [], providers }) {
         this.di = dippy.createContainer();
         this.modulesToResolve = new Set();

package/lib/index.d.ts

@@ -5,4 +5,5 @@ export * from './actions/declareAction';
 export * from '@tramvai/tokens-core';
 export { DI_TOKEN, IS_DI_CHILD_CONTAINER_TOKEN, Scope, Provider, createToken, provide, optional, ExtractTokenType, ExtractDependencyType, Module, MODULE_PARAMETERS, getModuleParameters, walkOfModules, isExtendedModule, ModuleType, ExtendedModule, declareModule, } from '@tinkoff/dippy';
 export { Deferred } from './utils/deferred.inline';
+export { DoubleLinkedList } from './utils/doubleLinkedList';
 //# sourceMappingURL=index.d.ts.map

package/lib/index.es.js

@@ -5,3 +5,4 @@ export { declareAction, isTramvaiAction } from './actions/declareAction.es.js';
 export * from '@tramvai/tokens-core';
 export { DI_TOKEN, IS_DI_CHILD_CONTAINER_TOKEN, MODULE_PARAMETERS, Module, Scope, createToken, declareModule, getModuleParameters, isExtendedModule, optional, provide, walkOfModules } from '@tinkoff/dippy';
 export { Deferred } from './utils/deferred.inline.es.js';
+export { DoubleLinkedList } from './utils/doubleLinkedList.es.js';

package/lib/index.js

@@ -9,6 +9,7 @@ var declareAction = require('./actions/declareAction.js');
 var tokensCore = require('@tramvai/tokens-core');
 var dippy = require('@tinkoff/dippy');
 var deferred_inline = require('./utils/deferred.inline.js');
+var doubleLinkedList = require('./utils/doubleLinkedList.js');
 
 
 
@@ -67,6 +68,7 @@ Object.defineProperty(exports, 'walkOfModules', {
 	get: function () { return dippy.walkOfModules; }
 });
 exports.Deferred = deferred_inline.Deferred;
+exports.DoubleLinkedList = doubleLinkedList.DoubleLinkedList;
 Object.keys(tokensCore).forEach(function (k) {
 	if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
 		enumerable: true,

package/lib/utils/deferred.inline.es.js

@@ -1,38 +1,41 @@
 class Deferred {
-    constructor() {
+    promise;
+    status = 'pending';
+    resolve = () => { };
+    reject = () => { };
+    resolveData;
+    rejectReason;
+    isResolved = () => {
+        return typeof this.resolveData !== 'undefined';
+    };
+    isRejected = () => {
+        return typeof this.rejectReason !== 'undefined';
+    };
+    reset = () => {
         this.status = 'pending';
-        this.resolve = () => { };
-        this.reject = () => { };
-        this.isResolved = () => {
-            return typeof this.resolveData !== 'undefined';
-        };
-        this.isRejected = () => {
-            return typeof this.rejectReason !== 'undefined';
-        };
-        this.reset = () => {
-            this.status = 'pending';
-            this.resolveData = undefined;
-            this.rejectReason = undefined;
-            this.promise = this.initPromise();
-        };
-        this.initPromise = () => {
-            return new Promise((resolve, reject) => {
-                this.resolve = (value) => {
-                    if (this.status === 'pending') {
-                        this.resolveData = value;
-                        this.status = 'resolved';
-                        resolve(value);
-                    }
-                };
-                this.reject = (reason) => {
-                    if (this.status === 'pending') {
-                        this.rejectReason = reason;
-                        this.status = 'rejected';
-                        reject(reason);
-                    }
-                };
-            });
-        };
+        this.resolveData = undefined;
+        this.rejectReason = undefined;
+        this.promise = this.initPromise();
+    };
+    initPromise = () => {
+        return new Promise((resolve, reject) => {
+            this.resolve = (value) => {
+                if (this.status === 'pending') {
+                    this.resolveData = value;
+                    this.status = 'resolved';
+                    resolve(value);
+                }
+            };
+            this.reject = (reason) => {
+                if (this.status === 'pending') {
+                    this.rejectReason = reason;
+                    this.status = 'rejected';
+                    reject(reason);
+                }
+            };
+        });
+    };
+    constructor() {
         this.promise = this.initPromise();
     }
 }

package/lib/utils/deferred.inline.js

@@ -3,40 +3,43 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 class Deferred {
-    constructor() {
+    promise;
+    status = 'pending';
+    resolve = () => { };
+    reject = () => { };
+    resolveData;
+    rejectReason;
+    isResolved = () => {
+        return typeof this.resolveData !== 'undefined';
+    };
+    isRejected = () => {
+        return typeof this.rejectReason !== 'undefined';
+    };
+    reset = () => {
         this.status = 'pending';
-        this.resolve = () => { };
-        this.reject = () => { };
-        this.isResolved = () => {
-            return typeof this.resolveData !== 'undefined';
-        };
-        this.isRejected = () => {
-            return typeof this.rejectReason !== 'undefined';
-        };
-        this.reset = () => {
-            this.status = 'pending';
-            this.resolveData = undefined;
-            this.rejectReason = undefined;
-            this.promise = this.initPromise();
-        };
-        this.initPromise = () => {
-            return new Promise((resolve, reject) => {
-                this.resolve = (value) => {
-                    if (this.status === 'pending') {
-                        this.resolveData = value;
-                        this.status = 'resolved';
-                        resolve(value);
-                    }
-                };
-                this.reject = (reason) => {
-                    if (this.status === 'pending') {
-                        this.rejectReason = reason;
-                        this.status = 'rejected';
-                        reject(reason);
-                    }
-                };
-            });
-        };
+        this.resolveData = undefined;
+        this.rejectReason = undefined;
+        this.promise = this.initPromise();
+    };
+    initPromise = () => {
+        return new Promise((resolve, reject) => {
+            this.resolve = (value) => {
+                if (this.status === 'pending') {
+                    this.resolveData = value;
+                    this.status = 'resolved';
+                    resolve(value);
+                }
+            };
+            this.reject = (reason) => {
+                if (this.status === 'pending') {
+                    this.rejectReason = reason;
+                    this.status = 'rejected';
+                    reject(reason);
+                }
+            };
+        });
+    };
+    constructor() {
         this.promise = this.initPromise();
     }
 }

package/lib/utils/doubleLinkedList.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Represents a node in the doubly linked list
+ * @interface
+ * @template Value
+ */
+interface ListNode<Value> {
+    /** Reference to next node */
+    next: ListNode<Value> | null;
+    /** Reference to previous node */
+    prev: ListNode<Value> | null;
+    /** The node's value */
+    value: Value;
+}
+/**
+ * Represents a doubly linked list data structure.
+ * @template Value The type of elements held in the list
+ */
+export declare class DoubleLinkedList<Value> {
+    /**
+     * The number of elements in the list
+     * @type {number}
+     */
+    length: number;
+    /**
+     * Reference to the first node in the list
+     * @type {ListNode<Value> | null}
+     */
+    start: null | ListNode<Value>;
+    /**
+     * Reference to the last node in the list
+     * @type {ListNode<Value> | null}
+     */
+    end: null | ListNode<Value>;
+    /**
+     * Creates a new DoubleLinkedList instance
+     * @constructor
+     * @param {Value[]} [initArray] Optional array of initial values
+     * @example
+     * const list = new DoubleLinkedList([1, 2, 3]);
+     */
+    constructor(initArray?: Value[]);
+    /**
+     * Adds a value to the end of the list
+     * @param {Value} value The value to add
+     * @example
+     * list.push(42);
+     */
+    push(value: Value): void;
+    /**
+     * Removes and returns the last value from the list
+     * @returns {Value | null} The removed value or null if list is empty
+     * @example
+     * const last = list.pop();
+     */
+    pop(): Value | null;
+    /**
+     * Removes and returns the first value from the list
+     * @returns {Value | null} The removed value or null if list is empty
+     * @example
+     * const first = list.shift();
+     */
+    shift(): Value | null;
+    /**
+     * Returns the current number of elements in the list
+     * @returns {number} The list size
+     * @example
+     * const size = list.size();
+     */
+    size(): number;
+    /**
+     * Converts the list to an array of values
+     * @returns {Value[]} Array containing list values
+     * @example
+     * const arr = list.toArray();
+     */
+    toArray(): Value[];
+    /**
+     * Returns a JSON string representation of the list
+     * @returns {string} JSON string of values
+     * @example
+     * const str = list.toString(); // "[1,2,3]"
+     */
+    toString(): string;
+    /**
+     * Iterates through the list values
+     * @yields {Value} The next value in the list
+     * @example
+     * for (const value of list) {
+     *   console.log(value);
+     * }
+     */
+    [Symbol.iterator](): Generator<Value, void, unknown>;
+}
+export {};
+//# sourceMappingURL=doubleLinkedList.d.ts.map

package/lib/utils/doubleLinkedList.es.js

@@ -0,0 +1,163 @@
+/**
+ * Represents a doubly linked list data structure.
+ * @template Value The type of elements held in the list
+ */
+class DoubleLinkedList {
+    /**
+     * The number of elements in the list
+     * @type {number}
+     */
+    length;
+    /**
+     * Reference to the first node in the list
+     * @type {ListNode<Value> | null}
+     */
+    start;
+    /**
+     * Reference to the last node in the list
+     * @type {ListNode<Value> | null}
+     */
+    end;
+    /**
+     * Creates a new DoubleLinkedList instance
+     * @constructor
+     * @param {Value[]} [initArray] Optional array of initial values
+     * @example
+     * const list = new DoubleLinkedList([1, 2, 3]);
+     */
+    constructor(initArray) {
+        this.length = 0;
+        this.start = null;
+        this.end = null;
+        if (initArray) {
+            for (const item of initArray) {
+                this.push(item);
+            }
+        }
+    }
+    /**
+     * Adds a value to the end of the list
+     * @param {Value} value The value to add
+     * @example
+     * list.push(42);
+     */
+    push(value) {
+        const newNode = {
+            value,
+            next: null,
+            prev: null,
+        };
+        this.length++;
+        if (this.start === null) {
+            this.start = newNode;
+            this.end = newNode;
+            return;
+        }
+        const currentEnd = this.end;
+        this.end = newNode;
+        this.end.prev = currentEnd;
+        if (currentEnd !== null) {
+            currentEnd.next = this.end;
+        }
+    }
+    /**
+     * Removes and returns the last value from the list
+     * @returns {Value | null} The removed value or null if list is empty
+     * @example
+     * const last = list.pop();
+     */
+    pop() {
+        if (this.end === null) {
+            return null;
+        }
+        this.length--;
+        // if equal we have only 1 node, so we just remove start
+        if (this.end === this.start) {
+            this.start = null;
+        }
+        const { value } = this.end;
+        this.end = this.end.prev;
+        if (this.end) {
+            this.end.next = null;
+        }
+        return value;
+    }
+    /**
+     * Removes and returns the first value from the list
+     * @returns {Value | null} The removed value or null if list is empty
+     * @example
+     * const first = list.shift();
+     */
+    shift() {
+        if (this.start === null) {
+            return null;
+        }
+        this.length--;
+        // if equal we have only 1 node, so we just remove end
+        if (this.end === this.start) {
+            this.end = null;
+        }
+        const { value } = this.start;
+        this.start = this.start.next;
+        if (this.start) {
+            this.start.prev = null;
+        }
+        return value;
+    }
+    /**
+     * Returns the current number of elements in the list
+     * @returns {number} The list size
+     * @example
+     * const size = list.size();
+     */
+    size() {
+        return this.length;
+    }
+    /**
+     * Converts the list to an array of values
+     * @returns {Value[]} Array containing list values
+     * @example
+     * const arr = list.toArray();
+     */
+    toArray() {
+        const result = [];
+        let current = this.start;
+        while (current) {
+            result.push(current.value);
+            current = current.next;
+        }
+        return result;
+    }
+    /**
+     * Returns a JSON string representation of the list
+     * @returns {string} JSON string of values
+     * @example
+     * const str = list.toString(); // "[1,2,3]"
+     */
+    toString() {
+        const result = [this.start?.value];
+        let currentNode = this.start;
+        while (currentNode?.next) {
+            result.push(currentNode.next.value);
+            currentNode = currentNode.next;
+        }
+        return JSON.stringify(result);
+    }
+    /**
+     * Iterates through the list values
+     * @yields {Value} The next value in the list
+     * @example
+     * for (const value of list) {
+     *   console.log(value);
+     * }
+     */
+    *[Symbol.iterator]() {
+        let current = this.start;
+        while (current) {
+            yield current.value;
+            current = current.next;
+        }
+    }
+}
+
+export { DoubleLinkedList };

package/lib/utils/doubleLinkedList.js

@@ -0,0 +1,167 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Represents a doubly linked list data structure.
+ * @template Value The type of elements held in the list
+ */
+class DoubleLinkedList {
+    /**
+     * The number of elements in the list
+     * @type {number}
+     */
+    length;
+    /**
+     * Reference to the first node in the list
+     * @type {ListNode<Value> | null}
+     */
+    start;
+    /**
+     * Reference to the last node in the list
+     * @type {ListNode<Value> | null}
+     */
+    end;
+    /**
+     * Creates a new DoubleLinkedList instance
+     * @constructor
+     * @param {Value[]} [initArray] Optional array of initial values
+     * @example
+     * const list = new DoubleLinkedList([1, 2, 3]);
+     */
+    constructor(initArray) {
+        this.length = 0;
+        this.start = null;
+        this.end = null;
+        if (initArray) {
+            for (const item of initArray) {
+                this.push(item);
+            }
+        }
+    }
+    /**
+     * Adds a value to the end of the list
+     * @param {Value} value The value to add
+     * @example
+     * list.push(42);
+     */
+    push(value) {
+        const newNode = {
+            value,
+            next: null,
+            prev: null,
+        };
+        this.length++;
+        if (this.start === null) {
+            this.start = newNode;
+            this.end = newNode;
+            return;
+        }
+        const currentEnd = this.end;
+        this.end = newNode;
+        this.end.prev = currentEnd;
+        if (currentEnd !== null) {
+            currentEnd.next = this.end;
+        }
+    }
+    /**
+     * Removes and returns the last value from the list
+     * @returns {Value | null} The removed value or null if list is empty
+     * @example
+     * const last = list.pop();
+     */
+    pop() {
+        if (this.end === null) {
+            return null;
+        }
+        this.length--;
+        // if equal we have only 1 node, so we just remove start
+        if (this.end === this.start) {
+            this.start = null;
+        }
+        const { value } = this.end;
+        this.end = this.end.prev;
+        if (this.end) {
+            this.end.next = null;
+        }
+        return value;
+    }
+    /**
+     * Removes and returns the first value from the list
+     * @returns {Value | null} The removed value or null if list is empty
+     * @example
+     * const first = list.shift();
+     */
+    shift() {
+        if (this.start === null) {
+            return null;
+        }
+        this.length--;
+        // if equal we have only 1 node, so we just remove end
+        if (this.end === this.start) {
+            this.end = null;
+        }
+        const { value } = this.start;
+        this.start = this.start.next;
+        if (this.start) {
+            this.start.prev = null;
+        }
+        return value;
+    }
+    /**
+     * Returns the current number of elements in the list
+     * @returns {number} The list size
+     * @example
+     * const size = list.size();
+     */
+    size() {
+        return this.length;
+    }
+    /**
+     * Converts the list to an array of values
+     * @returns {Value[]} Array containing list values
+     * @example
+     * const arr = list.toArray();
+     */
+    toArray() {
+        const result = [];
+        let current = this.start;
+        while (current) {
+            result.push(current.value);
+            current = current.next;
+        }
+        return result;
+    }
+    /**
+     * Returns a JSON string representation of the list
+     * @returns {string} JSON string of values
+     * @example
+     * const str = list.toString(); // "[1,2,3]"
+     */
+    toString() {
+        const result = [this.start?.value];
+        let currentNode = this.start;
+        while (currentNode?.next) {
+            result.push(currentNode.next.value);
+            currentNode = currentNode.next;
+        }
+        return JSON.stringify(result);
+    }
+    /**
+     * Iterates through the list values
+     * @yields {Value} The next value in the list
+     * @example
+     * for (const value of list) {
+     *   console.log(value);
+     * }
+     */
+    *[Symbol.iterator]() {
+        let current = this.start;
+        while (current) {
+            yield current.value;
+            current = current.next;
+        }
+    }
+}
+
+exports.DoubleLinkedList = DoubleLinkedList;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/core",
-  "version": "5.49.1",
+  "version": "5.53.74",
   "description": "",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -18,11 +18,11 @@
     "watch": "tsc -w"
   },
   "dependencies": {
+    "@tinkoff/dippy": "0.11.5",
     "@tinkoff/utils": "^2.1.2",
-    "@tramvai/tokens-common": "5.49.1",
-    "@tramvai/tokens-core": "5.49.1",
-    "@tramvai/types-actions-state-context": "5.49.1",
-    "@tinkoff/dippy": "0.11.4",
+    "@tramvai/tokens-common": "5.53.74",
+    "@tramvai/tokens-core": "5.53.74",
+    "@tramvai/types-actions-state-context": "5.53.74",
     "tslib": "^2.4.0"
   },
   "peerDependencies": {