atomic-fns 0.3.5 → 0.4.3

package/core/collections/test.html

@@ -1,10 +0,0 @@
-<script type="module">
-  import { SplayTree } from 'https://unpkg.com/atomic-fns/core/collections'
-  let tree = new SplayTree()
-
-  for (let i = 20; i > 0; i -= 2) {
-    tree.set(i, i)
-  }
-
-  console.log(tree)
-</script>

package/core/collections/typedArrays.d.ts

@@ -1,31 +0,0 @@
-export declare function getPointerArray(size: any): Uint8ArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor;
-export declare function getSignedPointerArray(size: any): Int8ArrayConstructor | Int16ArrayConstructor | Int32ArrayConstructor | Float64ArrayConstructor;
-/**
- * Function returning the minimal type able to represent the given number.
- *
- * @param  {number} value - Value to test.
- * @return {TypedArrayClass}
- */
-export declare function getNumberType(value: any): Uint8ArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor | Int8ArrayConstructor | Int16ArrayConstructor | Int32ArrayConstructor | Float64ArrayConstructor;
-export declare function getMinimalRepresentation(array: any, getter: any): null;
-/**
- * Function returning whether the given value is a typed array.
- *
- * @param  {any} value - Value to test.
- * @return {boolean}
- */
-export declare function isTypedArray(value: any): boolean;
-/**
- * Function used to concat byte arrays.
- *
- * @param  {...ByteArray}
- * @return {ByteArray}
- */
-export declare function concat(): any;
-/**
- * Function used to initialize a byte array of indices.
- *
- * @param  {number}    length - Length of target.
- * @return {ByteArray}
- */
-export declare function indices(length: any): any;

package/core/collections/typedArrays.js

@@ -1,143 +0,0 @@
-/**
- * When using an unsigned integer array to store pointers, one might want to
- * choose the optimal word size in regards to the actual numbers of pointers
- * to store.
- *
- * This helpers does just that.
- *
- * @param  {number} size - Expected size of the array to map.
- * @return {TypedArray}
- */
-const MAX_8BIT_INTEGER = Math.pow(2, 8) - 1;
-const MAX_16BIT_INTEGER = Math.pow(2, 16) - 1;
-const MAX_32BIT_INTEGER = Math.pow(2, 32) - 1;
-const MAX_SIGNED_8BIT_INTEGER = Math.pow(2, 7) - 1;
-const MAX_SIGNED_16BIT_INTEGER = Math.pow(2, 15) - 1;
-const MAX_SIGNED_32BIT_INTEGER = Math.pow(2, 31) - 1;
-export function getPointerArray(size) {
-    const maxIndex = size - 1;
-    if (maxIndex <= MAX_8BIT_INTEGER)
-        return Uint8Array;
-    if (maxIndex <= MAX_16BIT_INTEGER)
-        return Uint16Array;
-    // if (maxIndex <= MAX_32BIT_INTEGER) return Uint32Array
-    return Uint32Array;
-}
-export function getSignedPointerArray(size) {
-    const maxIndex = size - 1;
-    if (maxIndex <= MAX_SIGNED_8BIT_INTEGER)
-        return Int8Array;
-    if (maxIndex <= MAX_SIGNED_16BIT_INTEGER)
-        return Int16Array;
-    if (maxIndex <= MAX_SIGNED_32BIT_INTEGER)
-        return Int32Array;
-    return Float64Array;
-}
-/**
- * Function returning the minimal type able to represent the given number.
- *
- * @param  {number} value - Value to test.
- * @return {TypedArrayClass}
- */
-export function getNumberType(value) {
-    // <= 32 bits itnteger?
-    if (value === (value | 0)) {
-        // Negative
-        if (Math.sign(value) === -1) {
-            if (value <= 127 && value >= -128)
-                return Int8Array;
-            if (value <= 32767 && value >= -32768)
-                return Int16Array;
-            return Int32Array;
-        }
-        else {
-            if (value <= 255)
-                return Uint8Array;
-            if (value <= 65535)
-                return Uint16Array;
-            return Uint32Array;
-        }
-    }
-    // 53 bits integer & floats
-    // NOTE: it's kinda hard to tell whether we could use 32bits or not...
-    return Float64Array;
-}
-/**
- * Function returning the minimal type able to represent the given array
- * of JavaScript numbers.
- *
- * @param  {array}    array  - Array to represent.
- * @param  {function} getter - Optional getter.
- * @return {TypedArrayClass}
- */
-const TYPE_PRIORITY = {
-    Uint8Array: 1,
-    Int8Array: 2,
-    Uint16Array: 3,
-    Int16Array: 4,
-    Uint32Array: 5,
-    Int32Array: 6,
-    Float32Array: 7,
-    Float64Array: 8
-};
-export function getMinimalRepresentation(array, getter) {
-    let maxType = null;
-    let maxPriority = 0;
-    let p;
-    let t;
-    let v;
-    let i;
-    let l;
-    for (i = 0, l = array.length; i < l; i++) {
-        v = getter ? getter(array[i]) : array[i];
-        t = exports.getNumberType(v);
-        p = TYPE_PRIORITY[t.name];
-        if (p > maxPriority) {
-            maxPriority = p;
-            maxType = t;
-        }
-    }
-    return maxType;
-}
-/**
- * Function returning whether the given value is a typed array.
- *
- * @param  {any} value - Value to test.
- * @return {boolean}
- */
-export function isTypedArray(value) {
-    return ArrayBuffer.isView(value);
-}
-/**
- * Function used to concat byte arrays.
- *
- * @param  {...ByteArray}
- * @return {ByteArray}
- */
-export function concat() {
-    let length = 0;
-    let i;
-    let o;
-    let l;
-    for (i = 0, l = arguments.length; i < l; i++)
-        length += arguments[i].length;
-    const array = new arguments[0].constructor(length);
-    for (i = 0, o = 0; i < l; i++) {
-        array.set(arguments[i], o);
-        o += arguments[i].length;
-    }
-    return array;
-}
-/**
- * Function used to initialize a byte array of indices.
- *
- * @param  {number}    length - Length of target.
- * @return {ByteArray}
- */
-export function indices(length) {
-    const PointerArray = exports.getPointerArray(length);
-    const array = new PointerArray(length);
-    for (let i = 0; i < length; i++)
-        array[i] = i;
-    return array;
-}

package/core/collections/typedArrays.ts

@@ -1,163 +0,0 @@
-/**
- * When using an unsigned integer array to store pointers, one might want to
- * choose the optimal word size in regards to the actual numbers of pointers
- * to store.
- *
- * This helpers does just that.
- *
- * @param  {number} size - Expected size of the array to map.
- * @return {TypedArray}
- */
-const MAX_8BIT_INTEGER = Math.pow(2, 8) - 1
-const MAX_16BIT_INTEGER = Math.pow(2, 16) - 1
-const MAX_32BIT_INTEGER = Math.pow(2, 32) - 1
-
-const MAX_SIGNED_8BIT_INTEGER = Math.pow(2, 7) - 1
-const MAX_SIGNED_16BIT_INTEGER = Math.pow(2, 15) - 1
-const MAX_SIGNED_32BIT_INTEGER = Math.pow(2, 31) - 1
-
-export function getPointerArray(size) {
-  const maxIndex = size - 1
-
-  if (maxIndex <= MAX_8BIT_INTEGER) return Uint8Array
-
-  if (maxIndex <= MAX_16BIT_INTEGER) return Uint16Array
-
-  // if (maxIndex <= MAX_32BIT_INTEGER) return Uint32Array
-
-  return Uint32Array
-}
-
-export function getSignedPointerArray(size) {
-  const maxIndex = size - 1
-
-  if (maxIndex <= MAX_SIGNED_8BIT_INTEGER) return Int8Array
-
-  if (maxIndex <= MAX_SIGNED_16BIT_INTEGER) return Int16Array
-
-  if (maxIndex <= MAX_SIGNED_32BIT_INTEGER) return Int32Array
-
-  return Float64Array
-}
-
-/**
- * Function returning the minimal type able to represent the given number.
- *
- * @param  {number} value - Value to test.
- * @return {TypedArrayClass}
- */
-export function getNumberType(value) {
-  // <= 32 bits itnteger?
-  if (value === (value | 0)) {
-    // Negative
-    if (Math.sign(value) === -1) {
-      if (value <= 127 && value >= -128) return Int8Array
-
-      if (value <= 32767 && value >= -32768) return Int16Array
-
-      return Int32Array
-    } else {
-      if (value <= 255) return Uint8Array
-
-      if (value <= 65535) return Uint16Array
-
-      return Uint32Array
-    }
-  }
-
-  // 53 bits integer & floats
-  // NOTE: it's kinda hard to tell whether we could use 32bits or not...
-  return Float64Array
-}
-
-/**
- * Function returning the minimal type able to represent the given array
- * of JavaScript numbers.
- *
- * @param  {array}    array  - Array to represent.
- * @param  {function} getter - Optional getter.
- * @return {TypedArrayClass}
- */
-const TYPE_PRIORITY = {
-  Uint8Array: 1,
-  Int8Array: 2,
-  Uint16Array: 3,
-  Int16Array: 4,
-  Uint32Array: 5,
-  Int32Array: 6,
-  Float32Array: 7,
-  Float64Array: 8
-}
-
-export function getMinimalRepresentation(array, getter) {
-  let maxType = null
-  let maxPriority = 0
-  let p
-  let t
-  let v
-  let i
-  let l
-
-  for (i = 0, l = array.length; i < l; i++) {
-    v = getter ? getter(array[i]) : array[i]
-    t = exports.getNumberType(v)
-    p = TYPE_PRIORITY[t.name]
-
-    if (p > maxPriority) {
-      maxPriority = p
-      maxType = t
-    }
-  }
-
-  return maxType
-}
-
-/**
- * Function returning whether the given value is a typed array.
- *
- * @param  {any} value - Value to test.
- * @return {boolean}
- */
-export function isTypedArray(value) {
-  return ArrayBuffer.isView(value)
-}
-
-/**
- * Function used to concat byte arrays.
- *
- * @param  {...ByteArray}
- * @return {ByteArray}
- */
-export function concat() {
-  let length = 0
-  let i
-  let o
-  let l
-
-  for (i = 0, l = arguments.length; i < l; i++) length += arguments[i].length
-
-  const array = new arguments[0].constructor(length)
-
-  for (i = 0, o = 0; i < l; i++) {
-    array.set(arguments[i], o)
-    o += arguments[i].length
-  }
-
-  return array
-}
-
-/**
- * Function used to initialize a byte array of indices.
- *
- * @param  {number}    length - Length of target.
- * @return {ByteArray}
- */
-export function indices(length) {
-  const PointerArray = exports.getPointerArray(length)
-
-  const array = new PointerArray(length)
-
-  for (let i = 0; i < length; i++) array[i] = i
-
-  return array
-}

package/core/functools/index.ts

@@ -1,260 +0,0 @@
-/**
- * This module includes functions that promote a more functional programming style.
- *
- * @module Functions
- */
-
-import { Function, isPromise } from '../globals/index.js'
-
-/**
- * Creates a function that invokes `fn` with the this binding of `thisArg` and `partials` as partially applied arguments.
- * @param {Function} fn The function to bind.
- * @param {*} thisArg The `this` value of `fn`.
- * @param {...*} [partials] The arguments to prepend to `fn`.
- * @returns {Function} Returns the new bound function.
- * @see {@link partial}
- */
-export const bind = (fn: Function, thisArg, ...partials) => fn.bind(thisArg, ...partials)
-
-/**
- * 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.
- * @param {number} [arity=func.length]
- * @returns Returns the new curried function.
- */
-export const curry = (func: Function, arity?: number) => {
-  if (typeof func !== 'function' || func.length < 2) return func
-  if (typeof arity !== 'number') arity = func.length
-  switch (arity) {
-    case 2:
-      return (arg0) => (arg1) => func(arg0, arg1)
-    case 3:
-      return (arg0) => (arg1) => (arg2) => func(arg0, arg1, arg2)
-    case 4:
-      return (arg0) => (arg1) => (arg2) => (arg3) => func(arg0, arg1, arg2, arg3)
-    case 5:
-      return (arg0) => (arg1) => (arg2) => (arg3) => (arg4) => func(arg0, arg1, arg2, arg3, arg4)
-    case 6:
-      return (arg0) => (arg1) => (arg2) => (arg3) => (arg4) => (arg5) =>
-        func(arg0, arg1, arg2, arg3, arg4, arg5)
-    case 7:
-      return (arg0) => (arg1) => (arg2) => (arg3) => (arg4) => (arg5) => (arg6) =>
-        func(arg0, arg1, arg2, arg3, arg4, arg5, arg6)
-    case 8:
-      return (arg0) => (arg1) => (arg2) => (arg3) => (arg4) => (arg5) => (arg6) => (arg7) =>
-        func(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    case 9:
-      return (arg0) =>
-        (arg1) =>
-        (arg2) =>
-        (arg3) =>
-        (arg4) =>
-        (arg5) =>
-        (arg6) =>
-        (arg7) =>
-        (arg8) =>
-          func(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-
-    default:
-      throw Error('The specified function uses too many arguments. Consider refactoring it.')
-  }
-}
-
-/**
- * Creates a function that invokes `fn` with partials prepended to the arguments it receives.
- * **Note:** The given function will have `this` bound to `undefined`. If using `this` inside `fn`, consider {@link bind} instead.
- * @param {Function} fn The function to bind.
- * @param {...*} [args] The arguments to apply to `fn`.
- * @returns {Function} Returns the new partially applied function
- */
-export const partial = (fn, ...args) => bind(fn, undefined, ...args)
-
-/**
- * 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.
- * @returns {Function} A new function that applies each given function on the result of the previous one.
- */
-export const flow =
-  (...args) =>
-  (x) => {
-    for (const fn of args) {
-      x = fn(x)
-    }
-    return x
-  }
-
-/**
- * This is just an alias for the {@link flow} function.
- * @see {@link flow}
- */
-export const pipe = flow
-
-export const compose = (...args) => flow(args.reverse())
-
-/**
- * Creates a function that memoizes the result of `func`. If `resolver` is provided, it determines the cache key for storing the result based on the arguments provided to the memoized function. By default, the first argument provided to the memoized function is used as the map cache key.
- *
- * @param {Function} func The function to have its output memoized.
- * @param {Function} [resolver] The function to resolve the cache key.
- * @return {Function} Returns the new memoized function.
- */
-export function memoize<T>(
-  func: Function<T>,
-  resolver?: Function
-): Function<ReturnType<typeof func>> {
-  const cache = new Map()
-  return (...args) => {
-    const key = resolver ? resolver(...args) : args[0]
-    const prev = cache.get(key)
-    if (prev !== undefined) return prev
-    const value = func(...args)
-    cache.set(key, value)
-    return value
-  }
-}
-
-// TODO: also sized lru_cache
-export function cache(target, name, descriptor) {
-  const original = descriptor.value
-  if (typeof original === 'function') {
-    descriptor.value = memoize(original)
-  }
-  return descriptor
-}
-
-/**
- * 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.
- *
- * @param {Function} func The function to debounce.
- * @param {number} wait The number of milliseconds to delay.
- * @param {{ maxWait: number }} [opts] The maximum time `func` is allowed to be delayed before it's invoked.
- * @returns Returns the new debounced function.
- */
-export function debounce(
-  func: Function,
-  wait: number,
-  { maxWait }: { maxWait?: number } = {}
-): Function {
-  let timer, maxTimer, lastResult
-  return (...args) => {
-    if (timer) clearTimeout(timer)
-    timer = setTimeout(() => {
-      clearTimeout(maxTimer)
-      maxTimer = null
-      lastResult = func(...args)
-    }, wait)
-
-    if (maxWait && !maxTimer) {
-      maxTimer = setTimeout(() => {
-        clearTimeout(timer)
-        maxTimer = null
-        lastResult = func(...args)
-      }, maxWait)
-    }
-
-    return lastResult
-  }
-}
-
-/**
- * Creates a throttled function that only invokes `func` at most once per every `wait` milliseconds. Subsequent calls to the throttled function return the result of the last successful invocation.
- *
- * @param {Function} func The function to throttle.
- * @param {number} wait The number of milliseconds to throttle invocations to.
- * @return {Function} Returns the new throttled function.
- */
-export function throttle(func: Function, wait: number): Function {
-  let pending = false
-  return (...args) => {
-    if (pending) return
-    func(...args)
-    pending = true
-    setTimeout(() => {
-      pending = false
-    }, wait)
-  }
-}
-
-/**
- * Creates a function that is restricted to invoking `func` once. Repeat calls to the function return the value of the first invocation. The `func` is invoked with the arguments of the created function.
- *
- * @param {Function} func The function to restrict
- * @returns {Function} Returns the new restricted function.
- * @example
-```js
-let func = x => x
-let single = once(func)
-single(1) // => 1
-single(2) // => 1
-single(3) // => 1
-// ...
-// => `func` is invoked only once.
-```
- */
-export function once<T>(func: Function<T>) {
-  let result, isCalled
-  return (...args) => {
-    if (!isCalled) {
-      result = func(...args)
-      isCalled = true
-    }
-    return result as T
-  }
-}
-
-export type Maybe<T> = T | undefined
-
-export type Result<T, E = any> = [Maybe<T>, Maybe<E>]
-
-export type Optional<T> = Maybe<T>
-
-/**
- * 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.
- * @returns {Function} A new function that wraps `fun`.
- * @template T,E
- */
-export function result<T = any, E = unknown>(
-  fun: Function<T>,
-  onFinally?: (err: E, res: T) => any
-) {
-  return (...args): Result<T, E> => {
-    let value, err
-    try {
-      value = fun(...args)
-    } catch (error) {
-      err = error
-    } finally {
-      onFinally?.(err, value)
-    }
-    return [value as T, err]
-  }
-}
-
-/**
- * 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
- */
-export function resultAsync<T = any, E = unknown>(
-  awaitable: Promise<T> | Function<Promise<T>>,
-  onFinally?: (err: E, res: T) => any
-) {
-  return async (...args): Promise<Result<T, E>> => {
-    let value, err
-    try {
-      const promise = isPromise(awaitable) ? awaitable : awaitable(...args)
-      value = await promise
-    } catch (error) {
-      err = error
-    } finally {
-      onFinally?.(err, value)
-    }
-    return [value as T, err]
-  }
-}