collect-your-stuff 2.1.2 → 2.2.0

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

@@ -12,53 +12,49 @@ export declare class Stack<T = any> implements IsStack<T>, Iterable<T> {
     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
+     * @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.
-     * @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
+     * @returns 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
+     * @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
-     * @return {Stack} This stack, so that adding can be chained
+     * @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.
-     * @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
+     * @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.
-     * @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}
+     * @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>;
 }

package/dist/collections/stack/Stack.js

@@ -1,129 +1,122 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.Stack = void 0
-require('core-js/modules/esnext.iterator.constructor.js')
-require('core-js/modules/esnext.iterator.for-each.js')
-const _LinkedList = require('../linked-list/LinkedList')
-const _Linker = require('../linked-list/Linker')
-/**
- * @file stack.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 2.0.0
- * @memberOf module:collect-your-stuff
- */
-
-/**
- * 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.
- */
-class Stack {
-  /**
-   * 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 = null, listClass = _LinkedList.LinkedList, linkerClass = _Linker.Linker) {
-    this.linkerClass = linkerClass
-    this.stackedList = stackedList === null ? new listClass(linkerClass) : stackedList
-  }
-
-  /**
-   * Check whether the stack has no items.
-   * @return {boolean}
-   */
-  empty () {
-    return this.size() <= 0
-  }
-
-  /**
-   * 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 () {
-    const top = this.stackedList.first
-    return top === null || typeof top === 'undefined' ? null : top.data
-  }
-
-  /**
-   * Take the item from the top of the stack.
-   * @return {*|null} The item, or null when the stack is empty
-   */
-  pop () {
-    const top = this.stackedList.first
-    if (top === null || typeof top === 'undefined') {
-      return null
-    }
-    this.stackedList.remove(top)
-    return top.data
-  }
-
-  /**
-   * 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) {
-    // The item is wrapped here rather than left to the list, since the list treats objects that look like a linker's
-    // settings (they have a data property) as such, and a stack must give back exactly what it was given
-    this.stackedList.prepend(new this.linkerClass({
-      data
-    }))
-    return this
-  }
-
-  /**
-   * Count the items in the stack.
-   * @return {number}
-   */
-  size () {
-    return this.stackedList.length
-  }
-
-  /**
-   * The item on the top of the stack (the same as peek).
-   * @return {*|null} The item, or null when the stack is empty
-   */
-  top () {
-    return this.peek()
-  }
-
-  /**
-   * Iterate over the items from the top of the stack to the bottom, without removing them.
-   * @return {Iterator}
-   */
-  [Symbol.iterator] () {
-    const linkers = this.stackedList[Symbol.iterator]()
-    return {
-      next: () => {
-        const result = linkers.next()
-        return result.done
-          ? {
-              done: true,
-              value: undefined
-            }
-          : {
-              done: false,
-              value: result.value.data
-            }
-      }
-    }
-  }
-}
-/**
- * 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}
- */
-exports.Stack = Stack
-Stack.fromArray = (values = [], listClass = _LinkedList.LinkedList, linkerClass = _Linker.Linker) => {
-  const stack = new Stack(null, listClass, linkerClass)
-  values.forEach(value => stack.push(value))
-  return stack
-}
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.Stack = void 0
+require('core-js/modules/esnext.iterator.constructor.js')
+require('core-js/modules/esnext.iterator.for-each.js')
+const _LinkedList = require('../linked-list/LinkedList')
+const _Linker = require('../linked-list/Linker')
+/**
+ * stack.
+ */
+
+/**
+ * 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.
+ */
+class Stack {
+  /**
+   * 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 = null, listClass = _LinkedList.LinkedList, linkerClass = _Linker.Linker) {
+    this.linkerClass = linkerClass
+    this.stackedList = stackedList === null ? new listClass(linkerClass) : stackedList
+  }
+
+  /**
+   * Check whether the stack has no items.
+   */
+  empty () {
+    return this.size() <= 0
+  }
+
+  /**
+   * Look at the item on the top of the stack, without removing it.
+   * @returns The item, or null when the stack is empty
+   */
+  peek () {
+    const top = this.stackedList.first
+    return top === null || typeof top === 'undefined' ? null : top.data
+  }
+
+  /**
+   * Take the item from the top of the stack.
+   * @returns The item, or null when the stack is empty
+   */
+  pop () {
+    const top = this.stackedList.first
+    if (top === null || typeof top === 'undefined') {
+      return null
+    }
+    this.stackedList.remove(top)
+    return top.data
+  }
+
+  /**
+   * 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) {
+    // The item is wrapped here rather than left to the list, since the list treats objects that look like a linker's
+    // settings (they have a data property) as such, and a stack must give back exactly what it was given
+    this.stackedList.prepend(new this.linkerClass({
+      data
+    }))
+    return this
+  }
+
+  /**
+   * Count the items in the stack.
+   */
+  size () {
+    return this.stackedList.length
+  }
+
+  /**
+   * The item on the top of the stack (the same as peek).
+   * @returns The item, or null when the stack is empty
+   */
+  top () {
+    return this.peek()
+  }
+
+  /**
+   * Iterate over the items from the top of the stack to the bottom, without removing them.
+   */
+  [Symbol.iterator] () {
+    const linkers = this.stackedList[Symbol.iterator]()
+    return {
+      next: () => {
+        const result = linkers.next()
+        return result.done
+          ? {
+              done: true,
+              value: undefined
+            }
+          : {
+              done: false,
+              value: result.value.data
+            }
+      }
+    }
+  }
+}
+/**
+ * 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
+ */
+exports.Stack = Stack
+Stack.fromArray = (values = [], listClass = _LinkedList.LinkedList, linkerClass = _Linker.Linker) => {
+  const stack = new Stack(null, listClass, linkerClass)
+  values.forEach(value => stack.push(value))
+  return stack
+}

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

@@ -1,8 +1,5 @@
 /**
- * @file stack.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.1.0
- * @memberOf module:collect-your-stuff
+ * stack.
  */
 import { IsRunnable } from '../../recipes/Runnable';
 import { IsLinker } from '../../recipes/IsLinker';
@@ -19,10 +16,10 @@ export declare class Stackable implements IsLinker, IsRunnable {
     next: Stackable | null;
     /**
      * Create a stackable item that can be used in a stack.
-     * @param {Object} [stackData={}] The settings for the new stackable.
-     * @param {*} [stackData.task=null] The data to be stored in this stackable
-     * @param {Stackable|null} [stackData.next=null] The reference to the next stackable if any
-     * @param {boolean|Function} [stackData.ready=false] Indicate if the stackable is ready to run
+     * @param stackData The settings for the new stackable.
+     * @param stackData.task The data to be stored in this stackable
+     * @param stackData.next The reference to the next stackable if any
+     * @param stackData.ready Indicate if the stackable is ready to run
      */
     constructor({ task, next, ready }?: {
         task?: any;
@@ -31,26 +28,22 @@ export declare class Stackable implements IsLinker, IsRunnable {
     });
     /**
      * Retrieve the data which should be formed as a task.
-     * @return {*}
      */
     get task(): any;
     /**
      * Run the stacked task.
-     * @return {*}
      */
     run(): any;
     /**
      * Make a new Stackable from the data given if it is not already a valid Stackable.
-     * @param {Stackable|*} stackable Return a valid Stackable instance from given data, or even an already valid one.
-     * @param {IsLinker} [classType=Stackable] Provide the type of IsLinker to use.
-     * @return {Stackable}
+     * @param stackable Return a valid Stackable instance from given data, or even an already valid one.
+     * @param classType Provide the type of IsLinker to use.
      */
     static make: (stackable: Stackable | any, classType?: any) => Stackable;
     /**
      * Convert an array into Stackable instances, return the head and tail Stackables.
-     * @param {Array} [values=[]] Provide an array of data that will be converted to a chain of stackable linkers.
-     * @param {IsLinker} [classType=Stackable] Provide the type of IsLinker to use.
-     * @returns {{head: Stackable, tail: Stackable}}
+     * @param values Provide an array of data that will be converted to a chain of stackable linkers.
+     * @param classType Provide the type of IsLinker to use.
      */
     static fromArray: (values?: Array<any>, classType?: any) => {
         head: IsLinker;