@hyperfixi/core 3.3.0 → 4.0.1

package/dist/registry/runtime-integration.d.ts

@@ -1,23 +0,0 @@
-import type { ExecutionContext } from '../types/core';
-import type { EventSource, EventSourceSubscribeOptions } from './event-source-registry';
-import type { EventSourceRegistry } from './event-source-registry';
-export interface RegistryIntegrationOptions {
-    enableEventSources?: boolean;
-    registry?: {
-        eventSources?: EventSourceRegistry;
-    };
-}
-export declare class RegistryIntegration {
-    private options;
-    private eventSourceRegistry;
-    constructor(options?: RegistryIntegrationOptions);
-    getEventSource(eventName: string): EventSource | undefined;
-    hasEventSource(eventName: string): boolean;
-    subscribeToEventSource(eventSourceName: string, options: EventSourceSubscribeOptions, context: ExecutionContext): import("./event-source-registry").EventSourceSubscription;
-    getEventSourceNames(): string[];
-    destroy(): void;
-}
-export declare function createRegistryIntegration(options?: RegistryIntegrationOptions): RegistryIntegration;
-export declare function getDefaultRegistryIntegration(): RegistryIntegration;
-export declare function resetDefaultRegistryIntegration(): void;
-//# sourceMappingURL=runtime-integration.d.ts.map

package/dist/registry/universal-types.cjs

@@ -1,91 +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 createTimerEventSource(name, interval) {
-    return {
-        name,
-        description: `Timer that fires every ${interval}ms`,
-        supportedEvents: [name],
-        subscribe(options, context) {
-            const handler = () => {
-                const payload = {
-                    type: name,
-                    data: { timestamp: Date.now() },
-                    target: isBrowserEnvironment() && typeof document !== 'undefined' ? document.body : {},
-                };
-                options.handler(payload, context);
-            };
-            const timerId = setInterval(handler, interval);
-            return {
-                id: `${name}_${Date.now()}_${Math.random().toString(36).slice(2)}`,
-                source: name,
-                event: name,
-                unsubscribe: () => clearInterval(timerId),
-            };
-        },
-        supports(event) {
-            return event === name;
-        },
-    };
-}
-function createAdaptiveEventSource(name, options) {
-    return {
-        name,
-        description: options?.description ?? `Adaptive ${name} events`,
-        supportedEvents: [name],
-        subscribe(subscribeOptions, context) {
-            let unsubscribe;
-            if (isBrowserEnvironment()) {
-                const handler = (e) => {
-                    const customEvent = e;
-                    const payload = {
-                        type: name,
-                        data: customEvent.detail,
-                        target: e.target instanceof Element ? e.target : null,
-                        nativeEvent: e,
-                    };
-                    subscribeOptions.handler(payload, context);
-                };
-                document.addEventListener(name, handler);
-                unsubscribe = () => document.removeEventListener(name, handler);
-            }
-            else if (isNodeEnvironment()) {
-                unsubscribe = () => {
-                };
-            }
-            else {
-                unsubscribe = () => { };
-            }
-            return {
-                id: `${name}_${Date.now()}_${Math.random().toString(36).slice(2)}`,
-                source: name,
-                event: name,
-                unsubscribe,
-            };
-        },
-        supports(event) {
-            return event === name;
-        },
-    };
-}
-function isBrowserLikePayload(payload) {
-    return isBrowserEnvironment() && (payload.target == null || payload.target instanceof Element);
-}
-function isServerLikePayload(payload) {
-    return (isNodeEnvironment() &&
-        typeof payload.data === 'object' &&
-        payload.data !== null &&
-        'request' in payload.data);
-}
-
-exports.createAdaptiveEventSource = createAdaptiveEventSource;
-exports.createTimerEventSource = createTimerEventSource;
-exports.isBrowserLikePayload = isBrowserLikePayload;
-exports.isServerLikePayload = isServerLikePayload;
-//# sourceMappingURL=universal-types.cjs.map

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

@@ -1,35 +0,0 @@
-import type { EventSourcePayload, EventSourceHandler, EventSource, RuntimeEnvironment } from './event-source-registry';
-import type { ExecutionContext } from '../types/core';
-import type { CommandWithParseInput } from '../runtime/command-adapter';
-export type UniversalEventPayload = EventSourcePayload<'universal'>;
-export type UniversalEventHandler = EventSourceHandler<'universal'>;
-export interface UniversalEventSource<TEnv extends RuntimeEnvironment = 'universal'> extends EventSource {
-}
-export interface TypedRegistry<TEnv extends RuntimeEnvironment = 'universal'> {
-    eventSources: {
-        register(name: string, source: UniversalEventSource<TEnv>): void;
-        get(name: string): UniversalEventSource<TEnv> | undefined;
-        has(name: string): boolean;
-        getSourceNames(): string[];
-    };
-    context: {
-        register<T>(name: string, provide: (ctx: ExecutionContext) => T, options?: {
-            description?: string;
-            cache?: boolean;
-        }): void;
-        has(name: string): boolean;
-        getProviderNames(): string[];
-    };
-    commands: {
-        register(command: CommandWithParseInput): void;
-        has(name: string): boolean;
-        getCommandNames(): string[];
-    };
-}
-export declare function createTimerEventSource(name: string, interval: number): UniversalEventSource;
-export declare function createAdaptiveEventSource(name: string, options?: {
-    description?: string;
-}): UniversalEventSource;
-export declare function isBrowserLikePayload(payload: UniversalEventPayload): boolean;
-export declare function isServerLikePayload(payload: UniversalEventPayload): boolean;
-//# sourceMappingURL=universal-types.d.ts.map

package/dist/registry/universal-types.mjs

@@ -1,86 +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 createTimerEventSource(name, interval) {
-    return {
-        name,
-        description: `Timer that fires every ${interval}ms`,
-        supportedEvents: [name],
-        subscribe(options, context) {
-            const handler = () => {
-                const payload = {
-                    type: name,
-                    data: { timestamp: Date.now() },
-                    target: isBrowserEnvironment() && typeof document !== 'undefined' ? document.body : {},
-                };
-                options.handler(payload, context);
-            };
-            const timerId = setInterval(handler, interval);
-            return {
-                id: `${name}_${Date.now()}_${Math.random().toString(36).slice(2)}`,
-                source: name,
-                event: name,
-                unsubscribe: () => clearInterval(timerId),
-            };
-        },
-        supports(event) {
-            return event === name;
-        },
-    };
-}
-function createAdaptiveEventSource(name, options) {
-    return {
-        name,
-        description: options?.description ?? `Adaptive ${name} events`,
-        supportedEvents: [name],
-        subscribe(subscribeOptions, context) {
-            let unsubscribe;
-            if (isBrowserEnvironment()) {
-                const handler = (e) => {
-                    const customEvent = e;
-                    const payload = {
-                        type: name,
-                        data: customEvent.detail,
-                        target: e.target instanceof Element ? e.target : null,
-                        nativeEvent: e,
-                    };
-                    subscribeOptions.handler(payload, context);
-                };
-                document.addEventListener(name, handler);
-                unsubscribe = () => document.removeEventListener(name, handler);
-            }
-            else if (isNodeEnvironment()) {
-                unsubscribe = () => {
-                };
-            }
-            else {
-                unsubscribe = () => { };
-            }
-            return {
-                id: `${name}_${Date.now()}_${Math.random().toString(36).slice(2)}`,
-                source: name,
-                event: name,
-                unsubscribe,
-            };
-        },
-        supports(event) {
-            return event === name;
-        },
-    };
-}
-function isBrowserLikePayload(payload) {
-    return isBrowserEnvironment() && (payload.target == null || payload.target instanceof Element);
-}
-function isServerLikePayload(payload) {
-    return (isNodeEnvironment() &&
-        typeof payload.data === 'object' &&
-        payload.data !== null &&
-        'request' in payload.data);
-}
-
-export { createAdaptiveEventSource, createTimerEventSource, isBrowserLikePayload, isServerLikePayload };
-//# sourceMappingURL=universal-types.mjs.map

package/dist/runtime/cleanup-registry.d.ts

@@ -1,47 +0,0 @@
-export type CleanupType = 'listener' | 'observer' | 'interval' | 'timeout' | 'custom';
-export interface CleanupEntry {
-    type: CleanupType;
-    cleanup: () => void;
-    target?: EventTarget;
-    eventName?: string;
-    description?: string;
-}
-export interface CleanupStats {
-    elementsTracked: number;
-    listeners: number;
-    observers: number;
-    intervals: number;
-    timeouts: number;
-    custom: number;
-    global: number;
-}
-export declare class CleanupRegistry {
-    private elementCleanups;
-    private elementCount;
-    private typeCounts;
-    private globalCleanups;
-    private debugMode;
-    constructor(options?: {
-        debug?: boolean;
-    });
-    registerListener(element: Element, target: EventTarget, eventName: string, handler: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
-    registerObserver(element: Element, observer: MutationObserver): void;
-    registerInterval(element: Element, intervalId: ReturnType<typeof setInterval>): void;
-    registerTimeout(element: Element, timeoutId: ReturnType<typeof setTimeout>): void;
-    registerCustom(element: Element, cleanup: () => void, description?: string): void;
-    registerGlobal(cleanup: () => void, type?: CleanupType, description?: string): void;
-    private addCleanup;
-    cleanupElement(element: Element): number;
-    cleanupElementTree(element: Element): number;
-    cleanupGlobal(): number;
-    cleanupAll(): number;
-    hasCleanups(element: Element): boolean;
-    getCleanupCount(element: Element): number;
-    getStats(): CleanupStats;
-    setDebugMode(enabled: boolean): void;
-}
-export declare function createAutoCleanupRegistry(options?: {
-    debug?: boolean;
-    root?: Element;
-}): CleanupRegistry;
-//# sourceMappingURL=cleanup-registry.d.ts.map

package/dist/runtime/command-adapter.d.ts

@@ -1,69 +0,0 @@
-import type { ExecutionContext, TypedExecutionContext, ValidationResult } from '../types/core';
-import type { ASTNode } from '../types/base-types';
-import { HookRegistry } from '../types/hooks';
-import type { BodyOps } from '../types/program';
-export interface RuntimeCommand {
-    name: string;
-    execute(context: ExecutionContext, ...args: unknown[]): Promise<unknown>;
-    validate?(input: unknown): ValidationResult<unknown>;
-    metadata?: {
-        description: string;
-        examples: readonly string[];
-        syntax: string;
-    };
-}
-export interface CommandMetadata {
-    description?: string;
-    examples?: readonly string[];
-    syntax?: string | readonly string[];
-    aliases?: readonly string[];
-    [extra: string]: unknown;
-}
-export interface CommandRawInput {
-    args: ASTNode[];
-    modifiers: Record<string, unknown>;
-    commandName?: string;
-    bodies?: BodyOps;
-}
-export interface CommandWithParseInput {
-    name: string;
-    parseInput?(raw: CommandRawInput, evaluator: {
-        evaluate(node: ASTNode, context: ExecutionContext): Promise<unknown>;
-    }, context: ExecutionContext): Promise<unknown>;
-    execute(input: unknown, context: TypedExecutionContext): unknown;
-    validate?(input: unknown): boolean;
-    readonly ownsConditionalModifier?: boolean;
-    metadata?: CommandMetadata;
-}
-export declare class CommandAdapterV2 implements RuntimeCommand {
-    private impl;
-    private hookRegistry;
-    constructor(impl: CommandWithParseInput, _legacySharedEvaluator?: unknown, hookRegistry?: HookRegistry);
-    setHookRegistry(registry: HookRegistry): void;
-    private createHookContext;
-    get name(): string;
-    get metadata(): {
-        description: string;
-        examples: readonly string[];
-        syntax: string;
-    };
-    execute(context: ExecutionContext, ...args: unknown[]): Promise<unknown>;
-    validate(input: unknown): ValidationResult<unknown>;
-}
-export declare class CommandRegistryV2 {
-    private adapters;
-    private implementations;
-    private hookRegistry?;
-    constructor(_legacySharedEvaluator?: unknown, hookRegistry?: HookRegistry);
-    setHookRegistry(registry: HookRegistry): void;
-    getHookRegistry(): HookRegistry | undefined;
-    register(impl: CommandWithParseInput): void;
-    getAdapter(name: string): CommandAdapterV2 | undefined;
-    has(name: string): boolean;
-    getCommandNames(): string[];
-    getImplementation(name: string): CommandWithParseInput | undefined;
-    getAdapters(): Map<string, CommandAdapterV2>;
-    validateCommand(name: string, input: unknown): ValidationResult<unknown>;
-}
-export declare function createCommandRegistryV2(commands: CommandWithParseInput[], _legacySharedEvaluator?: unknown, hookRegistry?: HookRegistry): CommandRegistryV2;
-//# sourceMappingURL=command-adapter.d.ts.map

package/dist/runtime/environment.d.ts

@@ -1,75 +0,0 @@
-export declare const isDeno: boolean;
-export declare const isNode: string | false;
-export declare const isBrowser: boolean;
-export interface RuntimeInfo {
-    name: 'deno' | 'node' | 'browser' | 'unknown';
-    version: string;
-    hasDOM: boolean;
-    hasWebAPIs: boolean;
-    hasFileSystem: boolean;
-    hasNetworking: boolean;
-    typescript: boolean;
-    supportsESM: boolean;
-    supportsWorkers: boolean;
-}
-export declare function getRuntimeInfo(): RuntimeInfo;
-export declare const logger: {
-    info: (message: string, ...args: unknown[]) => void;
-    warn: (message: string, ...args: unknown[]) => void;
-    error: (message: string, ...args: unknown[]) => void;
-    debug: (message: string, ...args: unknown[]) => void;
-};
-export declare const performance: {
-    now: () => number;
-    mark: (name: string) => void;
-    measure: (name: string, startMark?: string, endMark?: string) => void;
-};
-export declare class UniversalEventTarget {
-    private listeners;
-    addEventListener(type: string, listener: (event: any) => void): void;
-    removeEventListener(type: string, listener: (event: any) => void): void;
-    dispatchEvent(event: {
-        type: string;
-        [key: string]: any;
-    }): boolean;
-}
-export declare function getLLMRuntimeInfo(): {
-    runtime: "unknown" | "node" | "browser" | "deno";
-    version: string;
-    typescript: boolean;
-    capabilities: {
-        dom: boolean;
-        webapis: boolean;
-        filesystem: boolean;
-        networking: boolean;
-        workers: boolean;
-        esm: boolean;
-    };
-    features: {
-        dom?: boolean | undefined;
-        webapis?: boolean | undefined;
-        serviceWorkers?: boolean | undefined;
-        webAssembly?: boolean | undefined;
-        npm?: boolean | undefined;
-        packageJson?: boolean | undefined;
-        nodeModules?: boolean | undefined;
-        builtinModules?: boolean | undefined;
-        permissions?: string | undefined;
-        builtinTypescript?: boolean | undefined;
-        standardLibrary?: string | undefined;
-        jsr?: boolean | undefined;
-        denoDeploy?: boolean | undefined;
-    };
-    patterns: {
-        imports: string;
-        testing: string;
-        bundling: string;
-    };
-};
-export declare function importForEnvironment<T>(imports: {
-    deno?: () => Promise<T>;
-    node?: () => Promise<T>;
-    browser?: () => Promise<T>;
-    fallback?: () => Promise<T>;
-}): Promise<T>;
-//# sourceMappingURL=environment.d.ts.map

package/dist/runtime/plugin.d.ts

@@ -1,14 +0,0 @@
-import type { CommandRegistryV2 } from './command-adapter';
-import type { ParserExtensionRegistry } from '../parser/extensions';
-import type { Runtime } from './runtime';
-export interface HyperfixiPluginContext {
-    commandRegistry: CommandRegistryV2;
-    parserExtensions: ParserExtensionRegistry;
-    runtime: Runtime;
-}
-export interface HyperfixiPlugin {
-    name: string;
-    install(ctx: HyperfixiPluginContext): void;
-}
-export declare function installPlugin(runtime: Runtime, plugin: HyperfixiPlugin): void;
-//# sourceMappingURL=plugin.d.ts.map

package/dist/runtime/runtime-base.d.ts

@@ -1,100 +0,0 @@
-import type { ASTNode, ExecutionContext } from '../types/base-types';
-import type { CommandNode, EventHandlerNode, DefNode, BehaviorNode, ProgramNode, BlockNode, InitBlockNode, ObjectLiteralNode } from '../ast/nodes';
-import { type AnyNode } from '../ast/legacy';
-import type { ExecutionResult, ExecutionSignal } from '../types/result';
-import type { RuntimeHooks } from '../types/hooks';
-import { HookRegistry } from '../types/hooks';
-import type { ExpressionRegistry } from '../core/expression-registry';
-export declare class StrayControlFlowError extends Error {
-    readonly signal: ExecutionSignal;
-    constructor(signal: ExecutionSignal);
-}
-import { CommandRegistryV2 as CommandRegistry } from './command-adapter';
-import { CleanupRegistry } from './cleanup-registry';
-import { RegistryIntegration, type RegistryIntegrationOptions } from '../registry/runtime-integration';
-import type { Op, BodyOps } from '../types/program';
-export interface RuntimeBaseOptions {
-    logAll?: () => boolean;
-    registry: CommandRegistry;
-    enableAsyncCommands?: boolean;
-    commandTimeout?: number;
-    enableErrorReporting?: boolean;
-    expressionRegistry: ExpressionRegistry;
-    hooks?: RuntimeHooks;
-    enableAutoCleanup?: boolean;
-    registryIntegration?: RegistryIntegrationOptions | boolean;
-}
-export type BehaviorEntry = {
-    name: string;
-    parameters: string[];
-    type: 'imperative';
-    install: (element: HTMLElement, parameters: Record<string, unknown>) => void | Promise<void>;
-} | {
-    name: string;
-    parameters: string[];
-    type?: undefined;
-    eventHandlers: EventHandlerNode[];
-    initBlock?: ASTNode;
-};
-export interface BehaviorAPI {
-    has(name: string): boolean;
-    get(name: string): BehaviorEntry | undefined;
-    set(name: string, definition: BehaviorEntry): void;
-    resolve: ((name: string) => boolean) | null;
-    install(behaviorName: string, element: HTMLElement, parameters: Record<string, unknown>): Promise<void>;
-}
-export declare class RuntimeBase {
-    protected options: RuntimeBaseOptions;
-    protected registry: CommandRegistry;
-    protected expressionRegistry: ExpressionRegistry;
-    behaviorRegistry: Map<string, BehaviorEntry>;
-    behaviorAPI: BehaviorAPI;
-    protected globalVariables: Map<string, unknown>;
-    protected hookRegistry: HookRegistry;
-    protected cleanupRegistry: CleanupRegistry;
-    private autoCleanupObserver;
-    protected registryIntegration: RegistryIntegration | null;
-    protected runtimeWarnings: string[];
-    constructor(options: RuntimeBaseOptions);
-    private setupAutoCleanup;
-    registerHooks(name: string, hooks: RuntimeHooks): void;
-    unregisterHooks(name: string): boolean;
-    getRegisteredHooks(): string[];
-    cleanup(element: Element): number;
-    trackListener(element: Element, target: EventTarget, eventName: string, handler: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
-    cleanupTree(element: Element): number;
-    getCleanupStats(): ReturnType<CleanupRegistry['getStats']>;
-    getCleanupRegistry(): CleanupRegistry;
-    protected logError(...args: unknown[]): void;
-    protected logWarn(...args: unknown[]): void;
-    destroy(): void;
-    private hasErrorDiagnostics;
-    getWarnings(): readonly string[];
-    execute(node: AnyNode, context: ExecutionContext): Promise<unknown>;
-    protected executeNode(node: AnyNode, context: ExecutionContext): Promise<ExecutionResult<unknown>>;
-    private prepareContext;
-    private readonly ops;
-    compile(node: AnyNode): Op;
-    protected compileSequence(nodes: readonly AnyNode[]): Op;
-    private compileNode;
-    private dispatch;
-    protected processCommandWithResult(node: CommandNode, context: ExecutionContext, bodies?: BodyOps): Promise<ExecutionResult<unknown>>;
-    protected executeCommandSequenceWithResult(commands: readonly AnyNode[], context: ExecutionContext): Promise<ExecutionResult<unknown>>;
-    protected evaluateExpression(node: AnyNode, context: ExecutionContext): Promise<unknown>;
-    protected evaluateExpressionWithResult(node: AnyNode, context: ExecutionContext): Promise<ExecutionResult<unknown>>;
-    protected installFunction(node: DefNode, context: ExecutionContext): void;
-    protected executeProgram(node: ProgramNode, context: ExecutionContext): Promise<ExecutionResult<unknown>>;
-    protected executeBlock(node: BlockNode | InitBlockNode, context: ExecutionContext): Promise<ExecutionResult<unknown>>;
-    protected executeObjectLiteral(node: ObjectLiteralNode, context: ExecutionContext): Promise<Record<string, unknown>>;
-    protected executeBehaviorDefinition(node: BehaviorNode & {
-        readonly imperativeInstaller?: (element: HTMLElement, parameters: Record<string, any>) => void;
-    }, _context: ExecutionContext): Promise<void>;
-    protected installBehaviorOnElement(behaviorName: string, element: HTMLElement, parameters: Record<string, any>): Promise<void>;
-    protected executeEventHandler(node: EventHandlerNode, context: ExecutionContext): Promise<void>;
-    private static createEventHandler;
-    protected setupMutationObserver(targets: HTMLElement[], attr: string, commands: readonly AnyNode[], context: ExecutionContext): void;
-    protected setupChangeObserver(watchTarget: AnyNode, commands: readonly AnyNode[], context: ExecutionContext): Promise<void>;
-    protected queryElements(selector: string, context: ExecutionContext): HTMLElement[];
-    protected isElement(obj: unknown): obj is HTMLElement;
-}
-//# sourceMappingURL=runtime-base.d.ts.map

package/dist/runtime/runtime-factory.d.ts

@@ -1,29 +0,0 @@
-import { RuntimeBase } from './runtime-base';
-import { type ExpressionRegistry } from '../core/expression-registry';
-import type { ParserInterface } from '../parser/parser-interface';
-import type { ExecutionContext } from '../types/core';
-export interface TreeShakeableRuntimeOptions {
-    expressionRegistry: ExpressionRegistry;
-    enableAsyncCommands?: boolean;
-    commandTimeout?: number;
-    enableErrorReporting?: boolean;
-}
-export interface RuntimeOptions {
-    commands: Array<() => any>;
-    expressions?: Record<string, any>[];
-    parser?: ParserInterface;
-    enableAsyncCommands?: boolean;
-    commandTimeout?: number;
-    enableErrorReporting?: boolean;
-}
-export interface LokaScriptRuntime {
-    runtime: RuntimeBase;
-    parser?: ParserInterface;
-    run(code: string, element?: Element): Promise<unknown>;
-    execute(ast: any, context: ExecutionContext): Promise<unknown>;
-    parse(code: string): any;
-}
-export declare function createTreeShakeableRuntime(commands: any[], options: TreeShakeableRuntimeOptions): RuntimeBase;
-export declare function createRuntime(options: RuntimeOptions): LokaScriptRuntime;
-export type { ExpressionRegistry, ParserInterface };
-//# sourceMappingURL=runtime-factory.d.ts.map

package/dist/runtime/runtime.d.ts

@@ -1,20 +0,0 @@
-import { RuntimeBase } from './runtime-base';
-import { CommandRegistryV2 } from './command-adapter';
-export interface RuntimeOptions {
-    enableAsyncCommands?: boolean;
-    logAll?: () => boolean;
-    commandTimeout?: number;
-    enableErrorReporting?: boolean;
-    lazyLoad?: boolean;
-    expressionPreload?: 'core' | 'common' | 'all' | 'none';
-    registry?: CommandRegistryV2;
-    expressionRegistry?: import('../core/expression-registry').ExpressionRegistry;
-    useEnhancedCommands?: boolean;
-    commands?: string[];
-}
-export declare class Runtime extends RuntimeBase {
-    constructor(options?: RuntimeOptions);
-    getRegistry(): CommandRegistryV2;
-}
-export declare function createRuntime(options?: RuntimeOptions): Runtime;
-//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime/temporal-modifiers.d.ts

@@ -1,37 +0,0 @@
-export interface TemporalState {
-    id: string;
-    command: string;
-    element: HTMLElement;
-    originalState: any;
-    untilEvent: string;
-    untilTarget?: HTMLElement | Document | Window | undefined;
-    cleanup: () => void;
-    timestamp: number;
-}
-export interface TemporalModifierOptions {
-    command: string;
-    element: HTMLElement;
-    untilEvent: string;
-    untilTarget?: HTMLElement | Document | Window | undefined;
-    stateCapture: () => any;
-    stateRestore: (state: any) => void;
-}
-export declare class TemporalModifierManager {
-    private static instance;
-    private activeStates;
-    private nextId;
-    private constructor();
-    static getInstance(): TemporalModifierManager;
-    register(options: TemporalModifierOptions): string;
-    unregister(id: string): boolean;
-    getActiveStates(): TemporalState[];
-    getStatesForElement(element: HTMLElement): TemporalState[];
-    clearAll(): void;
-    get activeCount(): number;
-}
-export declare function createToggleUntil(element: HTMLElement, targetType: 'class' | 'attribute', targetName: string, untilEvent: string, untilTarget?: HTMLElement | Document | Window): string;
-export declare function createAddUntil(element: HTMLElement, targetType: 'class' | 'attribute', targetName: string, targetValue: string | undefined, untilEvent: string, untilTarget?: HTMLElement | Document | Window): string;
-export declare function createRemoveUntil(element: HTMLElement, targetType: 'class' | 'attribute', targetName: string, untilEvent: string, untilTarget?: HTMLElement | Document | Window): string;
-export declare const temporalModifierManager: TemporalModifierManager;
-export default TemporalModifierManager;
-//# sourceMappingURL=temporal-modifiers.d.ts.map

package/dist/test-setup.d.ts

@@ -1,28 +0,0 @@
-declare global {
-    namespace Vi {
-        interface AsymmetricMatchersContaining {
-            toBeValidHyperscriptAST(): any;
-            toExecuteSuccessfully(): any;
-        }
-    }
-}
-export declare const createTestElement: (html: string) => HTMLElement;
-export declare const waitForEvent: (target: EventTarget, eventName: string, timeout?: number) => Promise<Event>;
-export declare const createMockHyperscriptContext: (element?: HTMLElement) => {
-    me: HTMLElement | null;
-    it: any;
-    you: HTMLElement | null;
-    result: any;
-    locals: Map<string, any>;
-    globals: Map<string, any>;
-    registry: import("./core/expression-registry").ExpressionRegistry;
-};
-export declare const createTypedExecutionContext: (element?: HTMLElement) => {
-    me: HTMLElement | null;
-    it: any;
-    you: HTMLElement | null;
-    result: any;
-    locals: Map<string, any>;
-    globals: Map<string, any>;
-};
-//# sourceMappingURL=test-setup.d.ts.map