rnxsim 0.1.507 → 0.1.508

package/dist-lib/swift.cjs

@@ -0,0 +1,507 @@
+/*! rnx v0.1.508 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/swift.ts
+var swift_exports = {};
+__export(swift_exports, {
+  createSwiftModule: () => createSwiftModule
+});
+module.exports = __toCommonJS(swift_exports);
+
+// ../sootsim-swift/src/mount.tsx
+var import_swift_ui = require("@expo/ui/swift-ui");
+var import_react = require("react");
+var import_react_native = require("react-native");
+var import_jsx_runtime = require("react/jsx-runtime");
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readModifier(value) {
+  if (!isRecord(value) || typeof value.$type !== "string") {
+    throw new Error("swift modifier is not a { $type } object");
+  }
+  return { ...value, $type: value.$type };
+}
+function readNode(value) {
+  if (!isRecord(value)) throw new Error("swift node is not an object");
+  const { t, id, p, m, c, h } = value;
+  if (typeof t !== "string" || typeof id !== "string") {
+    throw new Error("swift node has no type or identity");
+  }
+  const node = { t, id };
+  if (p !== void 0) {
+    if (!isRecord(p)) throw new Error(`swift node ${id} has a non-object props`);
+    node.p = p;
+  }
+  if (m !== void 0) {
+    if (!Array.isArray(m)) throw new Error(`swift node ${id} has a non-array modifiers`);
+    node.m = m.map(readModifier);
+  }
+  if (c !== void 0) {
+    if (!Array.isArray(c)) throw new Error(`swift node ${id} has non-array children`);
+    node.c = c.map(readNode);
+  }
+  if (h !== void 0) {
+    if (!isRecord(h)) throw new Error(`swift node ${id} has non-object handlers`);
+    const handlers = {};
+    for (const [name, handlerId2] of Object.entries(h)) {
+      if (typeof handlerId2 !== "number") {
+        throw new Error(`swift node ${id} handler ${name} is not a number`);
+      }
+      handlers[name] = handlerId2;
+    }
+    node.h = handlers;
+  }
+  return node;
+}
+function readTree(text) {
+  const value = JSON.parse(text);
+  if (!Array.isArray(value)) throw new Error("swift tree is not an array");
+  return value.map(readNode);
+}
+var WASI_BADF = 8;
+function wasiImports(host) {
+  return {
+    args_get: () => 0,
+    args_sizes_get: (argcPtr, argvSizePtr) => {
+      host.writeU32(argcPtr, 0);
+      host.writeU32(argvSizePtr, 0);
+      return 0;
+    },
+    environ_get: () => 0,
+    environ_sizes_get: (countPtr, sizePtr) => {
+      host.writeU32(countPtr, 0);
+      host.writeU32(sizePtr, 0);
+      return 0;
+    },
+    fd_close: () => WASI_BADF,
+    fd_fdstat_get: () => WASI_BADF,
+    fd_prestat_get: () => WASI_BADF,
+    fd_prestat_dir_name: () => WASI_BADF,
+    fd_read: () => WASI_BADF,
+    fd_seek: () => WASI_BADF,
+    fd_write: (_fd, iovsPtr, iovsLen, writtenPtr) => {
+      const view = new DataView(host.bytes().buffer);
+      let written = 0;
+      for (let index = 0; index < iovsLen; index += 1) {
+        written += view.getUint32(iovsPtr + index * 8 + 4, true);
+      }
+      host.writeU32(writtenPtr, written);
+      return 0;
+    },
+    path_open: () => WASI_BADF,
+    proc_exit: (code) => {
+      throw new Error(`swift app exited with code ${code}`);
+    },
+    random_get: (bufferPtr, length) => {
+      crypto.getRandomValues(host.bytes().subarray(bufferPtr, bufferPtr + length));
+      return 0;
+    }
+  };
+}
+function rawExport(exports2, name) {
+  const value = exports2[name];
+  if (typeof value !== "function") {
+    throw new Error(`swift artifact has no exported function ${name}`);
+  }
+  return value;
+}
+function pointerExport(exports2, name) {
+  const fn = rawExport(exports2, name);
+  return (...args) => {
+    const result = Reflect.apply(fn, void 0, args);
+    if (typeof result !== "number") {
+      throw new Error(`swift export ${name} returned ${typeof result}`);
+    }
+    return result;
+  };
+}
+function voidExport(exports2, name) {
+  const fn = rawExport(exports2, name);
+  return (...args) => {
+    Reflect.apply(fn, void 0, args);
+  };
+}
+function instantiate(module2) {
+  let memory;
+  const requireMemory = () => {
+    if (!memory) throw new Error("swift artifact memory is not live");
+    return memory;
+  };
+  const host = {
+    writeU32(ptr, value) {
+      new DataView(requireMemory().buffer).setUint32(ptr, value, true);
+    },
+    bytes: () => new Uint8Array(requireMemory().buffer)
+  };
+  const instance = new WebAssembly.Instance(module2, {
+    wasi_snapshot_preview1: wasiImports(host)
+  });
+  const exportedMemory = instance.exports.memory;
+  if (!(exportedMemory instanceof WebAssembly.Memory)) {
+    throw new Error("swift artifact does not export its memory");
+  }
+  memory = exportedMemory;
+  const initialize = voidExport(instance.exports, "_initialize");
+  const mainArgv = voidExport(instance.exports, "__main_argc_argv");
+  const mount = pointerExport(instance.exports, "rnx_mount");
+  const event = pointerExport(instance.exports, "rnx_event");
+  const stateExport = pointerExport(instance.exports, "rnx_state_export");
+  const stateImport = voidExport(instance.exports, "rnx_state_import");
+  const alloc = pointerExport(instance.exports, "rnx_alloc");
+  const free = voidExport(instance.exports, "rnx_free");
+  const readBuffer = (ptr) => {
+    const view = new DataView(requireMemory().buffer);
+    const length = view.getUint32(ptr, true);
+    return new TextDecoder().decode(
+      new Uint8Array(requireMemory().buffer, ptr + 4, length)
+    );
+  };
+  const withPayload = (value, run) => {
+    const encoded = new TextEncoder().encode(JSON.stringify(value));
+    const ptr = alloc(encoded.length);
+    new Uint8Array(requireMemory().buffer).set(encoded, ptr);
+    const result = run(ptr, encoded.length);
+    free(ptr);
+    return result;
+  };
+  initialize();
+  mainArgv(0, 0);
+  return {
+    mount: () => readTree(readBuffer(mount())),
+    deliver: (handlerId2, payload) => readTree(
+      readBuffer(
+        withPayload(
+          payload,
+          (ptr, length) => (
+            // handler ids are opaque to the tenant: they come from the tree
+            // this instance just returned and they are only meaningful to it
+            event(handlerId2, ptr, length)
+          )
+        )
+      )
+    ),
+    exportState: () => readBuffer(stateExport()),
+    importState: (state) => {
+      withPayload(JSON.parse(state), (ptr, length) => {
+        stateImport(ptr, length);
+        return 0;
+      });
+    }
+  };
+}
+var compiledModules = /* @__PURE__ */ new Map();
+function compile(url) {
+  const cached = compiledModules.get(url);
+  if (cached) return cached;
+  const pending = fetch(url).then((response) => {
+    if (!response.ok) {
+      throw new Error(`swift artifact ${url} answered ${response.status}`);
+    }
+    return response.arrayBuffer();
+  }).then((bytes) => WebAssembly.compile(bytes));
+  compiledModules.set(url, pending);
+  return pending;
+}
+var HIERARCHICAL = /* @__PURE__ */ new Map([
+  ["label", "primary"],
+  ["secondaryLabel", "secondary"]
+]);
+function withAlpha(color, alpha) {
+  const hex = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(color);
+  if (hex) {
+    const digits = hex[1];
+    const full = digits.length === 3 ? digits.split("").map((digit) => digit + digit).join("") : digits;
+    const value = Number.parseInt(full, 16);
+    return `rgba(${value >> 16 & 255},${value >> 8 & 255},${value & 255},${alpha})`;
+  }
+  const rgba = /^rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*([\d.]+)\s*\)$/.exec(color);
+  if (rgba) {
+    return `rgba(${rgba[1]},${rgba[2]},${rgba[3]},${Number(rgba[4]) * alpha})`;
+  }
+  throw new Error(`swift color ${color} cannot take opacity ${alpha}`);
+}
+function splitColor(value) {
+  const at = value.lastIndexOf("@");
+  return at === -1 ? { name: value, alpha: 1 } : { name: value.slice(0, at), alpha: Number(value.slice(at + 1)) };
+}
+function resolveColor(value) {
+  const { name, alpha } = splitColor(value);
+  const resolved = (0, import_react_native.PlatformColor)(name);
+  if (alpha === 1) return resolved;
+  if (typeof resolved === "string") return withAlpha(resolved, alpha);
+  if (isRecord(resolved) && isRecord(resolved.dynamic)) {
+    const variants = {};
+    for (const [scheme, variant] of Object.entries(resolved.dynamic)) {
+      if (typeof variant !== "string") {
+        throw new Error(`swift color ${name} has a non-string ${scheme} variant`);
+      }
+      variants[scheme] = withAlpha(variant, alpha);
+    }
+    return { dynamic: variants };
+  }
+  throw new Error(`swift color ${name} cannot take opacity ${alpha}`);
+}
+function resolveModifier(modifier) {
+  const color = modifier.color;
+  if (typeof color !== "string") {
+    const glass = modifier.glass;
+    if (modifier.$type === "glassEffect" && isRecord(glass) && typeof glass.tint === "string") {
+      return { ...modifier, glass: { ...glass, tint: resolveColor(glass.tint) } };
+    }
+    return modifier;
+  }
+  const { name, alpha } = splitColor(color);
+  const level = modifier.$type === "foregroundStyle" ? HIERARCHICAL.get(name) : void 0;
+  if (level !== void 0 && alpha === 1) {
+    return {
+      $type: "foregroundStyle",
+      styleType: "hierarchical",
+      hierarchicalStyle: level
+    };
+  }
+  return { ...modifier, color: resolveColor(color) };
+}
+var NODE_COMPONENTS = {
+  Button: import_swift_ui.Button,
+  Capsule: import_swift_ui.Capsule,
+  Circle: import_swift_ui.Circle,
+  Divider: import_swift_ui.Divider,
+  Form: import_swift_ui.Form,
+  Group: import_swift_ui.Group,
+  HStack: import_swift_ui.HStack,
+  Image: import_swift_ui.Image,
+  List: import_swift_ui.List,
+  Rectangle: import_swift_ui.Rectangle,
+  RoundedRectangle: import_swift_ui.RoundedRectangle,
+  ScrollView: import_swift_ui.ScrollView,
+  Section: import_swift_ui.Section,
+  Slider: import_swift_ui.Slider,
+  Spacer: import_swift_ui.Spacer,
+  Text: import_swift_ui.Text,
+  TextField: import_swift_ui.TextField,
+  Toggle: import_swift_ui.Toggle,
+  VStack: import_swift_ui.VStack,
+  ZStack: import_swift_ui.ZStack
+};
+var TEXT_STYLE_SIZES = /* @__PURE__ */ new Map([
+  ["largeTitle", 34],
+  ["title", 28],
+  ["title2", 22],
+  ["title3", 20],
+  ["headline", 17],
+  ["subheadline", 15],
+  ["body", 17],
+  ["callout", 16],
+  ["footnote", 13],
+  ["caption", 12],
+  ["caption2", 11]
+]);
+var FONT_WEIGHTS = /* @__PURE__ */ new Map([
+  ["ultraLight", "100"],
+  ["thin", "200"],
+  ["light", "300"],
+  ["regular", "400"],
+  ["medium", "500"],
+  ["semibold", "600"],
+  ["bold", "700"],
+  ["heavy", "800"],
+  ["black", "900"]
+]);
+function fontModifier(modifiers) {
+  return modifiers?.find((modifier) => modifier.$type === "font");
+}
+function fontStyle(font) {
+  if (!font) return void 0;
+  const style = {};
+  if (typeof font.size === "number") style.fontSize = font.size;
+  else if (typeof font.style === "string") {
+    const size = TEXT_STYLE_SIZES.get(font.style);
+    if (size === void 0) throw new Error(`swift font style ${font.style} has no size`);
+    style.fontSize = size;
+  }
+  if (typeof font.weight === "string") {
+    const weight = FONT_WEIGHTS.get(font.weight);
+    if (weight === void 0)
+      throw new Error(`swift font weight ${font.weight} has no value`);
+    style.fontWeight = weight;
+  }
+  return style;
+}
+function handlerId(node, name) {
+  return node.h?.[name];
+}
+function nodeProps(node, deliver) {
+  const props = node.p ?? {};
+  switch (node.t) {
+    case "Text": {
+      const style = fontStyle(fontModifier(node.m));
+      return {
+        children: typeof props.children === "string" ? props.children : "",
+        ...style ? { style } : {}
+      };
+    }
+    case "Image": {
+      const font = fontModifier(node.m);
+      const size = typeof font?.size === "number" ? font.size : void 0;
+      return {
+        ...typeof props.systemName === "string" ? { systemName: props.systemName } : {},
+        ...size === void 0 ? {} : { size }
+      };
+    }
+    case "Toggle": {
+      const onValueChange = handlerId(node, "onValueChange");
+      return {
+        isOn: props.value === true,
+        ...onValueChange === void 0 ? {} : { onIsOnChange: (value) => deliver(onValueChange, value) }
+      };
+    }
+    case "TextField": {
+      const onChangeText = handlerId(node, "onChangeText");
+      return {
+        ...typeof props.placeholder === "string" ? { placeholder: props.placeholder } : {},
+        ...typeof props.defaultValue === "string" ? { defaultValue: props.defaultValue } : {},
+        ...onChangeText === void 0 ? {} : { onChangeText: (value) => deliver(onChangeText, value) }
+      };
+    }
+    case "Slider": {
+      const onValueChange = handlerId(node, "onValueChange");
+      return {
+        value: typeof props.value === "number" ? props.value : 0,
+        min: typeof props.min === "number" ? props.min : 0,
+        max: typeof props.max === "number" ? props.max : 1,
+        ...onValueChange === void 0 ? {} : { onValueChange: (value) => deliver(onValueChange, value) }
+      };
+    }
+    case "Button": {
+      const onPress = handlerId(node, "onPress");
+      return onPress === void 0 ? {} : { onPress: () => deliver(onPress, null) };
+    }
+    default:
+      return props;
+  }
+}
+function buttonModifier(modifier) {
+  if (modifier.$type === "glassEffect") {
+    const glass = modifier.glass;
+    const variant = isRecord(glass) && typeof glass.variant === "string" ? glass.variant : "regular";
+    return variant === "identity" ? modifier : { $type: "buttonStyle", style: "glass" };
+  }
+  if (modifier.$type === "foregroundStyle" && modifier.color !== void 0) {
+    return { $type: "tint", color: modifier.color };
+  }
+  return modifier;
+}
+function nodeModifiers(node) {
+  const resolved = node.m?.map(resolveModifier);
+  if (node.t !== "Button") return resolved;
+  return resolved?.map(buttonModifier);
+}
+function renderNode(node, deliver) {
+  const component = NODE_COMPONENTS[node.t];
+  if (!component) throw new Error(`swift view ${node.t} has no rnx kit component`);
+  const modifiers = nodeModifiers(node);
+  const children = node.c?.map((child) => renderNode(child, deliver));
+  return (0, import_react.createElement)(
+    component,
+    {
+      key: node.id,
+      ...modifiers === void 0 ? {} : { modifiers },
+      ...nodeProps(node, deliver)
+    },
+    ...children ?? []
+  );
+}
+var ROOT_KEY = "__rnx_swift_roots__";
+function rootRegistry() {
+  const existing = Reflect.get(globalThis, ROOT_KEY);
+  if (existing instanceof Map) return existing;
+  const created = /* @__PURE__ */ new Map();
+  Reflect.set(globalThis, ROOT_KEY, created);
+  return created;
+}
+function createRoot() {
+  let instance = null;
+  let source = null;
+  let state = { tree: null, error: null };
+  let swap = Promise.resolve();
+  const listeners = /* @__PURE__ */ new Set();
+  const publish = (next) => {
+    state = next;
+    for (const listener of listeners) listener();
+  };
+  const apply = async (options) => {
+    const carried = instance?.exportState() ?? null;
+    const created = instantiate(await compile(options.url));
+    if (carried !== null) created.importState(carried);
+    if (source !== options) return;
+    instance = created;
+    publish({ tree: created.mount(), error: null });
+  };
+  const component = function SwiftRoot() {
+    const rendered = (0, import_react.useSyncExternalStore)(
+      (listener) => {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+      () => state
+    );
+    if (rendered.error) throw rendered.error;
+    if (!rendered.tree) return null;
+    const deliver = (handlerId2, payload) => {
+      if (!instance) throw new Error("swift app received an event before it mounted");
+      publish({ tree: instance.deliver(handlerId2, payload), error: null });
+    };
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_swift_ui.Host, { style: { flex: 1 }, children: rendered.tree.map((node) => renderNode(node, deliver)) });
+  };
+  return {
+    component,
+    use(options) {
+      const changed = source === null || source.hash !== options.hash || source.url !== options.url;
+      if (changed) {
+        source = options;
+        swap = swap.then(
+          () => apply(options),
+          () => apply(options)
+        );
+        swap.catch((error) => {
+          publish({
+            tree: null,
+            error: error instanceof Error ? error : new Error(String(error))
+          });
+        });
+      }
+      return component;
+    }
+  };
+}
+function createSwiftModule(options) {
+  const rootId = options.rootId ?? "root";
+  const registry = rootRegistry();
+  const existing = registry.get(rootId);
+  const root = existing ?? createRoot();
+  if (!existing) registry.set(rootId, root);
+  return root.use(options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSwiftModule
+});