@hyperfixi/core 2.0.0

package/dist/parser/regex-parser.mjs

@@ -0,0 +1,409 @@
+function parseLite(code) {
+    const trimmed = code.trim();
+    const onMatch = trimmed.match(/^on\s+(\w+)(?:\s+from\s+([^\s]+))?\s+(.+)$/i);
+    if (onMatch) {
+        return {
+            event: onMatch[1],
+            filter: onMatch[2],
+            commands: parseCommands(onMatch[3]),
+        };
+    }
+    const everyMatch = trimmed.match(/^every\s+(\d+)(ms|s)?\s+(.+)$/i);
+    if (everyMatch) {
+        const ms = everyMatch[2] === 's' ? parseInt(everyMatch[1]) * 1000 : parseInt(everyMatch[1]);
+        return {
+            event: `interval:${ms}`,
+            commands: parseCommands(everyMatch[3]),
+        };
+    }
+    const initMatch = trimmed.match(/^init\s+(.+)$/i);
+    if (initMatch) {
+        return {
+            event: 'init',
+            commands: parseCommands(initMatch[1]),
+        };
+    }
+    return parseCommands(trimmed);
+}
+function parseCommands(code) {
+    const parts = code.split(/\s+(?:then|and)\s+/i);
+    return parts.map(parseCommand).filter(Boolean);
+}
+function parseCommand(code) {
+    const trimmed = code.trim();
+    if (!trimmed)
+        return null;
+    let match = trimmed.match(/^toggle\s+(\.\w+|\w+)(?:\s+on\s+(.+))?$/i);
+    if (match) {
+        return { name: 'toggle', args: [match[1]], target: match[2] };
+    }
+    match = trimmed.match(/^add\s+(\.\w+|\w+)(?:\s+to\s+(.+))?$/i);
+    if (match) {
+        return { name: 'add', args: [match[1]], target: match[2] };
+    }
+    match = trimmed.match(/^remove\s+(\.\w+)(?:\s+from\s+(.+))?$/i);
+    if (match) {
+        return { name: 'remove', args: [match[1]], target: match[2] };
+    }
+    match = trimmed.match(/^remove\s+(.+)$/i);
+    if (match) {
+        return { name: 'remove', args: [], target: match[1] };
+    }
+    match = trimmed.match(/^put\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s+(into|before|after)\s+(.+)$/i);
+    if (match) {
+        const content = match[1] || match[2] || match[3];
+        return { name: 'put', args: [content], modifier: match[4], target: match[5] };
+    }
+    match = trimmed.match(/^set\s+(.+?)\s+to\s+(.+)$/i);
+    if (match) {
+        return { name: 'set', args: [match[1], match[2]] };
+    }
+    match = trimmed.match(/^log\s+(.+)$/i);
+    if (match) {
+        return { name: 'log', args: [match[1]] };
+    }
+    match = trimmed.match(/^send\s+(\w+)(?:\s+to\s+(.+))?$/i);
+    if (match) {
+        return { name: 'send', args: [match[1]], target: match[2] };
+    }
+    match = trimmed.match(/^wait\s+(\d+)(ms|s)?$/i);
+    if (match) {
+        const ms = match[2] === 's' ? parseInt(match[1]) * 1000 : parseInt(match[1]);
+        return { name: 'wait', args: [ms.toString()] };
+    }
+    match = trimmed.match(/^(if|unless)\s+(.+?)\s+(toggle|add|remove|put|set|log|send|wait)\s+(.+)$/i);
+    if (match) {
+        const innerCmd = parseCommand(`${match[3]} ${match[4]}`);
+        if (innerCmd) {
+            innerCmd.modifier = match[1].toLowerCase();
+            innerCmd.args.unshift(match[2]);
+            return innerCmd;
+        }
+    }
+    match = trimmed.match(/^(show|hide)(?:\s+(.+))?$/i);
+    if (match) {
+        const target = match[2];
+        return match[1].toLowerCase() === 'show'
+            ? { name: 'remove', args: ['.hidden'], target }
+            : { name: 'add', args: ['.hidden'], target };
+    }
+    const parts = trimmed.split(/\s+/);
+    if (parts.length > 0) {
+        return { name: parts[0], args: parts.slice(1) };
+    }
+    return null;
+}
+function resolveTarget(target, me) {
+    if (!target)
+        return me;
+    const t = target.trim();
+    if (t === 'me')
+        return me;
+    if (t === 'body')
+        return document.body;
+    if (t.startsWith('#') || t.startsWith('.') || t.startsWith('[')) {
+        const elements = document.querySelectorAll(t);
+        return elements.length === 1 ? elements[0] : Array.from(elements);
+    }
+    if (/^\w+$/.test(t) && document.getElementById(t)) {
+        return document.getElementById(t);
+    }
+    return me;
+}
+function getClassName(arg) {
+    return arg.startsWith('.') ? arg.slice(1) : arg;
+}
+async function executeCommand(cmd, me, locals) {
+    const target = resolveTarget(cmd.target, me);
+    const elements = Array.isArray(target) ? target : target ? [target] : [me];
+    switch (cmd.name) {
+        case 'toggle': {
+            const className = getClassName(cmd.args[0]);
+            for (const el of elements) {
+                el.classList.toggle(className);
+            }
+            return elements.length === 1 ? elements[0] : elements;
+        }
+        case 'add': {
+            const className = getClassName(cmd.args[0]);
+            for (const el of elements) {
+                el.classList.add(className);
+            }
+            return elements.length === 1 ? elements[0] : elements;
+        }
+        case 'remove': {
+            if (cmd.args[0]) {
+                const className = getClassName(cmd.args[0]);
+                for (const el of elements) {
+                    el.classList.remove(className);
+                }
+            }
+            else {
+                for (const el of elements) {
+                    el.remove();
+                }
+            }
+            return null;
+        }
+        case 'put': {
+            const content = evaluateValue(cmd.args[0], me, locals);
+            for (const el of elements) {
+                switch (cmd.modifier?.toLowerCase()) {
+                    case 'into':
+                        el.innerHTML = String(content);
+                        break;
+                    case 'before':
+                        el.insertAdjacentHTML('beforebegin', String(content));
+                        break;
+                    case 'after':
+                        el.insertAdjacentHTML('afterend', String(content));
+                        break;
+                    default:
+                        el.innerHTML = String(content);
+                }
+            }
+            return elements.length === 1 ? elements[0] : elements;
+        }
+        case 'set': {
+            const [targetExpr, valueExpr] = cmd.args;
+            const value = evaluateValue(valueExpr, me, locals);
+            if (targetExpr.startsWith(':')) {
+                locals.set(targetExpr.slice(1), value);
+                return value;
+            }
+            const propMatch = targetExpr.match(/^(.+?)(?:'s|\.)\s*(\w+)$/);
+            if (propMatch) {
+                const obj = resolveTarget(propMatch[1], me);
+                if (obj) {
+                    obj[propMatch[2]] = value;
+                    return obj;
+                }
+            }
+            return value;
+        }
+        case 'log': {
+            const value = evaluateValue(cmd.args.join(' '), me, locals);
+            console.log(value);
+            return value;
+        }
+        case 'send': {
+            const eventName = cmd.args[0];
+            const event = new CustomEvent(eventName, { bubbles: true });
+            for (const el of elements) {
+                el.dispatchEvent(event);
+            }
+            return event;
+        }
+        case 'wait': {
+            const ms = parseInt(cmd.args[0]) || 0;
+            await new Promise(resolve => setTimeout(resolve, ms));
+            return ms;
+        }
+        default:
+            console.warn(`Unknown command: ${cmd.name}`);
+            return null;
+    }
+}
+function evaluateValue(expr, me, locals) {
+    if (!expr)
+        return undefined;
+    const e = expr.trim();
+    if ((e.startsWith('"') && e.endsWith('"')) || (e.startsWith("'") && e.endsWith("'"))) {
+        return e.slice(1, -1);
+    }
+    if (/^-?\d+(\.\d+)?$/.test(e)) {
+        return parseFloat(e);
+    }
+    if (e === 'true')
+        return true;
+    if (e === 'false')
+        return false;
+    if (e === 'null')
+        return null;
+    if (e.startsWith(':')) {
+        return locals.get(e.slice(1));
+    }
+    if (e === 'me')
+        return me;
+    if (e === 'my')
+        return me;
+    if (e === 'body')
+        return document.body;
+    const propMatch = e.match(/^(me|my)\.(\w+)$/);
+    if (propMatch) {
+        return me[propMatch[2]];
+    }
+    return e;
+}
+async function executeParsed(parsed, me, locals = new Map()) {
+    if (Array.isArray(parsed)) {
+        let result;
+        for (const cmd of parsed) {
+            if (cmd.modifier === 'if' || cmd.modifier === 'unless') {
+                const condition = evaluateCondition(cmd.args[0], me, locals);
+                const shouldRun = cmd.modifier === 'if' ? condition : !condition;
+                if (!shouldRun)
+                    continue;
+                cmd.args.shift();
+            }
+            result = await executeCommand(cmd, me, locals);
+        }
+        return result;
+    }
+    const handler = parsed;
+    const targetEl = handler.filter ? document.querySelector(handler.filter) : me;
+    const eventName = handler.event;
+    if (eventName.startsWith('interval:')) {
+        const ms = parseInt(eventName.split(':')[1]);
+        setInterval(async () => {
+            const handlerLocals = new Map(locals);
+            for (const cmd of handler.commands) {
+                await executeCommand(cmd, me, handlerLocals);
+            }
+        }, ms);
+        return me;
+    }
+    if (eventName === 'init') {
+        const handlerLocals = new Map(locals);
+        for (const cmd of handler.commands) {
+            await executeCommand(cmd, me, handlerLocals);
+        }
+        return me;
+    }
+    if (targetEl) {
+        targetEl.addEventListener(eventName, async (event) => {
+            const handlerLocals = new Map(locals);
+            handlerLocals.set('event', event);
+            for (const cmd of handler.commands) {
+                await executeCommand(cmd, me, handlerLocals);
+            }
+        });
+    }
+    return me;
+}
+function evaluateCondition(expr, me, locals) {
+    const e = expr.trim();
+    const hasMatch = e.match(/^(me|my)\s+has\s+\.(\w+)$/i);
+    if (hasMatch) {
+        return me.classList.contains(hasMatch[2]);
+    }
+    const propMatch = e.match(/^(me|my)\.(\w+)$/i);
+    if (propMatch) {
+        return Boolean(me[propMatch[2]]);
+    }
+    if (e.startsWith(':')) {
+        return Boolean(locals.get(e.slice(1)));
+    }
+    const value = evaluateValue(e, me, locals);
+    return Boolean(value);
+}
+function processElements(root = document) {
+    const elements = root.querySelectorAll('[_]');
+    for (const el of elements) {
+        const code = el.getAttribute('_');
+        if (code) {
+            try {
+                const parsed = parseLite(code);
+                executeParsed(parsed, el);
+            }
+            catch (err) {
+                console.error('HyperFixi Lite error:', err, 'Code:', code);
+            }
+        }
+    }
+}
+const api = {
+    version: '1.0.0-lite',
+    parse: parseLite,
+    execute: async (code, element) => {
+        const me = element || document.body;
+        const parsed = parseLite(code);
+        return executeParsed(parsed, me);
+    },
+    init: processElements,
+    process: processElements,
+    commands: ['add', 'remove', 'toggle', 'put', 'set', 'log', 'send', 'wait'],
+};
+if (typeof window !== 'undefined') {
+    window.hyperfixi = api;
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', () => processElements());
+    }
+    else {
+        processElements();
+    }
+}
+
+class RegexParserImpl {
+    constructor() {
+        this.name = 'regex';
+        this.supportedCommands = [
+            'add',
+            'remove',
+            'toggle',
+            'put',
+            'set',
+            'log',
+            'send',
+            'wait',
+        ];
+    }
+    parse(code) {
+        const result = api.parse(code);
+        if ('event' in result) {
+            return {
+                type: 'eventHandler',
+                event: result.event,
+                filter: result.filter,
+                commands: result.commands.map(cmd => this.convertCommand(cmd)),
+            };
+        }
+        if (Array.isArray(result)) {
+            if (result.length === 1) {
+                return this.convertCommand(result[0]);
+            }
+            return {
+                type: 'sequence',
+                commands: result.map(cmd => this.convertCommand(cmd)),
+            };
+        }
+        return this.convertCommand(result);
+    }
+    convertCommand(cmd) {
+        return {
+            type: 'command',
+            name: cmd.name,
+            args: cmd.args.map(arg => ({
+                type: 'literal',
+                value: arg,
+            })),
+            ...(cmd.target && {
+                target: {
+                    type: 'selector',
+                    value: cmd.target,
+                },
+            }),
+        };
+    }
+    parseCommands(code) {
+        const result = this.parse(code);
+        if (result.type === 'sequence' && 'commands' in result) {
+            return result.commands;
+        }
+        return [result];
+    }
+    supports(syntax) {
+        const firstWord = syntax.trim().split(/\s+/)[0]?.toLowerCase();
+        if (firstWord === 'on' || firstWord === 'every' || firstWord === 'init') {
+            return true;
+        }
+        return this.supportedCommands.includes(firstWord);
+    }
+}
+const regexParser = new RegexParserImpl();
+function createRegexParser() {
+    return new RegexParserImpl();
+}
+
+export { createRegexParser, regexParser };
+//# sourceMappingURL=regex-parser.mjs.map

package/dist/parser/runtime.d.ts

@@ -0,0 +1,3 @@
+import type { ASTNode, ExecutionContext } from '../types/core';
+export declare function evaluateAST(node: ASTNode, context: ExecutionContext): Promise<any>;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/parser/semantic-integration.d.ts

@@ -0,0 +1,61 @@
+import type { CommandNode } from '../types/core';
+export type SemanticValueType = 'literal' | 'selector' | 'reference' | 'property-path' | 'expression';
+export interface SemanticValue {
+    readonly type: SemanticValueType;
+    readonly value: string;
+    readonly raw?: string;
+}
+export type SemanticRole = 'patient' | 'destination' | 'source' | 'event' | 'condition' | 'quantity' | 'duration' | 'method' | 'responseType' | 'style' | 'loopType';
+export interface SemanticAnalysisResult {
+    readonly confidence: number;
+    readonly command?: {
+        readonly name: string;
+        readonly roles: ReadonlyMap<SemanticRole, SemanticValue>;
+    };
+    readonly errors?: string[];
+    readonly tokensConsumed?: number;
+}
+export interface SemanticAnalyzer {
+    analyze(input: string, language: string): SemanticAnalysisResult;
+    supportsLanguage(language: string): boolean;
+    supportedLanguages(): string[];
+}
+export declare const DEFAULT_CONFIDENCE_THRESHOLD = 0.5;
+export declare const HIGH_CONFIDENCE_THRESHOLD = 0.8;
+export interface SemanticIntegrationOptions {
+    analyzer: SemanticAnalyzer;
+    language: string;
+    confidenceThreshold?: number;
+    debug?: boolean;
+}
+export interface SemanticParseAttempt {
+    success: boolean;
+    node?: CommandNode;
+    confidence: number;
+    tokensConsumed?: number;
+    errors?: string[];
+}
+export declare class SemanticIntegrationAdapter {
+    private readonly analyzer;
+    private readonly language;
+    private readonly confidenceThreshold;
+    private readonly debugEnabled;
+    constructor(options: SemanticIntegrationOptions);
+    isAvailable(): boolean;
+    private static readonly SKIP_SEMANTIC_COMMANDS;
+    private shouldSkipSemantic;
+    trySemanticParse(input: string): SemanticParseAttempt;
+    private buildCommandNode;
+    private buildRepeatCommandNode;
+    private buildSetCommandNode;
+    private createPropertyNode;
+    private buildIfCommandNode;
+    private semanticValueToExpression;
+    private parseExpressionString;
+    getLanguage(): string;
+    getConfidenceThreshold(): number;
+}
+export declare function createSemanticIntegration(options: SemanticIntegrationOptions): SemanticIntegrationAdapter;
+export declare function shouldUseSemanticResult(result: SemanticAnalysisResult, threshold?: number): boolean;
+export declare function languageBenefitsFromSemantic(language: string): boolean;
+//# sourceMappingURL=semantic-integration.d.ts.map

package/dist/parser/token-consumer.d.ts

@@ -0,0 +1,35 @@
+import type { ASTNode, Token } from '../types/core';
+import type { TokenType } from './tokenizer';
+export interface ParserInterface {
+    isAtEnd(): boolean;
+    check(value: string): boolean;
+    checkTokenType(type: TokenType): boolean;
+    advance(): Token;
+    peek(): Token;
+    parsePrimary(): ASTNode;
+    parseExpression(): ASTNode;
+    isCommand(name: string): boolean;
+}
+export interface ParseUntilOptions {
+    additionalTerminators?: string[];
+    allowExpressions?: boolean;
+    stopAtCommands?: boolean;
+    stopWhen?: (parser: ParserInterface) => boolean;
+}
+export declare class TokenConsumer {
+    private parser;
+    constructor(parser: ParserInterface);
+    parseArgsUntilTerminator(options?: ParseUntilOptions): ASTNode[];
+    private shouldStopParsing;
+    consumeOptionalThe(): boolean;
+    consumeOptionalArticle(): 'a' | 'an' | null;
+    parsePrepositionTarget(preposition: string, parseExpression?: boolean): {
+        preposition: string;
+        target: ASTNode;
+    } | null;
+    parseOptionalModifiers(prepositions: Record<string, boolean>): Record<string, ASTNode>;
+    isAtCommandSeparator(): boolean;
+    consumeOptionalSeparator(): 'then' | 'and' | null;
+    tryParseKeywordPhrase(keywords: string[]): string | null;
+}
+//# sourceMappingURL=token-consumer.d.ts.map

package/dist/parser/token-predicates.d.ts

@@ -0,0 +1,77 @@
+import type { Token } from '../types/core';
+export declare function isCommand(token: Token): boolean;
+export declare function isKeyword(token: Token): boolean;
+export declare function isEvent(token: Token): boolean;
+export declare function isContextVar(token: Token): boolean;
+export declare function isLogicalOperator(token: Token): boolean;
+export declare function isComparisonOperator(token: Token): boolean;
+export declare function isIdentifierLike(token: Token): boolean;
+export declare function isSelector(token: Token): boolean;
+export declare function isBasicSelector(token: Token): boolean;
+export declare function isLiteral(token: Token): boolean;
+export declare function isOperator(token: Token): boolean;
+export declare function isReference(token: Token): boolean;
+export declare function isTimeExpression(token: Token): boolean;
+export declare function isSymbol(token: Token): boolean;
+export declare function isComment(token: Token): boolean;
+export declare function isIdentifier(token: Token): boolean;
+export declare function isString(token: Token): boolean;
+export declare function isNumber(token: Token): boolean;
+export declare function isBoolean(token: Token): boolean;
+export declare function isTemplateLiteral(token: Token): boolean;
+export declare function isQueryReference(token: Token): boolean;
+export declare function isIdSelector(token: Token): boolean;
+export declare function isClassSelector(token: Token): boolean;
+export declare function isCssSelector(token: Token): boolean;
+export declare function isGlobalVar(token: Token): boolean;
+export declare function isBasicOperator(token: Token): boolean;
+export declare function hasValue(token: Token, value: string): boolean;
+export declare function hasValueIn(token: Token, values: readonly string[]): boolean;
+export declare function isOperatorValue(token: Token, value: string): boolean;
+export declare function isPossessive(token: Token): boolean;
+export declare function isDot(token: Token): boolean;
+export declare function isOptionalChain(token: Token): boolean;
+export declare function isOpenBracket(token: Token): boolean;
+export declare function isOpenParen(token: Token): boolean;
+export declare function canStartExpression(token: Token): boolean;
+export declare function isCommandTerminator(token: Token): boolean;
+export declare const TokenPredicates: {
+    isCommand: typeof isCommand;
+    isKeyword: typeof isKeyword;
+    isEvent: typeof isEvent;
+    isContextVar: typeof isContextVar;
+    isLogicalOperator: typeof isLogicalOperator;
+    isComparisonOperator: typeof isComparisonOperator;
+    isIdentifierLike: typeof isIdentifierLike;
+    isSelector: typeof isSelector;
+    isBasicSelector: typeof isBasicSelector;
+    isLiteral: typeof isLiteral;
+    isOperator: typeof isOperator;
+    isReference: typeof isReference;
+    isTimeExpression: typeof isTimeExpression;
+    isSymbol: typeof isSymbol;
+    isComment: typeof isComment;
+    isIdentifier: typeof isIdentifier;
+    isString: typeof isString;
+    isNumber: typeof isNumber;
+    isBoolean: typeof isBoolean;
+    isTemplateLiteral: typeof isTemplateLiteral;
+    isQueryReference: typeof isQueryReference;
+    isIdSelector: typeof isIdSelector;
+    isClassSelector: typeof isClassSelector;
+    isCssSelector: typeof isCssSelector;
+    isGlobalVar: typeof isGlobalVar;
+    isBasicOperator: typeof isBasicOperator;
+    hasValue: typeof hasValue;
+    hasValueIn: typeof hasValueIn;
+    isOperatorValue: typeof isOperatorValue;
+    isPossessive: typeof isPossessive;
+    isDot: typeof isDot;
+    isOptionalChain: typeof isOptionalChain;
+    isOpenBracket: typeof isOpenBracket;
+    isOpenParen: typeof isOpenParen;
+    canStartExpression: typeof canStartExpression;
+    isCommandTerminator: typeof isCommandTerminator;
+};
+export default TokenPredicates;
+//# sourceMappingURL=token-predicates.d.ts.map

package/dist/parser/tokenizer.d.ts

@@ -0,0 +1,57 @@
+import type { Token } from '../types/core';
+export type { Token } from '../types/core';
+export declare enum TokenKind {
+    IDENTIFIER = "identifier",
+    STRING = "string",
+    NUMBER = "number",
+    SELECTOR = "selector",
+    OPERATOR = "operator",
+    TIME = "time",
+    TEMPLATE = "template",
+    COMMENT = "comment",
+    SYMBOL = "symbol",
+    UNKNOWN = "unknown"
+}
+export declare function getTokenKind(tokenType: TokenType): TokenKind;
+export declare enum TokenType {
+    KEYWORD = "keyword",
+    COMMAND = "command",
+    EXPRESSION = "expression",
+    STRING = "string",
+    NUMBER = "number",
+    BOOLEAN = "boolean",
+    TEMPLATE_LITERAL = "template_literal",
+    CSS_SELECTOR = "css_selector",
+    ID_SELECTOR = "id_selector",
+    CLASS_SELECTOR = "class_selector",
+    QUERY_REFERENCE = "query_reference",
+    CONTEXT_VAR = "context_var",
+    GLOBAL_VAR = "global_var",
+    EVENT = "event",
+    OPERATOR = "operator",
+    LOGICAL_OPERATOR = "logical_operator",
+    COMPARISON_OPERATOR = "comparison_operator",
+    TIME_EXPRESSION = "time_expression",
+    OBJECT_LITERAL = "object_literal",
+    ARRAY_LITERAL = "array_literal",
+    SYMBOL = "symbol",
+    COMMENT = "comment",
+    IDENTIFIER = "identifier",
+    UNKNOWN = "unknown"
+}
+export declare function enableDeferredClassification(): void;
+export declare function disableDeferredClassification(): void;
+export declare function isDeferredClassificationEnabled(): boolean;
+export declare function enableDualOutput(): void;
+export declare function disableDualOutput(): void;
+export declare function isDualOutputEnabled(): boolean;
+export interface Tokenizer {
+    input: string;
+    position: number;
+    line: number;
+    column: number;
+    tokens: Token[];
+}
+export declare function createTokenizer(): Tokenizer;
+export declare function tokenize(input: string): Token[];
+//# sourceMappingURL=tokenizer.d.ts.map