@clevertask/scribe 0.1.23 → 0.1.25

package/dist/table-transforms.js

@@ -0,0 +1,166 @@
+import { EditorState as e } from "@tiptap/pm/state";
+import { CellSelection as t, TableMap as n, addColumn as r, addRow as i, mergeCells as a, removeColumn as o, removeRow as s, splitCell as c } from "@tiptap/pm/tables";
+//#region lib/table-transforms.ts
+var l = class extends Error {
+	code;
+	cause;
+	constructor(e, t, n) {
+		super(t), this.name = "ScribeTableTransformError", this.code = e, this.cause = n;
+	}
+}, u = (e, t, n) => {
+	throw new l(e, t, n);
+}, d = (e) => typeof e == "object" && !!e && !Array.isArray(e), f = (e, t) => {
+	let n = Object.keys(e).sort(), r = [...t].sort();
+	return n.length === r.length && n.every((e, t) => e === r[t]);
+}, p = (e, t, n) => {
+	f(e, t) || u("invalid_input", `${n} must contain exactly: ${t.join(", ")}.`);
+}, m = (e, t, n, r) => {
+	(typeof e != "number" || !Number.isInteger(e) || e < t || e > n) && u("invalid_input", `${r} must be an integer from ${t} to ${n}.`);
+}, h = (e) => {
+	d(e) || u("invalid_input", "The table operation must be an object with a supported type.");
+	let t = e;
+	if (typeof t.type != "string" && u("invalid_input", "The table operation must be an object with a supported type."), t.type === "insert_row" || t.type === "delete_row" || t.type === "insert_column" || t.type === "delete_column") return p(t, ["type", "index"], "The table operation"), typeof t.index != "number" && u("invalid_input", "The table operation index must be a number."), {
+		type: t.type,
+		index: t.index
+	};
+	if (t.type === "merge_cells") {
+		p(t, ["type", "rectangle"], "The merge operation"), d(t.rectangle) || u("invalid_input", "The merge rectangle must be an object.");
+		let e = t.rectangle;
+		p(e, [
+			"topRow",
+			"leftColumn",
+			"bottomRowExclusive",
+			"rightColumnExclusive"
+		], "The merge rectangle");
+		let { topRow: n, leftColumn: r, bottomRowExclusive: i, rightColumnExclusive: a } = e;
+		return (typeof n != "number" || typeof r != "number" || typeof i != "number" || typeof a != "number") && u("invalid_input", "Every merge rectangle coordinate must be a number."), {
+			type: "merge_cells",
+			rectangle: {
+				topRow: n,
+				leftColumn: r,
+				bottomRowExclusive: i,
+				rightColumnExclusive: a
+			}
+		};
+	}
+	return t.type === "split_cell" ? (p(t, [
+		"type",
+		"row",
+		"column"
+	], "The split operation"), (typeof t.row != "number" || typeof t.column != "number") && u("invalid_input", "The split cell row and column must be numbers."), {
+		type: "split_cell",
+		row: t.row,
+		column: t.column
+	}) : u("invalid_input", `Unsupported table operation type: ${String(t.type)}.`);
+}, g = (e) => {
+	(typeof e != "object" || !e || typeof e.check != "function" || typeof e.nodeAt != "function" || typeof e.resolve != "function") && u("invalid_input", "The document must be a ProseMirror document node.");
+	try {
+		e.check();
+	} catch (e) {
+		u("unsupported_structure", "The document has an invalid ProseMirror structure.", e);
+	}
+}, _ = (e) => {
+	let t = !1;
+	e.descendants((e) => {
+		if (e.type.spec.tableRole === "table") return t = !0, !1;
+	}), t && u("unsupported_structure", "The target table contains a nested table.");
+}, v = (e, t) => {
+	(!Number.isInteger(t) || t < 0 || t > e.content.size) && u("invalid_target", `Table position must be an integer from 0 to ${e.content.size}.`);
+	let r = e.nodeAt(t);
+	r?.type.spec.tableRole !== "table" && u("invalid_target", "The target position does not point to a table.");
+	let i = r, a = e.resolve(t);
+	for (let e = a.depth; e > 0; --e) a.node(e).type.spec.tableRole === "table" && u("unsupported_structure", "A nested table cannot be transformed.");
+	_(i);
+	let o;
+	try {
+		o = n.get(i);
+	} catch (e) {
+		u("unsupported_structure", "The target table geometry could not be resolved.", e);
+	}
+	o || u("unsupported_structure", "The target table geometry could not be resolved.");
+	let s = o;
+	return s.problems && s.problems.length > 0 && u("unsupported_structure", "The target table has malformed geometry."), {
+		table: i,
+		map: s,
+		tableStart: t + 1,
+		top: 0,
+		left: 0,
+		bottom: s.height,
+		right: s.width
+	};
+}, y = (e) => {
+	let t = 0;
+	return e.forEach((e) => {
+		t += e.childCount;
+	}), t;
+}, b = (e, t) => ({
+	rows: t.height,
+	columns: t.width,
+	physicalCells: y(e)
+}), x = (e, t, n) => e.map[t * e.width + n], S = (e, n, r, i = r) => e.apply(e.tr.setSelection(t.create(e.doc, n + r, n + i))), C = (e, t, n) => {
+	let r, i = !1;
+	try {
+		i = e(t, (e) => {
+			r = e;
+		});
+	} catch (e) {
+		u("invalid_result", "The table command failed while producing a transaction.", e);
+	}
+	return (!i || !r?.docChanged) && u("operation_not_applicable", n), r;
+}, w = (e) => ({
+	top: e.topRow,
+	left: e.leftColumn,
+	bottom: e.bottomRowExclusive,
+	right: e.rightColumnExclusive
+}), T = (e, t) => (m(e.topRow, 0, t.height - 1, "Merge top row"), m(e.leftColumn, 0, t.width - 1, "Merge left column"), m(e.bottomRowExclusive, 1, t.height, "Merge exclusive bottom row"), m(e.rightColumnExclusive, 1, t.width, "Merge exclusive right column"), (e.bottomRowExclusive <= e.topRow || e.rightColumnExclusive <= e.leftColumn) && u("invalid_input", "The merge rectangle must have a positive width and height."), w(e)), E = (e, t) => e.top === t.top && e.left === t.left && e.bottom === t.bottom && e.right === t.right, D = (e, t, n, r, i) => {
+	let o = T(i, n), s = x(n, o.top, o.left), c = x(n, o.bottom - 1, o.right - 1);
+	E(o, n.rectBetween(s, c)) || u("operation_not_applicable", "The merge rectangle partially crosses an existing cell span.");
+	let l = n.cellsInRect(o);
+	l.length < 2 && u("operation_not_applicable", "The merge rectangle must contain at least two cells.");
+	let d = /* @__PURE__ */ new Set();
+	for (let e of l) {
+		let n = t.nodeAt(e);
+		n || u("unsupported_structure", "The merge rectangle contains an unresolved cell."), d.add(String(n.type.spec.tableRole));
+	}
+	d.size !== 1 && u("operation_not_applicable", "Header and body cells cannot be merged together.");
+	let f = S(e, r, s, c);
+	return C(a, f, "The selected cells do not form a mergeable rectangle.");
+}, O = (e, t, n, r, i, a) => {
+	m(i, 0, n.height - 1, "Split cell row"), m(a, 0, n.width - 1, "Split cell column");
+	let o = x(n, i, a), s = n.findCell(o);
+	(s.top !== i || s.left !== a) && u("operation_not_applicable", "A merged cell must be split from its top-left coordinate."), s.bottom - s.top === 1 && s.right - s.left === 1 && u("operation_not_applicable", "The selected cell is not merged and cannot be split."), t.nodeAt(o) || u("unsupported_structure", "The selected merged cell could not be resolved.");
+	let l = S(e, r, o);
+	return C(c, l, "The selected cell is not merged and cannot be split.");
+}, k = (e, t, n) => {
+	let r = t.rows, i = t.columns;
+	e.type === "insert_row" && (r += 1), e.type === "delete_row" && --r, e.type === "insert_column" && (i += 1), e.type === "delete_column" && --i, (n.rows !== r || n.columns !== i) && u("invalid_result", "The table transform produced unexpected logical geometry."), n.physicalCells < 1 && u("invalid_result", "The table transform produced a table without cells."), e.type === "merge_cells" && n.physicalCells >= t.physicalCells && u("invalid_result", "The merge did not reduce the number of physical cells."), e.type === "split_cell" && n.physicalCells <= t.physicalCells && u("invalid_result", "The split did not increase the number of physical cells.");
+}, A = (t, n, a) => {
+	g(t);
+	let c = h(a), l = e.create({
+		schema: t.type.schema,
+		doc: t
+	}), { map: d, table: f, tableStart: p } = v(t, n), _ = {
+		map: d,
+		table: f,
+		tableStart: p,
+		top: 0,
+		left: 0,
+		bottom: d.height,
+		right: d.width
+	}, y = b(f, d), x;
+	c.type === "insert_row" ? (m(c.index, 0, d.height, "Row insertion index"), x = i(l.tr, _, c.index)) : c.type === "delete_row" ? (m(c.index, 0, d.height - 1, "Row index"), d.height === 1 && u("operation_not_applicable", "The last table row cannot be deleted."), x = l.tr, s(x, _, c.index)) : c.type === "insert_column" ? (m(c.index, 0, d.width, "Column insertion index"), x = r(l.tr, _, c.index)) : c.type === "delete_column" ? (m(c.index, 0, d.width - 1, "Column index"), d.width === 1 && u("operation_not_applicable", "The last table column cannot be deleted."), x = l.tr, o(x, _, c.index)) : x = c.type === "merge_cells" ? D(l, f, d, p, c.rectangle) : O(l, f, d, p, c.row, c.column), x.docChanged || u("invalid_result", "The table transform did not change the document.");
+	try {
+		x.doc.check();
+	} catch (e) {
+		u("invalid_result", "The table transform produced an invalid document.", e);
+	}
+	let S = x.mapping.map(n, -1), C = v(x.doc, S), w = b(C.table, C.map);
+	return k(c, y, w), {
+		document: x.doc,
+		tablePosition: S,
+		before: y,
+		after: w
+	};
+};
+//#endregion
+export { l as ScribeTableTransformError, A as applyScribeTableTransform };

package/dist/utils/index.js

@@ -1,9 +1,9 @@
-import { t as e } from "../dist-ClNucvAM.js";
+import { t as e } from "../dist-xjmWZ-oh.js";
 import { t } from "../html-to-markdown-CKpceHDk.js";
 import { t as n } from "../markdown-to-html-zj2j0HLf.js";
 import { isInViewport as r } from "./is-in-viewport.js";
 import { convertLegacyMathDelimiters as i } from "./convert-legacy-math-delimiters.js";
-import { t as a } from "../extension-B7i7CZ1Y.js";
+import { t as a } from "../extension-9Oc-QD39.js";
 //#region lib/utils/create-scribe-editor.ts
 function o({ content: n = "", editable: r = !1, enableUndoRedo: i, externalLinkPreview: o, onContentChange: s }) {
 	return new e({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clevertask/scribe",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "private": false,
   "description": "A Radix-based Tiptap rich text editor with a Notion-style block interface for viewing and creating content. Perfect for diverse needs like notes, documents, AI chat, Markdown parsing, and comments.",
   "keywords": [