svedit 0.5.0 → 0.6.1

package/src/lib/commands.svelte.js

@@ -1,266 +0,0 @@
-import { split_annotated_text, join_annotated_text, get_char_length } from './util.js';
-import { get_default_node_type } from './Document.svelte.js';
-
-export function break_text_node(tr) {
-  const doc = tr.doc;
-  // Keep a reference of the original selection (before any transforms are applied)
-  const selection = doc.selection;
-  // First we need to ensure we have a text selection
-  if (selection.type !== 'text') return false;
-
-  // Next, we need to determine if the enclosing node is a pure text node (e.g. paragraph),
-  // which is wrapped inside a node_array (e.g. page.body)
-
-  // Owner of the text property (e.g. paragraph)
-  const node = doc.get(selection.path.slice(0, -1));
-  if (doc.kind(node) !== 'text') return false;
-  const is_inside_node_array = doc.inspect(selection.path.slice(0, -2))?.type === 'node_array';
-  // console.log('is_inside_node_array', is_inside_node_array);
-  if (!is_inside_node_array) return false; // Do nothing if we're not inside a node_array
-  const node_array_prop = selection.path.at(-3);
-  // console.log('node_array_prop', node_array_prop);
-  // Get the node that owns the node_array property (e.g. a page.body)
-  const node_array_node = doc.get(selection.path.slice(0, -3));
-  // console.log('node_array_node', $state.snapshot(node_array_node));
-
-  // Delete selection unless collapsed
-  if (selection.anchor_offset !== selection.focus_offset) {
-    tr.delete_selection();
-  }
-
-  const split_at_position = tr.doc.selection.anchor_offset;
-  const content = tr.doc.get(selection.path);
-  const [left_text, right_text] = split_annotated_text(content, split_at_position);
-
-  tr.set([node.id, 'content'], left_text);
-
-  const node_insert_position = {
-    type: 'node',
-    path: tr.doc.selection.path.slice(0, -2),
-    anchor_offset: parseInt(tr.doc.selection.path.at(-2), 10) + 1,
-    focus_offset: parseInt(tr.doc.selection.path.at(-2), 10) + 1,
-  };
-
-  // TODO: Only use default_node_type when cursor is at the end of
-  const node_array_property_definition = doc.schema[node_array_node.type].properties[node_array_prop];
-  const target_node_type = get_default_node_type(node_array_property_definition);
-
-  if (!target_node_type) {
-    console.warn('Cannot determine target node type for break_text_node - no default_ref_type and multiple node_types');
-    return false;
-  }
-
-  tr.set_selection(node_insert_position);
-
-  doc.config.inserters[target_node_type](tr, right_text);
-  return true;
-}
-
-export function join_text_node(tr) {
-  const doc = tr.doc;
-  // Keep a reference of the original selection (before any transforms are applied)
-  const selection = doc.selection;
-  // First we need to ensure we have a text selection
-  if (selection.type !== 'text') return false;
-
-  const node = doc.get(selection.path.slice(0, -1));
-  if (doc.kind(node) !== 'text') return false;
-  const is_inside_node_array = doc.inspect(selection.path.slice(0, -2))?.type === 'node_array';
-  // console.log('is_inside_node_array', is_inside_node_array);
-  if (!is_inside_node_array) return false; // Do nothing if we're not inside a node_array
-
-  const node_index = parseInt(doc.selection.path.at(-2), 10);
-
-  // Determine if we can join with the previous node
-  let can_join = false;
-  let predecessor_node = null;
-
-  if (node_index > 0) {
-    const previous_text_path = [...doc.selection.path.slice(0, -2), node_index - 1];
-    predecessor_node = doc.get(previous_text_path);
-    can_join = doc.kind(predecessor_node) === 'text';
-  }
-
-  // Special behavior: if we can't join and current node is empty, delete it
-  if (!can_join && node.content.text === '') {
-    tr.set_selection({
-      type: 'node',
-      path: doc.selection.path.slice(0, -2),
-      anchor_offset: node_index,
-      focus_offset: node_index + 1,
-    });
-    tr.delete_selection();
-    return true;
-  }
-
-  // If we can't join for any reason, return false
-  if (!can_join) {
-    return false;
-  }
-
-  // Normal joining logic - both nodes are text nodes
-  const previous_text_path = [...doc.selection.path.slice(0, -2), node_index - 1];
-  const joined_text = join_annotated_text(predecessor_node.content, node.content);
-
-  // Calculate cursor position based on original predecessor content length
-  const cursor_position = get_char_length(predecessor_node.content.text);
-
-  // First set the joined content on the predecessor node (preserves annotations)
-  tr.set([predecessor_node.id, 'content'], joined_text);
-
-  // Then delete the current node
-  tr.set_selection({
-    type: 'node',
-    path: doc.selection.path.slice(0, -2),
-    anchor_offset: node_index,
-    focus_offset: node_index + 1,
-  });
-
-  tr.delete_selection();
-
-  // Finally set the cursor position at the join point using the pre-calculated position
-  tr.set_selection({
-    type: 'text',
-    path: [...previous_text_path, 'content'],
-    anchor_offset: cursor_position,
-    focus_offset: cursor_position,
-  });
-  return true;
-}
-
-export function insert_default_node(tr) {
-  const doc = tr.doc;
-  const selection = doc.selection;
-
-  // Only work with collapsed node selections
-  if (selection?.type !== 'node' || selection.anchor_offset !== selection.focus_offset) {
-    return false;
-  }
-
-  const path = selection.path;
-  const node_array_node = doc.get(path.slice(0, -1));
-  const property_name = path.at(-1);
-
-  // Get the definition for this property
-  const property_definition = doc.schema[node_array_node.type].properties[property_name];
-  const default_type = get_default_node_type(property_definition);
-
-  // Use the inserter function if available
-  if (doc.config?.inserters?.[default_type]) {
-    doc.config.inserters[default_type](tr);
-    return true;
-  } else {
-    throw new Error(`No inserter function available for default node type '${default_type}'`);
-  }
-}
-
-export function select_all(tr) {
-  const doc = tr.doc;
-  const selection = doc.selection;
-
-  if (!selection) {
-    return false;
-  }
-
-  if (selection.type === 'text') {
-    const text_content = doc.get(selection.path);
-    const text_length = get_char_length(text_content.text);
-
-    // Check if all text is already selected
-    const is_all_text_selected =
-      Math.min(selection.anchor_offset, selection.focus_offset) === 0 &&
-      Math.max(selection.anchor_offset, selection.focus_offset) === text_length;
-
-    if (!is_all_text_selected) {
-      // Select all text in the current text node
-      tr.set_selection({
-        type: 'text',
-        path: selection.path,
-        anchor_offset: 0,
-        focus_offset: text_length
-      });
-      return true;
-    } else {
-      // All text is selected, move up to select the containing node
-      const node_path = selection.path.slice(0, -1); // Remove the property name (e.g., 'content')
-
-      // Check if we have enough path segments and if we're inside a node_array
-      if (node_path.length >= 2) {
-        const is_inside_node_array = doc.inspect(node_path.slice(0, -1))?.type === 'node_array';
-
-        if (is_inside_node_array) {
-          const node_index = parseInt(node_path.at(-1));
-          tr.set_selection({
-            type: 'node',
-            path: node_path.slice(0, -1),
-            anchor_offset: node_index,
-            focus_offset: node_index + 1
-          });
-          return true;
-        }
-      }
-      // Stop expanding - text is not in a selectable node_array
-    }
-  } else if (selection.type === 'node') {
-    const node_array_path = selection.path;
-    const node_array = doc.get(node_array_path);
-
-    // Check if the entire node_array is already selected
-    const is_entire_node_array_selected =
-      Math.min(selection.anchor_offset, selection.focus_offset) === 0 &&
-      Math.max(selection.anchor_offset, selection.focus_offset) === node_array.length;
-
-    if (!is_entire_node_array_selected) {
-      // Select the entire node_array
-      tr.set_selection({
-        type: 'node',
-        path: node_array_path,
-        anchor_offset: 0,
-        focus_offset: node_array.length
-      });
-      return true;
-    } else {
-      // Entire node_array is selected, try to move up to parent node_array
-      const parent_path = node_array_path.slice(0, -1);
-
-      // Check if we have enough path segments and if parent is a valid node_array
-      if (parent_path.length >= 2) {
-        const is_parent_node_array = doc.inspect(parent_path.slice(0, -1))?.type === 'node_array';
-
-        if (is_parent_node_array) {
-          const parent_node_index = parseInt(parent_path.at(-1));
-          tr.set_selection({
-            type: 'node',
-            path: parent_path.slice(0, -1),
-            anchor_offset: parent_node_index,
-            focus_offset: parent_node_index + 1
-          });
-          return true;
-        }
-      }
-      // Stop expanding - we've reached the top level
-    }
-  } else if (selection.type === 'property') {
-    // For property selections, select the containing node
-    const node_path = selection.path.slice(0, -1);
-
-    // Check if we have enough path segments and if we're inside a node_array
-    if (node_path.length >= 2) {
-      const is_inside_node_array = doc.inspect(node_path.slice(0, -1))?.type === 'node_array';
-
-      if (is_inside_node_array) {
-        const node_index = parseInt(node_path.at(-1));
-        tr.set_selection({
-          type: 'node',
-          path: node_path.slice(0, -1),
-          anchor_offset: node_index,
-          focus_offset: node_index + 1
-        });
-        return true;
-      }
-    }
-    // Stop expanding - property is not in a selectable node_array
-  }
-
-  return false;
-}

package/src/lib/util.js

@@ -1,269 +0,0 @@
-/**
- * @import { Annotation, AnnotatedText } from './types.d.ts';
- */
-
-/**
- * Get the actual character length (accounting for multi-byte characters)
- *
- * Uses Intl.Segmenter to count grapheme clusters rather than UTF-16 code units,
- * ensuring emojis and other complex Unicode sequences are counted as single characters.
- *
- * @param {string} str - The string to measure
- * @returns {number} The number of visual characters (grapheme clusters)
- *
- * @example
- * get_char_length('Hello') // Returns: 5
- * get_char_length('a😀b') // Returns: 3 (not 4)
- * get_char_length('👋🏽') // Returns: 1 (not 4 - skin tone modifier treated as single char)
- */
-export function get_char_length(str) {
-  const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
-  return [...segmenter.segment(str)].length;
-}
-
-/**
- * Get a single character at the specified position (accounting for multi-byte characters)
- *
- * Uses Intl.Segmenter to access grapheme clusters rather than UTF-16 code units,
- * ensuring emojis and other complex Unicode sequences are treated as single characters.
- *
- * @param {string} str - The string to access
- * @param {number} index - Character position (0-based)
- * @returns {string} The character at the specified position, or empty string if index is out of bounds
- *
- * @example
- * get_char_at('Hello', 1) // Returns: 'e'
- * get_char_at('a😀b', 1) // Returns: '😀' (full emoji)
- * get_char_at('👋🏽', 0) // Returns: '👋🏽' (skin tone modifier included)
- */
-export function get_char_at(str, index) {
-  const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
-  const segments = [...segmenter.segment(str)];
-  return segments[index].segment;
-}
-
-/**
- * Slice string by character positions (accounting for multi-byte characters)
- *
- * Uses Intl.Segmenter to slice by grapheme clusters rather than UTF-16 code units,
- * ensuring emojis and other complex Unicode sequences remain intact.
- *
- * @param {string} str - The string to slice
- * @param {number} start - Starting character position (inclusive)
- * @param {number} [end] - Ending character position (exclusive). If undefined, slices to end
- * @returns {string} The sliced string with complete characters
- *
- * @example
- * char_slice('Hello 😀 World', 6, 8) // Returns: '😀 ' (emoji stays intact)
- * char_slice('a👋🏽b', 1, 2) // Returns: '👋🏽' (skin tone modifier included)
- */
-export function char_slice(str, start, end = undefined) {
-  const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
-  const segments = [...segmenter.segment(str)];
-  return segments.slice(start, end).map(s => s.segment).join('');
-}
-
-/**
- * Convert UTF-16 code unit offset to grapheme cluster offset within a string
- *
- * Converts DOM selection offsets (which use UTF-16 code units) to character-based
- * offsets (grapheme clusters) for consistent text manipulation.
- *
- * @param {string} str - The string to convert offsets within
- * @param {number} utf16_offset - The UTF-16 code unit offset from DOM
- * @returns {number} The corresponding grapheme cluster offset
- *
- * @example
- * // For string "a😀b" where 😀 uses 2 UTF-16 code units
- * utf16_to_char_offset("a😀b", 3) // Returns: 2 (position after emoji)
- */
-export function utf16_to_char_offset(str, utf16_offset) {
-  const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
-  const segments = [...segmenter.segment(str)];
-  let char_offset = 0;
-  let utf16_count = 0;
-
-  for (const segment of segments) {
-    if (utf16_count >= utf16_offset) break;
-    utf16_count += segment.segment.length;
-    if (utf16_count > utf16_offset) break;
-    char_offset++;
-  }
-
-  return char_offset;
-}
-
-/**
- * Convert grapheme cluster offset to UTF-16 code unit offset within a string
- *
- * Converts character-based offsets (grapheme clusters) to DOM selection offsets
- * (UTF-16 code units) for proper DOM selection positioning.
- *
- * @param {string} str - The string to convert offsets within
- * @param {number} char_offset - The grapheme cluster offset
- * @returns {number} The corresponding UTF-16 code unit offset for DOM operations
- *
- * @example
- * // For string "a😀b" where 😀 uses 2 UTF-16 code units
- * char_to_utf16_offset("a😀b", 2) // Returns: 3 (UTF-16 position after emoji)
- */
-export function char_to_utf16_offset(str, char_offset) {
-  const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
-  const segments = [...segmenter.segment(str)];
-  let utf16_offset = 0;
-
-  for (let i = 0; i < Math.min(char_offset, segments.length); i++) {
-    utf16_offset += segments[i].segment.length;
-  }
-
-  return utf16_offset;
-}
-
-/**
- * Splits an annotated text at the specified character position.
- *
- * Annotations that span the split point will be divided appropriately,
- * with offsets adjusted for each resulting part.
- *
- * @param {AnnotatedText} text_with_annotations - Annotated text object
- * @param {number} at_position - Character position where to split (0-based)
- * @returns {[AnnotatedText, AnnotatedText]} Tuple of [left_part, right_part]
- *
- * @example
- * split_annotated_text({text: "Hello world", annotations: [{start_offset: 6, end_offset: 11, node_id: "strong"}]}, 8)
- * // Returns:
- * // [
- * //   {text: "Hello wo", annotations: [{start_offset: 6, end_offset: 8, node_id: "strong"}]},
- * //   {text: "rld", annotations: [{start_offset: 0, end_offset: 3, node_id: "strong"}]}
- * // ]
- */
-export function split_annotated_text(text_with_annotations, at_position) {
-  const {text, annotations} = text_with_annotations;
-
-  // Split the text using character-aware slicing
-  const left_text = char_slice(text, 0, at_position);
-  const right_text = char_slice(text, at_position);
-
-  /** @type {Array<Annotation>} */
-  const left_annotations = [];
-  /** @type {Array<Annotation>} */
-  const right_annotations = [];
-
-  // Process each annotation
-  for (const {start_offset, end_offset, node_id} of annotations) {
-    if (end_offset <= at_position) {
-      // Annotation is entirely in the left part
-      left_annotations.push({start_offset, end_offset, node_id});
-    } else if (start_offset >= at_position) {
-      // Annotation is entirely in the right part - shift offsets
-      right_annotations.push({start_offset: start_offset - at_position, end_offset: end_offset - at_position, node_id});
-    } else {
-      // Annotation spans the split point - split it
-      left_annotations.push({start_offset, end_offset: at_position, node_id});
-      right_annotations.push({start_offset: 0, end_offset: end_offset - at_position, node_id});
-    }
-  }
-
-  return [
-    {text: left_text, annotations: left_annotations},
-    {text: right_text, annotations: right_annotations}
-  ];
-}
-
-
-/**
- * Joins two annotated texts into a single annotated text.
- *
- * Annotations from the second text will have their offsets shifted by the length
- * of the first text. Adjacent annotations of the same type and data will be merged.
- *
- * @param {AnnotatedText} first_text - First annotated text object
- * @param {AnnotatedText} second_text - Second annotated text object
- * @returns {AnnotatedText} Combined annotated text object
- *
- * @example
- * join_annotated_text({text: "Hello wo", annotations: [{start_offset: 6, end_offset: 8, node_id: "strong"}]}, {text: "rld", annotations: [{start_offset: 0, end_offset: 3, node_id: "strong"}]})
- * // Returns: {text: "Hello world", annotations: [{start_offset: 6, end_offset: 11, node_id: "strong"}]}
- */
-export function join_annotated_text(first_text, second_text) {
-  const {text: first_text_content, annotations: first_annotations} = first_text;
-  const {text: second_text_content, annotations: second_annotations} = second_text;
-
-  // Join the text content
-  const joined_text = first_text_content + second_text_content;
-
-  // Start with all annotations from the first text (unchanged)
-  /** @type {Array<Annotation>} */
-  const joined_annotations = [...first_annotations];
-
-  // Add annotations from the second text, shifting their offsets
-  const offset = get_char_length(first_text_content);
-  for (const {start_offset, end_offset, node_id} of second_annotations) {
-    /** @type {Annotation} */
-    const shifted_annotation = {start_offset: start_offset + offset, end_offset: end_offset + offset, node_id};
-
-    // Check if this annotation can be merged with the last annotation from first text
-    const last_annotation = joined_annotations[joined_annotations.length - 1];
-    if (last_annotation &&
-        last_annotation.end_offset === shifted_annotation.start_offset && // annotations are adjacent
-        last_annotation.node_id === shifted_annotation.node_id) { // same node_id
-      // Merge by extending the end position of the last annotation
-      last_annotation.end_offset = shifted_annotation.end_offset;
-    } else {
-      // Add as separate annotation
-      joined_annotations.push(shifted_annotation);
-    }
-  }
-
-  return {text: joined_text, annotations: joined_annotations};
-}
-
-/**
- * Convert snake_case string to PascalCase
- *
- * @param {string} str - The snake_case string to convert
- * @returns {string} The converted PascalCase string
- *
- * @example
- * snake_to_pascal('list_item') // Returns: 'ListItem'
- */
-export function snake_to_pascal(str) {
-  return str
-    .split('_')
-    .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;
-}