@develia/commons 0.2.24 → 0.2.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@develia/commons",
-  "version": "0.2.24",
+  "version": "0.2.25",
   "author": {
     "name": "Antonio Gil Espinosa",
     "email": "antonio.gil.espinosa@gmail.com",
@@ -8,7 +8,7 @@
   },
   "type": "module",
   "main": "src/index.js",
-  "types": "src/index.ts",
+  "types": "src/index.d.ts",
   "license": "proprietary",
   "dependencies": {
   },

package/src/cache-dictionary.d.ts

@@ -0,0 +1,15 @@
+export default class CacheDictionary<T> {
+    private readonly fallback;
+    private readonly cache;
+    private readonly defaultDuration;
+    private readonly expiration;
+    constructor(fallback?: ((key: string) => T) | null, defaultDuration?: number | null);
+    getExpiration(key: string): Date | undefined;
+    setExpiration(key: string, expiration: Date | undefined): void;
+    setDuration(key: string, duration: number | null): void;
+    get(key: string): T | null;
+    set(key: string, value: T, duration?: number | null): void;
+    remove(key: string): void;
+    private isExpired;
+    private calculateExpiration;
+}

package/src/from.d.ts

@@ -0,0 +1,53 @@
+import { Consumer, EqualityComparer, Mapper, Predicate, Provider } from "./types.js";
+import Pair from "./pair.js";
+export default function from<T>(source: Iterable<T> | Provider<Iterable<T>>): From<T> | From<Pair<any, any>>;
+export declare class From<T> implements Iterable<T> {
+    static object(obj: any): From<Pair<any, any>>;
+    private static _shallowEqual;
+    private readonly _fn;
+    protected constructor(fn: Provider<Iterable<T>>);
+    static fn<T>(callable: Provider<Iterable<T>>): From<T>;
+    collect(): From<T>;
+    static iterable<T>(iterable: Iterable<T>): From<T>;
+    map<R>(mapper: Mapper<T, R>): From<R>;
+    [Symbol.iterator](): Iterator<T>;
+    all(predicate: Predicate<T>): boolean;
+    any(predicate: Predicate<T>): boolean;
+    filter(predicate: Predicate<T>): From<T>;
+    contains(value: T): boolean;
+    first(predicate?: Predicate<T>): T | undefined;
+    append(item: T): From<T>;
+    prepend(item: T): From<T>;
+    at(index: number): T | undefined;
+    last(predicate?: Predicate<T>): T | undefined;
+    mapMany<R>(mapper: Mapper<T, Iterable<R>>): From<R>;
+    flatten(): From<any>;
+    sum(mapper?: Mapper<T, number>): number;
+    avg(mapper?: Mapper<T, number>): number;
+    max(mapper: Mapper<T, number>): number;
+    min(mapper: Mapper<T, number>): number;
+    maxBy(mapper: Mapper<T, number>): T | undefined;
+    minBy(mapper: Mapper<T, number>): T | undefined;
+    orderBy<R>(mapper: Mapper<T, R>): From<T>;
+    groupBy<TKey>(keySelector: Mapper<T, TKey>, equalityComparer?: EqualityComparer<TKey>): From<Grouping<TKey, T>>;
+    head(n: number): From<T>;
+    tail(n: number): From<T>;
+    forEach(action: Consumer<T>): void;
+    toArray(): T[];
+    instancesOf(type: string): From<T>;
+    allInstanceOf(type: new (...args: any[]) => any): boolean;
+    distinct(eq_comparer?: EqualityComparer<T>): From<T>;
+    insert(item: T, index: number): From<T>;
+    skip(n: number): From<T>;
+    union(other: Iterable<T>): From<T>;
+    innerJoin<T2, R, R2>(other: Iterable<T2>, thisKeySelector: Mapper<T, R>, otherKeySelector: Mapper<T2, R>, resultSelector: (thisItem: T, otherItem: T2) => R2): From<R2>;
+    leftJoin<U, K, R>(other: Iterable<U>, thisKeySelector: Mapper<T, K>, otherKeySelector: Mapper<U, K>, resultSelector: (thisItem: T, otherItem: U | undefined) => R): From<R>;
+    leftGroupJoin<U, K, R>(other: Iterable<U>, thisKeySelector: Mapper<T, K>, otherKeySelector: Mapper<U, K>, resultSelector: (thisItem: T, otherItems: Array<U>) => R): From<R>;
+    rightGroupJoin<U, K, R>(other: Iterable<U>, thisKeySelector: Mapper<T, K>, otherKeySelector: Mapper<U, K>, resultSelector: (thisItems: Array<T>, otherItem: U) => R): From<R>;
+    rightJoin<U, K, R>(other: Iterable<U>, thisKeySelector: Mapper<T, K>, otherKeySelector: Mapper<U, K>, resultSelector: (thisItem: T | undefined, otherItem: U) => R): From<R>;
+}
+export declare class Grouping<TKey, T> extends From<T> {
+    private readonly _key;
+    get key(): TKey;
+    constructor(key: TKey, values: Array<T>);
+}

package/src/functions.d.ts

@@ -0,0 +1,44 @@
+import Pair from "./pair.js";
+export declare function isIterable(obj: any): boolean;
+export declare function clamp(n: number, min: number, max: number): number;
+/**
+ * Linearly remaps a value from its source range [`inMin`, `inMax`] to the destination range [`outMin`, `outMax`]
+ *
+ * @category Math
+ * @example
+ * ```
+ * const value = remap(0.5, 0, 1, 200, 400) // value will be 300
+ * ```
+ */
+export declare function lerp(n: number, inMin: number, inMax: number, outMin: number, outMax: number): number;
+/**
+ * Ensure prefix of a string
+ *
+ * @category String
+ */
+export declare function ensurePrefix(prefix: string, str: string): string;
+/**
+ * Ensure suffix of a string
+ *
+ * @category String
+ */
+export declare function ensureSuffix(suffix: string, str: string): string;
+export declare function isString(value: any): value is string;
+export declare function isNumber(value: any): value is number;
+export declare function isBoolean(value: any): value is boolean;
+export declare function isObject(value: any): value is object;
+export declare function isArray(value: any): value is any[];
+export declare function isFunction(value: any): value is Function;
+export declare function isUndefined(value: any): value is undefined;
+export declare function isNull(value: any): value is null;
+export declare function isBigInt(value: any): value is bigint;
+export declare function isSymbol(value: any): value is symbol;
+export declare function isNullOrUndefined(value: any): boolean;
+export declare function isEmpty(value: any): boolean;
+export declare function isEmptyOrWhitespace(value: any): boolean;
+export declare function ajaxSubmit(selectorOrElement: HTMLFormElement | string): Promise<Response> | undefined;
+export declare function toPairs(obj: any): Pair<any, any>[];
+export declare function promisify<T>(thing: any): Promise<T>;
+export declare function ajaxSubmission(selectorOrElement: HTMLFormElement | string, onSuccess?: null, onFailure?: null): void;
+export declare function deepClone<T>(obj: T): T;
+export declare function objectToFormData(data: Record<string, any>): FormData;

package/src/index.d.ts

@@ -0,0 +1,8 @@
+export * from './functions.js';
+export { default as CacheDictionary } from './cache-dictionary.js';
+export { default as from, From } from './from.js';
+export * from './types.js';
+export { default as Timer } from './timer.js';
+export { default as TimeSpan } from './timespan.js';
+export { default as Lazy } from './lazy.js';
+export { default as Pair } from './pair.js';

package/src/lazy.d.ts

@@ -0,0 +1,12 @@
+import { Nullable } from "./types.js";
+type FactoryMethod<T> = Promise<Nullable<T>> | (() => (Promise<Nullable<T>> | Nullable<T>));
+export default class Lazy<T> {
+    private _valueCreated;
+    private _value;
+    private readonly _factoryMethod;
+    constructor(getter: FactoryMethod<T>);
+    get valueCreated(): boolean;
+    getValue(): Promise<Nullable<T>>;
+    reset(): void;
+}
+export {};

package/src/pair.d.ts

@@ -0,0 +1,7 @@
+export default class Pair<TKey, TValue> {
+    get value(): TValue;
+    get key(): TKey;
+    private readonly _key;
+    private readonly _value;
+    constructor(key: TKey, value: TValue);
+}

package/src/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/src/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.d.ts

@@ -0,0 +1,7 @@
+export type EqualityComparer<T> = (arg1: T, arg2: T) => boolean;
+export type Consumer<T> = (arg: T) => void;
+export type Mapper<T, R> = (arg: T) => R;
+export type Predicate<T> = (arg: T) => boolean;
+export type Provider<T> = () => T;
+export type Nullable<T> = T | null;
+export type Deferred<T> = Promise<T> | ((...args: any[]) => T);

package/tsconfig.json

@@ -4,7 +4,8 @@
     "target": "ES2017",
     "sourceMap": true,
     "strict": true,
-    "esModuleInterop": true
+    "esModuleInterop": true,
+    "declaration": true
   },
   "exclude": [
     "node_modules"