@hyperfixi/core 2.0.0

package/dist/features/sockets.d.ts

@@ -0,0 +1,162 @@
+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 SocketsInputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+    [x: string]: unknown;
+}>;
+export declare const SocketsOutputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+    [x: string]: unknown;
+}>;
+export type SocketsInput = any;
+export type SocketsOutput = any;
+export interface SocketConnection {
+    id: string;
+    url: string;
+    protocols: string[];
+    websocket: WebSocket | null;
+    state: 'connecting' | 'connected' | 'disconnecting' | 'disconnected' | 'error';
+    reconnectAttempts: number;
+    lastError?: Error;
+    connectedAt?: number;
+    disconnectedAt?: number;
+    totalReconnects: number;
+    messagesSent: number;
+    messagesReceived: number;
+}
+export interface SocketEventHandler {
+    id: string;
+    event: 'open' | 'close' | 'error' | 'message';
+    filter?: string;
+    commands: any[];
+    options: {
+        once?: boolean;
+        debounce?: number;
+        throttle?: number;
+    };
+    isActive: boolean;
+    executionCount: number;
+    lastExecutionTime: number;
+}
+export interface QueuedMessage {
+    id: string;
+    data: any;
+    format: 'json' | 'text' | 'binary';
+    timestamp: number;
+    attempts: number;
+    maxAttempts: number;
+    lastAttempt?: number;
+    error?: Error;
+}
+export interface SocketMessage {
+    id: string;
+    connectionId: string;
+    type: 'incoming' | 'outgoing';
+    data: any;
+    format: 'json' | 'text' | 'binary';
+    timestamp: number;
+    size: number;
+    validated: boolean;
+    validationError?: string;
+}
+export interface SocketMetrics {
+    connectionId: string;
+    connectedAt?: number;
+    totalReconnects: number;
+    messagesSent: number;
+    messagesReceived: number;
+    bytesTransmitted: number;
+    bytesReceived: number;
+    averageLatency: number;
+    errorCount: number;
+    uptime: number;
+}
+export declare class TypedSocketsFeatureImplementation {
+    readonly name = "socketsFeature";
+    readonly category: "Frontend";
+    readonly description = "Type-safe WebSocket management feature with reconnection, message queuing, and comprehensive error handling";
+    readonly inputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    private evaluationHistory;
+    private connections;
+    private eventHandlers;
+    private messageQueue;
+    private messageHistory;
+    private errorHistory;
+    private throttleTimers;
+    private debounceTimers;
+    private filterCache;
+    readonly metadata: ContextMetadata;
+    readonly documentation: LLMDocumentation;
+    initialize(input: SocketsInput): Promise<EvaluationResult<SocketsOutput>>;
+    validate(input: unknown): ValidationResult;
+    private initializeConfig;
+    private createSocketConnection;
+    private registerEventHandler;
+    private connectWebSocket;
+    private handleWebSocketOpen;
+    private handleWebSocketClose;
+    private handleWebSocketError;
+    private handleWebSocketMessage;
+    private executeEventHandlers;
+    private executeHandlerCommands;
+    private executeBasicCommand;
+    private detectMessageFormat;
+    private calculateMessageSize;
+    private testMessageFilter;
+    private isThrottled;
+    private applyDebounce;
+    private processQueuedMessages;
+    private sendMessage;
+    private queueMessage;
+    private createConnectionEstablisher;
+    private createConnectionTerminator;
+    private createReconnector;
+    private createConnectionChecker;
+    private createStateGetter;
+    private createConnectionInfoGetter;
+    private createMessageSender;
+    private createJSONSender;
+    private createBinarySender;
+    private createMessageSubscriber;
+    private createMessageUnsubscriber;
+    private createMessageHistoryGetter;
+    private createEventHandlerAdder;
+    private createEventHandlerRemover;
+    private createEventEmitter;
+    private createHandlerGetter;
+    private createQueueAdder;
+    private createQueueProcessor;
+    private createQueueClearer;
+    private createQueueSizeGetter;
+    private createPendingGetter;
+    private createErrorHandler;
+    private createErrorHistoryGetter;
+    private createErrorClearer;
+    private createErrorHandlerSetter;
+    dispose(): void;
+    private trackPerformance;
+    getPerformanceMetrics(): {
+        totalInitializations: number;
+        successRate: number;
+        averageDuration: number;
+        lastEvaluationTime: number;
+        evaluationHistory: {
+            input: SocketsInput;
+            output?: SocketsOutput;
+            success: boolean;
+            duration: number;
+            timestamp: number;
+        }[];
+        totalConnections: number;
+        totalHandlers: number;
+        totalMessages: number;
+        totalErrors: number;
+        queuedMessages: number;
+    };
+}
+export declare function createSocketsFeature(): TypedSocketsFeatureImplementation;
+export declare function createSockets(socket: Partial<SocketsInput['socket']>, options?: Partial<SocketsInput>): Promise<EvaluationResult<SocketsOutput>>;
+export declare const enhancedSocketsImplementation: TypedSocketsFeatureImplementation;
+//# sourceMappingURL=sockets.d.ts.map

package/dist/features/webworker.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 WebWorkerInputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+    [x: string]: unknown;
+}>;
+export declare const WebWorkerOutputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+    [x: string]: unknown;
+}>;
+export type WebWorkerInput = any;
+export type WebWorkerOutput = any;
+export interface WorkerInstance {
+    id: string;
+    name?: string;
+    worker: Worker;
+    script: string;
+    type: 'module' | 'classic';
+    state: 'starting' | 'running' | 'terminating' | 'terminated' | 'error';
+    createdAt: number;
+    lastMessageTime: number;
+    messageCount: number;
+    errorCount: number;
+    isTerminating: boolean;
+}
+export interface WorkerMessage {
+    id: string;
+    workerId: string;
+    type: 'outgoing' | 'incoming';
+    data: any;
+    transferables?: Transferable[];
+    timestamp: number;
+    format: 'json' | 'text' | 'binary';
+    size?: number;
+    error?: Error;
+}
+export interface WorkerEventHandler {
+    id: string;
+    workerId: string;
+    eventType: 'message' | 'error' | 'messageerror';
+    commands: any[];
+    filter?: string;
+    options?: {
+        throttle?: number;
+        debounce?: number;
+    };
+    isActive: boolean;
+    executionCount: number;
+    lastExecutionTime: number;
+}
+export declare class TypedWebWorkerFeatureImplementation {
+    readonly name = "webworkerFeature";
+    readonly category: "Frontend";
+    readonly description = "Type-safe Web Worker management feature with message handling, event processing, and comprehensive error management";
+    readonly inputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    private evaluationHistory;
+    private workers;
+    private messageHistory;
+    private eventHandlers;
+    private messageQueue;
+    private errorHistory;
+    private throttleTimers;
+    private debounceTimers;
+    private filterCache;
+    readonly metadata: ContextMetadata;
+    readonly documentation: LLMDocumentation;
+    initialize(input: WebWorkerInput): Promise<EvaluationResult<WebWorkerOutput>>;
+    validate(input: unknown): ValidationResult;
+    private initializeConfig;
+    private createWorker;
+    private handleWorkerMessage;
+    private handleWorkerError;
+    private handleWorkerMessageError;
+    private processEventHandlers;
+    private executeEventHandler;
+    private executeCommands;
+    private executeBasicCommand;
+    private isValidWorkerScript;
+    private detectMessageFormat;
+    private testMessageFilter;
+    private isThrottled;
+    private applyDebounce;
+    private createWorkerCreator;
+    private createWorkerTerminator;
+    private createWorkerRestarter;
+    private createWorkerGetter;
+    private createWorkerLister;
+    private createWorkerInfoGetter;
+    private createMessageSender;
+    private createJSONSender;
+    private createBinarySender;
+    private createBroadcaster;
+    private createMessageHistoryGetter;
+    private createMessageSubscriber;
+    private createMessageUnsubscriber;
+    private createEventHandlerAdder;
+    private createEventHandlerRemover;
+    private createEventHandlerGetter;
+    private createEventEmitter;
+    private createQueueAdder;
+    private createQueueProcessor;
+    private createQueueSizeGetter;
+    private createPendingGetter;
+    private createQueueClearer;
+    private createErrorHandler;
+    private createErrorHistoryGetter;
+    private createErrorClearer;
+    private createErrorHandlerSetter;
+    dispose(): void;
+    private trackPerformance;
+    getPerformanceMetrics(): {
+        totalInitializations: number;
+        successRate: number;
+        averageDuration: number;
+        lastEvaluationTime: number;
+        evaluationHistory: {
+            input: WebWorkerInput;
+            output?: WebWorkerOutput;
+            success: boolean;
+            duration: number;
+            timestamp: number;
+        }[];
+        totalWorkers: number;
+        totalMessages: number;
+        totalErrors: number;
+        totalEventHandlers: number;
+        queuedMessages: number;
+    };
+}
+export declare function createWebWorkerFeature(): TypedWebWorkerFeatureImplementation;
+export declare function createWebWorker(worker: Partial<WebWorkerInput['worker']>, options?: Partial<WebWorkerInput>): Promise<EvaluationResult<WebWorkerOutput>>;
+export declare const enhancedWebWorkerImplementation: TypedWebWorkerFeatureImplementation;
+//# sourceMappingURL=webworker.d.ts.map

package/dist/htmx/htmx-attribute-processor.d.ts

@@ -0,0 +1,84 @@
+import { type HtmxConfig } from './htmx-translator.js';
+export interface HtmxConfiguringEventDetail {
+    config: HtmxConfig;
+    element: Element;
+}
+export interface HtmxBeforeRequestEventDetail {
+    element: Element;
+    url: string | undefined;
+    method: string;
+}
+export interface HtmxAfterSettleEventDetail {
+    element: Element;
+    target: string | undefined;
+}
+export interface HtmxErrorEventDetail {
+    element: Element;
+    error: Error;
+}
+export interface FxInitEventDetail {
+    element: Element;
+    options: EventListenerOptions;
+}
+export interface FxConfigEventDetail {
+    cfg: {
+        trigger: string;
+        method: string;
+        action: string | undefined;
+        headers: Record<string, string>;
+        target: string | undefined;
+        swap: string;
+        body: FormData | null;
+        drop: number;
+        transition: boolean | ((callback: () => void) => void);
+        preventTrigger: boolean;
+        signal: AbortSignal;
+        confirm?: () => Promise<boolean>;
+    };
+    element: Element;
+}
+export interface FxAfterEventDetail {
+    cfg: FxConfigEventDetail['cfg'] & {
+        response: Response | null;
+        text: string;
+    };
+    element: Element;
+}
+export interface FxFinallyEventDetail {
+    element: Element;
+    success: boolean;
+}
+export interface HtmxProcessorOptions {
+    processExisting?: boolean;
+    watchMutations?: boolean;
+    debug?: boolean;
+    root?: Element;
+    requestDropping?: boolean;
+    fixiEvents?: boolean;
+}
+declare const HTMX_ALL_ATTRS: string[];
+declare const FIXI_ATTRS: string[];
+export declare class HtmxAttributeProcessor {
+    private options;
+    private observer;
+    private processedElements;
+    private executeCallback;
+    private pendingRequests;
+    private dispatchLifecycleEvent;
+    constructor(options?: HtmxProcessorOptions);
+    init(executeCallback: (code: string, element: Element) => Promise<void>): void;
+    destroy(): void;
+    scanForHtmxElements(root?: Element): Element[];
+    collectAttributes(element: Element): HtmxConfig;
+    collectFxAttributes(element: Element): HtmxConfig;
+    private isFxElement;
+    processElement(element: Element): void;
+    processSubtree(root: Element): void;
+    private startObserver;
+    manualProcess(element: Element): string;
+    hasPendingRequest(element: Element): boolean;
+    abortPendingRequest(element: Element): boolean;
+}
+export { FIXI_ATTRS, HTMX_ALL_ATTRS as HTMX_ATTRS };
+export { translateToHyperscript, type HtmxConfig } from './htmx-translator.js';
+//# sourceMappingURL=htmx-attribute-processor.d.ts.map

package/dist/htmx/htmx-translator.d.ts

@@ -0,0 +1,19 @@
+export interface HtmxConfig {
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    url?: string;
+    target?: string;
+    swap?: string;
+    trigger?: string;
+    confirm?: string;
+    boost?: boolean;
+    vals?: string;
+    headers?: string;
+    pushUrl?: boolean | string;
+    replaceUrl?: boolean | string;
+    onHandlers?: Record<string, string>;
+}
+export declare function translateToHyperscript(config: HtmxConfig, element: Element): string;
+export declare function hasHtmxAttributes(element: Element): boolean;
+export declare function hasFxAttributes(element: Element): boolean;
+export declare function hasAnyAttributes(element: Element): boolean;
+//# sourceMappingURL=htmx-translator.d.ts.map

package/dist/htmx/index.d.ts

@@ -0,0 +1,3 @@
+export { HtmxAttributeProcessor, type HtmxProcessorOptions } from './htmx-attribute-processor.js';
+export { translateToHyperscript, hasHtmxAttributes, type HtmxConfig } from './htmx-translator.js';
+//# sourceMappingURL=index.d.ts.map