@talex-touch/utils 1.0.18 → 1.0.20

package/renderer/hooks/initialize.ts

@@ -0,0 +1,198 @@
+/**
+ * Interface for renderer initialization information
+ * @interface IInitializationInfo
+ */
+export interface IInitializationInfo {
+  /** Timestamp when the renderer process was initialized */
+  initTimestamp: number
+  /** ISO string of initialization time */
+  initTime: string
+  /** User agent string */
+  userAgent: string
+  /** Current URL of the renderer */
+  currentUrl: string
+  /** Operating system platform */
+  platform: NodeJS.Platform
+  /** Screen resolution information */
+  screenResolution: {
+    width: number
+    height: number
+    pixelRatio: number
+  }
+  /** Window size information */
+  windowSize: {
+    innerWidth: number
+    innerHeight: number
+    outerWidth: number
+    outerHeight: number
+  }
+  /** Performance timing information */
+  performance: {
+    navigationStart: number
+    loadEventEnd?: number
+    domContentLoadedEventEnd?: number
+  }
+  /** Browser/renderer capabilities */
+  capabilities: {
+    webgl: boolean
+    webgl2: boolean
+    webAudio: boolean
+    serviceWorker: boolean
+  }
+}
+
+declare global {
+  export interface Window {
+    /** Global initialization information cache */
+    $initInfo: IInitializationInfo
+  }
+}
+
+/**
+ * Checks WebGL support
+ * @returns True if WebGL is supported
+ */
+function checkWebGLSupport(): boolean {
+  try {
+    const canvas = document.createElement('canvas')
+    return !!(canvas.getContext('webgl') || canvas.getContext('experimental-webgl'))
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Checks WebGL2 support
+ * @returns True if WebGL2 is supported
+ */
+function checkWebGL2Support(): boolean {
+  try {
+    const canvas = document.createElement('canvas')
+    return !!canvas.getContext('webgl2')
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Checks Web Audio API support
+ * @returns True if Web Audio API is supported
+ */
+function checkWebAudioSupport(): boolean {
+  return 'AudioContext' in window || 'webkitAudioContext' in window
+}
+
+/**
+ * Checks Service Worker support
+ * @returns True if Service Worker is supported
+ */
+function checkServiceWorkerSupport(): boolean {
+  return 'serviceWorker' in navigator
+}
+
+/**
+ * Initializes renderer process with system and performance information
+ * @returns Initialization information object
+ */
+export function useInitialize(): IInitializationInfo {
+  if (window.$initInfo) {
+    return window.$initInfo
+  }
+
+  const now = Date.now()
+  const initInfo: IInitializationInfo = {
+    initTimestamp: now,
+    initTime: new Date(now).toISOString(),
+    userAgent: navigator.userAgent,
+    currentUrl: window.location.href,
+    platform: process.platform,
+    screenResolution: {
+      width: screen.width,
+      height: screen.height,
+      pixelRatio: window.devicePixelRatio || 1
+    },
+    windowSize: {
+      innerWidth: window.innerWidth,
+      innerHeight: window.innerHeight,
+      outerWidth: window.outerWidth,
+      outerHeight: window.outerHeight
+    },
+    performance: {
+      navigationStart: performance.timeOrigin || now,
+      loadEventEnd: (performance.getEntriesByType('navigation')[0] as PerformanceNavigationTiming)?.loadEventEnd || undefined,
+      domContentLoadedEventEnd: (performance.getEntriesByType('navigation')[0] as PerformanceNavigationTiming)?.domContentLoadedEventEnd || undefined
+    },
+    capabilities: {
+      webgl: checkWebGLSupport(),
+      webgl2: checkWebGL2Support(),
+      webAudio: checkWebAudioSupport(),
+      serviceWorker: checkServiceWorkerSupport()
+    }
+  }
+
+  return window.$initInfo = initInfo
+}
+
+/**
+ * Gets the initialization timestamp
+ * @returns Timestamp when the renderer was initialized
+ */
+export function getInitTimestamp(): number {
+  return useInitialize().initTimestamp
+}
+
+/**
+ * Gets the initialization time as ISO string
+ * @returns ISO string of initialization time
+ */
+export function getInitTime(): string {
+  return useInitialize().initTime
+}
+
+/**
+ * Gets the time elapsed since initialization in milliseconds
+ * @returns Time elapsed since initialization
+ */
+export function getTimeElapsed(): number {
+  return Date.now() - getInitTimestamp()
+}
+
+/**
+ * Gets screen resolution information
+ * @returns Screen resolution object
+ */
+export function getScreenInfo() {
+  return useInitialize().screenResolution
+}
+
+/**
+ * Gets window size information
+ * @returns Window size object
+ */
+export function getWindowInfo() {
+  return useInitialize().windowSize
+}
+
+/**
+ * Gets renderer capabilities
+ * @returns Capabilities object
+ */
+export function getCapabilities() {
+  return useInitialize().capabilities
+}
+
+/**
+ * Refreshes performance timing information
+ * @returns Updated initialization info
+ */
+export function refreshPerformanceInfo(): IInitializationInfo {
+  if (window.$initInfo) {
+    const navigationEntry = performance.getEntriesByType('navigation')[0] as PerformanceNavigationTiming
+    window.$initInfo.performance = {
+      navigationStart: performance.timeOrigin || window.$initInfo.performance.navigationStart,
+      loadEventEnd: navigationEntry?.loadEventEnd || undefined,
+      domContentLoadedEventEnd: navigationEntry?.domContentLoadedEventEnd || undefined
+    }
+  }
+  return window.$initInfo
+}

package/renderer/index.ts

@@ -1,2 +1,5 @@
 export * from './ref'
 export * from './storage'
+export * from './touch-sdk'
+export * from './touch-sdk/utils'
+export * from './hooks'

package/renderer/storage/app-settings.ts

@@ -32,3 +32,5 @@ class AppSettingsStorage extends TouchStorage<AppSetting> {
  * Global instance of the application settings
  */
 export const appSettings = new AppSettingsStorage();
+
+console.log(appSettings)

package/renderer/storage/base-storage.ts

@@ -327,6 +327,7 @@ export class TouchStorage<T extends object> {
     }
 
     const result = channel.sendSync('storage:get', this.#qualifiedName)
+    console.log("result", result)
     const parsed = result ? (result as Partial<T>) : {};
     this.assignData(parsed, true);
 

package/renderer/storage/openers.ts

@@ -0,0 +1,11 @@
+import { TouchStorage } from '.'
+import { openersOriginData, StorageList, type OpenersMap } from '../..'
+
+class OpenersStorage extends TouchStorage<OpenersMap> {
+  constructor() {
+    super(StorageList.OPENERS, JSON.parse(JSON.stringify(openersOriginData)))
+    this.setAutoSave(true)
+  }
+}
+
+export const openersStorage = new OpenersStorage()

package/renderer/touch-sdk/env.ts

@@ -0,0 +1,106 @@
+import { Terminal } from './terminal'
+import { ITouchClientChannel } from '@talex-touch/utils/channel'
+
+export class EnvDetector {
+  private static channel: ITouchClientChannel;
+
+  public static init(channel: ITouchClientChannel) {
+    this.channel = channel;
+  }
+
+  private static async checkCommand(
+    command: string,
+    versionArgs: string = '--version',
+    versionRegex: RegExp = /(\d+\.\d+\.\d+)/
+  ): Promise<string | false> {
+    if (!this.channel) {
+      throw new Error("EnvDetector not initialized. Call EnvDetector.init(channel) first.");
+    }
+    return new Promise((resolve) => {
+      const terminal = new Terminal(this.channel)
+      let output = ''
+      let resolved = false;
+
+      const resolveOnce = (value: string | false) => {
+        if (!resolved) {
+          resolved = true;
+          resolve(value);
+          // For child_process, there's no explicit disconnect/kill needed after it exits.
+          // The process lifecycle is managed by the OS once it's started and exits.
+        }
+      }
+
+      terminal.onData((data) => {
+        output += data
+        const match = output.match(versionRegex)
+        if (match && match[1]) {
+          resolveOnce(match[1])
+        }
+      })
+
+      terminal.onExit(() => {
+        const match = output.match(versionRegex)
+        resolveOnce(match && match[1] ? match[1] : false)
+      })
+
+      // Execute the command with arguments
+      terminal.exec(command, [versionArgs]).catch(() => {
+        resolveOnce(false)
+      })
+
+      // Timeout in case the command hangs or never returns
+      setTimeout(() => {
+        resolveOnce(false)
+      }, 2000);
+    })
+  }
+
+  static async getNode(): Promise<string | false> {
+    return this.checkCommand('node')
+  }
+
+  static async getNpm(): Promise<string | false> {
+    return this.checkCommand('npm')
+  }
+
+  static async getGit(): Promise<string | false> {
+    return this.checkCommand('git')
+  }
+
+  static async getDegit(): Promise<boolean> {
+    if (!this.channel) {
+      throw new Error("EnvDetector not initialized. Call EnvDetector.init(channel) first.");
+    }
+    return new Promise((resolve) => {
+       const terminal = new Terminal(this.channel)
+       let receivedOutput = false;
+       let resolved = false;
+
+       const resolveOnce = (value: boolean) => {
+         if (!resolved) {
+           resolved = true;
+           resolve(value);
+           // For child_process, there's no explicit disconnect/kill needed after it exits.
+         }
+       }
+
+       terminal.onData(() => {
+         receivedOutput = true;
+         resolveOnce(true); // As soon as we get any output, we know it's there.
+       })
+
+       terminal.onExit(() => {
+         resolveOnce(receivedOutput)
+       })
+
+       // Execute degit with --help
+       terminal.exec('degit', ['--help']).catch(() => {
+         resolveOnce(false)
+       })
+
+       setTimeout(() => {
+        resolveOnce(receivedOutput);
+       }, 2000)
+    });
+  }
+}

package/renderer/touch-sdk/index.ts

@@ -0,0 +1,108 @@
+import { ITouchClientChannel } from '@talex-touch/utils/channel'
+
+export interface TouchSDKOptions {
+  channel: ITouchClientChannel
+}
+
+export interface FolderOpenOptions {
+  path: string
+}
+
+export interface ExecuteCommandOptions {
+  command: string
+}
+
+export interface AppOpenOptions {
+  appName?: string
+  path?: string
+}
+
+export interface ExternalUrlOptions {
+  url: string
+}
+
+export class TouchSDK {
+  private channel: ITouchClientChannel
+
+  constructor(options: TouchSDKOptions) {
+    this.channel = options.channel
+  }
+
+  /**
+   * System Operations
+   */
+  async closeApp(): Promise<void> {
+    return this.channel.send('close')
+  }
+
+  async hideApp(): Promise<void> {
+    return this.channel.send('hide')
+  }
+
+  async minimizeApp(): Promise<void> {
+    return this.channel.send('minimize')
+  }
+
+  async openDevTools(): Promise<void> {
+    return this.channel.send('dev-tools')
+  }
+
+  async getCurrentWorkingDirectory(): Promise<string> {
+    return this.channel.send('common:cwd')
+  }
+
+  async getPackageInfo(): Promise<any> {
+    return this.channel.send('get-package')
+  }
+
+  async getOSInfo(): Promise<any> {
+    return this.channel.send('get-os')
+  }
+
+  /**
+   * File & Folder Operations
+   */
+  async openFolder(options: FolderOpenOptions): Promise<void> {
+    return this.channel.send('folder:open', options)
+  }
+
+  async executeCommand(options: ExecuteCommandOptions): Promise<void> {
+    return this.channel.send('execute:cmd', options)
+  }
+
+  async openApp(options: AppOpenOptions): Promise<void> {
+    return this.channel.send('app:open', options)
+  }
+
+  async openExternalUrl(options: ExternalUrlOptions): Promise<void> {
+    return this.channel.send('open-external', options)
+  }
+
+  /**
+   * Plugin Operations
+   */
+  async openPluginFolder(pluginName: string): Promise<void> {
+    return this.channel.send('plugin:explorer', pluginName)
+  }
+
+  /**
+   * Module Operations
+   */
+  async openModuleFolder(moduleName?: string): Promise<void> {
+    return this.channel.send('module:folder', { name: moduleName })
+  }
+
+  /**
+   * Event Registration
+   */
+  onChannelEvent(eventName: string, callback: (data: any) => void): () => void {
+    return this.channel.regChannel(eventName, callback)
+  }
+
+  /**
+   * Raw channel access for advanced usage
+   */
+  get rawChannel(): ITouchClientChannel {
+    return this.channel
+  }
+}

package/renderer/touch-sdk/terminal.ts

@@ -0,0 +1,85 @@
+import { ITouchClientChannel } from '@talex-touch/utils/channel'
+
+type DataCallback = (data: string) => void
+type ExitCallback = (exitCode: number | null) => void
+
+export class Terminal {
+  private id: string | null = null
+  private onDataCallback: DataCallback | null = null
+  private onExitCallback: ExitCallback | null = null
+  private channel: ITouchClientChannel
+
+  constructor(channel: ITouchClientChannel) {
+    this.channel = channel
+  }
+
+  /**
+   * Executes a command and returns the process ID.
+   * The command output will be sent via the 'terminal:data' event.
+   * The command exit code will be sent via the 'terminal:exit' event.
+   * @param command The command to execute.
+   * @param args The arguments for the command.
+   * @returns A promise that resolves with the process ID.
+   */
+  public async exec(command: string, args: string[] = []): Promise<string> {
+    // If there's an existing process, it should ideally be killed first.
+    // However, for simplicity in this refactor, we'll assume exec is called for a new, independent command.
+    // A more robust implementation might track multiple concurrent processes.
+    
+    const { id } = await this.channel.send('terminal:create', { command, args })
+    this.id = id
+    
+    // Re-register listeners for the new process ID
+    this.channel.regChannel('terminal:data', (channelData) => {
+      if (this.id === channelData.data.id && this.onDataCallback) {
+        this.onDataCallback(channelData.data.data)
+      }
+    })
+
+    this.channel.regChannel('terminal:exit', (channelData) => {
+      if (this.id === channelData.data.id && this.onExitCallback) {
+        this.onExitCallback(channelData.data.exitCode)
+        this.id = null
+      }
+    })
+    
+    return id
+  }
+
+  /**
+   * Writes data to the process stdin (if applicable).
+   * Note: This is less common with child_process for non-interactive commands.
+   * @param data The data to write.
+   */
+  public write(data: string): void {
+    if (this.id) {
+      this.channel.send('terminal:write', { id: this.id, data })
+    }
+  }
+
+  /**
+   * Kills the running process.
+   */
+  public kill(): void {
+    if (this.id) {
+      this.channel.send('terminal:kill', { id: this.id })
+      this.id = null
+    }
+  }
+
+  /**
+   * Sets the callback for receiving data from the process.
+   * @param callback The callback function.
+   */
+  public onData(callback: DataCallback): void {
+    this.onDataCallback = callback
+  }
+
+  /**
+   * Sets the callback for receiving the exit code from the process.
+   * @param callback The callback function.
+   */
+  public onExit(callback: ExitCallback): void {
+    this.onExitCallback = callback
+  }
+}

package/renderer/touch-sdk/utils.ts

@@ -0,0 +1,61 @@
+import { TouchSDK, TouchSDKOptions } from './index'
+
+/**
+ * Factory function to create a TouchSDK instance
+ */
+export function createTouchSDK(options: TouchSDKOptions): TouchSDK {
+  return new TouchSDK(options)
+}
+
+/**
+ * Singleton instance for convenience
+ */
+let sdkInstance: TouchSDK | null = null
+
+export function initTouchSDK(options: TouchSDKOptions): TouchSDK {
+  sdkInstance = new TouchSDK(options)
+  return sdkInstance
+}
+
+export function getTouchSDK(): TouchSDK {
+  if (!sdkInstance) {
+    throw new Error('TouchSDK not initialized. Call initTouchSDK first.')
+  }
+  return sdkInstance
+}
+
+export function useTouchSDK(options?: TouchSDKOptions) {
+  if (!sdkInstance) {
+    if ( !options ) {
+      throw new Error('TouchSDK not initialized. Call initTouchSDK first. Cannot use hook here.')
+    }
+    initTouchSDK(options)
+  }
+
+  return getTouchSDK()
+}
+
+/**
+ * Utility functions for common operations
+ */
+export const TouchUtils = {
+  async openFolder(path: string): Promise<void> {
+    return getTouchSDK().openFolder({ path })
+  },
+
+  async executeCommand(command: string): Promise<void> {
+    return getTouchSDK().executeCommand({ command })
+  },
+
+  async openApp(appName: string): Promise<void> {
+    return getTouchSDK().openApp({ appName })
+  },
+
+  async openUrl(url: string): Promise<void> {
+    return getTouchSDK().openExternalUrl({ url })
+  },
+
+  async openPluginFolder(pluginName: string): Promise<void> {
+    return getTouchSDK().openPluginFolder(pluginName)
+  }
+}

package/search/levenshtein-utils.ts

@@ -0,0 +1,39 @@
+/**
+ * Computes the Levenshtein distance between two strings.
+ * This is a standard dynamic programming implementation.
+ *
+ * @param s1 The first string.
+ * @param s2 The second string.
+ * @returns The Levenshtein distance.
+ */
+export function levenshteinDistance(s1: string, s2: string): number {
+  const m = s1.length;
+  const n = s2.length;
+
+  // Create a 2D array (m+1)x(n+1) to store distances
+  const dp: number[][] = Array(m + 1)
+    .fill(0)
+    .map(() => Array(n + 1).fill(0));
+
+  // Initialize the DP table
+  for (let i = 0; i <= m; i++) {
+    dp[i][0] = i;
+  }
+  for (let j = 0; j <= n; j++) {
+    dp[0][j] = j;
+  }
+
+  // Fill the DP table
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = s1[i - 1] === s2[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(
+        dp[i - 1][j] + 1, // Deletion
+        dp[i][j - 1] + 1, // Insertion
+        dp[i - 1][j - 1] + cost // Substitution
+      );
+    }
+  }
+
+  return dp[m][n];
+}