atomic-fns 0.3.5 → 0.4.2

package/{core → dist}/functools/index.d.ts

@@ -12,7 +12,7 @@ import { Function } from '../globals/index.js';
  * @returns {Function} Returns the new bound function.
  * @see {@link partial}
  */
-export declare const bind: (fn: Function, thisArg: any, ...partials: any[]) => (...args: any[]) => any;
+export declare const bind: (fn: Function, thisArg: any, ...partials: any[]) => any;
 /**
  * Creates a function that accepts arguments of `func` and either invokes `func` returning its result, if at least arity number of arguments have been provided, or returns a function that accepts the remaining `func` arguments, and so on. The arity of `func` may be specified if `func.length` is not sufficient.
  * @param {Function} func The function to curry.
@@ -27,7 +27,7 @@ export declare const curry: (func: Function, arity?: number) => Function<any>;
  * @param {...*} [args] The arguments to apply to `fn`.
  * @returns {Function} Returns the new partially applied function
  */
-export declare const partial: (fn: any, ...args: any[]) => (...args: any[]) => any;
+export declare const partial: (fn: any, ...args: any[]) => any;
 /**
  * Creates a function composition from a given set of functions that will be each applied on the result of the previous one from left to right.
  * @param {...*} [args] The set of functions to apply.
@@ -48,6 +48,14 @@ export declare const compose: (...args: any[]) => (x: any) => any;
  * @return {Function} Returns the new memoized function.
  */
 export declare function memoize<T>(func: Function<T>, resolver?: Function): Function<ReturnType<typeof func>>;
+/**
+ * Can be used as a decorator on any function or method to memoize its results.
+ * **NOTE:** By default the given function is memoized using it's first argument, regardless of others.
+ * @param target
+ * @param name
+ * @param descriptor
+ * @returns A memoized version of the given function
+ */
 export declare function cache(target: any, name: any, descriptor: any): any;
 /**
  * Creates a debounced function that delays invoking `func` until after `wait` milliseconds have elapsed since the last time the debounced function was invoked. Subsequent calls to the debounced function return the result of the last successful invocation. Provide options to set the `maxWait` milliseconds, regardless of when the function was last invoked.
@@ -77,11 +85,11 @@ export declare function throttle(func: Function, wait: number): Function;
 ```js
 let func = x => x
 let single = once(func)
-single(1) // => 1
-single(2) // => 1
-single(3) // => 1
+single(1) // 1
+single(2) // 1
+single(3) // 1
 // ...
-// => `func` is invoked only once.
+// `func` is invoked only once.
 ```
  */
 export declare function once<T>(func: Function<T>): (...args: any[]) => T;
@@ -90,19 +98,25 @@ export declare type Result<T, E = any> = [Maybe<T>, Maybe<E>];
 export declare type Optional<T> = Maybe<T>;
 /**
  * Wraps a function to catch any exceptions inside and return a `go` style error-return type {@link Result}.
- *
+ * @template T,E
  * @param {Function} fun The function to wrap and catch if it throws.
- * @param {?function(err: E, res: T): *} [onFinally] Optional callback that will be called on the `finally` clause if given.
+ * @param {Function} [onFinally] Optional callback that will be invoked with `(err?, value)` on the `finally` clause.
  * @returns {Function} A new function that wraps `fun`.
- * @template T,E
  */
 export declare function result<T = any, E = unknown>(fun: Function<T>, onFinally?: (err: E, res: T) => any): (...args: any[]) => Result<T, E>;
 /**
  * Wraps a function or promise to catch any exceptions inside and return a `go` style error-return type. This is like {@link result} but it deals with async functions or promises.
- *
- * @param {Function|Promise} awaitable The function or promise to await.
- * @param {?function(err: E, res: T): *} [onFinally] Optional callback that will be called on the `finally` clause if given.
- * @returns {Function} A new function that awaits the `awaitable` param and returns a {@link Result} type.
  * @template T,E
+ * @param {Function<T>|Promise<T>} awaitable The function or promise to await.
+ * @param {Function} [onFinally] Optional callback that will be invoked with `(err?, value)` on the `finally` clause.
+ * @returns {Function<Promise<Result<T, E>>>} A new function that awaits the `awaitable` param and returns a {@link Result} type.
  */
 export declare function resultAsync<T = any, E = unknown>(awaitable: Promise<T> | Function<Promise<T>>, onFinally?: (err: E, res: T) => any): (...args: any[]) => Promise<Result<T, E>>;
+/**
+ * Converts a function that expects a node-style callback argument like `(err, result)` to return a Promise instead.
+ * @template T
+ * @param {Function<T>} fun The given function to convert from callback style to Promise.
+ * @param {*} thisArg
+ * @returns {Function<Promise<T>>} A function that wraps `fun` and returns a Promise.
+ */
+export declare function promisify<T = any>(fun: Function<T>, thisArg: any): (...args: any[]) => Promise<T>;

package/{core → dist}/functools/index.js

@@ -89,7 +89,14 @@ export function memoize(func, resolver) {
         return value;
     };
 }
-// TODO: also sized lru_cache
+/**
+ * Can be used as a decorator on any function or method to memoize its results.
+ * **NOTE:** By default the given function is memoized using it's first argument, regardless of others.
+ * @param target
+ * @param name
+ * @param descriptor
+ * @returns A memoized version of the given function
+ */
 export function cache(target, name, descriptor) {
     const original = descriptor.value;
     if (typeof original === 'function') {
@@ -153,11 +160,11 @@ export function throttle(func, wait) {
 ```js
 let func = x => x
 let single = once(func)
-single(1) // => 1
-single(2) // => 1
-single(3) // => 1
+single(1) // 1
+single(2) // 1
+single(3) // 1
 // ...
-// => `func` is invoked only once.
+// `func` is invoked only once.
 ```
  */
 export function once(func) {
@@ -172,11 +179,10 @@ export function once(func) {
 }
 /**
  * Wraps a function to catch any exceptions inside and return a `go` style error-return type {@link Result}.
- *
+ * @template T,E
  * @param {Function} fun The function to wrap and catch if it throws.
- * @param {?function(err: E, res: T): *} [onFinally] Optional callback that will be called on the `finally` clause if given.
+ * @param {Function} [onFinally] Optional callback that will be invoked with `(err?, value)` on the `finally` clause.
  * @returns {Function} A new function that wraps `fun`.
- * @template T,E
  */
 export function result(fun, onFinally) {
     return (...args) => {
@@ -195,11 +201,10 @@ export function result(fun, onFinally) {
 }
 /**
  * Wraps a function or promise to catch any exceptions inside and return a `go` style error-return type. This is like {@link result} but it deals with async functions or promises.
- *
- * @param {Function|Promise} awaitable The function or promise to await.
- * @param {?function(err: E, res: T): *} [onFinally] Optional callback that will be called on the `finally` clause if given.
- * @returns {Function} A new function that awaits the `awaitable` param and returns a {@link Result} type.
  * @template T,E
+ * @param {Function<T>|Promise<T>} awaitable The function or promise to await.
+ * @param {Function} [onFinally] Optional callback that will be invoked with `(err?, value)` on the `finally` clause.
+ * @returns {Function<Promise<Result<T, E>>>} A new function that awaits the `awaitable` param and returns a {@link Result} type.
  */
 export function resultAsync(awaitable, onFinally) {
     return async (...args) => {
@@ -217,3 +222,20 @@ export function resultAsync(awaitable, onFinally) {
         return [value, err];
     };
 }
+/**
+ * Converts a function that expects a node-style callback argument like `(err, result)` to return a Promise instead.
+ * @template T
+ * @param {Function<T>} fun The given function to convert from callback style to Promise.
+ * @param {*} thisArg
+ * @returns {Function<Promise<T>>} A function that wraps `fun` and returns a Promise.
+ */
+export function promisify(fun, thisArg) {
+    const original = fun.bind(thisArg);
+    return async (...args) => {
+        return await new Promise((resolve, reject) => original(...args, (err, result) => {
+            if (err)
+                return reject(err);
+            resolve(result);
+        }));
+    };
+}

package/{core → dist}/globals/index.d.ts

@@ -92,7 +92,6 @@ export declare function type(value: any): any;
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString | Object.toString }
  */
 export declare const str: (obj: any) => any;
-export declare function hasOwnProperty(obj: any, prop: any): boolean;
 /** Check if value is a boolean type. */
 export declare const isBool: (x: any) => x is boolean;
 /** Check if value is an `Error` type. */
@@ -118,8 +117,6 @@ export declare const isNumber: (x: any) => x is number;
 export declare const isInteger: (x: any) => x is number;
 /** Check if value is a bigint type. */
 export declare const isBigint: (x: any) => x is BigInt;
-/** Check if value is NaN based on `Number.isNaN`. */
-export declare const isNaN: (x: any) => x is number;
 /** Check if value is a Promise type. */
 export declare const isPromise: (x: any) => x is Promise<any>;
 /** Check if value is a function type. */
@@ -129,9 +126,9 @@ export declare const isAsyncFunction: (x: any) => boolean;
 /** Check if value is a generator function type. */
 export declare const isGenerator: (x: any) => x is Generator<unknown, any, unknown>;
 /** Check if value is `null` or `undefined`. */
-export declare const isNull: (x: any) => x is null | undefined;
+export declare const isNull: (x: any) => x is null;
 /** Check if value === `undefined`. */
-export declare function isUndefined(o: any): boolean;
+export declare const isUndefined: (x: any) => x is undefined;
 /** Check if value is not `null` or `undefined`. */
 export declare const notNull: (x: any) => boolean;
 /** Returns `true` for objects without length or falsy values. */
@@ -164,10 +161,10 @@ export declare function len(value: any): any;
  * @example
 ```js
 uniqueId()
-// => 3445556877
+// 3445556877
 
 uniqueId('user_')
-// => 'user_1033763188'
+// 'user_1033763188'
 ```
  */
 export declare const uniqueId: (pre?: string) => any;
@@ -177,7 +174,7 @@ export declare const uniqueId: (pre?: string) => any;
  * @example
 ```js
 uuid()
-// => '183f8ef3-b8f0-4000-81f5-89234c836d00'
+// '183f8ef3-b8f0-4000-81f5-89234c836d00'
 ```
  */
 export declare const uuid: () => string;
@@ -213,7 +210,7 @@ export declare const values: (object: any) => unknown[];
  * @param attr A property key name.
  * @returns `true` if the object has the property name.
  */
-export declare const has: (obj: any, attr: PropertyKey) => any;
+export declare const has: (obj: any, attr: PropertyKey) => boolean;
 /**
  * Check if the attribute is present in the object or return a default value instead.
  * @param {PropertyKey} key
@@ -293,7 +290,7 @@ export declare const int: (x: any, base?: number) => number;
  */
 export declare const list: (value?: any) => unknown[];
 /**
- * Retrieve the next item from the iterator by calling it's `next()` method.
+ * Retrieve the next item from the iterator by calling its `next()` method.
  * @param iter The iterator.
  * @returns The next value from the iterator.
  */

package/{core → dist}/globals/index.js

@@ -122,9 +122,6 @@ export function type(value) {
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString | Object.toString }
  */
 export const str = (obj) => (obj != null ? obj.toString() : '');
-export function hasOwnProperty(obj, prop) {
-    return Object.prototype.hasOwnProperty.call(obj, prop);
-}
 /** Check if value is a boolean type. */
 export const isBool = (x) => type(x) === 'boolean';
 /** Check if value is an `Error` type. */
@@ -138,7 +135,7 @@ export const isIterable = (x) => {
 /** Check if value is a native `Date` type. */
 export const isDate = (x) => x instanceof Date;
 /** Check if value is an object type. */
-export const isObject = (x) => typeof x === 'object' && type(x) === 'object';
+export const isObject = (x) => type(x) === 'object';
 /** Check if value is a string type. */
 export const isString = (x) => type(x) === 'string';
 /** Check if value is an Array type. */
@@ -154,11 +151,9 @@ export const isArrayLike = (x) => {
 /** Check if value is a number type. */
 export const isNumber = (x) => type(x) === 'number';
 /** Check if value is an integer number type. */
-export const isInteger = (x) => type(x) === 'number' && Math.floor(x) === x;
+export const isInteger = (x) => type(x) === 'number' && Math.trunc(x) === x;
 /** Check if value is a bigint type. */
 export const isBigint = (x) => type(x) === 'bigint';
-/** Check if value is NaN based on `Number.isNaN`. */
-export const isNaN = (x) => Number.isNaN(x);
 /** Check if value is a Promise type. */
 export const isPromise = (x) => type(x) === 'Promise';
 /** Check if value is a function type. */
@@ -172,9 +167,7 @@ export const isGenerator = (x) => {
 /** Check if value is `null` or `undefined`. */
 export const isNull = (x) => x == null;
 /** Check if value === `undefined`. */
-export function isUndefined(o) {
-    return typeof o === 'undefined';
-}
+export const isUndefined = (x) => x === undefined;
 /** Check if value is not `null` or `undefined`. */
 export const notNull = (x) => x != null;
 /** Returns `true` for objects without length or falsy values. */
@@ -222,10 +215,10 @@ export function len(value) {
  * @example
 ```js
 uniqueId()
-// => 3445556877
+// 3445556877
 
 uniqueId('user_')
-// => 'user_1033763188'
+// 'user_1033763188'
 ```
  */
 export const uniqueId = (pre = '') => 
@@ -237,7 +230,7 @@ export const uniqueId = (pre = '') =>
  * @example
 ```js
 uuid()
-// => '183f8ef3-b8f0-4000-81f5-89234c836d00'
+// '183f8ef3-b8f0-4000-81f5-89234c836d00'
 ```
  */
 export const uuid = () => {
@@ -407,7 +400,7 @@ export const int = (x, base = 10) => parseInt(x, base);
  */
 export const list = (value) => (value ? Array.from(value) : []);
 /**
- * Retrieve the next item from the iterator by calling it's `next()` method.
+ * Retrieve the next item from the iterator by calling its `next()` method.
  * @param iter The iterator.
  * @returns The next value from the iterator.
  */

package/dist/i18n/date/index.d.ts

@@ -0,0 +1,204 @@
+import { Duration, DurationUnit, TDuration } from '../duration.js';
+import { asDate, formatDate, strftime } from '../format.js';
+import { DateParts, daysInMonth, daysInYear, isLeapYear, maxDate, minDate, weeksInYear } from './utils.js';
+export { asDate, daysInMonth, daysInYear, formatDate, isLeapYear, maxDate, minDate, strftime, weeksInYear };
+declare type DateInput = number | string | Date;
+declare type DateLike = DateInput | DateParts | IntlDate;
+export { DateInput, DateParts, DateLike };
+/**
+ * Creates a date tied to a given locale (default system locale) which can be formatted in that locale's language using the native {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl Intl Apis} directly or using a formatting string.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl Intl Apis}
+ */
+export declare class IntlDate {
+    private _date;
+    readonly locale?: string;
+    intlRelativeFormat: Intl.RelativeTimeFormat;
+    /** Parses the provided value as UTC date or returns the current UTC date. */
+    static UTC(value?: DateLike, locale?: string): IntlDate;
+    /** Returns the current local date and time.*/
+    static now(): IntlDate;
+    /** Creates a new date from a Unix timestamp (seconds since the unix epoch) */
+    static unix(seconds: number): IntlDate;
+    /**
+     * Creates a new `IntlDate` in local time and specified locale (default is system locale).
+     * **Note:** The allowed values for `month` start at 1, which is different from legacy `Date`
+     * @param {DateLike} obj The date value (default is current local time)
+     * @param {Object} opts The options for this date
+     * @param {boolean?} opts.utc Converts input or current time to UTC
+     * @param {string?} opts.locale A locale string to use for this date
+     * @returns
+     */
+    constructor(obj?: DateLike, { locale, utc }?: any);
+    /** Get the date's year. */
+    get year(): number;
+    /** Get the this date's month as a number from 1 to 12, inclusive. */
+    get month(): number;
+    /** Returns the weekday as a number between 1 and 7, inclusive, where Monday is 1 and Sunday is 7. */
+    get dayOfWeek(): number;
+    /** Get the this date's current day of the month. */
+    get day(): number;
+    /** Get the this date's current hour. */
+    get hour(): number;
+    /** Get the this date's current minute. */
+    get minute(): number;
+    /** Get the this date's current second. */
+    get second(): number;
+    /** Get the this date's current millisecond. */
+    get millisecond(): number;
+    isValid(): boolean;
+    /** Get the number of days in this date's month. */
+    daysInMonth(): number;
+    /** Get the number of days in this date's year. */
+    daysInYear(): 366 | 365;
+    dayOfYear(): number;
+    /** Returns `true` if this date's year is a leap year. */
+    isLeapYear(): boolean;
+    /** Gets the number of weeks according to locale in the current year. */
+    weeksInYear(): number;
+    /** Gets the number of weeks in the current year, according to ISO weeks. */
+    isoWeeksInYear(): number;
+    /** Returns the current week of the year. */
+    week(): any;
+    /** Returns the ISO week of the year. */
+    isoWeek(): any;
+    /**
+     * Returns a localized string representation of this date.
+     * @param {Intl.DateTimeFormatOptions} opts The options to use for the format
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/DateTimeFormat Intl.DateTimeFormat()}
+     */
+    toString(opts?: Intl.DateTimeFormatOptions): string;
+    /**
+     * Returns a localized string representation of this date, according to the given format string. Format codes use the same specification as {@link https://momentjs.com/docs/#/displaying/format/ moment}.
+     * @param {string} str The format string to use
+     * @see {@link https://momentjs.com/docs/#/displaying/format/ List of formats}
+     * @example
+  ```js
+  new IntlDate().format('MM/DD/YYYY') // '10/31/2022'
+  ```
+     */
+    format(str: string): string;
+    /**
+     * Returns a new copy of the native `Date` object used by this instance.
+     * @returns {Date} A new `Date` object
+     */
+    toDate(): Date;
+    /**
+     * Returns the number of seconds since the Unix Epoch (January 1, 1970 UTC).
+     * @see {@link IntlDate.timestamp}
+     * @see {@link IntlDate.unix}
+     * @example
+  ```js
+  new IntlDate().toSeconds() // 1318874398
+  ```
+     */
+    toSeconds(): number;
+    /**
+     * Returns the number of seconds since the Unix Epoch (January 1, 1970 UTC).
+     * @see {@link IntlDate.toSeconds}
+     * @see {@link IntlDate.unix}
+     * @example
+  ```js
+  new IntlDate().timestamp() // 1318874398
+  ```
+     */
+    timestamp(): number;
+    /**
+     * Returns the number of seconds since the Unix Epoch (January 1, 1970 UTC).
+     * @see {@link IntlDate.toSeconds}
+     * @see {@link IntlDate.timestamp}
+     * @example
+  ```js
+  new IntlDate().unix() // 1318874398
+  ```
+     */
+    unix(): number;
+    /** Formats a string to the ISO8601 standard.
+     * @example
+  ```js
+  new IntlDate().toISOString() // '2022-10-31T22:44:30.652Z'
+  ```
+     */
+    toISOString(): string;
+    /** Returns the date part formatted as ISO8601.
+     * @example
+  ```js
+  new IntlDate().toISODate() // '2022-10-31'
+  ```
+     */
+    toISODate(): string;
+    /** Returns the time part formatted as ISO8601.
+     * @example
+  ```js
+  new IntlDate().toISOTime() // 'T22:44:30.652Z'
+  ```
+     */
+    toISOTime(): string;
+    /**
+     * Returns an object containing year, month, day-of-month, hours, minutes, seconds, milliseconds.
+     * @returns {Object} An object like `{year, month, date, hours, minutes, seconds, ms}`
+     */
+    toObject(): DateParts;
+    /** Returns the number of milliseconds since the Unix Epoch (January 1, 1970 UTC)  */
+    getTime(): number;
+    /** Alias of {@link IntlDate.getTime}  */
+    valueOf(): number;
+    /** Returns the timezone string name  */
+    zoneName(): string;
+    /** Returns the timezone GMT offset as a string  */
+    zone(): string;
+    /** Returns the difference in `minutes` between this date and UTC  */
+    utcOffset(): number;
+    /**
+     * Check if this date is before another date. The other value will be parsed as an `IntlDate` if not already so.
+     * @param {DateLike} other Another date or date like object
+     * @returns {boolean} Returns `true` if this date is before the given value
+     */
+    isBefore(other: DateLike): boolean;
+    /**
+     * Check if this date is strictly after the given `start` and before `stop` dates. The values will be parsed as an `IntlDate` if not already so.
+     * @param {DateLike} start The smaller date
+     * @param {DateLike} stop The larger date
+     * @returns {boolean} Returns `true` if this date is greater than `start` and less than `stop`.
+     */
+    isBetween(start: DateLike, stop: DateLike): boolean;
+    /**
+     * Check if this date is after another date. The other value will be parsed as an `IntlDate` if not already so.
+     * @param {DateLike} other Another date or date like object
+     * @returns {boolean} Returns `true` if this date is after the given value
+     */
+    isAfter(other: DateLike): boolean;
+    /**
+     * Check if this date is the same as `other`.
+     * @param other Another date object
+     * @returns {boolean} Returns `true` if this date is the same as other
+     */
+    isSame(other: Date | IntlDate): boolean;
+    lt(other: Date | IntlDate): boolean;
+    eq(other: Date | IntlDate): boolean;
+    compare(other: Date | IntlDate): number;
+    set(values: DateParts): IntlDate;
+    get relativeFormat(): Intl.RelativeTimeFormat;
+    relativeTime(n: number, unit?: Intl.RelativeTimeFormatUnit): string;
+    fromNow(unit?: Intl.RelativeTimeFormatUnit): string;
+    from(other: DateLike, unit?: Intl.RelativeTimeFormatUnit): string;
+    toNow(unit?: Intl.RelativeTimeFormatUnit): string;
+    to(other: DateLike, unit?: Intl.RelativeTimeFormatUnit): string;
+    diff(other: DateLike, unit?: DurationUnit, exact?: boolean): number;
+    add(duration: TDuration, exact?: boolean): IntlDate;
+    subtract(duration: TDuration, exact?: boolean): IntlDate;
+    startOf(unit: DurationUnit): IntlDate;
+    endOf(unit: DurationUnit): IntlDate;
+    clone(date?: DateLike): IntlDate;
+    static max(...args: any[]): any;
+    static min(...args: any[]): any;
+    inspect(): string;
+}
+export declare function addDuration(date: DateInput, duration: number | TDuration | Duration, exact?: boolean): Date;
+/**
+ * Subtract the specified years, months, weeks, days, hours, minutes and seconds from the given date.
+ * @param date
+ * @param duration
+ * @param exact
+ * @returns
+ */
+export declare function subDuration(date: DateInput, duration: TDuration, exact?: boolean): Date;