@talex-touch/utils 1.0.42 → 1.0.45

package/__tests__/plugin-sdk-lifecycle.test.ts

@@ -0,0 +1,130 @@
+import { describe, expect, it, vi } from 'vitest'
+import { DivisionBoxEvents } from '../transport/events'
+import { createDivisionBoxSDK } from '../plugin/sdk/division-box'
+import { createFeatureSDK } from '../plugin/sdk/feature-sdk'
+import { createMetaSDK } from '../plugin/sdk/meta-sdk'
+
+type Handler = (payload: unknown) => unknown
+
+function createMockChannel() {
+  const listeners = new Map<string, Set<Handler>>()
+
+  const channel = {
+    send: vi.fn(async () => undefined),
+    regChannel: vi.fn((eventName: string, handler: Handler) => {
+      const bucket = listeners.get(eventName) || new Set<Handler>()
+      bucket.add(handler)
+      listeners.set(eventName, bucket)
+
+      return () => {
+        const current = listeners.get(eventName)
+        current?.delete(handler)
+      }
+    }),
+  }
+
+  const emit = async (eventName: string, payload: unknown) => {
+    const bucket = listeners.get(eventName)
+    if (!bucket) {
+      return
+    }
+
+    for (const handler of bucket) {
+      await handler(payload)
+    }
+  }
+
+  const listenerCount = (eventName: string) => listeners.get(eventName)?.size ?? 0
+
+  return { channel, emit, listenerCount }
+}
+
+describe('plugin sdk lifecycle', () => {
+  it('feature sdk removes channel listeners after dispose', async () => {
+    const { channel, emit, listenerCount } = createMockChannel()
+    const boxItemsAPI = {
+      pushItems: vi.fn(),
+      update: vi.fn(),
+      remove: vi.fn(),
+      clear: vi.fn(),
+      getItems: vi.fn(() => []),
+    }
+
+    const sdk = createFeatureSDK(boxItemsAPI, channel as any)
+    const onInput = vi.fn()
+    sdk.onInputChange(onInput)
+
+    expect(listenerCount('core-box:input-change')).toBe(1)
+
+    await emit('core-box:input-change', { input: 'hello' })
+    expect(onInput).toHaveBeenCalledWith('hello')
+
+    sdk.dispose()
+    expect(listenerCount('core-box:input-change')).toBe(0)
+
+    await emit('core-box:input-change', { input: 'world' })
+    expect(onInput).toHaveBeenCalledTimes(1)
+  })
+
+  it('division box sdk removes state listener after dispose', async () => {
+    const { channel, emit, listenerCount } = createMockChannel()
+    const sdk = createDivisionBoxSDK(channel as any)
+    const onStateChange = vi.fn()
+    sdk.onStateChange(onStateChange)
+
+    const eventName = DivisionBoxEvents.stateChanged.toEventName()
+    expect(listenerCount(eventName)).toBe(1)
+
+    await emit(eventName, { sessionId: 's1', newState: 'active' })
+    expect(onStateChange).toHaveBeenCalledWith({ sessionId: 's1', state: 'active' })
+
+    sdk.dispose()
+    expect(listenerCount(eventName)).toBe(0)
+  })
+
+  it('meta sdk clears execute listener after dispose', async () => {
+    const { channel, emit, listenerCount } = createMockChannel()
+    const sdk = createMetaSDK(channel as any, 'demo-plugin')
+    const onExecute = vi.fn()
+
+    sdk.onActionExecute(onExecute)
+    sdk.registerAction({
+      id: 'action-1',
+      render: {
+        basic: {
+          title: 'Action',
+          subtitle: 'Run action',
+          icon: { type: 'class', value: 'i-ri-star-line' },
+        },
+      },
+      priority: 1,
+    })
+
+    expect(listenerCount('meta-overlay:action-executed')).toBe(1)
+
+    await emit('meta-overlay:action-executed', {
+      pluginId: 'demo-plugin',
+      actionId: 'action-1',
+      item: {
+        id: 'item-1',
+        title: { text: 'Item 1' },
+        source: { id: 'demo', name: 'Demo' },
+      },
+    })
+    expect(onExecute).toHaveBeenCalledTimes(1)
+
+    sdk.dispose()
+    expect(listenerCount('meta-overlay:action-executed')).toBe(0)
+
+    await emit('meta-overlay:action-executed', {
+      pluginId: 'demo-plugin',
+      actionId: 'action-1',
+      item: {
+        id: 'item-2',
+        title: { text: 'Item 2' },
+        source: { id: 'demo', name: 'Demo' },
+      },
+    })
+    expect(onExecute).toHaveBeenCalledTimes(1)
+  })
+})

package/__tests__/power-sdk.test.ts

@@ -0,0 +1,143 @@
+import { describe, expect, it, vi } from 'vitest'
+import { AppEvents } from '../transport/events'
+import { createPowerSDK } from '../plugin/sdk/power'
+
+type ChannelListener = (payload: unknown) => unknown
+
+function createMockChannel(options: {
+  sendImpl?: (eventName: string, payload?: unknown) => Promise<unknown>
+} = {}) {
+  const listeners = new Map<string, Set<ChannelListener>>()
+
+  const channel = {
+    send: vi.fn(async (eventName: string, payload?: unknown) => {
+      if (options.sendImpl) {
+        return options.sendImpl(eventName, payload)
+      }
+      return null
+    }),
+    regChannel: vi.fn((eventName: string, handler: ChannelListener) => {
+      const set = listeners.get(eventName) || new Set<ChannelListener>()
+      set.add(handler)
+      listeners.set(eventName, set)
+
+      return () => {
+        const current = listeners.get(eventName)
+        current?.delete(handler)
+      }
+    }),
+  }
+
+  const emit = async (eventName: string, payload: unknown) => {
+    const set = listeners.get(eventName)
+    if (!set || set.size === 0) {
+      return
+    }
+
+    for (const handler of set) {
+      await handler(payload)
+    }
+  }
+
+  return { channel, emit }
+}
+
+describe('PowerSDK', () => {
+  it('returns lowPower=true when on battery and below threshold', async () => {
+    const { channel } = createMockChannel({
+      sendImpl: async (eventName) => {
+        if (eventName === AppEvents.fileIndex.batteryLevel.toEventName()) {
+          return { level: 15, charging: false }
+        }
+        return null
+      },
+    })
+
+    const sdk = createPowerSDK(channel as any)
+    const status = await sdk.getLowPowerStatus({ threshold: 20 })
+
+    expect(status).toEqual({
+      lowPower: true,
+      onBattery: true,
+      percent: 15,
+      threshold: 20,
+    })
+  })
+
+  it('falls back to safe defaults when battery query fails', async () => {
+    const { channel } = createMockChannel({
+      sendImpl: async () => {
+        throw new Error('query failed')
+      },
+    })
+
+    const sdk = createPowerSDK(channel as any)
+    const status = await sdk.getLowPowerStatus({ threshold: 999 })
+
+    expect(status).toEqual({
+      lowPower: false,
+      onBattery: false,
+      percent: null,
+      threshold: 100,
+    })
+  })
+
+  it('isLowPower returns boolean shortcut value', async () => {
+    const { channel } = createMockChannel({
+      sendImpl: async (eventName) => {
+        if (eventName === AppEvents.fileIndex.batteryLevel.toEventName()) {
+          return { level: 60, charging: false }
+        }
+        return null
+      },
+    })
+
+    const sdk = createPowerSDK(channel as any)
+
+    await expect(sdk.isLowPower({ threshold: 50 })).resolves.toBe(false)
+    await expect(sdk.isLowPower({ threshold: 70 })).resolves.toBe(true)
+  })
+
+  it('onLowPowerChanged emits immediately and deduplicates repeated states', async () => {
+    const { channel, emit } = createMockChannel({
+      sendImpl: async (eventName) => {
+        if (eventName === AppEvents.fileIndex.batteryLevel.toEventName()) {
+          return { level: 40, charging: false }
+        }
+        return null
+      },
+    })
+
+    const sdk = createPowerSDK(channel as any)
+    const callback = vi.fn()
+
+    const dispose = sdk.onLowPowerChanged(callback, { threshold: 30 })
+
+    await new Promise(resolve => setTimeout(resolve, 0))
+    expect(callback).toHaveBeenCalledTimes(1)
+    expect(callback).toHaveBeenLastCalledWith({
+      lowPower: false,
+      onBattery: true,
+      percent: 40,
+      threshold: 30,
+    })
+
+    const batteryStatusEvent = AppEvents.power.batteryStatus.toEventName()
+
+    await emit(batteryStatusEvent, { onBattery: true, percent: 20 })
+    expect(callback).toHaveBeenCalledTimes(2)
+    expect(callback).toHaveBeenLastCalledWith({
+      lowPower: true,
+      onBattery: true,
+      percent: 20,
+      threshold: 30,
+    })
+
+    await emit(batteryStatusEvent, { onBattery: true, percent: 20 })
+    expect(callback).toHaveBeenCalledTimes(2)
+
+    dispose()
+    await emit(batteryStatusEvent, { onBattery: false, percent: 90 })
+    expect(callback).toHaveBeenCalledTimes(2)
+  })
+})

package/__tests__/preset-export-types.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it } from 'vitest'
+import {
+  PRESET_EXPORT_VERSION,
+  createPresetExport,
+  validatePresetData,
+} from '../common/storage/entity/preset-export-types'
+import type {
+  CoreBoxThemeConfig,
+  LayoutAtomConfig,
+} from '../common/storage/entity/layout-atom-types'
+
+const layoutConfig: LayoutAtomConfig = {
+  preset: 'custom',
+  header: { border: 'solid', opacity: 1, height: 26, blur: false },
+  aside: { position: 'left', width: 68, border: 'solid', opacity: 0.6, collapsed: false },
+  view: { radius: [0, 0, 0, 0], shadow: 'none', padding: 0, background: 'transparent' },
+  nav: { style: 'icon', activeIndicator: 'dot' },
+}
+
+const coreBoxConfig: CoreBoxThemeConfig = {
+  preset: 'custom',
+  logo: { position: 'left', size: 24, style: 'default' },
+  input: { border: 'bottom', radius: 8, background: 'transparent' },
+  results: { itemRadius: 6, itemPadding: 8, divider: false, hoverStyle: 'background' },
+  container: { radius: 8, shadow: 'none', border: false },
+}
+
+describe('preset-export-types', () => {
+  it('validates legacy v1 payloads (layout/coreBox only)', () => {
+    const legacyPayload = {
+      version: 1,
+      exportedAt: new Date().toISOString(),
+      meta: {
+        name: 'Legacy Preset',
+      },
+      layout: layoutConfig,
+      coreBox: coreBoxConfig,
+    }
+
+    const result = validatePresetData(legacyPayload)
+    expect(result.valid).toBe(true)
+    expect(result.errors).toHaveLength(0)
+  })
+
+  it('validates v2 payload with theme and canvas fields', () => {
+    const payload = createPresetExport({
+      name: 'V2 Preset',
+      channel: 'beta',
+      source: 'nexus',
+      layout: layoutConfig,
+      coreBox: coreBoxConfig,
+      theme: {
+        window: 'Mica',
+        style: { dark: false, auto: true },
+        addon: { contrast: false, coloring: true },
+        transition: { route: 'slide' },
+      },
+      mainCanvas: {
+        enabled: true,
+        preset: 'custom',
+        columns: 12,
+        rowHeight: 24,
+        gap: 8,
+        items: [
+          { id: 'header', area: 'header', x: 0, y: 0, w: 12, h: 2 },
+          { id: 'aside', area: 'aside', x: 0, y: 2, w: 2, h: 8 },
+          { id: 'view', area: 'view', x: 2, y: 2, w: 10, h: 8 },
+        ],
+      },
+      coreBoxCanvas: {
+        enabled: true,
+        preset: 'custom',
+        columns: 12,
+        rowHeight: 24,
+        gap: 8,
+        items: [
+          { id: 'logo', area: 'logo', x: 0, y: 0, w: 1, h: 1 },
+          { id: 'input', area: 'input', x: 1, y: 0, w: 9, h: 1 },
+          { id: 'actions', area: 'actions', x: 10, y: 0, w: 2, h: 1 },
+        ],
+      },
+    })
+
+    const result = validatePresetData(payload)
+    expect(payload.version).toBe(PRESET_EXPORT_VERSION)
+    expect(result.valid).toBe(true)
+    expect(result.errors).toHaveLength(0)
+  })
+
+  it('rejects malformed coreBox config without results field', () => {
+    const badPayload = {
+      version: PRESET_EXPORT_VERSION,
+      exportedAt: new Date().toISOString(),
+      meta: {
+        name: 'Bad CoreBox Preset',
+      },
+      coreBox: {
+        preset: 'custom',
+        logo: { position: 'left', size: 24, style: 'default' },
+        input: { border: 'bottom', radius: 8, background: 'transparent' },
+      },
+    }
+
+    const result = validatePresetData(badPayload)
+    expect(result.valid).toBe(false)
+    expect(result.errors.some(error => error.includes('CoreBox'))).toBe(true)
+  })
+})

package/__tests__/search/fuzzy-match.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, it } from 'vitest'
+
+import { fuzzyMatch, indicesToRanges } from '../../search/fuzzy-match'
+
+describe('fuzzyMatch', () => {
+  describe('exact match', () => {
+    it('should match identical strings with score 1', () => {
+      const result = fuzzyMatch('hello', 'hello')
+      expect(result.matched).toBe(true)
+      expect(result.score).toBe(1)
+      expect(result.matchedIndices).toEqual([0, 1, 2, 3, 4])
+    })
+
+    it('should be case insensitive', () => {
+      const result = fuzzyMatch('Hello', 'hello')
+      expect(result.matched).toBe(true)
+      expect(result.score).toBe(1)
+    })
+
+    it('should match exact with mixed case', () => {
+      const result = fuzzyMatch('HeLLo', 'HELLO')
+      expect(result.matched).toBe(true)
+      expect(result.score).toBe(1)
+    })
+  })
+
+  describe('substring match', () => {
+    it('should match substring with score 0.95', () => {
+      const result = fuzzyMatch('hello world', 'hello')
+      expect(result.matched).toBe(true)
+      expect(result.score).toBe(0.95)
+      expect(result.matchedIndices).toEqual([0, 1, 2, 3, 4])
+    })
+
+    it('should match substring in middle', () => {
+      const result = fuzzyMatch('say hello there', 'hello')
+      expect(result.matched).toBe(true)
+      expect(result.score).toBe(0.95)
+    })
+  })
+
+  describe('subsequence match', () => {
+    it('should match subsequence like "vsc" to "Visual Studio Code"', () => {
+      const result = fuzzyMatch('Visual Studio Code', 'vsc')
+      expect(result.matched).toBe(true)
+      expect(result.score).toBeGreaterThan(0.8)
+    })
+
+    it('should match non-consecutive characters', () => {
+      const result = fuzzyMatch('abcdef', 'ace')
+      expect(result.matched).toBe(true)
+      expect(result.matchedIndices).toEqual([0, 2, 4])
+    })
+  })
+
+  describe('fuzzy match with errors', () => {
+    it('should match with one typo', () => {
+      const result = fuzzyMatch('hello', 'helol')
+      expect(result.matched).toBe(true)
+      expect(result.score).toBeGreaterThan(0.4)
+      expect(result.score).toBeLessThan(0.8)
+    })
+
+    it('should match with transposed characters', () => {
+      const result = fuzzyMatch('hello', 'hlelo')
+      expect(result.matched).toBe(true)
+    })
+
+    it('should not match with too many errors', () => {
+      const result = fuzzyMatch('hello', 'abcde')
+      expect(result.matched).toBe(false)
+    })
+  })
+
+  describe('edge cases', () => {
+    it('should return no match for empty query', () => {
+      const result = fuzzyMatch('hello', '')
+      expect(result.matched).toBe(false)
+      expect(result.score).toBe(0)
+    })
+
+    it('should return no match for empty target', () => {
+      const result = fuzzyMatch('', 'hello')
+      expect(result.matched).toBe(false)
+      expect(result.score).toBe(0)
+    })
+
+    it('should handle single character query', () => {
+      const result = fuzzyMatch('hello', 'h')
+      expect(result.matched).toBe(true)
+    })
+
+    it('should handle query longer than target', () => {
+      const result = fuzzyMatch('hi', 'hello')
+      expect(result.matched).toBe(false)
+    })
+  })
+})
+
+describe('indicesToRanges', () => {
+  it('should convert consecutive indices to single range', () => {
+    const ranges = indicesToRanges([0, 1, 2, 3, 4])
+    expect(ranges).toEqual([{ start: 0, end: 5 }])
+  })
+
+  it('should split non-consecutive indices into multiple ranges', () => {
+    const ranges = indicesToRanges([0, 2, 4])
+    expect(ranges).toEqual([
+      { start: 0, end: 1 },
+      { start: 2, end: 3 },
+      { start: 4, end: 5 },
+    ])
+  })
+
+  it('should handle mixed consecutive and non-consecutive', () => {
+    const ranges = indicesToRanges([0, 1, 2, 5, 6])
+    expect(ranges).toEqual([
+      { start: 0, end: 3 },
+      { start: 5, end: 7 },
+    ])
+  })
+
+  it('should handle empty array', () => {
+    const ranges = indicesToRanges([])
+    expect(ranges).toEqual([])
+  })
+
+  it('should handle single index', () => {
+    const ranges = indicesToRanges([3])
+    expect(ranges).toEqual([{ start: 3, end: 4 }])
+  })
+
+  it('should handle duplicate indices', () => {
+    const ranges = indicesToRanges([0, 0, 1, 1, 2])
+    expect(ranges).toEqual([{ start: 0, end: 3 }])
+  })
+})

package/__tests__/transport/port-policy.test.ts

@@ -0,0 +1,44 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import { AppEvents, ClipboardEvents, CoreBoxEvents } from '../../transport/events'
+import { isPortChannelEnabled, resolvePortChannelAllowlist } from '../../transport/sdk/port-policy'
+
+const ENV_KEY = 'TALEX_TRANSPORT_PORT_CHANNELS'
+const ORIGINAL_ENV = process.env[ENV_KEY]
+
+function restoreEnv(): void {
+  if (ORIGINAL_ENV === undefined) {
+    delete process.env[ENV_KEY]
+    return
+  }
+  process.env[ENV_KEY] = ORIGINAL_ENV
+}
+
+afterEach(() => {
+  restoreEnv()
+})
+
+describe('port-policy', () => {
+  it('uses default allowlist when env is unset', () => {
+    delete process.env[ENV_KEY]
+    const allowlist = resolvePortChannelAllowlist()
+    expect(allowlist.has(ClipboardEvents.change.toEventName())).toBe(true)
+    expect(allowlist.has(AppEvents.fileIndex.progress.toEventName())).toBe(true)
+    expect(allowlist.has(CoreBoxEvents.search.update.toEventName())).toBe(true)
+  })
+
+  it('parses env override list', () => {
+    process.env[ENV_KEY] = [
+      CoreBoxEvents.search.update.toEventName(),
+      ClipboardEvents.change.toEventName(),
+    ].join(',')
+    const allowlist = resolvePortChannelAllowlist()
+    expect(allowlist.has(CoreBoxEvents.search.update.toEventName())).toBe(true)
+    expect(allowlist.has(ClipboardEvents.change.toEventName())).toBe(true)
+    expect(allowlist.has(AppEvents.fileIndex.progress.toEventName())).toBe(false)
+  })
+
+  it('disables allowlist when env is blank', () => {
+    process.env[ENV_KEY] = '   '
+    expect(isPortChannelEnabled(ClipboardEvents.change.toEventName())).toBe(false)
+  })
+})