@hyperfixi/core 3.3.0 → 4.0.1

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

@@ -1,78 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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("..").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

@@ -1,67 +0,0 @@
-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/registry/browser-types.cjs

@@ -1,81 +0,0 @@
-'use strict';
-
-function isBrowserPayload(payload) {
-    return (typeof window !== 'undefined' &&
-        typeof document !== 'undefined' &&
-        (payload.target == null || payload.target instanceof Element));
-}
-function isBrowserEventSource(source) {
-    return typeof window !== 'undefined' && typeof document !== 'undefined';
-}
-function createDOMEventSource(eventName, options) {
-    const target = options?.target ?? document;
-    const capture = options?.capture ?? false;
-    return {
-        name: eventName,
-        description: options?.description ?? `DOM ${eventName} events`,
-        supportedEvents: [eventName],
-        subscribe(subscribeOptions, context) {
-            const handler = (e) => {
-                const payload = {
-                    type: eventName,
-                    data: e,
-                    target: e.target instanceof Element ? e.target : null,
-                    nativeEvent: e,
-                };
-                subscribeOptions.handler(payload, context);
-            };
-            target.addEventListener(eventName, handler, { capture });
-            return {
-                id: `${eventName}_${Date.now()}_${Math.random().toString(36).slice(2)}`,
-                source: eventName,
-                event: eventName,
-                unsubscribe: () => target.removeEventListener(eventName, handler, { capture }),
-            };
-        },
-        supports(event) {
-            return event === eventName;
-        },
-    };
-}
-function createCustomEventSource(eventName, options) {
-    const target = options?.target ?? document;
-    return {
-        name: eventName,
-        description: options?.description ?? `Custom ${eventName} events`,
-        supportedEvents: [eventName],
-        subscribe(subscribeOptions, context) {
-            const handler = (e) => {
-                const customEvent = e;
-                const payload = {
-                    type: eventName,
-                    data: customEvent.detail,
-                    target: e.target instanceof Element ? e.target : null,
-                    nativeEvent: e,
-                    meta: {
-                        bubbles: customEvent.bubbles,
-                        cancelable: customEvent.cancelable,
-                        composed: customEvent.composed,
-                    },
-                };
-                subscribeOptions.handler(payload, context);
-            };
-            target.addEventListener(eventName, handler);
-            return {
-                id: `${eventName}_${Date.now()}_${Math.random().toString(36).slice(2)}`,
-                source: eventName,
-                event: eventName,
-                unsubscribe: () => target.removeEventListener(eventName, handler),
-            };
-        },
-        supports(event) {
-            return event === eventName;
-        },
-    };
-}
-
-exports.createCustomEventSource = createCustomEventSource;
-exports.createDOMEventSource = createDOMEventSource;
-exports.isBrowserEventSource = isBrowserEventSource;
-exports.isBrowserPayload = isBrowserPayload;
-//# sourceMappingURL=browser-types.cjs.map

package/dist/registry/browser-types.d.ts

@@ -1,20 +0,0 @@
-import type { EventSourcePayload, EventSourceHandler, EventSource } from './event-source-registry';
-export interface BrowserEventPayload extends EventSourcePayload<'browser'> {
-    target?: Element | null;
-    nativeEvent?: Event;
-}
-export type BrowserEventHandler = EventSourceHandler<'browser'>;
-export interface BrowserEventSource extends EventSource {
-}
-export declare function isBrowserPayload(payload: EventSourcePayload): payload is BrowserEventPayload;
-export declare function isBrowserEventSource(source: EventSource): source is BrowserEventSource;
-export declare function createDOMEventSource(eventName: string, options?: {
-    description?: string;
-    target?: Element | Document;
-    capture?: boolean;
-}): BrowserEventSource;
-export declare function createCustomEventSource<TDetail = any>(eventName: string, options?: {
-    description?: string;
-    target?: Element | Document;
-}): BrowserEventSource;
-//# sourceMappingURL=browser-types.d.ts.map

package/dist/registry/browser-types.mjs

@@ -1,76 +0,0 @@
-function isBrowserPayload(payload) {
-    return (typeof window !== 'undefined' &&
-        typeof document !== 'undefined' &&
-        (payload.target == null || payload.target instanceof Element));
-}
-function isBrowserEventSource(source) {
-    return typeof window !== 'undefined' && typeof document !== 'undefined';
-}
-function createDOMEventSource(eventName, options) {
-    const target = options?.target ?? document;
-    const capture = options?.capture ?? false;
-    return {
-        name: eventName,
-        description: options?.description ?? `DOM ${eventName} events`,
-        supportedEvents: [eventName],
-        subscribe(subscribeOptions, context) {
-            const handler = (e) => {
-                const payload = {
-                    type: eventName,
-                    data: e,
-                    target: e.target instanceof Element ? e.target : null,
-                    nativeEvent: e,
-                };
-                subscribeOptions.handler(payload, context);
-            };
-            target.addEventListener(eventName, handler, { capture });
-            return {
-                id: `${eventName}_${Date.now()}_${Math.random().toString(36).slice(2)}`,
-                source: eventName,
-                event: eventName,
-                unsubscribe: () => target.removeEventListener(eventName, handler, { capture }),
-            };
-        },
-        supports(event) {
-            return event === eventName;
-        },
-    };
-}
-function createCustomEventSource(eventName, options) {
-    const target = options?.target ?? document;
-    return {
-        name: eventName,
-        description: options?.description ?? `Custom ${eventName} events`,
-        supportedEvents: [eventName],
-        subscribe(subscribeOptions, context) {
-            const handler = (e) => {
-                const customEvent = e;
-                const payload = {
-                    type: eventName,
-                    data: customEvent.detail,
-                    target: e.target instanceof Element ? e.target : null,
-                    nativeEvent: e,
-                    meta: {
-                        bubbles: customEvent.bubbles,
-                        cancelable: customEvent.cancelable,
-                        composed: customEvent.composed,
-                    },
-                };
-                subscribeOptions.handler(payload, context);
-            };
-            target.addEventListener(eventName, handler);
-            return {
-                id: `${eventName}_${Date.now()}_${Math.random().toString(36).slice(2)}`,
-                source: eventName,
-                event: eventName,
-                unsubscribe: () => target.removeEventListener(eventName, handler),
-            };
-        },
-        supports(event) {
-            return event === eventName;
-        },
-    };
-}
-
-export { createCustomEventSource, createDOMEventSource, isBrowserEventSource, isBrowserPayload };
-//# sourceMappingURL=browser-types.mjs.map

package/dist/registry/environment.cjs

@@ -1,36 +0,0 @@
-'use strict';
-
-function isBrowserEnvironment() {
-    return typeof window !== 'undefined' && typeof document !== 'undefined';
-}
-function isNodeEnvironment() {
-    return (typeof process !== 'undefined' && process.versions != null && process.versions.node != null);
-}
-function getRuntimeEnvironment() {
-    if (isBrowserEnvironment())
-        return 'browser';
-    if (isNodeEnvironment())
-        return 'node';
-    return 'unknown';
-}
-function assertBrowserEnvironment() {
-    if (!isBrowserEnvironment()) {
-        throw new Error('This function requires a browser environment with DOM APIs. ' +
-            'Current environment: ' +
-            getRuntimeEnvironment());
-    }
-}
-function assertNodeEnvironment() {
-    if (!isNodeEnvironment()) {
-        throw new Error('This function requires a Node.js environment. ' +
-            'Current environment: ' +
-            getRuntimeEnvironment());
-    }
-}
-
-exports.assertBrowserEnvironment = assertBrowserEnvironment;
-exports.assertNodeEnvironment = assertNodeEnvironment;
-exports.getRuntimeEnvironment = getRuntimeEnvironment;
-exports.isBrowserEnvironment = isBrowserEnvironment;
-exports.isNodeEnvironment = isNodeEnvironment;
-//# sourceMappingURL=environment.cjs.map

package/dist/registry/environment.d.ts

@@ -1,19 +0,0 @@
-export type RuntimeEnvironment = 'browser' | 'node' | 'universal';
-export type DetectEnvironment<T = typeof globalThis> = T extends {
-    document: any;
-    window: any;
-} ? 'browser' : T extends {
-    process: any;
-    require: any;
-} ? 'node' : 'universal';
-export declare function isBrowserEnvironment(): boolean;
-export declare function isNodeEnvironment(): boolean;
-export declare function getRuntimeEnvironment(): 'browser' | 'node' | 'unknown';
-export declare function assertBrowserEnvironment(): asserts this is {
-    window: Window;
-    document: Document;
-};
-export declare function assertNodeEnvironment(): asserts this is {
-    process: NodeJS.Process;
-};
-//# sourceMappingURL=environment.d.ts.map

package/dist/registry/environment.mjs

@@ -1,30 +0,0 @@
-function isBrowserEnvironment() {
-    return typeof window !== 'undefined' && typeof document !== 'undefined';
-}
-function isNodeEnvironment() {
-    return (typeof process !== 'undefined' && process.versions != null && process.versions.node != null);
-}
-function getRuntimeEnvironment() {
-    if (isBrowserEnvironment())
-        return 'browser';
-    if (isNodeEnvironment())
-        return 'node';
-    return 'unknown';
-}
-function assertBrowserEnvironment() {
-    if (!isBrowserEnvironment()) {
-        throw new Error('This function requires a browser environment with DOM APIs. ' +
-            'Current environment: ' +
-            getRuntimeEnvironment());
-    }
-}
-function assertNodeEnvironment() {
-    if (!isNodeEnvironment()) {
-        throw new Error('This function requires a Node.js environment. ' +
-            'Current environment: ' +
-            getRuntimeEnvironment());
-    }
-}
-
-export { assertBrowserEnvironment, assertNodeEnvironment, getRuntimeEnvironment, isBrowserEnvironment, isNodeEnvironment };
-//# sourceMappingURL=environment.mjs.map

package/dist/registry/event-source-registry.d.ts

@@ -1,54 +0,0 @@
-import type { ExecutionContext } from '../types/core';
-import type { RuntimeEnvironment } from './environment';
-export type { RuntimeEnvironment } from './environment';
-export type EventTarget<TEnv extends RuntimeEnvironment> = TEnv extends 'browser' ? Element : TEnv extends 'node' ? object : Element | object;
-export type NativeEvent<TEnv extends RuntimeEnvironment> = TEnv extends 'browser' ? Event : TEnv extends 'node' ? never : Event | undefined;
-export interface EventSourcePayload<TEnv extends RuntimeEnvironment = 'universal'> {
-    type: string;
-    data: unknown;
-    target?: EventTarget<TEnv> | null;
-    nativeEvent?: NativeEvent<TEnv>;
-    meta?: Record<string, unknown>;
-}
-export type EventSourceHandler<TEnv extends RuntimeEnvironment = 'universal'> = (payload: EventSourcePayload<TEnv>, context: ExecutionContext) => void;
-export interface EventSourceSubscription {
-    id: string;
-    source: string;
-    event: string;
-    unsubscribe: () => void;
-}
-export interface EventSourceSubscribeOptions {
-    event: string;
-    handler: EventSourceHandler;
-    target?: string | RegExp;
-    selector?: string;
-    options?: Record<string, unknown>;
-}
-export interface EventSource {
-    readonly name: string;
-    readonly description?: string;
-    readonly supportedEvents?: string[];
-    subscribe(options: EventSourceSubscribeOptions, context: ExecutionContext): EventSourceSubscription;
-    supports?(event: string): boolean;
-    initialize?(): Promise<void> | void;
-    destroy?(): void;
-}
-export declare class EventSourceRegistry {
-    private sources;
-    private subscriptions;
-    private nextId;
-    register(name: string, source: EventSource): void;
-    unregister(name: string): boolean;
-    get(name: string): EventSource | undefined;
-    has(name: string): boolean;
-    subscribe(sourceName: string, options: EventSourceSubscribeOptions, context: ExecutionContext): EventSourceSubscription | undefined;
-    unsubscribe(subscriptionId: string): boolean;
-    getSourceNames(): string[];
-    getSubscriptions(): EventSourceSubscription[];
-    findSourceForEvent(event: string): string | undefined;
-    generateId(): string;
-    destroy(): void;
-}
-export declare function createEventSourceRegistry(): EventSourceRegistry;
-export declare function getDefaultEventSourceRegistry(): EventSourceRegistry;
-//# sourceMappingURL=event-source-registry.d.ts.map

package/dist/registry/examples/server-commands.d.ts

@@ -1,6 +0,0 @@
-import type { CommandWithParseInput } from '../../runtime/command-adapter';
-export declare const respondCommand: CommandWithParseInput;
-export declare const redirectCommand: CommandWithParseInput;
-export declare const setHeaderCommand: CommandWithParseInput;
-export declare const serverPlugin: import("../index").LokaScriptPlugin;
-//# sourceMappingURL=server-commands.d.ts.map

package/dist/registry/examples/server-event-source.d.ts

@@ -1,32 +0,0 @@
-import type { EventSource, EventSourcePayload } from '../event-source-registry';
-import type { ExecutionContext } from '../../types/core';
-export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
-export interface ServerRequest {
-    method: HttpMethod;
-    url: string;
-    path: string;
-    query: Record<string, string | string[]>;
-    params: Record<string, string>;
-    headers: Record<string, string | string[]>;
-    body: unknown;
-}
-export interface ServerResponse {
-    status(code: number): ServerResponse;
-    header(name: string, value: string): ServerResponse;
-    json(data: unknown): void;
-    html(content: string): void;
-    text(content: string): void;
-    redirect(url: string, code?: number): void;
-    send(data: unknown): void;
-}
-export interface RequestHandler {
-    method: HttpMethod | '*';
-    pattern: string | RegExp;
-    handler: (payload: EventSourcePayload, context: ExecutionContext) => void;
-}
-export declare function createRequestEventSource(): EventSource & {
-    handleRequest(request: ServerRequest, response: ServerResponse): boolean;
-};
-export declare function createWebSocketEventSource(): EventSource;
-export declare function createSSEEventSource(): EventSource;
-//# sourceMappingURL=server-event-source.d.ts.map