@lingjingai/scriptctl 0.63.13 → 0.63.15

package/dist/infra/converters.js

@@ -1,689 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-import JSZip from "jszip";
-import { XMLParser } from "fast-xml-parser";
-import { fmtId, readText, sha256File, sha256Text, writeText, } from "../common.js";
-import { cleanEpisodeShortTitle, episodeNumberFromValue, isTechnicalEpisodeTitle, } from "./episode-title.js";
-function strOf(v) {
-    if (v === null || v === undefined)
-        return "";
-    return String(v);
-}
-function isDict(v) {
-    return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function isList(v) {
-    return Array.isArray(v);
-}
-function asList(v) {
-    return Array.isArray(v) ? v : [];
-}
-// ---------------------------------------------------------------------------
-// Text formats
-// ---------------------------------------------------------------------------
-export function convertTxt(source) {
-    return readText(source).replace(/^/, "");
-}
-export function rowsToMergedLines(rows) {
-    if (rows.length === 0)
-        return "";
-    const lines = [];
-    let prevScene = "";
-    for (let i = 1; i < rows.length; i++) {
-        const row = rows[i];
-        const nonEmpty = row.filter((c) => c);
-        if (nonEmpty.length === 0)
-            continue;
-        const first = row[0] ?? "";
-        if (first.includes("🎬") || /第\s*\d+\s*集/.test(first)) {
-            lines.push(`\n${first}`);
-            continue;
-        }
-        let scene = row.length > 1 ? row[1] ?? "" : "";
-        if (!scene)
-            scene = prevScene;
-        prevScene = scene;
-        const parts = [];
-        if (first)
-            parts.push(`${first}.`);
-        const remaining = row.slice(2).filter((c) => c);
-        if (scene && remaining.length > 0)
-            parts.push(`${scene}，${remaining.join("  ")}`);
-        else if (scene)
-            parts.push(scene);
-        else
-            parts.push(...remaining);
-        lines.push(parts.join(" "));
-    }
-    return lines.join("\n");
-}
-function attrOf(node, key) {
-    const attrs = node[":@"];
-    if (!isDict(attrs))
-        return "";
-    return strOf(attrs[key]).trim();
-}
-function firstChildNode(node, childName) {
-    for (const [key, value] of Object.entries(node)) {
-        if (localName(key) === childName && isList(value))
-            return value;
-    }
-    return null;
-}
-function textFromOrderedNodes(items) {
-    const parts = [];
-    const walk = (value) => {
-        if (!isList(value))
-            return;
-        for (const item of value) {
-            if (!isDict(item))
-                continue;
-            for (const [key, child] of Object.entries(item)) {
-                if (key === "#text" && child !== null && child !== undefined) {
-                    parts.push(strOf(child));
-                }
-                else if (key !== ":@" && isList(child)) {
-                    walk(child);
-                }
-            }
-        }
-    };
-    walk(items);
-    return parts.join("");
-}
-function parseXmlFile(xml) {
-    const parsed = xmlParser.parse(xml);
-    if (!isList(parsed))
-        throw new Error("xlsx xml part has an unexpected shape");
-    return parsed;
-}
-function findDescendantNodes(items, childName) {
-    const result = [];
-    const walk = (value) => {
-        const nodes = isList(value)
-            ? value.filter(isDict)
-            : isDict(value)
-                ? [value]
-                : [];
-        for (const item of nodes) {
-            for (const [key, child] of Object.entries(item)) {
-                if (localName(key) === childName && isList(child)) {
-                    result.push(item);
-                }
-                if (isList(child))
-                    walk(child);
-            }
-        }
-    };
-    walk(items);
-    return result;
-}
-function columnIndexFromRef(cellRef) {
-    const match = /^[A-Z]+/i.exec(cellRef.trim());
-    if (!match)
-        return null;
-    let index = 0;
-    for (const ch of match[0].toUpperCase()) {
-        index = index * 26 + ch.charCodeAt(0) - 64;
-    }
-    return index - 1;
-}
-function normalizeXlsxPartPath(baseDir, target) {
-    const rawPath = target.startsWith("/") ? target.slice(1) : `${baseDir}/${target}`;
-    const parts = rawPath.split("/");
-    const out = [];
-    for (const part of parts) {
-        if (!part || part === ".")
-            continue;
-        if (part === "..")
-            out.pop();
-        else
-            out.push(part);
-    }
-    return out.join("/");
-}
-async function readZipText(zip, partPath) {
-    const file = zip.file(partPath);
-    return file ? file.async("string") : null;
-}
-async function loadSharedStrings(zip) {
-    const xml = await readZipText(zip, "xl/sharedStrings.xml");
-    if (!xml)
-        return [];
-    const parsed = parseXmlFile(xml);
-    const strings = [];
-    for (const si of findDescendantNodes(parsed, "si")) {
-        strings.push(textFromOrderedNodes(firstChildNode(si, "si") ?? []));
-    }
-    return strings;
-}
-async function loadWorkbookSheets(zip) {
-    const workbookXml = await readZipText(zip, "xl/workbook.xml");
-    const relsXml = await readZipText(zip, "xl/_rels/workbook.xml.rels");
-    if (!workbookXml || !relsXml)
-        throw new Error("xlsx missing workbook metadata");
-    const rels = new Map();
-    for (const rel of findDescendantNodes(parseXmlFile(relsXml), "Relationship")) {
-        const id = attrOf(rel, "@_Id");
-        const target = attrOf(rel, "@_Target");
-        if (id && target)
-            rels.set(id, normalizeXlsxPartPath("xl", target));
-    }
-    const sheets = [];
-    for (const sheet of findDescendantNodes(parseXmlFile(workbookXml), "sheet")) {
-        const name = attrOf(sheet, "@_name");
-        const relId = attrOf(sheet, "@_r:id");
-        const sheetPath = rels.get(relId);
-        if (name && sheetPath)
-            sheets.push({ name, path: sheetPath });
-    }
-    if (sheets.length === 0)
-        throw new Error("xlsx workbook contains no readable sheets");
-    return sheets;
-}
-function cellText(cell, sharedStrings) {
-    const type = attrOf(cell, "@_t");
-    if (type === "inlineStr") {
-        const inline = findDescendantNodes(cell, "is")[0];
-        const inlineNodes = inline ? firstChildNode(inline, "is") : null;
-        return inlineNodes ? textFromOrderedNodes(inlineNodes).trim() : "";
-    }
-    const value = findDescendantNodes(cell, "v")[0];
-    const valueNode = value ? firstChildNode(value, "v") : null;
-    const rawValue = valueNode ? textFromOrderedNodes(valueNode).trim() : "";
-    if (!rawValue && type === "str") {
-        const formulaString = findDescendantNodes(cell, "is")[0];
-        const formulaNodes = formulaString ? firstChildNode(formulaString, "is") : null;
-        return formulaNodes ? textFromOrderedNodes(formulaNodes).trim() : "";
-    }
-    if (type === "s") {
-        const index = Number.parseInt(rawValue, 10);
-        return Number.isInteger(index) ? (sharedStrings[index] ?? "").trim() : "";
-    }
-    if (type === "b")
-        return rawValue === "1" ? "TRUE" : rawValue === "0" ? "FALSE" : rawValue;
-    if (type === "str")
-        return rawValue;
-    return rawValue;
-}
-async function sheetToRowsFromBuffer(buffer) {
-    const zip = await JSZip.loadAsync(buffer);
-    const [sharedStrings, sheets] = await Promise.all([
-        loadSharedStrings(zip),
-        loadWorkbookSheets(zip),
-    ]);
-    const result = [];
-    for (const sheet of sheets) {
-        const xml = await readZipText(zip, sheet.path);
-        if (!xml)
-            throw new Error(`xlsx missing worksheet part: ${sheet.path}`);
-        const rows = [];
-        for (const row of findDescendantNodes(parseXmlFile(xml), "row")) {
-            const cells = [];
-            for (const cell of findDescendantNodes(row, "c")) {
-                const ref = attrOf(cell, "@_r");
-                const index = ref ? columnIndexFromRef(ref) : null;
-                const text = cellText(cell, sharedStrings);
-                const targetIndex = index ?? cells.length;
-                while (cells.length < targetIndex)
-                    cells.push("");
-                cells[targetIndex] = text.trim();
-            }
-            if (cells.some((c) => c))
-                rows.push(cells);
-        }
-        result.push({ name: sheet.name, rows });
-    }
-    return result;
-}
-export async function convertXlsx(source) {
-    const buf = fs.readFileSync(source);
-    const sheets = await sheetToRowsFromBuffer(buf);
-    const parts = [];
-    for (const sheet of sheets) {
-        if (sheet.rows.length === 0)
-            continue;
-        parts.push(`## ${sheet.name}\n`);
-        parts.push(rowsToMergedLines(sheet.rows));
-    }
-    return parts.join("\n\n");
-}
-// ---------------------------------------------------------------------------
-// DOCX (jszip + fast-xml-parser)
-// ---------------------------------------------------------------------------
-const xmlParser = new XMLParser({
-    ignoreAttributes: false,
-    attributeNamePrefix: "@_",
-    preserveOrder: true,
-    trimValues: false,
-    textNodeName: "#text",
-});
-function localName(tag) {
-    const idx = tag.indexOf(":");
-    return idx >= 0 ? tag.slice(idx + 1) : tag;
-}
-function isParsedNode(node) {
-    return isDict(node);
-}
-function getChildren(node, tagPredicate) {
-    const out = [];
-    for (const key of Object.keys(node)) {
-        if (key.startsWith("@_") || key === "#text" || key === ":@")
-            continue;
-        if (tagPredicate(localName(key))) {
-            const value = node[key];
-            if (isList(value)) {
-                for (const item of value) {
-                    if (isParsedNode(item))
-                        out.push({ tag: key, node: item });
-                }
-            }
-            else if (isParsedNode(value)) {
-                out.push({ tag: key, node: value });
-            }
-        }
-    }
-    return out;
-}
-function paragraphText(paragraphNode) {
-    const parts = [];
-    function walk(items) {
-        if (!isList(items))
-            return;
-        for (const item of items) {
-            if (!isDict(item))
-                continue;
-            for (const [key, value] of Object.entries(item)) {
-                if (key === ":@")
-                    continue;
-                if (key === "#text" && typeof value === "string") {
-                    // ignore — we look at w:t below
-                    continue;
-                }
-                const local = localName(key);
-                if (local === "t") {
-                    if (isList(value)) {
-                        for (const inner of value) {
-                            if (isDict(inner)) {
-                                const txt = inner["#text"];
-                                if (typeof txt === "string")
-                                    parts.push(txt);
-                            }
-                        }
-                    }
-                }
-                else if (local === "tab") {
-                    parts.push("\t");
-                }
-                else if (local === "br" || local === "cr") {
-                    parts.push("\n");
-                }
-                else if (isList(value)) {
-                    walk(value);
-                }
-            }
-        }
-    }
-    walk(paragraphNode);
-    return parts.join("").trim();
-}
-function tableText(tableNode) {
-    const rows = [];
-    for (const item of tableNode) {
-        if (!isDict(item))
-            continue;
-        for (const [key, value] of Object.entries(item)) {
-            if (localName(key) !== "tr")
-                continue;
-            const cells = [];
-            if (isList(value)) {
-                for (const cellItem of value) {
-                    if (!isDict(cellItem))
-                        continue;
-                    for (const [ckey, cval] of Object.entries(cellItem)) {
-                        if (localName(ckey) !== "tc")
-                            continue;
-                        if (isList(cval)) {
-                            // find all w:p inside this w:tc
-                            const paragraphs = [];
-                            const collect = (items) => {
-                                if (!isList(items))
-                                    return;
-                                for (const x of items) {
-                                    if (!isDict(x))
-                                        continue;
-                                    for (const [k, v] of Object.entries(x)) {
-                                        if (localName(k) === "p" && isList(v)) {
-                                            const t = paragraphText(v);
-                                            if (t)
-                                                paragraphs.push(t);
-                                        }
-                                        else if (isList(v)) {
-                                            collect(v);
-                                        }
-                                    }
-                                }
-                            };
-                            collect(cval);
-                            cells.push(paragraphs.join(" ").trim());
-                        }
-                    }
-                }
-            }
-            if (cells.some((c) => c))
-                rows.push(cells);
-        }
-    }
-    return rowsToMergedLines(rows);
-}
-async function extractEmbeddedXlsx(zip) {
-    const results = [];
-    const xlsxFiles = [];
-    zip.forEach((relativePath) => {
-        if (relativePath.includes("embeddings") && relativePath.endsWith(".xlsx")) {
-            xlsxFiles.push(relativePath);
-        }
-    });
-    xlsxFiles.sort();
-    let index = 0;
-    for (const entry of xlsxFiles) {
-        index += 1;
-        const file = zip.file(entry);
-        if (!file)
-            continue;
-        const buf = await file.async("nodebuffer");
-        const sheets = await sheetToRowsFromBuffer(buf);
-        for (const sheet of sheets) {
-            if (sheet.rows.length > 0) {
-                results.push([`Embedded Sheet ${index}: ${sheet.name}`, rowsToMergedLines(sheet.rows)]);
-            }
-        }
-    }
-    return results;
-}
-export async function convertDocx(source) {
-    let zip;
-    try {
-        zip = await JSZip.loadAsync(fs.readFileSync(source));
-    }
-    catch (exc) {
-        throw new Error("source is not a valid docx zip file");
-    }
-    const documentXml = zip.file("word/document.xml");
-    if (!documentXml)
-        throw new Error("docx missing word/document.xml");
-    const xmlBytes = await documentXml.async("string");
-    const parsed = xmlParser.parse(xmlBytes);
-    // find <w:body> inside <w:document>
-    let body = null;
-    const findBody = (items) => {
-        if (!isList(items))
-            return;
-        for (const item of items) {
-            if (!isDict(item))
-                continue;
-            for (const [key, value] of Object.entries(item)) {
-                if (localName(key) === "body" && isList(value)) {
-                    body = value;
-                    return;
-                }
-                if (isList(value))
-                    findBody(value);
-            }
-        }
-    };
-    findBody(parsed);
-    const parts = [];
-    if (body === null) {
-        const collectParagraphs = (items) => {
-            if (!isList(items))
-                return;
-            for (const item of items) {
-                if (!isDict(item))
-                    continue;
-                for (const [key, value] of Object.entries(item)) {
-                    if (localName(key) === "p" && isList(value)) {
-                        const t = paragraphText(value);
-                        if (t)
-                            parts.push(t);
-                    }
-                    else if (isList(value)) {
-                        collectParagraphs(value);
-                    }
-                }
-            }
-        };
-        collectParagraphs(parsed);
-    }
-    else {
-        for (const child of body) {
-            if (!isDict(child))
-                continue;
-            for (const [key, value] of Object.entries(child)) {
-                if (key.startsWith("@_") || key === ":@" || key === "#text")
-                    continue;
-                if (!isList(value))
-                    continue;
-                const tag = localName(key);
-                if (tag === "p") {
-                    const t = paragraphText(value);
-                    if (t)
-                        parts.push(t);
-                }
-                else if (tag === "tbl") {
-                    const t = tableText(value);
-                    if (t)
-                        parts.push(t);
-                }
-            }
-        }
-    }
-    const embedded = await extractEmbeddedXlsx(zip);
-    for (const [label, markdown] of embedded) {
-        parts.push(`\n## ${label}\n`);
-        parts.push(markdown);
-    }
-    return [parts.join("\n\n"), embedded.length > 0];
-}
-// ---------------------------------------------------------------------------
-// JSON (script-like)
-// ---------------------------------------------------------------------------
-function assetIndex(items, idKey, nameKey, prefix) {
-    const result = new Map();
-    if (!isList(items))
-        return result;
-    for (let index = 0; index < items.length; index++) {
-        const item = items[index];
-        if (!isDict(item))
-            continue;
-        const rawId = item[idKey] ?? item["id"] ?? fmtId(prefix, index + 1);
-        const assetId = strOf(rawId).trim();
-        const rawName = item[nameKey] ?? item["name"] ?? assetId;
-        const name = strOf(rawName).trim();
-        if (assetId && name)
-            result.set(assetId, name);
-    }
-    return result;
-}
-function refId(ref, key) {
-    if (typeof ref === "string")
-        return ref;
-    if (isDict(ref))
-        return strOf(ref[key] ?? ref["id"]).trim();
-    return "";
-}
-function refNames(refs, index, key) {
-    if (!isList(refs))
-        return [];
-    const names = [];
-    for (const ref of refs) {
-        const name = index.get(refId(ref, key));
-        if (name && !names.includes(name))
-            names.push(name);
-    }
-    return names;
-}
-function firstRefName(refs, index, key) {
-    const names = refNames(refs, index, key);
-    return names[0] ?? "";
-}
-export async function convertJson(source) {
-    const text = readText(source).replace(/^/, "");
-    const data = JSON.parse(text);
-    if (!isDict(data) || !isList(data["episodes"])) {
-        throw new Error("JSON is not a script.json-like object with episodes[]");
-    }
-    const actors = assetIndex(data["actors"], "actor_id", "actor_name", "act");
-    const locations = assetIndex(data["locations"], "location_id", "location_name", "loc");
-    const props = assetIndex(data["props"], "prop_id", "prop_name", "prp");
-    const parts = [];
-    const title = strOf(data["title"] || path.basename(source, path.extname(source))).trim();
-    if (title)
-        parts.push(`# ${title}`);
-    const episodes = asList(data["episodes"]);
-    for (let epIndex = 0; epIndex < episodes.length; epIndex++) {
-        const episode = episodes[epIndex];
-        if (!isDict(episode))
-            continue;
-        const epNum = episodeNumberFromValue(episode["episode_id"]) ||
-            episodeNumberFromValue(episode["episode"]) ||
-            episodeNumberFromValue(episode["id"]) ||
-            epIndex + 1;
-        const rawEpTitle = strOf(episode["title"]).trim();
-        let epShortTitle = cleanEpisodeShortTitle(rawEpTitle);
-        if (isTechnicalEpisodeTitle(rawEpTitle))
-            epShortTitle = "";
-        parts.push(epShortTitle ? `\n第${epNum}集：${epShortTitle}` : `\n第${epNum}集`);
-        const scenes = asList(episode["scenes"]);
-        for (let sceneIndex = 0; sceneIndex < scenes.length; sceneIndex++) {
-            const scene = scenes[sceneIndex];
-            if (!isDict(scene))
-                continue;
-            const locName = firstRefName(scene["locations"], locations, "location_id") || "未知场景";
-            parts.push(`${epNum}-${sceneIndex + 1} 日 内 ${locName}`);
-            const actorNames = refNames(scene["actors"], actors, "actor_id");
-            if (actorNames.length > 0)
-                parts.push(`人物：${actorNames.join("、")}`);
-            const propNames = refNames(scene["props"], props, "prop_id");
-            if (propNames.length > 0)
-                parts.push(`道具：${propNames.join("、")}`);
-            for (const action of asList(scene["actions"])) {
-                if (!isDict(action))
-                    continue;
-                const content = strOf(action["content"]).trim();
-                if (!content)
-                    continue;
-                const actorName = actors.get(strOf(action["actor_id"]).trim()) ?? "";
-                if (action["type"] === "dialogue" && actorName) {
-                    parts.push(`${actorName}：${content}`);
-                }
-                else {
-                    parts.push(content);
-                }
-            }
-        }
-    }
-    return [parts.join("\n").trim() + "\n", false, "script"];
-}
-// ---------------------------------------------------------------------------
-// Source preparation
-// ---------------------------------------------------------------------------
-export async function prepareSource(sourcePath, workspace) {
-    const ext = path.extname(sourcePath).toLowerCase();
-    let content;
-    let hasStoryboard = false;
-    let explicitMode = null;
-    if (ext === ".txt" || ext === ".md") {
-        content = convertTxt(sourcePath);
-    }
-    else if (ext === ".json") {
-        const [text, sb, mode] = await convertJson(sourcePath);
-        content = text;
-        hasStoryboard = sb;
-        explicitMode = mode;
-    }
-    else if (ext === ".docx") {
-        const [text, sb] = await convertDocx(sourcePath);
-        content = text;
-        hasStoryboard = sb;
-    }
-    else if (ext === ".xlsx") {
-        content = await convertXlsx(sourcePath);
-    }
-    else {
-        throw new Error(`Unsupported file format: ${ext}`);
-    }
-    const sourceTextPath = path.join(workspace, "source.txt");
-    writeText(sourceTextPath, content);
-    const mode = explicitMode || (hasStoryboard ? "storyboard" : "script");
-    return {
-        projectName: path.basename(sourcePath, ext),
-        projectPath: path.resolve(workspace),
-        originalSourcePath: path.resolve(sourcePath),
-        sourceTextPath: path.resolve(sourceTextPath),
-        format: ext,
-        mode,
-        chars: Array.from(content).length,
-    };
-}
-export function makeSourceManifest(sourcePath, sourceTextPath, info) {
-    const text = readText(sourceTextPath);
-    const lineStarts = [];
-    let cursor = 0;
-    // Mirror Python splitlines(keepends=True)
-    const rawLines = [];
-    let start = 0;
-    let i = 0;
-    while (i < text.length) {
-        const ch = text[i];
-        if (ch === "\n") {
-            rawLines.push(text.slice(start, i + 1));
-            i += 1;
-            start = i;
-        }
-        else if (ch === "\r") {
-            if (text[i + 1] === "\n") {
-                rawLines.push(text.slice(start, i + 2));
-                i += 2;
-            }
-            else {
-                rawLines.push(text.slice(start, i + 1));
-                i += 1;
-            }
-            start = i;
-        }
-        else {
-            i += 1;
-        }
-    }
-    if (start < text.length)
-        rawLines.push(text.slice(start));
-    for (const raw of rawLines) {
-        lineStarts.push(cursor);
-        cursor += raw.length;
-    }
-    const linesNoEnd = text.split(/\r\n|\r|\n/);
-    if (text.endsWith("\n") || text.endsWith("\r"))
-        linesNoEnd.pop();
-    return {
-        version: 1,
-        source_path: path.resolve(sourcePath),
-        source_name: path.basename(sourcePath),
-        source_ext: path.extname(sourcePath).toLowerCase(),
-        source_sha256: sha256File(sourcePath),
-        source_text_path: path.resolve(sourceTextPath),
-        source_text_sha256: sha256Text(text),
-        chars: text.length,
-        lines: linesNoEnd.length,
-        line_starts: lineStarts,
-        prepare: {
-            mode: info["mode"],
-            format: info["format"],
-            chars: info["chars"],
-        },
-    };
-}
-// suppress unused warnings on Node Buffer/Uint8Array helpers
-void os;
-//# sourceMappingURL=converters.js.map