@etsoo/shared 1.2.52 → 1.2.55

package/src/types/EventClass.ts

@@ -4,55 +4,55 @@
  * D for data
  */
 export abstract class EventBase<T, D> {
-    private _propagationStopped: boolean = false;
-    /**
-     * stopImmediatePropagation called
-     */
-    get propagationStopped() {
-        return this._propagationStopped;
-    }
-
-    private _timeStamp: number;
-    /**
-     * Time stamp
-     */
-    get timeStamp() {
-        return this._timeStamp;
-    }
-
-    /**
-     * Constructor
-     * @param type Type
-     */
-    constructor(
-        public readonly target: {},
-        public readonly type: T,
-        public readonly data: D
-    ) {
-        this._timeStamp = Date.now();
-    }
-
-    /**
-     * Prevent all other listeners from being called
-     */
-    stopImmediatePropagation() {
-        this._propagationStopped = true;
-    }
+  private _propagationStopped: boolean = false;
+  /**
+   * stopImmediatePropagation called
+   */
+  get propagationStopped() {
+    return this._propagationStopped;
+  }
+
+  private _timeStamp: number;
+  /**
+   * Time stamp
+   */
+  get timeStamp() {
+    return this._timeStamp;
+  }
+
+  /**
+   * Constructor
+   * @param type Type
+   */
+  constructor(
+    public readonly target: {},
+    public readonly type: T,
+    public readonly data: D
+  ) {
+    this._timeStamp = Date.now();
+  }
+
+  /**
+   * Prevent all other listeners from being called
+   */
+  stopImmediatePropagation() {
+    this._propagationStopped = true;
+  }
 }
 
 /**
  * Event options
  */
 interface EventOptions {
-    /**
-     * A boolean value indicating that events of this type will be dispatched first
-     */
-    capture?: boolean;
-
-    /**
-     * A boolean value indicating that the listener should be invoked at most once after being added
-     */
-    once?: boolean;
+  /**
+   * A boolean value indicating that events of this type will be dispatched first
+   */
+  capture?: boolean;
+
+  /**
+   * A boolean value indicating that the listener should be invoked at most once after being added
+   */
+  once?: boolean;
 }
 
 type EventClassDef = { [key: string]: object };
@@ -63,196 +63,196 @@ type EventClassDef = { [key: string]: object };
  * D for data
  */
 export abstract class EventClass<D extends EventClassDef> {
-    // Listeners
-    private readonly listeners = new Map<
-        keyof D,
-        [(event: EventBase<keyof D, D[keyof D]>) => void, EventOptions?][]
-    >();
-
-    /**
-     * Has specific type events
-     * @param type Type
-     */
-    hasEvents<T extends keyof D>(type: T): boolean;
-
-    /**
-     * Has specific type and callback events
-     * @param type Type
-     * @param callback Callback
-     */
-    hasEvents<T extends keyof D>(
-        type: T,
-        callback: (event: EventBase<T, D[T]>) => void
-    ): boolean;
-
-    /**
-     * Has specific type and callback events
-     * @param type Type
-     * @param callback Callback
-     * @returns Result
-     */
-    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;
-
-        if (callback) {
-            return items.some((item) => item[0] == callback);
-        }
-
-        return true;
+  // Listeners
+  private readonly listeners = new Map<
+    keyof D,
+    [(event: EventBase<keyof D, D[keyof D]>) => void, EventOptions?][]
+  >();
+
+  /**
+   * Has specific type events
+   * @param type Type
+   */
+  hasEvents<T extends keyof D>(type: T): boolean;
+
+  /**
+   * Has specific type and callback events
+   * @param type Type
+   * @param callback Callback
+   */
+  hasEvents<T extends keyof D>(
+    type: T,
+    callback: (event: EventBase<T, D[T]>) => void
+  ): boolean;
+
+  /**
+   * Has specific type and callback events
+   * @param type Type
+   * @param callback Callback
+   * @returns Result
+   */
+  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;
+
+    if (callback) {
+      return items.some((item) => item[0] == callback);
     }
 
-    /**
-     * Remove all specific type events
-     * @param type Type
-     */
-    off<T extends keyof D>(type: T): void;
-
-    /**
-     * Remove specific type and callback event
-     * @param type Type
-     * @param callback Callback
-     */
-    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<T extends keyof D>(
-        type: T,
-        callback?: (event: EventBase<T, D[T]>) => void
-    ) {
-        if (callback == null) {
-            this.listeners.delete(type);
-            return;
-        }
-
-        const items = this.listeners.get(type);
-        if (items == null) return;
-
-        for (let i = items.length - 1; i >= 0; i--) {
-            if (items[i][0] == callback) {
-                items.splice(i, 1);
-            }
-        }
+    return true;
+  }
+
+  /**
+   * Remove all specific type events
+   * @param type Type
+   */
+  off<T extends keyof D>(type: T): void;
+
+  /**
+   * Remove specific type and callback event
+   * @param type Type
+   * @param callback Callback
+   */
+  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<T extends keyof D>(
+    type: T,
+    callback?: (event: EventBase<T, D[T]>) => void
+  ) {
+    if (callback == null) {
+      this.listeners.delete(type);
+      return;
     }
 
-    /**
-     * Add event listeners
-     * @param collection Collection of events
-     */
-    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<T extends keyof D>(
-        type: T,
-        callback: (event: EventBase<T, D[T]>) => void,
-        options?: EventOptions
-    ): void;
-
-    /**
-     * Add events
-     * @param type Type
-     * @param callback Callback
-     * @param options Options
-     */
-    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 keyof D;
-                const itemCallback = type[item] ?? callback;
-                if (itemCallback) this.on(item, itemCallback, options);
-            }
-            return;
-        }
-
-        if (callback == null) return;
-        this.listeners.has(type) || this.listeners.set(type, []);
+    const items = this.listeners.get(type);
+    if (items == null) return;
 
-        // String to T conversion problem
-        // "keyofStringsOnly": true could solve part of it
-        this.listeners.get(type)?.push([callback as any, options]);
+    for (let i = items.length - 1; i >= 0; i--) {
+      if (items[i][0] == callback) {
+        items.splice(i, 1);
+      }
     }
-
-    /**
-     * Trigger event
-     * @param event Event
-     */
-    trigger<T extends keyof D>(event: EventBase<T, D[T]>) {
-        const items = this.listeners.get(event.type);
-        if (items == null) return;
-
-        // Len
-        const len = items.length;
-        if (len === 0) return;
-
-        // Need to be removed indicies
-        const indicies: number[] = [];
-
-        // Capture items first
-        let stopped: boolean = false;
-        for (let c = 0; c < len; c++) {
-            const item = items[c];
-            const [callback, options] = item;
-            if (options == null || !options.capture) continue;
-
-            callback(event);
-
-            if (options.once) {
-                indicies.push(c);
-            }
-
-            if (event.propagationStopped) {
-                stopped = true;
-                break;
-            }
+  }
+
+  /**
+   * Add event listeners
+   * @param collection Collection of events
+   */
+  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<T extends keyof D>(
+    type: T,
+    callback: (event: EventBase<T, D[T]>) => void,
+    options?: EventOptions
+  ): void;
+
+  /**
+   * Add events
+   * @param type Type
+   * @param callback Callback
+   * @param options Options
+   */
+  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 keyof D;
+        const itemCallback = type[item] ?? callback;
+        if (itemCallback) this.on(item, itemCallback, options);
+      }
+      return;
+    }
 
-        if (!stopped) {
-            for (let c = 0; c < len; c++) {
-                const item = items[c];
-                const [callback, options] = item;
-                if (options?.capture) continue;
+    if (callback == null) return;
+    this.listeners.has(type) || this.listeners.set(type, []);
+
+    // 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<T extends keyof D>(event: EventBase<T, D[T]>) {
+    const items = this.listeners.get(event.type);
+    if (items == null) return;
+
+    // Len
+    const len = items.length;
+    if (len === 0) return;
+
+    // Need to be removed indicies
+    const indicies: number[] = [];
+
+    // Capture items first
+    let stopped: boolean = false;
+    for (let c = 0; c < len; c++) {
+      const item = items[c];
+      const [callback, options] = item;
+      if (options == null || !options.capture) continue;
+
+      callback(event);
+
+      if (options.once) {
+        indicies.push(c);
+      }
+
+      if (event.propagationStopped) {
+        stopped = true;
+        break;
+      }
+    }
 
-                callback(event);
+    if (!stopped) {
+      for (let c = 0; c < len; c++) {
+        const item = items[c];
+        const [callback, options] = item;
+        if (options?.capture) continue;
 
-                if (options?.once) {
-                    indicies.push(c);
-                }
+        callback(event);
 
-                if (event.propagationStopped) {
-                    stopped = true;
-                    break;
-                }
-            }
+        if (options?.once) {
+          indicies.push(c);
         }
 
-        // Remove all once handlers
-        for (let i = indicies.length - 1; i >= 0; i--) {
-            items.splice(indicies[i], 1);
+        if (event.propagationStopped) {
+          stopped = true;
+          break;
         }
+      }
+    }
+
+    // Remove all once handlers
+    for (let i = indicies.length - 1; i >= 0; i--) {
+      items.splice(indicies[i], 1);
     }
+  }
 }

package/src/types/FormData.ts

@@ -2,25 +2,25 @@
  * File like interface
  */
 export interface IFile {
-    /**
-     * Name of the file
-     */
-    readonly name: string;
+  /**
+   * Name of the file
+   */
+  readonly name: string;
 
-    /**
-     * Size of the file in bytes
-     */
-    readonly size: number;
+  /**
+   * Size of the file in bytes
+   */
+  readonly size: number;
 
-    /**
-     * MIME type
-     */
-    readonly type: string;
+  /**
+   * MIME type
+   */
+  readonly type: string;
 
-    /**
-     * Last modified time of the file, in millisecond since the UNIX epoch
-     */
-    readonly lastModified: number;
+  /**
+   * Last modified time of the file, in millisecond since the UNIX epoch
+   */
+  readonly lastModified: number;
 }
 
 /**
@@ -33,13 +33,13 @@ export type FormDataFieldValue = string | IFile;
  * https://developer.mozilla.org/en-US/docs/Web/API/FormData
  */
 export interface IFormData {
-    append(name: string, value: unknown, filename?: string): void;
-    delete(name: string): void;
-    entries(): IterableIterator<[string, FormDataEntryValue]>;
-    set(name: string, value: unknown, filename?: string): void;
-    get(name: string): FormDataFieldValue | null;
-    getAll(name: string): FormDataFieldValue[];
-    has(name: string): boolean;
-    keys(): IterableIterator<string>;
-    values(): IterableIterator<FormDataEntryValue>;
+  append(name: string, value: unknown, filename?: string): void;
+  delete(name: string): void;
+  entries(): IterableIterator<[string, FormDataEntryValue]>;
+  set(name: string, value: unknown, filename?: string): void;
+  get(name: string): FormDataFieldValue | null;
+  getAll(name: string): FormDataFieldValue[];
+  has(name: string): boolean;
+  keys(): IterableIterator<string>;
+  values(): IterableIterator<FormDataEntryValue>;
 }

package/src/types/ParsedPath.ts

@@ -2,9 +2,9 @@
  * Similar result with node.js path.parse(path)
  */
 export type ParsedPath = {
-    root: string;
-    dir: string;
-    base: string;
-    ext: string;
-    name: string;
+  root: string;
+  dir: string;
+  base: string;
+  ext: string;
+  name: string;
 };

package/tsconfig.cjs.json

@@ -1,18 +1,18 @@
 {
-    "compilerOptions": {
-        /* Visit https://aka.ms/tsconfig.json to read more about this file */
-        "target": "ES2020",
-        "module": "NodeNext",
-        "moduleResolution": "NodeNext",
-        "isolatedModules": true,
-        "outDir": "./lib/cjs",
-        "noEmit": false,
-        "declaration": true,
-        "strict": true,
-        "esModuleInterop": true,
-        "skipLibCheck": true,
-        "forceConsistentCasingInFileNames": true,
-        "lib": ["dom", "dom.iterable", "ESNext"]
-    },
-    "include": ["src"]
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+    "target": "ES2020",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "isolatedModules": true,
+    "outDir": "./lib/cjs",
+    "noEmit": false,
+    "declaration": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "lib": ["dom", "dom.iterable", "ESNext"]
+  },
+  "include": ["src"]
 }

package/tsconfig.json

@@ -1,18 +1,18 @@
 {
-    "compilerOptions": {
-        /* Visit https://aka.ms/tsconfig.json to read more about this file */
-        "target": "ES2020",
-        "module": "ESNext",
-        "moduleResolution": "Node10",
-        "isolatedModules": true,
-        "outDir": "./lib/mjs",
-        "noEmit": false,
-        "declaration": true,
-        "strict": true,
-        "esModuleInterop": true,
-        "skipLibCheck": true,
-        "forceConsistentCasingInFileNames": true,
-        "lib": ["dom", "dom.iterable", "esnext"]
-    },
-    "include": ["src"]
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "Node10",
+    "isolatedModules": true,
+    "outDir": "./lib/mjs",
+    "noEmit": false,
+    "declaration": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "lib": ["dom", "dom.iterable", "esnext"]
+  },
+  "include": ["src"]
 }

package/.eslintignore

@@ -1,3 +0,0 @@
-.github
-node_modules
-lib/

package/.eslintrc.json

@@ -1,29 +0,0 @@
-{
-    "env": {
-        "browser": true,
-        "node": true,
-        "es6": true,
-        "jest": true
-    },
-    "extends": ["airbnb-base", "prettier"],
-    "parser": "@typescript-eslint/parser",
-    "parserOptions": {
-        "ecmaVersion": 6,
-        "sourceType": "module"
-    },
-    "plugins": ["@typescript-eslint"],
-    "rules": {
-        "class-methods-use-this": "off",
-        "import/extensions": ["error", "never"],
-        "import/prefer-default-export": "off",
-        "@typescript-eslint/no-unused-vars": ["error"]
-    },
-    "settings": {
-        "import/resolver": {
-            "node": {
-                "paths": ["src"],
-                "extensions": [".ts"]
-            }
-        }
-    }
-}

package/.prettierignore

@@ -1,5 +0,0 @@
-.github
-node_modules
-lib/
-package-lock.json
-README.md

package/.prettierrc

@@ -1,6 +0,0 @@
-{
-    "trailingComma": "none",
-    "tabWidth": 4,
-    "semi": true,
-    "singleQuote": true
-}