@warp-drive/react 5.8.0-alpha.4 → 5.8.0-alpha.41

package/dist/unpkg/dev-deprecated/install.js

@@ -0,0 +1,102 @@
+import { use } from 'react';
+import { Signal } from 'signal-polyfill';
+import { setupSignals } from '@warp-drive/core/configure';
+import { g as getGlobalConfig, W as WatcherContext } from "./reactive-context-sqyJMb7I.js";
+
+/**
+ * {@include ./install.md}
+ * @module
+ */
+
+function tryConsumeContext(signal) {
+  // eslint-disable-next-line no-console
+  const logError = console.error;
+  try {
+    // eslint-disable-next-line no-console
+    console.error = () => {};
+    // ensure signals are watched by our closest watcher
+    const watcher = use(WatcherContext);
+    // eslint-disable-next-line no-console
+    console.error = logError;
+    watcher?.watcher.watch(signal);
+    {
+      if (getGlobalConfig().WarpDrive.debug.LOG_REACT_SIGNAL_INTEGRATION || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REACT_SIGNAL_INTEGRATION) {
+        // eslint-disable-next-line no-console
+        console.log(`[WarpDrive] Consumed Context Signal`, signal, watcher);
+      }
+    }
+  } catch {
+    // eslint-disable-next-line no-console
+    console.error = logError;
+    // if we are not in a React context, we will Error
+    // so we just ignore it.
+    {
+      if (getGlobalConfig().WarpDrive.debug.LOG_REACT_SIGNAL_INTEGRATION || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REACT_SIGNAL_INTEGRATION) {
+        // eslint-disable-next-line no-console
+        console.log(`[WarpDrive] No Context Available To Consume Signal`, signal);
+      }
+    }
+  }
+}
+let pending;
+async function settled() {
+  {
+    // in testing mode we provide a test waiter integration
+    if (!pending || !pending.length) return;
+    const current = pending ?? [];
+    pending = [];
+    await Promise.allSettled(current);
+    await Promise.resolve();
+    await Promise.resolve();
+    await Promise.resolve();
+    return settled();
+  }
+}
+function buildSignalConfig(options) {
+  return {
+    createSignal: (obj, key) => new Signal.State({
+      obj,
+      key
+    }, {
+      equals: () => false
+    }),
+    notifySignal: signal => {
+      {
+        if (getGlobalConfig().WarpDrive.debug.LOG_REACT_SIGNAL_INTEGRATION || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REACT_SIGNAL_INTEGRATION) {
+          if (Signal.subtle.hasSinks(signal)) {
+            // eslint-disable-next-line no-console
+            console.log(`[WarpDrive] Notifying Signal`, signal);
+          } else {
+            // eslint-disable-next-line no-console
+            console.log(`[WarpDrive] Notified Signal That Has No Watcher`, signal);
+          }
+        }
+      }
+      signal.set(signal.get());
+    },
+    consumeSignal: signal => {
+      tryConsumeContext(signal);
+      void signal.get();
+    },
+    createMemo: (object, key, fn) => {
+      const memo = new Signal.Computed(fn);
+      return () => {
+        tryConsumeContext(memo);
+        return memo.get();
+      };
+    },
+    waitFor: promise => {
+      {
+        pending = pending || [];
+        const newPromise = promise.finally(() => {
+          pending = pending.filter(p => p !== newPromise);
+        });
+        pending.push(newPromise);
+        return newPromise;
+      }
+    },
+    willSyncFlushWatchers: () => false
+  };
+}
+setupSignals(buildSignalConfig);
+export { buildSignalConfig, settled };

package/dist/unpkg/dev-deprecated/reactive-context-sqyJMb7I.js

@@ -0,0 +1,290 @@
+import { Signal } from 'signal-polyfill';
+import { createContext, useMemo, useSyncExternalStore } from 'react';
+import { jsxDEV } from 'react/jsx-dev-runtime';
+
+/*
+  These are the runtime implementations for the javascript macros that have
+  runtime implementations.
+
+  Not every macro has a runtime implementation, some only make sense in the
+  build and always run there.
+
+  Even when we have runtime implementations, we are still careful to emit static
+  errors during the build wherever possible, and runtime errors when necessary,
+  so that you're not surprised when you switch from runtime-mode to compile-time
+  mode.
+*/
+
+// This is here as a compile target for `getConfig` and `getOwnConfig` when
+// we're in runtime mode. This is not public API to call from your own code.
+function config(packageRoot) {
+  return runtimeConfig.packages[packageRoot];
+}
+function getGlobalConfig() {
+  return runtimeConfig.global;
+}
+const runtimeConfig = initializeRuntimeMacrosConfig();
+
+// this exists to be targeted by our babel plugin
+function initializeRuntimeMacrosConfig() {
+  return {
+    "packages": {},
+    "global": {
+      "@embroider/macros": {
+        "isTesting": false
+      },
+      "WarpDrive": {
+        "debug": {
+          "DEBUG_RELATIONSHIP_NOTIFICATIONS": false,
+          "LOG_CACHE": false,
+          "LOG_CACHE_POLICY": false,
+          "LOG_GRAPH": false,
+          "LOG_IDENTIFIERS": false,
+          "LOG_INSTANCE_CACHE": false,
+          "LOG_METRIC_COUNTS": false,
+          "LOG_MUTATIONS": false,
+          "LOG_NOTIFICATIONS": false,
+          "LOG_OPERATIONS": false,
+          "LOG_PAYLOADS": false,
+          "LOG_REACT_SIGNAL_INTEGRATION": false,
+          "LOG_REQUESTS": false,
+          "LOG_REQUEST_STATUS": false,
+          "__INTERNAL_LOG_NATIVE_MAP_SET_COUNTS": false
+        },
+        "polyfillUUID": false,
+        "includeDataAdapter": true,
+        "compatWith": null,
+        "deprecations": {
+          "DEPRECATE_CATCH_ALL": true,
+          "DEPRECATE_COMPUTED_CHAINS": true,
+          "DEPRECATE_EMBER_INFLECTOR": true,
+          "DEPRECATE_LEGACY_IMPORTS": true,
+          "DEPRECATE_MANY_ARRAY_DUPLICATES": true,
+          "DEPRECATE_NON_STRICT_ID": true,
+          "DEPRECATE_NON_STRICT_TYPES": true,
+          "DEPRECATE_NON_UNIQUE_PAYLOADS": true,
+          "DEPRECATE_RELATIONSHIP_REMOTE_UPDATE_CLEARING_LOCAL_STATE": true,
+          "DEPRECATE_STORE_EXTENDS_EMBER_OBJECT": true,
+          "DEPRECATE_TRACKING_PACKAGE": true,
+          "DISABLE_7X_DEPRECATIONS": true,
+          "ENABLE_LEGACY_REQUEST_METHODS": true,
+          "ENABLE_LEGACY_SCHEMA_SERVICE": true
+        },
+        "features": {
+          "ENFORCE_STRICT_RESOURCE_FINALIZATION": false,
+          "JSON_API_CACHE_VALIDATION_ERRORS": false,
+          "SAMPLE_FEATURE_FLAG": null
+        },
+        "activeLogging": {
+          "DEBUG_RELATIONSHIP_NOTIFICATIONS": true,
+          "LOG_CACHE": true,
+          "LOG_CACHE_POLICY": true,
+          "LOG_GRAPH": true,
+          "LOG_IDENTIFIERS": true,
+          "LOG_INSTANCE_CACHE": true,
+          "LOG_METRIC_COUNTS": true,
+          "LOG_MUTATIONS": true,
+          "LOG_NOTIFICATIONS": true,
+          "LOG_OPERATIONS": true,
+          "LOG_PAYLOADS": true,
+          "LOG_REACT_SIGNAL_INTEGRATION": true,
+          "LOG_REQUESTS": true,
+          "LOG_REQUEST_STATUS": true,
+          "__INTERNAL_LOG_NATIVE_MAP_SET_COUNTS": true
+        },
+        "env": {
+          "TESTING": true,
+          "PRODUCTION": false,
+          "DEBUG": true,
+          "IS_RECORDING": false,
+          "IS_CI": true,
+          "SHOULD_RECORD": false
+        }
+      }
+    }
+  };
+}
+function updaterMethods() {
+  return {
+    config,
+    getGlobalConfig,
+    setConfig(packageRoot, value) {
+      runtimeConfig.packages[packageRoot] = value;
+    },
+    setGlobalConfig(key, value) {
+      runtimeConfig.global[key] = value;
+    }
+  };
+}
+
+// this is how runtime config can get injected at boot. I'm not sure yet if this
+// should be public API, but we certainly need it internally to set things like
+// the global fastboot.isRunning.
+//
+// consumers of this API push a function onto
+// window._embroider_macros_runtime_config. The function is given four methods
+// which allow it to read and write the per-package and global configs. The
+// reason for allowing both read & write is that merging strategies are up to
+// each consumers -- read first, then merge, then write.
+//
+// For an example user of this API, see where we generate
+// embroider_macros_fastboot_init.js' in @embroider/core.
+let updaters = typeof window !== 'undefined' ? window._embroider_macros_runtime_config : undefined;
+if (updaters) {
+  let methods = updaterMethods();
+  for (let updater of updaters) {
+    updater(methods);
+  }
+}
+var _jsxFileName = "/home/runner/work/warp-drive/warp-drive/warp-drive-packages/react/src/-private/reactive-context.tsx";
+let nextFlush = null;
+let watchers = [];
+let watcherId = 0;
+function clearWatcher(state) {
+  state.watcher.unwatch(...Signal.subtle.introspectSources(state.watcher));
+}
+function flush(state) {
+  state.pending = false;
+  if (state.destroyed) {
+    {
+      if (getGlobalConfig().WarpDrive.debug.LOG_REACT_SIGNAL_INTEGRATION || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REACT_SIGNAL_INTEGRATION) {
+        console.log(`[WarpDrive] Detected Watcher Destroyed During Notify Flush, clearing signals`);
+      }
+    }
+    state.snapshot = null;
+    clearWatcher(state);
+    return;
+  }
+  {
+    if (getGlobalConfig().WarpDrive.debug.LOG_REACT_SIGNAL_INTEGRATION || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REACT_SIGNAL_INTEGRATION) {
+      console.log(`[WarpDrive] Notifying React That WatcherContext:${state.watcherId} Has Updated`);
+      console.log("all signals", new Set(Signal.subtle.introspectSources(state.watcher)));
+      console.log("dirty signals", new Set(state.watcher.getPending()));
+    }
+  } // any time signals have changed, we notify React that our store has updated
+  state.snapshot = {
+    watcher: state.watcher
+  };
+  if (state.notifyReact) state.notifyReact();
+
+  // tell the Watcher to start watching for changes again
+  // by signaling that notifications have been flushed.
+  state.watcher.watch();
+}
+function _createWatcher() {
+  const id = watcherId++;
+  {
+    if (getGlobalConfig().WarpDrive.debug.LOG_REACT_SIGNAL_INTEGRATION || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REACT_SIGNAL_INTEGRATION) {
+      console.log(`[WarpDrive] Creating a WatcherContext:${id}`);
+    }
+  }
+  const state = {
+    watcherId: id,
+    pending: false,
+    destroyed: false,
+    notifyReact: null,
+    watcher: null,
+    // the extra wrapper returned here ensures that the context value for the watcher
+    // changes causing a re-render when the watcher is updated.
+    snapshot: null
+  };
+  state.watcher = new Signal.subtle.Watcher((...args) => {
+    {
+      if (getGlobalConfig().WarpDrive.debug.LOG_REACT_SIGNAL_INTEGRATION || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REACT_SIGNAL_INTEGRATION) {
+        console.log(`watcher ${state.watcherId} notified`, args, state.watcher);
+      }
+    }
+    if (!state.pending && !state.destroyed) {
+      watchers.push(state);
+      state.pending = true;
+      if (!nextFlush) {
+        nextFlush = new Promise(resolve => {
+          queueMicrotask(() => {
+            queueMicrotask(() => {
+              queueMicrotask(() => {
+                watchers.forEach(flush);
+                {
+                  if (getGlobalConfig().WarpDrive.debug.LOG_REACT_SIGNAL_INTEGRATION || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REACT_SIGNAL_INTEGRATION) {
+                    console.log("Flushed watcher:", watchers.map(w => w.watcherId));
+                  }
+                }
+                watchers = [];
+                nextFlush = null;
+                resolve();
+              });
+            });
+          });
+        });
+      }
+    } else if (state.destroyed) {
+      {
+        if (getGlobalConfig().WarpDrive.debug.LOG_REACT_SIGNAL_INTEGRATION || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REACT_SIGNAL_INTEGRATION) {
+          console.log(`[WarpDrive] Detected Watcher Destroyed During Notify, clearing signals`);
+        }
+      } // if we are destroyed, we clear the watcher signals
+      // so that it does not continue to watch for changes.
+      state.snapshot = null;
+      clearWatcher(state);
+    }
+  });
+
+  // The watcher won't begin watching until we call `watcher.watch()`
+  state.watcher.watch();
+  state.snapshot = {
+    watcher: state.watcher
+  };
+  return state;
+}
+function useWatcher() {
+  const state = useMemo(_createWatcher, []);
+  return useSyncExternalStore(notifyChanged => {
+    {
+      if (getGlobalConfig().WarpDrive.debug.LOG_REACT_SIGNAL_INTEGRATION || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REACT_SIGNAL_INTEGRATION) {
+        console.log(`[WarpDrive] Subscribing to Watcher`);
+      }
+    }
+    state.destroyed = false;
+    state.notifyReact = notifyChanged;
+
+    // The watcher won't begin watching until we call `watcher.watch()`
+    state.watcher.watch();
+    return () => {
+      {
+        if (getGlobalConfig().WarpDrive.debug.LOG_REACT_SIGNAL_INTEGRATION || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REACT_SIGNAL_INTEGRATION) {
+          console.log(`[WarpDrive] Deactivating Watcher Subscription`);
+        }
+      }
+      state.destroyed = true;
+      state.notifyReact = null;
+    };
+  }, () => state.snapshot);
+}
+
+/**
+ * @category Contexts
+ */
+const WatcherContext = /*#__PURE__*/createContext(null);
+
+/**
+ *
+ * @category Components
+ */
+function ReactiveContext({
+  children
+}) {
+  const watcher = useWatcher();
+  /**
+   * Unlike other frameworks, React does not have a built-in way to provide
+   * a context value other than by rendering an extra component.
+   *
+   */
+  return /*#__PURE__*/jsxDEV(WatcherContext, {
+    value: watcher,
+    children: children
+  }, void 0, false, {
+    fileName: _jsxFileName,
+    lineNumber: 159,
+    columnNumber: 10
+  }, this);
+}
+export { ReactiveContext as R, WatcherContext as W, getGlobalConfig as g };

package/dist/unpkg/prod/index.js

@@ -0,0 +1,250 @@
+import { R as ReactiveContext } from "./reactive-context-DKimDkR3.js";
+export { W as WatcherContext } from "./reactive-context-DKimDkR3.js";
+import '@warp-drive/core';
+import { useMemo, createContext, use, useRef, useEffect } from 'react';
+import { jsx, Fragment } from 'react/jsx-runtime';
+import { createRequestSubscription } from '@warp-drive/core/reactive';
+import { DISPOSE, signal } from '@warp-drive/core/signals/-leaked';
+import '@warp-drive/core/request';
+const StoreContext = /*#__PURE__*/createContext(null);
+
+/**
+ * @category Hooks
+ */
+function useStore() {
+  const store = use(StoreContext);
+  return store;
+}
+/**
+ * @category Components
+ */
+function StoreProvider($props) {
+  const store = useMemo(() => "store" in $props ? $props.store : new $props.Store(), ["store" in $props ? $props.store : $props.Store]);
+  return /*#__PURE__*/jsx(StoreContext, {
+    value: store,
+    children: $props.children
+  });
+}
+const deferred = /* @__PURE__ */new WeakMap();
+function deferDecorator(proto, prop, desc) {
+  let map = deferred.get(proto);
+  if (!map) {
+    map = /* @__PURE__ */new Map();
+    deferred.set(proto, map);
+  }
+  map.set(prop, desc);
+}
+function findDeferredDecorator(target, prop) {
+  var _a;
+  let cursor = target.prototype;
+  while (cursor) {
+    let desc = (_a = deferred.get(cursor)) == null ? void 0 : _a.get(prop);
+    if (desc) {
+      return desc;
+    }
+    cursor = cursor.prototype;
+  }
+}
+function decorateFieldV2(prototype, prop, decorators, initializer) {
+  let desc = {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: null
+  };
+  if (initializer) {
+    desc.initializer = initializer;
+  }
+  for (let decorator of decorators) {
+    desc = decorator(prototype, prop, desc) || desc;
+  }
+  if (desc.initializer === void 0) {
+    Object.defineProperty(prototype, prop, desc);
+  } else {
+    deferDecorator(prototype, prop, desc);
+  }
+}
+function initializeDeferredDecorator(target, prop) {
+  let desc = findDeferredDecorator(target.constructor, prop);
+  if (desc) {
+    Object.defineProperty(target, prop, {
+      enumerable: desc.enumerable,
+      configurable: desc.configurable,
+      writable: desc.writable,
+      value: desc.initializer ? desc.initializer.call(target) : void 0
+    });
+  }
+}
+const IdleBlockMissingError = new Error("No idle block provided for <Request> component, and no query or request was provided.");
+class ReactiveArgs {
+  static {
+    decorateFieldV2(this.prototype, "request", [signal]);
+  }
+  #request = (initializeDeferredDecorator(this, "request"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "query", [signal]);
+  }
+  #query = (initializeDeferredDecorator(this, "query"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "autorefresh", [signal]);
+  }
+  #autorefresh = (initializeDeferredDecorator(this, "autorefresh"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "autorefreshThreshold", [signal]);
+  }
+  #autorefreshThreshold = (initializeDeferredDecorator(this, "autorefreshThreshold"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "autorefreshBehavior", [signal]);
+  }
+  #autorefreshBehavior = (initializeDeferredDecorator(this, "autorefreshBehavior"), void 0);
+}
+const DefaultChrome = ({
+  children
+}) => {
+  return /*#__PURE__*/jsx(Fragment, {
+    children: children
+  });
+};
+function Throw({
+  error
+}) {
+  throw error;
+}
+
+/**
+ * The `<Request />` component is a powerful tool for managing data fetching and
+ * state in your React application. It provides a declarative approach to reactive
+ * control-flow for managing requests and state in your application.
+ *
+ * The `<Request />` component is ideal for handling "boundaries", outside which some
+ * state is still allowed to be unresolved and within which it MUST be resolved.
+ *
+ * ## Request States
+ *
+ * `<Request />` has five states, only one of which will be active and rendered at a time.
+ *
+ * - `idle`: The component is waiting to be given a request to monitor
+ * - `loading`: The request is in progress
+ * - `error`: The request failed
+ * - `content`: The request succeeded
+ * - `cancelled`: The request was cancelled
+ *
+ * Additionally, the `content` state has a `refresh` method that can be used to
+ * refresh the request in the background, which is available as a sub-state of
+ * the `content` state.
+ *
+ * ### Example Usage
+ *
+ * ```tsx
+ * import { Request } from "@warp-drive/react";
+ *
+ * export function UserPreview($props: { id: string | null }) {
+ *   return (
+ *    <Request
+ *       query={findRecord('user', $props.id)}
+ *       states={{
+ *         idle: () => <div>Waiting for User Selection</div>,
+ *         loading: ({ state }) => <div>Loading user data...</div>,
+ *         cancelled: ({ error, features }) => (
+ *           <div>
+ *             <p>Request Cancelled</p>
+ *             <p><button onClick={features.retry}>Start Again?</button></p>
+ *           </div>
+ *         ),
+ *         error: ({ error, features }) => (
+ *           <div>
+ *             <p>Error: {error.message}</p>
+ *             <p><button onClick={features.retry}>Try Again?</button></p>
+ *           </div>
+ *         ),
+ *         content: ({ result, features }) => (
+ *           <div>
+ *            <h2>User Details</h2>
+ *            <p>ID: {result.id}</p>
+ *            <p>Name: {result.name}</p>
+ *          </div>
+ *        ),
+ *      }}
+ *    />
+ *   );
+ * }
+ *
+ * ```
+ *
+ * @category Components
+ */
+function Request($props) {
+  return /*#__PURE__*/jsx(ReactiveContext, {
+    children: /*#__PURE__*/jsx(InternalRequest, {
+      ...$props
+    })
+  });
+}
+function isStrictModeRender() {
+  useRef(0);
+
+  // in debug we need to skip every second invocation
+
+  return false;
+}
+function InternalRequest($props) {
+  isStrictModeRender();
+  const store = $props.store ?? useStore();
+  const Chrome = $props.chrome ?? DefaultChrome;
+  const sink = useRef(null);
+  const args = useRef(null);
+  if (!args.current) {
+    args.current = new ReactiveArgs();
+  }
+  Object.assign(args.current, $props);
+  if (sink.current && (sink.current.store !== store || $props.subscription)) {
+    sink.current[DISPOSE]();
+    sink.current = null;
+  }
+  if (!sink.current && !$props.subscription) {
+    sink.current = createRequestSubscription(store, args.current);
+  }
+  const initialized = useRef(null);
+  const effect = () => {
+    if (sink.current && (!initialized.current || initialized.current.disposable !== sink.current)) {
+      initialized.current = {
+        disposable: sink.current,
+        dispose: () => {
+          sink.current?.[DISPOSE]();
+          initialized.current = null;
+          sink.current = null;
+        }
+      };
+    }
+    return sink.current ? initialized.current.dispose : undefined;
+  };
+  let maybeEffect = effect;
+  useEffect(maybeEffect, [sink.current]);
+  const state = $props.subscription ?? sink.current;
+  const slots = $props.states;
+  return /*#__PURE__*/jsx(Chrome, {
+    state: state.isIdle ? null : state.reqState,
+    features: state.contentFeatures,
+    children:
+    // prettier-ignore
+    state.isIdle && slots.idle ? /*#__PURE__*/jsx(slots.idle, {}) : state.isIdle ? /*#__PURE__*/jsx(Throw, {
+      error: IdleBlockMissingError
+    }) : state.reqState.isLoading ? slots.loading ? /*#__PURE__*/jsx(slots.loading, {
+      state: state.reqState.loadingState
+    }) : '' : state.reqState.isCancelled && slots.cancelled ? /*#__PURE__*/jsx(slots.cancelled, {
+      error: state.reqState.reason,
+      features: state.errorFeatures
+    }) : state.reqState.isError && slots.error ? /*#__PURE__*/jsx(slots.error, {
+      error: state.reqState.reason,
+      features: state.errorFeatures
+    }) : state.reqState.isSuccess ? slots.content ? /*#__PURE__*/jsx(slots.content, {
+      result: state.reqState.value,
+      features: state.contentFeatures
+    }) : /*#__PURE__*/jsx(Throw, {
+      error: new Error('No content block provided for <Request> component.')
+    }) : !state.reqState.isCancelled ? /*#__PURE__*/jsx(Throw, {
+      error: state.reqState.reason
+    }) : '' // never
+  });
+}
+export { ReactiveContext, Request, StoreProvider, Throw, useStore };

package/dist/unpkg/prod/install.js

@@ -0,0 +1,56 @@
+import { use } from 'react';
+import { Signal } from 'signal-polyfill';
+import { setupSignals } from '@warp-drive/core/configure';
+import { W as WatcherContext } from "./reactive-context-DKimDkR3.js";
+
+/**
+ * {@include ./install.md}
+ * @module
+ */
+
+function tryConsumeContext(signal) {
+  // eslint-disable-next-line no-console
+  const logError = console.error;
+  try {
+    // eslint-disable-next-line no-console
+    console.error = () => {};
+    // ensure signals are watched by our closest watcher
+    const watcher = use(WatcherContext);
+    // eslint-disable-next-line no-console
+    console.error = logError;
+    watcher?.watcher.watch(signal);
+  } catch {
+    // eslint-disable-next-line no-console
+    console.error = logError;
+    // if we are not in a React context, we will Error
+    // so we just ignore it.
+  }
+}
+async function settled() {}
+function buildSignalConfig(options) {
+  return {
+    createSignal: (obj, key) => new Signal.State(null, {
+      equals: () => false
+    }),
+    notifySignal: signal => {
+      signal.set(signal.get());
+    },
+    consumeSignal: signal => {
+      tryConsumeContext(signal);
+      void signal.get();
+    },
+    createMemo: (object, key, fn) => {
+      const memo = new Signal.Computed(fn);
+      return () => {
+        tryConsumeContext(memo);
+        return memo.get();
+      };
+    },
+    waitFor: promise => {
+      return promise;
+    },
+    willSyncFlushWatchers: () => false
+  };
+}
+setupSignals(buildSignalConfig);
+export { buildSignalConfig, settled };