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

package/dist/prosemirror/extensions/marks/SmallCapsExtension.js

@@ -0,0 +1,24 @@
+import { createMarkExtension } from "../create.js";
+//#region src/prosemirror/extensions/marks/SmallCapsExtension.ts
+/**
+* Small Caps Mark Extension (w:smallCaps)
+*/
+const SmallCapsExtension = createMarkExtension({
+	name: "smallCaps",
+	schemaMarkName: "smallCaps",
+	markSpec: {
+		parseDOM: [{
+			style: "font-variant",
+			getAttrs: (value) => value === "small-caps" ? {} : false
+		}],
+		toDOM() {
+			return [
+				"span",
+				{ style: "font-variant: small-caps" },
+				0
+			];
+		}
+	}
+});
+//#endregion
+export { SmallCapsExtension };

package/dist/prosemirror/extensions/marks/StrikeExtension.d.ts

@@ -0,0 +1,9 @@
+import { MarkExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/marks/StrikeExtension.d.ts
+/**
+ * Strikethrough Mark Extension
+ */
+declare const StrikeExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { StrikeExtension };

package/dist/prosemirror/extensions/marks/StrikeExtension.js

@@ -0,0 +1,33 @@
+import { createMarkExtension } from "../create.js";
+import { panic } from "better-result";
+import { toggleMark } from "prosemirror-commands";
+//#region src/prosemirror/extensions/marks/StrikeExtension.ts
+/**
+* Strikethrough Mark Extension
+*/
+const StrikeExtension = createMarkExtension({
+	name: "strike",
+	schemaMarkName: "strike",
+	markSpec: {
+		attrs: { double: { default: false } },
+		parseDOM: [
+			{ tag: "s" },
+			{ tag: "strike" },
+			{ tag: "del" },
+			{
+				style: "text-decoration",
+				getAttrs: (value) => value.includes("line-through") ? {} : false
+			}
+		],
+		toDOM() {
+			return ["s", 0];
+		}
+	},
+	onSchemaReady(ctx) {
+		const strikeType = ctx.schema.marks["strike"];
+		if (!strikeType) panic("Missing mark type: strike");
+		return { commands: { toggleStrike: () => toggleMark(strikeType) } };
+	}
+});
+//#endregion
+export { StrikeExtension };

package/dist/prosemirror/extensions/marks/SubscriptExtension.d.ts

@@ -0,0 +1,9 @@
+import { MarkExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/marks/SubscriptExtension.d.ts
+/**
+ * Subscript Mark Extension
+ */
+declare const SubscriptExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { SubscriptExtension };

package/dist/prosemirror/extensions/marks/SubscriptExtension.js

@@ -0,0 +1,25 @@
+import { createMarkExtension } from "../create.js";
+import { panic } from "better-result";
+import { toggleMark } from "prosemirror-commands";
+//#region src/prosemirror/extensions/marks/SubscriptExtension.ts
+/**
+* Subscript Mark Extension
+*/
+const SubscriptExtension = createMarkExtension({
+	name: "subscript",
+	schemaMarkName: "subscript",
+	markSpec: {
+		excludes: "superscript",
+		parseDOM: [{ tag: "sub" }],
+		toDOM() {
+			return ["sub", 0];
+		}
+	},
+	onSchemaReady(ctx) {
+		const subscriptType = ctx.schema.marks["subscript"];
+		if (!subscriptType) panic("Missing mark type: subscript");
+		return { commands: { toggleSubscript: () => toggleMark(subscriptType) } };
+	}
+});
+//#endregion
+export { SubscriptExtension };

package/dist/prosemirror/extensions/marks/SuperscriptExtension.d.ts

@@ -0,0 +1,9 @@
+import { MarkExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/marks/SuperscriptExtension.d.ts
+/**
+ * Superscript Mark Extension
+ */
+declare const SuperscriptExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { SuperscriptExtension };

package/dist/prosemirror/extensions/marks/SuperscriptExtension.js

@@ -0,0 +1,25 @@
+import { createMarkExtension } from "../create.js";
+import { panic } from "better-result";
+import { toggleMark } from "prosemirror-commands";
+//#region src/prosemirror/extensions/marks/SuperscriptExtension.ts
+/**
+* Superscript Mark Extension
+*/
+const SuperscriptExtension = createMarkExtension({
+	name: "superscript",
+	schemaMarkName: "superscript",
+	markSpec: {
+		excludes: "subscript",
+		parseDOM: [{ tag: "sup" }],
+		toDOM() {
+			return ["sup", 0];
+		}
+	},
+	onSchemaReady(ctx) {
+		const superscriptType = ctx.schema.marks["superscript"];
+		if (!superscriptType) panic("Missing mark type: superscript");
+		return { commands: { toggleSuperscript: () => toggleMark(superscriptType) } };
+	}
+});
+//#endregion
+export { SuperscriptExtension };

package/dist/prosemirror/extensions/marks/TextColorExtension.d.ts

@@ -0,0 +1,9 @@
+import { MarkExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/marks/TextColorExtension.d.ts
+/**
+ * Text Color Mark Extension
+ */
+declare const TextColorExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { TextColorExtension };

package/dist/prosemirror/extensions/marks/TextColorExtension.js

@@ -0,0 +1,50 @@
+import { textToStyle } from "../../../utils/formatToStyle.js";
+import { expectTextColorMarkAttrs } from "../../attrs/index.js";
+import { createMarkExtension } from "../create.js";
+import { removeMark, setMark } from "./markUtils.js";
+import { panic } from "better-result";
+//#region src/prosemirror/extensions/marks/TextColorExtension.ts
+/**
+* Text Color Mark Extension
+*/
+const TextColorExtension = createMarkExtension({
+	name: "textColor",
+	schemaMarkName: "textColor",
+	markSpec: {
+		attrs: {
+			rgb: { default: null },
+			themeColor: { default: null },
+			themeTint: { default: null },
+			themeShade: { default: null }
+		},
+		parseDOM: [{
+			style: "color",
+			getAttrs: (value) => {
+				const hexMatch = /#(?<hex>[0-9a-fA-F]{6}|[0-9a-fA-F]{3})/u.exec(value);
+				if (hexMatch) return { rgb: (hexMatch.groups?.["hex"] ?? "").toUpperCase() };
+				return false;
+			}
+		}],
+		toDOM(mark) {
+			const cssColor = textToStyle({ color: expectTextColorMarkAttrs(mark) }).color;
+			return [
+				"span",
+				{ style: typeof cssColor === "string" && cssColor ? `color: ${cssColor}` : "" },
+				0
+			];
+		}
+	},
+	onSchemaReady(ctx) {
+		const textColorType = ctx.schema.marks["textColor"];
+		if (!textColorType) panic("Missing mark type: textColor");
+		return { commands: {
+			setTextColor: (attrs) => {
+				if (!attrs.rgb && !attrs.themeColor) return removeMark(textColorType);
+				return setMark(textColorType, attrs);
+			},
+			clearTextColor: () => removeMark(textColorType)
+		} };
+	}
+});
+//#endregion
+export { TextColorExtension };

package/dist/prosemirror/extensions/marks/TextEffectExtension.d.ts

@@ -0,0 +1,6 @@
+import { MarkExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/marks/TextEffectExtension.d.ts
+declare const TextEffectExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { TextEffectExtension };

package/dist/prosemirror/extensions/marks/TextEffectExtension.js

@@ -0,0 +1,35 @@
+import { TEXT_EFFECT_VALUES } from "../../../types/documentEnumValues.js";
+import { expectTextEffectMarkAttrs } from "../../attrs/index.js";
+import { createMarkExtension } from "../create.js";
+//#region src/prosemirror/extensions/marks/TextEffectExtension.ts
+const VARIANTS = TEXT_EFFECT_VALUES.filter((value) => value !== "none");
+const isVariant = (value) => value !== null && VARIANTS.includes(value);
+const TextEffectExtension = createMarkExtension({
+	name: "textEffect",
+	schemaMarkName: "textEffect",
+	markSpec: {
+		attrs: { effect: {} },
+		parseDOM: [{
+			tag: "span[data-effect]",
+			getAttrs: (dom) => {
+				if (typeof dom === "string") return false;
+				const value = dom.getAttribute("data-effect");
+				if (!isVariant(value)) return false;
+				return { effect: value };
+			}
+		}],
+		toDOM(mark) {
+			const { effect } = expectTextEffectMarkAttrs(mark);
+			return [
+				"span",
+				{
+					class: `docx-text-effect docx-text-effect-${effect}`,
+					"data-effect": effect
+				},
+				0
+			];
+		}
+	}
+});
+//#endregion
+export { TextEffectExtension };

package/dist/prosemirror/extensions/marks/TextEffectsExtensions.d.ts

@@ -0,0 +1,31 @@
+import { MarkExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/marks/TextEffectsExtensions.d.ts
+/**
+ * Additional Text Effect Mark Extensions
+ *
+ * Emboss (w:emboss), Imprint/Engrave (w:imprint), Text Shadow (w:shadow),
+ * Emphasis Marks (w:em), Text Outline (w:outline)
+ */
+/**
+ * Emboss — raised text effect via text-shadow
+ */
+declare const EmbossExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+/**
+ * Imprint/Engrave — engraved text effect via text-shadow
+ */
+declare const ImprintExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+/**
+ * Text Shadow (w:shadow) — subtle drop shadow on text
+ */
+declare const TextShadowExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+/**
+ * Emphasis Mark (w:em) — dot/circle/comma above/below text
+ */
+declare const EmphasisMarkExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+/**
+ * Text Outline (w:outline) — outlined text with no fill
+ */
+declare const TextOutlineExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { EmbossExtension, EmphasisMarkExtension, ImprintExtension, TextOutlineExtension, TextShadowExtension };

package/dist/prosemirror/extensions/marks/TextEffectsExtensions.js

@@ -0,0 +1,134 @@
+import { expectEmphasisMarkAttrs } from "../../attrs/index.js";
+import { createMarkExtension } from "../create.js";
+//#region src/prosemirror/extensions/marks/TextEffectsExtensions.ts
+/**
+* Additional Text Effect Mark Extensions
+*
+* Emboss (w:emboss), Imprint/Engrave (w:imprint), Text Shadow (w:shadow),
+* Emphasis Marks (w:em), Text Outline (w:outline)
+*/
+/**
+* Emboss — raised text effect via text-shadow
+*/
+const EmbossExtension = createMarkExtension({
+	name: "emboss",
+	schemaMarkName: "emboss",
+	markSpec: {
+		parseDOM: [{ tag: "span.docx-emboss" }],
+		toDOM() {
+			return [
+				"span",
+				{
+					class: "docx-emboss",
+					style: "text-shadow: 1px 1px 1px var(--doc-emboss-light, rgba(255,255,255,0.5)), -1px -1px 1px var(--doc-emboss-dark, rgba(0,0,0,0.3))"
+				},
+				0
+			];
+		}
+	}
+});
+/**
+* Imprint/Engrave — engraved text effect via text-shadow
+*/
+const ImprintExtension = createMarkExtension({
+	name: "imprint",
+	schemaMarkName: "imprint",
+	markSpec: {
+		parseDOM: [{ tag: "span.docx-imprint" }],
+		toDOM() {
+			return [
+				"span",
+				{
+					class: "docx-imprint",
+					style: "text-shadow: -1px -1px 1px var(--doc-imprint-light, rgba(255,255,255,0.5)), 1px 1px 1px var(--doc-imprint-dark, rgba(0,0,0,0.3))"
+				},
+				0
+			];
+		}
+	}
+});
+/**
+* Text Shadow (w:shadow) — subtle drop shadow on text
+*/
+const TextShadowExtension = createMarkExtension({
+	name: "textShadow",
+	schemaMarkName: "textShadow",
+	markSpec: {
+		parseDOM: [{ tag: "span.docx-text-shadow" }],
+		toDOM() {
+			return [
+				"span",
+				{
+					class: "docx-text-shadow",
+					style: "text-shadow: 1px 1px 2px var(--doc-text-shadow, rgba(0,0,0,0.3))"
+				},
+				0
+			];
+		}
+	}
+});
+/**
+* Emphasis Mark (w:em) — dot/circle/comma above/below text
+*/
+const EmphasisMarkExtension = createMarkExtension({
+	name: "emphasisMark",
+	schemaMarkName: "emphasisMark",
+	markSpec: {
+		attrs: { type: { default: "dot" } },
+		parseDOM: [{
+			tag: "span.docx-emphasis-mark",
+			getAttrs: (dom) => ({ type: dom.dataset["emType"] ?? "dot" })
+		}],
+		toDOM(mark) {
+			const emType = expectEmphasisMarkAttrs(mark).type ?? "dot";
+			let emStyle = "filled dot";
+			switch (emType) {
+				case "dot":
+					emStyle = "filled dot";
+					break;
+				case "comma":
+					emStyle = "filled sesame";
+					break;
+				case "circle":
+					emStyle = "filled circle";
+					break;
+				case "underDot":
+					emStyle = "filled dot";
+					break;
+				default: break;
+			}
+			const position = emType === "underDot" ? "under right" : "over right";
+			return [
+				"span",
+				{
+					class: "docx-emphasis-mark",
+					"data-em-type": emType,
+					style: `text-emphasis: ${emStyle}; text-emphasis-position: ${position}; -webkit-text-emphasis: ${emStyle}; -webkit-text-emphasis-position: ${position}`
+				},
+				0
+			];
+		}
+	}
+});
+/**
+* Text Outline (w:outline) — outlined text with no fill
+*/
+const TextOutlineExtension = createMarkExtension({
+	name: "textOutline",
+	schemaMarkName: "textOutline",
+	markSpec: {
+		parseDOM: [{ tag: "span.docx-text-outline" }],
+		toDOM() {
+			return [
+				"span",
+				{
+					class: "docx-text-outline",
+					style: "-webkit-text-stroke: 1px currentColor; -webkit-text-fill-color: transparent"
+				},
+				0
+			];
+		}
+	}
+});
+//#endregion
+export { EmbossExtension, EmphasisMarkExtension, ImprintExtension, TextOutlineExtension, TextShadowExtension };

package/dist/prosemirror/extensions/marks/TrackedChangeExtensions.d.ts

@@ -0,0 +1,22 @@
+import { MarkExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/marks/TrackedChangeExtensions.d.ts
+/**
+ * Tracked Change Mark Extensions — insertion and deletion marks
+ *
+ * Renders insertions with colored underline and deletions with colored
+ * strikethrough, matching the standard MS Word display for tracked changes.
+ * Colors are assigned per author via CSS custom properties (see editor.css).
+ */
+/**
+ * Insertion mark — text added in tracked changes
+ * Renders with per-author colored underline.
+ */
+declare const InsertionExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+/**
+ * Deletion mark — text removed in tracked changes
+ * Renders with per-author colored strikethrough.
+ */
+declare const DeletionExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { DeletionExtension, InsertionExtension };

package/dist/prosemirror/extensions/marks/TrackedChangeExtensions.js

@@ -0,0 +1,113 @@
+import { AUTHOR_COLORS, getAuthorColorIdx } from "../../../utils/authorColors.js";
+import { expectTrackedChangeMarkAttrs } from "../../attrs/index.js";
+import { createMarkExtension } from "../create.js";
+//#region src/prosemirror/extensions/marks/TrackedChangeExtensions.ts
+/**
+* Tracked Change Mark Extensions — insertion and deletion marks
+*
+* Renders insertions with colored underline and deletions with colored
+* strikethrough, matching the standard MS Word display for tracked changes.
+* Colors are assigned per author via CSS custom properties (see editor.css).
+*/
+/**
+* Build an inline style string for the tracked change author color.
+* ProseMirror toDOM runs before the layout painter, so we set the
+* decoration here for correct rendering in both the layout-painter
+* path and the ProseMirror DOM path.
+*/
+const insertionStyle = (color) => `color: ${color}; text-decoration: underline; text-decoration-color: ${color};`;
+const deletionStyle = (color) => `color: ${color}; text-decoration: line-through; text-decoration-color: ${color};`;
+/**
+* Insertion mark — text added in tracked changes
+* Renders with per-author colored underline.
+*/
+const InsertionExtension = createMarkExtension({
+	name: "insertion",
+	schemaMarkName: "insertion",
+	markSpec: {
+		attrs: {
+			revisionId: { default: 0 },
+			author: { default: "" },
+			date: { default: null },
+			moveKind: { default: null }
+		},
+		inclusive: false,
+		parseDOM: [{
+			tag: "span.docx-insertion",
+			getAttrs(dom) {
+				return {
+					revisionId: Number.parseInt(dom.dataset["revisionId"] ?? "0", 10),
+					author: dom.dataset["author"] ?? "",
+					date: dom.dataset["date"] ?? null
+				};
+			}
+		}],
+		toDOM(mark) {
+			const { revisionId, author, date } = expectTrackedChangeMarkAttrs(mark);
+			const idx = getAuthorColorIdx(author);
+			const color = AUTHOR_COLORS[idx] ?? "#000000";
+			const titleParts = [author, date ? new Date(date).toLocaleDateString() : ""].filter(Boolean);
+			return [
+				"span",
+				{
+					class: "docx-insertion",
+					"data-revision-id": String(revisionId),
+					"data-author": author,
+					"data-tc-author-idx": String(idx),
+					...date ? { "data-date": date } : {},
+					...titleParts.length > 0 ? { title: `Inserted: ${titleParts.join(", ")}` } : {},
+					style: insertionStyle(color)
+				},
+				0
+			];
+		}
+	}
+});
+/**
+* Deletion mark — text removed in tracked changes
+* Renders with per-author colored strikethrough.
+*/
+const DeletionExtension = createMarkExtension({
+	name: "deletion",
+	schemaMarkName: "deletion",
+	markSpec: {
+		attrs: {
+			revisionId: { default: 0 },
+			author: { default: "" },
+			date: { default: null },
+			moveKind: { default: null }
+		},
+		inclusive: false,
+		parseDOM: [{
+			tag: "span.docx-deletion",
+			getAttrs(dom) {
+				return {
+					revisionId: Number.parseInt(dom.dataset["revisionId"] ?? "0", 10),
+					author: dom.dataset["author"] ?? "",
+					date: dom.dataset["date"] ?? null
+				};
+			}
+		}],
+		toDOM(mark) {
+			const { revisionId, author, date } = expectTrackedChangeMarkAttrs(mark);
+			const idx = getAuthorColorIdx(author);
+			const color = AUTHOR_COLORS[idx] ?? "#000000";
+			const titleParts = [author, date ? new Date(date).toLocaleDateString() : ""].filter(Boolean);
+			return [
+				"span",
+				{
+					class: "docx-deletion",
+					"data-revision-id": String(revisionId),
+					"data-author": author,
+					"data-tc-author-idx": String(idx),
+					...date ? { "data-date": date } : {},
+					...titleParts.length > 0 ? { title: `Deleted: ${titleParts.join(", ")}` } : {},
+					style: deletionStyle(color)
+				},
+				0
+			];
+		}
+	}
+});
+//#endregion
+export { DeletionExtension, InsertionExtension };

package/dist/prosemirror/extensions/marks/UnderlineExtension.d.ts

@@ -0,0 +1,9 @@
+import { MarkExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/marks/UnderlineExtension.d.ts
+/**
+ * Underline Mark Extension
+ */
+declare const UnderlineExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { UnderlineExtension };

package/dist/prosemirror/extensions/marks/UnderlineExtension.js

@@ -0,0 +1,60 @@
+import { expectUnderlineMarkAttrs } from "../../attrs/index.js";
+import { createMarkExtension } from "../create.js";
+import { setMark } from "./markUtils.js";
+import { panic } from "better-result";
+import { toggleMark } from "prosemirror-commands";
+//#region src/prosemirror/extensions/marks/UnderlineExtension.ts
+/**
+* Underline Mark Extension
+*/
+const UnderlineExtension = createMarkExtension({
+	name: "underline",
+	schemaMarkName: "underline",
+	markSpec: {
+		attrs: {
+			style: { default: "single" },
+			color: { default: null }
+		},
+		parseDOM: [{ tag: "u" }, {
+			style: "text-decoration",
+			getAttrs: (value) => value.includes("underline") ? {} : false
+		}],
+		toDOM(mark) {
+			const attrs = expectUnderlineMarkAttrs(mark);
+			const style = attrs.style;
+			const colorRgb = attrs.color?.rgb;
+			const cssStyle = ["text-decoration: underline"];
+			if (style && style !== "single") {
+				const cssDecorationStyle = {
+					double: "double",
+					dotted: "dotted",
+					dash: "dashed",
+					wave: "wavy"
+				}[style];
+				if (cssDecorationStyle) cssStyle.push(`text-decoration-style: ${cssDecorationStyle}`);
+			}
+			if (colorRgb) cssStyle.push(`text-decoration-color: #${colorRgb}`);
+			return [
+				"span",
+				{ style: cssStyle.join("; ") },
+				0
+			];
+		}
+	},
+	onSchemaReady(ctx) {
+		const underlineType = ctx.schema.marks["underline"];
+		if (!underlineType) panic("Missing mark type: underline");
+		return {
+			commands: {
+				toggleUnderline: () => toggleMark(underlineType),
+				setUnderlineStyle: (style, color) => setMark(underlineType, {
+					style,
+					color
+				})
+			},
+			keyboardShortcuts: { "Mod-u": toggleMark(underlineType) }
+		};
+	}
+});
+//#endregion
+export { UnderlineExtension };

package/dist/prosemirror/extensions/marks/markUtils.d.ts

@@ -0,0 +1,34 @@
+import { document_d_exports } from "../../../types/document.js";
+import { Command, EditorState } from "prosemirror-state";
+import { Mark, MarkType, Schema } from "prosemirror-model";
+
+//#region src/prosemirror/extensions/marks/markUtils.d.ts
+type MarkAttrs = Record<string, unknown>;
+declare function setMark(markType: MarkType, attrs: MarkAttrs): Command;
+declare function removeMark(markType: MarkType): Command;
+/**
+ * Check if a mark is active in the current selection
+ */
+declare function isMarkActive(state: EditorState, markType: MarkType, attrs?: Record<string, unknown>): boolean;
+/**
+ * Get the current value of a mark attribute
+ */
+declare function getMarkAttr(state: EditorState, markType: MarkType, attr: string): unknown;
+/**
+ * Convert TextFormatting to marks array (used to restore formatting on empty paragraphs)
+ */
+declare function textFormattingToMarks(formatting: document_d_exports.TextFormatting, schema: Schema): Mark[];
+/**
+ * Clear all text formatting (remove all marks)
+ */
+declare const clearFormatting: Command;
+/**
+ * Create a command that sets a mark on the selection
+ */
+declare function createSetMarkCommand(markType: MarkType, attrs?: Record<string, unknown>): Command;
+/**
+ * Create a command that removes a mark from the selection
+ */
+declare function createRemoveMarkCommand(markType: MarkType): Command;
+//#endregion
+export { clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive, removeMark, setMark, textFormattingToMarks };