@talex-touch/utils 1.0.29 → 1.0.31

package/animation/window-node.ts

@@ -0,0 +1,202 @@
+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 {
+  intervalId: NodeJS.Timeout | null
+  completed: boolean
+}
+
+/**
+ * Simple easing function for smooth animation
+ */
+function easeInOutCubic(t: number): number {
+  return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2
+}
+
+/**
+ * Use native Node.js animation for window (main process only)
+ * @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 = {
+    intervalId: 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.intervalId) {
+        clearInterval(animationState.intervalId)
+        animationState.intervalId = null
+      }
+
+      // Reset state for new animation
+      animationState.completed = false
+
+      const browserWindow = window.window
+      const [currentWidth, currentHeight] = browserWindow.getSize()
+      const [x, y] = browserWindow.getPosition()
+
+      const startHeight = currentHeight
+      const heightDelta = newHeight - startHeight
+      const startTime = Date.now()
+      const durationMs = duration * 1000
+
+      return new Promise<boolean>((resolve) => {
+        animationState.intervalId = setInterval(() => {
+          // Check if window is still valid
+          if (!isWindowValid()) {
+            if (animationState.intervalId) {
+              clearInterval(animationState.intervalId)
+              animationState.intervalId = null
+            }
+            resolve(false)
+            return
+          }
+
+          const elapsed = Date.now() - startTime
+          const progress = Math.min(elapsed / durationMs, 1)
+          const easedProgress = easeInOutCubic(progress)
+          const animatedHeight = Math.round(startHeight + heightDelta * easedProgress)
+
+          browserWindow.setSize(currentWidth, animatedHeight)
+          browserWindow.setPosition(x, y)
+
+          if (progress >= 1) {
+            if (animationState.intervalId) {
+              clearInterval(animationState.intervalId)
+              animationState.intervalId = null
+            }
+            animationState.completed = true
+            resolve(true)
+          }
+        }, 16) // ~60fps
+      })
+    } catch (error) {
+      console.error('Error in updateHeight:', error)
+      return Promise.resolve(false)
+    }
+  }
+
+  const cancel = async (): Promise<boolean> => {
+    if (animationState.intervalId) {
+      clearInterval(animationState.intervalId)
+      animationState.intervalId = 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.intervalId) {
+      clearInterval(animationState.intervalId)
+      animationState.intervalId = null
+    }
+
+    // Set new window
+    currentWindow = newWindow
+  }
+
+  return {
+    updateHeight,
+    cancel,
+    toggleWindow,
+    changeWindow
+  }
+}
+

package/auth/clerk-types.ts

@@ -0,0 +1,56 @@
+export interface ClerkUser {
+  id: string
+  emailAddresses: Array<{
+    emailAddress: string
+    id: string
+  }>
+  firstName?: string
+  lastName?: string
+  username?: string
+  imageUrl?: string
+  createdAt: string
+  updatedAt: string
+}
+
+export interface ClerkAuthState {
+  isLoaded: boolean
+  isSignedIn: boolean
+  user: ClerkUser | null
+  sessionId: string | null
+}
+
+export interface LoginOptions {
+  onSuccess?: (user: any) => void
+  onError?: (error: any) => void
+}
+
+export interface LoginResult {
+  success: boolean
+  user?: any
+  error?: any
+}
+
+export interface CurrentUser {
+  id: string
+  name: string
+  email: string
+  avatar?: string
+  provider: string
+}
+
+/**
+ * Clerk Auth Config
+ */
+export interface ClerkConfig {
+  publishableKey: string
+  domain?: string
+  signInUrl?: string
+  signUpUrl?: string
+  afterSignInUrl?: string
+  afterSignUpUrl?: string
+}
+
+export type ClerkResourceSnapshot = {
+  user?: any | null
+  session?: { id?: string | null } | null
+}

package/auth/index.ts

@@ -0,0 +1,4 @@
+export * from './clerk-types'
+export * from './useClerkConfig'
+export * from './useClerkProvider'
+export * from './useAuthState'

package/auth/useAuthState.ts

@@ -0,0 +1,44 @@
+import { createGlobalState } from '@vueuse/core'
+import { shallowReactive, computed } from 'vue'
+import { ClerkAuthState, CurrentUser } from './clerk-types'
+
+export const useAuthState = createGlobalState(() => {
+  const authState = shallowReactive<ClerkAuthState>({
+    isLoaded: false,
+    isSignedIn: false,
+    user: null,
+    sessionId: null
+  })
+
+  return { authState }
+})
+
+export function useCurrentUser() {
+  const { authState } = useAuthState()
+
+  const currentUser = computed((): CurrentUser | null => {
+    if (!authState.isSignedIn || !authState.user) {
+      return null
+    }
+
+    const { firstName, lastName, username, imageUrl } = authState.user
+    let name = ''
+    if (firstName || lastName) {
+      name = [firstName, lastName].filter(Boolean).join(' ')
+    } else {
+      name = username || ''
+    }
+
+    const email = authState.user.emailAddresses?.[0]?.emailAddress || ''
+
+    return {
+      id: authState.user.id,
+      name,
+      email,
+      avatar: imageUrl,
+      provider: 'clerk'
+    }
+  })
+
+  return { currentUser, authState }
+}

package/auth/useClerkConfig.ts

@@ -0,0 +1,40 @@
+import { ClerkConfig } from "./clerk-types"
+
+const clerkPublishableKey = (import.meta.env as any).VITE_CLERK_PUBLISHABLE_KEY
+const clerkDomain = (import.meta.env as any).VITE_CLERK_DOMAIN
+
+if (!clerkPublishableKey?.length) {
+  throw new Error('VITE_CLERK_PUBLISHABLE_KEY is not set')
+}
+
+export const CLERK_PUBLISHABLE_KEY_KEY = 'clerk-publishable-key'
+
+export const defaultClerkConfig: ClerkConfig = {
+  publishableKey: clerkPublishableKey,
+  domain: clerkDomain,
+  signInUrl: '/sign-in',
+  signUpUrl: '/sign-up',
+  afterSignInUrl: '/home',
+  afterSignUpUrl: '/home'
+}
+
+export function useClerkConfig() {
+  const getClerkConfig = (): ClerkConfig => {
+    return {
+      ...defaultClerkConfig,
+      publishableKey:
+        localStorage.getItem(CLERK_PUBLISHABLE_KEY_KEY) || defaultClerkConfig.publishableKey
+    }
+  }
+
+  const setClerkConfig = (config: Partial<ClerkConfig>): void => {
+    if (config.publishableKey) {
+      localStorage.setItem(CLERK_PUBLISHABLE_KEY_KEY, config.publishableKey)
+    }
+  }
+
+  return {
+    getClerkConfig,
+    setClerkConfig
+  }
+}

package/auth/useClerkProvider.ts

@@ -0,0 +1,51 @@
+import { Clerk } from '@clerk/clerk-js'
+import { useClerkConfig } from './useClerkConfig'
+
+let clerkInstance: Clerk | null = null
+
+export function useClerkProvider() {
+  const initializeClerk = async (): Promise<Clerk> => {
+    if (clerkInstance) {
+      return clerkInstance
+    }
+
+    const { getClerkConfig } = useClerkConfig()
+    const config = getClerkConfig()
+
+    if (!config.publishableKey) {
+      throw new Error('Clerk publishable key is required')
+    }
+
+    try {
+      clerkInstance = new Clerk(config.publishableKey)
+      await clerkInstance.load()
+
+      console.log('Clerk initialized successfully')
+      return clerkInstance
+    } catch (error) {
+      console.error('Failed to initialize Clerk:', error)
+      throw error
+    }
+  }
+
+  const getClerk = (): Clerk | null => {
+    return clerkInstance
+  }
+
+  const isClerkInitialized = (): boolean => {
+    return clerkInstance !== null
+  }
+
+  const cleanupClerk = (): void => {
+    if (clerkInstance) {
+      clerkInstance = null
+    }
+  }
+
+  return {
+    initializeClerk,
+    getClerk,
+    isClerkInitialized,
+    cleanupClerk
+  }
+}

package/channel/index.ts

@@ -175,3 +175,9 @@ export interface StandardChannelData extends RawStandardChannelData {
 export type IChannelData = any //boolean | number | string | null | undefined | {
   // [prop: string]: any
 // }
+
+// Default export for Vite compatibility (only values, not types)
+export default {
+  ChannelType,
+  DataCode
+}

package/common/file-scan-utils.ts

@@ -7,7 +7,10 @@
  * @version 1.0.0
  */
 
-import path from 'path'
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const path = typeof window === 'undefined'
+  ? require('path')
+  : require('path-browserify')
 import {
   type FileScanOptions,
   DEFAULT_SCAN_OPTIONS,

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

@@ -14,7 +14,7 @@ const _appSettingOriginData = {
   },
   lang: {
     followSystem: true,
-    locale: 0,
+    locale: 'zh-CN',
   },
   keyBind: {
     summon: 'CTRL + E',
@@ -39,6 +39,20 @@ 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,
+  },
+  layout: 'simple',
 };
 
 export const appSettingOriginData = Object.freeze(_appSettingOriginData)

package/common/utils/file.ts

@@ -1,4 +1,7 @@
-import path from 'path-browserify'
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const path = typeof window === 'undefined'
+  ? require('path')
+  : require('path-browserify')
 
 /**
  * Enum for various file types.

package/common/utils/polling.ts

@@ -19,6 +19,7 @@ export class 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
@@ -111,17 +112,53 @@ export class PollingService {
    */
   public start(): void {
     if (this.isRunning) {
+      console.warn('[PollingService] Already running, skipping start.');
       return;
     }
     this.isRunning = true;
-    console.debug('[PollingService] Service started.');
+    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
+    }
+  }
+
   /**
    * 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;
     }
@@ -130,7 +167,18 @@ export class PollingService {
       clearTimeout(this.timerId);
       this.timerId = null;
     }
-    console.log('[PollingService] Service stopped.');
+    
+    // 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');
+    }
   }
 
   private _reschedule(): void {

package/core-box/README.md

@@ -140,7 +140,7 @@ The core interface for all search results:
 interface ISearchItem {
   name: string;                    // Display name
   desc: string;                    // Description
-  icon: IPluginIcon;              // Icon configuration
+  icon: ITuffIcon;              // Icon configuration
   push: boolean;                   // Push mode support
   names: string[];                 // Searchable names
   keyWords: string[];             // Search keywords

package/core-box/builder/tuff-builder.ts

@@ -972,7 +972,7 @@ class TuffUtils {
    * @param type - 图标类型
    * @returns {TuffIcon} 创建的图标对象
    */
-  static createIcon(value: string, type: 'emoji' | 'url' | 'base64' | 'component' = 'emoji'): TuffIcon {
+  static createIcon(value: string, type: 'emoji' | 'url' | 'file' = 'emoji'): TuffIcon {
     return {
       type,
       value