@hyperfixi/core 2.3.0 → 2.4.0

package/dist/expressions/positional/impl/bridge.d.ts

@@ -1,95 +0,0 @@
-import type { ExecutionContext, TypedExpressionContext, ExpressionEvaluationOptions } from '../../../types/base-types';
-export declare function createTypedExpressionContext(context: ExecutionContext, options?: ExpressionEvaluationOptions): TypedExpressionContext;
-export declare function updateExecutionContext(originalContext: ExecutionContext, typedContext: TypedExpressionContext): ExecutionContext;
-export declare class PositionalAdapter {
-    static evaluateFirst(context: ExecutionContext, collection?: unknown): Promise<unknown>;
-    static evaluateLast(context: ExecutionContext, collection?: unknown): Promise<unknown>;
-    static evaluateAt(context: ExecutionContext, index: number, collection?: unknown): Promise<unknown>;
-    static getExpressionMetadata(expressionName: string): import("../../../types/expression-types").ExpressionMetadata;
-    static getExpressionDocumentation(expressionName: string): unknown;
-    static validateExpressionInput(expressionName: string, input: unknown): import("../../../types/base-types").ValidationResult<unknown>;
-}
-export declare const EnhancedPositionalAdapter: typeof PositionalAdapter;
-export declare class LegacyCompatibilityLayer {
-    static firstExpression: {
-        name: string;
-        category: "Reference";
-        evaluatesTo: "Any";
-        evaluate(context: ExecutionContext, collection?: unknown): Promise<unknown>;
-        validate(args: unknown[]): string | null;
-    };
-    static lastExpression: {
-        name: string;
-        category: "Reference";
-        evaluatesTo: "Any";
-        evaluate(context: ExecutionContext, collection?: unknown): Promise<unknown>;
-        validate(args: unknown[]): string | null;
-    };
-    static atExpression: {
-        name: string;
-        category: "Reference";
-        evaluatesTo: "Any";
-        evaluate(context: ExecutionContext, index: number, collection?: unknown): Promise<unknown>;
-        validate(args: unknown[]): string | null;
-    };
-}
-export declare class ExpressionMigrationUtility {
-    private static migrationMap;
-    static enableEnhanced(expressionName: string): void;
-    static disableEnhanced(expressionName: string): void;
-    static isEnhancedEnabled(expressionName: string): boolean;
-    static getMigrationStatus(): {
-        [k: string]: boolean;
-    };
-    static enableAllEnhanced(): void;
-    static disableAllEnhanced(): void;
-}
-export declare class PositionalUtilities {
-    static safeFirst(context: ExecutionContext, collection?: unknown, fallback?: unknown): Promise<{
-        success: boolean;
-        value: unknown;
-        error?: unknown;
-    }>;
-    static safeLast(context: ExecutionContext, collection?: unknown, fallback?: unknown): Promise<{
-        success: boolean;
-        value: unknown;
-        error?: unknown;
-    }>;
-    static safeAt(context: ExecutionContext, index: number, collection?: unknown, fallback?: unknown): Promise<{
-        success: boolean;
-        value: unknown;
-        error?: unknown;
-    }>;
-    static batchPositionalOperations(context: ExecutionContext, operations: Array<{
-        type: 'first' | 'last' | 'at';
-        collection: unknown;
-        index?: number;
-        key?: string;
-    }>): Promise<{
-        success: boolean;
-        results: Record<string, unknown>;
-        errors: Array<unknown>;
-    }>;
-    static getAvailableOperations(): {
-        first: {
-            description: string;
-            complexity: string;
-        };
-        last: {
-            description: string;
-            complexity: string;
-        };
-        at: {
-            description: string;
-            complexity: string;
-        };
-    };
-    static analyzeCollection(collection: unknown): {
-        type: string;
-        length: number;
-        isIndexable: boolean;
-        supportsNegativeIndexing: boolean;
-        metadata: Record<string, unknown>;
-    };
-}
-//# sourceMappingURL=bridge.d.ts.map

package/dist/expressions/property/index.d.ts

@@ -1,55 +0,0 @@
-import type { ValidationResult, TypedExpressionContext, EvaluationType, ExpressionMetadata, EvaluationResult, ExpressionCategory } from '../../types/base-types';
-import type { HyperScriptValue } from '../../types/command-types';
-import { BaseExpressionImpl } from '../base-expression';
-type PropertyAccessInput = any;
-type PossessiveAccessInput = any;
-type AttributeAccessInput = any;
-export declare class MyExpression extends BaseExpressionImpl<PropertyAccessInput, HyperScriptValue> {
-    readonly name = "my";
-    readonly category: ExpressionCategory;
-    readonly syntax = "my property";
-    readonly description = "Accesses properties of the current context element (me) with validation";
-    readonly inputSchema: import("../../validation/lightweight-validators").RuntimeValidator<{
-        [x: string]: unknown;
-    }>;
-    readonly outputType: EvaluationType;
-    readonly metadata: ExpressionMetadata;
-    evaluate(context: TypedExpressionContext, input: PropertyAccessInput): Promise<EvaluationResult<HyperScriptValue>>;
-    validate(input: unknown): ValidationResult;
-}
-export declare class ItsExpression extends BaseExpressionImpl<PossessiveAccessInput, HyperScriptValue> {
-    readonly name = "its";
-    readonly category: ExpressionCategory;
-    readonly syntax = "target its property";
-    readonly description = "Generic possessive property access with comprehensive validation";
-    readonly inputSchema: import("../../validation/lightweight-validators").RuntimeValidator<{
-        [x: string]: unknown;
-    }>;
-    readonly outputType: EvaluationType;
-    readonly metadata: ExpressionMetadata;
-    evaluate(context: TypedExpressionContext, input: PossessiveAccessInput): Promise<EvaluationResult<HyperScriptValue>>;
-    validate(input: unknown): ValidationResult;
-}
-export declare class AttributeExpression extends BaseExpressionImpl<AttributeAccessInput, string | null> {
-    readonly name = "attribute";
-    readonly category: ExpressionCategory;
-    readonly syntax = "@attribute or element@attribute";
-    readonly description = "Accesses HTML attributes with comprehensive DOM validation";
-    readonly inputSchema: import("../../validation/lightweight-validators").RuntimeValidator<{
-        [x: string]: unknown;
-    }>;
-    readonly outputType: EvaluationType;
-    readonly metadata: ExpressionMetadata;
-    evaluate(context: TypedExpressionContext, input: AttributeAccessInput): Promise<EvaluationResult<string | null>>;
-    validate(input: unknown): ValidationResult;
-}
-export declare function createMyExpression(): MyExpression;
-export declare function createItsExpression(): ItsExpression;
-export declare function createAttributeExpression(): AttributeExpression;
-export declare const propertyExpressions: {
-    readonly my: MyExpression;
-    readonly its: ItsExpression;
-    readonly attribute: AttributeExpression;
-};
-export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/expressions/references/impl/bridge.d.ts

@@ -1,54 +0,0 @@
-import type { ExecutionContext, TypedExpressionContext, ExpressionEvaluationOptions } from '../../../types/base-types';
-export declare function createTypedExpressionContext(context: ExecutionContext, options?: ExpressionEvaluationOptions): TypedExpressionContext;
-export declare function updateExecutionContext(originalContext: ExecutionContext, typedContext: TypedExpressionContext): ExecutionContext;
-export declare class ExpressionAdapter {
-    static evaluateMe(context: ExecutionContext): Promise<HTMLElement | null>;
-    static evaluateYou(context: ExecutionContext): Promise<HTMLElement | null>;
-    static evaluateIt(context: ExecutionContext): Promise<unknown>;
-    static evaluateCSSSelector(context: ExecutionContext, selector: string, single?: boolean): Promise<HTMLElement | HTMLElement[] | null>;
-    static getExpressionMetadata(expressionName: string): import("../../../types/expression-types").ExpressionMetadata;
-    static getExpressionDocumentation(expressionName: string): unknown;
-    static validateExpressionInput(expressionName: string, input: unknown): import("../../../types/base-types").ValidationResult<unknown>;
-}
-export declare class LegacyCompatibilityLayer {
-    static meExpression: {
-        name: string;
-        category: "Reference";
-        evaluatesTo: "Element";
-        evaluate(context: ExecutionContext): Promise<HTMLElement | null>;
-        validate(): null;
-    };
-    static youExpression: {
-        name: string;
-        category: "Reference";
-        evaluatesTo: "Element";
-        evaluate(context: ExecutionContext): Promise<HTMLElement | null>;
-        validate(): null;
-    };
-    static itExpression: {
-        name: string;
-        category: "Reference";
-        evaluatesTo: "Any";
-        evaluate(context: ExecutionContext): Promise<unknown>;
-        validate(): null;
-    };
-    static createQuerySelector(single?: boolean): {
-        name: string;
-        category: "Reference";
-        evaluatesTo: "Element" | "Array";
-        evaluate(context: ExecutionContext, selector: string): Promise<HTMLElement | HTMLElement[] | null>;
-        validate(args: any[]): string | null;
-    };
-}
-export declare class ExpressionMigrationUtility {
-    private static migrationMap;
-    static enableEnhanced(expressionName: string): void;
-    static disableEnhanced(expressionName: string): void;
-    static isEnhancedEnabled(expressionName: string): boolean;
-    static getMigrationStatus(): {
-        [k: string]: boolean;
-    };
-    static enableAllEnhanced(): void;
-    static disableAllEnhanced(): void;
-}
-//# sourceMappingURL=bridge.d.ts.map

package/dist/extensions/index.d.ts

@@ -1,3 +0,0 @@
-export { TailwindExtension, tailwindExtension } from './tailwind';
-export type { TailwindOperation, TailwindStrategy, TailwindStrategyFunction } from './tailwind';
-//# sourceMappingURL=index.d.ts.map

package/dist/extensions/tailwind.d.ts

@@ -1,22 +0,0 @@
-export type TailwindOperation = 'hide' | 'show' | 'toggle';
-export type TailwindStrategy = 'twDisplay' | 'twVisibility' | 'twOpacity';
-export interface TailwindStrategyFunction {
-    (operation: TailwindOperation, element: HTMLElement): Promise<void>;
-}
-export declare class TailwindExtension {
-    private strategies;
-    private defaultStrategy;
-    constructor();
-    getStrategies(): Record<TailwindStrategy, TailwindStrategyFunction>;
-    setDefaultStrategy(strategy: TailwindStrategy): void;
-    getDefaultStrategy(): TailwindStrategy | null;
-    resetDefaultStrategy(): void;
-    executeStrategy(strategy: TailwindStrategy, operation: TailwindOperation, element: HTMLElement): Promise<void>;
-    executeWithDefaultStrategy(operation: TailwindOperation, element: HTMLElement): Promise<void>;
-    private createDisplayStrategy;
-    private createVisibilityStrategy;
-    private createOpacityStrategy;
-}
-export declare const tailwindExtension: TailwindExtension;
-export default TailwindExtension;
-//# sourceMappingURL=tailwind.d.ts.map

package/dist/mod.d.ts

@@ -1,63 +0,0 @@
-export type { BaseTypedExpression, TypedExecutionContext, TypedResult, ValidationResult, ExecutionContext, LLMDocumentation, EvaluationType, HyperScriptValueType, BaseTypedFeature, FeatureMetadata, CommandResult, BaseCommand, } from './types/base-types';
-export type { CommandImplementation, ExpressionImplementation, } from './types/core';
-export { HideCommand, createHideCommand } from './commands/dom/hide';
-export { ShowCommand } from './commands/dom/show';
-export { ToggleCommand } from './commands/dom/toggle';
-export { AddCommand } from './commands/dom/add';
-export { RemoveCommand } from './commands/dom/remove';
-export { TriggerCommand } from './commands/events/trigger';
-export { SendCommand } from './commands/events/send';
-export { GoCommand } from './commands/navigation/go';
-export { IfCommand } from './commands/control-flow/if';
-export { RepeatCommand } from './commands/control-flow/repeat';
-export { referencesExpressions, } from './expressions/references/index';
-export { logicalExpressions, } from './expressions/logical/index';
-export { conversionExpressions, } from './expressions/conversion/index';
-export { positionalExpressions, } from './expressions/positional/index';
-export { propertiesExpressions, } from './expressions/properties/index';
-export { specialExpressions, } from './expressions/special/index';
-export { createBehaviorsFeature } from './features/behaviors';
-export { createWebWorkerFeature } from './features/webworker';
-export { TailwindExtension, type TailwindStrategy } from './extensions/tailwind';
-export { createContext } from './core/context';
-export { Parser } from './parser/parser';
-export { Tokenizer } from './parser/tokenizer';
-export { isDeno, isNode, isBrowser, getRuntimeInfo, getLLMRuntimeInfo, logger, performance, UniversalEventTarget, } from './runtime/environment';
-export declare function getEnvironmentInfo(): {
-    runtime: string;
-    hasDOM: boolean;
-    hasWebAPIs: boolean;
-    typescript: boolean;
-    version: string;
-};
-export declare function createMinimalRuntime(): {
-    commands: Map<any, any>;
-    expressions: Map<any, any>;
-    features: Map<any, any>;
-    extensions: Map<any, any>;
-    addCommand(command: any): any;
-    addExpression(expression: any): any;
-    environment: {
-        runtime: string;
-        hasDOM: boolean;
-        hasWebAPIs: boolean;
-        typescript: boolean;
-        version: string;
-    };
-};
-export declare function createFullRuntime(): {
-    commands: Map<any, any>;
-    expressions: Map<any, any>;
-    features: Map<any, any>;
-    extensions: Map<any, any>;
-    addCommand(command: any): any;
-    addExpression(expression: any): any;
-    environment: {
-        runtime: string;
-        hasDOM: boolean;
-        hasWebAPIs: boolean;
-        typescript: boolean;
-        version: string;
-    };
-};
-//# sourceMappingURL=mod.d.ts.map

package/dist/parser/expression-parser.d.ts

@@ -1,6 +0,0 @@
-import type { ExecutionContext } from '../types/base-types';
-export declare class ExpressionParseError extends Error {
-    constructor(message: string, position?: number);
-}
-export declare function parseAndEvaluateExpression(expressionString: string, context: ExecutionContext): Promise<any>;
-//# sourceMappingURL=expression-parser.d.ts.map

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

@@ -1,18 +0,0 @@
-import { RuntimeBase } from './runtime-base';
-import { CommandRegistryV2 } from './command-adapter';
-import { BaseExpressionEvaluator } from '../core/base-expression-evaluator';
-export interface RuntimeExperimentalOptions {
-    lazyLoad?: boolean;
-    expressionPreload?: 'core' | 'all' | 'common' | 'none';
-    expressionEvaluator?: BaseExpressionEvaluator;
-    registry?: CommandRegistryV2;
-    enableAsyncCommands?: boolean;
-    commandTimeout?: number;
-    enableErrorReporting?: boolean;
-}
-export declare class RuntimeExperimental extends RuntimeBase {
-    constructor(options?: RuntimeExperimentalOptions);
-}
-export declare function createRuntimeExperimental(options?: RuntimeExperimentalOptions): RuntimeExperimental;
-export declare function createMinimalRuntime(commands: any[], options?: Omit<RuntimeExperimentalOptions, 'registry'>): RuntimeExperimental;
-//# sourceMappingURL=runtime-experimental.d.ts.map

package/dist/scripts/code-generator.d.ts

@@ -1,64 +0,0 @@
-export interface LSPCommand {
-    id: string;
-    name: string;
-    description: string;
-    syntax_canonical: string;
-    example_usage: string[];
-    elementType: string;
-    tags?: string[];
-    status?: string;
-    purpose?: string;
-}
-export interface LSPFeature {
-    id: string;
-    name: string;
-    description: string;
-    syntax_canonical: string;
-    example_usage: string[];
-    elementType: string;
-    tags?: string[];
-}
-export interface ParsedCommand {
-    name: string;
-    syntax: string;
-    description: string;
-    examples: string[];
-    category: string;
-}
-export interface ParsedFeature {
-    name: string;
-    syntax: string;
-    description: string;
-    examples: string[];
-}
-export interface GeneratedCommand {
-    code: string;
-    filePath: string;
-}
-export interface GeneratedTest {
-    code: string;
-    filePath: string;
-    testCases: string[];
-}
-export interface FilePaths {
-    implementation: string;
-    test: string;
-}
-export declare class CodeGenerator {
-    private commandCategories;
-    parseCommand(data: LSPCommand): ParsedCommand;
-    parseFeature(data: LSPFeature): ParsedFeature;
-    categorizeCommand(commandName: string): string;
-    generateFilePaths(name: string, type: 'command' | 'feature'): FilePaths;
-    generateCommandInterface(data: LSPCommand): GeneratedCommand;
-    generateCommandTest(data: LSPCommand): GeneratedTest;
-    private generateTestCase;
-    loadLSPData(): {
-        commands: LSPCommand[];
-        features: LSPFeature[];
-    };
-    generateMissingCommands(): void;
-    private capitalizeFirst;
-    private escapeString;
-}
-//# sourceMappingURL=code-generator.d.ts.map

package/dist/scripts/generate-missing-commands.d.ts

@@ -1,4 +0,0 @@
-declare function generatePriorityCommands(): void;
-declare function analyzeImplementationGap(): void;
-export { generatePriorityCommands, analyzeImplementationGap };
-//# sourceMappingURL=generate-missing-commands.d.ts.map