@agoric/vats 0.15.2-dev-b5a2ed1.0 → 0.15.2-dev-3da32ff.0

package/src/types.d.ts

@@ -1,129 +1,109 @@
-export type EOnly<T> = import('@endo/far').EOnly<T>;
-export type Board = ReturnType<ReturnType<typeof import('./lib-board.js').prepareBoardKit>>['board'];
+/* eslint-disable no-use-before-define */
+
+export type Board = ReturnType<
+  ReturnType<typeof import('./lib-board.js').prepareBoardKit>
+>['board'];
+
 /**
  * read-only access to a node in a name hierarchy
  *
- *   NOTE: We need to return arrays, not iterables, because even if marshal could
- *   allow passing a remote iterable, there would be an inordinate number of
- *   round trips for the contents of even the simplest nameHub.
+ * NOTE: We need to return arrays, not iterables, because even if marshal could
+ * allow passing a remote iterable, there would be an inordinate number of round
+ * trips for the contents of even the simplest nameHub.
  */
 export type NameHub = {
-    has: (key: string) => boolean;
-    /**
-     * Look up a path of keys
-     * starting from the current NameHub. Wait on any reserved promises.
-     */
-    lookup: (...path: string[]) => Promise<any>;
-    /**
-     * get
-     * all the entries available in the current NameHub
-     */
-    entries: (includeReserved?: boolean) => [string, unknown][];
-    /**
-     * get all names available in the current
-     * NameHub
-     */
-    keys: () => string[];
-    /**
-     * get all values available in the current
-     * NameHub
-     */
-    values: () => unknown[];
+  has: (key: string) => boolean;
+  /**
+   * Look up a path of keys starting from the current NameHub. Wait on any
+   * reserved promises.
+   */
+  lookup: (...path: string[]) => Promise<any>;
+  /** get all the entries available in the current NameHub */
+  entries: (includeReserved?: boolean) => [string, unknown][];
+  /** get all names available in the current NameHub */
+  keys: () => string[];
+  /** get all values available in the current NameHub */
+  values: () => unknown[];
 };
-/**
- * write access to a node in a name hierarchy
- */
+
+/** write access to a node in a name hierarchy */
 export type NameAdmin = {
-    provideChild: (key: string, reserved?: string[]) => Promise<NameHubKit>;
-    /**
-     * Mark a key as reserved;
-     * will return a promise that is fulfilled when the key is updated (or
-     * rejected when deleted). If the key was already set it does nothing.
-     */
-    reserve: (key: string) => Promise<void>;
-    /**
-     *   Update if not already updated. Return existing value, or newValue if not
-     *   existing.
-     */
-    default: <T>(key: string, newValue: T, newAdmin?: NameAdmin) => T;
-    /**
-     *   Update only if already initialized. Reject if not.
-     */
-    set: (key: string, newValue: unknown, newAdmin?: NameAdmin) => void;
-    /**
-     *   Fulfill an outstanding reserved promise (if any) to the newValue and set the
-     *   key to the newValue. If newAdmin is provided, set that to return via
-     *   lookupAdmin.
-     */
-    update: (key: string, newValue: unknown, newAdmin?: NameAdmin) => void;
-    /**
-     * Look up the
-     * `newAdmin` from the path of keys starting from the current NameAdmin. Wait
-     * on any reserved promises.
-     */
-    lookupAdmin: (...path: string[]) => Promise<NameAdmin>;
-    /**
-     * Delete a value and reject an
-     * outstanding reserved promise (if any).
-     */
-    delete: (key: string) => void;
-    /**
-     * get the NameHub corresponding to the
-     * current NameAdmin
-     */
-    readonly: () => NameHub;
-    onUpdate: (fn: undefined | NameHubUpdateHandler) => void;
+  provideChild: (key: string, reserved?: string[]) => Promise<NameHubKit>;
+  /**
+   * Mark a key as reserved; will return a promise that is fulfilled when the
+   * key is updated (or rejected when deleted). If the key was already set it
+   * does nothing.
+   */
+  reserve: (key: string) => Promise<void>;
+  /**
+   * Update if not already updated. Return existing value, or newValue if not
+   * existing.
+   */
+  default: <T>(key: string, newValue: T, newAdmin?: NameAdmin) => T;
+  /** Update only if already initialized. Reject if not. */
+  set: (key: string, newValue: unknown, newAdmin?: NameAdmin) => void;
+  /**
+   * Fulfill an outstanding reserved promise (if any) to the newValue and set
+   * the key to the newValue. If newAdmin is provided, set that to return via
+   * lookupAdmin.
+   */
+  update: (key: string, newValue: unknown, newAdmin?: NameAdmin) => void;
+  /**
+   * Look up the `newAdmin` from the path of keys starting from the current
+   * NameAdmin. Wait on any reserved promises.
+   */
+  lookupAdmin: (...path: string[]) => Promise<NameAdmin>;
+  /** Delete a value and reject an outstanding reserved promise (if any). */
+  delete: (key: string) => void;
+  /** get the NameHub corresponding to the current NameAdmin */
+  readonly: () => NameHub;
+  onUpdate: (fn: undefined | NameHubUpdateHandler) => void;
 };
+
 export type NameHubUpdateHandler = {
-    write: (entries: [string, unknown][]) => void;
+  write: (entries: [string, unknown][]) => void;
 };
-/**
- * a node in a name hierarchy
- */
+
+/** a node in a name hierarchy */
 export type NameHubKit = {
-    /**
-     * read access
-     */
-    nameHub: NameHub;
-    /**
-     * write access
-     */
-    nameAdmin: NameAdmin;
+  /** read access */
+  nameHub: NameHub;
+  /** write access */
+  nameAdmin: NameAdmin;
 };
+
 export type MyAddressNameAdmin = NameAdmin & {
-    getMyAddress(): string;
+  getMyAddress(): string;
 };
 export type NamesByAddressAdmin = NameAdmin & {
-    provideChild(addr: string, reserved?: string[]): Promise<{
-        nameHub: NameHub;
-        nameAdmin: MyAddressNameAdmin;
-    }>;
-    lookupAdmin(addr: string): Promise<MyAddressNameAdmin>;
+  provideChild(
+    addr: string,
+    reserved?: string[],
+  ): Promise<{
+    nameHub: NameHub;
+    nameAdmin: MyAddressNameAdmin;
+  }>;
+  lookupAdmin(addr: string): Promise<MyAddressNameAdmin>;
 };
-/**
- * An object that can receive messages from the
- *   bridge device
- */
+
+/** An object that can receive messages from the bridge device */
 export type BridgeHandler = {
-    /**
-     * Handle an inbound message
-     */
-    fromBridge: (obj: any) => Promise<void>;
+  /** Handle an inbound message */
+  fromBridge: (obj: any) => Promise<void>;
 };
-/**
- * An object which handles messages for a
- *   specific bridge
- */
+
+/** An object which handles messages for a specific bridge */
 export type ScopedBridgeManager = {
-    toBridge: (obj: any) => Promise<any>;
-    fromBridge: (obj: any) => Promise<void>;
-    initHandler: (handler: ERef<BridgeHandler>) => void;
-    setHandler: (handler: ERef<BridgeHandler>) => void;
+  toBridge: (obj: any) => Promise<any>;
+  fromBridge: (obj: any) => Promise<void>;
+  initHandler: (handler: ERef<BridgeHandler>) => void;
+  setHandler: (handler: ERef<BridgeHandler>) => void;
 };
-/**
- * The object to manage this bridge
- */
+
+/** The object to manage this bridge */
 export type BridgeManager = {
-    register: (bridgeId: string, handler?: ERef<BridgeHandler | undefined>) => ScopedBridgeManager;
+  register: (
+    bridgeId: string,
+    handler?: ERef<BridgeHandler | undefined>,
+  ) => ScopedBridgeManager;
 };
-//# sourceMappingURL=types.d.ts.map

package/src/types.js

@@ -1,101 +1,2 @@
-// @ts-check
-
+// Empty JS file to correspond with types.d.ts
 export {};
-
-/**
- * @template T
- * @typedef {import('@endo/far').EOnly<T>} EOnly
- */
-
-/**
- * @typedef {ReturnType<
- *   ReturnType<typeof import('./lib-board.js').prepareBoardKit>
- * >['board']} Board
- */
-
-/**
- * @typedef {object} NameHub read-only access to a node in a name hierarchy
- *
- *   NOTE: We need to return arrays, not iterables, because even if marshal could
- *   allow passing a remote iterable, there would be an inordinate number of
- *   round trips for the contents of even the simplest nameHub.
- * @property {(key: string) => boolean} has
- * @property {(...path: string[]) => Promise<any>} lookup Look up a path of keys
- *   starting from the current NameHub. Wait on any reserved promises.
- * @property {(includeReserved?: boolean) => [string, unknown][]} entries get
- *   all the entries available in the current NameHub
- * @property {() => string[]} keys get all names available in the current
- *   NameHub
- * @property {() => unknown[]} values get all values available in the current
- *   NameHub
- */
-
-/**
- * @typedef {object} NameAdmin write access to a node in a name hierarchy
- * @property {(key: string, reserved?: string[]) => Promise<NameHubKit>} provideChild
- * @property {(key: string) => Promise<void>} reserve Mark a key as reserved;
- *   will return a promise that is fulfilled when the key is updated (or
- *   rejected when deleted). If the key was already set it does nothing.
- * @property {<T>(key: string, newValue: T, newAdmin?: NameAdmin) => T} default
- *   Update if not already updated. Return existing value, or newValue if not
- *   existing.
- * @property {(key: string, newValue: unknown, newAdmin?: NameAdmin) => void} set
- *   Update only if already initialized. Reject if not.
- * @property {(key: string, newValue: unknown, newAdmin?: NameAdmin) => void} update
- *   Fulfill an outstanding reserved promise (if any) to the newValue and set the
- *   key to the newValue. If newAdmin is provided, set that to return via
- *   lookupAdmin.
- * @property {(...path: string[]) => Promise<NameAdmin>} lookupAdmin Look up the
- *   `newAdmin` from the path of keys starting from the current NameAdmin. Wait
- *   on any reserved promises.
- * @property {(key: string) => void} delete Delete a value and reject an
- *   outstanding reserved promise (if any).
- * @property {() => NameHub} readonly get the NameHub corresponding to the
- *   current NameAdmin
- * @property {(fn: undefined | NameHubUpdateHandler) => void} onUpdate
- *
- * @typedef {{ write: (entries: [string, unknown][]) => void }} NameHubUpdateHandler
- */
-
-/**
- * @typedef {object} NameHubKit a node in a name hierarchy
- * @property {NameHub} nameHub read access
- * @property {NameAdmin} nameAdmin write access
- */
-
-/** @typedef {NameAdmin & { getMyAddress(): string }} MyAddressNameAdmin */
-/**
- * @typedef {NameAdmin & {
- *   provideChild(
- *     addr: string,
- *     reserved?: string[],
- *   ): Promise<{
- *     nameHub: NameHub;
- *     nameAdmin: MyAddressNameAdmin;
- *   }>;
- *   lookupAdmin(addr: string): Promise<MyAddressNameAdmin>;
- * }} NamesByAddressAdmin
- */
-
-/**
- * @typedef {object} BridgeHandler An object that can receive messages from the
- *   bridge device
- * @property {(obj: any) => Promise<void>} fromBridge Handle an inbound message
- */
-
-/**
- * @typedef {object} ScopedBridgeManager An object which handles messages for a
- *   specific bridge
- * @property {(obj: any) => Promise<any>} toBridge
- * @property {(obj: any) => Promise<void>} fromBridge
- * @property {(handler: ERef<BridgeHandler>) => void} initHandler
- * @property {(handler: ERef<BridgeHandler>) => void} setHandler
- */
-
-/**
- * @typedef {object} BridgeManager The object to manage this bridge
- * @property {(
- *   bridgeId: string,
- *   handler?: ERef<BridgeHandler | undefined>,
- * ) => ScopedBridgeManager} register
- */

package/src/vat-provisioning.js

@@ -39,7 +39,7 @@ const prepareSpecializedNameAdmin = zone => {
        * @param {string} address
        * @param {string[]} [reserved]
        * @returns {Promise<{
-       *   nameHub: NameHub;
+       *   nameHub: import('./types.js').NameHub;
        *   nameAdmin: import('./types.js').MyAddressNameAdmin;
        * }>}
        */

package/tools/boot-test-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"boot-test-utils.d.ts","sourceRoot":"","sources":["boot-test-utils.js"],"names":[],"mappings":";;;;;;;;;;;AAkCO,6BAAqB;AAE5B,qBAAqB;AAErB,yBAFW,MAAM,CAEgB;AAE1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwCH;AAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiEN;AAEM,iDAON;mDAlJkD,2BAA2B;4CAClC,oBAAoB;6CACnB,qBAAqB;2CACvB,mBAAmB;6CACjB,qBAAqB;+CACnB,uBAAuB;sDAChB,8BAA8B;oDAChC,4BAA4B;2CACrC,mBAAmB"}
+{"version":3,"file":"boot-test-utils.d.ts","sourceRoot":"","sources":["boot-test-utils.js"],"names":[],"mappings":";;;;;;;;;;;AAkCO,6BAAqB;AAE5B,qBAAqB;AACrB,yBADW,MAAM,CACgB;AAE1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwCH;AAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiEN;AAEM,iDAON;mDAjJkD,2BAA2B;4CAClC,oBAAoB;6CACnB,qBAAqB;2CACvB,mBAAmB;6CACjB,qBAAqB;+CACnB,uBAAuB;sDAChB,8BAA8B;oDAChC,4BAA4B;2CACrC,mBAAmB"}

package/tools/boot-test-utils.js

@@ -35,7 +35,6 @@ export const vatRoots = {
 export const noop = () => {};
 
 /** @type {DProxy} */
-// @ts-expect-error cast
 export const mockDProxy = d => d;
 
 export const makeMock = log =>

package/tsconfig.json

@@ -9,6 +9,7 @@
     "*.js",
     "scripts/**/*.js",
     "src/**/*.js",
+    "src/**/*.d.ts",
     "test/**/*.js",
     "tools/**/*.js",
   ],