@zajno/common 1.3.8 → 1.3.9

package/src/dates/format.ts

@@ -1,5 +1,6 @@
 import * as MathX from '../math';
-import { decompose, decomposeDate, getDate, getDiscreteDiff, getTime } from './convert';
+import { decompose, decomposeDate, getDiscreteDiff } from './convert';
+import { getDate, getTime } from './parse';
 import { YearDate } from './yearDate';
 
 export namespace Format {

package/src/dates/parse.ts

@@ -1,4 +1,16 @@
 
+export function getTime(d: Date | number): number {
+    return d instanceof Date ? d.getTime() : d;
+}
+
+export function getDate(d: Date | number | string): Date {
+    if (!d) {
+        return null;
+    }
+
+    return new Date(d);
+}
+
 export namespace Parse {
     /** `YYYY-MM-DD` */
     export function fromDatePicker(str: string, local = false) {

package/src/dates/shift.ts

@@ -1,4 +1,4 @@
-import { getDate, getTime } from './convert';
+import { getDate, getTime } from './parse';
 import { DateX } from './datex';
 import { ConstantGranularity, Granularity } from './types';
 

package/src/dates/yearDate.ts

@@ -1,4 +1,4 @@
-import { getDate } from './convert';
+import { getDate } from './parse';
 
 /** Useful for recurring dates like birthday */
 export type YearDate = { day: number, month: number };

package/src/disposer.ts

@@ -0,0 +1,81 @@
+import logger from './logger';
+
+export interface IDisposable {
+    dispose(): void;
+}
+
+export interface DisposeFunction {
+    (): void;
+}
+
+export class Disposer {
+
+    private readonly _disposers: DisposeFunction[] = [];
+    private readonly _map = new Map<string, DisposeFunction>();
+
+    constructor(readonly logName: string = null) { }
+
+    add(d: DisposeFunction | IDisposable, id?: string) {
+        if (!d) {
+            return;
+        }
+
+        const dd: DisposeFunction = typeof d !== 'function'
+            ? (() => d.dispose ? d.dispose() : null)
+            : d;
+
+        this._disposers.push(dd);
+
+        if (id) {
+            // dispose previous identified disposer
+            if (this._map.has(id)) {
+                this.execute(id);
+            }
+
+            this._map.set(id, dd);
+        }
+    }
+
+    execute(id: string) {
+        const d = this._map.get(id);
+        if (!d) {
+            return;
+        }
+
+        this._map.delete(id);
+        const i = this._disposers.indexOf(d);
+        if (i >= 0) {
+            this._disposers.splice(i, 1);
+        }
+
+        d();
+    }
+
+    dispose(log = false) {
+        if (log) {
+            logger.log(
+                `[Disposer:${this.logName || '<unknown>'}] Disposing ${this._disposers.length} items including named ones:`,
+                Array.from(this._map.entries()).map(e => e[0]),
+            );
+        }
+
+        this._disposers.forEach(d => d());
+        this._disposers.length = 0;
+        this._map.clear();
+    }
+}
+
+export function combineDisposers(...items: DisposeFunction[]): DisposeFunction {
+    return () => items.forEach(i => i());
+}
+
+export class Disposable implements IDisposable {
+
+    protected readonly disposer = new Disposer();
+    protected _isDisposed = false;
+
+    public dispose = () => {
+        this._isDisposed = true;
+        this.disposer.dispose();
+    };
+}

package/src/transitionObserver.ts

@@ -1,7 +1,7 @@
 import { reaction } from 'mobx';
 import { IEvent, Event } from './event';
 import { ILogger, createLogger } from './logger';
-import { IDisposable } from './unsubscriber';
+import { IDisposable } from './disposer';
 
 export class TransitionObserver<T> implements IDisposable {
 

package/src/unsubscriber.ts

@@ -1,77 +1,11 @@
 import logger from './logger';
 
-export interface IDisposable {
-    dispose(): void;
-}
-
-export interface Disposer {
-    (): void;
-}
-
-export class Unsubscriber {
-
-    private readonly _disposers: Disposer[] = [];
-    private readonly _map = new Map<string, Disposer>();
-
-    constructor(readonly logName: string = null) { }
-
-    add(d: Disposer | IDisposable, id?: string) {
-        if (!d) {
-            return;
-        }
-
-        const dd: Disposer = typeof d !== 'function'
-            ? (() => d.dispose ? d.dispose() : null)
-            : d;
-
-        this._disposers.push(dd);
-
-        if (id) {
-            // dispose previous identified disposer
-            if (this._map.has(id)) {
-                this.execute(id);
-            }
-
-            this._map.set(id, dd);
-        }
-    }
-
-    execute(id: string) {
-        const d = this._map.get(id);
-        if (!d) {
-            return;
-        }
-
-        this._map.delete(id);
-        const i = this._disposers.indexOf(d);
-        if (i >= 0) {
-            this._disposers.splice(i, 1);
-        }
-
-        d();
-    }
-
-    dispose(log = false) {
-        if (log) {
-            logger.log(
-                `[Disposer:${this.logName || '<unknown>'}] Disposing ${this._disposers.length} items including named ones:`,
-                Array.from(this._map.entries()).map(e => e[0]),
-            );
-        }
-
-        this._disposers.forEach(d => d());
-        this._disposers.length = 0;
-        this._map.clear();
-    }
-}
-
-export function combineDisposers(...items: Disposer[]): Disposer {
-    return () => items.forEach(i => i());
-}
-
-export class Disposable implements IDisposable {
-
-    protected readonly disposer = new Unsubscriber();
-
-    public dispose = () => this.disposer.dispose();
-}
+export {
+    IDisposable,
+    DisposeFunction as Disposer,
+    combineDisposers,
+    Disposer as Unsubscriber,
+    Disposable,
+} from './disposer';
+
+logger.warn('@zajno/common: importing module "unsusbcriber" is deprecated; please change your import to "disposer" module.');