@agoric/internal 0.3.3-other-dev-8f8782b.0 → 0.3.3-other-dev-fbe72e7.0.fbe72e7

package/src/utils.d.ts

@@ -1,67 +0,0 @@
-export const BASIS_POINTS: 10000n;
-export function fromUniqueEntries<K, V>(allEntries: Iterable<[K, V]>): {};
-export function objectMap<O extends Record<string, any>, R>(original: O, mapFn: (value: O[keyof O], key: keyof O) => R): { [P in keyof O]: R; };
-export function listDifference(leftNames: Array<string | symbol>, rightNames: Array<string | symbol>): (string | symbol)[];
-export function throwLabeled(innerErr: Error, label: string | number, ErrorConstructor?: ErrorConstructor | undefined): never;
-export function applyLabelingError<A, R>(func: (...args: A[]) => R, args: A[], label?: string | number | undefined): R;
-/**
- * @template T
- * @typedef {{[KeyType in keyof T]: T[KeyType]} & {}} Simplify
- * flatten the type output to improve type hints shown in editors
- * https://github.com/sindresorhus/type-fest/blob/main/source/simplify.d.ts
- */
-/**
- * @typedef {(...args: any[]) => any} Callable
- */
-/**
- * @template {{}} T
- * @typedef {{ [K in keyof T]: T[K] extends Callable ? T[K] : DeeplyAwaited<T[K]> }} DeeplyAwaitedObject
- */
-/**
- * @template T
- * @typedef {T extends PromiseLike<any> ? Awaited<T> : T extends {} ? Simplify<DeeplyAwaitedObject<T>> : Awaited<T>} DeeplyAwaited
- */
-/**
- * A more constrained version of {deeplyFulfilled} for type safety until
- * https://github.com/endojs/endo/issues/1257
- * Useful in starting contracts that need all terms to be fulfilled
- * in order to be durable.
- *
- * @type {<T extends {}>(unfulfilledTerms: T) => Promise<DeeplyAwaited<T>>}
- */
-export const deeplyFulfilledObject: <T extends {}>(unfulfilledTerms: T) => Promise<DeeplyAwaited<T>>;
-export function makeMeasureSeconds(currentTimeMillisec: typeof import('perf_hooks').performance.now): <T>(fn: () => Promise<T>) => Promise<{
-    result: T;
-    duration: number;
-}>;
-export function makeAggregateError(errors: Error[], message?: string | undefined): Error;
-export function PromiseAllOrErrors<T>(items: readonly (T | PromiseLike<T>)[]): Promise<T[]>;
-/**
- * @type {<T>(
- *   trier: () => Promise<T>,
- *  finalizer: (error?: unknown) => Promise<void>,
- * ) => Promise<T>}
- */ export const aggregateTryFinally: <T>(trier: () => Promise<T>, finalizer: (error?: unknown) => Promise<void>) => Promise<T>;
-export function assertAllDefined<T extends Record<string, unknown>>(obj: T): asserts obj is AllDefined<T>;
-export const forever: AsyncIterable<undefined>;
-export function whileTrue<T>(produce: () => T): AsyncIterable<Awaited<T>>;
-export function untilTrue<T>(produce: () => T): AsyncIterable<Awaited<T>>;
-/** @type { <X, Y>(xs: X[], ys: Y[]) => [X, Y][]} */
-export const zip: <X, Y>(xs: X[], ys: Y[]) => [X, Y][];
-/** @type { <T extends Record<string, ERef<any>>>(obj: T) => Promise<{ [K in keyof T]: Awaited<T[K]>}> } */
-export const allValues: <T extends Record<string, any>>(obj: T) => Promise<{ [K in keyof T]: Awaited<T[K]>; }>;
-export function synchronizedTee<T = unknown>(sourceStream: AsyncIterator<T, void, void>, readerCount: number): AsyncGenerator<T, void, void>[];
-/**
- * <T>
- */
-export type ERef<T> = import('@endo/eventual-send').ERef<T>;
-/**
- * flatten the type output to improve type hints shown in editors
- * https://github.com/sindresorhus/type-fest/blob/main/source/simplify.d.ts
- */
-export type Simplify<T> = { [KeyType_1 in keyof T]: T[KeyType_1]; };
-export type Callable = (...args: any[]) => any;
-export type DeeplyAwaitedObject<T extends {}> = { [K in keyof T]: T[K] extends Callable ? T[K] : DeeplyAwaited<T[K]>; };
-export type DeeplyAwaited<T> = T extends PromiseLike<any> ? Awaited<T> : T extends {} ? Simplify<DeeplyAwaitedObject<T>> : Awaited<T>;
-export type AllDefined<T extends Record<string, unknown>> = { [P in keyof T]: Exclude<T[P], undefined>; };
-//# sourceMappingURL=utils.d.ts.map

package/src/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["utils.js"],"names":[],"mappings":"AAcA,kCAAoC;AAa7B,0EAcN;AA0CM,gJAIN;AAOM,0CAHI,MAAM,MAAM,GAAG,MAAM,CAAC,cACtB,MAAM,MAAM,GAAG,MAAM,CAAC,uBAKhC;AASM,uCALI,KAAK,SACL,MAAM,GAAC,MAAM,oDAEX,KAAK,CAYjB;AAUM,uHAyBN;AAGD;;;;;GAKG;AAEH;;GAEG;AAEH;;;GAGG;AAEH;;;GAGG;AAEH;;;;;;;GAOG;AACH,qGAGE;AAUK,wDAHI,cAAc,YAAY,EAAE,WAAW,CAAC,GAAG;;cACmB,MAAM;GAW9E;AAMM,2CAHI,KAAK,EAAE,uCAcjB;AAOM,4FAeN;AAED;;;;;GAKG,CAAC,mFAFoB,OAAO,KAAK,QAAQ,IAAI,CAAC,gBAY7C;AAiBG,0GAUN;AAQD,+CAAoD;AAU7C,0EAUH;AAUG,0EAaH;AAEJ,oDAAoD;AACpD,uDAAqE;AAErE,2GAA2G;AAC3G,+GAIE;AAWK,sGAFI,MAAM,mCA4FhB;;;;sBAlbyB,OAAO,qBAAqB,EAAE,IAAI,CAAC,CAAC,CAAC;;;;;;iCAkJxC,GAAG,EAAE,KAAK,GAAG;;+BAUvB,CAAC,SAAS,YAAY,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC,GAAG,CAAC,SAAS,EAAE,GAAG,SAAS,oBAAoB,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC"}

package/src/utils.js

@@ -1,451 +0,0 @@
-// @ts-check
-// @jessie-check
-
-import { E } from '@endo/far';
-import { deeplyFulfilled, isObject } from '@endo/marshal';
-import { isPromise, makePromiseKit } from '@endo/promise-kit';
-import { makeQueue } from '@endo/stream';
-import { asyncGenerate, makeSet } from 'jessie.js';
-
-const { entries, fromEntries, keys, values } = Object;
-const { ownKeys } = Reflect;
-
-const { details: X, quote: q, Fail } = assert;
-
-export const BASIS_POINTS = 10_000n;
-
-/** @template T @typedef {import('@endo/eventual-send').ERef<T>} ERef<T> */
-
-/**
- * Throws if multiple entries use the same property name. Otherwise acts
- * like `Object.fromEntries` but hardens the result.
- * Use it to protect from property names computed from user-provided data.
- *
- * @template K,V
- * @param {Iterable<[K,V]>} allEntries
- * @returns {{[k: K]: V}}
- */
-export const fromUniqueEntries = allEntries => {
-  const entriesArray = [...allEntries];
-  const result = harden(fromEntries(entriesArray));
-  if (ownKeys(result).length === entriesArray.length) {
-    return result;
-  }
-  const names = makeSet();
-  for (const [name, _] of entriesArray) {
-    if (names.has(name)) {
-      Fail`collision on property name ${q(name)}: ${entriesArray}`;
-    }
-    names.add(name);
-  }
-  throw Fail`internal: failed to create object from unique entries`;
-};
-harden(fromUniqueEntries);
-
-/**
- * By analogy with how `Array.prototype.map` will map the elements of
- * an array to transformed elements of an array of the same shape,
- * `objectMap` will do likewise for the string-named own enumerable
- * properties of an object.
- *
- * Typical usage applies `objectMap` to a CopyRecord, i.e.,
- * an object for which `passStyleOf(original) === 'copyRecord'`. For these,
- * none of the following edge cases arise. The result will be a CopyRecord
- * with exactly the same property names, whose values are the mapped form of
- * the original's values.
- *
- * When the original is not a CopyRecord, some edge cases to be aware of
- *    * No matter how mutable the original object, the returned object is
- *      hardened.
- *    * Only the string-named enumerable own properties of the original
- *      are mapped. All other properties are ignored.
- *    * If any of the original properties were accessors, `Object.entries`
- *      will cause its `getter` to be called and will use the resulting
- *      value.
- *    * No matter whether the original property was an accessor, writable,
- *      or configurable, all the properties of the returned object will be
- *      non-writable, non-configurable, data properties.
- *    * No matter what the original object may have inherited from, and
- *      no matter whether it was a special kind of object such as an array,
- *      the returned object will always be a plain object inheriting directly
- *      from `Object.prototype` and whose state is only these new mapped
- *      own properties.
- *
- * With these differences, even if the original object was not a CopyRecord,
- * if all the mapped values are Passable, then the returned object will be
- * a CopyRecord.
- *
- * @template {Record<string, any>} O
- * @param {O} original
- * @template R map result
- * @param {(value: O[keyof O], key: keyof O) => R} mapFn
- * @returns {{ [P in keyof O]: R}}
- */
-export const objectMap = (original, mapFn) => {
-  const ents = entries(original);
-  const mapEnts = ents.map(([k, v]) => [k, mapFn(v, k)]);
-  return harden(fromEntries(mapEnts));
-};
-harden(objectMap);
-
-/**
- * @param {Array<string | symbol>} leftNames
- * @param {Array<string | symbol>} rightNames
- */
-export const listDifference = (leftNames, rightNames) => {
-  const rightSet = makeSet(rightNames);
-  return leftNames.filter(name => !rightSet.has(name));
-};
-harden(listDifference);
-
-/**
- * @param {Error} innerErr
- * @param {string|number} label
- * @param {ErrorConstructor} [ErrorConstructor]
- * @returns {never}
- */
-export const throwLabeled = (innerErr, label, ErrorConstructor = undefined) => {
-  if (typeof label === 'number') {
-    label = `[${label}]`;
-  }
-  const outerErr = assert.error(
-    `${label}: ${innerErr.message}`,
-    ErrorConstructor,
-  );
-  assert.note(outerErr, X`Caused by ${innerErr}`);
-  throw outerErr;
-};
-harden(throwLabeled);
-
-/**
- * @template A,R
- * @param {(...args: A[]) => R} func
- * @param {A[]} args
- * @param {string|number} [label]
- * @returns {R}
- */
-export const applyLabelingError = (func, args, label = undefined) => {
-  if (label === undefined) {
-    return func(...args);
-  }
-  let result;
-  try {
-    result = func(...args);
-  } catch (err) {
-    throwLabeled(err, label);
-  }
-  if (isPromise(result)) {
-    // If result is a rejected promise, this will return a promise with a
-    // different rejection reason. But this confuses TypeScript because it types
-    // that case as `Promise<never>` which is cool for a promise that will never
-    // fulfill.  But TypeScript doesn't understand that this will only happen
-    // when `result` was a rejected promise. In only this case `R` should
-    // already allow `Promise<never>` as a subtype.
-    /** @type {unknown} */
-    const relabeled = E.when(result, undefined, reason =>
-      throwLabeled(reason, label),
-    );
-    return /** @type {R} */ (relabeled);
-  } else {
-    return result;
-  }
-};
-harden(applyLabelingError);
-
-/**
- * @template T
- * @typedef {{[KeyType in keyof T]: T[KeyType]} & {}} Simplify
- * flatten the type output to improve type hints shown in editors
- * https://github.com/sindresorhus/type-fest/blob/main/source/simplify.d.ts
- */
-
-/**
- * @typedef {(...args: any[]) => any} Callable
- */
-
-/**
- * @template {{}} T
- * @typedef {{ [K in keyof T]: T[K] extends Callable ? T[K] : DeeplyAwaited<T[K]> }} DeeplyAwaitedObject
- */
-
-/**
- * @template T
- * @typedef {T extends PromiseLike<any> ? Awaited<T> : T extends {} ? Simplify<DeeplyAwaitedObject<T>> : Awaited<T>} DeeplyAwaited
- */
-
-/**
- * A more constrained version of {deeplyFulfilled} for type safety until
- * https://github.com/endojs/endo/issues/1257
- * Useful in starting contracts that need all terms to be fulfilled
- * in order to be durable.
- *
- * @type {<T extends {}>(unfulfilledTerms: T) => Promise<DeeplyAwaited<T>>}
- */
-export const deeplyFulfilledObject = async obj => {
-  isObject(obj) || Fail`param must be an object`;
-  return deeplyFulfilled(obj);
-};
-
-/**
- * Returns a function that uses a millisecond-based time-since-epoch capability
- * (such as `performance.now`) to measure execution time of an async function
- * and report the result in seconds to match our telemetry standard.
- *
- * @param {typeof import('perf_hooks').performance.now} currentTimeMillisec
- * @returns {<T>(fn: () => Promise<T>) => Promise<{ result: T, duration: number }>}
- */
-export const makeMeasureSeconds = currentTimeMillisec => {
-  /** @param {() => any} fn */
-  const measureSeconds = async fn => {
-    const t0 = currentTimeMillisec();
-    const result = await fn();
-    const durationMillisec = currentTimeMillisec() - t0;
-    return { result, duration: durationMillisec / 1000 };
-  };
-  return measureSeconds;
-};
-
-/**
- * @param {Error[]} errors
- * @param {string} [message]
- */
-export const makeAggregateError = (errors, message) => {
-  const err = Error(message);
-  Object.defineProperties(err, {
-    name: {
-      value: 'AggregateError',
-    },
-    errors: {
-      value: errors,
-    },
-  });
-  return err;
-};
-
-/**
- * @template T
- * @param {readonly (T | PromiseLike<T>)[]} items
- * @returns {Promise<T[]>}
- */
-export const PromiseAllOrErrors = async items => {
-  return Promise.allSettled(items).then(results => {
-    const errors = /** @type {PromiseRejectedResult[]} */ (
-      results.filter(({ status }) => status === 'rejected')
-    ).map(result => result.reason);
-    if (!errors.length) {
-      return /** @type {PromiseFulfilledResult<T>[]} */ (results).map(
-        result => result.value,
-      );
-    } else if (errors.length === 1) {
-      throw errors[0];
-    } else {
-      throw makeAggregateError(errors);
-    }
-  });
-};
-
-/**
- * @type {<T>(
- *   trier: () => Promise<T>,
- *  finalizer: (error?: unknown) => Promise<void>,
- * ) => Promise<T>}
- */ export const aggregateTryFinally = async (trier, finalizer) =>
-  trier().then(
-    async result => finalizer().then(() => result),
-    async tryError =>
-      finalizer(tryError)
-        .then(
-          () => tryError,
-          finalizeError => makeAggregateError([tryError, finalizeError]),
-        )
-        .then(error => Promise.reject(error)),
-  );
-
-/**
- * @template {Record<string, unknown>} T
- * @typedef {{[P in keyof T]: Exclude<T[P], undefined>;}} AllDefined
- */
-
-/**
- * Concise way to check values are available from object literal shorthand.
- * Throws error message to specify the missing values.
- *
- * @template {Record<string, unknown>} T
- * @param {T} obj
- * @throws if any value in the object entries is not defined
- * @returns {asserts obj is AllDefined<T>}
- */
-
-export const assertAllDefined = obj => {
-  const missing = [];
-  for (const [key, val] of Object.entries(obj)) {
-    if (val === undefined) {
-      missing.push(key);
-    }
-  }
-  if (missing.length > 0) {
-    Fail`missing ${q(missing)}`;
-  }
-};
-
-/** @type {IteratorResult<undefined, never>} */
-const notDone = harden({ done: false, value: undefined });
-
-/** @type {IteratorResult<never, void>} */
-const alwaysDone = harden({ done: true, value: undefined });
-
-export const forever = asyncGenerate(() => notDone);
-
-/**
- * @template T
- * @param {() => T} produce
- * The value of `await produce()` is used for its truthiness vs falsiness.
- * IOW, it is coerced to a boolean so the caller need not bother doing this
- * themselves.
- * @returns {AsyncIterable<Awaited<T>>}
- */
-export const whileTrue = produce =>
-  asyncGenerate(async () => {
-    const value = await produce();
-    if (!value) {
-      return alwaysDone;
-    }
-    return harden({
-      done: false,
-      value,
-    });
-  });
-
-/**
- * @template T
- * @param {() => T} produce
- * The value of `await produce()` is used for its truthiness vs falsiness.
- * IOW, it is coerced to a boolean so the caller need not bother doing this
- * themselves.
- * @returns {AsyncIterable<Awaited<T>>}
- */
-export const untilTrue = produce =>
-  asyncGenerate(async () => {
-    const value = await produce();
-    if (value) {
-      return harden({
-        done: true,
-        value,
-      });
-    }
-    return harden({
-      done: false,
-      value,
-    });
-  });
-
-/** @type { <X, Y>(xs: X[], ys: Y[]) => [X, Y][]} */
-export const zip = (xs, ys) => harden(xs.map((x, i) => [x, ys[+i]]));
-
-/** @type { <T extends Record<string, ERef<any>>>(obj: T) => Promise<{ [K in keyof T]: Awaited<T[K]>}> } */
-export const allValues = async obj => {
-  const resolved = await Promise.all(values(obj));
-  // @ts-expect-error cast
-  return harden(fromEntries(zip(keys(obj), resolved)));
-};
-
-/**
- * A tee implementation where all readers are synchronized with each other.
- * They all consume the source stream in lockstep, and any one returning or
- * throwing early will affect the others.
- *
- * @template [T=unknown]
- * @param {AsyncIterator<T, void, void>} sourceStream
- * @param {number} readerCount
- */
-export const synchronizedTee = (sourceStream, readerCount) => {
-  /** @type {IteratorReturnResult<void> | undefined} */
-  let doneResult;
-
-  /** @typedef {IteratorResult<(value: PromiseLike<IteratorResult<T>>) => void>} QueuePayload */
-  /** @type {import('@endo/stream').AsyncQueue<QueuePayload>[]} */
-  const queues = [];
-
-  /** @returns {Promise<void>} */
-  const pullNext = async () => {
-    const requests = await Promise.allSettled(queues.map(queue => queue.get()));
-    const rejections = [];
-    /** @type {Array<(value: PromiseLike<IteratorResult<T>>) => void>} */
-    const resolvers = [];
-    let done = false;
-    for (const settledResult of requests) {
-      if (settledResult.status === 'rejected') {
-        rejections.push(settledResult.reason);
-      } else {
-        done ||= !!settledResult.value.done;
-        resolvers.push(settledResult.value.value);
-      }
-    }
-    /** @type {Promise<IteratorResult<T>>} */
-    let result;
-    if (doneResult) {
-      result = Promise.resolve(doneResult);
-    } else if (rejections.length) {
-      const error = assert.error(assert.details`Teed stream threw`);
-      assert.note(error, assert.details`Teed rejections: ${rejections}`);
-      result =
-        sourceStream.throw?.(error) ||
-        Promise.resolve(sourceStream.return?.()).then(() =>
-          Promise.reject(error),
-        );
-    } else if (done) {
-      result =
-        sourceStream.return?.() ||
-        Promise.resolve({ done: true, value: undefined });
-    } else {
-      result = sourceStream.next();
-    }
-    result.then(
-      r => {
-        if (r.done) {
-          doneResult = r;
-        }
-      },
-      () => {
-        doneResult = { done: true, value: undefined };
-      },
-    );
-    resolvers.forEach(resolve => resolve(result));
-    return pullNext();
-  };
-
-  const readers = Array.from({ length: readerCount }).map(() => {
-    /** @type {import('@endo/stream').AsyncQueue<QueuePayload>} */
-    const queue = makeQueue();
-    queues.push(queue);
-
-    /** @type {AsyncGenerator<T, void, void>} */
-    const reader = harden({
-      async next() {
-        /** @type {import('@endo/promise-kit').PromiseKit<IteratorResult<T>>} */
-        const { promise, resolve } = makePromiseKit();
-        queue.put({ value: resolve, done: false });
-        return promise;
-      },
-      async return() {
-        /** @type {import('@endo/promise-kit').PromiseKit<IteratorResult<T>>} */
-        const { promise, resolve } = makePromiseKit();
-        queue.put({ value: resolve, done: true });
-        return promise;
-      },
-      async throw(reason) {
-        const rejection = Promise.reject(reason);
-        queue.put(rejection);
-        return rejection;
-      },
-      // eslint-disable-next-line no-restricted-globals
-      [Symbol.asyncIterator]() {
-        return reader;
-      },
-    });
-    return reader;
-  });
-
-  void pullNext();
-  return readers;
-};