cs-element/dist/types/worker-interfaces.d.ts

Advanced reactive data management library with state machines, blueprints, persistence, compression, networking, and multithreading support

/**
 * Интерфейсы для Web Worker поддержки CSElement
 */
import { SerializedElement } from './interfaces';
export declare enum WorkerOperationType {
    CREATE_ELEMENT = "create_element",
    UPDATE_ELEMENT = "update_element",
    DELETE_ELEMENT = "delete_element",
    CLONE_ELEMENT = "clone_element",
    QUERY_ELEMENTS = "query_elements",
    ADVANCED_QUERY = "advanced_query",
    FILTER_ELEMENTS = "filter_elements",
    SORT_ELEMENTS = "sort_elements",
    TRANSFORM_DATA = "transform_data",
    VALIDATE_DATA = "validate_data",
    COMPUTE_STATISTICS = "compute_statistics",
    SERIALIZE_ELEMENT = "serialize_element",
    DESERIALIZE_ELEMENT = "deserialize_element",
    SERIALIZE_TREE = "serialize_tree",
    DESERIALIZE_TREE = "deserialize_tree",
    COMPUTE_DIFF = "compute_diff",
    APPLY_PATCH = "apply_patch",
    THREE_WAY_MERGE = "three_way_merge",
    ANALYZE_STRUCTURE = "analyze_structure",
    DETECT_CYCLES = "detect_cycles",
    COMPUTE_METRICS = "compute_metrics",
    VALIDATE_STRUCTURE = "validate_structure",
    CHECK_INTEGRITY = "check_integrity",
    CUSTOM_OPERATION = "custom_operation"
}
export interface WorkerMessage {
    id: string;
    type: WorkerOperationType;
    timestamp: number;
    payload: any;
}
export interface WorkerResponse {
    id: string;
    success: boolean;
    result?: any;
    error?: string;
    timestamp: number;
    executionTime: number;
}
export interface WorkerError {
    code: string;
    message: string;
    stack?: string;
    context?: any;
}
export interface CreateElementOperation {
    name: string;
    data?: Record<string, any>;
    parentId?: string;
    index?: number;
}
export interface UpdateElementOperation {
    elementId: string;
    changes: Record<string, any>;
    options?: {
        merge?: boolean;
        validate?: boolean;
    };
}
export interface QueryElementsOperation {
    rootId?: string;
    selector: string;
    filters?: Array<{
        field: string;
        operator: 'eq' | 'ne' | 'gt' | 'lt' | 'gte' | 'lte' | 'in' | 'nin' | 'regex';
        value: any;
    }>;
    sort?: Array<{
        field: string;
        direction: 'asc' | 'desc';
    }>;
    limit?: number;
    offset?: number;
}
export interface TransformDataOperation {
    elementIds: string[];
    transformFunction: string;
    options?: {
        parallel?: boolean;
        batchSize?: number;
    };
}
export interface SerializationOperation {
    elementId: string;
    options?: {
        includeChildren?: boolean;
        includeData?: boolean;
        includeMetadata?: boolean;
        maxDepth?: number;
        format?: 'json' | 'binary' | 'compressed';
    };
}
export interface DiffOperation {
    sourceId: string;
    targetId: string;
    options?: {
        algorithm?: 'myers' | 'patience' | 'histogram';
        ignoreWhitespace?: boolean;
        ignoreCase?: boolean;
        contextLines?: number;
    };
}
export interface MergeOperation {
    baseId: string;
    sourceId: string;
    targetId: string;
    options?: {
        strategy?: 'auto' | 'manual' | 'ours' | 'theirs';
        conflictResolution?: 'prompt' | 'auto';
    };
}
export interface AnalysisOperation {
    elementIds: string[];
    metrics: Array<'size' | 'depth' | 'complexity' | 'cycles' | 'connectivity'>;
    options?: {
        detailed?: boolean;
        includeVisualization?: boolean;
    };
}
export interface QueryResult {
    elements: SerializedElement[];
    total: number;
    hasMore: boolean;
    executionTime: number;
}
export interface TransformResult {
    processedCount: number;
    errors: Array<{
        elementId: string;
        error: string;
    }>;
    results: Record<string, any>;
}
export interface DiffResult {
    changes: DiffChange[];
    summary: {
        additions: number;
        deletions: number;
        modifications: number;
    };
    visualization?: string;
}
export interface MergeResult {
    merged: SerializedElement;
    conflicts: Array<{
        path: string;
        base: any;
        source: any;
        target: any;
        resolution?: 'auto' | 'manual';
    }>;
    success: boolean;
}
export interface AnalysisResult {
    metrics: Record<string, number>;
    insights: string[];
    recommendations: string[];
    visualization?: {
        type: 'graph' | 'tree' | 'heatmap';
        data: any;
    };
}
export interface WorkerConfig {
    maxConcurrentOperations: number;
    timeoutMs: number;
    memoryLimitMB: number;
    enableLogging: boolean;
    enableProfiling: boolean;
    enableCache: boolean;
    cacheSize: number;
}
export interface WorkerPool {
    size: number;
    strategy: 'round-robin' | 'least-busy' | 'random';
    healthCheck: boolean;
    recycleAfter: number;
}
export interface SerializableElement {
    id: string;
    name: string;
    data: Record<string, any>;
    children: Record<string, SerializableElement>;
    metadata?: {
        index?: number;
        depth?: number;
        path?: string[];
        createdAt?: number;
        updatedAt?: number;
    };
}
export interface WorkerTransferData {
    elements: Record<string, SerializableElement>;
    operations: WorkerMessage[];
    context?: {
        rootId?: string;
        timestamp: number;
        sessionId: string;
    };
}
export interface IWorkerManager {
    createWorker(config?: WorkerConfig): Promise<WorkerInstance>;
    terminateWorker(workerId: string): Promise<void>;
    executeOperation<T = any>(operation: WorkerMessage): Promise<T>;
    getWorkerStatus(workerId?: string): WorkerStatus;
    getPoolStatus(): PoolStatus;
}
export interface WorkerInstance {
    id: string;
    status: 'idle' | 'busy' | 'error' | 'terminated';
    createdAt: number;
    operationsCount: number;
    lastActivity: number;
    memoryUsage: number;
    execute<T = any>(operation: WorkerMessage): Promise<T>;
    terminate(): Promise<void>;
}
export interface WorkerStatus {
    id: string;
    status: 'idle' | 'busy' | 'error' | 'terminated';
    operationsCount: number;
    averageExecutionTime: number;
    memoryUsage: number;
    lastError?: WorkerError;
}
export interface PoolStatus {
    totalWorkers: number;
    activeWorkers: number;
    queuedOperations: number;
    totalOperations: number;
    averageExecutionTime: number;
    memoryUsage: number;
}
export interface SerializationResult {
    data: string | ArrayBuffer;
    format: 'json' | 'binary' | 'compressed';
    size: number;
    compressionRatio?: number;
    metadata: {
        elementCount: number;
        depth: number;
        serializedAt: number;
    };
}
export interface DiffChange {
    type: 'add' | 'remove' | 'modify' | 'move';
    path: string[];
    oldValue?: any;
    newValue?: any;
    metadata?: {
        confidence: number;
        algorithm: string;
    };
}
export interface MergeConflict {
    path: string[];
    base: any;
    source: any;
    target: any;
    type: 'content' | 'structure' | 'metadata';
    severity: 'low' | 'medium' | 'high';
    autoResolvable: boolean;
    suggestions: Array<{
        strategy: string;
        description: string;
        result: any;
    }>;
}
export interface ThreeWayMergeResult {
    merged: SerializableElement;
    conflicts: MergeConflict[];
    autoResolved: number;
    manualRequired: number;
    success: boolean;
    metadata: {
        algorithm: string;
        strategy: string;
        executionTime: number;
    };
}
export interface ChangeVisualization {
    type: 'tree' | 'graph' | 'timeline' | 'heatmap';
    data: any;
    options: {
        showDetails: boolean;
        groupByType: boolean;
        colorScheme: string;
        layout: string;
    };
    interactivity: {
        zoomable: boolean;
        selectable: boolean;
        filterable: boolean;
    };
}
export interface DiffVisualizationOptions {
    layout: 'side-by-side' | 'unified' | 'tree';
    highlightChanges: boolean;
    showLineNumbers: boolean;
    contextLines: number;
    wordWrap: boolean;
    theme: 'light' | 'dark' | 'auto';
}
export type WorkerOperationPayload<T extends WorkerOperationType> = T extends WorkerOperationType.CREATE_ELEMENT ? CreateElementOperation : T extends WorkerOperationType.UPDATE_ELEMENT ? UpdateElementOperation : T extends WorkerOperationType.QUERY_ELEMENTS ? QueryElementsOperation : T extends WorkerOperationType.TRANSFORM_DATA ? TransformDataOperation : T extends WorkerOperationType.SERIALIZE_ELEMENT ? SerializationOperation : T extends WorkerOperationType.COMPUTE_DIFF ? DiffOperation : T extends WorkerOperationType.THREE_WAY_MERGE ? MergeOperation : T extends WorkerOperationType.ANALYZE_STRUCTURE ? AnalysisOperation : any;
export type WorkerOperationResult<T extends WorkerOperationType> = T extends WorkerOperationType.QUERY_ELEMENTS ? QueryResult : T extends WorkerOperationType.TRANSFORM_DATA ? TransformResult : T extends WorkerOperationType.COMPUTE_DIFF ? DiffResult : T extends WorkerOperationType.THREE_WAY_MERGE ? ThreeWayMergeResult : T extends WorkerOperationType.ANALYZE_STRUCTURE ? AnalysisResult : any;
//# sourceMappingURL=worker-interfaces.d.ts.map