svedit 0.1.0

package/src/lib/commands.svelte.js

@@ -0,0 +1,261 @@
+import { split_annotated_string, join_annotated_string } 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_string(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][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);
+}
+
+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[0] === '') {
+    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_string(predecessor_node.content, node.content);
+
+  tr.set_selection({
+    type: 'node',
+    path: doc.selection.path.slice(0, -2),
+    anchor_offset: node_index,
+    focus_offset: node_index + 1,
+  });
+
+  tr.delete_selection();
+  tr.set_selection({
+    type: 'text',
+    path: [...previous_text_path, 'content'],
+    anchor_offset: predecessor_node.content[0].length,
+    focus_offset: predecessor_node.content[0].length,
+  });
+  tr.set([predecessor_node.id, 'content'], joined_text);
+}
+
+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][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);
+    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 = text_content[0].length;
+
+    // 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/index.js

@@ -0,0 +1,14 @@
+// Main exports for the svedit library
+export { default as Svedit } from './Svedit.svelte';
+export { default as AnnotatedStringProperty } from './AnnotatedStringProperty.svelte';
+export { default as CustomProperty } from './CustomProperty.svelte';
+export { default as Node } from './Node.svelte';
+export { default as NodeArrayProperty } from './NodeArrayProperty.svelte';
+
+// Core classes and utilities
+export { default as Document, define_document_schema } from './Document.svelte.js';
+export { default as Transaction } from './Transaction.svelte.js';
+
+// Commands and utilities
+export * from './commands.svelte.js';
+export * from './util.js';

package/src/lib/types.d.ts

@@ -0,0 +1,264 @@
+import type Document from './Document.svelte.js';
+import type Svedit from './Svedit.svelte';
+
+// ===== SVELTE TYPE IMPORTS =====
+
+/**
+ * Import Svelte's Snippet type for properly typing children in components
+ */
+import type { Component, Snippet } from 'svelte';
+
+// ===== SELECTION TYPE DEFINITIONS =====
+
+/**
+ * A unique node identifier (ideally UUID)
+ */
+export type NodeId = string;
+
+/**
+ * Array of IDs, property names (strings), or indexes (integers) that identify a node or property in the document
+ */
+export type DocumentPath = Array<string | number>;
+
+/**
+ * Text selection within a text property
+ */
+export type TextSelection = {
+  type: "text";
+  path: DocumentPath;
+  anchor_offset: number;
+  focus_offset: number;
+};
+
+/**
+ * Node selection within a node array
+ */
+export type NodeSelection = {
+  type: "node";
+  path: DocumentPath;
+  anchor_offset: number;
+  focus_offset: number;
+};
+
+/**
+ * Property selection within a node
+ */
+export type PropertySelection = {
+  type: "property";
+  path: DocumentPath;
+};
+
+/**
+ * Union type for all possible selection types
+ */
+export type Selection = TextSelection | NodeSelection | PropertySelection;
+
+// ===== SCHEMA TYPE DEFINITIONS =====
+
+/**
+ * Basic scalar types supported by the schema system.
+ */
+export type ScalarType = "string" | "number" | "boolean" | "integer" | "datetime";
+
+/**
+ * Array types for collections of scalar values.
+ */
+export type ArrayType = "string_array" | "number_array" | "boolean_array" | "integer_array";
+
+/**
+ * Special types for rich content.
+ */
+export type RichType = "annotated_string";
+
+/**
+ * Node reference types for linking to other nodes.
+ */
+export type ReferenceType = "node" | "node_array";
+
+/**
+ * All primitive types that can be used in property definitions.
+ */
+export type PrimitiveType = ScalarType | ArrayType | RichType;
+
+/**
+ * All possible property types in schemas.
+ */
+export type PropertyType = PrimitiveType | ReferenceType;
+
+/**
+ * Document schema primitive types - all possible property types in document schemas.
+ */
+export type DocumentSchemaPrimitive = "string" | "number" | "boolean" | "integer" | "datetime" | "string_array" | "number_array" | "boolean_array" | "integer_array" | "annotated_string" | "node" | "node_array";
+
+/**
+ * Maps document schema types to their JavaScript runtime types.
+ */
+export type DocumentSchemaValueToJs<T> =
+  T extends "string" ? string :
+  T extends "number" ? number :
+  T extends "boolean" ? boolean :
+  T extends "integer" ? number :
+  T extends "datetime" ? string :
+  T extends "string_array" ? Array<string> :
+  T extends "number_array" ? Array<number> :
+  T extends "boolean_array" ? Array<boolean> :
+  T extends "integer_array" ? Array<number> :
+  T extends "annotated_string" ? [string, Array<any>] :
+  T extends "node" ? string :
+  T extends "node_array" ? Array<string> :
+  never;
+
+/**
+ * Converts a document node schema definition to its inferred JS type.
+ * Handles the {type: "..."} wrapper structure used in document schemas.
+ */
+export type DocumentNodeToJs<S extends Record<string, {type: DocumentSchemaPrimitive}>> =
+  { id: string, type: string } & { [K in keyof S]: DocumentSchemaValueToJs<S[K]["type"]> };
+
+/**
+ * A property that stores a primitive value.
+ */
+export type PrimitiveProperty = {
+  [K in PrimitiveType]: { type: K }
+}[PrimitiveType];
+
+/**
+ * A property that stores a reference to a single node.
+ */
+export type NodeProperty = {
+  type: "node";
+  node_types: string[];
+  default_node_type?: string;
+};
+
+/**
+ * A property that stores an array of node references.
+ */
+export type NodeArrayProperty = {
+  type: "node_array";
+  node_types: string[];
+  default_node_type?: string;
+};
+
+/**
+ * Union type for all possible property definitions.
+ */
+export type PropertyDefinition = PrimitiveProperty | NodeProperty | NodeArrayProperty;
+
+/**
+ * A node schema defines the structure of a specific node type.
+ * Maps property names to their definitions.
+ */
+export type NodeSchema = Record<string, PropertyDefinition>;
+
+/**
+ * A document schema defines all node types available in a document.
+ * Maps node type names to their schemas.
+ */
+export type DocumentSchema = Record<string, NodeSchema>;
+
+/**
+ * A serialized node in the document format.
+ * Must have id and type properties, with other properties defined by the schema.
+ */
+export type SerializedNode = {
+  id: string;
+  type: string;
+  [key: string]: any;
+};
+
+/**
+ * The document serialization format - an array of serialized nodes.
+ * Nodes must be ordered so that referenced nodes come before nodes that reference them.
+ */
+export type SerializedDocument = SerializedNode[];
+
+/**
+ * Props for the AnnotatedStringProperty component
+ */
+export type AnnotatedStringPropertyProps = {
+  /** The full path to the property */
+  path: DocumentPath;
+  /** The `class` attribute on the content element */
+  class?: string;
+  /** A placeholder to be rendered for empty content */
+  placeholder?: string;
+};
+
+/**
+ * Props for the CustomProperty component
+ */
+export type CustomPropertyProps = {
+  /** The full path to the property */
+  path: DocumentPath;
+  /** The `class` attribute on the content element */
+  class?: string;
+  /** The content of the custom property (e.g. an image) */
+  children: Snippet;
+};
+
+/**
+ * Props for the NodeArray component
+ */
+export type NodeArrayPropertyProps = {
+  /** The full path to the property */
+  path: DocumentPath;
+  /** The `class` attribute on the container element */
+  class?: string;
+};
+
+/**
+ * Props for the Node component
+ */
+export type NodeProps = {
+  /** The full path to the node */
+  path: DocumentPath;
+  /** The type-specific content of the node */
+  children: Snippet;
+};
+
+/**
+ * Props for the CustomProperty component
+ */
+export type CustomPropertyProps = {
+  /** The full path to the property */
+  path: DocumentPath;
+  /** The `class` attribute on the content element */
+  class?: string;
+  /** The content of the custom property (e.g. an image) */
+  children: Snippet;
+};
+
+/**
+ * Props for the CustomProperty component
+ */
+export type SveditProps = {
+  /** The full path to the property */
+  doc: Document,
+  /** Determines wether the document should be editable or read-only. */
+  editable?: boolean,
+  /** The path to the root element (e.g. ['page_1']) */
+  path: DocumentPath,
+  /** The `class` attribute on the content element */
+  class?: string;
+};
+
+/**
+ * Represents an annotation in an annotated string
+ * Format: [start_offset, end_offset, type, options?]
+ */
+export type Annotation = [number, number, string, Record<string, any>?];
+
+/**
+ * Represents a fragment of annotated text content
+ */
+export type AnnotationFragment = {
+  /** The annotation type (e.g., 'link', 'emphasis', 'strong') */
+  type: string;
+  /** The text content of the annotation */
+  content: string;
+  /** Index of the annotation in the original array */
+  annotation_index: number;
+  /** Optional properties from the annotation's options object */
+  data?: any;
+};

package/src/lib/util.js

@@ -0,0 +1,78 @@
+// split_annotated_string(["Hello world", [[6,11, "strong"]]], 8)
+// =>
+// [
+//   ["Hello wo", [[6,8, "strong"]]]
+//   ["rld", [[0,3, "strong"]]]
+// ]
+export function split_annotated_string(text_with_annotations, at_position) {
+  const [text, annotations] = text_with_annotations;
+
+  // Split the text
+  const left_text = text.slice(0, at_position);
+  const right_text = text.slice(at_position);
+
+  const left_annotations = [];
+  const right_annotations = [];
+
+  // Process each annotation
+  for (const [start, end, type, data] of annotations) {
+    if (end <= at_position) {
+      // Annotation is entirely in the left part
+      left_annotations.push([start, end, type, data]);
+    } else if (start >= at_position) {
+      // Annotation is entirely in the right part - shift offsets
+      right_annotations.push([start - at_position, end - at_position, type, data]);
+    } else {
+      // Annotation spans the split point - split it
+      left_annotations.push([start, at_position, type, data]);
+      right_annotations.push([0, end - at_position, type, data]);
+    }
+  }
+
+  return [
+    [left_text, left_annotations],
+    [right_text, right_annotations]
+  ];
+}
+
+
+// join_annotated_string(["Hello wo", [[6,8, "strong"]]], ["rld", [[0,3, "strong"]]])
+// => ["Hello world", [[6,11, "strong"]]]
+export function join_annotated_string(first_text, second_text) {
+  const [first_text_content, first_annotations] = first_text;
+  const [second_text_content, 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)
+  const joined_annotations = [...first_annotations];
+
+  // Add annotations from the second text, shifting their offsets
+  const offset = first_text_content.length;
+  for (const [start, end, type, data] of second_annotations) {
+    const shifted_annotation = [start + offset, end + offset, type, data];
+
+    // 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[1] === shifted_annotation[0] && // annotations are adjacent
+        last_annotation[2] === shifted_annotation[2] && // same type
+        JSON.stringify(last_annotation[3]) === JSON.stringify(shifted_annotation[3])) { // same data
+      // Merge by extending the end position of the last annotation
+      last_annotation[1] = shifted_annotation[1];
+    } else {
+      // Add as separate annotation
+      joined_annotations.push(shifted_annotation);
+    }
+  }
+
+  return [joined_text, joined_annotations];
+}
+
+export function snake_to_pascal(str) {
+  return str
+    .split('_')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join('');
+}