@thelacanians/vue-native-runtime 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1847 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  NativeBridge: () => NativeBridge,
+  VActionSheet: () => VActionSheet,
+  VActivityIndicator: () => VActivityIndicator,
+  VAlertDialog: () => VAlertDialog,
+  VButton: () => VButton,
+  VImage: () => VImage,
+  VInput: () => VInput,
+  VKeyboardAvoiding: () => VKeyboardAvoiding,
+  VList: () => VList,
+  VModal: () => VModal,
+  VPicker: () => VPicker,
+  VProgressBar: () => VProgressBar,
+  VSafeArea: () => VSafeArea,
+  VScrollView: () => VScrollView,
+  VSegmentedControl: () => VSegmentedControl,
+  VSlider: () => VSlider,
+  VStatusBar: () => VStatusBar,
+  VSwitch: () => VSwitch,
+  VText: () => VText,
+  VView: () => VView,
+  VWebView: () => VWebView,
+  createApp: () => createApp,
+  createCommentNode: () => createCommentNode,
+  createNativeNode: () => createNativeNode,
+  createStyleSheet: () => createStyleSheet,
+  createTextNode: () => createTextNode,
+  render: () => render,
+  resetNodeId: () => resetNodeId,
+  useAnimation: () => useAnimation,
+  useAppState: () => useAppState,
+  useAsyncStorage: () => useAsyncStorage,
+  useBackHandler: () => useBackHandler,
+  useBiometry: () => useBiometry,
+  useCamera: () => useCamera,
+  useClipboard: () => useClipboard,
+  useColorScheme: () => useColorScheme,
+  useDeviceInfo: () => useDeviceInfo,
+  useGeolocation: () => useGeolocation,
+  useHaptics: () => useHaptics,
+  useHttp: () => useHttp,
+  useKeyboard: () => useKeyboard,
+  useLinking: () => useLinking,
+  useNetwork: () => useNetwork,
+  useNotifications: () => useNotifications,
+  usePermissions: () => usePermissions,
+  useShare: () => useShare,
+  vShow: () => vShow,
+  validStyleProperties: () => validStyleProperties
+});
+module.exports = __toCommonJS(index_exports);
+var import_runtime_core32 = require("@vue/runtime-core");
+
+// src/renderer.ts
+var import_runtime_core = require("@vue/runtime-core");
+
+// src/node.ts
+var import_reactivity = require("@vue/reactivity");
+var nextNodeId = 1;
+var MAX_NODE_ID = 2147483647;
+function resetNodeId() {
+  nextNodeId = 1;
+}
+function getNextNodeId() {
+  const id = nextNodeId;
+  if (nextNodeId >= MAX_NODE_ID) {
+    nextNodeId = 1;
+  } else {
+    nextNodeId++;
+  }
+  return id;
+}
+function createNativeNode(type) {
+  const node = {
+    id: getNextNodeId(),
+    type,
+    props: {},
+    children: [],
+    parent: null,
+    isText: false
+  };
+  return (0, import_reactivity.markRaw)(node);
+}
+function createTextNode(text) {
+  const node = {
+    id: getNextNodeId(),
+    type: "__TEXT__",
+    props: {},
+    children: [],
+    parent: null,
+    isText: true,
+    text
+  };
+  return (0, import_reactivity.markRaw)(node);
+}
+function createCommentNode(text) {
+  const node = {
+    id: getNextNodeId(),
+    type: "__COMMENT__",
+    props: {},
+    children: [],
+    parent: null,
+    isText: false
+  };
+  return (0, import_reactivity.markRaw)(node);
+}
+
+// src/bridge.ts
+var NativeBridgeImpl = class {
+  constructor() {
+    /** Pending operations waiting to be flushed to native */
+    this.pendingOps = [];
+    /** Whether a microtask flush has been scheduled */
+    this.flushScheduled = false;
+    /** Event handler registry: "nodeId:eventName" -> callback */
+    this.eventHandlers = /* @__PURE__ */ new Map();
+    /** Pending async callbacks from native module invocations */
+    this.pendingCallbacks = /* @__PURE__ */ new Map();
+    /** Auto-incrementing callback ID for async native module calls */
+    this.nextCallbackId = 1;
+    /** Global event listeners: eventName -> Set of callbacks */
+    this.globalEventHandlers = /* @__PURE__ */ new Map();
+  }
+  // ---------------------------------------------------------------------------
+  // Operation batching
+  // ---------------------------------------------------------------------------
+  /**
+   * Enqueue an operation to be sent to the native side.
+   * If this is the first operation in the current microtask cycle,
+   * schedule a flush via queueMicrotask.
+   */
+  enqueue(op, args) {
+    this.pendingOps.push({ op, args });
+    if (!this.flushScheduled) {
+      this.flushScheduled = true;
+      queueMicrotask(() => this.flush());
+    }
+  }
+  /**
+   * Flush all pending operations to the native side by calling
+   * __VN_flushOperations with the JSON-serialized operation array.
+   */
+  flush() {
+    this.flushScheduled = false;
+    if (this.pendingOps.length === 0) return;
+    const ops = this.pendingOps;
+    this.pendingOps = [];
+    const json = JSON.stringify(ops);
+    const flushFn = globalThis.__VN_flushOperations;
+    if (typeof flushFn === "function") {
+      flushFn(json);
+    } else if (__DEV__) {
+      console.warn(
+        "[VueNative] __VN_flushOperations is not registered. Make sure the Swift runtime has been initialized."
+      );
+    }
+  }
+  /**
+   * Force an immediate synchronous flush. Used for testing and for
+   * critical operations that must be committed before the next microtask.
+   */
+  flushSync() {
+    this.flush();
+  }
+  /**
+   * Return the number of pending operations. Useful for testing.
+   */
+  getPendingCount() {
+    return this.pendingOps.length;
+  }
+  // ---------------------------------------------------------------------------
+  // Node lifecycle operations
+  //
+  // Operation names match the Swift NativeBridge.processOperations() switch:
+  //   "create", "createText", "setText", "setElementText"
+  // ---------------------------------------------------------------------------
+  /**
+   * Tell native to create a new view node.
+   * Swift handler: handleCreate(args: [nodeId, type])
+   */
+  createNode(nodeId, type) {
+    this.enqueue("create", [nodeId, type]);
+  }
+  /**
+   * Tell native to create a text node.
+   * Swift handler: handleCreateText(args: [nodeId, text])
+   */
+  createTextNode(nodeId, text) {
+    this.enqueue("createText", [nodeId, text]);
+  }
+  /**
+   * Update the text content of a text node.
+   * Swift handler: handleSetText(args: [nodeId, text])
+   */
+  setText(nodeId, text) {
+    this.enqueue("setText", [nodeId, text]);
+  }
+  /**
+   * Set the text content of an element node (replaces all children with text).
+   * Swift handler: handleSetElementText(args: [nodeId, text])
+   */
+  setElementText(nodeId, text) {
+    this.enqueue("setElementText", [nodeId, text]);
+  }
+  // ---------------------------------------------------------------------------
+  // Property / style updates
+  // ---------------------------------------------------------------------------
+  /**
+   * Update a single property on a native view.
+   * Swift handler: handleUpdateProp(args: [nodeId, key, value])
+   */
+  updateProp(nodeId, key, value) {
+    this.enqueue("updateProp", [nodeId, key, value]);
+  }
+  /**
+   * Update a single style property on a native view.
+   * Swift handler: handleUpdateStyle(args: [nodeId, { key: value }])
+   *
+   * Each style property update is sent as a dictionary with one key,
+   * matching the Swift side which iterates over the dictionary entries.
+   */
+  updateStyle(nodeId, key, value) {
+    this.enqueue("updateStyle", [nodeId, { [key]: value }]);
+  }
+  // ---------------------------------------------------------------------------
+  // Tree mutations
+  // ---------------------------------------------------------------------------
+  /**
+   * Append a child node to a parent node.
+   * Swift handler: handleAppendChild(args: [parentId, childId])
+   */
+  appendChild(parentId, childId) {
+    this.enqueue("appendChild", [parentId, childId]);
+  }
+  /**
+   * Insert a child node before a reference node within a parent.
+   * Swift handler: handleInsertBefore(args: [parentId, childId, beforeId])
+   */
+  insertBefore(parentId, childId, anchorId) {
+    this.enqueue("insertBefore", [parentId, childId, anchorId]);
+  }
+  /**
+   * Remove a child node from its parent.
+   * Swift handler: handleRemoveChild(args: [childId])
+   * Note: Swift only needs the childId since it calls removeFromSuperview().
+   */
+  removeChild(_parentId, childId) {
+    this.enqueue("removeChild", [childId]);
+  }
+  // ---------------------------------------------------------------------------
+  // Event handling
+  // ---------------------------------------------------------------------------
+  /**
+   * Register an event listener for a node.
+   * The native side will call __VN_handleEvent when this event fires.
+   * Swift handler: handleAddEventListener(args: [nodeId, eventName])
+   */
+  addEventListener(nodeId, eventName, callback) {
+    const key = `${nodeId}:${eventName}`;
+    this.eventHandlers.set(key, callback);
+    this.enqueue("addEventListener", [nodeId, eventName]);
+  }
+  /**
+   * Remove a previously registered event listener.
+   * Swift handler: handleRemoveEventListener(args: [nodeId, eventName])
+   */
+  removeEventListener(nodeId, eventName) {
+    const key = `${nodeId}:${eventName}`;
+    this.eventHandlers.delete(key);
+    this.enqueue("removeEventListener", [nodeId, eventName]);
+  }
+  /**
+   * Called from Swift via globalThis.__VN_handleEvent when a native event fires.
+   * Looks up the registered handler and invokes it with the event payload.
+   */
+  handleNativeEvent(nodeId, eventName, payload) {
+    const key = `${nodeId}:${eventName}`;
+    const handler = this.eventHandlers.get(key);
+    if (handler) {
+      try {
+        handler(payload);
+      } catch (err) {
+        console.error(`[VueNative] Error in event handler "${eventName}" on node ${nodeId}:`, err);
+      }
+    } else if (__DEV__) {
+      console.warn(
+        `[VueNative] No handler registered for event "${eventName}" on node ${nodeId}`
+      );
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Root view
+  // ---------------------------------------------------------------------------
+  /**
+   * Tell native which node ID is the root of the view tree.
+   * Swift handler: handleSetRootView(args: [nodeId])
+   */
+  setRootView(nodeId) {
+    this.enqueue("setRootView", [nodeId]);
+  }
+  // ---------------------------------------------------------------------------
+  // Native module invocation
+  // ---------------------------------------------------------------------------
+  /**
+   * Invoke a native module method asynchronously. Returns a Promise that
+   * resolves when Swift/Kotlin calls __VN_resolveCallback with the matching callbackId.
+   *
+   * A 30-second timeout is applied. If the native side never responds (e.g. due to
+   * a crash or unregistered module), the Promise rejects with a clear error instead
+   * of hanging forever.
+   */
+  invokeNativeModule(moduleName, methodName, args = [], timeoutMs = 3e4) {
+    return new Promise((resolve, reject) => {
+      const callbackId = this.nextCallbackId++;
+      const timeoutId = setTimeout(() => {
+        if (this.pendingCallbacks.has(callbackId)) {
+          this.pendingCallbacks.delete(callbackId);
+          reject(new Error(
+            `[VueNative] Native module ${moduleName}.${methodName} timed out after ${timeoutMs}ms`
+          ));
+        }
+      }, timeoutMs);
+      this.pendingCallbacks.set(callbackId, { resolve, reject, timeoutId });
+      this.enqueue("invokeNativeModule", [moduleName, methodName, args, callbackId]);
+    });
+  }
+  /**
+   * Invoke a native module method synchronously.
+   * This sends the operation immediately and expects no callback.
+   * Use sparingly -- prefer the async variant.
+   */
+  invokeNativeModuleSync(moduleName, methodName, args = []) {
+    this.enqueue("invokeNativeModuleSync", [moduleName, methodName, args]);
+  }
+  /**
+   * Called from Swift via globalThis.__VN_resolveCallback when an async
+   * native module invocation completes.
+   */
+  resolveCallback(callbackId, result, error) {
+    const pending = this.pendingCallbacks.get(callbackId);
+    if (!pending) {
+      if (__DEV__) {
+        console.warn(
+          `[VueNative] Received callback for unknown callbackId: ${callbackId}`
+        );
+      }
+      return;
+    }
+    clearTimeout(pending.timeoutId);
+    this.pendingCallbacks.delete(callbackId);
+    if (error != null) {
+      pending.reject(typeof error === "string" ? new Error(error) : error);
+    } else {
+      pending.resolve(result);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Global push events
+  // ---------------------------------------------------------------------------
+  /**
+   * Register a handler for a push-based global event from native.
+   * Returns an unsubscribe function.
+   */
+  onGlobalEvent(eventName, handler) {
+    if (!this.globalEventHandlers.has(eventName)) {
+      this.globalEventHandlers.set(eventName, /* @__PURE__ */ new Set());
+    }
+    this.globalEventHandlers.get(eventName).add(handler);
+    return () => {
+      this.globalEventHandlers.get(eventName)?.delete(handler);
+    };
+  }
+  /**
+   * Called from Swift via globalThis.__VN_handleGlobalEvent when a push event fires.
+   */
+  handleGlobalEvent(eventName, payloadJSON) {
+    let payload;
+    try {
+      payload = JSON.parse(payloadJSON);
+    } catch {
+      payload = {};
+    }
+    const handlers = this.globalEventHandlers.get(eventName);
+    if (handlers) {
+      handlers.forEach((h21) => {
+        try {
+          h21(payload);
+        } catch (err) {
+          console.error(`[VueNative] Error in global event handler "${eventName}":`, err);
+        }
+      });
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Cleanup
+  // ---------------------------------------------------------------------------
+  /**
+   * Reset all internal state. Used for testing.
+   */
+  reset() {
+    this.pendingOps = [];
+    this.flushScheduled = false;
+    this.eventHandlers.clear();
+    this.pendingCallbacks.clear();
+    this.nextCallbackId = 1;
+    this.globalEventHandlers.clear();
+  }
+};
+if (typeof globalThis.__DEV__ === "undefined") {
+  ;
+  globalThis.__DEV__ = true;
+}
+var NativeBridge = new NativeBridgeImpl();
+globalThis.__VN_handleEvent = NativeBridge.handleNativeEvent.bind(NativeBridge);
+globalThis.__VN_resolveCallback = NativeBridge.resolveCallback.bind(NativeBridge);
+globalThis.__VN_handleGlobalEvent = NativeBridge.handleGlobalEvent.bind(NativeBridge);
+globalThis.__VN_teardown = () => {
+  NativeBridge.reset();
+  resetNodeId();
+};
+
+// src/renderer.ts
+function toEventName(key) {
+  return key.slice(2).toLowerCase();
+}
+function patchStyle(nodeId, prevStyle, nextStyle) {
+  const prev = prevStyle || {};
+  const next = nextStyle || {};
+  for (const key in next) {
+    if (next[key] !== prev[key]) {
+      NativeBridge.updateStyle(nodeId, key, next[key]);
+    }
+  }
+  for (const key in prev) {
+    if (!(key in next)) {
+      NativeBridge.updateStyle(nodeId, key, null);
+    }
+  }
+}
+var nodeOps = {
+  /**
+   * Create a native element node.
+   */
+  createElement(type) {
+    const node = createNativeNode(type);
+    NativeBridge.createNode(node.id, type);
+    return node;
+  },
+  /**
+   * Create a text node containing raw text content.
+   */
+  createText(text) {
+    const node = createTextNode(text);
+    NativeBridge.createTextNode(node.id, text);
+    return node;
+  },
+  /**
+   * Create a comment node. Comments are invisible placeholders used by Vue
+   * for anchoring conditional and list rendering. We create a JS-side node
+   * but do NOT send it to native — comments have no visual representation.
+   */
+  createComment(text) {
+    return createCommentNode(text);
+  },
+  /**
+   * Update the text content of a text node.
+   */
+  setText(node, text) {
+    node.text = text;
+    NativeBridge.setText(node.id, text);
+  },
+  /**
+   * Set the text content of an element, replacing all its children.
+   */
+  setElementText(node, text) {
+    for (const child of node.children) {
+      child.parent = null;
+    }
+    node.children = [];
+    NativeBridge.setElementText(node.id, text);
+  },
+  /**
+   * Patch a single prop on an element. Routes to the appropriate bridge
+   * method based on the prop key:
+   * - "on*" keys -> event listener management
+   * - "style"  -> style diffing
+   * - all else -> updateProp
+   */
+  patchProp(el, key, prevValue, nextValue) {
+    if (key.startsWith("on") && key.length > 2 && key[2] === key[2].toUpperCase()) {
+      const eventName = toEventName(key);
+      if (prevValue) {
+        NativeBridge.removeEventListener(el.id, eventName);
+      }
+      if (nextValue) {
+        NativeBridge.addEventListener(el.id, eventName, nextValue);
+      }
+      return;
+    }
+    if (key === "style") {
+      patchStyle(el.id, prevValue, nextValue);
+      return;
+    }
+    el.props[key] = nextValue;
+    NativeBridge.updateProp(el.id, key, nextValue);
+  },
+  /**
+   * Insert a child node into a parent, optionally before an anchor node.
+   * Manages both the JS-side tree structure and the native-side tree.
+   */
+  insert(child, parent, anchor) {
+    if (child.parent) {
+      const oldParent = child.parent;
+      const idx = oldParent.children.indexOf(child);
+      if (idx !== -1) {
+        oldParent.children.splice(idx, 1);
+      }
+    }
+    child.parent = parent;
+    if (anchor) {
+      const anchorIdx = parent.children.indexOf(anchor);
+      if (anchorIdx !== -1) {
+        parent.children.splice(anchorIdx, 0, child);
+      } else {
+        parent.children.push(child);
+      }
+      if (child.type !== "__COMMENT__") {
+        if (anchor.type !== "__COMMENT__") {
+          NativeBridge.insertBefore(parent.id, child.id, anchor.id);
+        } else {
+          const realAnchor = findNextNonComment(parent, anchor);
+          if (realAnchor) {
+            NativeBridge.insertBefore(parent.id, child.id, realAnchor.id);
+          } else {
+            NativeBridge.appendChild(parent.id, child.id);
+          }
+        }
+      }
+    } else {
+      parent.children.push(child);
+      if (child.type !== "__COMMENT__") {
+        NativeBridge.appendChild(parent.id, child.id);
+      }
+    }
+  },
+  /**
+   * Remove a child from the tree.
+   */
+  remove(child) {
+    const parent = child.parent;
+    if (parent) {
+      const idx = parent.children.indexOf(child);
+      if (idx !== -1) {
+        parent.children.splice(idx, 1);
+      }
+      child.parent = null;
+      if (child.type !== "__COMMENT__") {
+        NativeBridge.removeChild(parent.id, child.id);
+      }
+    }
+  },
+  /**
+   * Return the parent of a node.
+   */
+  parentNode(node) {
+    return node.parent;
+  },
+  /**
+   * Return the next sibling of a node in the parent's children array.
+   */
+  nextSibling(node) {
+    const parent = node.parent;
+    if (!parent) return null;
+    const idx = parent.children.indexOf(node);
+    if (idx === -1 || idx >= parent.children.length - 1) return null;
+    return parent.children[idx + 1];
+  }
+};
+function findNextNonComment(parent, anchor) {
+  const idx = parent.children.indexOf(anchor);
+  if (idx === -1) return null;
+  for (let i = idx + 1; i < parent.children.length; i++) {
+    if (parent.children[i].type !== "__COMMENT__") {
+      return parent.children[i];
+    }
+  }
+  return null;
+}
+var { render, createApp: baseCreateApp } = (0, import_runtime_core.createRenderer)(nodeOps);
+
+// src/components/VView.ts
+var import_runtime_core2 = require("@vue/runtime-core");
+var VView = (0, import_runtime_core2.defineComponent)({
+  name: "VView",
+  props: {
+    style: Object,
+    testID: String,
+    accessibilityLabel: String
+  },
+  setup(props, { slots }) {
+    return () => (0, import_runtime_core2.h)("VView", { ...props }, slots.default?.());
+  }
+});
+
+// src/components/VText.ts
+var import_runtime_core3 = require("@vue/runtime-core");
+var VText = (0, import_runtime_core3.defineComponent)({
+  name: "VText",
+  props: {
+    style: Object,
+    numberOfLines: Number,
+    selectable: {
+      type: Boolean,
+      default: false
+    },
+    accessibilityRole: String
+  },
+  setup(props, { slots }) {
+    return () => (0, import_runtime_core3.h)("VText", { ...props }, slots.default?.());
+  }
+});
+
+// src/components/VButton.ts
+var import_runtime_core4 = require("@vue/runtime-core");
+var VButton = (0, import_runtime_core4.defineComponent)({
+  name: "VButton",
+  props: {
+    style: Object,
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    activeOpacity: {
+      type: Number,
+      default: 0.7
+    },
+    onPress: Function,
+    onLongPress: Function
+  },
+  setup(props, { slots }) {
+    return () => (0, import_runtime_core4.h)(
+      "VButton",
+      {
+        ...props,
+        onPress: props.disabled ? void 0 : props.onPress,
+        onLongPress: props.disabled ? void 0 : props.onLongPress
+      },
+      slots.default?.()
+    );
+  }
+});
+
+// src/components/VInput.ts
+var import_runtime_core5 = require("@vue/runtime-core");
+var VInput = (0, import_runtime_core5.defineComponent)({
+  name: "VInput",
+  props: {
+    modelValue: {
+      type: String,
+      default: ""
+    },
+    placeholder: String,
+    secureTextEntry: {
+      type: Boolean,
+      default: false
+    },
+    keyboardType: {
+      type: String,
+      default: "default"
+    },
+    returnKeyType: {
+      type: String,
+      default: "done"
+    },
+    autoCapitalize: {
+      type: String,
+      default: "sentences"
+    },
+    autoCorrect: {
+      type: Boolean,
+      default: true
+    },
+    maxLength: Number,
+    multiline: {
+      type: Boolean,
+      default: false
+    },
+    style: Object
+  },
+  emits: ["update:modelValue", "focus", "blur", "submit"],
+  setup(props, { emit }) {
+    const onChangetext = (payload) => {
+      const text = typeof payload === "string" ? payload : payload?.text ?? "";
+      emit("update:modelValue", text);
+    };
+    const onFocus = (payload) => {
+      emit("focus", payload);
+    };
+    const onBlur = (payload) => {
+      emit("blur", payload);
+    };
+    const onSubmit = (payload) => {
+      emit("submit", payload);
+    };
+    return () => (0, import_runtime_core5.h)("VInput", {
+      text: props.modelValue,
+      placeholder: props.placeholder,
+      secureTextEntry: props.secureTextEntry,
+      keyboardType: props.keyboardType,
+      returnKeyType: props.returnKeyType,
+      autoCapitalize: props.autoCapitalize,
+      autoCorrect: props.autoCorrect,
+      maxLength: props.maxLength,
+      multiline: props.multiline,
+      style: props.style,
+      onChangetext,
+      onFocus,
+      onBlur,
+      onSubmit
+    });
+  }
+});
+
+// src/components/VSwitch.ts
+var import_runtime_core6 = require("@vue/runtime-core");
+var VSwitch = (0, import_runtime_core6.defineComponent)({
+  name: "VSwitch",
+  props: {
+    modelValue: {
+      type: Boolean,
+      default: false
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    onTintColor: String,
+    thumbTintColor: String,
+    style: Object
+  },
+  emits: ["update:modelValue", "change"],
+  setup(props, { emit }) {
+    const onChange = (payload) => {
+      const value = typeof payload === "boolean" ? payload : !!(payload?.value ?? payload);
+      emit("update:modelValue", value);
+      emit("change", value);
+    };
+    return () => (0, import_runtime_core6.h)("VSwitch", {
+      value: props.modelValue,
+      disabled: props.disabled,
+      onTintColor: props.onTintColor,
+      thumbTintColor: props.thumbTintColor,
+      style: props.style,
+      onChange
+    });
+  }
+});
+
+// src/components/VActivityIndicator.ts
+var import_runtime_core7 = require("@vue/runtime-core");
+var VActivityIndicator = (0, import_runtime_core7.defineComponent)({
+  name: "VActivityIndicator",
+  props: {
+    animating: {
+      type: Boolean,
+      default: true
+    },
+    color: String,
+    size: {
+      type: String,
+      default: "medium"
+      // 'small' | 'medium' | 'large'
+    },
+    hidesWhenStopped: {
+      type: Boolean,
+      default: true
+    },
+    style: Object
+  },
+  setup(props) {
+    return () => (0, import_runtime_core7.h)("VActivityIndicator", {
+      animating: props.animating,
+      color: props.color,
+      size: props.size,
+      hidesWhenStopped: props.hidesWhenStopped,
+      style: props.style
+    });
+  }
+});
+
+// src/components/VScrollView.ts
+var import_runtime_core8 = require("@vue/runtime-core");
+var VScrollView = (0, import_runtime_core8.defineComponent)({
+  name: "VScrollView",
+  props: {
+    horizontal: {
+      type: Boolean,
+      default: false
+    },
+    showsVerticalScrollIndicator: {
+      type: Boolean,
+      default: true
+    },
+    showsHorizontalScrollIndicator: {
+      type: Boolean,
+      default: false
+    },
+    scrollEnabled: {
+      type: Boolean,
+      default: true
+    },
+    bounces: {
+      type: Boolean,
+      default: true
+    },
+    pagingEnabled: {
+      type: Boolean,
+      default: false
+    },
+    contentContainerStyle: Object,
+    /** Whether the pull-to-refresh indicator is active */
+    refreshing: {
+      type: Boolean,
+      default: false
+    },
+    style: Object
+  },
+  emits: ["scroll", "refresh"],
+  setup(props, { slots, emit }) {
+    const onScroll = (payload) => {
+      emit("scroll", payload);
+    };
+    const onRefresh = () => {
+      emit("refresh");
+    };
+    return () => (0, import_runtime_core8.h)(
+      "VScrollView",
+      {
+        horizontal: props.horizontal,
+        showsVerticalScrollIndicator: props.showsVerticalScrollIndicator,
+        showsHorizontalScrollIndicator: props.showsHorizontalScrollIndicator,
+        scrollEnabled: props.scrollEnabled,
+        bounces: props.bounces,
+        pagingEnabled: props.pagingEnabled,
+        contentContainerStyle: props.contentContainerStyle,
+        refreshing: props.refreshing,
+        style: props.style,
+        onScroll,
+        onRefresh
+      },
+      slots.default?.()
+    );
+  }
+});
+
+// src/components/VImage.ts
+var import_runtime_core9 = require("@vue/runtime-core");
+var VImage = (0, import_runtime_core9.defineComponent)({
+  name: "VImage",
+  props: {
+    source: Object,
+    resizeMode: {
+      type: String,
+      default: "cover"
+    },
+    style: Object,
+    testID: String,
+    accessibilityLabel: String
+  },
+  emits: ["load", "error"],
+  setup(props, { emit }) {
+    return () => (0, import_runtime_core9.h)(
+      "VImage",
+      {
+        ...props,
+        onLoad: () => emit("load"),
+        onError: (e) => emit("error", e)
+      }
+    );
+  }
+});
+
+// src/components/VKeyboardAvoiding.ts
+var import_runtime_core10 = require("@vue/runtime-core");
+var VKeyboardAvoiding = (0, import_runtime_core10.defineComponent)({
+  name: "VKeyboardAvoiding",
+  props: {
+    style: Object,
+    testID: String
+  },
+  setup(props, { slots }) {
+    return () => (0, import_runtime_core10.h)("VKeyboardAvoiding", { ...props }, slots.default?.());
+  }
+});
+
+// src/components/VSafeArea.ts
+var import_runtime_core11 = require("@vue/runtime-core");
+var VSafeArea = (0, import_runtime_core11.defineComponent)({
+  name: "VSafeArea",
+  props: {
+    style: { type: Object, default: () => ({}) }
+  },
+  setup(props, { slots }) {
+    return () => (0, import_runtime_core11.h)("VSafeArea", { style: props.style }, slots.default?.());
+  }
+});
+
+// src/components/VSlider.ts
+var import_runtime_core12 = require("@vue/runtime-core");
+var VSlider = (0, import_runtime_core12.defineComponent)({
+  name: "VSlider",
+  props: {
+    modelValue: { type: Number, default: 0 },
+    min: { type: Number, default: 0 },
+    max: { type: Number, default: 1 },
+    style: { type: Object, default: () => ({}) }
+  },
+  emits: ["update:modelValue", "change"],
+  setup(props, { emit }) {
+    return () => (0, import_runtime_core12.h)("VSlider", {
+      style: props.style,
+      value: props.modelValue,
+      minimumValue: props.min,
+      maximumValue: props.max,
+      onChange: (val) => {
+        emit("update:modelValue", val);
+        emit("change", val);
+      }
+    });
+  }
+});
+
+// src/components/VList.ts
+var import_runtime_core13 = require("@vue/runtime-core");
+var VList = (0, import_runtime_core13.defineComponent)({
+  name: "VList",
+  props: {
+    /** Array of data items to render */
+    data: {
+      type: Array,
+      required: true
+    },
+    /** Extract a unique key from each item. Defaults to index as string. */
+    keyExtractor: {
+      type: Function,
+      default: (_item, index) => String(index)
+    },
+    /** Estimated height per row in points. Used before layout runs. Default: 44 */
+    estimatedItemHeight: {
+      type: Number,
+      default: 44
+    },
+    /** Show vertical scroll indicator. Default: true */
+    showsScrollIndicator: {
+      type: Boolean,
+      default: true
+    },
+    /** Enable bounce at scroll boundaries. Default: true */
+    bounces: {
+      type: Boolean,
+      default: true
+    },
+    /** Render list horizontally. Default: false */
+    horizontal: {
+      type: Boolean,
+      default: false
+    },
+    style: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  emits: ["scroll", "endReached"],
+  setup(props, { slots, emit }) {
+    return () => {
+      const items = props.data ?? [];
+      const children = [];
+      if (slots.header) {
+        children.push(
+          (0, import_runtime_core13.h)("VView", { key: "__header__", style: { flexShrink: 0 } }, slots.header())
+        );
+      }
+      if (items.length === 0 && slots.empty) {
+        children.push(
+          (0, import_runtime_core13.h)("VView", { key: "__empty__", style: { flexShrink: 0 } }, slots.empty())
+        );
+      }
+      for (let index = 0; index < items.length; index++) {
+        const item = items[index];
+        children.push(
+          (0, import_runtime_core13.h)(
+            "VView",
+            {
+              key: props.keyExtractor(item, index),
+              style: { flexShrink: 0 }
+            },
+            slots.item?.({ item, index }) ?? []
+          )
+        );
+      }
+      if (slots.footer) {
+        children.push(
+          (0, import_runtime_core13.h)("VView", { key: "__footer__", style: { flexShrink: 0 } }, slots.footer())
+        );
+      }
+      return (0, import_runtime_core13.h)(
+        "VList",
+        {
+          style: props.style,
+          estimatedItemHeight: props.estimatedItemHeight,
+          showsScrollIndicator: props.showsScrollIndicator,
+          bounces: props.bounces,
+          horizontal: props.horizontal,
+          onScroll: (e) => emit("scroll", e),
+          onEndReached: () => emit("endReached")
+        },
+        children
+      );
+    };
+  }
+});
+
+// src/components/VModal.ts
+var import_runtime_core14 = require("@vue/runtime-core");
+var VModal = (0, import_runtime_core14.defineComponent)({
+  name: "VModal",
+  props: {
+    visible: {
+      type: Boolean,
+      default: false
+    },
+    style: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  emits: ["dismiss"],
+  setup(props, { slots, emit }) {
+    return () => (0, import_runtime_core14.h)(
+      "VModal",
+      {
+        visible: props.visible,
+        style: props.style,
+        onDismiss: () => emit("dismiss")
+      },
+      slots.default?.() ?? []
+    );
+  }
+});
+
+// src/components/VAlertDialog.ts
+var import_runtime_core15 = require("@vue/runtime-core");
+var VAlertDialog = (0, import_runtime_core15.defineComponent)({
+  name: "VAlertDialog",
+  props: {
+    visible: { type: Boolean, default: false },
+    title: { type: String, default: "" },
+    message: { type: String, default: "" },
+    buttons: { type: Array, default: () => [] }
+  },
+  emits: ["confirm", "cancel", "action"],
+  setup(props, { emit }) {
+    return () => (0, import_runtime_core15.h)("VAlertDialog", {
+      visible: props.visible,
+      title: props.title,
+      message: props.message,
+      buttons: props.buttons,
+      onConfirm: (e) => emit("confirm", e),
+      onCancel: () => emit("cancel"),
+      onAction: (e) => emit("action", e)
+    });
+  }
+});
+
+// src/components/VStatusBar.ts
+var import_runtime_core16 = require("@vue/runtime-core");
+var VStatusBar = (0, import_runtime_core16.defineComponent)({
+  name: "VStatusBar",
+  props: {
+    barStyle: { type: String, default: "default" },
+    hidden: { type: Boolean, default: false },
+    animated: { type: Boolean, default: true }
+  },
+  setup(props) {
+    return () => (0, import_runtime_core16.h)("VStatusBar", {
+      barStyle: props.barStyle,
+      hidden: props.hidden,
+      animated: props.animated
+    });
+  }
+});
+
+// src/components/VWebView.ts
+var import_runtime_core17 = require("@vue/runtime-core");
+var VWebView = (0, import_runtime_core17.defineComponent)({
+  name: "VWebView",
+  props: {
+    source: { type: Object, required: true },
+    style: { type: Object, default: () => ({}) },
+    javaScriptEnabled: { type: Boolean, default: true }
+  },
+  emits: ["load", "error", "message"],
+  setup(props, { emit }) {
+    return () => (0, import_runtime_core17.h)("VWebView", {
+      source: props.source,
+      style: props.style,
+      javaScriptEnabled: props.javaScriptEnabled,
+      onLoad: (e) => emit("load", e),
+      onError: (e) => emit("error", e),
+      onMessage: (e) => emit("message", e)
+    });
+  }
+});
+
+// src/components/VProgressBar.ts
+var import_runtime_core18 = require("@vue/runtime-core");
+var VProgressBar = (0, import_runtime_core18.defineComponent)({
+  name: "VProgressBar",
+  props: {
+    progress: { type: Number, default: 0 },
+    progressTintColor: { type: String, default: void 0 },
+    trackTintColor: { type: String, default: void 0 },
+    animated: { type: Boolean, default: true },
+    style: { type: Object, default: () => ({}) }
+  },
+  setup(props) {
+    return () => (0, import_runtime_core18.h)("VProgressBar", {
+      progress: props.progress,
+      progressTintColor: props.progressTintColor,
+      trackTintColor: props.trackTintColor,
+      animated: props.animated,
+      style: props.style
+    });
+  }
+});
+
+// src/components/VPicker.ts
+var import_runtime_core19 = require("@vue/runtime-core");
+var VPicker = (0, import_runtime_core19.defineComponent)({
+  name: "VPicker",
+  props: {
+    mode: { type: String, default: "date" },
+    value: { type: Number, default: void 0 },
+    // epoch milliseconds
+    minimumDate: { type: Number, default: void 0 },
+    maximumDate: { type: Number, default: void 0 },
+    minuteInterval: { type: Number, default: 1 },
+    style: { type: Object, default: () => ({}) }
+  },
+  emits: ["change"],
+  setup(props, { emit }) {
+    return () => (0, import_runtime_core19.h)("VPicker", {
+      mode: props.mode,
+      value: props.value,
+      minimumDate: props.minimumDate,
+      maximumDate: props.maximumDate,
+      minuteInterval: props.minuteInterval,
+      style: props.style,
+      onChange: (e) => emit("change", e)
+    });
+  }
+});
+
+// src/components/VSegmentedControl.ts
+var import_runtime_core20 = require("@vue/runtime-core");
+var VSegmentedControl = (0, import_runtime_core20.defineComponent)({
+  name: "VSegmentedControl",
+  props: {
+    values: { type: Array, required: true },
+    selectedIndex: { type: Number, default: 0 },
+    tintColor: { type: String, default: void 0 },
+    enabled: { type: Boolean, default: true },
+    style: { type: Object, default: () => ({}) }
+  },
+  emits: ["change"],
+  setup(props, { emit }) {
+    return () => (0, import_runtime_core20.h)("VSegmentedControl", {
+      values: props.values,
+      selectedIndex: props.selectedIndex,
+      tintColor: props.tintColor,
+      enabled: props.enabled,
+      style: props.style,
+      onChange: (e) => emit("change", e)
+    });
+  }
+});
+
+// src/components/VActionSheet.ts
+var import_runtime_core21 = require("@vue/runtime-core");
+var VActionSheet = (0, import_runtime_core21.defineComponent)({
+  name: "VActionSheet",
+  props: {
+    visible: { type: Boolean, default: false },
+    title: { type: String, default: void 0 },
+    message: { type: String, default: void 0 },
+    actions: { type: Array, default: () => [] }
+  },
+  emits: ["action", "cancel"],
+  setup(props, { emit }) {
+    return () => (0, import_runtime_core21.h)("VActionSheet", {
+      visible: props.visible,
+      title: props.title,
+      message: props.message,
+      actions: props.actions,
+      onAction: (e) => emit("action", e),
+      onCancel: () => emit("cancel")
+    });
+  }
+});
+
+// src/directives/vShow.ts
+var vShow = {
+  beforeMount(el, { value }) {
+    NativeBridge.updateProp(el.id, "hidden", !value);
+  },
+  updated(el, { value, oldValue }) {
+    if (value === oldValue) return;
+    NativeBridge.updateProp(el.id, "hidden", !value);
+  }
+};
+
+// src/index.ts
+__reExport(index_exports, require("@vue/runtime-core"), module.exports);
+
+// src/stylesheet.ts
+var validStyleProperties = /* @__PURE__ */ new Set([
+  // Layout (Yoga / Flexbox)
+  "flex",
+  "flexDirection",
+  "flexWrap",
+  "flexGrow",
+  "flexShrink",
+  "flexBasis",
+  "justifyContent",
+  "alignItems",
+  "alignSelf",
+  "alignContent",
+  "position",
+  "top",
+  "right",
+  "bottom",
+  "left",
+  "width",
+  "height",
+  "minWidth",
+  "minHeight",
+  "maxWidth",
+  "maxHeight",
+  "margin",
+  "marginTop",
+  "marginRight",
+  "marginBottom",
+  "marginLeft",
+  "marginHorizontal",
+  "marginVertical",
+  "padding",
+  "paddingTop",
+  "paddingRight",
+  "paddingBottom",
+  "paddingLeft",
+  "paddingHorizontal",
+  "paddingVertical",
+  "gap",
+  "rowGap",
+  "columnGap",
+  "display",
+  "overflow",
+  "zIndex",
+  "aspectRatio",
+  // Visual
+  "backgroundColor",
+  "opacity",
+  // Borders
+  "borderWidth",
+  "borderTopWidth",
+  "borderRightWidth",
+  "borderBottomWidth",
+  "borderLeftWidth",
+  "borderColor",
+  "borderTopColor",
+  "borderRightColor",
+  "borderBottomColor",
+  "borderLeftColor",
+  "borderRadius",
+  "borderTopLeftRadius",
+  "borderTopRightRadius",
+  "borderBottomLeftRadius",
+  "borderBottomRightRadius",
+  "borderStyle",
+  // Shadow
+  "shadowColor",
+  "shadowOffset",
+  "shadowOpacity",
+  "shadowRadius",
+  // Text
+  "color",
+  "fontSize",
+  "fontWeight",
+  "fontFamily",
+  "fontStyle",
+  "lineHeight",
+  "letterSpacing",
+  "textAlign",
+  "textDecorationLine",
+  "textDecorationStyle",
+  "textDecorationColor",
+  "textTransform",
+  "includeFontPadding",
+  // Image
+  "resizeMode",
+  "tintColor",
+  // Transform
+  "transform"
+]);
+function createStyleSheet(styles) {
+  const isDev = typeof __DEV__ !== "undefined" ? __DEV__ : true;
+  if (isDev) {
+    for (const styleName in styles) {
+      const styleObj = styles[styleName];
+      for (const prop in styleObj) {
+        if (!validStyleProperties.has(prop)) {
+          console.warn(
+            `[VueNative] Unknown style property "${prop}" in style "${styleName}". This property will be ignored by the native renderer.`
+          );
+        }
+      }
+    }
+  }
+  const result = {};
+  for (const key in styles) {
+    result[key] = Object.freeze({ ...styles[key] });
+  }
+  return Object.freeze(result);
+}
+
+// src/composables/useHaptics.ts
+function useHaptics() {
+  function vibrate(style = "medium") {
+    return NativeBridge.invokeNativeModule("Haptics", "vibrate", [style]).then(() => void 0);
+  }
+  function notificationFeedback(type = "success") {
+    return NativeBridge.invokeNativeModule("Haptics", "notificationFeedback", [type]).then(() => void 0);
+  }
+  function selectionChanged() {
+    return NativeBridge.invokeNativeModule("Haptics", "selectionChanged", []).then(() => void 0);
+  }
+  return { vibrate, notificationFeedback, selectionChanged };
+}
+
+// src/composables/useAsyncStorage.ts
+function useAsyncStorage() {
+  function getItem(key) {
+    return NativeBridge.invokeNativeModule("AsyncStorage", "getItem", [key]);
+  }
+  function setItem(key, value) {
+    return NativeBridge.invokeNativeModule("AsyncStorage", "setItem", [key, value]).then(() => void 0);
+  }
+  function removeItem(key) {
+    return NativeBridge.invokeNativeModule("AsyncStorage", "removeItem", [key]).then(() => void 0);
+  }
+  function getAllKeys() {
+    return NativeBridge.invokeNativeModule("AsyncStorage", "getAllKeys", []);
+  }
+  function clear() {
+    return NativeBridge.invokeNativeModule("AsyncStorage", "clear", []).then(() => void 0);
+  }
+  return { getItem, setItem, removeItem, getAllKeys, clear };
+}
+
+// src/composables/useClipboard.ts
+var import_runtime_core22 = require("@vue/runtime-core");
+function useClipboard() {
+  const content = (0, import_runtime_core22.ref)("");
+  function copy(text) {
+    return NativeBridge.invokeNativeModule("Clipboard", "copy", [text]).then(() => void 0);
+  }
+  async function paste() {
+    const text = await NativeBridge.invokeNativeModule("Clipboard", "paste", []);
+    const result = typeof text === "string" ? text : "";
+    content.value = result;
+    return result;
+  }
+  return { copy, paste, content };
+}
+
+// src/composables/useDeviceInfo.ts
+var import_runtime_core23 = require("@vue/runtime-core");
+function useDeviceInfo() {
+  const model = (0, import_runtime_core23.ref)("");
+  const systemVersion = (0, import_runtime_core23.ref)("");
+  const systemName = (0, import_runtime_core23.ref)("");
+  const name = (0, import_runtime_core23.ref)("");
+  const screenWidth = (0, import_runtime_core23.ref)(0);
+  const screenHeight = (0, import_runtime_core23.ref)(0);
+  const scale = (0, import_runtime_core23.ref)(1);
+  const isLoaded = (0, import_runtime_core23.ref)(false);
+  async function fetchInfo() {
+    const info = await NativeBridge.invokeNativeModule("DeviceInfo", "getInfo", []);
+    model.value = info.model ?? "";
+    systemVersion.value = info.systemVersion ?? "";
+    systemName.value = info.systemName ?? "";
+    name.value = info.name ?? "";
+    screenWidth.value = info.screenWidth ?? 0;
+    screenHeight.value = info.screenHeight ?? 0;
+    scale.value = info.scale ?? 1;
+    isLoaded.value = true;
+  }
+  (0, import_runtime_core23.onMounted)(() => {
+    fetchInfo();
+  });
+  return {
+    model,
+    systemVersion,
+    systemName,
+    name,
+    screenWidth,
+    screenHeight,
+    scale,
+    isLoaded,
+    fetchInfo
+  };
+}
+
+// src/composables/useKeyboard.ts
+var import_runtime_core24 = require("@vue/runtime-core");
+function useKeyboard() {
+  const isVisible = (0, import_runtime_core24.ref)(false);
+  const height = (0, import_runtime_core24.ref)(0);
+  function dismiss() {
+    return NativeBridge.invokeNativeModule("Keyboard", "dismiss", []).then(() => void 0);
+  }
+  async function getHeight() {
+    const result = await NativeBridge.invokeNativeModule("Keyboard", "getHeight", []);
+    isVisible.value = result.isVisible ?? false;
+    height.value = result.height ?? 0;
+    return result;
+  }
+  return { isVisible, height, dismiss, getHeight };
+}
+
+// src/composables/useAnimation.ts
+var Easing = {
+  linear: "linear",
+  ease: "ease",
+  easeIn: "easeIn",
+  easeOut: "easeOut",
+  easeInOut: "easeInOut"
+};
+function useAnimation() {
+  function timing(viewId, toStyles, config = {}) {
+    return NativeBridge.invokeNativeModule("Animation", "timing", [viewId, toStyles, config]);
+  }
+  function spring(viewId, toStyles, config = {}) {
+    return NativeBridge.invokeNativeModule("Animation", "spring", [viewId, toStyles, config]);
+  }
+  function keyframe(viewId, steps, config = {}) {
+    return NativeBridge.invokeNativeModule("Animation", "keyframe", [viewId, steps, config]);
+  }
+  function sequence(animations) {
+    return NativeBridge.invokeNativeModule("Animation", "sequence", [animations]);
+  }
+  function parallel(animations) {
+    return NativeBridge.invokeNativeModule("Animation", "parallel", [animations]);
+  }
+  function fadeOut(viewId, duration = 300) {
+    return timing(viewId, { opacity: 0 }, { duration });
+  }
+  function fadeIn(viewId, duration = 300) {
+    return timing(viewId, { opacity: 1 }, { duration });
+  }
+  function slideInFromRight(viewId, duration = 300) {
+    return timing(viewId, { translateX: 0 }, { duration, easing: "easeOut" });
+  }
+  function slideOutToRight(viewId, duration = 300) {
+    return timing(viewId, { translateX: 400 }, { duration, easing: "easeIn" });
+  }
+  return {
+    timing,
+    spring,
+    keyframe,
+    sequence,
+    parallel,
+    fadeIn,
+    fadeOut,
+    slideInFromRight,
+    slideOutToRight,
+    Easing
+  };
+}
+
+// src/composables/useNetwork.ts
+var import_runtime_core25 = require("@vue/runtime-core");
+function useNetwork() {
+  const isConnected = (0, import_runtime_core25.ref)(true);
+  const connectionType = (0, import_runtime_core25.ref)("unknown");
+  NativeBridge.invokeNativeModule("Network", "getStatus").then((status) => {
+    isConnected.value = status.isConnected;
+    connectionType.value = status.connectionType;
+  }).catch(() => {
+  });
+  const unsubscribe = NativeBridge.onGlobalEvent("network:change", (payload) => {
+    isConnected.value = payload.isConnected;
+    connectionType.value = payload.connectionType;
+  });
+  (0, import_runtime_core25.onUnmounted)(unsubscribe);
+  return { isConnected, connectionType };
+}
+
+// src/composables/useAppState.ts
+var import_runtime_core26 = require("@vue/runtime-core");
+function useAppState() {
+  const state = (0, import_runtime_core26.ref)("active");
+  NativeBridge.invokeNativeModule("AppState", "getState").then((s) => {
+    state.value = s;
+  }).catch(() => {
+  });
+  const unsubscribe = NativeBridge.onGlobalEvent("appState:change", (payload) => {
+    state.value = payload.state;
+  });
+  (0, import_runtime_core26.onUnmounted)(unsubscribe);
+  return { state };
+}
+
+// src/composables/useLinking.ts
+function useLinking() {
+  async function openURL(url) {
+    await NativeBridge.invokeNativeModule("Linking", "openURL", [url]);
+  }
+  async function canOpenURL(url) {
+    return NativeBridge.invokeNativeModule("Linking", "canOpenURL", [url]);
+  }
+  return { openURL, canOpenURL };
+}
+
+// src/composables/useShare.ts
+function useShare() {
+  async function share(content) {
+    return NativeBridge.invokeNativeModule("Share", "share", [content]);
+  }
+  return { share };
+}
+
+// src/composables/usePermissions.ts
+function usePermissions() {
+  async function request(permission) {
+    return NativeBridge.invokeNativeModule("Permissions", "request", [permission]);
+  }
+  async function check(permission) {
+    return NativeBridge.invokeNativeModule("Permissions", "check", [permission]);
+  }
+  return { request, check };
+}
+
+// src/composables/useGeolocation.ts
+var import_runtime_core27 = require("@vue/runtime-core");
+function useGeolocation() {
+  const coords = (0, import_runtime_core27.ref)(null);
+  const error = (0, import_runtime_core27.ref)(null);
+  let watchId = null;
+  async function getCurrentPosition() {
+    const result = await NativeBridge.invokeNativeModule("Geolocation", "getCurrentPosition");
+    coords.value = result;
+    return result;
+  }
+  async function watchPosition() {
+    const id = await NativeBridge.invokeNativeModule("Geolocation", "watchPosition");
+    watchId = id;
+    const unsubscribe = NativeBridge.onGlobalEvent("location:update", (payload) => {
+      coords.value = payload;
+    });
+    (0, import_runtime_core27.onUnmounted)(() => {
+      unsubscribe();
+      if (watchId !== null) clearWatch(watchId);
+    });
+    return id;
+  }
+  async function clearWatch(id) {
+    await NativeBridge.invokeNativeModule("Geolocation", "clearWatch", [id]);
+    watchId = null;
+  }
+  return { coords, error, getCurrentPosition, watchPosition, clearWatch };
+}
+
+// src/composables/useCamera.ts
+function useCamera() {
+  async function launchCamera(options = {}) {
+    return NativeBridge.invokeNativeModule("Camera", "launchCamera", [options]);
+  }
+  async function launchImageLibrary(options = {}) {
+    return NativeBridge.invokeNativeModule("Camera", "launchImageLibrary", [options]);
+  }
+  return { launchCamera, launchImageLibrary };
+}
+
+// src/composables/useNotifications.ts
+var import_runtime_core28 = require("@vue/runtime-core");
+function useNotifications() {
+  const isGranted = (0, import_runtime_core28.ref)(false);
+  async function requestPermission() {
+    const granted = await NativeBridge.invokeNativeModule("Notifications", "requestPermission");
+    isGranted.value = granted;
+    return granted;
+  }
+  async function getPermissionStatus() {
+    return NativeBridge.invokeNativeModule("Notifications", "getPermissionStatus");
+  }
+  async function scheduleLocal(notification) {
+    return NativeBridge.invokeNativeModule("Notifications", "scheduleLocal", [notification]);
+  }
+  async function cancel(id) {
+    return NativeBridge.invokeNativeModule("Notifications", "cancel", [id]);
+  }
+  async function cancelAll() {
+    return NativeBridge.invokeNativeModule("Notifications", "cancelAll");
+  }
+  function onNotification(handler) {
+    const unsubscribe = NativeBridge.onGlobalEvent("notification:received", handler);
+    (0, import_runtime_core28.onUnmounted)(unsubscribe);
+    return unsubscribe;
+  }
+  return { isGranted, requestPermission, getPermissionStatus, scheduleLocal, cancel, cancelAll, onNotification };
+}
+
+// src/composables/useBiometry.ts
+function useBiometry() {
+  async function authenticate(reason = "Authenticate") {
+    return NativeBridge.invokeNativeModule("Biometry", "authenticate", [reason]);
+  }
+  async function getSupportedBiometry() {
+    return NativeBridge.invokeNativeModule("Biometry", "getSupportedBiometry");
+  }
+  async function isAvailable() {
+    return NativeBridge.invokeNativeModule("Biometry", "isAvailable");
+  }
+  return { authenticate, getSupportedBiometry, isAvailable };
+}
+
+// src/composables/useHttp.ts
+var import_runtime_core29 = require("@vue/runtime-core");
+function useHttp(config = {}) {
+  const loading = (0, import_runtime_core29.ref)(false);
+  const error = (0, import_runtime_core29.ref)(null);
+  async function request(method, url, options = {}) {
+    const fullUrl = config.baseURL ? `${config.baseURL}${url}` : url;
+    loading.value = true;
+    error.value = null;
+    try {
+      const mergedHeaders = {
+        "Content-Type": "application/json",
+        ...config.headers ?? {},
+        ...options.headers ?? {}
+      };
+      const fetchOptions = {
+        method: method.toUpperCase(),
+        headers: mergedHeaders
+      };
+      if (options.body !== void 0) {
+        fetchOptions.body = JSON.stringify(options.body);
+      }
+      const response = await fetch(fullUrl, fetchOptions);
+      const data = await response.json();
+      return {
+        data,
+        status: response.status,
+        ok: response.ok,
+        headers: {}
+      };
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      error.value = msg;
+      throw e;
+    } finally {
+      loading.value = false;
+    }
+  }
+  return {
+    loading,
+    error,
+    get: (url, headers) => request("GET", url, { headers }),
+    post: (url, body, headers) => request("POST", url, { body, headers }),
+    put: (url, body, headers) => request("PUT", url, { body, headers }),
+    patch: (url, body, headers) => request("PATCH", url, { body, headers }),
+    delete: (url, headers) => request("DELETE", url, { headers })
+  };
+}
+
+// src/composables/useColorScheme.ts
+var import_runtime_core30 = require("@vue/runtime-core");
+function useColorScheme() {
+  const colorScheme = (0, import_runtime_core30.ref)("light");
+  const isDark = (0, import_runtime_core30.ref)(false);
+  const unsubscribe = NativeBridge.onGlobalEvent(
+    "colorScheme:change",
+    (payload) => {
+      colorScheme.value = payload.colorScheme;
+      isDark.value = payload.colorScheme === "dark";
+    }
+  );
+  (0, import_runtime_core30.onUnmounted)(unsubscribe);
+  return { colorScheme, isDark };
+}
+
+// src/composables/useBackHandler.ts
+var import_runtime_core31 = require("@vue/runtime-core");
+function useBackHandler(handler) {
+  let unsubscribe = null;
+  (0, import_runtime_core31.onMounted)(() => {
+    unsubscribe = NativeBridge.onGlobalEvent("hardware:backPress", () => {
+      handler();
+    });
+  });
+  (0, import_runtime_core31.onUnmounted)(() => {
+    unsubscribe?.();
+    unsubscribe = null;
+  });
+}
+
+// src/index.ts
+function createApp(rootComponent, rootProps) {
+  const app = baseCreateApp(rootComponent, rootProps);
+  app.component("VView", VView);
+  app.component("VText", VText);
+  app.component("VButton", VButton);
+  app.component("VInput", VInput);
+  app.component("VSwitch", VSwitch);
+  app.component("VActivityIndicator", VActivityIndicator);
+  app.component("VScrollView", VScrollView);
+  app.component("VImage", VImage);
+  app.component("VKeyboardAvoiding", VKeyboardAvoiding);
+  app.component("VSafeArea", VSafeArea);
+  app.component("VSlider", VSlider);
+  app.component("VList", VList);
+  app.component("VModal", VModal);
+  app.component("VAlertDialog", VAlertDialog);
+  app.component("VStatusBar", VStatusBar);
+  app.component("VWebView", VWebView);
+  app.component("VProgressBar", VProgressBar);
+  app.component("VPicker", VPicker);
+  app.component("VSegmentedControl", VSegmentedControl);
+  app.component("VActionSheet", VActionSheet);
+  app.directive("show", vShow);
+  app.config.errorHandler = (err, instance, info) => {
+    const error = err instanceof Error ? err : new Error(String(err));
+    const componentName = instance?.$options?.name || instance?.$.type?.name || "Anonymous";
+    const errorInfo = JSON.stringify({
+      message: error.message,
+      stack: error.stack || "",
+      componentName,
+      info
+    });
+    console.error(`[VueNative] Error in ${componentName}: ${error.message}`);
+    const handleError = globalThis.__VN_handleError;
+    if (typeof handleError === "function") {
+      handleError(errorInfo);
+    }
+  };
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    app.config.warnHandler = (msg, instance, trace) => {
+      const componentName = instance?.$options?.name || instance?.$.type?.name || "Anonymous";
+      console.warn(`[VueNative] Warning in ${componentName}: ${msg}`);
+    };
+  }
+  app.start = () => {
+    const root = createNativeNode("__ROOT__");
+    NativeBridge.createNode(root.id, "__ROOT__");
+    NativeBridge.setRootView(root.id);
+    const vnode = (0, import_runtime_core32.createVNode)(rootComponent, rootProps);
+    vnode.appContext = app._context;
+    render(vnode, root);
+    return root;
+  };
+  return app;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NativeBridge,
+  VActionSheet,
+  VActivityIndicator,
+  VAlertDialog,
+  VButton,
+  VImage,
+  VInput,
+  VKeyboardAvoiding,
+  VList,
+  VModal,
+  VPicker,
+  VProgressBar,
+  VSafeArea,
+  VScrollView,
+  VSegmentedControl,
+  VSlider,
+  VStatusBar,
+  VSwitch,
+  VText,
+  VView,
+  VWebView,
+  createApp,
+  createCommentNode,
+  createNativeNode,
+  createStyleSheet,
+  createTextNode,
+  render,
+  resetNodeId,
+  useAnimation,
+  useAppState,
+  useAsyncStorage,
+  useBackHandler,
+  useBiometry,
+  useCamera,
+  useClipboard,
+  useColorScheme,
+  useDeviceInfo,
+  useGeolocation,
+  useHaptics,
+  useHttp,
+  useKeyboard,
+  useLinking,
+  useNetwork,
+  useNotifications,
+  usePermissions,
+  useShare,
+  vShow,
+  validStyleProperties,
+  ...require("@vue/runtime-core")
+});