svedit 0.5.0 → 0.6.0

package/dist/{Document.svelte.d.ts → Session.svelte.d.ts}

@@ -1,66 +1,32 @@
 /**
- * @import {
- *   NodeId,
- *   DocumentPath,
- *   Selection,
- *   Annotation,
- *   PrimitiveType,
- *   NodeProperty,
- *   NodeArrayProperty,
- *   NodeKind,
- *   NodeSchema,
- *   DocumentSchema,
- *   SerializedDocument
- * } from './types.d.ts';
+ * @typedef {Object} SessionOptions
+ * @property {Selection} [selection] - Initial selection state
  */
-/**
- * Identity function — keeps schema at runtime & makes IDE infer types.
- * Similar to your define_schema pattern but for document schemas.
- *
- * @template {Record<string, NodeSchema>} S
- * @param {S} schema - The document schema to validate
- * @returns {S} The same schema, but with type information preserved
- */
-export function define_document_schema<S extends Record<string, NodeSchema>>(schema: S): S;
-/**
- * Check if a string represents a valid primitive type.
- * @param {string} type - The type string to check
- * @returns {type is PrimitiveType} True if it's a valid primitive type
- */
-export function is_primitive_type(type: string): type is PrimitiveType;
-/**
- * Get the default node type for a property that references nodes.
- * @param {NodeProperty | NodeArrayProperty} property_definition - The property definition
- * @returns {string | null} The default node type, or null if none specified
- */
-export function get_default_node_type(property_definition: NodeProperty | NodeArrayProperty): string | null;
-/**
- * Validate a document schema to ensure all referenced node types exist.
- * @param {DocumentSchema} document_schema - The document schema to validate
- * @throws {Error} Throws if the document schema is invalid
- */
-export function validate_document_schema(document_schema: DocumentSchema): void;
-export default class Document {
+export default class Session {
     /**
      * @param {DocumentSchema} schema - The document schema
-     * @param {SerializedDocument} serialized_doc - The serialized document array
-     * @param {object} [options] - Optional configuration
+     * @param {Document} doc - The document
+     * @param {object} config - configuration object
+     * @param {Object} [options]
      * @param {Selection} [options.selection] - Initial selection state
-     * @param {any} [options.config] - Document configuration
      */
-    constructor(schema: DocumentSchema, serialized_doc: SerializedDocument, { selection, config }?: {
+    constructor(schema: DocumentSchema, doc: Document, config: object, options?: {
         selection?: Selection;
-        config?: any;
     });
+    /** @type {DocumentSchema} */
+    schema: DocumentSchema;
+    /** @type {Document} */
+    doc: Document;
+    /** @type {any} */
     config: any;
-    document_id: any;
-    nodes: any;
     history: any[];
     history_index: number;
+    last_batch_started: any;
+    commands: {};
+    keymap: {};
     can_undo: boolean;
     can_redo: boolean;
     selected_node: any;
-    layout_node: any;
     available_annotation_types: any;
     /**
      * Sets the selection with validation
@@ -81,18 +47,26 @@ export default class Document {
      * @private
      */
     private _validate_selection;
-    schema: DocumentSchema;
+    /**
+     * Gets the document_id from the doc
+     * @returns {string}
+     */
+    get document_id(): string;
+    validate_doc(): void;
     generate_id(): any;
-    get_available_annotation_types(): any;
-    get_selected_node(): any;
-    get_layout_node(): any;
-    _apply_op(op: any): void;
     /**
-     * Validate a node against the document schema.
-     * @param {any} node - The node to validate
-     * @throws {Error} Throws if the node is invalid
+     * Initialize commands and keymap for this session.
+     * Called by Svedit component when it has the necessary context.
+     *
+     * NOTE: This assumes a single Svedit instance per session.
+     * For multiple editors on the same document, this architecture would need
+     * to be refactored to support multiple sessions per document.
+     *
+     * @param {object} context - The svedit context with session, editable, canvas, etc.
      */
-    validate_node(node: any): void;
+    initialize_commands(context: object): void;
+    get_available_annotation_types(): any;
+    get_selected_node(): any;
     /**
      * Creates a new transaction for making atomic changes to the document.
      *
@@ -101,10 +75,15 @@ export default class Document {
     get tr(): Transaction;
     /**
      * Applies a transaction to the document.
+     * Auto-batches history entries with debounced behavior (max one entry per 2 seconds) when batch is true.
      *
      * @param {Transaction} transaction - The transaction to apply
+     * @param {object} [options] - Optional configuration
+     * @param {boolean} [options.batch=false] - Whether to allow batching with previous transaction
      */
-    apply(transaction: Transaction): this;
+    apply(transaction: Transaction, { batch }?: {
+        batch?: boolean;
+    }): this;
     undo(): this;
     redo(): this;
     /**
@@ -113,19 +92,19 @@ export default class Document {
      * @returns {any} Either a node instance object or the value of a property
      * @example
      * // Get a node by ID
-     * doc.get('list_1') // => { type: 'list', id: 'list_1', ... }
+     * session.get('list_1') // => { type: 'list', id: 'list_1', ... }
      *
      * @example
      * // Get a node array property
-     * doc.get(['list_1', 'list_items']) // => [ 'list_item_1', 'list_item_2' ]
+     * session.get(['list_1', 'list_items']) // => [ 'list_item_1', 'list_item_2' ]
      *
      * @example
      * // Get a specific node from an array
-     * doc.get(['page_1', 'body', 3, 'list_items', 0]) // => { type: 'list_item', id: 'list_item_1', ... }
+     * session.get(['page_1', 'body', 3, 'list_items', 0]) // => { type: 'list_item', id: 'list_item_1', ... }
      *
      * @example
      * // Get an annotated text property
-     * doc.get(['page_1', 'cover', 'title']) // => {text: 'Hello world', annotations: []}
+     * session.get(['page_1', 'cover', 'title']) // => {text: 'Hello world', annotations: []}
      */
     get(path: DocumentPath | string): any;
     /**
@@ -135,7 +114,7 @@ export default class Document {
      * @todo The layout of these should be improved and more explictly typed
      *
      * @example
-     * doc.inspect(['page_1', 'body']) => {
+     * session.inspect(['page_1', 'body']) => {
      *   kind: 'property',
      *   name: 'body',
      *   type: 'node_array',
@@ -144,7 +123,7 @@ export default class Document {
      * }
      *
      * @example
-     * doc.inspect(['page_1', 'body', 1]) => {
+     * session.inspect(['page_1', 'body', 1]) => {
      *   kind: 'node',
      *   id: 'paragraph_234',
      *   type: 'paragraph',
@@ -183,10 +162,10 @@ export default class Document {
      * 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
+     * @param {string} [annotation_type] Optional annotation type to filter by
      * @returns {Annotation|null}
      */
-    active_annotation(annotation_type: string): Annotation | null;
+    active_annotation(annotation_type?: string): Annotation | null;
     get_selected_annotated_text(): {
         text: string;
         annotations: any;
@@ -195,18 +174,29 @@ export default class Document {
     get_selected_plain_text(): string;
     get_selected_nodes(): any;
     select_parent(): void;
-    get_selection_range(): {
-        start: number;
-        end: number;
-        length: number;
-    };
-    traverse(node_id: any): any[];
     /**
-     * Convert the document to serialized format.
-     * @returns {SerializedDocument} The serialized document array
+     * Traverses the document and returns a list of nodes in depth-first order.
+     *
+     * The traversal order is:
+     * 1. Leaf nodes first
+     * 2. Branch nodes second
+     * 3. Root node (entry point) last
+     *
+     * @param {string} node_id - The ID of the node to start traversing from
+     * @returns {Array<DocumentNode>} Array of nodes in depth-first order
+     * @note Nodes that are not reachable from the entry point node will not be included
+     */
+    traverse(node_id: string): Array<DocumentNode>;
+    /**
+     * Convert the document to a clean format for persistence.
+     *
+     * We make a traversal to ensure that orphaned nodes are not included,
+     * and that leaf nodes go first, followed by branches and the root node at last.
+     *
+     * @returns {Document} The document
      */
-    to_json(): SerializedDocument;
-    property_type(type: any, property: any): "string" | "number" | "boolean" | "node_array" | "node" | "annotated_text" | "integer" | "integer_array" | "number_array" | "string_array" | "datetime" | "boolean_array";
+    to_json(): Document;
+    property_type(type: any, property: any): string;
     count_references(node_id: any): number;
     /**
      * @param {NodeId} node_id
@@ -215,16 +205,19 @@ export default class Document {
     get_referenced_nodes(node_id: NodeId): NodeId[];
     #private;
 }
-import type { NodeSchema } from './types.d.ts';
-import type { PrimitiveType } from './types.d.ts';
-import type { NodeProperty } from './types.d.ts';
-import type { NodeArrayProperty } from './types.d.ts';
+export type SessionOptions = {
+    /**
+     * - Initial selection state
+     */
+    selection?: Selection;
+};
 import type { DocumentSchema } from './types.d.ts';
+import type { Document } from './types.d.ts';
 import type { Selection } from './types.d.ts';
 import Transaction from './Transaction.svelte.js';
 import type { DocumentPath } from './types.d.ts';
 import type { NodeKind } from './types.d.ts';
 import type { Annotation } from './types.d.ts';
-import type { SerializedDocument } from './types.d.ts';
+import type { DocumentNode } from './types.d.ts';
 import type { NodeId } from './types.d.ts';
-//# sourceMappingURL=Document.svelte.d.ts.map
+//# sourceMappingURL=Session.svelte.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Session.svelte.d.ts","sourceRoot":"","sources":["../src/lib/Session.svelte.js"],"names":[],"mappings":"AA6BA;;;GAGG;AAEH;IA8BC;;;;;;OAMG;IACH,oBANW,cAAc,OACd,QAAQ,UACR,MAAM,YAEd;QAA4B,SAAS,GAA7B,SAAS;KACnB,EAWA;IA3CD,6BAA6B;IAC7B,QADW,cAAc,CACH;IAEtB,uBAAuB;IACvB,KADW,QAAQ,CACA;IAEnB,kBAAkB;IAClB,QADW,GAAG,CACQ;IAEtB,eAAyB;IACzB,sBAA+B;IAC/B,wBAA2C;IAI3C,aAA0B;IAC1B,WAAwB;IAGxB,kBAA6C;IAC7C,kBAAkE;IAGlE,mBAAmD;IACnD,gCAA6E;IA6B7E;;;;OAIG;IACH,qBAHW,SAAS,GAAG,SAAS,EAQ/B;IAlBD;;;OAGG;IACH,iBAFa,SAAS,GAAG,SAAS,CAIjC;IAcD;;;;;;OAMG;IACH,4BAyDC;IAED;;;OAGG;IACH,mBAFa,MAAM,CAIlB;IAED,qBAIC;IAED,mBAMC;IAED;;;;;;;;;OASG;IACH,6BAFW,MAAM,QAQhB;IAED,sCAKC;IAGD,yBAkBC;IAED;;;;OAIG;IACH,UAFa,WAAW,CAKvB;IAED;;;;;;;OAOG;IACH,mBAJW,WAAW,cAEnB;QAA0B,KAAK,GAAvB,OAAO;KACjB,QA4CA;IAED,aAgBC;IAED,aAaC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,UAlBW,YAAY,GAAC,MAAM,GACjB,GAAG,CAmBf;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,cAHW,YAAY,GACV;QAAC,IAAI,EAAE,UAAU,GAAC,MAAM,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,CAIzD;IAED;;;;;OAKG;IACH,WAHW,GAAG,GACD,QAAQ,CAIpB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,cACN,SAAS,GACP,OAAO,CAcnB;IAED;;;;;OAKG;IACH,wCAHW,SAAS,GACP,SAAS,CAerB;IAED;;;;;;OAMG;IACH,oCAHW,MAAM,GACJ,UAAU,GAAC,IAAI,CAI3B;IAED;;;;MA6BC;IAGD,kCAOC;IAED,0BAOC;IAED,sBAmCC;IAED;;;;;;;;;;;OAWG;IACH,kBAJW,MAAM,GACJ,KAAK,CAAC,YAAY,CAAC,CAK/B;IAED;;;;;;;OAOG;IACH,WAFa,QAAQ,CAWpB;IAID,gDAEC;IAGD,uCAEC;IAGD;;;OAGG;IACH,8BAHW,MAAM,GACJ,MAAM,EAAE,CAOpB;;CACD;;;;;gBAljBa,SAAS;;oCAPb,cAAc;8BAAd,cAAc;+BAAd,cAAc;wBAxBA,yBAAyB;kCAwBvC,cAAc;8BAAd,cAAc;gCAAd,cAAc;kCAAd,cAAc;4BAAd,cAAc"}