@hyperfixi/core 2.0.0

package/dist/parser/helpers/ast-helpers.d.ts

@@ -0,0 +1,22 @@
+import type { ASTNode } from '../../types/core';
+import type { Position, IdentifierNode, LiteralNode, BinaryExpressionNode, UnaryExpressionNode, CallExpressionNode, MemberExpressionNode, SelectorNode, PossessiveExpressionNode, BlockNode, StringLiteralNode, ObjectLiteralNode, ArrayLiteralNode, PropertyOfExpressionNode, CommandSequenceNode } from '../parser-types';
+export declare function createLiteral(value: unknown, raw: string, pos: Position): LiteralNode;
+export declare function createIdentifier(name: string, pos: Position): IdentifierNode;
+export declare function createBinaryExpression(operator: string, left: ASTNode, right: ASTNode, pos: Position): BinaryExpressionNode;
+export declare function createUnaryExpression(operator: string, argument: ASTNode, prefix: boolean, pos: Position): UnaryExpressionNode;
+export declare function createCallExpression(callee: ASTNode, args: ASTNode[], pos: Position): CallExpressionNode;
+export declare function createMemberExpression(object: ASTNode, property: ASTNode, computed: boolean, pos: Position): MemberExpressionNode;
+export declare function createSelector(value: string, pos: Position): SelectorNode;
+export declare function createPossessiveExpression(object: ASTNode, property: ASTNode, pos: Position): PossessiveExpressionNode;
+export declare function createBlock(commands: ASTNode[], pos: Position): BlockNode;
+export declare function createStringLiteral(value: string, pos: Position): StringLiteralNode;
+export declare function createObjectLiteral(properties: Array<{
+    key: ASTNode;
+    value: ASTNode;
+}>, pos: Position): ObjectLiteralNode;
+export declare function createArrayLiteral(elements: ASTNode[], pos: Position): ArrayLiteralNode;
+export declare function createPropertyOfExpression(property: ASTNode, target: ASTNode, pos: Position): PropertyOfExpressionNode;
+export declare function createCommandSequence(commands: ASTNode[]): CommandSequenceNode;
+export declare function createErrorNode(pos: Position): IdentifierNode;
+export declare function createProgramNode(statements: ASTNode[]): ASTNode;
+//# sourceMappingURL=ast-helpers.d.ts.map

package/dist/parser/helpers/parsing-helpers.d.ts

@@ -0,0 +1,19 @@
+import type { Token, ASTNode } from '../../types/core';
+import type { ParserContext } from '../parser-types';
+export interface MultiWordPattern {
+    command: string;
+    keywords: string[];
+    syntax: string;
+}
+export declare const MULTI_WORD_PATTERNS: MultiWordPattern[];
+export declare function getMultiWordPattern(commandName: string): MultiWordPattern | null;
+export declare function isKeyword(token: Token | undefined, keywords: string[]): boolean;
+export declare const DEFAULT_BOUNDARY_KEYWORDS: readonly ["then", "and", "else", "end"];
+export declare function isCommandBoundary(ctx: ParserContext, additionalBoundaries?: string[]): boolean;
+export declare function parseArgumentsUntilBoundary(ctx: ParserContext, additionalBoundaries?: string[], maxArgs?: number): ASTNode[];
+export declare function parseOneArgument(ctx: ParserContext, additionalBoundaries?: string[]): ASTNode | undefined;
+export declare function consumeKeywordToArgs(ctx: ParserContext, keyword: string, args: ASTNode[]): boolean;
+export declare function consumeOneOfKeywordsToArgs(ctx: ParserContext, keywords: string[], args: ASTNode[]): string | null;
+export declare function parseHyphenatedName(ctx: ParserContext): string;
+export declare function consumeOptionalKeyword(ctx: ParserContext, keyword: string): boolean;
+//# sourceMappingURL=parsing-helpers.d.ts.map

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

@@ -0,0 +1,28 @@
+import type { Token } from '../../types/core';
+import type { TokenKind } from '../tokenizer';
+export interface TokenStreamState {
+    tokens: Token[];
+    current: number;
+}
+export interface TokenNavigator {
+    advance(): Token;
+    peek(): Token;
+    previous(): Token;
+    check(value: string): boolean;
+    match(...values: string[]): boolean;
+    matchOperator(operator: string): boolean;
+    isAtEnd(): boolean;
+    consume(expected: string, message: string): Token;
+}
+export declare function peekMatches(tokens: Token[], current: number, expected: string): boolean;
+export declare function peekMatchesKind(tokens: Token[], current: number, expectedKind: TokenKind): boolean;
+export declare function peekAhead(tokens: Token[], current: number, offset?: number): Token;
+export declare function isLastToken(tokens: Token[], current: number): boolean;
+export declare function remainingTokens(tokens: Token[], current: number): number;
+export declare function getTokenAt(tokens: Token[], index: number): Token;
+export { isKeyword } from './parsing-helpers';
+export declare function findNextToken(tokens: Token[], current: number, value: string): number;
+export declare function findNextTokenKind(tokens: Token[], current: number, kind: TokenKind): number;
+export declare function getTokensUntil(tokens: Token[], current: number, until: string): Token[];
+export declare function matchesSequence(tokens: Token[], current: number, sequence: string[]): boolean;
+//# sourceMappingURL=token-helpers.d.ts.map

package/dist/parser/hybrid/aliases.d.ts

@@ -0,0 +1,7 @@
+export declare const COMMAND_ALIASES: Record<string, string>;
+export declare const EVENT_ALIASES: Record<string, string>;
+export declare function normalizeCommand(name: string): string;
+export declare function normalizeEvent(name: string): string;
+export declare function addCommandAliases(aliases: Record<string, string>): void;
+export declare function addEventAliases(aliases: Record<string, string>): void;
+//# sourceMappingURL=aliases.d.ts.map

package/dist/parser/hybrid/aliases.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const COMMAND_ALIASES = {
+    flip: 'toggle',
+    switch: 'toggle',
+    display: 'show',
+    reveal: 'show',
+    conceal: 'hide',
+    increase: 'increment',
+    decrease: 'decrement',
+    fire: 'trigger',
+    dispatch: 'send',
+    navigate: 'go',
+    goto: 'go',
+};
+const EVENT_ALIASES = {
+    clicked: 'click',
+    pressed: 'keydown',
+    changed: 'change',
+    submitted: 'submit',
+    loaded: 'load',
+};
+function normalizeCommand(name) {
+    const lower = name.toLowerCase();
+    return COMMAND_ALIASES[lower] || lower;
+}
+function normalizeEvent(name) {
+    const lower = name.toLowerCase();
+    return EVENT_ALIASES[lower] || lower;
+}
+function addCommandAliases(aliases) {
+    Object.assign(COMMAND_ALIASES, aliases);
+}
+function addEventAliases(aliases) {
+    Object.assign(EVENT_ALIASES, aliases);
+}
+
+exports.COMMAND_ALIASES = COMMAND_ALIASES;
+exports.EVENT_ALIASES = EVENT_ALIASES;
+exports.addCommandAliases = addCommandAliases;
+exports.addEventAliases = addEventAliases;
+exports.normalizeCommand = normalizeCommand;
+exports.normalizeEvent = normalizeEvent;
+//# sourceMappingURL=aliases.js.map

package/dist/parser/hybrid/aliases.mjs

@@ -0,0 +1,37 @@
+const COMMAND_ALIASES = {
+    flip: 'toggle',
+    switch: 'toggle',
+    display: 'show',
+    reveal: 'show',
+    conceal: 'hide',
+    increase: 'increment',
+    decrease: 'decrement',
+    fire: 'trigger',
+    dispatch: 'send',
+    navigate: 'go',
+    goto: 'go',
+};
+const EVENT_ALIASES = {
+    clicked: 'click',
+    pressed: 'keydown',
+    changed: 'change',
+    submitted: 'submit',
+    loaded: 'load',
+};
+function normalizeCommand(name) {
+    const lower = name.toLowerCase();
+    return COMMAND_ALIASES[lower] || lower;
+}
+function normalizeEvent(name) {
+    const lower = name.toLowerCase();
+    return EVENT_ALIASES[lower] || lower;
+}
+function addCommandAliases(aliases) {
+    Object.assign(COMMAND_ALIASES, aliases);
+}
+function addEventAliases(aliases) {
+    Object.assign(EVENT_ALIASES, aliases);
+}
+
+export { COMMAND_ALIASES, EVENT_ALIASES, addCommandAliases, addEventAliases, normalizeCommand, normalizeEvent };
+//# sourceMappingURL=aliases.mjs.map

package/dist/parser/hybrid/ast-types.d.ts

@@ -0,0 +1,97 @@
+export interface ASTNode {
+    type: string;
+    [key: string]: any;
+}
+export interface CommandNode extends ASTNode {
+    type: 'command';
+    name: string;
+    args: ASTNode[];
+    target?: ASTNode;
+    modifier?: string;
+}
+export interface BlockNode extends ASTNode {
+    type: 'if' | 'repeat' | 'for' | 'while' | 'fetch';
+    condition?: ASTNode;
+    body: ASTNode[];
+    elseBody?: ASTNode[];
+}
+export interface EventModifiers {
+    once?: boolean;
+    prevent?: boolean;
+    stop?: boolean;
+    debounce?: number;
+    throttle?: number;
+}
+export interface EventNode extends ASTNode {
+    type: 'event';
+    event: string;
+    filter?: ASTNode;
+    modifiers: EventModifiers;
+    body: ASTNode[];
+}
+export interface SequenceNode extends ASTNode {
+    type: 'sequence';
+    commands: ASTNode[];
+}
+export interface LiteralNode extends ASTNode {
+    type: 'literal';
+    value: any;
+    unit?: string;
+}
+export interface IdentifierNode extends ASTNode {
+    type: 'identifier';
+    value: string;
+}
+export interface SelectorNode extends ASTNode {
+    type: 'selector';
+    value: string;
+}
+export interface VariableNode extends ASTNode {
+    type: 'variable';
+    name: string;
+    scope: 'local' | 'global';
+}
+export interface BinaryNode extends ASTNode {
+    type: 'binary';
+    operator: string;
+    left: ASTNode;
+    right: ASTNode;
+}
+export interface UnaryNode extends ASTNode {
+    type: 'unary';
+    operator: string;
+    operand: ASTNode;
+}
+export interface PossessiveNode extends ASTNode {
+    type: 'possessive';
+    object: ASTNode;
+    property: string;
+}
+export interface MemberNode extends ASTNode {
+    type: 'member';
+    object: ASTNode;
+    property: ASTNode | string;
+    computed?: boolean;
+}
+export interface CallNode extends ASTNode {
+    type: 'call';
+    callee: ASTNode;
+    args: ASTNode[];
+}
+export interface PositionalNode extends ASTNode {
+    type: 'positional';
+    position: string;
+    target: ASTNode;
+}
+export interface ObjectNode extends ASTNode {
+    type: 'object';
+    properties: Array<{
+        key: string;
+        value: ASTNode;
+    }>;
+}
+export interface ArrayNode extends ASTNode {
+    type: 'array';
+    elements: ASTNode[];
+}
+//# sourceMappingURL=ast-types.d.ts.map

package/dist/parser/hybrid/ast-types.js

@@ -0,0 +1,3 @@
+'use strict';
+
+//# sourceMappingURL=ast-types.js.map

package/dist/parser/hybrid/ast-types.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=ast-types.mjs.map

package/dist/parser/hybrid/index.d.ts

@@ -0,0 +1,6 @@
+export { tokenize, KEYWORDS } from './tokenizer';
+export type { Token, TokenType } from './tokenizer';
+export type { ASTNode, CommandNode, BlockNode, EventNode, EventModifiers, SequenceNode, LiteralNode, IdentifierNode, SelectorNode, VariableNode, BinaryNode, UnaryNode, PossessiveNode, MemberNode, CallNode, PositionalNode, ObjectNode, ArrayNode, } from './ast-types';
+export { COMMAND_ALIASES, EVENT_ALIASES, normalizeCommand, normalizeEvent, addCommandAliases, addEventAliases, } from './aliases';
+export { HybridParser } from './parser-core';
+//# sourceMappingURL=index.d.ts.map