@witchcraft/editor 0.0.8 → 0.1.0

package/src/runtime/pm/utils/generateRandomDoc.ts

@@ -1,140 +1,63 @@
-import { unreachable } from "@alanscodelog/utils/unreachable"
 import { faker } from "@faker-js/faker"
-import type { Mark, MarkType, Node } from "@tiptap/pm/model"
+import type { Node } from "@tiptap/pm/model"
 import type { builders } from "prosemirror-test-builder"
 
-import { generateRandomTree } from "./generateRandomTree.js"
+import type { GeneratorConfigEntry } from "./generator/createGeneratorConfig.js"
 
-import type { GeneratorConfigEntry } from "../generator.js"
 import { generatorConfig } from "../generator.js"
 
-/**
- * Generates a random doc using faker js.
- *
- * A config describing how to create the doc is required. One is available under `pm/generator`.
- *
- * @experimental
- */
 export function generateRandomDoc<
-	TBuilder extends ReturnType<typeof builders>,
-	TData extends string
+	TBuilder extends ReturnType<typeof builders>
 >(
-	builder: TBuilder,
-	config: GeneratorConfigEntry<any, any, any, any>[] = generatorConfig,
-	treeOptions?: Parameters<typeof generateRandomTree>[1],
-	{
-		checkAfterNodeCreation = false
-	}: {
-		/**
-		 * Checks if every returned node is valid for debugging invalid generator configs.
-		 *
-		 * A check is always done on the root node at the end regardless of this option.
-		 *
-		 * It is very slow (each check, rechecks children).
-		 *
-		 * @default false
-		 */
-		checkAfterNodeCreation?: boolean
-	} = {}
-): Node {
-	const schema = builder.schema
-
-	const map: Record<string, GeneratorConfigEntry<any, any, any, any>> = {}
-	function schemaFilter(name: string) {
-		return name !== "text" && name !== schema.topNodeType.name
-	}
-
-	for (const entry of config) {
-		for (const node of entry.parents.names) {
-			if (node === "") throw new Error(`Empty node name ""`)
-			const type = entry.parents.type === "node" ? schema.nodes[node] : schema.marks[node]
-			if (type === undefined && node !== "text") {
-				throw new Error(`${node} (on entry of type ${entry.parents.type}) not found in schema. Valid names are ${Object.keys(entry.parents.type === "node" ? schema.nodes : schema.marks)}`)
-			}
-
-			for (const node of entry.parents.names) {
-				const subEntry = { ...entry }
-				if (entry.ignoreValidation === undefined || entry.ignoreValidation !== true) {
-					const childrenToValidate = (entry.children.names ?? []).filter(_ => !Array.isArray(entry.ignoreValidation) || !entry.ignoreValidation.includes(_))
-					for (const child of childrenToValidate) {
-						if (child === "") throw new Error(`Empty node name ""`)
-						if (entry.children.type === "node") {
-							const childType = schema.nodes[child]
-							const possibleNames = [childType.name, ...((childType.spec.group ?? "").split(" ").filter(e => e !== ""))]
-							const isAllowedChild = type.spec.content && possibleNames.some(n => type.spec.content!.includes(n))
-							// we don't use contentMatch.matchType because
-							// it can give false negatives when the content expression
-							// has multiple types like type1+ type2+,
-							// it will only return true for type1 in those cases
-							if (!(isAllowedChild && schemaFilter(childType.name))) {
-								throw new Error(`Node ${node} cannot contain child of type ${child}`)
-							}
-						} else {
-							const childType = schema.marks[child]
-							if (entry.parents.type === "node") {
-								// not sure why this is returning false when it shouldn't (e.g. paragraph can't contain bold)
-								// if (!(type as NodeType).allowsMarkType(childType)) {
-								// 	throw new Error(`Node ${node} cannot contain mark child of type ${child}`)
-								// }
-							} else {
-								const possibleNames = [childType.name, ...((childType.spec.group ?? "").split(" ").filter(e => e !== ""))]
-								const t = type as MarkType
-								const isExcluded = t.spec.excludes !== undefined
-									&& possibleNames.some(n => {
-										// _ this means exclude everything in prosemirror
-										return t.spec.excludes!.includes(n)
-											|| t.spec.excludes!.includes("_")
-									})
-								if (isExcluded) {
-									throw new Error(`Mark ${node} cannot contain mark child of type ${child}`)
-								}
-							}
-						}
-					}
-				}
-				map[node] = { ...subEntry }
+	pm: TBuilder,
+	config: GeneratorConfigEntry<any, any, any, any>[] = generatorConfig
+) {
+	function generateNode(
+		pm: TBuilder,
+		nodeConfig: GeneratorConfigEntry<TBuilder, any, any, any, any>,
+		parentType: string,
+		depth = 0
+	): Node {
+		if (!nodeConfig.parents.names.includes(parentType)) {
+			throw new Error(`Node config ${nodeConfig.parents.names.join(", ")} does not include parent type ${parentType}`)
+		}
+		const nodes = []
+		if ("count" in nodeConfig) {
+			const childrenCount = nodeConfig.count(depth)
+			for (let i = 0; i < childrenCount; i++) {
+				const type = pickWeightedChild(nodeConfig.children.names)
+				if (type === undefined) continue
+				if (nodeConfig?.skipChild?.(parentType, type, depth)) continue
+				const childConfig = config.find(c => {
+					return c.parents.names.includes(type)
+				})
+				if (!childConfig) continue
+				const child = generateNode(pm, childConfig, type, depth + 1)
+				if (child === undefined) continue
+				nodes.push(child)
 			}
 		}
+		return nodeConfig.create(pm, parentType, nodes)
 	}
+	const firstEntry = config[0]
+	if (firstEntry === undefined) throw new Error("No config entries found.")
+	if (!("children" in firstEntry)) throw new Error("No children found in the first config entry. The first entry must have children.")
+	const startingType = pickWeightedChild(firstEntry.parents.names.map(name => [name, 1]))
+	if (startingType === undefined) throw new Error("No starting type found.")
+	return generateNode(pm, config[0], startingType)
+}
 
 
-	const children = generateRandomTree<Node | Mark | string, TData>({
-		parentData: (data?: TData): TData => {
-			if (data === "") return "" as TData
-			if (!data) unreachable()
-			if (!map[data] || !map[data].children.names || map[data].children.names.length === 0) {
-				// we must prematurely end the branch as the node can contain no children
-				return "" as TData
-			} else {
-				const picked = faker.helpers.arrayElement(map[data].children.names)
-				return picked as TData
-			}
-		},
-		createNode: (children, _isLeaf, data): Node | Mark | string | undefined => {
-			if (data === "") return undefined
-			if (!data) unreachable()
-			const type = schema.nodes[data]
-			// type allows no children or isn't configured to generate children
-			if (!type) return undefined
-
-			const parent = map[data]?.create?.(data, children as any)
-				?? builder[data]({}, ...children as any)
-
-			if (checkAfterNodeCreation) {
-				;(parent as any)?.check?.()
-			}
-
-			return parent
-		}
-	}, {
-		...treeOptions,
-		initialData: schema.topNodeType.name as TData
-	})
-
-	const doc = map[schema.topNodeType.name]?.create?.(schema.topNodeType.name as any, children as any)
-		?? builder[schema.topNodeType.name]({}, ...children as any)
+export function pickWeightedChild(options: [string, number][]): string | undefined {
+	const totalWeight = options.reduce((sum, [, weight]) => sum + weight, 0)
+	if (totalWeight === 0) return undefined
 
-	;(doc as any).check?.()
-	return doc as Node
+	let random = faker.number.float({ min: 0, max: totalWeight })
+	for (const [name, weight] of options) {
+		if (random < weight) return name
+		random -= weight
+	}
+	// Fallback to first if rounding errors occur
+	return options[0][0]
 }
 

package/src/runtime/pm/utils/generator/createGeneratorConfig.ts

@@ -0,0 +1,56 @@
+import type { Mark, Node } from "@tiptap/pm/model"
+import type { builders } from "prosemirror-test-builder"
+
+export function createGeneratorConfig<
+	TBuilder extends ReturnType<typeof builders>,
+	TChildType extends "node" | "text",
+	TParentType extends "node" | "text",
+	TChildNodeType extends TChildType extends "node" ? Node : (Mark | string),
+	TParentNodeType extends TParentType extends "node" ? Node : (Mark | string)
+>(
+	config: GeneratorConfigEntry<TBuilder, TChildType, TParentType, TChildNodeType, TParentNodeType>
+): GeneratorConfigEntry<TBuilder, TChildType, TParentType, TChildNodeType, TParentNodeType> {
+	return config
+}
+
+export type GeneratorConfigEntry<
+	TBuilder extends ReturnType<typeof builders>,
+	TChildType extends "node" | "text" = "node" | "text",
+	TParentType extends "node" | "text" = "node" | "text",
+	TChildNodeType extends TChildType extends "node" ? Node : (Mark | string) = TChildType extends "node" ? Node : (Mark | string),
+	TParentNodeType extends TParentType extends "node" ? Node : (Mark | string) = TParentType extends "node" ? Node : (Mark | string)
+> = {
+	/**
+	 * Creates the node. Can return undefined to "terminate" the branch being created, the node will be filtered out of the nodes passed to it's parent.
+	 *
+	 * Note also, it is not required to use the children. You can ignore them or use a subset or create different ones if needed (some node types *require* text and if count returns 0 children will be empty, which can cause issues).
+	 */
+	create: (pm: TBuilder, parentType: string, children: TChildNodeType[]) => TParentNodeType | undefined
+	parents: {
+		/**
+		 * The type of the parent (node or "text") where "text" is a string or mark.
+		 * Determines the call signature of the create function.
+		 */
+		type: TParentType
+		/** Possible parent nodes that can have the given children. The children need not be direct descendants or real prosemirror nodes since `create` is what determines how they're created. */
+		names: string[]
+	}
+} & (
+	// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+	{} | {
+		skipChild?: (parentType: string, childType: string, depth: number) => boolean
+		children: {
+			/** The type of children (node or "text") where "text" is a string or mark. */
+			type: TChildType
+			/* Children types and their relative weights. */
+			names: [name: string, weight: number][]
+		}
+		/**
+		 * How many children to generate, is passed the depth so you can make the tree "slimmer" as it does deeper.
+		 *
+		 * See the `sometimesZero`, `influenceWithDepth` and `createRandomChildCountGenerator` helpers to make this easier to control.
+		 */
+		count: (depth: number) => number
+	}
+)
+

package/src/runtime/pm/utils/generator/createPsuedoSentence.ts

@@ -0,0 +1,18 @@
+import { faker } from "@faker-js/faker"
+
+export function createPsuedoSentence({ min = 0, max = 10}: { min?: number, max?: number } = {}) {
+	// sentence generated with string.sample (which contains all possible chars) instead of lorem.sentence
+	const sentenceLength = faker.number.int({ min, max })
+	const sentence = Array.from(
+		{ length: sentenceLength },
+		() => {
+			const doLorem = faker.number.float() < 0.5
+			if (doLorem) {
+				return faker.lorem.word()
+			} else {
+				return faker.string.sample({ min: 1, max: 10 })
+			}
+		}
+	).join(" ")
+	return sentence
+}

package/src/runtime/pm/utils/generator/createRandomChildCountGenerator.ts

@@ -0,0 +1,31 @@
+import { faker } from "@faker-js/faker"
+
+import { influenceWithDepth } from "./influenceWithDepth.js"
+import { sometimesZero } from "./sometimesZero.js"
+
+/**
+ * Combines `sometimesZero` and `influenceWithDepth` to create a function that returns a random number to pass to `count`.
+ *
+ * ```ts
+ * count: createRandomChildCountGenerator({ max: 10, depthInfluence: 0.5 })
+ * // or
+ * count: (depth: number) => createRandomChildCountGenerator({ max: 10, depthInfluence: 0.5 })(depth)
+ * ```
+ */
+export function createRandomChildCountGenerator({
+	max = 10,
+	zeroChance = 0.05,
+	depthInfluence = 1
+}: {
+	max: number
+	zeroChance?: number
+	depthInfluence?: number
+}) {
+	return (depth: number) => {
+		depth++
+		return sometimesZero(
+			faker.number.int({ min: 1, max: influenceWithDepth(max, depth, depthInfluence) || 1 }),
+			zeroChance
+		)
+	}
+}

package/src/runtime/pm/utils/generator/getTextOrMarkLength.ts

@@ -0,0 +1,9 @@
+import type { Mark } from "@tiptap/pm/model"
+
+export function getTextOrMarkLength(textOrMark: string | Mark) {
+	if (typeof textOrMark === "string") {
+		return textOrMark.length
+	}
+	const textNodes = (textOrMark as any).flat.map((_: any) => "text" in _ ? _.text.length : getTextOrMarkLength(_ as any)) as number[]
+	return textNodes.reduce((a, b) => a + b, 0)
+}

package/src/runtime/pm/utils/generator/influenceWithDepth.ts

@@ -0,0 +1,11 @@
+/**
+ * Decreases the given number by dividing it by the depth + 1 (so it it's not zero). Returns a floored *int*.
+ *
+ * Intended to help decrease the number of nodes as the depth increases. Can be adjusted by the strength parameter, to, for example, decrease the adjustment for nodes that tend to be deeper.
+ */
+export function influenceWithDepth(num: number, depth: number, strength: number = 1) {
+	if (num === 0) return 0
+	depth++ // don't allow it to be 0
+	const adjusted = Math.floor(num / (depth * strength))
+	return adjusted
+}

package/src/runtime/pm/utils/generator/sometimesZero.ts

@@ -0,0 +1,16 @@
+import { faker } from "@faker-js/faker"
+
+/**
+ * Returns 0 instead of the given number depending on the chance passed (0.05 by default).
+ *
+ * This is useful to avoid too many empty nodes without having to increase the max a lot.
+ *
+ * You can pass chance 0 to always return the given number.
+ */
+
+export function sometimesZero(num: number, chance: number = 0.05, getRandom = faker.number.float) {
+	if (getRandom() < chance) {
+		return 0
+	}
+	return num
+}

package/dist/runtime/pm/utils/generateRandomTree.d.ts

@@ -1,50 +0,0 @@
-/**
- * Generates a random tree structure where the probability of generating children
- * decreases linearly with depth, resulting in a tree that is bushy at the top
- * and sparse towards the maximum depth.
- *
- * This function is agnostic to the actual node structure, relying on the caller-provided
- * callbacks to create and link nodes.
- *
- * It uses faker.js for randomness (even on the option parameters).
- *
- * See {@link generateRandomDoc} for an example of how to use it.
- *
- * @experimental
- */
-export declare function generateRandomTree<T, TData>({ createNode, parentData }: {
-    /** A function that creates a new node (type T) given its depth. */
-    createNode: (children: T[], isLeaf: boolean, parentData?: TData) => T | undefined;
-    /**
-     * A function that is called before creating a a node or it's children whose result is passed to both. This allows creating children that will be compatible with the parent (via this same function, it is passed it's parent).
-     *
-     * For example, we could randomly generate a parent type. It's then passed both to the children, to limit the types of children nodes, and to the parent so it can actually create it.
-     */
-    parentData?: (parentData?: TData) => TData;
-}, { rootNodes: rootNodes, depth, minChildren, maxInitialChildren, initialData }?: {
-    /**
-     * The exact number of nodes at depth 0.
-     *
-     * @default faker.number.int({ min: 0, max: 5 })
-     */
-    rootNodes?: number;
-    /**
-     * The maximum depth of the tree (0-indexed). Nodes at this depth will have 0 children.
-     *
-     * @default faker.number.int({ min: 0, max: 5 })
-     */
-    depth?: number;
-    /**
-     * The absolute minimum number of children any node can have.
-     *
-     * @default 0
-     */
-    minChildren?: number;
-    /**
-     * The maximum children a node can have at depth 0. This value scales down as depth increases.
-     *
-     * @default 10
-     */
-    maxInitialChildren?: number;
-    initialData?: TData;
-}): T[];

package/dist/runtime/pm/utils/generateRandomTree.js

@@ -1,38 +0,0 @@
-import { faker } from "@faker-js/faker";
-export function generateRandomTree({
-  createNode,
-  parentData
-}, {
-  rootNodes = faker.number.int({ min: 0, max: 5 }),
-  depth = faker.number.int({ min: 0, max: 5 }),
-  minChildren = 0,
-  maxInitialChildren = 10,
-  initialData
-} = {}) {
-  const generateChildren = (currentDepth, childCount, pData) => {
-    const res = [];
-    for (let i = 0; i < childCount; i++) {
-      const numChildren = calculateNumChildren(depth, currentDepth, minChildren, maxInitialChildren);
-      const data = parentData?.(pData) ?? void 0;
-      const parent = createNode(
-        generateChildren(currentDepth + 1, numChildren, data),
-        numChildren === 0,
-        data
-      );
-      if (parent === void 0) continue;
-      res.push(parent);
-    }
-    return res;
-  };
-  return generateChildren(0, rootNodes, initialData);
-}
-function calculateNumChildren(depth, currentDepth, minChildren, maxInitialChildren) {
-  const decayFactor = depth > 0 ? (depth - currentDepth) / depth : 0;
-  const maxAtDepth = minChildren + (maxInitialChildren - minChildren) * decayFactor;
-  const maxChildrenAtDepth = Math.max(minChildren, Math.floor(maxAtDepth));
-  let numChildren = 0;
-  if (currentDepth < depth) {
-    numChildren = faker.number.int({ min: minChildren, max: maxChildrenAtDepth });
-  }
-  return numChildren;
-}

package/src/runtime/pm/utils/generateRandomTree.ts

@@ -1,100 +0,0 @@
-import { faker } from "@faker-js/faker"
-/**
- * Generates a random tree structure where the probability of generating children
- * decreases linearly with depth, resulting in a tree that is bushy at the top
- * and sparse towards the maximum depth.
- *
- * This function is agnostic to the actual node structure, relying on the caller-provided
- * callbacks to create and link nodes.
- *
- * It uses faker.js for randomness (even on the option parameters).
- *
- * See {@link generateRandomDoc} for an example of how to use it.
- *
- * @experimental
- */
-export function generateRandomTree<T, TData>(
-	{
-		createNode,
-		parentData
-	}: {
-		/** A function that creates a new node (type T) given its depth. */
-		createNode: (children: T[], isLeaf: boolean, parentData?: TData) => T | undefined
-		/**
-		 * A function that is called before creating a a node or it's children whose result is passed to both. This allows creating children that will be compatible with the parent (via this same function, it is passed it's parent).
-		 *
-		 * For example, we could randomly generate a parent type. It's then passed both to the children, to limit the types of children nodes, and to the parent so it can actually create it.
-		 */
-		parentData?: (parentData?: TData) => TData
-	},
-	{
-		rootNodes: rootNodes = faker.number.int({ min: 0, max: 5 }),
-		depth = faker.number.int({ min: 0, max: 5 }),
-		minChildren = 0,
-		maxInitialChildren = 10,
-		initialData
-	}: {
-		/**
-		 * The exact number of nodes at depth 0.
-		 *
-		 * @default faker.number.int({ min: 0, max: 5 })
-		 */
-		rootNodes?: number
-		/**
-		 * The maximum depth of the tree (0-indexed). Nodes at this depth will have 0 children.
-		 *
-		 * @default faker.number.int({ min: 0, max: 5 })
-		 */
-		depth?: number
-		/**
-		 * The absolute minimum number of children any node can have.
-		 *
-		 * @default 0
-		 */
-		minChildren?: number
-		/**
-		 * The maximum children a node can have at depth 0. This value scales down as depth increases.
-		 *
-		 * @default 10
-		 */
-		maxInitialChildren?: number
-		initialData?: TData
-	} = {}
-): T[] {
-	const generateChildren = (currentDepth: number, childCount: number, pData?: TData): T[] => {
-		const res: T[] = []
-		for (let i = 0; i < childCount; i++) {
-			const numChildren = calculateNumChildren(depth, currentDepth, minChildren, maxInitialChildren)
-
-			const data = parentData?.(pData) ?? undefined
-			const parent = createNode(
-				generateChildren(currentDepth + 1, numChildren, data),
-				numChildren === 0,
-				data
-			)
-			if (parent === undefined) continue
-			res.push(parent)
-		}
-		return res
-	}
-
-	return generateChildren(0, rootNodes, initialData)
-}
-
-function calculateNumChildren(
-	depth: number,
-	currentDepth: number,
-	minChildren: number,
-	maxInitialChildren: number
-): number {
-	const decayFactor = depth > 0 ? (depth - currentDepth) / depth : 0
-	const maxAtDepth = minChildren + (maxInitialChildren - minChildren) * decayFactor
-	const maxChildrenAtDepth = Math.max(minChildren, Math.floor(maxAtDepth))
-
-	let numChildren = 0
-
-	if (currentDepth < depth) {
-		numChildren = faker.number.int({ min: minChildren, max: maxChildrenAtDepth })
-	}
-	return numChildren
-}