@stll/folio-core 0.0.1-placeholder.0 → 0.1.0

package/dist/prosemirror/plugins/templatePreviewValues.js

@@ -0,0 +1,117 @@
+import { scanDirectives } from "./templateDirectives.js";
+import { Plugin, PluginKey } from "prosemirror-state";
+import { Decoration, DecorationSet } from "prosemirror-view";
+//#region src/prosemirror/plugins/templatePreviewValues.ts
+/** Concatenated plain text of a preview value. */
+const templatePreviewValueText = (value) => typeof value === "string" ? value : value.runs.map((run) => run.text).join("");
+/** Stable identity of a preview value (text + formatting), for decoration
+*  keys and change detection. Distinguishes a plain string from a rich
+*  value with the same text. */
+const templatePreviewValueFingerprint = (value) => {
+	if (typeof value === "string") return value;
+	return value.runs.map((run) => `${run.bold === true ? "b" : ""}${run.italic === true ? "i" : ""}:${run.text}`).join("\0");
+};
+const KEY_HOLDER_SYMBOL = Symbol.for("stll.folio.templatePreviewValuesKey");
+const keyHolder = globalThis;
+const templatePreviewValuesKey = keyHolder[KEY_HOLDER_SYMBOL] ?? (keyHolder[KEY_HOLDER_SYMBOL] = new PluginKey("templatePreviewValues"));
+/** A rich span as DOM: text wrapped in `<em>` / `<strong>` per its flags. */
+function buildSpanNode(span) {
+	let node = document.createTextNode(span.text);
+	if (span.italic === true) {
+		const em = document.createElement("em");
+		em.append(node);
+		node = em;
+	}
+	if (span.bold === true) {
+		const strong = document.createElement("strong");
+		strong.append(node);
+		node = strong;
+	}
+	return node;
+}
+function buildValueWidget(value, mode) {
+	return () => {
+		const span = document.createElement("span");
+		span.className = mode === "highlighted" ? "folio-template-preview-value folio-template-preview-value--highlighted" : "folio-template-preview-value";
+		span.contentEditable = "false";
+		if (typeof value === "string") {
+			span.textContent = value;
+			return span;
+		}
+		for (const run of value.runs) span.append(buildSpanNode(run));
+		return span;
+	};
+}
+function collectPreviewEntries(doc, preview) {
+	if (!preview || Object.keys(preview.values).length === 0) return [];
+	const entries = [];
+	for (const range of scanDirectives(doc)) {
+		if (range.kind !== "placeholder" && range.kind !== "clause") continue;
+		const value = preview.values[range.expr];
+		if (value === void 0 || templatePreviewValueText(value) === "") continue;
+		entries.push({
+			from: range.from,
+			to: range.to,
+			expr: range.expr,
+			value
+		});
+	}
+	return entries;
+}
+function buildDecorationSet(doc, entries, mode) {
+	if (entries.length === 0) return DecorationSet.empty;
+	const decorations = [];
+	for (const entry of entries) decorations.push(Decoration.inline(entry.from, entry.to, { class: "folio-template-preview-original" }, {
+		inclusiveStart: false,
+		inclusiveEnd: false
+	}), Decoration.widget(entry.from, buildValueWidget(entry.value, mode), {
+		side: 1,
+		marks: [],
+		ignoreSelection: true,
+		key: `folio-template-preview-${entry.expr}-${entry.from}-${mode}-${templatePreviewValueFingerprint(entry.value)}`
+	}));
+	return DecorationSet.create(doc, decorations);
+}
+function createTemplatePreviewValuesPlugin() {
+	return new Plugin({
+		key: templatePreviewValuesKey,
+		state: {
+			init() {
+				return {
+					preview: null,
+					entries: [],
+					decorationSet: DecorationSet.empty
+				};
+			},
+			apply(tr, prev, _oldState, newState) {
+				const meta = tr.getMeta(templatePreviewValuesKey);
+				if (meta !== void 0) {
+					const entries = collectPreviewEntries(newState.doc, meta.preview);
+					return {
+						preview: meta.preview,
+						entries,
+						decorationSet: buildDecorationSet(newState.doc, entries, meta.preview?.mode ?? "plain")
+					};
+				}
+				if (tr.docChanged && prev.preview) {
+					const entries = collectPreviewEntries(newState.doc, prev.preview);
+					return {
+						preview: prev.preview,
+						entries,
+						decorationSet: buildDecorationSet(newState.doc, entries, prev.preview.mode)
+					};
+				}
+				return prev;
+			}
+		},
+		props: { decorations(state) {
+			return templatePreviewValuesKey.getState(state)?.decorationSet;
+		} }
+	});
+}
+/** Push (or clear, with `null`) the live fill preview into the editor. */
+const setTemplatePreviewValues = (view, preview) => {
+	view.dispatch(view.state.tr.setMeta(templatePreviewValuesKey, { preview }));
+};
+//#endregion
+export { createTemplatePreviewValuesPlugin, setTemplatePreviewValues, templatePreviewValueFingerprint, templatePreviewValueText, templatePreviewValuesKey };

package/dist/prosemirror/plugins/templateSlashMenu.d.ts

@@ -0,0 +1,57 @@
+import { EditorState, Plugin, PluginKey, Transaction } from "prosemirror-state";
+
+//#region src/prosemirror/plugins/templateSlashMenu.d.ts
+type TemplateSlashMenuState = {
+  active: false;
+  from: null;
+  to: null;
+  query: "";
+} | {
+  active: true;
+  from: number;
+  to: number;
+  query: string;
+};
+/**
+ * Keyboard intents the plugin forwards to the host while the menu is open. The
+ * host owns the highlighted row and the menu list, so it decides whether each
+ * key is consumed; returning `true` lets the plugin `preventDefault` the event.
+ */
+type TemplateSlashMenuKeyAction = "up" | "down" | "forward" | "back" | "commit" | "dismiss";
+type TemplateSlashMenuPluginOptions = {
+  /** Fires whenever the trigger state changes (open, query edit, close). */onChange?: (state: TemplateSlashMenuState) => void;
+  /**
+   * Resolve a navigation/commit key while the menu is open. Returns `true` when
+   * the host consumed it (so the plugin swallows the event).
+   *  - `up`/`down`    move the highlighted row.
+   *  - `forward`      ArrowRight: enter a submenu row.
+   *  - `back`         ArrowLeft: step out of a submenu.
+   *  - `commit`       Enter: the host inserts the marker, then dispatches a
+   *                   clearing transaction; the plugin does not mutate the doc.
+   *  - `dismiss`      Escape: the host backs out of a submenu and returns `true`
+   *                   to keep the menu open, or returns `false` to let the
+   *                   plugin tear the trigger down.
+   */
+  onKeyAction?: (action: TemplateSlashMenuKeyAction) => boolean;
+};
+declare const templateSlashMenuKey: PluginKey<TemplateSlashMenuState>;
+declare const templateSlashMenuPlugin: (options?: TemplateSlashMenuPluginOptions) => Plugin<TemplateSlashMenuState>;
+declare const getTemplateSlashMenu: (state: EditorState) => TemplateSlashMenuState;
+/** Clear the trigger. Set on the host's marker-insert transaction so the
+ *  insertion and the teardown commit together. */
+declare const clearTemplateSlashMenu: (tr: Transaction) => Transaction;
+/** Delete just the query chars typed after `/`, keeping the `/` and the trigger
+ *  active so a submenu can start its own search from a blank query. No-op (and
+ *  returns the unmodified state) when no trigger is active or the query is
+ *  already empty. */
+declare const resetTemplateSlashQuery: (state: EditorState) => Transaction | null;
+/** Delete the `/query` the author typed, returning the PM range it occupied so
+ *  the host can insert a marker in its place. Returns null when no trigger is
+ *  active. The returned transaction also clears the trigger state. */
+declare const consumeTemplateSlashQuery: (state: EditorState) => {
+  tr: Transaction;
+  from: number;
+  to: number;
+} | null;
+//#endregion
+export { TemplateSlashMenuKeyAction, TemplateSlashMenuPluginOptions, TemplateSlashMenuState, clearTemplateSlashMenu, consumeTemplateSlashQuery, getTemplateSlashMenu, resetTemplateSlashQuery, templateSlashMenuKey, templateSlashMenuPlugin };

package/dist/prosemirror/plugins/templateSlashMenu.js

@@ -0,0 +1,184 @@
+import { getTemplateDirectives } from "./templateDirectives.js";
+import { Plugin, PluginKey } from "prosemirror-state";
+//#region src/prosemirror/plugins/templateSlashMenu.ts
+const IDLE = {
+	active: false,
+	from: null,
+	to: null,
+	query: ""
+};
+const QUERY_CHAR = /[\p{L}\p{N}_.-]/u;
+const KEY_HOLDER_SYMBOL = Symbol.for("stll.folio.templateSlashMenuKey");
+const keyHolder = globalThis;
+const templateSlashMenuKey = keyHolder[KEY_HOLDER_SYMBOL] ?? (keyHolder[KEY_HOLDER_SYMBOL] = new PluginKey("templateSlashMenu"));
+/** Whether the char immediately before `pos` is a marker boundary (start of the
+*  text block or whitespace). This is the misfire guard: a `/` mid-token (dates,
+*  URLs, and/or) has a word char before it and never opens the menu. */
+const atTriggerBoundary = (state, pos) => {
+	const $pos = state.doc.resolve(pos);
+	const offset = $pos.parentOffset;
+	if (offset === 0) return true;
+	const before = $pos.parent.textBetween(offset - 1, offset, "\n", "\n");
+	return before === "" || /\s/u.test(before);
+};
+/** Whether `pos` falls strictly inside an existing template directive. The
+*  slash activations insert markers as raw text rather than going through
+*  `insertInline`'s overlap guard, so opening here would nest markers — e.g. a
+*  `/` typed after `#if ` inside `{{#if condition}}` could produce
+*  `{{#if {{field}}}}`, which the scanner/fill grammar cannot interpret.
+*  Boundaries are exclusive: a caret right before `{{` or after `}}` is fine. */
+const insideDirective = (state, pos) => getTemplateDirectives(state).some((range) => pos > range.from && pos < range.to);
+/** Whether the `/` that opened the trigger is still present at `from`. */
+const slashStillAt = (state, from) => {
+	if (from < 0 || from > state.doc.content.size) return false;
+	const $from = state.doc.resolve(from);
+	if ($from.parentOffset >= $from.parent.content.size) return false;
+	return $from.parent.textBetween($from.parentOffset, $from.parentOffset + 1, "\n", "\n") === "/";
+};
+/**
+* The query the author has typed, read from the tracked trigger RANGE
+* `[from, to]` rather than the caret. `to` is carried through every transaction
+* by position mapping (it grows as the author types at the query end), so the
+* query is immune to the paged editor's relayout selection churn — the caret can
+* momentarily land anywhere without affecting it. Because the range only ever
+* grows with typed input, it never swallows prose that already followed the `/`.
+*
+* Returns the query string, or `null` when the span contains a terminator (a
+* typed space or punctuation) — the command is over.
+*/
+const readRangeQuery = (state, from, to) => {
+	const start = from + 1;
+	if (to <= start) return "";
+	const text = state.doc.textBetween(start, to, "\n", "\n");
+	for (const char of text) if (!QUERY_CHAR.test(char)) return null;
+	return text;
+};
+const sameState = (a, b) => a.active === b.active && a.from === b.from && a.query === b.query;
+/**
+* Open the trigger at the collapsed caret if the guards pass: insert the `/`
+* and dispatch the open meta in one transaction (so the slash and the anchor
+* share one undo step), and return `true`. Shared by the keydown opener (the
+* path that fires in folio's paged hidden-view input pipeline) and the
+* `handleTextInput` opener (plain ProseMirror views / playground). Both guard
+* on the menu not already being active, so they never double-open or double
+* insert the `/`.
+*/
+const tryOpenTrigger = (view) => {
+	if (getTemplateSlashMenu(view.state).active) return false;
+	const { from } = view.state.selection;
+	if (!view.state.selection.empty || !atTriggerBoundary(view.state, from) || insideDirective(view.state, from)) return false;
+	const tr = view.state.tr.insertText("/", from);
+	tr.setMeta(templateSlashMenuKey, {
+		type: "open",
+		from,
+		query: ""
+	});
+	view.dispatch(tr);
+	return true;
+};
+const templateSlashMenuPlugin = (options = {}) => {
+	return new Plugin({
+		key: templateSlashMenuKey,
+		state: {
+			init: () => IDLE,
+			apply: (tr, value, _oldState, newState) => {
+				const meta = tr.getMeta(templateSlashMenuKey);
+				if (meta?.type === "clear") return IDLE;
+				if (meta?.type === "open") return {
+					active: true,
+					from: meta.from,
+					to: meta.from + 1,
+					query: meta.query
+				};
+				if (!value.active) return value;
+				const from = tr.mapping.map(value.from, -1);
+				const to = tr.mapping.map(value.to, 1);
+				if (!slashStillAt(newState, from)) return IDLE;
+				if (tr.selectionSet) {
+					const { selection } = newState;
+					if (!selection.empty || selection.from < from || selection.from > to) return IDLE;
+				}
+				const query = readRangeQuery(newState, from, to);
+				if (query === null) return IDLE;
+				return {
+					active: true,
+					from,
+					to,
+					query
+				};
+			}
+		},
+		view: () => ({ update: (editorView, prevState) => {
+			const prev = templateSlashMenuKey.getState(prevState) ?? IDLE;
+			const curr = templateSlashMenuKey.getState(editorView.state) ?? IDLE;
+			if (!sameState(prev, curr)) options.onChange?.(curr);
+		} }),
+		props: {
+			handleTextInput: (view, _from, _to, text) => {
+				if (text !== "/") return false;
+				return tryOpenTrigger(view);
+			},
+			handleKeyDown: (view, event) => {
+				const current = templateSlashMenuKey.getState(view.state) ?? IDLE;
+				if (!current.active && event.key === "/" && !event.metaKey && !event.ctrlKey && !event.altKey) {
+					if (tryOpenTrigger(view)) {
+						event.preventDefault();
+						return true;
+					}
+					return false;
+				}
+				if (!current.active) return false;
+				if (event.metaKey || event.ctrlKey || event.altKey || event.shiftKey) return false;
+				const action = keyToAction(event.key);
+				if (action === null) return false;
+				const handledByHost = options.onKeyAction?.(action) ?? false;
+				if (action === "dismiss" && !handledByHost) view.dispatch(clearTemplateSlashMenu(view.state.tr));
+				event.preventDefault();
+				return true;
+			}
+		}
+	});
+};
+const keyToAction = (key) => {
+	if (key === "ArrowUp") return "up";
+	if (key === "ArrowDown") return "down";
+	if (key === "ArrowRight") return "forward";
+	if (key === "ArrowLeft") return "back";
+	if (key === "Enter") return "commit";
+	if (key === "Escape") return "dismiss";
+	return null;
+};
+const getTemplateSlashMenu = (state) => templateSlashMenuKey.getState(state) ?? IDLE;
+/** Clear the trigger. Set on the host's marker-insert transaction so the
+*  insertion and the teardown commit together. */
+const clearTemplateSlashMenu = (tr) => tr.setMeta(templateSlashMenuKey, { type: "clear" });
+/** Delete just the query chars typed after `/`, keeping the `/` and the trigger
+*  active so a submenu can start its own search from a blank query. No-op (and
+*  returns the unmodified state) when no trigger is active or the query is
+*  already empty. */
+const resetTemplateSlashQuery = (state) => {
+	const current = getTemplateSlashMenu(state);
+	if (!current.active) return null;
+	const queryStart = current.from + 1;
+	const queryEnd = current.to;
+	if (queryEnd <= queryStart) return null;
+	return state.tr.delete(queryStart, queryEnd);
+};
+/** Delete the `/query` the author typed, returning the PM range it occupied so
+*  the host can insert a marker in its place. Returns null when no trigger is
+*  active. The returned transaction also clears the trigger state. */
+const consumeTemplateSlashQuery = (state) => {
+	const current = getTemplateSlashMenu(state);
+	if (!current.active) return null;
+	const from = current.from;
+	const to = current.to;
+	const tr = state.tr.delete(from, to);
+	clearTemplateSlashMenu(tr);
+	return {
+		tr,
+		from,
+		to
+	};
+};
+//#endregion
+export { clearTemplateSlashMenu, consumeTemplateSlashQuery, getTemplateSlashMenu, resetTemplateSlashQuery, templateSlashMenuKey, templateSlashMenuPlugin };

package/dist/prosemirror/schema/index.d.ts

@@ -0,0 +1,15 @@
+import { ExtensionManager } from "../extensions/ExtensionManager.js";
+import { BlockSdtAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, ImagePositionAttrs, MathAttrs, ParagraphAttrs, SdtAttrs, ShapeAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs } from "./nodes.js";
+import { CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, RunFormattingOverrideAttrs, RunShadingAttrs, StrikeAttrs, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, UnderlineAttrs } from "./marks.js";
+
+//#region src/prosemirror/schema/index.d.ts
+declare const singletonManager: ExtensionManager;
+declare const schema: import("prosemirror-model").Schema<any, any>;
+/**
+ * Export types for convenience
+ */
+type DocxSchema = typeof schema;
+type DocxNode = ReturnType<typeof schema.node>;
+type DocxMark = ReturnType<typeof schema.mark>;
+//#endregion
+export { type BlockSdtAttrs, type CharacterSpacingAttrs, type CharacterStyleAttrs, type CommentAttrs, DocxMark, DocxNode, DocxSchema, type EmphasisMarkAttrs, type FieldAttrs, type FontFamilyAttrs, type FontSizeAttrs, type FootnoteRefAttrs, type HardBreakAttrs, type HighlightAttrs, type HyperlinkAttrs, type ImageAttrs, type ImagePositionAttrs, type MathAttrs, type ParagraphAttrs, type RunFormattingOverrideAttrs, type RunShadingAttrs, type SdtAttrs, type ShapeAttrs, type StrikeAttrs, type TableAttrs, type TableCellAttrs, type TableRowAttrs, type TextBoxAttrs, type TextColorAttrs, type TextEffectAttrs, type TrackedChangeMarkAttrs, type UnderlineAttrs, schema, singletonManager };

package/dist/prosemirror/schema/index.js

@@ -0,0 +1,20 @@
+import { ExtensionManager } from "../extensions/ExtensionManager.js";
+import { createStarterKit } from "../extensions/StarterKit.js";
+//#region src/prosemirror/schema/index.ts
+/**
+* ProseMirror Schema for DOCX Editor
+*
+* Singleton ExtensionManager that builds the schema and initializes runtime.
+* Legacy code imports `schema` and commands from here; new code should use
+* ExtensionManager directly.
+*/
+/**
+* Singleton ExtensionManager — builds schema + initializes runtime (plugins, commands, keymaps)
+*/
+const mgr = new ExtensionManager(createStarterKit());
+mgr.buildSchema();
+mgr.initializeRuntime();
+const singletonManager = mgr;
+const schema = mgr.getSchema();
+//#endregion
+export { schema, singletonManager };

package/dist/prosemirror/schema/marks.d.ts

@@ -0,0 +1,118 @@
+import { document_d_exports } from "../../types/document.js";
+import { ShadingProperties } from "../../types/colors.js";
+
+//#region src/prosemirror/schema/marks.d.ts
+/**
+ * Text color mark attributes
+ */
+type TextColorAttrs = {
+  rgb?: string;
+  themeColor?: document_d_exports.ThemeColorSlot;
+  themeTint?: string;
+  themeShade?: string;
+};
+/**
+ * Underline mark attributes
+ */
+type UnderlineAttrs = {
+  style?: document_d_exports.UnderlineStyle;
+  color?: TextColorAttrs;
+};
+type StrikeAttrs = {
+  double?: boolean;
+};
+/**
+ * Font size mark attributes
+ */
+type FontSizeAttrs = {
+  size: number;
+};
+/**
+ * Font family mark attributes
+ */
+type FontFamilyAttrs = {
+  ascii?: string;
+  hAnsi?: string;
+  eastAsia?: string;
+  cs?: string;
+  asciiTheme?: string;
+  hAnsiTheme?: string;
+  eastAsiaTheme?: string;
+  csTheme?: string;
+};
+type HighlightAttrs = {
+  color: NonNullable<document_d_exports.TextFormatting["highlight"]>;
+};
+/**
+ * Run-level shading mark attributes (w:shd). Carries the shading FILL as a
+ * flattened ColorValue (mirroring TextColorAttrs) plus the pattern. The default
+ * `clear` pattern is never stored (absence ⇒ the fill renders as a solid
+ * background and re-serializes to `w:val="clear"`); only non-clear patterns
+ * (`pct*`, stripes) are carried for export fidelity (`solid` is flattened into
+ * the fill). `patternColor` is the pattern foreground rgb (`w:shd w:color`),
+ * carried so a non-clear pattern's color survives export.
+ */
+type RunShadingAttrs = TextColorAttrs & {
+  pattern?: NonNullable<ShadingProperties["pattern"]>;
+  patternColor?: string;
+};
+type CharacterSpacingAttrs = {
+  spacing?: number;
+  position?: number;
+  scale?: number;
+  kerning?: number;
+};
+type EmphasisMarkAttrs = {
+  type?: Exclude<document_d_exports.EmphasisMark, "none">;
+};
+/**
+ * Text effect mark attributes (w:effect). The "none" sentinel is never marked;
+ * absence of the mark is the no-effect state.
+ */
+type TextEffectAttrs = {
+  effect: Exclude<document_d_exports.TextEffect, "none">;
+};
+type FootnoteRefAttrs = {
+  id: string | number;
+  noteType?: "footnote" | "endnote";
+  vertAlign?: "baseline" | "superscript";
+};
+type CommentAttrs = {
+  commentId: number;
+};
+type TrackedChangeMarkAttrs = {
+  revisionId: number;
+  author: string;
+  date?: string;
+  moveKind?: "moveTo" | "moveFrom";
+};
+type RunFormattingOverrideAttrs = { [K in keyof Pick<document_d_exports.TextFormatting, "bold" | "italic" | "strike" | "doubleStrike" | "allCaps" | "smallCaps" | "hidden" | "emboss" | "imprint" | "shadow" | "outline" | "rtl">]?: false } & {
+  underline?: "none";
+};
+/**
+ * Character style mark attributes (w:rStyle).
+ *
+ * `styleId` is the OOXML character style reference, carried so a styled run
+ * re-serializes as a style reference instead of losing the semantic link.
+ * `_styleRPr` is the style's own run properties snapshotted at load in mark
+ * normal form (the shape `marksToTextFormatting` produces); `fromProseDoc`
+ * subtracts values equal to this snapshot so style-provided formatting is not
+ * baked into the run as direct formatting on save. It is absent when the
+ * style was unknown at load — nothing was resolved, so nothing is subtracted
+ * and the reference round-trips verbatim.
+ */
+type CharacterStyleAttrs = {
+  styleId: string;
+  _styleRPr?: document_d_exports.TextFormatting;
+};
+/**
+ * Hyperlink mark attributes
+ */
+type HyperlinkAttrs = {
+  href: string;
+  tooltip?: string;
+  rId?: string;
+  _docxHyperlinkIndex?: number;
+};
+//#endregion
+export { CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, RunFormattingOverrideAttrs, RunShadingAttrs, StrikeAttrs, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, UnderlineAttrs };