svedit 0.9.0 → 0.11.0

package/src/lib/Transaction.svelte.js

@@ -18,8 +18,10 @@ import {
 	apply_op,
 	count_references_excluding_deleted,
 	validate_node,
+	fill_node_defaults,
 	get_active_annotation,
-	validate_selection
+	validate_selection,
+	can_switch_annotation_type
 } from './doc_utils.js';
 
 /**
@@ -60,6 +62,13 @@ export default class Transaction {
 		this.inverse_ops = [];
 		// Remember the selection before the transaction started
 		this.selection_before = selection;
+
+		/** @type {NodeId[]} */
+		this.created_node_ids = [];
+		/** @type {NodeId[]} */
+		this.modified_node_ids = [];
+		/** @type {NodeId[]} */
+		this.deleted_node_ids = [];
 	}
 
 	/**
@@ -119,9 +128,10 @@ export default class Transaction {
 	 * @throws {Error} Throws if the node is invalid
 	 */
 	validate_node(node) {
-		validate_node(node, this.schema, this.doc.nodes);
+		validate_node(node, this.schema, this.doc.nodes, { require_references: false });
 	}
 
+
 	/**
 	 * Gets all nodes referenced by a given node (recursively).
 	 *
@@ -166,6 +176,15 @@ export default class Transaction {
 		this.doc = apply_op(this.doc, op);
 	}
 
+	/**
+	 * @param {NodeId[]} node_ids
+	 * @param {NodeId} node_id
+	 * @private
+	 */
+	_track_node_id(node_ids, node_id) {
+		if (!node_ids.includes(node_id)) node_ids.push(node_id);
+	}
+
 	/**
 	 * Sets a property of a node to a new value.
 	 *
@@ -183,6 +202,13 @@ export default class Transaction {
 	 * ```
 	 */
 	set(path, value) {
+		const path_info = this.inspect(path);
+		if (path_info?.kind !== 'property') {
+			throw new Error(
+				`Transaction.set requires a path that points to a property, got ${JSON.stringify(path)}`
+			);
+		}
+
 		const node = this.get(path.slice(0, -1));
 
 		// Turns ["page_1", "body", "0", "description"]
@@ -192,9 +218,6 @@ export default class Transaction {
 
 		// Just to be sure, make a deep copy of the old value
 		const property_key = path.at(-1);
-		if (property_key === undefined) {
-			throw new Error('Invalid path: cannot get property key');
-		}
 		const property_key_str = String(property_key);
 		const previous_value = structuredClone($state.snapshot(node[property_key_str]));
 
@@ -218,10 +241,17 @@ export default class Transaction {
 		this.ops.push(op);
 		this.inverse_ops.push(['set', normalized_path, previous_value]);
 		this._apply_op(op);
-
-		for (const removed_node_id of removed_node_ids) {
-			// NOTE: This implicitly deletes childnodes as well, given that they are no longer referenced.
-			this.delete(removed_node_id);
+		this._track_node_id(this.modified_node_ids, node.id);
+
+		// Garbage-collect nodes whose only reference was via this property.
+		// We must use a ref-count-aware sweep instead of unconditional deletion
+		// because a node ID removed from this array may still be referenced
+		// elsewhere — either from a pre-existing reference (e.g. shared nodes)
+		// or from a node created earlier in the same transaction (the
+		// wrap-in-group pattern: create a wrapper that points at the children,
+		// then set the parent array to drop them).
+		if (removed_node_ids.length > 0) {
+			this._cascade_delete_unreferenced_nodes(removed_node_ids);
 		}
 
 		return this;
@@ -238,48 +268,28 @@ export default class Transaction {
 		for (const node of depth_first_nodes) {
 			const new_id = this.generate_id();
 			id_map[node.id] = new_id;
-			const new_node = { ...node, id: new_id };
+			let new_node = { ...node, id: new_id };
 			const node_schema = this.schema[node.type];
 
 			// Update all property references to use new IDs
 			for (const [property_name, property_definition] of Object.entries(node_schema.properties)) {
 				const prop_type = property_definition.type;
-				const value = node[property_name];
-
-				// Apply default values
-				if (prop_type === 'node_array') {
-					// [] is the default value for node arrays
-					new_node[property_name] = Array.isArray(value)
-						? value.map((ref_id) => id_map[ref_id])
-						: [];
-				} else if (prop_type === 'node') {
-					// null is the default value for node references
-					new_node[property_name] = typeof value === 'string' ? id_map[value] : null;
-				} else if (prop_type === 'annotated_text') {
-					if (value) {
-						const annotations = value.annotations.map((annotation) => {
-							const { start_offset, end_offset, node_id } = annotation;
-							return { start_offset, end_offset, node_id: id_map[node_id] || node_id };
-						});
-						new_node[property_name] = { text: value.text, annotations };
-					} else {
-						new_node[property_name] = { text: '', annotations: [] };
-					}
-				} else if (prop_type === 'string') {
-					new_node[property_name] = value ?? property_definition.default ?? '';
-				} else if (prop_type === 'integer') {
-					new_node[property_name] = value ?? property_definition.default ?? 0;
-				} else if (prop_type === 'number') {
-					new_node[property_name] = value ?? property_definition.default ?? 0;
-				} else if (prop_type === 'boolean') {
-					new_node[property_name] = value ?? property_definition.default ?? false;
-				} else if (['integer_array', 'number_array'].includes(prop_type)) {
-					new_node[property_name] = value ?? property_definition.default ?? [];
-				} else if (prop_type === 'string_array') {
-					new_node[property_name] = value ?? property_definition.default ?? [];
+				const value = new_node[property_name];
+
+				if (prop_type === 'node_array' && Array.isArray(value)) {
+					new_node[property_name] = value.map((ref_id) => id_map[ref_id]);
+				} else if (prop_type === 'node' && typeof value === 'string') {
+					new_node[property_name] = id_map[value];
+				} else if (prop_type === 'annotated_text' && value) {
+					const annotations = value.annotations.map((annotation) => {
+						const { start_offset, end_offset, node_id } = annotation;
+						return { start_offset, end_offset, node_id: id_map[node_id] || node_id };
+					});
+					new_node[property_name] = { text: value.text, annotations };
 				}
 			}
 
+			new_node = fill_node_defaults(new_node, this.schema);
 			this.create(new_node);
 		}
 
@@ -290,9 +300,9 @@ export default class Transaction {
 	 * Creates a new node in the document.
 	 *
 	 * The node must have a valid id and must not already exist in the document.
-	 * The node is validated against the document schema before creation.
+	 * Omitted properties with schema defaults are filled before validation.
 	 *
-	 * @param {any} node - The node object to create (must include id, type, and other properties)
+	 * @param {any} node - The node object to create (must include id, type, and required properties)
 	 * @returns {Transaction} This transaction instance for method chaining
 	 * @throws {Error} If the node ID is invalid or if the node already exists
 	 *
@@ -306,17 +316,20 @@ export default class Transaction {
 	 * ```
 	 */
 	create(node) {
+		const node_with_defaults = fill_node_defaults(node, this.schema);
+
 		// Validate node against schema
-		this.validate_node(node);
+		this.validate_node(node_with_defaults);
 
-		if (this.get(node.id)) {
-			throw new Error('Node with id ' + node.id + ' already exists');
+		if (this.get(node_with_defaults.id)) {
+			throw new Error('Node with id ' + node_with_defaults.id + ' already exists');
 		}
 
-		const op = ['create', node];
+		const op = ['create', node_with_defaults];
 		this.ops.push(op);
-		this.inverse_ops.push(['delete', node.id]);
+		this.inverse_ops.push(['delete', node_with_defaults.id]);
 		this._apply_op(op);
+		this._track_node_id(this.created_node_ids, node_with_defaults.id);
 		return this;
 	}
 
@@ -325,6 +338,13 @@ export default class Transaction {
 	 *
 	 * The node's current state is captured for undo support before deletion.
 	 *
+	 * NOTE: This is a force-delete and intentionally does NOT check whether
+	 * the node is still referenced from elsewhere — callers (e.g.
+	 * `annotate_text`) sometimes need to remove a node while a stale
+	 * reference to it still exists in the property they are about to update.
+	 * For ref-count-aware cleanup, see how `set` calls
+	 * `_cascade_delete_unreferenced_nodes`.
+	 *
 	 * @param {any} id - The ID of the node to delete
 	 * @returns {Transaction} This transaction instance for method chaining
 	 *
@@ -345,6 +365,7 @@ export default class Transaction {
 		this.ops.push(op);
 		this.inverse_ops.push(['create', previous_value]);
 		this._apply_op(op);
+		this._track_node_id(this.deleted_node_ids, id);
 		// Cascade delete any nodes that are now orphaned after removing this node
 		this._cascade_delete_unreferenced_nodes(referenced_nodes);
 		return this;
@@ -402,6 +423,8 @@ export default class Transaction {
 		const annotations = annotated_text.annotations;
 		const existing_annotation = this.active_annotation();
 		const existing_annotation_same_type = this.active_annotation(annotation_type);
+		const has_annotation_properties =
+			annotation_properties && Object.keys(annotation_properties).length > 0;
 
 		if (existing_annotation) {
 			// If there's an existing annotation of the same type, remove it
@@ -417,16 +440,30 @@ export default class Transaction {
 					annotations.splice(index, 1);
 				}
 			} else {
-				// If there's an annotation of a different type, don't add a new one
+				const existing_annotation_node = this.get(existing_annotation.node_id);
+				const can_switch_annotation =
+					!has_annotation_properties &&
+					this.available_annotation_types.includes(annotation_type) &&
+					can_switch_annotation_type(
+						this.schema,
+						existing_annotation_node,
+						annotation_type
+					);
+
+				if (can_switch_annotation) {
+					this.set([existing_annotation.node_id, 'type'], annotation_type);
+					return this;
+				}
+
+				// If there's an annotation of a different incompatible type, don't add a new one
 				return this;
 			}
 		} else {
 			if (is_selection_collapsed(this.selection)) {
-				console.log('Annotations can only be added to expanded text selections.');
 				return this;
 			}
 			if (!this.available_annotation_types.includes(annotation_type)) {
-				console.log(`Annotation type ${annotation_type} is not allowed here.`);
+				console.warn(`Annotation type ${annotation_type} is not allowed here.`);
 				return this;
 			}
 			const new_annotation_node = {
@@ -449,19 +486,25 @@ export default class Transaction {
 	}
 
 	/**
-	 * Deletes the currently selected text or nodes.
+	 * Deletes the currently selected text, node, or property.
 	 *
 	 * Behavior depends on selection type:
 	 * - For node selections: Removes selected nodes and cascades deletion of unreferenced nodes
 	 * - For text selections: Removes selected text and adjusts annotations accordingly
 	 * - For collapsed selections: Deletes the previous character/node (backward) or next character/node (forward)
-	 * - Property selections are ignored: Those are best handled handled via commands + keyboard shortcuts.
+	 * - For property selections: Delegates to the config's handle_property_deletion hook
 	 *
 	 * @param {'backward' | 'forward'} [direction] - Direction of deletion for collapsed selections
 	 * @returns {Transaction} This transaction instance for method chaining
 	 */
 	delete_selection(direction = 'backward') {
-		if (!this.selection || this.selection.type === 'property') return this;
+		if (!this.selection) return this;
+
+		if (this.selection.type === 'property') {
+			this.config.handle_property_deletion?.(this, this.selection.path);
+			return this;
+		}
+
 		const path = this.selection.path;
 
 		// Get the start and end indices for the selection
@@ -579,13 +622,11 @@ export default class Transaction {
 
 			text.annotations = new_annotations;
 
-			// Delete marked annotation nodes
-			for (const node_id of _deleted_nodes) {
-				this.delete(node_id);
-			}
-
 			this.set(path, text);
 
+			// Delete marked annotation nodes only if no other references remain.
+			this._cascade_delete_unreferenced_nodes(_deleted_nodes);
+
 			// Update the selection to the new caret position
 			this.selection = {
 				type: 'text',
@@ -778,6 +819,7 @@ export default class Transaction {
 				this.ops.push(op);
 				this.inverse_ops.push(['create', previous_value]);
 				this._apply_op(op);
+				this._track_node_id(this.deleted_node_ids, node_id);
 			}
 		}
 	}