@lovalingo/lovalingo 0.5.25 → 0.5.28

package/dist/utils/markerEngineState.d.ts

@@ -0,0 +1,4 @@
+export declare function getCustomExcludeSelector(): string | null;
+export declare function setCustomExcludeSelector(value: string | null): void;
+export declare function getActiveTranslationMap(): Map<string, string> | null;
+export declare function setActiveTranslationMap(value: Map<string, string> | null): void;

package/dist/utils/markerEngineState.js

@@ -0,0 +1,14 @@
+let customExcludeSelector = null;
+let activeTranslationMap = null;
+export function getCustomExcludeSelector() {
+    return customExcludeSelector;
+}
+export function setCustomExcludeSelector(value) {
+    customExcludeSelector = value;
+}
+export function getActiveTranslationMap() {
+    return activeTranslationMap;
+}
+export function setActiveTranslationMap(value) {
+    activeTranslationMap = value;
+}

package/dist/utils/markerEngineStats.d.ts

@@ -0,0 +1,3 @@
+import type { MarkerStats } from "./markerEngineTypes";
+export declare function buildEmptyStats(): MarkerStats;
+export declare function finalizeStats(stats: MarkerStats): void;

package/dist/utils/markerEngineStats.js

@@ -0,0 +1,28 @@
+export function buildEmptyStats() {
+    return {
+        totalTextNodes: 0,
+        markedNodes: 0,
+        skippedUnsafeNodes: 0,
+        skippedExcludedNodes: 0,
+        skippedNonTranslatableNodes: 0,
+        totalChars: 0,
+        markedChars: 0,
+        skippedUnsafeChars: 0,
+        skippedExcludedChars: 0,
+        skippedNonTranslatableChars: 0,
+        coverageRatio: 0,
+        coverageRatioChars: 0,
+    };
+}
+export function finalizeStats(stats) {
+    const eligibleNodes = stats.totalTextNodes -
+        stats.skippedUnsafeNodes -
+        stats.skippedExcludedNodes -
+        stats.skippedNonTranslatableNodes;
+    const eligibleChars = stats.totalChars -
+        stats.skippedUnsafeChars -
+        stats.skippedExcludedChars -
+        stats.skippedNonTranslatableChars;
+    stats.coverageRatio = eligibleNodes > 0 ? stats.markedNodes / eligibleNodes : 1;
+    stats.coverageRatioChars = eligibleChars > 0 ? stats.markedChars / eligibleChars : 1;
+}

package/dist/utils/markerEngineTranslations.d.ts

@@ -0,0 +1,3 @@
+import type { Translation } from "../types";
+export declare function setActiveTranslations(translations: Translation[] | null): void;
+export declare function addActiveTranslations(translations: Translation[] | Record<string, string> | null): number;

package/dist/utils/markerEngineTranslations.js

@@ -0,0 +1,49 @@
+import { normalizeWhitespace } from "./markerEngineDomUtils";
+import { getActiveTranslationMap, setActiveTranslationMap } from "./markerEngineState";
+export function setActiveTranslations(translations) {
+    if (!translations || translations.length === 0) {
+        setActiveTranslationMap(null);
+        return;
+    }
+    const map = new Map();
+    for (const t of translations) {
+        const source = normalizeWhitespace((t?.source_text || "").toString());
+        const translated = (t?.translated_text ?? "").toString();
+        if (!source || !translated)
+            continue;
+        map.set(source, translated);
+    }
+    setActiveTranslationMap(map);
+}
+export function addActiveTranslations(translations) {
+    if (!translations)
+        return 0;
+    const map = getActiveTranslationMap() ?? new Map();
+    let added = 0;
+    if (Array.isArray(translations)) {
+        for (const t of translations) {
+            const source = normalizeWhitespace((t?.source_text || "").toString());
+            const translated = (t?.translated_text ?? "").toString();
+            if (!source || !translated)
+                continue;
+            if (map.get(source) === translated)
+                continue;
+            map.set(source, translated);
+            added += 1;
+        }
+    }
+    else {
+        for (const [keyRaw, valueRaw] of Object.entries(translations || {})) {
+            const source = normalizeWhitespace((keyRaw || "").toString());
+            const translated = (valueRaw ?? "").toString();
+            if (!source || !translated)
+                continue;
+            if (map.get(source) === translated)
+                continue;
+            map.set(source, translated);
+            added += 1;
+        }
+    }
+    setActiveTranslationMap(map);
+    return added;
+}

package/dist/utils/markerEngineTypes.d.ts

@@ -0,0 +1,62 @@
+export type MarkerStats = {
+    totalTextNodes: number;
+    markedNodes: number;
+    skippedUnsafeNodes: number;
+    skippedExcludedNodes: number;
+    skippedNonTranslatableNodes: number;
+    totalChars: number;
+    markedChars: number;
+    skippedUnsafeChars: number;
+    skippedExcludedChars: number;
+    skippedNonTranslatableChars: number;
+    coverageRatio: number;
+    coverageRatioChars: number;
+};
+export type MarkerEngineOptions = {
+    throttleMs?: number;
+};
+export type DomScanOccurrence = {
+    source_text: string;
+    semantic_context?: string;
+};
+export type DomScanSegment = {
+    kind: "text" | "title" | "aria-label" | "placeholder";
+    selector: string | null;
+    original: string | null;
+    current: string | null;
+    html: null;
+};
+export type DomScanResult = {
+    version: 1;
+    stats: MarkerStats;
+    segments: DomScanSegment[];
+    occurrences: DomScanOccurrence[];
+    critical_occurrences?: DomScanOccurrence[];
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    truncated: boolean;
+};
+export type DomMiss = {
+    source_text: string;
+    semantic_context: string;
+};
+export type DomMissScanResult = {
+    misses: DomMiss[];
+};
+export type CriticalFingerprint = {
+    critical_count: number;
+    critical_hash: string;
+    viewport: {
+        width: number;
+        height: number;
+    };
+};
+export type TextOriginal = {
+    raw: string;
+    trimmed: string;
+    leading: string;
+    trailing: string;
+    id: string;
+};

package/dist/utils/markerEngineTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/markerEngineViewport.d.ts

@@ -0,0 +1,2 @@
+export declare function isInViewport(rect: DOMRect | null, viewportHeight: number, bufferPx: number): boolean;
+export declare function getTextNodeRect(node: Text): DOMRect | null;

package/dist/utils/markerEngineViewport.js

@@ -0,0 +1,27 @@
+export function isInViewport(rect, viewportHeight, bufferPx) {
+    if (!rect)
+        return false;
+    if (!Number.isFinite(rect.top) || !Number.isFinite(rect.bottom))
+        return false;
+    if (rect.width <= 0 || rect.height <= 0)
+        return false;
+    return rect.bottom > -bufferPx && rect.top < viewportHeight + bufferPx;
+}
+export function getTextNodeRect(node) {
+    try {
+        const range = document.createRange();
+        range.selectNodeContents(node);
+        const rect = range.getBoundingClientRect();
+        if (rect && rect.width > 0 && rect.height > 0)
+            return rect;
+    }
+    catch {
+        // ignore
+    }
+    try {
+        return node.parentElement ? node.parentElement.getBoundingClientRect() : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/utils/mergeEntitlements.d.ts

@@ -0,0 +1,2 @@
+import type { ProjectEntitlements } from "./apiTypes";
+export declare function mergeEntitlementsSeoEnabled(entitlements: ProjectEntitlements | null | undefined, seoEnabled: unknown): ProjectEntitlements | null;

package/dist/utils/mergeEntitlements.js

@@ -0,0 +1,7 @@
+export function mergeEntitlementsSeoEnabled(entitlements, seoEnabled) {
+    if (!entitlements)
+        return null;
+    if (typeof seoEnabled !== "boolean")
+        return entitlements;
+    return { ...entitlements, seoEnabled };
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.5.16";
+export declare const VERSION = "0.5.28";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "0.5.16";
+export const VERSION = "0.5.28";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lovalingo/lovalingo",
-  "version": "0.5.25",
+  "version": "0.5.28",
   "description": "React translation runtime with i18n routing, deterministic bundles + DOM rules, and zero-flash rendering.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/utils/translator.d.ts

@@ -1,80 +0,0 @@
-import { Translation, Exclusion } from '../types';
-export declare class Translator {
-    private translationMap;
-    private exclusions;
-    private nonTranslatableTerms;
-    constructor();
-    /**
-     * Check if element is interactive (should be preserved as island)
-     */
-    private isInteractive;
-    /**
-     * Check if text contains actual translatable content
-     */
-    private isTranslatableText;
-    /**
-     * Check if element should be treated as semantic boundary
-     * even though it's not in the predefined SEMANTIC_BOUNDARIES set
-     *
-     * Phase 1: Conservative approach - only leaf elements (no element children)
-     * This catches cases like: <span>text</span>, <div>text</div>, etc.
-     */
-    private shouldTreatAsSemantic;
-    private isLargeInteractiveContainer;
-    private sanitizePlaceholderMap;
-    private cleanupPreserveIds;
-    setTranslations(translations: Translation[]): void;
-    setExclusions(exclusions: Exclusion[]): void;
-    private isExcluded;
-    /**
-     * DOM-BASED EXTRACTION
-     * Uses DOM APIs to reliably parse and tokenize HTML
-     */
-    private extractTranslatableContent;
-    /**
-     * RECONSTRUCTION: Replace tokens with original HTML
-     */
-    private reconstructHTML;
-    /**
-     * Restore element to original HTML while preserving event listeners
-     */
-    private restoreElement;
-    /**
-     * Restore all elements to original state
-     */
-    restoreDOM(): void;
-    /**
-     * Mark all descendant elements with unique IDs before translation
-     * This allows us to reuse original DOM nodes (preserving event listeners)
-     */
-    private markElements;
-    /**
-     * After reconstruction, transplant original LIVE elements into new structure
-     * This preserves event listeners and framework connections
-     */
-    private transplantOriginalElements;
-    /**
-     * Directly update the parent element's children by transplanting from temp
-     * This avoids using innerHTML which would destroy event listeners
-     */
-    private updateElementChildren;
-    /**
-     * Update only text nodes within an element, preserving child elements
-     * Enhanced to handle nested structures recursively
-     */
-    private updateTextNodesOnly;
-    translateElement(element: HTMLElement): void;
-    /**
-     * Restore attribute to original value
-     */
-    private restoreAttribute;
-    /**
-     * Translate interactive element safely (preserves event handlers)
-     */
-    private translateInteractive;
-    /**
-     * Translate individual attributes
-     */
-    private translateAttribute;
-    translateDOM(): void;
-}