@talex-touch/utils 1.0.30 → 1.0.32

package/animation/window-node.ts

@@ -0,0 +1,205 @@
+import type { 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 - (-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/animation/window.ts

@@ -1,5 +1,5 @@
+import type { TalexTouch } from '../types'
 import gsap from 'gsap'
-import { TalexTouch } from '../types'
 
 /**
  * Window animation controller return type
@@ -52,7 +52,7 @@ export function useWindowAnimation(window?: TalexTouch.ITouchWindow): WindowAnim
 
   const animationState: AnimationState = {
     tween: null,
-    completed: false
+    completed: false,
   }
 
   /**
@@ -61,9 +61,9 @@ export function useWindowAnimation(window?: TalexTouch.ITouchWindow): WindowAnim
    */
   const isWindowValid = (): boolean => {
     return (
-      currentWindow !== null &&
-      currentWindow.window !== null &&
-      !currentWindow.window.isDestroyed()
+      currentWindow !== null
+      && currentWindow.window !== null
+      && !currentWindow.window.isDestroyed()
     )
   }
 
@@ -97,13 +97,13 @@ export function useWindowAnimation(window?: TalexTouch.ITouchWindow): WindowAnim
       return new Promise<boolean>((resolve) => {
         animationState.tween = gsap.to(
           {
-            height: currentHeight
+            height: currentHeight,
           },
           {
             height: newHeight,
             duration,
             ease: 'cubic-bezier(0.785, 0.135, 0.15, 0.86)',
-            onUpdate: function () {
+            onUpdate() {
               // Check if animation was cancelled or window destroyed
               if (!animationState.tween || !isWindowValid()) {
                 resolve(false)
@@ -122,11 +122,12 @@ export function useWindowAnimation(window?: TalexTouch.ITouchWindow): WindowAnim
             onKill: () => {
               animationState.tween = null
               resolve(false)
-            }
-          }
+            },
+          },
         )
       })
-    } catch (error) {
+    }
+    catch (error) {
       console.error('Error in updateHeight:', error)
       return Promise.resolve(false)
     }
@@ -152,12 +153,14 @@ export function useWindowAnimation(window?: TalexTouch.ITouchWindow): WindowAnim
       if (targetVisible) {
         // Show window
         browserWindow.show()
-      } else {
+      }
+      else {
         // Hide window
         if (process.platform === 'darwin') {
           // On macOS, we can simply hide the window
           browserWindow.hide()
-        } else {
+        }
+        else {
           // On other platforms, move window far off-screen before hiding
           browserWindow.setPosition(-100000, -100000)
           browserWindow.hide()
@@ -165,7 +168,8 @@ export function useWindowAnimation(window?: TalexTouch.ITouchWindow): WindowAnim
       }
 
       return Promise.resolve(true)
-    } catch (error) {
+    }
+    catch (error) {
       console.error('Error in toggleWindow:', error)
       return Promise.resolve(false)
     }
@@ -186,6 +190,6 @@ export function useWindowAnimation(window?: TalexTouch.ITouchWindow): WindowAnim
     updateHeight,
     cancel,
     toggleWindow,
-    changeWindow
+    changeWindow,
   }
-}
+}

package/auth/clerk-types.ts

@@ -50,7 +50,7 @@ export interface ClerkConfig {
   afterSignUpUrl?: string
 }
 
-export type ClerkResourceSnapshot = {
+export interface ClerkResourceSnapshot {
   user?: any | null
   session?: { id?: string | null } | null
 }

package/auth/index.ts

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

package/auth/useAuthState.ts

@@ -1,13 +1,13 @@
+import type { ClerkAuthState, CurrentUser } from './clerk-types'
 import { createGlobalState } from '@vueuse/core'
-import { shallowReactive } from 'vue'
-import { ClerkAuthState, CurrentUser } from './clerk-types'
+import { computed, shallowReactive } from 'vue'
 
 export const useAuthState = createGlobalState(() => {
   const authState = shallowReactive<ClerkAuthState>({
     isLoaded: false,
     isSignedIn: false,
     user: null,
-    sessionId: null
+    sessionId: null,
   })
 
   return { authState }
@@ -25,7 +25,8 @@ export function useCurrentUser() {
     let name = ''
     if (firstName || lastName) {
       name = [firstName, lastName].filter(Boolean).join(' ')
-    } else {
+    }
+    else {
       name = username || ''
     }
 
@@ -36,7 +37,7 @@ export function useCurrentUser() {
       name,
       email,
       avatar: imageUrl,
-      provider: 'clerk'
+      provider: 'clerk',
     }
   })
 

package/auth/useClerkConfig.ts

@@ -1,7 +1,7 @@
-import { ClerkConfig } from "./clerk-types"
+import type { ClerkConfig } from './clerk-types'
 
-const clerkPublishableKey = import.meta.env.VITE_CLERK_PUBLISHABLE_KEY
-const clerkDomain = import.meta.env.VITE_CLERK_DOMAIN
+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')
@@ -15,7 +15,7 @@ export const defaultClerkConfig: ClerkConfig = {
   signInUrl: '/sign-in',
   signUpUrl: '/sign-up',
   afterSignInUrl: '/home',
-  afterSignUpUrl: '/home'
+  afterSignUpUrl: '/home',
 }
 
 export function useClerkConfig() {
@@ -23,7 +23,7 @@ export function useClerkConfig() {
     return {
       ...defaultClerkConfig,
       publishableKey:
-        localStorage.getItem(CLERK_PUBLISHABLE_KEY_KEY) || defaultClerkConfig.publishableKey
+        localStorage.getItem(CLERK_PUBLISHABLE_KEY_KEY) || defaultClerkConfig.publishableKey,
     }
   }
 
@@ -35,6 +35,6 @@ export function useClerkConfig() {
 
   return {
     getClerkConfig,
-    setClerkConfig
+    setClerkConfig,
   }
 }

package/auth/useClerkProvider.ts

@@ -22,7 +22,8 @@ export function useClerkProvider() {
 
       console.log('Clerk initialized successfully')
       return clerkInstance
-    } catch (error) {
+    }
+    catch (error) {
       console.error('Failed to initialize Clerk:', error)
       throw error
     }
@@ -46,6 +47,6 @@ export function useClerkProvider() {
     initializeClerk,
     getClerk,
     isClerkInitialized,
-    cleanupClerk
+    cleanupClerk,
   }
 }

package/channel/index.ts

@@ -1,12 +1,12 @@
 export enum ChannelType {
-  MAIN = "main",
-  PLUGIN = "plugin"
+  MAIN = 'main',
+  PLUGIN = 'plugin',
 }
 
 export enum DataCode {
   SUCCESS = 200,
   NETWORK_ERROR = 500,
-  ERROR = 100
+  ERROR = 100,
 }
 
 export type ChannelCallback = (data: StandardChannelData) => any
@@ -20,7 +20,7 @@ export interface ITouchChannel {
    * @param eventName {string} The name of event, must be unique in the channel {@link ChannelType}
    * @param callback {Function} The callback function
    */
-  regChannel(type: ChannelType, eventName: string, callback: ChannelCallback): () => void
+  regChannel: (type: ChannelType, eventName: string, callback: ChannelCallback) => () => void
 
   /**
    * Unregister a channel
@@ -30,7 +30,7 @@ export interface ITouchChannel {
    * @param callback {Function} The callback function to unregister
    * @returns {boolean} Returns true if the channel was successfully unregistered, false otherwise
    */
-  unregChannel(type: ChannelType, eventName: string, callback: ChannelCallback): boolean
+  unregChannel: (type: ChannelType, eventName: string, callback: ChannelCallback) => boolean
 
   /**
    * @deprecated Use sendMain instead
@@ -39,7 +39,7 @@ export interface ITouchChannel {
    * @param eventName {string} The name of event, must be unique in the channel {@link ChannelType}
    * @param arg {any} The arguments of the message
    */
-  send(type: ChannelType, eventName: string, arg?: any): Promise<any>
+  send: (type: ChannelType, eventName: string, arg?: any) => Promise<any>
 
   /**
    * @deprecated Use sendToMain instead
@@ -49,14 +49,14 @@ export interface ITouchChannel {
    * @param eventName {string} The name of event, must be unique in the channel {@link ChannelType}
    * @param arg {any} The arguments of the message
    */
-  sendTo(win: Electron.BrowserWindow, type: ChannelType, eventName: string, arg: any): Promise<any>
+  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>
+  sendMain: (eventName: string, arg?: any) => Promise<any>
 
   /**
    * Send a message to main process with settled window
@@ -64,14 +64,14 @@ export interface ITouchChannel {
    * @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>
+  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>
+  sendPlugin: (pluginName: string, eventName: string, arg?: any) => Promise<any>
 
   /**
    * Send a message to plugin process with settled window
@@ -79,7 +79,7 @@ export interface ITouchChannel {
    * @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>
+  sendToPlugin: (pluginName: string, eventName: string, arg?: any) => Promise<any>
 
   /**
    * Request a encrypted name key. This key cannot decrypted to get the original name.
@@ -106,7 +106,7 @@ export interface ITouchClientChannel {
    * @param eventName {string} The name of event, must be unique in the channel {@link ChannelType
    * @param callback {Function} The callback function
    */
-  regChannel(eventName: string, callback: (data: StandardChannelData) => any): () => void
+  regChannel: (eventName: string, callback: (data: StandardChannelData) => any) => () => void
 
   /**
    * Unregister a channel
@@ -115,21 +115,21 @@ export interface ITouchClientChannel {
    * @param callback {Function} The callback function to unregister
    * @returns {boolean} Returns true if the channel was successfully unregistered, false otherwise
    */
-  unRegChannel(eventName: string, callback: (data: StandardChannelData) => any): boolean
+  unRegChannel: (eventName: string, callback: (data: StandardChannelData) => any) => boolean
 
   /**
    * Send a message to a channel
    * @param eventName {string} The name of event, must be unique in the channel {@link ChannelType}
    * @param arg {any} The arguments of the message
    */
-  send(eventName: string, arg?: any): Promise<any>
+  send: (eventName: string, arg?: any) => Promise<any>
 
   /**
    * Send a message to a channel and get the response
    * @param eventName {string} The name of event, must be unique in the channel {@link ChannelType}
    * @param arg {any} The arguments of the message
    */
-  sendSync(eventName: string, arg?: any): any
+  sendSync: (eventName: string, arg?: any) => any
 }
 
 export interface RawChannelSyncData {
@@ -149,11 +149,12 @@ export interface RawChannelSyncData {
 }
 
 export interface RawChannelHeaderData {
-  status: "reply" | "request";
-  type: ChannelType;
-  _originData?: any;
+  status: 'reply' | 'request'
+  type: ChannelType
+  _originData?: any
   uniqueKey?: string
-  event?: Electron.IpcMainEvent | Electron.IpcRendererEvent;
+  event?: Electron.IpcMainEvent | Electron.IpcMainInvokeEvent | Electron.IpcRendererEvent
+  plugin?: string
 }
 
 export interface RawChannelData {
@@ -172,6 +173,12 @@ export interface StandardChannelData extends RawStandardChannelData {
   reply: (code: DataCode, data: IChannelData) => void
 }
 
-export type IChannelData = any //boolean | number | string | null | undefined | {
-  // [prop: string]: any
+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,
+}