@talex-touch/utils 1.0.30 → 1.0.32

package/common/search/index.ts

@@ -1,4 +1,4 @@
-import { ISearchProvider, TuffQuery, TuffSearchResult } from '@talex-touch/utils'
+import type { ISearchProvider, TuffQuery, TuffSearchResult } from '@talex-touch/utils'
 
 export * from './gather'
 
@@ -30,7 +30,6 @@ export interface TuffUpdate {
   sourceStats?: TuffSearchResult['sources']
 }
 
-
 /**
  * Search Engine Interface (formerly ISearchEngine)
  *
@@ -41,13 +40,13 @@ export interface ISearchEngine<C> {
    * Registers a search provider with the engine.
    * @param provider - An instance of ISearchProvider.
    */
-  registerProvider(provider: ISearchProvider<C>): void
+  registerProvider: (provider: ISearchProvider<C>) => void
 
   /**
    * Unregisters a search provider by its unique ID.
    * @param providerId - The unique ID of the provider to remove.
    */
-  unregisterProvider(providerId: string): void
+  unregisterProvider: (providerId: string) => void
 
   /**
    * Executes a search across all registered and relevant providers.
@@ -57,11 +56,11 @@ export interface ISearchEngine<C> {
    * @returns A promise that resolves to a TuffSearchResult object,
    *          containing the ranked items and metadata about the search operation.
    */
-  search(query: TuffQuery): Promise<TuffSearchResult>
+  search: (query: TuffQuery) => Promise<TuffSearchResult>
 
   /**
    * Performs background maintenance tasks, such as pre-heating caches,
    * refreshing indexes, etc.
    */
-  maintain(): void
+  maintain: () => void
 }

package/common/storage/constants.ts

@@ -1,7 +1,8 @@
 export enum StorageList {
   APP_SETTING = 'app-setting.ini',
   SHORTCUT_SETTING = 'shortcut-setting.ini',
-  OPENERS = 'openers.json'
+  OPENERS = 'openers.json',
+  IntelligenceConfig = 'aisdk-config',
 }
 
 /**
@@ -13,5 +14,5 @@ export enum ConfigKeys {
    * Stores the timestamp of the last successful full application scan using mdfind.
    * This is used to schedule the next comprehensive scan.
    */
-  APP_PROVIDER_LAST_MDFIND_SCAN = 'app_provider_last_mdfind_scan'
+  APP_PROVIDER_LAST_MDFIND_SCAN = 'app_provider_last_mdfind_scan',
 }

package/common/storage/entity/app-settings.ts

@@ -39,7 +39,23 @@ const _appSettingOriginData = {
   searchEngine: {
     logsEnabled: false,
   },
-};
+  window: {
+    closeToTray: true,
+    startMinimized: false,
+    startSilent: false,
+  },
+  setup: {
+    accessibility: false,
+    notifications: false,
+    autoStart: false,
+    showTray: true,
+    adminPrivileges: false,
+    hideDock: false,
+    runAsAdmin: false,
+    customDesktop: false,
+  },
+  layout: 'simple',
+}
 
 export const appSettingOriginData = Object.freeze(_appSettingOriginData)
 
@@ -49,5 +65,5 @@ export const appSettingOriginData = Object.freeze(_appSettingOriginData)
  * Combines the default configuration with support for dynamic additional properties.
  */
 export type AppSetting = typeof _appSettingOriginData & {
-  [key: string]: any;
-};
+  [key: string]: any
+}

package/common/storage/entity/shortcut-settings.ts

@@ -4,19 +4,19 @@ export enum ShortcutType {
 }
 
 export interface ShortcutMeta {
-  creationTime: number;
-  modificationTime: number;
-  author: string;
-  description?: string;
+  creationTime: number
+  modificationTime: number
+  author: string
+  description?: string
 }
 
 export interface Shortcut {
-  id: string;
-  accelerator: string;
-  type: ShortcutType;
-  meta: ShortcutMeta;
+  id: string
+  accelerator: string
+  type: ShortcutType
+  meta: ShortcutMeta
 }
 
-export type ShortcutSetting = Shortcut[];
+export type ShortcutSetting = Shortcut[]
 
-export const shortcutSettingOriginData: ShortcutSetting = [];
+export const shortcutSettingOriginData: ShortcutSetting = []

package/common/storage/shortcut-storage.ts

@@ -1,12 +1,13 @@
+import type { Shortcut, ShortcutSetting } from './entity/shortcut-settings'
 import { StorageList } from './constants'
-import { shortcutSettingOriginData, ShortcutSetting, Shortcut } from './entity/shortcut-settings'
+import { shortcutSettingOriginData } from './entity/shortcut-settings'
 
 class ShortcutStorage {
   private _config: ShortcutSetting = []
 
   constructor(private readonly storage: {
-    getConfig: (name: string) => any,
-    saveConfig: (name: string, content?: string) => void,
+    getConfig: (name: string) => any
+    saveConfig: (name: string, content?: string) => void
   }) {
     this.init()
   }
@@ -16,7 +17,8 @@ class ShortcutStorage {
     if (!config || !Array.isArray(config) || config.length === 0) {
       this._config = [...shortcutSettingOriginData]
       this._save()
-    } else {
+    }
+    else {
       this._config = config
     }
   }

package/common/utils/file.ts

@@ -1,4 +1,15 @@
-import path from 'path-browserify'
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const path = (() => {
+  if (typeof window === 'undefined') {
+    return require('node:path')
+  }
+  try {
+    return require('path-browserify')
+  }
+  catch {
+    return require('node:path')
+  }
+})()
 
 /**
  * Enum for various file types.
@@ -18,7 +29,7 @@ export enum FileType {
   Spreadsheet = 'Spreadsheet',
   Presentation = 'Presentation',
   Ebook = 'Ebook',
-  Other = 'Other'
+  Other = 'Other',
 }
 
 const extensionMap: Map<FileType, Set<string>> = new Map([
@@ -34,8 +45,8 @@ const extensionMap: Map<FileType, Set<string>> = new Map([
   [FileType.Font, new Set(['.ttf', '.otf', '.woff', '.woff2'])],
   [FileType.Spreadsheet, new Set(['.xls', '.xlsx', '.csv', '.numbers'])],
   [FileType.Presentation, new Set(['.ppt', '.pptx', '.key'])],
-  [FileType.Ebook, new Set(['.epub', '.mobi', '.azw'])]
-]);
+  [FileType.Ebook, new Set(['.epub', '.mobi', '.azw'])],
+])
 
 /**
  * Get the file type from a file path.

package/common/utils/index.ts

@@ -10,7 +10,7 @@
  * ```
  */
 export async function sleep(time: number): Promise<number> {
-    return new Promise(resolve => setTimeout(() => resolve(time), time))
+  return new Promise(resolve => setTimeout(() => resolve(time), time))
 }
 
 /**
@@ -28,14 +28,14 @@ export async function sleep(time: number): Promise<number> {
  * ```
  */
 export function anyStr2Num(str: string): bigint {
-    const codes = Array.from(str).map(ch => ch.charCodeAt(0))
-    const minCode = Math.min(...codes)
+  const codes = Array.from(str).map(ch => ch.charCodeAt(0))
+  const minCode = Math.min(...codes)
 
-    const encoded = codes
-        .map(code => (code - minCode).toString().padStart(2, '0'))
-        .join('')
+  const encoded = codes
+    .map(code => (code - minCode).toString().padStart(2, '0'))
+    .join('')
 
-    return BigInt(`${minCode}000${encoded}`)
+  return BigInt(`${minCode}000${encoded}`)
 }
 
 /**
@@ -51,16 +51,16 @@ export function anyStr2Num(str: string): bigint {
  * ```
  */
 export function num2anyStr(num: bigint): string {
-    const [baseStr, encoded] = num.toString().split('000')
-    const base = Number(baseStr)
+  const [baseStr, encoded] = num.toString().split('000')
+  const base = Number(baseStr)
 
-    let result = ''
-    for (let i = 0; i < encoded.length; i += 2) {
-        const offset = Number(encoded.slice(i, i + 2))
-        result += String.fromCharCode(base + offset)
-    }
+  let result = ''
+  for (let i = 0; i < encoded.length; i += 2) {
+    const offset = Number(encoded.slice(i, i + 2))
+    result += String.fromCharCode(base + offset)
+  }
 
-    return result
+  return result
 }
 
 const LOCALHOST_KEYS = ['localhost', '127.0.0.1']
@@ -78,7 +78,7 @@ const LOCALHOST_KEYS = ['localhost', '127.0.0.1']
  * ```
  */
 export function isLocalhostUrl(urlStr: string): boolean {
-    return LOCALHOST_KEYS.includes(new URL(urlStr).hostname)
+  return LOCALHOST_KEYS.includes(new URL(urlStr).hostname)
 }
 
 /**
@@ -90,85 +90,95 @@ export function isLocalhostUrl(urlStr: string): boolean {
  * @throws Error if an unsupported value is found (reports path and type).
  */
 export function structuredStrictStringify(value: unknown): string {
-  const seen = new WeakMap<object, string>();
+  const seen = new WeakMap<object, string>()
   const badTypes = [
-    'symbol'
-  ];
+    'symbol',
+  ]
   // Support Map/Set, but not Error, DOM, Proxy, WeakMap, WeakSet
   function getType(val: any): string {
-    if (val === null) return 'null';
-    if (Array.isArray(val)) return 'Array';
+    if (val === null)
+      return 'null'
+    if (Array.isArray(val))
+      return 'Array'
     if (typeof Document !== 'undefined') {
-      if (val instanceof Node) return 'DOMNode';
+      if (val instanceof Node)
+        return 'DOMNode'
     }
     // if (val instanceof Error) return 'Error';
-    if (val instanceof WeakMap) return 'WeakMap';
-    if (val instanceof WeakSet) return 'WeakSet';
-    if (typeof val === 'object' && val !== null && val.constructor?.name === 'Proxy') return 'Proxy';
-    if (typeof val === 'bigint') return 'BigInt';
-    return typeof val;
+    if (val instanceof WeakMap)
+      return 'WeakMap'
+    if (val instanceof WeakSet)
+      return 'WeakSet'
+    if (typeof val === 'object' && val !== null && val.constructor?.name === 'Proxy')
+      return 'Proxy'
+    if (typeof val === 'bigint')
+      return 'BigInt'
+    return typeof val
   }
 
   function serialize(val: any, path: string): any {
-    const type = getType(val);
+    const type = getType(val)
     // Block disallowed/unsafe types and edge cases for structured-clone
     if (badTypes.includes(typeof val) || type === 'DOMNode' || type === 'Proxy' || type === 'WeakMap' || type === 'WeakSet' || type === 'BigInt') {
-      throw new Error(`Cannot serialize property at path "${path}": type "${type}"`);
+      throw new Error(`Cannot serialize property at path "${path}": type "${type}"`)
     }
     // JSON doesn't support undefined, skip it for values in objects, preserve in arrays as null
-    if (typeof val === 'undefined') return null;
+    if (typeof val === 'undefined')
+      return null
     // Simple value
     if (
-      val === null ||
-      typeof val === 'number' ||
-      typeof val === 'boolean' ||
-      typeof val === 'string'
-    ) return val;
+      val === null
+      || typeof val === 'number'
+      || typeof val === 'boolean'
+      || typeof val === 'string'
+    ) {
+      return val
+    }
     // Cycle check
     if (typeof val === 'object') {
       if (seen.has(val)) {
-        return `[Circular ~${seen.get(val)}]`; // You could just throw if you dislike this fallback!
+        return `[Circular ~${seen.get(val)}]` // You could just throw if you dislike this fallback!
       }
-      seen.set(val, path);
+      seen.set(val, path)
       if (val instanceof Error) {
         return {
           name: val.name,
           message: val.message,
           stack: val.stack,
-        };
+        }
       }
       if (Array.isArray(val)) {
-        return val.map((item, idx) => serialize(item, `${path}[${idx}]`));
+        return val.map((item, idx) => serialize(item, `${path}[${idx}]`))
       }
       if (val instanceof Date) {
-        return val.toISOString();
+        return val.toISOString()
       }
       if (val instanceof Map) {
-        const obj: Record<string, any> = {};
+        const obj: Record<string, any> = {}
         for (const [k, v] of val.entries()) {
-          obj[typeof k === 'string' ? k : JSON.stringify(k)] = serialize(v, `${path}[Map(${typeof k === 'string' ? k : JSON.stringify(k)})]`);
+          obj[typeof k === 'string' ? k : JSON.stringify(k)] = serialize(v, `${path}[Map(${typeof k === 'string' ? k : JSON.stringify(k)})]`)
         }
-        return obj;
+        return obj
       }
       if (val instanceof Set) {
-        return Array.from(val).map((item, idx) => serialize(item, `${path}[SetEntry${idx}]`));
+        return Array.from(val).map((item, idx) => serialize(item, `${path}[SetEntry${idx}]`))
       }
       // General object
-      const res: any = {};
+      const res: any = {}
       for (const key of Object.keys(val)) {
-        res[key] = serialize(val[key], `${path}.${key}`);
+        res[key] = serialize(val[key], `${path}.${key}`)
       }
-      return res;
+      return res
     }
-    throw new Error(`Cannot serialize property at path "${path}": unknown type`);
+    throw new Error(`Cannot serialize property at path "${path}": unknown type`)
   }
 
-  return JSON.stringify(serialize(value, 'root'));
+  return JSON.stringify(serialize(value, 'root'))
 }
 
-export * from './timing'
+export * from './file'
 
-export { runAdaptiveTaskQueue, type AdaptiveTaskQueueOptions } from './task-queue'
+export { type AdaptiveTaskQueueOptions, runAdaptiveTaskQueue } from './task-queue'
 
 export * from './time'
-export * from './file'
+export * from './timing'

package/common/utils/polling.ts

@@ -6,19 +6,20 @@
  */
 
 interface PollingTask {
-  id: string;
-  callback: () => void | Promise<void>;
-  intervalMs: number;
-  nextRunMs: number;
+  id: string
+  callback: () => void | Promise<void>
+  intervalMs: number
+  nextRunMs: number
 }
 
-type TimeUnit = 'seconds' | 'minutes' | 'hours';
+type TimeUnit = 'seconds' | 'minutes' | 'hours'
 
 export class PollingService {
-  private static instance: PollingService;
-  private tasks = new Map<string, PollingTask>();
-  private timerId: NodeJS.Timeout | null = null;
-  private isRunning = false;
+  private static instance: PollingService
+  private tasks = new Map<string, PollingTask>()
+  private timerId: NodeJS.Timeout | null = null
+  private isRunning = false
+  private quitListenerCleanup?: () => void
 
   private constructor() {
     // Private constructor to enforce singleton pattern
@@ -26,21 +27,21 @@ export class PollingService {
 
   public static getInstance(): PollingService {
     if (!PollingService.instance) {
-      PollingService.instance = new PollingService();
+      PollingService.instance = new PollingService()
     }
-    return PollingService.instance;
+    return PollingService.instance
   }
 
   private convertToMs(interval: number, unit: TimeUnit): number {
     switch (unit) {
       case 'seconds':
-        return interval * 1000;
+        return interval * 1000
       case 'minutes':
-        return interval * 60 * 1000;
+        return interval * 60 * 1000
       case 'hours':
-        return interval * 60 * 60 * 1000;
+        return interval * 60 * 60 * 1000
       default:
-        throw new Error(`Invalid time unit: ${unit}`);
+        throw new Error(`Invalid time unit: ${unit}`)
     }
   }
 
@@ -53,31 +54,31 @@ export class PollingService {
   public register(
     id: string,
     callback: () => void | Promise<void>,
-    options: { interval: number; unit: TimeUnit; runImmediately?: boolean }
+    options: { interval: number, unit: TimeUnit, runImmediately?: boolean },
   ): void {
     if (this.tasks.has(id)) {
-      console.warn(`[PollingService] Task with ID '${id}' is already registered. Overwriting.`);
+      console.warn(`[PollingService] Task with ID '${id}' is already registered. Overwriting.`)
     }
 
-    const intervalMs = this.convertToMs(options.interval, options.unit);
+    const intervalMs = this.convertToMs(options.interval, options.unit)
     if (intervalMs <= 0) {
-      console.error(`[PollingService] Task '${id}' has an invalid interval of ${intervalMs}ms. Registration aborted.`);
-      return;
+      console.error(`[PollingService] Task '${id}' has an invalid interval of ${intervalMs}ms. Registration aborted.`)
+      return
     }
 
-    const nextRunMs = options.runImmediately ? Date.now() : Date.now() + intervalMs;
+    const nextRunMs = options.runImmediately ? Date.now() : Date.now() + intervalMs
 
     this.tasks.set(id, {
       id,
       callback,
       intervalMs,
       nextRunMs,
-    });
+    })
 
-    console.log(`[PollingService] Task '${id}' registered to run every ${options.interval} ${options.unit}.`);
+    console.log(`[PollingService] Task '${id}' registered to run every ${options.interval} ${options.unit}.`)
 
     if (this.isRunning) {
-      this._reschedule();
+      this._reschedule()
     }
   }
 
@@ -87,12 +88,13 @@ export class PollingService {
    */
   public unregister(id: string): void {
     if (this.tasks.delete(id)) {
-      console.log(`[PollingService] Task '${id}' unregistered.`);
+      console.log(`[PollingService] Task '${id}' unregistered.`)
       if (this.isRunning) {
-        this._reschedule();
+        this._reschedule()
       }
-    } else {
-      console.warn(`[PollingService] Attempted to unregister a non-existent task with ID '${id}'.`);
+    }
+    else {
+      console.warn(`[PollingService] Attempted to unregister a non-existent task with ID '${id}'.`)
     }
   }
 
@@ -102,7 +104,7 @@ export class PollingService {
    * @returns - True if the task is registered, false otherwise.
    */
   public isRegistered(id: string): boolean {
-    return this.tasks.has(id);
+    return this.tasks.has(id)
   }
 
   /**
@@ -111,74 +113,123 @@ export class PollingService {
    */
   public start(): void {
     if (this.isRunning) {
-      return;
+      console.warn('[PollingService] Already running, skipping start.')
+      return
+    }
+    this.isRunning = true
+    console.log('[PollingService] Polling service started')
+    this._setupQuitListener()
+    this._reschedule()
+  }
+
+  /**
+   * Sets up Electron app quit listener if running in Electron environment
+   * Uses lazy resolution to avoid hard dependency on Electron
+   */
+  private _setupQuitListener(): void {
+    // Check if we're in Electron environment
+    try {
+      // Use dynamic require to avoid hard dependency on Electron
+      // Similar to the approach used in packages/utils/plugin/channel.ts
+      const electron = (globalThis as any)?.electron
+        ?? (typeof require !== 'undefined' ? require('electron') : null)
+
+      if (electron?.app) {
+        const app = electron.app
+
+        // Listen to before-quit event
+        const quitHandler = () => {
+          this.stop('app quit')
+        }
+
+        app.on('before-quit', quitHandler)
+
+        // Store cleanup function
+        this.quitListenerCleanup = () => {
+          app.removeListener('before-quit', quitHandler)
+        }
+      }
+    }
+    catch (error) {
+      // Not in Electron environment or Electron not available
+      // This is fine, just skip the quit listener setup
     }
-    this.isRunning = true;
-    console.debug('[PollingService] Service started.');
-    this._reschedule();
   }
 
   /**
    * Stops the polling service and clears all scheduled tasks.
+   * @param reason - Optional reason for stopping the service (for logging purposes)
    */
-  public stop(): void {
+  public stop(reason?: string): void {
     if (!this.isRunning) {
-      return;
+      return
     }
-    this.isRunning = false;
+    this.isRunning = false
     if (this.timerId) {
-      clearTimeout(this.timerId);
-      this.timerId = null;
+      clearTimeout(this.timerId)
+      this.timerId = null
+    }
+
+    // Clean up quit listener
+    if (this.quitListenerCleanup) {
+      this.quitListenerCleanup()
+      this.quitListenerCleanup = undefined
+    }
+
+    if (reason) {
+      console.log(`[PollingService] Stopping polling service: ${reason}`)
+    }
+    else {
+      console.log('[PollingService] Polling service stopped')
     }
-    console.log('[PollingService] Service stopped.');
   }
 
   private _reschedule(): void {
     if (this.timerId) {
-      clearTimeout(this.timerId);
-      this.timerId = null;
+      clearTimeout(this.timerId)
+      this.timerId = null
     }
 
     if (!this.isRunning || this.tasks.size === 0) {
-      return;
+      return
     }
 
-    const now = Date.now();
+    const now = Date.now()
     const nextTask = Array.from(this.tasks.values()).reduce((prev, curr) =>
-      prev.nextRunMs < curr.nextRunMs ? prev : curr
-    );
+      prev.nextRunMs < curr.nextRunMs ? prev : curr,
+    )
 
-    const delay = Math.max(0, nextTask.nextRunMs - now);
-    this.timerId = setTimeout(() => this._tick(), delay);
+    const delay = Math.max(0, nextTask.nextRunMs - now)
+    this.timerId = setTimeout(() => this._tick(), delay)
   }
 
   private async _tick(): Promise<void> {
-    const now = Date.now();
-    const tasksToRun: PollingTask[] = [];
+    const now = Date.now()
+    const tasksToRun: PollingTask[] = []
 
     for (const task of this.tasks.values()) {
       if (task.nextRunMs <= now) {
-        tasksToRun.push(task);
+        tasksToRun.push(task)
       }
     }
 
     if (tasksToRun.length > 0) {
-        // console.debug(`[PollingService] Executing ${tasksToRun.length} tasks.`);
-        for (const task of tasksToRun) {
-          try {
-            await task.callback();
-          } catch (error) {
-            console.error(`[PollingService] Error executing task '${task.id}':`, error);
-          }
-          // Update next run time based on its last scheduled run time, not 'now'.
-          // This prevents drift if a task takes a long time to execute.
-          task.nextRunMs += task.intervalMs;
+      // console.debug(`[PollingService] Executing ${tasksToRun.length} tasks.`);
+      for (const task of tasksToRun) {
+        try {
+          await task.callback()
+        }
+        catch (error) {
+          console.error(`[PollingService] Error executing task '${task.id}':`, error)
         }
+        // Update next run time based on its last scheduled run time, not 'now'.
+        // This prevents drift if a task takes a long time to execute.
+        task.nextRunMs += task.intervalMs
+      }
     }
 
-
-    this._reschedule();
+    this._reschedule()
   }
 }
 
-export const pollingService = PollingService.getInstance();
+export const pollingService = PollingService.getInstance()