rubico 2.7.6 → 2.7.8

package/x/find.d.ts

@@ -1,34 +0,0 @@
-export = find;
-/**
- * @name find
- *
- * @synopsis
- * ```coffeescript [specscript]
- * Foldable<T> = Iterable<T>|AsyncIterable<T>|{ reduce: (any, T)=>any }|Object<T>
- *
- * var T any,
- *   predicate T=>Promise|boolean,
- *   foldable Foldable<T>,
- *   result Promise|T|undefined
- *
- * find(predicate)(foldable) -> result
- * ```
- *
- * @description
- * Get the first element in a foldable collection that matches a predicate.
- *
- * ```javascript [playground]
- * import find from 'https://unpkg.com/rubico/dist/x/find.es.js'
- *
- * const users = [
- *   { name: 'John', age: 16 },
- *   { name: 'Jill', age: 32 },
- *   { name: 'John', age: 51 },
- * ]
- *
- * console.log(
- *   find(user => user.age > 50)(users),
- * ) // { name: 'John', age: 51 }
- * ```
- */
-declare function find(predicate: any): (value: any) => any;

package/x/findIndex.d.ts

@@ -1,25 +0,0 @@
-export = findIndex;
-/**
- * @name findIndex
- *
- * @synopsis
- * ```coffeescript [specscript]
- * findIndex(predicate function)(array Array) -> index Promise|number
- * ```
- *
- * @description
- * Returns the index of the first element in an array that satisfies the predicate. Returns -1 if no element satisfies the predicate.
- *
- * ```javascript [playground]
- * import findIndex from 'https://unpkg.com/rubico/dist/x/findIndex.es.js'
- *
- * const oddNumberIndex = findIndex(function isOdd(number) {
- *   return number % 2 == 1
- * })([2, 3, 5])
- *
- * console.log(oddNumberIndex) // 1
- * ```
- *
- * @since 1.6.26
- */
-declare function findIndex(predicate: any): (array: any) => any;

package/x/first.d.ts

@@ -1,23 +0,0 @@
-export = first;
-/**
- * @name first
- *
- * @synopsis
- * ```coffeescript [specscript]
- * var value Array|string
- *
- * first(value) -> any
- * ```
- *
- * @description
- * Get the first element of a collection
- *
- * ```javascript [playground]
- * import first from 'https://unpkg.com/rubico/dist/x/first.es.js'
- *
- * console.log(first([1, 2, 3])) // 1
- * console.log(first('abc')) // 'a'
- * console.log(first([])) // undefined
- * ```
- */
-declare function first(value: any): any;

package/x/flatten.d.ts

@@ -1,57 +0,0 @@
-export = flatten;
-/**
- * @name flatten
- *
- * @synopsis
- * ```coffeescript [specscript]
- * Stream<T> = { read: ()=>T, write: T=>() }
- * Monad<T> = Array<T>|String<T>|Set<T>
- *   |TypedArray<T>|Stream<T>|Iterator<T>|AsyncIterator<T>
- *   |{ chain: T=>Monad<T> }|{ flatMap: T=>Monad<T> }|Object<T>
- * Reducer<T> = (any, T)=>Promise|any
- * Foldable<T> = Iterable<T>|AsyncIterable<T>|{ reduce: Reducer<T>=>any }|Object<T>
- *
- * var T any,
- *   monad Monad<Monad<T>|Foldable<T>|T>,
- *   args ...any,
- *   generatorFunction ...args=>Generator<Monad<T>|Foldable<T>|T>,
- *   asyncGeneratorFunction ...args=>AsyncGenerator<Monad<T>|Foldable<T>|T>,
- *   reducer Reducer<Monad<T>|Foldable<T>|T>
- *
- * flatten(monad) -> Monad<T>
- *
- * flatten(generatorFunction) -> ...args=>Generator<T>
- *
- * flatten(asyncGeneratorFunction) -> ...args=>AsyncGenerator<T>
- *
- * flatten(reducer) -> Reducer<T>
- * ```
- *
- * @description
- * Flatten a collection. Works in transducer position.
- *
- * ```javascript [playground]
- * import flatten from 'https://unpkg.com/rubico/dist/x/flatten.es.js'
- *
- * flatten([
- *   [1, 1],
- *   new Set([2, 2]),
- *   (function* () { yield 3; yield 3 })(),
- *   (async function* () { yield 4; yield 4 })(),
- *   { a: 5, b: 5 },
- *   6,
- *   Promise.resolve(7),
- *   new Uint8Array([8]),
- * ]).then(console.log)
- * // [1, 1, 2, 3, 3, 5, 5, 6, 7, 8, 4, 4]
- *
- * const add = (a, b) => a + b
- *
- * console.log(
- *   [[1], [2], [3], [4], [5]].reduce(flatten(add), 0),
- * ) // 15
- * ```
- *
- * @TODO flatten for each type
- */
-declare function flatten(value: any): any;

package/x/groupBy.d.ts

@@ -1,50 +0,0 @@
-export = groupBy;
-/**
- * @name groupBy
- *
- * @synopsis
- * ```coffeescript [specscript]
- * Reducer<T> = (any, T)=>Promise|any
- * Foldable<T> = Iterable<T>|AsyncIterable<T>|{ reduce: Reducer<T>=>any }|Object<T>
- *
- * var property any,
- *   resolver any=>Promise|any,
- *   value Foldable
- *
- * groupBy(property)(value) -> groupedByProperty Map<any=>Array>
- *
- * groupBy(resolver)(value) -> groupedByResolver Promise|Map<any=>Array>
- * ```
- *
- * @description
- * Group a foldable collection into a Map of arrays by a property on each of its elements.
- *
- * ```javascript [playground]
- * import groupBy from 'https://unpkg.com/rubico/dist/x/groupBy.es.js'
- *
- * console.log(
- *   groupBy('age')([
- *     { name: 'John', age: 22 },
- *     { name: 'Jane', age: 22 },
- *     { name: 'Henry', age: 23 },
- *   ]),
- * )
- * // Map {
- * //   22 => [{ name: 'John', age: 22 }, { name: 'Jane', age: 22 }],
- * //   23 => [{ name: 'Henry', age: 23 }],
- * // }
- * ```
- *
- * Additionally, pass a resolver in property position to resolve a value for group membership for each element.
- *
- * ```javascript [playground]
- * import groupBy from 'https://unpkg.com/rubico/dist/x/groupBy.es.js'
- *
- * console.log(
- *   groupBy(
- *     word => word.toLowerCase(),
- *   )(['Hello', 'hello', 'Hey']),
- * ) // Map { 'hello' => ['Hello', 'hello'], 'hey' => ['Hey'] }
- * ```
- */
-declare function groupBy(propertyOrResolver: any): any;

package/x/has.d.ts

@@ -1,25 +0,0 @@
-export = has;
-/**
- * @name has
- *
- * @synopsis
- * ```coffeescript [specscript]
- * has(key any)(container Set|Map|{ has: function }|Object) -> Promise|boolean
- * ```
- *
- * @description
- * Check if a collection has a key.
- *
- * ```javascript [playground]
- * import has from 'https://unpkg.com/rubico/dist/x/has.es.js'
- *
- * console.log(
- *   has('a')({ a: 1, b: 2, c: 3 }),
- * ) // true
- *
- * console.log(
- *   has('a')({}),
- * ) // false
- * ```
- */
-declare function has(key: any): (container: any) => any;

package/x/heapUsedInLoop.d.ts

@@ -1,53 +0,0 @@
-export = heapUsedInLoop;
-/**
- * @name heapUsedInLoop
- *
- * @catchphrase
- * max and avg heap used in loop
- *
- * @synopsis
- * heapUsedInLoop(
- *   desc string,
- *   loopCount number,
- *   func (loop number)=>any
- * ) -> ()
- *
- * @description
- * **heapUsedInLoop** is a memory usage measurement function. Supply `description`, `loopCount`, and a function `func` for that function to be run `loopCount` times, finally logging average and max heap used per loop in terms of megabytes MiB.
- *
- * ```javascript
- * heapUsedInLoop('my-description', 1e5, function () {
- *   return 1 + 1
- * }) /*
- * 0 5.88 MiB
- * 1 5.92 MiB
- * ...
- * 99997 7.34 MiB
- * 99998 7.34 MiB
- * 99999 7.35 MiB
- * my-description: 1e+5: {
- *   "max": "7.15 MiB",
- *   "avg": "5.50 MiB"
- * }
- * ```
- *
- * @node-only
- */
-declare function heapUsedInLoop(desc: any, loopCount: any, func: any): void;
-declare namespace heapUsedInLoop {
-    function skip(): void;
-    /**
-     * @name heapUsedInLoop.async
-     *
-     * @synopsis
-     * heapUsedInLoop.async(
-     *   desc string,
-     *   loopCount number,
-     *   func (loop number)=>Promise|any
-     * ) -> ()
-     */
-    function async(desc: any, loopCount: any, func: any): Promise<void>;
-    namespace async {
-        function skip(): void;
-    }
-}

package/x/identity.d.ts

@@ -1,21 +0,0 @@
-export = identity;
-/**
- * @name identity
- *
- * @synopsis
- * ```coffeescript [specscript]
- * identity(value any) -> value
- * ```
- *
- * @description
- * Pass a value and receive the same value back.
- *
- * ```javascript [playground]
- * import identity from 'https://unpkg.com/rubico/dist/x/identity.es.js'
- *
- * console.log(
- *   identity(1),
- * ) // 1
- * ```
- */
-declare function identity(value: any): any;

package/x/includes.d.ts

@@ -1,25 +0,0 @@
-export = includes;
-/**
- * @name includes
- *
- * @synopsis
- * ```coffeescript [specscript]
- * includes(value any)(container Array|String|Object) -> boolean
- * ```
- *
- * @description
- * Check if a collection includes another value by [SameValueZero](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero).
- *
- * ```javascript [playground]
- * import includes from 'https://unpkg.com/rubico/dist/x/includes.es.js'
- *
- * console.log(
- *   includes(5)([1, 2, 3, 4, 5])
- * ) // true
- *
- * console.log(
- *   includes(5)([1, 2, 3])
- * ) // false
- * ```
- */
-declare function includes(value: any): (container: any) => any;

package/x/index.d.ts

@@ -1,34 +0,0 @@
-import append = require("./append");
-import callProp = require("./callProp");
-import defaultsDeep = require("./defaultsDeep");
-import differenceWith = require("./differenceWith");
-import filterOut = require("./filterOut");
-import find = require("./find");
-import findIndex = require("./findIndex");
-import first = require("./first");
-import flatten = require("./flatten");
-import groupBy = require("./groupBy");
-import has = require("./has");
-import identity = require("./identity");
-import includes = require("./includes");
-import isDeepEqual = require("./isDeepEqual");
-import isEmpty = require("./isEmpty");
-import isEqual = require("./isEqual");
-import isFunction = require("./isFunction");
-import isObject = require("../_internal/isObject");
-import isString = require("./isString");
-import keys = require("./keys");
-import last = require("./last");
-import maxBy = require("./maxBy");
-import noop = require("./noop");
-import pluck = require("./pluck");
-import prepend = require("./prepend");
-import size = require("./size");
-import trace = require("./trace");
-import unionWith = require("./unionWith");
-import uniq = require("./uniq");
-import unless = require("./unless");
-import values = require("./values");
-import when = require("./when");
-import isIn = require("./isIn");
-export { append, callProp, defaultsDeep, differenceWith, filterOut, find, findIndex, first, flatten, groupBy, has, identity, includes, isDeepEqual, isEmpty, isEqual, isFunction, isObject, isString, keys, last, maxBy, noop, pluck, prepend, size, trace, unionWith, uniq, unless, values, when, isIn };

package/x/is.d.ts

@@ -1,2 +0,0 @@
-export = is;
-declare function is(constructor: any): (x: any) => boolean;

package/x/isDeepEqual.d.ts

@@ -1,42 +0,0 @@
-export = isDeepEqual;
-/**
- * @name isDeepEqual
- *
- * @synopsis
- * ```coffeescript [specscript]
- * Nested<T> = Array<Array<T>|Object<T>|Iterable<T>|T>|Object<Array<T>|Object<T>|Iterable<T>|T>
- *
- * var left Nested,
- *   right Nested
- *
- * isDeepEqual(left, right) -> boolean
- * ```
- *
- * @description
- * Check two values for deep [SameValueZero](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) equality.
- *
- * ```javascript [playground]
- * import isDeepEqual from 'https://unpkg.com/rubico/dist/x/isDeepEqual.es.js'
- *
- * console.log(
- *   isDeepEqual({ a: 1, b: 2, c: [3] }, { a: 1, b: 2, c: [3] }),
- * ) // true
- *
- * console.log(
- *   isDeepEqual({ a: 1, b: 2, c: [3] }, { a: 1, b: 2, c: [5] }),
- * ) // false
- * ```
- *
- * When passed a resolver function as the left or right argument or resolvers as both arguments, returns a function that resolves the value by the resolver before performing the deep equal comparison.
- *
- * ```javascript [playground]
- * import isDeepEqual from 'https://unpkg.com/rubico/dist/x/isDeepEqual.es.js'
- *
- * const isPropADeepEqualTo123Array = isDeepEqual(object => object.a, [1, 2, 3])
- *
- * console.log(
- *   isPropADeepEqualTo123Array({ a: [1, 2, 3] }),
- * ) // true
- * ```
- */
-declare function isDeepEqual(left: any, right: any): any;

package/x/isEmpty.d.ts

@@ -1,24 +0,0 @@
-export = isEmpty;
-/**
- * @name isEmpty
- *
- * @synopsis
- * ```coffeescript [specscript]
- * isEmpty(value any) -> boolean
- * ```
- *
- * @description
- * Check if a value is empty.
- *
- * ```javascript [playground]
- * import isEmpty from 'https://unpkg.com/rubico/dist/x/isEmpty.es.js'
- *
- * console.log('', isEmpty('')) // true
- * console.log([], isEmpty([])) // true
- * console.log({}, isEmpty({})) // true
- * console.log([1, 2, 3], isEmpty([1, 2, 3])) // false
- * console.log(new Set([1, 2, 3]), isEmpty(new Set([1, 2, 3]))) // false
- * console.log({ a: 1, b: 2, c: 3 }, isEmpty({ a: 1, b: 2, c: 3 })) // false
- * ```
- */
-declare function isEmpty(value: any): boolean;

package/x/isEqual.d.ts

@@ -1,2 +0,0 @@
-export = isEqual;
-declare function isEqual(a: any, b: any): boolean;

package/x/isFunction.d.ts

@@ -1,23 +0,0 @@
-export = isFunction;
-/**
- * @name isFunction
- *
- * @synopsis
- * ```coffeescript [specscript]
- * isFunction(value any) -> boolean
- * ```
- *
- * @description
- * Determine whether a value is a function.
- *
- * ```javascript [playground]
- * import isFunction from 'https://unpkg.com/rubico/dist/x/isFunction.es.js'
- *
- * const add = (a, b) => a + b
- *
- * console.log(
- *   isFunction(add),
- * ) // true
- * ```
- */
-declare function isFunction(value: any): boolean;

package/x/isIn.d.ts

@@ -1,61 +0,0 @@
-export = isIn;
-/**
- * @name isIn
- *
- * @synopsis
- * ```coffeescript [specscript]
- * isIn(container Array|Object|String|Set|Map)(value any) -> boolean
- * ```
- *
- * @description
- * Counterpart to includes. Check if a collection includes another value.
- *
- * ```javascript [playground]
- * import isIn from 'https://unpkg.com/rubico/dist/x/isIn.es.js'
- *
- * console.log(
- *   isIn([1, 2, 3](1)
- * ) // true
- *
- * console.log(
- *   isIn([1, 2, 3](4)
- * ) // false
- *
- * console.log(
- *   isIn({ a: 1 })(1)
- * ) // true
- *
- * console.log(
- *   isIn({ a: 1 })(2)
- * ) // true
- *
- * console.log(
- *   isIn('abc')('a')
- * ) // true
- *
- * console.log(
- *   isIn('abc')('ab')
- * ) // true
- *
- * console.log(
- *   isIn('abc')('d')
- * ) // false
- *
- * console.log(
- *   isIn(new Set([1, 2, 3]))(1)
- * ) // true
- *
- * console.log(
- *   isIn(new Set([1, 2, 3]))(4)
- * ) // false
- *
- * console.log(
- *   isIn(new Map([[1, 1], [2, 2], [3, 3]]))(1)
- * ) // true
- *
- * console.log(
- *   isIn(new Map([[1, 1], [2, 2], [3, 3]]))(4)
- * ) // false
- * ```
- */
-declare function isIn(...args: any[]): any;

package/x/isObject.d.ts

@@ -1,2 +0,0 @@
-export = isObject;
-import isObject = require("../_internal/isObject");

package/x/isString.benchmarks.d.ts

@@ -1 +0,0 @@
-export {};

package/x/isString.d.ts

@@ -1,21 +0,0 @@
-export = isString;
-/**
- * @name isString
- *
- * @synopsis
- * ```coffeescript [specscript]
- * isString(value any) -> boolean
- * ```
- *
- * @description
- * Determine whether a value is a string.
- *
- * ```javascript [playground]
- * import isString from 'https://unpkg.com/rubico/dist/x/isString.es.js'
- *
- * console.log(
- *   isString('hey'),
- * ) // true
- * ```
- */
-declare function isString(value: any): boolean;

package/x/keys.d.ts

@@ -1,23 +0,0 @@
-export = keys;
-/**
- * @name keys
- *
- * @synopsis
- * ```coffeescript [specscript]
- * keys(value string|Array|Set|Map|object) -> Array<key number|string>
- * ```
- *
- * @description
- * Get an array of keys from an instance.
- *
- * ```javascript [playground]
- * import keys from 'https://unpkg.com/rubico/dist/x/keys.es.js'
- *
- * console.log(keys({ a: 1, b: 2, c: 3 })) // ['a', 'b', 'c']
- * console.log(keys(['hello', 'world'])) // [0, 1]
- * console.log(keys(new Map([['hello', 1], ['world', 2]]))) // ['hello', 'world']
- * ```
- *
- * @since 1.6.25
- */
-declare function keys(object: any): any[];

package/x/last.d.ts

@@ -1,22 +0,0 @@
-export = last;
-/**
- * @name last
- *
- * @synopsis
- * ```coffeescript [specscript]
- * var value Array|string
- *
- * last(value) -> any
- * ```
- *
- * @description
- * Get the last element of a collection
- *
- * ```javascript [playground]
- * import last from 'https://unpkg.com/rubico/dist/x/last.es.js'
- *
- * console.log(last([1, 2, 3])) // 3
- * console.log(last([])) // undefined
- * ```
- */
-declare function last(value: any): any;

package/x/maxBy.d.ts

@@ -1,41 +0,0 @@
-export = maxBy;
-/**
- * @name maxBy
- *
- * @synopsis
- * ```coffeescript [specscript]
- * maxBy(array Array, path string) -> maxElementByPath any
- *
- * maxBy(path string)(array Array) -> maxElementByPath any
- * ```
- *
- * @description
- * Finds the element that is the max by a property denoted by path.
- *
- * ```javascript [playground]
- * import maxBy from 'https://unpkg.com/rubico/dist/x/maxBy.es.js'
- *
- * const array = [{ a: 1 }, { a: 2 }, { a: 3 }]
- *
- * const maxElement = maxBy(array, 'a')
- *
- * console.log(maxElement) // { a: 3 }
- * ```
- *
- * `maxBy` composes in a lazy way.
- *
- * ```javascript [playground]
- * import maxBy from 'https://unpkg.com/rubico/dist/x/maxBy.es.js'
- *
- * const numbers = [1, 2, 3]
- *
- * const maxElement = pipe(numbers, [
- *   map(number => number ** 2),
- *   map(number => ({ a: { b: { c: number } } })),
- *   maxBy('a.b.c')
- * ])
- *
- * console.log(maxElement) // { a: { b: { c: 9 } } }
- * ```
- */
-declare function maxBy(...args: any[]): any;

package/x/noop.d.ts

@@ -1,21 +0,0 @@
-export = noop;
-/**
- * @name noop
- *
- * @synopsis
- * ```coffeescript [specscript]
- * noop() -> undefined
- * ```
- *
- * @description
- * Doesn't do anything.
- *
- * ```javascript [playground]
- * import noop from 'https://unpkg.com/rubico/dist/x/noop.es.js'
- *
- * console.log(
- *   noop(),
- * ) // undefined
- * ```
- */
-declare function noop(): void;