mn-rails-core 0.1.0

package/dist/index.js

@@ -0,0 +1,1645 @@
+// src/MN.ts
+import { MN as BaseMN7 } from "marginnote";
+
+// src/db/NoteDatabase.ts
+var NoteDatabase = class {
+  db;
+  constructor(db) {
+    this.db = db ?? Database.sharedInstance();
+  }
+  getNoteById(noteId) {
+    try {
+      const note = this.db.getNoteById(noteId);
+      return note ?? null;
+    } catch {
+      return null;
+    }
+  }
+  getNotebookById(notebookId) {
+    try {
+      const topic = this.db.getNotebookById(notebookId);
+      return topic ?? null;
+    } catch {
+      return null;
+    }
+  }
+  getDocumentById(md5) {
+    try {
+      const book = this.db.getDocumentById(md5);
+      return book ?? null;
+    } catch {
+      return null;
+    }
+  }
+  getMediaByHash(hash) {
+    try {
+      const media = this.db.getMediaByHash(hash);
+      return media ?? null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * 获取所有笔记。若提供 notebookId 则返回该笔记本的笔记，否则聚合所有笔记本的笔记。
+   */
+  getAllNotes(notebookId) {
+    try {
+      if (notebookId) {
+        const topic = this.db.getNotebookById(notebookId);
+        return topic?.notes ?? [];
+      }
+      const notebooks = this.db.allNotebooks();
+      return notebooks.flatMap((n) => n.notes ?? []);
+    } catch {
+      return [];
+    }
+  }
+  createNote(title, notebookId, docMd5) {
+    try {
+      const notebook = this.getNotebookById(notebookId);
+      if (!notebook) return null;
+      const doc = (docMd5 ? this.getDocumentById(docMd5) : null) ?? (notebook.documents?.[0] ?? (notebook.mainDocMd5 ? this.getDocumentById(notebook.mainDocMd5) : null));
+      if (!doc) return null;
+      const note = Note.createWithTitleNotebookDocument(title, notebook, doc);
+      if (note) {
+        note.noteTitle = title;
+        return note;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  updateNote(noteId, updates) {
+    try {
+      const note = this.getNoteById(noteId);
+      if (!note) return false;
+      if (updates.noteTitle !== void 0) note.noteTitle = updates.noteTitle;
+      if (updates.excerptText !== void 0) note.excerptText = updates.excerptText;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  deleteNote(noteId) {
+    try {
+      this.db.deleteBookNote(noteId);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/config/Config.ts
+import { MN as BaseMN } from "marginnote";
+var Config = class {
+  prefix;
+  constructor(prefix) {
+    this.prefix = prefix;
+  }
+  get(key, defaultValue) {
+    try {
+      const fullKey = `${this.prefix}.${key}`;
+      const value = NSUserDefaults.standardUserDefaults().objectForKey(fullKey);
+      return value !== null && value !== void 0 ? value : defaultValue;
+    } catch (error) {
+      BaseMN.log(`Config get failed: ${key}`, "error");
+      return defaultValue;
+    }
+  }
+  set(key, value) {
+    try {
+      const fullKey = `${this.prefix}.${key}`;
+      NSUserDefaults.standardUserDefaults().setObjectForKey(value, fullKey);
+      return NSUserDefaults.standardUserDefaults().synchronize();
+    } catch (error) {
+      BaseMN.log(`Config set failed: ${key}`, "error");
+      return false;
+    }
+  }
+  remove(key) {
+    try {
+      const fullKey = `${this.prefix}.${key}`;
+      NSUserDefaults.standardUserDefaults().removeObjectForKey(fullKey);
+      return NSUserDefaults.standardUserDefaults().synchronize();
+    } catch (error) {
+      BaseMN.log(`Config remove failed: ${key}`, "error");
+      return false;
+    }
+  }
+  getAll() {
+    try {
+      const defaults = NSUserDefaults.standardUserDefaults();
+      const allKeys = defaults.dictionaryRepresentation();
+      const result = {};
+      for (const key in allKeys) {
+        if (key.startsWith(this.prefix + ".")) {
+          const shortKey = key.substring(this.prefix.length + 1);
+          result[shortKey] = allKeys[key];
+        }
+      }
+      return result;
+    } catch (error) {
+      BaseMN.log("Config getAll failed", "error");
+      return {};
+    }
+  }
+  clear() {
+    try {
+      const all = this.getAll();
+      for (const key in all) this.remove(key);
+      return true;
+    } catch (error) {
+      BaseMN.log("Config clear failed", "error");
+      return false;
+    }
+  }
+};
+
+// src/state/StateManager.ts
+import { reactive, watch, effect, stop } from "@vue/reactivity";
+
+// src/bridge/MessageBridge.ts
+import { MN as BaseMN3 } from "marginnote";
+
+// src/bridge/Bridge.ts
+import { MN as BaseMN2 } from "marginnote";
+var BridgeManager = class {
+  controllers = /* @__PURE__ */ new Map();
+  pendingRequests = /* @__PURE__ */ new Map();
+  /**
+   * 注册 Controller 的 actions
+   */
+  register(controllerName, actions) {
+    this.controllers.set(controllerName, actions);
+    BaseMN2.log(`Bridge: Registered controller "${controllerName}"`, "bridge");
+  }
+  /**
+   * 注销 Controller
+   */
+  unregister(controllerName) {
+    this.controllers.delete(controllerName);
+    BaseMN2.log(`Bridge: Unregistered controller "${controllerName}"`, "bridge");
+  }
+  /**
+   * 调用 action
+   */
+  async call(controllerName, actionName, ...args) {
+    const controller = this.controllers.get(controllerName);
+    if (!controller) {
+      throw new Error(`Controller "${controllerName}" not found`);
+    }
+    const action = controller[actionName];
+    if (!action || typeof action !== "function") {
+      throw new Error(`Action "${actionName}" not found in controller "${controllerName}"`);
+    }
+    try {
+      const result = await action(...args);
+      return result;
+    } catch (error) {
+      BaseMN2.error(`Bridge call error: ${error}`, "bridge");
+      throw error;
+    }
+  }
+  /**
+   * 处理来自 WebView 的消息
+   */
+  async handleMessage(message) {
+    try {
+      const result = await this.call(message.controller, message.action, ...message.args);
+      return {
+        id: message.id,
+        success: true,
+        data: result
+      };
+    } catch (error) {
+      return {
+        id: message.id,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * 获取所有已注册的 Controller 名称
+   */
+  getControllerNames() {
+    return Array.from(this.controllers.keys());
+  }
+  /**
+   * 获取 Controller 的所有 action 名称
+   */
+  getActionNames(controllerName) {
+    const controller = this.controllers.get(controllerName);
+    if (!controller) {
+      return [];
+    }
+    return Object.keys(controller).filter((key) => typeof controller[key] === "function");
+  }
+};
+var bridgeManagerInstance = null;
+function getBridgeManager() {
+  if (!bridgeManagerInstance) {
+    bridgeManagerInstance = new BridgeManager();
+    bridgeManagerInstance.register("__MN_RAILS_INTERNAL__", {
+      __stateUpdate__: async (payload) => {
+        const defaultState = getState("__default__");
+        if (defaultState) {
+          defaultState.syncFromWebView("__webview__", payload.state);
+          return { success: true };
+        }
+        return { success: false, error: "Default state not found" };
+      }
+    });
+  }
+  return bridgeManagerInstance;
+}
+var bridge = new Proxy({}, {
+  get(target, controllerName) {
+    return new Proxy({}, {
+      get(target2, actionName) {
+        return async (...args) => {
+          const manager = getBridgeManager();
+          return manager.call(controllerName, actionName, ...args);
+        };
+      }
+    });
+  }
+});
+
+// src/bridge/MessageBridge.ts
+var MessageBridge = class {
+  webViews = /* @__PURE__ */ new Map();
+  // WebView 实例映射
+  /**
+   * 注册 WebView
+   */
+  registerWebView(webViewId, webView) {
+    this.webViews.set(webViewId, webView);
+    this.injectBridgeScript(webViewId, webView);
+  }
+  /**
+   * 注销 WebView
+   */
+  unregisterWebView(webViewId) {
+    this.webViews.delete(webViewId);
+  }
+  /**
+   * 注入 bridge 脚本到 WebView
+   */
+  injectBridgeScript(webViewId, webView) {
+    const bridgeScript = `
+      (function() {
+        if (window.__MN_RAILS_BRIDGE__) return;
+        
+        window.__MN_RAILS_BRIDGE__ = {
+          call: function(controller, action, ...args) {
+            return new Promise((resolve, reject) => {
+              const message = {
+                id: Date.now() + '-' + Math.random(),
+                controller: controller,
+                action: action,
+                args: args
+              };
+              
+              // \u53D1\u9001\u6D88\u606F\u5230\u539F\u751F\u7AEF
+              if (window.webkit && window.webkit.messageHandlers && window.webkit.messageHandlers.bridge) {
+                window.webkit.messageHandlers.bridge.postMessage(message);
+              } else {
+                // \u964D\u7EA7\u65B9\u6848\uFF1A\u4F7F\u7528 prompt
+                const result = prompt('__MN_RAILS_BRIDGE__', JSON.stringify(message));
+                if (result) {
+                  try {
+                    const response = JSON.parse(result);
+                    if (response.success) {
+                      resolve(response.data);
+                    } else {
+                      reject(new Error(response.error));
+                    }
+                  } catch (e) {
+                    reject(e);
+                  }
+                } else {
+                  reject(new Error('Bridge call failed'));
+                }
+              }
+            });
+          }
+        };
+        
+        // \u5BFC\u51FA bridge \u5BF9\u8C61
+        window.bridge = new Proxy({}, {
+          get(target, controllerName) {
+            return new Proxy({}, {
+              get(target, actionName) {
+                return function(...args) {
+                  return window.__MN_RAILS_BRIDGE__.call(controllerName, actionName, ...args);
+                };
+              }
+            });
+          }
+        });
+
+        // \u7C7B\u578B\u5B9A\u4E49\u4F1A\u5728 WebViewManager \u751F\u6210 HTML \u65F6\u901A\u8FC7 script \u6807\u7B7E\u6CE8\u5165
+        // \u8FD9\u91CC\u4E0D\u9700\u8981\u989D\u5916\u5904\u7406
+
+        // \u72B6\u6001\u7BA1\u7406\u76F8\u5173
+        // \u521D\u59CB\u5316\u72B6\u6001\u5B58\u50A8\uFF08\u4F7F\u7528\u7B80\u5355\u7684\u54CD\u5E94\u5F0F\u5B9E\u73B0\uFF09
+        window.__MN_RAILS_STATE__ = window.__MN_RAILS_STATE__ || {};
+        
+        // \u72B6\u6001\u66F4\u65B0\u51FD\u6570\uFF08\u7B80\u5355\u7684\u54CD\u5E94\u5F0F\u5B9E\u73B0\uFF0C\u4E0D\u4F9D\u8D56 Vue\uFF09
+        var isSyncingFromNative = false; // \u9632\u6B62\u5FAA\u73AF\u540C\u6B65
+        
+        function makeReactive(obj) {
+          const listeners = new Map();
+          const proxy = new Proxy(obj, {
+            set(target, key, value) {
+              const oldValue = target[key];
+              target[key] = value;
+              // \u89E6\u53D1\u76D1\u542C\u5668
+              if (listeners.has(key)) {
+                listeners.get(key).forEach(fn => {
+                  try {
+                    fn(value, oldValue, key);
+                  } catch (e) {
+                    console.error('State listener error:', e);
+                  }
+                });
+              }
+              // \u81EA\u52A8\u540C\u6B65\u5230\u539F\u751F\u7AEF\uFF08\u5982\u679C\u503C\u53D1\u751F\u53D8\u5316\u4E14\u4E0D\u662F\u4ECE\u539F\u751F\u7AEF\u540C\u6B65\u7684\uFF09
+              if (oldValue !== value && !isSyncingFromNative && window.__MN_RAILS_STATE_UPDATE__) {
+                try {
+                  window.__MN_RAILS_STATE_UPDATE__({ [key]: value });
+                } catch (e) {
+                  console.error('Failed to sync state to native:', e);
+                }
+              }
+              return true;
+            },
+            get(target, key) {
+              return target[key];
+            }
+          });
+          proxy._listeners = listeners;
+          return proxy;
+        }
+
+        // \u521B\u5EFA\u54CD\u5E94\u5F0F\u72B6\u6001\u5BF9\u8C61
+        if (!window.__MN_RAILS_STATE_REACTIVE__) {
+          window.__MN_RAILS_STATE_REACTIVE__ = makeReactive({});
+        }
+
+        // \u72B6\u6001\u66F4\u65B0\u5904\u7406\u5668
+        window.__MN_RAILS_STATE_HANDLER__ = function(message) {
+          if (message.type === 'state-update' && message.payload) {
+            const newState = message.payload.state;
+            const timestamp = message.payload.timestamp;
+            
+            // \u8BBE\u7F6E\u6807\u5FD7\uFF0C\u9632\u6B62\u89E6\u53D1\u540C\u6B65\u56DE\u539F\u751F\u7AEF
+            isSyncingFromNative = true;
+            try {
+              // \u66F4\u65B0\u72B6\u6001\u5BF9\u8C61
+              Object.keys(newState).forEach(key => {
+                window.__MN_RAILS_STATE_REACTIVE__[key] = newState[key];
+              });
+              
+              // \u540C\u6B65\u5230\u975E\u54CD\u5E94\u5F0F\u526F\u672C
+              Object.assign(window.__MN_RAILS_STATE__, newState);
+              
+              // \u89E6\u53D1\u5168\u5C40\u72B6\u6001\u66F4\u65B0\u4E8B\u4EF6
+              if (window.dispatchEvent) {
+                window.dispatchEvent(new CustomEvent('__mn_rails_state_update__', {
+                  detail: { state: newState, timestamp: timestamp }
+                }));
+              }
+            } finally {
+              // \u5EF6\u8FDF\u91CD\u7F6E\u6807\u5FD7
+              setTimeout(function() {
+                isSyncingFromNative = false;
+              }, 0);
+            }
+          }
+        };
+
+        // \u72B6\u6001\u66F4\u65B0\u56DE\u4F20\u51FD\u6570
+        window.__MN_RAILS_STATE_UPDATE__ = function(stateUpdate) {
+          const message = {
+            type: 'state-update-from-webview',
+            payload: {
+              state: stateUpdate,
+              timestamp: Date.now()
+            }
+          };
+          
+          // \u901A\u8FC7 bridge \u53D1\u9001\u6D88\u606F\u5230\u539F\u751F\u7AEF
+          if (window.__MN_RAILS_BRIDGE__) {
+            // \u4F7F\u7528\u4E00\u4E2A\u7279\u6B8A\u7684 controller \u548C action \u6765\u4F20\u9012\u72B6\u6001\u66F4\u65B0
+            window.__MN_RAILS_BRIDGE__.call('__MN_RAILS_INTERNAL__', '__stateUpdate__', message.payload)
+              .catch(err => console.error('Failed to sync state to native:', err));
+          }
+        };
+
+        // \u6D88\u606F\u5904\u7406\u5668\uFF08\u5904\u7406\u6765\u81EA\u539F\u751F\u7AEF\u7684\u6D88\u606F\uFF09
+        window.__MN_RAILS_MESSAGE_HANDLER__ = function(message) {
+          if (message.type === 'state-update') {
+            window.__MN_RAILS_STATE_HANDLER__(message);
+          }
+        };
+
+        // useState Hook \u5B9E\u73B0
+        window.useState = function(key, defaultValue, onChange) {
+          // \u786E\u4FDD\u72B6\u6001\u5BF9\u8C61\u5B58\u5728
+          if (!window.__MN_RAILS_STATE_REACTIVE__) {
+            window.__MN_RAILS_STATE_REACTIVE__ = makeReactive({});
+          }
+          
+          const state = window.__MN_RAILS_STATE_REACTIVE__;
+          
+          // \u5982\u679C\u72B6\u6001\u4E0D\u5B58\u5728\u4E14\u6709\u9ED8\u8BA4\u503C\uFF0C\u521D\u59CB\u5316\u72B6\u6001
+          if (!(key in state) && defaultValue !== undefined) {
+            state[key] = defaultValue;
+          }
+          
+          // \u6CE8\u518C\u76D1\u542C\u5668\uFF08\u5982\u679C\u6709 onChange \u56DE\u8C03\uFF09
+          let unsubscribe = null;
+          if (typeof onChange === 'function') {
+            const listener = function(newValue, oldValue, changedKey) {
+              if (changedKey === key) {
+                onChange(newValue, oldValue);
+              }
+            };
+            
+            // \u786E\u4FDD _listeners \u5B58\u5728
+            if (!state._listeners) {
+              state._listeners = new Map();
+            }
+            
+            // \u6CE8\u518C\u76D1\u542C\u5668
+            if (!state._listeners.has(key)) {
+              state._listeners.set(key, []);
+            }
+            state._listeners.get(key).push(listener);
+            
+            // \u8FD4\u56DE\u53D6\u6D88\u76D1\u542C\u7684\u51FD\u6570
+            unsubscribe = function() {
+              if (state._listeners) {
+                const listeners = state._listeners.get(key);
+                if (listeners) {
+                  const index = listeners.indexOf(listener);
+                  if (index > -1) {
+                    listeners.splice(index, 1);
+                  }
+                  if (listeners.length === 0) {
+                    state._listeners.delete(key);
+                  }
+                }
+              }
+            };
+          }
+          
+          // Getter \u51FD\u6570
+          const getter = function() {
+            return state[key];
+          };
+          
+          // Setter \u51FD\u6570
+          const setter = function(valueOrUpdater) {
+            const currentValue = state[key];
+            let newValue;
+            
+            // \u652F\u6301\u51FD\u6570\u5F62\u5F0F\u7684\u66F4\u65B0\uFF1Asetter(prev => newValue)
+            if (typeof valueOrUpdater === 'function') {
+              newValue = valueOrUpdater(currentValue);
+            } else {
+              newValue = valueOrUpdater;
+            }
+            
+            // \u66F4\u65B0\u72B6\u6001\uFF08\u4F1A\u81EA\u52A8\u89E6\u53D1\u76D1\u542C\u5668\u548C\u540C\u6B65\uFF09
+            state[key] = newValue;
+          };
+          
+          // \u8FD4\u56DE [getter, setter] \u6216 [getter, setter, unsubscribe]
+          if (unsubscribe) {
+            return [getter, setter, unsubscribe];
+          }
+          return [getter, setter];
+        };
+      })();
+    `;
+    try {
+      if (webView && typeof webView.evaluateJavaScript === "function") {
+        webView.evaluateJavaScript(bridgeScript);
+      }
+    } catch (error) {
+      BaseMN3.error(`Failed to inject bridge script: ${error}`, "webview");
+    }
+  }
+  /**
+   * 处理来自 WebView 的消息
+   */
+  async handleWebViewMessage(webViewId, message) {
+    const manager = getBridgeManager();
+    return manager.handleMessage(message);
+  }
+  /**
+   * 发送消息到 WebView
+   */
+  sendToWebView(webViewId, type, payload) {
+    const webView = this.webViews.get(webViewId);
+    if (!webView) {
+      BaseMN3.error(`WebView "${webViewId}" not found`, "webview");
+      return;
+    }
+    const script = `
+      if (window.__MN_RAILS_MESSAGE_HANDLER__) {
+        window.__MN_RAILS_MESSAGE_HANDLER__(${JSON.stringify({ type, payload })});
+      }
+    `;
+    try {
+      if (webView && typeof webView.evaluateJavaScript === "function") {
+        webView.evaluateJavaScript(script);
+      }
+    } catch (error) {
+      BaseMN3.error(`Failed to send message to WebView: ${error}`, "webview");
+    }
+  }
+};
+var messageBridgeInstance = null;
+function getMessageBridge() {
+  if (!messageBridgeInstance) {
+    messageBridgeInstance = new MessageBridge();
+  }
+  return messageBridgeInstance;
+}
+
+// src/state/StateManager.ts
+var StateManager = class {
+  state;
+  watchHandles = /* @__PURE__ */ new Map();
+  webViewWatchHandles = [];
+  registeredWebViews = /* @__PURE__ */ new Set();
+  autoSyncHandle = null;
+  isSyncing = false;
+  // 防止循环同步
+  constructor(initialState) {
+    this.state = reactive({ ...initialState });
+    this.setupAutoSync();
+  }
+  /**
+   * 获取状态值
+   */
+  get(key) {
+    return this.state[key];
+  }
+  /**
+   * 设置状态值
+   */
+  set(key, value) {
+    this.state[key] = value;
+  }
+  /**
+   * 获取整个状态对象
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * 监听状态变化
+   */
+  watch(key, listener, options) {
+    const keyStr = key;
+    const stopHandle = watch(
+      () => this.state[key],
+      (newValue, oldValue) => {
+        try {
+          listener(newValue, oldValue, keyStr);
+        } catch (error) {
+          MN.error(`State listener error for key "${keyStr}": ${error}`, "state");
+        }
+      },
+      {
+        immediate: options?.immediate ?? false,
+        deep: options?.deep ?? true
+      }
+    );
+    if (!this.watchHandles.has(keyStr)) {
+      this.watchHandles.set(keyStr, []);
+    }
+    this.watchHandles.get(keyStr).push(stopHandle);
+    return () => {
+      stopHandle();
+      const handles = this.watchHandles.get(keyStr);
+      if (handles) {
+        const index = handles.indexOf(stopHandle);
+        if (index > -1) {
+          handles.splice(index, 1);
+        }
+        if (handles.length === 0) {
+          this.watchHandles.delete(keyStr);
+        }
+      }
+    };
+  }
+  /**
+   * 监听整个状态变化
+   */
+  watchAll(listener) {
+    const runner = effect(() => {
+      try {
+        const currentState = { ...this.state };
+        listener(currentState);
+      } catch (error) {
+        MN.error(`WebView state listener error: ${error}`, "state");
+      }
+    });
+    this.webViewWatchHandles.push(runner);
+    return () => {
+      stop(runner);
+      const idx = this.webViewWatchHandles.indexOf(runner);
+      if (idx > -1) this.webViewWatchHandles.splice(idx, 1);
+    };
+  }
+  /**
+   * 同步状态到 WebView
+   */
+  syncToWebView(webViewId, state) {
+    const messageBridge = getMessageBridge();
+    const stateToSync = state || this.getState();
+    messageBridge.sendToWebView(webViewId, "state-update", {
+      state: stateToSync,
+      timestamp: Date.now()
+    });
+    MN.log(`State synced to WebView: ${webViewId}`, "state");
+  }
+  /**
+   * 从 WebView 同步状态
+   */
+  syncFromWebView(webViewId, state) {
+    this.isSyncing = true;
+    try {
+      Object.keys(state).forEach((key) => {
+        if (key in this.state) {
+          this.state[key] = state[key];
+        }
+      });
+      MN.log(`State synced from WebView: ${webViewId}`, "state");
+    } finally {
+      setTimeout(() => {
+        this.isSyncing = false;
+      }, 0);
+    }
+  }
+  /**
+   * 注册需要同步状态的 WebView
+   */
+  registerWebView(webViewId) {
+    if (this.registeredWebViews.has(webViewId)) {
+      MN.log(`WebView "${webViewId}" already registered`, "state");
+      return;
+    }
+    this.registeredWebViews.add(webViewId);
+    this.syncInitialState(webViewId);
+    MN.log(`WebView "${webViewId}" registered for state sync`, "state");
+  }
+  /**
+   * 取消注册 WebView
+   */
+  unregisterWebView(webViewId) {
+    if (this.registeredWebViews.delete(webViewId)) {
+      MN.log(`WebView "${webViewId}" unregistered from state sync`, "state");
+    }
+  }
+  /**
+   * 同步初始状态到新注册的 WebView
+   */
+  syncInitialState(webViewId) {
+    this.syncToWebView(webViewId);
+  }
+  /**
+   * 设置自动同步监听
+   */
+  setupAutoSync() {
+    this.autoSyncHandle = this.watchAll((state) => {
+      if (this.isSyncing) {
+        return;
+      }
+      this.registeredWebViews.forEach((webViewId) => {
+        this.syncToWebView(webViewId, state);
+      });
+    });
+  }
+  /**
+   * 清理资源
+   */
+  destroy() {
+    if (this.autoSyncHandle) {
+      this.autoSyncHandle();
+      this.autoSyncHandle = null;
+    }
+    this.watchHandles.forEach((handles) => {
+      handles.forEach((handle) => handle());
+    });
+    this.watchHandles.clear();
+    this.webViewWatchHandles.forEach((handle) => stop(handle));
+    this.webViewWatchHandles = [];
+    this.registeredWebViews.clear();
+  }
+};
+var stateManagers = /* @__PURE__ */ new Map();
+function defineState(name, initialState) {
+  const existing = stateManagers.get(name);
+  if (existing) {
+    MN.log(`State "${name}" already exists, returning existing instance`, "state");
+    return existing;
+  }
+  const manager = new StateManager(initialState);
+  stateManagers.set(name, manager);
+  MN.log(`State "${name}" defined`, "state");
+  return manager;
+}
+function getState(name) {
+  const m = stateManagers.get(name);
+  return m == null ? void 0 : m;
+}
+
+// src/webui/WebViewManager.ts
+import { MN as BaseMN5 } from "marginnote";
+
+// src/utils/file.ts
+import { MN as BaseMN4 } from "marginnote";
+function readFile(path) {
+  try {
+    const data = NSFileManager.defaultManager().contentsAtPath?.(path);
+    return data ? String(data) : null;
+  } catch (error) {
+    BaseMN4.log(`Read file failed: ${path}`, "error");
+    return null;
+  }
+}
+function fileExists(path) {
+  try {
+    const manager = NSFileManager.defaultManager();
+    return manager.fileExistsAtPath(path);
+  } catch (error) {
+    return false;
+  }
+}
+function createDirectory(path, createIntermediates = true) {
+  try {
+    const manager = NSFileManager.defaultManager();
+    const fn = manager.createDirectoryAtPathWithIntermediateDirectoriesAttributesError;
+    if (typeof fn === "function") {
+      return fn(path, createIntermediates, {}, null);
+    }
+    return manager.createDirectoryAtPathAttributes(path, {});
+  } catch (error) {
+    BaseMN4.log(`Create directory failed: ${path}`, "error");
+    return false;
+  }
+}
+function getAddonPath() {
+  try {
+    const addon = BaseMN4.currentAddon;
+    if (addon) {
+      if (addon.path) {
+        return addon.path;
+      }
+      if (addon.dir) {
+        return addon.dir;
+      }
+      if (addon.bundlePath) {
+        return addon.bundlePath;
+      }
+    }
+    return null;
+  } catch (error) {
+    BaseMN4.log(`Failed to get addon path: ${error}`, "error");
+    return null;
+  }
+}
+function getViewsPath() {
+  const addonPath = getAddonPath();
+  if (!addonPath) {
+    return null;
+  }
+  const srcViewsPath = `${addonPath}/src/views`;
+  if (fileExists(srcViewsPath)) {
+    return srcViewsPath;
+  }
+  const viewsPath = `${addonPath}/views`;
+  if (fileExists(viewsPath)) {
+    return viewsPath;
+  }
+  return null;
+}
+
+// src/webui/WebViewManager.ts
+var WebViewManager = class {
+  webViews = /* @__PURE__ */ new Map();
+  messageBridge = getMessageBridge();
+  componentCache = /* @__PURE__ */ new Map();
+  // 组件缓存
+  /**
+   * 渲染 WebView
+   */
+  async render(component, props, frame) {
+    try {
+      const webViewId = `webview-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+      const defaultFrame = frame || { x: 0, y: 0, width: 400, height: 600 };
+      const webViewFrame = {
+        x: defaultFrame.x,
+        y: defaultFrame.y,
+        width: defaultFrame.width,
+        height: defaultFrame.height
+      };
+      const webView = new UIWebView(webViewFrame);
+      const html = this.generateHTML(component, props);
+      webView.loadHTMLStringBaseURL(html, null);
+      this.messageBridge.registerWebView(webViewId, webView);
+      const defaultState = getState("__default__");
+      if (defaultState) {
+        defaultState.registerWebView(webViewId);
+      }
+      const instance = {
+        id: webViewId,
+        webView,
+        component,
+        props
+      };
+      this.webViews.set(webViewId, instance);
+      BaseMN5.log(`WebView rendered: ${webViewId}`, "webview");
+      return instance;
+    } catch (error) {
+      BaseMN5.error(`Failed to render WebView: ${error}`, "webview");
+      return null;
+    }
+  }
+  /**
+   * 加载组件文件
+   * 只允许加载编译后的文件（.js）或 HTML 文件（最终产物）
+   * 禁止运行时解析 .vue 或 .jsx 源文件
+   */
+  loadComponent(componentName) {
+    const viewsPath = getViewsPath();
+    if (!viewsPath) {
+      BaseMN5.error(`Views path not found, component loading disabled`, "webview");
+      return null;
+    }
+    const compiledJsPath = `${viewsPath}/${componentName}.js`;
+    if (fileExists(compiledJsPath)) {
+      const content = readFile(compiledJsPath);
+      if (content) {
+        BaseMN5.log(`Component loaded (compiled): ${componentName}.js`, "webview");
+        return { content, type: "js" };
+      }
+    }
+    const htmlPath = `${viewsPath}/${componentName}.html`;
+    if (fileExists(htmlPath)) {
+      const content = readFile(htmlPath);
+      if (content) {
+        BaseMN5.log(`Component loaded: ${componentName}.html`, "webview");
+        return { content, type: "html" };
+      }
+    }
+    const vuePath = `${viewsPath}/${componentName}.vue`;
+    const jsxPath = `${viewsPath}/${componentName}.jsx`;
+    if (fileExists(vuePath) || fileExists(jsxPath)) {
+      const sourceExt = fileExists(vuePath) ? ".vue" : ".jsx";
+      BaseMN5.error(
+        `Component "${componentName}" source file (${sourceExt}) found but compiled file (.js) not found. Please run "mn-rails build" or "mn-rails dev" to compile the component.`,
+        "webview"
+      );
+      return null;
+    }
+    BaseMN5.error(
+      `Component "${componentName}" not found. Expected compiled file: ${compiledJsPath} or HTML file: ${htmlPath}. If you have a .vue or .jsx source file, please run "mn-rails build" or "mn-rails dev" to compile it.`,
+      "webview"
+    );
+    return null;
+  }
+  /**
+   * 解析组件内容
+   * 只支持 HTML 和 JS 文件（最终产物）
+   * 禁止运行时解析 .vue 或 .jsx 源文件
+   */
+  parseComponentContent(content, type) {
+    if (type === "html") {
+      const scriptMatch = content.match(/<script[^>]*>([\s\S]*?)<\/script>/);
+      const styleMatch = content.match(/<style[^>]*>([\s\S]*?)<\/style>/);
+      let template = content;
+      if (scriptMatch) {
+        template = template.replace(/<script[^>]*>[\s\S]*?<\/script>/g, "");
+      }
+      if (styleMatch) {
+        template = template.replace(/<style[^>]*>[\s\S]*?<\/style>/g, "");
+      }
+      return {
+        template: template.trim(),
+        script: scriptMatch ? scriptMatch[1].trim() : void 0,
+        style: styleMatch ? styleMatch[1].trim() : void 0
+      };
+    } else {
+      return {
+        script: content
+      };
+    }
+  }
+  /**
+   * 加载类型定义文件
+   */
+  loadTypeDefinitions() {
+    const addonPath = getAddonPath();
+    if (!addonPath) {
+      return null;
+    }
+    const possiblePaths = [
+      `${addonPath}/bridge-types.js`,
+      `${addonPath}/dist/bridge-types.js`,
+      `${addonPath}/views/bridge-types.js`
+    ];
+    for (const typePath of possiblePaths) {
+      if (fileExists(typePath)) {
+        const content = readFile(typePath);
+        if (content) {
+          BaseMN5.log(`Type definitions loaded from: ${typePath}`, "webview");
+          return content;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * 生成 HTML 内容
+   */
+  generateHTML(component, props) {
+    const propsJson = props ? JSON.stringify(props) : "{}";
+    const componentData = this.loadComponent(component);
+    let templateContent = "";
+    let scriptContent = "";
+    let styleContent = "";
+    if (componentData) {
+      const parsed = this.parseComponentContent(componentData.content, componentData.type);
+      templateContent = parsed.template || "";
+      scriptContent = parsed.script || "";
+      styleContent = parsed.style || "";
+    } else {
+      templateContent = `
+        <h1>MN Rails WebView</h1>
+        <p>Component: ${component}</p>
+        <p>Props: ${propsJson}</p>
+        <p>Bridge is available: <span id="bridge-status">Checking...</span></p>
+      `;
+      scriptContent = `
+        // \u7B49\u5F85 bridge \u548C useState \u521D\u59CB\u5316
+        setTimeout(() => {
+          const statusEl = document.getElementById('bridge-status');
+          if (window.bridge) {
+            statusEl.textContent = 'Available';
+            statusEl.style.color = 'green';
+          } else {
+            statusEl.textContent = 'Not available';
+            statusEl.style.color = 'red';
+          }
+          
+          // \u68C0\u67E5 useState \u662F\u5426\u53EF\u7528
+          if (typeof window.useState === 'function') {
+            console.log('useState hook is available');
+          }
+        }, 100);
+      `;
+    }
+    const typeDefinitions = this.loadTypeDefinitions();
+    const typeScriptTag = typeDefinitions ? `<script>${typeDefinitions}</script>` : "";
+    return `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>MN Rails WebView - ${component}</title>
+  <style>
+    body {
+      margin: 0;
+      padding: 16px;
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    }
+    ${styleContent}
+  </style>
+  ${typeScriptTag}
+</head>
+<body>
+  <div id="app">
+    ${templateContent}
+  </div>
+  <script>
+    // \u4F20\u9012 props \u5230\u7EC4\u4EF6
+    window.__MN_RAILS_PROPS__ = ${propsJson};
+    
+    ${scriptContent}
+  </script>
+</body>
+</html>
+    `.trim();
+  }
+  /**
+   * 销毁 WebView
+   */
+  destroy(webViewId) {
+    const instance = this.webViews.get(webViewId);
+    if (!instance) {
+      return false;
+    }
+    const defaultState = getState("__default__");
+    if (defaultState) {
+      defaultState.unregisterWebView(webViewId);
+    }
+    this.messageBridge.unregisterWebView(webViewId);
+    this.webViews.delete(webViewId);
+    BaseMN5.log(`WebView destroyed: ${webViewId}`, "webview");
+    return true;
+  }
+  /**
+   * 获取 WebView 实例
+   */
+  get(webViewId) {
+    return this.webViews.get(webViewId);
+  }
+  /**
+   * 获取所有 WebView 实例
+   */
+  getAll() {
+    return Array.from(this.webViews.values());
+  }
+  /**
+   * 更新 WebView 的 props
+   */
+  updateProps(webViewId, props) {
+    const instance = this.webViews.get(webViewId);
+    if (!instance) {
+      return false;
+    }
+    instance.props = { ...instance.props, ...props };
+    this.messageBridge.sendToWebView(webViewId, "props-update", props);
+    return true;
+  }
+};
+var webViewManagerInstance = null;
+function getWebViewManager() {
+  if (!webViewManagerInstance) {
+    webViewManagerInstance = new WebViewManager();
+  }
+  return webViewManagerInstance;
+}
+
+// src/nativeui/NativeUIManager.ts
+import { MN as BaseMN6 } from "marginnote";
+var UIButtonType = globalThis.UIButtonType;
+var UIControlEvents = globalThis.UIControlEvents;
+var NativeUIManager = class {
+  elements = /* @__PURE__ */ new Map();
+  createButton(config) {
+    try {
+      const elementId = `button-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+      const button = UIButton.buttonWithType(UIButtonType?.system ?? 0);
+      button.setTitleForState(config.title, 0);
+      const color = this.getColorForStyle(config.style || "default");
+      button.setTitleColorForState(color, 0);
+      const frame = config.frame || { x: 0, y: 0, width: 100, height: 44 };
+      button.frame = { x: frame.x, y: frame.y, width: frame.width, height: frame.height };
+      if (config.action) {
+        button.addTargetActionForControlEvents(
+          { handleAction: config.action },
+          "handleAction",
+          UIControlEvents?.TouchUpInside ?? 64
+        );
+      }
+      const element = { id: elementId, element: button, type: "button" };
+      this.elements.set(elementId, element);
+      BaseMN6.log(`Button created: ${elementId}`, "nativeui");
+      return element;
+    } catch (error) {
+      BaseMN6.error(`Failed to create button: ${error}`, "nativeui");
+      return null;
+    }
+  }
+  createLabel(config) {
+    try {
+      const elementId = `label-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+      const frame = config.frame || { x: 0, y: 0, width: 200, height: 44 };
+      const labelFrame = { x: frame.x, y: frame.y, width: frame.width, height: frame.height };
+      const label = new UILabel(labelFrame);
+      label.text = config.text;
+      label.textColor = config.color ?? UIColor.blackColor();
+      const element = { id: elementId, element: label, type: "label" };
+      this.elements.set(elementId, element);
+      BaseMN6.log(`Label created: ${elementId}`, "nativeui");
+      return element;
+    } catch (error) {
+      BaseMN6.error(`Failed to create label: ${error}`, "nativeui");
+      return null;
+    }
+  }
+  getColorForStyle(style) {
+    switch (style) {
+      case "primary":
+        return UIColor.systemBlueColor?.() ?? UIColor.blueColor();
+      case "danger":
+        return UIColor.redColor();
+      default:
+        return UIColor.blackColor();
+    }
+  }
+  destroy(elementId) {
+    const element = this.elements.get(elementId);
+    if (!element) return false;
+    this.elements.delete(elementId);
+    BaseMN6.log(`UI element destroyed: ${elementId}`, "nativeui");
+    return true;
+  }
+  get(elementId) {
+    return this.elements.get(elementId);
+  }
+  getAll() {
+    return Array.from(this.elements.values());
+  }
+  clear() {
+    this.elements.clear();
+    BaseMN6.log("All UI elements cleared", "nativeui");
+  }
+};
+var nativeUIManagerInstance = null;
+function getNativeUIManager() {
+  if (!nativeUIManagerInstance) {
+    nativeUIManagerInstance = new NativeUIManager();
+  }
+  return nativeUIManagerInstance;
+}
+
+// src/MN.ts
+var _defaultStateName = "__default__";
+var _dbInstance = null;
+var _configInstance = null;
+function getDb() {
+  if (!_dbInstance) _dbInstance = new NoteDatabase(BaseMN7.db);
+  return _dbInstance;
+}
+function getConfig() {
+  if (!_configInstance) _configInstance = new Config(`mn-rails.${BaseMN7.currentAddon.key}`);
+  return _configInstance;
+}
+var _MN = new Proxy(BaseMN7, {
+  get(target, prop) {
+    switch (prop) {
+      case "db":
+        return getDb();
+      case "config":
+        return getConfig();
+      case "webUI": {
+        const mgr = getWebViewManager();
+        return {
+          render: (c, p, f) => mgr.render(c, p, f),
+          destroy: (id) => mgr.destroy(id),
+          get: (id) => mgr.get(id),
+          updateProps: (id, p) => mgr.updateProps(id, p)
+        };
+      }
+      case "nativeUI": {
+        const mgr = getNativeUIManager();
+        return {
+          createButton: (config) => mgr.createButton(config),
+          createLabel: (config) => mgr.createLabel(config),
+          destroy: (id) => mgr.destroy(id),
+          get: (id) => mgr.get(id),
+          clear: () => mgr.clear()
+        };
+      }
+      case "defineState":
+        return function(definition, name) {
+          return defineState(name ?? _defaultStateName, definition);
+        };
+      case "getState":
+        return function(name) {
+          return getState(name ?? _defaultStateName);
+        };
+      case "state":
+        return getState(_defaultStateName);
+      case "currentNotebookId":
+        return target.currnetNotebookId;
+      case "currentDocMd5":
+        return target.currentDocmd5;
+      default:
+        return target[prop];
+    }
+  }
+});
+var MN = _MN;
+
+// src/lifecycle/LifecycleManager.ts
+var defineLifecycleHandlers = globalThis.defineLifecycleHandlers;
+var LifecycleManager = class {
+  app;
+  constructor(app) {
+    this.app = app;
+    this.register();
+  }
+  /**
+   * 注册生命周期钩子
+   */
+  register() {
+    if (typeof defineLifecycleHandlers !== "function") {
+      console.warn("defineLifecycleHandlers is not available. Lifecycle hooks will not work.");
+      return;
+    }
+    defineLifecycleHandlers({
+      instanceMethods: {
+        // 笔记本打开时
+        notebookWillOpen: (notebookid) => {
+          this.app.onNotebookChanged?.(notebookid);
+        },
+        // 笔记本关闭时
+        notebookWillClose: (notebookid) => {
+          this.app.onNotebookClosing?.(notebookid);
+        },
+        // 文档打开时
+        documentDidOpen: (docmd5) => {
+          this.app.onDocumentOpened?.(docmd5);
+        },
+        // 文档关闭时
+        documentWillClose: (docmd5) => {
+          this.app.onDocumentClosing?.(docmd5);
+        }
+      },
+      classMethods: {
+        // 插件连接时（相当于 onLaunch）
+        addonDidConnect: () => {
+          this.app.onLaunch?.();
+        },
+        // 插件断开连接时（相当于 onExit）
+        addonWillDisconnect: () => {
+          this.app.onExit?.();
+        },
+        // 应用进入后台
+        applicationDidEnterBackground: () => {
+        },
+        // 应用进入前台
+        applicationWillEnterForeground: () => {
+        }
+      }
+    });
+  }
+  /**
+   * 手动触发笔记选中事件
+   * 
+   * MarginNote 没有提供"笔记选中"的原生生命周期钩子，因此需要开发者手动监听 MarginNote 的笔记选择相关 API，
+   * 并在检测到笔记选中时调用此方法。
+   * 
+   * 调用此方法会触发 App 的 `onNoteSelected` 钩子。
+   * 
+   * 典型用法：
+   * 1. 在 App 的 `onLaunch` 中注册 MarginNote 的笔记选择监听器（如通过 `MN.notificationCenter` 或其他 API）
+   * 2. 在监听器回调中调用 `this.lifecycle.triggerNoteSelected(note)`
+   * 3. 框架会自动调用 App 的 `onNoteSelected` 方法
+   * 
+   * @param note - 被选中的笔记对象
+   * 
+   * @example
+   * ```typescript
+   * class MyPlugin extends App {
+   *   onLaunch() {
+   *     // 注册笔记选择监听
+   *     MN.notificationCenter.addObserver('noteSelected', (note) => {
+   *       this.lifecycle?.triggerNoteSelected(note);
+   *     });
+   *   }
+   * 
+   *   onNoteSelected(note) {
+   *     console.log('Note selected:', note);
+   *   }
+   * }
+   * ```
+   */
+  triggerNoteSelected(note) {
+    this.app.onNoteSelected?.(note);
+  }
+  /**
+   * 手动触发配置文件切换事件
+   * 
+   * MarginNote 没有提供"配置文件切换"的原生生命周期钩子，因此需要开发者手动监听 MarginNote 的配置切换相关 API，
+   * 并在检测到配置切换时调用此方法。
+   * 
+   * 调用此方法会触发 App 的 `onProfileChanged` 钩子。
+   * 
+   * 典型用法：
+   * 1. 在 App 的 `onLaunch` 中注册 MarginNote 的配置切换监听器（如通过 `MN.notificationCenter` 或其他 API）
+   * 2. 在监听器回调中调用 `this.lifecycle.triggerProfileChanged(profileId)`
+   * 3. 框架会自动调用 App 的 `onProfileChanged` 方法
+   * 
+   * @param profileId - 新的配置文件 ID
+   * 
+   * @example
+   * ```typescript
+   * class MyPlugin extends App {
+   *   onLaunch() {
+   *     // 注册配置切换监听
+   *     MN.notificationCenter.addObserver('profileChanged', (profileId) => {
+   *       this.lifecycle?.triggerProfileChanged(profileId);
+   *     });
+   *   }
+   * 
+   *   onProfileChanged(profileId) {
+   *     console.log('Profile changed to:', profileId);
+   *   }
+   * }
+   * ```
+   */
+  triggerProfileChanged(profileId) {
+    this.app.onProfileChanged?.(profileId);
+  }
+};
+
+// src/App.ts
+var App = class {
+  lifecycleManager;
+  constructor() {
+    this.lifecycleManager = new LifecycleManager(this);
+  }
+  /**
+   * 获取生命周期管理器（用于手动触发事件）
+   * 
+   * 返回 LifecycleManager 实例，用于在 App 子类中手动触发某些生命周期事件。
+   * 
+   * 典型用法：
+   * - 在 `onLaunch` 中注册 MarginNote 的监听器（如笔记选择、配置切换等）
+   * - 在监听器回调中调用 `this.lifecycle.triggerNoteSelected(note)` 或 `this.lifecycle.triggerProfileChanged(profileId)`
+   * - 这些调用会触发对应的 `onNoteSelected` 或 `onProfileChanged` 钩子
+   * 
+   * @example
+   * ```typescript
+   * class MyPlugin extends App {
+   *   onLaunch() {
+   *     // 注册笔记选择监听
+   *     MN.notificationCenter.addObserver('noteSelected', (note) => {
+   *       this.lifecycle?.triggerNoteSelected(note);
+   *     });
+   *   }
+   * }
+   * ```
+   */
+  get lifecycle() {
+    return this.lifecycleManager;
+  }
+};
+
+// src/Controller.ts
+var Controller = class {
+  controllerName;
+  constructor(name) {
+    this.controllerName = name || this.constructor.name;
+    this.registerActions();
+  }
+  /**
+   * Controller 销毁时调用
+   */
+  onDestroy() {
+    this.unregisterActions();
+  }
+  /**
+   * 定义供 Web 端调用的 actions
+   * 子类应该重写此属性以提供类型安全的 API
+   */
+  actions = {};
+  /**
+   * 注册 actions 到 Bridge
+   */
+  registerActions() {
+    if (Object.keys(this.actions).length > 0) {
+      const manager = getBridgeManager();
+      manager.register(this.controllerName, this.actions);
+    }
+  }
+  /**
+   * 注销 actions
+   */
+  unregisterActions() {
+    const manager = getBridgeManager();
+    manager.unregister(this.controllerName);
+  }
+  /**
+   * 更新 actions（当 actions 发生变化时调用）
+   */
+  updateActions() {
+    this.unregisterActions();
+    this.registerActions();
+  }
+};
+
+// src/bridge/web-bridge.ts
+function createWebBridge() {
+  const w = typeof window !== "undefined" ? window : void 0;
+  if (w?.bridge) return w.bridge;
+  return new Proxy({}, {
+    get(_target, controllerName) {
+      return new Proxy({}, {
+        get(_t, actionName) {
+          return async (...args) => {
+            const g = typeof window !== "undefined" ? window : void 0;
+            if (g?.__MN_RAILS_BRIDGE__) {
+              return g.__MN_RAILS_BRIDGE__.call(controllerName, actionName, ...args);
+            }
+            throw new Error("Bridge not available");
+          };
+        }
+      });
+    }
+  });
+}
+
+// src/utils/dialog.ts
+var UIAlertViewStyle = globalThis.UIAlertViewStyle;
+var _lang = typeof globalThis.lang !== "undefined" ? globalThis.lang : { sure: "OK", cancel: "Cancel", make_your_choice: "Make your choice" };
+function alert(message) {
+  try {
+    MN.app.alert(message);
+  } catch (error) {
+    MN.log(`Alert failed: ${error}`, "error");
+  }
+}
+function popup(options) {
+  const {
+    title = MN.currentAddon.title,
+    message,
+    type = UIAlertViewStyle?.Default ?? 0,
+    buttons = [_lang.sure],
+    canCancel = true,
+    multiLine = false
+  } = options;
+  return new Promise((resolve) => {
+    try {
+      if (canCancel) {
+        UIAlertView.showWithTitleMessageStyleCancelButtonTitleOtherButtonTitlesTapBlock(
+          title,
+          message,
+          type,
+          _lang.cancel,
+          multiLine ? buttons.map((k) => byteSlice(k.replace(/\n/g, ""), 0, 40)) : buttons,
+          (alert2, buttonIndex) => {
+            resolve({
+              inputContent: type === (UIAlertViewStyle?.Default ?? 0) ? void 0 : alert2.textFieldAtIndex(0)?.text,
+              buttonIndex: buttonIndex - 1
+            });
+          }
+        );
+      } else {
+        UIAlertView.showWithTitleMessageStyleCancelButtonTitleOtherButtonTitlesTapBlock(
+          title,
+          message,
+          type,
+          multiLine ? byteSlice(buttons[0].replace(/\n/g, ""), 0, 40) : buttons[0],
+          multiLine ? buttons.slice(1).map((k) => byteSlice(k.replace(/\n/g, ""), 0, 40)) : buttons.slice(1),
+          (alert2, buttonIndex) => {
+            resolve({
+              inputContent: type === (UIAlertViewStyle?.Default ?? 0) ? void 0 : alert2.textFieldAtIndex(0)?.text,
+              buttonIndex
+            });
+          }
+        );
+      }
+    } catch (error) {
+      MN.log(`Popup failed: ${error}`, "error");
+      resolve({ buttonIndex: -1 });
+    }
+  });
+}
+async function confirm(title = MN.currentAddon.title, message = "") {
+  const { buttonIndex } = await popup({
+    title,
+    message,
+    buttons: [_lang.sure],
+    multiLine: false,
+    canCancel: true
+  });
+  return buttonIndex === 0;
+}
+async function select(options, title = MN.currentAddon.title, message = _lang.make_your_choice, canCancel = false) {
+  const { buttonIndex } = await popup({
+    title,
+    message,
+    buttons: options,
+    multiLine: true,
+    canCancel
+  });
+  if (buttonIndex === -1) {
+    return null;
+  }
+  return {
+    value: options[buttonIndex],
+    index: buttonIndex
+  };
+}
+function byteLength(text) {
+  return Array.from(text).reduce((acc, cur) => {
+    acc += cur.charCodeAt(0) > 255 ? 2 : 1;
+    return acc;
+  }, 0);
+}
+function byteSlice(text, begin, ...rest) {
+  const res = [begin, ...rest].map((k) => {
+    if (k < 0) k = byteLength(text) + k;
+    if (k === 0 || k === 1) return k;
+    return Array.from(text).reduce(
+      (acc, cur, index) => {
+        const byte = acc.byte + (cur.charCodeAt(0) > 255 ? 2 : 1);
+        if (!acc.enough && byte <= k) {
+          acc = { index, byte, enough: false };
+        } else {
+          if (!acc.enough) {
+            acc.enough = true;
+          }
+        }
+        return acc;
+      },
+      { index: 0, byte: 0, enough: false }
+    ).index + 1;
+  });
+  return text.slice(res[0], res[1]);
+}
+
+// src/utils/note.ts
+function getNoteAllText(note) {
+  const parts = [];
+  if (note.noteTitle) {
+    parts.push(note.noteTitle);
+  }
+  if (note.excerptText) {
+    parts.push(note.excerptText);
+  }
+  if (note.comments && note.comments.length > 0) {
+    note.comments.forEach((comment) => {
+      if (comment.type === "TextNote" && comment.text) {
+        parts.push(comment.text);
+      }
+    });
+  }
+  return parts.join("\n\n");
+}
+function isNoteExist(note) {
+  if (typeof note === "string") {
+    return MN.db.getNoteById(note) !== null;
+  } else {
+    return MN.db.getNoteById(note.noteId) !== null;
+  }
+}
+function getLinkedNotes(note) {
+  const linkedNotes = [];
+  if (note.linkedNotes && note.linkedNotes.length > 0) {
+    note.linkedNotes.forEach((link) => {
+      const linkedNote = MN.db.getNoteById(link.noteid);
+      if (linkedNote) {
+        linkedNotes.push(linkedNote);
+      }
+    });
+  }
+  return linkedNotes;
+}
+function getChildNotes(note) {
+  return note.childNotes || [];
+}
+function getParentNote(note) {
+  return note.parentNote || null;
+}
+export {
+  App,
+  BridgeManager,
+  Config,
+  Controller,
+  LifecycleManager,
+  MN,
+  MessageBridge,
+  NativeUIManager,
+  NoteDatabase,
+  StateManager,
+  WebViewManager,
+  alert,
+  bridge,
+  confirm,
+  createDirectory,
+  createWebBridge,
+  defineState,
+  fileExists,
+  getAddonPath,
+  getBridgeManager,
+  getChildNotes,
+  getLinkedNotes,
+  getMessageBridge,
+  getNativeUIManager,
+  getNoteAllText,
+  getParentNote,
+  getState,
+  getViewsPath,
+  getWebViewManager,
+  isNoteExist,
+  popup,
+  readFile,
+  select
+};