@agoric/store 0.9.3-dev-57802f9.0 → 0.9.3-other-dev-1f26562.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/store",
-  "version": "0.9.3-dev-57802f9.0+57802f9",
+  "version": "0.9.3-other-dev-1f26562.0+1f26562",
   "description": "Wrapper for JavaScript map",
   "type": "module",
   "main": "src/index.js",
@@ -13,7 +13,7 @@
     "test:xs": "exit 0",
     "lint-fix": "yarn lint:eslint --fix",
     "lint": "run-s --continue-on-error lint:*",
-    "lint:types": "tsc",
+    "lint:types": "tsc -p jsconfig.json",
     "lint:eslint": "eslint ."
   },
   "repository": {
@@ -30,17 +30,17 @@
   },
   "homepage": "https://github.com/Agoric/agoric-sdk#readme",
   "dependencies": {
-    "@agoric/assert": "0.6.1-dev-57802f9.0+57802f9",
-    "@endo/exo": "^0.2.5",
-    "@endo/marshal": "^0.8.8",
-    "@endo/pass-style": "^0.1.6",
-    "@endo/patterns": "^0.2.5"
+    "@agoric/assert": "0.6.1-other-dev-1f26562.0+1f26562",
+    "@endo/exo": "0.2.2",
+    "@endo/marshal": "0.8.5",
+    "@endo/pass-style": "0.1.3",
+    "@endo/patterns": "0.2.2"
   },
   "devDependencies": {
-    "@agoric/time": "0.3.3-dev-57802f9.0+57802f9",
-    "@endo/init": "^0.5.59",
-    "@endo/ses-ava": "^0.2.43",
-    "ava": "^5.3.0"
+    "@agoric/swingset-vat": "0.32.3-other-dev-1f26562.0+1f26562",
+    "@agoric/time": "0.3.3-other-dev-1f26562.0+1f26562",
+    "@endo/ses-ava": "0.2.40",
+    "ava": "^5.2.0"
   },
   "files": [
     "src/",
@@ -54,10 +54,7 @@
     "files": [
       "test/**/test-*.js"
     ],
-    "require": [
-      "@endo/init/debug.js"
-    ],
     "timeout": "2m"
   },
-  "gitHead": "57802f970619d66d45608e819f443131e3bf6b66"
+  "gitHead": "1f265627270d514ab48943f86c668eb58a280552"
 }

package/src/index.js

@@ -56,7 +56,7 @@ export { makeScalarSetStore } from './stores/scalarSetStore.js';
 export { makeScalarWeakMapStore } from './stores/scalarWeakMapStore.js';
 export { makeScalarMapStore } from './stores/scalarMapStore.js';
 
-export { provideLazy, isCopyMap, isCopySet } from './stores/store-utils.js';
+export { provideLazy } from './stores/store-utils.js';
 
 // /////////////////////// Deprecated Legacy ///////////////////////////////////
 

package/src/legacy/legacyMap.js

@@ -3,37 +3,35 @@ import { q, Fail } from '@agoric/assert';
 import '../types.js';
 
 /**
- * This module and its fraternal sibling legacyWeakMap exist only to ease a
- * transition to the modern `store` system, are deprecated, and will eventually
- * disappear. They are needed for now to support some of the uses of the old
- * behavior that are not compatible with the new. The constraint imposed by the
- * new is that only passables can be used as values, and only keys (roughly,
- * structures, aka comparables) can be used as values.
+ * This module and its fraternal sibling legacyWeakMap exist only to
+ * ease a transition to the modern `store` system, are deprecated,
+ * and will eventually disappear. They are needed for now to support
+ * some of the uses of the old behavior that are not compatible with
+ * the new. The constraint imposed by the new is that only passables can
+ * be used as values, and only keys (roughly, structures, aka comparables)
+ * can be used as values.
  *
  * See https://github.com/Agoric/agoric-sdk/pull/3567
- *
  * TODO Once that PR is merged, link to the documents rather than the PRs.
  *
  * Each of these non-conforming uses should be marked with a
- *
  * ```js
  * // Legacy because...
  * ```
- *
- * comment explaining the problem inhibiting conversion to the new system. Some
- * of these problems as of this writing:
- *
- * - A promiseKit used as a value, even though a promiseKit is not a passable.
- *   Solutions are to make it a passable, or to convert the container back to a
- *   conventional JavaScript Map.
- * - A mutable array used as a value, that is subsequently mutated. Freezing the
- *   array wouldn't work of course because it would break the subsequent
- *   mutation. Using a far object wrapping an array would likely work fine.
+ * comment explaining the problem inhibiting conversion to the new
+ * system. Some of these problems as of this writing:
+ *    * A promiseKit used as a value, even though a promiseKit is not
+ *      a passable. Solutions are to make it a passable, or to convert
+ *      the container back to a conventional JavaScript Map.
+ *    * A mutable array used as a value, that is subsequently mutated.
+ *      Freezing the array wouldn't work of course because it would break
+ *      the subsequent mutation. Using a far object wrapping an array would
+ *      likely work fine.
  *
  * @deprecated switch to ScalarMap if possible, Map otherwise
  * @template K,V
- * @param {string} [tag] - tag for debugging
- * @returns {LegacyMap<K, V>}
+ * @param {string} [tag='key'] - tag for debugging
+ * @returns {LegacyMap<K,V>}
  */
 export const makeLegacyMap = (tag = 'key') => {
   const m = new Map();

package/src/legacy/legacyWeakMap.js

@@ -6,8 +6,8 @@ import '../types.js';
  *
  * @deprecated switch to ScalarWeakMap if possible, WeakMap otherwise
  * @template K,V
- * @param {string} [tag] - tag for debugging
- * @returns {LegacyWeakMap<K, V>}
+ * @param {string} [tag='key'] - tag for debugging
+ * @returns {LegacyWeakMap<K,V>}
  */
 export const makeLegacyWeakMap = (tag = 'key') => {
   /** @type {WeakMap<K & object, V>} */

package/src/stores/scalarMapStore.js

@@ -20,12 +20,12 @@ const { quote: q } = assert;
 /**
  * @template {Key} K
  * @template {Passable} V
- * @param {Map<K, V>} jsmap
+ * @param {Map<K,V>} jsmap
  * @param {(k: K, v: V) => void} assertKVOkToAdd
  * @param {(k: K, v: V) => void} assertKVOkToSet
- * @param {(k: K) => void} [assertKeyOkToDelete]
+ * @param {((k: K) => void)} [assertKeyOkToDelete]
  * @param {string} [tag]
- * @returns {MapStore<K, V>}
+ * @returns {MapStore<K,V>}
  */
 export const makeMapStoreMethods = (
   jsmap,
@@ -77,7 +77,7 @@ export const makeMapStoreMethods = (
   /**
    * @param {Pattern} [keyPatt]
    * @param {Pattern} [valuePatt]
-   * @returns {Iterable<[K, V]>}
+   * @returns {Iterable<[K,V]>}
    */
   const entries = (keyPatt = undefined, valuePatt = undefined) =>
     mapIterable(keys(keyPatt, valuePatt), k => [
@@ -117,21 +117,21 @@ export const makeMapStoreMethods = (
 };
 
 /**
- * Distinguishes between adding a new key (init) and updating or referencing a
- * key (get, set, delete).
+ * Distinguishes between adding a new key (init) and updating or
+ * referencing a key (get, set, delete).
  *
- * `init` is only allowed if the key does not already exist. `Get`, `set` and
- * `delete` are only allowed if the key does already exist.
+ * `init` is only allowed if the key does not already exist. `Get`,
+ * `set` and `delete` are only allowed if the key does already exist.
  *
- * This is a _scalar_ map in that the keys can only be atomic values, primitives
+ * This is a *scalar* map in that the keys can only be atomic values, primitives
  * or remotables. Other storeMaps will accept, for example, copyArrays and
  * copyRecords, as keys and look them up based on equality of their contents.
  *
  * @template {Key} K
  * @template {Passable} V
- * @param {string} [tag] - the column name for the key
+ * @param {string} [tag='key'] - the column name for the key
  * @param {StoreOptions} [options]
- * @returns {MapStore<K, V>}
+ * @returns {MapStore<K,V>}
  */
 export const makeScalarMapStore = (
   tag = 'key',

package/src/stores/scalarSetStore.js

@@ -74,18 +74,18 @@ export const makeSetStoreMethods = (
 };
 
 /**
- * Distinguishes between adding a new key (init) and updating or referencing a
- * key (get, set, delete).
+ * Distinguishes between adding a new key (init) and updating or
+ * referencing a key (get, set, delete).
  *
- * `init` is only allowed if the key does not already exist. `Get`, `set` and
- * `delete` are only allowed if the key does already exist.
+ * `init` is only allowed if the key does not already exist. `Get`,
+ * `set` and `delete` are only allowed if the key does already exist.
  *
- * This is a _scalar_ set in that the keys can only be atomic values, primitives
+ * This is a *scalar* set in that the keys can only be atomic values, primitives
  * or remotables. Other storeSets will accept, for example, copyArrays and
  * copyRecords, as keys and look them up based on equality of their contents.
  *
  * @template K
- * @param {string} [tag] - tag for debugging
+ * @param {string} [tag='key'] - tag for debugging
  * @param {StoreOptions} [options]
  * @returns {SetStore<K>}
  */

package/src/stores/scalarWeakMapStore.js

@@ -11,7 +11,7 @@ const { quote: q, Fail } = assert;
  * @param {(k: K, v: V) => void} assertKVOkToSet
  * @param {(k: K) => void} [assertKeyOkToDelete]
  * @param {string} [keyName]
- * @returns {WeakMapStore<K, V>}
+ * @returns {WeakMapStore<K,V>}
  */
 export const makeWeakMapStoreMethods = (
   jsmap,
@@ -58,12 +58,8 @@ export const makeWeakMapStoreMethods = (
     },
 
     addAll: entries => {
-      if (typeof entries[Symbol.iterator] !== 'function') {
-        if (Object.isFrozen(entries) && isCopyMap(entries)) {
-          entries = getCopyMapEntries(entries);
-        } else {
-          Fail`provided data source is not iterable: ${entries}`;
-        }
+      if (isCopyMap(entries)) {
+        entries = getCopyMapEntries(entries);
       }
       for (const [key, value] of /** @type {Iterable<[K, V]>} */ (entries)) {
         // Don't assert that the key either does or does not exist.
@@ -75,22 +71,22 @@ export const makeWeakMapStoreMethods = (
 };
 
 /**
- * This is a _scalar_ mapStore in that the keys can only be atomic values:
- * primitives or remotables. Other mapStores will accept, for example,
- * copyArrays and copyRecords as keys and look them up based on equality of
- * their contents.
+ * This is a *scalar* mapStore in that the keys can only be atomic values:
+ * primitives or remotables.
+ * Other mapStores will accept, for example, copyArrays and
+ * copyRecords as keys and look them up based on equality of their contents.
  *
  * TODO For now, this scalarWeakMap accepts only remotables, reflecting the
- * constraints of the underlying JavaScript WeakMap it uses internally. But it
- * should accept the primitives as well, storing them in a separate internal
+ * constraints of the underlying JavaScript WeakMap it uses internally. But
+ * it should accept the primitives as well, storing them in a separate internal
  * map. What makes it "weak" is that it provides no API for enumerating what's
- * there. Though note that this would only enables collection of the remotables,
- * since the other primitives may always reappear.
+ * there. Though note that this would only enables collection of the
+ * remotables, since the other primitives may always reappear.
  *
  * @template K,V
- * @param {string} [tag] - tag for debugging
+ * @param {string} [tag='key'] - tag for debugging
  * @param {StoreOptions} [options]
- * @returns {WeakMapStore<K, V>}
+ * @returns {WeakMapStore<K,V>}
  */
 export const makeScalarWeakMapStore = (
   tag = 'key',

package/src/stores/scalarWeakSetStore.js

@@ -42,12 +42,8 @@ export const makeWeakSetStoreMethods = (
     },
 
     addAll: keys => {
-      if (typeof keys[Symbol.iterator] !== 'function') {
-        if (Object.isFrozen(keys) && isCopySet(keys)) {
-          keys = getCopySetKeys(keys);
-        } else {
-          Fail`provided data source is not iterable: ${keys}`;
-        }
+      if (isCopySet(keys)) {
+        keys = getCopySetKeys(keys);
       }
       for (const key of /** @type {Iterable<K>} */ (keys)) {
         assertKeyOkToAdd(key);
@@ -58,19 +54,19 @@ export const makeWeakSetStoreMethods = (
 };
 
 /**
- * This is a _scalar_ set in that the keys can only be atomic values, primitives
+ * This is a *scalar* set in that the keys can only be atomic values, primitives
  * or remotables. Other storeSets will accept, for example, copyArrays and
  * copyRecords, as keys and look them up based on equality of their contents.
  *
  * TODO For now, this scalarWeakSet accepts only remotables, reflecting the
- * constraints of the underlying JavaScript WeakSet it uses internally. But it
- * should accept the primitives as well, storing them in a separate internal
+ * constraints of the underlying JavaScript WeakSet it uses internally. But
+ * it should accept the primitives as well, storing them in a separate internal
  * set. What makes it "weak" is that it provides no API for enumerating what's
- * there. Though note that this would only enables collection of the remotables,
- * since the other primitives may always appear.
+ * there. Though note that this would only enables collection of the
+ * remotables, since the other primitives may always appear.
  *
  * @template K
- * @param {string} [tag] - tag for debugging
+ * @param {string} [tag='key'] - tag for debugging
  * @param {StoreOptions} [options]
  * @returns {WeakSetStore<K>}
  */

package/src/stores/store-utils.js

@@ -1,28 +1,26 @@
 import { Far } from '@endo/marshal';
 import { M, matches } from '@endo/patterns';
 
-/** @typedef {import('@endo/marshal').RankCompare} RankCompare */
-
 const { Fail, quote: q } = assert;
 
-// TODO: Undate `@endo/patterns` to export the original, and delete the
-// reimplementation here.
 /**
- * Should behave identically to the one in `@endo/patterns`, but reimplemented
- * for now because `@endo/patterns` forgot to export this one. This one is
- * simple enough that I prefer a reimplementation to a deep import.
+ * Should behave identically to the one in `@endo/patterns`, but
+ * reimplemented for now because `@endo/patterns` forgot to export this one.
+ * This one is simple enough that I prefer a reimplementation to a deep import.
+ * TODO: Undate `@endo/patterns` to export the original, and delete the
+ * reimplementation here.
  *
  * @param {Passable} s
  * @returns {s is CopySet}
  */
 export const isCopySet = s => matches(s, M.set());
 
-// TODO: Undate `@endo/patterns` to export the original, and delete the
-// reimplementation here.
 /**
- * Should behave identically to the one in `@endo/patterns`, but reimplemented
- * for now because `@endo/patterns` forgot to export this one. This one is
- * simple enough that I prefer a reimplementation to a deep import.
+ * Should behave identically to the one in `@endo/patterns`, but
+ * reimplemented for now because `@endo/patterns` forgot to export this one.
+ * This one is simple enough that I prefer a reimplementation to a deep import.
+ * TODO: Undate `@endo/patterns` to export the original, and delete the
+ * reimplementation here.
  *
  * @param {Passable} m
  * @returns {m is CopyMap}
@@ -45,7 +43,7 @@ export const isCopyMap = m => matches(m, M.map());
  * @param {(k: K, v?: V) => void} assertOkToAdd
  * @param {(k: K) => void} [assertOkToDelete]
  * @param {string} [keyName]
- * @returns {CurrentKeysKit<K, V>}
+ * @returns {CurrentKeysKit<K,V>}
  */
 export const makeCurrentKeysKit = (
   getRawKeys,
@@ -109,12 +107,13 @@ export const makeCurrentKeysKit = (
 harden(makeCurrentKeysKit);
 
 /**
- * Call `provideLazy` to get or make the value associated with the key. If there
- * already is one, return that. Otherwise, call `makeValue(key)`, remember it as
- * the value for that key, and return it.
+ * Call `provideLazy` to get or make the value associated with the key.
+ * If there already is one, return that. Otherwise,
+ * call `makeValue(key)`, remember it as the value for
+ * that key, and return it.
  *
  * @template K,V
- * @param {WeakMapStore<K, V>} mapStore
+ * @param {WeakMapStore<K,V>} mapStore
  * @param {K} key
  * @param {(key: K) => V} makeValue
  * @returns {V}
@@ -128,11 +127,12 @@ export const provideLazy = (mapStore, key, makeValue) => {
 harden(provideLazy);
 
 /**
- * Helper for use cases in which the maker function is async. For two
- * provideLazy calls with the same key, one may be making when the other call
- * starts and it would make again. (Then there'd be a collision when the second
- * tries to store the key.) This prevents that race condition by immediately
- * storing a Promise for the maker in an ephemeral store.
+ * Helper for use cases in which the maker function is async.
+ * For two provideLazy calls with the same key, one may be making when the
+ * other call starts and it would make again.
+ * (Then there'd be a collision when the second tries to store
+ * the key.) This prevents that race condition by immediately storing a Promise
+ * for the maker in an ephemeral store.
  *
  * When the `store` argument is durable storage, note that it's possible for
  * termination to happen after the make completes and before it reaches durable
@@ -147,16 +147,17 @@ export const makeAtomicProvider = store => {
   const pending = new Map();
 
   /**
-   * Call `provideAsync` to get or make the value associated with the key, when
-   * the maker is asynchronous. If there already is one, return that. Otherwise,
-   * call `makeValue(key)`, remember it as the value for that key, and return
-   * it.
+   * Call `provideAsync` to get or make the value associated with the key,
+   * when the maker is asynchronous.
+   * If there already is one, return that. Otherwise,
+   * call `makeValue(key)`, remember it as the value for
+   * that key, and return it.
    *
    * @param {K} key
-   * @param {(key: K) => Promise<V>} makeValue make the value for the store if
-   *   it hasn't been made yet or the last make failed
+   * @param {(key: K) => Promise<V>} makeValue make the value for the store
+   * if it hasn't been made yet or the last make failed
    * @param {(key: K, value: V) => Promise<void>} [finishValue] runs exactly
-   *   once after a new value is added to the store
+   * once after a new value is added to the store
    * @returns {Promise<V>}
    */
   const provideAsync = (key, makeValue, finishValue) => {