@creejs/commons-collection 2.0.1 → 2.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@creejs/commons-collection",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "Commons Collection",
   "keywords": [
     "commons",

package/types/capped-set.d.ts

@@ -13,9 +13,12 @@ export default class CappedSet {
     constructor(capacity: number);
     capacity: number;
     /**
+     * 1. key is the Value stored in CappedSet
+     * 2. value is a Node
+     * 3. JS Map preserve the insertion order
      * @type {Map<any, Node>}
      */
-    _set: Map<any, Node>;
+    _map: Map<any, Node>;
     /**
      * @type {Node|undefined}
      */
@@ -25,7 +28,13 @@ export default class CappedSet {
      */
     _tail: Node | undefined;
     get size(): number;
+    /**
+     * get the oldest element
+     */
     get oldest(): any;
+    /**
+     * get the newest element
+     */
     get newest(): any;
     /**
      * Adds a value to the capped set. If the value already exists, it will be moved to the most recent position.

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

@@ -0,0 +1,96 @@
+/**
+ * Hour-Minute-Second-Time-Wheel Cache
+ * 1. TTL must be less than 24 Hours
+ */
+export default class Hour24TimeWheelCache extends EventEmitter {
+    static get DowngradType(): {
+        HourToSecond: string;
+        HourToMinute: string;
+        MinuteToSecond: string;
+    };
+    static get Event(): {
+        Downgrade: string;
+        Expired: string;
+    };
+    /**
+     * Second Wheel:
+     * 1. 1 Tick Mark is 1 Second, is 1000 Milliseconds
+     * 2. 60 Slots, maximumly, SencondWheel can contain 60 Seconds
+     * 3. 60 Seconds should be stored in MinuteWheel
+     *   * 01   00:00:00.XXX -> 00:00:59.XXX   in   Slot01  Index00
+     *   * 02   00:00:01.XXX -> 00:00:01.XXX   in   Slot02  Index01
+     *   * 60   00:00:59.XXX -> 00:00:59.XXX   in   Slot60  Index59
+     * @type {TimeWheelCache}
+     */
+    _secondWheel: TimeWheelCache;
+    /**
+     * Minute Wheel:
+     * 1. 1 Tick Mark is 1 Minute, is 60 * 1000 Milliseconds
+     * 2. 60 Slots, maximumly, MinuteWheel can contain 60 Minutes
+     *   * 01   00:00:00 -> 00:00:59   in   Slot01    Index00
+     *   * 02   00:01:00 -> 00:01:59   in   Slot02    Index01
+     *   * 60   00:59:00 -> 00:59:59   in   Slot60    Index59
+     * @type {TimeWheelCache}
+     */
+    _minuteWheel: TimeWheelCache;
+    /**
+     * Hour Wheel:
+     * 1. 1 Tick Mark is 1 Hour, is 60 * 60 * 1000 Milliseconds
+     * 2. 24 Slots, maximumly, HourWheel can contain 23:59:59
+     *   * 01 00:00:00 -> 00:59:59   in   Slot01    Index00
+     *   * 02 01:00:00 -> 01:59:59   in   Slot02    Index01
+     *   * 24 23:00:00 -> 23:59:59   in   Slot23    Index23
+     * @type {TimeWheelCache}
+     */
+    _hourWheel: TimeWheelCache;
+    /**
+     * @type {Map<any, TimeWheelCache>}
+     */
+    _cache: Map<any, TimeWheelCache>;
+    /**
+     * Max Time to Live, atom unit "millisecond"
+     * @returns {number}
+     */
+    get maxTtl(): number;
+    get autoEvictRunning(): boolean;
+    _init(): void;
+    destroy(): void;
+    /**
+     * @param {any} key
+     * @param {any} value
+     * @param {number} ttl Time To Live, unit "millisencond", ttl should < 24 Hours
+     * @returns {boolean}
+     */
+    set(key: any, value: any, ttl: number): boolean;
+    /**
+     * @param {any} key
+     * @returns {boolean}
+     */
+    delete(key: any): boolean;
+    /**
+     * Checks if the cache contains the specified key.
+     * @param {any} key - The key to check for existence in the cache.
+     * @returns {boolean} - True if the key exists in the cache, false otherwise.
+     */
+    has(key: any): boolean;
+    clear(): void;
+    /**
+     *
+     * @param {any} key
+     * @returns {any}
+     */
+    get(key: any): any;
+    size(): number;
+}
+export type Timestamp = number;
+import { EventEmitter } from '@creejs/commons-events';
+import TimeWheelCache from './time-wheel-cache.js';
+export namespace DowngradType {
+    let HourToSecond: string;
+    let HourToMinute: string;
+    let MinuteToSecond: string;
+}
+export namespace Event {
+    let Downgrade: string;
+    let Expired: string;
+}

package/types/index.d.ts

@@ -1,6 +1,10 @@
 declare namespace _default {
     export { CappedSet };
+    export { TimeWheelCache };
+    export { Hour24TimeWheelCache };
 }
 export default _default;
-export { CappedSet };
 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 };

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

@@ -0,0 +1,104 @@
+/**
+ * Not Found Better Implementation in npmjs.com, so do it by ourselves.
+ *
+ * Key Points:
+ * 1. Basic Atom Unit is "tick", 1 tick = 1 tickInterval
+ * 3. How many milliseconds does 1 Tick represent is defined by "tickInterval"
+ * 4. How many Ticks does the Wheel own is defined by "tickCount"
+ */
+export default class TimeWheelCache extends EventEmitter {
+    /**
+     * @param {TimeWheelCacheOptions} [options]
+     */
+    constructor(options?: TimeWheelCacheOptions);
+    get Event(): {
+        Advance: string;
+        Expired: string;
+    };
+    options: {};
+    /**
+     * How many milliseconds does one Tick represent
+     */
+    _tickInterval: number;
+    /**
+     * How many Ticks does the Wheel have
+     */
+    _tickCount: number;
+    /**
+     * Slots, one Tick owns one Slot to store key and expire timestamp
+     * @type {Map<any, {value: any, slotIndex: number, expireTimestamp: number}>[]}
+     */
+    _slots: Map<any, {
+        value: any;
+        slotIndex: number;
+        expireTimestamp: number;
+    }>[];
+    /**
+     * Data Cache
+     * @type {Map<any, {value: any, slotIndex: number, expireTimestamp: number}>}
+     */
+    _cache: Map<any, {
+        value: any;
+        slotIndex: number;
+        expireTimestamp: number;
+    }>;
+    _currentSlotIndex: number;
+    /** @type {NodeJS.Timeout|undefined} */
+    _timer: NodeJS.Timeout | undefined;
+    get tickInterval(): number;
+    get tickCount(): number;
+    /**
+     * Max Time to Live, atom unit "millisecond"
+     * @returns {number}
+     */
+    get maxTtl(): number;
+    _maxTtl: number | undefined;
+    get autoEvictRunning(): boolean;
+    _startAutoEvict(): void;
+    _stopAutoEvict(): void;
+    _advance(): void;
+    destroy(): void;
+    /**
+     * 1. "key" is not Nil
+     * 2. "value" is not Nil
+     * 3. "ttl" must > 0 && <= maxTtl, maxTtl = tickCount * tickInterval
+     *    * > 0: CAN NOT go to past
+     *    * < maxTtl: Wheel is Round, eg.
+     *      * "Hour Wheel" has 24 Hour-Tick-Mark
+     *      * CAN NOT distinguish 24 hours and 48 hours
+     * 4. Understand the difference between "ttl" and "timestamp"
+     *    * TTL is Indexed from 1
+     *      * eg. ttl = 60, should be stored in Slot[59]
+     *    * Timestamp is Indexed from 0
+     * @param {any} key
+     * @param {any} value
+     * @param {number} ttl Time to Live, atom unit "millisecond"
+     * @returns {boolean}
+     */
+    set(key: any, value: any, ttl: number): boolean;
+    /**
+     * @param {any} key
+     * @returns {boolean}
+     */
+    delete(key: any): boolean;
+    /**
+     * Checks if the cache contains the specified key.
+     * @param {any} key - The key to check for existence in the cache.
+     * @returns {boolean} - True if the key exists in the cache, false otherwise.
+     */
+    has(key: any): boolean;
+    clear(): void;
+    /**
+     *
+     * @param {any} key
+     * @returns {any}
+     */
+    get(key: any): any;
+    size(): number;
+}
+export type Timestamp = number;
+export type TimeWheelCacheOptions = {
+    tickInterval: number;
+    tickCount: number;
+};
+import { EventEmitter } from '@creejs/commons-events';