@ayden-fc2/riffle-bridge-web 1.0.0

package/dist/index.js

@@ -0,0 +1,942 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AudioController: () => AudioController,
+  BridgeCore: () => BridgeCore,
+  CameraController: () => CameraController,
+  ConfigController: () => ConfigController,
+  DeviceController: () => DeviceController,
+  FileStorageController: () => FileStorageController,
+  HapticController: () => HapticController,
+  MicrophoneController: () => MicrophoneController,
+  RiffleBridge: () => RiffleBridge,
+  RiffleBridgeTweaks: () => RiffleBridgeTweaks,
+  SensorController: () => SensorController,
+  TweakValue: () => TweakValue,
+  Utils: () => Utils,
+  createTweaks: () => createTweaks,
+  getBridgeCore: () => getBridgeCore,
+  getRiffleBridge: () => getRiffleBridge,
+  riffleBridgeTweaks: () => riffleBridgeTweaks
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core.ts
+var TIMEOUT_CONFIG = {
+  fileStorage: {
+    downloadAndSave: 3e4,
+    downloadWithCache: 3e4,
+    takePhoto: 15e3,
+    pickFromGallery: 15e3,
+    default: 1e4
+  },
+  device: {
+    default: 8e3
+  },
+  default: {
+    default: 5e3
+  }
+};
+function getTimeout(module2, method) {
+  const moduleConfig = TIMEOUT_CONFIG[module2] || TIMEOUT_CONFIG.default;
+  return moduleConfig[method] || moduleConfig.default || 5e3;
+}
+var BridgeCore = class {
+  constructor() {
+    this.messageId = 0;
+    this.initialized = false;
+    this.sensorHandlers = /* @__PURE__ */ new Map();
+    this.init();
+  }
+  /**
+   * 初始化 Bridge
+   */
+  init() {
+    if (this.initialized) return;
+    if (!window.__RIFFLE_CALLBACKS__) {
+      window.__RIFFLE_CALLBACKS__ = /* @__PURE__ */ new Map();
+    }
+    window.handleNativeResponse = this.handleResponse.bind(this);
+    window.handleSensorData = this.handleSensorData.bind(this);
+    window.__RIFFLE_SENSOR_HANDLERS__ = this.sensorHandlers;
+    this.initialized = true;
+    console.log("[RiffleBridge] Core initialized");
+  }
+  /**
+   * 检查是否在 React Native WebView 环境中
+   */
+  isAvailable() {
+    return typeof window !== "undefined" && typeof window.ReactNativeWebView !== "undefined";
+  }
+  /**
+   * 等待 Bridge 就绪
+   */
+  async waitForReady(timeout = 3e3) {
+    if (this.isAvailable()) return true;
+    return new Promise((resolve) => {
+      const startTime = Date.now();
+      const check = () => {
+        if (this.isAvailable()) {
+          resolve(true);
+          return;
+        }
+        if (Date.now() - startTime > timeout) {
+          resolve(false);
+          return;
+        }
+        setTimeout(check, 50);
+      };
+      check();
+    });
+  }
+  /**
+   * 确保在 React Native WebView 环境中运行
+   * @throws Error 如果不在 RN WebView 环境中
+   */
+  ensureAvailable() {
+    if (!this.isAvailable()) {
+      throw new Error(
+        "[RiffleBridge] Not available. This SDK requires React Native WebView environment.\nPlease ensure:\n1. Your app is running inside a React Native WebView\n2. Native side has injected the minimal bridge script\n3. window.ReactNativeWebView is available"
+      );
+    }
+  }
+  /**
+   * 发送消息到 Native
+   * @throws Error 如果不在 RN WebView 环境中
+   */
+  async send(module2, method, params = {}) {
+    this.ensureAvailable();
+    const id = `msg_${++this.messageId}_${Date.now()}`;
+    const timeout = getTimeout(module2, method);
+    return new Promise((resolve, reject) => {
+      window.__RIFFLE_CALLBACKS__.set(id, (response) => {
+        if (response.success) {
+          resolve(response.data);
+        } else {
+          reject(new Error(response.error || "Unknown error"));
+        }
+      });
+      const message = {
+        id,
+        module: module2,
+        method,
+        params,
+        timestamp: Date.now()
+      };
+      window.ReactNativeWebView.postMessage(JSON.stringify(message));
+      setTimeout(() => {
+        if (window.__RIFFLE_CALLBACKS__.has(id)) {
+          window.__RIFFLE_CALLBACKS__.delete(id);
+          reject(new Error(`Request timeout (${timeout / 1e3}s) for ${module2}.${method}`));
+        }
+      }, timeout);
+    });
+  }
+  /**
+   * 处理 Native 响应
+   */
+  handleResponse(responseStr) {
+    try {
+      const response = JSON.parse(responseStr);
+      const callback = window.__RIFFLE_CALLBACKS__?.get(response.id);
+      if (callback) {
+        window.__RIFFLE_CALLBACKS__.delete(response.id);
+        callback(response);
+      }
+    } catch (error) {
+      console.error("[RiffleBridge] Failed to handle response:", error);
+    }
+  }
+  /**
+   * 处理传感器数据
+   */
+  handleSensorData(data) {
+    const { sensor, values } = data;
+    const handlers = this.sensorHandlers.get(sensor);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(values);
+        } catch (error) {
+          console.error(`[RiffleBridge] Sensor callback error (${sensor}):`, error);
+        }
+      });
+    }
+  }
+  /**
+   * 订阅传感器数据
+   */
+  onSensorData(sensor, callback) {
+    if (!this.sensorHandlers.has(sensor)) {
+      this.sensorHandlers.set(sensor, /* @__PURE__ */ new Set());
+    }
+    this.sensorHandlers.get(sensor).add(callback);
+    return () => {
+      this.sensorHandlers.get(sensor)?.delete(callback);
+    };
+  }
+  /**
+   * 清除所有传感器订阅
+   */
+  clearSensorSubscriptions() {
+    this.sensorHandlers.clear();
+  }
+};
+var bridgeCoreInstance = null;
+function getBridgeCore() {
+  if (!bridgeCoreInstance) {
+    bridgeCoreInstance = new BridgeCore();
+  }
+  return bridgeCoreInstance;
+}
+
+// src/controllers/index.ts
+var HapticController = class {
+  constructor(core) {
+    this.core = core;
+  }
+  async light() {
+    await this.core.send("haptic", "light");
+  }
+  async medium() {
+    await this.core.send("haptic", "medium");
+  }
+  async heavy() {
+    await this.core.send("haptic", "heavy");
+  }
+  async success() {
+    await this.core.send("haptic", "success");
+  }
+  async warning() {
+    await this.core.send("haptic", "warning");
+  }
+  async error() {
+    await this.core.send("haptic", "error");
+  }
+  async selection() {
+    await this.core.send("haptic", "selection");
+  }
+  /**
+   * 播放震动序列
+   */
+  async sequence(types, interval = 200) {
+    for (let i = 0; i < types.length; i++) {
+      const type = types[i];
+      const method = this[type];
+      if (typeof method === "function") {
+        await method.call(this);
+      }
+      if (i < types.length - 1) {
+        await new Promise((resolve) => setTimeout(resolve, interval));
+      }
+    }
+  }
+  /**
+   * 根据强度震动
+   */
+  async intensity(level) {
+    if (level <= 0.3) return this.light();
+    if (level <= 0.7) return this.medium();
+    return this.heavy();
+  }
+};
+var SensorController = class {
+  constructor(core) {
+    this.core = core;
+    this.isActive = false;
+    this.activeTypes = [];
+  }
+  /**
+   * 启动传感器
+   */
+  async start(options = {}) {
+    const {
+      types = ["accelerometer", "gyroscope", "magnetometer", "barometer"],
+      interval = 100
+    } = options;
+    const result = await this.core.send(
+      "sensors",
+      "start",
+      { types, updateInterval: interval }
+    );
+    this.isActive = true;
+    this.activeTypes = types;
+    return result;
+  }
+  /**
+   * 停止传感器
+   */
+  async stop() {
+    const result = await this.core.send("sensors", "stop");
+    this.isActive = false;
+    this.activeTypes = [];
+    return result;
+  }
+  /**
+   * 监听加速度计数据
+   */
+  onAccelerometer(callback) {
+    return this.core.onSensorData("accelerometer", callback);
+  }
+  /**
+   * 监听陀螺仪数据
+   */
+  onGyroscope(callback) {
+    return this.core.onSensorData("gyroscope", callback);
+  }
+  /**
+   * 监听磁力计数据
+   */
+  onMagnetometer(callback) {
+    return this.core.onSensorData("magnetometer", callback);
+  }
+  /**
+   * 监听气压计数据
+   */
+  onBarometer(callback) {
+    return this.core.onSensorData("barometer", callback);
+  }
+  /**
+   * 获取当前状态
+   */
+  getStatus() {
+    return { isActive: this.isActive, activeTypes: this.activeTypes };
+  }
+};
+var DeviceController = class {
+  constructor(core) {
+    this.core = core;
+  }
+  async getDeviceInfo() {
+    return this.core.send("device", "getDeviceInfo");
+  }
+  async getBatteryInfo() {
+    return this.core.send("device", "getBatteryInfo");
+  }
+  async getNetworkInfo() {
+    return this.core.send("device", "getNetworkInfo");
+  }
+  async getSystemInfo() {
+    return this.core.send("device", "getSystemInfo");
+  }
+  async getAppInfo() {
+    return this.core.send("device", "getAppInfo");
+  }
+  async getScreenInfo() {
+    return this.core.send("device", "getScreenInfo");
+  }
+  async getAllInfo() {
+    return this.core.send("device", "getAllInfo");
+  }
+};
+var FileStorageController = class {
+  constructor(core) {
+    this.core = core;
+  }
+  async init() {
+    return this.core.send("fileStorage", "init");
+  }
+  async getStorageStats() {
+    return this.core.send("fileStorage", "getStorageStats");
+  }
+  async takePhoto() {
+    return this.core.send("fileStorage", "takePhoto");
+  }
+  async pickFromGallery() {
+    return this.core.send("fileStorage", "pickFromGallery");
+  }
+  async saveFile(sourceUri, filename, subfolder) {
+    return this.core.send("fileStorage", "saveFile", {
+      sourceUri,
+      filename,
+      subfolder
+    });
+  }
+  async listFiles(subfolder) {
+    return this.core.send("fileStorage", "listFiles", { subfolder });
+  }
+  async downloadAndSave(url, filename, subfolder) {
+    return this.core.send("fileStorage", "downloadAndSave", {
+      url,
+      downloadFilename: filename,
+      downloadSubfolder: subfolder
+    });
+  }
+  async getLocalFileByUrl(url) {
+    return this.core.send("fileStorage", "getLocalFileByUrl", {
+      checkUrl: url
+    });
+  }
+  async clearAppFiles() {
+    return this.core.send("fileStorage", "clearAppFiles");
+  }
+  async deleteFile(filename, subfolder) {
+    return this.core.send("fileStorage", "deleteFile", {
+      deleteFilename: filename,
+      deleteSubfolder: subfolder
+    });
+  }
+  async loadUrlMappings() {
+    return this.core.send("fileStorage", "loadUrlMappings");
+  }
+  async downloadWithCache(url, checkCache = true) {
+    return this.core.send("fileStorage", "downloadWithCache", {
+      downloadUrl: url,
+      checkCache
+    });
+  }
+  async clearUrlMappings() {
+    return this.core.send("fileStorage", "clearUrlMappings");
+  }
+  async removeUrlMapping(url) {
+    return this.core.send("fileStorage", "removeUrlMapping", { removeUrl: url });
+  }
+  async addCustomFileMapping(customKey, localUri) {
+    return this.core.send("fileStorage", "addCustomFileMapping", {
+      customKey,
+      localPath: localUri
+    });
+  }
+  async readAsBase64(uriOrKey) {
+    return this.core.send("fileStorage", "readAsBase64", { uriOrKey });
+  }
+};
+var AudioController = class {
+  constructor(core, fileStorage) {
+    this.core = core;
+    this.fileStorage = fileStorage;
+  }
+  /**
+   * 解析 URI，返回可播放的实际路径
+   */
+  async resolveUri(uri) {
+    if (!uri) throw new Error("URI is required");
+    if (uri.startsWith("file://")) {
+      return uri;
+    }
+    if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
+      const cached = await this.fileStorage.getLocalFileByUrl(uri);
+      if (cached?.exists && cached.uri) {
+        return cached.uri;
+      }
+      throw new Error(`File mapping not found: ${uri}`);
+    }
+    try {
+      const cached = await this.fileStorage.getLocalFileByUrl(uri);
+      if (cached?.exists && cached.uri) {
+        return cached.uri;
+      }
+    } catch {
+    }
+    return uri;
+  }
+  /**
+   * 播放音频（智能解析 URI）
+   */
+  async playOnline(options) {
+    const { uri, ...playOptions } = options;
+    let resolvedUri = await this.resolveUri(uri);
+    if (uri.startsWith("http") && resolvedUri === uri) {
+      try {
+        const downloadResult = await this.fileStorage.downloadWithCache(uri);
+        if (downloadResult?.uri) {
+          resolvedUri = downloadResult.uri;
+        }
+      } catch (e) {
+        console.warn("[AudioController] Cache failed, using online URL:", e);
+      }
+    }
+    return this.core.send("audio", "playOnline", {
+      ...playOptions,
+      uri: resolvedUri
+    });
+  }
+  async pause() {
+    return this.core.send("audio", "pause");
+  }
+  async resume() {
+    return this.core.send("audio", "resume");
+  }
+  async stop() {
+    return this.core.send("audio", "stop");
+  }
+  async setVolume(volume) {
+    return this.core.send("audio", "setVolume", { volume });
+  }
+  async setRate(rate) {
+    return this.core.send("audio", "setRate", { rate });
+  }
+  async getStatus() {
+    return this.core.send("audio", "getStatus");
+  }
+};
+var CameraController = class {
+  constructor(core) {
+    this.core = core;
+  }
+  async open(options = {}) {
+    const { facing = "back" } = options;
+    return this.core.send("camera", "open", { facing });
+  }
+  async close() {
+    return this.core.send("camera", "close");
+  }
+  async toggleFacing() {
+    return this.core.send("camera", "toggleFacing");
+  }
+  async takePhoto() {
+    return this.core.send("camera", "takePhoto");
+  }
+  async setFilter(filter) {
+    return this.core.send("camera", "setFilter", { filter });
+  }
+  async setFlash(enabled) {
+    return this.core.send("camera", "setFlash", { enabled });
+  }
+  async toggleFlash() {
+    return this.core.send("camera", "toggleFlash");
+  }
+};
+var MicrophoneController = class {
+  constructor(core) {
+    this.core = core;
+    this.isRecording = false;
+  }
+  async requestPermission() {
+    return this.core.send("microphone", "requestPermission");
+  }
+  async start(options = {}) {
+    const { enableMonitoring = true } = options;
+    const result = await this.core.send("microphone", "start", {
+      enableMonitoring
+    });
+    this.isRecording = true;
+    return result;
+  }
+  async stop() {
+    const result = await this.core.send("microphone", "stop");
+    this.isRecording = false;
+    return result;
+  }
+  async pause() {
+    return this.core.send("microphone", "pause");
+  }
+  async resume() {
+    return this.core.send("microphone", "resume");
+  }
+  async getStatus() {
+    return this.core.send("microphone", "getStatus");
+  }
+  /**
+   * 监听音量数据
+   */
+  onVolumeData(callback) {
+    return this.core.onSensorData("microphone_volume", callback);
+  }
+  getRecordingState() {
+    return this.isRecording;
+  }
+};
+var ConfigController = class {
+  constructor(core) {
+    this.core = core;
+    this.currentConfig = null;
+  }
+  async updateParams(configData) {
+    this.currentConfig = configData;
+    return this.core.send("config", "updateParams", configData);
+  }
+  getCurrentConfig() {
+    return this.currentConfig;
+  }
+  async resetToDefaults() {
+    return this.core.send("config", "resetToDefaults");
+  }
+};
+
+// src/bridge.ts
+var Utils = class {
+  /**
+   * 计算向量模长
+   */
+  static magnitude(x, y, z) {
+    return Math.sqrt(x * x + y * y + z * z);
+  }
+  /**
+   * 获取倾斜方向
+   */
+  static getTiltDirection(x, y, threshold = 2) {
+    if (Math.abs(x) > Math.abs(y)) {
+      return x > threshold ? "right" : x < -threshold ? "left" : "center";
+    } else {
+      return y > threshold ? "forward" : y < -threshold ? "backward" : "center";
+    }
+  }
+  /**
+   * 获取摇晃强度
+   */
+  static getShakeIntensity(x, y, z) {
+    const magnitude = this.magnitude(x, y, z);
+    if (magnitude > 15) return "strong";
+    if (magnitude > 8) return "medium";
+    if (magnitude > 3) return "light";
+    return "none";
+  }
+};
+var RiffleBridge = class {
+  constructor() {
+    /** 工具函数 */
+    this.utils = Utils;
+    this.core = getBridgeCore();
+    this.haptic = new HapticController(this.core);
+    this.sensor = new SensorController(this.core);
+    this.device = new DeviceController(this.core);
+    this.fileStorage = new FileStorageController(this.core);
+    this.audio = new AudioController(this.core, this.fileStorage);
+    this.camera = new CameraController(this.core);
+    this.microphone = new MicrophoneController(this.core);
+    this.config = new ConfigController(this.core);
+  }
+  /**
+   * 检查 Bridge 是否可用
+   */
+  isAvailable() {
+    return this.core.isAvailable();
+  }
+  /**
+   * 等待 Bridge 就绪
+   */
+  async waitForReady(timeout) {
+    return this.core.waitForReady(timeout);
+  }
+  /**
+   * 获取 SDK 版本
+   */
+  getVersion() {
+    return "1.0.0";
+  }
+  /**
+   * 便捷方法：震动
+   */
+  async vibrate(type = "light") {
+    const method = this.haptic[type];
+    if (typeof method === "function") {
+      await method.call(this.haptic);
+    } else {
+      throw new Error(`Unsupported haptic type: ${type}`);
+    }
+  }
+};
+var riffleBridgeInstance = null;
+function getRiffleBridge() {
+  if (!riffleBridgeInstance) {
+    riffleBridgeInstance = new RiffleBridge();
+  }
+  return riffleBridgeInstance;
+}
+
+// src/tweaks.ts
+var TweakValue = class {
+  constructor(_key, _config, syncCallback = null) {
+    this._key = _key;
+    this._config = _config;
+    this._listeners = /* @__PURE__ */ new Set();
+    this._value = _config.value;
+    this._syncCallback = syncCallback;
+  }
+  /** 获取当前值 */
+  get value() {
+    return this._value;
+  }
+  /** 获取配置 */
+  get config() {
+    return this._config;
+  }
+  /** 获取键名 */
+  get key() {
+    return this._key;
+  }
+  /**
+   * 设置值
+   * @param newValue 新值
+   * @param skipSync 是否跳过同步到 Native
+   */
+  set(newValue, skipSync = false) {
+    if (this._value !== newValue) {
+      this._value = newValue;
+      this._notifyListeners();
+      if (!skipSync && this._syncCallback) {
+        this._syncCallback();
+      }
+    }
+  }
+  /**
+   * 内部设置（不触发同步，用于接收 Native 更新）
+   */
+  _setInternal(newValue) {
+    if (this._value !== newValue) {
+      this._value = newValue;
+      this._notifyListeners();
+    }
+  }
+  /**
+   * 订阅值变化
+   */
+  subscribe(listener) {
+    this._listeners.add(listener);
+    return () => this._listeners.delete(listener);
+  }
+  /**
+   * 监听值变化
+   */
+  onChange(callback) {
+    return this.subscribe(() => callback(this._value));
+  }
+  /**
+   * React Hook: 获取响应式值
+   * 需要传入 React 实例或使用 createTweaks 时传入
+   */
+  useState(react) {
+    const ReactRef = react || _globalReact;
+    if (!ReactRef?.useSyncExternalStore) {
+      console.warn("[RiffleBridgeTweaks] React.useSyncExternalStore not available, returning static value");
+      return this._value;
+    }
+    return ReactRef.useSyncExternalStore(
+      (callback) => this.subscribe(callback),
+      () => this._value,
+      () => this._value
+    );
+  }
+  _notifyListeners() {
+    this._listeners.forEach((listener) => {
+      try {
+        listener();
+      } catch (e) {
+        console.error("[RiffleBridgeTweaks] Listener error:", e);
+      }
+    });
+  }
+};
+var _globalReact = null;
+var RiffleBridgeTweaks = class {
+  constructor(config) {
+    this._tweaks = /* @__PURE__ */ new Map();
+    this._syncDebounceTimer = null;
+    this._config = config;
+    const debouncedSync = () => {
+      if (this._syncDebounceTimer) {
+        clearTimeout(this._syncDebounceTimer);
+      }
+      this._syncDebounceTimer = setTimeout(() => {
+        this._syncToNative();
+      }, 50);
+    };
+    for (const [key, cfg] of Object.entries(config)) {
+      this._tweaks.set(key, new TweakValue(key, cfg, debouncedSync));
+    }
+    this._setupMessageListener();
+    this._setupGlobalCallbacks();
+    this._syncToNative();
+    console.log("[RiffleBridgeTweaks] Initialized");
+  }
+  /**
+   * 获取指定键的配置项
+   */
+  get(key) {
+    return this._tweaks.get(key);
+  }
+  /**
+   * 获取所有值
+   */
+  getData() {
+    const data = {};
+    for (const [key, tweak] of this._tweaks) {
+      data[key] = tweak.value;
+    }
+    return data;
+  }
+  /**
+   * 获取完整配置（含元数据）
+   */
+  toJSON() {
+    const result = {};
+    for (const [key, tweak] of this._tweaks) {
+      result[key] = { ...tweak.config, value: tweak.value };
+    }
+    return result;
+  }
+  /**
+   * 批量更新值
+   */
+  update(updates) {
+    for (const [key, value] of Object.entries(updates)) {
+      const tweak = this._tweaks.get(key);
+      if (tweak) {
+        tweak.set(value);
+      }
+    }
+    this._syncToNative();
+  }
+  /**
+   * 重置为默认值
+   */
+  reset() {
+    for (const [key, tweak] of this._tweaks) {
+      tweak.set(this._config[key].value);
+    }
+    this._syncToNative();
+  }
+  /**
+   * 获取所有配置键名
+   */
+  keys() {
+    return Array.from(this._tweaks.keys());
+  }
+  /**
+   * 监听任意参数变化
+   */
+  onAnyChange(callback) {
+    const unsubscribes = [];
+    for (const [key, tweak] of this._tweaks) {
+      unsubscribes.push(tweak.onChange((value) => callback(key, value)));
+    }
+    return () => unsubscribes.forEach((unsub) => unsub());
+  }
+  /**
+   * 设置消息监听
+   */
+  _setupMessageListener() {
+    if (typeof window === "undefined") return;
+    window.addEventListener("message", (event) => {
+      const data = event.data;
+      if (!data || typeof data !== "object") return;
+      const { type, payload } = data;
+      if (type === "tweak-update" && payload) {
+        const { key, value } = payload;
+        const tweak = this._tweaks.get(key);
+        if (tweak) {
+          tweak._setInternal(value);
+        }
+      }
+      if (type === "tweaks-update" && payload) {
+        for (const [key, value] of Object.entries(payload)) {
+          const tweak = this._tweaks.get(key);
+          if (tweak) {
+            tweak._setInternal(value);
+          }
+        }
+      }
+    });
+  }
+  /**
+   * 设置全局回调函数（兼容旧版 Native 调用方式）
+   */
+  _setupGlobalCallbacks() {
+    if (typeof window === "undefined") return;
+    const self = this;
+    window.updateConfigFromNative = function(key, value) {
+      const tweak = self._tweaks.get(key);
+      if (tweak) {
+        tweak._setInternal(value);
+      }
+    };
+    window.applyConfigFromNative = function(allData) {
+      for (const [key, value] of Object.entries(allData)) {
+        const tweak = self._tweaks.get(key);
+        if (tweak) {
+          tweak._setInternal(value);
+        }
+      }
+    };
+    window.resetConfigToDefaults = function() {
+      for (const [key, tweak] of self._tweaks) {
+        tweak._setInternal(self._config[key].value);
+      }
+    };
+  }
+  /**
+   * 同步配置到 Native
+   */
+  _syncToNative() {
+    try {
+      const bridge = getRiffleBridge();
+      if (!bridge.isAvailable()) {
+        return;
+      }
+      bridge.config.updateParams({
+        tweaks: this.toJSON(),
+        data: this.getData(),
+        timestamp: Date.now()
+      });
+    } catch (e) {
+      console.error("[RiffleBridgeTweaks] Sync failed:", e);
+    }
+  }
+};
+function createTweaks(config, options = {}) {
+  if (options.React) {
+    _globalReact = options.React;
+  }
+  const instance = new RiffleBridgeTweaks(config);
+  return new Proxy(instance, {
+    get(target, prop) {
+      if (prop in target) {
+        const value = target[prop];
+        return typeof value === "function" ? value.bind(target) : value;
+      }
+      return target.get(prop);
+    },
+    ownKeys(target) {
+      return target.keys();
+    },
+    getOwnPropertyDescriptor(target, prop) {
+      if (target.keys().includes(prop)) {
+        return { enumerable: true, configurable: true };
+      }
+      return void 0;
+    }
+  });
+}
+function riffleBridgeTweaks(config, options = {}) {
+  return createTweaks(config, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AudioController,
+  BridgeCore,
+  CameraController,
+  ConfigController,
+  DeviceController,
+  FileStorageController,
+  HapticController,
+  MicrophoneController,
+  RiffleBridge,
+  RiffleBridgeTweaks,
+  SensorController,
+  TweakValue,
+  Utils,
+  createTweaks,
+  getBridgeCore,
+  getRiffleBridge,
+  riffleBridgeTweaks
+});