@creejs/commons-collection 2.0.3 → 2.0.5

package/types/fixed-linked-list.d.ts

@@ -0,0 +1,59 @@
+/**
+ * A fixed-capacity linked list that automatically removes elements when capacity is exceeded.
+ * When adding to the end (addLast), it removes the first element if capacity is full.
+ * When adding to the beginning (addFirst), it removes the last element if capacity is full.
+ *
+ * @class FixedLinkedList
+ * @extends LinkedList
+ */
+export default class FixedLinkedList extends LinkedList {
+    /**
+     * Creates a new FixedLinkedList instance with a fixed capacity.
+     * @constructor
+     * @param {number} capacity - The maximum number of elements the list can hold (must be > 0)
+     * @throws {Error} If capacity is less than or equal to 0
+     */
+    constructor(capacity: number);
+    capacity: number;
+    /**
+     * Adds a value to the beginning of the linked list.
+     * If the list is at capacity, removes the last element before adding.
+     * @param {*} value - The value to add
+     * @returns {FixedLinkedList} This linked list instance for chaining
+     */
+    addFirst(value: any): FixedLinkedList;
+    /**
+     * Adds a value to the end of the linked list.
+     * If the list is at capacity, removes the first element before adding.
+     * @param {*} value - The value to add
+     * @returns {FixedLinkedList} This linked list instance for chaining
+     */
+    addLast(value: any): FixedLinkedList;
+    /**
+     * Adds a value to the end of the linked list.
+     * If the list is at capacity, removes the first element before adding.
+     * @param {*} value - The value to add
+     * @returns {FixedLinkedList} This linked list instance for chaining
+     */
+    add(value: any): FixedLinkedList;
+    /**
+     * Inserts a value at the specified index.
+     * If the list is at capacity and index is not at the end, removes the first element before adding.
+     * If the list is at capacity and index is at the end, removes the first element before adding.
+     * @param {number} index - The index at which to insert the value
+     * @param {*} value - The value to insert
+     * @returns {FixedLinkedList} This linked list instance for chaining
+     */
+    insertAt(index: number, value: any): FixedLinkedList;
+    /**
+     * Returns the remaining capacity of the list.
+     * @returns {number} The number of additional elements that can be added
+     */
+    get remainingCapacity(): number;
+    /**
+     * Checks if the list is at full capacity.
+     * @returns {boolean} True if the list is full, false otherwise
+     */
+    get isFull(): boolean;
+}
+import LinkedList from './linked-list.js';

package/types/hour24-time-wheel-cache.d.ts

@@ -12,6 +12,11 @@ export default class Hour24TimeWheelCache extends EventEmitter {
         Downgrade: string;
         Expired: string;
     };
+    /**
+     *
+     */
+    constructor(autoStart?: boolean);
+    _autoStart: boolean;
     /**
      * Second Wheel:
      * 1. 1 Tick Mark is 1 Second, is 1000 Milliseconds
@@ -53,6 +58,7 @@ export default class Hour24TimeWheelCache extends EventEmitter {
      */
     get maxTtl(): number;
     get autoEvictRunning(): boolean;
+    get autoStart(): boolean;
     _init(): void;
     start(): void;
     stop(): void;

package/types/index.d.ts

@@ -2,9 +2,13 @@ declare namespace _default {
     export { CappedSet };
     export { TimeWheelCache };
     export { Hour24TimeWheelCache };
+    export { LinkedList };
+    export { FixedLinkedList };
 }
 export default _default;
 import CappedSet from './capped-set.js';
 import TimeWheelCache from './time-wheel-cache.js';
 import Hour24TimeWheelCache from './hour24-time-wheel-cache.js';
-export { CappedSet, TimeWheelCache, Hour24TimeWheelCache };
+import LinkedList from './linked-list.js';
+import FixedLinkedList from './fixed-linked-list.js';
+export { CappedSet, TimeWheelCache, Hour24TimeWheelCache, LinkedList, FixedLinkedList };

package/types/linked-list.d.ts

@@ -0,0 +1,178 @@
+/**
+ * A doubly linked list implementation.
+ *
+ * @class LinkedList
+ */
+export default class LinkedList {
+    /**
+     * @type {Node|undefined}
+     */
+    _head: Node | undefined;
+    /**
+     * @type {Node|undefined}
+     */
+    _tail: Node | undefined;
+    /**
+     * @type {number}
+     */
+    _size: number;
+    get size(): number;
+    /**
+     * get the first element
+     */
+    get first(): any;
+    /**
+     * get the last element
+     */
+    get last(): any;
+    /**
+     * Adds a value to the beginning of the linked list.
+     * @param {*} value - The value to add
+     * @returns {LinkedList} This linked list instance for chaining
+     */
+    addFirst(value: any): LinkedList;
+    /**
+     * Adds a value to the end of the linked list.
+     * @param {*} value - The value to add
+     * @returns {LinkedList} This linked list instance for chaining
+     */
+    addLast(value: any): LinkedList;
+    /**
+     * Adds a value to the end of the linked list.
+     * @param {*} value - The value to add
+     * @returns {LinkedList} This linked list instance for chaining
+     */
+    add(value: any): LinkedList;
+    /**
+     * Removes and returns the first element from the linked list.
+     * @returns {*} The removed value, or undefined if the list is empty
+     */
+    removeFirst(): any;
+    /**
+     * Removes and returns the last element from the linked list.
+     * @returns {*} The removed value, or undefined if the list is empty
+     */
+    removeLast(): any;
+    /**
+     * Removes the first occurrence of the specified value from the linked list.
+     * @param {*} value - The value to remove
+     * @param {function(*, *): boolean} [comparator] - Optional comparison function (a, b) => boolean
+     * @returns {boolean} True if the value was found and removed, false otherwise
+     */
+    remove(value: any, comparator?: (arg0: any, arg1: any) => boolean): boolean;
+    /**
+     * Removes all occurrences of the specified value from the linked list.
+     * @param {*} value - The value to remove
+     * @param {function(*, *): boolean} [comparator] - Optional comparison function (a, b) => boolean
+     * @returns {number} The number of elements removed
+     */
+    removeAll(value: any, comparator?: (arg0: any, arg1: any) => boolean): number;
+    /**
+     * Removes the element at the specified index.
+     * @param {number} index - The index of the element to remove
+     * @returns {*} The removed value, or undefined if index is out of bounds
+     */
+    removeAt(index: number): any;
+    /**
+     * Checks if the linked list contains the specified value.
+     * @param {*} value - The value to check for
+     * @param {function(*, *): boolean} [comparator] - Optional comparison function (a, b) => boolean
+     * @returns {boolean} True if the value exists, false otherwise
+     */
+    contains(value: any, comparator?: (arg0: any, arg1: any) => boolean): boolean;
+    /**
+     * Returns the index of the first occurrence of the specified value.
+     * @param {*} value - The value to find
+     * @param {function(*, *): boolean} [comparator] - Optional comparison function (a, b) => boolean
+     * @returns {number} The index of the value, or -1 if not found
+     */
+    indexOf(value: any, comparator?: (arg0: any, arg1: any) => boolean): number;
+    /**
+     * Returns the index of the last occurrence of the specified value.
+     * @param {*} value - The value to find
+     * @param {function(*, *): boolean} [comparator] - Optional comparison function (a, b) => boolean
+     * @returns {number} The index of the last occurrence, or -1 if not found
+     */
+    indexLastOf(value: any, comparator?: (arg0: any, arg1: any) => boolean): number;
+    /**
+     * Gets the value at the specified index.
+     * @param {number} index - The index of the value to get
+     * @returns {*} The value at the index, or undefined if index is out of bounds
+     */
+    get(index: number): any;
+    /**
+     * Inserts a value at the specified index.
+     * @param {number} index - The index at which to insert the value
+     * @param {*} value - The value to insert
+     * @returns {LinkedList} This linked list instance for chaining
+     */
+    insertAt(index: number, value: any): LinkedList;
+    /**
+     * Removes all elements from the linked list.
+     */
+    clear(): void;
+    /**
+     * Returns an array containing all the values in the linked list.
+     * @returns {any[]} An array of all values
+     */
+    toArray(): any[];
+    /**
+     * Returns an iterator of the values in the linked list.
+     * @returns {Iterator<any>} An iterator object that yields the values of the linked list
+     */
+    values(): Iterator<any>;
+    /**
+     * Returns a slice of the linked list as an array.
+     * @param {number} [start=0] - The start index (inclusive). If negative, counts from the end.
+     * @param {number} [end=this.size] - The end index (exclusive). If negative, counts from the end.
+     * @returns {any[]} An array containing the sliced elements
+     */
+    slice(start?: number, end?: number): any[];
+    /**
+     * Returns a string representation of the FixedLinkedList.
+     * @returns {string} String representation
+     */
+    toString(): string;
+    /**
+     * Slice implementation for positive indices (iterates from head to tail)
+     * @param {number} start - Normalized start index (inclusive)
+     * @param {number} end - Normalized end index (exclusive)
+     * @returns {any[]} An array containing the sliced elements
+     * @private
+     */
+    private _slicePositive;
+    /**
+     * Slice implementation for negative indices (iterates from tail to head)
+     * @param {number} start - Normalized start index (inclusive)
+     * @param {number} end - Normalized end index (exclusive)
+     * @returns {any[]} An array containing the sliced elements
+     * @private
+     */
+    private _sliceNegative;
+    /**
+     * Removes a node from the linked list.
+     * @param {Node} node - The node to be removed
+     * @private
+     */
+    private _removeNode;
+    /**
+     * Default comparator for strict equality comparison.
+     * @param {*} a - First value to compare
+     * @param {*} b - Second value to compare
+     * @returns {boolean} True if values are strictly equal
+     * @private
+     */
+    private _defaultComparator;
+    [Symbol.iterator](): {
+        next(): {
+            value: any;
+            done: boolean;
+        };
+        [Symbol.iterator](): /*elided*/ any;
+    };
+}
+export type Node = {
+    value: any;
+    prev: Node | undefined;
+    next: Node | undefined;
+};

package/types/time-wheel-cache.d.ts

@@ -15,7 +15,7 @@ export default class TimeWheelCache extends EventEmitter {
         Advance: string;
         Expired: string;
     };
-    options: {};
+    options: TimeWheelCacheOptions;
     /**
      * How many milliseconds does one Tick represent
      */
@@ -24,6 +24,11 @@ export default class TimeWheelCache extends EventEmitter {
      * How many Ticks does the Wheel have
      */
     _tickCount: number;
+    /**
+     * Whether auto start "AutoEvict"
+     * @type {boolean}
+     */
+    _autoStart: boolean;
     /**
      * Slots, one Tick owns one Slot to store key and expire timestamp
      * @type {Map<any, {value: any, slotIndex: number, expireTimestamp: number}>[]}
@@ -55,6 +60,7 @@ export default class TimeWheelCache extends EventEmitter {
     _maxTtl: number | undefined;
     assertStarted(): void;
     get autoEvictRunning(): boolean;
+    get autoStart(): boolean;
     _startAutoEvict(): void;
     _stopAutoEvict(): void;
     _advance(): void;
@@ -101,7 +107,8 @@ export default class TimeWheelCache extends EventEmitter {
 }
 export type Timestamp = number;
 export type TimeWheelCacheOptions = {
-    tickInterval: number;
-    tickCount: number;
+    autoStart?: boolean;
+    tickInterval?: number;
+    tickCount?: number;
 };
 import { EventEmitter } from '@creejs/commons-events';