@public-tauri/raycast-convert 1.0.1 → 1.1.0

package/templates/raycast-worker-runtime.ts

@@ -0,0 +1,240 @@
+
+/**
+ * Generated into converted plugins as `.raycast-build/raycast-worker-runtime.ts`.
+ * React custom renderer: Raycast List/Detail/Action UI runs in the Node Worker; snapshots go to the wujie view client.
+ *
+ * 由 `server.ts` 引入；插件业务代码通过 `@raycast/api`（别名到 `@public-tauri/api/raycast`）导入 UI 与 API。
+ */
+import React from 'react';
+import Reconciler from 'react-reconciler';
+import { DefaultEventPriority } from 'react-reconciler/constants.js';
+import type { RaycastViewSnapshot } from './raycast-view-protocol';
+import type { JsonPatchOp } from './json-patch';
+import { generateJsonPatch } from './json-patch';
+import { __getRaycastContext, __setRaycastContext } from '@public-tauri/api/raycast';
+import type {
+  HostElementInstance,
+  HostInstance,
+  HostRootContainer,
+  HostTextInstance,
+} from './host-instance';
+import { buildSnapshotFromHostRoot } from './virtual-serialize';
+
+let viewLaunchProps: Record<string, unknown> = {};
+
+export function __setRaycastViewContext(context: {
+  pluginName?: string;
+  commandName?: string;
+  preferences?: Record<string, unknown>;
+  supportPath?: string;
+  assetsPath?: string;
+  launchProps?: Record<string, unknown>;
+}) {
+  viewLaunchProps = context.launchProps || {};
+  __setRaycastContext({
+    pluginName: context.pluginName,
+    commandName: context.commandName,
+    commandMode: 'view',
+    preferences: context.preferences,
+    supportPath: context.supportPath,
+    assetsPath: context.assetsPath,
+  });
+}
+
+const noop = () => {};
+
+const swallowError = (_error: Error, _info: unknown) => {};
+
+export function createRaycastViewSession(options: {
+  emitSnapshot: (snapshot: RaycastViewSnapshot) => void;
+  emitPatch: (patches: JsonPatchOp[]) => void;
+}) {
+  const handlers = new Map<string, (...args: unknown[]) => void | Promise<void>>();
+  let hostIdSeq = 0;
+  const nextHostId = () => {
+    hostIdSeq += 1;
+    return `rv:n:${hostIdSeq}`;
+  };
+
+  let latestSnapshot: RaycastViewSnapshot | null = null;
+  let sentInitialSnapshot = false;
+  const rootNode: HostRootContainer = { children: [] };
+  let snapshotQueued = false;
+
+  const serializeRoot = (): RaycastViewSnapshot => buildSnapshotFromHostRoot(rootNode.children, handlers, {
+    commandName: __getRaycastContext().commandName || '',
+  });
+
+  const emitSnapshot = () => {
+    const nextSnapshot = serializeRoot();
+
+    if (!sentInitialSnapshot || !latestSnapshot) {
+      latestSnapshot = nextSnapshot;
+      sentInitialSnapshot = true;
+      options.emitSnapshot(latestSnapshot);
+      return;
+    }
+
+    const patches = generateJsonPatch(latestSnapshot, nextSnapshot);
+    latestSnapshot = nextSnapshot;
+    if (patches.length > 0) {
+      options.emitPatch(patches);
+    }
+  };
+
+  const scheduleSnapshotAfterCommit = () => {
+    if (snapshotQueued) return;
+    snapshotQueued = true;
+    queueMicrotask(() => {
+      snapshotQueued = false;
+      emitSnapshot();
+      reconciler.flushSyncWork?.();
+    });
+  };
+
+  const hostConfig = {
+    getRootHostContext: () => ({}),
+    prepareForCommit: () => null,
+    preparePortalMount: () => null,
+    clearContainer: () => false,
+    resetAfterCommit: () => {
+      scheduleSnapshotAfterCommit();
+    },
+    getChildHostContext: () => ({}),
+    shouldSetTextContent: () => false,
+    createInstance: (type: string, props: Record<string, unknown>): HostElementInstance => {
+      console.log('createInstance', type, props);
+      return {
+        type,
+        hostId: nextHostId(),
+        props,
+        parent: null,
+        children: [],
+      };
+    },
+    createTextInstance: (text: string): HostTextInstance => ({
+      type: 'text',
+      hostId: nextHostId(),
+      text,
+      parent: null,
+    }),
+    resetTextContent: noop,
+    hideTextInstance: noop,
+    unhideTextInstance: noop,
+    getPublicInstance: (instance: HostInstance) => instance,
+    hideInstance: noop,
+    unhideInstance: noop,
+    appendInitialChild: (parent: HostElementInstance | HostRootContainer, child: HostInstance) => {
+      child.parent = parent;
+      parent.children.push(child);
+    },
+    appendChild: (parent: HostElementInstance | HostRootContainer, child: HostInstance) => {
+      child.parent = parent;
+      parent.children.push(child);
+    },
+    insertBefore: (parent: HostElementInstance | HostRootContainer, child: HostInstance, beforeChild: HostInstance) => {
+      child.parent = parent;
+      parent.children = parent.children.filter(item => item !== child);
+      parent.children.splice(parent.children.indexOf(beforeChild), 0, child);
+    },
+    finalizeInitialChildren: () => false,
+    isPrimaryRenderer: true,
+    supportsMutation: true,
+    supportsPersistence: false,
+    supportsHydration: false,
+    scheduleTimeout: setTimeout,
+    cancelTimeout: clearTimeout,
+    noTimeout: -1,
+    getCurrentEventPriority: () => DefaultEventPriority,
+    getCurrentUpdatePriority: () => DefaultEventPriority,
+    setCurrentUpdatePriority: noop,
+    resolveUpdatePriority: () => DefaultEventPriority,
+    shouldAttemptEagerTransition: () => false,
+    maySuspendCommit: () => false,
+    preloadInstance: () => true,
+    startSuspendingCommit: noop,
+    suspendInstance: noop,
+    waitForCommitToBeReady: () => noop,
+    mayResourceSuspendCommit: () => false,
+    beforeActiveInstanceBlur: noop,
+    afterActiveInstanceBlur: noop,
+    detachDeletedInstance: noop,
+    getInstanceFromNode: () => null,
+    prepareScopeUpdate: noop,
+    getInstanceFromScope: () => null,
+    appendChildToContainer: (container: HostRootContainer, child: HostInstance) => {
+      child.parent = container;
+      container.children.push(child);
+    },
+    insertInContainerBefore: (container: HostRootContainer, child: HostInstance, beforeChild: HostInstance) => {
+      child.parent = container;
+      container.children = container.children.filter(item => item !== child);
+      container.children.splice(container.children.indexOf(beforeChild), 0, child);
+    },
+    removeChildFromContainer: (container: HostRootContainer, child: HostInstance) => {
+      container.children = container.children.filter(item => item !== child);
+      child.parent = null;
+    },
+    prepareUpdate: () => true,
+    commitMount: noop,
+    // React 19 / reconciler ≥0.31：无 updatePayload，签名为 (instance, type, prevProps, nextProps, internalHandle)
+    commitUpdate: (instance: HostElementInstance, _type: unknown, _prevProps: unknown, nextProps: Record<string, unknown>) => {
+      instance.props = nextProps;
+    },
+    commitTextUpdate: (textInstance: HostTextInstance, _oldText: string, newText: string) => {
+      textInstance.text = newText;
+    },
+    removeChild: (parent: HostElementInstance, child: HostInstance) => {
+      parent.children = parent.children.filter(item => item !== child);
+      child.parent = null;
+    },
+  };
+
+  // HostConfig 随 react-reconciler 版本扩展字段；变异宿主只需最小子集（见官方 custom renderer 示例）。
+  const reconciler = Reconciler(hostConfig as any);
+
+  let rootContainer: ReturnType<typeof reconciler.createContainer> | null = null;
+
+  const mount = async (Command: React.ComponentType<Record<string, unknown>>) => {
+    hostIdSeq = 0;
+    rootContainer = reconciler.createContainer(
+      rootNode,
+      0,
+      null,
+      false,
+      null,
+      '',
+      swallowError,
+      swallowError,
+      swallowError,
+      noop,
+    );
+    reconciler.updateContainer(
+      React.createElement(Command, viewLaunchProps),
+      rootContainer,
+      null,
+      noop,
+    );
+    reconciler.flushSyncWork?.();
+  };
+
+  const dispatchHostEvent = async (hostId: string, event = 'onAction', args: unknown[] = []) => {
+    const handler = handlers.get(`${hostId}:${event}`);
+    if (!handler) throw new Error(`Unknown Raycast host event: ${hostId} · ${event}`);
+    await handler(...args);
+    reconciler.flushSyncWork?.();
+  };
+
+  const unmount = () => {
+    if (rootContainer) {
+      reconciler.updateContainer(null, rootContainer, null, noop);
+      rootContainer = null;
+    }
+    hostIdSeq = 0;
+    latestSnapshot = null;
+    sentInitialSnapshot = false;
+    handlers.clear();
+  };
+
+  return { mount, dispatchHostEvent, unmount };
+}

package/templates/virtual-serialize.ts

@@ -0,0 +1,215 @@
+/**
+ * 将 HostInstance 树序列化为可 JSON 的快照（raycast-view-protocol）。
+ *
+ * - 元素节点来自 reconciler，自带 hostId；props 中的 React slot（detail / actions）在序列化时展开并分配 rv:p:* 合成 id。
+ * - 函数型 props：写入 Worker Map[`${hostId}:${propName}`]，快照中序列化为 \`${RAYCAST_SERIALIZED_FUNC_PREFIX}\${propName}\`（JSON 字符串）。
+ */
+import React from 'react';
+import {
+  RAYCAST_SERIALIZED_FUNC_PREFIX,
+  type RaycastViewSnapshot,
+  type SerializedHostNode,
+} from './raycast-view-protocol';
+import type { HostInstance } from './host-instance';
+import { isHostText } from './host-instance';
+
+export type HostEventHandlerRegistry = Map<string, (...args: unknown[]) => void | Promise<void>>;
+
+const SKIP_PROP_KEYS = new Set(['key', 'ref', '__self', '__source']);
+
+function cloneJsonSafe(value: unknown): unknown {
+  if (value === null || value === undefined) return value;
+  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') return value;
+  if (typeof value === 'symbol' || typeof value === 'function') return undefined;
+  if (Array.isArray(value)) {
+    const arr = value.map(cloneJsonSafe).filter(v => v !== undefined);
+    return arr;
+  }
+  if (typeof value === 'object') {
+    try {
+      return JSON.parse(JSON.stringify(value));
+    } catch {
+      return undefined;
+    }
+  }
+  return undefined;
+}
+
+function isHostTextLike(value: unknown): value is { hostId: string; type: 'text'; text: string } {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const obj = value as Record<string, unknown>;
+  return obj.type === 'text' && typeof obj.hostId === 'string' && typeof obj.text === 'string';
+}
+
+function isHostElementLike(value: unknown): value is {
+  hostId: string;
+  type: string;
+  props: Record<string, unknown>;
+  children: unknown[];
+} {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const obj = value as Record<string, unknown>;
+  return (
+    typeof obj.hostId === 'string'
+    && typeof obj.type === 'string'
+    && obj.type !== 'text'
+    && typeof obj.props === 'object'
+    && obj.props !== null
+    && !Array.isArray(obj.props)
+    && Array.isArray(obj.children)
+  );
+}
+
+function isHostInstanceLike(value: unknown): value is HostInstance {
+  return isHostTextLike(value) || isHostElementLike(value);
+}
+
+function isPlainRecord(value: unknown): value is Record<string, unknown> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+function isReactElementLike(value: unknown): value is { $$typeof: unknown } {
+  return Boolean(value && typeof value === 'object' && '$$typeof' in (value as Record<string, unknown>));
+}
+
+function serializeReactElementTree(
+  value: unknown,
+  handlers: HostEventHandlerRegistry,
+  nextSlotId: () => string,
+): SerializedHostNode | undefined {
+  if (!React.isValidElement(value)) return undefined;
+  const el = value as React.ReactElement<Record<string, unknown>>;
+  const { type } = el;
+
+  if (typeof type === 'function') {
+    const maybeClassComponent = Boolean((type as { prototype?: { isReactComponent?: unknown } }).prototype?.isReactComponent);
+    if (maybeClassComponent) return undefined;
+    try {
+      const rendered = (type as React.FC<Record<string, unknown>>)(el.props ?? {});
+      return serializeReactElementTree(rendered, handlers, nextSlotId);
+    } catch {
+      return undefined;
+    }
+  }
+
+  if (typeof type === 'symbol') {
+    const children = React.Children.toArray(el.props?.children as React.ReactNode)
+      .map(ch => serializeReactElementTree(ch, handlers, nextSlotId))
+      .filter((x): x is SerializedHostNode => x !== undefined);
+    return children[0];
+  }
+
+  if (typeof type !== 'string') return undefined;
+
+  const hostId = nextSlotId();
+  const propsOut = serializeHostProps(el.props ?? {}, hostId, handlers, nextSlotId);
+  const children = React.Children.toArray(el.props?.children as React.ReactNode)
+    .map(ch => serializeReactElementTree(ch, handlers, nextSlotId))
+    .filter((x): x is SerializedHostNode => x !== undefined);
+
+  return {
+    hostId,
+    type,
+    props: propsOut,
+    children,
+  };
+}
+
+function serializeUnknownPropValue(
+  value: unknown,
+  handlers: HostEventHandlerRegistry,
+  nextSlotId: () => string,
+  seen: WeakSet<object>,
+): unknown {
+  if (value === undefined) return undefined;
+  if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+    return value;
+  }
+  if (isHostInstanceLike(value)) {
+    return serializeHostSubtree(value, handlers, nextSlotId);
+  }
+  if (Array.isArray(value)) {
+    return value
+      .map(item => serializeUnknownPropValue(item, handlers, nextSlotId, seen))
+      .filter(item => item !== undefined);
+  }
+  if (typeof value === 'object') {
+    if (seen.has(value)) return undefined;
+    seen.add(value);
+
+    if (isReactElementLike(value)) {
+      return serializeReactElementTree(value, handlers, nextSlotId);
+    }
+
+    if (!isPlainRecord(value)) {
+      return cloneJsonSafe(value);
+    }
+
+    const obj = value;
+    const out: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(obj)) {
+      if (typeof v === 'function') continue;
+      const serialized = serializeUnknownPropValue(v, handlers, nextSlotId, seen);
+      if (serialized !== undefined) out[k] = serialized;
+    }
+    return out;
+  }
+  return cloneJsonSafe(value);
+}
+
+function serializeHostProps(
+  props: Record<string, unknown>,
+  hostId: string,
+  handlers: HostEventHandlerRegistry,
+  nextSlotId: () => string,
+): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(props)) {
+    if (SKIP_PROP_KEYS.has(k) || k === 'children') continue;
+    if (typeof v === 'function') {
+      handlers.set(`${hostId}:${k}`, v as (...args: unknown[]) => void | Promise<void>);
+      out[k] = `${RAYCAST_SERIALIZED_FUNC_PREFIX}${k}`;
+      continue;
+    }
+    const c = serializeUnknownPropValue(v, handlers, nextSlotId, new WeakSet<object>());
+    if (c !== undefined) out[k] = c;
+  }
+  return out;
+}
+
+function serializeHostSubtree(
+  node: HostInstance | undefined,
+  handlers: HostEventHandlerRegistry,
+  nextSlotId: () => string,
+): SerializedHostNode {
+  if (!node) {
+    return { hostId: 'rv:root:empty', type: 'raycast:empty', props: {}, children: [] };
+  }
+  if (isHostText(node)) {
+    return { hostId: node.hostId, type: 'text', text: node.text };
+  }
+  const propsOut = serializeHostProps(node.props, node.hostId, handlers, nextSlotId);
+  const children = node.children.map(ch => serializeHostSubtree(ch, handlers, nextSlotId));
+  return { hostId: node.hostId, type: node.type, props: propsOut, children };
+}
+
+export function buildSnapshotFromHostRoot(
+  rootChildren: HostInstance[],
+  handlers: HostEventHandlerRegistry,
+  meta: { commandName: string },
+): RaycastViewSnapshot {
+  handlers.clear();
+  let slotSeq = 0;
+  const nextSlotId = () => {
+    slotSeq += 1;
+    return `rv:p:${slotSeq}`;
+  };
+  console.log('rootChildren', rootChildren);
+  const root = serializeHostSubtree(rootChildren[0], handlers, nextSlotId);
+  return {
+    commandName: meta.commandName,
+    root,
+  };
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts", "tsdown.config.ts"],
+  "exclude": ["node_modules", "dist"]
+}