@talex-touch/utils 1.0.42 → 1.0.44

package/plugin/sdk/core-box.ts

@@ -1,20 +1,11 @@
-import type { IPluginRendererChannel } from './types'
+import { useChannel } from './channel'
+import { usePluginName } from './plugin-info'
 
-function ensurePluginContext(): { channel: IPluginRendererChannel, pluginName: string } {
-  const plugin = (window as any)?.$plugin
-  if (!plugin?.name) {
-    throw new Error('[TouchSDK] Unable to resolve plugin name inside renderer context.')
-  }
+function ensurePluginContext(): { channel: ReturnType<typeof useChannel>, pluginName: string } {
+  const pluginName = usePluginName('[TouchSDK] Unable to resolve plugin name inside renderer context.')
+  const channel = useChannel('[TouchSDK] Channel bridge is not available for the current plugin renderer.')
 
-  const channel = (window as any)?.$channel as IPluginRendererChannel | undefined
-  if (!channel) {
-    throw new Error('[TouchSDK] Channel bridge is not available for the current plugin renderer.')
-  }
-
-  return {
-    channel,
-    pluginName: plugin.name as string,
-  }
+  return { channel, pluginName }
 }
 
 /**

package/plugin/sdk/division-box.ts

@@ -1,6 +1,6 @@
 /**
  * DivisionBox SDK for Plugin Development
- * 
+ *
  * Provides a simple API for plugins to create and manage DivisionBox instances.
  * DivisionBox is a lightweight floating window container for plugin UIs and tools.
  */
@@ -10,8 +10,17 @@ import type {
   DivisionBoxConfig,
   DivisionBoxState,
   SessionInfo,
+  StateChangeEvent,
 } from '../../types/division-box'
+import { createPluginTuffTransport } from '../../transport'
+import { createDisposableBag } from '../../transport/sdk'
+import { DivisionBoxEvents } from '../../transport/events'
 import { ensureRendererChannel } from './channel'
+import { tryGetPluginSdkApi } from './plugin-info'
+
+function resolveSdkApi(): number | undefined {
+  return tryGetPluginSdkApi()
+}
 
 /**
  * State change event handler
@@ -21,9 +30,11 @@ export type StateChangeHandler = (data: {
   state: DivisionBoxState
 }) => void
 
+export type LifecycleChangeHandler = (event: StateChangeEvent) => void
+
 /**
  * DivisionBox SDK interface for plugins
- * 
+ *
  * @example
  * ```typescript
  * // Open a DivisionBox
@@ -33,12 +44,12 @@ export type StateChangeHandler = (data: {
  *   size: 'medium',
  *   keepAlive: true
  * })
- * 
+ *
  * // Listen for state changes
  * plugin.divisionBox.onStateChange((data) => {
  *   console.log(`Session ${data.sessionId} is now ${data.state}`)
  * })
- * 
+ *
  * // Close the DivisionBox
  * await plugin.divisionBox.close(sessionId)
  * ```
@@ -46,10 +57,10 @@ export type StateChangeHandler = (data: {
 export interface DivisionBoxSDK {
   /**
    * Opens a new DivisionBox instance
-   * 
+   *
    * @param config - Configuration for the DivisionBox
    * @returns Promise resolving to session information
-   * 
+   *
    * @example
    * ```typescript
    * const { sessionId } = await plugin.divisionBox.open({
@@ -68,65 +79,67 @@ export interface DivisionBoxSDK {
    * })
    * ```
    */
-  open(config: DivisionBoxConfig): Promise<SessionInfo>
+  open: (config: DivisionBoxConfig) => Promise<SessionInfo>
 
   /**
    * Closes a DivisionBox instance
-   * 
+   *
    * @param sessionId - The session ID to close
    * @param options - Optional close options
    * @returns Promise that resolves when closed
-   * 
+   *
    * @example
    * ```typescript
    * // Simple close
    * await plugin.divisionBox.close(sessionId)
-   * 
+   *
    * // Close with delay and animation
    * await plugin.divisionBox.close(sessionId, {
    *   delay: 1000,
    *   animation: true
    * })
-   * 
+   *
    * // Force close (ignore keepAlive)
    * await plugin.divisionBox.close(sessionId, {
    *   force: true
    * })
    * ```
    */
-  close(sessionId: string, options?: CloseOptions): Promise<void>
+  close: (sessionId: string, options?: CloseOptions) => Promise<void>
 
   /**
    * Registers a state change listener
-   * 
+   *
    * @param handler - Callback function for state changes
    * @returns Unsubscribe function
-   * 
+   *
    * @example
    * ```typescript
    * const unsubscribe = plugin.divisionBox.onStateChange((data) => {
    *   console.log(`Session ${data.sessionId} changed to ${data.state}`)
    * })
-   * 
+   *
    * // Later, unsubscribe
    * unsubscribe()
    * ```
    */
-  onStateChange(handler: StateChangeHandler): () => void
+  onStateChange: (handler: StateChangeHandler) => () => void
+
+  onLifecycleChange: (handler: LifecycleChangeHandler) => () => void
 
   /**
    * Updates session state data
-   * 
+   *
    * @param sessionId - The session ID
    * @param key - State key
    * @param value - State value
    * @returns Promise that resolves when updated
-   * 
+   *
    * @example
    * ```typescript
    * // Save scroll position
    * await plugin.divisionBox.updateState(sessionId, 'scrollY', 150)
-   * 
+   *
    * // Save draft content
    * await plugin.divisionBox.updateState(sessionId, 'draft', {
    *   text: 'Hello world',
@@ -134,126 +147,208 @@ export interface DivisionBoxSDK {
    * })
    * ```
    */
-  updateState(sessionId: string, key: string, value: any): Promise<void>
+  updateState: (sessionId: string, key: string, value: any) => Promise<void>
 
   /**
    * Gets session state data
-   * 
+   *
    * @param sessionId - The session ID
    * @param key - State key
    * @returns Promise resolving to the state value
-   * 
+   *
    * @example
    * ```typescript
    * const scrollY = await plugin.divisionBox.getState(sessionId, 'scrollY')
    * const draft = await plugin.divisionBox.getState(sessionId, 'draft')
    * ```
    */
-  getState(sessionId: string, key: string): Promise<any>
+  getState: (sessionId: string, key: string) => Promise<any>
+
+  /**
+   * 释放 SDK 内部注册的监听器
+   */
+  dispose: () => void
 }
 
 /**
  * Creates a DivisionBox SDK instance for plugin use
- * 
+ *
  * @param channel - The plugin channel bridge for IPC communication
  * @returns Configured DivisionBox SDK instance
- * 
+ *
  * @internal
  */
 export function createDivisionBoxSDK(channel: any): DivisionBoxSDK {
   const stateChangeHandlers: Set<StateChangeHandler> = new Set()
+  const lifecycleChangeHandlers: Set<LifecycleChangeHandler> = new Set()
+  const transport = createPluginTuffTransport(channel)
+  const disposables = createDisposableBag()
+  let disposed = false
 
-  // Register listener for state change events from main process
-  // The channel can be either IPluginChannelBridge (main process) or window.$channel (renderer)
-  const registerListener = () => {
-    if (channel.onMain) {
-      // Main process plugin context
-      channel.onMain('division-box:state-changed', (event: any) => {
-        stateChangeHandlers.forEach(handler => handler(event.data || event))
-      })
-    } else if (channel.on) {
-      // Renderer process context
-      channel.on('division-box:state-changed', (data: any) => {
-        stateChangeHandlers.forEach(handler => handler(data))
-      })
+  const emitStateChange = (payload: StateChangeEvent) => {
+    for (const handler of lifecycleChangeHandlers) {
+      try {
+        handler(payload)
+      }
+      catch (error) {
+        console.error('[DivisionBox SDK] onLifecycleChange handler error:', error)
+      }
     }
+
+    for (const handler of stateChangeHandlers) {
+      try {
+        handler({ sessionId: payload.sessionId, state: payload.newState })
+      }
+      catch (error) {
+        console.error('[DivisionBox SDK] onStateChange handler error:', error)
+      }
+    }
+  }
+
+  const dispose = () => {
+    if (disposed) {
+      return
+    }
+
+    disposed = true
+    stateChangeHandlers.clear()
+    lifecycleChangeHandlers.clear()
+    disposables.dispose()
+    transport.destroy()
   }
 
-  registerListener()
+  const ensureActive = (method: string) => {
+    if (disposed) {
+      throw new Error(`[DivisionBox SDK] Cannot call ${method} after dispose`)
+    }
+  }
+
+  try {
+    disposables.add(
+      transport.on(DivisionBoxEvents.stateChanged, (payload: StateChangeEvent) => {
+        emitStateChange(payload)
+      }),
+    )
+  }
+  catch {
+    const registerFallback =
+      typeof channel?.onMain === 'function'
+        ? channel.onMain.bind(channel)
+        : typeof channel?.on === 'function'
+          ? channel.on.bind(channel)
+          : null
+
+    if (registerFallback) {
+      const fallbackDispose = registerFallback('division-box:state-changed', (raw: any) => {
+        const payload = (raw?.data || raw) as StateChangeEvent
+        if (payload?.sessionId) {
+          emitStateChange(payload)
+        }
+      })
+      if (typeof fallbackDispose === 'function') {
+        disposables.add(fallbackDispose)
+      }
+    }
+  }
 
-  const send: (eventName: string, payload?: any) => Promise<any> =
-    typeof channel?.sendToMain === 'function'
-      ? channel.sendToMain.bind(channel)
-      : typeof channel?.send === 'function'
-        ? channel.send.bind(channel)
-        : (() => {
-            throw new Error('[DivisionBox SDK] Channel send function not available')
-          })()
+  if (typeof window !== 'undefined' && typeof window.addEventListener === 'function') {
+    const onBeforeUnload = () => dispose()
+    window.addEventListener('beforeunload', onBeforeUnload, { once: true })
+    disposables.add(() => window.removeEventListener('beforeunload', onBeforeUnload))
+  }
 
   return {
     async open(config: DivisionBoxConfig): Promise<SessionInfo> {
-      // Send to main process
-      const result = await send('division-box:open', config)
-      
+      ensureActive('open')
+      const result = await transport.send(DivisionBoxEvents.open, {
+        ...(config as any),
+        _sdkapi: resolveSdkApi(),
+      })
+
       if (!result.success) {
         throw new Error(result.error?.message || 'Failed to open DivisionBox')
       }
-      
+
+      if (!result.data) {
+        throw new Error('Failed to open DivisionBox')
+      }
+
       return result.data
     },
 
     async close(sessionId: string, options?: CloseOptions): Promise<void> {
-      const result = await send('division-box:close', { sessionId, options })
-      
+      ensureActive('close')
+      const result = await transport.send(DivisionBoxEvents.close, {
+        sessionId,
+        options,
+        _sdkapi: resolveSdkApi(),
+      })
+
       if (!result.success) {
         throw new Error(result.error?.message || 'Failed to close DivisionBox')
       }
     },
 
     onStateChange(handler: StateChangeHandler): () => void {
+      ensureActive('onStateChange')
       stateChangeHandlers.add(handler)
-      
+
       return () => {
         stateChangeHandlers.delete(handler)
       }
     },
 
+    onLifecycleChange(handler: LifecycleChangeHandler): () => void {
+      ensureActive('onLifecycleChange')
+      lifecycleChangeHandlers.add(handler)
+
+      return () => {
+        lifecycleChangeHandlers.delete(handler)
+      }
+    },
+
     async updateState(sessionId: string, key: string, value: any): Promise<void> {
-      const result = await send('division-box:update-state', {
+      ensureActive('updateState')
+      const result = await transport.send(DivisionBoxEvents.updateState, {
         sessionId,
         key,
-        value
+        value,
+        _sdkapi: resolveSdkApi(),
       })
-      
+
       if (!result.success) {
         throw new Error(result.error?.message || 'Failed to update state')
       }
     },
 
     async getState(sessionId: string, key: string): Promise<any> {
-      const result = await send('division-box:get-state', {
+      ensureActive('getState')
+      const result = await transport.send(DivisionBoxEvents.getState, {
         sessionId,
-        key
+        key,
+        _sdkapi: resolveSdkApi(),
       })
-      
+
       if (!result.success) {
         throw new Error(result.error?.message || 'Failed to get state')
       }
-      
+
       return result.data
-    }
+    },
+
+    dispose,
   }
 }
 
 /**
  * Hook for using DivisionBox SDK in plugin context
- * 
+ *
  * @returns DivisionBox SDK instance
- * 
+ *
  * @example
  * ```typescript
  * const divisionBox = useDivisionBox()
- * 
+ *
  * const { sessionId } = await divisionBox.open({
  *   url: 'https://example.com',
  *   title: 'My Tool'

package/plugin/sdk/examples/storage-onDidChange-example.js

@@ -1,3 +1,6 @@
+import { hasWindow } from '@talex-touch/utils/env'
+import { useTouchSDK } from '@talex-touch/utils/plugin/sdk'
+
 /**
  * Storage onDidChange 示例
  * 展示如何使用 storage.onDidChange 监听存储文件变化
@@ -5,7 +8,7 @@
  */
 
 // 获取SDK实例
-const sdk = window.$touchSDK
+const sdk = useTouchSDK()
 
 // 示例1: 监听特定配置文件的变化
 function setupConfigListener() {
@@ -189,7 +192,7 @@ window.storageOnDidChangeExample = {
 }
 
 // 自动运行示例（可选）
-if (typeof window !== 'undefined' && window.location.hostname === 'localhost') {
+if (hasWindow() && window.location.hostname === 'localhost') {
   console.log('[Auto] Setting up storage listeners...')
 
   // 设置配置监听