@hyperfixi/core 2.3.1 → 2.5.0

package/dist/multilingual/bridge.d.ts

@@ -19,7 +19,7 @@ export interface ParseToASTResult {
     warnings?: string[];
 }
 export declare class SemanticGrammarBridge {
-    private analyzer;
+    private _initialized;
     private config;
     constructor(config?: BridgeConfig);
     initialize(): Promise<void>;

package/dist/multilingual/index.js

@@ -2,6 +2,75 @@
 
 var semantic = require('@lokascript/semantic');
 
+function checkDebugEnabled() {
+    if (typeof localStorage !== 'undefined') {
+        try {
+            const ls = localStorage;
+            const setting = ls.getItem('hyperfixi:debug') || ls.getItem('lokascript:debug');
+            if (setting === '*' || setting === 'true')
+                return true;
+        }
+        catch {
+        }
+    }
+    if (typeof window !== 'undefined' && window.__HYPERFIXI_DEBUG__) {
+        return true;
+    }
+    if (typeof process !== 'undefined' && process.env?.HYPERFIXI_DEBUG === 'true') {
+        return true;
+    }
+    return false;
+}
+const isDebugEnabled = checkDebugEnabled();
+const DEBUG = {
+    commands: isDebugEnabled,
+    events: isDebugEnabled,
+    parsing: isDebugEnabled,
+    expressions: isDebugEnabled,
+    styles: isDebugEnabled,
+    runtime: isDebugEnabled,
+    loops: isDebugEnabled,
+    async: isDebugEnabled,
+};
+const debug = {
+    command: (...args) => {
+        if (DEBUG.commands)
+            console.log('🔧', ...args);
+    },
+    event: (...args) => {
+        if (DEBUG.events)
+            console.log('🎯', ...args);
+    },
+    parse: (...args) => {
+        if (DEBUG.parsing)
+            console.log('📝', ...args);
+    },
+    expr: (...args) => {
+        if (DEBUG.expressions)
+            console.log('🔍', ...args);
+    },
+    expressions: (...args) => {
+        if (DEBUG.expressions)
+            console.log('🔍', ...args);
+    },
+    style: (...args) => {
+        if (DEBUG.styles)
+            console.log('🎨', ...args);
+    },
+    runtime: (...args) => {
+        if (DEBUG.runtime)
+            console.log('🚀', ...args);
+    },
+    loop: (...args) => {
+        if (DEBUG.loops)
+            console.log('🔁', ...args);
+    },
+    async: (...args) => {
+        if (DEBUG.async)
+            console.log('⏳', ...args);
+    },
+};
+
 let _semanticModule = null;
 async function getSemanticModule() {
     if (!_semanticModule) {
@@ -11,18 +80,18 @@ async function getSemanticModule() {
 }
 class SemanticGrammarBridge {
     constructor(config = {}) {
-        this.analyzer = null;
+        this._initialized = false;
         this.config = {
             confidenceThreshold: config.confidenceThreshold ?? semantic.DEFAULT_CONFIDENCE_THRESHOLD,
             fallbackOnLowConfidence: config.fallbackOnLowConfidence ?? true,
         };
     }
     async initialize() {
-        const semantic = await getSemanticModule();
-        this.analyzer = semantic.createSemanticAnalyzer();
+        await getSemanticModule();
+        this._initialized = true;
     }
     isInitialized() {
-        return this.analyzer !== null;
+        return this._initialized;
     }
     async transform(input, sourceLang, targetLang) {
         if (!this.isInitialized()) {
@@ -64,9 +133,8 @@ class SemanticGrammarBridge {
         if (!this.isInitialized()) {
             await this.initialize();
         }
-        if (!this.analyzer)
-            return null;
-        const result = this.analyzer.analyze(input, lang);
+        const semantic = await getSemanticModule();
+        const result = semantic.parseSemantic(input, lang);
         return result.node ?? null;
     }
     async render(node, targetLang) {
@@ -77,17 +145,15 @@ class SemanticGrammarBridge {
         if (!this.isInitialized()) {
             await this.initialize();
         }
-        if (!this.analyzer)
-            return null;
-        const result = this.analyzer.analyze(input, lang);
+        const semantic = await getSemanticModule();
+        const result = semantic.parseSemantic(input, lang);
         if (result.confidence >= this.config.confidenceThreshold && result.node) {
-            const semantic = await getSemanticModule();
             try {
                 const buildResult = semantic.buildAST(result.node);
                 return buildResult.ast;
             }
             catch (error) {
-                console.warn('[SemanticGrammarBridge] AST build failed, using fallback:', error);
+                debug.runtime('[SemanticGrammarBridge] AST build failed, using fallback:', error);
             }
         }
         return null;
@@ -96,17 +162,8 @@ class SemanticGrammarBridge {
         if (!this.isInitialized()) {
             await this.initialize();
         }
-        if (!this.analyzer) {
-            return {
-                ast: null,
-                usedDirectPath: false,
-                confidence: 0,
-                lang,
-                fallbackText: null,
-            };
-        }
-        const result = this.analyzer.analyze(input, lang);
         const semantic = await getSemanticModule();
+        const result = semantic.parseSemantic(input, lang);
         if (result.confidence >= this.config.confidenceThreshold && result.node) {
             try {
                 const buildResult = semantic.buildAST(result.node);

package/dist/multilingual/index.mjs

@@ -1,5 +1,74 @@
 import { DEFAULT_CONFIDENCE_THRESHOLD } from '@lokascript/semantic';
 
+function checkDebugEnabled() {
+    if (typeof localStorage !== 'undefined') {
+        try {
+            const ls = localStorage;
+            const setting = ls.getItem('hyperfixi:debug') || ls.getItem('lokascript:debug');
+            if (setting === '*' || setting === 'true')
+                return true;
+        }
+        catch {
+        }
+    }
+    if (typeof window !== 'undefined' && window.__HYPERFIXI_DEBUG__) {
+        return true;
+    }
+    if (typeof process !== 'undefined' && process.env?.HYPERFIXI_DEBUG === 'true') {
+        return true;
+    }
+    return false;
+}
+const isDebugEnabled = checkDebugEnabled();
+const DEBUG = {
+    commands: isDebugEnabled,
+    events: isDebugEnabled,
+    parsing: isDebugEnabled,
+    expressions: isDebugEnabled,
+    styles: isDebugEnabled,
+    runtime: isDebugEnabled,
+    loops: isDebugEnabled,
+    async: isDebugEnabled,
+};
+const debug = {
+    command: (...args) => {
+        if (DEBUG.commands)
+            console.log('🔧', ...args);
+    },
+    event: (...args) => {
+        if (DEBUG.events)
+            console.log('🎯', ...args);
+    },
+    parse: (...args) => {
+        if (DEBUG.parsing)
+            console.log('📝', ...args);
+    },
+    expr: (...args) => {
+        if (DEBUG.expressions)
+            console.log('🔍', ...args);
+    },
+    expressions: (...args) => {
+        if (DEBUG.expressions)
+            console.log('🔍', ...args);
+    },
+    style: (...args) => {
+        if (DEBUG.styles)
+            console.log('🎨', ...args);
+    },
+    runtime: (...args) => {
+        if (DEBUG.runtime)
+            console.log('🚀', ...args);
+    },
+    loop: (...args) => {
+        if (DEBUG.loops)
+            console.log('🔁', ...args);
+    },
+    async: (...args) => {
+        if (DEBUG.async)
+            console.log('⏳', ...args);
+    },
+};
+
 let _semanticModule = null;
 async function getSemanticModule() {
     if (!_semanticModule) {
@@ -9,18 +78,18 @@ async function getSemanticModule() {
 }
 class SemanticGrammarBridge {
     constructor(config = {}) {
-        this.analyzer = null;
+        this._initialized = false;
         this.config = {
             confidenceThreshold: config.confidenceThreshold ?? DEFAULT_CONFIDENCE_THRESHOLD,
             fallbackOnLowConfidence: config.fallbackOnLowConfidence ?? true,
         };
     }
     async initialize() {
-        const semantic = await getSemanticModule();
-        this.analyzer = semantic.createSemanticAnalyzer();
+        await getSemanticModule();
+        this._initialized = true;
     }
     isInitialized() {
-        return this.analyzer !== null;
+        return this._initialized;
     }
     async transform(input, sourceLang, targetLang) {
         if (!this.isInitialized()) {
@@ -62,9 +131,8 @@ class SemanticGrammarBridge {
         if (!this.isInitialized()) {
             await this.initialize();
         }
-        if (!this.analyzer)
-            return null;
-        const result = this.analyzer.analyze(input, lang);
+        const semantic = await getSemanticModule();
+        const result = semantic.parseSemantic(input, lang);
         return result.node ?? null;
     }
     async render(node, targetLang) {
@@ -75,17 +143,15 @@ class SemanticGrammarBridge {
         if (!this.isInitialized()) {
             await this.initialize();
         }
-        if (!this.analyzer)
-            return null;
-        const result = this.analyzer.analyze(input, lang);
+        const semantic = await getSemanticModule();
+        const result = semantic.parseSemantic(input, lang);
         if (result.confidence >= this.config.confidenceThreshold && result.node) {
-            const semantic = await getSemanticModule();
             try {
                 const buildResult = semantic.buildAST(result.node);
                 return buildResult.ast;
             }
             catch (error) {
-                console.warn('[SemanticGrammarBridge] AST build failed, using fallback:', error);
+                debug.runtime('[SemanticGrammarBridge] AST build failed, using fallback:', error);
             }
         }
         return null;
@@ -94,17 +160,8 @@ class SemanticGrammarBridge {
         if (!this.isInitialized()) {
             await this.initialize();
         }
-        if (!this.analyzer) {
-            return {
-                ast: null,
-                usedDirectPath: false,
-                confidence: 0,
-                lang,
-                fallbackText: null,
-            };
-        }
-        const result = this.analyzer.analyze(input, lang);
         const semantic = await getSemanticModule();
+        const result = semantic.parseSemantic(input, lang);
         if (result.confidence >= this.config.confidenceThreshold && result.node) {
             try {
                 const buildResult = semantic.buildAST(result.node);

package/dist/parser/command-parsers/animation-commands.d.ts

@@ -2,4 +2,5 @@ import type { ParserContext, IdentifierNode } from '../parser-types';
 import type { Token } from '../../types/core';
 export declare function parseMeasureCommand(ctx: ParserContext, identifierNode: IdentifierNode): import("../../types/core").CommandNode;
 export declare function parseTransitionCommand(ctx: ParserContext, commandToken: Token): import("../../types/core").CommandNode;
+export declare function parseStartCommand(ctx: ParserContext, identifierNode: IdentifierNode): import('../../types/core').CommandNode;
 //# sourceMappingURL=animation-commands.d.ts.map

package/dist/parser/command-parsers/utility-commands.d.ts

@@ -6,4 +6,5 @@ export declare function parseMultiWordCommand(ctx: ParserContext, commandToken:
 export declare function parseFetchCommand(ctx: ParserContext, commandToken: Token): CommandNode;
 export declare function parseJsCommand(ctx: ParserContext, identifierNode: IdentifierNode): CommandNode;
 export declare function parseTellCommand(ctx: ParserContext, identifierNode: IdentifierNode): CommandNode;
+export declare function parsePickCommand(ctx: ParserContext, identifierNode: IdentifierNode): CommandNode;
 //# sourceMappingURL=utility-commands.d.ts.map

package/dist/parser/extensions.d.ts

@@ -0,0 +1,51 @@
+import type { BindingPowerEntry, InfixHandler, PrefixHandler } from './pratt-parser';
+import type { ASTNode, ExecutionContext } from '../types/base-types';
+import type { Token } from '../types/core';
+import type { ParserContext } from './parser-types';
+export type FeatureParseFn = (ctx: ParserContext, token: Token) => ASTNode | null;
+export type NodeEvaluatorFn = (node: ASTNode, context: ExecutionContext) => unknown | Promise<unknown>;
+export type GlobalWriteHook = (name: string, value: unknown, context: ExecutionContext) => void;
+export type GlobalReadHook = (name: string, context: ExecutionContext) => void;
+export type LocalWriteHook = (name: string, value: unknown, context: ExecutionContext) => void;
+export type LocalReadHook = (name: string, context: ExecutionContext) => void;
+export type NodeWriterFn = (node: ASTNode, value: unknown, context: ExecutionContext) => void | Promise<void>;
+export declare function getRegisteredFeature(name: string): FeatureParseFn | undefined;
+export declare function getRegisteredNodeEvaluator(type: string): NodeEvaluatorFn | undefined;
+export declare function getRegisteredNodeWriter(type: string): NodeWriterFn | undefined;
+export declare function getGlobalWriteHooks(): Iterable<GlobalWriteHook>;
+export declare function notifyGlobalRead(name: string, context: ExecutionContext): void;
+export declare function getLocalWriteHooks(): Iterable<LocalWriteHook>;
+export declare function notifyLocalWrite(name: string, value: unknown, context: ExecutionContext): void;
+export declare function notifyLocalRead(name: string, context: ExecutionContext): void;
+export interface ParserExtensionSnapshot {
+    commands: string[];
+    operators: string[];
+    prattEntries: Array<[string, BindingPowerEntry]>;
+    features: Array<[string, FeatureParseFn]>;
+    nodeEvaluators: Array<[string, NodeEvaluatorFn]>;
+    nodeWriters: Array<[string, NodeWriterFn]>;
+    globalWriteHooks: GlobalWriteHook[];
+    globalReadHooks: GlobalReadHook[];
+    localWriteHooks: LocalWriteHook[];
+    localReadHooks: LocalReadHook[];
+}
+export declare class ParserExtensionRegistry {
+    registerCommand(name: string): void;
+    registerCompoundOperator(token: string): void;
+    registerInfixOperator(token: string, leftBp: number, rightBp: number, handler: InfixHandler): void;
+    registerPrefixOperator(token: string, bp: number, handler: PrefixHandler): void;
+    hasCommand(name: string): boolean;
+    registerFeature(keyword: string, parseFn: FeatureParseFn): void;
+    hasFeature(name: string): boolean;
+    registerNodeEvaluator(nodeType: string, fn: NodeEvaluatorFn): void;
+    registerNodeWriter(nodeType: string, fn: NodeWriterFn): void;
+    registerGlobalWriteHook(hook: GlobalWriteHook): () => void;
+    registerGlobalReadHook(hook: GlobalReadHook): () => void;
+    registerLocalWriteHook(hook: LocalWriteHook): () => void;
+    registerLocalReadHook(hook: LocalReadHook): () => void;
+    snapshot(): ParserExtensionSnapshot;
+    restore(snapshot: ParserExtensionSnapshot): void;
+}
+export declare function getParserExtensionRegistry(): ParserExtensionRegistry;
+export declare function setGlobal(context: ExecutionContext, name: string, value: unknown): void;
+//# sourceMappingURL=extensions.d.ts.map