svedit 0.4.0 → 0.5.0

package/src/lib/Transaction.svelte.js

@@ -1,8 +1,9 @@
 /**
- * @import { NodeId, SerializedNode, Selection, DocumentPath } from './types.js'
+ * @import { NodeId, Selection, DocumentPath } from './types.js'
  */
 
-import { get_char_length, char_slice } from './util.js';
+import { get_char_length, char_slice, traverse } from './util.js';
+import { join_text_node } from './commands.svelte.js';
 
 /**
  * Transaction class for managing atomic document operations with undo/redo support.
@@ -63,6 +64,7 @@ export default class Transaction {
    *
    * @param {DocumentPath} path - Array path to the property (e.g., ["node_1", "title"])
    * @param {any} value - The new value to set
+   * @returns {Transaction} This transaction instance for method chaining
    *
    * @example
    * ```js
@@ -89,6 +91,64 @@ export default class Transaction {
     this.ops.push(op);
     this.inverse_ops.push(['set', path, previous_value]);
     this.doc._apply_op(op);
+    return this;
+  }
+
+  // Takes a subgraph and constructs new nodes from it
+  // NOTE: all ids will be mapped to new unique ids.
+  // NOTE: Omitted properties will be populated with default values.
+  build(node_id, nodes) {
+    const depth_first_nodes = traverse(node_id, this.doc.schema, nodes);
+    // This maps original ids to newly generated ids
+    const id_map = {};
+
+    for (const node of depth_first_nodes) {
+      const new_id = this.doc.generate_id();
+      id_map[node.id] = new_id;
+      const new_node = { ...node, id: new_id };
+      const node_schema = this.doc.schema[node.type];
+
+      // Update all property references to use new IDs
+      for (const [property_name, property_definition] of Object.entries(node_schema.properties)) {
+        const property_type = property_definition.type;
+        const value = node[property_name];
+
+        // Apply default values
+        if (property_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 (property_type === 'node') {
+          // null is the default value for node references
+          new_node[property_name] = typeof value === 'string' ? id_map[value] : null;
+        } else if (property_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 (property_type === 'string') {
+          new_node[property_name] = value ?? property_definition.default ?? '';
+        } else if (property_type === 'integer') {
+          new_node[property_name] = value ?? property_definition.default ?? 0;
+        } else if (property_type === 'number') {
+          new_node[property_name] = value ?? property_definition.default ?? 0;
+        } else if (property_type === 'boolean') {
+          new_node[property_name] = value ?? property_definition.default ?? false;
+        } else if (['integer_array', 'number_array'].includes(property_type)) {
+          new_node[property_name] = value ?? property_definition.default ?? [];
+        } else if (property_type === 'string_array') {
+          new_node[property_name] = value ?? property_definition.default ?? [];
+        }
+      }
+
+      this.create(new_node);
+    }
+
+    return id_map[depth_first_nodes.at(-1).id];
   }
 
   /**
@@ -232,23 +292,60 @@ export default class Transaction {
    * 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
+   * - For collapsed selections: Deletes the previous character/node (backward) or next character/node (forward)
    *
+   * @param {'backward' | 'forward'} [direction] - Direction of deletion for collapsed selections
    * @returns {Transaction} This transaction instance for method chaining
    */
-  delete_selection() {
+  delete_selection(direction = 'backward') {
     if (!this.doc.selection) return this;
     const path = this.doc.selection.path;
+
+    if (this.doc.selection.type === 'property') {
+      this.set(path, '');
+      return this;
+    }
+
     // Get the start and end indices for the selection
     let start = Math.min(this.doc.selection.anchor_offset, this.doc.selection.focus_offset);
     let end = Math.max(this.doc.selection.anchor_offset, this.doc.selection.focus_offset);
+    let length;
+
+    if (this.doc.selection?.type === 'text') {
+      const text_content = this.doc.get(this.doc.selection.path).text;
+      length = get_char_length(text_content);
+    } else if (this.doc.selection?.type === 'node') {
+      const node_array = this.doc.get(this.doc.selection.path);
+      length = node_array.length;
+    }
 
-    // If selection is collapsed we delete the previous node
+    // If selection is collapsed we delete the previous char/node (backward)
+    // or the next char/node (forward)
     if (start === end) {
-      if (start > 0) {
+      if (direction === 'backward' && start > 0) {
         start = start - 1;
-      } else {
-        return this; // cursor is at the very beginning, do nothing.
+      } else if (direction === 'forward' && end < length) {
+        end = end + 1;
+      } else if (direction === 'backward' && start === 0) {
+        join_text_node(this);
+        return this;
+      } else if (direction === 'forward' && end === length) {
+        // At end of text - try to join with next text node
+        const node_index = parseInt(String(this.doc.selection.path.at(-2)), 10);
+        const successor_node = this.doc.get([...this.doc.selection.path.slice(0, -2), node_index + 1]);
+        // Check if next node is a text node
+        if (successor_node && this.doc.kind(successor_node) === 'text') {
+          // Set selection to beginning of next text node
+          this.set_selection({
+            type: 'text',
+            path: [...this.doc.selection.path.slice(0, -2), node_index + 1, 'content'],
+            anchor_offset: 0,
+            focus_offset: 0
+          });
+          // Use join_text_node to merge with previous node
+          join_text_node(this);
+        }
+        return this;
       }
     }
 
@@ -344,23 +441,17 @@ export default class Transaction {
   /**
    * Inserts an array of nodes at the current node selection.
    *
-   * If there's a current selection, it will be deleted first. New nodes are
-   * created if they don't already exist (e.g., for cut+paste scenarios).
+   * If there's a current selection, it will be deleted first.
    *
-   * @param {SerializedNode[]} nodes - Array of node objects to insert
+   * @param {NodeId[]} node_ids - Array of node IDs to insert
    * @returns {Transaction} This transaction instance for method chaining
    *
-   * @note Assumes we only insert new nodes, not reference existing ones
-   *
    * @example
    * ```js
-   * tr.insert_nodes([
-   *   {id: 'para_1', type: 'paragraph', content: ['Hello', []]},
-   *   {id: 'para_2', type: 'paragraph', content: ['World', []]}
-   * ]);
+   * tr.insert_nodes_new(['para_1', 'para_2']);
    * ```
    */
-  insert_nodes(nodes) {
+  insert_nodes(node_ids) {
     if (this.doc.selection.type !== 'node') return this;
 
     // Unless cursor is collapsed, delete the selected nodes as a first step
@@ -382,13 +473,6 @@ export default class Transaction {
       node_array.splice(start, end - start);
     }
 
-    // First create the new nodes (unless they already exists e.g. in case of cut+paste)
-    nodes.forEach(node => {
-      if (!this.doc.get(node.id)) {
-        this.create(node);
-      }
-    });
-    const node_ids = nodes.map(node => node.id);
     node_array.splice(start, 0, ...node_ids);
 
     // Update the node_array in the entry
@@ -398,7 +482,7 @@ export default class Transaction {
       type: 'node',
       path: [...this.doc.selection.path],
       anchor_offset: start,
-      focus_offset: start + nodes.length
+      focus_offset: start + node_ids.length
     };
     return this;
   }
@@ -419,7 +503,7 @@ export default class Transaction {
    * tr.insert_text('Hello, world!');
    * ```
    */
-  insert_text(replaced_text) {
+  insert_text(replaced_text, annotations = [], nodes = {}) {
     if (this.doc.selection.type !== 'text') return this;
 
     const annotated_text = structuredClone($state.snapshot(this.doc.get(this.doc.selection.path)));
@@ -487,6 +571,32 @@ export default class Transaction {
       focus_offset: start + get_char_length(replaced_text),
     };
     this.doc.selection = new_selection;
+
+    // Now we apply annotations if there are any, but only if there's no active annotation
+    // at the current collapsed cursor
+    if (!this.doc.active_annotation() && annotations.length > 0) {
+      const new_annotations = annotations.map(annotation => {
+        const original_annotation_node = nodes[annotation.node_id];
+        const text_property_definition = this.doc.inspect(this.doc.selection.path);
+        // console.log('original_annotation_node.type', original_annotation_node.type);
+        // console.log('text_property_definition', text_property_definition);
+        if (text_property_definition.node_types.includes(original_annotation_node.type)) {
+          const new_annotation_node_id = this.build(annotation.node_id, nodes);
+          return {
+            start_offset: start + annotation.start_offset,
+            end_offset: start + annotation.end_offset,
+            node_id: new_annotation_node_id
+          };
+        } else {
+          // Annotation type not allowed in new context, skip it.
+          return null;
+        }
+      }).filter(Boolean);
+      const next_annotated_text = structuredClone(annotated_text);
+      next_annotated_text.annotations = next_annotated_text.annotations.concat(new_annotations);
+      this.set(this.doc.selection.path, next_annotated_text); // this will update the current state and create a history entry
+    }
+
     return this;
   }
 

package/src/lib/commands.svelte.js

@@ -117,7 +117,7 @@ export function join_text_node(tr) {
   });
 
   tr.delete_selection();
-  
+
   // Finally set the cursor position at the join point using the pre-calculated position
   tr.set_selection({
     type: 'text',
@@ -145,11 +145,6 @@ export function insert_default_node(tr) {
   const property_definition = doc.schema[node_array_node.type].properties[property_name];
   const default_type = get_default_node_type(property_definition);
 
-  // Only proceed if there's exactly one allowed node_type
-  // if (!default_type || property_schema.node_types.length !== 1) {
-  //   return false;
-  // }
-
   // Use the inserter function if available
   if (doc.config?.inserters?.[default_type]) {
     doc.config.inserters[default_type](tr);

package/src/lib/util.js

@@ -233,3 +233,37 @@ export function snake_to_pascal(str) {
     .map(word => word.charAt(0).toUpperCase() + word.slice(1))
     .join('');
 }
+
+export function traverse(node_id, schema, nodes) {
+  const json = [];
+  const visited = {};
+  const visit = (node) => {
+    if (!node || visited[node.id]) {
+      return;
+    }
+    visited[node.id] = true;
+    for (const [property_name, value] of Object.entries(node)) {
+      const property_definition = schema[node.type].properties[property_name];
+
+      if (property_definition?.type === 'node_array') {
+        for (const v of value) {
+          if (typeof v === 'string') {
+            visit(nodes[v]);
+          }
+        }
+      } else if (property_definition?.type === 'node') {
+        visit(nodes[value]);
+      } else if (property_definition?.type === 'annotated_text') {
+        for (const annotation of value.annotations) {
+          visit(nodes[annotation.node_id]);
+        }
+      }
+    }
+    // Finally add the node to the result.
+    // Deep clone, to make sure nothing of the original document is referenced.
+    json.push(structuredClone(node));
+  }
+  // Start with the root node (document_id)
+  visit(nodes[node_id]);
+  return json;
+}