@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/craft-bridge.js

@@ -0,0 +1,511 @@
+export const CRAFT_BRIDGE_SCRIPT = `
+<script>
+(function() {
+  'use strict';
+
+  // Skip if already initialized or not in Craft environment
+  if (window.__craftBridgeInitialized) return;
+  window.__craftBridgeInitialized = true;
+
+  // Message ID counter
+  let messageId = 0;
+  const generateId = () => 'msg_' + Date.now() + '_' + (++messageId);
+
+  // Pending requests
+  const pending = new Map();
+
+  // Event listeners
+  const eventListeners = new Map();
+
+  // Configuration
+  const config = {
+    debug: false,
+    timeout: 30000
+  };
+
+  // Send message to native
+  function send(message) {
+    const json = JSON.stringify(message);
+
+    if (config.debug) {
+      console.log('[Craft Bridge] Sending:', message.method, message.params);
+    }
+
+    // iOS WKWebView
+    if (window.webkit?.messageHandlers?.craft) {
+      window.webkit.messageHandlers.craft.postMessage(message);
+      return true;
+    }
+
+    // Android WebView
+    if (window.CraftBridge) {
+      window.CraftBridge.postMessage(json);
+      return true;
+    }
+
+    // Electron IPC
+    if (window.craftIPC) {
+      window.craftIPC.send('bridge-message', message);
+      return true;
+    }
+
+    return false;
+  }
+
+  // Make a request and wait for response
+  function request(method, params) {
+    return new Promise((resolve, reject) => {
+      const id = generateId();
+      const timeout = setTimeout(() => {
+        pending.delete(id);
+        reject(new Error('Request timeout: ' + method));
+      }, config.timeout);
+
+      pending.set(id, { resolve, reject, timeout });
+
+      const sent = send({
+        id,
+        type: 'request',
+        method,
+        params
+      });
+
+      if (!sent) {
+        clearTimeout(timeout);
+        pending.delete(id);
+        // Return gracefully if not in Craft environment
+        resolve(undefined);
+      }
+    });
+  }
+
+  // Handle incoming messages
+  function handleMessage(event) {
+    let data;
+    try {
+      data = event.detail || (typeof event.data === 'string' ? JSON.parse(event.data) : event.data);
+    }
+catch (e) {
+      return;
+    }
+
+    if (!data || !data.id) return;
+
+    if (config.debug) {
+      console.log('[Craft Bridge] Received:', data);
+    }
+
+    if (data.type === 'response') {
+      const req = pending.get(data.id);
+      if (req) {
+        clearTimeout(req.timeout);
+        pending.delete(data.id);
+        if (data.error) {
+          req.reject(new Error(data.error.message));
+        }
+else {
+          req.resolve(data.result);
+        }
+      }
+    }
+else if (data.type === 'event' && data.method) {
+      const listeners = eventListeners.get(data.method) || [];
+      listeners.forEach(fn => fn(data.params));
+    }
+  }
+
+  // Listen for messages
+  window.addEventListener('message', handleMessage);
+  window.addEventListener('craft-bridge-message', handleMessage);
+
+  // Check if running in Craft
+  function isCraft() {
+    return !!(
+      window.webkit?.messageHandlers?.craft ||
+      window.CraftBridge ||
+      window.craftIPC
+    );
+  }
+
+  // Subscribe to events
+  function on(event, callback) {
+    if (!eventListeners.has(event)) {
+      eventListeners.set(event, []);
+    }
+    eventListeners.get(event).push(callback);
+    return () => {
+      const listeners = eventListeners.get(event);
+      const idx = listeners.indexOf(callback);
+      if (idx > -1) listeners.splice(idx, 1);
+    };
+  }
+
+  function sendNativeUI(action, data) {
+    if (window.webkit?.messageHandlers?.craft) {
+      window.webkit.messageHandlers.craft.postMessage({ t: 'nativeUI', a: action, d: data || {} });
+      return true;
+    }
+
+    if (window.CraftBridge?.postMessage) {
+      window.CraftBridge.postMessage(JSON.stringify({ t: 'nativeUI', a: action, d: data || {} }));
+      return true;
+    }
+
+    return send({
+      id: generateId(),
+      type: 'nativeUI',
+      action,
+      data: data || {}
+    });
+  }
+
+  // Live component handles, keyed by id, so an event coming back from the host
+  // can be routed to the callbacks registered on the right one. Without this
+  // the onSelect/onSpaceChange callbacks were stored and never invoked.
+  const sidebars = new Map();
+  const spacesSidebars = new Map();
+
+  function createNativeUIFacade() {
+    class Sidebar {
+      constructor(id) {
+        this.id = id;
+        this._selectCallbacks = [];
+      }
+      addSection(section) {
+        sendNativeUI('addSidebarSection', { sidebarId: this.id, section });
+        return this;
+      }
+      setSelectedItem(itemId) {
+        sendNativeUI('setSelectedItem', { sidebarId: this.id, itemId });
+        return this;
+      }
+      onSelect(callback) {
+        this._selectCallbacks.push(callback);
+        return this;
+      }
+      destroy() {
+        sidebars.delete(this.id);
+        sendNativeUI('destroyComponent', { id: this.id, type: 'sidebar' });
+      }
+    }
+
+    /**
+     * An Arc-style sidebar of swipeable spaces.
+     *
+     * Separate from Sidebar rather than an option on it: a source list selects
+     * one row out of many, while a spaces sidebar selects one whole SCENE, and
+     * a host that renders the switcher natively (a segmented control in the
+     * toolbar, a Touch Bar strip) needs the space list, not the item list.
+     */
+    class SpacesSidebar {
+      constructor(id) {
+        this.id = id;
+        this._spaceCallbacks = [];
+      }
+      setSpaces(spaces) {
+        sendNativeUI('setSidebarSpaces', { sidebarId: this.id, spaces });
+        return this;
+      }
+      setActiveSpace(spaceId) {
+        sendNativeUI('setActiveSpace', { sidebarId: this.id, spaceId });
+        return this;
+      }
+      onSpaceChange(callback) {
+        this._spaceCallbacks.push(callback);
+        return this;
+      }
+      destroy() {
+        spacesSidebars.delete(this.id);
+        sendNativeUI('destroyComponent', { id: this.id, type: 'spacesSidebar' });
+      }
+    }
+
+    class FileBrowser {
+      constructor(id) {
+        this.id = id;
+      }
+      addFile(file) {
+        sendNativeUI('addFile', { browserId: this.id, file });
+        return this;
+      }
+      addFiles(files) {
+        sendNativeUI('addFiles', { browserId: this.id, files });
+        return this;
+      }
+      clearFiles() {
+        sendNativeUI('clearFiles', { browserId: this.id });
+        return this;
+      }
+      destroy() {
+        sendNativeUI('destroyComponent', { id: this.id, type: 'fileBrowser' });
+      }
+    }
+
+    class SplitView {
+      constructor(id, sidebar, browser) {
+        this.id = id;
+        this.sidebar = sidebar;
+        this.browser = browser;
+      }
+      setDividerPosition(position) {
+        sendNativeUI('setDividerPosition', { splitViewId: this.id, position });
+        return this;
+      }
+      destroy() {
+        sendNativeUI('destroyComponent', { id: this.id, type: 'splitView' });
+      }
+    }
+
+    // Host -> page. The host names the component in the payload; we look up the
+    // handle and fan out to whatever the page registered on it.
+    on('sidebar.select', function(params) {
+      const sidebar = sidebars.get(params && params.sidebarId);
+      if (sidebar) sidebar._selectCallbacks.forEach(fn => fn(params.itemId));
+    });
+    on('sidebar.spaceChange', function(params) {
+      const sidebar = spacesSidebars.get(params && params.sidebarId);
+      if (sidebar) sidebar._spaceCallbacks.forEach(fn => fn(params.spaceId));
+    });
+
+    return {
+      createSidebar(options) {
+        const opts = options || {};
+        const id = opts.id || 'sidebar-' + Date.now() + '-' + Math.random().toString(36).slice(2);
+        sendNativeUI('createSidebar', Object.assign({}, opts, { id }));
+        const sidebar = new Sidebar(id);
+        sidebars.set(id, sidebar);
+        return sidebar;
+      },
+      createSpacesSidebar(options) {
+        const opts = options || {};
+        const id = opts.id || 'spaces-' + Date.now() + '-' + Math.random().toString(36).slice(2);
+        sendNativeUI('createSpacesSidebar', Object.assign({}, opts, { id }));
+        const sidebar = new SpacesSidebar(id);
+        spacesSidebars.set(id, sidebar);
+        return sidebar;
+      },
+      createFileBrowser(options) {
+        const opts = options || {};
+        const id = opts.id || 'browser-' + Date.now() + '-' + Math.random().toString(36).slice(2);
+        sendNativeUI('createFileBrowser', Object.assign({}, opts, { id }));
+        return new FileBrowser(id);
+      },
+      createSplitView(options) {
+        if (!options?.sidebar || !options?.browser) {
+          throw new Error('createSplitView requires sidebar and browser options');
+        }
+        const id = options.id || 'splitview-' + Date.now() + '-' + Math.random().toString(36).slice(2);
+        sendNativeUI('createSplitView', {
+          id,
+          sidebarId: options.sidebar.id,
+          browserId: options.browser.id
+        });
+        return new SplitView(id, options.sidebar, options.browser);
+      },
+      showQuickLook(options) {
+        sendNativeUI('showQuickLook', options);
+      },
+      closeQuickLook() {
+        sendNativeUI('closeQuickLook', {});
+      },
+      toggleQuickLook(options) {
+        sendNativeUI('toggleQuickLook', options);
+      }
+    };
+  }
+
+  const existingCraft = window.craft || {};
+  const nativeUI = existingCraft.nativeUI || createNativeUIFacade();
+  const componentAPI = existingCraft.components || Object.assign({}, nativeUI, {
+    updateComponent: (id, props) => request('component.update', { componentId: id, props }),
+    destroyComponent: (id) => request('component.destroy', { componentId: id })
+  });
+
+  // Build the craft API object
+  window.craft = Object.assign({}, existingCraft, {
+    // Meta
+    isCraft,
+    on,
+    config,
+
+    // Window API
+    window: {
+      show: () => request('window.show'),
+      hide: () => request('window.hide'),
+      close: () => request('window.close'),
+      minimize: () => request('window.minimize'),
+      maximize: () => request('window.maximize'),
+      restore: () => request('window.restore'),
+      focus: () => request('window.focus'),
+      blur: () => request('window.blur'),
+      setTitle: (title) => request('window.setTitle', { title }),
+      setSize: (width, height) => request('window.setSize', { width, height }),
+      setPosition: (x, y) => request('window.setPosition', { x, y }),
+      setFullscreen: (fullscreen) => request('window.setFullscreen', { fullscreen }),
+      setAlwaysOnTop: (alwaysOnTop) => request('window.setAlwaysOnTop', { alwaysOnTop }),
+      getSize: () => request('window.getSize'),
+      getPosition: () => request('window.getPosition'),
+      isFullscreen: () => request('window.isFullscreen'),
+      isMaximized: () => request('window.isMaximized'),
+      isMinimized: () => request('window.isMinimized'),
+      isVisible: () => request('window.isVisible'),
+      center: () => request('window.center'),
+      toggleFullscreen: () => request('window.toggleFullscreen'),
+      startDrag: () => request('window.startDrag'),
+    },
+
+    // System Tray/Menubar API
+    tray: {
+      setTitle: (title) => request('tray.setTitle', { title }),
+      setTooltip: (tooltip) => request('tray.setTooltip', { tooltip }),
+      setIcon: (icon) => request('tray.setIcon', { icon }),
+      setMenu: (menu) => request('tray.setMenu', { menu }),
+      show: () => request('tray.show'),
+      hide: () => request('tray.hide'),
+      onClick: (callback) => on('tray.click', callback),
+      onDoubleClick: (callback) => on('tray.doubleClick', callback),
+      onRightClick: (callback) => on('tray.rightClick', callback),
+    },
+
+    // App API
+    app: {
+      quit: () => request('app.quit'),
+      hide: () => request('app.hide'),
+      show: () => request('app.show'),
+      focus: () => request('app.focus'),
+      getInfo: () => request('app.getInfo'),
+      getVersion: () => request('app.getVersion'),
+      getName: () => request('app.getName'),
+      getPath: (name) => request('app.getPath', { name }),
+      isDarkMode: () => request('app.isDarkMode'),
+      getLocale: () => request('app.getLocale'),
+      setBadge: (badge) => request('app.setBadge', { badge }),
+      hideDockIcon: () => request('app.hideDockIcon'),
+      showDockIcon: () => request('app.showDockIcon'),
+      notify: (options) => request('app.notify', options),
+      registerShortcut: (accelerator, callback) => {
+        const id = generateId();
+        on('shortcut.' + id, callback);
+        return request('app.registerShortcut', { accelerator, id });
+      },
+      unregisterShortcut: (accelerator) => request('app.unregisterShortcut', { accelerator }),
+    },
+
+    // Dialog API
+    dialog: {
+      openFile: (options) => request('dialog.openFile', options),
+      openFolder: (options) => request('dialog.openFolder', options),
+      saveFile: (options) => request('dialog.saveFile', options),
+      showAlert: (options) => request('dialog.showAlert', options),
+      showConfirm: (options) => request('dialog.showConfirm', options),
+      showPrompt: (options) => request('dialog.showPrompt', options),
+      showColorPicker: (options) => request('dialog.showColorPicker', options),
+    },
+
+    // Clipboard API
+    clipboard: {
+      writeText: (text) => request('clipboard.writeText', { text }),
+      readText: () => request('clipboard.readText'),
+      writeHTML: (html) => request('clipboard.writeHTML', { html }),
+      readHTML: () => request('clipboard.readHTML'),
+      clear: () => request('clipboard.clear'),
+    },
+
+    // File System API (limited for security)
+    fs: {
+      readFile: (path, encoding) => request('fs.readFile', { path, encoding }),
+      writeFile: (path, content, encoding) => request('fs.writeFile', { path, content, encoding }),
+      exists: (path) => request('fs.exists', { path }),
+      stat: (path) => request('fs.stat', { path }),
+      readDir: (path) => request('fs.readDir', { path }),
+      createDir: (path, recursive) => request('fs.createDir', { path, recursive }),
+      remove: (path, recursive) => request('fs.remove', { path, recursive }),
+    },
+
+    // Process/Shell API (limited for security)
+    process: {
+      exec: (command, options) => request('process.exec', { command, ...options }),
+      spawn: (command, args, options) => request('process.spawn', { command, args, ...options }),
+      env: () => request('process.env'),
+      cwd: () => request('process.cwd'),
+      platform: () => request('process.platform'),
+    },
+
+    // Gesture stream
+    //
+    // A webview's wheel events carry no phase information, so a page can only
+    // guess where a trackpad swipe begins and ends \u2014 typically with an idle
+    // timeout, which mistimes the release and cannot see momentum at all. The
+    // host holds the real NSEvent, so it forwards the phases instead:
+    //
+    //   { axis: 'horizontal' | 'vertical',
+    //     phase: 'begin' | 'change' | 'end',
+    //     deltaX, deltaY,            // points since the last event
+    //     velocityX, velocityY,      // points per second, at 'end'
+    //     momentum: boolean }        // the OS is coasting, not the finger
+    //
+    // Consumers must stay correct when nothing ever arrives: a host without
+    // gesture support simply never emits, so keep the wheel path bound and let
+    // a begin phase take over from it.
+    gestures: {
+      onSwipe: (callback) => on('gesture.swipe', callback),
+    },
+
+    // Native component helpers
+    nativeUI,
+    components: componentAPI
+  });
+
+  // Dispatch ready event
+  window.dispatchEvent(new CustomEvent('craft:ready', { detail: { isCraft: isCraft() } }));
+
+  if (config.debug) {
+    console.log('[Craft Bridge] Initialized, isCraft:', isCraft());
+  }
+})();
+</script>
+`;
+export function generateCraftBridgeScript(config = {}) {
+  const { debug = !1, timeout = 30000 } = config;
+  return CRAFT_BRIDGE_SCRIPT.replace("debug: false,", `debug: ${debug},`).replace("timeout: 30000", `timeout: ${timeout}`);
+}
+export function isCraftEnvironment() {
+  return !1;
+}
+export function processCraftDirective(content, _context = {}) {
+  const craftDirectivePattern = /@craft(?:\(([\s\S]*?)\))?/g;
+  return content.replace(craftDirectivePattern, (match, configStr) => {
+    let config = {};
+    if (configStr)
+      try {
+        config = JSON.parse(configStr.replace(/'/g, '"'));
+      } catch {
+        try {
+          config = Function(`return ${configStr}`)();
+        } catch {
+          console.warn(`[stx] Invalid @craft config: ${configStr}`);
+        }
+      }
+    return generateCraftBridgeScript(config);
+  });
+}
+export function injectCraftBridge(html, config = {}) {
+  if (html.includes("__craftBridgeInitialized"))
+    return html;
+  const script = generateCraftBridgeScript(config);
+  if (html.includes("</head>"))
+    return html.replace("</head>", `${script}
+</head>`);
+  if (html.includes("<body"))
+    return html.replace(/(<body[^>]*>)/, `$1
+${script}`);
+  return script + html;
+}
+const craftBridge = {
+  CRAFT_BRIDGE_SCRIPT,
+  generateCraftBridgeScript,
+  processCraftDirective,
+  injectCraftBridge,
+  isCraftEnvironment
+};
+export default craftBridge;