svedit 0.3.0 → 0.4.0

package/src/lib/commands.svelte.js

@@ -1,4 +1,4 @@
-import { split_annotated_string, join_annotated_string, get_char_length } from './util.js';
+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) {
@@ -30,7 +30,7 @@ export function break_text_node(tr) {
 
   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);
+  const [left_text, right_text] = split_annotated_text(content, split_at_position);
 
   tr.set([node.id, 'content'], left_text);
 
@@ -42,7 +42,7 @@ export function break_text_node(tr) {
   };
 
   // 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 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) {
@@ -82,7 +82,7 @@ export function join_text_node(tr) {
   }
 
   // Special behavior: if we can't join and current node is empty, delete it
-  if (!can_join && node.content[0] === '') {
+  if (!can_join && node.content.text === '') {
     tr.set_selection({
       type: 'node',
       path: doc.selection.path.slice(0, -2),
@@ -100,8 +100,15 @@ export function join_text_node(tr) {
 
   // 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);
+  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),
@@ -110,13 +117,14 @@ 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',
     path: [...previous_text_path, 'content'],
-    anchor_offset: get_char_length(predecessor_node.content[0]),
-    focus_offset: get_char_length(predecessor_node.content[0]),
+    anchor_offset: cursor_position,
+    focus_offset: cursor_position,
   });
-  tr.set([predecessor_node.id, 'content'], joined_text);
   return true;
 }
 
@@ -134,7 +142,7 @@ export function insert_default_node(tr) {
   const property_name = path.at(-1);
 
   // Get the definition for this property
-  const property_definition = doc.schema[node_array_node.type][property_name];
+  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
@@ -161,7 +169,7 @@ export function select_all(tr) {
 
   if (selection.type === 'text') {
     const text_content = doc.get(selection.path);
-    const text_length = get_char_length(text_content[0]);
+    const text_length = get_char_length(text_content.text);
 
     // Check if all text is already selected
     const is_all_text_selected =

package/src/lib/index.js

@@ -1,6 +1,6 @@
 // Main exports for the svedit library
 export { default as Svedit } from './Svedit.svelte';
-export { default as AnnotatedStringProperty } from './AnnotatedStringProperty.svelte';
+export { default as AnnotatedTextProperty } from './AnnotatedTextProperty.svelte';
 export { default as CustomProperty } from './CustomProperty.svelte';
 export { default as Node } from './Node.svelte';
 export { default as NodeArrayProperty } from './NodeArrayProperty.svelte';

package/src/lib/types.d.ts

@@ -68,7 +68,7 @@ export type ArrayType = "string_array" | "number_array" | "boolean_array" | "int
 /**
  * Special types for rich content.
  */
-export type RichType = "annotated_string";
+export type RichType = "annotated_text";
 
 /**
  * Node reference types for linking to other nodes.
@@ -88,7 +88,7 @@ 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";
+export type DocumentSchemaPrimitive = "string" | "number" | "boolean" | "integer" | "datetime" | "string_array" | "number_array" | "boolean_array" | "integer_array" | "annotated_text" | "node" | "node_array";
 
 /**
  * Maps document schema types to their JavaScript runtime types.
@@ -103,7 +103,7 @@ export type DocumentSchemaValueToJs<T> =
   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 "annotated_text" ? AnnotatedText :
   T extends "node" ? string :
   T extends "node_array" ? Array<string> :
   never;
@@ -112,15 +112,24 @@ export type DocumentSchemaValueToJs<T> =
  * 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"]> };
+export type DocumentNodeToJs<S extends NodeSchema> =
+  { id: string, type: string } & { [K in keyof S["properties"]]: DocumentSchemaValueToJs<S["properties"][K]["type"]> };
 
 /**
- * A property that stores a primitive value.
+ * A property that stores an annotated text with required allow_newlines setting.
+ */
+export type AnnotatedTextProperty = {
+  type: 'annotated_text';
+  node_types?: string[];
+  allow_newlines: boolean;
+};
+
+/**
+ * A property that stores a primitive value (excluding annotated_text).
  */
 export type PrimitiveProperty = {
-  [K in PrimitiveType]: { type: K }
-}[PrimitiveType];
+  [K in Exclude<PrimitiveType, 'annotated_text'>]: { type: K }
+}[Exclude<PrimitiveType, 'annotated_text'>];
 
 /**
  * A property that stores a reference to a single node.
@@ -143,13 +152,36 @@ export type NodeArrayProperty = {
 /**
  * Union type for all possible property definitions.
  */
-export type PropertyDefinition = PrimitiveProperty | NodeProperty | NodeArrayProperty;
+export type PropertyDefinition = PrimitiveProperty | AnnotatedTextProperty | NodeProperty | NodeArrayProperty;
+
+/**
+ * Node kind values for different types of content nodes
+ */
+export type NodeKind = 'document' | 'block' | 'text' | 'annotation';
+
+/**
+ * Schema for text nodes - must have a content property of type annotated_text
+ */
+export type TextNodeSchema = {
+  kind: 'text';
+  properties: {
+    content: AnnotatedTextProperty;
+  } & Record<string, PropertyDefinition>;
+};
+
+/**
+ * Schema for non-text nodes
+ */
+export type NonTextNodeSchema = {
+  kind: 'document' | 'block' | 'annotation';
+  properties: Record<string, PropertyDefinition>;
+};
 
 /**
  * A node schema defines the structure of a specific node type.
- * Maps property names to their definitions.
+ * Contains a kind and properties object that maps property names to their definitions.
  */
-export type NodeSchema = Record<string, PropertyDefinition>;
+export type NodeSchema = TextNodeSchema | NonTextNodeSchema;
 
 /**
  * A document schema defines all node types available in a document.
@@ -174,9 +206,9 @@ export type SerializedNode = {
 export type SerializedDocument = SerializedNode[];
 
 /**
- * Props for the AnnotatedStringProperty component
+ * Props for the AnnotatedTextProperty component
  */
-export type AnnotatedStringPropertyProps = {
+export type AnnotatedTextPropertyProps = {
   /** The full path to the property */
   path: DocumentPath;
   /** The `class` attribute on the content element */
@@ -239,26 +271,39 @@ export type SveditProps = {
   editable?: boolean,
   /** The path to the root element (e.g. ['page_1']) */
   path: DocumentPath,
-  /** The `class` attribute on the content element */
+  /** The `class` attribute on the canvas element */
   class?: string;
+  /** The `autocapitalize` attribute on the canvas element */
+  autocapitalize?: 'on' | 'off';
+  /** The `spellcheck` attribute on the canvas element */
+  spellcheck?: 'true' | 'false';
 };
 
 /**
  * Represents an annotation in an annotated string
- * Format: [start_offset, end_offset, type, options?]
  */
-export type Annotation = [number, number, string, Record<string, any>?];
+export type Annotation = {
+  start_offset: number;
+  end_offset: number;
+  node_id: NodeId;
+};
+
+/**
+ * Represents an annotated text with text and annotations
+ */
+export type AnnotatedText = {
+  text: string;
+  annotations: Array<Annotation>;
+};
 
 /**
  * Represents a fragment of annotated text content
  */
-export type AnnotationFragment = {
-  /** The annotation type (e.g., 'link', 'emphasis', 'strong') */
-  type: string;
+export type AnnotationFragment = string | {
+  /** NodeId that has annotation type and details */
+  node: any;
   /** 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

@@ -1,5 +1,5 @@
 /**
- * @import { Annotation } from './types.d.ts';
+ * @import { Annotation, AnnotatedText } from './types.d.ts';
  */
 
 /**
@@ -120,25 +120,25 @@ export function char_to_utf16_offset(str, char_offset) {
 }
 
 /**
- * Splits an annotated string at the specified character position.
+ * 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 {[string, Array<Annotation>]} text_with_annotations - Tuple of [text, annotations] where annotations follow the Annotation type: [start, end, type, data?]
+ * @param {AnnotatedText} text_with_annotations - Annotated text object
  * @param {number} at_position - Character position where to split (0-based)
- * @returns {[[string, Array<Annotation>], [string, Array<Annotation>]]} Tuple of [left_part, right_part] where each part is [text, annotations]
+ * @returns {[AnnotatedText, AnnotatedText]} Tuple of [left_part, right_part]
  *
  * @example
- * split_annotated_string(["Hello world", [[6,11, "strong"]]], 8)
+ * split_annotated_text({text: "Hello world", annotations: [{start_offset: 6, end_offset: 11, node_id: "strong"}]}, 8)
  * // Returns:
  * // [
- * //   ["Hello wo", [[6,8, "strong"]]]
- * //   ["rld", [[0,3, "strong"]]]
+ * //   {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_string(text_with_annotations, at_position) {
-  const [text, annotations] = text_with_annotations;
+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);
@@ -150,44 +150,44 @@ export function split_annotated_string(text_with_annotations, at_position) {
   const right_annotations = [];
 
   // Process each annotation
-  for (const [start, end, type, data] of annotations) {
-    if (end <= at_position) {
+  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, end, type, data]);
-    } else if (start >= at_position) {
+      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 - at_position, end - at_position, type, data]);
+      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, at_position, type, data]);
-      right_annotations.push([0, end - at_position, type, data]);
+      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 [
-    [left_text, left_annotations],
-    [right_text, right_annotations]
+    {text: left_text, annotations: left_annotations},
+    {text: right_text, annotations: right_annotations}
   ];
 }
 
 
 /**
- * Joins two annotated strings into a single annotated string.
+ * 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 {[string, Array<Annotation>]} first_text - First annotated string tuple where annotations follow the Annotation type: [start, end, type, data?]
- * @param {[string, Array<Annotation>]} second_text - Second annotated string tuple where annotations follow the Annotation type: [start, end, type, data?]
- * @returns {[string, Array<Annotation>]} Combined annotated string tuple [text, annotations]
+ * @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_string(["Hello wo", [[6,8, "strong"]]], ["rld", [[0,3, "strong"]]])
- * // Returns: ["Hello world", [[6,11, "strong"]]]
+ * 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_string(first_text, second_text) {
-  const [first_text_content, first_annotations] = first_text;
-  const [second_text_content, second_annotations] = second_text;
+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;
@@ -198,25 +198,24 @@ export function join_annotated_string(first_text, second_text) {
 
   // Add annotations from the second text, shifting their offsets
   const offset = get_char_length(first_text_content);
-  for (const [start, end, type, data] of second_annotations) {
+  for (const {start_offset, end_offset, node_id} of second_annotations) {
     /** @type {Annotation} */
-    const shifted_annotation = [start + offset, end + offset, type, data];
+    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[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
+        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[1] = shifted_annotation[1];
+      last_annotation.end_offset = shifted_annotation.end_offset;
     } else {
       // Add as separate annotation
       joined_annotations.push(shifted_annotation);
     }
   }
 
-  return [joined_text, joined_annotations];
+  return {text: joined_text, annotations: joined_annotations};
 }
 
 /**

package/dist/AnnotatedStringProperty.svelte.d.ts

@@ -1,7 +0,0 @@
-export default AnnotatedStringProperty;
-type AnnotatedStringProperty = {
-    $on?(type: string, callback: (e: any) => void): () => void;
-    $set?(props: Partial<AnnotatedStringPropertyProps>): void;
-};
-declare const AnnotatedStringProperty: import("svelte").Component<import("./types.d.ts").AnnotatedStringPropertyProps, {}, "">;
-//# sourceMappingURL=AnnotatedStringProperty.svelte.d.ts.map

package/dist/AnnotatedStringProperty.svelte.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AnnotatedStringProperty.svelte.d.ts","sourceRoot":"","sources":["../src/lib/AnnotatedStringProperty.svelte.js"],"names":[],"mappings":";;;;;AAwFA,+HAAsE"}