@nocobase/plugin-flow-engine 2.0.0-alpha.2

package/dist/node_modules/ses/src/error/note-log-args.js

@@ -0,0 +1,77 @@
+// @ts-check
+/* eslint-disable @endo/no-polymorphic-call */
+/* eslint-disable no-restricted-globals */
+
+import { makeCacheMapKit } from '@endo/cache-map';
+
+/**
+ * @import {CacheMapKit} from '@endo/cache-map';
+ * @import {LogArgs} from './internal-types.js';
+ */
+
+const { freeze } = Object;
+const { isSafeInteger } = Number;
+
+const defaultLoggedErrorsBudget = 1000;
+const defaultArgsPerErrorBudget = 100;
+
+/**
+ * @param {number} [errorsBudget]
+ * @param {number} [argsPerErrorBudget]
+ */
+export const makeNoteLogArgsArrayKit = (
+  errorsBudget = defaultLoggedErrorsBudget,
+  argsPerErrorBudget = defaultArgsPerErrorBudget,
+) => {
+  if (!isSafeInteger(argsPerErrorBudget) || argsPerErrorBudget < 1) {
+    throw TypeError(
+      'argsPerErrorBudget must be a safe positive integer number',
+    );
+  }
+
+  /**
+   * Maps from an error to an array of log args, where each log args is
+   * remembered as an annotation on that error. This can be used, for example,
+   * to keep track of additional causes of the error. The elements of any
+   * log args may include errors which are associated with further annotations.
+   * An augmented console, like the causal console of `console.js`, could
+   * then retrieve the graph of such annotations.
+   *
+   * @type {CacheMapKit<WeakMapConstructor, Error, LogArgs[]>}
+   */
+  const { cache: noteLogArgsArrayMap } = makeCacheMapKit(errorsBudget);
+
+  /**
+   * @param {Error} error
+   * @param {LogArgs} logArgs
+   */
+  const addLogArgs = (error, logArgs) => {
+    const logArgsArray = noteLogArgsArrayMap.get(error);
+    if (logArgsArray !== undefined) {
+      if (logArgsArray.length >= argsPerErrorBudget) {
+        logArgsArray.shift();
+      }
+      logArgsArray.push(logArgs);
+    } else {
+      noteLogArgsArrayMap.set(error, [logArgs]);
+    }
+  };
+  freeze(addLogArgs);
+
+  /**
+   * @param {Error} error
+   * @returns {LogArgs[] | undefined}
+   */
+  const takeLogArgsArray = error => {
+    const result = noteLogArgsArrayMap.get(error);
+    noteLogArgsArrayMap.delete(error);
+    return result;
+  };
+  freeze(takeLogArgsArray);
+
+  return freeze({
+    addLogArgs,
+    takeLogArgsArray,
+  });
+};
+freeze(makeNoteLogArgsArrayKit);

package/dist/node_modules/ses/src/error/stringify-utils.js

@@ -0,0 +1,195 @@
+// @ts-check
+
+import {
+  Set,
+  String,
+  isArray,
+  arrayJoin,
+  arraySlice,
+  arraySort,
+  arrayMap,
+  keys,
+  fromEntries,
+  freeze,
+  is,
+  isError,
+  setAdd,
+  setHas,
+  stringIncludes,
+  stringStartsWith,
+  stringifyJson,
+  toStringTagSymbol,
+} from '../commons.js';
+
+/** @import {StringablePayload} from '../../types.js' */
+
+/**
+ * Joins English terms with commas and an optional conjunction.
+ *
+ * @param {(string | StringablePayload)[]} terms
+ * @param {"and" | "or"} conjunction
+ */
+export const enJoin = (terms, conjunction) => {
+  if (terms.length === 0) {
+    return '(none)';
+  } else if (terms.length === 1) {
+    return terms[0];
+  } else if (terms.length === 2) {
+    const [first, second] = terms;
+    return `${first} ${conjunction} ${second}`;
+  } else {
+    return `${arrayJoin(arraySlice(terms, 0, -1), ', ')}, ${conjunction} ${
+      terms[terms.length - 1]
+    }`;
+  }
+};
+
+/**
+ * Prepend the correct indefinite article onto a noun, typically a typeof
+ * result, e.g., "an object" vs. "a number"
+ *
+ * @param {string} str The noun to prepend
+ * @returns {string} The noun prepended with a/an
+ */
+const an = str => {
+  str = `${str}`;
+  if (str.length >= 1 && stringIncludes('aeiouAEIOU', str[0])) {
+    return `an ${str}`;
+  }
+  return `a ${str}`;
+};
+freeze(an);
+export { an };
+
+/**
+ * Like `JSON.stringify` but does not blow up if given a cycle or a bigint.
+ * This is not
+ * intended to be a serialization to support any useful unserialization,
+ * or any programmatic use of the resulting string. The string is intended
+ * *only* for showing a human under benign conditions, in order to be
+ * informative enough for some
+ * logging purposes. As such, this `bestEffortStringify` has an
+ * imprecise specification and may change over time.
+ *
+ * The current `bestEffortStringify` possibly emits too many "seen"
+ * markings: Not only for cycles, but also for repeated subtrees by
+ * object identity.
+ *
+ * As a best effort only for diagnostic interpretation by humans,
+ * `bestEffortStringify` also turns various cases that normal
+ * `JSON.stringify` skips or errors on, like `undefined` or bigints,
+ * into strings that convey their meaning. To distinguish this from
+ * strings in the input, these synthesized strings always begin and
+ * end with square brackets. To distinguish those strings from an
+ * input string with square brackets, and input string that starts
+ * with an open square bracket `[` is itself placed in square brackets.
+ *
+ * @param {any} payload
+ * @param {(string|number)=} spaces
+ * @returns {string}
+ */
+const bestEffortStringify = (payload, spaces = undefined) => {
+  const seenSet = new Set();
+  const replacer = (_, val) => {
+    switch (typeof val) {
+      case 'object': {
+        if (val === null) {
+          return null;
+        }
+        if (setHas(seenSet, val)) {
+          return '[Seen]';
+        }
+        setAdd(seenSet, val);
+        if (isError(val)) {
+          return `[${val.name}: ${val.message}]`;
+        }
+        if (toStringTagSymbol in val) {
+          // For the built-ins that have or inherit a `Symbol.toStringTag`-named
+          // property, most of them inherit the default `toString` method,
+          // which will print in a similar manner: `"[object Foo]"` vs
+          // `"[Foo]"`. The exceptions are
+          //    * `Symbol.prototype`, `BigInt.prototype`, `String.prototype`
+          //      which don't matter to us since we handle primitives
+          //      separately and we don't care about primitive wrapper objects.
+          //    * TODO
+          //      `Date.prototype`, `TypedArray.prototype`.
+          //      Hmmm, we probably should make special cases for these. We're
+          //      not using these yet, so it's not urgent. But others will run
+          //      into these.
+          //
+          // Once #2018 is closed, the only objects in our code that have or
+          // inherit a `Symbol.toStringTag`-named property are remotables
+          // or their remote presences.
+          // This printing will do a good job for these without
+          // violating abstraction layering. This behavior makes sense
+          // purely in terms of JavaScript concepts. That's some of the
+          // motivation for choosing that representation of remotables
+          // and their remote presences in the first place.
+          return `[${val[toStringTagSymbol]}]`;
+        }
+        if (isArray(val)) {
+          return val;
+        }
+        const names = keys(val);
+        if (names.length < 2) {
+          return val;
+        }
+        let sorted = true;
+        for (let i = 1; i < names.length; i += 1) {
+          if (names[i - 1] >= names[i]) {
+            sorted = false;
+            break;
+          }
+        }
+        if (sorted) {
+          return val;
+        }
+        arraySort(names);
+        const entries = arrayMap(names, name => [name, val[name]]);
+        return fromEntries(entries);
+      }
+      case 'function': {
+        return `[Function ${val.name || '<anon>'}]`;
+      }
+      case 'string': {
+        if (stringStartsWith(val, '[')) {
+          return `[${val}]`;
+        }
+        return val;
+      }
+      case 'undefined':
+      case 'symbol': {
+        return `[${String(val)}]`;
+      }
+      case 'bigint': {
+        return `[${val}n]`;
+      }
+      case 'number': {
+        if (is(val, NaN)) {
+          return '[NaN]';
+        } else if (val === Infinity) {
+          return '[Infinity]';
+        } else if (val === -Infinity) {
+          return '[-Infinity]';
+        }
+        return val;
+      }
+      default: {
+        return val;
+      }
+    }
+  };
+  try {
+    return stringifyJson(payload, replacer, spaces);
+  } catch (_err) {
+    // Don't do anything more fancy here if there is any
+    // chance that might throw, unless you surround that
+    // with another try-catch-recovery. For example,
+    // the caught thing might be a proxy or other exotic
+    // object rather than an error. The proxy might throw
+    // whenever it is possible for it to.
+    return '[Something that failed to stringify]';
+  }
+};
+freeze(bestEffortStringify);
+export { bestEffortStringify };

package/dist/node_modules/ses/src/error/tame-console.js

@@ -0,0 +1,197 @@
+// @ts-check
+
+import {
+  // Using TypeError minimizes risk of exposing the feral Error constructor
+  TypeError,
+  apply,
+  defineProperty,
+  freeze,
+  globalThis,
+} from '../commons.js';
+import { loggedErrorHandler as defaultHandler } from './assert.js';
+import { makeCausalConsole } from './console.js';
+import { makeRejectionHandlers } from './unhandled-rejection.js';
+
+/**
+ * @import {VirtualConsole} from './types.js'
+ * @import {GetStackString} from './internal-types.js';
+ */
+
+const failFast = message => {
+  throw TypeError(message);
+};
+
+const wrapLogger = (logger, thisArg) =>
+  freeze((...args) => apply(logger, thisArg, args));
+
+/**
+ * Wrap console unless suppressed.
+ * At the moment, the console is considered a host power in the start
+ * compartment, and not a primordial. Hence it is absent from the whilelist
+ * and bypasses the intrinsicsCollector.
+ *
+ * @param {"safe" | "unsafe"} consoleTaming
+ * @param {"platform" | "exit" | "abort" | "report" | "none"} [errorTrapping]
+ * @param {"report" | "none"} [unhandledRejectionTrapping]
+ * @param {GetStackString=} optGetStackString
+ */
+export const tameConsole = (
+  consoleTaming = 'safe',
+  errorTrapping = 'platform',
+  unhandledRejectionTrapping = 'report',
+  optGetStackString = undefined,
+) => {
+  let loggedErrorHandler;
+  if (optGetStackString === undefined) {
+    loggedErrorHandler = defaultHandler;
+  } else {
+    loggedErrorHandler = {
+      ...defaultHandler,
+      getStackString: optGetStackString,
+    };
+  }
+
+  // eslint-disable-next-line no-restricted-globals
+  const originalConsole = /** @type {VirtualConsole} */ (
+    // eslint-disable-next-line no-nested-ternary
+    typeof globalThis.console !== 'undefined'
+      ? globalThis.console
+      : typeof globalThis.print === 'function'
+        ? // Make a good-enough console for eshost (including only functions that
+          // log at a specific level with no special argument interpretation).
+          // https://console.spec.whatwg.org/#logging
+          (p => freeze({ debug: p, log: p, info: p, warn: p, error: p }))(
+            // eslint-disable-next-line no-undef
+            wrapLogger(globalThis.print),
+          )
+        : undefined
+  );
+
+  // Upgrade a log-only console (as in `eshost -h SpiderMonkey`).
+  if (originalConsole && originalConsole.log) {
+    for (const methodName of ['warn', 'error']) {
+      if (!originalConsole[methodName]) {
+        defineProperty(originalConsole, methodName, {
+          value: wrapLogger(originalConsole.log, originalConsole),
+        });
+      }
+    }
+  }
+
+  const ourConsole = /** @type {VirtualConsole} */ (
+    consoleTaming === 'unsafe'
+      ? originalConsole
+      : makeCausalConsole(originalConsole, loggedErrorHandler)
+  );
+
+  // Attach platform-specific error traps such that any error that gets thrown
+  // at top-of-turn (the bottom of stack) will get logged by our causal
+  // console, revealing the diagnostic information associated with the error,
+  // including the stack from when the error was created.
+
+  // In the following Node.js and web browser cases, `process` and `window` are
+  // spelled as `globalThis` properties to avoid the overweaning gaze of
+  // Parcel, which dutifully installs an unnecessary `process` shim if we ever
+  // utter that. That unnecessary shim forces the whole bundle into sloppy mode,
+  // which in turn breaks SES's strict mode invariant.
+
+  // Disable the polymorphic check for the rest of this file.  It's too noisy
+  // when dealing with platform APIs.
+  /* eslint-disable @endo/no-polymorphic-call */
+
+  // Node.js
+  const globalProcess = globalThis.process || undefined;
+  if (
+    errorTrapping !== 'none' &&
+    typeof globalProcess === 'object' &&
+    typeof globalProcess.on === 'function'
+  ) {
+    let terminate;
+    if (errorTrapping === 'platform' || errorTrapping === 'exit') {
+      const { exit } = globalProcess;
+      // If there is a function-valued process.on but no function-valued process.exit,
+      // fail early without caring whether errorTrapping is "platform" only by default.
+      typeof exit === 'function' || failFast('missing process.exit');
+      terminate = () => exit(globalProcess.exitCode || -1);
+    } else if (errorTrapping === 'abort') {
+      terminate = globalProcess.abort;
+      typeof terminate === 'function' || failFast('missing process.abort');
+    }
+
+    globalProcess.on('uncaughtException', error => {
+      // See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_UNCAUGHT_EXCEPTION.md
+      ourConsole.error('SES_UNCAUGHT_EXCEPTION:', error);
+      if (terminate) {
+        terminate();
+      }
+    });
+  }
+  if (
+    unhandledRejectionTrapping !== 'none' &&
+    typeof globalProcess === 'object' &&
+    typeof globalProcess.on === 'function'
+  ) {
+    const handleRejection = reason => {
+      // See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_UNHANDLED_REJECTION.md
+      ourConsole.error('SES_UNHANDLED_REJECTION:', reason);
+      // 'platform' and 'report' just log the reason.
+    };
+    // Maybe track unhandled promise rejections.
+    const h = makeRejectionHandlers(handleRejection);
+    if (h) {
+      // Rejection handlers are supported.
+      globalProcess.on('unhandledRejection', h.unhandledRejectionHandler);
+      globalProcess.on('rejectionHandled', h.rejectionHandledHandler);
+      globalProcess.on('exit', h.processTerminationHandler);
+    }
+  }
+
+  // Browser
+  const globalWindow = globalThis.window || undefined;
+  if (
+    errorTrapping !== 'none' &&
+    typeof globalWindow === 'object' &&
+    typeof globalWindow.addEventListener === 'function'
+  ) {
+    globalWindow.addEventListener('error', event => {
+      event.preventDefault();
+      // See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_UNCAUGHT_EXCEPTION.md
+      ourConsole.error('SES_UNCAUGHT_EXCEPTION:', event.error);
+      // 'platform' and 'report' just log the reason.
+      if (errorTrapping === 'exit' || errorTrapping === 'abort') {
+        globalWindow.location.href = `about:blank`;
+      }
+    });
+  }
+  if (
+    unhandledRejectionTrapping !== 'none' &&
+    typeof globalWindow === 'object' &&
+    typeof globalWindow.addEventListener === 'function'
+  ) {
+    const handleRejection = reason => {
+      // See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_UNHANDLED_REJECTION.md
+      ourConsole.error('SES_UNHANDLED_REJECTION:', reason);
+    };
+
+    const h = makeRejectionHandlers(handleRejection);
+    if (h) {
+      // Rejection handlers are supported.
+      globalWindow.addEventListener('unhandledrejection', event => {
+        event.preventDefault();
+        h.unhandledRejectionHandler(event.reason, event.promise);
+      });
+
+      globalWindow.addEventListener('rejectionhandled', event => {
+        event.preventDefault();
+        h.rejectionHandledHandler(event.promise);
+      });
+
+      globalWindow.addEventListener('beforeunload', _event => {
+        h.processTerminationHandler();
+      });
+    }
+  }
+  /* eslint-enable @endo/no-polymorphic-call */
+
+  return { console: ourConsole };
+};