@talex-touch/utils 1.0.18 → 1.0.21

package/core-box/index.ts

@@ -3,5 +3,8 @@
  * Search box core functionality package
  */
 
-export * from './search';
-export * from './types';
+// 导出 TUFF DSL 相关内容
+export * from './tuff/index.js';
+
+// 导出 TUFF Builder 相关内容
+export * from './builder/index.js';

package/core-box/run-tests.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+# 运行 TUFF Builder 测试
+# 测试文件位于 packages/test/src/core-box 目录下
+cd "$(dirname "$0")"
+cd ../../../
+pnpm --filter test test

package/core-box/search.ts

@@ -1,536 +1 @@
-/**
- * Search utility functions and helpers
- * Provides tools for creating, managing, and manipulating search results
- */
-
-import { 
-  ISearchItem, 
-  IDataItem, 
-  IAppItem, 
-  IFileItem, 
-  IFeatureItem,
-  RenderMode,
-  IRenderConfig
-} from './types';
-
-/**
- * Search result utility functions
- * Collection of helper functions for working with search results
- */
-export const SearchUtils = {
-  /**
-   * Creates a basic search result item with standard configuration
-   * 
-   * @param options - Configuration options for the search item
-   * @returns A configured ISearchItem instance
-   * 
-   * @example
-   * ```typescript
-   * const item = SearchUtils.createSearchItem({
-   *   name: "My Feature",
-   *   desc: "A useful feature",
-   *   pluginName: "my-plugin",
-   *   keyWords: ["feature", "utility"]
-   * });
-   * ```
-   */
-  createSearchItem(options: {
-    /** Display name of the item */
-    name: string;
-    /** Description text */
-    desc: string;
-    /** Name of the associated plugin */
-    pluginName: string;
-    /** Plugin type classification */
-    pluginType?: string;
-    /** General type classification */
-    type?: string;
-    /** Whether push mode is supported */
-    push?: boolean;
-    /** Additional search keywords */
-    keyWords?: string[];
-    /** Icon type (e.g., 'remix', 'file') */
-    iconType?: string;
-    /** Icon value/name */
-    iconValue?: string;
-    /** Custom render configuration */
-    render?: IRenderConfig;
-    /** Additional properties */
-    [key: string]: any;
-  }): ISearchItem {
-    const {
-      name,
-      desc,
-      pluginName,
-      pluginType = 'feature',
-      type = 'plugin',
-      push = false,
-      keyWords = [],
-      iconType = 'remix',
-      iconValue = 'function',
-      render,
-      ...extra
-    } = options;
-    
-    return {
-      name,
-      desc,
-      icon: {
-        type: iconType,
-        value: iconValue,
-        init: async () => {}
-      },
-      push,
-      names: [name],
-      keyWords: [name, ...keyWords],
-      pluginType,
-      type,
-      value: pluginName,
-      amo: 0,
-      render: render || { mode: RenderMode.STANDARD },
-      ...extra
-    };
-  },
-  
-  /**
-   * Creates a data processing result item
-   * Specialized for items that represent processed data
-   * 
-   * @param options - Configuration options for the data item
-   * @returns A configured IDataItem instance
-   */
-  createDataItem(options: {
-    /** Display name of the processed result */
-    name: string;
-    /** Description of the processing */
-    desc: string;
-    /** Name of the plugin that processed the data */
-    pluginName: string;
-    /** Source service or system */
-    source?: string;
-    /** Type of data processing */
-    dataType?: string;
-    /** Original input data */
-    originalData?: any;
-    /** Processed output data */
-    processedData?: any;
-    /** Quality score (0-100) */
-    quality?: number;
-    /** Whether result is from cache */
-    cached?: boolean;
-    /** Processing duration in ms */
-    duration?: number;
-    /** Confidence level (0-100) */
-    confidence?: number;
-    /** Additional metadata */
-    metadata?: Record<string, any>;
-    /** Icon configuration */
-    iconType?: string;
-    iconValue?: string;
-    /** Search keywords */
-    keyWords?: string[];
-    /** Plugin type */
-    pluginType?: string;
-    /** Custom render configuration */
-    render?: IRenderConfig;
-  }): IDataItem {
-    const { 
-      name, 
-      desc, 
-      pluginName, 
-      source, 
-      dataType, 
-      originalData, 
-      processedData, 
-      quality, 
-      cached, 
-      duration, 
-      confidence, 
-      metadata,
-      iconType = 'remix',
-      iconValue = 'function',
-      keyWords = [],
-      pluginType = 'data',
-      render
-    } = options;
-    
-    return {
-      name,
-      desc,
-      icon: {
-        type: iconType,
-        value: iconValue,
-        init: async () => {}
-      },
-      push: false,
-      names: [name],
-      keyWords: [name, ...keyWords],
-      pluginType,
-      type: 'plugin',
-      value: pluginName,
-      source,
-      dataType,
-      originalData,
-      processedData,
-      quality,
-      cached,
-      duration,
-      confidence,
-      metadata,
-      amo: 0,
-      render: render || { mode: RenderMode.STANDARD }
-    };
-  },
-  
-  /**
-   * Creates an application search result item
-   * Specialized for representing applications in search results
-   * 
-   * @param options - Configuration options for the app item
-   * @returns A configured IAppItem instance
-   */
-  createAppItem(options: {
-    /** Application name */
-    name: string;
-    /** Application description */
-    desc: string;
-    /** Action to execute when selected */
-    action: string;
-    /** Application file path */
-    path?: string;
-    /** Application version */
-    version?: string;
-    /** File size in bytes */
-    size?: number;
-    /** Last used timestamp */
-    lastUsed?: number;
-    /** Application category */
-    category?: string;
-    /** Whether app is running */
-    isRunning?: boolean;
-    /** Icon file path */
-    iconPath?: string;
-    /** Search keywords */
-    keyWords?: string[];
-    /** Custom render configuration */
-    render?: IRenderConfig;
-  }): IAppItem {
-    const { 
-      name, 
-      desc, 
-      action, 
-      path, 
-      version, 
-      size, 
-      lastUsed, 
-      category,
-      isRunning,
-      iconPath, 
-      keyWords = [],
-      render
-    } = options;
-    
-    return {
-      name,
-      desc,
-      icon: {
-        type: iconPath ? 'file' : 'remix',
-        value: iconPath || 'apps',
-        init: async () => {}
-      },
-      push: false,
-      names: [name],
-      keyWords: [name, ...keyWords],
-      pluginType: 'app',
-      type: 'app',
-      value: name,
-      action,
-      path,
-      version,
-      size,
-      lastUsed,
-      category,
-      isRunning,
-      amo: 0,
-      render: render || { mode: RenderMode.STANDARD }
-    };
-  },
-  
-  /**
-   * Creates a file search result item
-   * Specialized for representing files in search results
-   * 
-   * @param options - Configuration options for the file item
-   * @returns A configured IFileItem instance
-   */
-  createFileItem(options: {
-    /** File name */
-    name: string;
-    /** Full file path */
-    filePath: string;
-    /** File description */
-    desc?: string;
-    /** File size in bytes */
-    fileSize?: number;
-    /** MIME type */
-    fileType?: string;
-    /** File extension */
-    extension?: string;
-    /** Modified timestamp */
-    modifiedTime?: number;
-    /** Created timestamp */
-    createdTime?: number;
-    /** Whether file is accessible */
-    accessible?: boolean;
-    /** Search keywords */
-    keyWords?: string[];
-    /** Custom render configuration */
-    render?: IRenderConfig;
-  }): IFileItem {
-    const { 
-      name, 
-      filePath, 
-      desc, 
-      fileSize, 
-      fileType, 
-      extension,
-      modifiedTime, 
-      createdTime,
-      accessible,
-      keyWords = [],
-      render
-    } = options;
-    
-    return {
-      name,
-      desc: desc || filePath,
-      icon: {
-        type: 'remix',
-        value: 'file',
-        init: async () => {}
-      },
-      push: false,
-      names: [name],
-      keyWords: [name, filePath, ...keyWords],
-      pluginType: 'file',
-      type: 'file',
-      value: filePath,
-      action: `open "${filePath}"`,
-      filePath,
-      fileSize,
-      fileType,
-      extension,
-      modifiedTime,
-      createdTime,
-      accessible,
-      amo: 0,
-      render: render || { mode: RenderMode.STANDARD }
-    };
-  },
-
-  /**
-   * Creates a feature search result item
-   * Specialized for representing plugin features in search results
-   *
-   * @param options - Configuration options for the feature item
-   * @returns A configured IFeatureItem instance
-   */
-  createFeatureItem(options: {
-    /** Feature name */
-    name: string;
-    /** Feature description */
-    desc: string;
-    /** Unique feature identifier */
-    featureId: string;
-    /** Name of the owning plugin */
-    pluginName: string;
-    /** Detailed feature description */
-    featureDesc?: string;
-    /** Feature parameters */
-    parameters?: Record<string, any>;
-    /** Whether feature is enabled */
-    enabled?: boolean;
-    /** Feature category */
-    category?: string;
-    /** Icon configuration */
-    iconType?: string;
-    iconValue?: string;
-    /** Search keywords */
-    keyWords?: string[];
-    /** Custom render configuration */
-    render?: IRenderConfig;
-  }): IFeatureItem {
-    const {
-      name,
-      desc,
-      featureId,
-      pluginName,
-      featureDesc,
-      parameters,
-      enabled,
-      category,
-      iconType = 'remix',
-      iconValue = 'function',
-      keyWords = [],
-      render
-    } = options;
-
-    return {
-      name,
-      desc,
-      icon: {
-        type: iconType,
-        value: iconValue,
-        init: async () => {}
-      },
-      push: false,
-      names: [name],
-      keyWords: [name, ...keyWords],
-      pluginType: 'feature',
-      type: 'plugin',
-      value: pluginName,
-      featureId,
-      pluginName,
-      featureDesc,
-      parameters,
-      enabled,
-      category,
-      amo: 0,
-      render: render || { mode: RenderMode.STANDARD }
-    };
-  },
-
-  /**
-   * Creates an error search result item
-   * Used to display error states in search results
-   *
-   * @param options - Configuration options for the error item
-   * @returns A configured ISearchItem representing an error
-   */
-  createErrorItem(options: {
-    /** Error title */
-    title: string;
-    /** Error message */
-    error: string;
-    /** Plugin that generated the error */
-    pluginName: string;
-    /** Original query that caused the error */
-    originalQuery?: string;
-    /** Custom render configuration */
-    render?: IRenderConfig;
-  }): ISearchItem {
-    const { title, error, pluginName, originalQuery, render } = options;
-
-    return {
-      name: title,
-      desc: `Error: ${error}`,
-      icon: {
-        type: 'remix',
-        value: 'error-warning',
-        init: async () => {}
-      },
-      push: false,
-      names: [title],
-      keyWords: originalQuery ? [originalQuery, 'error', 'failed'] : ['error', 'failed'],
-      pluginType: 'error',
-      type: 'plugin',
-      value: pluginName,
-      error,
-      originalQuery,
-      amo: 0,
-      render: render || { mode: RenderMode.STANDARD }
-    };
-  },
-
-  /**
-   * Sorts search results by priority and relevance
-   * Uses a weighted scoring system based on type, usage, and name
-   *
-   * @param items - Array of search items to sort
-   * @returns Sorted array of search items
-   */
-  sortByPriority(items: ISearchItem[]): ISearchItem[] {
-    return items.sort((a, b) => {
-      // Type-based weight scoring
-      const typeWeights: Record<string, number> = {
-        app: 10,
-        feature: 5,
-        cmd: 5,
-        plugin: 3,
-        file: 2,
-        text: 1,
-        error: 0
-      };
-
-      const aWeight = typeWeights[a.pluginType] || typeWeights[a.type] || 0;
-      const bWeight = typeWeights[b.pluginType] || typeWeights[b.type] || 0;
-
-      if (aWeight !== bWeight) {
-        return bWeight - aWeight;
-      }
-
-      // Usage frequency scoring
-      const aAmo = a.amo || 0;
-      const bAmo = b.amo || 0;
-
-      if (aAmo !== bAmo) {
-        return bAmo - aAmo;
-      }
-
-      // Alphabetical sorting as final tiebreaker
-      return a.name.localeCompare(b.name);
-    });
-  },
-
-  /**
-   * Removes duplicate search result items
-   * Uses a combination of name, description, and value for uniqueness
-   *
-   * @param items - Array of search items that may contain duplicates
-   * @returns Array with duplicate items removed
-   */
-  removeDuplicates(items: ISearchItem[]): ISearchItem[] {
-    const seen = new Set<string>();
-    return items.filter(item => {
-      const key = `${item.name}-${item.desc}-${item.value}`;
-      if (seen.has(key)) {
-        return false;
-      }
-      seen.add(key);
-      return true;
-    });
-  },
-
-  /**
-   * Filters search results based on confidence score
-   * Only returns items that meet the minimum confidence threshold
-   *
-   * @param items - Array of search items to filter
-   * @param minConfidence - Minimum confidence score (0-100)
-   * @returns Filtered array of search items
-   */
-  filterByConfidence(items: ISearchItem[], minConfidence: number = 0): ISearchItem[] {
-    return items.filter(item => {
-      const confidence = (item as IDataItem).confidence;
-      return confidence === undefined || confidence >= minConfidence;
-    });
-  },
-
-  /**
-   * Groups search results by their plugin type
-   * Useful for organizing results in the UI
-   *
-   * @param items - Array of search items to group
-   * @returns Object with plugin types as keys and arrays of items as values
-   */
-  groupByPluginType(items: ISearchItem[]): Record<string, ISearchItem[]> {
-    return items.reduce((groups, item) => {
-      const type = item.pluginType;
-      if (!groups[type]) {
-        groups[type] = [];
-      }
-      groups[type].push(item);
-      return groups;
-    }, {} as Record<string, ISearchItem[]>);
-  }
-};
+export {}

package/core-box/tuff/index.ts

@@ -0,0 +1,6 @@
+/**
+ * TUFF DSL 模块导出
+ * Typed Unified Flex Format 数据结构定义
+ */
+
+export * from './tuff-dsl';