@agoric/internal 0.4.0 → 0.4.1-upgrade-23-dev-bd79330.0.bd79330

package/vendor/anylogger.ts

@@ -0,0 +1,160 @@
+// @ts-nocheck
+/* eslint-disable -- vendored upstream source */
+/**
+ * VENDORED SOURCE - DO NOT EDIT DIRECTLY
+ *
+ * Source of truth for the anylogger vendored module.
+ *
+ * This vendoring flow intentionally keeps three files:
+ * - `vendor/anylogger.ts`: upstream TypeScript source (kept close to upstream).
+ * - `vendor/anylogger.js`: generated runtime for consumers that import JS directly.
+ * - `vendor/anylogger.d.ts`: generated declarations for type imports from that same JS path.
+ *
+ * To regenerate generated artifacts after editing the TypeScript source file (vendor/anylogger.ts):
+ * `cd packages/internal && yarn run -T tsc --project vendor/tsconfig.anylogger.json`
+ */
+// prettier-ignore-start
+
+/**
+ * A log function is a function that takes a variable amount of
+ * arguments and returns void.
+ */
+export type LogFunction = (...args: any) => void;
+
+/**
+ * The default base log levels for anylogger.
+ */
+export type LogLevels = {
+  error: 1;
+  warn: 2;
+  info: 3;
+  log: 4;
+  debug: 5;
+  trace: 6;
+};
+
+/**
+ * A log level is a string that is a key of `LogLevels`.
+ */
+export type LogLevel = keyof LogLevels;
+
+/**
+ * All loggers, keyed by name.
+ */
+export type AllLoggers = {
+  [name: string]: Logger;
+};
+
+/**
+ * An alias for the much used concept of a LoggerName.
+ */
+export type LoggerName = string;
+
+/**
+ * An adapter accepts a LogFunction and returns a Logger.
+ */
+export type Adapter = (logfn: LogFunction) => Logger;
+
+/**
+ * A logger is a log function that has a `name` that corresponds to the logger
+ * name, a method `enabledFor(level: LogLevel)` to check whether the logger is
+ * enabled for a certain log level, and log methods for each of the log levels
+ * supported by AnyLogger: `error`, `warn`, `info`, `log`, `debug` and `trace`.
+ */
+export type Logger = LogFunction & {
+  readonly name: LoggerName;
+  enabledFor: (level?: LogLevel) => boolean | void;
+} & {
+  [P in keyof LogLevels as `${P}`]: LogFunction;
+};
+
+/**
+ * Gets or creates a logger by name.
+ */
+export type AnyLogger = ((name: LoggerName) => Logger) & {
+  /**
+   * Stores all loggers created so far.
+   */
+  all: AllLoggers;
+
+  /**
+   * An object containing a mapping of level names to level values.
+   */
+  levels: { [level: string]: number };
+
+  /**
+   * Called when a new logger needs to be created.
+   */
+  new: (name: LoggerName) => LogFunction;
+
+  /**
+   * Called by the log function that the default implementation of
+   * `anylogger.new` creates.
+   */
+  log: (name: LoggerName, ...args: any) => void;
+
+  /**
+   * Called when a log function needs to be extended.
+   */
+  ext: Adapter;
+};
+
+/**
+ * Back-compat alias used by callers in this repository.
+ */
+export type BaseLevels = LogLevels;
+
+/**
+ *  A  N  Y  L  O  G  G  E  R
+ *  Get a logger. Any logger.
+ */
+
+// the main `anylogger` function
+const anylogger = ((name: LoggerName) =>
+  // return the existing logger, or
+  anylogger.all[name] ||
+  // create and store a new logger with that name
+  (anylogger.all[name] = anylogger.ext(anylogger.new(name)))) as AnyLogger;
+
+// all loggers created so far
+anylogger.all = Object.create(null);
+
+// the supported levels
+anylogger.levels = { error: 1, warn: 2, info: 3, log: 4, debug: 5, trace: 6 };
+
+// creates a new named log function
+anylogger.new = name =>
+  ({
+    // to assign the function `name`, set it to a named key in an object.
+    // the default implementation calls `anylogger.log`, which should be a
+    // good choice in many cases.
+    [name]: (...args: any[]) => anylogger.log(name, ...args),
+  })[name]; // return only the function, not the encapsulating object
+
+// logs with the logger with the given `name`
+anylogger.log = (name, ...args: any[]) => {
+  // select the logger to use
+  anylogger.all[name][
+    // select the level to use
+    // if multiple args and first matches a level name
+    args.length > 1 && anylogger.levels[args[0] as string]
+      ? (args.shift() as string) // use the level from the args
+      : 'log' // else use default level `'log'`
+  ](...args); // call method matching level with remaining args
+};
+
+// extends the given `logger` function
+// the implementation here only adds no-ops
+// adapters should change this behavior
+anylogger.ext = (logger: LogFunction) => {
+  (logger as Logger).enabledFor = () => {};
+  for (const method in anylogger.levels) {
+    (logger as Logger)[method as LogLevel] = () => {};
+  }
+  return logger as Logger;
+};
+
+// this is a real ESM module
+export default anylogger;
+
+// prettier-ignore-end

package/vendor/tsconfig.anylogger.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "rootDir": ".",
+    "declaration": true,
+    "declarationMap": false,
+    "emitDeclarationOnly": false,
+    "skipLibCheck": true,
+    "strict": false,
+    "removeComments": false
+  },
+  "include": ["./anylogger.ts"]
+}

package/exported.js

@@ -1,2 +0,0 @@
-// Dummy file for .d.ts twin to declare ambients
-export {};

package/src/marshal.d.ts

@@ -1,33 +0,0 @@
-export function makeBoardRemote({ boardId, iface }: {
-    boardId: string | null;
-    iface?: string;
-}): BoardRemote;
-export function slotToBoardRemote(boardId: string, iface: string): BoardRemote;
-export function boardSlottingMarshaller(slotToVal?: (slot: string, iface: string) => any): Omit<import("@endo/marshal").Marshal<string | null>, "serialize" | "unserialize">;
-/**
- * @type {TypedPattern<CapData<any>>}
- */
-export const CapDataShape: TypedPattern<CapData<any>>;
-export function assertCapData(data: unknown): asserts data is CapData<unknown>;
-export function unmarshalFromVstorage(data: Map<string, string>, key: string, fromCapData: ReturnType<typeof import("@endo/marshal").makeMarshal>["fromCapData"], index: number): any;
-export function makeHistoryReviver(entries: [string, string][], slotToVal?: (slot: string, iface?: string) => any): {
-    getItem: (key: string) => any;
-    children: (prefix: string) => string[];
-    has: (k: string) => boolean;
-};
-export const pureDataMarshaller: {
-    toCapData: import("@endo/marshal").ToCapData<CapData<unknown>>;
-    fromCapData: import("@endo/marshal").FromCapData<CapData<unknown>>;
-    serialize: import("@endo/marshal").ToCapData<CapData<unknown>>;
-    unserialize: import("@endo/marshal").FromCapData<CapData<unknown>>;
-};
-/**
- * Should be a union with Remotable, but that's `any`, making this type
- * meaningless
- */
-export type BoardRemote = {
-    getBoardId: () => string | null;
-};
-import type { CapData } from '@endo/marshal';
-import type { TypedPattern } from './types.js';
-//# sourceMappingURL=marshal.d.ts.map

package/src/marshal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"marshal.d.ts","sourceRoot":"","sources":["marshal.js"],"names":[],"mappings":"AAuBO,oDAHI;IAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GACxC,WAAW,CAKvB;AAMM,2CAHI,MAAM,SACN,MAAM,eAGoB;AAqB9B,oDANI,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,GAAG,GAClC,IAAI,CAChB,OAAW,eAAe,EAAE,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,EAClD,WAAe,GAAG,aAAa,CAC5B,CAMH;AAGD;;GAEG;AACH,2BAFU,aAAa,QAAQ,GAAG,CAAC,CAAC,CAE+B;AAS5D,oCAHI,OAAO,GACL,QAAQ,IAAI,IAAI,QAAQ,OAAO,CAAC,CAO5C;AAeM,4CATI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,OACnB,MAAM,eACN,UAAU,CACpB,cAAkB,eAAe,EAAE,WAAW,CAC3C,CAAC,aAAa,CAAC,SACR,MAAM,GAEJ,GAAG,CAwBf;AASM,4CAHI,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,cAClB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,GAAG;mBAQlC,MAAM;uBAEN,MAAM;aAYN,MAAM;EAInB;AAID;;;;;EAEG;;;;;0BA1IU;IAAE,UAAU,EAAE,MAAM,MAAM,GAAG,IAAI,CAAA;CAAE;6BARtB,eAAe;kCACV,YAAY"}

package/src/types.ts

@@ -1,129 +0,0 @@
-/* eslint-disable max-classes-per-file */
-import type { ERef, RemotableBrand } from '@endo/eventual-send';
-import type { Primitive } from '@endo/pass-style';
-import type { Pattern } from '@endo/patterns';
-import type { Callable } from './ses-utils.js';
-
-/**
- * A map corresponding with a total function such that `get(key)` is assumed to
- * always succeed.
- */
-export type TotalMap<K, V> = Omit<Map<K, V>, 'get'> & {
-  /** Returns the element associated with the specified key in the TotalMap. */
-  get: (key: K) => V;
-};
-export type TotalMapFrom<M extends Map<any, any>> =
-  M extends Map<infer K, infer V> ? TotalMap<K, V> : never;
-
-/**
- * A permit is either `true` or a string (both meaning no attenuation, with a
- * string serving as a grouping label for convenience and/or diagram
- * generation), or an object whose keys identify child properties and whose
- * corresponding values are theirselves (recursive) Permits.
- */
-export type Permit<T> =
-  | true
-  | string
-  | Partial<{ [K in keyof T]: K extends string ? Permit<T[K]> : never }>;
-
-export type Attenuated<T, P extends Permit<T>> = P extends object
-  ? {
-      [K in keyof P]: K extends keyof T
-        ? P[K] extends Permit<T[K]>
-          ? Attenuated<T[K], P[K]>
-          : never
-        : never;
-    }
-  : T;
-
-export declare class Callback<I extends (...args: any[]) => any> {
-  private iface: I;
-
-  public target: any;
-
-  public methodName?: PropertyKey;
-
-  public bound: unknown[];
-
-  public isSync: boolean;
-}
-
-export declare class SyncCallback<
-  I extends (...args: unknown[]) => any,
-> extends Callback<I> {
-  private syncIface: I;
-
-  public isSync: true;
-}
-
-/**
-Returns a boolean for whether the given type is primitive value or primitive type.
- 
-@example
-```
-IsPrimitive<'string'>
-//=> true
- 
-IsPrimitive<string>
-//=> true
- 
-IsPrimitive<Object>
-//=> false
-```
- */
-export type IsPrimitive<T> = [T] extends [Primitive] ? true : false;
-
-/** Recursively extract the non-callable properties of T */
-export type DataOnly<T> =
-  IsPrimitive<T> extends true
-    ? T
-    : T extends Callable
-      ? never
-      : { [P in keyof T as T[P] extends Callable ? never : P]: DataOnly<T[P]> };
-
-/**
- * A type that doesn't assume its parameter is local, but is satisfied with both
- * local and remote references. It accepts both near and marshalled references
- * that were returned from `Remotable` or `Far`.
- */
-export type Remote<Primary, Local = DataOnly<Primary>> =
-  | Primary
-  | RemotableBrand<Local, Primary>;
-
-// TODO: Add type tests for FarRef and Remote.
-/**
- * Potentially remote promises or settled references.
- */
-export type FarRef<Primary, Local = DataOnly<Primary>> = ERef<
-  Remote<Primary, Local>
->;
-
-/*
- * Stop-gap until https://github.com/Agoric/agoric-sdk/issues/6160
- * explictly specify the type that the Pattern will verify through a match.
- *
- * TODO move all this pattern typing stuff to @endo/patterns
- */
-declare const validatedType: unique symbol;
-/**
- * Tag a pattern with the static type it represents.
- */
-export type TypedPattern<T> = Pattern & { [validatedType]?: T };
-
-export declare type PatternType<TM extends TypedPattern<any>> =
-  TM extends TypedPattern<infer T> ? T : never;
-
-// TODO make Endo's mustMatch do this
-/**
- * Returning normally indicates success. Match failure is indicated by
- * throwing.
- *
- * Note: remotables can only be matched as "remotable", not the specific kind.
- *
- * @see {import('@endo/patterns').mustMatch} for the implementation. This one has a type annotation to narrow if the pattern is a TypedPattern.
- */
-export declare type MustMatch = <P extends Pattern>(
-  specimen: unknown,
-  pattern: P,
-  label?: string | number,
-) => asserts specimen is P extends TypedPattern<any> ? PatternType<P> : unknown;