@talex-touch/utils 1.0.30 → 1.0.32

package/plugin/preload.ts

@@ -1,18 +1,21 @@
 import type { ITouchClientChannel } from '../channel'
+import type { ITouchSDK } from './sdk/index'
+// Import SDK for side effects (initializes hooks)
 import './sdk/index'
 
-// window type
+// window type - includes both plugin preload types and SDK types
 declare global {
-  export interface Window {
+  interface Window {
     $plugin: {
       name: string
-      path: Object
+      path: object
     }
     $channel: ITouchClientChannel
     $crash: (message: string, extraData: any) => void
     $config: {
       themeStyle: any
     }
+    $touchSDK: ITouchSDK
   }
 }
 

package/plugin/providers/registry.ts

@@ -1,18 +1,18 @@
-import { defaultRiskPromptHandler } from '../risk'
 import type { PluginInstallRequest, PluginInstallResult, PluginProvider, PluginProviderContext } from './types'
+import { defaultRiskPromptHandler } from '../risk'
 
 class ProviderRegistry {
   private providers: PluginProvider[] = []
 
   register(provider: PluginProvider): void {
-    if (this.providers.some((item) => item.type === provider.type)) {
+    if (this.providers.some(item => item.type === provider.type)) {
       throw new Error(`Plugin provider '${provider.type}' already registered`)
     }
     this.providers.push(provider)
   }
 
   unregister(type: PluginProvider['type']): void {
-    this.providers = this.providers.filter((item) => item.type !== type)
+    this.providers = this.providers.filter(item => item.type !== type)
   }
 
   clear(): void {
@@ -20,19 +20,20 @@ class ProviderRegistry {
   }
 
   resolve(request: PluginInstallRequest): PluginProvider | undefined {
-    return this.providers.find((provider) => provider.canHandle(request))
+    return this.providers.find(provider => provider.canHandle(request))
   }
 
   async install(
     request: PluginInstallRequest,
-    context: PluginProviderContext = {}
+    context: PluginProviderContext = {},
   ): Promise<PluginInstallResult | undefined> {
     const provider = this.resolve(request)
-    if (!provider) return undefined
+    if (!provider)
+      return undefined
 
     const composedContext: PluginProviderContext = {
       riskPrompt: defaultRiskPromptHandler,
-      ...context
+      ...context,
     }
 
     if (!composedContext.riskPrompt) {

package/plugin/providers/types.ts

@@ -1,5 +1,5 @@
-import type { IDownloadOptions, IDownloadResult } from '../plugin-source'
 import type { IManifest } from '..'
+import type { IDownloadOptions, IDownloadResult } from '../plugin-source'
 import type { RiskPromptHandler } from '../risk'
 
 export enum PluginProviderType {
@@ -7,7 +7,7 @@ export enum PluginProviderType {
   NPM = 'npm',
   TPEX = 'tpex',
   FILE = 'file',
-  DEV = 'dev'
+  DEV = 'dev',
 }
 
 export interface PluginInstallRequest {
@@ -43,11 +43,11 @@ export interface PluginInstallResult extends IDownloadResult {
 
 export interface PluginProvider {
   readonly type: PluginProviderType
-  canHandle(request: PluginInstallRequest): boolean
-  install(
+  canHandle: (request: PluginInstallRequest) => boolean
+  install: (
     request: PluginInstallRequest,
-    context?: PluginProviderContext
-  ): Promise<PluginInstallResult>
+    context?: PluginProviderContext,
+  ) => Promise<PluginInstallResult>
 }
 
 export interface PluginInstallSummary {

package/plugin/sdk/channel.ts

@@ -1,48 +1,48 @@
-import type { ITouchClientChannel } from '@talex-touch/utils/channel';
-import { genChannel } from '../channel';
-import type { IPluginRendererChannel, PluginChannelHandler } from './types';
+import type { ITouchClientChannel } from '@talex-touch/utils/channel'
+import type { IPluginRendererChannel, PluginChannelHandler } from './types'
+import { genChannel } from '../channel'
 
-const ensureClientChannel = (): ITouchClientChannel => genChannel();
+const ensureClientChannel = (): ITouchClientChannel => genChannel()
 
 export function createPluginRendererChannel(): IPluginRendererChannel {
-  const client = ensureClientChannel();
+  const client = ensureClientChannel()
 
   return {
     send(eventName, payload) {
-      return client.send(eventName, payload);
+      return client.send(eventName, payload)
     },
 
     sendSync(eventName, payload) {
-      return client.sendSync(eventName, payload);
+      return client.sendSync(eventName, payload)
     },
 
     on(eventName, handler) {
-      return client.regChannel(eventName, handler);
+      return client.regChannel(eventName, handler)
     },
 
     once(eventName, handler) {
-      let dispose: () => void = () => void 0;
+      let dispose: () => void = () => void 0
       const wrapped: PluginChannelHandler = (event) => {
-        dispose();
-        handler(event);
-      };
+        dispose()
+        handler(event)
+      }
 
-      dispose = client.regChannel(eventName, wrapped);
-      return dispose;
+      dispose = client.regChannel(eventName, wrapped)
+      return dispose
     },
 
     get raw() {
-      return client;
-    }
-  };
+      return client
+    },
+  }
 }
 
-let cachedRendererChannel: IPluginRendererChannel | null = null;
+let cachedRendererChannel: IPluginRendererChannel | null = null
 
 export function usePluginRendererChannel(): IPluginRendererChannel {
   if (!cachedRendererChannel) {
-    cachedRendererChannel = createPluginRendererChannel();
+    cachedRendererChannel = createPluginRendererChannel()
   }
 
-  return cachedRendererChannel;
+  return cachedRendererChannel
 }

package/plugin/sdk/clipboard.ts

@@ -1,6 +1,6 @@
 import type { PluginClipboardHistoryResponse, PluginClipboardItem } from './types'
 
-const ensurePluginChannel = () => {
+function ensurePluginChannel() {
   const channel = (window as any)?.$channel
   if (!channel) {
     throw new Error('[Plugin SDK] Clipboard channel requires plugin renderer context with $channel available.')
@@ -8,13 +8,15 @@ const ensurePluginChannel = () => {
   return channel
 }
 
-const normalizeItem = (item: PluginClipboardItem | null): PluginClipboardItem | null => {
-  if (!item) return item
+function normalizeItem(item: PluginClipboardItem | null): PluginClipboardItem | null {
+  if (!item)
+    return item
   if (!item.meta && typeof item.metadata === 'string') {
     try {
       const parsed = JSON.parse(item.metadata)
       return { ...item, meta: parsed }
-    } catch {
+    }
+    catch {
       return { ...item, meta: null }
     }
   }
@@ -61,7 +63,7 @@ export function useClipboardHistory() {
         : []
       return {
         ...response,
-        history
+        history,
       }
     },
 
@@ -94,6 +96,6 @@ export function useClipboardHistory() {
         return Boolean((response as any).success)
       }
       return true
-    }
+    },
   }
 }

package/plugin/sdk/common.ts

@@ -17,8 +17,10 @@ export function regShortcut(key: string, func: Function): boolean {
   const channel = genChannel()
 
   const res = channel.sendSync('shortcon:reg', { key })
-  if (res instanceof String) throw new Error(String(res))
-  if (res === false) return false
+  if (res instanceof String)
+    throw new Error(String(res))
+  if (res === false)
+    return false
 
   channel.regChannel('shortcon:trigger', ({ data }) => key === data.key && func())
 
@@ -33,16 +35,17 @@ export function regShortcut(key: string, func: Function): boolean {
  */
 export async function communicateWithPlugin(
   key: string,
-  info: any = {}
+  info: any = {},
 ): Promise<any> {
   const channel = genChannel()
 
   try {
     return await channel.send('index:communicate', {
       key,
-      info
+      info,
     })
-  } catch (error) {
+  }
+  catch (error) {
     console.error(`[Plugin SDK] Failed to communicate`, error)
     throw error
   }
@@ -59,7 +62,8 @@ export async function sendMessage(message: string, data: any = {}): Promise<any>
 
   try {
     return await channel.send(`plugin:${message}`, data)
-  } catch (error) {
+  }
+  catch (error) {
     console.error(`[Plugin SDK] Failed to send message: ${message}`, error)
     throw error
   }

package/plugin/sdk/core-box.ts

@@ -1,6 +1,6 @@
 import type { IPluginRendererChannel } from './types'
 
-const ensurePluginContext = (): { channel: IPluginRendererChannel; pluginName: string } => {
+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.')
@@ -13,7 +13,7 @@ const ensurePluginContext = (): { channel: IPluginRendererChannel; pluginName: s
 
   return {
     channel,
-    pluginName: plugin.name as string
+    pluginName: plugin.name as string,
   }
 }
 
@@ -24,4 +24,3 @@ export async function clearCoreBoxItems(): Promise<void> {
   const { channel, pluginName } = ensurePluginContext()
   await channel.send('core-box:clear-items', { pluginName })
 }
-

package/plugin/sdk/division-box.ts

@@ -0,0 +1,266 @@
+/**
+ * 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.
+ */
+
+import type {
+  CloseOptions,
+  DivisionBoxConfig,
+  DivisionBoxState,
+  SessionInfo,
+} from '../../types/division-box'
+
+/**
+ * State change event handler
+ */
+export type StateChangeHandler = (data: {
+  sessionId: string
+  state: DivisionBoxState
+}) => void
+
+/**
+ * DivisionBox SDK interface for plugins
+ * 
+ * @example
+ * ```typescript
+ * // Open a DivisionBox
+ * const { sessionId } = await plugin.divisionBox.open({
+ *   url: 'https://example.com/tool',
+ *   title: 'My Tool',
+ *   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)
+ * ```
+ */
+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({
+   *   url: 'https://example.com',
+   *   title: 'Web Tool',
+   *   icon: 'ri:tools-line',
+   *   size: 'medium',
+   *   keepAlive: true,
+   *   header: {
+   *     show: true,
+   *     title: 'Custom Title',
+   *     actions: [
+   *       { label: 'Refresh', icon: 'ri:refresh-line', onClick: () => {} }
+   *     ]
+   *   }
+   * })
+   * ```
+   */
+  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>
+
+  /**
+   * 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
+
+  /**
+   * 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',
+   *   timestamp: Date.now()
+   * })
+   * ```
+   */
+  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>
+}
+
+/**
+ * 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()
+
+  // 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))
+      })
+    }
+  }
+
+  registerListener()
+
+  return {
+    async open(config: DivisionBoxConfig): Promise<SessionInfo> {
+      // Send to main process
+      const sendFn = channel.sendToMain || channel.send
+      const result = await sendFn('division-box:open', config)
+      
+      if (!result.success) {
+        throw new Error(result.error?.message || 'Failed to open DivisionBox')
+      }
+      
+      return result.data
+    },
+
+    async close(sessionId: string, options?: CloseOptions): Promise<void> {
+      const sendFn = channel.sendToMain || channel.send
+      const result = await sendFn('division-box:close', { sessionId, options })
+      
+      if (!result.success) {
+        throw new Error(result.error?.message || 'Failed to close DivisionBox')
+      }
+    },
+
+    onStateChange(handler: StateChangeHandler): () => void {
+      stateChangeHandlers.add(handler)
+      
+      return () => {
+        stateChangeHandlers.delete(handler)
+      }
+    },
+
+    async updateState(sessionId: string, key: string, value: any): Promise<void> {
+      const sendFn = channel.sendToMain || channel.send
+      const result = await sendFn('division-box:update-state', {
+        sessionId,
+        key,
+        value
+      })
+      
+      if (!result.success) {
+        throw new Error(result.error?.message || 'Failed to update state')
+      }
+    },
+
+    async getState(sessionId: string, key: string): Promise<any> {
+      const sendFn = channel.sendToMain || channel.send
+      const result = await sendFn('division-box:get-state', {
+        sessionId,
+        key
+      })
+      
+      if (!result.success) {
+        throw new Error(result.error?.message || 'Failed to get state')
+      }
+      
+      return result.data
+    }
+  }
+}
+
+/**
+ * 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'
+ * })
+ * ```
+ */
+export function useDivisionBox(): DivisionBoxSDK {
+  // @ts-ignore - window.$channel is injected by the plugin system
+  const channel = window.$channel
+  
+  if (!channel) {
+    throw new Error('[DivisionBox SDK] Channel not available. Make sure this is called in a plugin context.')
+  }
+  
+  return createDivisionBoxSDK(channel)
+}

package/plugin/sdk/enum/bridge-event.ts

@@ -1,4 +1,4 @@
 export enum BridgeEventForCoreBox {
   CORE_BOX_INPUT_CHANGE = 'core-box:input-change',
- CORE_BOX_CLIPBOARD_CHANGE = 'core-box:clipboard-change'
+  CORE_BOX_CLIPBOARD_CHANGE = 'core-box:clipboard-change',
 }

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

@@ -185,7 +185,7 @@ window.storageOnDidChangeExample = {
   setupMultipleFileListeners,
   setupDynamicListener,
   setupConditionalListener,
-  setupBatchOperationListener
+  setupBatchOperationListener,
 }
 
 // 自动运行示例（可选）