svedit 0.11.1 → 0.13.0

package/src/lib/{paste_utils.js → paste_utils.ts}

@@ -1,12 +1,23 @@
-/**
- * @import { DocumentSchema } from './types.d.ts'
- */
+import type { Text, DocumentNode, DocumentSchema } from './types.js';
 
-export function normalize_line_endings(text) {
+function is_record(value: unknown): value is Record<string, unknown> {
+	return typeof value === 'object' && value !== null;
+}
+
+function is_text(value: unknown): value is Text {
+	return (
+		is_record(value) &&
+		typeof value.content === 'string' &&
+		Array.isArray(value.marks) &&
+		Array.isArray(value.annotations)
+	);
+}
+
+export function normalize_line_endings(text: string): string {
 	return text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
 }
 
-export function dedent_plain_text(plain_text) {
+export function dedent_plain_text(plain_text: string): string {
 	const lines = normalize_line_endings(plain_text).split('\n');
 	if (lines.length < 2) return plain_text;
 
@@ -42,101 +53,81 @@ export function dedent_plain_text(plain_text) {
 		.join('\n');
 }
 
-export function split_plain_text_paragraphs(plain_text) {
+export function split_plain_text_paragraphs(plain_text: string): string[] {
 	return normalize_line_endings(plain_text)
 		.split(/\n{2,}/)
 		.map((fragment) => fragment.trim())
 		.filter(Boolean);
 }
 
-export function normalize_plain_text_for_single_line_property(plain_text) {
+export function normalize_plain_text_for_single_line_property(plain_text: string): string {
 	return normalize_line_endings(plain_text).replace(/\s*\n+\s*/g, ' ');
 }
 
-/**
- * @param {string | null | undefined} node_type
- * @param {DocumentSchema} schema
- * @returns {string | null}
- */
-export function get_text_property_name(node_type, schema) {
+export function get_text_property_name(
+	node_type: string | null | undefined,
+	schema: DocumentSchema
+): string | null {
 	if (!node_type) return null;
 	const node_schema = schema[node_type];
 	if (!node_schema || node_schema.kind !== 'text') return null;
-	if (node_schema.properties?.content?.type === 'annotated_text') return 'content';
+	if (node_schema.properties?.content?.type === 'text') return 'content';
 	return (
 		Object.entries(node_schema.properties).find(([, property_definition]) => {
-			return property_definition.type === 'annotated_text';
+			return property_definition.type === 'text';
 		})?.[0] || null
 	);
 }
 
-/**
- * @param {any} node
- * @param {DocumentSchema} schema
- * @returns {{ text: string, annotations: any[] } | null}
- */
-export function get_text_content(node, schema) {
-	if (!node || typeof node !== 'object') return null;
+export function get_text_content(node: unknown, schema: DocumentSchema): Text | null {
+	if (!is_record(node)) return null;
 
-	const text_property_name = get_text_property_name(node.type, schema);
-	if (
-		text_property_name &&
-		node[text_property_name] &&
-		typeof node[text_property_name].text === 'string' &&
-		Array.isArray(node[text_property_name].annotations)
-	) {
+	const node_type = typeof node.type === 'string' ? node.type : null;
+	const text_property_name = get_text_property_name(node_type, schema);
+	if (text_property_name && is_text(node[text_property_name])) {
 		return node[text_property_name];
 	}
 
-	if (node.content && typeof node.content.text === 'string' && Array.isArray(node.content.annotations)) {
+	if (is_text(node.content)) {
 		return node.content;
 	}
 
 	return null;
 }
 
-/**
- * @param {any} node
- * @param {DocumentSchema} schema
- * @returns {boolean}
- */
-export function is_text_like_node_payload(node, schema) {
-	if (!node || typeof node !== 'object') return false;
-	if (schema[node.type]?.kind === 'text') return true;
+export function is_text_like_node_payload(node: unknown, schema: DocumentSchema): boolean {
+	if (!is_record(node)) return false;
+	if (typeof node.type === 'string' && schema[node.type]?.kind === 'text') return true;
 	return !!get_text_content(node, schema);
 }
 
-/**
- * @param {any} node_array_property_definition
- * @param {DocumentSchema} schema
- * @returns {string | null}
- */
-export function get_default_text_node(node_array_property_definition, schema) {
+export function get_default_text_node(
+	node_array_property_definition: unknown,
+	schema: DocumentSchema
+): string | null {
 	if (
-		node_array_property_definition?.type !== 'node_array' ||
+		!is_record(node_array_property_definition) ||
+		node_array_property_definition.type !== 'node_array' ||
 		!Array.isArray(node_array_property_definition.node_types)
 	) {
 		return null;
 	}
 
 	const default_node_type = node_array_property_definition.default_node_type;
-	if (default_node_type && schema[default_node_type]?.kind === 'text') {
+	if (typeof default_node_type === 'string' && schema[default_node_type]?.kind === 'text') {
 		return default_node_type;
 	}
 
-	return (
-		node_array_property_definition.node_types.find((node_type) => schema[node_type]?.kind === 'text') ||
-		null
-	);
+	return (node_array_property_definition.node_types.find(
+		(node_type: unknown) => typeof node_type === 'string' && schema[node_type]?.kind === 'text'
+	) || null) as string | null;
 }
 
-/**
- * @param {string[]} paragraph_fragments
- * @param {string | null | undefined} node_type
- * @param {DocumentSchema} schema
- * @returns {{ main_nodes: string[], nodes: Record<string, any> } | null}
- */
-export function create_plain_text_nodes_payload(paragraph_fragments, node_type, schema) {
+export function create_plain_text_nodes_payload(
+	paragraph_fragments: string[],
+	node_type: string | null | undefined,
+	schema: DocumentSchema
+): { main_nodes: string[]; nodes: Record<string, DocumentNode> } | null {
 	if (!Array.isArray(paragraph_fragments) || paragraph_fragments.length === 0 || !node_type) {
 		return null;
 	}
@@ -144,7 +135,7 @@ export function create_plain_text_nodes_payload(paragraph_fragments, node_type,
 	const text_property_name = get_text_property_name(node_type, schema);
 	if (!text_property_name) return null;
 
-	const payload = {
+	const payload: { main_nodes: string[]; nodes: Record<string, DocumentNode> } = {
 		main_nodes: [],
 		nodes: {}
 	};
@@ -156,7 +147,8 @@ export function create_plain_text_nodes_payload(paragraph_fragments, node_type,
 			id: node_id,
 			type: node_type,
 			[text_property_name]: {
-				text: fragment,
+				content: fragment,
+				marks: [],
 				annotations: []
 			}
 		};

package/src/lib/{transforms.svelte.js → transforms.svelte.ts}

@@ -1,20 +1,33 @@
-import { split_annotated_text, join_annotated_text, get_char_length } from './utils.js';
+import { split_text, join_text, get_char_length } from './utils.js';
 import { get_default_node_type } from './doc_utils.js';
+import type Transaction from './Transaction.svelte.js';
+import type {
+	DocumentNode,
+	DocumentPath,
+	NodeArrayProperty,
+	NodeProperty,
+	Selection,
+	TextSelection
+} from './types.js';
 
 /**
  * Set multiple properties on a node via a transaction.
  *
- * @param {object} tr - The transaction
- * @param {Array} path - Path to the node
- * @param {Record<string, any>} properties - Key/value pairs to set
+ * @param tr - The transaction
+ * @param path - Path to the node
+ * @param properties - Key/value pairs to set
  */
-export function set_properties(tr, path, properties) {
+export function set_properties(
+	tr: Transaction,
+	path: DocumentPath,
+	properties: Record<string, unknown>
+): void {
 	for (const [key, value] of Object.entries(properties)) {
 		tr.set([...path, key], value);
 	}
 }
 
-export function break_text_node(tr) {
+export function break_text_node(tr: Transaction): boolean {
 	// Keep a reference of the original selection (before any transforms are applied)
 	const selection = tr.selection;
 	// First we need to ensure we have a text selection
@@ -28,33 +41,35 @@ export function break_text_node(tr) {
 	if (tr.kind(node) !== 'text') return false;
 	const is_inside_node_array = tr.inspect(selection.path.slice(0, -2))?.type === 'node_array';
 	if (!is_inside_node_array) return false; // Do nothing if we're not inside a node_array
-	const node_array_prop = selection.path.at(-3);
+	const node_array_prop = String(selection.path.at(-3));
 	// Get the node that owns the node_array property (e.g. a page.body)
 	const node_array_node = tr.get(selection.path.slice(0, -3));
 
-
 	// Delete selection unless collapsed
 	if (selection.anchor_offset !== selection.focus_offset) {
 		tr.delete_selection();
 	}
 
-	const split_at_position = tr.selection.anchor_offset;
+	// After delete_selection the selection is still a (collapsed) text selection
+	const split_at_position = (tr.selection as TextSelection).anchor_offset;
 	const content = tr.get(selection.path);
-	const [left_text, right_text] = split_annotated_text(content, split_at_position);
+	const [left_text, right_text] = split_text(content, split_at_position);
 
 	tr.set([node.id, 'content'], left_text);
 
-	const node_insert_position = {
+	const node_insert_position: Selection = {
 		type: 'node',
 		path: tr.selection.path.slice(0, -2),
-		anchor_offset: parseInt(tr.selection.path.at(-2), 10) + 1,
-		focus_offset: parseInt(tr.selection.path.at(-2), 10) + 1
+		anchor_offset: (tr.selection.path.at(-2) as number) + 1,
+		focus_offset: (tr.selection.path.at(-2) as number) + 1
 	};
 
 	// TODO: Only use default_node_type when caret is at the end of
 	const node_array_property_definition =
 		tr.schema[node_array_node.type].properties[node_array_prop];
-	const target_node_type = get_default_node_type(node_array_property_definition);
+	const target_node_type = get_default_node_type(
+		node_array_property_definition as NodeProperty | NodeArrayProperty
+	);
 
 	if (!target_node_type) {
 		console.warn(
@@ -69,7 +84,7 @@ export function break_text_node(tr) {
 	return true;
 }
 
-export function join_text_node(tr) {
+export function join_text_node(tr: Transaction): boolean {
 	// Keep a reference of the original selection (before any transforms are applied)
 	const selection = tr.selection;
 	// First we need to ensure we have a text selection
@@ -80,20 +95,20 @@ export function join_text_node(tr) {
 	const is_inside_node_array = tr.inspect(selection.path.slice(0, -2))?.type === 'node_array';
 	if (!is_inside_node_array) return false; // Do nothing if we're not inside a node_array
 
-	const node_index = parseInt(tr.selection.path.at(-2), 10);
+	const node_index = tr.selection.path.at(-2) as number;
 
 	// Determine if we can join with the previous node
 	let can_join = false;
-	let predecessor_node = null;
+	let predecessor_node: DocumentNode | null = null;
 
 	if (node_index > 0) {
 		const previous_text_path = [...tr.selection.path.slice(0, -2), node_index - 1];
 		predecessor_node = tr.get(previous_text_path);
-		can_join = tr.kind(predecessor_node) === 'text';
+		can_join = predecessor_node !== null && tr.kind(predecessor_node) === 'text';
 	}
 
 	// Special behavior: if we can't join and current node is empty, delete it
-	if (!can_join && node.content.text === '') {
+	if (!can_join && node.content.content === '') {
 		tr.set_selection({
 			type: 'node',
 			path: tr.selection.path.slice(0, -2),
@@ -105,16 +120,16 @@ export function join_text_node(tr) {
 	}
 
 	// If we can't join for any reason, return false
-	if (!can_join) {
+	if (!can_join || !predecessor_node) {
 		return false;
 	}
 
 	// Normal joining logic - both nodes are text nodes
 	const previous_text_path = [...tr.selection.path.slice(0, -2), node_index - 1];
-	const joined_text = join_annotated_text(predecessor_node.content, node.content);
+	const joined_text = join_text(predecessor_node.content, node.content);
 
 	// Calculate caret position based on original predecessor content length
-	const caret_position = get_char_length(predecessor_node.content.text);
+	const caret_position = get_char_length(predecessor_node.content.content);
 
 	// First set the joined content on the predecessor node (preserves annotations)
 	tr.set([predecessor_node.id, 'content'], joined_text);
@@ -139,7 +154,7 @@ export function join_text_node(tr) {
 	return true;
 }
 
-export function insert_default_node(tr) {
+export function insert_default_node(tr: Transaction): boolean {
 	const selection = tr.selection;
 
 	// Only work with collapsed node selections
@@ -149,15 +164,17 @@ export function insert_default_node(tr) {
 
 	const path = selection.path;
 	const node_array_node = tr.get(path.slice(0, -1));
-	const property_name = path.at(-1);
+	const property_name = String(path.at(-1));
 
 	// Get the definition for this property
 	const property_definition = tr.schema[node_array_node.type].properties[property_name];
-	const default_type = get_default_node_type(property_definition);
+	const default_type = get_default_node_type(
+		property_definition as NodeProperty | NodeArrayProperty
+	);
 
 	// Use the inserter function if available
-	if (tr.config?.inserters?.[default_type]) {
-		tr.config.inserters[default_type](tr);
+	if (tr.config?.inserters?.[default_type as string]) {
+		tr.config.inserters[default_type as string](tr);
 		return true;
 	} else {
 		throw new Error(`No inserter function available for default node type '${default_type}'`);