si-funciona 2.6.1 → 2.6.2

package/README.md

@@ -249,6 +249,7 @@ Simplify working with object by providing array-like parsing. Also, provides clo
         * [.mapObject(obj, fn, [thisArg])](#module_objectHelpers.mapObject) ⇒ <code>Object</code> \| <code>Array</code>
         * [.isObject(object)](#module_objectHelpers.isObject) ⇒ <code>boolean</code>
         * [.isInstanceObject(object)](#module_objectHelpers.isInstanceObject) ⇒ <code>boolean</code>
+        * [.isEqual(first, second)](#module_objectHelpers.isEqual) ⇒ <code>boolean</code>
         * [.isCloneable(value)](#module_objectHelpers.isCloneable) ⇒ <code>boolean</code>
         * [.filterObject(obj, fn, [thisArg])](#module_objectHelpers.filterObject) ⇒ <code>Object</code> \| <code>Array</code>
         * [.emptyObject(item)](#module_objectHelpers.emptyObject) ⇒ <code>boolean</code>
@@ -409,6 +410,26 @@ Check if the current object has inherited properties.
 | --- | --- |
 | object | <code>Object</code> \| <code>Array</code> | 
 
+<a name="module_objectHelpers.isEqual"></a>
+
+### objectHelpers.isEqual(first, second) ⇒ <code>boolean</code>
+Check whether two values are equal by value, however they are stored: two separately made arrays or objects with the
+same contents are equal, while two references only need to be the same when the value is a function.
+- Primitives are equal when they are the same value (and NaN equals NaN)
+- Arrays are equal when they have the same elements in the same order
+- Objects are equal when they have the same prototype (the same kind of object) and the same own properties with
+equal values, the order of the properties does not matter
+- Dates, regular expressions, Maps and Sets are compared by what they hold
+- Circular references are handled: a pair of objects which is already being compared is taken to be equal
+
+**Kind**: static method of [<code>objectHelpers</code>](#module_objectHelpers)  
+**Returns**: <code>boolean</code> - True when the values are equal.  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| first | <code>\*</code> | The first value. |
+| second | <code>\*</code> | The second value. |
+
 <a name="module_objectHelpers.isCloneable"></a>
 
 ### objectHelpers.isCloneable(value) ⇒ <code>boolean</code>
@@ -577,31 +598,40 @@ Reduce several numbers to their simplest form / ratio
 <a name="module_numberHelpers.randomNumber"></a>
 
 ### numberHelpers.randomNumber(range, [offset], [interval]) ⇒ <code>number</code>
-Create a single random number within provided range. And with optional offset,
-The distance between the result numbers can be adjusted with interval.
+Create a single random number from offset up to (but never including) offset + range. With optional offset,
+the distance between the result numbers can be adjusted with interval. Matches randomInteger, which gives the
+whole numbers of the same span.
 
 **Kind**: static method of [<code>numberHelpers</code>](#module_numberHelpers)  
 
 | Param | Type | Default | Description |
 | --- | --- | --- | --- |
-| range | <code>number</code> |  | Choose the breadth of the random number (0-100 would be 100 for range) |
-| [offset] | <code>number</code> | <code>0</code> | Choose the starting number (1-10 would be 1 for offset, 9 for range) |
-| [interval] | <code>number</code> | <code>1</code> | Choose the distance between numbers (~5, ~10, ~15 would be 5 for interval, 1 for offset, 2 for range) |
+| range | <code>number</code> |  | Choose the breadth of the random number (0 up to, but not including, 100 would be 100 for range) |
+| [offset] | <code>number</code> | <code>0</code> | Choose the starting number (1 up to, but not including, 10 would be 1 for offset, 9 for range) |
+| [interval] | <code>number</code> | <code>1</code> | Choose the multiplier applied to the result (~5, ~10, ~15 would be 5 for interval, 1 for offset, 2 for range) |
 
 <a name="module_numberHelpers.randomInteger"></a>
 
 ### numberHelpers.randomInteger(range, [offset], [interval]) ⇒ <code>number</code>
-Create a single random integer within provide range. And with optional offset,
-The distance between the result numbers can be adjusted with interval.
+Create a single random integer from a set of `range` possible values, starting at the optional offset.
+With no offset the result is 0 to range - 1 (so range is the number of possible values, the same as an array length
+when choosing an index). The distance between the result numbers can be adjusted with interval.
 
 **Kind**: static method of [<code>numberHelpers</code>](#module_numberHelpers)  
 
 | Param | Type | Default | Description |
 | --- | --- | --- | --- |
-| range | <code>number</code> |  | Choose the breadth of the random number (0-100 would be 100 for range) |
-| [offset] | <code>number</code> | <code>0</code> | Choose the starting number (1-10 would be 1 for offset, 9 for range) |
-| [interval] | <code>number</code> | <code>1</code> | Choose the distance between numbers (5, 10, 15 would be 5 for interval, 1 for offset, 2 for range) |
+| range | <code>number</code> |  | The number of possible values (0-99 would be 100 for range) |
+| [offset] | <code>number</code> | <code>0</code> | Choose the starting number (1-10 would be 1 for offset, 10 for range) |
+| [interval] | <code>number</code> | <code>1</code> | Choose the distance between numbers (5, 10, 15 would be 5 for interval, 1 for offset, 3 for range) |
 
+**Example**  
+```js
+randomInteger(1) // always 0 (one possible value)
+randomInteger(2) // 0 or 1
+randomInteger(3, 1, 5) // 5, 10 or 15
+items[randomInteger(items.length)] // a random valid index
+```
 <a name="module_numberHelpers.lowestCommonDenominator"></a>
 
 ### numberHelpers.lowestCommonDenominator(...numbers) ⇒ <code>number</code>

package/browser/siFunciona.js

@@ -1707,13 +1707,19 @@
     })
     exports.default = void 0
     /**
- * Create a single random integer within provide range. And with optional offset,
- * The distance between the result numbers can be adjusted with interval.
+ * Create a single random integer from a set of `range` possible values, starting at the optional offset.
+ * With no offset the result is 0 to range - 1 (so range is the number of possible values, the same as an array length
+ * when choosing an index). The distance between the result numbers can be adjusted with interval.
+ * @example
+ * randomInteger(1) // always 0 (one possible value)
+ * randomInteger(2) // 0 or 1
+ * randomInteger(3, 1, 5) // 5, 10 or 15
+ * items[randomInteger(items.length)] // a random valid index
  * @memberOf module:numberHelpers
- * @param {number} range - Choose the breadth of the random number (0-100 would be 100 for range)
- * @param {number} [offset=0] - Choose the starting number (1-10 would be 1 for offset, 9 for range)
+ * @param {number} range - The number of possible values (0-99 would be 100 for range)
+ * @param {number} [offset=0] - Choose the starting number (1-10 would be 1 for offset, 10 for range)
  * @param {number} [interval=1] - Choose the distance between numbers (5, 10, 15 would be 5 for interval, 1 for
- * offset, 2 for range)
+ * offset, 3 for range)
  * @returns {number}
  */
     const randomInteger = (range, offset = 0, interval = 1) => (Math.floor(Math.random() * range) + offset) * interval
@@ -1727,13 +1733,14 @@
     })
     exports.default = void 0
     /**
- * Create a single random number within provided range. And with optional offset,
- * The distance between the result numbers can be adjusted with interval.
+ * Create a single random number from offset up to (but never including) offset + range. With optional offset,
+ * the distance between the result numbers can be adjusted with interval. Matches randomInteger, which gives the
+ * whole numbers of the same span.
  * @memberOf module:numberHelpers
- * @param {number} range - Choose the breadth of the random number (0-100 would be 100 for range)
- * @param {number} [offset=0] - Choose the starting number (1-10 would be 1 for offset, 9 for range)
- * @param {number} [interval=1] - Choose the distance between numbers (~5, ~10, ~15 would be 5 for interval, 1 for
- * offset, 2 for range)
+ * @param {number} range - Choose the breadth of the random number (0 up to, but not including, 100 would be 100 for range)
+ * @param {number} [offset=0] - Choose the starting number (1 up to, but not including, 10 would be 1 for offset, 9 for range)
+ * @param {number} [interval=1] - Choose the multiplier applied to the result (~5, ~10, ~15 would be 5 for interval,
+ * 1 for offset, 2 for range)
  * @returns {number}
  */
     const randomNumber = (range, offset = 0, interval = 1) => (Math.random() * range + offset) * interval

package/dist/helpers/arrays/BasicQueue.d.ts

@@ -1,65 +1,65 @@
-export type callableLater = {
-    fn?: Function;
-    args?: Array<any>;
-};
-export type queuedItem = {
-    item: callableLater | any;
-    generator: Generator;
-};
-/**
- * Define the format of a queue.
- * @typedef {Object} IsQueue
- * @memberOf module:arrayHelpers
- * @property {Array|*} innerList - Stores the data for the queue
- * @method dequeue - Pulls the first item from the queue
- * @method empty - Check if the queue is empty
- * @method enqueue - Adds and item to the end of the queue
- * @method peek - Get the next queue item but does not remove it
- * @method size - Get the size of the queue
- */
-export interface IsQueue<queuedItem> {
-    dequeue: () => queuedItem | null;
-    empty: () => boolean;
-    enqueue: (data: queuedItem) => void;
-    peek: () => queuedItem | null;
-    size: () => number;
-}
-/**
- * Class BasicQueue is a functional example of a queue to be used with queueManager.
- * @memberOf module:arrayHelpers
- */
-declare class BasicQueue implements IsQueue<queuedItem> {
-    private readonly innerList;
-    /**
-     * @param {Array} [innerList=[]] - Items to pre-populate the queue with, in order.
-     */
-    constructor(innerList?: queuedItem[] | any);
-    /**
-     * Remove and return the next item in the queue
-     * @returns {queuedItem|*}
-     */
-    dequeue(): queuedItem | any;
-    /**
-     * Check if the queue is empty
-     * @returns {boolean}
-     */
-    empty(): boolean;
-    /**
-     * Add an item to the end of the queue
-     * @param {queuedItem|*} data
-     * @returns {BasicQueue}
-     */
-    enqueue(data: queuedItem | any): IsQueue<queuedItem>;
-    /**
-     * Retrieve the next item from the queue
-     * @returns {queuedItem|*}
-     */
-    peek(): queuedItem | any;
-    /**
-     * Get the quantity of items in the queue
-     * @returns {number}
-     */
-    size(): number;
-}
-export default BasicQueue;
+export type callableLater = {
+    fn?: Function;
+    args?: Array<any>;
+};
+export type queuedItem = {
+    item: callableLater | any;
+    generator: Generator;
+};
+/**
+ * Define the format of a queue.
+ * @typedef {Object} IsQueue
+ * @memberOf module:arrayHelpers
+ * @property {Array|*} innerList - Stores the data for the queue
+ * @method dequeue - Pulls the first item from the queue
+ * @method empty - Check if the queue is empty
+ * @method enqueue - Adds and item to the end of the queue
+ * @method peek - Get the next queue item but does not remove it
+ * @method size - Get the size of the queue
+ */
+export interface IsQueue<queuedItem> {
+    dequeue: () => queuedItem | null;
+    empty: () => boolean;
+    enqueue: (data: queuedItem) => void;
+    peek: () => queuedItem | null;
+    size: () => number;
+}
+/**
+ * Class BasicQueue is a functional example of a queue to be used with queueManager.
+ * @memberOf module:arrayHelpers
+ */
+declare class BasicQueue implements IsQueue<queuedItem> {
+    private readonly innerList;
+    /**
+     * @param {Array} [innerList=[]] - Items to pre-populate the queue with, in order.
+     */
+    constructor(innerList?: queuedItem[] | any);
+    /**
+     * Remove and return the next item in the queue
+     * @returns {queuedItem|*}
+     */
+    dequeue(): queuedItem | any;
+    /**
+     * Check if the queue is empty
+     * @returns {boolean}
+     */
+    empty(): boolean;
+    /**
+     * Add an item to the end of the queue
+     * @param {queuedItem|*} data
+     * @returns {BasicQueue}
+     */
+    enqueue(data: queuedItem | any): IsQueue<queuedItem>;
+    /**
+     * Retrieve the next item from the queue
+     * @returns {queuedItem|*}
+     */
+    peek(): queuedItem | any;
+    /**
+     * Get the quantity of items in the queue
+     * @returns {number}
+     */
+    size(): number;
+}
+export default BasicQueue;
 //# sourceMappingURL=BasicQueue.d.ts.map

package/dist/helpers/arrays/BasicQueue.js

@@ -1,61 +1,61 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.default = void 0
-/**
- * Class BasicQueue is a functional example of a queue to be used with queueManager.
- * @memberOf module:arrayHelpers
- */
-class BasicQueue {
-  /**
-   * @param {Array} [innerList=[]] - Items to pre-populate the queue with, in order.
-   */
-  constructor (innerList = []) {
-    this.innerList = innerList
-  }
-
-  /**
-   * Remove and return the next item in the queue
-   * @returns {queuedItem|*}
-   */
-  dequeue () {
-    return this.innerList.shift()
-  }
-
-  /**
-   * Check if the queue is empty
-   * @returns {boolean}
-   */
-  empty () {
-    return !this.size()
-  }
-
-  /**
-   * Add an item to the end of the queue
-   * @param {queuedItem|*} data
-   * @returns {BasicQueue}
-   */
-  enqueue (data) {
-    this.innerList.push(data)
-    return this
-  }
-
-  /**
-   * Retrieve the next item from the queue
-   * @returns {queuedItem|*}
-   */
-  peek () {
-    return this.empty() ? null : this.innerList[0]
-  }
-
-  /**
-   * Get the quantity of items in the queue
-   * @returns {number}
-   */
-  size () {
-    return this.innerList.length
-  }
-}
-const _default = exports.default = BasicQueue
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.default = void 0
+/**
+ * Class BasicQueue is a functional example of a queue to be used with queueManager.
+ * @memberOf module:arrayHelpers
+ */
+class BasicQueue {
+  /**
+   * @param {Array} [innerList=[]] - Items to pre-populate the queue with, in order.
+   */
+  constructor (innerList = []) {
+    this.innerList = innerList
+  }
+
+  /**
+   * Remove and return the next item in the queue
+   * @returns {queuedItem|*}
+   */
+  dequeue () {
+    return this.innerList.shift()
+  }
+
+  /**
+   * Check if the queue is empty
+   * @returns {boolean}
+   */
+  empty () {
+    return !this.size()
+  }
+
+  /**
+   * Add an item to the end of the queue
+   * @param {queuedItem|*} data
+   * @returns {BasicQueue}
+   */
+  enqueue (data) {
+    this.innerList.push(data)
+    return this
+  }
+
+  /**
+   * Retrieve the next item from the queue
+   * @returns {queuedItem|*}
+   */
+  peek () {
+    return this.empty() ? null : this.innerList[0]
+  }
+
+  /**
+   * Get the quantity of items in the queue
+   * @returns {number}
+   */
+  size () {
+    return this.innerList.length
+  }
+}
+const _default = exports.default = BasicQueue

package/dist/helpers/arrays/addUniqueToArray.d.ts

@@ -1,10 +1,10 @@
-/**
- * Having an array and a potential new array element, check if the element is in the array, if not append to array.
- * @memberOf module:arrayHelpers
- * @param {*} item - An potential array element, possibly a DomItem
- * @param {Array} array - An array where an element may be appended.
- * @returns {Array}
- */
-declare const addUniqueToArray: (item: any, array: Array<any>) => Array<any>;
-export default addUniqueToArray;
+/**
+ * Having an array and a potential new array element, check if the element is in the array, if not append to array.
+ * @memberOf module:arrayHelpers
+ * @param {*} item - An potential array element, possibly a DomItem
+ * @param {Array} array - An array where an element may be appended.
+ * @returns {Array}
+ */
+declare const addUniqueToArray: (item: any, array: Array<any>) => Array<any>;
+export default addUniqueToArray;
 //# sourceMappingURL=addUniqueToArray.d.ts.map

package/dist/helpers/arrays/addUniqueToArray.js

@@ -1,16 +1,16 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.default = void 0
-require('core-js/modules/es.array.includes.js')
-/**
- * Having an array and a potential new array element, check if the element is in the array, if not append to array.
- * @memberOf module:arrayHelpers
- * @param {*} item - An potential array element, possibly a DomItem
- * @param {Array} array - An array where an element may be appended.
- * @returns {Array}
- */
-const addUniqueToArray = (item, array) => !array.includes(item) ? array.concat([item]) : array
-const _default = exports.default = addUniqueToArray
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.default = void 0
+require('core-js/modules/es.array.includes.js')
+/**
+ * Having an array and a potential new array element, check if the element is in the array, if not append to array.
+ * @memberOf module:arrayHelpers
+ * @param {*} item - An potential array element, possibly a DomItem
+ * @param {Array} array - An array where an element may be appended.
+ * @returns {Array}
+ */
+const addUniqueToArray = (item, array) => !array.includes(item) ? array.concat([item]) : array
+const _default = exports.default = addUniqueToArray

package/dist/helpers/arrays/buildArray.d.ts

@@ -1,11 +1,11 @@
-/**
- * Leverage buildArrayBase to generate an array filled with a copy of the provided item.
- * The length defines how long the array should be.
- * @memberOf module:arrayHelpers
- * @param {*} item - The item to be used for each array element
- * @param {number} length - The desired length of the array
- * @returns {Array.<*>}
- */
-declare const buildArray: (item: any, length: number) => Array<any>;
-export default buildArray;
+/**
+ * Leverage buildArrayBase to generate an array filled with a copy of the provided item.
+ * The length defines how long the array should be.
+ * @memberOf module:arrayHelpers
+ * @param {*} item - The item to be used for each array element
+ * @param {number} length - The desired length of the array
+ * @returns {Array.<*>}
+ */
+declare const buildArray: (item: any, length: number) => Array<any>;
+export default buildArray;
 //# sourceMappingURL=buildArray.d.ts.map

package/dist/helpers/arrays/buildArray.js

@@ -1,25 +1,25 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.default = void 0
-const _cloneObject = _interopRequireDefault(require('../objects/cloneObject'))
-function _interopRequireDefault (e) { return e && e.__esModule ? e : { default: e } }
-/**
- * Leverage buildArrayBase to generate an array filled with a copy of the provided item.
- * The length defines how long the array should be.
- * @memberOf module:arrayHelpers
- * @param {*} item - The item to be used for each array element
- * @param {number} length - The desired length of the array
- * @returns {Array.<*>}
- */
-const buildArray = (item, length) => {
-  const arr = []
-  while (arr.length < length) {
-    const cloned = (0, _cloneObject.default)(item)
-    arr.push(cloned)
-  }
-  return arr
-}
-const _default = exports.default = buildArray
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.default = void 0
+const _cloneObject = _interopRequireDefault(require('../objects/cloneObject'))
+function _interopRequireDefault (e) { return e && e.__esModule ? e : { default: e } }
+/**
+ * Leverage buildArrayBase to generate an array filled with a copy of the provided item.
+ * The length defines how long the array should be.
+ * @memberOf module:arrayHelpers
+ * @param {*} item - The item to be used for each array element
+ * @param {number} length - The desired length of the array
+ * @returns {Array.<*>}
+ */
+const buildArray = (item, length) => {
+  const arr = []
+  while (arr.length < length) {
+    const cloned = (0, _cloneObject.default)(item)
+    arr.push(cloned)
+  }
+  return arr
+}
+const _default = exports.default = buildArray

package/dist/helpers/arrays/buildArrayOfReferences.d.ts

@@ -1,11 +1,11 @@
-/**
- * Leverage buildArrayBase to generate an array filled with references to the provided item.
- * The length defines how long the array should be.
- * @memberOf module:arrayHelpers
- * @param {*} item - The item to be used for each array element
- * @param {number} length - The desired length of the array
- * @returns {Array.<*>}
- */
-declare const buildArrayOfReferences: (item: any, length: number) => Array<any>;
-export default buildArrayOfReferences;
+/**
+ * Leverage buildArrayBase to generate an array filled with references to the provided item.
+ * The length defines how long the array should be.
+ * @memberOf module:arrayHelpers
+ * @param {*} item - The item to be used for each array element
+ * @param {number} length - The desired length of the array
+ * @returns {Array.<*>}
+ */
+declare const buildArrayOfReferences: (item: any, length: number) => Array<any>;
+export default buildArrayOfReferences;
 //# sourceMappingURL=buildArrayOfReferences.d.ts.map

package/dist/helpers/arrays/buildArrayOfReferences.js

@@ -1,22 +1,22 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.default = void 0
-/**
- * Leverage buildArrayBase to generate an array filled with references to the provided item.
- * The length defines how long the array should be.
- * @memberOf module:arrayHelpers
- * @param {*} item - The item to be used for each array element
- * @param {number} length - The desired length of the array
- * @returns {Array.<*>}
- */
-const buildArrayOfReferences = (item, length) => {
-  const arr = []
-  while (arr.length < length) {
-    arr.push(item)
-  }
-  return arr
-}
-const _default = exports.default = buildArrayOfReferences
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.default = void 0
+/**
+ * Leverage buildArrayBase to generate an array filled with references to the provided item.
+ * The length defines how long the array should be.
+ * @memberOf module:arrayHelpers
+ * @param {*} item - The item to be used for each array element
+ * @param {number} length - The desired length of the array
+ * @returns {Array.<*>}
+ */
+const buildArrayOfReferences = (item, length) => {
+  const arr = []
+  while (arr.length < length) {
+    arr.push(item)
+  }
+  return arr
+}
+const _default = exports.default = buildArrayOfReferences