@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/react-native/index.js

@@ -0,0 +1,1547 @@
+import {
+  __commonJS,
+  __toESM
+} from "../_browser-chunks/chunk-IMSF75WX.js";
+
+// ../../node_modules/setimmediate/setImmediate.js
+var require_setImmediate = __commonJS({
+  "../../node_modules/setimmediate/setImmediate.js"(exports) {
+    (function(global2, undefined2) {
+      "use strict";
+      if (global2.setImmediate)
+        return;
+      var nextHandle = 1, tasksByHandle = {}, currentlyRunningATask = !1, doc = global2.document, registerImmediate;
+      function setImmediate(callback) {
+        typeof callback != "function" && (callback = new Function("" + callback));
+        for (var args = new Array(arguments.length - 1), i = 0; i < args.length; i++)
+          args[i] = arguments[i + 1];
+        var task = { callback, args };
+        return tasksByHandle[nextHandle] = task, registerImmediate(nextHandle), nextHandle++;
+      }
+      function clearImmediate(handle) {
+        delete tasksByHandle[handle];
+      }
+      function run(task) {
+        var callback = task.callback, args = task.args;
+        switch (args.length) {
+          case 0:
+            callback();
+            break;
+          case 1:
+            callback(args[0]);
+            break;
+          case 2:
+            callback(args[0], args[1]);
+            break;
+          case 3:
+            callback(args[0], args[1], args[2]);
+            break;
+          default:
+            callback.apply(undefined2, args);
+            break;
+        }
+      }
+      function runIfPresent(handle) {
+        if (currentlyRunningATask)
+          setTimeout(runIfPresent, 0, handle);
+        else {
+          var task = tasksByHandle[handle];
+          if (task) {
+            currentlyRunningATask = !0;
+            try {
+              run(task);
+            } finally {
+              clearImmediate(handle), currentlyRunningATask = !1;
+            }
+          }
+        }
+      }
+      function installNextTickImplementation() {
+        registerImmediate = function(handle) {
+          process.nextTick(function() {
+            runIfPresent(handle);
+          });
+        };
+      }
+      function canUsePostMessage() {
+        if (global2.postMessage && !global2.importScripts) {
+          var postMessageIsAsynchronous = !0, oldOnMessage = global2.onmessage;
+          return global2.onmessage = function() {
+            postMessageIsAsynchronous = !1;
+          }, global2.postMessage("", "*"), global2.onmessage = oldOnMessage, postMessageIsAsynchronous;
+        }
+      }
+      function installPostMessageImplementation() {
+        var messagePrefix = "setImmediate$" + Math.random() + "$", onGlobalMessage = function(event) {
+          event.source === global2 && typeof event.data == "string" && event.data.indexOf(messagePrefix) === 0 && runIfPresent(+event.data.slice(messagePrefix.length));
+        };
+        global2.addEventListener ? global2.addEventListener("message", onGlobalMessage, !1) : global2.attachEvent("onmessage", onGlobalMessage), registerImmediate = function(handle) {
+          global2.postMessage(messagePrefix + handle, "*");
+        };
+      }
+      function installMessageChannelImplementation() {
+        var channel = new MessageChannel();
+        channel.port1.onmessage = function(event) {
+          var handle = event.data;
+          runIfPresent(handle);
+        }, registerImmediate = function(handle) {
+          channel.port2.postMessage(handle);
+        };
+      }
+      function installReadyStateChangeImplementation() {
+        var html = doc.documentElement;
+        registerImmediate = function(handle) {
+          var script = doc.createElement("script");
+          script.onreadystatechange = function() {
+            runIfPresent(handle), script.onreadystatechange = null, html.removeChild(script), script = null;
+          }, html.appendChild(script);
+        };
+      }
+      function installSetTimeoutImplementation() {
+        registerImmediate = function(handle) {
+          setTimeout(runIfPresent, 0, handle);
+        };
+      }
+      var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global2);
+      attachTo = attachTo && attachTo.setTimeout ? attachTo : global2, {}.toString.call(global2.process) === "[object process]" ? installNextTickImplementation() : canUsePostMessage() ? installPostMessageImplementation() : global2.MessageChannel ? installMessageChannelImplementation() : doc && "onreadystatechange" in doc.createElement("script") ? installReadyStateChangeImplementation() : installSetTimeoutImplementation(), attachTo.setImmediate = setImmediate, attachTo.clearImmediate = clearImmediate;
+    })(typeof self > "u" ? typeof global > "u" ? exports : global : self);
+  }
+});
+
+// ../../node_modules/deepmerge/dist/cjs.js
+var require_cjs = __commonJS({
+  "../../node_modules/deepmerge/dist/cjs.js"(exports, module) {
+    "use strict";
+    var isMergeableObject = function(value) {
+      return isNonNullObject(value) && !isSpecial(value);
+    };
+    function isNonNullObject(value) {
+      return !!value && typeof value == "object";
+    }
+    function isSpecial(value) {
+      var stringValue = Object.prototype.toString.call(value);
+      return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
+    }
+    var canUseSymbol = typeof Symbol == "function" && Symbol.for, REACT_ELEMENT_TYPE = canUseSymbol ? /* @__PURE__ */ Symbol.for("react.element") : 60103;
+    function isReactElement(value) {
+      return value.$$typeof === REACT_ELEMENT_TYPE;
+    }
+    function emptyTarget(val) {
+      return Array.isArray(val) ? [] : {};
+    }
+    function cloneUnlessOtherwiseSpecified(value, options) {
+      return options.clone !== !1 && options.isMergeableObject(value) ? deepmerge2(emptyTarget(value), value, options) : value;
+    }
+    function defaultArrayMerge(target, source, options) {
+      return target.concat(source).map(function(element) {
+        return cloneUnlessOtherwiseSpecified(element, options);
+      });
+    }
+    function getMergeFunction(key, options) {
+      if (!options.customMerge)
+        return deepmerge2;
+      var customMerge = options.customMerge(key);
+      return typeof customMerge == "function" ? customMerge : deepmerge2;
+    }
+    function getEnumerableOwnPropertySymbols(target) {
+      return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
+        return Object.propertyIsEnumerable.call(target, symbol);
+      }) : [];
+    }
+    function getKeys(target) {
+      return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
+    }
+    function propertyIsOnObject(object, property) {
+      try {
+        return property in object;
+      } catch {
+        return !1;
+      }
+    }
+    function propertyIsUnsafe(target, key) {
+      return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
+    }
+    function mergeObject(target, source, options) {
+      var destination = {};
+      return options.isMergeableObject(target) && getKeys(target).forEach(function(key) {
+        destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
+      }), getKeys(source).forEach(function(key) {
+        propertyIsUnsafe(target, key) || (propertyIsOnObject(target, key) && options.isMergeableObject(source[key]) ? destination[key] = getMergeFunction(key, options)(target[key], source[key], options) : destination[key] = cloneUnlessOtherwiseSpecified(source[key], options));
+      }), destination;
+    }
+    function deepmerge2(target, source, options) {
+      options = options || {}, options.arrayMerge = options.arrayMerge || defaultArrayMerge, options.isMergeableObject = options.isMergeableObject || isMergeableObject, options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
+      var sourceIsArray = Array.isArray(source), targetIsArray = Array.isArray(target), sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
+      return sourceAndTargetTypesMatch ? sourceIsArray ? options.arrayMerge(target, source, options) : mergeObject(target, source, options) : cloneUnlessOtherwiseSpecified(source, options);
+    }
+    deepmerge2.all = function(array, options) {
+      if (!Array.isArray(array))
+        throw new Error("first argument should be an array");
+      return array.reduce(function(prev, next) {
+        return deepmerge2(prev, next, options);
+      }, {});
+    };
+    var deepmerge_1 = deepmerge2;
+    module.exports = deepmerge_1;
+  }
+});
+
+// src/react-native/index.ts
+import { darkTheme as darkTheme2, theme as theme2 } from "@aussieljk/forkbook/internal/react-native-theming";
+
+// src/react-native/Start.tsx
+import {
+  composeConfigs,
+  addons as previewAddons2,
+  PreviewWithSelection as PreviewWithSelection2
+} from "@aussieljk/forkbook/internal/preview-api";
+import { addons as managerAddons2 } from "@aussieljk/forkbook/manager-api";
+
+// src/react-native/polyfill.ts
+var import_setimmediate = __toESM(require_setImmediate(), 1);
+
+// src/react-native/Start.tsx
+import { Channel as Channel2 } from "@aussieljk/forkbook/internal/channels";
+
+// src/react-native/View.tsx
+var import_deepmerge = __toESM(require_cjs(), 1);
+import { darkTheme, theme } from "@aussieljk/forkbook/internal/react-native-theming";
+import {
+  transformStoryIndexToStoriesHash
+} from "@aussieljk/forkbook/internal/react-native-ui-common";
+import { dedent } from "ts-dedent";
+import { useEffect as useEffect2, useMemo as useMemo2, useReducer as useReducer2, useState } from "react";
+import { SafeAreaProvider, useSafeAreaInsets } from "react-native-safe-area-context";
+import { Channel, WebsocketTransport } from "@aussieljk/forkbook/internal/channels";
+import { CHANNEL_CREATED, SET_CURRENT_STORY } from "@aussieljk/forkbook/internal/core-events";
+import { toId } from "@aussieljk/forkbook/internal/csf";
+import {
+  addons as previewAddons
+} from "@aussieljk/forkbook/internal/preview-api";
+import { addons as managerAddons } from "@aussieljk/forkbook/manager-api";
+import { FullUI as DeviceUI } from "@aussieljk/forkbook/react-native-ui";
+
+// src/react-native/patchChannelForRN.ts
+function snapshotValue(value, depth = 0) {
+  if (depth > 3) return "[...]";
+  if (value == null) return value;
+  if (typeof value == "function") return;
+  if (typeof value != "object") return value;
+  if (Array.isArray(value))
+    return value.map((item) => snapshotValue(item, depth + 1));
+  let result = {};
+  for (let key of Object.keys(value))
+    try {
+      result[key] = snapshotValue(value[key], depth + 1);
+    } catch {
+      result[key] = "[Error]";
+    }
+  return result;
+}
+function isSyntheticEvent(value) {
+  return value !== null && typeof value == "object" && typeof value.persist == "function" && "nativeEvent" in value;
+}
+function sanitizeActionArgs(value) {
+  return isSyntheticEvent(value) ? snapshotValue(value) : Array.isArray(value) ? value.map(sanitizeActionArgs) : value;
+}
+function patchChannelForRN(channel) {
+  globalThis.CHANNEL_OPTIONS = {
+    maxDepth: 5
+  };
+  let originalEmit = channel.emit.bind(channel);
+  channel.emit = (eventName, ...args) => {
+    if (eventName === "storybook/actions/action-event") {
+      let actionDisplay = args[0];
+      actionDisplay?.data?.args != null && (actionDisplay.data.args = sanitizeActionArgs(actionDisplay.data.args));
+    }
+    return originalEmit(eventName, ...args);
+  };
+}
+
+// src/react-native/View.tsx
+import {
+  ActivityIndicator,
+  Linking,
+  Platform,
+  View as RNView,
+  StatusBar,
+  useColorScheme
+} from "react-native";
+
+// src/react-native/components/StoryView/StoryView.tsx
+import { styled, useTheme } from "@aussieljk/forkbook/internal/react-native-theming";
+import React3, { useCallback as useCallback2, useMemo } from "react";
+import { Keyboard, View as View2 } from "react-native";
+
+// ../../node_modules/jotai/esm/vanilla/internals.mjs
+function hasInitialValue(atom2) {
+  return "init" in atom2;
+}
+function isActuallyWritableAtom(atom2) {
+  return typeof atom2.write == "function";
+}
+function hasOnMount(atom2) {
+  return !!atom2.onMount;
+}
+function isAtomStateInitialized(atomState) {
+  return "v" in atomState || "e" in atomState;
+}
+function returnAtomValue(atomState) {
+  if ("e" in atomState)
+    throw atomState.e;
+  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !("v" in atomState))
+    throw new Error("[Bug] atom state is not initialized");
+  return atomState.v;
+}
+function isPromiseLike(p) {
+  return typeof p?.then == "function";
+}
+function shouldThrowSynchronously(error) {
+  if (!(error instanceof Error))
+    return !1;
+  let name = error.name, message = error.message.toLowerCase();
+  return (name === "RangeError" || name === "InternalError") && (message.includes("call stack") || message.includes("too much recursion") || message.includes("stack overflow"));
+}
+function addPendingPromiseToDependency(atom2, promise, dependencyAtomState) {
+  if (!dependencyAtomState.p.has(atom2)) {
+    dependencyAtomState.p.add(atom2);
+    let cleanup = () => dependencyAtomState.p.delete(atom2);
+    promise.then(cleanup, cleanup);
+  }
+}
+function getMountedOrPendingDependents(atom2, atomState, mountedMap) {
+  let mounted = mountedMap.get(atom2), mountedDependents = mounted?.t, pendingDependents = atomState.p;
+  if (!mountedDependents?.size)
+    return pendingDependents;
+  if (!pendingDependents.size)
+    return mountedDependents;
+  let dependents = new Set(mountedDependents);
+  for (let a of pendingDependents)
+    dependents.add(a);
+  return dependents;
+}
+function hasOnInit(atom2) {
+  return !!atom2.INTERNAL_onInit;
+}
+var BUILDING_BLOCK_atomRead = (_buildingBlocks, _store, atom2, ...params) => atom2.read(...params), BUILDING_BLOCK_atomWrite = (_buildingBlocks, _store, atom2, ...params) => atom2.write(...params), BUILDING_BLOCK_atomOnInit = (_buildingBlocks, store2, atom2) => atom2.INTERNAL_onInit(store2), BUILDING_BLOCK_atomOnMount = (_buildingBlocks, _store, atom2, setAtom) => {
+  var _a;
+  return (_a = atom2.onMount) == null ? void 0 : _a.call(atom2, setAtom);
+}, BUILDING_BLOCK_ensureAtomState = (buildingBlocks, store2, atom2) => {
+  var _a;
+  let atomStateMap = buildingBlocks[0], atomState = atomStateMap.get(atom2);
+  if (!atomState) {
+    let storeHooks = buildingBlocks[6], atomOnInit = buildingBlocks[9];
+    atomState = { d: /* @__PURE__ */ new Map(), p: /* @__PURE__ */ new Set(), n: 0 }, atomStateMap.set(atom2, atomState), (_a = storeHooks.i) == null || _a.call(storeHooks, atom2), hasOnInit(atom2) && atomOnInit(buildingBlocks, store2, atom2);
+  }
+  return atomState;
+}, BUILDING_BLOCK_flushCallbacks = (buildingBlocks, store2) => {
+  var _a;
+  let mountedMap = buildingBlocks[1], changedAtoms = buildingBlocks[3], mountCallbacks = buildingBlocks[4], unmountCallbacks = buildingBlocks[5], storeHooks = buildingBlocks[6], recomputeInvalidatedAtoms = buildingBlocks[13];
+  if (!storeHooks.f && !changedAtoms.size && !mountCallbacks.size && !unmountCallbacks.size)
+    return;
+  let errors = [], call = (fn) => {
+    try {
+      fn();
+    } catch (e) {
+      errors.push(e);
+    }
+  };
+  do {
+    storeHooks.f && call(storeHooks.f);
+    let callbacks = /* @__PURE__ */ new Set();
+    for (let atom2 of changedAtoms) {
+      let listeners = (_a = mountedMap.get(atom2)) == null ? void 0 : _a.l;
+      if (listeners)
+        for (let listener of listeners)
+          callbacks.add(listener);
+    }
+    changedAtoms.clear();
+    for (let fn of unmountCallbacks)
+      callbacks.add(fn);
+    unmountCallbacks.clear();
+    for (let fn of mountCallbacks)
+      callbacks.add(fn);
+    mountCallbacks.clear();
+    for (let fn of callbacks)
+      call(fn);
+    changedAtoms.size && recomputeInvalidatedAtoms(buildingBlocks, store2);
+  } while (changedAtoms.size || unmountCallbacks.size || mountCallbacks.size);
+  if (errors.length)
+    throw new AggregateError(errors);
+}, BUILDING_BLOCK_recomputeInvalidatedAtoms = (buildingBlocks, store2) => {
+  let mountedMap = buildingBlocks[1], invalidatedAtoms = buildingBlocks[2], changedAtoms = buildingBlocks[3], ensureAtomState = buildingBlocks[11], readAtomState = buildingBlocks[14], mountDependencies = buildingBlocks[17];
+  if (!changedAtoms.size)
+    return;
+  let sortedReversedAtoms = [], sortedReversedStates = [], visiting = /* @__PURE__ */ new WeakSet(), visited = /* @__PURE__ */ new WeakSet(), stackAtoms = [], stackStates = [];
+  for (let atom2 of changedAtoms)
+    stackAtoms.push(atom2), stackStates.push(ensureAtomState(buildingBlocks, store2, atom2));
+  for (; stackAtoms.length; ) {
+    let top = stackAtoms.length - 1, a = stackAtoms[top], aState = stackStates[top];
+    if (visited.has(a)) {
+      stackAtoms.pop(), stackStates.pop();
+      continue;
+    }
+    if (visiting.has(a)) {
+      if (invalidatedAtoms.get(a) === aState.n)
+        sortedReversedAtoms.push(a), sortedReversedStates.push(aState);
+      else if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && invalidatedAtoms.has(a))
+        throw new Error("[Bug] invalidated atom exists");
+      visited.add(a), stackAtoms.pop(), stackStates.pop();
+      continue;
+    }
+    visiting.add(a);
+    for (let d of getMountedOrPendingDependents(a, aState, mountedMap))
+      visiting.has(d) || (stackAtoms.push(d), stackStates.push(ensureAtomState(buildingBlocks, store2, d)));
+  }
+  for (let i = sortedReversedAtoms.length - 1; i >= 0; --i) {
+    let a = sortedReversedAtoms[i], aState = sortedReversedStates[i], hasChangedDeps = !1;
+    for (let dep of aState.d.keys())
+      if (dep !== a && changedAtoms.has(dep)) {
+        hasChangedDeps = !0;
+        break;
+      }
+    hasChangedDeps && (invalidatedAtoms.set(a, aState.n), readAtomState(buildingBlocks, store2, a), mountDependencies(buildingBlocks, store2, a)), invalidatedAtoms.delete(a);
+  }
+}, storeMutationSet = /* @__PURE__ */ new WeakSet(), BUILDING_BLOCK_readAtomState = (buildingBlocks, store2, atom2) => {
+  var _a, _b;
+  let mountedMap = buildingBlocks[1], invalidatedAtoms = buildingBlocks[2], changedAtoms = buildingBlocks[3], storeHooks = buildingBlocks[6], atomRead = buildingBlocks[7], ensureAtomState = buildingBlocks[11], flushCallbacks = buildingBlocks[12], recomputeInvalidatedAtoms = buildingBlocks[13], readAtomState = buildingBlocks[14], writeAtomState = buildingBlocks[16], mountDependencies = buildingBlocks[17], setAtomStateValueOrPromise = buildingBlocks[20], registerAbortHandler = buildingBlocks[26], storeEpochHolder = buildingBlocks[28], atomState = ensureAtomState(buildingBlocks, store2, atom2), storeEpochNumber = storeEpochHolder[0];
+  if (isAtomStateInitialized(atomState)) {
+    if (
+      // If the atom is mounted, we can use cached atom state,
+      // because it should have been updated by dependencies.
+      // We can't use the cache if the atom is invalidated.
+      mountedMap.has(atom2) && invalidatedAtoms.get(atom2) !== atomState.n || // If atom is not mounted, we can use cached atom state,
+      // only if store hasn't been mutated.
+      atomState.m === storeEpochNumber
+    )
+      return atomState.m = storeEpochNumber, atomState;
+    let hasChangedDeps = !1;
+    for (let [a, n] of atomState.d)
+      if (readAtomState(buildingBlocks, store2, a).n !== n) {
+        hasChangedDeps = !0;
+        break;
+      }
+    if (!hasChangedDeps)
+      return atomState.m = storeEpochNumber, atomState;
+  }
+  let isSync = !0, prevDeps = new Set(atomState.d.keys()), pruneDependencies = () => {
+    for (let a of prevDeps)
+      atomState.d.delete(a);
+  }, mountDependenciesIfAsync = () => {
+    if (mountedMap.has(atom2)) {
+      let shouldRecompute = !changedAtoms.size;
+      mountDependencies(buildingBlocks, store2, atom2), shouldRecompute && (recomputeInvalidatedAtoms(buildingBlocks, store2), flushCallbacks(buildingBlocks, store2));
+    }
+  }, getter = (a) => {
+    var _a2;
+    if (a === atom2) {
+      let aState2 = ensureAtomState(buildingBlocks, store2, a);
+      if (!isAtomStateInitialized(aState2))
+        if (hasInitialValue(a))
+          setAtomStateValueOrPromise(buildingBlocks, store2, a, a.init);
+        else
+          throw new Error("no atom init");
+      return returnAtomValue(aState2);
+    }
+    let aState = readAtomState(buildingBlocks, store2, a);
+    try {
+      return returnAtomValue(aState);
+    } finally {
+      prevDeps.delete(a), atomState.d.set(a, aState.n), isPromiseLike(atomState.v) && addPendingPromiseToDependency(atom2, atomState.v, aState), mountedMap.has(atom2) && ((_a2 = mountedMap.get(a)) == null || _a2.t.add(atom2)), isSync || mountDependenciesIfAsync();
+    }
+  }, controller, setSelf, options = {
+    get signal() {
+      return controller || (controller = new AbortController()), controller.signal;
+    },
+    get setSelf() {
+      return (import.meta.env ? import.meta.env.MODE : void 0) !== "production" && console.warn(
+        "[DEPRECATED] setSelf is deprecated and will be removed in v3."
+      ), (import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !isActuallyWritableAtom(atom2) && console.warn("setSelf function cannot be used with read-only atom"), !setSelf && isActuallyWritableAtom(atom2) && (setSelf = (...args) => {
+        if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && isSync && console.warn("setSelf function cannot be called in sync"), !isSync)
+          try {
+            return writeAtomState(buildingBlocks, store2, atom2, args);
+          } finally {
+            recomputeInvalidatedAtoms(buildingBlocks, store2), flushCallbacks(buildingBlocks, store2);
+          }
+      }), setSelf;
+    }
+  }, prevEpochNumber = atomState.n, prevInvalidated = invalidatedAtoms.get(atom2) === prevEpochNumber;
+  try {
+    (import.meta.env ? import.meta.env.MODE : void 0) !== "production" && storeMutationSet.delete(store2);
+    let valueOrPromise = atomRead(
+      buildingBlocks,
+      store2,
+      atom2,
+      getter,
+      options
+    );
+    if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && storeMutationSet.has(store2) && console.warn(
+      "Detected store mutation during atom read. This is not supported."
+    ), setAtomStateValueOrPromise(buildingBlocks, store2, atom2, valueOrPromise), isPromiseLike(valueOrPromise)) {
+      registerAbortHandler(
+        buildingBlocks,
+        store2,
+        valueOrPromise,
+        () => controller?.abort()
+      );
+      let settle = () => {
+        pruneDependencies(), mountDependenciesIfAsync();
+      };
+      valueOrPromise.then(settle, settle);
+    } else
+      pruneDependencies();
+    return (_a = storeHooks.r) == null || _a.call(storeHooks, atom2), atomState.m = storeEpochNumber, atomState;
+  } catch (error) {
+    if (shouldThrowSynchronously(error))
+      throw error;
+    return delete atomState.v, atomState.e = error, ++atomState.n, atomState.m = storeEpochNumber, atomState;
+  } finally {
+    isSync = !1, atomState.n !== prevEpochNumber && prevInvalidated && (invalidatedAtoms.set(atom2, atomState.n), changedAtoms.add(atom2), (_b = storeHooks.c) == null || _b.call(storeHooks, atom2));
+  }
+}, BUILDING_BLOCK_invalidateDependents = (buildingBlocks, store2, atom2) => {
+  let mountedMap = buildingBlocks[1], invalidatedAtoms = buildingBlocks[2], ensureAtomState = buildingBlocks[11], stack = [atom2];
+  for (; stack.length; ) {
+    let a = stack.pop(), aState = ensureAtomState(buildingBlocks, store2, a);
+    for (let d of getMountedOrPendingDependents(a, aState, mountedMap)) {
+      let dState = ensureAtomState(buildingBlocks, store2, d);
+      invalidatedAtoms.get(d) !== dState.n && (invalidatedAtoms.set(d, dState.n), stack.push(d));
+    }
+  }
+}, BUILDING_BLOCK_writeAtomState = (buildingBlocks, store2, atom2, args) => {
+  let changedAtoms = buildingBlocks[3], storeHooks = buildingBlocks[6], atomWrite = buildingBlocks[8], ensureAtomState = buildingBlocks[11], flushCallbacks = buildingBlocks[12], recomputeInvalidatedAtoms = buildingBlocks[13], readAtomState = buildingBlocks[14], invalidateDependents = buildingBlocks[15], writeAtomState = buildingBlocks[16], mountDependencies = buildingBlocks[17], setAtomStateValueOrPromise = buildingBlocks[20], storeEpochHolder = buildingBlocks[28], isSync = !0, getter = (a) => returnAtomValue(readAtomState(buildingBlocks, store2, a)), setter = (a, ...args2) => {
+    var _a;
+    let aState = ensureAtomState(buildingBlocks, store2, a);
+    try {
+      if (a === atom2) {
+        if (!hasInitialValue(a))
+          throw new Error("atom not writable");
+        (import.meta.env ? import.meta.env.MODE : void 0) !== "production" && storeMutationSet.add(store2);
+        let prevEpochNumber = aState.n, v = args2[0];
+        setAtomStateValueOrPromise(buildingBlocks, store2, a, v), mountDependencies(buildingBlocks, store2, a), prevEpochNumber !== aState.n && (++storeEpochHolder[0], changedAtoms.add(a), invalidateDependents(buildingBlocks, store2, a), (_a = storeHooks.c) == null || _a.call(storeHooks, a));
+        return;
+      } else
+        return writeAtomState(buildingBlocks, store2, a, args2);
+    } finally {
+      isSync || (recomputeInvalidatedAtoms(buildingBlocks, store2), flushCallbacks(buildingBlocks, store2));
+    }
+  };
+  try {
+    return atomWrite(buildingBlocks, store2, atom2, getter, setter, ...args);
+  } finally {
+    isSync = !1;
+  }
+}, BUILDING_BLOCK_mountDependencies = (buildingBlocks, store2, atom2) => {
+  var _a;
+  let mountedMap = buildingBlocks[1], changedAtoms = buildingBlocks[3], storeHooks = buildingBlocks[6], ensureAtomState = buildingBlocks[11], invalidateDependents = buildingBlocks[15], mountAtom = buildingBlocks[18], unmountAtom = buildingBlocks[19], atomState = ensureAtomState(buildingBlocks, store2, atom2), mounted = mountedMap.get(atom2);
+  if (mounted && atomState.d.size > 0) {
+    for (let [a, n] of atomState.d)
+      if (!mounted.d.has(a)) {
+        let aState = ensureAtomState(buildingBlocks, store2, a);
+        mountAtom(buildingBlocks, store2, a).t.add(atom2), mounted.d.add(a), n !== aState.n && (changedAtoms.add(a), invalidateDependents(buildingBlocks, store2, a), (_a = storeHooks.c) == null || _a.call(storeHooks, a));
+      }
+    for (let a of mounted.d)
+      if (!atomState.d.has(a)) {
+        mounted.d.delete(a);
+        let aMounted = unmountAtom(buildingBlocks, store2, a);
+        aMounted?.t.delete(atom2);
+      }
+  }
+}, BUILDING_BLOCK_mountAtom = (buildingBlocks, store2, atom2) => {
+  var _a;
+  let mountedMap = buildingBlocks[1], mountCallbacks = buildingBlocks[4], storeHooks = buildingBlocks[6], atomOnMount = buildingBlocks[10], ensureAtomState = buildingBlocks[11], flushCallbacks = buildingBlocks[12], recomputeInvalidatedAtoms = buildingBlocks[13], readAtomState = buildingBlocks[14], writeAtomState = buildingBlocks[16], mountAtom = buildingBlocks[18], atomState = ensureAtomState(buildingBlocks, store2, atom2), mounted = mountedMap.get(atom2);
+  if (!mounted) {
+    readAtomState(buildingBlocks, store2, atom2);
+    for (let a of atomState.d.keys())
+      mountAtom(buildingBlocks, store2, a).t.add(atom2);
+    if (mounted = {
+      l: /* @__PURE__ */ new Set(),
+      d: new Set(atomState.d.keys()),
+      t: /* @__PURE__ */ new Set()
+    }, mountedMap.set(atom2, mounted), isActuallyWritableAtom(atom2) && hasOnMount(atom2)) {
+      let processOnMount = () => {
+        let isSync = !0, setAtom = (...args) => {
+          try {
+            return writeAtomState(buildingBlocks, store2, atom2, args);
+          } finally {
+            isSync || (recomputeInvalidatedAtoms(buildingBlocks, store2), flushCallbacks(buildingBlocks, store2));
+          }
+        };
+        try {
+          let onUnmount = atomOnMount(buildingBlocks, store2, atom2, setAtom);
+          onUnmount && (mounted.u = () => {
+            isSync = !0;
+            try {
+              onUnmount();
+            } finally {
+              isSync = !1;
+            }
+          });
+        } finally {
+          isSync = !1;
+        }
+      };
+      mountCallbacks.add(processOnMount);
+    }
+    (_a = storeHooks.m) == null || _a.call(storeHooks, atom2);
+  }
+  return mounted;
+}, BUILDING_BLOCK_unmountAtom = (buildingBlocks, store2, atom2) => {
+  var _a, _b;
+  let mountedMap = buildingBlocks[1], unmountCallbacks = buildingBlocks[5], storeHooks = buildingBlocks[6], ensureAtomState = buildingBlocks[11], unmountAtom = buildingBlocks[19], atomState = ensureAtomState(buildingBlocks, store2, atom2), mounted = mountedMap.get(atom2);
+  if (!mounted || mounted.l.size)
+    return mounted;
+  let isDependent = !1;
+  for (let a of mounted.t)
+    if ((_a = mountedMap.get(a)) != null && _a.d.has(atom2)) {
+      isDependent = !0;
+      break;
+    }
+  if (!isDependent) {
+    mounted.u && unmountCallbacks.add(mounted.u), mounted = void 0, mountedMap.delete(atom2);
+    for (let a of atomState.d.keys()) {
+      let aMounted = unmountAtom(buildingBlocks, store2, a);
+      aMounted?.t.delete(atom2);
+    }
+    (_b = storeHooks.u) == null || _b.call(storeHooks, atom2);
+    return;
+  }
+  return mounted;
+}, BUILDING_BLOCK_setAtomStateValueOrPromise = (buildingBlocks, store2, atom2, valueOrPromise) => {
+  let ensureAtomState = buildingBlocks[11], abortPromise = buildingBlocks[27], atomState = ensureAtomState(buildingBlocks, store2, atom2), hasPrevValue = "v" in atomState, prevValue = atomState.v;
+  if (isPromiseLike(valueOrPromise))
+    for (let a of atomState.d.keys())
+      addPendingPromiseToDependency(
+        atom2,
+        valueOrPromise,
+        ensureAtomState(buildingBlocks, store2, a)
+      );
+  atomState.v = valueOrPromise, delete atomState.e, (!hasPrevValue || !Object.is(prevValue, atomState.v)) && (++atomState.n, isPromiseLike(prevValue) && abortPromise(buildingBlocks, store2, prevValue));
+}, BUILDING_BLOCK_storeGet = (buildingBlocks, store2, atom2) => {
+  let readAtomState = buildingBlocks[14];
+  return returnAtomValue(readAtomState(buildingBlocks, store2, atom2));
+}, BUILDING_BLOCK_storeSet = (buildingBlocks, store2, atom2, ...args) => {
+  let changedAtoms = buildingBlocks[3], flushCallbacks = buildingBlocks[12], recomputeInvalidatedAtoms = buildingBlocks[13], writeAtomState = buildingBlocks[16], prevChangedAtomsSize = changedAtoms.size;
+  try {
+    return writeAtomState(buildingBlocks, store2, atom2, args);
+  } finally {
+    changedAtoms.size !== prevChangedAtomsSize && (recomputeInvalidatedAtoms(buildingBlocks, store2), flushCallbacks(buildingBlocks, store2));
+  }
+}, BUILDING_BLOCK_storeSub = (buildingBlocks, store2, atom2, listener) => {
+  let flushCallbacks = buildingBlocks[12], recomputeInvalidatedAtoms = buildingBlocks[13], mountAtom = buildingBlocks[18], unmountAtom = buildingBlocks[19], listeners = mountAtom(buildingBlocks, store2, atom2).l;
+  return listeners.add(listener), recomputeInvalidatedAtoms(buildingBlocks, store2), flushCallbacks(buildingBlocks, store2), () => {
+    listeners.delete(listener), unmountAtom(buildingBlocks, store2, atom2), recomputeInvalidatedAtoms(buildingBlocks, store2), flushCallbacks(buildingBlocks, store2);
+  };
+}, BUILDING_BLOCK_registerAbortHandler = (buildingBlocks, _store, promise, abortHandler) => {
+  let abortHandlersMap = buildingBlocks[25], abortHandlers = abortHandlersMap.get(promise);
+  if (!abortHandlers) {
+    abortHandlers = /* @__PURE__ */ new Set(), abortHandlersMap.set(promise, abortHandlers);
+    let cleanup = () => abortHandlersMap.delete(promise);
+    promise.then(cleanup, cleanup);
+  }
+  abortHandlers.add(abortHandler);
+}, BUILDING_BLOCK_abortPromise = (buildingBlocks, _store, promise) => {
+  let abortHandlers = buildingBlocks[25].get(promise);
+  abortHandlers?.forEach((fn) => fn());
+}, buildingBlockMap = /* @__PURE__ */ new WeakMap();
+function getBuildingBlocks(store2) {
+  let buildingBlocks = buildingBlockMap.get(store2);
+  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !buildingBlocks)
+    throw new Error(
+      "Store must be created by buildStore to read its building blocks"
+    );
+  let enhanceBuildingBlocks = buildingBlocks[24];
+  return enhanceBuildingBlocks ? enhanceBuildingBlocks(buildingBlocks, store2) : buildingBlocks;
+}
+function buildStore(...partialBuildingBlocks) {
+  let store2 = {
+    get(atom2) {
+      return storeGet(buildingBlocks, store2, atom2);
+    },
+    set(atom2, ...args) {
+      return storeSet(buildingBlocks, store2, atom2, ...args);
+    },
+    sub(atom2, listener) {
+      return storeSub(buildingBlocks, store2, atom2, listener);
+    }
+  }, buildingBlocks = [
+    // store state
+    /* @__PURE__ */ new WeakMap(),
+    // atomStateMap
+    /* @__PURE__ */ new WeakMap(),
+    // mountedMap
+    /* @__PURE__ */ new WeakMap(),
+    // invalidatedAtoms
+    /* @__PURE__ */ new Set(),
+    // changedAtoms
+    /* @__PURE__ */ new Set(),
+    // mountCallbacks
+    /* @__PURE__ */ new Set(),
+    // unmountCallbacks
+    {},
+    // storeHooks
+    // atom interceptors
+    BUILDING_BLOCK_atomRead,
+    BUILDING_BLOCK_atomWrite,
+    BUILDING_BLOCK_atomOnInit,
+    BUILDING_BLOCK_atomOnMount,
+    // building-block functions
+    BUILDING_BLOCK_ensureAtomState,
+    BUILDING_BLOCK_flushCallbacks,
+    BUILDING_BLOCK_recomputeInvalidatedAtoms,
+    BUILDING_BLOCK_readAtomState,
+    BUILDING_BLOCK_invalidateDependents,
+    BUILDING_BLOCK_writeAtomState,
+    BUILDING_BLOCK_mountDependencies,
+    BUILDING_BLOCK_mountAtom,
+    BUILDING_BLOCK_unmountAtom,
+    BUILDING_BLOCK_setAtomStateValueOrPromise,
+    BUILDING_BLOCK_storeGet,
+    BUILDING_BLOCK_storeSet,
+    BUILDING_BLOCK_storeSub,
+    void 0,
+    // enhanceBuildingBlocks
+    // abortable promise support
+    /* @__PURE__ */ new WeakMap(),
+    // abortHandlersMap
+    BUILDING_BLOCK_registerAbortHandler,
+    BUILDING_BLOCK_abortPromise,
+    // store epoch
+    [0]
+  ].map((fn, i) => partialBuildingBlocks[i] || fn);
+  buildingBlockMap.set(store2, Object.freeze(buildingBlocks));
+  let storeGet = buildingBlocks[21], storeSet = buildingBlocks[22], storeSub = buildingBlocks[23];
+  return store2;
+}
+
+// ../../node_modules/jotai/esm/vanilla.mjs
+var keyCount = 0;
+function atom(read, write) {
+  let key = `atom${++keyCount}`, config = {
+    toString() {
+      return (import.meta.env ? import.meta.env.MODE : void 0) !== "production" && this.debugLabel ? key + ":" + this.debugLabel : key;
+    }
+  };
+  return typeof read == "function" ? config.read = read : (config.init = read, config.read = defaultRead, config.write = defaultWrite), write && (config.write = write), config;
+}
+function defaultRead(get) {
+  return get(this);
+}
+function defaultWrite(get, set, arg) {
+  return set(
+    this,
+    typeof arg == "function" ? arg(get(this)) : arg
+  );
+}
+var overriddenCreateStore;
+function createStore() {
+  return overriddenCreateStore ? overriddenCreateStore() : buildStore();
+}
+var defaultStore;
+function getDefaultStore() {
+  return defaultStore || (defaultStore = createStore(), (import.meta.env ? import.meta.env.MODE : void 0) !== "production" && (globalThis.__JOTAI_DEFAULT_STORE__ || (globalThis.__JOTAI_DEFAULT_STORE__ = defaultStore), globalThis.__JOTAI_DEFAULT_STORE__ !== defaultStore && console.warn(
+    "Detected multiple Jotai instances. It may cause unexpected behavior with the default store. https://github.com/pmndrs/jotai/discussions/2044"
+  ))), defaultStore;
+}
+
+// ../../node_modules/jotai/esm/react.mjs
+import React, { createContext, useContext, useRef, createElement, useReducer, useEffect, useDebugValue, useCallback } from "react";
+var StoreContext = createContext(
+  void 0
+);
+function useStore(options) {
+  let store2 = useContext(StoreContext);
+  return options?.store || store2 || getDefaultStore();
+}
+var isPromiseLike2 = (x) => typeof x?.then == "function", attachPromiseStatus = (promise) => {
+  promise.status || (promise.status = "pending", promise.then(
+    (v) => {
+      promise.status = "fulfilled", promise.value = v;
+    },
+    (e) => {
+      promise.status = "rejected", promise.reason = e;
+    }
+  ));
+}, use = React.use || // A shim for older React versions
+((promise) => {
+  if (promise.status === "pending")
+    throw promise;
+  if (promise.status === "fulfilled")
+    return promise.value;
+  throw promise.status === "rejected" ? promise.reason : (attachPromiseStatus(promise), promise);
+}), continuablePromiseMap = /* @__PURE__ */ new WeakMap(), createContinuablePromise = (store2, promise, getValue) => {
+  let buildingBlocks = getBuildingBlocks(store2), registerAbortHandler = buildingBlocks[26], continuablePromise = continuablePromiseMap.get(promise);
+  return continuablePromise || (continuablePromise = new Promise((resolve, reject) => {
+    let curr = promise, onFulfilled = (me) => (v) => {
+      curr === me && resolve(v);
+    }, onRejected = (me) => (e) => {
+      curr === me && reject(e);
+    }, onAbort = () => {
+      try {
+        let nextValue = getValue();
+        isPromiseLike2(nextValue) ? (continuablePromiseMap.set(nextValue, continuablePromise), curr = nextValue, nextValue.then(onFulfilled(nextValue), onRejected(nextValue)), registerAbortHandler(buildingBlocks, store2, nextValue, onAbort)) : resolve(nextValue);
+      } catch (e) {
+        reject(e);
+      }
+    };
+    promise.then(onFulfilled(promise), onRejected(promise)), registerAbortHandler(buildingBlocks, store2, promise, onAbort);
+  }), continuablePromiseMap.set(promise, continuablePromise)), continuablePromise;
+};
+function useAtomValue(atom2, options) {
+  let { delay, unstable_promiseStatus: promiseStatus = !React.use } = options || {}, store2 = useStore(options), [[valueFromReducer, storeFromReducer, atomFromReducer], rerender] = useReducer(
+    (prev) => {
+      let nextValue = store2.get(atom2);
+      return Object.is(prev[0], nextValue) && prev[1] === store2 && prev[2] === atom2 ? prev : [nextValue, store2, atom2];
+    },
+    void 0,
+    () => [store2.get(atom2), store2, atom2]
+  ), value = valueFromReducer;
+  if ((storeFromReducer !== store2 || atomFromReducer !== atom2) && (rerender(), value = store2.get(atom2)), useEffect(() => {
+    let unsub = store2.sub(atom2, () => {
+      if (promiseStatus)
+        try {
+          let value2 = store2.get(atom2);
+          isPromiseLike2(value2) && attachPromiseStatus(
+            createContinuablePromise(store2, value2, () => store2.get(atom2))
+          );
+        } catch {
+        }
+      if (typeof delay == "number") {
+        console.warn(`[DEPRECATED] delay option is deprecated and will be removed in v3.
+
+Migration guide:
+
+Create a custom hook like the following.
+
+function useAtomValueWithDelay<Value>(
+  atom: Atom<Value>,
+  options: { delay: number },
+): Value {
+  const { delay } = options
+  const store = useStore(options)
+  const [value, setValue] = useState(() => store.get(atom))
+  useEffect(() => {
+    const unsub = store.sub(atom, () => {
+      setTimeout(() => setValue(store.get(atom)), delay)
+    })
+    return unsub
+  }, [store, atom, delay])
+  return value
+}
+`), setTimeout(rerender, delay);
+        return;
+      }
+      rerender();
+    });
+    return rerender(), unsub;
+  }, [store2, atom2, delay, promiseStatus]), useDebugValue(value), isPromiseLike2(value)) {
+    let promise = createContinuablePromise(
+      store2,
+      value,
+      () => store2.get(atom2)
+    );
+    return promiseStatus && attachPromiseStatus(promise), use(promise);
+  }
+  return value;
+}
+function useSetAtom(atom2, options) {
+  let store2 = useStore(options);
+  return useCallback(
+    (...args) => {
+      if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !("write" in atom2))
+        throw new Error("not writable atom");
+      return store2.set(atom2, ...args);
+    },
+    [store2, atom2]
+  );
+}
+
+// src/react-native/hooks.tsx
+var store = createStore(), storyContextAtom = atom(null);
+function useSetStoryContext() {
+  return useSetAtom(storyContextAtom, { store });
+}
+function useStoryContext() {
+  return useAtomValue(storyContextAtom, { store });
+}
+
+// src/react-native/components/StoryView/ErrorBoundary.tsx
+import React2 from "react";
+import { View, Text } from "react-native";
+import { jsx } from "react/jsx-runtime";
+var ErrorBoundary = class extends React2.Component {
+  constructor(props) {
+    super(props), this.state = { hasError: !1 };
+  }
+  static getDerivedStateFromError(_error) {
+    return { hasError: !0 };
+  }
+  componentDidCatch(error, info) {
+    this.props.onError(error, info.componentStack);
+  }
+  render() {
+    return this.state.hasError ? jsx(
+      View,
+      {
+        style: {
+          margin: 16,
+          padding: 16,
+          borderColor: "red",
+          borderWidth: 2,
+          alignItems: "center",
+          justifyContent: "center",
+          borderRadius: 4
+        },
+        children: jsx(Text, { style: { fontWeight: "bold" }, children: "Something went wrong rendering your story" })
+      }
+    ) : this.props.children;
+  }
+};
+
+// src/react-native/components/StoryView/StoryView.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function dismissOnStartResponder() {
+  return Keyboard.dismiss(), !1;
+}
+var Text2 = styled.Text(({ theme: theme3 }) => ({
+  color: theme3?.color?.defaultText
+})), errorContainerStyle = {
+  flex: 1,
+  padding: 16,
+  alignItems: "center",
+  justifyContent: "center"
+}, layoutStyles = {
+  padded: { padding: 8 },
+  centered: { alignItems: "center", justifyContent: "center" },
+  fullscreen: {}
+}, StoryView = ({
+  useWrapper = !0,
+  storyBackgroundColor
+}) => {
+  let context = useStoryContext(), id = context?.id, theme3 = useTheme(), containerStyle = useMemo(() => {
+    let layout = context?.parameters?.layout, layoutStyle = typeof layout == "string" && layout in layoutStyles ? layoutStyles[layout] : {};
+    return {
+      flex: 1,
+      backgroundColor: storyBackgroundColor || theme3.background?.content,
+      overflow: "hidden",
+      ...layoutStyle
+    };
+  }, [theme3.background?.content, context?.parameters?.layout, storyBackgroundColor]), onError = useCallback2(() => {
+    console.log(`Error rendering story for ${context?.title} ${context?.name}`);
+  }, [context?.title, context?.name]);
+  if (context && context.unboundStoryFn) {
+    let { unboundStoryFn: StoryComponent } = context;
+    return useWrapper ? jsx2(
+      View2,
+      {
+        style: containerStyle,
+        testID: id,
+        accessibilityLabel: id,
+        importantForAccessibility: "no",
+        onStartShouldSetResponder: dismissOnStartResponder,
+        children: jsx2(ErrorBoundary, { onError, children: StoryComponent && jsx2(StoryComponent, { ...context }) })
+      },
+      id
+    ) : jsx2(ErrorBoundary, { onError, children: StoryComponent && jsx2(StoryComponent, { ...context }) });
+  }
+  return jsx2(View2, { style: errorContainerStyle, children: jsx2(Text2, { children: "Please select a story to preview." }) });
+}, StoryView_default = React3.memo(StoryView);
+
+// src/react-native/constants.ts
+var RN_STORYBOOK_STORAGE_KEY = "lastOpenedStory", RN_STORYBOOK_EVENTS = {
+  RN_GET_INDEX: "RN_GET_INDEX",
+  RN_GET_INDEX_RESPONSE: "RN_GET_INDEX_RESPONSE"
+}, STORYBOOK_STORY_ID_PARAM = "STORYBOOK_STORY_ID";
+
+// src/react-native/View.tsx
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+function resolveStoryBackgroundColor(story) {
+  let backgroundGlobal = story?.globals?.backgrounds?.value, bgParams = story?.parameters?.backgrounds, backgroundName = backgroundGlobal;
+  if (backgroundName) {
+    if (bgParams?.options?.[backgroundName]?.value)
+      return bgParams.options[backgroundName].value;
+    if (backgroundName.startsWith("#")) return backgroundName;
+  }
+}
+var View3 = class {
+  constructor(preview, channel, options) {
+    this._setStory = () => {
+    };
+    this._forceRerender = () => {
+    };
+    this._ready = !1;
+    this._asyncStorageStoryId = null;
+    this._idToPrepared = {};
+    this._storyIdExists = (storyId) => Object.keys(this._storyIndex.entries).includes(storyId);
+    this._selectInitialStory = async ({
+      selectionSpecifier,
+      storyIdFromUrl
+    }) => {
+      this._preview.selectionStore.selectionSpecifier = storyIdFromUrl ? { storySpecifier: storyIdFromUrl, viewMode: "story" } : selectionSpecifier, this._preview.selectionStore.selection = void 0, await this._preview.selectSpecifiedStory();
+    };
+    this._getInitialStory = async ({
+      initialSelection,
+      shouldPersistSelection = !0
+    } = {}) => {
+      if (initialSelection)
+        return typeof initialSelection == "string" ? { storySpecifier: initialSelection, viewMode: "story" } : {
+          storySpecifier: toId(initialSelection.kind, initialSelection.name),
+          viewMode: "story"
+        };
+      if (shouldPersistSelection)
+        try {
+          let value = this._asyncStorageStoryId;
+          return !value && this._storage != null && (value = await this._storage.getItem(RN_STORYBOOK_STORAGE_KEY), value || (await new Promise((resolve) => setTimeout(resolve, 100)), value = await this._storage.getItem(RN_STORYBOOK_STORAGE_KEY)), this._asyncStorageStoryId = value), { storySpecifier: (value && this._storyIdExists(value) ? value : void 0) ?? "*", viewMode: "story" };
+        } catch (e) {
+          console.warn("storybook-log: error reading from async storage", e);
+        }
+      return { storySpecifier: "*", viewMode: "story" };
+    };
+    this._getHost = (params = {}) => params.host ? params.host : globalThis.STORYBOOK_WEBSOCKET?.host ? globalThis.STORYBOOK_WEBSOCKET.host : Platform.OS === "android" ? "10.0.2.2" : "localhost";
+    this.__getPort = (params = {}) => params.port ? params.port : globalThis.STORYBOOK_WEBSOCKET?.port ? globalThis.STORYBOOK_WEBSOCKET.port : 7007;
+    this._isSecureConnection = (params = {}) => typeof params.secured == "boolean" ? params.secured : globalThis.STORYBOOK_WEBSOCKET?.secured ?? !1;
+    this._getServerChannel = (params = {}) => {
+      let host = this._getHost(params), port = `:${this.__getPort(params)}`, query = params.query || "", url = `${this._isSecureConnection(params) ? "wss" : "ws"}://${host}${port}/${query}`, channel = new Channel({
+        async: !0,
+        transport: new WebsocketTransport({
+          url,
+          onError: (e) => {
+            console.log(`WebsocketTransport error ${JSON.stringify(e)}`);
+          }
+        })
+      });
+      return patchChannelForRN(channel), channel;
+    };
+    this.createPreparedStoryMapping = async () => {
+      await this._preview.ready().then(
+        () => Promise.all(
+          Object.keys(this._storyIndex.entries).map(async (storyId) => {
+            this._idToPrepared[storyId] = await this._preview.loadStory({ storyId });
+          })
+        )
+      );
+    };
+    this.getStorybookUI = (params = {}) => {
+      let {
+        enableWebsockets = !!globalThis.STORYBOOK_WEBSOCKET,
+        CustomUIComponent,
+        hasStoryWrapper: storyViewWrapper = !0
+      } = params, storage = params.storage ?? {
+        getItem: async (key) => null,
+        setItem: async (key, value) => {
+        }
+      }, onDeviceUI = this._options?.disableUI ? !1 : params.onDeviceUI ?? !0, shouldPersistSelection = this._options.disableUI ? !1 : params.shouldPersistSelection ?? !0, FullUI = ((enabled) => enabled && DeviceUI ? DeviceUI : ({ children }) => children)(onDeviceUI && !CustomUIComponent);
+      if (this._storage = storage ?? {
+        getItem: async (key) => null,
+        setItem: async (key, value) => {
+        }
+      }, enableWebsockets) {
+        let channel = this._getServerChannel(params);
+        managerAddons.setChannel(channel), previewAddons.setChannel(channel), this._channel = channel, this._preview.channel = channel, this._preview.setupListeners(), channel.emit(CHANNEL_CREATED), this._preview.ready().then(() => this._preview.onStoryIndexChanged());
+      }
+      this._channel.on(RN_STORYBOOK_EVENTS.RN_GET_INDEX, () => {
+        this._channel.emit(RN_STORYBOOK_EVENTS.RN_GET_INDEX_RESPONSE, { index: this._storyIndex });
+      }), managerAddons.loadAddons({
+        store: () => ({
+          fromId: (id) => {
+            if (!this._ready)
+              throw new Error("Storybook is not ready yet");
+            return this._preview.getStoryContext(this._idToPrepared[id]);
+          },
+          getSelection: () => this._preview.currentSelection,
+          _channel: this._channel
+        })
+      });
+      let self2 = this;
+      return () => {
+        let setContext = useSetStoryContext(), story = useStoryContext(), colorScheme = useColorScheme(), [update, forceUpdate] = useReducer2((x) => x + 1, 0), [ready, setReady] = useState(!1), appliedTheme = useMemo2(
+          () => (0, import_deepmerge.default)(colorScheme === "dark" ? darkTheme : theme, params.theme ?? {}),
+          [colorScheme]
+        );
+        useEffect2(() => {
+          let listener = Linking.addEventListener("url", ({ url }) => {
+            if (typeof url == "string") {
+              let storyId = new URL(url).searchParams.get(STORYBOOK_STORY_ID_PARAM), hasStoryId = storyId && typeof storyId == "string", storyExists = hasStoryId && self2._storyIdExists(storyId);
+              storyExists && self2._ready && (console.log(`STORYBOOK: Linking event received, navigating to story: ${storyId}`), self2._channel.emit(SET_CURRENT_STORY, { storyId })), hasStoryId && !storyExists && console.log(
+                `STORYBOOK: Linking event received, but story does not exist: ${storyId}`
+              );
+            }
+          });
+          return () => {
+            listener.remove();
+          };
+        }, []), useEffect2(() => {
+          self2.createPreparedStoryMapping().then(
+            () => Linking.getInitialURL().then((url) => {
+              if (url && typeof url == "string") {
+                let storyId = new URL(url).searchParams.get(STORYBOOK_STORY_ID_PARAM), hasStoryId = typeof storyId == "string", storyExists = hasStoryId && self2._storyIdExists(storyId);
+                if (hasStoryId && !storyExists && console.log(
+                  `STORYBOOK: Initial Linking event received, but story does not exist: ${storyId}`
+                ), storyExists)
+                  return storyId;
+              }
+              return null;
+            })
+          ).then(
+            (initialStoryIdFromUrl) => self2._getInitialStory(params).then((st) => (initialStoryIdFromUrl && console.log(
+              `STORYBOOK: Setting initial story from Linking event, storyId: ${initialStoryIdFromUrl}`
+            ), self2._selectInitialStory({
+              selectionSpecifier: st,
+              storyIdFromUrl: initialStoryIdFromUrl
+            })))
+          ).then(() => {
+            let currentStoryId = self2._preview.currentSelection?.storyId, preparedStory = currentStoryId ? self2._idToPrepared[currentStoryId] : void 0;
+            preparedStory && setContext(
+              self2._preview.getStoryContext(
+                preparedStory
+              )
+            ), self2._ready = !0, setReady(!0);
+          }).catch((e) => console.error(e)), self2._setStory = (newStory) => {
+            if (setContext(newStory), shouldPersistSelection && !params.storage && console.warn(dedent`Please set storage in getStorybookUI like this:
+              const StorybookUIRoot = view.getStorybookUI({
+                storage: {
+                  getItem: AsyncStorage.getItem,
+                  setItem: AsyncStorage.setItem,
+                },
+              });
+            `), shouldPersistSelection && self2._storage && self2._ready)
+              try {
+                self2._asyncStorageStoryId = newStory.id;
+                let ret = self2._storage.setItem(RN_STORYBOOK_STORAGE_KEY, newStory.id);
+                ret && typeof ret.then == "function" && ret.catch((e) => {
+                  console.warn("storybook-log: error writing to async storage", e);
+                });
+              } catch (e) {
+                console.warn("storybook-log: error writing to async storage", e);
+              }
+          }, self2._forceRerender = () => forceUpdate();
+        }, []);
+        let storyHash = useMemo2(() => ready ? transformStoryIndexToStoriesHash(self2._storyIndex, {
+          docsOptions: { docsMode: !1, defaultName: "" },
+          filters: {},
+          allStatuses: {},
+          provider: {
+            handleAPI: () => ({}),
+            getConfig: () => ({})
+          }
+        }) : {}, [ready, update]);
+        if (!ready)
+          return jsx3(
+            RNView,
+            {
+              style: {
+                position: "absolute",
+                top: 0,
+                left: 0,
+                right: 0,
+                bottom: 0,
+                alignItems: "center",
+                justifyContent: "center"
+              },
+              children: jsx3(ActivityIndicator, { animating: !0, size: "large" })
+            }
+          );
+        let storyBackgroundColor = globalThis.FEATURES?.ondeviceBackgrounds ? resolveStoryBackgroundColor(story) : void 0;
+        return onDeviceUI ? CustomUIComponent ? jsx3(
+          CustomUIComponent,
+          {
+            story,
+            storyHash,
+            setStory: (newStoryId) => self2._channel.emit(SET_CURRENT_STORY, { storyId: newStoryId }),
+            storage,
+            theme: appliedTheme,
+            storyBackgroundColor,
+            children: jsx3(
+              StoryView_default,
+              {
+                useWrapper: storyViewWrapper,
+                storyBackgroundColor
+              }
+            )
+          }
+        ) : jsx3(
+          FullUI,
+          {
+            storage,
+            theme: appliedTheme,
+            storyHash,
+            story,
+            setStory: (newStoryId) => self2._channel.emit(SET_CURRENT_STORY, { storyId: newStoryId }),
+            storyBackgroundColor,
+            children: jsx3(StoryView_default, { useWrapper: storyViewWrapper, storyBackgroundColor })
+          }
+        ) : jsxs(SafeAreaProvider, { children: [
+          jsx3(StatusBar, { hidden: !0 }),
+          jsx3(
+            WithSafeArea,
+            {
+              id: story?.id ?? "",
+              safeAreaEnabled: !(story?.parameters?.noSafeArea ?? !1),
+              children: jsx3(
+                StoryView_default,
+                {
+                  useWrapper: storyViewWrapper,
+                  storyBackgroundColor
+                }
+              )
+            }
+          )
+        ] });
+      };
+    };
+    this._preview = preview, this._channel = channel, this._options = options ?? {};
+  }
+}, WithSafeArea = ({
+  children,
+  id,
+  safeAreaEnabled
+}) => {
+  let insets = useSafeAreaInsets();
+  return jsx3(
+    RNView,
+    {
+      style: {
+        flex: 1,
+        paddingTop: safeAreaEnabled ? insets.top : 0,
+        paddingBottom: safeAreaEnabled ? insets.bottom : 0
+      },
+      accessibilityLabel: id,
+      testID: id,
+      accessible: !0,
+      children
+    }
+  );
+};
+
+// src/react-native/prepareStories.ts
+import {
+  sortStoriesV7,
+  userOrAutoTitleFromSpecifier
+} from "@aussieljk/forkbook/internal/preview-api";
+import { isExportStory, storyNameFromExport, toId as toId2 } from "@aussieljk/forkbook/internal/csf";
+function prepareStories({
+  storyEntries,
+  options,
+  storySort
+}) {
+  let index = {
+    v: 5,
+    entries: {}
+  }, importMap = {}, makeTitle = (fileName, specifier, userTitle) => {
+    let title = userOrAutoTitleFromSpecifier(fileName, specifier, userTitle);
+    if (title)
+      return title.replace("./", "");
+    throw console.log({
+      fileName,
+      userTitle,
+      storyEntries: storyEntries.map((entry) => ({ ...entry, importPathMatcher: entry.importPathMatcher.source })),
+      title: title ?? ""
+    }), new Error("Could not generate title");
+  };
+  storyEntries.forEach((specifier) => {
+    let { req, directory: root } = specifier;
+    req.keys().forEach((filename) => {
+      try {
+        let fileExports = req(filename);
+        if (!fileExports.default) return;
+        let meta = fileExports.default;
+        Object.keys(fileExports).forEach((key) => {
+          if (key === "default" || !isExportStory(key, fileExports.default)) return;
+          let exportValue = fileExports[key];
+          if (!exportValue) return;
+          let title = makeTitle(filename, specifier, meta.title);
+          if (title) {
+            let nameFromExport = storyNameFromExport(key), id = toId2(title, nameFromExport), name = nameFromExport;
+            typeof exportValue == "function" ? name = exportValue?.storyName || nameFromExport : name = exportValue?.name || exportValue?.storyName || nameFromExport, index.entries[id] = {
+              type: "story",
+              id,
+              name,
+              title,
+              importPath: `${root}/${filename.substring(2)}`,
+              // FIXME: use normalize function here
+              tags: ["story"],
+              subtype: "story"
+            };
+            let importedStories = req(filename), stories = Object.entries(importedStories).reduce((carry, [storyKey, story]) => (isExportStory(storyKey, fileExports.default) && (story.play && !options?.playFn ? carry[storyKey] = { ...story, play: void 0 } : carry[storyKey] = story), carry), {});
+            importMap[`${root}/${filename.substring(2)}`] = stories;
+          } else
+            console.log(`Unexpected error while loading ${filename}: could not find title`);
+        });
+      } catch (error) {
+        let typedError = error, errorString = typedError.message && typedError.stack ? `${typedError.message}
+ ${typedError.stack}` : typedError.toString();
+        console.error(`Unexpected error while loading ${filename}: ${errorString}`);
+      }
+    });
+  });
+  let sortableStories = Object.values(index.entries);
+  return sortStoriesV7(
+    sortableStories,
+    storySort,
+    Object.values(index.entries).map((entry) => entry.importPath)
+  ), { index: { v: 5, entries: sortableStories.reduce(
+    (acc, item) => (acc[item.id] = item, acc),
+    {}
+  ) }, importMap };
+}
+
+// src/react-native/backgrounds/register.tsx
+import { addons, types } from "@aussieljk/forkbook/manager-api";
+
+// src/react-native/backgrounds/BackgroundPanel.tsx
+import { View as View4 } from "react-native";
+import { useCallback as useCallback3 } from "react";
+import { UPDATE_GLOBALS } from "@aussieljk/forkbook/internal/core-events";
+import { styled as styled3 } from "@aussieljk/forkbook/internal/react-native-theming";
+
+// src/react-native/backgrounds/Swatch.tsx
+import { styled as styled2 } from "@aussieljk/forkbook/internal/react-native-theming";
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+var PressableSwatch = styled2.TouchableOpacity(({ theme: theme3 }) => ({
+  marginBottom: 10,
+  borderWidth: 1,
+  borderColor: theme3.appBorderColor,
+  borderRadius: 6,
+  backgroundColor: theme3.background.content,
+  paddingVertical: 4,
+  paddingHorizontal: 4
+})), ColorSwatch = styled2.View(({ color, theme: theme3 }) => ({
+  height: 40,
+  width: "100%",
+  borderRadius: 4,
+  backgroundColor: color,
+  borderColor: theme3.appBorderColor,
+  borderWidth: 1
+})), ValueContainer = styled2.View(() => ({
+  flex: 1,
+  flexDirection: "row",
+  justifyContent: "space-between",
+  padding: 4,
+  paddingBottom: 0
+})), NameText = styled2.Text(({ theme: theme3 }) => ({
+  fontSize: theme3.typography.size.s2,
+  color: theme3.color.defaultText,
+  fontWeight: theme3.typography.weight.bold
+})), ValueText = styled2.Text(({ theme: theme3 }) => ({
+  fontSize: theme3.typography.size.s2,
+  color: theme3.color.defaultText
+})), Swatch = ({ name, value, setBackground, disabled }) => jsxs2(
+  PressableSwatch,
+  {
+    onPress: () => setBackground(value),
+    disabled,
+    style: { opacity: disabled ? 0.5 : 1 },
+    children: [
+      jsx4(ColorSwatch, { color: value }),
+      jsxs2(ValueContainer, { children: [
+        jsx4(NameText, { children: name }),
+        jsx4(ValueText, { children: value })
+      ] })
+    ]
+  }
+), Swatch_default = Swatch;
+
+// src/react-native/backgrounds/constants.ts
+var PARAM_KEY = "backgrounds", ADDON_ID = "storybook-addon-background", PANEL_ID = `${ADDON_ID}/background-panel`;
+
+// src/react-native/backgrounds/BackgroundPanel.tsx
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+var codeSample = `
+// In your preview config (.storybook/preview.tsx):
+import type { Preview } from '@aussieljk/forkbook/react-native';
+
+const preview: Preview = {
+  parameters: {
+    backgrounds: {
+      options: {
+        dark: { name: 'Dark', value: '#333333' },
+        light: { name: 'Light', value: '#F7F9F2' },
+        maroon: { name: 'Maroon', value: '#400000' },
+      },
+    },
+  },
+  initialGlobals: {
+    backgrounds: { value: 'light' },
+  },
+};
+
+export default preview;
+`.trim(), ThemedText = styled3.Text(({ theme: theme3 }) => ({
+  color: theme3.color.defaultText
+})), TitleText = styled3.Text(({ theme: theme3 }) => ({
+  color: theme3.color.defaultText,
+  fontSize: 16,
+  marginBottom: 8
+})), ParagraphText = styled3.Text(({ theme: theme3 }) => ({
+  color: theme3.color.defaultText,
+  marginBottom: 8
+})), LockedText = styled3.Text(({ theme: theme3 }) => ({
+  color: theme3.color.defaultText,
+  marginBottom: 10,
+  fontStyle: "italic",
+  opacity: 0.7
+})), Instructions = () => jsxs3(View4, { children: [
+  jsx5(TitleText, { children: "Setup Instructions" }),
+  jsx5(ParagraphText, { children: "Add background options to your preview parameters. Each option should include a name and the corresponding color value." }),
+  jsx5(ParagraphText, { children: "Below is an example of how to configure backgrounds in your preview config. Long press the example to copy it." }),
+  jsx5(ThemedText, { selectable: !0, children: codeSample })
+] }), BackgroundPanel = ({ active, api, channel }) => {
+  let store2 = api.store(), storyId = store2.getSelection()?.storyId, story = storyId ? store2.fromId(storyId) : null, isLocked = !!story?.storyGlobals?.[PARAM_KEY], setBackground = useCallback3(
+    (name) => {
+      channel.emit(UPDATE_GLOBALS, { globals: { [PARAM_KEY]: { value: name } } });
+    },
+    [channel]
+  ), options = story?.parameters?.[PARAM_KEY]?.options;
+  return options && Object.keys(options).length > 0 ? jsxs3(View4, { style: { padding: 10 }, children: [
+    isLocked && jsx5(LockedText, { children: "Background is set at the story level" }),
+    Object.entries(options).map(([key, { name, value }]) => jsx5(View4, { children: jsx5(
+      Swatch_default,
+      {
+        value,
+        name: name || key,
+        setBackground: () => setBackground(key),
+        disabled: isLocked
+      }
+    ) }, `${key} ${value}`))
+  ] }) : jsx5(View4, { style: { padding: 10 }, children: jsx5(Instructions, {}) });
+}, BackgroundPanel_default = BackgroundPanel;
+
+// src/react-native/backgrounds/register.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+function registerBackgroundsAddon() {
+  addons.register(ADDON_ID, (api) => {
+    let channel = addons.getChannel();
+    addons.add(PANEL_ID, {
+      type: types.PANEL,
+      title: "Backgrounds",
+      render: ({ active }) => jsx6(BackgroundPanel_default, { channel, api, active }),
+      paramKey: PARAM_KEY
+    });
+  });
+}
+
+// src/react-native/Start.tsx
+import { Fragment, jsx as jsx7 } from "react/jsx-runtime";
+var createPreviewRoot = () => ({
+  component: () => jsx7(Fragment, {}),
+  canvasElement: null,
+  mount: () => Promise.resolve({}),
+  storyResult: null,
+  T: null
+}), getReactNativeProjectAnnotations = (getView) => ({
+  renderToCanvas: (context) => {
+    getView()?._setStory(context.storyContext);
+  },
+  render: (args, context) => {
+    let { id, component: Component } = context;
+    if (!Component)
+      throw new Error(
+        `Unable to render story ${id} as the component annotation is missing from the default export`
+      );
+    return jsx7(Component, { ...args });
+  }
+});
+globalThis.FEATURES = Object.assign(globalThis.FEATURES ?? {}, {
+  measure: !1,
+  outline: !1,
+  interactions: !1,
+  viewport: !1,
+  highlight: !1,
+  backgrounds: !1
+});
+var ReactNativePreview = class extends PreviewWithSelection2 {
+  constructor() {
+    super(...arguments);
+    this.renderSelectionQueue = Promise.resolve();
+  }
+  renderSelection(options) {
+    let run = this.renderSelectionQueue.then(() => super.renderSelection(options));
+    return this.renderSelectionQueue = run.catch(() => {
+    }), run;
+  }
+  // Storybook tears down a story that is still rendering (e.g. its loaders are running) by waiting briefly and then
+  // reloading the page, which restarts the app in Expo and never resolves elsewhere in React Native. Abort the render
+  // instead: once its loaders finish it sees the abort and doesn't draw.
+  async teardownRender(...[render, options]) {
+    if (render && "isPending" in render && render.isPending()) {
+      this.storyRenders = this.storyRenders.filter((r) => r !== render), render.torndown = !0, render.cancelRender(), render.story && await this.storyStoreValue?.cleanupStory(render.story);
+      return;
+    }
+    await super.teardownRender(render, options);
+  }
+}, getProjectAnnotations = (view, annotations) => async () => composeConfigs([getReactNativeProjectAnnotations(() => view), ...annotations]);
+function start({
+  annotations,
+  storyEntries,
+  options
+}) {
+  let composedAnnotations = composeConfigs(annotations), { index, importMap } = prepareStories({
+    storyEntries,
+    options,
+    storySort: composedAnnotations.parameters?.options?.storySort
+  }), channel = new Channel2({});
+  managerAddons2.setChannel(channel), previewAddons2.setChannel(channel), globalThis.FEATURES?.ondeviceBackgrounds && registerBackgroundsAddon();
+  let previewView = {
+    prepareForStory: () => createPreviewRoot(),
+    prepareForDocs: () => createPreviewRoot(),
+    showErrorDisplay: (e) => {
+      console.log(e);
+    },
+    showDocs: () => {
+    },
+    showMain: () => {
+    },
+    showNoPreview: () => {
+    },
+    showPreparingDocs: () => {
+    },
+    showPreparingStory: () => {
+    },
+    showStory: () => {
+    },
+    showStoryDuringRender: () => {
+    }
+  }, selectionStore = {
+    selection: null,
+    selectionSpecifier: null,
+    setQueryParams: () => {
+    },
+    setSelection: (selection) => {
+      preview.selectionStore.selection = selection;
+    }
+  }, view, getProjectAnnotationsInitial = async () => composeConfigs([getReactNativeProjectAnnotations(() => view), ...annotations]), preview = new ReactNativePreview(
+    async (importPath) => importMap[importPath],
+    getProjectAnnotationsInitial,
+    selectionStore,
+    previewView
+  );
+  if (view = new View3(preview, channel, options), global) {
+    let storybookGlobal = global;
+    storybookGlobal.__STORYBOOK_ADDONS_CHANNEL__ = channel, storybookGlobal.__STORYBOOK_PREVIEW__ = preview;
+  }
+  return view._storyIndex = index, preview.getStoryIndexFromServer = async () => view._storyIndex, view;
+}
+function updateView(viewInstance, annotations, normalizedStories, options) {
+  let storySort = composeConfigs(annotations).parameters?.options?.storySort, { importMap, index } = prepareStories({
+    storyEntries: normalizedStories,
+    options,
+    storySort
+  });
+  viewInstance._preview.onStoryHotUpdated(), viewInstance._preview.onStoriesChanged({
+    importFn: async (importPath) => importMap[importPath]
+  }), viewInstance._preview.onGetProjectAnnotationsChanged({
+    getProjectAnnotations: getProjectAnnotations(viewInstance, annotations)
+  }), viewInstance._storyIndex = index, viewInstance._preview.onStoryIndexChanged().then(() => {
+    viewInstance.createPreparedStoryMapping().then(() => viewInstance._forceRerender());
+  });
+}
+export {
+  RN_STORYBOOK_EVENTS,
+  RN_STORYBOOK_STORAGE_KEY,
+  STORYBOOK_STORY_ID_PARAM,
+  darkTheme2 as darkTheme,
+  getProjectAnnotations,
+  prepareStories,
+  start,
+  theme2 as theme,
+  updateView
+};