@typewirets/react 0.1.0 → 0.2.0-rc.1

package/dist/types/index.js

@@ -9,88 +9,383 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _ReactResolutionContext_resolutionContext, _ReactResolutionContext_resolutions, _ReactResolutionContext_resolutionErrors;
+var _ReactResolutionContext_instances, _ReactResolutionContext_resolutionContext, _ReactResolutionContext_resolutionErrors, _ReactResolutionContext_generation, _ReactResolutionContext_allClearedAt, _ReactResolutionContext_clearedAt, _ReactResolutionContext_clearedSince;
 import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * TypeWire React Integration
+ *
+ * Provides React bindings for TypeWire dependency injection, enabling
+ * context-based dependency resolution within React component trees.
+ *
+ * Key exports:
+ * - {@link ReactResolutionContext} — Wraps a `ResolutionContext` with error caching, so a failed resolution doesn't loop under Suspense
+ * - {@link ContainerContext} — React Context holding the active resolution context
+ * - {@link useContainer} — Hook to access the current resolution context
+ * - {@link useTypeWire} — Hook to resolve a TypeWire with React Suspense support
+ * - {@link usePreload} — Hook that suspends a subtree once until a set of wires is created
+ * - {@link ResolutionContextProvider} — Component that provides a resolution context to the tree
+ *
+ * @packageDocumentation
+ */
 import * as React from "react";
 import { TypeWireError, TypeWireContainer, } from "@typewirets/core";
+/**
+ * A React-aware wrapper around {@link ResolutionContext} that caches resolution
+ * errors.
+ *
+ * When a component suspends on a resolution that then fails, React renders it
+ * again, and that render would start a new creation, suspend, fail and repeat
+ * forever. To stop that loop, the error from a failed `get` is cached, and
+ * later `get` and `getSync` calls for the same `TypeSymbol` throw it without
+ * calling the underlying context.
+ *
+ * A cached error lasts until {@link ReactResolutionContext.clearErrors} is
+ * called, even across `unbind` and a re-apply: this class only sees a
+ * `ResolutionContext`, so it cannot tell that a binding changed. To retry
+ * after replacing a binding, call `clearErrors` and then reset the error
+ * boundary that caught the error.
+ *
+ * Calls that run while a resolution is in flight are not deduplicated here.
+ * The underlying context must share one in-flight creation per singleton
+ * itself, or readers may get different instances. `TypeWireContainer` does,
+ * and never hands a creation started before `unbind` to new callers. So does
+ * the `@typewirets/inversify` adapter, because Inversify 7 shares concurrent
+ * singleton `getAsync` calls. A custom `ResolutionContext` must do the same.
+ *
+ * @example
+ * ```typescript
+ * const container = new TypeWireContainer();
+ * const context = new ReactResolutionContext(container);
+ * const value = await context.get(MySymbol);
+ *
+ * // After replacing the binding for MySymbol:
+ * context.clearErrors(MySymbol);
+ * ```
+ */
 export class ReactResolutionContext {
     constructor(resolutionContext) {
+        _ReactResolutionContext_instances.add(this);
+        /** The underlying resolution context that performs actual dependency resolution. */
         _ReactResolutionContext_resolutionContext.set(this, void 0);
-        _ReactResolutionContext_resolutions.set(this, new Map());
+        /** Cached resolution errors, keyed by symbol, to fail fast on repeated access. */
         _ReactResolutionContext_resolutionErrors.set(this, new Map());
+        /** Counts `clearErrors` calls, so a `get` can tell if one ran while it waited. */
+        _ReactResolutionContext_generation.set(this, 0);
+        /** The generation of the last `clearErrors()` call that cleared every symbol. */
+        _ReactResolutionContext_allClearedAt.set(this, 0);
+        /** The generation of the last `clearErrors(typeSymbol)` call, per symbol. */
+        _ReactResolutionContext_clearedAt.set(this, new Map());
         __classPrivateFieldSet(this, _ReactResolutionContext_resolutionContext, resolutionContext, "f");
     }
+    /**
+     * Synchronously retrieves a resolved instance for the given type symbol.
+     *
+     * @template T The type of the resolved instance
+     * @param typeSymbol - The typed symbol identifying the dependency to resolve
+     * @returns The resolved instance
+     * @throws Re-throws the cached error if a previous async resolution for this symbol failed
+     * @throws Throws if the instance has not been resolved yet (see {@link ResolutionContext.getSync})
+     */
     getSync(typeSymbol) {
         if (__classPrivateFieldGet(this, _ReactResolutionContext_resolutionErrors, "f").has(typeSymbol.symbol)) {
             throw __classPrivateFieldGet(this, _ReactResolutionContext_resolutionErrors, "f").get(typeSymbol.symbol);
         }
         return __classPrivateFieldGet(this, _ReactResolutionContext_resolutionContext, "f").getSync(typeSymbol);
     }
+    /**
+     * Asynchronously resolves an instance for the given type symbol.
+     *
+     * If a previous resolution for this symbol failed, the cached error is
+     * thrown immediately. Otherwise the call goes to the underlying context,
+     * which joins a creation already in flight for a singleton.
+     *
+     * @template T The type of the resolved instance
+     * @param typeSymbol - The typed symbol identifying the dependency to resolve
+     * @returns A promise that resolves to the instance
+     * @throws Re-throws the cached error if a previous resolution for this symbol failed
+     */
     async get(typeSymbol) {
-        if (__classPrivateFieldGet(this, _ReactResolutionContext_resolutionErrors, "f").has(typeSymbol.symbol)) {
-            throw __classPrivateFieldGet(this, _ReactResolutionContext_resolutionErrors, "f").get(typeSymbol.symbol);
+        const symbol = typeSymbol.symbol;
+        if (__classPrivateFieldGet(this, _ReactResolutionContext_resolutionErrors, "f").has(symbol)) {
+            throw __classPrivateFieldGet(this, _ReactResolutionContext_resolutionErrors, "f").get(symbol);
         }
-        const promise = __classPrivateFieldGet(this, _ReactResolutionContext_resolutions, "f").get(typeSymbol.symbol);
-        if (promise) {
-            return promise;
+        const startedAt = __classPrivateFieldGet(this, _ReactResolutionContext_generation, "f");
+        try {
+            return await __classPrivateFieldGet(this, _ReactResolutionContext_resolutionContext, "f").get(typeSymbol);
         }
-        const newResolution = __classPrivateFieldGet(this, _ReactResolutionContext_resolutionContext, "f").get(typeSymbol);
-        __classPrivateFieldGet(this, _ReactResolutionContext_resolutions, "f").set(typeSymbol.symbol, newResolution);
-        return newResolution
-            .catch((err) => {
-            __classPrivateFieldGet(this, _ReactResolutionContext_resolutionErrors, "f").set(typeSymbol.symbol, err);
+        catch (err) {
+            // A failure that settles after `clearErrors` belongs to the attempt the
+            // caller just discarded: hand it to this caller, but don't cache it.
+            if (!__classPrivateFieldGet(this, _ReactResolutionContext_instances, "m", _ReactResolutionContext_clearedSince).call(this, symbol, startedAt)) {
+                __classPrivateFieldGet(this, _ReactResolutionContext_resolutionErrors, "f").set(symbol, err);
+            }
             throw err;
-        })
-            .finally(() => {
-            __classPrivateFieldGet(this, _ReactResolutionContext_resolutions, "f").delete(typeSymbol.symbol);
-        });
+        }
     }
+    /**
+     * Forgets cached resolution errors, so the next `get` or `getSync` asks the
+     * underlying context again.
+     *
+     * Call it after replacing a failed binding (`unbind`, then apply the wire
+     * again), then reset the error boundary that shows the error. A failure that
+     * was still in flight when you call this is not cached when it settles.
+     *
+     * @param typeSymbol - The symbol whose error to forget. Omit to forget all.
+     */
+    clearErrors(typeSymbol) {
+        __classPrivateFieldSet(this, _ReactResolutionContext_generation, __classPrivateFieldGet(this, _ReactResolutionContext_generation, "f") + 1, "f");
+        if (typeSymbol) {
+            __classPrivateFieldGet(this, _ReactResolutionContext_resolutionErrors, "f").delete(typeSymbol.symbol);
+            __classPrivateFieldGet(this, _ReactResolutionContext_clearedAt, "f").set(typeSymbol.symbol, __classPrivateFieldGet(this, _ReactResolutionContext_generation, "f"));
+            return;
+        }
+        __classPrivateFieldGet(this, _ReactResolutionContext_resolutionErrors, "f").clear();
+        __classPrivateFieldGet(this, _ReactResolutionContext_clearedAt, "f").clear();
+        __classPrivateFieldSet(this, _ReactResolutionContext_allClearedAt, __classPrivateFieldGet(this, _ReactResolutionContext_generation, "f"), "f");
+    }
+}
+_ReactResolutionContext_resolutionContext = new WeakMap(), _ReactResolutionContext_resolutionErrors = new WeakMap(), _ReactResolutionContext_generation = new WeakMap(), _ReactResolutionContext_allClearedAt = new WeakMap(), _ReactResolutionContext_clearedAt = new WeakMap(), _ReactResolutionContext_instances = new WeakSet(), _ReactResolutionContext_clearedSince = function _ReactResolutionContext_clearedSince(symbol, generation) {
+    const clearedAt = Math.max(__classPrivateFieldGet(this, _ReactResolutionContext_allClearedAt, "f"), __classPrivateFieldGet(this, _ReactResolutionContext_clearedAt, "f").get(symbol) ?? 0);
+    return clearedAt > generation;
+};
+/**
+ * The wrapper {@link ResolutionContextProvider} uses for each plain context, so
+ * every render and every mount of a provider for that context share one error
+ * cache and one context value.
+ */
+const reactResolutionContexts = new WeakMap();
+function reactResolutionContextFor(resolutionContext) {
+    if (resolutionContext instanceof ReactResolutionContext) {
+        return resolutionContext;
+    }
+    let wrapper = reactResolutionContexts.get(resolutionContext);
+    if (!wrapper) {
+        wrapper = new ReactResolutionContext(resolutionContext);
+        reactResolutionContexts.set(resolutionContext, wrapper);
+    }
+    return wrapper;
 }
-_ReactResolutionContext_resolutionContext = new WeakMap(), _ReactResolutionContext_resolutions = new WeakMap(), _ReactResolutionContext_resolutionErrors = new WeakMap();
+/**
+ * React Context that holds the active {@link ResolutionContext} for the component tree.
+ *
+ * The default value is an empty {@link TypeWireContainer} wrapped in a
+ * {@link ReactResolutionContext}. In practice, you should provide your own
+ * container via {@link ResolutionContextProvider}.
+ */
 export const ContainerContext = React.createContext(new ReactResolutionContext(new TypeWireContainer()));
+/**
+ * Hook to access the current {@link ResolutionContext} from the nearest
+ * {@link ResolutionContextProvider}.
+ *
+ * @returns The current resolution context
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const container = useContainer();
+ *   // Use container for manual resolution if needed
+ * }
+ * ```
+ */
 export function useContainer() {
     const container = React.useContext(ContainerContext);
     return container;
 }
-export function useTypeWire(typeWire) {
+/** Error reason thrown by {@link useTypeWire} with `{ suspend: false }`. */
+const ReasonNotPreloaded = "NotPreloaded";
+const ScopeSingleton = "singleton";
+/** Marks a state that has no value yet, so falsy values still count as values. */
+const NotReady = Symbol("NotReady");
+/**
+ * Reads a wire synchronously. Returns `NotReady` when the value isn't
+ * created yet and can be waited for; rethrows any other error.
+ */
+function readSync(typeWire, container) {
+    try {
+        return typeWire.getInstanceSync(container);
+    }
+    catch (err) {
+        if (err instanceof TypeWireError && err.retriable) {
+            return NotReady;
+        }
+        throw err;
+    }
+}
+function notPreloaded(typeWire, cause) {
+    const name = typeWire.type.symbol.description ?? "(unnamed wire)";
+    const err = new TypeWireError(ReasonNotPreloaded, `${name} is not ready. It was rendered with { suspend: false } before it was created: preload it (container.preload or usePreload) before this component renders.`);
+    err.retriable = false;
+    Object.defineProperty(err, "cause", {
+        value: cause,
+        enumerable: false,
+        writable: true,
+        configurable: true,
+    });
+    return err;
+}
+/**
+ * Hook that resolves a {@link TypeWire} within the current container context,
+ * with React Suspense integration.
+ *
+ * Resolution behavior:
+ * 1. **Sync available** — If the wire can be resolved synchronously (e.g., a singleton
+ *    that was already created or preloaded), the value is returned immediately,
+ *    including falsy values such as `0`, `""`, `false` and `null`.
+ * 2. **Async pending** — If sync resolution fails with a retriable error, the hook
+ *    starts an async resolution and throws the promise to trigger React Suspense.
+ *    With `{ suspend: false }` it throws a `TypeWireError` with reason
+ *    `NotPreloaded` instead.
+ * 3. **Error** — If sync resolution fails with a non-retriable error, it is re-thrown.
+ *
+ * To render without a fallback, preload the wires first, with
+ * `container.preload` before rendering or {@link usePreload} higher in the
+ * tree. A wire nobody preloaded suspends, so this hook must be used inside a
+ * `<Suspense>` boundary unless you pass `{ suspend: false }`.
+ *
+ * @template T The type of the resolved instance
+ * @param typeWire - The TypeWire to resolve
+ * @param opts - Optional settings; see {@link UseTypeWireOpts}
+ * @returns The resolved instance
+ * @throws The resolution promise when the value is not yet available (for Suspense)
+ * @throws {@link TypeWireError} with reason `NotPreloaded` when the value is not yet available and `suspend` is `false`
+ * @throws {@link TypeWireError} if synchronous resolution fails with a non-retriable error
+ *
+ * @example
+ * ```tsx
+ * function UserProfile() {
+ *   const userService = useTypeWire(UserServiceWire);
+ *   return <div>{userService.getName()}</div>;
+ * }
+ *
+ * // Preloaded before rendering: no fallback.
+ * await container.preload({ wires: [UserServiceWire] });
+ *
+ * // Or wrap in Suspense for wires that may not be ready yet.
+ * <Suspense fallback={<Loading />}>
+ *   <UserProfile />
+ * </Suspense>
+ * ```
+ */
+export function useTypeWire(typeWire, opts) {
     const container = useContainer();
-    const [value, setValue] = React.useState(() => {
+    const suspend = opts?.suspend ?? true;
+    const [state, setState] = React.useState(() => ({ value: readSync(typeWire, container) }));
+    if (state.value === NotReady && !suspend) {
+        let cause;
         try {
-            return typeWire.getInstanceSync(container);
+            typeWire.getInstanceSync(container);
         }
         catch (err) {
-            if (err instanceof TypeWireError && err.retriable) {
-                return null;
-            }
-            throw err;
+            cause = err;
         }
-    });
+        throw notPreloaded(typeWire, cause);
+    }
     const promise = typeWire.getInstance(container);
     React.useEffect(() => {
-        let mounted = false;
+        let mounted = true;
         promise
             .then((value) => {
             if (mounted) {
-                console.log("we got the value", value);
-                setValue(() => value);
+                // Keep the same state object for the same value, so React skips the
+                // re-render; a new object here would re-render, start a new
+                // `getInstance` and run this effect again, forever.
+                setState((prev) => (Object.is(prev.value, value) ? prev : { value }));
             }
         })
             .catch((err) => {
-            console.error(err);
+            if (mounted) {
+                console.error(err);
+            }
         });
         return () => {
             mounted = false;
         };
     }, [promise]);
-    if (value) {
-        return value;
+    if (state.value !== NotReady) {
+        return state.value;
     }
     throw promise;
 }
+/**
+ * Hook that suspends the calling component until every singleton in
+ * `opts.wires` is created, so components below it read them with
+ * {@link useTypeWire} without suspending.
+ *
+ * Use it where a part of the app starts (a route, a panel, a feature), under
+ * one `<Suspense>` boundary: the fallback shows once for the whole set, and
+ * the creations run in parallel. A creation that fails reaches the nearest
+ * error boundary.
+ *
+ * It works with any resolution context, including the Inversify adapter.
+ * Outside React, use `container.preload` instead.
+ *
+ * @param opts - The wires to preload; see {@link UsePreloadOpts}
+ * @throws A promise while any of the wires is still being created (for Suspense)
+ * @throws The creation's error, once one has failed
+ *
+ * @example
+ * ```tsx
+ * function ReportsRoute() {
+ *   usePreload({ wires: [reportsServiceWire, chartsWire] });
+ *   return <ReportsPage />;
+ * }
+ *
+ * <Suspense fallback={<Loading />}>
+ *   <ReportsRoute />
+ * </Suspense>
+ * ```
+ */
+export function usePreload(opts) {
+    const container = useContainer();
+    const pending = [];
+    for (const wire of opts.wires) {
+        if ((wire.scope ?? ScopeSingleton) !== ScopeSingleton) {
+            continue;
+        }
+        if (readSync(wire, container) === NotReady) {
+            pending.push(wire.getInstance(container));
+        }
+    }
+    if (pending.length > 0) {
+        throw Promise.all(pending);
+    }
+}
+/**
+ * React component that provides a {@link ResolutionContext} to the component tree.
+ *
+ * If the given `resolutionContext` is not already a {@link ReactResolutionContext},
+ * it is wrapped in one, so a failed resolution reaches an error boundary
+ * instead of retrying under Suspense. Each plain context gets one wrapper,
+ * reused on every render and every mount, so re-rendering the provider keeps
+ * cached errors and gives consumers the same context value.
+ *
+ * A cached error lasts until `clearErrors` is called, even after `unbind` and
+ * a re-apply. To be able to retry, create the {@link ReactResolutionContext}
+ * yourself, pass it here, and call its `clearErrors` after replacing the
+ * binding.
+ *
+ * The context must share one in-flight creation per singleton (as
+ * `TypeWireContainer` does); see {@link ReactResolutionContext}.
+ *
+ * @param props.resolutionContext - The resolution context to provide to descendants
+ * @param props.children - Child components that will have access to the context
+ *
+ * @example
+ * ```tsx
+ * async function main() {
+ *   const container = new TypeWireContainer();
+ *   await AppWireGroup.apply(container);
+ *
+ *   createRoot(document.getElementById('root')!).render(
+ *     <ResolutionContextProvider resolutionContext={container}>
+ *       <App />
+ *     </ResolutionContextProvider>
+ *   );
+ * }
+ * ```
+ */
 export function ResolutionContextProvider(props) {
-    const resolutionContext = props.resolutionContext instanceof ReactResolutionContext
-        ? props.resolutionContext
-        : new ReactResolutionContext(props.resolutionContext);
+    const resolutionContext = reactResolutionContextFor(props.resolutionContext);
     return (_jsx(ContainerContext, { value: resolutionContext, children: props.children }));
 }
 //# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.tsx"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.tsx"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typewirets/react",
-  "version": "0.1.0",
+  "version": "0.2.0-rc.1",
   "description": "React adapter for TypeWire dependency injection",
   "type": "module",
   "main": "dist/cjs/index.js",
@@ -15,12 +15,8 @@
   },
   "files": [
     "dist",
-    "src/*.ts",
-    "src/*.tsx",
-    "!src/**/*.test.ts",
-    "!src/**/*.test.tsx",
-    "!src/**/__tests__/**",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "keywords": [
@@ -55,8 +51,13 @@
     "zustand": "^5.0.3",
     "@typewirets/typescript-config": "0.0.0"
   },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22"
+  },
   "peerDependencies": {
-    "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+    "@types/react": "^16.8 || ^17.0 || ^18.0 || ^19.0",
+    "react": "^16.8 || ^17.0 || ^18.0 || ^19.0"
   },
   "peerDependenciesMeta": {
     "@types/react": {
@@ -64,15 +65,15 @@
     }
   },
   "dependencies": {
-    "@typewirets/core": "0.1.0"
+    "@typewirets/core": "0.2.0-rc.1"
   },
   "scripts": {
     "build": "pnpm clean && pnpm --filter '@typewirets/react' --parallel '/^build:.*/'",
-    "build:cjs": "tsc --project tsconfig.build.json --outDir dist/cjs --module Commonjs --moduleResolution Node",
+    "build:cjs": "node ../../scripts/write-cjs-package-json.mjs && tsc --project tsconfig.build.json --outDir dist/cjs --module Commonjs --moduleResolution Node",
     "build:esm": "tsc --project tsconfig.build.json --outDir dist/esm --module ES2020 --moduleResolution Node",
     "build:types": "tsc --project tsconfig.build.json --outDir dist/types --declaration --declarationMap",
     "dev": "pnpm clean && pnpm --filter '@typewirets/react' --parallel '/^dev:.*/'",
-    "dev:cjs": "tsc --watch --project tsconfig.build.json --outDir dist/cjs --module Commonjs --moduleResolution Node",
+    "dev:cjs": "node ../../scripts/write-cjs-package-json.mjs && tsc --watch --project tsconfig.build.json --outDir dist/cjs --module Commonjs --moduleResolution Node",
     "dev:esm": "tsc --watch --project tsconfig.build.json --outDir dist/esm --module ES2020 --moduleResolution Node",
     "dev:types": "tsc --watch --project tsconfig.build.json --outDir dist/types --declaration --declarationMap",
     "clean": "rimraf dist",

package/src/index.tsx

@@ -1,111 +0,0 @@
-import * as React from "react";
-import {
-  type ResolutionContext,
-  type TypeSymbol,
-  type TypeWire,
-  TypeWireError,
-  TypeWireContainer,
-} from "@typewirets/core";
-
-export class ReactResolutionContext {
-  readonly #resolutionContext: ResolutionContext;
-  readonly #resolutions: Map<symbol, Promise<unknown>> = new Map();
-  readonly #resolutionErrors: Map<symbol, unknown> = new Map();
-
-  constructor(resolutionContext: ResolutionContext) {
-    this.#resolutionContext = resolutionContext;
-  }
-
-  getSync<T>(typeSymbol: TypeSymbol<T>): T {
-    if (this.#resolutionErrors.has(typeSymbol.symbol)) {
-      throw this.#resolutionErrors.get(typeSymbol.symbol);
-    }
-    return this.#resolutionContext.getSync(typeSymbol);
-  }
-
-  async get<T>(typeSymbol: TypeSymbol<T>): Promise<T> {
-    if (this.#resolutionErrors.has(typeSymbol.symbol)) {
-      throw this.#resolutionErrors.get(typeSymbol.symbol);
-    }
-
-    const promise = this.#resolutions.get(typeSymbol.symbol) as Promise<T>;
-    if (promise) {
-      return promise;
-    }
-
-    const newResolution = this.#resolutionContext.get(typeSymbol);
-    this.#resolutions.set(typeSymbol.symbol, newResolution);
-    return newResolution
-      .catch((err) => {
-        this.#resolutionErrors.set(typeSymbol.symbol, err);
-        throw err;
-      })
-      .finally(() => {
-        this.#resolutions.delete(typeSymbol.symbol);
-      });
-  }
-}
-
-export const ContainerContext = React.createContext<ResolutionContext>(
-  new ReactResolutionContext(new TypeWireContainer()),
-);
-
-export function useContainer() {
-  const container = React.useContext(ContainerContext);
-  return container;
-}
-
-export function useTypeWire<T>(typeWire: TypeWire<T>): T {
-  const container = useContainer();
-  const [value, setValue] = React.useState(() => {
-    try {
-      return typeWire.getInstanceSync(container);
-    } catch (err: unknown) {
-      if (err instanceof TypeWireError && err.retriable) {
-        return null;
-      }
-
-      throw err;
-    }
-  });
-
-  const promise = typeWire.getInstance(container);
-  React.useEffect(() => {
-    let mounted = false;
-
-    promise
-      .then((value) => {
-        if (mounted) {
-          console.log("we got the value", value);
-          setValue(() => value);
-        }
-      })
-      .catch((err) => {
-        console.error(err);
-      });
-    return () => {
-      mounted = false;
-    };
-  }, [promise]);
-
-  if (value) {
-    return value;
-  }
-
-  throw promise;
-}
-
-export function ResolutionContextProvider(props: {
-  resolutionContext: ResolutionContext;
-  children?: React.ReactNode;
-}) {
-  const resolutionContext =
-    props.resolutionContext instanceof ReactResolutionContext
-      ? props.resolutionContext
-      : new ReactResolutionContext(props.resolutionContext);
-  return (
-    <ContainerContext value={resolutionContext}>
-      {props.children}
-    </ContainerContext>
-  );
-}