@magicdoor/magic-use-case-react 0.1.0

package/dist/index.js

@@ -0,0 +1,819 @@
+import { useState, useMemo, useCallback, useRef, useEffect, Component } from 'react';
+import { jsx, Fragment } from 'react/jsx-runtime';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
+
+// ../core/dist/index.js
+var __defProp2 = Object.defineProperty;
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+var ConcreteEventEmitter = class {
+  constructor() {
+    __publicField2(this, "events", {});
+    __publicField2(this, "stateChange", "stateChange");
+    __publicField2(this, "navigation", "navigation");
+    __publicField2(this, "error", "error");
+    __publicField2(this, "state");
+  }
+  registerForStateChange(handler) {
+    this.register(this.stateChange, handler);
+    if (this.state !== void 0) {
+      try {
+        handler(this.state);
+      } catch (error) {
+        this.unregister(this.stateChange, handler);
+        throw error;
+      }
+    }
+  }
+  unregisterFromStateChange(handler) {
+    this.unregister(this.stateChange, handler);
+  }
+  registerForNavigation(handler) {
+    this.register(this.navigation, handler);
+  }
+  unregisterFromNavigation(handler) {
+    this.unregister(this.navigation, handler);
+  }
+  registerForErrors(handler) {
+    this.register(this.error, handler);
+  }
+  unregisterFromErrors(handler) {
+    this.unregister(this.error, handler);
+  }
+  emitStateChange(data) {
+    this.state = data;
+    this.emit(this.stateChange, data);
+  }
+  /**
+   * Drops the retained state as well as notifying. Without clearing `state`,
+   * `registerForStateChange` would replay the pre-reset value to any presenter
+   * constructed afterwards.
+   */
+  resetState() {
+    this.state = void 0;
+    this.emit(this.stateChange, void 0);
+  }
+  emitError(error) {
+    if (!this.events[this.error]?.length) {
+      console.error("Unhandled use case error:", error);
+      return;
+    }
+    this.emit(this.error, error);
+  }
+  emitNavigation(url) {
+    this.emit(this.navigation, url);
+  }
+  register(event, handler) {
+    if (!this.events[event]) {
+      this.events[event] = [];
+    }
+    this.events[event].push(handler);
+  }
+  unregister(event, handler) {
+    if (!this.events[event]) return;
+    this.events[event] = this.events[event].filter((h2) => h2 !== handler);
+  }
+  emit(event, data) {
+    if (!this.events[event]) return;
+    this.events[event].forEach((handler) => {
+      try {
+        handler(data);
+      } catch (error) {
+        console.error(`Error in ${event} handler:`, error);
+      }
+    });
+  }
+};
+function createScope(initialState) {
+  const scope = {
+    state: initialState,
+    initialStatePromise: void 0,
+    runningUseCases: /* @__PURE__ */ new Map(),
+    emitter: new ConcreteEventEmitter(),
+    sources: /* @__PURE__ */ new Map(),
+    openMutationWindows: 0
+  };
+  return scope;
+}
+var browserScope = createScope();
+var resolveScope = () => browserScope;
+function currentScope() {
+  return resolveScope();
+}
+function setScopeResolver(resolver) {
+  resolveScope = resolver;
+}
+function onError(handler) {
+  const { emitter } = currentScope();
+  const wrapper = (data) => {
+    if (data instanceof Error) handler(data);
+  };
+  emitter.registerForErrors(wrapper);
+  return () => emitter.unregisterFromErrors(wrapper);
+}
+function onNavigation(handler) {
+  const { emitter } = currentScope();
+  const wrapper = (data) => {
+    if (typeof data === "string") handler(data);
+  };
+  emitter.registerForNavigation(wrapper);
+  return () => emitter.unregisterFromNavigation(wrapper);
+}
+function openMutationWindow() {
+  currentScope().openMutationWindows += 1;
+}
+function closeMutationWindow() {
+  const scope = currentScope();
+  scope.openMutationWindows = Math.max(0, scope.openMutationWindows - 1);
+}
+function isMutationWindowOpen() {
+  return currentScope().openMutationWindows > 0;
+}
+async function withMutationWindow(run) {
+  openMutationWindow();
+  try {
+    return await run();
+  } finally {
+    closeMutationWindow();
+  }
+}
+function assertMutationWindowOpen(operation) {
+  if (isMutationWindowOpen()) return;
+  throw new Error(
+    `[magic-use-case] ${operation} is only allowed inside a running use case.`
+  );
+}
+var mutatingMapMethods = /* @__PURE__ */ new Set(["set", "delete", "clear"]);
+var mutatingSetMethods = /* @__PURE__ */ new Set(["add", "delete", "clear"]);
+var mutatingArrayMethods = /* @__PURE__ */ new Set([
+  "push",
+  "pop",
+  "shift",
+  "unshift",
+  "splice",
+  "sort",
+  "reverse",
+  "fill",
+  "copyWithin"
+]);
+var iteratorKeys = /* @__PURE__ */ new Set(["values", "entries", Symbol.iterator]);
+var READONLY = {
+  marker: /* @__PURE__ */ Symbol("readonly"),
+  cache: /* @__PURE__ */ new WeakMap(),
+  label: "readonly ",
+  allows: () => false,
+  reject(action) {
+    throw new Error(`Cannot ${action} on readonly object`);
+  }
+};
+var USE_CASE = {
+  marker: /* @__PURE__ */ Symbol("useCaseWritable"),
+  cache: /* @__PURE__ */ new WeakMap(),
+  label: "",
+  allows: isMutationWindowOpen,
+  reject(action) {
+    throw new Error(
+      `[magic-use-case] Cannot ${action} outside a use case.
+
+Application state may only be mutated from within a running use case, so that every change emits a state-change event and reaches the UI. Mutating it elsewhere would leave presenters showing stale data.
+
+Move this write into a use case's runLogic().`
+    );
+  }
+};
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function mustReturnRaw(target, prop) {
+  const descriptor = Object.getOwnPropertyDescriptor(target, prop);
+  return descriptor !== void 0 && descriptor.configurable === false && descriptor.writable === false;
+}
+function wrap(value, policy) {
+  return isObject(value) ? proxyFor(value, policy) : value;
+}
+function createMapProxy(target, policy) {
+  return new Proxy(target, {
+    get(target2, prop, receiver) {
+      if (prop === policy.marker) return true;
+      if (typeof prop === "string" && mutatingMapMethods.has(prop)) {
+        if (!policy.allows()) return () => policy.reject(`call .${prop}() on ${policy.label}Map`);
+        const method = Reflect.get(target2, prop, target2);
+        return method.bind(target2);
+      }
+      if (prop === "get") {
+        return (key) => wrap(target2.get(key), policy);
+      }
+      if (prop === "forEach") {
+        return (cb) => target2.forEach((v2, k2) => cb(wrap(v2, policy), k2, receiver));
+      }
+      if (iteratorKeys.has(prop)) {
+        return function* () {
+          if (prop === "values") {
+            for (const v2 of target2.values()) yield wrap(v2, policy);
+          } else {
+            for (const [k2, v2] of target2.entries()) yield [k2, wrap(v2, policy)];
+          }
+        };
+      }
+      const value = Reflect.get(target2, prop, target2);
+      if (prop === "constructor" || typeof value !== "function") return value;
+      return value.bind(target2);
+    },
+    set(target2, prop, value) {
+      if (!policy.allows()) policy.reject(`set property '${String(prop)}'`);
+      return Reflect.set(target2, prop, value);
+    },
+    deleteProperty(target2, prop) {
+      if (!policy.allows()) policy.reject(`delete property '${String(prop)}'`);
+      return Reflect.deleteProperty(target2, prop);
+    },
+    defineProperty(target2, prop, attributes) {
+      if (!policy.allows()) policy.reject(`define property '${String(prop)}'`);
+      return Reflect.defineProperty(target2, prop, attributes);
+    }
+  });
+}
+function createSetProxy(target, policy) {
+  return new Proxy(target, {
+    get(target2, prop, receiver) {
+      if (prop === policy.marker) return true;
+      if (typeof prop === "string" && mutatingSetMethods.has(prop)) {
+        if (!policy.allows()) return () => policy.reject(`call .${prop}() on ${policy.label}Set`);
+        const method = Reflect.get(target2, prop, target2);
+        return method.bind(target2);
+      }
+      if (iteratorKeys.has(prop)) {
+        return function* () {
+          for (const v2 of target2.values()) yield wrap(v2, policy);
+        };
+      }
+      if (prop === "forEach") {
+        return (cb) => target2.forEach((v2) => cb(wrap(v2, policy), wrap(v2, policy), receiver));
+      }
+      const value = Reflect.get(target2, prop, target2);
+      if (prop === "constructor" || typeof value !== "function") return value;
+      return value.bind(target2);
+    },
+    set(target2, prop, value) {
+      if (!policy.allows()) policy.reject(`set property '${String(prop)}'`);
+      return Reflect.set(target2, prop, value);
+    },
+    deleteProperty(target2, prop) {
+      if (!policy.allows()) policy.reject(`delete property '${String(prop)}'`);
+      return Reflect.deleteProperty(target2, prop);
+    },
+    defineProperty(target2, prop, attributes) {
+      if (!policy.allows()) policy.reject(`define property '${String(prop)}'`);
+      return Reflect.defineProperty(target2, prop, attributes);
+    }
+  });
+}
+function createObjectProxy(target, policy) {
+  return new Proxy(target, {
+    get(target2, prop) {
+      if (prop === policy.marker) return true;
+      if (Array.isArray(target2) && typeof prop === "string" && mutatingArrayMethods.has(prop)) {
+        if (!policy.allows()) return () => policy.reject(`call .${prop}() on ${policy.label}Array`);
+        const method = Reflect.get(target2, prop, target2);
+        return method.bind(target2);
+      }
+      const value = Reflect.get(target2, prop, target2);
+      if (typeof value === "function") return prop === "constructor" ? value : value.bind(target2);
+      if (!isObject(value) || mustReturnRaw(target2, prop)) return value;
+      return proxyFor(value, policy);
+    },
+    set(target2, prop, value) {
+      if (!policy.allows()) policy.reject(`set property '${String(prop)}'`);
+      return Reflect.set(target2, prop, value);
+    },
+    deleteProperty(target2, prop) {
+      if (!policy.allows()) policy.reject(`delete property '${String(prop)}'`);
+      return Reflect.deleteProperty(target2, prop);
+    },
+    defineProperty(target2, prop, attributes) {
+      if (!policy.allows()) policy.reject(`define property '${String(prop)}'`);
+      return Reflect.defineProperty(target2, prop, attributes);
+    }
+  });
+}
+function proxyFor(obj, policy) {
+  if (obj === null || typeof obj !== "object") return obj;
+  if (obj[policy.marker]) return obj;
+  const cached = policy.cache.get(obj);
+  if (cached) return cached;
+  let proxy;
+  if (obj instanceof Map) {
+    proxy = createMapProxy(obj, policy);
+  } else if (obj instanceof Set) {
+    proxy = createSetProxy(obj, policy);
+  } else {
+    proxy = createObjectProxy(obj, policy);
+  }
+  policy.cache.set(obj, proxy);
+  return proxy;
+}
+function deepReadonly(obj) {
+  return proxyFor(obj, READONLY);
+}
+function useCaseWritable(obj) {
+  return proxyFor(obj, USE_CASE);
+}
+function cloneCollection(value, seen) {
+  if (value instanceof Map) {
+    const copy = /* @__PURE__ */ new Map();
+    seen.set(value, copy);
+    for (const [k2, v2] of value.entries()) {
+      copy.set(deepClone(k2, seen), deepClone(v2, seen));
+    }
+    return copy;
+  }
+  if (value instanceof Set) {
+    const copy = /* @__PURE__ */ new Set();
+    seen.set(value, copy);
+    for (const v2 of value.values()) {
+      copy.add(deepClone(v2, seen));
+    }
+    return copy;
+  }
+  if (Array.isArray(value)) {
+    const copy = [];
+    seen.set(value, copy);
+    for (const v2 of value) copy.push(deepClone(v2, seen));
+    return copy;
+  }
+  return void 0;
+}
+function deepClone(value, seen = /* @__PURE__ */ new WeakMap()) {
+  if (value === null || typeof value !== "object") return value;
+  const asObject = value;
+  const existing = seen.get(asObject);
+  if (existing !== void 0) return existing;
+  if (value instanceof Date) return new Date(value.getTime());
+  if (value instanceof RegExp) return new RegExp(value.source, value.flags);
+  const collection = cloneCollection(asObject, seen);
+  if (collection !== void 0) return collection;
+  const copy = Object.create(Object.getPrototypeOf(asObject));
+  seen.set(asObject, copy);
+  for (const key of Reflect.ownKeys(asObject)) {
+    const descriptor = Object.getOwnPropertyDescriptor(asObject, key);
+    if (!descriptor) continue;
+    if ("value" in descriptor) {
+      Object.defineProperty(copy, key, {
+        ...descriptor,
+        value: deepClone(descriptor.value, seen)
+      });
+    } else {
+      Object.defineProperty(copy, key, descriptor);
+    }
+  }
+  if (Object.isFrozen(asObject)) Object.freeze(copy);
+  else if (Object.isSealed(asObject)) Object.seal(copy);
+  return copy;
+}
+var entryPoints = /* @__PURE__ */ new WeakSet();
+function createUseCase(UseCaseClass, onProgress) {
+  const useCase = new UseCaseClass(onProgress);
+  entryPoints.add(useCase);
+  return useCase;
+}
+var UseCase = class {
+  constructor(onProgress) {
+    __publicField2(this, "onProgress");
+    this.onProgress = onProgress;
+  }
+  /** Resolved per emit, so an execution always announces on the scope it is running in. */
+  get eventEmitter() {
+    return currentScope().emitter;
+  }
+  execute(params) {
+    return this.run(params, { hasCaller: !entryPoints.has(this) });
+  }
+  /**
+   * Starts a use case that this one does not wait for. It runs on its own: the
+   * caller returns and announces its own changes immediately, and the detached
+   * run announces its own when it lands. Nobody is waiting on it, so its failure
+   * is reported rather than thrown.
+   */
+  detach(UseCaseClass, params) {
+    void createUseCase(UseCaseClass).run(params, { hasCaller: false }).catch(() => void 0);
+  }
+  async run(params, run) {
+    const scope = currentScope();
+    if (scope.state === void 0) {
+      if (!scope.initialStatePromise) {
+        scope.initialStatePromise = this.initializeState().then((state) => {
+          scope.state = deepClone(state);
+        });
+      }
+      try {
+        await scope.initialStatePromise;
+      } catch (error) {
+        this.reportUnlessCallerWill(error, run);
+        throw error;
+      } finally {
+        scope.initialStatePromise = void 0;
+      }
+    }
+    const classMap = scope.runningUseCases.get(this.constructor) ?? /* @__PURE__ */ new Map();
+    scope.runningUseCases.set(this.constructor, classMap);
+    const paramsKey = JSON.stringify(params);
+    if (classMap.has(paramsKey)) {
+      await classMap.get(paramsKey);
+      this.announceUnlessCallerWill(run);
+      return;
+    }
+    const executionPromise = this.runWithUpdate(() => this.runLogic(params), run);
+    classMap.set(paramsKey, executionPromise);
+    try {
+      await executionPromise;
+    } finally {
+      classMap.delete(paramsKey);
+      if (classMap.size === 0) {
+        scope.runningUseCases.delete(this.constructor);
+      }
+    }
+  }
+  getState() {
+    return useCaseWritable(currentScope().state);
+  }
+  /**
+   * Clears application state so the next execution bootstraps it again.
+   *
+   * All four pieces of module state go together: the state itself, the
+   * emitter's retained copy, the in-flight dedup map, and any bootstrap in
+   * flight. Leaving any one behind resurrects the old state.
+   */
+  resetAppState() {
+    assertMutationWindowOpen("Resetting application state");
+    const scope = currentScope();
+    scope.state = void 0;
+    scope.runningUseCases.clear();
+    scope.initialStatePromise = void 0;
+    this.eventEmitter.resetState();
+  }
+  navigate(url) {
+    this.eventEmitter.emitNavigation(url);
+  }
+  /**
+   * Announces a failure the screen should hear about, for a use case that
+   * handles the failure rather than rethrowing it. Anything rethrown is
+   * reported on its way out and must not be reported here as well.
+   */
+  report(error) {
+    this.eventEmitter.emitError(error);
+  }
+  /**
+   * A run announces its work unless somebody is waiting on it. A nested run
+   * stays silent and its caller announces everything written beneath it, once.
+   *
+   * Whether a run has a caller is known when it starts, which is what keeps an
+   * unrelated run finishing at the same moment from being swallowed: two flows
+   * a screen started independently each reach it on their own.
+   */
+  async runWithUpdate(functionToRun, run) {
+    try {
+      await withMutationWindow(functionToRun);
+    } catch (error) {
+      this.reportUnlessCallerWill(error, run);
+      throw error;
+    } finally {
+      this.announceUnlessCallerWill(run);
+    }
+  }
+  announceUnlessCallerWill(run) {
+    if (run.hasCaller) return;
+    this.eventEmitter.emitStateChange(deepReadonly(currentScope().state));
+  }
+  /**
+   * Counting who is running cannot tell a caller from an unrelated run that
+   * happens to overlap, and guessing wrong loses the failure entirely. Whether
+   * this run has a caller is known when it starts, so that is what decides.
+   */
+  reportUnlessCallerWill(error, run) {
+    if (run.hasCaller) return;
+    this.report(error instanceof Error ? error : new Error(String(error)));
+  }
+};
+function acquireSource(scope, presentation) {
+  const existing = scope.sources.get(presentation);
+  if (existing) {
+    existing.presenters += 1;
+    return existing;
+  }
+  const source = {
+    model: void 0,
+    listeners: /* @__PURE__ */ new Set(),
+    presenters: 1,
+    handler: (state) => {
+      if (state === void 0) {
+        source.model = void 0;
+      } else {
+        try {
+          source.model = presentation(state);
+        } catch (error) {
+          console.error("[magic-use-case] A presentation threw; its model is left empty.", error);
+          source.model = void 0;
+        }
+      }
+      source.listeners.forEach((listener) => listener(source.model));
+    }
+  };
+  scope.sources.set(presentation, source);
+  scope.emitter.registerForStateChange(source.handler);
+  if (source.model === void 0 && scope.state !== void 0) {
+    source.handler(deepReadonly(scope.state));
+  }
+  return source;
+}
+function releaseSource(scope, presentation) {
+  const source = scope.sources.get(presentation);
+  if (!source) return;
+  source.presenters -= 1;
+  if (source.presenters > 0) return;
+  scope.emitter.unregisterFromStateChange(source.handler);
+  scope.sources.delete(presentation);
+}
+var Presenter = class {
+  constructor(presentation) {
+    __publicField2(this, "model");
+    __publicField2(this, "subscribers", /* @__PURE__ */ new Set());
+    __publicField2(this, "presentation");
+    __publicField2(this, "source");
+    __publicField2(this, "onModel");
+    __publicField2(this, "scope");
+    this.presentation = presentation;
+    this.onModel = (model) => {
+      this.model = model;
+      this.notifySubscribers();
+    };
+    this.scope = currentScope();
+    this.source = acquireSource(this.scope, presentation);
+    this.model = this.source.model;
+    this.source.listeners.add(this.onModel);
+  }
+  subscribe(listener) {
+    this.subscribers.add(listener);
+    listener(this.model);
+  }
+  unsubscribe(listener) {
+    this.subscribers.delete(listener);
+  }
+  notifySubscribers() {
+    this.subscribers.forEach((listener) => listener(this.model));
+  }
+  destroy() {
+    if (!this.source) return;
+    this.source.listeners.delete(this.onModel);
+    this.source = void 0;
+    releaseSource(this.scope, this.presentation);
+    this.subscribers.clear();
+    this.model = void 0;
+  }
+};
+function currentModelFor(presentation) {
+  const { state } = currentScope();
+  if (state === void 0) {
+    return void 0;
+  }
+  try {
+    return presentation(deepReadonly(state));
+  } catch (error) {
+    console.error("[magic-use-case] A presentation threw; its model is left empty.", error);
+    return void 0;
+  }
+}
+var M = ((i) => (i[i.AggregateError = 1] = "AggregateError", i[i.ArrowFunction = 2] = "ArrowFunction", i[i.ErrorPrototypeStack = 4] = "ErrorPrototypeStack", i[i.ObjectAssign = 8] = "ObjectAssign", i[i.BigIntTypedArray = 16] = "BigIntTypedArray", i[i.RegExp = 32] = "RegExp", i))(M || {});
+var L = "__SEROVAL_REFS__";
+var U = /* @__PURE__ */ new Map();
+typeof globalThis != "undefined" ? Object.defineProperty(globalThis, L, { value: U, configurable: true, writable: false, enumerable: false }) : typeof window != "undefined" ? Object.defineProperty(window, L, { value: U, configurable: true, writable: false, enumerable: false }) : typeof self != "undefined" ? Object.defineProperty(self, L, { value: U, configurable: true, writable: false, enumerable: false }) : typeof global != "undefined" && Object.defineProperty(global, L, { value: U, configurable: true, writable: false, enumerable: false });
+var ee = () => {
+  let e = { p: 0, s: 0, f: 0 };
+  return e.p = new Promise((r, t) => {
+    e.s = r, e.f = t;
+  }), e;
+};
+var In = (e, r) => {
+  e.s(r), e.p.s = 1, e.p.v = r;
+};
+var Rn = (e, r) => {
+  e.f(r), e.p.s = 2, e.p.v = r;
+};
+ee.toString();
+In.toString();
+Rn.toString();
+var wr = (e) => {
+  let r = atob(e), t = r.length, n = new Uint8Array(t);
+  for (let a = 0; a < t; a++) n[a] = r.charCodeAt(a);
+  return n.buffer;
+};
+wr.toString();
+var oe = ((t) => (t[t.Vanilla = 1] = "Vanilla", t[t.Cross = 2] = "Cross", t))(oe || {});
+var Ro = () => T;
+Ro.toString();
+var STATE_GLOBAL = "__MAGIC_USE_CASE_STATE__";
+function transferredState() {
+  return globalThis[STATE_GLOBAL];
+}
+function adoptSerializedState() {
+  const state = transferredState();
+  if (state === void 0) {
+    return false;
+  }
+  const scope = createScope(state);
+  setScopeResolver(() => scope);
+  return true;
+}
+function useReconciledStore(initialState) {
+  const [state, setState] = useState(initialState);
+  const updateState = useCallback((newData) => {
+    setState((prevState) => {
+      const resolvedState = typeof newData === "function" ? newData(prevState) : newData;
+      if (prevState === void 0) {
+        return resolvedState;
+      }
+      if (deepEqual(prevState, resolvedState)) {
+        return prevState;
+      } else {
+        return cloneWithNewReferences(resolvedState, prevState);
+      }
+    });
+  }, []);
+  return [state, updateState];
+}
+function deepEqual(obj1, obj2) {
+  if (obj1 == null || obj2 == null || typeof obj1 !== "object" || typeof obj2 !== "object") return obj1 === obj2;
+  if (obj1 instanceof Date && obj2 instanceof Date) return obj1.getTime() === obj2.getTime();
+  if (obj1 instanceof Set && obj2 instanceof Set) {
+    if (obj1.size !== obj2.size) return false;
+    const arr2 = [...obj2];
+    return [...obj1].every((val) => arr2.some((val2) => deepEqual(val, val2)));
+  }
+  if (obj1 instanceof Map && obj2 instanceof Map) {
+    if (obj1.size !== obj2.size) return false;
+    return [...obj1.keys()].every((key) => obj2.has(key) && deepEqual(obj1.get(key), obj2.get(key)));
+  }
+  if (Object.getPrototypeOf(obj1) !== Object.getPrototypeOf(obj2)) return false;
+  const rec1 = obj1;
+  const rec2 = obj2;
+  const keys1 = Object.keys(rec1);
+  const keys2 = Object.keys(rec2);
+  if (keys1.length !== keys2.length) return false;
+  return keys1.every((key) => key in rec2 && deepEqual(rec1[key], rec2[key]));
+}
+function cloneWithNewReferences(obj, referenceObj) {
+  if (Array.isArray(obj) && Array.isArray(referenceObj)) {
+    return obj.map(
+      (item, index) => deepEqual(item, referenceObj[index]) ? referenceObj[index] : cloneWithNewReferences(item, referenceObj[index])
+    );
+  } else if (obj instanceof Map && referenceObj instanceof Map) {
+    const newMap = /* @__PURE__ */ new Map();
+    let hasChanges = obj.size !== referenceObj.size;
+    for (const [key, value] of obj) {
+      const refValue = referenceObj.get(key);
+      if (deepEqual(value, refValue)) {
+        newMap.set(key, refValue);
+      } else {
+        newMap.set(key, cloneWithNewReferences(value, refValue));
+        hasChanges = true;
+      }
+    }
+    return hasChanges ? newMap : obj;
+  } else if (obj instanceof Set && referenceObj instanceof Set) {
+    const refArr = [...referenceObj];
+    const newArr = [...obj].map((val) => {
+      const match = refArr.find((ref) => deepEqual(val, ref));
+      return match !== void 0 ? match : val;
+    });
+    const hasChanges = obj.size !== referenceObj.size || newArr.some((v2, i) => v2 !== [...obj][i]);
+    return hasChanges ? new Set(newArr) : obj;
+  } else if (obj && typeof obj === "object" && obj.constructor === Object) {
+    const newObj = Object.create(Object.getPrototypeOf(obj));
+    let hasChanges = false;
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        const clonedValue = referenceObj && deepEqual(obj[key], referenceObj[key]) ? referenceObj[key] : cloneWithNewReferences(obj[key], referenceObj ? referenceObj[key] : void 0);
+        if (clonedValue !== obj[key]) hasChanges = true;
+        newObj[key] = clonedValue;
+      }
+    }
+    return hasChanges ? newObj : obj;
+  }
+  return obj;
+}
+
+// src/hooks/usePresenter.ts
+function usePresenter(presentation) {
+  const presentationRef = useRef(presentation);
+  const [model, setModel] = useReconciledStore(() => currentModelFor(presentationRef.current));
+  const updateModel = useCallback(
+    (newModel) => {
+      setModel(newModel);
+    },
+    [setModel]
+  );
+  useEffect(() => {
+    const presenter = new Presenter(presentationRef.current);
+    presenter.subscribe(updateModel);
+    return () => {
+      presenter.unsubscribe(updateModel);
+      presenter.destroy();
+    };
+  }, [updateModel]);
+  return { model: model === void 0 ? void 0 : deepReadonly(model) };
+}
+function useUseCase(UseCaseClass) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [progress, setProgress] = useState(0);
+  const [didSucceed, setDidSucceed] = useState(false);
+  const useCase = useMemo(() => createUseCase(UseCaseClass, setProgress), [UseCaseClass]);
+  const execute = useCallback(
+    async (params) => {
+      setIsLoading(true);
+      setDidSucceed(false);
+      try {
+        await useCase.execute(params);
+        setDidSucceed(true);
+      } catch {
+        setDidSucceed(false);
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [useCase]
+  );
+  return { execute, isLoading, didSucceed, progress };
+}
+var ErrorBoundary = class extends Component {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "state", {});
+  }
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(error) {
+    this.props.onError(error);
+  }
+  render() {
+    const error = this.props.error || this.state.error;
+    if (error) {
+      return this.props.renderErrorDialog({
+        error,
+        onClose: () => {
+          this.setState({ error: void 0 });
+          this.props.onClose();
+        }
+      });
+    }
+    return this.props.children;
+  }
+};
+var ErrorHandler = (props) => {
+  const [error, setError] = useState();
+  const propsRef = useRef(props);
+  propsRef.current = props;
+  const reportError = useCallback((error2) => {
+    const shouldReport = propsRef.current.onWillReportError(error2);
+    if (shouldReport) {
+      setError(error2);
+      propsRef.current.onDidReportError?.(error2);
+    }
+  }, []);
+  const clearError = () => {
+    setError(void 0);
+  };
+  useEffect(() => {
+    return onError(reportError);
+  }, [reportError]);
+  return /* @__PURE__ */ jsx(
+    ErrorBoundary,
+    {
+      onError: reportError,
+      renderErrorDialog: props.renderErrorDialog,
+      error,
+      onClose: clearError,
+      children: /* @__PURE__ */ jsx(Fragment, { children: props.children })
+    }
+  );
+};
+var Navigator = (props) => {
+  useEffect(() => {
+    return onNavigation((url) => {
+      if (url) {
+        props.onNavigate?.(url);
+      }
+    });
+  }, [props.onNavigate]);
+  return null;
+};
+
+// src/index.ts
+adoptSerializedState();
+function usePresenter2(presentation) {
+  return usePresenter(presentation);
+}
+
+export { ErrorHandler, Navigator, Presenter, UseCase, createScope, onError, onNavigation, setScopeResolver, usePresenter2 as usePresenter, useUseCase };