@etsoo/shared 1.1.30 → 1.1.33

package/README.md

@@ -68,6 +68,7 @@ ETSOO Extended abstract history class
 |back|Back to the previous state|
 |clear|Clear all states but keep event listeners|
 |forward|Forward to the next state|
+|getStatus|Get [undo, redo] status|
 |go|Go to the specific state|
 |pushState|Adds an entry to the history stack|
 |replaceState|Modifies the current history entry|

package/__tests__/EHistory.ts

@@ -1,27 +1,20 @@
-import {
-    EHistory,
-    EHistoryEventData,
-    EHistoryEventType
-} from '../src/types/EHistory';
-import { EventBase } from '../src/types/EventClass';
+import { EHistory, EHistoryEvent } from '../src/types/EHistory';
 
 // Extended for tests
-class LHistoryEvent extends EventBase<EHistoryEventType, EHistoryEventData> {}
-class LHistory extends EHistory<number, EHistoryEventData> {
-    protected createEvent(type: EHistoryEventType, index: number) {
-        return new LHistoryEvent(this, type, { index });
-    }
-}
+class LHistory extends EHistory<number> {}
 
 test('Tests for history', () => {
     const history = new LHistory();
     expect(history.index).toBe(-1);
     history.pushState(1);
+    expect(history.getStatus()).toStrictEqual([false, false]);
     history.pushState(2);
     history.pushState(3);
+    expect(history.getStatus()).toStrictEqual([true, false]);
     expect(history.states).toStrictEqual([1, 2, 3]);
     expect(history.index).toBe(2);
     history.back();
+    expect(history.getStatus()).toStrictEqual([true, true]);
     history.pushState(4);
     expect(history.index).toBe(2);
     expect(history.states).toStrictEqual([1, 2, 4]);
@@ -37,14 +30,14 @@ test('Tests for history', () => {
 
 test('Tests for events', () => {
     const navigatorFn = jest.fn();
-    const navigatorStopFn = jest.fn((event: LHistoryEvent) => {
+    const navigatorStopFn = jest.fn((event: EHistoryEvent) => {
         event.stopImmediatePropagation();
     });
     const clearFn = jest.fn();
     const pushFn = jest.fn();
     const replaceFn = jest.fn();
 
-    const history = new LHistory();
+    const history = new LHistory(3);
 
     history.on({
         clear: clearFn,
@@ -78,4 +71,9 @@ test('Tests for events', () => {
 
     // Previous handler stopped propagation
     expect(navigatorFn).toBeCalledTimes(5);
+
+    history.pushState(3);
+    history.pushState(4);
+    history.pushState(5);
+    expect(history.length).toBe(3);
 });

package/lib/cjs/types/EHistory.d.ts

@@ -12,10 +12,16 @@ export interface EHistoryEventData {
      */
     index: number;
 }
+/**
+ * ETSOO Extended history event
+ */
+export declare class EHistoryEvent extends EventBase<EHistoryEventType, EHistoryEventData> {
+}
 /**
  * ETSOO Extended abstract history class
  */
-export declare abstract class EHistory<T, D extends EHistoryEventData = EHistoryEventData> extends EventClass<EHistoryEventType, D> {
+export declare abstract class EHistory<T> extends EventClass<EHistoryEventType, EHistoryEventData> {
+    readonly maxDepth: number;
     private _index;
     /**
      * States
@@ -33,6 +39,11 @@ export declare abstract class EHistory<T, D extends EHistoryEventData = EHistory
      * Get current state
      */
     get state(): T | undefined;
+    /**
+     * Constructor
+     * @param maxDepth Max depth of the history
+     */
+    constructor(maxDepth?: number);
     /**
      * Back to the previous state
      */
@@ -46,11 +57,15 @@ export declare abstract class EHistory<T, D extends EHistoryEventData = EHistory
      * @param type Type
      * @param index Current index
      */
-    protected abstract createEvent(type: EHistoryEventType, index: number): EventBase<EHistoryEventType, D>;
+    protected createEvent(type: EHistoryEventType, index: number): EHistoryEvent;
     /**
      * Forward to the next state
      */
     forward(): void;
+    /**
+     * Get [undo, redo] status
+     */
+    getStatus(): [boolean, boolean];
     /**
      * Go to the specific state
      * @param delta A negative value moves backwards, a positive value moves forwards

package/lib/cjs/types/EHistory.js

@@ -1,13 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EHistory = void 0;
+exports.EHistory = exports.EHistoryEvent = void 0;
 const EventClass_1 = require("./EventClass");
+/**
+ * ETSOO Extended history event
+ */
+class EHistoryEvent extends EventClass_1.EventBase {
+}
+exports.EHistoryEvent = EHistoryEvent;
 /**
  * ETSOO Extended abstract history class
  */
 class EHistory extends EventClass_1.EventClass {
-    constructor() {
-        super(...arguments);
+    /**
+     * Constructor
+     * @param maxDepth Max depth of the history
+     */
+    constructor(maxDepth = 20) {
+        super();
+        this.maxDepth = maxDepth;
         // Index
         this._index = -1;
         /**
@@ -50,12 +61,32 @@ class EHistory extends EventClass_1.EventClass {
         this._index = -1;
         this.trigger(this.createEvent('clear', this._index));
     }
+    /**
+     * Create event
+     * @param type Type
+     * @param index Current index
+     */
+    createEvent(type, index) {
+        return new EHistoryEvent(this, type, { index });
+    }
     /**
      * Forward to the next state
      */
     forward() {
         this.go(1);
     }
+    /**
+     * Get [undo, redo] status
+     */
+    getStatus() {
+        if (this.length < 2)
+            return [false, false];
+        if (this._index <= 0)
+            return [false, true];
+        if (this._index + 1 >= this.length)
+            return [true, false];
+        return [true, true];
+    }
     /**
      * Go to the specific state
      * @param delta A negative value moves backwards, a positive value moves forwards
@@ -85,6 +116,9 @@ class EHistory extends EventClass_1.EventClass {
         }
         this.states.push(state);
         this._index++;
+        if (this.length > this.maxDepth) {
+            this.states.shift();
+        }
         this.trigger(this.createEvent('push', this._index));
     }
     /**

package/lib/mjs/types/EHistory.d.ts

@@ -12,10 +12,16 @@ export interface EHistoryEventData {
      */
     index: number;
 }
+/**
+ * ETSOO Extended history event
+ */
+export declare class EHistoryEvent extends EventBase<EHistoryEventType, EHistoryEventData> {
+}
 /**
  * ETSOO Extended abstract history class
  */
-export declare abstract class EHistory<T, D extends EHistoryEventData = EHistoryEventData> extends EventClass<EHistoryEventType, D> {
+export declare abstract class EHistory<T> extends EventClass<EHistoryEventType, EHistoryEventData> {
+    readonly maxDepth: number;
     private _index;
     /**
      * States
@@ -33,6 +39,11 @@ export declare abstract class EHistory<T, D extends EHistoryEventData = EHistory
      * Get current state
      */
     get state(): T | undefined;
+    /**
+     * Constructor
+     * @param maxDepth Max depth of the history
+     */
+    constructor(maxDepth?: number);
     /**
      * Back to the previous state
      */
@@ -46,11 +57,15 @@ export declare abstract class EHistory<T, D extends EHistoryEventData = EHistory
      * @param type Type
      * @param index Current index
      */
-    protected abstract createEvent(type: EHistoryEventType, index: number): EventBase<EHistoryEventType, D>;
+    protected createEvent(type: EHistoryEventType, index: number): EHistoryEvent;
     /**
      * Forward to the next state
      */
     forward(): void;
+    /**
+     * Get [undo, redo] status
+     */
+    getStatus(): [boolean, boolean];
     /**
      * Go to the specific state
      * @param delta A negative value moves backwards, a positive value moves forwards

package/lib/mjs/types/EHistory.js

@@ -1,10 +1,20 @@
-import { EventClass } from './EventClass';
+import { EventBase, EventClass } from './EventClass';
+/**
+ * ETSOO Extended history event
+ */
+export class EHistoryEvent extends EventBase {
+}
 /**
  * ETSOO Extended abstract history class
  */
 export class EHistory extends EventClass {
-    constructor() {
-        super(...arguments);
+    /**
+     * Constructor
+     * @param maxDepth Max depth of the history
+     */
+    constructor(maxDepth = 20) {
+        super();
+        this.maxDepth = maxDepth;
         // Index
         this._index = -1;
         /**
@@ -47,12 +57,32 @@ export class EHistory extends EventClass {
         this._index = -1;
         this.trigger(this.createEvent('clear', this._index));
     }
+    /**
+     * Create event
+     * @param type Type
+     * @param index Current index
+     */
+    createEvent(type, index) {
+        return new EHistoryEvent(this, type, { index });
+    }
     /**
      * Forward to the next state
      */
     forward() {
         this.go(1);
     }
+    /**
+     * Get [undo, redo] status
+     */
+    getStatus() {
+        if (this.length < 2)
+            return [false, false];
+        if (this._index <= 0)
+            return [false, true];
+        if (this._index + 1 >= this.length)
+            return [true, false];
+        return [true, true];
+    }
     /**
      * Go to the specific state
      * @param delta A negative value moves backwards, a positive value moves forwards
@@ -82,6 +112,9 @@ export class EHistory extends EventClass {
         }
         this.states.push(state);
         this._index++;
+        if (this.length > this.maxDepth) {
+            this.states.shift();
+        }
         this.trigger(this.createEvent('push', this._index));
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@etsoo/shared",
-    "version": "1.1.30",
+    "version": "1.1.33",
     "description": "TypeScript shared utilities and functions",
     "main": "lib/cjs/index.js",
     "module": "lib/mjs/index.js",

package/src/types/EHistory.ts

@@ -15,13 +15,21 @@ export interface EHistoryEventData {
     index: number;
 }
 
+/**
+ * ETSOO Extended history event
+ */
+export class EHistoryEvent extends EventBase<
+    EHistoryEventType,
+    EHistoryEventData
+> {}
+
 /**
  * ETSOO Extended abstract history class
  */
-export abstract class EHistory<
-    T,
-    D extends EHistoryEventData = EHistoryEventData
-> extends EventClass<EHistoryEventType, D> {
+export abstract class EHistory<T> extends EventClass<
+    EHistoryEventType,
+    EHistoryEventData
+> {
     // Index
     private _index: number = -1;
 
@@ -52,6 +60,14 @@ export abstract class EHistory<
         return this.states[this._index];
     }
 
+    /**
+     * Constructor
+     * @param maxDepth Max depth of the history
+     */
+    constructor(public readonly maxDepth: number = 20) {
+        super();
+    }
+
     /**
      * Back to the previous state
      */
@@ -74,10 +90,9 @@ export abstract class EHistory<
      * @param type Type
      * @param index Current index
      */
-    protected abstract createEvent(
-        type: EHistoryEventType,
-        index: number
-    ): EventBase<EHistoryEventType, D>;
+    protected createEvent(type: EHistoryEventType, index: number) {
+        return new EHistoryEvent(this, type, { index });
+    }
 
     /**
      * Forward to the next state
@@ -86,6 +101,16 @@ export abstract class EHistory<
         this.go(1);
     }
 
+    /**
+     * Get [undo, redo] status
+     */
+    getStatus(): [boolean, boolean] {
+        if (this.length < 2) return [false, false];
+        if (this._index <= 0) return [false, true];
+        if (this._index + 1 >= this.length) return [true, false];
+        return [true, true];
+    }
+
     /**
      * Go to the specific state
      * @param delta A negative value moves backwards, a positive value moves forwards
@@ -119,6 +144,11 @@ export abstract class EHistory<
 
         this.states.push(state);
         this._index++;
+
+        if (this.length > this.maxDepth) {
+            this.states.shift();
+        }
+
         this.trigger(this.createEvent('push', this._index));
     }