@develia/commons 0.3.7 → 0.3.9

package/dist/index.cjs.js

@@ -1002,4 +1002,3 @@ exports.lerp = lerp;
 exports.objectToFormData = objectToFormData;
 exports.promisify = promisify;
 exports.toPairs = toPairs;
-//# sourceMappingURL=index.cjs.js.map

package/dist/index.esm.js

@@ -968,4 +968,3 @@ class Lazy {
 }
 
 export { CacheDictionary, From, Lazy, Pair, TimeSpan, Timer, ajaxSubmission, ajaxSubmit, clamp, deepClone, ensurePrefix, ensureSuffix, from, isArray, isBigInt, isBoolean, isEmpty, isEmptyOrWhitespace, isFunction, isIterable, isNull, isNullOrUndefined, isNumber, isObject, isString, isSymbol, isUndefined, lerp, objectToFormData, promisify, toPairs };
-//# sourceMappingURL=index.esm.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@develia/commons",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "author": {
     "name": "Antonio Gil Espinosa",
     "email": "antonio.gil.espinosa@gmail.com",

package/rollup.config.js

@@ -7,12 +7,10 @@ export default {
     input: 'src/index.ts',
     output: [{
         file: 'dist/index.cjs.js',
-        format: 'cjs',
-        sourcemap: true
+        format: 'cjs'
     }, {
         file: 'dist/index.esm.js',
-        format: 'esm',
-        sourcemap: true
+        format: 'esm'
     }/*, {
         file: 'dist/index.umd.js',
         format: 'umd',
@@ -23,9 +21,7 @@ export default {
         resolve(),
         commonjs(),
         typescript({
-            tsconfig: "tsconfig.json", // Asegúrate de que el tsconfig esté correctamente configurado
-            sourceMap: true,
-            inlineSources: true
+            tsconfig: "tsconfig.json"
         })
     ]
 };

package/tsconfig.json

@@ -1,10 +1,13 @@
 {
   "compilerOptions": {
+    //"sourceMap": true,
     "module": "ESNext",
     "target": "ESNext",
-    "strict": true,
-    "declaration": true,
-    "sourceRoot": "./src/"
+    "strict": true
+    /*"declaration": true,
+    "declarationMap": true,*/
+    /*"outDir": "./dist",
+    "rootDir": "./src"*/
   },
   "exclude": [
     "node_modules",

package/dist/cache-dictionary.d.ts

@@ -1,15 +0,0 @@
-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/dist/from.d.ts

@@ -1,53 +0,0 @@
-import { Consumer, EqualityComparer, UnaryFunction, Predicate, Provider } from "./types";
-import Pair from "./pair";
-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: UnaryFunction<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: UnaryFunction<T, Iterable<R>>): From<R>;
-    flatten(): From<any>;
-    sum(mapper?: UnaryFunction<T, number>): number;
-    avg(mapper?: UnaryFunction<T, number>): number;
-    max(mapper: UnaryFunction<T, number>): number;
-    min(mapper: UnaryFunction<T, number>): number;
-    maxBy(mapper: UnaryFunction<T, number>): T | undefined;
-    minBy(mapper: UnaryFunction<T, number>): T | undefined;
-    orderBy<R>(mapper: UnaryFunction<T, R>): From<T>;
-    groupBy<TKey>(keySelector: UnaryFunction<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: UnaryFunction<T, R>, otherKeySelector: UnaryFunction<T2, R>, resultSelector: (thisItem: T, otherItem: T2) => R2): From<R2>;
-    leftJoin<U, K, R>(other: Iterable<U>, thisKeySelector: UnaryFunction<T, K>, otherKeySelector: UnaryFunction<U, K>, resultSelector: (thisItem: T, otherItem: U | undefined) => R): From<R>;
-    leftGroupJoin<U, K, R>(other: Iterable<U>, thisKeySelector: UnaryFunction<T, K>, otherKeySelector: UnaryFunction<U, K>, resultSelector: (thisItem: T, otherItems: Array<U>) => R): From<R>;
-    rightGroupJoin<U, K, R>(other: Iterable<U>, thisKeySelector: UnaryFunction<T, K>, otherKeySelector: UnaryFunction<U, K>, resultSelector: (thisItems: Array<T>, otherItem: U) => R): From<R>;
-    rightJoin<U, K, R>(other: Iterable<U>, thisKeySelector: UnaryFunction<T, K>, otherKeySelector: UnaryFunction<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/dist/functions.d.ts

@@ -1,45 +0,0 @@
-import Pair from "./pair";
-import { Nullable, Provider } from "./types";
-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>;
-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?: Nullable<Provider<Nullable<any>>>, onFailure?: Nullable<Provider<Nullable<any>>>): void;
-export declare function deepClone<T>(obj: T): T;
-export declare function objectToFormData(data: Record<string, any>): FormData;

package/dist/index.cjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.d.ts

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

package/dist/index.esm.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/lazy.d.ts

@@ -1,12 +0,0 @@
-import { Nullable } from "./types";
-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/dist/pair.d.ts

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

package/dist/timer.d.ts

@@ -1,18 +0,0 @@
-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/timespan.d.ts

@@ -1,46 +0,0 @@
-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/dist/types.d.ts

@@ -1,7 +0,0 @@
-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>;