@talex-touch/utils 1.0.17 → 1.0.20

package/animation/window.ts

@@ -0,0 +1,191 @@
+import gsap from 'gsap'
+import { TalexTouch } from '../types'
+
+/**
+ * Window animation controller return type
+ */
+export interface WindowAnimationController {
+  /**
+   * Update window height with animation
+   * @param newHeight - The new height to animate to
+   * @param duration - Animation duration in seconds (default: 0.5)
+   * @returns Promise that resolves to true if animation completed successfully, false if interrupted
+   */
+  updateHeight: (newHeight: number, duration?: number) => Promise<boolean>
+
+  /**
+   * Cancel current animation
+   * @returns Promise that resolves to true if there was an animation to cancel, false otherwise
+   */
+  cancel: () => Promise<boolean>
+
+  /**
+   * Toggle window visibility
+   * @param visible - Optional parameter to explicitly set visibility state
+   * @returns Promise that resolves to true if operation completed successfully, false otherwise
+   */
+  toggleWindow: (visible?: boolean) => Promise<boolean>
+
+  /**
+   * Change current window instance
+   * @param newWindow - New TouchWindow instance
+   */
+  changeWindow: (newWindow: TalexTouch.ITouchWindow) => void
+}
+
+/**
+ * Tracks the state of an animation
+ */
+interface AnimationState {
+  tween: gsap.core.Tween | null
+  completed: boolean
+}
+
+/**
+ * Use GSAP to animate window with cubic-bezier easing
+ * @param window - TouchWindow instance (optional, can be set later with changeWindow)
+ * @returns WindowAnimationController with updateHeight, cancel, toggleWindow, and changeWindow methods
+ */
+export function useWindowAnimation(window?: TalexTouch.ITouchWindow): WindowAnimationController {
+  // Store current window reference inside the function scope
+  let currentWindow: TalexTouch.ITouchWindow | null = window || null
+
+  const animationState: AnimationState = {
+    tween: null,
+    completed: false
+  }
+
+  /**
+   * Check if current window is valid
+   * @returns true if window is valid, false otherwise
+   */
+  const isWindowValid = (): boolean => {
+    return (
+      currentWindow !== null &&
+      currentWindow.window !== null &&
+      !currentWindow.window.isDestroyed()
+    )
+  }
+
+  /**
+   * Get current window with validation
+   * @returns current window or throws error if invalid
+   */
+  const getCurrentWindow = (): TalexTouch.ITouchWindow => {
+    if (!isWindowValid()) {
+      throw new Error('Window is not valid or has been destroyed')
+    }
+    return currentWindow!
+  }
+
+  const updateHeight = async (newHeight: number, duration: number = 0.5): Promise<boolean> => {
+    try {
+      const window = getCurrentWindow()
+
+      // Cancel any existing animation
+      if (animationState.tween) {
+        animationState.tween.kill()
+      }
+
+      // Reset state for new animation
+      animationState.completed = false
+
+      const browserWindow = window.window
+      const [currentWidth, currentHeight] = browserWindow.getSize()
+      const [x, y] = browserWindow.getPosition()
+
+      return new Promise<boolean>((resolve) => {
+        animationState.tween = gsap.to(
+          {
+            height: currentHeight
+          },
+          {
+            height: newHeight,
+            duration,
+            ease: 'cubic-bezier(0.785, 0.135, 0.15, 0.86)',
+            onUpdate: function () {
+              // Check if animation was cancelled or window destroyed
+              if (!animationState.tween || !isWindowValid()) {
+                resolve(false)
+                return
+              }
+
+              const animatedHeight = Math.round(this.targets()[0].height)
+              browserWindow.setSize(currentWidth, animatedHeight)
+              browserWindow.setPosition(x, y)
+            },
+            onComplete: () => {
+              animationState.tween = null
+              animationState.completed = true
+              resolve(true)
+            },
+            onKill: () => {
+              animationState.tween = null
+              resolve(false)
+            }
+          }
+        )
+      })
+    } catch (error) {
+      console.error('Error in updateHeight:', error)
+      return Promise.resolve(false)
+    }
+  }
+
+  const cancel = async (): Promise<boolean> => {
+    if (animationState.tween) {
+      animationState.tween.kill()
+      animationState.tween = null
+      return Promise.resolve(true)
+    }
+    return Promise.resolve(false)
+  }
+
+  const toggleWindow = async (visible?: boolean): Promise<boolean> => {
+    try {
+      const window = getCurrentWindow()
+      const browserWindow = window.window
+
+      // Determine target visibility state
+      const targetVisible = visible !== undefined ? visible : !browserWindow.isVisible()
+
+      if (targetVisible) {
+        // Show window
+        browserWindow.show()
+      } else {
+        // Hide window
+        if (process.platform === 'darwin') {
+          // On macOS, we can simply hide the window
+          browserWindow.hide()
+        } else {
+          // On other platforms, move window far off-screen before hiding
+          browserWindow.setPosition(-100000, -100000)
+          browserWindow.hide()
+        }
+      }
+
+      return Promise.resolve(true)
+    } catch (error) {
+      console.error('Error in toggleWindow:', error)
+      return Promise.resolve(false)
+    }
+  }
+
+  const changeWindow = (newWindow: TalexTouch.ITouchWindow): void => {
+    // Cancel any ongoing animation
+    if (animationState.tween) {
+      animationState.tween.kill()
+      animationState.tween = null
+    }
+
+    // Set new window
+    currentWindow = newWindow
+  }
+
+  return {
+    updateHeight,
+    cancel,
+    toggleWindow,
+    changeWindow
+  }
+}

package/channel/index.ts

@@ -21,6 +21,7 @@ export interface ITouchChannel {
   regChannel(type: ChannelType, eventName: string, callback: (data: StandardChannelData) => any): () => void
 
   /**
+   * @deprecated Use sendMain instead
    * Send a message to a channel
    * @param type {@link ChannelType} The type of channel
    * @param eventName {string} The name of event, must be unique in the channel {@link ChannelType}
@@ -29,6 +30,7 @@ export interface ITouchChannel {
   send(type: ChannelType, eventName: string, arg?: any): Promise<any>
 
   /**
+   * @deprecated Use sendToMain instead
    * Send a message to a channel with settled window
    * @param win {@link Electron.BrowserWindow} the window you want to sent
    * @param type {@link ChannelType} The type of channel
@@ -36,6 +38,51 @@ export interface ITouchChannel {
    * @param arg {any} The arguments of the message
    */
   sendTo(win: Electron.BrowserWindow, type: ChannelType, eventName: string, arg: any): Promise<any>
+
+  /**
+   * Send a message to main process
+   * @param eventName {string} The name of event, must be unique in the channel {@link ChannelType}
+   * @param arg {any} The arguments of the message
+   */
+  sendMain(eventName: string, arg?: any): Promise<any>
+
+  /**
+   * Send a message to main process with settled window
+   * @param win {@link Electron.BrowserWindow} the window you want to sent
+   * @param eventName {string} The name of event, must be unique in the channel {@link ChannelType}
+   * @param arg {any} The arguments of the message
+   */
+  sendToMain(win: Electron.BrowserWindow, eventName: string, arg?: any): Promise<any>
+
+  /**
+   * Send a message to all plugin process with settled window
+   * @param eventName {string} The name of event, must be unique in the channel {@link ChannelType}
+   * @param arg {any} The arguments of the message
+   */
+  sendPlugin(pluginName: string, eventName: string, arg?: any): Promise<any>
+
+  /**
+   * Send a message to plugin process with settled window
+   * @param pluginName {string} The name of plugin
+   * @param eventName {string} The name of event, must be unique in the channel {@link ChannelType}
+   * @param arg {any} The arguments of the message
+   */
+  sendToPlugin(pluginName: string, eventName: string, arg?: any): Promise<any>
+
+  /**
+   * Request a encrypted name key. This key cannot decrypted to get the original name.
+   * After use, you should revoke this key.
+   * @description Request a encrypted name key, and return the encrypted key
+   * @param name {string} The name of key
+   */
+  requestKey: (name: string) => string
+
+  /**
+   * Unregister a encrypted name key
+   * @description Unregister a encrypted name key, and return the encrypted key
+   * @param key {string} The encrypted key
+   */
+  revokeKey: (key: string) => boolean
 }
 
 export interface ITouchClientChannel {
@@ -84,6 +131,7 @@ export interface RawChannelHeaderData {
   status: "reply" | "request";
   type: ChannelType;
   _originData?: any;
+  uniqueKey?: string
   event?: Electron.IpcMainEvent | Electron.IpcRendererEvent;
 }
 
@@ -105,4 +153,4 @@ export interface StandardChannelData extends RawStandardChannelData {
 
 export type IChannelData = any //boolean | number | string | null | undefined | {
   // [prop: string]: any
-// }
+// }

package/common/index.ts

@@ -1,2 +1,4 @@
 export * from './storage/index'
 export * from './utils'
+export * from './search'
+export * from '../electron/file-parsers'

package/common/search/gather.ts

@@ -0,0 +1,45 @@
+import { TuffUpdate } from "."
+
+/**
+ * @interface ITuffGatherOptions
+ * @description Configuration options for the search result aggregator.
+ */
+export interface ITuffGatherOptions {
+  /**
+   * The number of providers to run in parallel.
+   * @default 3
+   */
+  concurrency?: number
+  /**
+   * The time to wait for more results before flushing the buffer.
+   * @default 100
+   */
+  coalesceGapMs?: number
+  /**
+   * A shorter grace period for the first batch to ensure a quick initial response.
+   * @default 50
+   */
+  firstBatchGraceMs?: number
+  /**
+   * A small debounce delay for the push function to avoid rapid-fire updates.
+   * @default 10
+   */
+  debouncePushMs?: number
+  /**
+   * The maximum time to wait for a single provider to return results.
+   * @default 5000
+   */
+  taskTimeoutMs?: number
+}
+
+/**
+ * Defines the type signature for the real-time update callback function.
+ * @param update - The data object containing update information.
+ */
+export type TuffAggregatorCallback = (update: TuffUpdate) => void
+
+export interface IGatherController {
+  abort: () => void
+  promise: Promise<number>
+  signal: AbortSignal
+}

package/common/search/index.ts

@@ -0,0 +1,67 @@
+import { ISearchProvider, TuffQuery, TuffSearchResult } from '@talex-touch/utils'
+
+export * from './gather'
+
+/**
+ * Represents a single update pushed from the search-gatherer.
+ * It provides a snapshot of the search progress at a point in time.
+ */
+export interface TuffUpdate {
+  /**
+   * New search results from the current push batch.
+   * Each element is a complete TuffSearchResult from a provider.
+   */
+  newResults: TuffSearchResult[]
+  /**
+   * Total number of items aggregated so far.
+   */
+  totalCount: number
+  /**
+   * Flag indicating whether all search tasks (both default and fallback queues) have completed.
+   */
+  isDone: boolean
+  /**
+   * Flag indicating whether the search was cancelled.
+   */
+  cancelled?: boolean
+  /**
+   * Statistics about the performance of each search provider.
+   */
+  sourceStats?: TuffSearchResult['sources']
+}
+
+
+/**
+ * Search Engine Interface (formerly ISearchEngine)
+ *
+ * Defines the core functionality of the search aggregator and orchestrator.
+ */
+export interface ISearchEngine<C> {
+  /**
+   * Registers a search provider with the engine.
+   * @param provider - An instance of ISearchProvider.
+   */
+  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
+
+  /**
+   * Executes a search across all registered and relevant providers.
+   * It aggregates, scores, and ranks the results.
+   *
+   * @param query - The search query object.
+   * @returns A promise that resolves to a TuffSearchResult object,
+   *          containing the ranked items and metadata about the search operation.
+   */
+  search(query: TuffQuery): Promise<TuffSearchResult>
+
+  /**
+   * Performs background maintenance tasks, such as pre-heating caches,
+   * refreshing indexes, etc.
+   */
+  maintain(): void
+}

package/common/storage/constants.ts

@@ -1,3 +1,17 @@
 export enum StorageList {
-  APP_SETTING = "app-setting.ini"
-}
+  APP_SETTING = 'app-setting.ini',
+  SHORTCUT_SETTING = 'shortcut-setting.ini',
+  OPENERS = 'openers.json'
+}
+
+/**
+ * Defines keys for the global configuration stored in the database `config` table.
+ * Using an enum prevents magic strings and ensures consistency across the application.
+ */
+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'
+}

package/common/storage/entity/index.ts

@@ -1 +1,2 @@
-export * from './app-settings'
+export * from './app-settings'
+export * from './openers'

package/common/storage/entity/openers.ts

@@ -0,0 +1,32 @@
+export interface OpenerInfo {
+  /**
+   * Bundle identifier of the application responsible for handling the file type.
+   */
+  bundleId: string
+
+  /**
+   * Display name of the application.
+   */
+  name: string
+
+  /**
+   * Icon for the application (data URL or resolvable path).
+   */
+  logo: string
+
+  /**
+   * Absolute path of the application bundle/executable.
+   */
+  path?: string
+
+  /**
+   * ISO timestamp representing when this mapping was last refreshed.
+   */
+  lastResolvedAt?: string
+}
+
+export type OpenersMap = Record<string, OpenerInfo>
+
+const _openersOriginData: OpenersMap = {}
+
+export const openersOriginData = Object.freeze(_openersOriginData)

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

@@ -0,0 +1,22 @@
+export enum ShortcutType {
+  MAIN = 'main',
+  RENDERER = 'renderer',
+}
+
+export interface ShortcutMeta {
+  creationTime: number;
+  modificationTime: number;
+  author: string;
+  description?: string;
+}
+
+export interface Shortcut {
+  id: string;
+  accelerator: string;
+  type: ShortcutType;
+  meta: ShortcutMeta;
+}
+
+export type ShortcutSetting = Shortcut[];
+
+export const shortcutSettingOriginData: ShortcutSetting = [];

package/common/storage/shortcut-storage.ts

@@ -0,0 +1,58 @@
+import { StorageList } from './constants'
+import { shortcutSettingOriginData, ShortcutSetting, Shortcut } from './entity/shortcut-settings'
+
+class ShortcutStorage {
+  private _config: ShortcutSetting = []
+
+  constructor(private readonly storage: {
+    getConfig: (name: string) => any,
+    saveConfig: (name: string, content?: string) => void,
+  }) {
+    this.init()
+  }
+
+  private init() {
+    const config = this.storage.getConfig(StorageList.SHORTCUT_SETTING)
+    if (!config || !Array.isArray(config) || config.length === 0) {
+      this._config = [...shortcutSettingOriginData]
+      this._save()
+    } else {
+      this._config = config
+    }
+  }
+
+  private _save() {
+    this.storage.saveConfig(StorageList.SHORTCUT_SETTING, JSON.stringify(this._config, null, 2))
+  }
+
+  getAllShortcuts(): Shortcut[] {
+    return this._config
+  }
+
+  getShortcutById(id: string): Shortcut | undefined {
+    return this._config.find(s => s.id === id)
+  }
+
+  addShortcut(shortcut: Shortcut): boolean {
+    if (this.getShortcutById(shortcut.id)) {
+      console.warn(`Shortcut with ID ${shortcut.id} already exists.`)
+      return false
+    }
+    this._config.push(shortcut)
+    this._save()
+    return true
+  }
+
+  updateShortcutAccelerator(id: string, newAccelerator: string): boolean {
+    const shortcut = this.getShortcutById(id)
+    if (!shortcut) {
+      return false
+    }
+    shortcut.accelerator = newAccelerator
+    shortcut.meta.modificationTime = Date.now()
+    this._save()
+    return true
+  }
+}
+
+export default ShortcutStorage

package/common/utils/file.ts

@@ -0,0 +1,62 @@
+import path from 'path-browserify'
+
+/**
+ * Enum for various file types.
+ * @enum {string}
+ */
+export enum FileType {
+  Image = 'Image',
+  Document = 'Document',
+  Audio = 'Audio',
+  Video = 'Video',
+  Archive = 'Archive',
+  Code = 'Code',
+  Text = 'Text',
+  Design = 'Design',
+  Model3D = '3D Model',
+  Font = 'Font',
+  Spreadsheet = 'Spreadsheet',
+  Presentation = 'Presentation',
+  Ebook = 'Ebook',
+  Other = 'Other'
+}
+
+const extensionMap: Map<FileType, Set<string>> = new Map([
+  [FileType.Image, new Set(['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.svg', '.ico', '.tiff'])],
+  [FileType.Document, new Set(['.doc', '.docx', '.pdf', '.odt', '.rtf'])],
+  [FileType.Audio, new Set(['.mp3', '.wav', '.ogg', '.flac', '.aac', '.m4a'])],
+  [FileType.Video, new Set(['.mp4', '.avi', '.mov', '.wmv', '.mkv', '.flv', '.webm'])],
+  [FileType.Archive, new Set(['.zip', '.rar', '.7z', '.tar', '.gz', '.bz2'])],
+  [FileType.Code, new Set(['.js', '.ts', '.jsx', '.tsx', '.html', '.css', '.scss', '.json', '.xml', '.java', '.py', '.c', '.cpp', '.go', '.rs', '.php', '.sh'])],
+  [FileType.Text, new Set(['.txt', '.md', '.log'])],
+  [FileType.Design, new Set(['.psd', '.ai', '.fig', '.sketch', '.xd', '.afdesign'])],
+  [FileType.Model3D, new Set(['.obj', '.fbx', '.stl', '.dae', '.blend', '.3ds'])],
+  [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'])]
+]);
+
+/**
+ * Get the file type from a file path.
+ * @param {string} filePath - The path to the file.
+ * @returns {FileType} The type of the file.
+ */
+export function getFileTypeFromPath(filePath: string): FileType {
+  const extension = path.extname(filePath).toLowerCase()
+  return getFileTypeFromExtension(extension)
+}
+
+/**
+ * Get the file type from a file extension.
+ * @param {string} extension - The file extension, including the dot.
+ * @returns {FileType} The type of the file.
+ */
+export function getFileTypeFromExtension(extension: string): FileType {
+  for (const [type, extensions] of extensionMap.entries()) {
+    if (extensions.has(extension)) {
+      return type
+    }
+  }
+  return FileType.Other
+}

package/common/{utils.ts → utils/index.ts}

@@ -101,7 +101,7 @@ export function structuredStrictStringify(value: unknown): string {
     if (typeof Document !== 'undefined') {
       if (val instanceof Node) return 'DOMNode';
     }
-    if (val instanceof Error) return 'Error';
+    // 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';
@@ -112,7 +112,7 @@ export function structuredStrictStringify(value: unknown): string {
   function serialize(val: any, path: string): any {
     const type = getType(val);
     // Block disallowed/unsafe types and edge cases for structured-clone
-    if (badTypes.includes(typeof val) || type === 'DOMNode' || type === 'Error' || type === 'Proxy' || type === 'WeakMap' || type === 'WeakSet' || type === 'BigInt') {
+    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}"`);
     }
     // JSON doesn't support undefined, skip it for values in objects, preserve in arrays as null
@@ -130,6 +130,13 @@ export function structuredStrictStringify(value: unknown): string {
         return `[Circular ~${seen.get(val)}]`; // You could just throw if you dislike this fallback!
       }
       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}]`));
       }
@@ -158,3 +165,8 @@ export function structuredStrictStringify(value: unknown): string {
 
   return JSON.stringify(serialize(value, 'root'));
 }
+
+export { runAdaptiveTaskQueue, type AdaptiveTaskQueueOptions } from './task-queue'
+
+export * from './time'
+export * from './file'