collect-your-stuff 2.1.1 → 2.2.0

package/dist/collections/queue/TaskQueue.js

@@ -1,137 +1,128 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.TaskQueue = void 0
-var _Queueable = require('./Queueable')
-var _LinkedList = require('../linked-list/LinkedList')
-/**
- * @file task queue
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
- */
-
-/**
- * Maintain a series of queued tasks (Queueables): dequeue() takes the next task from the front and RUNS it, giving each
- * task in turn a chance to run (a task which is not ready, or which has not finished, is placed at the back again).
- * This is a task scheduler, for a plain first-in-first-out collection of items use Queue.
- */
-class TaskQueue {
-  /**
-   * Instantiate the queue with the given queue list.
-   * @param {Iterable|LinkedList} queuedList Give the list of queueables to start in this queue.
-   * @param {IsArrayable} [listClass=LinkedList] The type of list to create when no queued list is given.
-   * @param {Queueable} [queueableClass=Queueable] The class used to wrap queued items.
-   */
-  constructor (queuedList = null, listClass = _LinkedList.LinkedList, queueableClass = _Queueable.Queueable) {
-    this.listClass = listClass
-    this.queueableClass = queueableClass
-    if (queuedList === null) {
-      queuedList = new listClass(queueableClass)
-    }
-    this.queuedList = queuedList
-  }
-
-  /**
-   * Take a queued task from the front of the queue and run it if ready. A task which is not ready yet is kept in the
-   * queue (never dropped), a task which is still running is reported as blocking and left to finish on its own, and
-   * completed tasks are discarded.
-   * @return {completeResponse|*}
-   */
-  dequeue () {
-    let next = this.remove()
-    // Tasks which already completed are discarded when they reach the front of the queue
-    while (next && next.complete) {
-      next = this.remove()
-    }
-    if (!next) {
-      return {
-        success: 'No more queueable tasks in the queue',
-        error: false,
-        context: this.queuedList
-      }
-    }
-    if (next.running) {
-      // The unfinished task reports back through its own complete callback, so it is not kept in the queue
-      return {
-        success: false,
-        error: 'The queue has been blocked by an unfinished task.',
-        context: next
-      }
-    }
-    if (!next.isReady) {
-      // Keep the task (at the back, so the next dequeue can try the other tasks) rather than losing it
-      this.enqueue(next)
-      // We could go check the next in queue here but if we end up in a state where nothing is ready it would infinite loop
-      // Also, we want the loop handled externally
-      return {
-        success: false,
-        error: 'Unable to find ready task.',
-        context: next
-      }
-    }
-    if (!this.empty()) {
-      // Place back in queue to be checked once again next time, only if the queue will not be empty
-      this.enqueue(next)
-    }
-    return next.run.call(next)
-  }
-
-  /**
-   * Return true if the queue is empty (there are no tasks in the queue list)
-   * @return {boolean}
-   */
-  empty () {
-    return this.size() <= 0
-  }
-
-  /**
-   * Add a queued task to the end of the queue
-   * @param {Queueable} queueable Add a new queueable to the end of the queue
-   */
-  enqueue (queueable) {
-    this.queuedList.append(queueable)
-  }
-
-  /**
-   * Take a look at the next queued task
-   * @return {Queueable}
-   */
-  peek () {
-    return this.queuedList.first
-  }
-
-  /**
-   * Remove the next queued item and return it.
-   * @return {Queueable|null}
-   */
-  remove () {
-    if (this.empty()) {
-      return null
-    }
-    return this.queuedList.remove(this.queuedList.first)
-  }
-
-  /**
-   * Get the length of the current queue.
-   * @return {number}
-   */
-  size () {
-    return this.queuedList.length
-  }
-}
-/**
- * Convert an array to a TaskQueue.
- * @param {Array} values An array of values which will be converted to queueables in this queue
- * @param {Queueable} queueableClass The class to use for each queueable
- * @param {TaskQueue|Iterable} listClass The class to use to manage the queueables
- * @returns {TaskQueue}
- */
-exports.TaskQueue = TaskQueue
-TaskQueue.fromArray = (values = [], queueableClass = _Queueable.Queueable, listClass = _LinkedList.LinkedList) => {
-  const list = new listClass(queueableClass)
-  list.initialize(queueableClass.fromArray(values, queueableClass).head)
-  return new TaskQueue(list, listClass, queueableClass)
-}
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.TaskQueue = void 0
+const _Queueable = require('./Queueable')
+const _LinkedList = require('../linked-list/LinkedList')
+/**
+ * task queue
+ */
+
+/**
+ * Maintain a series of queued tasks (Queueables): dequeue() takes the next task from the front and RUNS it, giving each
+ * task in turn a chance to run (a task which is not ready, or which has not finished, is placed at the back again).
+ * This is a task scheduler, for a plain first-in-first-out collection of items use Queue.
+ */
+class TaskQueue {
+  /**
+   * Instantiate the queue with the given queue list.
+   * @param queuedList Give the list of queueables to start in this queue.
+   * @param listClass The type of list to create when no queued list is given.
+   * @param queueableClass The class used to wrap queued items.
+   */
+  constructor (queuedList = null, listClass = _LinkedList.LinkedList, queueableClass = _Queueable.Queueable) {
+    this.listClass = listClass
+    this.queueableClass = queueableClass
+    if (queuedList === null) {
+      queuedList = new listClass(queueableClass)
+    }
+    this.queuedList = queuedList
+  }
+
+  /**
+   * Take a queued task from the front of the queue and run it if ready. A task which is not ready yet is kept in the
+   * queue (never dropped), a task which is still running is reported as blocking and left to finish on its own, and
+   * completed tasks are discarded.
+   */
+  dequeue () {
+    let next = this.remove()
+    // Tasks which already completed are discarded when they reach the front of the queue
+    while (next && next.complete) {
+      next = this.remove()
+    }
+    if (!next) {
+      return {
+        success: 'No more queueable tasks in the queue',
+        error: false,
+        context: this.queuedList
+      }
+    }
+    if (next.running) {
+      // The unfinished task reports back through its own complete callback, so it is not kept in the queue
+      return {
+        success: false,
+        error: 'The queue has been blocked by an unfinished task.',
+        context: next
+      }
+    }
+    if (!next.isReady) {
+      // Keep the task (at the back, so the next dequeue can try the other tasks) rather than losing it
+      this.enqueue(next)
+      // We could go check the next in queue here but if we end up in a state where nothing is ready it would infinite loop
+      // Also, we want the loop handled externally
+      return {
+        success: false,
+        error: 'Unable to find ready task.',
+        context: next
+      }
+    }
+    if (!this.empty()) {
+      // Place back in queue to be checked once again next time, only if the queue will not be empty
+      this.enqueue(next)
+    }
+    return next.run.call(next)
+  }
+
+  /**
+   * Return true if the queue is empty (there are no tasks in the queue list)
+   */
+  empty () {
+    return this.size() <= 0
+  }
+
+  /**
+   * Add a queued task to the end of the queue
+   * @param queueable Add a new queueable to the end of the queue
+   */
+  enqueue (queueable) {
+    this.queuedList.append(queueable)
+  }
+
+  /**
+   * Take a look at the next queued task
+   */
+  peek () {
+    return this.queuedList.first
+  }
+
+  /**
+   * Remove the next queued item and return it.
+   */
+  remove () {
+    if (this.empty()) {
+      return null
+    }
+    return this.queuedList.remove(this.queuedList.first)
+  }
+
+  /**
+   * Get the length of the current queue.
+   */
+  size () {
+    return this.queuedList.length
+  }
+}
+/**
+ * Convert an array to a TaskQueue.
+ * @param values An array of values which will be converted to queueables in this queue
+ * @param queueableClass The class to use for each queueable
+ * @param listClass The class to use to manage the queueables
+ */
+exports.TaskQueue = TaskQueue
+TaskQueue.fromArray = (values = [], queueableClass = _Queueable.Queueable, listClass = _LinkedList.LinkedList) => {
+  const list = new listClass(queueableClass)
+  list.initialize(queueableClass.fromArray(values, queueableClass).head)
+  return new TaskQueue(list, listClass, queueableClass)
+}

package/dist/collections/scoped-collection/ScopedCollection.d.ts

@@ -0,0 +1,42 @@
+/**
+ * scoped collection
+ */
+import { IsScopedCollection } from '../../recipes/IsScopedCollection';
+/**
+ * A keyed collection, partitioned by an arbitrary scope object: values are stored and looked up by key, with a
+ * separate key space per scope. Scopes are held by a WeakMap, so a scope that nothing else references any more
+ * takes its whole key space with it - useful anywhere state needs to be tracked per instance of something (a
+ * tree's root, a session) without that something needing to hold the state itself.
+ */
+export declare class ScopedCollection<Scope extends object = object, Key = any, Value = any> implements IsScopedCollection<Scope, Key, Value> {
+    private readonly scopes;
+    constructor();
+    /**
+     * Remove a key from a scope's key space.
+     * @param scope The scope to remove the key from
+     * @param key The key to remove
+     * @returns Whether a value was actually removed
+     */
+    delete(scope: Scope, key: Key): boolean;
+    /**
+     * Look up a value by key within a scope.
+     * @param scope The scope to look within
+     * @param key The key to look up
+     * @returns The value, or undefined when the scope or key is not present
+     */
+    get(scope: Scope, key: Key): Value | undefined;
+    /**
+     * Check whether a key exists within a scope.
+     * @param scope The scope to look within
+     * @param key The key to check
+     */
+    has(scope: Scope, key: Key): boolean;
+    /**
+     * Store a value under a key within a scope.
+     * @param scope The scope to store the key within
+     * @param key The key to store the value under
+     * @param value The value to store
+     * @returns This collection, so that setting can be chained
+     */
+    set(scope: Scope, key: Key, value: Value): this;
+}

package/dist/collections/scoped-collection/ScopedCollection.js

@@ -0,0 +1,81 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.ScopedCollection = void 0
+require('core-js/modules/esnext.map.delete-all.js')
+require('core-js/modules/esnext.map.every.js')
+require('core-js/modules/esnext.map.filter.js')
+require('core-js/modules/esnext.map.find.js')
+require('core-js/modules/esnext.map.find-key.js')
+require('core-js/modules/esnext.map.includes.js')
+require('core-js/modules/esnext.map.key-of.js')
+require('core-js/modules/esnext.map.map-keys.js')
+require('core-js/modules/esnext.map.map-values.js')
+require('core-js/modules/esnext.map.merge.js')
+require('core-js/modules/esnext.map.reduce.js')
+require('core-js/modules/esnext.map.some.js')
+require('core-js/modules/esnext.map.update.js')
+require('core-js/modules/esnext.weak-map.delete-all.js')
+/**
+ * A keyed collection, partitioned by an arbitrary scope object: values are stored and looked up by key, with a
+ * separate key space per scope. Scopes are held by a WeakMap, so a scope that nothing else references any more
+ * takes its whole key space with it - useful anywhere state needs to be tracked per instance of something (a
+ * tree's root, a session) without that something needing to hold the state itself.
+ */
+class ScopedCollection {
+  constructor () {
+    this.scopes = new WeakMap()
+  }
+
+  /**
+   * Remove a key from a scope's key space.
+   * @param scope The scope to remove the key from
+   * @param key The key to remove
+   * @returns Whether a value was actually removed
+   */
+  delete (scope, key) {
+    const keyedValues = this.scopes.get(scope)
+    return typeof keyedValues === 'undefined' ? false : keyedValues.delete(key)
+  }
+
+  /**
+   * Look up a value by key within a scope.
+   * @param scope The scope to look within
+   * @param key The key to look up
+   * @returns The value, or undefined when the scope or key is not present
+   */
+  get (scope, key) {
+    let _a
+    return (_a = this.scopes.get(scope)) === null || _a === void 0 ? void 0 : _a.get(key)
+  }
+
+  /**
+   * Check whether a key exists within a scope.
+   * @param scope The scope to look within
+   * @param key The key to check
+   */
+  has (scope, key) {
+    let _a, _b
+    return (_b = (_a = this.scopes.get(scope)) === null || _a === void 0 ? void 0 : _a.has(key)) !== null && _b !== void 0 ? _b : false
+  }
+
+  /**
+   * Store a value under a key within a scope.
+   * @param scope The scope to store the key within
+   * @param key The key to store the value under
+   * @param value The value to store
+   * @returns This collection, so that setting can be chained
+   */
+  set (scope, key, value) {
+    let keyedValues = this.scopes.get(scope)
+    if (typeof keyedValues === 'undefined') {
+      keyedValues = new Map()
+      this.scopes.set(scope, keyedValues)
+    }
+    keyedValues.set(key, value)
+    return this
+  }
+}
+exports.ScopedCollection = ScopedCollection

package/dist/collections/scoped-collection/ScopedCollection.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.ScopedCollection=void 0,require("core-js/modules/esnext.map.delete-all.js"),require("core-js/modules/esnext.map.every.js"),require("core-js/modules/esnext.map.filter.js"),require("core-js/modules/esnext.map.find.js"),require("core-js/modules/esnext.map.find-key.js"),require("core-js/modules/esnext.map.includes.js"),require("core-js/modules/esnext.map.key-of.js"),require("core-js/modules/esnext.map.map-keys.js"),require("core-js/modules/esnext.map.map-values.js"),require("core-js/modules/esnext.map.merge.js"),require("core-js/modules/esnext.map.reduce.js"),require("core-js/modules/esnext.map.some.js"),require("core-js/modules/esnext.map.update.js"),require("core-js/modules/esnext.weak-map.delete-all.js");class ScopedCollection{constructor(){this.scopes=new WeakMap}delete(e,s){const o=this.scopes.get(e);return void 0!==o&&o.delete(s)}get(e,s){var o;return null===(o=this.scopes.get(e))||void 0===o?void 0:o.get(s)}has(e,s){var o,r;return null!==(r=null===(o=this.scopes.get(e))||void 0===o?void 0:o.has(s))&&void 0!==r&&r}set(e,s,o){let r=this.scopes.get(e);return void 0===r&&(r=new Map,this.scopes.set(e,r)),r.set(s,o),this}}exports.ScopedCollection=ScopedCollection;

package/dist/collections/stack/Stack.d.ts

@@ -1,64 +1,60 @@
-import { Linker } from '../linked-list/Linker';
-import { IsArrayable } from '../../recipes/IsArrayable';
-import { IsStack } from '../../recipes/IsStack';
-/**
- * A last-in-first-out collection: items are added to the top with push and taken from the top with pop. Any value can
- * be stacked (it is stored as it is, whether it is a function, an object or null), and adding and taking are constant
- * time. To stack tasks which are run as they are taken use TaskStack.
- */
-export declare class Stack<T = any> implements IsStack<T>, Iterable<T> {
-    /** The list which stores the stacked items, the first is the top of the stack. */
-    stackedList: IsArrayable<any>;
-    private readonly linkerClass;
-    /**
-     * Instantiate the stack, optionally with a list of items to start from.
-     * @param {IsArrayable|null} [stackedList=null] The list of linkers to start in this stack (the first is the top)
-     * @param {IsArrayable} [listClass=LinkedList] The type of list to create when no stacked list is given
-     * @param {Linker} [linkerClass=Linker] The class used to hold each stacked item
-     */
-    constructor(stackedList?: IsArrayable<any> | null, listClass?: any, linkerClass?: typeof Linker);
-    /**
-     * Check whether the stack has no items.
-     * @return {boolean}
-     */
-    empty(): boolean;
-    /**
-     * Look at the item on the top of the stack, without removing it.
-     * @return {*|null} The item, or null when the stack is empty
-     */
-    peek(): T | null;
-    /**
-     * Take the item from the top of the stack.
-     * @return {*|null} The item, or null when the stack is empty
-     */
-    pop(): T | null;
-    /**
-     * Add an item to the top of the stack.
-     * @param {*} data The item to add
-     * @return {Stack} This stack, so that adding can be chained
-     */
-    push(data: T): this;
-    /**
-     * Count the items in the stack.
-     * @return {number}
-     */
-    size(): number;
-    /**
-     * The item on the top of the stack (the same as peek).
-     * @return {*|null} The item, or null when the stack is empty
-     */
-    top(): T | null;
-    /**
-     * Iterate over the items from the top of the stack to the bottom, without removing them.
-     * @return {Iterator}
-     */
-    [Symbol.iterator](): Iterator<T>;
-    /**
-     * Convert an array to a Stack by pushing each value in turn, so the last value is on the top.
-     * @param {Array} [values=[]] The items to stack
-     * @param {IsArrayable} [listClass=LinkedList] The type of list used to store the items
-     * @param {Linker} [linkerClass=Linker] The class used to hold each stacked item
-     * @returns {Stack}
-     */
-    static fromArray: <T_1 = any>(values?: Array<T_1>, listClass?: any, linkerClass?: typeof Linker) => Stack<T_1>;
-}
+import { Linker } from '../linked-list/Linker';
+import { IsArrayable } from '../../recipes/IsArrayable';
+import { IsStack } from '../../recipes/IsStack';
+/**
+ * A last-in-first-out collection: items are added to the top with push and taken from the top with pop. Any value can
+ * be stacked (it is stored as it is, whether it is a function, an object or null), and adding and taking are constant
+ * time. To stack tasks which are run as they are taken use TaskStack.
+ */
+export declare class Stack<T = any> implements IsStack<T>, Iterable<T> {
+    /** The list which stores the stacked items, the first is the top of the stack. */
+    stackedList: IsArrayable<any>;
+    private readonly linkerClass;
+    /**
+     * Instantiate the stack, optionally with a list of items to start from.
+     * @param stackedList The list of linkers to start in this stack (the first is the top)
+     * @param listClass The type of list to create when no stacked list is given
+     * @param linkerClass The class used to hold each stacked item
+     */
+    constructor(stackedList?: IsArrayable<any> | null, listClass?: any, linkerClass?: typeof Linker);
+    /**
+     * Check whether the stack has no items.
+     */
+    empty(): boolean;
+    /**
+     * Look at the item on the top of the stack, without removing it.
+     * @returns The item, or null when the stack is empty
+     */
+    peek(): T | null;
+    /**
+     * Take the item from the top of the stack.
+     * @returns The item, or null when the stack is empty
+     */
+    pop(): T | null;
+    /**
+     * Add an item to the top of the stack.
+     * @param data The item to add
+     * @returns This stack, so that adding can be chained
+     */
+    push(data: T): this;
+    /**
+     * Count the items in the stack.
+     */
+    size(): number;
+    /**
+     * The item on the top of the stack (the same as peek).
+     * @returns The item, or null when the stack is empty
+     */
+    top(): T | null;
+    /**
+     * Iterate over the items from the top of the stack to the bottom, without removing them.
+     */
+    [Symbol.iterator](): Iterator<T>;
+    /**
+     * Convert an array to a Stack by pushing each value in turn, so the last value is on the top.
+     * @param values The items to stack
+     * @param listClass The type of list used to store the items
+     * @param linkerClass The class used to hold each stacked item
+     */
+    static fromArray: <T_1 = any>(values?: Array<T_1>, listClass?: any, linkerClass?: typeof Linker) => Stack<T_1>;
+}