@lovalingo/lovalingo 0.5.25 → 0.5.28

package/dist/utils/api.js

@@ -1,57 +1,5 @@
+import { getNavigationResponseStatus, isOkHttpStatus, looksLikeNotFoundDocument, normalizeApiBase } from './apiUtils';
 import { warnDebug, errorDebug } from './logger';
-const OK_HTTP_STATUSES = new Set([200, 201]);
-const NOT_FOUND_TITLE_HINTS = /404|not found|page not found|page missing|does not exist|error 404/i;
-function getNavigationResponseStatus() {
-    if (typeof performance === "undefined" || typeof performance.getEntriesByType !== "function")
-        return null;
-    const entries = performance.getEntriesByType("navigation");
-    if (!entries || entries.length === 0)
-        return null;
-    const entry = entries[0];
-    const rawStatus = entry?.responseStatus;
-    const status = typeof rawStatus === "number" ? Math.floor(rawStatus) : NaN;
-    if (!Number.isFinite(status) || status <= 0)
-        return null;
-    return status;
-}
-// Why: avoid tracking misses/pageviews for non-OK responses (404/5xx) so bad routes don't pollute discovery.
-function isOkHttpStatus(status) {
-    if (typeof status !== "number")
-        return true;
-    return OK_HTTP_STATUSES.has(status);
-}
-function looksLikeNotFoundDocument() {
-    if (typeof document === "undefined")
-        return false;
-    const title = (document.title || "").toString().trim().toLowerCase();
-    if (title && NOT_FOUND_TITLE_HINTS.test(title))
-        return true;
-    const bodyText = (document.body?.textContent || "").toString().slice(0, 2000).toLowerCase();
-    if (!bodyText)
-        return false;
-    const has404 = /\b404\b/.test(bodyText);
-    const hasNotFound = /not found|page not found|page missing|does not exist|error 404/.test(bodyText);
-    return has404 && hasNotFound;
-}
-function normalizeApiBase(raw) {
-    const input = (raw || "").toString().trim();
-    if (!input)
-        return "https://cdn.lovalingo.com";
-    let base = input.replace(/\/functions\/v1\/?$/i, "").replace(/\/$/, "");
-    try {
-        const parsed = new URL(base);
-        const host = parsed.hostname.toLowerCase();
-        // Why: runtime endpoints moved off Supabase Edge Functions; fall back to CDN if a Supabase host is supplied.
-        if (host.endsWith(".supabase.co")) {
-            warnDebug("LovalingoAPI", `apiBase points to Supabase (${host}); falling back to https://cdn.lovalingo.com`);
-            return "https://cdn.lovalingo.com";
-        }
-    }
-    catch {
-        // Ignore parse errors and keep the raw base.
-    }
-    return base;
-}
 export class LovalingoAPI {
     constructor(apiKey, apiBase, pathConfig, editKey) {
         this.entitlements = null;

package/dist/utils/apiTypes.d.ts

@@ -0,0 +1,78 @@
+import type { DomRule } from "../types";
+export interface ProjectEntitlements {
+    tier: "starter" | "startup" | "global";
+    maxTargetLocales: number;
+    allowedTargetLocales: string[];
+    brandingRequired: boolean;
+    hreflangEnabled: boolean;
+    seoEnabled?: boolean;
+}
+export type SeoBundleResponse = {
+    locale?: string;
+    normalized_path?: string;
+    routing_strategy?: string;
+    seo?: Record<string, unknown>;
+    alternates?: {
+        canonical?: string;
+        xDefault?: string;
+        languages?: Record<string, string>;
+    };
+    seoEnabled?: boolean;
+    entitlements?: ProjectEntitlements;
+};
+export type BootstrapResponse = {
+    locale?: string;
+    normalized_path?: string;
+    routing_strategy?: string;
+    non_localized_paths?: Array<{
+        pattern?: string;
+        match_type?: string;
+        updated_at?: string | null;
+    }>;
+    inactive_pages?: Array<{
+        page_path?: string;
+        updated_at?: string | null;
+    }>;
+    loading_bg_color?: string | null;
+    branding_enabled?: boolean;
+    seoEnabled?: boolean;
+    entitlements?: ProjectEntitlements;
+    alternates?: {
+        canonical?: string;
+        xDefault?: string;
+        languages?: Record<string, string>;
+    } | null;
+    seo?: Record<string, unknown>;
+    jsonld?: Array<{
+        type: string;
+        json: unknown;
+        hash?: string;
+    }>;
+    dom_rules?: DomRule[];
+    exclusions?: unknown[];
+    critical?: {
+        map?: Record<string, string>;
+        keys?: number;
+        viewport?: unknown;
+        etag?: string;
+    };
+    etag?: string;
+};
+export type MissReportItem = {
+    source_text: string;
+    semantic_context?: string | null;
+};
+export type MissReportResponse = {
+    translations?: Array<{
+        source_text: string;
+        translated_text: string;
+    }>;
+    pii?: string[];
+    ignored?: boolean;
+    reason?: string;
+};
+export type MissReportOptions = {
+    pathOrUrl?: string;
+    sourceLocale?: string;
+    locales?: string[];
+};

package/dist/utils/apiTypes.js

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

package/dist/utils/apiUtils.d.ts

@@ -0,0 +1,4 @@
+export declare function getNavigationResponseStatus(): number | null;
+export declare function isOkHttpStatus(status: number | null): boolean;
+export declare function looksLikeNotFoundDocument(): boolean;
+export declare function normalizeApiBase(raw: string): string;

package/dist/utils/apiUtils.js

@@ -0,0 +1,54 @@
+import { warnDebug } from "./logger";
+const OK_HTTP_STATUSES = new Set([200, 201]);
+const NOT_FOUND_TITLE_HINTS = /404|not found|page not found|page missing|does not exist|error 404/i;
+export function getNavigationResponseStatus() {
+    if (typeof performance === "undefined" || typeof performance.getEntriesByType !== "function")
+        return null;
+    const entries = performance.getEntriesByType("navigation");
+    if (!entries || entries.length === 0)
+        return null;
+    const entry = entries[0];
+    const rawStatus = entry?.responseStatus;
+    const status = typeof rawStatus === "number" ? Math.floor(rawStatus) : NaN;
+    if (!Number.isFinite(status) || status <= 0)
+        return null;
+    return status;
+}
+// Why: avoid tracking misses/pageviews for non-OK responses (404/5xx) so bad routes don't pollute discovery.
+export function isOkHttpStatus(status) {
+    if (typeof status !== "number")
+        return true;
+    return OK_HTTP_STATUSES.has(status);
+}
+export function looksLikeNotFoundDocument() {
+    if (typeof document === "undefined")
+        return false;
+    const title = (document.title || "").toString().trim().toLowerCase();
+    if (title && NOT_FOUND_TITLE_HINTS.test(title))
+        return true;
+    const bodyText = (document.body?.textContent || "").toString().slice(0, 2000).toLowerCase();
+    if (!bodyText)
+        return false;
+    const has404 = /\b404\b/.test(bodyText);
+    const hasNotFound = /not found|page not found|page missing|does not exist|error 404/.test(bodyText);
+    return has404 && hasNotFound;
+}
+export function normalizeApiBase(raw) {
+    const input = (raw || "").toString().trim();
+    if (!input)
+        return "https://cdn.lovalingo.com";
+    let base = input.replace(/\/functions\/v1\/?$/i, "").replace(/\/$/, "");
+    try {
+        const parsed = new URL(base);
+        const host = parsed.hostname.toLowerCase();
+        // Why: runtime endpoints moved off Supabase Edge Functions; fall back to CDN if a Supabase host is supplied.
+        if (host.endsWith(".supabase.co")) {
+            warnDebug("LovalingoAPI", `apiBase points to Supabase (${host}); falling back to https://cdn.lovalingo.com`);
+            return "https://cdn.lovalingo.com";
+        }
+    }
+    catch {
+        // Ignore parse errors and keep the raw base.
+    }
+    return base;
+}

package/dist/utils/languageFlags.d.ts

@@ -0,0 +1,7 @@
+export declare function normalizeLocaleCode(locale: unknown): string;
+export declare function parseLocale(locale: unknown): {
+    language: string;
+    region: string | null;
+};
+export declare function countryCodeToFlagEmoji(countryCode: unknown): string | null;
+export declare function resolveLocaleFlag(locale: unknown): string;

package/dist/utils/languageFlags.js

@@ -0,0 +1,90 @@
+const EXACT_LOCALE_FLAG_OVERRIDES = {
+    en: "🇬🇧",
+    ar: "🇸🇦",
+    zh: "🇨🇳",
+    fa: "🇮🇷",
+    he: "🇮🇱",
+};
+const LANGUAGE_DEFAULT_REGION = {
+    ar: "SA",
+    bn: "BD",
+    cs: "CZ",
+    da: "DK",
+    de: "DE",
+    el: "GR",
+    en: "GB",
+    es: "ES",
+    fa: "IR",
+    fi: "FI",
+    fr: "FR",
+    he: "IL",
+    hi: "IN",
+    hu: "HU",
+    hy: "AM",
+    id: "ID",
+    it: "IT",
+    ja: "JP",
+    ko: "KR",
+    nl: "NL",
+    no: "NO",
+    pl: "PL",
+    pt: "PT",
+    ro: "RO",
+    ru: "RU",
+    sk: "SK",
+    sv: "SE",
+    th: "TH",
+    tr: "TR",
+    uk: "UA",
+    vi: "VN",
+    yo: "NG",
+    zh: "CN",
+};
+export function normalizeLocaleCode(locale) {
+    if (typeof locale !== "string")
+        return "";
+    return locale.trim().replace(/_/g, "-").toLowerCase();
+}
+export function parseLocale(locale) {
+    const normalized = normalizeLocaleCode(locale);
+    if (!normalized)
+        return { language: "", region: null };
+    const parts = normalized.split("-").filter(Boolean);
+    const language = parts[0] || "";
+    const regionPart = parts.find((part, index) => index > 0 && /^[a-z]{2}$/.test(part));
+    const region = regionPart ? regionPart.toUpperCase() : null;
+    return { language, region };
+}
+export function countryCodeToFlagEmoji(countryCode) {
+    if (typeof countryCode !== "string")
+        return null;
+    const normalized = countryCode.trim().toUpperCase();
+    if (!/^[A-Z]{2}$/.test(normalized))
+        return null;
+    const first = normalized.charCodeAt(0) + 127397;
+    const second = normalized.charCodeAt(1) + 127397;
+    return String.fromCodePoint(first, second);
+}
+export function resolveLocaleFlag(locale) {
+    const normalized = normalizeLocaleCode(locale);
+    if (!normalized)
+        return "🌐";
+    const exact = EXACT_LOCALE_FLAG_OVERRIDES[normalized];
+    if (exact)
+        return exact;
+    const { language, region } = parseLocale(normalized);
+    if (!language)
+        return "🌐";
+    if (region) {
+        const regionFlag = countryCodeToFlagEmoji(region);
+        if (regionFlag)
+            return regionFlag;
+    }
+    const defaultRegion = LANGUAGE_DEFAULT_REGION[language];
+    if (defaultRegion) {
+        const defaultFlag = countryCodeToFlagEmoji(defaultRegion);
+        if (defaultFlag)
+            return defaultFlag;
+    }
+    return "🌐";
+}

package/dist/utils/markerEngine.d.ts

@@ -1,70 +1,12 @@
-import type { Exclusion, Translation } from "../types";
-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;
-};
-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 declare function getCriticalFingerprint(): CriticalFingerprint;
+import type { Exclusion } from "../types";
+import type { MarkerEngineOptions, MarkerStats } from "./markerEngineTypes";
+import { applyActiveTranslations, restoreDom } from "./markerEngineApply";
+import { getCriticalFingerprint } from "./markerEngineCritical";
+import { scanDomForMisses } from "./markerEngineMisses";
+import { addActiveTranslations, setActiveTranslations } from "./markerEngineTranslations";
 export declare function startMarkerEngine(options?: MarkerEngineOptions): typeof stopMarkerEngine;
 export declare function stopMarkerEngine(): void;
 export declare function getMarkerStats(): MarkerStats;
 export declare function setMarkerEngineExclusions(exclusions: Exclusion[] | null): void;
-export declare function setActiveTranslations(translations: Translation[] | null): void;
-export declare function addActiveTranslations(translations: Translation[] | Record<string, string> | null): number;
-export declare function applyActiveTranslations(root?: ParentNode | null): number;
-export declare function scanDomForMisses(opts: {
-    max: number;
-    ignore?: Set<string>;
-}): DomMissScanResult;
-export declare function restoreDom(root?: ParentNode | null): void;
-export {};
+export { applyActiveTranslations, scanDomForMisses, restoreDom, setActiveTranslations, addActiveTranslations, getCriticalFingerprint };
+export type { MarkerStats, MarkerEngineOptions, DomScanOccurrence, DomScanSegment, DomScanResult, DomMiss, DomMissScanResult, CriticalFingerprint, } from "./markerEngineTypes";