edytor 1.0.0-rc.2 → 1.0.0

package/dist/session/props.js

@@ -1,162 +0,0 @@
-/**
- * Properties: the deep proxy behind `block.data`, `atom.data` and
- * `edytor.data` (syncrostate's feel, one small module).
- *
- * A read goes to `read()` every time (the view's live, reactive source), so
- * a template that reads `block.data.title` re-renders when anyone changes
- * it. Plain objects read as nested proxies, arrays as array proxies,
- * everything else as the raw value; a proxy is cached per path, so its
- * identity is stable. An object or array held in an array item is that
- * item's (its path names the item by id, from `ids`): it stays on its item
- * wherever peers move it, so `{#each list as item (item)}` keeps a row, and
- * the focused field in it, on its item; once the item is removed, or its
- * array is, its writes are refused. A key is a path segment as
- * `keySegment` writes it (`~abc` as `~0abc`: never an item's id). A write
- * is one data patch through `write` (a
- * command): `obj.key = v`, `arr[i] = v` (by index) and `delete obj.key`
- * patch that path (a write inside an item, that item);
- * `push`, `pop`, `shift`, `unshift`, `splice` and `length` are one
- * `splice`, `sort` and `reverse` one `order` (the items move), `fill` and
- * `copyWithin` writes of the items they change.
- * `JSON.stringify` and `$state.snapshot` read plain JSON through it.
- */
-import { keySegment, segmentKey } from '../crdt/data.js';
-const isObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
-/** A plain JSON copy (proxies included), or `undefined`. */
-const plain = (v) => (v === undefined ? v : JSON.parse(JSON.stringify(v)));
-/** The items of `now` that differ from `was`, as writes of those items. */
-const changed = (_, __, was, now) => now.flatMap((value, i) => JSON.stringify(value) === JSON.stringify(was[i]) ? [] : [{ at: `${i}`, value }]);
-/**
- * Each array mutator as the patches of the array (or of its items `at`),
- * from its length `n`, the call's `args`, the array `was` and the result `out`.
- */
-const MUTATORS = {
-    push: (n, args) => ({ splice: [n, 0, ...args] }),
-    pop: (n) => ({ splice: [Math.max(n - 1, 0), n && 1] }),
-    shift: () => ({ splice: [0, 1] }),
-    unshift: (_, args) => ({ splice: [0, 0, ...args] }),
-    // The start and count `splice` resolved (negative, fractional, past the end).
-    splice: (n, [start, , ...items], _, out) => {
-        const s = Math.trunc(Number(start)) || 0;
-        return { splice: [s < 0 ? Math.max(n + s, 0) : Math.min(s, n), out.length, ...items] };
-    },
-    sort: (n, [compare], was) => ({ order: sorted(n, was, compare) }),
-    reverse: (n) => ({ order: Array.from({ length: n }, (_, i) => n - 1 - i) }),
-    fill: changed,
-    copyWithin: changed
-};
-/** The indexes `Array.prototype.sort` puts `values` in (stable, `undefined` compare: by string). */
-const sorted = (n, values, compare) => {
-    const by = typeof compare === 'function'
-        ? compare
-        : (a, b) => (`${a}` < `${b}` ? -1 : `${a}` > `${b}` ? 1 : 0);
-    return Array.from({ length: n }, (_, i) => i).sort((a, b) => by(values[a], values[b]));
-};
-export const propsProxy = (read, write, 
-/** The ids of the items of the array at a path (`facade.dataItemIds`). */
-ids = () => []) => {
-    const cache = new Map();
-    // Item ids per array path, for the value `read()` last gave.
-    let seen;
-    const known = new Map();
-    const idsOf = (path) => {
-        const now = read();
-        if (now !== seen) {
-            seen = now;
-            known.clear();
-        }
-        const key = JSON.stringify(path);
-        return known.get(key) ?? known.set(key, ids(path)).get(key);
-    };
-    const at = (path) => path.reduce((v, k, n) => /^~[a-z]/.test(k)
-        ? Array.isArray(v)
-            ? v[idsOf(path.slice(0, n)).indexOf(k)]
-            : undefined // its array is gone
-        : v !== null && typeof v === 'object'
-            ? v[segmentKey(k)]
-            : undefined, read());
-    const put = (path, value) => write([{ path, ...(value !== undefined && { value: plain(value) }) }]);
-    const wrap = (path, v) => Array.isArray(v) || isObject(v) ? proxy(path, Array.isArray(v)) : v;
-    const proxy = (path, array) => {
-        const key = `${array ? '[' : '{'}${JSON.stringify(path)}`;
-        const cached = cache.get(key);
-        if (cached)
-            return cached;
-        const current = () => {
-            const v = at(path);
-            return array ? (Array.isArray(v) ? v : []) : isObject(v) ? v : {};
-        };
-        /** The path of child `k`: an item by its id, a key as its segment. */
-        const child = (k) => [...path, (array && idsOf(path)[Number(k)]) || keySegment(k)];
-        const items = () => current().map((v, i) => wrap(child(`${i}`), v));
-        const own = (k) => Object.prototype.hasOwnProperty.call(current(), k);
-        const made = new Proxy(array ? [] : {}, {
-            get(target, k) {
-                if (typeof k === 'symbol')
-                    return array && k === Symbol.iterator
-                        ? () => items()[Symbol.iterator]()
-                        : Reflect.get(target, k);
-                if (array && k === 'length')
-                    return current().length;
-                if (own(k))
-                    return wrap(child(k), current()[k]);
-                if (array && Object.hasOwn(MUTATORS, k))
-                    return (...args) => {
-                        const was = plain(current());
-                        const next = [...was];
-                        const fn = Array.prototype[k];
-                        args = args.map((a) => (a !== null && typeof a === 'object' ? plain(a) : a));
-                        const out = fn.apply(next, args);
-                        const ops = [MUTATORS[k](was.length, args, was, out)].flat();
-                        write(ops.map(({ at, ...op }) => ({ ...op, path: at ? [...path, at] : path })));
-                        return out === next ? made : out;
-                    };
-                const method = array ? Array.prototype[k] : undefined;
-                if (typeof method === 'function')
-                    return (...args) => method.apply(items(), args);
-                return Reflect.get(target, k);
-            },
-            set(_, k, value) {
-                if (typeof k === 'symbol')
-                    return false;
-                if (array && k === 'length') {
-                    const n = current().length;
-                    const nulls = Array.from({ length: Math.max(value - n, 0) }, () => null);
-                    write([{ path, splice: [Math.min(value, n), Math.max(n - value, 0), ...nulls] }]);
-                }
-                else
-                    put([...path, keySegment(k)], value);
-                return true;
-            },
-            deleteProperty(_, k) {
-                if (typeof k === 'symbol')
-                    return false;
-                if (own(k))
-                    put([...path, keySegment(k)], undefined);
-                return true;
-            },
-            has: (target, k) => (typeof k === 'string' && own(k)) || Reflect.has(target, k),
-            ownKeys: () => [...Object.keys(current()), ...(array ? ['length'] : [])],
-            getOwnPropertyDescriptor(target, k) {
-                if (array && k === 'length')
-                    return (Reflect.getOwnPropertyDescriptor(target, k) && {
-                        value: current().length,
-                        writable: true,
-                        enumerable: false,
-                        configurable: false
-                    });
-                if (typeof k !== 'string' || !own(k))
-                    return undefined;
-                return {
-                    value: wrap(child(k), current()[k]),
-                    writable: true,
-                    enumerable: true,
-                    configurable: true
-                };
-            }
-        });
-        cache.set(key, made);
-        return made;
-    };
-    return proxy([], false);
-};

package/dist/text/deltas.d.ts

@@ -1,22 +0,0 @@
-import type { JSONText, SerializableContent } from '../utils/json.ts';
-export type Mark = [string, SerializableContent];
-export type JSONDelta = {
-    text: string;
-    marks: Mark[];
-    id: string;
-};
-export declare const deltaToJson: (delta: JSONDelta[]) => JSONText[];
-/**
- * Convert a text segment's run items into render deltas.
- * `items` are the `{kind:'text'}` entries of one logical text segment (the
- * runs between two inline atoms — or the whole content when no inline is
- * present). Adjacent same-mark items are already merged by the runs view;
- * the guard below keeps the contract total for unmerged item lists
- * (detached spec buffers, `project()` raw items).
- *
- * Returns `[deltas, isEmpty]` mirroring the historical `toDeltas` signature.
- */
-export declare const runsToDeltas: (items: readonly {
-    text: string;
-    marks?: Record<string, unknown>;
-}[]) => readonly [JSONDelta[], boolean];

package/dist/text/deltas.js

@@ -1,46 +0,0 @@
-export const deltaToJson = (delta) => {
-    return delta.map((d) => {
-        const result = {
-            text: d.text,
-            marks: Object.fromEntries(d.marks)
-        };
-        if (d.marks.length === 0) {
-            delete result.marks;
-        }
-        return result;
-    });
-};
-/**
- * Convert a text segment's run items into render deltas.
- * `items` are the `{kind:'text'}` entries of one logical text segment (the
- * runs between two inline atoms — or the whole content when no inline is
- * present). Adjacent same-mark items are already merged by the runs view;
- * the guard below keeps the contract total for unmerged item lists
- * (detached spec buffers, `project()` raw items).
- *
- * Returns `[deltas, isEmpty]` mirroring the historical `toDeltas` signature.
- */
-export const runsToDeltas = (items) => {
-    const result = [];
-    let isEmpty = true;
-    for (const item of items) {
-        if (!item.text)
-            continue;
-        const marks = Object.entries(item.marks ?? {});
-        const last = result[result.length - 1];
-        if (last &&
-            last.marks.length === marks.length &&
-            last.marks.every(([k, v]) => item.marks?.[k] === v)) {
-            last.text += item.text;
-        }
-        else {
-            result.push({
-                text: item.text,
-                marks,
-                id: crypto.randomUUID()
-            });
-        }
-        isEmpty = false;
-    }
-    return [result, isEmpty];
-};

package/dist/text/text.utils.d.ts

@@ -1,45 +0,0 @@
-import type { JSONText, SerializableContent } from '../utils/json.js';
-import type { Text } from './text.svelte.js';
-export type TextOperations = {
-    insertText: {
-        value: string;
-        isAutoDot?: boolean;
-        start?: number;
-        end?: number;
-        marks?: Record<string, SerializableContent | null>;
-    };
-    deleteText: {
-        direction: 'BACKWARD' | 'FORWARD';
-        length: number;
-    };
-    splitText: {
-        index?: number;
-    };
-    setText: {
-        value: JSONText[];
-    };
-    markText: {
-        mark: string;
-        start?: number;
-        end?: number;
-        value?: SerializableContent | null;
-        toggle?: boolean;
-    };
-    removeMarksFromText: {
-        start?: number;
-        end?: number;
-    };
-};
-export declare function batch<T extends (...args: any[]) => any, O extends keyof TextOperations>(operation: O, func: T): T;
-export declare function insertText(this: Text, { value, isAutoDot, start, end, marks }: TextOperations['insertText']): void;
-export declare function getMarksAtRange(this: Text, yStart: number, yEnd: number): JSONText[];
-export declare const getPreviousGraphemeStart: (value: string, offset: number) => number;
-export declare const getNextGraphemeEnd: (value: string, offset: number) => number;
-export declare function deleteText(this: Text, { direction, length }: TextOperations['deleteText']): {
-    start: number;
-    end: number;
-} | undefined;
-export declare function removeMarksFromText(this: Text, { start, end }: TextOperations['removeMarksFromText']): void;
-export declare function markText(this: Text, { mark, value, toggle, start, end }: TextOperations['markText']): void;
-export declare function splitText(this: Text, { index }: TextOperations['splitText']): JSONText[];
-export declare function setText(this: Text, { value }: TextOperations['setText']): void;

package/dist/text/text.utils.js

@@ -1,199 +0,0 @@
-import { marksForInsertion } from '../session/editing/text.js';
-export function batch(operation, func) {
-    return function (payload) {
-        // Dispatched like block operations (`session/commands.ts`): plugins see
-        // `block: this.parent` + `text: this`, the text arm of `ChangePayload`.
-        const out = this.edytor.dispatcher.dispatch(operation, payload, { block: this.parent, text: this }, func);
-        return this.edytor.dispatcher.answer(out);
-    };
-}
-export function insertText({ value, isAutoDot, start = this.edytor.selection.state.yStart, end = this.edytor.selection.state.yEnd, marks }) {
-    const isCollapsed = start === end || !end;
-    // The caret's pending marks apply to an insertion at the caret, which consumes them.
-    const { selection } = this.edytor;
-    const { startText, yStart } = selection.state;
-    const pending = startText === this && yStart === start ? selection.pending : undefined;
-    marks ??= marksForInsertion(this, start, {
-        replaced: isCollapsed ? undefined : this.getMarksAtRange(start, end),
-        pending
-    });
-    this.edytor.transact(() => {
-        if (isAutoDot) {
-            // Replace the previous char with the inserted value (autocorrect).
-            this.deleteAt(start - 1, 1);
-            this.insertAt(start - 1, value, marks);
-        }
-        else if (!isCollapsed) {
-            this.deleteAt(start, end - start);
-            this.insertAt(start, value, marks);
-        }
-        else {
-            this.insertAt(start, value, marks);
-        }
-    });
-    if (pending)
-        selection.stage(undefined);
-}
-export function getMarksAtRange(yStart, yEnd) {
-    const result = [];
-    let offset = 0;
-    let entered = false;
-    // Iterate the MODEL runs (`this.value`), never `this.children` — the
-    // children getter applies the block's `transformText` (e.g. code
-    // tokens), whose marks are local decorations. Reading them here leaked
-    // `codeToken` into persisted marks: typed/composed text inside a code
-    // line inherited the decoration, splitting the serialized content.
-    const parts = this.value;
-    for (let i = 0; i < parts.length; i++) {
-        const { text, marks } = parts[i];
-        const length = text.length;
-        const end = offset + length;
-        if (yStart >= offset && yStart < end) {
-            // Found start of range
-            entered = true;
-            const startOffset = yStart - offset;
-            const endOffset = Math.min(length, yEnd - offset);
-            result.push({
-                text: text.slice(startOffset, endOffset),
-                marks: { ...(marks ?? {}) }
-            });
-        }
-        else if (entered && end <= yEnd) {
-            // Middle of range
-            result.push({
-                text,
-                marks: { ...(marks ?? {}) }
-            });
-        }
-        else if (entered && offset < yEnd && yEnd <= end) {
-            // End of range
-            const endOffset = yEnd - offset;
-            result.push({
-                text: text.slice(0, endOffset),
-                marks: { ...(marks ?? {}) }
-            });
-            break;
-        }
-        offset += length;
-    }
-    return result;
-}
-const getGraphemeBoundaries = (value) => {
-    const Segmenter = Intl.Segmenter;
-    if (Segmenter) {
-        return Array.from(new Segmenter(undefined, { granularity: 'grapheme' }).segment(value)).map(({ index, segment }) => ({
-            start: index,
-            end: index + segment.length
-        }));
-    }
-    let index = 0;
-    return Array.from(value).map((segment) => {
-        const start = index;
-        index += segment.length;
-        return {
-            start,
-            end: index
-        };
-    });
-};
-export const getPreviousGraphemeStart = (value, offset) => {
-    const clampedOffset = Math.min(Math.max(offset, 0), value.length);
-    let previousStart = 0;
-    for (const boundary of getGraphemeBoundaries(value)) {
-        if (boundary.end >= clampedOffset) {
-            return boundary.start < clampedOffset ? boundary.start : previousStart;
-        }
-        previousStart = boundary.start;
-    }
-    return previousStart;
-};
-export const getNextGraphemeEnd = (value, offset) => {
-    const clampedOffset = Math.min(Math.max(offset, 0), value.length);
-    for (const boundary of getGraphemeBoundaries(value)) {
-        if (boundary.end > clampedOffset) {
-            return boundary.end;
-        }
-    }
-    return clampedOffset;
-};
-export function deleteText({ direction, length = 1 }) {
-    const { yStart, isCollapsed } = this.edytor.selection.state;
-    const requestedLength = Math.max(0, length);
-    const textLength = this.length;
-    if (requestedLength === 0 || textLength === 0) {
-        return;
-    }
-    const shouldDeleteSingleGrapheme = isCollapsed && requestedLength === 1;
-    const start = shouldDeleteSingleGrapheme && direction === 'BACKWARD'
-        ? getPreviousGraphemeStart(this.stringContent, yStart)
-        : direction === 'BACKWARD' && isCollapsed
-            ? Math.max(0, yStart - requestedLength)
-            : Math.max(0, yStart);
-    const end = shouldDeleteSingleGrapheme && direction === 'FORWARD'
-        ? getNextGraphemeEnd(this.stringContent, yStart)
-        : direction === 'BACKWARD' && isCollapsed
-            ? Math.min(textLength, yStart)
-            : Math.min(textLength, start + requestedLength);
-    const deleteLength = end - start;
-    if (deleteLength <= 0) {
-        return;
-    }
-    this.deleteAt(start, deleteLength);
-    return { start, end };
-}
-export function removeMarksFromText({ start = this.edytor.selection.state.yStart || 0, end = this.edytor.selection.state.yEnd || this.length }) {
-    // Persisted mark changes delegate to the document: `clearMarks` discovers
-    // every mark name present in the range and unsets them; `segStart` maps
-    // the segment-local range into the block's display offsets.
-    this.parent.model?.clearMarks(this.segStart + start, end - start);
-}
-export function markText({ mark, value = true, toggle = false, start = this.edytor.selection.state.yStart, end = this.edytor.selection.state.yEnd }) {
-    if (start === end) {
-        // A caret stages the full set the next insertion carries (values kept).
-        const { selection } = this.edytor;
-        const { [mark]: current = null, ...rest } = marksForInsertion(this, start, {
-            pending: selection.pending
-        });
-        const next = current !== null && toggle ? null : value;
-        selection.stage(next === null ? rest : { ...rest, [mark]: next });
-        return;
-    }
-    const marksAtRange = this.getMarksAtRange(start, end);
-    const spreadOnAllRange = marksAtRange.length > 0 && marksAtRange.every(({ marks }) => marks && mark in marks);
-    this.formatAt(start, end - start, { [mark]: spreadOnAllRange && toggle ? null : value });
-}
-// This function split a Y.Text at an index, delete what is after the index and returns the deleted content as a JSONText[]
-export function splitText({ index = this.edytor.selection.state.yStart }) {
-    let offset = 0;
-    let content = [];
-    for (const child of this.value) {
-        const textLength = child.text.length;
-        const nextOffset = offset + textLength;
-        if (offset < index) {
-            content.push({
-                text: child.text.slice(index - offset),
-                marks: child.marks
-            });
-        }
-        else {
-            // Text fully after split point
-            content.push({
-                text: child.text,
-                marks: child.marks
-            });
-        }
-        offset = nextOffset;
-    }
-    this.deleteAt(index, this.length - index);
-    return content;
-}
-export function setText({ value }) {
-    this.deleteAt(0, this.length);
-    let offset = 0;
-    for (const part of value) {
-        if (part.text.length) {
-            this.insertAt(offset, part.text, part.marks);
-            offset += part.text.length;
-        }
-    }
-}