@hyperfixi/core 2.3.0 → 2.4.0

package/dist/commands/navigation/go.d.ts

@@ -18,6 +18,9 @@ export declare class GoCommand implements DecoratedCommand {
     }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<GoCommandInput>;
     execute(input: GoCommandInput, context: TypedExecutionContext): Promise<GoCommandOutput>;
     private isUrlNavigation;
+    private isBareUrl;
+    private findBareUrl;
+    private navigateToBareUrl;
     private goBack;
     private navigateToUrl;
     private isValidUrl;

package/dist/commands/navigation/scroll-to.d.ts

@@ -0,0 +1,26 @@
+import type { ExecutionContext, TypedExecutionContext } from '../../types/core';
+import type { ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface ScrollCommandInput {
+    args: unknown[];
+}
+export interface ScrollCommandOutput {
+    element: HTMLElement;
+    position: ScrollLogicalPosition;
+    smooth: boolean;
+}
+export declare class ScrollCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<ScrollCommandInput>;
+    execute(input: ScrollCommandInput, context: TypedExecutionContext): Promise<ScrollCommandOutput>;
+    private parsePosition;
+    private resolveTarget;
+}
+export declare const createScrollCommand: () => ScrollCommand;
+export default ScrollCommand;
+//# sourceMappingURL=scroll-to.d.ts.map

package/dist/commands/utility/beep.d.ts

@@ -3,13 +3,13 @@ import type { ASTNode, ExpressionNode } from '../../types/base-types';
 import type { ExpressionEvaluator } from '../../core/expression-evaluator';
 import { type DecoratedCommand, type CommandMetadata } from '../decorators';
 export interface BeepCommandInput {
-    expressions?: any[];
+    expressions?: unknown[];
 }
 export interface BeepCommandOutput {
     expressionCount: number;
     debugged: boolean;
     outputs: Array<{
-        value: any;
+        value: unknown;
         type: string;
         representation: string;
     }>;

package/dist/commands/utility/breakpoint.d.ts

@@ -0,0 +1,19 @@
+import type { ExecutionContext, TypedExecutionContext, ASTNode, ExpressionNode } from '../../types/base-types';
+import type { ExpressionEvaluator } from '../../core/expression-evaluator';
+import { type DecoratedCommand, type CommandMetadata } from '../decorators';
+export interface BreakpointCommandInput {
+    _tag?: 'breakpoint';
+}
+export declare class BreakpointCommand implements DecoratedCommand {
+    readonly name: string;
+    readonly metadata: CommandMetadata;
+    parseInput(_raw: {
+        args: ASTNode[];
+        modifiers: Record<string, ExpressionNode>;
+    }, _evaluator: ExpressionEvaluator, _context: ExecutionContext): Promise<BreakpointCommandInput>;
+    execute(_input: BreakpointCommandInput, _context: TypedExecutionContext): Promise<void>;
+    validate(input: unknown): input is BreakpointCommandInput;
+}
+export declare const createBreakpointCommand: () => BreakpointCommand;
+export default BreakpointCommand;
+//# sourceMappingURL=breakpoint.d.ts.map

package/dist/commands/utility/pick.d.ts

@@ -3,14 +3,23 @@ import type { ASTNode, ExpressionNode } from '../../types/base-types';
 import type { ExpressionEvaluator } from '../../core/expression-evaluator';
 import { type DecoratedCommand, type CommandMetadata } from '../decorators';
 export interface PickCommandInput {
+    variant?: 'first' | 'last' | 'random' | 'range' | 'match' | 'matches';
     items?: unknown[];
     array?: unknown[];
+    count?: number;
+    rangeStart?: number | 'start';
+    rangeEnd?: number | 'end';
+    rangeMode?: 'default' | 'inclusive' | 'exclusive';
+    source?: string;
+    regex?: string;
+    flags?: string;
 }
 export interface PickCommandOutput {
     selectedItem: unknown;
-    selectedIndex: number;
+    selectedIndex?: number;
     sourceLength: number;
-    sourceType: 'items' | 'array';
+    sourceType: 'items' | 'array' | 'string';
+    variant: PickCommandInput['variant'];
 }
 export declare class PickCommand implements DecoratedCommand {
     readonly name: string;

package/dist/compatibility/browser-bundle-modular.d.ts

@@ -1,5 +1,5 @@
 import { createRuntime, type LokaScriptRuntime } from '../runtime/runtime-factory';
-import { ConfigurableExpressionEvaluator } from '../core/configurable-expression-evaluator';
+import { createExpressionRegistry } from '../core/expression-registry';
 declare const hyperfixi: LokaScriptRuntime;
 declare const api: {
     version: string;
@@ -14,5 +14,5 @@ declare const api: {
 };
 declare function processElements(root?: Element | Document): void;
 export default api;
-export { hyperfixi, api, processElements, createRuntime, ConfigurableExpressionEvaluator, };
+export { hyperfixi, api, processElements, createRuntime, createExpressionRegistry, };
 //# sourceMappingURL=browser-bundle-modular.d.ts.map

package/dist/compatibility/browser-bundle-multilingual.d.ts

@@ -6,7 +6,7 @@ declare const api: {
     translate(code: string, sourceLang: string, targetLang: string): string;
     getAllTranslations(code: string, sourceLang: string): Record<string, string>;
     createContext: typeof createContext;
-    runtime: import("../runtime/runtime-experimental").RuntimeExperimental;
+    runtime: import("..").RuntimeBase;
     version: string;
     commands: readonly ["hide", "show", "add", "remove", "toggle", "put", "make", "wait", "fetch", "set", "get", "increment", "decrement", "default", "trigger", "send", "go", "if", "repeat", "break", "continue", "halt", "return", "exit", "unless", "throw", "call", "pseudo-command", "append", "transition", "measure", "settle", "take", "js", "async", "log", "tell", "copy", "pick", "beep", "install", "render"];
     supportedLanguages: readonly ["en", "ja", "ar", "es", "ko", "zh", "tr", "pt", "fr", "de", "id", "qu", "sw"];

package/dist/compatibility/browser-bundle-semantic-complete.d.ts

@@ -1,6 +1,6 @@
 import { createContext } from '../core/context';
 import type { ASTNode } from '../types/base-types';
-import { getSupportedLanguages } from '@lokascript/semantic';
+import { parseSemantic, getSupportedLanguages } from '@lokascript/semantic';
 declare const api: {
     execute(code: string, lang: string, context?: any): Promise<any>;
     parse(code: string, lang: string): ASTNode | null;
@@ -10,8 +10,8 @@ declare const api: {
     isLanguageSupported(lang: string): boolean;
     getTokenizer(lang: string): import("@lokascript/semantic").LanguageTokenizer | undefined;
     createContext: typeof createContext;
-    runtime: import("../runtime/runtime-experimental").RuntimeExperimental;
-    analyzer: import("@lokascript/semantic").SemanticAnalyzer;
+    runtime: import("..").RuntimeBase;
+    parseSemantic: typeof parseSemantic;
     version: string;
     semanticVersion: string;
     commands: readonly ["hide", "show", "add", "remove", "toggle", "put", "make", "wait", "fetch", "set", "get", "increment", "decrement", "default", "trigger", "send", "go", "if", "repeat", "break", "continue", "halt", "return", "exit", "unless", "throw", "call", "pseudo-command", "append", "transition", "measure", "settle", "take", "js", "async", "log", "tell", "copy", "pick", "beep", "install", "render"];

package/dist/compatibility/browser-bundle.d.ts

@@ -2,22 +2,22 @@ import { evalHyperScript, evalHyperScriptAsync, evalHyperScriptSmart } from './e
 import { hyperscript, config } from '../api/lokascript-api';
 import type { RuntimeHooks } from '../types/hooks';
 import { defaultAttributeProcessor } from '../dom/attribute-processor';
-import { tailwindExtension } from '../extensions/tailwind';
 import { Parser } from '../parser/parser';
 import { Runtime } from '../runtime/runtime';
 import { tokenize } from '../parser/tokenizer';
 import { debug, debugControl } from '../utils/debug';
 import { styleBatcher, ObjectPool } from '../utils/performance';
 import { enableDebugEvents, disableDebugEvents, isDebugEnabled, getDebugStats, resetDebugStats, getEventHistory, replayEvents } from '../utils/debug-events';
-import { createSemanticAnalyzer, parse as semanticParse, translate, render, toExplicit, fromExplicit } from '@lokascript/semantic';
+import { parseSemantic, parse as semanticParse, translate, render, toExplicit, fromExplicit } from '@lokascript/semantic';
 import type { LokaScriptRegistry } from '../registry';
 import { registerFetchResponseType } from '../commands/async/fetch';
+import { installPlugin } from '../runtime/plugin';
+import { getParserExtensionRegistry } from '../parser/extensions';
 import type { CompileResult, NewCompileOptions } from '../api/hyperscript-api';
 interface HyperFixiBrowserAPI {
     evalHyperScript: typeof evalHyperScript;
     evalHyperScriptAsync: typeof evalHyperScriptAsync;
     evalHyperScriptSmart: typeof evalHyperScriptSmart;
-    tailwindExtension: typeof tailwindExtension;
     compile: (code: string, options?: NewCompileOptions) => CompileResult;
     compileSync: (code: string, options?: NewCompileOptions) => CompileResult;
     compileMultilingual: (code: string, language: string) => Promise<CompileResult>;
@@ -30,13 +30,15 @@ interface HyperFixiBrowserAPI {
     Parser: typeof Parser;
     Runtime: typeof Runtime;
     tokenize: typeof tokenize;
+    installPlugin: typeof installPlugin;
+    getParserExtensionRegistry: typeof getParserExtensionRegistry;
     attributeProcessor: typeof defaultAttributeProcessor;
     debug: typeof debug;
     debugControl: typeof debugControl;
     styleBatcher: typeof styleBatcher;
     ObjectPool: typeof ObjectPool;
     semantic: {
-        createAnalyzer: typeof createSemanticAnalyzer;
+        parseSemantic: typeof parseSemantic;
         parse: typeof semanticParse;
         translate: typeof translate;
         render: typeof render;
@@ -57,8 +59,10 @@ interface HyperFixiBrowserAPI {
     registerHooks: (name: string, hooks: RuntimeHooks) => void;
     unregisterHooks: (name: string) => boolean;
     getRegisteredHooks: () => string[];
+    getDefaultRuntime: typeof hyperscript.getDefaultRuntime;
     registry: LokaScriptRegistry;
     registerFetchResponseType: typeof registerFetchResponseType;
+    evalLSENode(node: import('@lokascript/framework').SemanticNode, element?: Element): Promise<unknown>;
 }
 declare global {
     interface Window {
@@ -84,10 +88,11 @@ declare const hyperfixiAPI: {
     Parser: typeof Parser;
     Runtime: typeof Runtime;
     tokenize: typeof tokenize;
+    installPlugin: typeof installPlugin;
+    getParserExtensionRegistry: typeof getParserExtensionRegistry;
     processNode: (element: Element | Document) => Promise<void>;
     process: (element: Element | Document) => Promise<void>;
     attributeProcessor: import("../dom/attribute-processor").AttributeProcessor;
-    tailwindExtension: import("../extensions/tailwind").TailwindExtension;
     styleBatcher: import("../utils/performance").StyleBatcher;
     ObjectPool: typeof ObjectPool;
     debug: {
@@ -111,7 +116,7 @@ declare const hyperfixiAPI: {
         };
     };
     semantic: {
-        createAnalyzer: typeof createSemanticAnalyzer;
+        parseSemantic: typeof parseSemantic;
         parse: typeof semanticParse;
         translate: typeof translate;
         render: typeof render;
@@ -132,8 +137,10 @@ declare const hyperfixiAPI: {
     registerHooks: (name: string, hooks: RuntimeHooks) => void;
     unregisterHooks: (name: string) => boolean;
     getRegisteredHooks: () => string[];
+    getDefaultRuntime: () => Runtime;
     registry: LokaScriptRegistry;
     registerFetchResponseType: typeof registerFetchResponseType;
+    evalLSENode: (node: import("@lokascript/framework").SemanticNode, element?: Element) => Promise<unknown>;
     version: string;
 };
 export default hyperfixiAPI;

package/dist/compatibility/browser-modular.d.ts

@@ -1,7 +1,6 @@
 import { evalHyperScript, evalHyperScriptAsync, evalHyperScriptSmart } from './eval-hyperscript';
 import { hyperscript } from '../api/hyperscript-api';
 import { defaultAttributeProcessor } from '../dom/attribute-processor';
-import { tailwindExtension } from '../extensions/tailwind';
 import { Parser } from '../parser/parser';
 import { Runtime } from '../runtime/runtime';
 import { tokenize } from '../parser/tokenizer';
@@ -24,7 +23,6 @@ declare const hyperfixi: {
     processNode: (element: Element | Document) => Promise<void>;
     process: (element: Element | Document) => Promise<void>;
     attributeProcessor: import("../dom/attribute-processor").AttributeProcessor;
-    tailwindExtension: import("../extensions/tailwind").TailwindExtension;
     styleBatcher: import("../utils/performance").StyleBatcher;
     ObjectPool: typeof ObjectPool;
     debug: {
@@ -48,6 +46,6 @@ declare const hyperfixi: {
     };
     version: string;
 };
-export { evalHyperScript, evalHyperScriptAsync, evalHyperScriptSmart, hyperscript, Parser, Runtime, tokenize, defaultAttributeProcessor, tailwindExtension, debug, styleBatcher, ObjectPool, preloadDocumentFeatures, loadRequiredFeatures, detectFeatures, isFeatureLoaded, getLoadedFeatures, preloadFeatures, };
+export { evalHyperScript, evalHyperScriptAsync, evalHyperScriptSmart, hyperscript, Parser, Runtime, tokenize, defaultAttributeProcessor, debug, styleBatcher, ObjectPool, preloadDocumentFeatures, loadRequiredFeatures, detectFeatures, isFeatureLoaded, getLoadedFeatures, preloadFeatures, };
 export default hyperfixi;
 //# sourceMappingURL=browser-modular.d.ts.map

package/dist/core/expression-evaluator.d.ts

@@ -1,6 +1,6 @@
-import { BaseExpressionEvaluator } from './base-expression-evaluator';
-export declare class ExpressionEvaluator extends BaseExpressionEvaluator {
-    constructor();
-    private registerExpressions;
+import type { ASTNode } from '../types/base-types';
+import type { ExecutionContext } from '../types/core';
+export interface ExpressionEvaluator {
+    evaluate(node: ASTNode, context: ExecutionContext): Promise<any>;
 }
 //# sourceMappingURL=expression-evaluator.d.ts.map

package/dist/core/expression-registry.d.ts

@@ -0,0 +1,8 @@
+import type { ExpressionImplementation } from '../types/core';
+export type ExpressionRegistry = ReadonlyMap<string, ExpressionImplementation>;
+interface ExpressionLike {
+    evaluate: (...args: any[]) => any;
+}
+export declare function createExpressionRegistry(...categories: ReadonlyArray<Readonly<Record<string, ExpressionLike>>>): ExpressionRegistry;
+export {};
+//# sourceMappingURL=expression-registry.d.ts.map

package/dist/expressions/bundles/common-expressions.d.ts

@@ -1,9 +1,9 @@
-import { ConfigurableExpressionEvaluator } from '../../core/configurable-expression-evaluator';
+import type { ExpressionRegistry } from '../../core/expression-registry';
 import { referencesExpressions } from '../references/index';
 import { logicalExpressions } from '../logical/index';
 import { specialExpressions } from '../special/index';
 import { conversionExpressions } from '../conversion/index';
 import { positionalExpressions } from '../positional/index';
-export declare function createCommonExpressionEvaluator(): ConfigurableExpressionEvaluator;
+export declare function createCommonRegistry(): ExpressionRegistry;
 export { referencesExpressions, logicalExpressions, specialExpressions, conversionExpressions, positionalExpressions, };
 //# sourceMappingURL=common-expressions.d.ts.map

package/dist/expressions/bundles/core-expressions.d.ts

@@ -1,7 +1,7 @@
-import { ConfigurableExpressionEvaluator } from '../../core/configurable-expression-evaluator';
+import type { ExpressionRegistry } from '../../core/expression-registry';
 import { referencesExpressions } from '../references/index';
 import { logicalExpressions } from '../logical/index';
 import { specialExpressions } from '../special/index';
-export declare function createCoreExpressionEvaluator(): ConfigurableExpressionEvaluator;
+export declare function createCoreRegistry(): ExpressionRegistry;
 export { referencesExpressions, logicalExpressions, specialExpressions };
 //# sourceMappingURL=core-expressions.d.ts.map

package/dist/expressions/bundles/full-expressions.d.ts

@@ -1,10 +1,10 @@
-import { ConfigurableExpressionEvaluator } from '../../core/configurable-expression-evaluator';
+import type { ExpressionRegistry } from '../../core/expression-registry';
 import { referencesExpressions } from '../references/index';
 import { logicalExpressions } from '../logical/index';
 import { specialExpressions } from '../special/index';
 import { conversionExpressions } from '../conversion/index';
 import { positionalExpressions } from '../positional/index';
 import { propertiesExpressions } from '../properties/index';
-export declare function createFullExpressionEvaluator(): ConfigurableExpressionEvaluator;
+export declare function createFullRegistry(): ExpressionRegistry;
 export { referencesExpressions, logicalExpressions, specialExpressions, conversionExpressions, positionalExpressions, propertiesExpressions, };
 //# sourceMappingURL=full-expressions.d.ts.map

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

@@ -1,6 +1,6 @@
-export { createCoreExpressionEvaluator } from './core-expressions';
-export { createCommonExpressionEvaluator } from './common-expressions';
-export { createFullExpressionEvaluator } from './full-expressions';
+export { createCoreRegistry } from './core-expressions';
+export { createCommonRegistry } from './common-expressions';
+export { createFullRegistry } from './full-expressions';
 export { referencesExpressions, logicalExpressions, specialExpressions } from './core-expressions';
 export { conversionExpressions, positionalExpressions } from './common-expressions';
 export { propertiesExpressions } from './full-expressions';

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

@@ -0,0 +1,35 @@
+import type { ExpressionImplementation } from '../../types/core';
+import type { ASTNode } from '../../types/base-types';
+export type CollectionOperator = 'where' | 'sorted by' | 'mapped to' | 'split by' | 'joined by';
+export type SortOrder = 'asc' | 'desc';
+export interface CollectionExpressionNode {
+    type: 'collectionExpression';
+    operator: CollectionOperator;
+    collection: ASTNode;
+    right: ASTNode;
+    order?: SortOrder;
+    start?: number;
+    end?: number;
+    line?: number;
+    column?: number;
+}
+export declare function toIterableArray(value: unknown): unknown[];
+export declare function evaluateWhere(collection: unknown, predicate: ASTNode, evalWithIt: (node: ASTNode, it: unknown) => Promise<unknown>): Promise<unknown[]>;
+export declare function evaluateSortedBy(collection: unknown, keyExpr: ASTNode, order: SortOrder, evalWithIt: (node: ASTNode, it: unknown) => Promise<unknown>): Promise<unknown[]>;
+export declare function evaluateMappedTo(collection: unknown, expr: ASTNode, evalWithIt: (node: ASTNode, it: unknown) => Promise<unknown>): Promise<unknown[]>;
+export declare function evaluateSplitBy(value: unknown, separator: unknown): string[];
+export declare function evaluateJoinedBy(value: unknown, separator: unknown): string;
+export declare const whereExpression: ExpressionImplementation;
+export declare const sortedByExpression: ExpressionImplementation;
+export declare const mappedToExpression: ExpressionImplementation;
+export declare const splitByExpression: ExpressionImplementation;
+export declare const joinedByExpression: ExpressionImplementation;
+export declare const collectionExpressions: {
+    readonly where: ExpressionImplementation;
+    readonly sortedBy: ExpressionImplementation;
+    readonly mappedTo: ExpressionImplementation;
+    readonly splitBy: ExpressionImplementation;
+    readonly joinedBy: ExpressionImplementation;
+};
+export type CollectionExpressionName = keyof typeof collectionExpressions;
+//# sourceMappingURL=index.d.ts.map

package/dist/expressions/conversion/impl/index.d.ts

@@ -2,7 +2,7 @@ import { type RuntimeValidator } from '../../../validation/lightweight-validator
 import type { TypedExpressionContext, EvaluationResult, ExpressionMetadata, BaseTypedExpression, ValidationResult, EvaluationType } from '../../../types/base-types';
 import type { ExpressionCategory, LLMDocumentation } from '../../../types/expression-types';
 import { BaseExpressionImpl } from '../../base-expression';
-export type SupportedConversionType = 'Array' | 'Boolean' | 'Date' | 'Float' | 'Fragment' | 'HTML' | 'Int' | 'JSON' | 'Number' | 'Object' | 'String' | 'Values' | 'Values:Form' | 'Values:JSON' | `Fixed:${number}` | string;
+export type SupportedConversionType = 'Array' | 'Boolean' | 'Date' | 'Float' | 'Fragment' | 'FormEncoded' | 'HTML' | 'Int' | 'JSON' | 'JSONString' | 'Number' | 'Object' | 'String' | 'Values' | 'Values:Form' | 'Values:JSON' | `Fixed:${number}` | string;
 export interface EnhancedTypeConverter<T = unknown> {
     (value: unknown, context: TypedExpressionContext): EvaluationResult<T>;
 }

package/dist/expressions/index.d.ts

@@ -4,8 +4,9 @@ export { specialExpressions as special } from './bundles/core-expressions';
 export { conversionExpressions as conversion } from './bundles/common-expressions';
 export { positionalExpressions as positional } from './bundles/common-expressions';
 export { propertiesExpressions as properties } from './bundles/full-expressions';
-export { createCoreExpressionEvaluator, createCommonExpressionEvaluator, createFullExpressionEvaluator, } from './bundles';
-export { ConfigurableExpressionEvaluator } from '../core/configurable-expression-evaluator';
-export { BaseExpressionEvaluator } from '../core/base-expression-evaluator';
+export { createCoreRegistry, createCommonRegistry, createFullRegistry } from './bundles';
+export declare function createFullExpressionRegistry(): import("../core/expression-registry").ExpressionRegistry;
+export { createExpressionRegistry } from '../core/expression-registry';
+export type { ExpressionRegistry } from '../core/expression-registry';
 export * from './bundles';
 //# sourceMappingURL=index.d.ts.map