svedit 0.1.0

package/dist/Svedit.svelte.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"Svedit.svelte.d.ts","sourceRoot":"","sources":["../src/lib/Svedit.svelte.js"],"names":[],"mappings":";;;;;;;AA64BA;;OAAqD;iCAj4BgE,cAAc"}

package/dist/Transaction.svelte.d.ts

@@ -0,0 +1,198 @@
+/**
+ * @import { NodeId, SerializedNode, Selection, DocumentPath } from './types.js'
+ */
+/**
+ * Transaction class for managing atomic document operations with undo/redo support.
+ *
+ * A Transaction provides a way to group multiple document operations (create, delete, set)
+ * into a single atomic unit that can be applied or rolled back as one. It maintains
+ * both forward operations and their inverse operations for undo functionality.
+ *
+ * @example
+ * ```js
+ * const tr = doc.tr;
+ * tr.set(['node_1', 'title'], 'New Title');
+ * tr.create({id: 'node_2', type: 'paragraph', content: 'Hello'});
+ * doc.apply(tr); // Applies all operations atomically
+ * ```
+ */
+export default class Transaction {
+    /**
+     * Creates a new Transaction for the given document.
+     *
+     * @param {any} doc - The document instance this transaction operates on
+     */
+    constructor(doc: any);
+    doc: any;
+    /** @type {Record<string, any>[]} */
+    ops: Record<string, any>[];
+    /** @type {Record<string, any>[]} */
+    inverse_ops: Record<string, any>[];
+    selection_before: any;
+    /**
+     * Gets a value from the document at the specified path.
+     *
+     * @param {DocumentPath} path - The path to the value in the document
+     * @returns {any} The value at the specified path
+     */
+    get(path: DocumentPath): any;
+    /**
+     * Gets the current selection state of the document.
+     *
+     * @returns {Selection} The current selection object
+     */
+    get selection(): Selection;
+    /**
+     * Sets a property of a node to a new value.
+     *
+     * This is the core operation for modifying document properties. It records
+     * both the forward operation and its inverse for undo support.
+     *
+     * @param {DocumentPath} path - Array path to the property (e.g., ["node_1", "title"])
+     * @param {any} value - The new value to set
+     *
+     * @example
+     * ```js
+     * tr.set(["list_1", "list_items"], [1, 2, 3]);
+     * tr.set(["page_1", "body", "0", "description"], ["Hello world", []]);
+     * ```
+     */
+    set(path: DocumentPath, value: any): void;
+    /**
+     * Creates a new node in the document.
+     *
+     * The node must have a valid id and must not already exist in the document.
+     * The node is validated against the document schema before creation.
+     *
+     * @param {any} node - The node object to create (must include id, type, and other properties)
+     * @returns {Transaction} This transaction instance for method chaining
+     * @throws {Error} If the node ID is invalid or if the node already exists
+     *
+     * @example
+     * ```js
+     * tr.create({
+     *   id: 'para_123',
+     *   type: 'paragraph',
+     *   content: ['Hello world', []]
+     * });
+     * ```
+     */
+    create(node: any): Transaction;
+    /**
+     * Deletes a node from the document by its ID.
+     *
+     * The node's current state is captured for undo support before deletion.
+     *
+     * @param {any} id - The ID of the node to delete
+     * @returns {Transaction} This transaction instance for method chaining
+     *
+     * @example
+     * ```js
+     * tr.delete('node_123');
+     * ```
+     */
+    delete(id: any): Transaction;
+    /**
+     * Sets the document selection.
+     *
+     * @param {Selection} selection - The new selection object
+     * @returns {Transaction} This transaction instance for method chaining
+     * @todo Check if selection is valid and throw error if not
+     */
+    set_selection(selection: Selection): Transaction;
+    /**
+     * Adds, updates, or removes text annotations in the current selection.
+     *
+     * Handles various annotation scenarios including adding new annotations,
+     * updating existing ones (especially for links), and removing annotations
+     * when conflicting types are applied.
+     *
+     * @param {any} annotation_type - The type of annotation (e.g., 'link', 'bold', 'italic')
+     * @param {any} annotation_data - Additional data for the annotation (e.g., href for links)
+     * @returns {Transaction} This transaction instance for method chaining
+     *
+     * @example
+     * ```js
+     * // Add a link annotation
+     * tr.annotate_text('link', { href: 'https://example.com' });
+     *
+     * // Add emphasis
+     * tr.annotate_text('emphasis', {});
+     * ```
+     */
+    annotate_text(annotation_type: any, annotation_data: any): Transaction;
+    /**
+     * Deletes the currently selected text or nodes.
+     *
+     * 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
+     *
+     * @returns {Transaction} This transaction instance for method chaining
+     */
+    delete_selection(): 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).
+     *
+     * @param {SerializedNode[]} nodes - Array of node objects 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;
+    /**
+     * Inserts text at the current text selection, replacing any selected content.
+     *
+     * Updates both the text content and adjusts annotation offsets to maintain
+     * annotation integrity after the text insertion.
+     *
+     * @param {string} replaced_text - The text to insert
+     * @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;
+    /**
+     * Recursively deletes nodes that become unreferenced after the initial deletion.
+     *
+     * This method implements cascade deletion by checking reference counts and
+     * removing nodes that are no longer referenced by any other nodes in the document.
+     *
+     * @param {NodeId[]} removed_node_ids - Array of node IDs that were initially removed
+     * @private
+     */
+    private _cascade_delete_unreferenced_nodes;
+    /**
+     * Counts references to a target node, excluding nodes that are marked for deletion.
+     *
+     * This is used during cascade deletion to determine if a node can be safely
+     * deleted without breaking document integrity.
+     *
+     * @param {NodeId} target_node_id - The node ID to count references for
+     * @param {Record<NodeId, boolean>} nodes_to_delete - Nodes already marked for deletion
+     * @returns {number} The number of references to the target node
+     * @private
+     */
+    private _count_references_excluding_deleted;
+}
+import type { DocumentPath } from './types.js';
+import type { Selection } from './types.js';
+import type { SerializedNode } from './types.js';
+//# sourceMappingURL=Transaction.svelte.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Transaction.svelte.d.ts","sourceRoot":"","sources":["../src/lib/Transaction.svelte.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;;;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,mBACH,GAAG,GACD,WAAW,CAqFvB;IAED;;;;;;;;;OASG;IACH,oBAFa,WAAW,CA8FvB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,oBAbW,cAAc,EAAE,GACd,WAAW,CAqDvB;IAED;;;;;;;;;;;;;;;OAeG;IACH,2BAVW,MAAM,GACJ,WAAW,CAsEvB;IAED;;;;;;;;OAQG;IACH,2CA+BC;IAED;;;;;;;;;;OAUG;IACH,4CAqBC;CACF;kCA/jBmE,YAAY;+BAAZ,YAAY;oCAAZ,YAAY"}