@thomasfosterau/effect-richtext 0.0.0-stage → 0.1.0

package/dist/compat/test-builder.d.ts

@@ -0,0 +1,98 @@
+import { Attrs, MarkSpec, Node, NodeSpec, Schema } from "./model.js";
+import { OrderedMap } from "./orderedmap.js";
+type Tags = {
+  [tag: string]: number;
+};
+/**
+ * A child argument of a builder.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type ChildSpec = string | Node | {
+  flat: ReadonlyArray<Node>;
+  tag: Tags;
+};
+/**
+ * A node builder.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type NodeBuilder = (attrsOrFirstChild?: Attrs | ChildSpec, ...children: Array<ChildSpec>) => Node & {
+  tag: Tags;
+};
+/**
+ * A mark builder.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type MarkBuilder = (attrsOrFirstChild?: Attrs | ChildSpec, ...children: Array<ChildSpec>) => ChildSpec;
+type Builders<S extends Schema> = {
+  schema: S;
+} & { [key in keyof S["nodes"]]: NodeBuilder; } & { [key in keyof S["marks"]]: MarkBuilder; } & {
+  [name: string]: NodeBuilder | MarkBuilder;
+};
+/**
+ * Create a set of builder functions for the given schema.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare function builders<Nodes extends string = any, Marks extends string = any>(schema: Schema<Nodes, Marks>, names?: {
+  [name: string]: Attrs;
+}): Builders<Schema<Nodes, Marks>>;
+/**
+ * The test schema: the basic schema plus list nodes.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const schema: Schema<keyof OrderedMap<NodeSpec>, keyof OrderedMap<MarkSpec>>;
+/**
+ * Compare two values with their `eq` method.
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+export declare function eq<T extends {
+  eq(other: T): boolean;
+}>(a: T, b: T): boolean;
+/** @since 0.1.0 */
+export declare const doc: NodeBuilder;
+/** @since 0.1.0 */
+export declare const p: NodeBuilder;
+/** @since 0.1.0 */
+export declare const code_block: NodeBuilder;
+/** @since 0.1.0 */
+export declare const pre: NodeBuilder;
+/** @since 0.1.0 */
+export declare const h1: NodeBuilder;
+/** @since 0.1.0 */
+export declare const h2: NodeBuilder;
+/** @since 0.1.0 */
+export declare const h3: NodeBuilder;
+/** @since 0.1.0 */
+export declare const li: NodeBuilder;
+/** @since 0.1.0 */
+export declare const ul: NodeBuilder;
+/** @since 0.1.0 */
+export declare const ol: NodeBuilder;
+/** @since 0.1.0 */
+export declare const img: NodeBuilder;
+/** @since 0.1.0 */
+export declare const hr: NodeBuilder;
+/** @since 0.1.0 */
+export declare const br: NodeBuilder;
+/** @since 0.1.0 */
+export declare const blockquote: NodeBuilder;
+/** @since 0.1.0 */
+export declare const a: MarkBuilder;
+/** @since 0.1.0 */
+export declare const em: MarkBuilder;
+/** @since 0.1.0 */
+export declare const strong: MarkBuilder;
+/** @since 0.1.0 */
+export declare const code: MarkBuilder;
+export {};

package/dist/compat/test-builder.js

@@ -0,0 +1,197 @@
+import { Node, Schema } from "./model.js";
+import { schema as schema$1 } from "./schema-basic.js";
+import { addListNodes } from "./schema-list.js";
+// src/compat/test-builder.ts
+/**
+* A `prosemirror-test-builder`-compatible module, built on the compat
+* facades: helpers for building documents in tests, with `<tag>`
+* position markers.
+*
+* Ported from prosemirror-test-builder (MIT, Marijn Haverbeke and others).
+*
+* @since 0.1.0
+*/
+const noTag = Node.prototype.tag = Object.create(null);
+function flatten(schema, children, f) {
+	const result = [];
+	let pos = 0, tag = noTag;
+	for (let i = 0; i < children.length; i++) {
+		const child = children[i];
+		if (typeof child == "string") {
+			const re = /<(\w+)>/g;
+			let m, at = 0, out = "";
+			while (m = re.exec(child)) {
+				out += child.slice(at, m.index);
+				pos += m.index - at;
+				at = m.index + m[0].length;
+				if (tag == noTag) tag = Object.create(null);
+				tag[m[1]] = pos;
+			}
+			out += child.slice(at);
+			pos += child.length - at;
+			if (out) result.push(f(schema.text(out)));
+		} else {
+			if (child.tag && child.tag != Node.prototype.tag) {
+				if (tag == noTag) tag = Object.create(null);
+				for (const id in child.tag) tag[id] = child.tag[id] + (child.flat || child.isText ? 0 : 1) + pos;
+			}
+			if (child.flat) for (let j = 0; j < child.flat.length; j++) {
+				const node = f(child.flat[j]);
+				pos += node.nodeSize;
+				result.push(node);
+			}
+			else {
+				const node = f(child);
+				pos += node.nodeSize;
+				result.push(node);
+			}
+		}
+	}
+	return {
+		nodes: result,
+		tag
+	};
+}
+function id(x) {
+	return x;
+}
+function takeAttrs(attrs, args) {
+	const a0 = args[0];
+	if (!args.length || a0 && (typeof a0 == "string" || a0 instanceof Node || a0.flat)) return attrs;
+	args.shift();
+	if (!attrs) return a0;
+	if (!a0) return attrs;
+	const result = {};
+	for (const prop in attrs) result[prop] = attrs[prop];
+	for (const prop in a0) result[prop] = a0[prop];
+	return result;
+}
+function block(type, attrs = null) {
+	const result = function(...args) {
+		const myAttrs = takeAttrs(attrs, args);
+		const { nodes, tag } = flatten(type.schema, args, id);
+		const node = type.create(myAttrs, nodes);
+		if (tag != noTag) node.tag = tag;
+		return node;
+	};
+	if (type.isLeaf) try {
+		result.flat = [type.create(attrs)];
+	} catch {}
+	return result;
+}
+function mark(type, attrs) {
+	return function(...args) {
+		const mark = type.create(takeAttrs(attrs, args));
+		const { nodes, tag } = flatten(type.schema, args, (n) => {
+			const newMarks = mark.addToSet(n.marks);
+			return newMarks.length > n.marks.length ? n.mark(newMarks) : n;
+		});
+		return {
+			flat: nodes,
+			tag
+		};
+	};
+}
+/**
+* Create a set of builder functions for the given schema.
+*
+* @since 0.1.0
+* @category constructors
+*/
+function builders(schema, names) {
+	const result = { schema };
+	for (const name in schema.nodes) result[name] = block(schema.nodes[name], {});
+	for (const name in schema.marks) result[name] = mark(schema.marks[name], {});
+	if (names) for (const name in names) {
+		const value = names[name], typeName = value.nodeType || value.markType || name;
+		let type;
+		if (type = schema.nodes[typeName]) result[name] = block(type, value);
+		else if (type = schema.marks[typeName]) result[name] = mark(type, value);
+	}
+	return result;
+}
+/**
+* The test schema: the basic schema plus list nodes.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const schema = new Schema({
+	nodes: addListNodes(schema$1.spec.nodes, "paragraph block*", "block"),
+	marks: schema$1.spec.marks
+});
+const b = builders(schema, {
+	p: { nodeType: "paragraph" },
+	pre: { nodeType: "code_block" },
+	h1: {
+		nodeType: "heading",
+		level: 1
+	},
+	h2: {
+		nodeType: "heading",
+		level: 2
+	},
+	h3: {
+		nodeType: "heading",
+		level: 3
+	},
+	li: { nodeType: "list_item" },
+	ul: { nodeType: "bullet_list" },
+	ol: { nodeType: "ordered_list" },
+	br: { nodeType: "hard_break" },
+	img: {
+		nodeType: "image",
+		src: "img.png"
+	},
+	hr: { nodeType: "horizontal_rule" },
+	a: {
+		markType: "link",
+		href: "foo"
+	}
+});
+/**
+* Compare two values with their `eq` method.
+*
+* @since 0.1.0
+* @category utils
+*/
+function eq(a, b) {
+	return a.eq(b);
+}
+/** @since 0.1.0 */
+const doc = b.doc;
+/** @since 0.1.0 */
+const p = b.p;
+/** @since 0.1.0 */
+const code_block = b.code_block;
+/** @since 0.1.0 */
+const pre = b.pre;
+/** @since 0.1.0 */
+const h1 = b.h1;
+/** @since 0.1.0 */
+const h2 = b.h2;
+/** @since 0.1.0 */
+const h3 = b.h3;
+/** @since 0.1.0 */
+const li = b.li;
+/** @since 0.1.0 */
+const ul = b.ul;
+/** @since 0.1.0 */
+const ol = b.ol;
+/** @since 0.1.0 */
+const img = b.img;
+/** @since 0.1.0 */
+const hr = b.hr;
+/** @since 0.1.0 */
+const br = b.br;
+/** @since 0.1.0 */
+const blockquote = b.blockquote;
+/** @since 0.1.0 */
+const a = b.a;
+/** @since 0.1.0 */
+const em = b.em;
+/** @since 0.1.0 */
+const strong = b.strong;
+/** @since 0.1.0 */
+const code = b.code;
+export { a, blockquote, br, builders, code, code_block, doc, em, eq, h1, h2, h3, hr, img, li, ol, p, pre, schema, strong, ul };