@sutrata/editor 0.1.0

package/dist/editor/sutra-to-prosemirror.js

@@ -0,0 +1,154 @@
+import { schema } from './schema';
+function spansToNodes(spans) {
+    return spans.flatMap(span => {
+        if (span.type === 'text')
+            return span.text ? [schema.text(span.text)] : [];
+        if (span.type === 'note') {
+            if (!span.text)
+                return [];
+            const markType = schema.marks['note_mark'];
+            return [schema.text(span.text).mark([markType.create()])];
+        }
+        const inner = spansToNodes(span.spans);
+        const markType = schema.marks[span.type];
+        if (!markType || inner.length === 0)
+            return inner;
+        return inner.map(n => n.mark([markType.create()]));
+    });
+}
+function textNodes(text) {
+    const lines = text.split('\n');
+    const nodes = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line)
+            nodes.push(schema.text(line));
+        if (i < lines.length - 1)
+            nodes.push(schema.nodes['hard_break'].create());
+    }
+    return nodes;
+}
+function sceneContentToNodes(nodes) {
+    const result = [];
+    for (const node of nodes) {
+        switch (node.type) {
+            case 'action':
+                result.push(schema.nodes['action'].create({}, spansToNodes(node.spans)));
+                break;
+            case 'character': {
+                // Name, extension and dual-marker are rendered as one continuous
+                // text run — see character-decoration-plugin.ts, which recognizes
+                // a trailing "(...)"/"^" live and styles it, rather than storing
+                // them as separate node attrs.
+                const cueText = [node.name, node.extension, node.isDual ? '^' : null]
+                    .filter((part) => !!part)
+                    .join(' ');
+                result.push(schema.nodes['character'].create({}, textNodes(cueText)));
+                for (const child of node.children) {
+                    if (child.type === 'dialogue') {
+                        result.push(schema.nodes['dialogue'].create({}, spansToNodes(child.spans)));
+                    }
+                    else {
+                        result.push(schema.nodes['parenthetical'].create({}, textNodes(child.text)));
+                    }
+                }
+                break;
+            }
+            case 'dual-dialogue':
+                result.push(...sceneContentToNodes([node.left]));
+                result.push(...sceneContentToNodes([node.right]));
+                break;
+            case 'transition':
+                result.push(schema.nodes['transition'].create({}, textNodes(node.text)));
+                break;
+            case 'centered':
+                result.push(schema.nodes['centered'].create({}, textNodes(node.text)));
+                break;
+            case 'lyrics':
+                result.push(schema.nodes['lyrics'].create({}, spansToNodes(node.spans)));
+                break;
+            case 'note':
+                result.push(schema.nodes['note'].create({}, textNodes(node.text)));
+                break;
+            case 'comment':
+                result.push(schema.nodes['comment'].create({}, textNodes(node.text)));
+                break;
+            case 'page-break':
+                result.push(schema.nodes['page_break'].create());
+                break;
+        }
+    }
+    return result;
+}
+/**
+ * Frontmatter → title_page node. One frontmatter_field per key; one-level
+ * nested maps (multilingual title:) flatten to dotted keys ("title.hi").
+ */
+function frontmatterToNode(doc) {
+    const fm = doc.frontmatter;
+    if (!fm)
+        return null;
+    const fields = [];
+    for (const [key, value] of Object.entries(fm.data)) {
+        if (value !== null && typeof value === 'object') {
+            for (const [sub, subVal] of Object.entries(value)) {
+                fields.push(schema.nodes['frontmatter_field'].create({ fmKey: `${key}.${sub}` }, textNodes(String(subVal))));
+            }
+        }
+        else {
+            fields.push(schema.nodes['frontmatter_field'].create({ fmKey: key }, textNodes(String(value ?? ''))));
+        }
+    }
+    if (fields.length === 0)
+        return null;
+    return schema.nodes['title_page'].create({}, fields);
+}
+export function sutraToProsemirror(doc) {
+    const topNodes = [];
+    const titlePage = frontmatterToNode(doc);
+    if (titlePage)
+        topNodes.push(titlePage);
+    for (const node of doc.children) {
+        switch (node.type) {
+            case 'section':
+                topNodes.push(schema.nodes['section'].create({ level: node.level, id: node.id }, textNodes(node.text)));
+                break;
+            case 'scene-heading': {
+                const sceneNode = node;
+                topNodes.push(schema.nodes['scene_heading'].create({ id: sceneNode.id }, textNodes(sceneNode.text)));
+                for (const meta of sceneNode.metadata) {
+                    topNodes.push(schema.nodes['scene_metadata'].create({ metaKey: meta.key }, textNodes(meta.value)));
+                }
+                topNodes.push(...sceneContentToNodes(sceneNode.children));
+                break;
+            }
+            case 'action':
+                topNodes.push(schema.nodes['action'].create({}, spansToNodes(node.spans)));
+                break;
+            case 'transition':
+                topNodes.push(schema.nodes['transition'].create({}, textNodes(node.text)));
+                break;
+            case 'centered':
+                topNodes.push(schema.nodes['centered'].create({}, textNodes(node.text)));
+                break;
+            case 'lyrics':
+                topNodes.push(schema.nodes['lyrics'].create({}, spansToNodes(node.spans)));
+                break;
+            case 'note':
+                topNodes.push(schema.nodes['note'].create({}, textNodes(node.text)));
+                break;
+            case 'comment':
+                topNodes.push(schema.nodes['comment'].create({}, textNodes(node.text)));
+                break;
+            case 'page-break':
+                topNodes.push(schema.nodes['page_break'].create());
+                break;
+        }
+    }
+    // doc content is 'title_page? block+' — always need at least one body block
+    const hasBlock = topNodes.some(n => n.type.name !== 'title_page');
+    if (!hasBlock) {
+        topNodes.push(schema.nodes['action'].create({}, []));
+    }
+    return schema.nodes['doc'].create({}, topNodes);
+}

package/dist/editor/transliterate-input.d.ts

@@ -0,0 +1,10 @@
+import { Plugin } from 'prosemirror-state';
+/** Enable or disable transliteration mode. */
+export declare function setTranslitMode(enabled: boolean, lang?: string): void;
+/** Returns whether transliteration mode is active. */
+export declare function isTranslitMode(): boolean;
+/**
+ * ProseMirror plugin that intercepts text input and converts roman keystrokes
+ * to native script on word boundaries.
+ */
+export declare function createTranslitPlugin(): Plugin<any>;

package/dist/editor/transliterate-input.js

@@ -0,0 +1,88 @@
+import { Plugin } from 'prosemirror-state';
+import { transliterate } from '@sutra/parser';
+// Map BCP-47 codes to Script names used by the transliterate engine
+const LANG_TO_SCRIPT = {
+    'hi': 'devanagari',
+    'mr': 'devanagari',
+    'sa': 'devanagari',
+    'ta': 'tamil',
+    'te': 'telugu',
+    'kn': 'kannada',
+    'ml': 'malayalam',
+    'bn': 'bengali',
+    'gu': 'gujarati',
+    'pa': 'gurmukhi',
+    'or': 'odia',
+};
+// Word boundary characters — trigger transliteration
+const WORD_BOUNDARIES = new Set([' ', '\t', '\n', '.', ',', '?', '!', ':', ';', '-', '(', ')']);
+const globalState = {
+    enabled: false,
+    buffer: '',
+    currentLang: 'hi',
+};
+/** Enable or disable transliteration mode. */
+export function setTranslitMode(enabled, lang = 'hi') {
+    globalState.enabled = enabled;
+    globalState.currentLang = lang;
+    globalState.buffer = '';
+}
+/** Returns whether transliteration mode is active. */
+export function isTranslitMode() {
+    return globalState.enabled;
+}
+/**
+ * ProseMirror plugin that intercepts text input and converts roman keystrokes
+ * to native script on word boundaries.
+ */
+export function createTranslitPlugin() {
+    return new Plugin({
+        props: {
+            handleTextInput(view, _from, _to, text) {
+                if (!globalState.enabled)
+                    return false;
+                const script = LANG_TO_SCRIPT[globalState.currentLang];
+                if (!script)
+                    return false;
+                if (WORD_BOUNDARIES.has(text)) {
+                    // Flush buffer: transliterate and replace
+                    if (globalState.buffer.length > 0) {
+                        const native = transliterate(globalState.buffer, script);
+                        const { state, dispatch } = view;
+                        const { from } = state.selection;
+                        // Replace the buffered roman text with native script + boundary char
+                        const bufferStart = from - globalState.buffer.length;
+                        const tr = state.tr
+                            .replaceWith(bufferStart, from, state.schema.text(native + text));
+                        globalState.buffer = '';
+                        dispatch(tr);
+                        return true;
+                    }
+                    // Nothing buffered, let boundary char through
+                    return false;
+                }
+                else {
+                    // Accumulate roman keystrokes in buffer
+                    globalState.buffer += text;
+                    // Let ProseMirror insert the roman char temporarily (user sees buffering)
+                    return false;
+                }
+            },
+            handleKeyDown(_view, event) {
+                if (!globalState.enabled)
+                    return false;
+                // Backspace: remove from buffer too
+                if (event.key === 'Backspace' && globalState.buffer.length > 0) {
+                    globalState.buffer = globalState.buffer.slice(0, -1);
+                    return false; // let PM handle the actual deletion
+                }
+                // Escape: clear buffer without inserting
+                if (event.key === 'Escape') {
+                    globalState.buffer = '';
+                    return false;
+                }
+                return false;
+            },
+        },
+    });
+}

package/dist/extensions/storage-adapter.d.ts

@@ -0,0 +1,59 @@
+import type { VersionEntry } from '../types';
+import type { ScreenplayStyleDefinition } from '../styles/types';
+/**
+ * Injected by the embedder (OSS spec §11.5). The OSS app supplies a local
+ * implementation (IndexedDB + File System Access API, see @sutrata/app's
+ * local-storage-adapter.ts); Sutrata Cloud supplies a networked one.
+ *
+ * `handle` fields are opaque (`unknown`) on purpose: a web FileSystemFileHandle
+ * has no equivalent in a non-web adapter. Callers just thread whatever the
+ * adapter returned back into a later saveFile() call without inspecting it.
+ */
+export interface StorageAdapter {
+    saveDocument(path: string, content: string): Promise<void>;
+    loadDocument(path: string): Promise<string | null>;
+    listVersions(path: string): Promise<VersionEntry[]>;
+    openFile(): Promise<{
+        name: string;
+        content: string;
+        handle: unknown;
+    } | null>;
+    openDocx(): Promise<{
+        name: string;
+        buffer: ArrayBuffer;
+    } | null>;
+    openStyleJson(): Promise<{
+        name: string;
+        text: string;
+    } | null>;
+    saveFile(name: string, content: string, existingHandle?: unknown): Promise<{
+        savedName: string;
+        handle: unknown;
+    } | null>;
+    saveStyle(style: ScreenplayStyleDefinition): Promise<void>;
+    loadAllStyles(): Promise<ScreenplayStyleDefinition[]>;
+    deleteStyle(id: string): Promise<void>;
+    /**
+     * Optional: lets a restored session (see DocumentContext's boot-recovery
+     * effect) keep writing straight back to the file the user had open instead
+     * of forcing Save As. Adapters without a handle concept (Cloud, or a
+     * browser build with no persisted-handle support) simply omit these; the
+     * caller feature-detects with `?.`. `restoreFileHandle` should only ever
+     * return a handle that's usable without prompting — if permission would
+     * need to be re-requested, return null and let the user Save As instead.
+     */
+    persistFileHandle?(path: string, handle: unknown): Promise<void>;
+    restoreFileHandle?(path: string): Promise<unknown | null>;
+    /**
+     * Optional: delete all saved versions of a document. Used by the version
+     * history UI's "clear all versions" action.
+     */
+    deleteAllVersions?(path: string): Promise<void>;
+    /**
+     * Optional: save a version snapshot for a document. Adapters should only
+     * persist a new version entry when there is a difference against the previous version.
+     */
+    saveVersion?(path: string, content: string): Promise<boolean>;
+}
+export declare const StorageAdapterProvider: import("react").Provider<StorageAdapter | null>;
+export declare function useStorageAdapter(): StorageAdapter;

package/dist/extensions/storage-adapter.js

@@ -0,0 +1,9 @@
+import { createContext, useContext } from 'react';
+const StorageAdapterContext = createContext(null);
+export const StorageAdapterProvider = StorageAdapterContext.Provider;
+export function useStorageAdapter() {
+    const adapter = useContext(StorageAdapterContext);
+    if (!adapter)
+        throw new Error('useStorageAdapter must be used inside a StorageAdapterProvider (DocumentProvider supplies one)');
+    return adapter;
+}

package/dist/extensions/types.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Type-only extension-point surface (OSS spec §11.5). These declare the shape
+ * embedders (Sutrata Cloud, third-party plugins) will implement, but nothing
+ * in @sutrata/editor is wired to them yet — ai-client.ts and voice-service.ts
+ * are still direct imports within this package, not injected. Promoting them
+ * to real dependency-injected providers (matching StorageAdapter's pattern in
+ * ./storage-adapter.ts) is future work; see docs/TODO.
+ *
+ * [P1 interface, stable by P2] per the OSS spec — these shapes may still
+ * change before they're load-bearing.
+ */
+/** LLM completion with streaming; declares capabilities and data-policy text for disclosure. */
+export interface AIProvider {
+    id: string;
+    displayName: string;
+    dataPolicyText: string;
+    complete(prompt: string, opts?: {
+        stream?: boolean;
+    }): Promise<string>;
+}
+/** Speech-to-text. */
+export interface SpeechProvider {
+    id: string;
+    displayName: string;
+    transcribe(audio: Blob, opts?: {
+        language?: string;
+    }): Promise<string>;
+}
+/** Current user identity, permissions (read-only, comment, edit), feature flags. */
+export interface SessionContext {
+    userId: string | null;
+    displayName: string | null;
+    permission: 'read' | 'comment' | 'edit';
+    featureFlags: Record<string, boolean>;
+}
+/** Add side panels, inspector sections, and app-bar items; receives the AST and scene IDs. */
+export interface PanelRegistry {
+    registerPanel(panel: {
+        id: string;
+        title: string;
+        render: () => unknown;
+    }): void;
+}
+/** Add commands, menu items, keyboard shortcuts. */
+export interface CommandRegistry {
+    registerCommand(command: {
+        id: string;
+        label: string;
+        run: () => void;
+        shortcut?: string;
+    }): void;
+}
+/** Add export formats and report types. */
+export interface ExportRegistry {
+    registerExporter(exporter: {
+        id: string;
+        label: string;
+        run: (text: string) => Promise<Blob>;
+    }): void;
+}
+/** Hook to bind the editor state to an external real-time sync provider (e.g. a Yjs document). */
+export interface CollabBinding {
+    bind(): () => void;
+}
+/** Render external annotations (comments, breakdown highlights, revision marks) anchored to
+ *  scene IDs and text ranges. */
+export interface DecorationProvider {
+    getDecorations(sceneId: string): Array<{
+        from: number;
+        to: number;
+        className: string;
+    }>;
+}

package/dist/extensions/types.js

@@ -0,0 +1,12 @@
+/**
+ * Type-only extension-point surface (OSS spec §11.5). These declare the shape
+ * embedders (Sutrata Cloud, third-party plugins) will implement, but nothing
+ * in @sutrata/editor is wired to them yet — ai-client.ts and voice-service.ts
+ * are still direct imports within this package, not injected. Promoting them
+ * to real dependency-injected providers (matching StorageAdapter's pattern in
+ * ./storage-adapter.ts) is future work; see docs/TODO.
+ *
+ * [P1 interface, stable by P2] per the OSS spec — these shapes may still
+ * change before they're load-bearing.
+ */
+export {};

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

@@ -0,0 +1,8 @@
+import type { DocumentNode } from '@sutrata/parser';
+import type { ScreenplayStyleDefinition } from '../styles/types';
+/** 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 declare function exportToDocx(ast: DocumentNode, styleOverride?: string, customStyles?: ScreenplayStyleDefinition[], skipNotes?: boolean): Promise<Blob>;