si-funciona 2.3.3 → 2.3.4

package/dist/helpers/descriptors.js

@@ -1,42 +1,58 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.default = void 0
-require('core-js/stable')
-var _assignDescriptor = _interopRequireDefault(require('./descriptors/assignDescriptor'))
-var _assignDescriptorDetail = _interopRequireDefault(require('./descriptors/assignDescriptorDetail'))
-var _checkClearValues = _interopRequireDefault(require('./descriptors/checkClearValues'))
-var _checkDescriptorComplete = _interopRequireDefault(require('./descriptors/checkDescriptorComplete'))
-var _cloneDescriptor = _interopRequireDefault(require('./descriptors/cloneDescriptor'))
-var _cloneDescriptorDetail = _interopRequireDefault(require('./descriptors/cloneDescriptorDetail'))
-var _compareDescriptor = _interopRequireDefault(require('./descriptors/compareDescriptor'))
-var _describeObject = _interopRequireDefault(require('./descriptors/describeObject'))
-var _describeObjectMap = _interopRequireDefault(require('./descriptors/describeObjectMap'))
-var _describeObjectDetail = _interopRequireDefault(require('./descriptors/describeObjectDetail'))
-var _nextReference = _interopRequireDefault(require('./descriptors/nextReference'))
-var _sameDescriptor = _interopRequireDefault(require('./descriptors/sameDescriptor'))
-function _interopRequireDefault (e) { return e && e.__esModule ? e : { default: e } }
-/**
- * Create a format to standardize every object into a specific template.
- * @file
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
- * @module objectDescriptors
- * @memberOf module:siFunciona
- */
-var _default = exports.default = {
-  assignDescriptor: _assignDescriptor.default,
-  assignDescriptorDetail: _assignDescriptorDetail.default,
-  checkClearValues: _checkClearValues.default,
-  checkDescriptorComplete: _checkDescriptorComplete.default,
-  cloneDescriptor: _cloneDescriptor.default,
-  cloneDescriptorDetail: _cloneDescriptorDetail.default,
-  compareDescriptor: _compareDescriptor.default,
-  describeObject: _describeObject.default,
-  describeObjectMap: _describeObjectMap.default,
-  describeObjectDetail: _describeObjectDetail.default,
-  nextReference: _nextReference.default,
-  sameDescriptor: _sameDescriptor.default
-}
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.default = void 0
+require('core-js/stable')
+var _assignDescriptor = _interopRequireDefault(require('./descriptors/assignDescriptor'))
+var _assignDescriptorDetail = _interopRequireDefault(require('./descriptors/assignDescriptorDetail'))
+var _checkClearValues = _interopRequireDefault(require('./descriptors/checkClearValues'))
+var _checkDescriptorComplete = _interopRequireDefault(require('./descriptors/checkDescriptorComplete'))
+var _cloneDescriptor = _interopRequireDefault(require('./descriptors/cloneDescriptor'))
+var _cloneDescriptorDetail = _interopRequireDefault(require('./descriptors/cloneDescriptorDetail'))
+var _compareDescriptor = _interopRequireDefault(require('./descriptors/compareDescriptor'))
+var _describeObject = _interopRequireDefault(require('./descriptors/describeObject'))
+var _describeObjectMap = _interopRequireDefault(require('./descriptors/describeObjectMap'))
+var _describeObjectDetail = _interopRequireDefault(require('./descriptors/describeObjectDetail'))
+var _nextReference = _interopRequireDefault(require('./descriptors/nextReference'))
+var _sameDescriptor = _interopRequireDefault(require('./descriptors/sameDescriptor'))
+function _interopRequireDefault (e) { return e && e.__esModule ? e : { default: e } }
+/**
+ * A "descriptor" is a flat, serializable snapshot of an object or array's shape: for each property, its type(s),
+ * whether it's nullable, and - if the property's own value is itself an object/array - a reference to that nested
+ * value's own descriptor elsewhere in the same list, rather than nesting descriptors inside descriptors. This flat,
+ * reference-based structure is what lets these utilities walk deeply nested and even circular object graphs (an
+ * object that contains itself, directly or indirectly) without infinite recursion, since a value that's already
+ * been described is simply pointed to again instead of re-described.
+ *
+ * Start with {@link module:objectDescriptors.describeObjectMap}, which takes any real object or array and produces
+ * this flat list of descriptors for you - the other functions here (comparing, merging, cloning descriptors) are
+ * building blocks used internally, or useful once you already have descriptors to work with directly.
+ *
+ * The concrete use this module has earned its keep on: describing two objects and comparing the results tells
+ * you whether they're the same shape and values even when they're different references entirely (see
+ * {@link module:objectDescriptors.sameDescriptor}/{@link module:objectDescriptors.compareDescriptor}) - useful
+ * anywhere you need to check that two objects genuinely match without caring whether they're literally the same
+ * instance. A descriptor also doubles as a flat, structured summary of an object's shape, which can be handy for
+ * discussion or assessment purposes (e.g. describing what an object looks like without dumping the whole thing).
+ * @file
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ * @module objectDescriptors
+ * @memberOf module:siFunciona
+ */
+var _default = exports.default = {
+  assignDescriptor: _assignDescriptor.default,
+  assignDescriptorDetail: _assignDescriptorDetail.default,
+  checkClearValues: _checkClearValues.default,
+  checkDescriptorComplete: _checkDescriptorComplete.default,
+  cloneDescriptor: _cloneDescriptor.default,
+  cloneDescriptorDetail: _cloneDescriptorDetail.default,
+  compareDescriptor: _compareDescriptor.default,
+  describeObject: _describeObject.default,
+  describeObjectMap: _describeObjectMap.default,
+  describeObjectDetail: _describeObjectDetail.default,
+  nextReference: _nextReference.default,
+  sameDescriptor: _sameDescriptor.default
+}

package/dist/helpers/functions/makeBasicQueue.d.ts

@@ -1,11 +1,11 @@
-import 'core-js/stable';
-import { IsQueue, queuedItem } from '../arrays/BasicQueue';
-/**
- * Create an instance of a basic queue.
- * @memberOf module:functionHelpers
- * @param {Array} initialQueue
- * @returns {IsQueue}
- */
-declare const makeBasicQueue: (initialQueue?: queuedItem[] | any) => IsQueue<any>;
-export default makeBasicQueue;
+import 'core-js/stable';
+import { IsQueue, queuedItem } from '../arrays/BasicQueue';
+/**
+ * Create an instance of a basic queue.
+ * @memberOf module:functionHelpers
+ * @param {Array} [initialQueue=[]] - Items to pre-populate the queue with, in order.
+ * @returns {IsQueue}
+ */
+declare const makeBasicQueue: (initialQueue?: queuedItem[] | any) => IsQueue<any>;
+export default makeBasicQueue;
 //# sourceMappingURL=makeBasicQueue.d.ts.map

package/dist/helpers/functions/makeBasicQueue.js

@@ -1,19 +1,19 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.default = void 0
-require('core-js/stable')
-var _BasicQueue = _interopRequireDefault(require('../arrays/BasicQueue'))
-function _interopRequireDefault (e) { return e && e.__esModule ? e : { default: e } }
-/**
- * Create an instance of a basic queue.
- * @memberOf module:functionHelpers
- * @param {Array} initialQueue
- * @returns {IsQueue}
- */
-const makeBasicQueue = (initialQueue = []) => {
-  return new _BasicQueue.default(initialQueue)
-}
-var _default = exports.default = makeBasicQueue
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.default = void 0
+require('core-js/stable')
+var _BasicQueue = _interopRequireDefault(require('../arrays/BasicQueue'))
+function _interopRequireDefault (e) { return e && e.__esModule ? e : { default: e } }
+/**
+ * Create an instance of a basic queue.
+ * @memberOf module:functionHelpers
+ * @param {Array} [initialQueue=[]] - Items to pre-populate the queue with, in order.
+ * @returns {IsQueue}
+ */
+const makeBasicQueue = (initialQueue = []) => {
+  return new _BasicQueue.default(initialQueue)
+}
+var _default = exports.default = makeBasicQueue

package/dist/helpers/functions/queueManager.d.ts

@@ -1,48 +1,50 @@
-import 'core-js/stable';
-import 'regenerator-runtime/runtime';
-import { IsQueue, queuedItem } from '../arrays/BasicQueue';
-/**
- * Each time queue handle is called the passed function is added to the queue to be called when ready.
- * @typedef {Object} module:functionHelpers~queueedRunnable
- * @memberOf module:functionHelpers
- * @property {Object.<fn|args, Function|Array.<*>>} item - Stores the function and the arguments to apply to it when called
- * @property {Generator} generator - The generator instance which can be used to yield function results
- */
-export type queuedRunnable = {
-    item: {
-        fn: Function | queuedItem;
-        args: any[];
-    };
-    generator: Generator;
-};
-/**
- * The pushed function is added to the queue to be called when ready.
- * @typedef {Function} module:functionHelpers~queueManagerPush
- * @memberOf module:functionHelpers
- * @param {Function} fn - A function to enqueue
- * @param  {...*} args - Arguments to be passed to the function once it is ready
- * @returns {Promise}
- */
-export type queuePush = (fn: Function, ...args: any) => Promise<any>;
-/**
- * Each time queue handle is called the passed function is added to the queue to be called when ready.
- * @typedef {Object} module:functionHelpers~queueManagerHandle
- * @memberOf module:functionHelpers
- * @property {Function} start - Callable property that will disable paused state and run the next queue
- * @property  {Function} pause - Callable property that will switch state to paused
- * @property {module:functionHelpers~queueManagerPush} push - Callable property that takes a function to add to the queue
- */
-export type queueManagerHandle = {
-    start: () => void;
-    pause: () => void;
-    push: queuePush;
-};
-/**
- * Manage functions to run sequentially.
- * @memberOf module:functionHelpers
- * @param {IsQueue} [queue=[]] - The iterable that can be used to store queued functions
- * @returns {module:functionHelpers~queueManagerHandle}
- */
-declare const queueManager: (queue?: IsQueue<queuedItem>) => queueManagerHandle;
-export default queueManager;
+import 'core-js/stable';
+import 'regenerator-runtime/runtime';
+import { IsQueue, queuedItem } from '../arrays/BasicQueue';
+/**
+ * Each time queue handle is called the passed function is added to the queue to be called when ready.
+ * @typedef {Object} module:functionHelpers~queueedRunnable
+ * @memberOf module:functionHelpers
+ * @property {Object.<fn|args, Function|Array.<*>>} item - Stores the function and the arguments to apply to it when called
+ * @property {Generator} generator - The generator instance which can be used to yield function results
+ */
+export type queuedRunnable = {
+    item: {
+        fn: Function | queuedItem;
+        args: any[];
+    };
+    generator: Generator;
+};
+/**
+ * The pushed function is added to the queue to be called when ready.
+ * @typedef {Function} module:functionHelpers~queueManagerPush
+ * @memberOf module:functionHelpers
+ * @param {Function} fn - A function to enqueue
+ * @param  {...*} args - Arguments to be passed to the function once it is ready
+ * @returns {Promise}
+ */
+export type queuePush = (fn: Function, ...args: any) => Promise<any>;
+/**
+ * Each time queue handle is called the passed function is added to the queue to be called when ready.
+ * @typedef {Object} module:functionHelpers~queueManagerHandle
+ * @memberOf module:functionHelpers
+ * @property {Function} start - Callable property that will disable paused state and run the next queue
+ * @property  {Function} pause - Callable property that will switch state to paused
+ * @property {module:functionHelpers~queueManagerPush} push - Callable property that takes a function to add to the queue
+ */
+export type queueManagerHandle = {
+    start: () => void;
+    pause: () => void;
+    push: queuePush;
+};
+/**
+ * Manage functions to run sequentially.
+ * @memberOf module:functionHelpers
+ * @param {IsQueue|Array} [queue=null] - The queue to manage. Pass a plain array to have it converted into a
+ * {@link module:arrayHelpers.BasicQueue} automatically, or a custom queue implementing `IsQueue`; omit it (or pass
+ * `null`) to have one created for you.
+ * @returns {module:functionHelpers~queueManagerHandle}
+ */
+declare const queueManager: (queue?: IsQueue<queuedItem>) => queueManagerHandle;
+export default queueManager;
 //# sourceMappingURL=queueManager.d.ts.map

package/dist/helpers/functions/queueManager.js

@@ -1,122 +1,124 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.default = void 0
-require('core-js/modules/esnext.iterator.constructor.js')
-require('core-js/modules/esnext.iterator.for-each.js')
-require('core-js/stable')
-require('regenerator-runtime/runtime')
-var _makeBasicQueue = _interopRequireDefault(require('./makeBasicQueue'))
-function _interopRequireDefault (e) { return e && e.__esModule ? e : { default: e } }
-/**
- * Manage functions to run sequentially.
- * @memberOf module:functionHelpers
- * @param {IsQueue} [queue=[]] - The iterable that can be used to store queued functions
- * @returns {module:functionHelpers~queueManagerHandle}
- */
-const queueManager = (queue = null) => {
-  let isRunning = false
-  let isPaused = true
-  /**
-   * Convert a function to a queueable object.
-   * @param {Promise.resolve} resolve
-   * @param {Promise.reject} reject
-   * @param {Function} fn
-   * @param {...*} args
-   * @returns {queuedRunnable}
-   */
-  const makeQueuedRunnable = (resolve, reject, fn, ...args) => {
-    const generator = (function * () {
-      const item = yield
-      return typeof item.fn === 'function' ? resolve(item.fn(...item.args)) : reject(item)
-    }())
-    // Prepare the generator to be used on the subsequent call
-    generator.next()
-    return {
-      item: {
-        fn: fn,
-        args: args
-      },
-      generator: generator
-    }
-  }
-  /**
-   * After an item is run, THEN run this function to reset isRunning
-   * @param {*} result
-   * @returns {*}
-   */
-  const postRun = result => {
-    isRunning = false
-    runNextItem()
-    return result
-  }
-  /**
-   * When ready, runs the next queued runnable generator.
-   * @returns {IteratorYieldResult|null}
-   */
-  const runNextItem = () => {
-    if (!isPaused && !queue.empty() && !isRunning) {
-      isRunning = true
-      let toRun = queue.dequeue()
-      if (typeof toRun === 'undefined' || toRun === null) {
-        return null
-      }
-      if (typeof toRun === 'function') {
-        new Promise((resolve, reject) => {
-          toRun = makeQueuedRunnable(resolve, reject, toRun)
-          runNextItem()
-        }).then(postRun)
-      }
-      if ('success' in toRun) {
-        // Some run responses return an object with 'success' property.
-        console.info(toRun.success)
-        return null
-      }
-      if (!toRun.generator || 'error' in toRun) {
-        // Some run responses return an object with an 'error' property
-        let errorMessage = 'Verify queued function implements "done()" state.'
-        if ('error' in toRun && toRun.error) {
-          errorMessage = `[${toRun.error}]: ${errorMessage}`
-        }
-        throw new Error(errorMessage)
-      }
-      if (toRun.generator && toRun.item) {
-        // Ensure the returned result has both the generator and the item to be valid
-        return toRun.generator.next(toRun.item)
-      }
-    }
-    return null
-  }
-  /**
-   * Add a function into the queue to be run when ready.
-   * @param {Function} fn - The function to run when ready
-   * @param {...*} args - Optional arguments to apply when the function is ready to be run
-   * @returns Promise
-   */
-  const pushAnother = (fn, ...args) => new Promise((resolve, reject) => {
-    queue.enqueue(makeQueuedRunnable(resolve, reject, fn, ...args))
-    runNextItem()
-  }).then(postRun)
-  if (Array.isArray(queue)) {
-    const queueArray = queue
-    queue = (0, _makeBasicQueue.default)()
-    queueArray.forEach(queued => pushAnother(queued))
-  }
-  if (queue === null) {
-    queue = (0, _makeBasicQueue.default)()
-  }
-  runNextItem()
-  return {
-    start: () => {
-      isPaused = false
-      runNextItem()
-    },
-    pause: () => {
-      isPaused = true
-    },
-    push: pushAnother
-  }
-}
-var _default = exports.default = queueManager
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.default = void 0
+require('core-js/modules/esnext.iterator.constructor.js')
+require('core-js/modules/esnext.iterator.for-each.js')
+require('core-js/stable')
+require('regenerator-runtime/runtime')
+var _makeBasicQueue = _interopRequireDefault(require('./makeBasicQueue'))
+function _interopRequireDefault (e) { return e && e.__esModule ? e : { default: e } }
+/**
+ * Manage functions to run sequentially.
+ * @memberOf module:functionHelpers
+ * @param {IsQueue|Array} [queue=null] - The queue to manage. Pass a plain array to have it converted into a
+ * {@link module:arrayHelpers.BasicQueue} automatically, or a custom queue implementing `IsQueue`; omit it (or pass
+ * `null`) to have one created for you.
+ * @returns {module:functionHelpers~queueManagerHandle}
+ */
+const queueManager = (queue = null) => {
+  let isRunning = false
+  let isPaused = true
+  /**
+   * Convert a function to a queueable object.
+   * @param {Promise.resolve} resolve
+   * @param {Promise.reject} reject
+   * @param {Function} fn
+   * @param {...*} args
+   * @returns {queuedRunnable}
+   */
+  const makeQueuedRunnable = (resolve, reject, fn, ...args) => {
+    const generator = (function * () {
+      const item = yield
+      return typeof item.fn === 'function' ? resolve(item.fn(...item.args)) : reject(item)
+    }())
+    // Prepare the generator to be used on the subsequent call
+    generator.next()
+    return {
+      item: {
+        fn: fn,
+        args: args
+      },
+      generator: generator
+    }
+  }
+  /**
+   * After an item is run, THEN run this function to reset isRunning
+   * @param {*} result
+   * @returns {*}
+   */
+  const postRun = result => {
+    isRunning = false
+    runNextItem()
+    return result
+  }
+  /**
+   * When ready, runs the next queued runnable generator.
+   * @returns {IteratorYieldResult|null}
+   */
+  const runNextItem = () => {
+    if (!isPaused && !queue.empty() && !isRunning) {
+      isRunning = true
+      let toRun = queue.dequeue()
+      if (typeof toRun === 'undefined' || toRun === null) {
+        return null
+      }
+      if (typeof toRun === 'function') {
+        new Promise((resolve, reject) => {
+          toRun = makeQueuedRunnable(resolve, reject, toRun)
+          runNextItem()
+        }).then(postRun)
+      }
+      if ('success' in toRun) {
+        // Some run responses return an object with 'success' property.
+        console.info(toRun.success)
+        return null
+      }
+      if (!toRun.generator || 'error' in toRun) {
+        // Some run responses return an object with an 'error' property
+        let errorMessage = 'Verify queued function implements "done()" state.'
+        if ('error' in toRun && toRun.error) {
+          errorMessage = `[${toRun.error}]: ${errorMessage}`
+        }
+        throw new Error(errorMessage)
+      }
+      if (toRun.generator && toRun.item) {
+        // Ensure the returned result has both the generator and the item to be valid
+        return toRun.generator.next(toRun.item)
+      }
+    }
+    return null
+  }
+  /**
+   * Add a function into the queue to be run when ready.
+   * @param {Function} fn - The function to run when ready
+   * @param {...*} args - Optional arguments to apply when the function is ready to be run
+   * @returns Promise
+   */
+  const pushAnother = (fn, ...args) => new Promise((resolve, reject) => {
+    queue.enqueue(makeQueuedRunnable(resolve, reject, fn, ...args))
+    runNextItem()
+  }).then(postRun)
+  if (Array.isArray(queue)) {
+    const queueArray = queue
+    queue = (0, _makeBasicQueue.default)()
+    queueArray.forEach(queued => pushAnother(queued))
+  }
+  if (queue === null) {
+    queue = (0, _makeBasicQueue.default)()
+  }
+  runNextItem()
+  return {
+    start: () => {
+      isPaused = false
+      runNextItem()
+    },
+    pause: () => {
+      isPaused = true
+    },
+    push: pushAnother
+  }
+}
+var _default = exports.default = queueManager

package/dist/helpers/functions/relevancyFilter.d.ts

@@ -1,36 +1,36 @@
-import 'core-js/stable';
-/**
- * An object having an integer valued property named 'relevance'.
- * @typedef {Object} relevanceObject
- * @memberOf module:functionHelpers
- * @property {Array|Object} source
- * @property {Array|Object} object
- * @property {number} relevance
- */
-export type relevanceObject = {
-    source: Array<any> | Object;
-    object: Array<any> | Object;
-    relevance: number;
-};
-/**
- * A map of relevanceObjects which can be manipulated to filter results.
- * @typedef {Array.<relevanceObject>} relevanceMap
- * @memberOf module:functionHelpers
- */
-export type relevanceMap = Array<relevanceObject>;
-type relevancyFilterOptions = {
-    mapLimit?: number;
-    relevancyRange?: number;
-};
-/**
- * Remove elements out of relevance range and update the max relevance.
- * @memberOf module:functionHelpers
- * @param {relevanceMap} map
- * @param {Object} [options={}]
- * @param {int} [options.mapLimit=1000]
- * @param {int} [options.relevancyRange=100]
- * @returns {relevanceMap}
- */
-declare const relevancyFilter: (map: relevanceMap, { mapLimit, relevancyRange }?: relevancyFilterOptions) => relevanceMap;
-export default relevancyFilter;
+import 'core-js/stable';
+/**
+ * An object having an integer valued property named 'relevance'.
+ * @typedef {Object} relevanceObject
+ * @memberOf module:functionHelpers
+ * @property {Array|Object} source
+ * @property {Array|Object} object
+ * @property {number} relevance
+ */
+export type relevanceObject = {
+    source: Array<any> | Object;
+    object: Array<any> | Object;
+    relevance: number;
+};
+/**
+ * A map of relevanceObjects which can be manipulated to filter results.
+ * @typedef {Array.<relevanceObject>} relevanceMap
+ * @memberOf module:functionHelpers
+ */
+export type relevanceMap = Array<relevanceObject>;
+type relevancyFilterOptions = {
+    mapLimit?: number;
+    relevancyRange?: number;
+};
+/**
+ * Remove elements out of relevance range and update the max relevance.
+ * @memberOf module:functionHelpers
+ * @param {relevanceMap} map
+ * @param {Object} [options={}]
+ * @param {number} [options.mapLimit=1000] - Only filter once the map exceeds this many entries.
+ * @param {number} [options.relevancyRange=100] - How many of the most-recent relevance values to keep.
+ * @returns {relevanceMap}
+ */
+declare const relevancyFilter: (map: relevanceMap, { mapLimit, relevancyRange }?: relevancyFilterOptions) => relevanceMap;
+export default relevancyFilter;
 //# sourceMappingURL=relevancyFilter.d.ts.map