fixup! remove some * imports

Author: erights

packages/internal/src/lib-chainStorage.js

@@ -4,7 +4,7 @@ import { Fail } from '@endo/errors';
 import { E, Far } from '@endo/far';
 import { M } from '@endo/patterns';
 import { makeHeapZone } from '@agoric/base-zone/heap.js';
-import * as cb from './callback.js';
+import { callE, makeFunctionCallback } from './callback.js';
 
 /**
  * @import {ERef} from '@endo/far';
@@ -188,7 +188,7 @@ export const prepareChainStorageNode = zone => {
        */
       async getStoreKey() {
         const { path, messenger } = this.state;
-        return cb.callE(messenger, {
+        return callE(messenger, {
           method: 'getStoreKey',
           args: [path],
         });
@@ -220,7 +220,7 @@ export const prepareChainStorageNode = zone => {
         } else {
           entry = [path, value];
         }
-        await cb.callE(messenger, {
+        await callE(messenger, {
           method: sequence ? 'append' : 'set',
           args: [entry],
         });
@@ -257,7 +257,7 @@ export function makeChainStorageRoot(
   rootPath,
   rootOptions = {},
 ) {
-  const messenger = cb.makeFunctionCallback(handleStorageMessage);
+  const messenger = makeFunctionCallback(handleStorageMessage);
 
   // Use the heapZone directly.
   const rootNode = makeHeapChainStorageNode(messenger, rootPath, rootOptions);

packages/internal/test/callback.test.js

@@ -3,7 +3,16 @@ import test from 'ava';
 
 import { Far } from '@endo/far';
 import { makeHeapZone } from '@agoric/base-zone/heap.js';
-import * as cb from '../src/callback.js';
+import {
+  makeSyncFunctionCallback,
+  makeSyncMethodCallback,
+  callSync,
+  makeMethodCallback,
+  callE,
+  makeFunctionCallback,
+  isCallback,
+  prepareAttenuator,
+} from '../src/callback.js';
 import {
   passableSymbolForName,
   unpassableSymbolForName,
@@ -21,36 +30,36 @@ test('near function callbacks', t => {
   const f = (a, b, c) => `${a + b}${c}`;
 
   /** @type {SyncCallback<typeof f>} */
-  const cb0 = cb.makeSyncFunctionCallback(f);
+  const cb0 = makeSyncFunctionCallback(f);
   t.deepEqual(cb0, { target: f, bound: [], isSync: true });
 
   /** @type {SyncCallback<(b: number, c: string) => string>} */
-  const cb1 = cb.makeSyncFunctionCallback(f, 9);
+  const cb1 = makeSyncFunctionCallback(f, 9);
   t.deepEqual(cb1, { target: f, bound: [9], isSync: true });
 
   /** @type {SyncCallback<(c: string) => string>} */
-  const cb2 = cb.makeSyncFunctionCallback(f, 9, 10);
+  const cb2 = makeSyncFunctionCallback(f, 9, 10);
   t.deepEqual(cb2, { target: f, bound: [9, 10], isSync: true });
 
   // @ts-expect-error deliberate: boolean is not assignable to string
-  const cb3 = cb.makeSyncFunctionCallback(f, 9, 10, true);
+  const cb3 = makeSyncFunctionCallback(f, 9, 10, true);
   t.deepEqual(cb3, { target: f, bound: [9, 10, true], isSync: true });
 
   // @ts-expect-error deliberate: Expected 4 arguments but got 5
-  t.is(cb.callSync(cb0, 2, 3, 'go', 'bad'), '5go');
+  t.is(callSync(cb0, 2, 3, 'go', 'bad'), '5go');
 
   // @ts-expect-error deliberate: number is not assignable to string
-  t.is(cb.callSync(cb0, 2, 3, 2), '52');
+  t.is(callSync(cb0, 2, 3, 2), '52');
 
-  t.is(cb.callSync(cb1, 10, 'go'), '19go');
-  t.is(cb.callSync(cb2, 'go'), '19go');
+  t.is(callSync(cb1, 10, 'go'), '19go');
+  t.is(callSync(cb2, 'go'), '19go');
 
   const cbp2 = /** @type {SyncCallback<(...args: unknown[]) => any>} */ ({
     target: Promise.resolve(f),
     methodName: undefined,
     bound: [9, 10],
   });
-  t.throws(() => cb.callSync(cbp2, 'go'), { message: /not a function/ });
+  t.throws(() => callSync(cbp2, 'go'), { message: /not a function/ });
 });
 
 test('near method callbacks', t => {
@@ -78,15 +87,15 @@ test('near method callbacks', t => {
   };
 
   /** @type {SyncCallback<typeof o.m1>} */
-  const cb0 = cb.makeSyncMethodCallback(o, 'm1');
+  const cb0 = makeSyncMethodCallback(o, 'm1');
   t.deepEqual(cb0, { target: o, methodName: 'm1', bound: [], isSync: true });
 
   /** @type {SyncCallback<(b: number, c: string) => string>} */
-  const cb1 = cb.makeSyncMethodCallback(o, 'm1', 9);
+  const cb1 = makeSyncMethodCallback(o, 'm1', 9);
   t.deepEqual(cb1, { target: o, methodName: 'm1', bound: [9], isSync: true });
 
   /** @type {SyncCallback<(c: string) => string>} */
-  const cb2 = cb.makeSyncMethodCallback(o, 'm1', 9, 10);
+  const cb2 = makeSyncMethodCallback(o, 'm1', 9, 10);
   t.deepEqual(cb2, {
     target: o,
     methodName: 'm1',
@@ -95,7 +104,7 @@ test('near method callbacks', t => {
   });
 
   // @ts-expect-error deliberate: boolean is not assignable to string
-  const cb3 = cb.makeSyncMethodCallback(o, 'm1', 9, 10, true);
+  const cb3 = makeSyncMethodCallback(o, 'm1', 9, 10, true);
   t.deepEqual(cb3, {
     target: o,
     methodName: 'm1',
@@ -104,24 +113,24 @@ test('near method callbacks', t => {
   });
 
   /** @type {SyncCallback<(c: string) => string>} */
-  const cb4 = cb.makeSyncMethodCallback(o, m2, 9, 10);
+  const cb4 = makeSyncMethodCallback(o, m2, 9, 10);
   t.deepEqual(cb4, { target: o, methodName: m2, bound: [9, 10], isSync: true });
 
   // @ts-expect-error deliberate: Expected 4 arguments but got 5
-  t.is(cb.callSync(cb0, 2, 3, 'go', 'bad'), '5go');
+  t.is(callSync(cb0, 2, 3, 'go', 'bad'), '5go');
 
   // @ts-expect-error deliberate: number is not assignable to string
-  t.is(cb.callSync(cb0, 2, 3, 2), '52');
+  t.is(callSync(cb0, 2, 3, 2), '52');
 
-  t.is(cb.callSync(cb1, 10, 'go'), '19go');
-  t.is(cb.callSync(cb2, 'go'), '19go');
-  t.is(cb.callSync(cb4, 'go'), '19go');
+  t.is(callSync(cb1, 10, 'go'), '19go');
+  t.is(callSync(cb2, 'go'), '19go');
+  t.is(callSync(cb4, 'go'), '19go');
 
   // @ts-expect-error deliberate: Promise provides no match for the signature
-  const cbp2 = cb.makeSyncMethodCallback(Promise.resolve(o), 'm1', 9, 10);
+  const cbp2 = makeSyncMethodCallback(Promise.resolve(o), 'm1', 9, 10);
   t.like(cbp2, { methodName: 'm1', bound: [9, 10], isSync: true });
   t.assert(cbp2.target instanceof Promise);
-  t.throws(() => cb.callSync(cbp2, 'go'), { message: /not a function/ });
+  t.throws(() => callSync(cbp2, 'go'), { message: /not a function/ });
 });
 
 test('far method callbacks', async t => {
@@ -148,23 +157,23 @@ test('far method callbacks', async t => {
   });
 
   /** @type {Callback<(c: string) => Promise<string>>} */
-  const cbp2 = cb.makeMethodCallback(Promise.resolve(o), 'm1', 9, 10);
+  const cbp2 = makeMethodCallback(Promise.resolve(o), 'm1', 9, 10);
   t.like(cbp2, { methodName: 'm1', bound: [9, 10] });
   t.assert(cbp2.target instanceof Promise);
-  const p2r = cb.callE(cbp2, 'go');
+  const p2r = callE(cbp2, 'go');
   t.assert(p2r instanceof Promise);
   t.is(await p2r, '19go');
 
   /** @type {Callback<(c: string) => Promise<string>>} */
-  const cbp3 = cb.makeMethodCallback(Promise.resolve(o), 'm2', 9, 10);
+  const cbp3 = makeMethodCallback(Promise.resolve(o), 'm2', 9, 10);
   t.like(cbp3, { methodName: 'm2', bound: [9, 10] });
   t.assert(cbp3.target instanceof Promise);
-  const p3r = cb.callE(cbp3, 'go');
+  const p3r = callE(cbp3, 'go');
   t.assert(p3r instanceof Promise);
   t.is(await p3r, '19go');
 
   // @ts-expect-error deliberate: is not assignable to SyncCallback
-  const thunk = () => cb.callSync(cbp2, 'go');
+  const thunk = () => callSync(cbp2, 'go');
   t.throws(thunk, { message: /not a function/ });
 });
 
@@ -178,105 +187,96 @@ test('far function callbacks', async t => {
   const f = async (a, b, c) => `${a + b}${c}`;
 
   /** @type {Callback<(c: string) => Promise<string>>} */
-  const cbp2 = cb.makeFunctionCallback(Promise.resolve(f), 9, 10);
+  const cbp2 = makeFunctionCallback(Promise.resolve(f), 9, 10);
   t.like(cbp2, { bound: [9, 10] });
   t.assert(cbp2.target instanceof Promise);
   // @ts-expect-error deliberate: is not assignable to SyncCallback
-  const thunk = () => cb.callSync(cbp2, 'go');
+  const thunk = () => callSync(cbp2, 'go');
   t.throws(thunk, { message: /not a function/ });
-  const p2r = cb.callE(cbp2, 'go');
+  const p2r = callE(cbp2, 'go');
   t.assert(p2r instanceof Promise);
   t.is(await p2r, '19go');
 });
 
 test('bad callbacks', t => {
   t.throws(
     // @ts-expect-error deliberate: number is not assignable to function
-    () => cb.makeFunctionCallback(42),
+    () => makeFunctionCallback(42),
     undefined,
     'number as function presence',
   );
   t.throws(
-    () => cb.makeMethodCallback('string', 'slice'),
+    () => makeMethodCallback('string', 'slice'),
     undefined,
     'string as presence',
   );
   t.throws(
     // @ts-expect-error deliberate: object is not assignable to function
-    () => cb.makeSyncFunctionCallback({}),
+    () => makeSyncFunctionCallback({}),
     undefined,
     'plain object as function',
   );
   t.throws(
-    () => cb.makeSyncMethodCallback(false, 'valueOf'),
+    () => makeSyncMethodCallback(false, 'valueOf'),
     undefined,
     'boolean as object',
   );
 });
 
 test('isCallback', t => {
   t.true(
-    cb.isCallback(cb.makeFunctionCallback(async () => {})),
+    isCallback(makeFunctionCallback(async () => {})),
     'makeFunctionCallback',
   );
   const sym = Symbol.asyncIterator;
   t.true(
-    cb.isCallback(cb.makeMethodCallback({ [sym]: async () => {} }, sym)),
+    isCallback(makeMethodCallback({ [sym]: async () => {} }, sym)),
     'makeMethodCallback',
   );
   t.true(
-    cb.isCallback(cb.makeSyncFunctionCallback(() => {})),
+    isCallback(makeSyncFunctionCallback(() => {})),
     'makeSyncFunctionCallback',
   );
   t.true(
-    cb.isCallback(cb.makeSyncMethodCallback({ m: () => {} }, 'm')),
+    isCallback(makeSyncMethodCallback({ m: () => {} }, 'm')),
     'makeSyncMethodCallback',
   );
   // manually-implemented original-format callback objects must always work
-  t.true(cb.isCallback({ target: () => {}, bound: [] }), 'manual function');
+  t.true(isCallback({ target: () => {}, bound: [] }), 'manual function');
   t.true(
-    cb.isCallback({ target: {}, methodName: 'foo', bound: [] }),
+    isCallback({ target: {}, methodName: 'foo', bound: [] }),
     'manual method',
   );
   t.true(
-    cb.isCallback({
+    isCallback({
       target: {},
       methodName: passableSymbolForName('foo'),
       bound: [],
     }),
     'manual symbol-keyed method',
   );
 
-  t.false(cb.isCallback(undefined), 'undefined');
-  t.false(cb.isCallback(null), 'null');
-  t.false(cb.isCallback('string'), 'string');
-  t.false(cb.isCallback({}), 'empty object');
-  t.false(
-    cb.isCallback({ target: 'non-object', bound: [] }),
-    'non-object target',
-  );
+  t.false(isCallback(undefined), 'undefined');
+  t.false(isCallback(null), 'null');
+  t.false(isCallback('string'), 'string');
+  t.false(isCallback({}), 'empty object');
+  t.false(isCallback({ target: 'non-object', bound: [] }), 'non-object target');
   t.false(
-    cb.isCallback({
+    isCallback({
       target: {},
       methodName: unpassableSymbolForName('foo'),
       bound: [],
     }),
     'unique symbol method name',
   );
-  t.false(cb.isCallback({ target: {}, bound: {} }), 'non-array bound args');
-  t.false(
-    cb.isCallback({ target: {}, bound: undefined }),
-    'undefined bound args',
-  );
-  t.false(
-    cb.isCallback({ target: {}, methodName: 'foo' }),
-    'missing bound args',
-  );
+  t.false(isCallback({ target: {}, bound: {} }), 'non-array bound args');
+  t.false(isCallback({ target: {}, bound: undefined }), 'undefined bound args');
+  t.false(isCallback({ target: {}, methodName: 'foo' }), 'missing bound args');
 });
 
 test('makeAttenuator', async t => {
   const zone = makeHeapZone();
-  const makeAttenuator = cb.prepareAttenuator(zone, ['m0', 'm1', 'm2', 'm4']);
+  const makeAttenuator = prepareAttenuator(zone, ['m0', 'm1', 'm2', 'm4']);
   const target = Far('original', {
     m0() {
       return 'return original.m0';
@@ -314,7 +314,7 @@ test('makeAttenuator', async t => {
     isSync: true,
     overrides: {
       m1: null,
-      m2: cb.makeMethodCallback(
+      m2: makeMethodCallback(
         Far('Abc', {
           abc() {
             return 'return abc';

packages/vats/src/vat-bridge.js

@@ -1,7 +1,7 @@
 import { Fail } from '@endo/errors';
 import { Far } from '@endo/far';
 import { makeDurableZone } from '@agoric/zone/durable.js';
-import * as cb from '@agoric/internal/src/callback.js';
+import { makeMethodCallback } from '@agoric/internal/src/callback.js';
 import { prepareChainStorageNode } from '@agoric/internal/src/lib-chainStorage.js';
 import { prepareBridgeManager } from './bridge.js';
 
@@ -34,7 +34,7 @@ export function buildRootObject(vatPowers, _args, baggage) {
 
     const storageBridgeManager = await storageBridgeManagerP;
     const rootNode = makeChainStorageNode(
-      cb.makeMethodCallback(storageBridgeManager, 'toBridge'),
+      makeMethodCallback(storageBridgeManager, 'toBridge'),
       rootPath,
       options,
     );