si-funciona 2.6.1 → 2.7.0

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

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

@@ -1,97 +1,97 @@
-/**
- * Store the comparison result for an element that may exist in either of compared arrays.
- * - value stores the element value from the arrays being compared
- * - results has the comparison results where first index (0) is result for first compared array
- *   and the second index (1) will be the result for the second compared array
- * @example
- * // example of input and resulting output
- *
- * const arr1 = ['match1', 'firstMismatch1', 'match2', 'firstMismatch2', 'badMatch1']
- * const arr2 = ['match1', 'match2', 'secondMismatch1', 'badMatch1', 'badMatch1']
- *
- * // Taking the first element in both, then the value: 'match1' exists in both arrays
- * // compareArrayResult will be { value: 'match1', result: [0, 0] }
- * // First index of 0 indicates this value in the first array exists in the second array
- * // Second index of 0 indicates this value in the second array exists in the first array
- *
- * // Taking the second element in the first array, then the value: 'firstMismatch1' exists in only the first array
- * // compareArrayResult will be { value: 'firstMismatch1', result: [1, -1] }
- * // First index of 1 indicates this value in the first array might need to be added to the second array
- * // Second index of -1 indicates this value only exists in the first array
- *
- * // Taking the third element in the second array, then the value: 'secondMismatch1' exists in only the second array
- * // compareArrayResult will be { value: 'secondMismatch1', result: [-1, 1] }
- * // First index of -1 indicates this value only exists in the second array
- * // Second index of 1 indicates this value in the second array might need to be added to the first array
- * @typedef {Object.<string, string|Array.<number>>} module:arrayHelpers~compareArrayResult
- * @memberOf module:arrayHelpers
- * @property {string} value - The element value being compared
- * @property {Array.<Array.<string|number>>} keys - Keys in arrays associated with this value
- * @property {Array.<number>} result - The results in the order of the compared arrays
- */
-export type compareArrayResult = {
-    value: string;
-    keys: Array<Array<number | string>>;
-    result: Array<number>;
-};
-export type compareArrayResultMap = Array<compareArrayResult>;
-/**
- * Compare two Arrays and return the Object where the value for each property is as follows:
- * -1 to indicate val1 is less than val2
- * 0 to indicate both values are the equal
- * 1 to indicate val1 is greater than val2
- * The returned Object uses the element values as the property names
- * This functions works by first creating a concatenated array of all unique values. Then for each unique values,
- * convert to a string and use it as a new property name. Array filter each array checking if it has the unique value.
- * Use the lengths of these filtered arrays to compare. So if the first array has the value and the second one doesn't
- * the first length will be one or more and the second will be zero, if the both have the value then both will be one
- * or more.
- * @example
- * // example of input and resulting output
- * compareArrays(
- *   ['match1', 'firstMismatch1', 'match2', 'firstMismatch2', 'badMatch1'],
- *   ['match1', 'match2', 'secondMismatch1', 'badMatch1', 'badMatch1']
- * )
- * // unique array
- * ['match1', 'firstMismatch1', 'match2', 'firstMismatch2', 'badMatch1', 'secondMismatch1']
- * // result object
- * [
- *   {
- *     value: 'match1',
- *     keys: [[0], [0]],
- *     result: [0, 0]
- *   },
- *   {
- *     value: 'firstMismatch1',
- *     keys: [[1], []],
- *     result: [1, -1]
- *   },
- *   {
- *     value: 'match2',
- *     keys: [[2], [1]],
- *     result: [0, 0]
- *   },
- *   {
- *     value: 'firstMismatch2',
- *     keys: [[3], []],
- *     result: [1, -1]
- *   },
- *   {
- *     value: 'badMatch1',
- *     keys: [[4], [3, 4]],
- *     result: [0, 0]
- *   },
- *   {
- *     value: 'secondMismatch1',
- *     keys: [[], [2]],
- *     result: [-1, 1]
- *   }
- * ]
- *
- * @memberOf module:arrayHelpers
- * @param {...Array} arrays - The arrays to compare
- * @returns {Array.<module:arrayHelpers~compareArrayResult>}
- */
-declare const compareArrays: (...arrays: Array<Array<any>>) => compareArrayResultMap;
-export default compareArrays;
+/**
+ * Store the comparison result for an element that may exist in either of compared arrays.
+ * - value stores the element value from the arrays being compared
+ * - results has the comparison results where first index (0) is result for first compared array
+ *   and the second index (1) will be the result for the second compared array
+ * @example
+ * // example of input and resulting output
+ *
+ * const arr1 = ['match1', 'firstMismatch1', 'match2', 'firstMismatch2', 'badMatch1']
+ * const arr2 = ['match1', 'match2', 'secondMismatch1', 'badMatch1', 'badMatch1']
+ *
+ * // Taking the first element in both, then the value: 'match1' exists in both arrays
+ * // compareArrayResult will be { value: 'match1', result: [0, 0] }
+ * // First index of 0 indicates this value in the first array exists in the second array
+ * // Second index of 0 indicates this value in the second array exists in the first array
+ *
+ * // Taking the second element in the first array, then the value: 'firstMismatch1' exists in only the first array
+ * // compareArrayResult will be { value: 'firstMismatch1', result: [1, -1] }
+ * // First index of 1 indicates this value in the first array might need to be added to the second array
+ * // Second index of -1 indicates this value only exists in the first array
+ *
+ * // Taking the third element in the second array, then the value: 'secondMismatch1' exists in only the second array
+ * // compareArrayResult will be { value: 'secondMismatch1', result: [-1, 1] }
+ * // First index of -1 indicates this value only exists in the second array
+ * // Second index of 1 indicates this value in the second array might need to be added to the first array
+ * @typedef {Object.<string, string|Array.<number>>} module:arrayHelpers~compareArrayResult
+ * @memberOf module:arrayHelpers
+ * @property {string} value - The element value being compared
+ * @property {Array.<Array.<string|number>>} keys - Keys in arrays associated with this value
+ * @property {Array.<number>} result - The results in the order of the compared arrays
+ */
+export type compareArrayResult = {
+    value: string;
+    keys: Array<Array<number | string>>;
+    result: Array<number>;
+};
+export type compareArrayResultMap = Array<compareArrayResult>;
+/**
+ * Compare two Arrays and return the Object where the value for each property is as follows:
+ * -1 to indicate val1 is less than val2
+ * 0 to indicate both values are the equal
+ * 1 to indicate val1 is greater than val2
+ * The returned Object uses the element values as the property names
+ * This functions works by first creating a concatenated array of all unique values. Then for each unique values,
+ * convert to a string and use it as a new property name. Array filter each array checking if it has the unique value.
+ * Use the lengths of these filtered arrays to compare. So if the first array has the value and the second one doesn't
+ * the first length will be one or more and the second will be zero, if the both have the value then both will be one
+ * or more.
+ * @example
+ * // example of input and resulting output
+ * compareArrays(
+ *   ['match1', 'firstMismatch1', 'match2', 'firstMismatch2', 'badMatch1'],
+ *   ['match1', 'match2', 'secondMismatch1', 'badMatch1', 'badMatch1']
+ * )
+ * // unique array
+ * ['match1', 'firstMismatch1', 'match2', 'firstMismatch2', 'badMatch1', 'secondMismatch1']
+ * // result object
+ * [
+ *   {
+ *     value: 'match1',
+ *     keys: [[0], [0]],
+ *     result: [0, 0]
+ *   },
+ *   {
+ *     value: 'firstMismatch1',
+ *     keys: [[1], []],
+ *     result: [1, -1]
+ *   },
+ *   {
+ *     value: 'match2',
+ *     keys: [[2], [1]],
+ *     result: [0, 0]
+ *   },
+ *   {
+ *     value: 'firstMismatch2',
+ *     keys: [[3], []],
+ *     result: [1, -1]
+ *   },
+ *   {
+ *     value: 'badMatch1',
+ *     keys: [[4], [3, 4]],
+ *     result: [0, 0]
+ *   },
+ *   {
+ *     value: 'secondMismatch1',
+ *     keys: [[], [2]],
+ *     result: [-1, 1]
+ *   }
+ * ]
+ *
+ * @memberOf module:arrayHelpers
+ * @param {...Array} arrays - The arrays to compare
+ * @returns {Array.<module:arrayHelpers~compareArrayResult>}
+ */
+declare const compareArrays: (...arrays: Array<Array<any>>) => compareArrayResultMap;
+export default compareArrays;
 //# sourceMappingURL=compareArrays.d.ts.map