@talex-touch/utils 1.0.39 → 1.0.42

package/plugin/sdk/hooks/bridge.ts

@@ -3,53 +3,109 @@ import { ensureRendererChannel } from '../channel'
 
 export type BridgeEvent = BridgeEventForCoreBox
 
-/**
- * Defines the shape of a bridge hook function.
- * @template T The type of data the hook will receive.
- */
-export type BridgeHook<T = any> = (data: T) => void
+export interface BridgeEventMeta {
+  timestamp: number
+  fromCache: boolean
+}
+
+export interface BridgeEventPayload<T = any> {
+  data: T
+  meta: BridgeEventMeta
+}
+
+/** @template T The type of data the hook will receive. */
+export type BridgeHook<T = any> = (payload: BridgeEventPayload<T>) => void
+
+interface CachedEvent<T = any> {
+  data: T
+  timestamp: number
+}
 
 const __hooks: Record<BridgeEvent, Array<BridgeHook>> = {
   [BridgeEventForCoreBox.CORE_BOX_INPUT_CHANGE]: [],
   [BridgeEventForCoreBox.CORE_BOX_CLIPBOARD_CHANGE]: [],
+  [BridgeEventForCoreBox.CORE_BOX_KEY_EVENT]: [],
 }
 
-/**
- * Injects a hook for a given bridge event.
- * @param type The bridge event type.
- * @param hook The hook function to inject.
- * @returns The wrapped hook function.
- * @internal
- * @template T The type of data the hook will receive.
- */
-export function injectBridgeEvent<T>(type: BridgeEvent, hook: BridgeHook<T>) {
-  const hooks: Array<BridgeHook<T>> = __hooks[type] || (__hooks[type] = [])
+const __eventCache: Map<BridgeEvent, CachedEvent[]> = new Map()
+const __channelRegistered = new Set<BridgeEvent>()
+
+const CACHE_MAX_SIZE: Record<BridgeEvent, number> = {
+  [BridgeEventForCoreBox.CORE_BOX_INPUT_CHANGE]: 1,
+  [BridgeEventForCoreBox.CORE_BOX_CLIPBOARD_CHANGE]: 1,
+  [BridgeEventForCoreBox.CORE_BOX_KEY_EVENT]: 10,
+}
+
+function invokeHook<T>(hook: BridgeHook<T>, data: T, fromCache: boolean, timestamp: number): void {
+  try {
+    hook({ data, meta: { timestamp, fromCache } })
+  }
+  catch (e) {
+    console.error('[TouchSDK] Bridge hook error:', e)
+  }
+}
+
+function registerEarlyListener(type: BridgeEvent): void {
+  if (__channelRegistered.has(type)) return
 
-  // Only register the channel listener once per event type
-  if (hooks.length === 0) {
-    const channel = ensureRendererChannel('[TouchSDK] Bridge channel not available. Make sure hooks run in plugin renderer context.')
+  try {
+    const channel = ensureRendererChannel()
     channel.regChannel(type, ({ data }) => {
-      console.debug(`[TouchSDK] ${type} event received: `, data)
-      // When the event is received, call all registered hooks for this type
-      const registeredHooks = __hooks[type]
-      if (registeredHooks) {
-        registeredHooks.forEach(h => h(data))
+      const timestamp = Date.now()
+      const hooks = __hooks[type]
+
+      if (hooks && hooks.length > 0) {
+        hooks.forEach(h => invokeHook(h, data, false, timestamp))
+      }
+      else {
+        if (!__eventCache.has(type)) __eventCache.set(type, [])
+        const cache = __eventCache.get(type)!
+        const maxSize = CACHE_MAX_SIZE[type] ?? 1
+        cache.push({ data, timestamp })
+        while (cache.length > maxSize) cache.shift()
+        console.debug(`[TouchSDK] ${type} cached, size: ${cache.length}`)
       }
     })
+    __channelRegistered.add(type)
+  }
+  catch {
+    // Channel not ready yet
   }
+}
 
-  const wrappedHook = (data: T) => {
-    try {
-      hook(data)
-    }
-    catch (e) {
-      console.error(`[TouchSDK] ${type} hook error: `, e)
-    }
+/** Clears the event cache for a specific event type or all types. */
+export function clearBridgeEventCache(type?: BridgeEvent): void {
+  if (type) {
+    __eventCache.delete(type)
+  }
+  else {
+    __eventCache.clear()
   }
+}
 
-  hooks.push(wrappedHook)
+// Auto-init on module load
+;(function initBridgeEventCache() {
+  setTimeout(() => {
+    Object.values(BridgeEventForCoreBox).forEach(e => registerEarlyListener(e as BridgeEvent))
+  }, 0)
+})()
 
-  return wrappedHook
+/** @internal Injects a hook for a given bridge event with cache replay. */
+export function injectBridgeEvent<T>(type: BridgeEvent, hook: BridgeHook<T>) {
+  const hooks: Array<BridgeHook<T>> = __hooks[type] || (__hooks[type] = [])
+
+  // Ensure channel listener is registered
+  registerEarlyListener(type)
+
+  // Replay cached events to this new hook
+  const cached = __eventCache.get(type)
+  if (cached && cached.length > 0) {
+    cached.forEach(({ data, timestamp }) => invokeHook(hook, data as T, true, timestamp))
+    __eventCache.delete(type)
+  }
+
+  hooks.push(hook)
+  return hook
 }
 
 /**
@@ -60,11 +116,29 @@ export function injectBridgeEvent<T>(type: BridgeEvent, hook: BridgeHook<T>) {
  */
 export const createBridgeHook = <T>(type: BridgeEvent) => (hook: BridgeHook<T>) => injectBridgeEvent<T>(type, hook)
 
-/**
- * Hook for when the core box input changes.
- * The hook receives the new input value as a string.
- * @param data The input change data (string).
- */
-export const onCoreBoxInputChange = createBridgeHook<{ query: string }>(BridgeEventForCoreBox.CORE_BOX_INPUT_CHANGE)
+export interface CoreBoxInputData {
+  query: { inputs: Array<any>, text: string }
+}
+
+export interface CoreBoxKeyEventData {
+  key: string
+  code: string
+  metaKey: boolean
+  ctrlKey: boolean
+  altKey: boolean
+  shiftKey: boolean
+  repeat: boolean
+}
+
+export interface CoreBoxClipboardData {
+  item: any
+}
+
+/** Hook for CoreBox input changes. Payload includes `data` and `meta` (timestamp, fromCache). */
+export const onCoreBoxInputChange = createBridgeHook<CoreBoxInputData>(BridgeEventForCoreBox.CORE_BOX_INPUT_CHANGE)
+
+/** Hook for CoreBox clipboard changes. Payload includes `data` and `meta` (timestamp, fromCache). */
+export const onCoreBoxClipboardChange = createBridgeHook<CoreBoxClipboardData>(BridgeEventForCoreBox.CORE_BOX_CLIPBOARD_CHANGE)
 
-export const onCoreBoxClipboardChange = createBridgeHook<{ item: any }>(BridgeEventForCoreBox.CORE_BOX_CLIPBOARD_CHANGE)
+/** Hook for keyboard events forwarded from CoreBox. Payload includes `data` and `meta` (timestamp, fromCache). */
+export const onCoreBoxKeyEvent = createBridgeHook<CoreBoxKeyEventData>(BridgeEventForCoreBox.CORE_BOX_KEY_EVENT)

package/plugin/sdk/index.ts

@@ -13,9 +13,11 @@ export * from './clipboard'
 export * from './core-box'
 export * from './division-box'
 export * from './feature-sdk'
+export * from './flow'
 export { createFeaturesManager, useFeatures } from './features'
 
 export * from './hooks/index'
+export * from './performance'
 export * from './service/index'
 export * from './storage'
 export * from './system'

package/plugin/sdk/performance.ts

@@ -0,0 +1,186 @@
+/**
+ * Plugin Performance SDK
+ *
+ * Provides APIs for plugins to access their own performance metrics
+ * and storage statistics.
+ */
+import type { ITouchClientChannel } from '@talex-touch/utils/channel'
+import type { StorageStats } from '../../types/storage'
+import { ensureRendererChannel } from './channel'
+
+/**
+ * Performance metrics interface
+ */
+export interface PerformanceMetrics {
+  /** Plugin load time in milliseconds */
+  loadTime: number
+  /** Estimated memory usage in bytes */
+  memoryUsage: number
+  /** CPU usage percentage (0-100) */
+  cpuUsage: number
+  /** Last active timestamp */
+  lastActiveTime: number
+}
+
+/**
+ * Plugin paths interface
+ */
+export interface PluginPaths {
+  /** Plugin installation directory */
+  pluginPath: string
+  /** Plugin data directory */
+  dataPath: string
+  /** Plugin config directory */
+  configPath: string
+  /** Plugin logs directory */
+  logsPath: string
+  /** Plugin temp directory */
+  tempPath: string
+}
+
+/**
+ * Performance SDK interface
+ */
+export interface PerformanceSDK {
+  /**
+   * Get storage statistics for the current plugin
+   *
+   * @example
+   * ```typescript
+   * const stats = await plugin.performance.getStorageStats()
+   * console.log(`Using ${stats.usagePercent}% of storage`)
+   * ```
+   */
+  getStorageStats: () => Promise<StorageStats>
+
+  /**
+   * Get performance metrics for the current plugin
+   *
+   * @example
+   * ```typescript
+   * const metrics = await plugin.performance.getMetrics()
+   * console.log(`Load time: ${metrics.loadTime}ms`)
+   * ```
+   */
+  getMetrics: () => Promise<PerformanceMetrics>
+
+  /**
+   * Get all paths for the current plugin
+   *
+   * @example
+   * ```typescript
+   * const paths = await plugin.performance.getPaths()
+   * console.log(`Plugin installed at: ${paths.pluginPath}`)
+   * ```
+   */
+  getPaths: () => Promise<PluginPaths>
+
+  /**
+   * Get combined performance data (storage + metrics + paths)
+   *
+   * @example
+   * ```typescript
+   * const data = await plugin.performance.getAll()
+   * console.log(data.storage, data.metrics, data.paths)
+   * ```
+   */
+  getAll: () => Promise<{
+    storage: StorageStats
+    metrics: PerformanceMetrics
+    paths: PluginPaths
+  }>
+}
+
+/**
+ * Creates a Performance SDK instance for plugin use
+ *
+ * @param channel - The plugin channel bridge for IPC communication
+ * @returns Configured Performance SDK instance
+ *
+ * @internal
+ */
+export function createPerformanceSDK(channel: ITouchClientChannel): PerformanceSDK {
+  return {
+    async getStorageStats(): Promise<StorageStats> {
+      try {
+        const result = await channel.send('plugin:storage:get-stats')
+        return result?.data || {
+          totalSize: 0,
+          fileCount: 0,
+          dirCount: 0,
+          maxSize: 10 * 1024 * 1024,
+          usagePercent: 0,
+        }
+      }
+      catch (error) {
+        console.error('[Performance SDK] Failed to get storage stats:', error)
+        throw error
+      }
+    },
+
+    async getMetrics(): Promise<PerformanceMetrics> {
+      try {
+        const result = await channel.send('plugin:performance:get-metrics')
+        return result?.data || {
+          loadTime: 0,
+          memoryUsage: 0,
+          cpuUsage: 0,
+          lastActiveTime: 0,
+        }
+      }
+      catch (error) {
+        console.error('[Performance SDK] Failed to get performance metrics:', error)
+        throw error
+      }
+    },
+
+    async getPaths(): Promise<PluginPaths> {
+      try {
+        const result = await channel.send('plugin:performance:get-paths')
+        return result?.data || {
+          pluginPath: '',
+          dataPath: '',
+          configPath: '',
+          logsPath: '',
+          tempPath: '',
+        }
+      }
+      catch (error) {
+        console.error('[Performance SDK] Failed to get plugin paths:', error)
+        throw error
+      }
+    },
+
+    async getAll(): Promise<{
+      storage: StorageStats
+      metrics: PerformanceMetrics
+      paths: PluginPaths
+    }> {
+      const [storage, metrics, paths] = await Promise.all([
+        this.getStorageStats(),
+        this.getMetrics(),
+        this.getPaths(),
+      ])
+
+      return { storage, metrics, paths }
+    },
+  }
+}
+
+/**
+ * Hook for using Performance SDK in plugin context
+ *
+ * @returns Performance SDK instance
+ *
+ * @example
+ * ```typescript
+ * const performance = usePerformance()
+ *
+ * const stats = await performance.getStorageStats()
+ * const metrics = await performance.getMetrics()
+ * ```
+ */
+export function usePerformance(): PerformanceSDK {
+  const channel = ensureRendererChannel('[Performance SDK] Channel not available. Make sure this is called in a plugin context.')
+  return createPerformanceSDK(channel)
+}

package/plugin/widget.ts

@@ -18,6 +18,11 @@ export interface WidgetRegistrationPayload {
   code: string
   styles: string
   hash: string
+  /**
+   * List of allowed module dependencies for widget sandbox
+   * Widget 沙箱允许的模块依赖列表
+   */
+  dependencies?: string[]
 }
 
 export function makeWidgetId(pluginName: string, featureId: string): string {

package/renderer/hooks/arg-mapper.ts

@@ -5,6 +5,8 @@
 export interface IArgMapperOptions {
   /** The type of touch window - either main window or core-box popup */
   touchType?: 'main' | 'core-box'
+  /** The sub-type for core-box windows (e.g., division-box) */
+  coreType?: 'division-box'
   /** User data directory path */
   userDataDir?: string
   /** Application path */
@@ -32,22 +34,17 @@ declare global {
  * @returns Mapped command line arguments as key-value pairs
  */
 export function useArgMapper(args: string[] = process.argv): IArgMapperOptions {
-  if (window.$argMapper) {
-    return window.$argMapper
-  }
+  if (window.$argMapper) return window.$argMapper
 
   const mapper: IArgMapperOptions = {}
-
   for (const arg of args) {
     if (arg.startsWith('--') && arg.includes('=')) {
       const [key, ...valueParts] = arg.slice(2).split('=')
       const value = valueParts.join('=')
-
       const camelCaseKey = key.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase())
       mapper[camelCaseKey] = value
     }
   }
-
   return window.$argMapper = mapper
 }
 
@@ -76,3 +73,20 @@ export function isMainWindow() {
 export function isCoreBox() {
   return useTouchType() === 'core-box'
 }
+
+/**
+ * Gets the core-box sub-type from command line arguments
+ * @returns The core type ('division-box') or undefined
+ */
+export function useCoreType() {
+  const argMapper = useArgMapper()
+  return argMapper.coreType
+}
+
+/**
+ * Checks if the current window is a division-box window
+ * @returns True if the current window is a division-box
+ */
+export function isDivisionBox() {
+  return isCoreBox() && useCoreType() === 'division-box'
+}