svedit 0.4.0 → 0.6.0

package/dist/UnknownNode.svelte

@@ -1,12 +1,12 @@
 <script>
-  import { getContext } from 'svelte';
-  import Node from './Node.svelte';
+	import { getContext } from 'svelte';
+	import Node from './Node.svelte';
 
-  const svedit = getContext('svedit');
-  let { path } = $props();
-	let node = $derived(svedit.doc.get(path));
+	const svedit = getContext('svedit');
+	let { path } = $props();
+	let node = $derived(svedit.session.get(path));
 </script>
 
 <Node {path}>
-  Unknown: {node.type}.
+	Unknown: {node.type}.
 </Node>

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

@@ -1 +1 @@
-{"version":3,"file":"UnknownNode.svelte.d.ts","sourceRoot":"","sources":["../src/lib/UnknownNode.svelte.js"],"names":[],"mappings":";;;;;AAqBA;UAV2B,GAAG;WAU4B;wBAVvC;IAAE,IAAI,EAAE,GAAG,CAAA;CAAE"}
+{"version":3,"file":"UnknownNode.svelte.d.ts","sourceRoot":"","sources":["../src/lib/UnknownNode.svelte.js"],"names":[],"mappings":";;;;;AAqBA;UAV0B,GAAG;WAU6B;wBAVxC;IAAE,IAAI,EAAE,GAAG,CAAA;CAAE"}

package/dist/doc_utils.d.ts

@@ -0,0 +1,127 @@
+/**
+ * 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;
+/**
+ * Validate a node against its schema.
+ * @param {any} node - The node to validate
+ * @param {DocumentSchema} schema - The document schema
+ * @param {Record<string, any>} all_nodes - All nodes in the document to check references
+ * @throws {Error} Throws if the node is invalid
+ */
+export function validate_node(node: any, schema: DocumentSchema, all_nodes?: Record<string, any>): void;
+/**
+ * Gets a value from the document at the specified path.
+ *
+ * @param {DocumentSchema} schema - The document schema
+ * @param {Document} doc - The document containing nodes
+ * @param {DocumentPath|string} path - Array path to the value, or a string node ID
+ * @returns {any} The value at the specified path
+ */
+export function get(schema: DocumentSchema, doc: Document, path: DocumentPath | string): any;
+/**
+ * Gets the type of a property from the schema.
+ *
+ * @param {object} schema - The document schema
+ * @param {string} type - The node type
+ * @param {string} property - The property name
+ * @returns {string} The property type
+ */
+export function property_type(schema: object, type: string, property: string): string;
+/**
+ * Determines the kind of a node ('block', 'text', or 'annotation').
+ *
+ * @param {object} schema - The document schema
+ * @param {any} node - The node to check
+ * @returns {'block'|'text'|'annotation'} The node kind
+ */
+export function kind(schema: object, node: any): "block" | "text" | "annotation";
+/**
+ * Inspects a path to get metadata about the value at that location.
+ *
+ * @param {DocumentSchema} schema - The document schema
+ * @param {Document} doc - The document containing nodes
+ * @param {DocumentPath} path - The path to inspect
+ * @returns {{kind: 'property'|'node', [key: string]: any}} Metadata about the path
+ */
+export function inspect(schema: DocumentSchema, doc: Document, path: DocumentPath): {
+    kind: "property" | "node";
+    [key: string]: any;
+};
+/**
+ * Applies an operation to a document and returns the new document.
+ * Uses copy-on-write semantics.
+ *
+ * @param {Document} doc - The document to apply the operation to
+ * @param {Array} op - The operation to apply [type, ...args]
+ * @returns {Document} The new document with the operation applied
+ */
+export function apply_op(doc: Document, op: any[]): Document;
+/**
+ * Counts how many times a node is referenced in the document.
+ *
+ * @param {DocumentSchema} schema - The document schema
+ * @param {Document} doc - The document containing nodes
+ * @param {NodeId} node_id - The node ID to count references for
+ * @returns {number} The number of references
+ */
+export function count_references(schema: DocumentSchema, doc: Document, node_id: NodeId): number;
+/**
+ * Gets the currently active annotation at the selection, optionally filtered by type.
+ *
+ * An annotation is considered "active" if it overlaps with the current selection in any way:
+ * - Annotation contains the selection start
+ * - Annotation contains the selection end
+ * - Selection fully contains the annotation
+ *
+ * @param {DocumentSchema} schema - The document schema
+ * @param {Document} doc - The document containing nodes
+ * @param {Selection} [selection] - The current selection
+ * @param {string} [annotation_type] - Optional annotation type to filter by
+ * @returns {Annotation | null} The active annotation, or null if none found
+ */
+export function get_active_annotation(schema: DocumentSchema, doc: Document, selection?: Selection, annotation_type?: string): Annotation | null;
+/**
+ * Counts references to a node, excluding nodes marked for deletion.
+ *
+ * @param {DocumentSchema} schema - The document schema
+ * @param {Document} doc - The document containing nodes
+ * @param {NodeId} target_node_id - The node ID to count references for
+ * @param {Record<NodeId, boolean>} nodes_to_delete - Nodes marked for deletion
+ * @returns {number} The number of references excluding deleted nodes
+ */
+export function count_references_excluding_deleted(schema: DocumentSchema, doc: Document, target_node_id: NodeId, nodes_to_delete: Record<NodeId, boolean>): number;
+import type { NodeSchema } from './types';
+import type { PrimitiveType } from './types';
+import type { NodeProperty } from './types';
+import type { NodeArrayProperty } from './types';
+import type { DocumentSchema } from './types';
+import type { Document } from './types';
+import type { DocumentPath } from './types';
+import type { NodeId } from './types';
+import type { Selection } from './types';
+import type { Annotation } from './types';
+//# sourceMappingURL=doc_utils.d.ts.map

package/dist/doc_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doc_utils.d.ts","sourceRoot":"","sources":["../src/lib/doc_utils.js"],"names":[],"mappings":"AAWA;;;;;;;GAOG;AACH,uCAJ0C,CAAC,SAA7B,MAAM,CAAC,MAAM,EAAE,UAAU,CAAE,UAC9B,CAAC,GACC,CAAC,CAIb;AAED;;;;GAIG;AACH,wCAHW,MAAM,GACJ,IAAI,IAAI,aAAa,CAejC;AAED;;;;GAIG;AACH,2DAHW,YAAY,GAAG,iBAAiB,GAC9B,MAAM,GAAG,IAAI,CAWzB;AAED;;;;GAIG;AACH,0DAHW,cAAc,QAmBxB;AAgDD;;;;;;GAMG;AACH,oCALW,GAAG,UACH,cAAc,cACd,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,QA6D7B;AAED;;;;;;;GAOG;AACH,4BALW,cAAc,OACd,QAAQ,QACR,YAAY,GAAC,MAAM,GACjB,GAAG,CA4Ef;AAED;;;;;;;GAOG;AACH,sCALW,MAAM,QACN,MAAM,YACN,MAAM,GACJ,MAAM,CAclB;AAED;;;;;;GAMG;AACH,6BAJW,MAAM,QACN,GAAG,GACD,OAAO,GAAC,MAAM,GAAC,YAAY,CAIvC;AAED;;;;;;;GAOG;AACH,gCALW,cAAc,OACd,QAAQ,QACR,YAAY,GACV;IAAC,IAAI,EAAE,UAAU,GAAC,MAAM,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAC,CAoBzD;AAED;;;;;;;GAOG;AACH,8BAJW,QAAQ,cAEN,QAAQ,CAkCpB;AAED;;;;;;;GAOG;AACH,yCALW,cAAc,OACd,QAAQ,WACR,MAAM,GACJ,MAAM,CAoBlB;AAED;;;;;;;;;;;;;GAaG;AACH,8CANW,cAAc,OACd,QAAQ,cACR,SAAS,oBACT,MAAM,GACJ,UAAU,GAAG,IAAI,CAwB7B;AAED;;;;;;;;GAQG;AACH,2DANW,cAAc,OACd,QAAQ,kBACR,MAAM,mBACN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACrB,MAAM,CA0BlB;gCA3dqJ,SAAS;mCAAT,SAAS;kCAAT,SAAS;uCAAT,SAAS;oCAAT,SAAS;8BAAT,SAAS;kCAAT,SAAS;4BAAT,SAAS;+BAAT,SAAS;gCAAT,SAAS"}

package/dist/doc_utils.js

@@ -0,0 +1,482 @@
+/**
+ * Shared document utilities used by both Session and Transaction.
+ *
+ * These functions operate on the core document state (schema, doc, selection, config)
+ * without any history management or transaction tracking.
+ *
+ * @import { NodeId, DocumentPath, PrimitiveType, NodeProperty, NodeArrayProperty, NodeSchema, DocumentSchema, Selection, Annotation, Document } from './types'
+ */
+
+import { get_selection_range } from './utils.js';
+
+/**
+ * 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(schema) {
+	return schema;
+}
+
+/**
+ * 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) {
+	return [
+		'string',
+		'number',
+		'boolean',
+		'integer',
+		'datetime',
+		'annotated_text',
+		'string_array',
+		'number_array',
+		'boolean_array',
+		'integer_array'
+	].includes(type);
+}
+
+/**
+ * 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) {
+	if (!property_definition || !property_definition.node_types) {
+		return null;
+	}
+
+	return (
+		property_definition.default_node_type ||
+		(property_definition.node_types.length === 1 ? property_definition.node_types[0] : 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) {
+	// Check that all referenced node types exist
+	for (const [node_type, node_schema] of Object.entries(document_schema)) {
+		for (const [prop_name, prop_def] of Object.entries(node_schema.properties)) {
+			if (prop_def.type === 'node' || prop_def.type === 'node_array') {
+				const missing_types = prop_def.node_types.filter(
+					(ref_type) => !(ref_type in document_schema)
+				);
+				if (missing_types.length > 0) {
+					throw new Error(
+						`Node type "${node_type}" property "${prop_name}" references unknown node types: ${missing_types.join(', ')}. Available node types: ${Object.keys(document_schema).join(', ')}`
+					);
+				}
+			}
+		}
+	}
+}
+
+/**
+ * Validate a primitive value against its schema type.
+ * @param {PrimitiveType} type - The expected type
+ * @param {any} value - The value to validate
+ * @returns {boolean} True if the value matches the type
+ */
+function validate_primitive_value(type, value) {
+	switch (type) {
+		case 'string':
+			return typeof value === 'string';
+		case 'number':
+			return typeof value === 'number' && !isNaN(value);
+		case 'boolean':
+			return typeof value === 'boolean';
+		case 'integer':
+			return Number.isInteger(value);
+		case 'datetime':
+			return typeof value === 'string' && !isNaN(Date.parse(value));
+		case 'annotated_text':
+			return (
+				typeof value === 'object' &&
+				value !== null &&
+				typeof value.text === 'string' &&
+				Array.isArray(value.annotations)
+			);
+		case 'string_array':
+			return Array.isArray(value) && value.every((v) => typeof v === 'string');
+		case 'number_array':
+			return Array.isArray(value) && value.every((v) => typeof v === 'number' && !isNaN(v));
+		case 'boolean_array':
+			return Array.isArray(value) && value.every((v) => typeof v === 'boolean');
+		case 'integer_array':
+			return Array.isArray(value) && value.every((v) => Number.isInteger(v));
+		default:
+			return false;
+	}
+}
+
+/**
+ * @param {String} id
+ * @returns {boolean}
+ */
+function is_id_valid(id) {
+	return typeof id === 'string' && id.length > 0;
+}
+
+/**
+ * Validate a node against its schema.
+ * @param {any} node - The node to validate
+ * @param {DocumentSchema} schema - The document schema
+ * @param {Record<string, any>} all_nodes - All nodes in the document to check references
+ * @throws {Error} Throws if the node is invalid
+ */
+export function validate_node(node, schema, all_nodes = {}) {
+	if (!is_id_valid(node.id)) {
+		throw new Error(`Node ${node.id} has an invalid id.`);
+	}
+
+	if (!node.type || !schema[node.type]) {
+		throw new Error(`Node ${node.id} has an invalid type: ${node.type}`);
+	}
+
+	const node_schema = schema[node.type];
+
+	for (const [prop_name, prop_def] of Object.entries(node_schema.properties)) {
+		const value = node[prop_name];
+
+		// Check primitive types
+		if (is_primitive_type(prop_def.type)) {
+			if (!validate_primitive_value(prop_def.type, value)) {
+				throw new Error(
+					`Node ${node.id} has an invalid property: ${prop_name} must be of type ${prop_def.type}.`
+				);
+			}
+		}
+		// Check node references
+		if (prop_def.type === 'node') {
+			if (!is_id_valid(value)) {
+				throw new Error(
+					`Node ${node.id} has an invalid property: ${prop_name} must be a valid node id.`
+				);
+			}
+			// Check if referenced node exists and is of allowed type
+			const referenced_node = all_nodes[value];
+			if (referenced_node && !prop_def.node_types.includes(referenced_node.type)) {
+				throw new Error(
+					`Node ${node.id} property ${prop_name} references node ${value} of type ${referenced_node.type}, but only types [${/** @type {NodeProperty} */ (prop_def).node_types.join(', ')}] are allowed.`
+				);
+			}
+		}
+		// Check node arrays
+		else if (prop_def.type === 'node_array') {
+			if (
+				!Array.isArray(value) ||
+				!value.every((id) => typeof id === 'string' && is_id_valid(id))
+			) {
+				throw new Error(
+					`Node ${node.id} has an invalid property: ${prop_name} must be an array of node ids.`
+				);
+			}
+			// Check if all referenced nodes are of allowed types
+			for (const ref_id of value) {
+				const referenced_node = all_nodes[ref_id];
+				if (referenced_node && !prop_def.node_types.includes(referenced_node.type)) {
+					throw new Error(
+						`Node ${node.id} property ${prop_name} references node ${ref_id} of type ${referenced_node.type}, but only types [${prop_def.node_types.join(', ')}] are allowed.`
+					);
+				}
+			}
+		}
+	}
+}
+
+/**
+ * Gets a value from the document at the specified path.
+ *
+ * @param {DocumentSchema} schema - The document schema
+ * @param {Document} doc - The document containing nodes
+ * @param {DocumentPath|string} path - Array path to the value, or a string node ID
+ * @returns {any} The value at the specified path
+ */
+export function get(schema, doc, path) {
+	if (typeof path === 'string') {
+		path = [path];
+	}
+	if (!(Array.isArray(path) && path.length >= 1)) {
+		throw new Error(`Invalid path provided ${JSON.stringify(path)}`);
+	}
+
+	let val = doc.nodes[path[0]];
+	let val_type = 'node';
+
+	for (let i = 1; i < path.length; i++) {
+		const path_segment = path[i];
+		const path_segment_str = String(path_segment);
+		if (val_type === 'node') {
+			if (property_type(schema, val.type, path_segment_str) === 'node_array') {
+				val = val[path_segment];
+				val_type = 'node_array';
+			} else if (property_type(schema, val.type, path_segment_str) === 'annotated_text') {
+				val = val[path_segment];
+				val_type = 'annotated_text';
+			} else if (property_type(schema, val.type, path_segment_str) === 'node') {
+				val = doc.nodes[val[path_segment]];
+				val_type = 'node';
+			} else if (
+				['string_array', 'integer_array'].includes(
+					property_type(schema, val.type, path_segment_str)
+				)
+			) {
+				val = val[path_segment];
+				val_type = 'value_array';
+			} else {
+				val = val[path_segment];
+				val_type = 'value';
+			}
+		} else if (val_type === 'node_array') {
+			val = doc.nodes[val[path_segment]];
+			val_type = 'node';
+		} else if (val_type === 'value_array') {
+			val = val[path_segment];
+			val_type = 'value';
+		} else if (val_type === 'annotated_text') {
+			if (path_segment === 'text') {
+				val = val.text;
+				val_type = 'value';
+			} else if (path_segment === 'annotations') {
+				val = val.annotations;
+				val_type = 'annotation_array';
+			} else {
+				throw new Error(
+					`Invalid path segment "${path_segment}" for annotated_text. Use "text" or "annotations".`
+				);
+			}
+		} else if (val_type === 'annotation_array') {
+			val = val[path_segment];
+			val_type = 'annotation';
+		} else if (val_type === 'annotation') {
+			if (path_segment === 'node_id') {
+				val = doc.nodes[val.node_id];
+				val_type = 'node';
+			} else if (path_segment === 'start_offset') {
+				val = val.start_offset;
+				val_type = 'value';
+			} else if (path_segment === 'end_offset') {
+				val = val.end_offset;
+				val_type = 'value';
+			} else {
+				throw new Error(
+					`Invalid path segment "${path_segment}" for annotation. Use "start_offset", "end_offset", or "node_id".`
+				);
+			}
+		}
+	}
+	return val;
+}
+
+/**
+ * Gets the type of a property from the schema.
+ *
+ * @param {object} schema - The document schema
+ * @param {string} type - The node type
+ * @param {string} property - The property name
+ * @returns {string} The property type
+ */
+export function property_type(schema, type, property) {
+	if (typeof type !== 'string') throw new Error(`Invalid type ${type} provided`);
+	if (typeof property !== 'string') throw new Error(`Invalid property ${property} provided`);
+
+	if (property === 'type') return 'string';
+	if (property === 'id') return 'string';
+
+	if (!schema[type]) throw new Error(`Type ${type} not found in schema`);
+	if (!schema[type].properties[property])
+		throw new Error(`Property ${property} not found in type ${type}`);
+
+	return schema[type].properties[property].type;
+}
+
+/**
+ * Determines the kind of a node ('block', 'text', or 'annotation').
+ *
+ * @param {object} schema - The document schema
+ * @param {any} node - The node to check
+ * @returns {'block'|'text'|'annotation'} The node kind
+ */
+export function kind(schema, node) {
+	return schema[node.type].kind;
+}
+
+/**
+ * Inspects a path to get metadata about the value at that location.
+ *
+ * @param {DocumentSchema} schema - The document schema
+ * @param {Document} doc - The document containing nodes
+ * @param {DocumentPath} path - The path to inspect
+ * @returns {{kind: 'property'|'node', [key: string]: any}} Metadata about the path
+ */
+export function inspect(schema, doc, path) {
+	const parent = path.length > 1 ? get(schema, doc, path.slice(0, -1)) : undefined;
+	if (parent?.type) {
+		const property_name = path.at(-1);
+		return {
+			kind: 'property',
+			name: property_name,
+			...schema[parent.type].properties[property_name]
+		};
+	} else {
+		const node = get(schema, doc, path);
+		return {
+			kind: 'node',
+			id: node.id,
+			type: node.type,
+			properties: schema[node.type]
+		};
+	}
+}
+
+/**
+ * Applies an operation to a document and returns the new document.
+ * Uses copy-on-write semantics.
+ *
+ * @param {Document} doc - The document to apply the operation to
+ * @param {Array} op - The operation to apply [type, ...args]
+ * @returns {Document} The new document with the operation applied
+ */
+export function apply_op(doc, op) {
+	const [type, ...args] = op;
+	if (type === 'set') {
+		const [node_id, property] = args[0];
+		const value = structuredClone(args[1]);
+		return {
+			...doc,
+			nodes: {
+				...doc.nodes,
+				[node_id]: {
+					...doc.nodes[node_id],
+					[property]: value
+				}
+			}
+		};
+	} else if (type === 'create') {
+		return {
+			...doc,
+			nodes: {
+				...doc.nodes,
+				[args[0].id]: structuredClone(args[0])
+			}
+		};
+	} else if (type === 'delete') {
+		// eslint-disable-next-line
+		const { [args[0]]: _removed, ...remaining_nodes } = doc.nodes;
+		return {
+			...doc,
+			nodes: remaining_nodes
+		};
+	}
+	return doc;
+}
+
+/**
+ * Counts how many times a node is referenced in the document.
+ *
+ * @param {DocumentSchema} schema - The document schema
+ * @param {Document} doc - The document containing nodes
+ * @param {NodeId} node_id - The node ID to count references for
+ * @returns {number} The number of references
+ */
+export function count_references(schema, doc, node_id) {
+	let count = 0;
+
+	for (const node of Object.values(doc.nodes)) {
+		for (const [property, value] of Object.entries(node)) {
+			if (property === 'id' || property === 'type') continue;
+
+			const prop_type = property_type(schema, node.type, property);
+
+			if (prop_type === 'node_array' && Array.isArray(value)) {
+				count += value.filter((id) => id === node_id).length;
+			} else if (prop_type === 'node' && value === node_id) {
+				count += 1;
+			}
+		}
+	}
+
+	return count;
+}
+
+/**
+ * Gets the currently active annotation at the selection, optionally filtered by type.
+ *
+ * An annotation is considered "active" if it overlaps with the current selection in any way:
+ * - Annotation contains the selection start
+ * - Annotation contains the selection end
+ * - Selection fully contains the annotation
+ *
+ * @param {DocumentSchema} schema - The document schema
+ * @param {Document} doc - The document containing nodes
+ * @param {Selection} [selection] - The current selection
+ * @param {string} [annotation_type] - Optional annotation type to filter by
+ * @returns {Annotation | null} The active annotation, or null if none found
+ */
+export function get_active_annotation(schema, doc, selection, annotation_type) {
+	if (selection?.type !== 'text') return null;
+	const range = get_selection_range(selection);
+	if (!range) return null;
+
+	const annotated_text = get(schema, doc, selection.path);
+	const annotations = annotated_text.annotations;
+
+	const active_annotation =
+		annotations.find(
+			(/** @type {Annotation} */ { start_offset, end_offset }) =>
+				(start_offset <= range.start_offset && end_offset > range.start_offset) ||
+				(start_offset < range.end_offset && end_offset >= range.end_offset) ||
+				(start_offset >= range.start_offset && end_offset <= range.end_offset)
+		) || null;
+
+	if (annotation_type && active_annotation) {
+		const annotation_node = get(schema, doc, [active_annotation.node_id]);
+		return annotation_node?.type === annotation_type ? active_annotation : null;
+	} else {
+		return active_annotation;
+	}
+}
+
+/**
+ * Counts references to a node, excluding nodes marked for deletion.
+ *
+ * @param {DocumentSchema} schema - The document schema
+ * @param {Document} doc - The document containing nodes
+ * @param {NodeId} target_node_id - The node ID to count references for
+ * @param {Record<NodeId, boolean>} nodes_to_delete - Nodes marked for deletion
+ * @returns {number} The number of references excluding deleted nodes
+ */
+export function count_references_excluding_deleted(schema, doc, target_node_id, nodes_to_delete) {
+	let count = 0;
+
+	for (const node of Object.values(doc.nodes)) {
+		if (nodes_to_delete[node.id]) continue;
+
+		for (const [property, value] of Object.entries(node)) {
+			if (property === 'id' || property === 'type') continue;
+
+			const prop_type = property_type(schema, node.type, property);
+
+			if (prop_type === 'node_array' && Array.isArray(value)) {
+				count += value.filter((id) => id === target_node_id).length;
+			} else if (prop_type === 'node' && value === target_node_id) {
+				count += 1;
+			} else if (prop_type === 'annotated_text' && value && value.annotations) {
+				count += value.annotations.filter(
+					(annotation) => annotation.node_id === target_node_id
+				).length;
+			}
+		}
+	}
+
+	return count;
+}

package/dist/index.d.ts

@@ -3,8 +3,12 @@ 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";
+export { default as Session } from "./Session.svelte.js";
 export { default as Transaction } from "./Transaction.svelte.js";
-export * from "./commands.svelte.js";
-export * from "./util.js";
-export { default as Document, define_document_schema } from "./Document.svelte.js";
+export { default as Command } from "./Command.svelte.js";
+export * from "./Command.svelte.js";
+export * from "./transforms.svelte.js";
+export * from "./utils.js";
+export { define_document_schema, is_primitive_type, get_default_node_type, validate_document_schema, validate_node } from "./doc_utils.js";
+export { KeyMapper, define_keymap } from "./KeyMapper.svelte.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -6,9 +6,25 @@ 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 Session } from './Session.svelte.js';
 export { default as Transaction } from './Transaction.svelte.js';
 
-// Commands and utilities
-export * from './commands.svelte.js';
-export * from './util.js';
+// Document utilities
+export {
+	define_document_schema,
+	is_primitive_type,
+	get_default_node_type,
+	validate_document_schema,
+	validate_node
+} from './doc_utils.js';
+
+// Command system
+export { default as Command } from './Command.svelte.js';
+export * from './Command.svelte.js';
+
+// Keyboard handling
+export { KeyMapper, define_keymap } from './KeyMapper.svelte.js';
+
+// Transforms and utilities
+export * from './transforms.svelte.js';
+export * from './utils.js';

package/dist/{commands.svelte.d.ts → transforms.svelte.d.ts}

@@ -1,5 +1,4 @@
 export function break_text_node(tr: any): boolean;
 export function join_text_node(tr: any): boolean;
 export function insert_default_node(tr: any): boolean;
-export function select_all(tr: any): boolean;
-//# sourceMappingURL=commands.svelte.d.ts.map
+//# sourceMappingURL=transforms.svelte.d.ts.map