@magicdoor/magic-use-case-solid 0.1.0

package/dist/index.js

@@ -0,0 +1,805 @@
+import { isServer, createComponent, memo, getRequestEvent } from 'solid-js/web';
+import { createSignal, onCleanup, ErrorBoundary, Show } from 'solid-js';
+import { createStore, reconcile } from 'solid-js/store';
+
+// ../core/dist/index.js
+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, typeof key !== "symbol" ? key + "" : key, value);
+var ConcreteEventEmitter = class {
+  constructor() {
+    __publicField(this, "events", {});
+    __publicField(this, "stateChange", "stateChange");
+    __publicField(this, "navigation", "navigation");
+    __publicField(this, "error", "error");
+    __publicField(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) {
+    __publicField(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) {
+    __publicField(this, "model");
+    __publicField(this, "subscribers", /* @__PURE__ */ new Set());
+    __publicField(this, "presentation");
+    __publicField(this, "source");
+    __publicField(this, "onModel");
+    __publicField(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;
+  }
+};
+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 v = Symbol.asyncIterator;
+var C = Symbol.iterator;
+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 xr = () => {
+  let e = [], r = [], t = true, n = false, a = 0, s = (l, g, S) => {
+    for (S = 0; S < a; S++) r[S] && r[S][g](l);
+  }, i = (l, g, S, d) => {
+    for (g = 0, S = e.length; g < S; g++) d = e[g], !t && g === S - 1 ? l[n ? "return" : "throw"](d) : l.next(d);
+  }, u = (l, g) => (t && (g = a++, r[g] = l), i(l), () => {
+    t && (r[g] = r[a], r[a--] = void 0);
+  });
+  return { __SEROVAL_STREAM__: true, on: (l) => u(l), next: (l) => {
+    t && (e.push(l), s(l, "next"));
+  }, throw: (l) => {
+    t && (e.push(l), s(l, "throw"), t = false, n = false, r.length = 0);
+  }, return: (l) => {
+    t && (e.push(l), s(l, "return"), t = false, n = true, r.length = 0);
+  } };
+};
+xr.toString();
+var Tr = (e) => (r) => () => {
+  let t = 0, n = { [e]: () => n, next: () => {
+    if (t > r.d) return { done: true, value: void 0 };
+    let a = t++, s = r.v[a];
+    if (a === r.t) throw s;
+    return { done: a === r.d, value: s };
+  } };
+  return n;
+};
+Tr.toString();
+var Or = (e, r) => (t) => () => {
+  let n = 0, a = -1, s = false, i = [], u = [], l = (S = 0, d = u.length) => {
+    for (; S < d; S++) u[S].s({ done: true, value: void 0 });
+  };
+  t.on({ next: (S) => {
+    let d = u.shift();
+    d && d.s({ done: false, value: S }), i.push(S);
+  }, throw: (S) => {
+    let d = u.shift();
+    d && d.f(S), l(), a = i.length, s = true, i.push(S);
+  }, return: (S) => {
+    let d = u.shift();
+    d && d.s({ done: true, value: S }), l(), a = i.length, i.push(S);
+  } });
+  let g = { [e]: () => g, next: () => {
+    if (a === -1) {
+      let K = n++;
+      if (K >= i.length) {
+        let tt = r();
+        return u.push(tt), tt.p;
+      }
+      return { done: false, value: i[K] };
+    }
+    if (n > a) return { done: true, value: void 0 };
+    let S = n++, d = i[S];
+    if (S !== a) return { done: false, value: d };
+    if (s) throw d;
+    return { done: true, value: d };
+  } };
+  return g;
+};
+Or.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();
+Tr(C);
+Or(v, ee);
+var oe = ((t) => (t[t.Vanilla = 1] = "Vanilla", t[t.Cross = 2] = "Cross", t))(oe || {});
+var Ro = () => T;
+Ro.toString();
+var Xt = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_";
+Xt.length;
+var Qt = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_";
+Qt.length;
+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 createReconciledStore(initialData) {
+  const [store, setStore] = createStore(initialData);
+  const updateStore = (data) => {
+    if (typeof data === "function") {
+      const newData = data(store);
+      setStore(reconcile(newData));
+    } else {
+      setStore(reconcile(data));
+    }
+  };
+  return [store, updateStore];
+}
+
+// src/hooks/usePresenter.ts
+function usePresenter(presentation) {
+  const [model, setModel] = createReconciledStore({ value: void 0 });
+  const presenter = new Presenter(presentation);
+  const updateModel = (newModel) => {
+    setModel({ value: newModel });
+  };
+  presenter.subscribe(updateModel);
+  onCleanup(() => {
+    presenter.unsubscribe(updateModel);
+    presenter.destroy();
+  });
+  return {
+    model: () => {
+      const current = model.value;
+      return current === void 0 ? void 0 : deepReadonly(current);
+    }
+  };
+}
+var scopes = /* @__PURE__ */ new WeakMap();
+function resolveServerScope() {
+  const event = getRequestEvent();
+  if (!event) {
+    throw new Error(
+      "[magic-use-case] No request scope is available.\n\nOn a server, application state belongs to the request being served, so that concurrent requests never share it. This ran on a server but outside a request, so there is no request to resolve a scope from \u2014 and falling back to a shared one would serve a user another user's data."
+    );
+  }
+  const existing = scopes.get(event);
+  if (existing) {
+    return existing;
+  }
+  const scope = createScope();
+  scopes.set(event, scope);
+  return scope;
+}
+function useUseCase(UseCaseClass) {
+  const [isLoading, setIsLoading] = createSignal(false);
+  const [progress, setProgress] = createSignal(0);
+  const [didSucceed, setDidSucceed] = createSignal(false);
+  const useCase = createUseCase(UseCaseClass, setProgress);
+  const execute = async (params) => {
+    setIsLoading(true);
+    setDidSucceed(false);
+    try {
+      await useCase.execute(params);
+      setDidSucceed(true);
+    } catch {
+      setDidSucceed(false);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  return { execute, isLoading, didSucceed, progress };
+}
+var ErrorHandler = (props) => {
+  const [error, setError] = createSignal(void 0);
+  const reportError = (error2) => {
+    const shouldReport = props.onWillReportError(error2);
+    if (shouldReport) {
+      setError(error2);
+      props.onDidReportError?.(error2);
+    }
+  };
+  const clearError = () => {
+    setError(void 0);
+  };
+  const unsubscribe = onError(reportError);
+  onCleanup(unsubscribe);
+  return createComponent(ErrorBoundary, {
+    fallback: (error2, reset) => props.renderErrorDialog({
+      error: error2,
+      onClose: reset
+    }),
+    get children() {
+      return [memo(() => props.children), createComponent(Show, {
+        get when() {
+          return error();
+        },
+        get children() {
+          return props.renderErrorDialog({
+            error: error(),
+            onClose: clearError
+          });
+        }
+      })];
+    }
+  });
+};
+var Navigator = (props) => {
+  const unsubscribe = onNavigation((url) => {
+    if (url) {
+      props.onNavigate?.(url);
+    }
+  });
+  onCleanup(unsubscribe);
+  return null;
+};
+
+// src/ui/StateTransfer.browser.tsx
+var StateTransfer = () => null;
+
+// src/index.ts
+if (isServer) {
+  setScopeResolver(resolveServerScope);
+} else {
+  adoptSerializedState();
+}
+function usePresenter2(presentation) {
+  return usePresenter(presentation);
+}
+
+export { ErrorHandler, Navigator, Presenter, StateTransfer, UseCase, createScope, onError, onNavigation, setScopeResolver, usePresenter2 as usePresenter, useUseCase };