ramda-adjunct 2.30.0 → 2.33.0

package/types/index.d.ts

@@ -14,6 +14,10 @@ declare namespace RamdaAdjunct {
         reduce<Acc>(fn: (acc: Acc, val: T) => Acc, initAcc: Acc): Acc;
     }
 
+    interface Filterable<T> {
+        filter(fn: (t: T) => Boolean): Filterable<T>;
+    }
+
     interface Semigroup {
         // https://www.typescriptlang.org/docs/handbook/advanced-types.html#polymorphic-this-types
         concat(other: this): this;
@@ -40,6 +44,7 @@ declare namespace RamdaAdjunct {
     interface Dictionary<T> { [key: string]: T; }
 
     type DictPred<T> = (value: T, key: string) => boolean;
+    type Primitive = string | number | bigint | boolean | undefined | null | symbol;
 
     interface Static {
         /**
@@ -62,6 +67,24 @@ declare namespace RamdaAdjunct {
          */
         isBoolean(val: any): val is boolean;
 
+        /**
+         * Checks if value is a primitive data type. There are 6 primitive data types: `string`, `number`, `bigint`, `boolean`, `undefined`, `symbol` and a special case of `null`.
+         * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Primitive_values
+         * for definition of what sub-types comprise a primitive.
+         */
+        isPrimitive<T>(val: T | Primitive): val is Primitive;
+
+        /**
+         * Checks if value is not a primitive data type. There are 6 primitive data types: `string`, `number`, `bigint`, `boolean`, `undefined`, `symbol` and a special case of `null`.
+         */
+        isNotPrimitive<T>(val: T | Primitive): val is T;
+
+        /**
+         * Checks if an object exists in another object's prototype chain.
+         */
+        isPrototypeOf(type: object, object: object): boolean;
+        isPrototypeOf(type: object): (object: object) => boolean;
+
         /**
          * Returns `true` if the given value is its type's empty value, `null` or `undefined`.
          */
@@ -95,7 +118,8 @@ declare namespace RamdaAdjunct {
         /**
          * Checks if input value is complement of `null` or `undefined`.
          */
-        isNotNil(val: any): boolean;
+        /* tslint:disable-next-line:no-null-undefined-union null or undefined is the accurate type here */
+        isNotNil<T>(val: T | null | undefined): val is T;
 
         /**
          * Checks if input value is complement of `null`.
@@ -331,6 +355,11 @@ declare namespace RamdaAdjunct {
          */
         isInteger(val: any): val is number;
 
+        /**
+         * Checks whether the passed value is a signed 32 bit `integer`.
+         */
+        isInteger32(val: any): boolean;
+
         /**
          * Checks whether the passed value is complement of `integer`.
          */
@@ -426,6 +455,12 @@ declare namespace RamdaAdjunct {
          */
         isSparseArray(val: any): boolean;
 
+        /**
+         * Checks whether the passed value is
+         * {@link https://github.com/getify/You-Dont-Know-JS/blob/9959fc904d584bbf0b02cf41c192f74ff4238581/types-grammar/ch4.md#the-curious-case-of-the-|a sentinel value}.
+         */
+        isSentinelValue(val: any): boolean;
+
         /**
          * A function that returns `undefined`.
          */
@@ -705,6 +740,28 @@ declare namespace RamdaAdjunct {
             (acc: TResult, list: R): TResult
         };
 
+        /**
+         * {@link http://ramdajs.com/docs/#filter|R.filter} function that more closely resembles `Array.prototype.filter`.
+         * It takes two new parameters to its callback function: the current index, and the entire list.
+         *
+         * `filterIndexed` implementation is simple: `
+         *  const filterIndexed = R.addIndex(R.filter);
+         * `
+         */
+        filterIndexed<T>(iterator: (elem: T, idx: number, list: T[]) => Boolean, list: ReadonlyArray<T>): T[];
+        filterIndexed<T>(iterator: (elem: T, idx: number, list: T[]) => Boolean): (list: ReadonlyArray<T>) => T[];
+        filterIndexed<T>(
+            iterator: (elem: T, idx: number, list: Dictionary<T>) => Boolean,
+            list: Dictionary<T>,
+        ): Dictionary<T>;
+        filterIndexed<T>(
+            iterator: (elem: T, idx: number, list: Dictionary<T>) => Boolean,
+        ): (list: Dictionary<T>) => Dictionary<T>;
+        filterIndexed<T>(iterator: (elem: T, idx: number, list: Filterable<T>) => Boolean, list: Filterable<T>): Filterable<T>;
+        filterIndexed<T>(iterator: (elem: T, idx: number, list: Filterable<T>) => Boolean): (list: Filterable<T>) => Filterable<Boolean>;
+        filterIndexed(iterator: (char: string, idx: number, str: string) => Boolean, str: string): string[];
+        filterIndexed(iterator: (char: string, idx: number, str: string) => Boolean): (str: string) => string[];
+
         /**
          * Given an `Iterable`(arrays are `Iterable`), or a promise of an `Iterable`,
          * which produces promises (or a mix of promises and values),
@@ -945,6 +1002,14 @@ declare namespace RamdaAdjunct {
             reject<T>(options: { timeout: number, value: T }): Promise<T>
         };
 
+        /**
+         * Composable shortcut for `Promise.catch`.
+         * The catchP function returns a Promise. It takes two arguments: a callback function for the rejections of the Promise
+         * and the promise instance itself.
+         */
+        catchP<A, B = unknown>(onRejected: (error: any) => B | Promise<B>, promise: Promise<A>): Promise<A | B>;
+        catchP<A, B = unknown>(onRejected: (error: any) => B | Promise<B>): (promise: Promise<A>) => Promise<A | B>;
+
         /**
          * Composable shortcut for `Promise.then`.
          * The thenP function returns a Promise. It takes two arguments: a callback function for the success of the Promise
@@ -1125,6 +1190,19 @@ declare namespace RamdaAdjunct {
         defaultWhen<DefVal, Val>(predicate: Function, defaultVal: DefVal): (val: Val) => DefVal | Val;
         defaultWhen(predicate: Function): <DefVal, Val>(defaultVal: DefVal) => (val: Val) => DefVal | Val;
 
+        /**
+         * Returns the first element of the list which matches the predicate.
+         * Returns default value if no element matches or matched element is `null`, `undefined` or `NaN`.
+         * Dispatches to the find method of the second argument, if present.
+         * Acts as a transducer if a transformer is given in list position.
+         */
+        findOr<DefVal, T>(defaultVal: DefVal, predicate: (element: T) => boolean, list: ReadonlyArray<T>): T | DefVal;
+        findOr<DefVal, T>(defaultVal: DefVal, predicate: (element: T) => boolean): (list: ReadonlyArray<T>) => T | DefVal;
+        findOr<DefVal, T>(defaultVal: DefVal): {
+            (predicate: (element: T) => boolean, list: ReadonlyArray<T>): T | DefVal;
+            (predicate: (element: T) => boolean): (list: ReadonlyArray<T>) => T | DefVal;
+        };
+
         /**
          * Y-combinator
          *
@@ -1434,6 +1512,12 @@ declare namespace RamdaAdjunct {
         invokeArgs(pathToMethod: string[], args: any[]): (obj: object) => any;
         invokeArgs(pathToMethod: string[]): (args: any[], obj: object) => any;
 
+        /**
+         * Invokes the method at path of object.
+         */
+        invoke(pathToMethod: string[], obj: object): any;
+        invoke(pathToMethod: string[]): (obj: object) => any;
+
         /**
          * Converts double-precision 64-bit binary format IEEE 754 to signed 32 bit integer number.
          */

package/.mocharc.js

@@ -1,9 +0,0 @@
-'use strict';
-
-module.exports = {
-  recursive: true,
-  spec: 'test/**/*.js',
-  require: ['test/mocha-bootstrap.js'],
-  reporter: 'mocha-multi-reporters',
-  'reporter-options': 'configFile=test/mocha-multi.json',
-};