svedit 0.4.0 → 0.6.0

package/src/lib/utils.js

@@ -0,0 +1,338 @@
+/**
+ * @import { Annotation, AnnotatedText, SelectionRange, Selection } from './types.d.ts';
+ */
+
+/**
+ * Detect if the current browser is on a mobile device
+ * @returns {boolean} true if mobile browser, false otherwise
+ */
+export function is_mobile_browser() {
+	if (typeof window === 'undefined' || typeof navigator === 'undefined') {
+		return false;
+	}
+
+	const user_agent = navigator.userAgent;
+	return (
+		/iPhone|iPad|iPod|Android|Mobile/i.test(user_agent) ||
+		'ontouchstart' in window ||
+		navigator.maxTouchPoints > 0
+	);
+}
+
+/**
+ * Detect if the current browser is Chrome on desktop
+ * @returns {boolean} true if Chrome desktop browser, false otherwise
+ */
+export function is_chrome_desktop_browser() {
+	if (typeof window === 'undefined' || typeof navigator === 'undefined') {
+		return false;
+	}
+	const user_agent = navigator.userAgent;
+	const is_chrome = user_agent.includes('Chrome') && !user_agent.includes('Edg');
+	const is_mobile = is_mobile_browser();
+	return is_chrome && !is_mobile;
+}
+
+/**
+ * Get the actual character length (accounting for multi-byte characters)
+ *
+ * Uses Intl.Segmenter to count grapheme clusters rather than UTF-16 code units,
+ * ensuring emojis and other complex Unicode sequences are counted as single characters.
+ *
+ * @param {string} str - The string to measure
+ * @returns {number} The number of visual characters (grapheme clusters)
+ *
+ * @example
+ * get_char_length('Hello') // Returns: 5
+ * get_char_length('a😀b') // Returns: 3 (not 4)
+ * get_char_length('👋🏽') // Returns: 1 (not 4 - skin tone modifier treated as single char)
+ */
+export function get_char_length(str) {
+	const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
+	return [...segmenter.segment(str)].length;
+}
+
+/**
+ * Get a single character at the specified position (accounting for multi-byte characters)
+ *
+ * Uses Intl.Segmenter to access grapheme clusters rather than UTF-16 code units,
+ * ensuring emojis and other complex Unicode sequences are treated as single characters.
+ *
+ * @param {string} str - The string to access
+ * @param {number} index - Character position (0-based)
+ * @returns {string} The character at the specified position, or empty string if index is out of bounds
+ *
+ * @example
+ * get_char_at('Hello', 1) // Returns: 'e'
+ * get_char_at('a😀b', 1) // Returns: '😀' (full emoji)
+ * get_char_at('👋🏽', 0) // Returns: '👋🏽' (skin tone modifier included)
+ */
+export function get_char_at(str, index) {
+	const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
+	const segments = [...segmenter.segment(str)];
+	return segments[index].segment;
+}
+
+/**
+ * Slice string by character positions (accounting for multi-byte characters)
+ *
+ * Uses Intl.Segmenter to slice by grapheme clusters rather than UTF-16 code units,
+ * ensuring emojis and other complex Unicode sequences remain intact.
+ *
+ * @param {string} str - The string to slice
+ * @param {number} start - Starting character position (inclusive)
+ * @param {number} [end] - Ending character position (exclusive). If undefined, slices to end
+ * @returns {string} The sliced string with complete characters
+ *
+ * @example
+ * char_slice('Hello 😀 World', 6, 8) // Returns: '😀 ' (emoji stays intact)
+ * char_slice('a👋🏽b', 1, 2) // Returns: '👋🏽' (skin tone modifier included)
+ */
+export function char_slice(str, start, end = undefined) {
+	const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
+	const segments = [...segmenter.segment(str)];
+	return segments
+		.slice(start, end)
+		.map((s) => s.segment)
+		.join('');
+}
+
+/**
+ * Convert UTF-16 code unit offset to grapheme cluster offset within a string
+ *
+ * Converts DOM selection offsets (which use UTF-16 code units) to character-based
+ * offsets (grapheme clusters) for consistent text manipulation.
+ *
+ * @param {string} str - The string to convert offsets within
+ * @param {number} utf16_offset - The UTF-16 code unit offset from DOM
+ * @returns {number} The corresponding grapheme cluster offset
+ *
+ * @example
+ * // For string "a😀b" where 😀 uses 2 UTF-16 code units
+ * utf16_to_char_offset("a😀b", 3) // Returns: 2 (position after emoji)
+ */
+export function utf16_to_char_offset(str, utf16_offset) {
+	const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
+	const segments = [...segmenter.segment(str)];
+	let char_offset = 0;
+	let utf16_count = 0;
+
+	for (const segment of segments) {
+		if (utf16_count >= utf16_offset) break;
+		utf16_count += segment.segment.length;
+		if (utf16_count > utf16_offset) break;
+		char_offset++;
+	}
+
+	return char_offset;
+}
+
+/**
+ * Convert grapheme cluster offset to UTF-16 code unit offset within a string
+ *
+ * Converts character-based offsets (grapheme clusters) to DOM selection offsets
+ * (UTF-16 code units) for proper DOM selection positioning.
+ *
+ * @param {string} str - The string to convert offsets within
+ * @param {number} char_offset - The grapheme cluster offset
+ * @returns {number} The corresponding UTF-16 code unit offset for DOM operations
+ *
+ * @example
+ * // For string "a😀b" where 😀 uses 2 UTF-16 code units
+ * char_to_utf16_offset("a😀b", 2) // Returns: 3 (UTF-16 position after emoji)
+ */
+export function char_to_utf16_offset(str, char_offset) {
+	const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
+	const segments = [...segmenter.segment(str)];
+	let utf16_offset = 0;
+
+	for (let i = 0; i < Math.min(char_offset, segments.length); i++) {
+		utf16_offset += segments[i].segment.length;
+	}
+
+	return utf16_offset;
+}
+
+/**
+ * Splits an annotated text at the specified character position.
+ *
+ * Annotations that span the split point will be divided appropriately,
+ * with offsets adjusted for each resulting part.
+ *
+ * @param {AnnotatedText} text_with_annotations - Annotated text object
+ * @param {number} at_position - Character position where to split (0-based)
+ * @returns {[AnnotatedText, AnnotatedText]} Tuple of [left_part, right_part]
+ *
+ * @example
+ * split_annotated_text({text: "Hello world", annotations: [{start_offset: 6, end_offset: 11, node_id: "strong"}]}, 8)
+ * // Returns:
+ * // [
+ * //   {text: "Hello wo", annotations: [{start_offset: 6, end_offset: 8, node_id: "strong"}]},
+ * //   {text: "rld", annotations: [{start_offset: 0, end_offset: 3, node_id: "strong"}]}
+ * // ]
+ */
+export function split_annotated_text(text_with_annotations, at_position) {
+	const { text, annotations } = text_with_annotations;
+
+	// Split the text using character-aware slicing
+	const left_text = char_slice(text, 0, at_position);
+	const right_text = char_slice(text, at_position);
+
+	/** @type {Array<Annotation>} */
+	const left_annotations = [];
+	/** @type {Array<Annotation>} */
+	const right_annotations = [];
+
+	// Process each annotation
+	for (const { start_offset, end_offset, node_id } of annotations) {
+		if (end_offset <= at_position) {
+			// Annotation is entirely in the left part
+			left_annotations.push({ start_offset, end_offset, node_id });
+		} else if (start_offset >= at_position) {
+			// Annotation is entirely in the right part - shift offsets
+			right_annotations.push({
+				start_offset: start_offset - at_position,
+				end_offset: end_offset - at_position,
+				node_id
+			});
+		} else {
+			// Annotation spans the split point - split it
+			left_annotations.push({ start_offset, end_offset: at_position, node_id });
+			right_annotations.push({ start_offset: 0, end_offset: end_offset - at_position, node_id });
+		}
+	}
+
+	return [
+		{ text: left_text, annotations: left_annotations },
+		{ text: right_text, annotations: right_annotations }
+	];
+}
+
+/**
+ * Joins two annotated texts into a single annotated text.
+ *
+ * Annotations from the second text will have their offsets shifted by the length
+ * of the first text. Adjacent annotations of the same type and data will be merged.
+ *
+ * @param {AnnotatedText} first_text - First annotated text object
+ * @param {AnnotatedText} second_text - Second annotated text object
+ * @returns {AnnotatedText} Combined annotated text object
+ *
+ * @example
+ * join_annotated_text({text: "Hello wo", annotations: [{start_offset: 6, end_offset: 8, node_id: "strong"}]}, {text: "rld", annotations: [{start_offset: 0, end_offset: 3, node_id: "strong"}]})
+ * // Returns: {text: "Hello world", annotations: [{start_offset: 6, end_offset: 11, node_id: "strong"}]}
+ */
+export function join_annotated_text(first_text, second_text) {
+	const { text: first_text_content, annotations: first_annotations } = first_text;
+	const { text: second_text_content, annotations: second_annotations } = second_text;
+
+	// Join the text content
+	const joined_text = first_text_content + second_text_content;
+
+	// Start with all annotations from the first text (unchanged)
+	/** @type {Array<Annotation>} */
+	const joined_annotations = [...first_annotations];
+
+	// Add annotations from the second text, shifting their offsets
+	const offset = get_char_length(first_text_content);
+	for (const { start_offset, end_offset, node_id } of second_annotations) {
+		/** @type {Annotation} */
+		const shifted_annotation = {
+			start_offset: start_offset + offset,
+			end_offset: end_offset + offset,
+			node_id
+		};
+
+		// Check if this annotation can be merged with the last annotation from first text
+		const last_annotation = joined_annotations[joined_annotations.length - 1];
+		if (
+			last_annotation &&
+			last_annotation.end_offset === shifted_annotation.start_offset && // annotations are adjacent
+			last_annotation.node_id === shifted_annotation.node_id
+		) {
+			// same node_id
+			// Merge by extending the end position of the last annotation
+			last_annotation.end_offset = shifted_annotation.end_offset;
+		} else {
+			// Add as separate annotation
+			joined_annotations.push(shifted_annotation);
+		}
+	}
+
+	return { text: joined_text, annotations: joined_annotations };
+}
+
+/**
+ * Convert snake_case string to PascalCase
+ *
+ * @param {string} str - The snake_case string to convert
+ * @returns {string} The converted PascalCase string
+ *
+ * @example
+ * snake_to_pascal('list_item') // Returns: 'ListItem'
+ */
+export function snake_to_pascal(str) {
+	return str
+		.split('_')
+		.map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+		.join('');
+}
+
+export function traverse(node_id, schema, nodes) {
+	const json = [];
+	const visited = {};
+	const visit = (node) => {
+		if (!node || visited[node.id]) {
+			return;
+		}
+		visited[node.id] = true;
+		for (const [property_name, value] of Object.entries(node)) {
+			const property_definition = schema[node.type].properties[property_name];
+
+			if (property_definition?.type === 'node_array') {
+				for (const v of value) {
+					if (typeof v === 'string') {
+						visit(nodes[v]);
+					}
+				}
+			} else if (property_definition?.type === 'node') {
+				visit(nodes[value]);
+			} else if (property_definition?.type === 'annotated_text') {
+				for (const annotation of value.annotations) {
+					visit(nodes[annotation.node_id]);
+				}
+			}
+		}
+		// Finally add the node to the result.
+		// Deep clone, to make sure nothing of the original document is referenced.
+		json.push(structuredClone(node));
+	};
+	// Start with the root node (document_id)
+	visit(nodes[node_id]);
+	return json;
+}
+
+/**
+ * Extracts the normalized range from a text or node selection.
+ * Returns start and end offsets in document order (start <= end), regardless of selection direction.
+ * @param {Selection} [selection] - The selection to extract the range from
+ * @returns {SelectionRange | null} The normalized selection range, or null if selection is null, undefined, or a property selection
+ */
+export function get_selection_range(selection) {
+	if (selection && selection.type !== 'property') {
+		return {
+			start_offset: Math.min(selection.anchor_offset, selection.focus_offset),
+			end_offset: Math.max(selection.anchor_offset, selection.focus_offset)
+		};
+	} else {
+		return null;
+	}
+}
+
+export function is_selection_collapsed(selection) {
+	if (selection && selection.type !== 'property') {
+		return selection.anchor_offset === selection.focus_offset;
+	} else {
+		return false;
+	}
+}

package/dist/Document.svelte.d.ts

@@ -1,214 +0,0 @@
-/**
- * @import {
- *   NodeId,
- *   DocumentPath,
- *   Selection,
- *   Annotation,
- *   PrimitiveType,
- *   DocumentSchemaPrimitive,
- *   NodeProperty,
- *   NodeArrayProperty,
- *   NodeKind,
- *   NodeSchema,
- *   TextNodeSchema,
- *   NonTextNodeSchema,
- *   DocumentSchema,
- *   SerializedDocument
- * } from './types.d.ts';
- */
-/**
- * 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 {
-    /**
-     * @param {DocumentSchema} schema - The document schema
-     * @param {SerializedDocument} serialized_doc - The serialized document array
-     * @param {object} [options] - Optional configuration
-     * @param {Selection} [options.selection] - Initial selection state
-     * @param {any} [options.config] - Document configuration
-     */
-    constructor(schema: DocumentSchema, serialized_doc: SerializedDocument, { selection, config }?: {
-        selection?: Selection;
-        config?: any;
-    });
-    config: any;
-    document_id: any;
-    nodes: any;
-    history: any[];
-    history_index: number;
-    can_undo: boolean;
-    can_redo: boolean;
-    selected_node: any;
-    layout_node: any;
-    available_annotation_types: any;
-    /**
-     * Sets the selection with validation
-     * @param {Selection | undefined} value - The new selection
-     * @throws {Error} Throws if the selection is invalid
-     */
-    set selection(value: Selection | undefined);
-    /**
-     * Gets the current selection
-     * @returns {Selection | undefined}
-     */
-    get selection(): Selection | undefined;
-    /**
-     * Validates that a selection is within bounds and refers to valid paths.
-     *
-     * @param {Selection} selection - The selection to validate
-     * @throws {Error} Throws if the selection is invalid
-     * @private
-     */
-    private _validate_selection;
-    schema: DocumentSchema;
-    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
-     */
-    validate_node(node: any): void;
-    /**
-     * Creates a new transaction for making atomic changes to the document.
-     *
-     * @returns {Transaction} A new transaction instance
-     */
-    get tr(): Transaction;
-    /**
-     * Applies a transaction to the document.
-     *
-     * @param {Transaction} transaction - The transaction to apply
-     */
-    apply(transaction: Transaction): this;
-    undo(): this;
-    redo(): this;
-    /**
-     * Gets a node instance or property value at the specified path.
-     * @param {DocumentPath|string} path - Path to the node or property
-     * @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', ... }
-     *
-     * @example
-     * // Get a node array property
-     * doc.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', ... }
-     *
-     * @example
-     * // Get an annotated text property
-     * doc.get(['page_1', 'cover', 'title']) // => {text: 'Hello world', annotations: []}
-     */
-    get(path: DocumentPath | string): any;
-    /**
-     * While .get gives you the value of a path, inspect gives you
-     * the type info of that value.
-     *
-     * @todo The layout of these should be improved and more explictly typed
-     *
-     * @example
-     * doc.inspect(['page_1', 'body']) => {
-     *   kind: 'property',
-     *   name: 'body',
-     *   type: 'node_array',
-     *   node_types: ['text', 'story', 'list'],
-     *   default_node_type: 'text'
-     * }
-     *
-     * @example
-     * doc.inspect(['page_1', 'body', 1]) => {
-     *   kind: 'node',
-     *   id: 'paragraph_234',
-     *   type: 'paragraph',
-     *   properties: {...}
-     * }
-     *
-     * @param {DocumentPath} path
-     * @returns {{kind: 'property'|'node', [key: string]: any}}
-     */
-    inspect(path: DocumentPath): {
-        kind: "property" | "node";
-        [key: string]: any;
-    };
-    /**
-     * Determines the kind of a node ('block' for structured blocks, 'text' for pure
-     * text nodes or 'annotation' for annotation nodes.
-     * @param {any} node
-     * @returns {NodeKind}
-     */
-    kind(node: any): NodeKind;
-    /**
-     * 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
-     * @returns {Annotation|null}
-     */
-    active_annotation(annotation_type: string): Annotation | null;
-    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
-     */
-    to_json(): SerializedDocument;
-    property_type(type: any, property: any): "string" | "number" | "boolean" | "node" | "node_array" | "annotated_text" | "integer" | "datetime" | "string_array" | "number_array" | "boolean_array" | "integer_array";
-    count_references(node_id: any): number;
-    /**
-     * @param {NodeId} node_id
-     * @returns {NodeId[]}
-     */
-    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';
-import type { DocumentSchema } 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 { NodeId } from './types.d.ts';
-//# sourceMappingURL=Document.svelte.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Document.svelte.d.ts","sourceRoot":"","sources":["../src/lib/Document.svelte.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;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,CAQjC;AAED;;;;GAIG;AACH,2DAHW,YAAY,GAAG,iBAAiB,GAC9B,MAAM,GAAG,IAAI,CASzB;AAED;;;;GAIG;AACH,0DAHW,cAAc,QAexB;AAuGD;IAgGE;;;;;;OAMG;IACH,oBANW,cAAc,kBACd,kBAAkB,0BAE1B;QAA4B,SAAS,GAA7B,SAAS;QACK,MAAM,GAApB,GAAG;KACb,EAqBA;IAxHD,YAAkB;IAClB,iBAAuB;IACvB,WAAiB;IACjB,eAAqB;IACrB,sBAA2B;IAG3B,kBAA6C;IAC7C,kBAAkE;IAGnE,mBAAmD;IACnD,iBAA+C;IAC/C,gCAA6E;IAU5E;;;;OAIG;IACH,qBAHW,SAAS,GAAG,SAAS,EAQ/B;IAlBD;;;OAGG;IACH,iBAFa,SAAS,GAAG,SAAS,CAIjC;IAcD;;;;;;OAMG;IACH,4BAiDC;IAaC,uBAAoB;IAkBtB,mBAMC;IAED,sCAKA;IAGD,yBAkBC;IAID,uBAoBC;IAGA,yBAWC;IAED;;;;OAIG;IACH,oBAHW,GAAG,QAKb;IAED;;;;OAIG;IACH,UAFa,WAAW,CASvB;IAED;;;;OAIG;IACH,mBAFW,WAAW,QAkBrB;IAED,aAWC;IAED,aAaC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,UAlBW,YAAY,GAAC,MAAM,GACjB,GAAG,CAoFf;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,cAHW,YAAY,GACV;QAAC,IAAI,EAAE,UAAU,GAAC,MAAM,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,CAuBzD;IAED;;;;;OAKG;IACH,WAHW,GAAG,GACD,QAAQ,CAIpB;IAED;;;;;;OAMG;IACH,mCAHW,MAAM,GACJ,UAAU,GAAC,IAAI,CAqB3B;IAGD,kCAOC;IAED,0BAOC;IAED,sBAmCC;IAED;;;;MAaC;IAKD,8BAgCC;IAED;;;OAGG;IACH,WAFa,kBAAkB,CAI9B;IAID,mNAWC;IAGD,uCAkBC;IAGD;;;OAGG;IACH,8BAHW,MAAM,GACJ,MAAM,EAAE,CASpB;;CACF;gCAxwBS,cAAc;mCAAd,cAAc;kCAAd,cAAc;uCAAd,cAAc;oCAAd,cAAc;+BAAd,cAAc;wBAnBA,yBAAyB;kCAmBvC,cAAc;8BAAd,cAAc;gCAAd,cAAc;wCAAd,cAAc;4BAAd,cAAc"}