atomic-fns 0.3.1 → 0.3.3

package/core/datetime/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * This module includes classes and functions to work with Date types.
+ *
+ * @module Date
+ */
+export declare const MINUTE_SECONDS = 60;
+export declare const HOUR_SECONDS: number;
+export declare const DAY_SECONDS: number;
+export declare const WEEK_SECONDS: number;
+export declare const MILLISECONDS = 1000;
+export declare const MINUTE_MILLISECONDS: number;
+export declare const HOUR_MILLISECONDS: number;
+export declare const DAY_MILLISECONDS: number;
+export declare const WEEK_MILLISECONDS: number;
+export declare const MS = "millisecond";
+export declare const S = "second";
+export declare const MIN = "minute";
+export declare const H = "hour";
+export declare const D = "day";
+export declare const W = "week";
+export declare const M = "month";
+export declare const Q = "quarter";
+export declare const Y = "year";
+export declare const DATE = "date";
+export declare const FORMAT_DEFAULT = "YYYY-MM-DDTHH:mm:ssZ";
+export declare const INVALID_DATE_STRING = "Invalid Date";
+export declare const REGEX_PARSE: RegExp;
+export declare const REGEX_FORMAT: RegExp;
+export declare const now: number;
+export declare type DatetimeOptions = {
+    year: number;
+    month?: number;
+    day?: number;
+    hour?: number;
+    minute?: number;
+    second?: number;
+    millisecond?: number;
+    locale?: string;
+    utc?: boolean;
+};
+export declare class Datetime {
+    #private;
+    constructor(opts?: string | number | Date | DatetimeOptions);
+    format(locale?: string, opts?: Intl.DateTimeFormatOptions): string;
+}

package/core/datetime/index.js

@@ -0,0 +1,71 @@
+/**
+ * This module includes classes and functions to work with Date types.
+ *
+ * @module Date
+ */
+import { get } from '../globals';
+// Constants
+export const MINUTE_SECONDS = 60;
+export const HOUR_SECONDS = MINUTE_SECONDS * 60;
+export const DAY_SECONDS = HOUR_SECONDS * 24;
+export const WEEK_SECONDS = DAY_SECONDS * 7;
+export const MILLISECONDS = 1e3;
+export const MINUTE_MILLISECONDS = MINUTE_SECONDS * MILLISECONDS;
+export const HOUR_MILLISECONDS = HOUR_SECONDS * MILLISECONDS;
+export const DAY_MILLISECONDS = DAY_SECONDS * MILLISECONDS;
+export const WEEK_MILLISECONDS = WEEK_SECONDS * MILLISECONDS;
+// English locales
+export const MS = 'millisecond';
+export const S = 'second';
+export const MIN = 'minute';
+export const H = 'hour';
+export const D = 'day';
+export const W = 'week';
+export const M = 'month';
+export const Q = 'quarter';
+export const Y = 'year';
+export const DATE = 'date';
+export const FORMAT_DEFAULT = 'YYYY-MM-DDTHH:mm:ssZ';
+export const INVALID_DATE_STRING = 'Invalid Date';
+// regex
+export const REGEX_PARSE = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/;
+export const REGEX_FORMAT = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g;
+export const now = new Date().getTime();
+function parseDate(date) {
+    if (date === null)
+        return new Date(NaN);
+    if (!date)
+        return new Date();
+    if (date instanceof Date)
+        return new Date(date);
+    const utc = date.utc;
+    if (typeof date === 'string' && !/Z$/i.test(date)) {
+        const d = date.match(REGEX_PARSE);
+        if (d) {
+            const m = d[2] - 1 || 0;
+            const ms = (d[7] || '0').slice(0, 3);
+            if (utc) {
+                return new Date(Date.UTC(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms));
+            }
+            return new Date(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms);
+        }
+    }
+    return new Date(date);
+}
+export class Datetime {
+    #date = new Date(); // defaults to now
+    #UTC = false; // use current locale by default
+    constructor(opts) {
+        this.#date = parseDate(opts);
+        this.#UTC = get('utc', opts, false);
+        // this.init()
+    }
+    // Display
+    // Format
+    format(locale, opts) {
+        if (opts && opts.timeZone === undefined && this.#UTC) {
+            opts.timeZone = 'utc';
+        }
+        return this.#date.toLocaleDateString(locale, opts);
+    }
+}

package/core/datetime/index.ts

@@ -0,0 +1,128 @@
+/**
+ * This module includes classes and functions to work with Date types.
+ *
+ * @module Date
+ */
+
+import { get } from '../globals'
+
+// Constants
+export const MINUTE_SECONDS = 60
+export const HOUR_SECONDS = MINUTE_SECONDS * 60
+export const DAY_SECONDS = HOUR_SECONDS * 24
+export const WEEK_SECONDS = DAY_SECONDS * 7
+
+export const MILLISECONDS = 1e3
+export const MINUTE_MILLISECONDS = MINUTE_SECONDS * MILLISECONDS
+export const HOUR_MILLISECONDS = HOUR_SECONDS * MILLISECONDS
+export const DAY_MILLISECONDS = DAY_SECONDS * MILLISECONDS
+export const WEEK_MILLISECONDS = WEEK_SECONDS * MILLISECONDS
+
+// English locales
+export const MS = 'millisecond'
+export const S = 'second'
+export const MIN = 'minute'
+export const H = 'hour'
+export const D = 'day'
+export const W = 'week'
+export const M = 'month'
+export const Q = 'quarter'
+export const Y = 'year'
+export const DATE = 'date'
+
+export const FORMAT_DEFAULT = 'YYYY-MM-DDTHH:mm:ssZ'
+
+export const INVALID_DATE_STRING = 'Invalid Date'
+
+// regex
+export const REGEX_PARSE =
+  /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/
+export const REGEX_FORMAT =
+  /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g
+
+export const now = new Date().getTime()
+
+export type DatetimeOptions = {
+  year: number
+  month?: number
+  day?: number
+  hour?: number
+  minute?: number
+  second?: number
+  millisecond?: number
+  locale?: string
+  utc?: boolean
+}
+
+function parseDate(date) {
+  if (date === null) return new Date(NaN)
+  if (!date) return new Date()
+  if (date instanceof Date) return new Date(date)
+  const utc = date.utc
+  if (typeof date === 'string' && !/Z$/i.test(date)) {
+    const d = date.match(REGEX_PARSE) as any
+    if (d) {
+      const m = d[2] - 1 || 0
+      const ms = (d[7] || '0').slice(0, 3)
+      if (utc) {
+        return new Date(Date.UTC(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms))
+      }
+      return new Date(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms)
+    }
+  }
+  return new Date(date)
+}
+
+export class Datetime {
+  #date = new Date() // defaults to now
+  #UTC = false // use current locale by default
+
+  constructor(opts?: string | number | Date | DatetimeOptions) {
+    this.#date = parseDate(opts)
+    this.#UTC = get('utc', opts, false)
+    // this.init()
+  }
+
+  // Display
+  // Format
+  format(locale?: string, opts?: Intl.DateTimeFormatOptions) {
+    if (opts && opts.timeZone === undefined && this.#UTC) {
+      opts.timeZone = 'utc'
+    }
+    return this.#date.toLocaleDateString(locale, opts)
+  }
+
+  // Time from now
+  // Time from X
+  // Difference
+
+  // Parsing
+  // Parse String + Date Format
+  // Parse String + Time Format
+  // Parse String + Format + locale
+
+  // Getter/Setters
+  // Hour/Minute/Second/Millis
+  // Day of Month
+  // Day of Week
+  // Day of Year
+  // Week of Year
+  // Days in Month
+  // Weeks in Year
+  // max of two dates
+  // min of two dates
+
+  // Manipulate
+  // Add
+  // Subtract
+  // Start of Time
+  // End of Time
+
+  // Query
+  // Is Before
+  // Is Same
+  // Is After
+  // Is Between
+  // Is Leap Year
+  // Is a Date
+}

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

@@ -88,7 +88,7 @@ export declare function once(func: Function): (...args: any[]) => any;
 export declare type Maybe<T> = T | undefined;
 export declare type Result<T, E = any> = [Maybe<T>, Maybe<E>];
 /**
- * Wraps a function to catch any exceptions inside and return a `go` style error-return type.
+ * Wraps a function to catch any exceptions inside and return a `go` style error-return type {@link Result}.
  *
  * @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.
@@ -101,7 +101,7 @@ export declare function result<T = any, E = unknown>(fun: Function<T>, onFinally
  *
  * @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 return type.
+ * @returns {Function} A new function that awaits the `awaitable` param and returns a {@link Result} type.
  * @template T,E
  */
 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>>;

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

@@ -171,7 +171,7 @@ export function once(func) {
     };
 }
 /**
- * Wraps a function to catch any exceptions inside and return a `go` style error-return type.
+ * Wraps a function to catch any exceptions inside and return a `go` style error-return type {@link Result}.
  *
  * @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.
@@ -198,7 +198,7 @@ export function result(fun, onFinally) {
  *
  * @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 return type.
+ * @returns {Function} A new function that awaits the `awaitable` param and returns a {@link Result} type.
  * @template T,E
  */
 export function resultAsync(awaitable, onFinally) {

package/{src → core}/functools/index.ts

@@ -204,7 +204,7 @@ export type Maybe<T> = T | undefined
 export type Result<T, E = any> = [Maybe<T>, Maybe<E>]
 
 /**
- * Wraps a function to catch any exceptions inside and return a `go` style error-return type.
+ * Wraps a function to catch any exceptions inside and return a `go` style error-return type {@link Result}.
  *
  * @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.
@@ -233,7 +233,7 @@ export function result<T = any, E = unknown>(
  *
  * @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 return type.
+ * @returns {Function} A new function that awaits the `awaitable` param and returns a {@link Result} type.
  * @template T,E
  */
 export function resultAsync<T = any, E = unknown>(

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

@@ -3,11 +3,6 @@
  *
  * @module Globals
  */
-/** Describes a function used to compare two values.
- *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#description Array.sort()}
- */
-export declare type Comp = (x: any, y: any) => -1 | 0 | 1;
 /** This is just a noop function. */
 export declare const _: () => void;
 /**
@@ -27,7 +22,7 @@ export declare type Function<T = any> = (...args: any) => T;
  * @see {@link Collections.sortedUniq}
  * @see {@link Collections.groupBy}
  */
-export declare type Iteratee<T = any> = (value: T, key?: any, arr?: any) => any;
+export declare type Iteratee<T = any, K = any> = (value: T, key?: K, arr?: any) => any;
 export declare type Predicate<T = any> = (value: T) => any;
 /** A function that always returns `true`. */
 export declare const True: () => boolean;
@@ -130,7 +125,7 @@ export declare const isGenerator: (x: any) => x is Generator<unknown, any, unkno
 export declare const isNull: (x: any) => x is null | undefined;
 /** Check if value is not `null` or `undefined`. */
 export declare const notNull: (x: any) => boolean;
-/** Returns `true` for objects without length or falsey values. */
+/** Returns `true` for objects without length or falsy values. */
 export declare const isEmpty: (x: any) => boolean;
 /** Check if value is a `Symbol` type */
 export declare const isSymbol: (x: any) => x is symbol;

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

@@ -164,7 +164,7 @@ export const isGenerator = (x) => {
 export const isNull = (x) => x == null;
 /** Check if value is not `null` or `undefined`. */
 export const notNull = (x) => x != null;
-/** Returns `true` for objects without length or falsey values. */
+/** Returns `true` for objects without length or falsy values. */
 export const isEmpty = (x) => (len(x) === 0 ? true : !x);
 /** Check if value is a `Symbol` type */
 export const isSymbol = (x) => type(x) === 'symbol';
@@ -179,12 +179,15 @@ export const isSymbol = (x) => type(x) === 'symbol';
 export function len(value) {
     if (value == null)
         return;
-    if (value.length !== undefined) {
+    if (isNumber(value.length)) {
         return value.length;
     }
     if (isFunc(value.size)) {
         return value.size();
     }
+    if (isNumber(value.size)) {
+        return value.size;
+    }
     if (isObject(value)) {
         return Object.keys(value).length;
     }

package/{src → core}/globals/index.ts

@@ -4,12 +4,6 @@
  * @module Globals
  */
 
-/** Describes a function used to compare two values.
- *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#description Array.sort()}
- */
-export type Comp = (x, y) => -1 | 0 | 1
-
 /** This is just a noop function. */
 export const _ = () => {}
 
@@ -31,7 +25,7 @@ export type Function<T = any> = (...args: any) => T
  * @see {@link Collections.sortedUniq}
  * @see {@link Collections.groupBy}
  */
-export type Iteratee<T = any> = (value: T, key?, arr?) => any
+export type Iteratee<T = any, K = any> = (value: T, key?: K, arr?) => any
 
 export type Predicate<T = any> = (value: T) => any
 
@@ -204,7 +198,7 @@ export const isNull = (x): x is null | undefined => x == null
 /** Check if value is not `null` or `undefined`. */
 export const notNull = (x) => x != null
 
-/** Returns `true` for objects without length or falsey values. */
+/** Returns `true` for objects without length or falsy values. */
 export const isEmpty = (x) => (len(x) === 0 ? true : !x)
 
 /** Check if value is a `Symbol` type */
@@ -220,12 +214,15 @@ export const isSymbol = (x): x is symbol => type(x) === 'symbol'
  */
 export function len(value) {
   if (value == null) return
-  if (value.length !== undefined) {
+  if (isNumber(value.length)) {
     return value.length
   }
   if (isFunc(value.size)) {
     return value.size()
   }
+  if (isNumber(value.size)) {
+    return value.size
+  }
   if (isObject(value)) {
     return Object.keys(value).length
   }

package/{src → core}/index.d.ts

@@ -1,5 +1,4 @@
 export * from './collections/index.js';
-export * from './datetime/index.js';
 export * from './functools/index.js';
 export * from './globals/index.js';
 export * from './itertools/index.js';

package/{src → core}/index.js

@@ -1,5 +1,4 @@
 export * from './collections/index.js';
-export * from './datetime/index.js';
 export * from './functools/index.js';
 export * from './globals/index.js';
 export * from './itertools/index.js';

package/{src → core}/index.ts

@@ -1,5 +1,4 @@
 export * from './collections/index.js'
-export * from './datetime/index.js'
 export * from './functools/index.js'
 export * from './globals/index.js'
 export * from './itertools/index.js'

package/{src → core}/itertools/index.d.ts

@@ -3,8 +3,8 @@
  *
  * @module Iterators
  */
-import { Comp, Function, Predicate } from '../globals/index.js';
-import { add } from '../operators/index.js';
+import { Function, Iteratee, Predicate } from '../globals/index.js';
+import { add, Comparer } from '../operators/index.js';
 /**
  * Make an iterator that returns accumulated sums, or accumulated results of other binary functions (specified via the optional `func` argument).
  * @param iterable The iterable to accumulate
@@ -82,6 +82,8 @@ export declare function contains(collection: Iterable<any>, value: any): any;
  * @returns Elements
  */
 export declare function dropWhile<T>(iterable: Iterable<T>, predicate: Predicate): Generator<unknown, any, unknown>;
+export declare function iforEach<T>(iterable: Iterable<T>, fun: Iteratee<T>): void;
+export declare function IterableIterator<T = any>(next: any): Iterator<T, any, undefined> & Iterable<T>;
 /**
  * Yields elements like `[index, item]` from an iterable. Index starts at zero by default.
  * @template T
@@ -106,7 +108,7 @@ export declare function enumerate<T = any>(iterable: Iterable<T>, start?: number
  */
 export declare function first<T>(iterable: Iterable<T>): any;
 /**
- * Creates a new generator that filters all `falsey` and empty values from iterable.
+ * Creates a new generator that filters all falsy and empty values from iterable.
  * @param arr The array to compact
  * @returns A new array with the filtered values.
  * @example
@@ -120,7 +122,7 @@ export declare function icompact<T>(iterable: Iterable<T>): Generator<T, void, u
  * Iterates over elements of collection, producing only those elements where predicate returns a `truthy` value.
  */
 export declare function ifilter<T>(iterable: Iterable<T>, predicate: Predicate): Generator<T, void, unknown>;
-export declare function imap<T>(iterable: Iterable<T>, mapFn: (x: T) => any): Generator<any, void, unknown>;
+export declare function imap<T, TReturn = any>(iterable: Iterable<T>, mapFn: (x: T) => TReturn): Generator<TReturn, void, unknown>;
 /**
  * Returns a generator flattening one level of nesting in a list of lists.
  * @param iterables The iterable to flatten
@@ -187,13 +189,13 @@ export declare function reduce<T>(iterable: Iterable<T>, reducer: (prev: T, valu
 export declare function reversed<T>(iterable: Iterable<T>): T[];
 export declare function sorted(args: any[]): any[];
 export declare function sorted(args: any[], reverse: boolean): any[];
-export declare function sorted(args: any[], reverse: boolean, comp: Comp): any[];
+export declare function sorted(args: any[], reverse: boolean, comp: Comparer): any[];
 export declare function sorted(args: any[], key: Function): any[];
 export declare function sorted(args: any[], key: Function, reverse: boolean): any[];
 export declare function sort(args: any[]): any[];
 export declare function sort(args: any[], reverse: boolean): any[];
-export declare function sort(args: any[], compareFn: Comp): any[];
-export declare function sort(args: any[], reverse: boolean, compareFn: Comp): any[];
+export declare function sort(args: any[], compareFn: Comparer): any[];
+export declare function sort(args: any[], reverse: boolean, compareFn: Comparer): any[];
 export declare function take<T>(n: number, iterable: Iterable<T>): unknown[];
 /**
  * Returns a generator that takes elements from the iterable as long as the predicate is `true`.

package/{src → core}/itertools/index.js

@@ -4,7 +4,7 @@
  * @module Iterators
  */
 import { call, isEmpty, isObject, notNull, ValueError } from '../globals/index.js';
-import { add, bool, comp, eq, id } from '../operators/index.js';
+import { add, bool, compare, eq, id } from '../operators/index.js';
 /**
  * Make an iterator that returns accumulated sums, or accumulated results of other binary functions (specified via the optional `func` argument).
  * @param iterable The iterable to accumulate
@@ -109,7 +109,7 @@ export function contains(collection, value) {
         return includes;
     return any(collection, (x) => eq(value, x));
 }
-const compKey = (cmp, key) => (x, y) => cmp(key(x), key(y));
+const compKey = (compare, key) => (x, y) => compare(key(x), key(y));
 /**
  * Returns a generator that drops elements from the iterable as long as the predicate is `true`; afterwards, returns every remaining element. Note, the generator does not produce any output until the predicate first becomes `false`.
  * @param iterable The iterable to inspect.
@@ -134,6 +134,22 @@ export function* dropWhile(iterable, predicate) {
         yield head.value;
     }
 }
+export function iforEach(iterable, fun) {
+    for (const [index, value] of enumerate(iterable)) {
+        if (fun(value, index, iterable) === false) {
+            return;
+        }
+    }
+}
+export function IterableIterator(next) {
+    const it = {
+        next,
+        [Symbol.iterator]() {
+            return this;
+        }
+    };
+    return it;
+}
 /**
  * Yields elements like `[index, item]` from an iterable. Index starts at zero by default.
  * @template T
@@ -165,7 +181,7 @@ export function first(iterable) {
     return iter(iterable).next().value;
 }
 /**
- * Creates a new generator that filters all `falsey` and empty values from iterable.
+ * Creates a new generator that filters all falsy and empty values from iterable.
  * @param arr The array to compact
  * @returns A new array with the filtered values.
  * @example
@@ -350,8 +366,8 @@ export function reversed(iterable) {
  *
  * @param {(Array | Object)} args
  * @param {(boolean | Function)} [key]
- * @param {(boolean | Comp)} [reverse]
- * @param {Comp} [compareFn]
+ * @param {(boolean | Comparer)} [reverse]
+ * @param {Comparer} [compareFn]
  * @return
  */
 export function sorted(args, key, reverse, compareFn) {
@@ -368,7 +384,7 @@ export function sorted(args, key, reverse, compareFn) {
         key = id;
     }
     const copy = Array.from(args);
-    const _compare = compKey(compareFn || comp, key || id);
+    const _compare = compKey(compareFn || compare, key || id);
     copy.sort(_compare);
     if (reverse)
         copy.reverse();
@@ -381,8 +397,8 @@ export function sorted(args, key, reverse, compareFn) {
  *   - sort([...], true, (x, y) => number) => reverse and using custom compare
  *
  * @param {any[]} args
- * @param {(boolean | Comp)} [reverse]
- * @param {Comp} [compareFn]
+ * @param {(boolean | Comparer)} [reverse]
+ * @param {Comparer} [compareFn]
  * @return
  */
 export function sort(args, reverse, compareFn) {
@@ -390,7 +406,7 @@ export function sort(args, reverse, compareFn) {
         compareFn = reverse;
         reverse = false;
     }
-    args.sort(compareFn || comp);
+    args.sort(compareFn || compare);
     if (reverse === true)
         args.reverse();
     return args;