@hyperfixi/core 2.0.0

package/dist/parser/types.d.ts

@@ -0,0 +1,118 @@
+export type TokenType = 'STRING' | 'NUMBER' | 'BOOLEAN' | 'NULL' | 'IDENTIFIER' | 'KEYWORD' | 'OPERATOR' | 'COMPARISON' | 'LOGICAL' | 'ASSIGNMENT' | 'LPAREN' | 'RPAREN' | 'LBRACKET' | 'RBRACKET' | 'LBRACE' | 'RBRACE' | 'COMMA' | 'DOT' | 'COLON' | 'SEMICOLON' | 'APOSTROPHE' | 'WHITESPACE' | 'NEWLINE' | 'EOF' | 'UNKNOWN';
+export interface Token {
+    type: TokenType;
+    value: string;
+    position: number;
+    line: number;
+    column: number;
+}
+export type ASTNodeType = 'Literal' | 'Identifier' | 'BinaryExpression' | 'UnaryExpression' | 'CallExpression' | 'MemberExpression' | 'ConditionalExpression' | 'ExpressionStatement' | 'BlockStatement' | 'EventStatement' | 'CommandStatement' | 'EventHandler' | 'Command' | 'Selector' | 'PropertyAccess' | 'PossessiveExpression';
+export interface BaseASTNode {
+    type: ASTNodeType;
+    position: {
+        start: number;
+        end: number;
+        line: number;
+        column: number;
+    };
+}
+export interface LiteralNode extends BaseASTNode {
+    type: 'Literal';
+    value: string | number | boolean | null;
+    raw: string;
+}
+export interface IdentifierNode extends BaseASTNode {
+    type: 'Identifier';
+    name: string;
+}
+export interface BinaryExpressionNode extends BaseASTNode {
+    type: 'BinaryExpression';
+    operator: string;
+    left: ASTNode;
+    right: ASTNode;
+}
+export interface UnaryExpressionNode extends BaseASTNode {
+    type: 'UnaryExpression';
+    operator: string;
+    argument: ASTNode;
+    prefix: boolean;
+}
+export interface CallExpressionNode extends BaseASTNode {
+    type: 'CallExpression';
+    callee: ASTNode;
+    arguments: ASTNode[];
+}
+export interface MemberExpressionNode extends BaseASTNode {
+    type: 'MemberExpression';
+    object: ASTNode;
+    property: ASTNode;
+    computed: boolean;
+}
+export interface EventHandlerNode extends BaseASTNode {
+    type: 'EventHandler';
+    event: string;
+    selector?: string;
+    commands: CommandNode[];
+}
+export interface CommandNode extends BaseASTNode {
+    type: 'Command';
+    name: string;
+    arguments: ASTNode[];
+    target?: ASTNode;
+}
+export interface SelectorNode extends BaseASTNode {
+    type: 'Selector';
+    value: string;
+}
+export interface PossessiveExpressionNode extends BaseASTNode {
+    type: 'PossessiveExpression';
+    object: ASTNode;
+    property: ASTNode;
+}
+export type ASTNode = LiteralNode | IdentifierNode | BinaryExpressionNode | UnaryExpressionNode | CallExpressionNode | MemberExpressionNode | EventHandlerNode | CommandNode | SelectorNode | PossessiveExpressionNode;
+export interface ParseResult {
+    ast: ASTNode;
+    tokens: Token[];
+    errors: ParseError[];
+}
+export interface ParseError {
+    name?: string;
+    message: string;
+    position: number;
+    line: number;
+    column: number;
+    token?: Token;
+}
+export interface KeywordResolver {
+    resolve(token: string): string | undefined;
+    isCommand(token: string): boolean;
+    isKeyword(token: string): boolean;
+}
+export interface SemanticAnalyzerInterface {
+    analyze(input: string, language: string): {
+        confidence: number;
+        command?: {
+            name: string;
+            roles: ReadonlyMap<string, {
+                type: string;
+                value: string;
+            }>;
+        };
+        errors?: string[];
+        tokensConsumed?: number;
+    };
+    supportsLanguage(language: string): boolean;
+    supportedLanguages(): string[];
+}
+export interface ParserOptions {
+    includeWhitespace?: boolean;
+    includeComments?: boolean;
+    strict?: boolean;
+    keywords?: KeywordResolver;
+    semanticAnalyzer?: SemanticAnalyzerInterface;
+    language?: string;
+    semanticConfidenceThreshold?: number;
+    registryIntegration?: any;
+}
+export declare const HYPERSCRIPT_KEYWORDS: Set<string>;
+//# sourceMappingURL=types.d.ts.map

package/dist/performance/expression-cache.d.ts

@@ -0,0 +1,78 @@
+export declare class LRUCache<K, V> {
+    private readonly maxSize;
+    private readonly ttl;
+    private cache;
+    private accessOrder;
+    private accessCounter;
+    constructor(maxSize?: number, ttl?: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    delete(key: K): boolean;
+    clear(): void;
+    size(): number;
+    private evictLRU;
+    getStats(): {
+        size: number;
+        maxSize: number;
+        hitRate: number;
+        avgAge: number;
+        totalAccesses: number;
+    };
+}
+export declare class HyperscriptCache {
+    private readonly domQueryCache;
+    private readonly exprResultCache;
+    private readonly cssMatchCache;
+    private readonly formValueCache;
+    private hits;
+    private misses;
+    querySelector(selector: string): Element | null;
+    querySelectorAll(selector: string): Element[];
+    getElementById(id: string): Element | null;
+    getElementsByClassName(className: string): Element[];
+    matches(element: Element, selector: string): boolean;
+    getExpressionResult(exprKey: string): any;
+    setExpressionResult(exprKey: string, result: any): void;
+    getFormValue(form: HTMLFormElement): any;
+    setFormValue(form: HTMLFormElement, value: any): void;
+    invalidateElementCache(element: Element): void;
+    invalidateAll(): void;
+    private getElementCacheKey;
+    private getElementPosition;
+    getPerformanceStats(): {
+        hits: number;
+        misses: number;
+        hitRate: number;
+        domQueryCache: {
+            size: number;
+            maxSize: number;
+            hitRate: number;
+            avgAge: number;
+            totalAccesses: number;
+        };
+        exprResultCache: {
+            size: number;
+            maxSize: number;
+            hitRate: number;
+            avgAge: number;
+            totalAccesses: number;
+        };
+        cssMatchCache: {
+            size: number;
+            maxSize: number;
+            hitRate: number;
+            avgAge: number;
+            totalAccesses: number;
+        };
+        formValueCache: {
+            size: number;
+            maxSize: number;
+            hitRate: number;
+            avgAge: number;
+            totalAccesses: number;
+        };
+    };
+    cleanup(): void;
+}
+export declare const globalCache: HyperscriptCache;
+//# sourceMappingURL=expression-cache.d.ts.map

package/dist/performance/integration.d.ts

@@ -0,0 +1,40 @@
+import type { ExecutionContext, ExpressionImplementation } from '../types/core';
+export interface PerformanceMetrics {
+    tokenizationTime: number;
+    evaluationTime: number;
+    cacheHitRate: number;
+    memoryUsage: number;
+    domOperations: number;
+}
+declare class PerformanceTracker {
+    private metrics;
+    private startTimes;
+    startTimer(operation: string): void;
+    endTimer(operation: string): number;
+    recordTokenization(duration: number): void;
+    recordEvaluation(duration: number): void;
+    updateCacheMetrics(): void;
+    getMetrics(): PerformanceMetrics;
+    reset(): void;
+}
+export declare const performanceTracker: PerformanceTracker;
+export declare function evaluateExpressionWithCache<T>(cacheKey: string, evaluator: () => Promise<T>, _context: ExecutionContext): Promise<T>;
+export declare function queryWithCache(selector: string): Element | null;
+export declare function queryAllWithCache(selector: string): Element[];
+export declare function matchesWithCache(element: Element, selector: string): boolean;
+export declare function wrapExpressionForPerformance(expression: ExpressionImplementation): ExpressionImplementation;
+export declare function tokenizeWithPerformance(input: string): import("../types/core").Token[];
+export declare function performCleanup(): void;
+export declare function enableAutoCleanup(intervalMs?: number): void;
+export declare function disableAutoCleanup(): void;
+declare class DOMBatcher {
+    private pendingOperations;
+    private batchTimeout;
+    addOperation(operation: () => void): void;
+    flush(): void;
+}
+export declare const domBatcher: DOMBatcher;
+export declare function batchDOMOperation(operation: () => void): void;
+export declare function generatePerformanceReport(): string;
+export {};
+//# sourceMappingURL=integration.d.ts.map

package/dist/performance/production-monitor.d.ts

@@ -0,0 +1,67 @@
+export interface PerformanceMetric {
+    name: string;
+    category: 'command' | 'expression' | 'validation' | 'runtime' | 'system';
+    timestamp: number;
+    duration: number;
+    success: boolean;
+    metadata?: Record<string, any>;
+    severity: 'info' | 'warning' | 'error';
+}
+export interface PerformanceThresholds {
+    command: {
+        warning: number;
+        error: number;
+    };
+    expression: {
+        warning: number;
+        error: number;
+    };
+    validation: {
+        warning: number;
+        error: number;
+    };
+}
+export interface SystemMetrics {
+    memoryUsage: NodeJS.MemoryUsage;
+    cpuUsage: NodeJS.CpuUsage;
+    timestamp: number;
+}
+export declare class ProductionPerformanceMonitor {
+    private metrics;
+    private systemMetrics;
+    private isEnabled;
+    private maxMetrics;
+    private flushInterval;
+    private lastCpuUsage;
+    private readonly thresholds;
+    constructor(options?: {
+        enabled?: boolean;
+        thresholds?: Partial<PerformanceThresholds>;
+        maxMetrics?: number;
+        flushIntervalMs?: number;
+    });
+    record(name: string, category: PerformanceMetric['category'], duration: number, success?: boolean, metadata?: Record<string, any>): void;
+    measure<T>(name: string, category: PerformanceMetric['category'], operation: () => Promise<T> | T, metadata?: Record<string, any>): Promise<T>;
+    getStats(category?: PerformanceMetric['category']): {
+        total: number;
+        successful: number;
+        failed: number;
+        averageDuration: number;
+        medianDuration: number;
+        maxDuration: number;
+        minDuration: number;
+        warnings: number;
+        errors: number;
+    };
+    getRecentMetrics(minutes?: number): PerformanceMetric[];
+    getCurrentSystemMetrics(): SystemMetrics;
+    generateReport(): string;
+    clear(): void;
+    setEnabled(enabled: boolean): void;
+    private startSystemMonitoring;
+    destroy(): void;
+}
+export declare const productionMonitor: ProductionPerformanceMonitor;
+export declare function monitorPerformance(category: PerformanceMetric['category'], name?: string): <T extends (...args: any[]) => any>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>;
+export declare function measureOperation<T>(name: string, operation: () => Promise<T> | T, category?: PerformanceMetric['category']): Promise<T>;
+//# sourceMappingURL=production-monitor.d.ts.map

package/dist/reference/index.d.ts

@@ -0,0 +1,41 @@
+export interface CommandRef {
+    name: string;
+    description: string;
+    syntax: string;
+    category: CommandCategory;
+    availability: BundleAvailability;
+    examples: string[];
+}
+export type CommandCategory = 'dom' | 'async' | 'data' | 'utility' | 'events' | 'navigation' | 'control-flow' | 'execution' | 'content' | 'animation' | 'advanced' | 'behaviors' | 'templates';
+export type BundleAvailability = 'lite' | 'lite-plus' | 'hybrid' | 'full';
+export declare const commands: Record<string, CommandRef>;
+export declare function getCommandsByCategory(category: CommandCategory): CommandRef[];
+export declare function getCommandsByAvailability(availability: BundleAvailability): CommandRef[];
+export declare function searchCommands(query: string): CommandRef[];
+export interface BundleRef {
+    name: string;
+    file: string;
+    size: string;
+    commandCount: number;
+    hasBlocks: boolean;
+    hasEventModifiers: boolean;
+    hasPositional: boolean;
+    useCase: string;
+    importPath: string;
+}
+export declare const bundles: BundleRef[];
+export declare function findBundleForFeatures(options: {
+    commands?: string[];
+    blocks?: boolean;
+    eventModifiers?: boolean;
+    positional?: boolean;
+}): BundleRef | undefined;
+export interface PatternRef {
+    name: string;
+    description: string;
+    code: string;
+    commands: string[];
+}
+export declare const patterns: PatternRef[];
+export declare function searchPatterns(query: string): PatternRef[];
+//# sourceMappingURL=index.d.ts.map