vidspotai-shared 1.0.94 → 1.0.96

package/lib/utils/outreachTemplate.js

@@ -0,0 +1,174 @@
+"use strict";
+/**
+ * Outreach template utilities — shared between Firebase Functions (schema
+ * validation) and the node-express-server (fan-out processor).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTemplateVariables = extractTemplateVariables;
+exports.resolveTemplate = resolveTemplate;
+exports.resolvePlaceholdersDeep = resolvePlaceholdersDeep;
+exports.localizePlanText = localizePlanText;
+exports.generateLandingPageSlug = generateLandingPageSlug;
+const translation_service_1 = require("../services/translation/translation.service");
+const logger_1 = require("./logger");
+/** Extract {{variable}} names from a script template string. */
+function extractTemplateVariables(script) {
+    const matches = script.matchAll(/\{\{([a-zA-Z][a-zA-Z0-9_]*)\}\}/g);
+    const seen = new Set();
+    for (const m of matches) {
+        const name = m[1];
+        if (name)
+            seen.add(name);
+    }
+    return Array.from(seen);
+}
+/**
+ * Resolve a script template by substituting `{{varName}}` tokens with values
+ * from the `variables` map. Throws if a required variable is missing or empty.
+ */
+function resolveTemplate(scriptTemplate, variables) {
+    return scriptTemplate.replace(/\{\{([a-zA-Z][a-zA-Z0-9_]*)\}\}/g, (_, name) => {
+        const val = variables[name];
+        if (val === undefined || val === "") {
+            throw new Error(`Missing required template variable: {{${name}}}`);
+        }
+        return val;
+    });
+}
+/**
+ * Lenient variant of {@link resolveTemplate}: substitutes known `{{var}}` tokens
+ * and leaves unknown ones intact (no throw). Used for deep plan resolution where
+ * required-variable validation has already happened against the scriptTemplate.
+ */
+function resolveLenient(text, variables) {
+    return text.replace(/\{\{([a-zA-Z][a-zA-Z0-9_]*)\}\}/g, (whole, name) => {
+        const val = variables[name];
+        return val === undefined || val === "" ? whole : val;
+    });
+}
+/**
+ * Deep-clone `value` and substitute `{{variables}}` inside every string it
+ * contains (recursively through objects and arrays). Non-string leaves are
+ * copied as-is; unknown tokens are left intact.
+ *
+ * Reach uses this to personalize an authored produced-scene `VideoPlan` per
+ * recipient — resolving `{{name}}`/`{{company}}` in scene voiceover lines,
+ * overlay text, visual prompts and titles — without re-planning. The input must
+ * be JSON-serializable (VideoPlan is); functions/Dates are not supported.
+ */
+function resolvePlaceholdersDeep(value, variables) {
+    if (typeof value === "string") {
+        return resolveLenient(value, variables);
+    }
+    if (Array.isArray(value)) {
+        return value.map((v) => resolvePlaceholdersDeep(v, variables));
+    }
+    if (value !== null && typeof value === "object") {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = resolvePlaceholdersDeep(v, variables);
+        }
+        return out;
+    }
+    return value;
+}
+/**
+ * Normalize a BCP-47 locale to its primary language subtag, lowercased
+ * (e.g. "es-419" → "es", "pt_BR" → "pt"). Returns undefined for empty input.
+ */
+function primaryLang(locale) {
+    if (!locale)
+        return undefined;
+    const base = locale.trim().toLowerCase().split(/[-_]/)[0];
+    return base || undefined;
+}
+/**
+ * Translate the viewer-facing TEXT of a produced-scene {@link VideoPlan} into
+ * `toLocale` — the produced-scene half of Reach's multilingual wedge.
+ *
+ * Translates only what a viewer hears/reads: the plan `title`, each scene's
+ * `voiceoverLine`, `onScreenText`, and every `overlays[].text`. Visual `prompt`s
+ * and internal `intent`s are deliberately LEFT in the source language — those
+ * feed the video models, which expect (and were tuned on) English prompts.
+ *
+ * Behaviour:
+ * - No-ops (returns the input unchanged) when `toLocale` is absent or resolves
+ *   to the same primary language as `fromLocale`.
+ * - Dedupes repeated strings (watermarks/CTAs recur across scenes) so each
+ *   unique string is translated once, with bounded concurrency.
+ * - **Fails open per string:** a translation error keeps the original text
+ *   rather than throwing — a translation outage must never block a render.
+ *
+ * Returns a deep clone; the input plan is never mutated.
+ */
+async function localizePlanText(plan, toLocale, fromLocale = "en") {
+    const to = primaryLang(toLocale);
+    const from = primaryLang(fromLocale) ?? "en";
+    if (!to || to === from)
+        return plan;
+    // ── Collect unique translatable strings ──────────────────────────────────
+    const unique = new Set();
+    const collect = (s) => {
+        if (s && s.trim())
+            unique.add(s);
+    };
+    collect(plan.title);
+    for (const scene of plan.scenes) {
+        collect(scene.voiceoverLine);
+        collect(scene.onScreenText);
+        for (const ov of scene.overlays ?? [])
+            collect(ov.text);
+    }
+    if (unique.size === 0)
+        return plan;
+    // ── Translate each unique string once (bounded concurrency, fail-open) ────
+    const map = new Map();
+    const originals = Array.from(unique);
+    const CONCURRENCY = 5;
+    for (let i = 0; i < originals.length; i += CONCURRENCY) {
+        const batch = originals.slice(i, i + CONCURRENCY);
+        await Promise.all(batch.map(async (orig) => {
+            try {
+                const translated = await translation_service_1.translationService.translate(orig, from, to);
+                if (translated && translated.trim())
+                    map.set(orig, translated);
+            }
+            catch (err) {
+                logger_1.logger.warn("localizePlanText: string translation failed, keeping original", {
+                    toLocale: to,
+                    err: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }));
+    }
+    if (map.size === 0)
+        return plan;
+    // ── Apply onto a deep clone (prompt/intent stay in source language) ───────
+    const out = JSON.parse(JSON.stringify(plan));
+    const tr = (s) => s && map.has(s) ? map.get(s) : s;
+    out.title = tr(out.title);
+    for (const scene of out.scenes) {
+        scene.voiceoverLine = tr(scene.voiceoverLine);
+        scene.onScreenText = tr(scene.onScreenText);
+        if (scene.overlays) {
+            for (const ov of scene.overlays) {
+                const t = tr(ov.text);
+                if (t)
+                    ov.text = t;
+            }
+        }
+    }
+    return out;
+}
+/** Generate a short URL-safe slug for a landing page (16 chars, alphanumeric). */
+function generateLandingPageSlug() {
+    const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+    let slug = "";
+    const arr = new Uint8Array(16);
+    // Use Math.random-based fallback since crypto.getRandomValues may not exist in
+    // all Node envs; for uniqueness we rely on Firestore write-time collision checks.
+    for (let i = 0; i < 16; i++) {
+        slug += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return slug;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vidspotai-shared",
-  "version": "1.0.94",
+  "version": "1.0.96",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "exports": {