svedit 0.4.0 → 0.6.0

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

@@ -1 +1 @@
-{"version":3,"file":"Svedit.svelte.d.ts","sourceRoot":"","sources":["../src/lib/Svedit.svelte.js"],"names":[],"mappings":";;;;;;;AAo6CA;;eAAqD;iCAx5CgE,cAAc"}
+{"version":3,"file":"Svedit.svelte.d.ts","sourceRoot":"","sources":["../src/lib/Svedit.svelte.js"],"names":[],"mappings":";;;;;;;AAszCA;;eAAqD;iCA9xC1C,cAAc"}

package/dist/Transaction.svelte.d.ts

@@ -7,38 +7,106 @@
  *
  * @example
  * ```js
- * const tr = doc.tr;
+ * const tr = session.tr;
  * tr.set(['node_1', 'title'], 'New Title');
  * tr.create({id: 'node_2', type: 'paragraph', content: 'Hello'});
- * doc.apply(tr); // Applies all operations atomically
+ * session.apply(tr); // Applies all operations atomically
  * ```
  */
 export default class Transaction {
     /**
-     * Creates a new Transaction for the given document.
+     * Creates a new Transaction with the given state.
      *
-     * @param {any} doc - The document instance this transaction operates on
+     * @param {DocumentSchema} schema - The document schema
+     * @param {Document} doc - The document state {document_id, nodes}
+     * @param {Selection | null} selection - The current selection
+     * @param {object} config - The document config (including generate_id)
      */
-    constructor(doc: any);
-    doc: any;
+    constructor(schema: DocumentSchema, doc: Document, selection: Selection | null, config: object);
+    schema: DocumentSchema;
+    /** @type {object} */
+    doc: object;
+    /** @type {Selection} */
+    selection: Selection;
+    config: any;
     /** @type {Record<string, any>[]} */
     ops: Record<string, any>[];
     /** @type {Record<string, any>[]} */
     inverse_ops: Record<string, any>[];
-    selection_before: any;
+    selection_before: Selection;
     /**
      * Gets a value from the document at the specified path.
      *
-     * @param {DocumentPath} path - The path to the value in the document
+     * @param {DocumentPath|string} path - The path to the value in the document, or a string node ID
      * @returns {any} The value at the specified path
      */
-    get(path: DocumentPath): any;
+    get(path: DocumentPath | string): any;
     /**
-     * Gets the current selection state of the document.
+     * Gets the type of a property from the schema.
      *
-     * @returns {Selection} The current selection object
+     * @param {string} type - The node type
+     * @param {string} property - The property name
+     * @returns {string} The property type
      */
-    get selection(): Selection;
+    property_type(type: string, property: string): string;
+    /**
+     * Determines the kind of a node ('block', 'text', or 'annotation').
+     *
+     * @param {any} node - The node to check
+     * @returns {'block'|'text'|'annotation'} The node kind
+     */
+    kind(node: any): "block" | "text" | "annotation";
+    /**
+     * Inspects a path to get metadata about the value at that location.
+     *
+     * @param {DocumentPath} path - The path to inspect
+     * @returns {{kind: 'property'|'node', [key: string]: any}} Metadata about the path
+     */
+    inspect(path: DocumentPath): {
+        kind: "property" | "node";
+        [key: string]: any;
+    };
+    /**
+     * Generates a new unique ID using the config's generate_id function.
+     *
+     * @returns {string} A new unique ID
+     */
+    generate_id(): string;
+    /**
+     * Validates a node against the document schema.
+     *
+     * @param {any} node - The node to validate
+     * @throws {Error} Throws if the node is invalid
+     */
+    validate_node(node: any): void;
+    /**
+     * Gets all nodes referenced by a given node (recursively).
+     *
+     * @param {NodeId} node_id - The node ID to get references for
+     * @returns {NodeId[]} Array of referenced node IDs
+     */
+    get_referenced_nodes(node_id: NodeId): NodeId[];
+    /**
+     * Gets the available annotation types for the current selection.
+     *
+     * @returns {string[]} Array of available annotation type names
+     */
+    get available_annotation_types(): string[];
+    /**
+     * Returns the annotation object that is currently "under the cursor".
+     * NOTE: Annotations in Svedit are exclusive, so there can only be one active_annotation
+     *
+     * @param {string} [annotation_type] Optional annotation type to filter by
+     * @returns {Annotation|null}
+     */
+    active_annotation(annotation_type?: string): Annotation | null;
+    /**
+     * Applies an operation to the document (internal).
+     *
+     * @param {Array} op - The operation to apply
+     * @private
+     */
+    private _apply_op;
     /**
      * Sets a property of a node to a new value.
      *
@@ -47,6 +115,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
@@ -54,7 +123,8 @@ export default class Transaction {
      * tr.set(["page_1", "body", "0", "description"], {text: "Hello world", annotations: []});
      * ```
      */
-    set(path: DocumentPath, value: any): void;
+    set(path: DocumentPath, value: any): Transaction;
+    build(node_id: any, nodes: any): any;
     /**
      * Creates a new node in the document.
      *
@@ -97,6 +167,14 @@ export default class Transaction {
      * @throws {Error} Throws if the selection is invalid or out of bounds
      */
     set_selection(selection: Selection): Transaction;
+    /**
+     * Validates a selection against the current document state.
+     *
+     * @param {Selection} selection - The selection to validate
+     * @throws {Error} Throws if the selection is invalid
+     * @private
+     */
+    private _validate_selection;
     /**
      * Adds, updates, or removes text annotations in the current selection.
      *
@@ -124,63 +202,53 @@ 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)
+     * - Property selections are ignored: Those are best handled handled via commands + keyboard shortcuts.
      *
+     * @param {'backward' | 'forward'} [direction] - Direction of deletion for collapsed selections
      * @returns {Transaction} This transaction instance for method chaining
      */
-    delete_selection(): Transaction;
+    delete_selection(direction?: "backward" | "forward"): Transaction;
     /**
-     * Inserts an array of nodes at the current node selection.
+     * Inserts nodes at the current node selection position.
      *
-     * 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 the selection is expanded (not collapsed), first deletes the selected nodes
+     * before inserting the new ones.
      *
-     * @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', []]}
-     * ]);
-     * ```
      */
-    insert_nodes(nodes: SerializedNode[]): Transaction;
+    insert_nodes(node_ids: NodeId[]): Transaction;
     /**
-     * Inserts text at the current text selection, replacing any selected content.
+     * Inserts text at the current text selection position.
      *
-     * Updates both the text content and adjusts annotation offsets to maintain
-     * annotation integrity after the text insertion.
+     * Handles annotation adjustments when text is inserted, including:
+     * - Expanding annotations that contain the insertion point
+     * - Shifting annotations that come after the insertion point
+     * - Optionally applying new annotations to the inserted text
      *
      * @param {string} replaced_text - The text to insert
+     * @param {Array} [annotations] - Optional annotations to apply to the inserted text
+     * @param {object} [nodes] - Optional node definitions for annotation nodes
      * @returns {Transaction} This transaction instance for method chaining
-     *
-     * @todo Support annotations attached to replaced_text for full copy&paste support
-     *
-     * @example
-     * ```js
-     * tr.insert_text('Hello, world!');
-     * ```
      */
-    insert_text(replaced_text: string): Transaction;
+    insert_text(replaced_text: string, annotations?: any[], nodes?: object): Transaction;
     /**
-     * Recursively deletes nodes that become unreferenced after the initial deletion.
+     * Recursively deletes nodes that are no longer referenced in the document.
      *
-     * This method implements cascade deletion by checking reference counts and
-     * removing nodes that are no longer referenced by any other nodes in the document.
+     * This handles the cascade deletion of child nodes when their parent
+     * references are removed. Uses reference counting to determine which
+     * nodes are safe to delete.
      *
-     * @param {NodeId[]} removed_node_ids - Array of node IDs that were initially removed
+     * @param {NodeId[]} potentially_orphaned_nodes - Array of node IDs to check
      * @private
      */
     private _cascade_delete_unreferenced_nodes;
     /**
-     * Counts references to a target node, excluding nodes that are marked for deletion.
+     * Counts references to a node, excluding nodes that have been marked for deletion.
      *
-     * This is used during cascade deletion to determine if a node can be safely
-     * deleted without breaking document integrity.
+     * This is used during cascade deletion to accurately count remaining references
+     * as nodes are being deleted.
      *
      * @param {NodeId} target_node_id - The node ID to count references for
      * @param {Record<NodeId, boolean>} nodes_to_delete - Nodes already marked for deletion
@@ -189,7 +257,10 @@ export default class Transaction {
      */
     private _count_references_excluding_deleted;
 }
-import type { DocumentPath } from './types.js';
-import type { Selection } from './types.js';
-import type { SerializedNode } from './types.js';
+import type { DocumentSchema } from './types.d.js';
+import type { Selection } from './types.d.js';
+import type { DocumentPath } from './types.d.js';
+import type { NodeId } from './types.d.js';
+import type { Annotation } from './types.d.js';
+import type { Document } from './types.d.js';
 //# sourceMappingURL=Transaction.svelte.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Transaction.svelte.d.ts","sourceRoot":"","sources":["../src/lib/Transaction.svelte.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH;IACE;;;;OAIG;IACH,iBAFW,GAAG,EAWb;IARC,SAAc;IAEd,oCAAoC;IACpC,KADW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CACnB;IACb,oCAAoC;IACpC,aADW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CACX;IAErB,sBAA0C;IAG5C;;;;;OAKG;IACH,UAHW,YAAY,GACV,GAAG,CAIf;IAED;;;;OAIG;IACH,iBAFa,SAAS,CAIrB;IAED;;;;;;;;;;;;;;OAcG;IACH,UATW,YAAY,SACZ,GAAG,QA2Bb;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,aAbW,GAAG,GACD,WAAW,CAyBvB;IAED;;;;;;;;;;;;OAYG;IACH,WARW,GAAG,GACD,WAAW,CAcvB;IAED;;;;;;OAMG;IACH,yBAJW,SAAS,GACP,WAAW,CAOvB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,+BAbW,GAAG,yBACH,GAAG,GACD,WAAW,CAuDvB;IAED;;;;;;;;;OASG;IACH,oBAFa,WAAW,CAyGvB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,oBAbW,cAAc,EAAE,GACd,WAAW,CAqDvB;IAED;;;;;;;;;;;;;;;OAeG;IACH,2BAVW,MAAM,GACJ,WAAW,CA8EvB;IAED;;;;;;;;OAQG;IACH,2CA+BC;IAED;;;;;;;;;;OAUG;IACH,4CAuBC;CACF;kCAxjBmE,YAAY;+BAAZ,YAAY;oCAAZ,YAAY"}
+{"version":3,"file":"Transaction.svelte.d.ts","sourceRoot":"","sources":["../src/lib/Transaction.svelte.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;;;;OAOG;IACH,oBALW,cAAc,OACd,QAAQ,aACR,SAAS,GAAG,IAAI,UAChB,MAAM,EAgBhB;IAbA,uBAAoB;IACpB,qBAAqB;IACrB,KADW,MAAM,CACH;IACd,wBAAwB;IACxB,WADW,SAAS,CACM;IAC1B,YAAoB;IAEpB,oCAAoC;IACpC,KADW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CACnB;IACb,oCAAoC;IACpC,aADW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CACX;IAErB,4BAAiC;IAGlC;;;;;OAKG;IACH,UAHW,YAAY,GAAC,MAAM,GACjB,GAAG,CAIf;IAED;;;;;;OAMG;IACH,oBAJW,MAAM,YACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,WAHW,GAAG,GACD,OAAO,GAAC,MAAM,GAAC,YAAY,CAIvC;IAED;;;;;OAKG;IACH,cAHW,YAAY,GACV;QAAC,IAAI,EAAE,UAAU,GAAC,MAAM,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,CAIzD;IAED;;;;OAIG;IACH,eAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,oBAHW,GAAG,QAKb;IAED;;;;;OAKG;IACH,8BAHW,MAAM,GACJ,MAAM,EAAE,CAKpB;IAED;;;;OAIG;IACH,kCAFa,MAAM,EAAE,CAOpB;IAED;;;;;;OAMG;IACH,oCAHW,MAAM,GACJ,UAAU,GAAC,IAAI,CAI3B;IAED;;;;;OAKG;IACH,kBAEC;IAED;;;;;;;;;;;;;;;OAeG;IACH,UAVW,YAAY,SACZ,GAAG,GACD,WAAW,CAmDvB;IAKD,qCAsDC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,aAbW,GAAG,GACD,WAAW,CAyBvB;IAED;;;;;;;;;;;;OAYG;IACH,WARW,GAAG,GACD,WAAW,CAuBvB;IAED;;;;;;OAMG;IACH,yBAJW,SAAS,GACP,WAAW,CAOvB;IAED;;;;;;OAMG;IACH,4BA6CC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,+BAbW,GAAG,yBACH,GAAG,GACD,WAAW,CA+DvB;IAED;;;;;;;;;;;OAWG;IACH,6BAHW,UAAU,GAAG,SAAS,GACpB,WAAW,CA0IvB;IAED;;;;;;;;OAQG;IACH,uBAHW,MAAM,EAAE,GACN,WAAW,CAkCvB;IAED;;;;;;;;;;;;OAYG;IACH,2BALW,MAAM,+BAEN,MAAM,GACJ,WAAW,CAqGvB;IAED;;;;;;;;;OASG;IACH,2CAgCC;IAED;;;;;;;;;;OAUG;IACH,4CAOC;CACD;oCA91ByF,cAAc;+BAAd,cAAc;kCAAd,cAAc;4BAAd,cAAc;gCAAd,cAAc;8BAAd,cAAc"}