@hyperfixi/core 2.0.0

package/dist/features/def.d.ts

@@ -0,0 +1,135 @@
+import type { ValidationResult, LLMDocumentation, EvaluationType, ExecutionContext } from '../types/base-types';
+import type { ContextMetadata } from '../types/context-types';
+import type { EvaluationResult } from '../types/command-types';
+export declare const DefInputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+    [x: string]: unknown;
+}>;
+export declare const DefOutputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+    [x: string]: unknown;
+}>;
+export type DefInput = any;
+export type DefOutput = any;
+export interface FunctionDefinition {
+    name: string;
+    namespace?: string;
+    parameters: string[];
+    body: any[];
+    catchBlock?: {
+        parameter: string;
+        body: any[];
+    };
+    finallyBlock?: any[];
+    isAsync: boolean;
+    returnType?: string;
+    context: ExecutionContext;
+    metadata: FunctionMetadata;
+}
+export interface FunctionMetadata {
+    name: string;
+    namespace?: string;
+    parameters: string[];
+    isAsync: boolean;
+    returnType?: string;
+    complexity: number;
+    createdAt: number;
+    callCount: number;
+    averageExecutionTime: number;
+}
+export interface FunctionCall {
+    functionName: string;
+    parameters: any[];
+    context: ExecutionContext;
+    timestamp: number;
+    result?: any;
+    error?: Error;
+    executionTime: number;
+}
+export declare class TypedDefFeatureImplementation {
+    readonly name = "defFeature";
+    readonly category: "Universal";
+    readonly description = "Type-safe function definition feature with parameter validation, closure support, and async execution";
+    readonly inputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    private evaluationHistory;
+    private functions;
+    private callHistory;
+    private namespaces;
+    readonly metadata: ContextMetadata;
+    readonly documentation: LLMDocumentation;
+    initialize(input: DefInput): Promise<EvaluationResult<DefOutput>>;
+    validate(input: unknown): ValidationResult;
+    private initializeConfig;
+    private registerFunction;
+    private createFunctionDefiner;
+    private createFunctionCaller;
+    private createFunctionChecker;
+    private createFunctionRemover;
+    private createFunctionLister;
+    private createMetadataGetter;
+    private createParameterValidator;
+    private createParameterBinder;
+    private createSignatureGetter;
+    private createFunctionInvoker;
+    private createAsyncInvoker;
+    private createClosureCreator;
+    private createCallStackGetter;
+    private createTypeChecker;
+    private createTypeInferrer;
+    private createTypeValidator;
+    private createTypeAnnotator;
+    private createErrorHandler;
+    private createCatchBlockGetter;
+    private createFinallyBlockGetter;
+    private executeFunction;
+    private executeAsyncFunction;
+    private executeCatchBlock;
+    private executeFinallyBlock;
+    private calculateComplexity;
+    dispose(): void;
+    private trackPerformance;
+    getPerformanceMetrics(): {
+        totalInitializations: number;
+        successRate: number;
+        averageDuration: number;
+        lastEvaluationTime: number;
+        evaluationHistory: {
+            input: DefInput;
+            output?: DefOutput;
+            success: boolean;
+            duration: number;
+            timestamp: number;
+        }[];
+        totalFunctions: number;
+        totalNamespaces: number;
+        totalCalls: number;
+        averageCallTime: number;
+    };
+}
+export declare function createDefFeature(): TypedDefFeatureImplementation;
+export declare function createDef(definition: Partial<DefInput['definition']>, options?: Partial<DefInput>): Promise<EvaluationResult<DefOutput>>;
+export declare class DefFeature {
+    private static instance;
+    private functions;
+    readonly name = "def";
+    readonly description = "Function definition feature for hyperscript";
+    static getInstance(): DefFeature;
+    defineFunction(name: string, parameters: string[], body: any[], context: ExecutionContext, catchBlock?: {
+        parameter: string;
+        body: any[];
+    }, finallyBlock?: any[], force?: boolean): void;
+    hasFunction(name: string): boolean;
+    getFunctionNames(): string[];
+    getFunction(name: string): FunctionDefinition | undefined;
+    getFunctionsByNamespace(namespace: string): FunctionDefinition[];
+    executeFunction(name: string, args: any[], context: ExecutionContext): Promise<any>;
+    private evaluateExpression;
+    defineAsyncFunction(name: string, parameters: string[], body: any[], context: ExecutionContext): void;
+    removeFunction(name: string): boolean;
+    getJavaScriptFunction(name: string, context?: ExecutionContext): Function;
+    getFunctionMetadata(name: string): FunctionMetadata | null;
+    clear(): void;
+}
+export declare const enhancedDefImplementation: TypedDefFeatureImplementation;
+//# sourceMappingURL=def.d.ts.map

package/dist/features/eventsource.d.ts

@@ -0,0 +1,140 @@
+import type { ContextMetadata, EvaluationResult } from '../types/context-types';
+import type { ValidationResult, EvaluationType } from '../types/base-types';
+import type { LLMDocumentation } from '../types/command-types';
+export declare const EventSourceInputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+    [x: string]: unknown;
+}>;
+export declare const EventSourceOutputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+    [x: string]: unknown;
+}>;
+export type EventSourceInput = any;
+export type EventSourceOutput = any;
+export interface EventSourceConnection {
+    id: string;
+    url: string;
+    eventSource: EventSource | null;
+    state: 'connecting' | 'connected' | 'disconnecting' | 'disconnected' | 'error';
+    createdAt: number;
+    connectedAt?: number;
+    disconnectedAt?: number;
+    lastMessageTime: number;
+    messageCount: number;
+    errorCount: number;
+    retryAttempts: number;
+    maxRetryAttempts: number;
+}
+export interface SSEMessage {
+    id: string;
+    connectionId: string;
+    event: string;
+    data: any;
+    timestamp: number;
+    format: 'text' | 'json' | 'raw';
+    lastEventId?: string;
+    retry?: number;
+    origin?: string;
+}
+export interface SSEEventHandler {
+    id: string;
+    connectionId: string;
+    eventType: string;
+    commands: any[];
+    filter?: string;
+    options?: {
+        throttle?: number;
+        debounce?: number;
+    };
+    isActive: boolean;
+    executionCount: number;
+    lastExecutionTime: number;
+}
+export interface MessageBuffer {
+    connectionId: string;
+    messages: SSEMessage[];
+    maxSize: number;
+    flushInterval: number;
+    lastFlushTime: number;
+    autoFlushTimer?: number;
+}
+export declare class TypedEventSourceFeatureImplementation {
+    readonly name = "eventsourceFeature";
+    readonly category: "Frontend";
+    readonly description = "Type-safe Server-Sent Events management feature with connection handling, message processing, and comprehensive error recovery";
+    readonly inputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    private evaluationHistory;
+    private connections;
+    private messageHistory;
+    private eventHandlers;
+    private messageBuffers;
+    private errorHistory;
+    private throttleTimers;
+    private debounceTimers;
+    private filterCache;
+    readonly metadata: ContextMetadata;
+    readonly documentation: LLMDocumentation;
+    initialize(input: EventSourceInput): Promise<EvaluationResult<EventSourceOutput>>;
+    validate(input: unknown): ValidationResult;
+    private initializeConfig;
+    private createConnection;
+    private handleConnectionOpen;
+    private handleMessage;
+    private handleConnectionError;
+    private scheduleReconnection;
+    private attemptReconnection;
+    private processEventHandlers;
+    private executeEventHandler;
+    private executeCommands;
+    private executeBasicCommand;
+    private isValidEventSourceURL;
+    private detectMessageFormat;
+    private testEventFilter;
+    private isThrottled;
+    private applyDebounce;
+    private createConnectionEstablisher;
+    private createConnectionDisconnector;
+    private createConnectionReconnector;
+    private createStateGetter;
+    private createConnectionInfoGetter;
+    private createConnectionChecker;
+    private createEventHandlerAdder;
+    private createEventHandlerRemover;
+    private createEventHandlerGetter;
+    private createEventEmitter;
+    private createMessageHistoryGetter;
+    private createBufferGetter;
+    private createBufferFlusher;
+    private createHistoryClearer;
+    private createMessageSubscriber;
+    private createMessageUnsubscriber;
+    private createErrorHandler;
+    private createErrorHistoryGetter;
+    private createErrorClearer;
+    private createErrorHandlerSetter;
+    dispose(): void;
+    private trackPerformance;
+    getPerformanceMetrics(): {
+        totalInitializations: number;
+        successRate: number;
+        averageDuration: number;
+        lastEvaluationTime: number;
+        evaluationHistory: {
+            input: EventSourceInput;
+            output?: EventSourceOutput;
+            success: boolean;
+            duration: number;
+            timestamp: number;
+        }[];
+        totalConnections: number;
+        totalMessages: number;
+        totalErrors: number;
+        totalEventHandlers: number;
+        bufferedMessages: number;
+    };
+}
+export declare function createEventSourceFeature(): TypedEventSourceFeatureImplementation;
+export declare function createEventSource(source: Partial<EventSourceInput['source']>, options?: Partial<EventSourceInput>): Promise<EvaluationResult<EventSourceOutput>>;
+export declare const enhancedEventSourceImplementation: TypedEventSourceFeatureImplementation;
+//# sourceMappingURL=eventsource.d.ts.map

package/dist/features/init.d.ts

@@ -0,0 +1,135 @@
+import type { ContextMetadata, EvaluationResult } from '../types/context-types';
+import type { ValidationResult, EvaluationType } from '../types/base-types';
+import type { LLMDocumentation } from '../types/command-types';
+export declare const InitInputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+    [x: string]: unknown;
+}>;
+export declare const InitOutputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+    [x: string]: unknown;
+}>;
+export type InitInput = any;
+export type InitOutput = any;
+export interface InitRegistration {
+    id: string;
+    element: HTMLElement;
+    selector?: string;
+    commands: any[];
+    timing: {
+        immediate: boolean;
+        delay: number;
+        defer: boolean;
+    };
+    lifecycle: {
+        runOnce: boolean;
+        resetOnRemoval: boolean;
+        propagateToChildren: boolean;
+    };
+    execution: {
+        parallel: boolean;
+        stopOnError: boolean;
+        timeout: number;
+    };
+    state: 'pending' | 'running' | 'completed' | 'error';
+    createdAt: number;
+    processedAt?: number;
+    executionCount: number;
+    lastError?: Error;
+}
+export interface InitExecution {
+    id: string;
+    registrationId: string;
+    element: HTMLElement;
+    commands: any[];
+    startTime: number;
+    endTime?: number;
+    duration?: number;
+    success: boolean;
+    error?: Error;
+    result?: any;
+}
+export interface InitLifecycleEvent {
+    type: 'element-added' | 'element-removed' | 'dom-ready' | 'init-start' | 'init-complete' | 'init-error';
+    element?: HTMLElement;
+    registration?: InitRegistration;
+    timestamp: number;
+    data?: any;
+}
+export declare class TypedInitFeatureImplementation {
+    readonly name = "initFeature";
+    readonly category: "Frontend";
+    readonly description = "Type-safe element initialization feature with lifecycle management, error handling, and performance optimization";
+    readonly inputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    private evaluationHistory;
+    private registrations;
+    private elementRegistrations;
+    private executionHistory;
+    private lifecycleEvents;
+    private errorHistory;
+    private processedElements;
+    private domObserver?;
+    readonly metadata: ContextMetadata;
+    readonly documentation: LLMDocumentation;
+    initialize(input: InitInput): Promise<EvaluationResult<InitOutput>>;
+    validate(input: unknown): ValidationResult;
+    private initializeConfig;
+    private registerElement;
+    private processRegistration;
+    private createExecutionContext;
+    private executeCommandsSequential;
+    private executeCommandsParallel;
+    private executeCommand;
+    private setupDOMObserver;
+    private handleElementAdded;
+    private handleElementRemoved;
+    private emitLifecycleEvent;
+    private isValidSelector;
+    private createElementRegistrar;
+    private createElementUnregistrar;
+    private createElementProcessor;
+    private createAllElementsProcessor;
+    private createRegistrationChecker;
+    private createProcessingChecker;
+    private createRegistrationGetter;
+    private createRegisteredElementsLister;
+    private createCommandExecutor;
+    private createParallelExecutor;
+    private createRetryExecutor;
+    private createExecutionHistoryGetter;
+    private createHistoryClearer;
+    private createElementAddedHandler;
+    private createElementRemovedHandler;
+    private createDOMReadyHandler;
+    private createSystemResetter;
+    private createErrorHandler;
+    private createErrorHistoryGetter;
+    private createErrorClearer;
+    private createErrorHandlerSetter;
+    dispose(): void;
+    private trackPerformance;
+    getPerformanceMetrics(): {
+        totalInitializations: number;
+        successRate: number;
+        averageDuration: number;
+        lastEvaluationTime: number;
+        evaluationHistory: {
+            input: InitInput;
+            output?: InitOutput;
+            success: boolean;
+            duration: number;
+            timestamp: number;
+        }[];
+        totalRegistrations: number;
+        totalExecutions: number;
+        totalErrors: number;
+        processedElementsCount: number;
+        lifecycleEventsCount: number;
+    };
+}
+export declare function createInitFeature(): TypedInitFeatureImplementation;
+export declare function createInit(target: HTMLElement | string, commands: any[], options?: Partial<InitInput>): Promise<EvaluationResult<InitOutput>>;
+export declare const enhancedInitImplementation: TypedInitFeatureImplementation;
+export { TypedInitFeatureImplementation as InitFeature };
+//# sourceMappingURL=init.d.ts.map

package/dist/features/on.d.ts

@@ -0,0 +1,131 @@
+import type { ValidationResult, LLMDocumentation, EvaluationType, ExecutionContext } from '../types/base-types';
+import type { ContextMetadata } from '../types/context-types';
+import type { EvaluationResult } from '../types/command-types';
+export declare const EnhancedOnInputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+    [x: string]: unknown;
+}>;
+export declare const EnhancedOnOutputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+    [x: string]: unknown;
+}>;
+export type EnhancedOnInput = any;
+export type EnhancedOnOutput = any;
+export interface EventListener {
+    id: string;
+    eventType: string;
+    target: string | HTMLElement;
+    commands: any[];
+    context: ExecutionContext;
+    options: EventListenerOptions & {
+        once?: boolean;
+        passive?: boolean;
+        capture?: boolean;
+        delegated?: boolean;
+        filter?: string;
+        inSelector?: string;
+        every?: boolean;
+        throttle?: number;
+        debounce?: number;
+    };
+    isActive: boolean;
+    isPaused: boolean;
+    executionCount: number;
+    lastExecutionTime: number;
+    averageExecutionTime: number;
+}
+export interface EventExecution {
+    listenerId: string;
+    eventType: string;
+    timestamp: number;
+    event: Event;
+    commands: any[];
+    result?: any;
+    error?: Error;
+    executionTime: number;
+    preventDefault: boolean;
+    stopPropagation: boolean;
+}
+export interface EventFilter {
+    id: string;
+    expression: string;
+    compiled: Function;
+    isActive: boolean;
+}
+export declare class TypedOnFeatureImplementation {
+    readonly name = "onFeature";
+    readonly category: "Frontend";
+    readonly description = "Type-safe event handling feature with advanced filtering, throttling, and execution control";
+    readonly inputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    private evaluationHistory;
+    private listeners;
+    private executionHistory;
+    private filters;
+    private errorHistory;
+    private throttleTimers;
+    private debounceTimers;
+    private filterCache;
+    readonly metadata: ContextMetadata;
+    readonly documentation: LLMDocumentation;
+    initialize(input: EnhancedOnInput): Promise<EvaluationResult<EnhancedOnOutput>>;
+    validate(input: unknown): ValidationResult;
+    private initializeConfig;
+    private registerEventListener;
+    private attachDOMListener;
+    private createDOMEventHandler;
+    private executeEventHandler;
+    private executeCommands;
+    private executeBasicCommand;
+    private isValidEventType;
+    private testEventFilter;
+    private testInSelectorFilter;
+    private isThrottled;
+    private applyDebounce;
+    private createEventListener;
+    private createEventUnlistener;
+    private createEventTrigger;
+    private createListenerGetter;
+    private createListenerPauser;
+    private createListenerResumer;
+    private createCommandExecutor;
+    private createAsyncExecutor;
+    private createExecutionHistoryGetter;
+    private createHistoryClearer;
+    private createFilterAdder;
+    private createFilterRemover;
+    private createFilterTester;
+    private createFilterGetter;
+    private createThrottleController;
+    private createDebounceController;
+    private createThrottleDelaySetter;
+    private createDebounceDelaySetter;
+    private createErrorHandler;
+    private createErrorHistoryGetter;
+    private createErrorClearer;
+    private createErrorHandlerSetter;
+    dispose(): void;
+    private trackPerformance;
+    getPerformanceMetrics(): {
+        totalInitializations: number;
+        successRate: number;
+        averageDuration: number;
+        lastEvaluationTime: number;
+        evaluationHistory: {
+            input: EnhancedOnInput;
+            output?: EnhancedOnOutput;
+            success: boolean;
+            duration: number;
+            timestamp: number;
+        }[];
+        totalListeners: number;
+        totalExecutions: number;
+        totalErrors: number;
+        averageExecutionTime: number;
+    };
+}
+export declare function createOnFeature(_eventManager?: unknown): TypedOnFeatureImplementation;
+export declare function createOn(event: Partial<EnhancedOnInput['event']>, commands: any[], options?: Partial<EnhancedOnInput>): Promise<EvaluationResult<EnhancedOnOutput>>;
+export declare const enhancedOnImplementation: TypedOnFeatureImplementation;
+export { TypedOnFeatureImplementation as OnFeature };
+//# sourceMappingURL=on.d.ts.map

package/dist/features/predefined-behaviors/dropdown-behavior.d.ts

@@ -0,0 +1,20 @@
+import type { BehaviorDefinition } from './types';
+export interface DropdownBehaviorOptions {
+    closeOnClickOutside?: boolean;
+    closeOnClickInside?: boolean;
+    closeOnEscape?: boolean;
+    openClass?: string;
+    animationDuration?: number;
+}
+export declare const dropdownBehaviorDefinition: BehaviorDefinition;
+export declare function createDropdownBehavior(element: HTMLDetailsElement, options?: DropdownBehaviorOptions): void;
+declare global {
+    interface HTMLDetailsElement {
+        openDropdown(): void;
+        closeDropdown(): void;
+        toggleDropdown(): void;
+        isDropdownOpen(): boolean;
+    }
+}
+export default dropdownBehaviorDefinition;
+//# sourceMappingURL=dropdown-behavior.d.ts.map

package/dist/features/predefined-behaviors/index.d.ts

@@ -0,0 +1,12 @@
+export { modalBehaviorDefinition, createModalBehavior, type ModalBehaviorOptions, } from './modal-behavior';
+export { dropdownBehaviorDefinition, createDropdownBehavior, type DropdownBehaviorOptions, } from './dropdown-behavior';
+export { toggleGroupBehaviorDefinition, createToggleGroupBehavior, type ToggleGroupBehaviorOptions, } from './toggle-group-behavior';
+export type { BehaviorDefinition, BehaviorRegistry } from './types';
+export declare const predefinedBehaviors: {
+    readonly 'modal-behavior': () => Promise<import("./types").BehaviorDefinition>;
+    readonly 'dropdown-behavior': () => Promise<import("./types").BehaviorDefinition>;
+    readonly 'toggle-group-behavior': () => Promise<import("./types").BehaviorDefinition>;
+};
+export declare function getBehavior(name: string): Promise<import("./types").BehaviorDefinition>;
+export declare function listBehaviors(): string[];
+//# sourceMappingURL=index.d.ts.map

package/dist/features/predefined-behaviors/modal-behavior.d.ts

@@ -0,0 +1,18 @@
+import type { BehaviorDefinition } from './types';
+export interface ModalBehaviorOptions {
+    closeOnBackdropClick?: boolean;
+    closeOnEscape?: boolean;
+    backdropClass?: string;
+    modal?: boolean;
+}
+export declare const modalBehaviorDefinition: BehaviorDefinition;
+export declare function createModalBehavior(element: HTMLDialogElement, options?: ModalBehaviorOptions): void;
+declare global {
+    interface HTMLDialogElement {
+        openModal(): void;
+        closeModal(returnValue?: string): void;
+        isModalOpen(): boolean;
+    }
+}
+export default modalBehaviorDefinition;
+//# sourceMappingURL=modal-behavior.d.ts.map

package/dist/features/predefined-behaviors/toggle-group-behavior.d.ts

@@ -0,0 +1,23 @@
+import type { BehaviorDefinition } from './types';
+export interface ToggleGroupBehaviorOptions {
+    name?: string;
+    itemSelector?: string;
+    activeClass?: string;
+    allowNone?: boolean;
+    keyboardNavigation?: boolean;
+    initialActive?: string | number;
+}
+export declare const toggleGroupBehaviorDefinition: BehaviorDefinition;
+export declare function createToggleGroupBehavior(element: HTMLElement, options?: ToggleGroupBehaviorOptions): void;
+declare global {
+    interface HTMLElement {
+        activateItem(item: HTMLElement | string | number): void;
+        deactivateAll(): void;
+        getActiveItem(): HTMLElement | null;
+        getActiveValue(): string | null;
+        next(): void;
+        previous(): void;
+    }
+}
+export default toggleGroupBehaviorDefinition;
+//# sourceMappingURL=toggle-group-behavior.d.ts.map

package/dist/features/predefined-behaviors/types.d.ts

@@ -0,0 +1,14 @@
+export interface BehaviorDefinition {
+    name: string;
+    parameters?: string[];
+    init(element: HTMLElement, options?: Record<string, any>): void;
+    destroy(element: HTMLElement): void;
+}
+export interface BehaviorRegistry {
+    register(definition: BehaviorDefinition): void;
+    unregister(name: string): void;
+    get(name: string): BehaviorDefinition | undefined;
+    has(name: string): boolean;
+    list(): string[];
+}
+//# sourceMappingURL=types.d.ts.map