@etsoo/shared 1.1.33 → 1.1.34

package/__tests__/EHistory.ts

@@ -1,4 +1,4 @@
-import { EHistory, EHistoryEvent } from '../src/types/EHistory';
+import { EHistory, EHistoryNavigateEvent } from '../src/types/EHistory';
 
 // Extended for tests
 class LHistory extends EHistory<number> {}
@@ -30,7 +30,7 @@ test('Tests for history', () => {
 
 test('Tests for events', () => {
     const navigatorFn = jest.fn();
-    const navigatorStopFn = jest.fn((event: EHistoryEvent) => {
+    const navigatorStopFn = jest.fn((event: EHistoryNavigateEvent) => {
         event.stopImmediatePropagation();
     });
     const clearFn = jest.fn();

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

@@ -1,26 +1,38 @@
 import { EventBase, EventClass } from './EventClass';
-/**
- * ETSOO Extended history event type
- */
-export declare type EHistoryEventType = 'navigate' | 'push' | 'replace' | 'clear';
-/**
- * ETSOO Extended history event data
- */
-export interface EHistoryEventData {
+interface EHistoryEventData {
     /**
      * Current index
      */
     index: number;
 }
+interface EHistoryNavigateEventData extends EHistoryEventData {
+    /**
+     * Delta
+     */
+    delta: number;
+}
+declare type EHistoryEventDef = {
+    clear: EHistoryEventData;
+    navigate: EHistoryNavigateEventData;
+    push: EHistoryEventData;
+    replace: EHistoryEventData;
+};
+declare type EHistoryEventType = Exclude<keyof EHistoryEventDef, 'navigate'>;
 /**
  * ETSOO Extended history event
  */
 export declare class EHistoryEvent extends EventBase<EHistoryEventType, EHistoryEventData> {
 }
+/**
+ * ETSOO Extended history navigate event
+ */
+export declare class EHistoryNavigateEvent extends EventBase<'navigate', EHistoryNavigateEventData> {
+    constructor(target: {}, data: EHistoryNavigateEventData);
+}
 /**
  * ETSOO Extended abstract history class
  */
-export declare abstract class EHistory<T> extends EventClass<EHistoryEventType, EHistoryEventData> {
+export declare abstract class EHistory<T> extends EventClass<EHistoryEventDef> {
     readonly maxDepth: number;
     private _index;
     /**
@@ -57,7 +69,8 @@ export declare abstract class EHistory<T> extends EventClass<EHistoryEventType,
      * @param type Type
      * @param index Current index
      */
-    protected createEvent(type: EHistoryEventType, index: number): EHistoryEvent;
+    protected createEvent<T extends EHistoryEventType>(type: T, index: number): EHistoryEvent;
+    protected createNavigateEvent(index: number, delta: number): EHistoryNavigateEvent;
     /**
      * Forward to the next state
      */
@@ -82,3 +95,4 @@ export declare abstract class EHistory<T> extends EventClass<EHistoryEventType,
      */
     replaceState(state: T): void;
 }
+export {};

package/lib/cjs/types/EHistory.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EHistory = exports.EHistoryEvent = void 0;
+exports.EHistory = exports.EHistoryNavigateEvent = exports.EHistoryEvent = void 0;
 const EventClass_1 = require("./EventClass");
 /**
  * ETSOO Extended history event
@@ -8,6 +8,15 @@ const EventClass_1 = require("./EventClass");
 class EHistoryEvent extends EventClass_1.EventBase {
 }
 exports.EHistoryEvent = EHistoryEvent;
+/**
+ * ETSOO Extended history navigate event
+ */
+class EHistoryNavigateEvent extends EventClass_1.EventBase {
+    constructor(target, data) {
+        super(target, 'navigate', data);
+    }
+}
+exports.EHistoryNavigateEvent = EHistoryNavigateEvent;
 /**
  * ETSOO Extended abstract history class
  */
@@ -69,6 +78,9 @@ class EHistory extends EventClass_1.EventClass {
     createEvent(type, index) {
         return new EHistoryEvent(this, type, { index });
     }
+    createNavigateEvent(index, delta) {
+        return new EHistoryNavigateEvent(this, { index, delta });
+    }
     /**
      * Forward to the next state
      */
@@ -103,7 +115,7 @@ class EHistory extends EventClass_1.EventClass {
         // Update the index
         this._index = newIndex;
         // Trigger event
-        this.trigger(this.createEvent('navigate', newIndex));
+        this.trigger(this.createNavigateEvent(newIndex, delta));
     }
     /**
      * Adds an entry to the history stack

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

@@ -3,8 +3,8 @@
  * T for type
  * D for data
  */
-export declare abstract class EventBase<T extends string, D> {
-    readonly target: EventClass<T, D>;
+export declare abstract class EventBase<T, D> {
+    readonly target: {};
     readonly type: T;
     readonly data: D;
     private _propagationStopped;
@@ -21,7 +21,7 @@ export declare abstract class EventBase<T extends string, D> {
      * Constructor
      * @param type Type
      */
-    constructor(target: EventClass<T, D>, type: T, data: D);
+    constructor(target: {}, type: T, data: D);
     /**
      * Prevent all other listeners from being called
      */
@@ -40,65 +40,56 @@ interface EventOptions {
      */
     once?: boolean;
 }
-/**
- * Event class callback
- * T for type
- * D for data
- */
-export declare type EventClassCallback<T extends string, D> = (event: EventBase<T, D>) => void;
-/**
- * Event class collection definition
- * T for type
- * D for data
- */
-export declare type EventClassCollection<T extends string, D> = {
-    [key in T]?: EventClassCallback<T, D>;
+declare type EventClassDef = {
+    [key: string]: {};
 };
 /**
  * Event class
  * T for type
  * D for data
  */
-export declare abstract class EventClass<T extends string, D> {
+export declare abstract class EventClass<D extends EventClassDef> {
     private readonly listeners;
     /**
      * Has specific type events
      * @param type Type
      */
-    hasEvents(type: T): boolean;
+    hasEvents<T extends keyof D>(type: T): boolean;
     /**
      * Has specific type and callback events
      * @param type Type
      * @param callback Callback
      */
-    hasEvents(type: T, callback: EventClassCallback<T, D>): boolean;
+    hasEvents<T extends keyof D>(type: T, callback: (event: EventBase<T, D[T]>) => void): boolean;
     /**
      * Remove all specific type events
      * @param type Type
      */
-    off(type: T): void;
+    off<T extends keyof D>(type: T): void;
     /**
      * Remove specific type and callback event
      * @param type Type
      * @param callback Callback
      */
-    off(type: T, callback: EventClassCallback<T, D>): void;
+    off<T extends keyof D>(type: T, callback: (event: EventBase<T, D[T]>) => void): void;
     /**
      * Add event listeners
      * @param collection Collection of events
      */
-    on(collection: EventClassCollection<T, D>): void;
+    on(collection: {
+        [type in keyof D]: (event: EventBase<type, D[type]>) => void;
+    }): void;
     /**
      * Add event listener
      * @param type Type
      * @param callback Callback
      * @param options Options
      */
-    on(type: T, callback: EventClassCallback<T, D>, options?: EventOptions): void;
+    on<T extends keyof D>(type: T, callback: (event: EventBase<T, D[T]>) => void, options?: EventOptions): void;
     /**
      * Trigger event
      * @param event Event
      */
-    trigger(event: EventBase<T, D>): void;
+    trigger<T extends keyof D>(event: EventBase<T, D[T]>): void;
 }
 export {};

package/lib/cjs/types/EventClass.js

@@ -102,6 +102,8 @@ class EventClass {
         if (callback == null)
             return;
         this.listeners.has(type) || this.listeners.set(type, []);
+        // String to T conversion problem
+        // "keyofStringsOnly": true could solve part of it
         (_b = this.listeners.get(type)) === null || _b === void 0 ? void 0 : _b.push([callback, options]);
     }
     /**

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

@@ -1,26 +1,38 @@
 import { EventBase, EventClass } from './EventClass';
-/**
- * ETSOO Extended history event type
- */
-export declare type EHistoryEventType = 'navigate' | 'push' | 'replace' | 'clear';
-/**
- * ETSOO Extended history event data
- */
-export interface EHistoryEventData {
+interface EHistoryEventData {
     /**
      * Current index
      */
     index: number;
 }
+interface EHistoryNavigateEventData extends EHistoryEventData {
+    /**
+     * Delta
+     */
+    delta: number;
+}
+declare type EHistoryEventDef = {
+    clear: EHistoryEventData;
+    navigate: EHistoryNavigateEventData;
+    push: EHistoryEventData;
+    replace: EHistoryEventData;
+};
+declare type EHistoryEventType = Exclude<keyof EHistoryEventDef, 'navigate'>;
 /**
  * ETSOO Extended history event
  */
 export declare class EHistoryEvent extends EventBase<EHistoryEventType, EHistoryEventData> {
 }
+/**
+ * ETSOO Extended history navigate event
+ */
+export declare class EHistoryNavigateEvent extends EventBase<'navigate', EHistoryNavigateEventData> {
+    constructor(target: {}, data: EHistoryNavigateEventData);
+}
 /**
  * ETSOO Extended abstract history class
  */
-export declare abstract class EHistory<T> extends EventClass<EHistoryEventType, EHistoryEventData> {
+export declare abstract class EHistory<T> extends EventClass<EHistoryEventDef> {
     readonly maxDepth: number;
     private _index;
     /**
@@ -57,7 +69,8 @@ export declare abstract class EHistory<T> extends EventClass<EHistoryEventType,
      * @param type Type
      * @param index Current index
      */
-    protected createEvent(type: EHistoryEventType, index: number): EHistoryEvent;
+    protected createEvent<T extends EHistoryEventType>(type: T, index: number): EHistoryEvent;
+    protected createNavigateEvent(index: number, delta: number): EHistoryNavigateEvent;
     /**
      * Forward to the next state
      */
@@ -82,3 +95,4 @@ export declare abstract class EHistory<T> extends EventClass<EHistoryEventType,
      */
     replaceState(state: T): void;
 }
+export {};

package/lib/mjs/types/EHistory.js

@@ -4,6 +4,14 @@ import { EventBase, EventClass } from './EventClass';
  */
 export class EHistoryEvent extends EventBase {
 }
+/**
+ * ETSOO Extended history navigate event
+ */
+export class EHistoryNavigateEvent extends EventBase {
+    constructor(target, data) {
+        super(target, 'navigate', data);
+    }
+}
 /**
  * ETSOO Extended abstract history class
  */
@@ -65,6 +73,9 @@ export class EHistory extends EventClass {
     createEvent(type, index) {
         return new EHistoryEvent(this, type, { index });
     }
+    createNavigateEvent(index, delta) {
+        return new EHistoryNavigateEvent(this, { index, delta });
+    }
     /**
      * Forward to the next state
      */
@@ -99,7 +110,7 @@ export class EHistory extends EventClass {
         // Update the index
         this._index = newIndex;
         // Trigger event
-        this.trigger(this.createEvent('navigate', newIndex));
+        this.trigger(this.createNavigateEvent(newIndex, delta));
     }
     /**
      * Adds an entry to the history stack

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

@@ -3,8 +3,8 @@
  * T for type
  * D for data
  */
-export declare abstract class EventBase<T extends string, D> {
-    readonly target: EventClass<T, D>;
+export declare abstract class EventBase<T, D> {
+    readonly target: {};
     readonly type: T;
     readonly data: D;
     private _propagationStopped;
@@ -21,7 +21,7 @@ export declare abstract class EventBase<T extends string, D> {
      * Constructor
      * @param type Type
      */
-    constructor(target: EventClass<T, D>, type: T, data: D);
+    constructor(target: {}, type: T, data: D);
     /**
      * Prevent all other listeners from being called
      */
@@ -40,65 +40,56 @@ interface EventOptions {
      */
     once?: boolean;
 }
-/**
- * Event class callback
- * T for type
- * D for data
- */
-export declare type EventClassCallback<T extends string, D> = (event: EventBase<T, D>) => void;
-/**
- * Event class collection definition
- * T for type
- * D for data
- */
-export declare type EventClassCollection<T extends string, D> = {
-    [key in T]?: EventClassCallback<T, D>;
+declare type EventClassDef = {
+    [key: string]: {};
 };
 /**
  * Event class
  * T for type
  * D for data
  */
-export declare abstract class EventClass<T extends string, D> {
+export declare abstract class EventClass<D extends EventClassDef> {
     private readonly listeners;
     /**
      * Has specific type events
      * @param type Type
      */
-    hasEvents(type: T): boolean;
+    hasEvents<T extends keyof D>(type: T): boolean;
     /**
      * Has specific type and callback events
      * @param type Type
      * @param callback Callback
      */
-    hasEvents(type: T, callback: EventClassCallback<T, D>): boolean;
+    hasEvents<T extends keyof D>(type: T, callback: (event: EventBase<T, D[T]>) => void): boolean;
     /**
      * Remove all specific type events
      * @param type Type
      */
-    off(type: T): void;
+    off<T extends keyof D>(type: T): void;
     /**
      * Remove specific type and callback event
      * @param type Type
      * @param callback Callback
      */
-    off(type: T, callback: EventClassCallback<T, D>): void;
+    off<T extends keyof D>(type: T, callback: (event: EventBase<T, D[T]>) => void): void;
     /**
      * Add event listeners
      * @param collection Collection of events
      */
-    on(collection: EventClassCollection<T, D>): void;
+    on(collection: {
+        [type in keyof D]: (event: EventBase<type, D[type]>) => void;
+    }): void;
     /**
      * Add event listener
      * @param type Type
      * @param callback Callback
      * @param options Options
      */
-    on(type: T, callback: EventClassCallback<T, D>, options?: EventOptions): void;
+    on<T extends keyof D>(type: T, callback: (event: EventBase<T, D[T]>) => void, options?: EventOptions): void;
     /**
      * Trigger event
      * @param event Event
      */
-    trigger(event: EventBase<T, D>): void;
+    trigger<T extends keyof D>(event: EventBase<T, D[T]>): void;
 }
 export {};

package/lib/mjs/types/EventClass.js

@@ -98,6 +98,8 @@ export class EventClass {
         if (callback == null)
             return;
         this.listeners.has(type) || this.listeners.set(type, []);
+        // String to T conversion problem
+        // "keyofStringsOnly": true could solve part of it
         (_b = this.listeners.get(type)) === null || _b === void 0 ? void 0 : _b.push([callback, options]);
     }
     /**

package/package.json

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

package/src/types/EHistory.ts

@@ -1,20 +1,28 @@
 import { EventBase, EventClass } from './EventClass';
 
-/**
- * ETSOO Extended history event type
- */
-export type EHistoryEventType = 'navigate' | 'push' | 'replace' | 'clear';
-
-/**
- * ETSOO Extended history event data
- */
-export interface EHistoryEventData {
+interface EHistoryEventData {
     /**
      * Current index
      */
     index: number;
 }
 
+interface EHistoryNavigateEventData extends EHistoryEventData {
+    /**
+     * Delta
+     */
+    delta: number;
+}
+
+type EHistoryEventDef = {
+    clear: EHistoryEventData;
+    navigate: EHistoryNavigateEventData;
+    push: EHistoryEventData;
+    replace: EHistoryEventData;
+};
+
+type EHistoryEventType = Exclude<keyof EHistoryEventDef, 'navigate'>;
+
 /**
  * ETSOO Extended history event
  */
@@ -24,12 +32,21 @@ export class EHistoryEvent extends EventBase<
 > {}
 
 /**
- * ETSOO Extended abstract history class
+ * ETSOO Extended history navigate event
  */
-export abstract class EHistory<T> extends EventClass<
-    EHistoryEventType,
-    EHistoryEventData
+export class EHistoryNavigateEvent extends EventBase<
+    'navigate',
+    EHistoryNavigateEventData
 > {
+    constructor(target: {}, data: EHistoryNavigateEventData) {
+        super(target, 'navigate', data);
+    }
+}
+
+/**
+ * ETSOO Extended abstract history class
+ */
+export abstract class EHistory<T> extends EventClass<EHistoryEventDef> {
     // Index
     private _index: number = -1;
 
@@ -90,10 +107,14 @@ export abstract class EHistory<T> extends EventClass<
      * @param type Type
      * @param index Current index
      */
-    protected createEvent(type: EHistoryEventType, index: number) {
+    protected createEvent<T extends EHistoryEventType>(type: T, index: number) {
         return new EHistoryEvent(this, type, { index });
     }
 
+    protected createNavigateEvent(index: number, delta: number) {
+        return new EHistoryNavigateEvent(this, { index, delta });
+    }
+
     /**
      * Forward to the next state
      */
@@ -129,7 +150,7 @@ export abstract class EHistory<T> extends EventClass<
         this._index = newIndex;
 
         // Trigger event
-        this.trigger(this.createEvent('navigate', newIndex));
+        this.trigger(this.createNavigateEvent(newIndex, delta));
     }
 
     /**

package/src/types/EventClass.ts

@@ -3,7 +3,7 @@
  * T for type
  * D for data
  */
-export abstract class EventBase<T extends string, D> {
+export abstract class EventBase<T, D> {
     private _propagationStopped: boolean = false;
     /**
      * stopImmediatePropagation called
@@ -25,7 +25,7 @@ export abstract class EventBase<T extends string, D> {
      * @param type Type
      */
     constructor(
-        public readonly target: EventClass<T, D>,
+        public readonly target: {},
         public readonly type: T,
         public readonly data: D
     ) {
@@ -55,48 +55,35 @@ interface EventOptions {
     once?: boolean;
 }
 
-/**
- * Event class callback
- * T for type
- * D for data
- */
-export type EventClassCallback<T extends string, D> = (
-    event: EventBase<T, D>
-) => void;
-
-/**
- * Event class collection definition
- * T for type
- * D for data
- */
-export type EventClassCollection<T extends string, D> = {
-    [key in T]?: EventClassCallback<T, D>;
-};
+type EventClassDef = { [key: string]: {} };
 
 /**
  * Event class
  * T for type
  * D for data
  */
-export abstract class EventClass<T extends string, D> {
+export abstract class EventClass<D extends EventClassDef> {
     // Listeners
     private readonly listeners = new Map<
-        T,
-        [EventClassCallback<T, D>, EventOptions?][]
+        keyof D,
+        [(event: EventBase<keyof D, D[keyof D]>) => void, EventOptions?][]
     >();
 
     /**
      * Has specific type events
      * @param type Type
      */
-    hasEvents(type: T): boolean;
+    hasEvents<T extends keyof D>(type: T): boolean;
 
     /**
      * Has specific type and callback events
      * @param type Type
      * @param callback Callback
      */
-    hasEvents(type: T, callback: EventClassCallback<T, D>): boolean;
+    hasEvents<T extends keyof D>(
+        type: T,
+        callback: (event: EventBase<T, D[T]>) => void
+    ): boolean;
 
     /**
      * Has specific type and callback events
@@ -104,7 +91,10 @@ export abstract class EventClass<T extends string, D> {
      * @param callback Callback
      * @returns Result
      */
-    hasEvents(type: T, callback?: EventClassCallback<T, D>) {
+    hasEvents<T extends keyof D>(
+        type: T,
+        callback?: (event: EventBase<T, D[T]>) => void
+    ) {
         const items = this.listeners.get(type);
         if (items == null || items.length === 0) return false;
 
@@ -119,21 +109,27 @@ export abstract class EventClass<T extends string, D> {
      * Remove all specific type events
      * @param type Type
      */
-    off(type: T): void;
+    off<T extends keyof D>(type: T): void;
 
     /**
      * Remove specific type and callback event
      * @param type Type
      * @param callback Callback
      */
-    off(type: T, callback: EventClassCallback<T, D>): void;
+    off<T extends keyof D>(
+        type: T,
+        callback: (event: EventBase<T, D[T]>) => void
+    ): void;
 
     /**
      * Remove specific type and callback event
      * @param type Type
      * @param callback Callback
      */
-    off(type: T, callback?: EventClassCallback<T, D>) {
+    off<T extends keyof D>(
+        type: T,
+        callback?: (event: EventBase<T, D[T]>) => void
+    ) {
         if (callback == null) {
             this.listeners.delete(type);
             return;
@@ -153,7 +149,9 @@ export abstract class EventClass<T extends string, D> {
      * Add event listeners
      * @param collection Collection of events
      */
-    on(collection: EventClassCollection<T, D>): void;
+    on(collection: {
+        [type in keyof D]: (event: EventBase<type, D[type]>) => void;
+    }): void;
 
     /**
      * Add event listener
@@ -161,9 +159,9 @@ export abstract class EventClass<T extends string, D> {
      * @param callback Callback
      * @param options Options
      */
-    on(
+    on<T extends keyof D>(
         type: T,
-        callback: EventClassCallback<T, D>,
+        callback: (event: EventBase<T, D[T]>) => void,
         options?: EventOptions
     ): void;
 
@@ -173,14 +171,18 @@ export abstract class EventClass<T extends string, D> {
      * @param callback Callback
      * @param options Options
      */
-    on(
-        type: EventClassCollection<T, D> | T,
-        callback?: EventClassCallback<T, D>,
+    on<T extends keyof D>(
+        type:
+            | {
+                  [type in keyof D]: (event: EventBase<type, D[type]>) => void;
+              }
+            | T,
+        callback?: (event: EventBase<T, D[T]>) => void,
         options?: EventOptions
     ) {
         if (typeof type === 'object') {
             for (const key in type) {
-                const item = key as T;
+                const item = key as keyof D;
                 const itemCallback = type[item] ?? callback;
                 if (itemCallback) this.on(item, itemCallback, options);
             }
@@ -189,14 +191,17 @@ export abstract class EventClass<T extends string, D> {
 
         if (callback == null) return;
         this.listeners.has(type) || this.listeners.set(type, []);
-        this.listeners.get(type)?.push([callback, options]);
+
+        // String to T conversion problem
+        // "keyofStringsOnly": true could solve part of it
+        this.listeners.get(type)?.push([callback as any, options]);
     }
 
     /**
      * Trigger event
      * @param event Event
      */
-    trigger(event: EventBase<T, D>) {
+    trigger<T extends keyof D>(event: EventBase<T, D[T]>) {
         const items = this.listeners.get(event.type);
         if (items == null) return;