@hyperfixi/core 3.3.0 → 4.0.1

package/dist/multilingual/index.cjs

@@ -1,394 +1,28 @@
 'use strict';
 
-var semantic = require('@lokascript/semantic');
-var intent = require('@lokascript/intent');
-
-const DEFAULT_CONFIDENCE_THRESHOLD = 0.5;
-
-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;
+let semanticModule = null;
+async function semantic() {
+    semanticModule ?? (semanticModule = await import('@lokascript/semantic'));
+    return semanticModule;
 }
-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('\ud83d\udd27', ...args);
-    },
-    event: (...args) => {
-        if (DEBUG.events)
-            console.log('\ud83c\udfaf', ...args);
-    },
-    parse: (...args) => {
-        if (DEBUG.parsing)
-            console.log('\ud83d\udcdd', ...args);
-    },
-    expr: (...args) => {
-        if (DEBUG.expressions)
-            console.log('\ud83d\udd0d', ...args);
-    },
-    expressions: (...args) => {
-        if (DEBUG.expressions)
-            console.log('\ud83d\udd0d', ...args);
-    },
-    style: (...args) => {
-        if (DEBUG.styles)
-            console.log('\ud83c\udfa8', ...args);
-    },
-    runtime: (...args) => {
-        if (DEBUG.runtime)
-            console.log('\ud83d\ude80', ...args);
-    },
-    loop: (...args) => {
-        if (DEBUG.loops)
-            console.log('\ud83d\udd01', ...args);
-    },
-    async: (...args) => {
-        if (DEBUG.async)
-            console.log('\u23f3', ...args);
-    },
-};
-
-function unconsumedInputWarnings(node) {
-    const diagnostics = node
-        .diagnostics;
-    if (!diagnostics?.length)
-        return [];
-    return diagnostics.filter(d => d.code === 'unconsumed-input').map(d => d.message);
-}
-let _semanticModule = null;
-async function getSemanticModule() {
-    if (!_semanticModule) {
-        _semanticModule = await import('@lokascript/semantic');
-    }
-    return _semanticModule;
+async function parse(input, lang = 'en') {
+    return (await semantic()).parseSemantic(input, lang).node ?? null;
 }
-class SemanticGrammarBridge {
-    constructor(config = {}) {
-        this._initialized = false;
-        this.config = {
-            confidenceThreshold: config.confidenceThreshold ?? DEFAULT_CONFIDENCE_THRESHOLD,
-            fallbackOnLowConfidence: config.fallbackOnLowConfidence ?? true,
-        };
-    }
-    async initialize() {
-        await getSemanticModule();
-        this._initialized = true;
-    }
-    isInitialized() {
-        return this._initialized;
-    }
-    async transform(input, sourceLang, targetLang) {
-        if (!this.isInitialized()) {
-            await this.initialize();
-        }
-        if (sourceLang === targetLang) {
-            return {
-                output: input,
-                usedSemantic: false,
-                confidence: 1.0,
-                sourceLang,
-                targetLang,
-            };
-        }
-        const semantic = await getSemanticModule();
-        try {
-            const output = semantic.translate(input, sourceLang, targetLang);
-            if (output !== input) {
-                return {
-                    output,
-                    usedSemantic: true,
-                    confidence: 0.9,
-                    sourceLang,
-                    targetLang,
-                };
-            }
-        }
-        catch {
-        }
-        return {
-            output: input,
-            usedSemantic: false,
-            confidence: 0,
-            sourceLang,
-            targetLang,
-        };
-    }
-    async parse(input, lang) {
-        if (!this.isInitialized()) {
-            await this.initialize();
-        }
-        const semantic = await getSemanticModule();
-        const result = semantic.parseSemantic(input, lang);
-        return result.node ?? null;
-    }
-    async render(node, targetLang) {
-        const semantic = await getSemanticModule();
-        return semantic.render(node, targetLang);
-    }
-    async parseToAST(input, lang) {
-        if (!this.isInitialized()) {
-            await this.initialize();
-        }
-        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);
-                return buildResult.ast;
-            }
-            catch (error) {
-                debug.runtime('[SemanticGrammarBridge] AST build failed, using fallback:', error);
-            }
-        }
-        return null;
-    }
-    async parseToASTWithDetails(input, lang) {
-        if (!this.isInitialized()) {
-            await this.initialize();
-        }
-        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);
-                return {
-                    ast: buildResult.ast,
-                    usedDirectPath: true,
-                    confidence: result.confidence,
-                    lang,
-                    fallbackText: null,
-                    warnings: [...(buildResult.warnings ?? []), ...unconsumedInputWarnings(result.node)],
-                };
-            }
-            catch {
-            }
-        }
-        if (result.node && this.config.fallbackOnLowConfidence) {
-            const englishText = semantic.render(result.node, 'en');
-            return {
-                ast: null,
-                usedDirectPath: false,
-                confidence: result.confidence,
-                lang,
-                fallbackText: englishText,
-            };
-        }
-        return {
-            ast: null,
-            usedDirectPath: false,
-            confidence: result.confidence,
-            lang,
-            fallbackText: null,
-        };
-    }
-    async getAllTranslations(input, sourceLang) {
-        const semantic = await getSemanticModule();
-        const languages = semantic.getSupportedLanguages();
-        const results = {};
-        for (const lang of languages) {
-            results[lang] = await this.transform(input, sourceLang, lang);
-        }
-        return results;
-    }
-}
-let _defaultBridge = null;
-async function getDefaultBridge() {
-    if (!_defaultBridge) {
-        _defaultBridge = new SemanticGrammarBridge();
-        await _defaultBridge.initialize();
-    }
-    return _defaultBridge;
+async function render(node, lang) {
+    return (await semantic()).render(node, lang);
 }
 async function translate(input, sourceLang, targetLang) {
-    const bridge = await getDefaultBridge();
-    const result = await bridge.transform(input, sourceLang, targetLang);
-    return result.output;
-}
-
-const INTERCHANGE_ADAPTER = {
-    getIdentifierName(node) {
-        if (node.type !== 'identifier')
-            return undefined;
-        const ident = node;
-        if (typeof ident.name === 'string' && ident.name !== '')
-            return ident.name;
-        if (typeof ident.value === 'string')
-            return ident.value;
-        return undefined;
-    },
-    convertValue(node) {
-        return node;
-    },
-    createLiteralValue(text) {
-        return { type: 'literal', value: text };
-    },
-};
-const schemaRoleInferrer = (name, args, modifiers, target) => {
-    const schema = semantic.getSchema(name);
-    if (!schema)
-        return null;
-    const inferred = intent.inferRolesFromSchema(schema, args, modifiers, target, INTERCHANGE_ADAPTER);
-    const declared = schema.ast
-        ?.modifiers;
-    if (declared && modifiers) {
-        for (const [key, role] of Object.entries(declared)) {
-            const value = modifiers[key];
-            const isNode = !!value && typeof value === 'object' && 'type' in value;
-            if (isNode && inferred[role] === undefined) {
-                inferred[role] = value;
-            }
-        }
-    }
-    return Object.keys(inferred).length > 0
-        ? inferred
-        : null;
-};
-
-class MultilingualHyperscript {
-    constructor(config = {}) {
-        this.initialized = false;
-        this.bridge = new SemanticGrammarBridge(config);
-    }
-    async initialize() {
-        if (this.initialized)
-            return;
-        await this.bridge.initialize();
-        this.initialized = true;
-    }
-    isInitialized() {
-        return this.initialized;
-    }
-    async ensureInitialized() {
-        if (!this.initialized) {
-            await this.initialize();
-        }
-    }
-    async parse(input, lang = 'en') {
-        await this.ensureInitialized();
-        return this.bridge.parse(input, lang);
-    }
-    async parseToAST(input, lang = 'en') {
-        await this.ensureInitialized();
-        return this.bridge.parseToAST(input, lang);
-    }
-    async parseToASTWithDetails(input, lang = 'en') {
-        await this.ensureInitialized();
-        return this.bridge.parseToASTWithDetails(input, lang);
+    if (sourceLang === targetLang)
+        return input;
+    try {
+        return (await semantic()).translate(input, sourceLang, targetLang);
     }
-    async translate(input, from, to) {
-        await this.ensureInitialized();
-        const result = await this.bridge.transform(input, from, to);
-        return result.output;
-    }
-    async translateWithDetails(input, from, to) {
-        await this.ensureInitialized();
-        return this.bridge.transform(input, from, to);
-    }
-    async render(node, lang) {
-        await this.ensureInitialized();
-        return this.bridge.render(node, lang);
-    }
-    async getAllTranslations(input, from) {
-        await this.ensureInitialized();
-        const all = await this.bridge.getAllTranslations(input, from);
-        const supported = new Set(this.getSupportedLanguages());
-        return Object.fromEntries(Object.entries(all).filter(([lang]) => supported.has(lang)));
-    }
-    getSupportedLanguages() {
-        return [
-            'en',
-            'ja',
-            'ar',
-            'es',
-            'ko',
-            'zh',
-            'tr',
-            'pt',
-            'fr',
-            'de',
-            'id',
-            'qu',
-            'sw',
-        ];
-    }
-    isLanguageSupported(lang) {
-        return this.getSupportedLanguages().includes(lang);
-    }
-    getLanguageInfo(lang) {
-        return LANGUAGE_INFO[lang];
-    }
-    getAllLanguageInfo() {
-        return { ...LANGUAGE_INFO };
-    }
-}
-const LANGUAGE_INFO = {
-    en: { code: 'en', name: 'English', nativeName: 'English', direction: 'ltr', wordOrder: 'SVO' },
-    ja: { code: 'ja', name: 'Japanese', nativeName: '\u65e5\u672c\u8a9e', direction: 'ltr', wordOrder: 'SOV' },
-    ar: { code: 'ar', name: 'Arabic', nativeName: '\u0627\u0644\u0639\u0631\u0628\u064a\u0629', direction: 'rtl', wordOrder: 'VSO' },
-    es: { code: 'es', name: 'Spanish', nativeName: 'Espa\u00f1ol', direction: 'ltr', wordOrder: 'SVO' },
-    ko: { code: 'ko', name: 'Korean', nativeName: '\ud55c\uad6d\uc5b4', direction: 'ltr', wordOrder: 'SOV' },
-    zh: { code: 'zh', name: 'Chinese', nativeName: '\u4e2d\u6587', direction: 'ltr', wordOrder: 'SVO' },
-    tr: { code: 'tr', name: 'Turkish', nativeName: 'T\u00fcrk\u00e7e', direction: 'ltr', wordOrder: 'SOV' },
-    pt: {
-        code: 'pt',
-        name: 'Portuguese',
-        nativeName: 'Portugu\u00eas',
-        direction: 'ltr',
-        wordOrder: 'SVO',
-    },
-    fr: { code: 'fr', name: 'French', nativeName: 'Fran\u00e7ais', direction: 'ltr', wordOrder: 'SVO' },
-    de: { code: 'de', name: 'German', nativeName: 'Deutsch', direction: 'ltr', wordOrder: 'SVO' },
-    id: {
-        code: 'id',
-        name: 'Indonesian',
-        nativeName: 'Bahasa Indonesia',
-        direction: 'ltr',
-        wordOrder: 'SVO',
-    },
-    qu: { code: 'qu', name: 'Quechua', nativeName: 'Runasimi', direction: 'ltr', wordOrder: 'SOV' },
-    sw: { code: 'sw', name: 'Swahili', nativeName: 'Kiswahili', direction: 'ltr', wordOrder: 'SVO' },
-};
-let _defaultInstance = null;
-async function getMultilingual() {
-    if (!_defaultInstance) {
-        _defaultInstance = new MultilingualHyperscript();
-        await _defaultInstance.initialize();
+    catch {
+        return input;
     }
-    return _defaultInstance;
 }
-const multilingual = new MultilingualHyperscript();
 
-exports.MultilingualHyperscript = MultilingualHyperscript;
-exports.SemanticGrammarBridge = SemanticGrammarBridge;
-exports.getDefaultBridge = getDefaultBridge;
-exports.getMultilingual = getMultilingual;
-exports.multilingual = multilingual;
-exports.schemaRoleInferrer = schemaRoleInferrer;
+exports.parse = parse;
+exports.render = render;
 exports.translate = translate;
 //# sourceMappingURL=index.cjs.map

package/dist/multilingual/index.d.ts

@@ -1,33 +1,5 @@
-import type { SemanticNode, ASTNode } from '@lokascript/semantic';
-import { SemanticGrammarBridge, getDefaultBridge, translate, type BridgeConfig, type BridgeResult, type ParseToASTResult } from './bridge';
-export { schemaRoleInferrer } from './schema-roles';
-export { SemanticGrammarBridge, getDefaultBridge, translate, type BridgeConfig, type BridgeResult, type ParseToASTResult, };
-export declare class MultilingualHyperscript {
-    private bridge;
-    private initialized;
-    constructor(config?: BridgeConfig);
-    initialize(): Promise<void>;
-    isInitialized(): boolean;
-    private ensureInitialized;
-    parse(input: string, lang?: string): Promise<SemanticNode | null>;
-    parseToAST(input: string, lang?: string): Promise<ASTNode | null>;
-    parseToASTWithDetails(input: string, lang?: string): Promise<ParseToASTResult>;
-    translate(input: string, from: string, to: string): Promise<string>;
-    translateWithDetails(input: string, from: string, to: string): Promise<BridgeResult>;
-    render(node: SemanticNode, lang: string): Promise<string>;
-    getAllTranslations(input: string, from: string): Promise<Record<string, BridgeResult>>;
-    getSupportedLanguages(): string[];
-    isLanguageSupported(lang: string): boolean;
-    getLanguageInfo(lang: string): LanguageInfo | undefined;
-    getAllLanguageInfo(): Record<string, LanguageInfo>;
-}
-export interface LanguageInfo {
-    code: string;
-    name: string;
-    nativeName: string;
-    direction: 'ltr' | 'rtl';
-    wordOrder: 'SVO' | 'SOV' | 'VSO' | 'VOS';
-}
-export declare function getMultilingual(): Promise<MultilingualHyperscript>;
-export declare const multilingual: MultilingualHyperscript;
+import type { SemanticNode } from '@lokascript/semantic';
+export declare function parse(input: string, lang?: string): Promise<SemanticNode | null>;
+export declare function render(node: SemanticNode, lang: string): Promise<string>;
+export declare function translate(input: string, sourceLang: string, targetLang: string): Promise<string>;
 //# sourceMappingURL=index.d.ts.map