@thomasfosterau/effect-richtext 0.0.0-stage → 0.1.0

package/dist/schema-list/commands.d.ts

@@ -0,0 +1,66 @@
+import { NodeRange } from "../model/resolvedpos.js";
+import { AnySchema, NodeAttrsInput, NodeNames, NodeType } from "../model/schema.js";
+import "../model.js";
+import { Command, Transaction } from "../state/transaction.js";
+import "../state.js";
+/**
+ * Returns a command function that wraps the selection in a list with
+ * the given type and attributes. If `dispatch` is not given, only
+ * succeeds with a value indicating whether this is possible, without
+ * performing the change.
+ *
+ * @since 0.1.0
+ * @category commands
+ */
+export declare const wrapInList: <Sc extends AnySchema, N extends NodeNames<Sc>>(listType: NodeType<Sc, N>, attrs?: NodeAttrsInput<Sc, N> | null) => Command<Sc>;
+/**
+ * Try to wrap the given node range in a list of the given type. Return
+ * `true` when this is possible, `false` otherwise. When `tr` is
+ * non-null, the wrapping is added to that transaction. When it is
+ * `null`, the function only queries whether the wrapping is possible.
+ *
+ * @since 0.1.0
+ * @category transforms
+ */
+export declare function wrapRangeInList<Sc extends AnySchema, N extends NodeNames<Sc>>(tr: Transaction<Sc> | null, range: NodeRange<Sc>, listType: NodeType<Sc, N>, attrs?: NodeAttrsInput<Sc, N> | null): boolean;
+/**
+ * The list item type(s) a list command acts on: one node type, or
+ * several for lists that mix kinds of items (prosemirror-schema-list
+ * 1.6.0).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type ItemTypes<Sc extends AnySchema, N extends NodeNames<Sc>> = NodeType<Sc, N> | ReadonlyArray<NodeType<Sc, N>>;
+/**
+ * Build a command that splits a non-empty textblock at the top level of
+ * a list item by also splitting that list item.
+ *
+ * @since 0.1.0
+ * @category commands
+ */
+export declare const splitListItem: <Sc extends AnySchema, N extends NodeNames<Sc>>(itemType: ItemTypes<Sc, N>, itemAttrs?: NodeAttrsInput<Sc, N>) => Command<Sc>;
+/**
+ * Acts like `splitListItem`, but without resetting the set of active
+ * marks at the cursor.
+ *
+ * @since 0.1.0
+ * @category commands
+ */
+export declare const splitListItemKeepMarks: <Sc extends AnySchema, N extends NodeNames<Sc>>(itemType: ItemTypes<Sc, N>, itemAttrs?: NodeAttrsInput<Sc, N>) => Command<Sc>;
+/**
+ * Create a command to lift the list item around the selection up into
+ * a wrapping list.
+ *
+ * @since 0.1.0
+ * @category commands
+ */
+export declare const liftListItem: <Sc extends AnySchema, N extends NodeNames<Sc>>(itemType: ItemTypes<Sc, N>) => Command<Sc>;
+/**
+ * Create a command to sink the list item around the selection down into
+ * an inner list.
+ *
+ * @since 0.1.0
+ * @category commands
+ */
+export declare const sinkListItem: <Sc extends AnySchema, N extends NodeNames<Sc>>(itemType: ItemTypes<Sc, N>) => Command<Sc>;

package/dist/schema-list/commands.js

@@ -0,0 +1,203 @@
+import { done, keepMarks, syncCommand } from "../commands/internal.js";
+import { Fragment } from "../model/fragment.js";
+import { NodeRange } from "../model/resolvedpos.js";
+import { Slice } from "../model/replace.js";
+import { Selection } from "../state/selection.js";
+import { canJoin, canSplit, findWrappingOrNull, liftTargetOrNull } from "../transform/structure.js";
+import { ReplaceAroundStep } from "../transform/replace_step.js";
+// src/schema-list/commands.ts
+/**
+* List commands, ported from `prosemirror-schema-list`.
+*
+* Ported from prosemirror-schema-list (MIT, Marijn Haverbeke and others).
+*
+* @since 0.1.0
+*/
+/**
+* Returns a command function that wraps the selection in a list with
+* the given type and attributes. If `dispatch` is not given, only
+* succeeds with a value indicating whether this is possible, without
+* performing the change.
+*
+* @since 0.1.0
+* @category commands
+*/
+const wrapInList = (listType, attrs = null) => syncCommand((state, dispatching) => {
+	const { $from, $to } = state.selection;
+	const range = $from.blockRangeOrNull($to);
+	if (!range) return false;
+	const tr = dispatching ? state.tr : null;
+	if (!wrapRangeInList(tr, range, listType, attrs)) return false;
+	return tr ? tr.scrollIntoView() : true;
+});
+/**
+* Try to wrap the given node range in a list of the given type. Return
+* `true` when this is possible, `false` otherwise. When `tr` is
+* non-null, the wrapping is added to that transaction. When it is
+* `null`, the function only queries whether the wrapping is possible.
+*
+* @since 0.1.0
+* @category transforms
+*/
+function wrapRangeInList(tr, range, listType, attrs = null) {
+	let doJoin = false, outerRange = range;
+	const doc = range.$from.doc;
+	if (range.depth >= 2 && range.$from.node(range.depth - 1).type.compatibleContent(listType) && range.startIndex === 0) {
+		if (range.$from.index(range.depth - 1) === 0) return false;
+		const $insert = doc.resolveUnsafe(range.start - 2);
+		outerRange = new NodeRange($insert, $insert, range.depth);
+		if (range.endIndex < range.parent.childCount) range = new NodeRange(range.$from, doc.resolveUnsafe(range.$to.end(range.depth)), range.depth);
+		doJoin = true;
+	}
+	const wrap = findWrappingOrNull(outerRange, listType, attrs, range);
+	if (!wrap) return false;
+	if (tr) doWrapInList(tr, range, wrap, doJoin, listType);
+	return true;
+}
+function doWrapInList(tr, range, wrappers, joinBefore, listType) {
+	let content = Fragment.empty;
+	for (let i = wrappers.length - 1; i >= 0; i--) content = Fragment.from(wrappers[i].type.createUnsafe(wrappers[i].attrs, content));
+	tr.stepUnsafe(new ReplaceAroundStep(range.start - (joinBefore ? 2 : 0), range.end, range.start, range.end, new Slice(content, 0, 0), wrappers.length, true));
+	let found = 0;
+	for (let i = 0; i < wrappers.length; i++) if (wrappers[i].type === listType) found = i + 1;
+	const splitDepth = wrappers.length - found;
+	let splitPos = range.start + wrappers.length - (joinBefore ? 2 : 0);
+	const parent = range.parent;
+	for (let i = range.startIndex, e = range.endIndex, first = true; i < e; i++, first = false) {
+		if (!first && splitDepth && canSplit(tr.doc, splitPos, splitDepth)) {
+			tr.splitUnsafe(splitPos, splitDepth);
+			splitPos += 2 * splitDepth;
+		}
+		splitPos += parent.childUnsafe(i).nodeSize;
+	}
+	return tr;
+}
+const isItem = (itemType, type) => Array.isArray(itemType) ? itemType.indexOf(type) > -1 : type === itemType;
+const itemRange = (state, itemType) => {
+	const { $from, $to } = state.selection;
+	return $from.blockRangeOrNull($to, (node) => {
+		const first = node.content.content[0];
+		return !!first && isItem(itemType, first.type);
+	});
+};
+/**
+* Build a command that splits a non-empty textblock at the top level of
+* a list item by also splitting that list item.
+*
+* @since 0.1.0
+* @category commands
+*/
+const splitListItem = (itemType, itemAttrs) => syncCommand((state, dispatching) => {
+	const sel = state.selection, { $from, $to } = sel;
+	const node = sel.node;
+	if (node && node.isBlock || $from.depth < 2 || !$from.sameParent($to)) return false;
+	const grandParent = $from.node(-1);
+	if (!isItem(itemType, grandParent.type)) return false;
+	if ($from.parent.content.size === 0 && $from.node(-1).childCount === $from.indexAfter(-1)) {
+		if ($from.depth === 3 || !isItem(itemType, $from.node(-3).type) || $from.index(-2) !== $from.node(-2).childCount - 1) return false;
+		return done(dispatching, () => {
+			let wrap = Fragment.empty;
+			const depthBefore = $from.index(-1) ? 1 : $from.index(-2) ? 2 : 3;
+			for (let d = $from.depth - depthBefore; d >= $from.depth - 3; d--) wrap = Fragment.from($from.node(d).copy(wrap));
+			const depthAfter = $from.indexAfter(-1) < $from.node(-2).childCount ? 1 : $from.indexAfter(-2) < $from.node(-3).childCount ? 2 : 3;
+			wrap = wrap.append(Fragment.from($from.node(-3).type.createAndFillOrNull()));
+			const start = $from.beforeUnsafe($from.depth - (depthBefore - 1));
+			const tr = state.tr.replaceUnsafe(start, $from.afterUnsafe(-depthAfter), new Slice(wrap, 4 - depthBefore, 0));
+			let sel = -1;
+			tr.doc.nodesBetween(start, tr.doc.content.size, (node, pos) => {
+				if (sel > -1) return false;
+				if (node.isTextblock && node.content.size === 0) sel = pos + 1;
+			});
+			if (sel > -1) tr.setSelectionUnsafe(Selection.near(tr.doc.resolveUnsafe(sel)));
+			return tr.scrollIntoView();
+		});
+	}
+	const nextType = $to.pos === $from.end() ? grandParent.contentMatchAtUnsafe(0).defaultTypeOrNull : null;
+	const tr = state.tr.deleteUnsafe($from.pos, $to.pos);
+	const types = nextType ? [itemAttrs ? {
+		type: grandParent.type,
+		attrs: itemAttrs
+	} : null, { type: nextType }] : void 0;
+	if (!canSplit(tr.doc, $from.pos, 2, types)) return false;
+	return done(dispatching, () => tr.splitUnsafe($from.pos, 2, types).scrollIntoView());
+});
+/**
+* Acts like `splitListItem`, but without resetting the set of active
+* marks at the cursor.
+*
+* @since 0.1.0
+* @category commands
+*/
+const splitListItemKeepMarks = (itemType, itemAttrs) => {
+	const split = splitListItem(itemType, itemAttrs);
+	return (state, dispatch) => split(state, keepMarks(state, dispatch));
+};
+/**
+* Create a command to lift the list item around the selection up into
+* a wrapping list.
+*
+* @since 0.1.0
+* @category commands
+*/
+const liftListItem = (itemType) => syncCommand((state, dispatching) => {
+	const { $from } = state.selection;
+	const range = itemRange(state, itemType);
+	if (!range) return false;
+	if (!dispatching) return true;
+	if (isItem(itemType, $from.node(range.depth - 1).type)) return liftToOuterList(state, range);
+	else return liftOutOfList(state, range);
+});
+function liftToOuterList(state, range) {
+	const tr = state.tr, end = range.end, endOfList = range.$to.end(range.depth);
+	const itemType = range.parent.childUnsafe(range.endIndex - 1).type;
+	if (end < endOfList) {
+		tr.stepUnsafe(new ReplaceAroundStep(end - 1, endOfList, end, endOfList, new Slice(Fragment.from(itemType.createUnsafe(null, range.parent.copy())), 1, 0), 1, true));
+		range = new NodeRange(tr.doc.resolveUnsafe(range.$from.pos), tr.doc.resolveUnsafe(endOfList), range.depth);
+	}
+	const target = liftTargetOrNull(range);
+	if (target == null) return false;
+	tr.liftUnsafe(range, target);
+	const $after = tr.doc.resolveUnsafe(tr.mapping.map(end, -1) - 1);
+	if (canJoin(tr.doc, $after.pos) && $after.nodeBeforeOrNull.type === $after.nodeAfterOrNull.type) tr.joinUnsafe($after.pos);
+	return tr.scrollIntoView();
+}
+function liftOutOfList(state, range) {
+	const tr = state.tr, list = range.parent;
+	for (let pos = range.end, i = range.endIndex - 1, e = range.startIndex; i > e; i--) {
+		pos -= list.childUnsafe(i).nodeSize;
+		tr.deleteUnsafe(pos - 1, pos + 1);
+	}
+	const $start = tr.doc.resolveUnsafe(range.start), item = $start.nodeAfterOrNull;
+	if (tr.mapping.map(range.end) !== range.start + item.nodeSize) return false;
+	const atStart = range.startIndex === 0, atEnd = range.endIndex === list.childCount;
+	const parent = $start.node(-1), indexBefore = $start.index(-1);
+	if (!parent.canReplace(indexBefore + (atStart ? 0 : 1), indexBefore + 1, item.content.append(atEnd ? Fragment.empty : Fragment.from(list)))) return false;
+	const start = $start.pos, end = start + item.nodeSize;
+	tr.stepUnsafe(new ReplaceAroundStep(start - (atStart ? 1 : 0), end + (atEnd ? 1 : 0), start + 1, end - 1, new Slice((atStart ? Fragment.empty : Fragment.from(list.copy(Fragment.empty))).append(atEnd ? Fragment.empty : Fragment.from(list.copy(Fragment.empty))), atStart ? 0 : 1, atEnd ? 0 : 1), atStart ? 0 : 1));
+	return tr.scrollIntoView();
+}
+/**
+* Create a command to sink the list item around the selection down into
+* an inner list.
+*
+* @since 0.1.0
+* @category commands
+*/
+const sinkListItem = (itemType) => syncCommand((state, dispatching) => {
+	const range = itemRange(state, itemType);
+	if (!range) return false;
+	const startIndex = range.startIndex;
+	if (startIndex === 0) return false;
+	const parent = range.parent, nodeBefore = parent.childUnsafe(startIndex - 1);
+	if (!isItem(itemType, nodeBefore.type)) return false;
+	return done(dispatching, () => {
+		const lastBefore = nodeBefore.content.content[nodeBefore.childCount - 1];
+		const nestedBefore = !!lastBefore && lastBefore.type === parent.type;
+		const nestedItem = nestedBefore ? lastBefore.content.content[lastBefore.childCount - 1] : void 0;
+		const inner = Fragment.from(nestedItem ? nestedItem.type.createUnsafe() : null);
+		const slice = new Slice(Fragment.from(nodeBefore.type.createUnsafe(null, Fragment.from(parent.type.createUnsafe(null, inner)))), nestedBefore ? 3 : 1, 0);
+		const before = range.start, after = range.end;
+		return state.tr.stepUnsafe(new ReplaceAroundStep(before - (nestedBefore ? 3 : 1), after, before, after, slice, 1, true)).scrollIntoView();
+	});
+});
+export { liftListItem, sinkListItem, splitListItem, splitListItemKeepMarks, wrapInList, wrapRangeInList };

package/dist/schema-list.d.ts

@@ -0,0 +1,92 @@
+import { NodeSpec } from "./model/schema.js";
+import { Node } from "./model/node.js";
+import { ContentExpr, ContentInput } from "./model/content.js";
+import "./model.js";
+import { ItemTypes, liftListItem, sinkListItem, splitListItem, splitListItemKeepMarks, wrapInList, wrapRangeInList } from "./schema-list/commands.js";
+import * as S from "effect/Schema";
+/**
+ * An ordered list node spec. Has a single attribute, `order`, which
+ * determines the number at which the list starts counting, and
+ * defaults to 1. Represented as an `<ol>` element.
+ *
+ * @since 0.1.0
+ * @category specs
+ */
+export declare const orderedList: {
+  readonly attrs: {
+    readonly order: {
+      readonly schema: S.Number;
+      readonly default: 1;
+    };
+  };
+  readonly parseDOM: readonly [{
+    readonly tag: "ol";
+    readonly getAttrs: (dom: HTMLElement) => {
+      order: number;
+    };
+  }];
+  readonly toDOM: (node: Node<any, any>) => readonly any[];
+};
+/**
+ * A bullet list node spec, represented in the DOM as `<ul>`.
+ *
+ * @since 0.1.0
+ * @category specs
+ */
+export declare const bulletList: {
+  readonly parseDOM: readonly [{
+    readonly tag: "ul";
+  }];
+  readonly toDOM: () => readonly any[] | readonly [string, ...any[]];
+};
+/**
+ * A list item (`<li>`) spec.
+ *
+ * @since 0.1.0
+ * @category specs
+ */
+export declare const listItem: {
+  readonly parseDOM: readonly [{
+    readonly tag: "li";
+  }];
+  readonly toDOM: () => readonly any[] | readonly [string, ...any[]];
+  readonly defining: true;
+};
+/**
+ * The node specs added by `addListNodes`.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type ListNodes<ItemRefs extends string, Group extends string | undefined> = {
+  readonly ordered_list: typeof orderedList & {
+    readonly content: ContentExpr<"list_item">;
+    readonly group: Group;
+  };
+  readonly bullet_list: typeof bulletList & {
+    readonly content: ContentExpr<"list_item">;
+    readonly group: Group;
+  };
+  readonly list_item: typeof listItem & {
+    readonly content: ContentExpr<ItemRefs>;
+  };
+};
+/**
+ * Convenience function for adding list-related node types to a set of
+ * node specs. Adds them under the names `"ordered_list"`,
+ * `"bullet_list"`, and `"list_item"`.
+ *
+ * `itemContent` determines the content expression for the list items.
+ * If you want the commands defined in this module to apply to your
+ * list structure, it should have a shape like
+ * `Content.seq("paragraph", Content.zeroOrMore("block"))`.
+ * `listGroup` can be given to assign a group name to the list node
+ * types, for example `"block"`.
+ *
+ * @since 0.1.0
+ * @category specs
+ */
+export declare const addListNodes: <const N extends {
+  readonly [name: string]: NodeSpec;
+}, const ItemRefs extends string, const Group extends string | undefined = undefined>(nodes: N, itemContent: ContentInput<ItemRefs>, listGroup?: Group) => N & ListNodes<ItemRefs, Group>;
+export { ItemTypes, liftListItem, sinkListItem, splitListItem, splitListItemKeepMarks, wrapInList, wrapRangeInList };

package/dist/schema-list.js

@@ -0,0 +1,100 @@
+import { oneOrMore, ref } from "./model/content.js";
+import { nodeSpec } from "./model/schema.js";
+import { liftListItem, sinkListItem, splitListItem, splitListItemKeepMarks, wrapInList, wrapRangeInList } from "./schema-list/commands.js";
+import * as Predicate from "effect/Predicate";
+import * as S from "effect/Schema";
+// src/schema-list.ts
+/**
+* List node specs and list commands, ported from
+* `prosemirror-schema-list`.
+*
+* @since 0.1.0
+*/
+const olDOM = ["ol", 0];
+const ulDOM = ["ul", 0];
+const liDOM = ["li", 0];
+/**
+* An ordered list node spec. Has a single attribute, `order`, which
+* determines the number at which the list starts counting, and
+* defaults to 1. Represented as an `<ol>` element.
+*
+* @since 0.1.0
+* @category specs
+*/
+const orderedList = nodeSpec({
+	attrs: { order: {
+		schema: S.Number,
+		default: 1
+	} },
+	parseDOM: [{
+		tag: "ol",
+		getAttrs(dom) {
+			return { order: dom.hasAttribute("start") ? +dom.getAttribute("start") : 1 };
+		}
+	}],
+	toDOM(node) {
+		return node.attrs.order === 1 ? olDOM : [
+			"ol",
+			{ start: node.attrs.order },
+			0
+		];
+	}
+});
+/**
+* A bullet list node spec, represented in the DOM as `<ul>`.
+*
+* @since 0.1.0
+* @category specs
+*/
+const bulletList = nodeSpec({
+	parseDOM: [{ tag: "ul" }],
+	toDOM() {
+		return ulDOM;
+	}
+});
+/**
+* A list item (`<li>`) spec.
+*
+* @since 0.1.0
+* @category specs
+*/
+const listItem = nodeSpec({
+	parseDOM: [{ tag: "li" }],
+	toDOM() {
+		return liDOM;
+	},
+	defining: true
+});
+/**
+* Convenience function for adding list-related node types to a set of
+* node specs. Adds them under the names `"ordered_list"`,
+* `"bullet_list"`, and `"list_item"`.
+*
+* `itemContent` determines the content expression for the list items.
+* If you want the commands defined in this module to apply to your
+* list structure, it should have a shape like
+* `Content.seq("paragraph", Content.zeroOrMore("block"))`.
+* `listGroup` can be given to assign a group name to the list node
+* types, for example `"block"`.
+*
+* @since 0.1.0
+* @category specs
+*/
+const addListNodes = (nodes, itemContent, listGroup) => ({
+	...nodes,
+	ordered_list: {
+		...orderedList,
+		content: oneOrMore("list_item"),
+		group: listGroup
+	},
+	bullet_list: {
+		...bulletList,
+		content: oneOrMore("list_item"),
+		group: listGroup
+	},
+	list_item: {
+		...listItem,
+		content: Predicate.isString(itemContent) ? ref(itemContent) : itemContent
+	}
+});
+export { addListNodes, bulletList, liftListItem, listItem, orderedList, sinkListItem, splitListItem, splitListItemKeepMarks, wrapInList, wrapRangeInList };

package/dist/state/errors.d.ts

@@ -0,0 +1,39 @@
+import * as Schema from "effect/Schema";
+declare const StateError_base: Schema.Class<StateError, Schema.TaggedStruct<"StateError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * An invalid editor state operation: a state configuration without a
+ * schema or document, two different instances of a keyed plugin, a
+ * transaction applied to a state it wasn't created for, or invalid
+ * JSON field names.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class StateError extends StateError_base {}
+declare const SelectionError_base: Schema.Class<SelectionError, Schema.TaggedStruct<"SelectionError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * An invalid selection: a node selection at a position with no node
+ * after it, a selection that points into a different document than the
+ * one it is used with, or a duplicate selection JSON id.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class SelectionError extends SelectionError_base {}
+/**
+ * Union of the errors defined by the state layer.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export type StateFailure = StateError | SelectionError;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+export declare const isStateFailure: (u: unknown) => u is StateFailure;
+export {};

package/dist/state/errors.js

@@ -0,0 +1,32 @@
+import * as Schema from "effect/Schema";
+// src/state/errors.ts
+/**
+* Tagged errors raised by the state layer.
+*
+* @since 0.1.0
+*/
+/**
+* An invalid editor state operation: a state configuration without a
+* schema or document, two different instances of a keyed plugin, a
+* transaction applied to a state it wasn't created for, or invalid
+* JSON field names.
+*
+* @since 0.1.0
+* @category errors
+*/
+var StateError = class extends Schema.TaggedError()("StateError", { message: Schema.String }) {};
+/**
+* An invalid selection: a node selection at a position with no node
+* after it, a selection that points into a different document than the
+* one it is used with, or a duplicate selection JSON id.
+*
+* @since 0.1.0
+* @category errors
+*/
+var SelectionError = class extends Schema.TaggedError()("SelectionError", { message: Schema.String }) {};
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isStateFailure = (u) => u instanceof StateError || u instanceof SelectionError;
+export { SelectionError, StateError, isStateFailure };