@develia/commons 0.3.9 → 0.3.12

package/dist/types/timer.d.ts

@@ -0,0 +1,18 @@
+export default class Timer {
+    private _callback;
+    private _interval;
+    private _intervalId;
+    /**
+     * @param callback Callback
+     * @param interval Seconds between calls
+     */
+    constructor(callback: () => void, interval: number);
+    get running(): boolean;
+    get interval(): number;
+    set interval(value: number);
+    get callback(): () => void;
+    set callback(value: () => void);
+    start(): void;
+    stop(): void;
+    restart(): void;
+}

package/dist/types/timespan.d.ts

@@ -0,0 +1,46 @@
+export default class TimeSpan {
+    milliseconds: number;
+    private constructor();
+    seconds(): number;
+    minutes(): number;
+    hours(): number;
+    days(): number;
+    weeks(): number;
+    static fromMilliseconds(milliseconds: number): TimeSpan;
+    static fromSeconds(seconds: number): TimeSpan;
+    static fromMinutes(minutes: number): TimeSpan;
+    static fromHours(hours: number): TimeSpan;
+    static fromDays(days: number): TimeSpan;
+    static fromWeeks(weeks: number): TimeSpan;
+    addMilliseconds(milliseconds: number): TimeSpan;
+    addSeconds(seconds: number): TimeSpan;
+    addMinutes(minutes: number): TimeSpan;
+    addHours(hours: number): TimeSpan;
+    addDays(days: number): TimeSpan;
+    addWeeks(weeks: number): TimeSpan;
+    subtractMilliseconds(milliseconds: number): TimeSpan;
+    subtractSeconds(seconds: number): TimeSpan;
+    subtractMinutes(minutes: number): TimeSpan;
+    subtractHours(hours: number): TimeSpan;
+    subtractDays(days: number): TimeSpan;
+    subtractWeeks(weeks: number): TimeSpan;
+    add(other: TimeSpan): TimeSpan;
+    subtract(other: TimeSpan): TimeSpan;
+    addTo(date: Date): Date;
+    subtractFrom(date: Date): Date;
+    static fromDifference(earlierDate: Date, laterDate: Date): TimeSpan;
+    format(format?: string): string;
+    eq(other: TimeSpan): boolean;
+    le(other: TimeSpan): boolean;
+    lt(other: TimeSpan): boolean;
+    ge(other: TimeSpan): boolean;
+    gt(other: TimeSpan): boolean;
+    multiply(number: number): TimeSpan;
+    divide(number: number): TimeSpan;
+    abs(): TimeSpan;
+    static readonly INFINITE: TimeSpan;
+    static readonly NEGATIVE_INFINITE: TimeSpan;
+    isInfinite(): boolean;
+    isPositiveInfinite(): boolean;
+    isNegativeInfinite(): boolean;
+}

package/{src/types.ts → dist/types/types.d.ts}

@@ -1,14 +1,7 @@
-export type EqualityComparer<T> = (arg1: T, arg2: T) => boolean;
-
-export type UnaryFunction<T, R> = (arg: T) => R;
-
-export type Consumer<T> = (arg: T) => void
-
-export type Predicate<T> = (arg: T) => boolean;
-
-export type Provider<T> = () => T;
-
-export type Nullable<T> = T | null;
-
-export type Deferred<T> = Promise<T> | Provider<T>
-
+export type EqualityComparer<T> = (arg1: T, arg2: T) => boolean;
+export type UnaryFunction<T, R> = (arg: T) => R;
+export type Consumer<T> = (arg: T) => void;
+export type Predicate<T> = (arg: T) => boolean;
+export type Provider<T> = () => T;
+export type Nullable<T> = T | null;
+export type Deferred<T> = Promise<T> | Provider<T>;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@develia/commons",
-  "version": "0.3.9",
+  "version": "0.3.12",
   "author": {
     "name": "Antonio Gil Espinosa",
     "email": "antonio.gil.espinosa@gmail.com",
     "url": "https://antoniogilespinosa.com"
   },
-  "types": "dist/index.d.ts",
+  "types": "dist/types/index.d.ts",
   "main": "dist/index.cjs.js",
   "module": "dist/index.esm.js",
   "license": "proprietary",
@@ -15,11 +15,16 @@
     "@rollup/plugin-node-resolve": "^15.2.3",
     "@types/node": "^20.12.12",
     "rollup": "^2.79.1",
-    "rollup-plugin-terser": "^7.0.2",
-    "typescript": "^5.1.3",
-    "rollup-plugin-typescript2": "^0.36.0"
+    "typescript": "^5.1.3"
   },
   "scripts": {
-    "build": "rollup -c"
-  }
+    "build": "rollup -c",
+    "watch": "rollup -c -w"
+  },
+  "dependencies": {
+    "@rollup/plugin-typescript": "^11.1.6"
+  },
+  "files": [
+    "dist"
+  ]
 }

package/rollup.config.js

@@ -1,27 +0,0 @@
-// rollup.config.js
-import resolve from '@rollup/plugin-node-resolve';
-import commonjs from '@rollup/plugin-commonjs';
-import typescript from 'rollup-plugin-typescript2';
-
-export default {
-    input: 'src/index.ts',
-    output: [{
-        file: 'dist/index.cjs.js',
-        format: 'cjs'
-    }, {
-        file: 'dist/index.esm.js',
-        format: 'esm'
-    }/*, {
-        file: 'dist/index.umd.js',
-        format: 'umd',
-        sourcemap: true,
-        name: 'develia',
-    }*/],
-    plugins: [
-        resolve(),
-        commonjs(),
-        typescript({
-            tsconfig: "tsconfig.json"
-        })
-    ]
-};

package/src/cache-dictionary.ts

@@ -1,78 +0,0 @@
-export default class CacheDictionary<T> {
-    private readonly fallback: ((key: string) => T) | null;
-    private readonly cache: { [key: string]: T };
-    private readonly defaultDuration: number | null;
-    private readonly expiration: { [key: string]: Date | undefined };
-
-    constructor(fallback: ((key: string) => T) | null = null, defaultDuration: number | null = null) {
-        this.fallback = fallback;
-        this.cache = {};
-        this.defaultDuration = defaultDuration;
-        this.expiration = {};
-    }
-
-
-    public getExpiration(key: string): Date | undefined {
-        return this.expiration[key];
-    }
-
-    public setExpiration(key: string, expiration: Date | undefined): void {
-        this.expiration[key] = expiration;
-    }
-
-    public setDuration(key: string, duration: number | null): void {
-        if (duration === null) {
-            delete this.expiration[key];
-        } else {
-            const expiration = new Date();
-            expiration.setSeconds(expiration.getSeconds() + duration);
-            this.expiration[key] = expiration;
-        }
-    }
-
-    public get(key: string): T | null {
-        if (!this.cache.hasOwnProperty(key)) {
-            if (this.fallback) {
-                this.cache[key] = this.fallback(key);
-                this.expiration[key] = this.calculateExpiration(this.defaultDuration);
-            } else {
-                return null;
-            }
-        }
-
-        if (this.isExpired(key)) {
-            this.remove(key);
-            return null;
-        }
-
-        return this.cache[key];
-    }
-
-    public set(key: string, value: T, duration: number | null = null): void {
-        this.cache[key] = value;
-        this.expiration[key] = this.calculateExpiration(duration);
-    }
-
-    public remove(key: string): void {
-        delete this.cache[key];
-        delete this.expiration[key];
-    }
-
-    private isExpired(key: string): boolean {
-        const expiration = this.expiration[key];
-        if (expiration instanceof Date) {
-            return expiration < new Date();
-        }
-        return false;
-    }
-
-    private calculateExpiration(duration: number | null): Date | undefined {
-        if (duration === null) {
-            return undefined;
-        }
-
-        const expiration = new Date();
-        expiration.setSeconds(expiration.getSeconds() + duration);
-        return expiration;
-    }
-}