@sutrata/editor 0.1.0

package/dist/file/docx-exporter.js

@@ -0,0 +1,494 @@
+import { Document, Packer, Paragraph, TextRun, Table, TableRow, TableCell, AlignmentType, BorderStyle, PageBreak, WidthType, TabStopType, LineRuleType, Header, PageNumber, } from 'docx';
+import { resolveStyle } from '../styles/registry';
+import { styleToDocxParagraphStyles } from '../styles/docx-adapter';
+import { SCRIPT_UNICODE_RANGES } from '../styles/script-ranges';
+import { DEFAULT_COVER_LAYOUT } from '../styles/types';
+/** Flatten inline span trees into flat formatting runs. `skipNotes` drops inline
+ *  `[[ ]]` note spans entirely (see the "Skip notes" export option). */
+function flattenSpans(spans, props = {}, skipNotes = false) {
+    const result = [];
+    for (const s of spans) {
+        if (s.type === 'text') {
+            result.push({ text: s.text, ...props });
+        }
+        else if (s.type === 'bold') {
+            result.push(...flattenSpans(s.spans, { ...props, bold: true }, skipNotes));
+        }
+        else if (s.type === 'italic') {
+            result.push(...flattenSpans(s.spans, { ...props, italic: true }, skipNotes));
+        }
+        else if (s.type === 'underline') {
+            result.push(...flattenSpans(s.spans, { ...props, underline: true }, skipNotes));
+        }
+        else if (s.type === 'note') {
+            if (skipNotes)
+                continue;
+            // Matches whole-line note styling (italic, brackets kept visible).
+            result.push({ text: `[[ ${s.text} ]]`, ...props, italic: true });
+        }
+    }
+    return result;
+}
+const SCRIPT_RANGES = Object.entries(SCRIPT_UNICODE_RANGES).map(([code, re]) => ({ code, re }));
+const SCRIPT_FONT_BY_LANG = {
+    hi: 'Noto Sans Devanagari', ta: 'Noto Sans Tamil', te: 'Noto Sans Telugu',
+    kn: 'Noto Sans Kannada', ml: 'Noto Sans Malayalam', bn: 'Noto Sans Bengali',
+    gu: 'Noto Sans Gujarati', pa: 'Noto Sans Gurmukhi', or: 'Noto Sans Oriya',
+    si: 'Noto Sans Sinhala',
+};
+/** Which complex-script lang code (if any) a run's text belongs to \u2014 the shared key
+ *  space for both `complexScriptFontOverrides` and `italicScripts`. Unicode presence
+ *  wins over `defaultLang` (mixed-script documents), matching getComplexFont's
+ *  original priority.
+ *
+ *  The `defaultLang` fallback (for text with no script-specific characters at all,
+ *  e.g. bare punctuation/numbers between Indic words) must never fire for text that
+ *  contains actual Latin letters \u2014 otherwise a document with `lang: ta` would treat
+ *  every English word (scene headings, "EXT.", character extensions, a plain title)
+ *  as Tamil too, which for most styles is a harmless font substitution (Noto Sans/
+ *  Serif Tamil both ship full Latin glyphs) but is actively wrong once a style forces
+ *  italics for that script (Traditional) \u2014 English text would come out italicized
+ *  for no reason. */
+function matchScriptCode(text, defaultLang = 'en') {
+    for (const { code, re } of SCRIPT_RANGES) {
+        if (re.test(text))
+            return code;
+    }
+    if (/[A-Za-z]/.test(text))
+        return null;
+    return defaultLang in SCRIPT_FONT_BY_LANG ? defaultLang : null;
+}
+/** Resolve a complex-script font override for a matched script code. Returns null when
+ *  the text needs no override (plain Latin) \u2014 never a specific "Latin font" name, since
+ *  that decision belongs to the active style's fontFamily (applied at the paragraph-style
+ *  level). `overrides` is a style's optional `complexScriptFontOverrides` (e.g.
+ *  Traditional's Tamil -> Noto Serif Tamil) \u2014 DOCX runs can only ever name one font,
+ *  unlike a CSS font stack, so a style whose body font *does* cover a script it cares
+ *  about must say so explicitly here rather than relying on per-glyph fallback like the
+ *  editor/print CSS do. */
+function getComplexFont(code, overrides) {
+    if (!code)
+        return null;
+    return overrides?.[code] ?? SCRIPT_FONT_BY_LANG[code] ?? null;
+}
+/** Generate docx TextRun list with correct font mapping. `italicScripts` (a style's
+ *  per-script "italic is this script's standard look here" list, e.g. Traditional's
+ *  Tamil) forces italics regardless of the run's own markup or `forceItalics` \u2014 matches
+ *  the editor's `.cs-force-italic-<code>` behavior. */
+function createRuns(runProps, defaultLang, forceItalics = false, complexScriptFontOverrides, italicScripts) {
+    return runProps.map(r => {
+        const code = matchScriptCode(r.text, defaultLang);
+        const csFont = getComplexFont(code, complexScriptFontOverrides);
+        const scriptForcesItalic = code !== null && (italicScripts?.includes(code) ?? false);
+        const runOptions = {
+            text: r.text,
+            bold: r.bold,
+            italics: r.italic || forceItalics || scriptForcesItalic,
+            underline: r.underline ? {} : undefined,
+        };
+        // Only set font override for Indic scripts to support proper rendering,
+        // leaving latin/general characters to use the paragraph style's own font.
+        if (csFont) {
+            runOptions.font = {
+                ascii: csFont,
+                hAnsi: csFont,
+                cs: csFont,
+                eastAsia: csFont,
+            };
+        }
+        return new TextRun(runOptions);
+    });
+}
+/** Vertical placement of the 'corners' cover, as fractions of the printable page height:
+ *  where the title block starts and where the bottom-right date/contact block starts.
+ *  Matches print-adapter.ts's .print-cover-corners padding (20% top / block sitting ~6%
+ *  above the bottom edge), so the DOCX and PDF covers land in the same place. */
+const COVER_CORNERS_TOP_FRACTION = 0.22;
+const COVER_CORNERS_BOTTOM_FRACTION = 0.78;
+/** DOCX has no way to anchor a block to the bottom of a page, so the corner cover is
+ *  positioned by stacking empty paragraphs of an exact, known height (rather than
+ *  Normal-styled blank ones, whose height depends on the reader's default font). */
+const COVER_SPACER_TWIPS = 240; // 12pt
+/** Height budgeted per date/contact line — their run sizes (10pt/11pt) plus leading. */
+const COVER_CONTACT_LINE_TWIPS = 280;
+/** Enough exact-height spacers to cover `twips` (never negative — a block that already
+ *  overshoots its target simply gets none). */
+function spacerParagraphs(twips) {
+    const count = Math.max(0, Math.round(twips / COVER_SPACER_TWIPS));
+    return Array.from({ length: count }, () => new Paragraph({
+        spacing: { before: 0, after: 0, line: COVER_SPACER_TWIPS, lineRule: LineRuleType.EXACT },
+    }));
+}
+/** Approximate rendered height of a run of cover paragraphs, from their style's font
+ *  sizes and spacing. Approximate is enough: it only decides how many spacers separate
+ *  the two corner blocks, and the bottom block's placement is clamped so an
+ *  underestimate can't push it onto a second page. Assumes each element occupies one
+ *  line — a title or logline long enough to wrap just rides slightly lower. */
+function estimateBlockHeightTwips(style, keys) {
+    return keys.reduce((sum, key) => {
+        const el = style.elements[key];
+        return sum + Math.round(el.fontSizePt * 1.15 * 20) + Math.round((el.spaceBeforePt ?? 0) * 20)
+            + Math.round((el.spaceAfterPt ?? 0) * 20);
+    }, 0);
+}
+/** Main exporter function. `styleOverride` picks a style id for this export only
+ *  (without touching the document); otherwise the document's frontmatter `style:`
+ *  field is used, falling back to the default style. `customStyles` is the list of
+ *  user-imported styles loaded from IndexedDB (see file/storage.ts). `skipNotes` omits
+ *  both block-level and inline `[[ ]]` notes from the exported document. */
+export async function exportToDocx(ast, styleOverride, customStyles = [], skipNotes = false) {
+    const frontmatter = ast.frontmatter?.data;
+    const defaultLang = frontmatter?.['lang'] ?? 'en';
+    const style = resolveStyle(styleOverride ?? frontmatter?.['style'], customStyles);
+    const bodyFont = style.fontFamily;
+    const runsFor = (props, forceItalics = false) => createRuns(props, defaultLang, forceItalics, style.complexScriptFontOverrides, style.italicScripts);
+    const pageFormat = frontmatter?.['page']?.toLowerCase() ?? 'letter';
+    const pageWidthTwips = pageFormat === 'a4' ? 11906 : 12240;
+    const pageHeightTwips = pageFormat === 'a4' ? 16838 : 15840;
+    const pageMarginLeftTwips = Math.round(style.page.marginLeftIn * 1440);
+    const pageMarginRightTwips = Math.round(style.page.marginRightIn * 1440);
+    const pageMarginTopTwips = Math.round(style.page.marginTopIn * 1440);
+    const pageMarginBottomTwips = Math.round(style.page.marginBottomIn * 1440);
+    // Right edge of the printable area, measured from the page margin — where
+    // a scene number's right-aligned tab stop should land (matches the UI's
+    // right-aligned scene-number box, no leading "#").
+    const contentRightEdgeTwips = pageWidthTwips - pageMarginLeftTwips - pageMarginRightTwips;
+    const childrenNodes = [];
+    const hasCover = Boolean(frontmatter && (frontmatter['title'] || frontmatter['author']));
+    // 1. Cover Page (if frontmatter has title)
+    if (hasCover && frontmatter) {
+        const titleText = String(frontmatter['title'] || 'Untitled');
+        const authorText = String(frontmatter['author'] || '');
+        const loglineText = String(frontmatter['logline'] || '');
+        const dateText = String(frontmatter['date'] || '');
+        const contactText = String(frontmatter['contact'] || '');
+        const titlePara = new Paragraph({
+            style: 'CineTitle',
+            children: runsFor([{ text: titleText.toUpperCase(), bold: true }]),
+        });
+        const loglineParas = loglineText
+            ? loglineText.split('\n').map(line => new Paragraph({
+                style: 'CineLogline',
+                children: runsFor([{ text: line, italic: true }]),
+            }))
+            : [];
+        // Deliberately not the author style: these mirror the PDF cover's small gray
+        // date/contact lines (.print-cover-date / .print-cover-contact), not the
+        // author's display size.
+        const dateRun = (indent) => new Paragraph({
+            alignment: indent === undefined ? AlignmentType.CENTER : undefined,
+            indent: indent === undefined ? undefined : { left: indent },
+            children: [new TextRun({ text: dateText, font: bodyFont, size: 20, color: '777777' })],
+        });
+        const contactRuns = (indent) => contactText.split('\n').map(line => new Paragraph({
+            alignment: indent === undefined ? AlignmentType.CENTER : undefined,
+            indent: indent === undefined ? undefined : { left: indent },
+            children: [new TextRun({ text: line, font: bodyFont, size: 22, color: '888888' })],
+        }));
+        if ((style.coverLayout ?? DEFAULT_COVER_LAYOUT) === 'corners') {
+            // Title / "by <author>" / logline flush top-left, date + contact in the
+            // bottom-right corner — the PDF cover's .print-cover-corners layout, rebuilt
+            // out of the only vertical tool DOCX gives us: exact-height spacer paragraphs
+            // (see spacerParagraphs) counted off against the printable page height.
+            const contentHeightTwips = pageHeightTwips - pageMarginTopTwips - pageMarginBottomTwips;
+            const topBlock = [
+                titlePara,
+                ...(authorText ? [new Paragraph({
+                        style: 'CineAuthor',
+                        children: runsFor([{ text: `by ${authorText}` }]),
+                    })] : []),
+                ...loglineParas,
+            ];
+            const bottomIndent = Math.round(contentRightEdgeTwips * 0.55);
+            const bottomBlock = [
+                ...(dateText ? [dateRun(bottomIndent)] : []),
+                ...(contactText ? contactRuns(bottomIndent) : []),
+            ];
+            const topOffsetTwips = Math.round(contentHeightTwips * COVER_CORNERS_TOP_FRACTION);
+            const topSpacers = spacerParagraphs(topOffsetTwips);
+            childrenNodes.push(...topSpacers, ...topBlock);
+            // Fill down to the bottom block's target, but never past the point where the
+            // block itself would no longer fit — an overshoot would spill the corner onto
+            // a second cover page.
+            const usedTwips = topSpacers.length * COVER_SPACER_TWIPS
+                + estimateBlockHeightTwips(style, ['title', ...(authorText ? ['author'] : []), ...loglineParas.map(() => 'logline')]);
+            const bottomHeightTwips = bottomBlock.length * COVER_CONTACT_LINE_TWIPS;
+            const bottomTopTwips = Math.min(Math.round(contentHeightTwips * COVER_CORNERS_BOTTOM_FRACTION), contentHeightTwips - bottomHeightTwips);
+            childrenNodes.push(...spacerParagraphs(bottomTopTwips - usedTwips), ...bottomBlock);
+        }
+        else {
+            for (let k = 0; k < 12; k++) {
+                childrenNodes.push(new Paragraph({ text: '' }));
+            }
+            childrenNodes.push(titlePara);
+            childrenNodes.push(new Paragraph({ text: '' }));
+            childrenNodes.push(new Paragraph({
+                alignment: AlignmentType.CENTER,
+                children: [new TextRun({ text: 'by', font: bodyFont, size: 24 /* 12pt */ })],
+            }));
+            childrenNodes.push(new Paragraph({ text: '' }));
+            childrenNodes.push(new Paragraph({
+                style: 'CineAuthor',
+                children: runsFor([{ text: authorText }]),
+            }));
+            if (loglineParas.length > 0) {
+                for (let k = 0; k < 6; k++)
+                    childrenNodes.push(new Paragraph({ text: '' }));
+                childrenNodes.push(...loglineParas);
+            }
+            if (dateText) {
+                for (let k = 0; k < 10; k++)
+                    childrenNodes.push(new Paragraph({ text: '' }));
+                childrenNodes.push(dateRun());
+            }
+            if (contactText) {
+                if (!dateText) {
+                    for (let k = 0; k < 10; k++)
+                        childrenNodes.push(new Paragraph({ text: '' }));
+                }
+                else {
+                    childrenNodes.push(new Paragraph({ text: '' }));
+                    childrenNodes.push(new Paragraph({ text: '' }));
+                }
+                childrenNodes.push(...contactRuns());
+            }
+        }
+        childrenNodes.push(new Paragraph({ children: [new PageBreak()] }));
+    }
+    // Helper to process standard scene content node and return array of docx components
+    function processNode(n) {
+        if (n.type === 'action') {
+            const runs = runsFor(flattenSpans(n.spans, {}, skipNotes));
+            return [
+                new Paragraph({
+                    style: 'CineAction',
+                    children: runs,
+                }),
+            ];
+        }
+        if (n.type === 'character') {
+            const charName = n.name.toUpperCase();
+            const ext = n.extension ? ` ${n.extension.toUpperCase()}` : '';
+            const headText = `${charName}${ext}`;
+            const runs = runsFor([{ text: headText, bold: true }]);
+            const result = [
+                new Paragraph({
+                    style: 'CineCharacter',
+                    children: runs,
+                }),
+            ];
+            for (const c of n.children) {
+                if (c.type === 'parenthetical') {
+                    const pText = `(${c.text})`;
+                    result.push(new Paragraph({
+                        style: 'CineParenthetical',
+                        children: runsFor([{ text: pText }]),
+                    }));
+                }
+                else {
+                    const dialogueRuns = runsFor(flattenSpans(c.spans, {}, skipNotes));
+                    result.push(new Paragraph({
+                        style: 'CineDialogue',
+                        children: dialogueRuns,
+                    }));
+                }
+            }
+            return result;
+        }
+        if (n.type === 'transition') {
+            const transText = n.text.toUpperCase();
+            return [
+                new Paragraph({
+                    style: 'CineTransition',
+                    children: runsFor([{ text: transText }]),
+                }),
+            ];
+        }
+        if (n.type === 'centered') {
+            return [
+                new Paragraph({
+                    style: 'CineCentered',
+                    children: runsFor([{ text: n.text }]),
+                }),
+            ];
+        }
+        if (n.type === 'lyrics') {
+            const runs = runsFor(flattenSpans(n.spans, {}, skipNotes), true);
+            return [
+                new Paragraph({
+                    style: 'CineLyrics',
+                    children: runs,
+                }),
+            ];
+        }
+        if (n.type === 'note') {
+            if (skipNotes)
+                return [];
+            const noteText = `[[ ${n.text} ]]`;
+            return [
+                new Paragraph({
+                    style: 'CineNote',
+                    children: runsFor([{ text: noteText, italic: true }]),
+                }),
+            ];
+        }
+        if (n.type === 'comment') {
+            const commentText = `<!-- ${n.text} -->`;
+            return [
+                new Paragraph({
+                    style: 'CineComment',
+                    children: runsFor([{ text: commentText, italic: true }]),
+                }),
+            ];
+        }
+        if (n.type === 'page-break') {
+            return [new Paragraph({ children: [new PageBreak()] })];
+        }
+        if (n.type === 'dual-dialogue') {
+            const leftParas = [];
+            const leftChar = n.left;
+            const leftRuns = runsFor([{ text: `${leftChar.name.toUpperCase()}${leftChar.extension ? ` ${leftChar.extension.toUpperCase()}` : ''}`, bold: true }]);
+            leftParas.push(new Paragraph({ style: 'CineCharacter', children: leftRuns }));
+            for (const c of leftChar.children) {
+                if (c.type === 'parenthetical') {
+                    leftParas.push(new Paragraph({ style: 'CineParenthetical', children: runsFor([{ text: `(${c.text})` }]) }));
+                }
+                else {
+                    leftParas.push(new Paragraph({
+                        style: 'CineDialogue',
+                        children: runsFor(flattenSpans(c.spans, {}, skipNotes)),
+                    }));
+                }
+            }
+            const rightParas = [];
+            const rightChar = n.right;
+            const rightRuns = runsFor([{ text: `${rightChar.name.toUpperCase()}${rightChar.extension ? ` ${rightChar.extension.toUpperCase()}` : ''}`, bold: true }]);
+            rightParas.push(new Paragraph({ style: 'CineCharacter', children: rightRuns }));
+            for (const c of rightChar.children) {
+                if (c.type === 'parenthetical') {
+                    rightParas.push(new Paragraph({ style: 'CineParenthetical', children: runsFor([{ text: `(${c.text})` }]) }));
+                }
+                else {
+                    rightParas.push(new Paragraph({
+                        style: 'CineDialogue',
+                        children: runsFor(flattenSpans(c.spans, {}, skipNotes)),
+                    }));
+                }
+            }
+            return [
+                new Table({
+                    width: { size: 100, type: WidthType.PERCENTAGE },
+                    borders: {
+                        top: { style: BorderStyle.NONE, size: 0, color: 'auto' },
+                        bottom: { style: BorderStyle.NONE, size: 0, color: 'auto' },
+                        left: { style: BorderStyle.NONE, size: 0, color: 'auto' },
+                        right: { style: BorderStyle.NONE, size: 0, color: 'auto' },
+                        insideHorizontal: { style: BorderStyle.NONE, size: 0, color: 'auto' },
+                        insideVertical: { style: BorderStyle.NONE, size: 0, color: 'auto' },
+                    },
+                    rows: [
+                        new TableRow({
+                            children: [
+                                new TableCell({
+                                    children: leftParas,
+                                    width: { size: 50, type: WidthType.PERCENTAGE },
+                                }),
+                                new TableCell({
+                                    children: rightParas,
+                                    width: { size: 50, type: WidthType.PERCENTAGE },
+                                }),
+                            ],
+                        }),
+                    ],
+                }),
+            ];
+        }
+        return [];
+    }
+    // Iterate over children
+    for (const node of ast.children) {
+        if (node.type === 'section') {
+            const sectText = node.text;
+            childrenNodes.push(new Paragraph({
+                style: 'CineSection',
+                children: runsFor([{ text: sectText, bold: true }]),
+            }));
+            for (const subNode of node.children) {
+                childrenNodes.push(...processNode(subNode));
+            }
+        }
+        else if (node.type === 'scene-heading') {
+            const headingRuns = runsFor([{ text: node.text.toUpperCase(), bold: true }]);
+            if (node.id) {
+                headingRuns.push(new TextRun({ text: '\t' }), ...runsFor([{ text: node.id, bold: true }]));
+            }
+            childrenNodes.push(new Paragraph({
+                style: 'CineSceneHeading',
+                tabStops: node.id
+                    ? [{ type: TabStopType.RIGHT, position: contentRightEdgeTwips }]
+                    : undefined,
+                children: headingRuns,
+            }));
+            for (const subNode of node.children) {
+                childrenNodes.push(...processNode(subNode));
+            }
+        }
+        else {
+            childrenNodes.push(...processNode(node));
+        }
+    }
+    // Running header: "p<n>" in the top right, as a PAGE field so Word keeps it correct as
+    // the document is edited. The PDF export's other header cell — "<scene> CONTINUED:" on a
+    // page that opens mid-scene — has no DOCX equivalent: it depends on where the page break
+    // falls, and Word neither exposes that to a field nor lets a header vary per page within
+    // a section. (Only the cover is special-cased, via titlePage below.)
+    const runningHeader = new Header({
+        children: [
+            new Paragraph({
+                alignment: AlignmentType.RIGHT,
+                children: [
+                    new TextRun({
+                        children: ['p', PageNumber.CURRENT],
+                        font: bodyFont,
+                        size: Math.round(style.elements.action.fontSizePt * 2),
+                        italics: true,
+                    }),
+                ],
+            }),
+        ],
+    });
+    // Create document with screenplay styles driven by the resolved ScreenplayStyleDefinition
+    const doc = new Document({
+        styles: {
+            paragraphStyles: styleToDocxParagraphStyles(style, contentRightEdgeTwips),
+        },
+        sections: [
+            {
+                properties: {
+                    // The cover takes Word's "different first page" header (an empty one) and page
+                    // number 0, so the first page of the script itself comes out as p1.
+                    titlePage: hasCover,
+                    page: {
+                        size: {
+                            width: pageWidthTwips,
+                            height: pageHeightTwips,
+                        },
+                        margin: {
+                            top: pageMarginTopTwips,
+                            bottom: pageMarginBottomTwips,
+                            left: pageMarginLeftTwips,
+                            right: pageMarginRightTwips,
+                        },
+                        pageNumbers: hasCover ? { start: 0 } : undefined,
+                    },
+                },
+                headers: {
+                    default: runningHeader,
+                    ...(hasCover ? { first: new Header({ children: [new Paragraph({ text: '' })] }) } : {}),
+                },
+                children: childrenNodes,
+            },
+        ],
+    });
+    return Packer.toBlob(doc);
+}

package/dist/file/docx-importer.d.ts

@@ -0,0 +1,10 @@
+export interface DocxImportResult {
+    /** Reconstructed Sutra body text (no frontmatter), or null if nothing importable was found. */
+    bodyText: string | null;
+    warnings: string[];
+}
+/** Parses a .docx file (as produced by exportToDocx, possibly re-saved from Word with
+ *  corrections and/or font changes) back into Sutra body text. The title page, if any,
+ *  is not reimported — only content carrying the CineXxx paragraph styles the exporter
+ *  applies to the screenplay body is recognized. */
+export declare function importDocx(buffer: ArrayBuffer): Promise<DocxImportResult>;