si-funciona 2.6.1 → 2.7.0

package/dist/helpers/functions/makeBasicQueue.js

@@ -1,18 +1,18 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.default = void 0
-const _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)
-}
-const _default = exports.default = makeBasicQueue
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.default = void 0
+const _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)
+}
+const _default = exports.default = makeBasicQueue

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

@@ -1,10 +1,10 @@
-/**
- * Prepare functions to be called once the body is available.
- * @memberOf module:functionHelpers
- * @param {Function} callback
- * @param {boolean} [reset=false]
- * @returns {Array.<Function>}
- */
-declare const onBodyLoad: (callback: Function, reset?: boolean) => Array<Function>;
-export default onBodyLoad;
+/**
+ * Prepare functions to be called once the body is available.
+ * @memberOf module:functionHelpers
+ * @param {Function} callback
+ * @param {boolean} [reset=false]
+ * @returns {Array.<Function>}
+ */
+declare const onBodyLoad: (callback: Function, reset?: boolean) => Array<Function>;
+export default onBodyLoad;
 //# sourceMappingURL=onBodyLoad.d.ts.map

package/dist/helpers/functions/onBodyLoad.js

@@ -1,75 +1,75 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.default = void 0
-const _queueManager = _interopRequireDefault(require('./queueManager'))
-function _interopRequireDefault (e) { return e && e.__esModule ? e : { default: e } }
-const __awaiter = void 0 && (void 0).__awaiter || function (thisArg, _arguments, P, generator) {
-  function adopt (value) {
-    return value instanceof P
-      ? value
-      : new P(function (resolve) {
-        resolve(value)
-      })
-  }
-  return new (P || (P = Promise))(function (resolve, reject) {
-    function fulfilled (value) {
-      try {
-        step(generator.next(value))
-      } catch (e) {
-        reject(e)
-      }
-    }
-    function rejected (value) {
-      try {
-        step(generator.throw(value))
-      } catch (e) {
-        reject(e)
-      }
-    }
-    function step (result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected)
-    }
-    step((generator = generator.apply(thisArg, _arguments || [])).next())
-  })
-}
-const queue = []
-const manager = (0, _queueManager.default)()
-manager.start()
-let observer = null
-const doReset = () => observer = null
-const initializeObserver = () => __awaiter(void 0, void 0, void 0, function * () {
-  observer = new MutationObserver(() => {
-    if (document.body) {
-      while (queue.length) {
-        manager.push(queue.shift())
-      }
-      observer.disconnect()
-      doReset()
-    }
-  })
-  observer.observe(document.documentElement, {
-    childList: true
-  })
-  return observer
-})
-/**
- * Prepare functions to be called once the body is available.
- * @memberOf module:functionHelpers
- * @param {Function} callback
- * @param {boolean} [reset=false]
- * @returns {Array.<Function>}
- */
-const onBodyLoad = (callback, reset = false) => {
-  if (reset) {
-    doReset()
-  }
-  queue.push(callback)
-  if (observer === null) {
-    initializeObserver()
-  }
-  return queue
-}
-const _default = exports.default = onBodyLoad
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.default = void 0
+const _queueManager = _interopRequireDefault(require('./queueManager'))
+function _interopRequireDefault (e) { return e && e.__esModule ? e : { default: e } }
+const __awaiter = void 0 && (void 0).__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt (value) {
+    return value instanceof P
+      ? value
+      : new P(function (resolve) {
+        resolve(value)
+      })
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled (value) {
+      try {
+        step(generator.next(value))
+      } catch (e) {
+        reject(e)
+      }
+    }
+    function rejected (value) {
+      try {
+        step(generator.throw(value))
+      } catch (e) {
+        reject(e)
+      }
+    }
+    function step (result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected)
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next())
+  })
+}
+const queue = []
+const manager = (0, _queueManager.default)()
+manager.start()
+let observer = null
+const doReset = () => observer = null
+const initializeObserver = () => __awaiter(void 0, void 0, void 0, function * () {
+  observer = new MutationObserver(() => {
+    if (document.body) {
+      while (queue.length) {
+        manager.push(queue.shift())
+      }
+      observer.disconnect()
+      doReset()
+    }
+  })
+  observer.observe(document.documentElement, {
+    childList: true
+  })
+  return observer
+})
+/**
+ * Prepare functions to be called once the body is available.
+ * @memberOf module:functionHelpers
+ * @param {Function} callback
+ * @param {boolean} [reset=false]
+ * @returns {Array.<Function>}
+ */
+const onBodyLoad = (callback, reset = false) => {
+  if (reset) {
+    doReset()
+  }
+  queue.push(callback)
+  if (observer === null) {
+    initializeObserver()
+  }
+  return queue
+}
+const _default = exports.default = onBodyLoad

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

@@ -1,10 +1,10 @@
-/**
- * Take one or more function with a single parameter and return value.
- * Pass a parameter and the value will be transformed by each function then returned.
- * @memberOf module:functionHelpers
- * @param {...Function} fns - Takes a series of functions having the same parameter
- * @returns {*}
- */
-declare const pipe: (...fns: Function[]) => any;
-export default pipe;
+/**
+ * Take one or more function with a single parameter and return value.
+ * Pass a parameter and the value will be transformed by each function then returned.
+ * @memberOf module:functionHelpers
+ * @param {...Function} fns - Takes a series of functions having the same parameter
+ * @returns {*}
+ */
+declare const pipe: (...fns: Function[]) => any;
+export default pipe;
 //# sourceMappingURL=pipe.d.ts.map

package/dist/helpers/functions/pipe.js

@@ -1,17 +1,17 @@
-'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.reduce.js')
-/**
- * Take one or more function with a single parameter and return value.
- * Pass a parameter and the value will be transformed by each function then returned.
- * @memberOf module:functionHelpers
- * @param {...Function} fns - Takes a series of functions having the same parameter
- * @returns {*}
- */
-const pipe = (...fns) => x => fns.reduce((y, f) => f(y), x)
-const _default = exports.default = pipe
+'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.reduce.js')
+/**
+ * Take one or more function with a single parameter and return value.
+ * Pass a parameter and the value will be transformed by each function then returned.
+ * @memberOf module:functionHelpers
+ * @param {...Function} fns - Takes a series of functions having the same parameter
+ * @returns {*}
+ */
+const pipe = (...fns) => x => fns.reduce((y, f) => f(y), x)
+const _default = exports.default = pipe

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

@@ -1,20 +1,20 @@
-/**
- * The return function which takes the missing parameter in order to call the preloaded function.
- * @typedef {Function} module:functionHelpers~callWithMissing
- * @memberOf module:functionHelpers
- * @param {*} missing - The missing parameter to be applied
- * @returns {*}
- */
-type callWithMissing = (missing: any) => any;
-/**
- * Provide an array of parameters to be used with a function, allow the function to be called later
- * with the missing parameter.
- * @memberOf module:functionHelpers
- * @param {Function} fn - The function to be called
- * @param {Array} params - The parameters to preload
- * @param {number} [unassignedParam=0] - Position of missing parameter (zero indexed)
- * @returns {module:functionHelpers~callWithMissing}
- */
-declare const preloadParams: (fn: Function, params?: Array<any>, unassignedParam?: number) => callWithMissing;
-export default preloadParams;
+/**
+ * The return function which takes the missing parameter in order to call the preloaded function.
+ * @typedef {Function} module:functionHelpers~callWithMissing
+ * @memberOf module:functionHelpers
+ * @param {*} missing - The missing parameter to be applied
+ * @returns {*}
+ */
+type callWithMissing = (missing: any) => any;
+/**
+ * Provide an array of parameters to be used with a function, allow the function to be called later
+ * with the missing parameter.
+ * @memberOf module:functionHelpers
+ * @param {Function} fn - The function to be called
+ * @param {Array} params - The parameters to preload
+ * @param {number} [unassignedParam=0] - Position of missing parameter (zero indexed)
+ * @returns {module:functionHelpers~callWithMissing}
+ */
+declare const preloadParams: (fn: Function, params?: Array<any>, unassignedParam?: number) => callWithMissing;
+export default preloadParams;
 //# sourceMappingURL=preloadParams.d.ts.map

package/dist/helpers/functions/preloadParams.js

@@ -1,20 +1,20 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.default = void 0
-/**
- * Provide an array of parameters to be used with a function, allow the function to be called later
- * with the missing parameter.
- * @memberOf module:functionHelpers
- * @param {Function} fn - The function to be called
- * @param {Array} params - The parameters to preload
- * @param {number} [unassignedParam=0] - Position of missing parameter (zero indexed)
- * @returns {module:functionHelpers~callWithMissing}
- */
-const preloadParams = (fn, params = [], unassignedParam = 0) => missing => {
-  params.splice(unassignedParam, 0, missing)
-  return fn(...params)
-}
-const _default = exports.default = preloadParams
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.default = void 0
+/**
+ * Provide an array of parameters to be used with a function, allow the function to be called later
+ * with the missing parameter.
+ * @memberOf module:functionHelpers
+ * @param {Function} fn - The function to be called
+ * @param {Array} params - The parameters to preload
+ * @param {number} [unassignedParam=0] - Position of missing parameter (zero indexed)
+ * @returns {module:functionHelpers~callWithMissing}
+ */
+const preloadParams = (fn, params = [], unassignedParam = 0) => missing => {
+  params.splice(unassignedParam, 0, missing)
+  return fn(...params)
+}
+const _default = exports.default = preloadParams

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

@@ -1,49 +1,49 @@
-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;
+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