edytor 1.0.0-rc.2 → 1.0.0

package/dist/block/block.utils.js

@@ -1,356 +0,0 @@
-import { id } from '../utils.js';
-import { cloneJson, jsonBlockToSpec, jsonContentToItems } from '../utils/json.js';
-import { InlineBlock } from './inlineBlock.svelte.js';
-/**
- * Bind an operation onto its wrapper: every call is dispatched as a command
- * (`session/commands.ts`): admission, hooks before any write (on the command
- * and, when `prepare` answers one document plan, on each planned step), one
- * transaction, normalization, the result. `func` receives the prepared plan
- * and answers the op's document result; `resolve` turns it into wrappers
- * after the commit patched them.
- */
-export function batch(operation, func, prepare, resolve) {
-    return function (...[payload]) {
-        const out = this.edytor.dispatcher.dispatch(operation, payload, { block: this }, (p, plan) => func.call(this, p, plan), prepare && ((p) => prepare.call(this, p)));
-        const value = resolve ? resolve.call(this, out, payload) : out;
-        return this.edytor.dispatcher.answer(value);
-    };
-}
-/**
- * The handle of block `id` (null: refused at preparation, or gone; undefined:
- * the command did not run). Inside an outer transaction too: the index shows
- * the block that transaction created.
- */
-export function blockOf(id) {
-    return id === undefined ? undefined : (id && this.edytor.idToBlock.get(id)) || null;
-}
-const REFUSED = { status: 'refused', ids: [] };
-/**
- * An op's body over its prepared plan: write it and request normalization of
- * the blocks it touched (captured before the write). Answers the applied
- * plan, or null when it was refused.
- */
-const applyPlan = (block, plan, touched) => {
-    if (!('writes' in plan))
-        return null;
-    block.edytor.facade.apply(plan);
-    for (const parent of touched)
-        parent?.normalizeChildren();
-    return plan;
-};
-/** The document's name for `block`'s child list: `null` for the root. */
-const ref = (block) => (block.isRoot ? null : block.id);
-/**
- * Dispatch `operation` on `block` as the one plan `prepare` answers (a
- * composed command: hooks see it and each planned step, one transaction).
- * `then` runs in that transaction once the plan applied, with the payload
- * hooks left. Answers the applied plan, or null when refused.
- */
-export const dispatchPlan = (block, operation, payload, prepare, touched = [block.parent], then) => block.edytor.dispatcher.dispatch(operation, payload, { block }, (p, plan = prepare(p)) => {
-    const applied = applyPlan(block, plan, touched);
-    if (applied)
-        then?.(p);
-    return applied;
-}, prepare) ?? null;
-/** One child at `index` (a default-kind block without `block`); see {@link addChildBlocks}. */
-export function addChildBlock({ block, index }) {
-    const blocks = [block || { type: this.edytor.defaultChild(this) }];
-    return addChildBlocks.call(this, { blocks, index })[0];
-}
-/** Children at `index`, clamped to the child list (at its end by default); ids kept or minted. */
-export function addChildBlocks({ blocks, index = this.children.length }) {
-    index = Math.max(0, Math.min(index, this.children.length));
-    const specs = blocks.map((block) => ({ ...block, id: block.id ?? id('b') }));
-    this.insertChildren(index, specs);
-    this.normalizeChildren();
-    return specs.map((spec) => this.edytor.idToBlock.block(spec.id));
-}
-/** Insert `block` as a sibling of `this`, `after` it or before it. */
-const prepareSibling = (self, block, after) => self.parent
-    ? self.edytor.facade.prepare.insertBlocks({ parent: ref(self.parent), index: self.index + (after ? 1 : 0) }, [jsonBlockToSpec(block)])
-    : REFUSED;
-export function prepareInsertAfter({ block }) {
-    return prepareSibling(this, block, true);
-}
-export function prepareInsertBefore({ block }) {
-    return prepareSibling(this, block, false);
-}
-/** Apply `plan` under `this`'s parent; the id it answers first (inserted or surviving). */
-function resultOf(plan) {
-    return applyPlan(this, plan, [this.parent])?.ids[0] ?? null;
-}
-export function insertBlockAfter(payload, plan = prepareInsertAfter.call(this, payload)) {
-    return resultOf.call(this, plan);
-}
-export function insertBlockBefore(payload, plan = prepareInsertBefore.call(this, payload)) {
-    return resultOf.call(this, plan);
-}
-export function prepareDuplicate() {
-    if (!this.parent || !this.isInTree)
-        return REFUSED;
-    return this.edytor.facade.prepare.duplicateBlock(this.id, (_, kind) => id(kind === 'block' ? 'b' : 'i'));
-}
-export function duplicateBlock(_ = {}, plan = prepareDuplicate.call(this)) {
-    return resultOf.call(this, plan);
-}
-export function prepareSplit({ index, text }) {
-    if (!text || !this.parent || !this.model)
-        return REFUSED;
-    // The sibling takes its parent's default child type and no data — a
-    // list-like kind (`continues`) keeps its own, with its first preset's data.
-    const { continues, presets } = this.definition;
-    const tail = continues
-        ? { type: this.type, data: { ...(presets?.[0]?.data ?? {}) } }
-        : { type: this.edytor.defaultChild(this.parent), data: {} };
-    const offset = text.segStart + index;
-    return this.edytor.facade.prepare.splitBlock(this.model.id, offset, id('b'), tail);
-}
-/**
- * A split whose children stay with the block (a container's header): the
- * tail, of `tail`'s kind, becomes the block's first child (`child`) or its
- * next sibling. One plan: the document's split step, placed here, without
- * the move that gives the tail the children.
- */
-export function prepareSplitKeepingChildren({ index, text }, tail, child) {
-    if (!text || !this.parent || !this.model)
-        return REFUSED;
-    const { facade } = this.edytor;
-    const born = id('b');
-    const split = facade.prepare.splitBlock(this.model.id, text.segStart + index, born, tail);
-    const step = 'writes' in split ? split.writes[0] : undefined;
-    if (step?.op !== 'splitBlock')
-        return REFUSED;
-    if (!child)
-        return facade.compose({ ...split, writes: [step] });
-    // The rank of a first child, and the document's answer on placing the kind there.
-    const slot = facade.prepare.insertBlocks({ parent: this.model.id, index: 0 }, [
-        { id: born, type: tail.type }
-    ]);
-    const first = 'writes' in slot ? slot.writes[0] : undefined;
-    if (first?.op !== 'insertBlocks')
-        return REFUSED;
-    const placed = { ...step, parent: this.model.id, rank: first.ranks[0] };
-    return facade.compose({ ...split, writes: [placed] });
-}
-export function splitBlock(payload, plan = prepareSplit.call(this, payload)) {
-    return applyPlan(this, plan, [this.parent])?.effect.creates[0] ?? null;
-}
-export function prepareRemove({ keepChildren = true } = {}) {
-    if (!this.parent || !this.model || !this.isInTree)
-        return REFUSED;
-    return this.edytor.facade.prepare.deleteBlock(this.model.id, { keepChildren });
-}
-export function removeBlock(payload = {}, plan = prepareRemove.call(this, payload)) {
-    applyPlan(this, plan, [this.parent]);
-}
-export function prepareMergeBackward() {
-    return this.parent && this.model
-        ? this.edytor.facade.prepare.mergeBackward(this.model.id)
-        : REFUSED;
-}
-export function prepareMergeForward() {
-    return this.parent && this.model
-        ? this.edytor.facade.prepare.mergeForward(this.model.id)
-        : REFUSED;
-}
-export function mergeBlockBackward(_ = {}, plan = prepareMergeBackward.call(this)) {
-    return resultOf.call(this, plan);
-}
-export function mergeBlockForward(_ = {}, plan = prepareMergeForward.call(this)) {
-    return resultOf.call(this, plan);
-}
-/** The destination parent a view-tree path (`[...parentPath, index]`) names. */
-const parentAt = (edytor, path) => {
-    let parent = edytor.root;
-    for (const index of path.slice(0, -1))
-        parent = parent?.children[index];
-    return [parent, path.at(-1)];
-};
-export function prepareMove({ path }) {
-    // Admission: the caller path is a view-tree address — validate its shape
-    // and resolve it to the destination PARENT block + index. Structural
-    // permission is the document's (`canPlace`: island seals, void/island
-    // destinations, moves into the block's own subtree).
-    if (!path.length || path.some((p) => isNaN(p) || p < 0) || !this.parent)
-        return REFUSED;
-    const [parent, index] = parentAt(this.edytor, path);
-    if (!parent || !this.model)
-        return REFUSED;
-    return this.edytor.facade.prepare.moveBlock(this.model.id, { parent: ref(parent), index });
-}
-export function moveBlock(payload, plan = prepareMove.call(this, payload)) {
-    return applyPlan(this, plan, [this.parent, parentAt(this.edytor, payload.path)[0]]) ? this : null;
-}
-/**
- * Grouped move — the operation-layer counterpart of `moveBlock` for
- * drags/multi-moves. `path` is the same view-tree address shape:
- * the prefix resolves the destination PARENT block, the last element is
- * the FINAL index — already discounted for the moved members by the
- * caller (the `facade.moveBlocks` contract, which counts the
- * destination's children with the moved members excluded). Structural
- * permission stays in the facade.
- */
-export function prepareMoves({ blocks, path }) {
-    if (!path.length || path.some((p) => isNaN(p) || p < 0) || !blocks.length)
-        return REFUSED;
-    const [parent, index] = parentAt(this.edytor, path);
-    if (!parent || blocks.some((block) => block.isRoot))
-        return REFUSED;
-    return this.edytor.facade.prepare.moveBlocks(blocks.map((block) => block.id), { parent: ref(parent), index });
-}
-export function moveBlocks(payload, plan = prepareMoves.call(this, payload)) {
-    const { blocks, path } = payload;
-    const parents = new Set([...blocks.map((block) => block.parent), parentAt(this.edytor, path)[0]]);
-    return applyPlan(this, plan, [...parents]) ? blocks : [];
-}
-/**
- * The facade owns the refusal rules (`unNestBlock`: top-level blocks,
- * island-sealed blocks and sealed destinations).
- */
-export function prepareUnNest() {
-    return this.parent && this.model
-        ? this.edytor.facade.prepare.unNestBlock(this.model.id)
-        : REFUSED;
-}
-export function unNestBlock(_ = {}, plan = prepareUnNest.call(this)) {
-    return applyPlan(this, plan, [this.parent, this.parent?.parent, this]) ? this : null;
-}
-/**
- * Admission resolves the nest target — the previous sibling — and the
- * facade owns permission: `nestBlock` refuses void/island/inside-island
- * targets and island-sealed sources (`canPlace`).
- */
-export function prepareNest() {
-    const target = this.previousBlock?.id;
-    return this.parent && this.model && target != null
-        ? this.edytor.facade.prepare.nestBlock(this.model.id, target)
-        : REFUSED;
-}
-export function nestBlock(_ = {}, plan = prepareNest.call(this)) {
-    return applyPlan(this, plan, [this.parent, this.previousBlock]) ? this : null;
-}
-export function prepareSet({ value }) {
-    if (!this.model)
-        return REFUSED;
-    // Spec preparation is pure JSON → `ContentItem`/`BlockSpec` conversion:
-    // the document stores the items verbatim and derives the content
-    // invariant on projection.
-    return this.edytor.facade.prepare.setBlock(this.model.id, {
-        ...(value.type !== undefined ? { type: value.type } : {}),
-        ...(value.data !== undefined ? { data: cloneJson(value.data) } : {}),
-        ...(value.content !== undefined ? { content: jsonContentToItems(value.content) } : {}),
-        ...(value.children !== undefined
-            ? { children: value.children.map((child) => jsonBlockToSpec(child)) }
-            : {})
-    });
-}
-export function setBlock(payload, plan = prepareSet.call(this, payload)) {
-    if (!applyPlan(this, plan, [this]))
-        return;
-    this.normalizeContent();
-}
-export function pushContentIntoBlock({ value }) {
-    const model = this.model;
-    if (!model)
-        return;
-    for (const part of value) {
-        if (part instanceof InlineBlock) {
-            const { id, type, data } = part;
-            model.insertInline(model.length, { id, type, ...(data ? { data: cloneJson(data) } : {}) });
-        }
-        else {
-            for (const { text, marks } of part.value)
-                if (text.length)
-                    model.insertText(model.length, text, marks);
-        }
-    }
-    this.normalizeContent();
-}
-export function prepareRemoveInline({ index }) {
-    const part = this.content.at(index);
-    return part instanceof InlineBlock && this.model
-        ? this.edytor.facade.prepare.removeInline(this.model.id, part.id)
-        : REFUSED;
-}
-export function removeInlineBlock(payload, plan = prepareRemoveInline.call(this, payload)) {
-    if (applyPlan(this, plan, []))
-        this.normalizeContent();
-}
-export function preparePatch({ ops, atom }) {
-    const target = this.isRoot ? null : atom === undefined ? this.id : { block: this.id, atom };
-    return this.edytor.facade.prepare.patchData(target, ops);
-}
-export function patchData(payload, plan = preparePatch.call(this, payload)) {
-    applyPlan(this, plan, []);
-}
-/**
- * Insert an inline atom at `index` of `text`. Answers the atom's id; the
- * batched operation resolves it to the text after the atom once committed
- * ({@link textAfterAtom}), where the caret's pending marks follow.
- */
-export function addInlineBlock({ index, block, text }) {
-    const atom = { ...block, id: block.id ?? id('i') };
-    this.model?.insertInline(text.segStart + index, {
-        id: atom.id,
-        type: atom.type,
-        ...(atom.data ? { data: cloneJson(atom.data) } : {})
-    });
-    this.normalizeContent();
-    return atom.id;
-}
-/** The text after atom `atom` of this block; the caret's pending marks follow it there. */
-export function textAfterAtom(atom) {
-    if (atom === undefined)
-        return undefined;
-    const at = this.content.findIndex((part) => part.id === atom);
-    const after = at < 0 ? undefined : this.content[at + 1];
-    if (!after || after instanceof InlineBlock)
-        return null;
-    const { selection } = this.edytor;
-    const pending = selection.pending;
-    const caret = pending && selection.textValue(after, 0);
-    if (caret && caret.kind === 'text')
-        selection.select(Object.freeze({ ...caret, pending }));
-    return after;
-}
-/**
- * Normalization runs at the end of the command's transaction
- * (`Dispatcher.drain`): a normalizer reads handles over the index; when a
- * plugin hook answers work, the work runs in the same transaction and the
- * block is requested again (bounded by the dispatcher's pass limit).
- */
-export function normalizeContent() {
-    if (this.edytor.dispatcher.defer(this, normalizeContent))
-        return;
-    // The v14 content model maintains the part invariants by construction —
-    // projected content always derives to text-first/text-last/non-adjacent
-    // parts — so the only remaining normalization is the plugin hook.
-    const work = this.definition?.normalizeContent?.({ block: this });
-    if (work) {
-        this.edytor.dispatcher.write(work);
-        this.normalizeContent();
-    }
-}
-export function normalizeChildren() {
-    if (this.edytor.dispatcher.defer(this, normalizeChildren))
-        return;
-    // An emptied root writes nothing: the view shows its virtual paragraph (`doc.empty.virtual`).
-    const work = this.definition?.normalizeChildren?.({ block: this });
-    if (work) {
-        this.edytor.dispatcher.write(work);
-        this.normalizeChildren();
-    }
-}
-export function prepareDeleteRange({ start: [startIndex, startOffset], end: [endIndex, endOffset] }) {
-    const parts = this.edytor.idToBlock.parts(this.id);
-    const [startPart, endPart] = [parts.at(startIndex), parts.at(endIndex)];
-    if (!startPart || !endPart || !this.model)
-        return REFUSED;
-    const at = startPart.start + startOffset;
-    const length = Math.max(0, endPart.start + endOffset - at);
-    return this.edytor.facade.prepare.deleteText(this.model.id, at, length);
-}
-export function deleteContentAtRange(payload, plan = prepareDeleteRange.call(this, payload)) {
-    if (applyPlan(this, plan, []))
-        this.normalizeContent();
-}