@formicoidea/labre-core 0.58.0 → 0.59.0

package/dist/_pkgs/data-view/view-presets/table/pc/table-view-ui-logic.js

@@ -154,10 +154,13 @@ export class TableViewUI extends DataViewUIBase {
                 dataViewLogic: this.logic,
             })
             : ''}
-      <div class="${tableWrapperStyle}" style="${wrapperStyle}">
+      <div
+        class="${tableWrapperStyle} dv-table-wrapper"
+        style="${wrapperStyle}"
+      >
         <div
           ${ref(this.logic.scrollContainer$)}
-          class="${tableScrollContainerStyle}"
+          class="${tableScrollContainerStyle} dv-table-scroll-container"
           @wheel="${this.logic.onWheel}"
         >
           <div

package/dist/_pkgs/std/clipboard/clipboard.d.ts

@@ -1,5 +1,10 @@
-import type { BlockSnapshot, Slice, Store, TransformerMiddleware } from '../../store/index.js';
+import type { BlockSnapshot, InsertedBlockSnapshot, Slice, Store, TransformerMiddleware } from '../../store/index.js';
 import { LifeCycleWatcher } from '../extension/index.js';
+/** What `Clipboard.prepareBlockSnapshot` resolves to. */
+export interface PreparedBlockSnapshotPaste {
+    readonly id: string;
+    insert(doc: Store): InsertedBlockSnapshot | undefined;
+}
 export declare class Clipboard extends LifeCycleWatcher {
     static key: string;
     protected get _adapters(): import("./clipboard-adapter.js").ClipboardAdapterConfig[];
@@ -11,6 +16,15 @@ export declare class Clipboard extends LifeCycleWatcher {
     duplicateSlice: (slice: Slice, doc: Store, parent?: string, index?: number, type?: string) => Promise<void>;
     paste: (event: ClipboardEvent, doc: Store, parent?: string, index?: number) => Promise<Slice | null | undefined>;
     pasteBlockSnapshot: (snapshot: BlockSnapshot, doc: Store, parent?: string, index?: number) => Promise<import("../../store/index.js").BlockModel<object> | undefined>;
+    /**
+     * `pasteBlockSnapshot` in two halves (ADR 0042): the returned promise does
+     * the async work and writes nothing; `insert(doc)` then writes
+     * synchronously, so a caller can run it inside its own transaction, and
+     * `flushAfterImport()` runs the import middlewares once that transaction
+     * has ended. Both halves use one transformer, whose middlewares keep their
+     * state between them.
+     */
+    prepareBlockSnapshot: (snapshot: BlockSnapshot, parent?: string, index?: number) => Promise<PreparedBlockSnapshotPaste | undefined>;
     unuse: (middleware: TransformerMiddleware) => void;
     use: (middleware: TransformerMiddleware) => void;
     get configs(): Map<string, string>;

package/dist/_pkgs/std/clipboard/clipboard.js

@@ -130,6 +130,24 @@ export class Clipboard extends LifeCycleWatcher {
         this.pasteBlockSnapshot = async (snapshot, doc, parent, index) => {
             return this._getJob().snapshotToBlock(snapshot, doc, parent, index);
         };
+        /**
+         * `pasteBlockSnapshot` in two halves (ADR 0042): the returned promise does
+         * the async work and writes nothing; `insert(doc)` then writes
+         * synchronously, so a caller can run it inside its own transaction, and
+         * `flushAfterImport()` runs the import middlewares once that transaction
+         * has ended. Both halves use one transformer, whose middlewares keep their
+         * state between them.
+         */
+        this.prepareBlockSnapshot = async (snapshot, parent, index) => {
+            const job = this._getJob();
+            const prepared = await job.prepareSnapshotToBlock(snapshot, parent, index);
+            if (!prepared)
+                return;
+            return {
+                id: prepared.id,
+                insert: (doc) => job.insertPrepared(prepared, doc),
+            };
+        };
         this.unuse = (middleware) => {
             this._jobMiddlewares = this._jobMiddlewares.filter(m => m !== middleware);
         };

package/dist/_pkgs/std/inline/components/embed-gap.js

@@ -7,5 +7,5 @@ export const EmbedGap = html `<span
     padding: '0 0.5px',
     outline: 'none',
 })}
-  ><v-text></v-text
+  ><v-text empty></v-text
 ></span>`;

package/dist/_pkgs/std/inline/components/v-line.js

@@ -126,7 +126,7 @@ let VLine = (() => {
             if (this.elements.length === 0) {
                 // don't use v-element because it not correspond to the actual delta
                 return html `
-        <div><v-text .str=${ZERO_WIDTH_FOR_EMPTY_LINE}></v-text></div>
+        <div><v-text empty .str=${ZERO_WIDTH_FOR_EMPTY_LINE}></v-text></div>
       `;
             }
             const inlineEditor = this.inlineEditor;

package/dist/_pkgs/std/inline/components/v-text.d.ts

@@ -1,7 +1,19 @@
 import { LitElement } from 'lit';
-export declare class VText extends LitElement {
+declare const VText_base: typeof LitElement;
+export declare class VText extends VText_base {
+    private readonly _std;
+    private _showInvisibles$;
     createRenderRoot(): this;
-    render(): import("lit-html").TemplateResult<1>;
+    connectedCallback(): void;
+    private _segments;
+    render(): import("lit-html").TemplateResult<1> | import("lit-html").TemplateResult<1>[];
+    /**
+     * A placeholder, not text of the model: the zero-width character an empty
+     * line or an embed gap renders so the caret has somewhere to go. Counted as
+     * length 0 by the offsets (`calculateTextLength`), whatever its content —
+     * a zero-width space the USER stored is text and keeps its length.
+     */
+    accessor empty: boolean;
     accessor str: string;
 }
 declare global {
@@ -9,3 +21,4 @@ declare global {
         'v-text': VText;
     }
 }
+export {};

package/dist/_pkgs/std/inline/components/v-text.js

@@ -32,43 +32,175 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { html, LitElement } from 'lit';
+import { SignalWatcher } from '../../../global/lit/index.js';
+import { ContextConsumer } from '@lit/context';
+import { css, html, LitElement, nothing, unsafeCSS } from 'lit';
 import { property } from 'lit/decorators.js';
 import { styleMap } from 'lit/directives/style-map.js';
-import { ZERO_WIDTH_FOR_EMPTY_LINE } from '../consts.js';
+import { stdContext } from '../../view/element/lit-host.js';
+import { INLINE_ROOT_ATTR, SHOW_INVISIBLES_ATTR, ZERO_WIDTH_FOR_EMPTY_LINE, } from '../consts.js';
+import { InvisibleCharactersDisplayIdentifier, segmentInvisibleCharacters, } from '../utils/invisible-characters.js';
+const textStyle = styleMap({
+    'word-break': 'break-word',
+    'text-wrap': 'wrap',
+    'white-space-collapse': 'break-spaces',
+});
+/**
+ * The marks of "show special characters". Each mark is drawn by an
+ * absolutely positioned `::before` over a span that still holds the original
+ * character: the layout, the offsets, a copy and the IME see the text as it is.
+ * Line ends are drawn per `v-line` from the attribute the editor sets on its
+ * host, so they need no element of their own. Colours are theme tokens.
+ */
+const invisiblesStyles = css `
+  [data-v-invisible] {
+    position: relative;
+  }
+  [data-v-invisible]::before {
+    position: absolute;
+    left: 0;
+    right: 0;
+    text-align: center;
+    pointer-events: none;
+    user-select: none;
+    color: var(--affine-text-disable-color, currentColor);
+    font-weight: normal;
+    font-style: normal;
+  }
+  [data-v-invisible='space']::before {
+    content: '·';
+  }
+  [data-v-invisible='tab']::before {
+    content: '→';
+  }
+  [data-v-invisible='nbsp']::before {
+    content: '°';
+  }
+  [data-v-invisible='invisible']::before {
+    content: '';
+    left: -1px;
+    right: auto;
+    top: 10%;
+    bottom: 10%;
+    border-left: 2px solid var(--affine-error-color, currentColor);
+  }
+  [${unsafeCSS(SHOW_INVISIBLES_ATTR)}] v-line::after {
+    position: absolute;
+    pointer-events: none;
+    user-select: none;
+    color: var(--affine-text-disable-color, currentColor);
+  }
+  [${unsafeCSS(SHOW_INVISIBLES_ATTR)}] v-line:not(:last-of-type)::after {
+    content: '↵';
+  }
+  [${unsafeCSS(SHOW_INVISIBLES_ATTR)}] v-line:last-of-type::after {
+    content: '¶';
+  }
+`;
+/**
+ * One `[data-v-text]` span holding one text node. We need to avoid
+
+ * appearing before and after the span element, which will cause the sync
+ * problem about the cursor position.
+ */
+function renderRun(text, kind, empty = false) {
+    return html `<span
+    style=${textStyle}
+    data-v-text="true"
+    data-v-empty=${empty ? 'true' : nothing}
+    data-v-invisible=${kind ?? nothing}
+    >${text}</span
+  >`;
+}
+const styledRoots = new WeakSet();
+/**
+ * Adopt the marks' stylesheet once per document or shadow root, the first
+ * time a mark is rendered there: `v-text` renders in light DOM, so a static
+ * `styles` would never apply.
+ */
+function adoptInvisiblesStyles(node) {
+    const root = node.getRootNode();
+    if (!(root instanceof Document || root instanceof ShadowRoot))
+        return;
+    if (styledRoots.has(root))
+        return;
+    const sheet = invisiblesStyles.styleSheet;
+    if (!sheet)
+        return;
+    styledRoots.add(root);
+    root.adoptedStyleSheets = [...root.adoptedStyleSheets, sheet];
+}
 let VText = (() => {
-    let _classSuper = LitElement;
+    let _classSuper = SignalWatcher(LitElement);
+    let _empty_decorators;
+    let _empty_initializers = [];
+    let _empty_extraInitializers = [];
     let _str_decorators;
     let _str_initializers = [];
     let _str_extraInitializers = [];
     return class VText extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _empty_decorators = [property({ type: Boolean })];
             _str_decorators = [property({ attribute: false })];
+            __esDecorate(this, null, _empty_decorators, { kind: "accessor", name: "empty", static: false, private: false, access: { has: obj => "empty" in obj, get: obj => obj.empty, set: (obj, value) => { obj.empty = value; } }, metadata: _metadata }, _empty_initializers, _empty_extraInitializers);
             __esDecorate(this, null, _str_decorators, { kind: "accessor", name: "str", static: false, private: false, access: { has: obj => "str" in obj, get: obj => obj.str, set: (obj, value) => { obj.str = value; } }, metadata: _metadata }, _str_initializers, _str_extraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         createRenderRoot() {
             return this;
         }
+        connectedCallback() {
+            super.connectedCallback();
+            this._showInvisibles$ =
+                this._std.value?.getOptional(InvisibleCharactersDisplayIdentifier)
+                    ?.showInvisibles$ ?? null;
+        }
+        _segments() {
+            if (!this._showInvisibles$?.value || this.empty)
+                return null;
+            // An embed's placeholder is one character of the model drawn as
+            // something else: never a mark on it.
+            if (this.closest('[data-v-embed="true"]'))
+                return null;
+            // Re-cutting the text under an IME composition would tear the
+            // composition apart: the plain run stays until the next render.
+            const root = this.closest(`[${INLINE_ROOT_ATTR}]`);
+            if (root?.inlineEditor?.isComposing)
+                return null;
+            return segmentInvisibleCharacters(this.str);
+        }
         render() {
-            // we need to avoid \n appearing before and after the span element, which will
-            // cause the sync problem about the cursor position
-            return html `<span
-      style=${styleMap({
-                'word-break': 'break-word',
-                'text-wrap': 'wrap',
-                'white-space-collapse': 'break-spaces',
-            })}
-      data-v-text="true"
-      >${this.str}</span
-    >`;
+            const segments = this._segments();
+            if (!segments)
+                return renderRun(this.str, undefined, this.empty);
+            adoptInvisiblesStyles(this);
+            // Several `[data-v-text]` spans, one text node each: offsets add the
+            // text nodes of every span (`getTextNodesFromElement`), so the caret and
+            // the selection map exactly as for one span.
+            return segments.map(segment => renderRun(segment.text, segment.kind));
         }
-        #str_accessor_storage = __runInitializers(this, _str_initializers, ZERO_WIDTH_FOR_EMPTY_LINE);
+        #empty_accessor_storage;
+        /**
+         * A placeholder, not text of the model: the zero-width character an empty
+         * line or an embed gap renders so the caret has somewhere to go. Counted as
+         * length 0 by the offsets (`calculateTextLength`), whatever its content —
+         * a zero-width space the USER stored is text and keeps its length.
+         */
+        get empty() { return this.#empty_accessor_storage; }
+        set empty(value) { this.#empty_accessor_storage = value; }
+        #str_accessor_storage;
         get str() { return this.#str_accessor_storage; }
         set str(value) { this.#str_accessor_storage = value; }
         constructor() {
             super(...arguments);
+            // Resolved once, on connect: the editor host provides `std`, and `std` the
+            // viewer's choice. Outside a host (the document title, a standalone inline
+            // editor) there is none, and nothing is ever marked.
+            this._std = new ContextConsumer(this, { context: stdContext });
+            this._showInvisibles$ = null;
+            this.#empty_accessor_storage = __runInitializers(this, _empty_initializers, false);
+            this.#str_accessor_storage = (__runInitializers(this, _empty_extraInitializers), __runInitializers(this, _str_initializers, ZERO_WIDTH_FOR_EMPTY_LINE));
             __runInitializers(this, _str_extraInitializers);
         }
     };

package/dist/_pkgs/std/inline/consts.d.ts

@@ -1,3 +1,8 @@
 export declare const ZERO_WIDTH_FOR_EMPTY_LINE: string;
 export declare const ZERO_WIDTH_FOR_EMBED_NODE: string;
 export declare const INLINE_ROOT_ATTR = "data-v-root";
+/**
+ * Set on the editor host while its viewer shows the special characters; the
+ * line ends are drawn from it (`v-text.ts`).
+ */
+export declare const SHOW_INVISIBLES_ATTR = "data-show-invisibles";

package/dist/_pkgs/std/inline/consts.js

@@ -2,3 +2,8 @@ import { IS_SAFARI } from '../../global/env/index.js';
 export const ZERO_WIDTH_FOR_EMPTY_LINE = IS_SAFARI ? '\u200C' : '\u200B';
 export const ZERO_WIDTH_FOR_EMBED_NODE = IS_SAFARI ? '\u200B' : '\u200C';
 export const INLINE_ROOT_ATTR = 'data-v-root';
+/**
+ * Set on the editor host while its viewer shows the special characters; the
+ * line ends are drawn from it (`v-text.ts`).
+ */
+export const SHOW_INVISIBLES_ATTR = 'data-show-invisibles';

package/dist/_pkgs/std/inline/utils/index.d.ts

@@ -9,3 +9,4 @@ export * from './range-conversion.js';
 export * from './renderer.js';
 export * from './text.js';
 export * from './transform-input.js';
+export * from './invisible-characters.js';

package/dist/_pkgs/std/inline/utils/index.js

@@ -9,3 +9,4 @@ export * from './range-conversion.js';
 export * from './renderer.js';
 export * from './text.js';
 export * from './transform-input.js';
+export * from './invisible-characters.js';

package/dist/_pkgs/std/inline/utils/invisible-characters.d.ts

@@ -0,0 +1,57 @@
+import type { ReadonlySignal } from '@preact/signals-core';
+/**
+ * The characters a reader cannot see and a writer rarely typed: the ones an
+ * AI text generator, a copy from a web page or a "watermarking" tool leaves in
+ * a paragraph. `text.invisibles.remove` strips them and the "show special
+ * characters" display marks them.
+ *
+ * - U+200B zero width space, U+2060 word joiner, U+FEFF zero width no-break
+ *   space — a BOM inside a text is a watermark, never a byte order mark;
+ * - U+00AD soft hyphen, U+180E Mongolian vowel separator;
+ * - U+2061–U+2064 the invisible math operators;
+ * - U+E0000–U+E007F the tag characters ("ASCII smuggling");
+ * - U+200D zero width joiner — see {@link findInvisibleCharacters} for the
+ *   two contexts where it and the tags are kept.
+ *
+ * Deliberately NOT here: U+200C zero width non-joiner, which Persian and the
+ * Indic scripts need, and the no-break spaces U+00A0 and U+202F, which French
+ * typography needs before `: ; ! ?` and inside quotation marks.
+ */
+export declare const INVISIBLE_CHARACTERS: ReadonlySet<number>;
+/** A character to strip or mark, as a UTF-16 slice of the string. */
+export interface InvisibleCharacterRun {
+    index: number;
+    length: number;
+}
+/**
+ * Every character of {@link INVISIBLE_CHARACTERS} in `str`, one run per code
+ * point, in order. Kept, so never reported: a ZWJ joining two pictographs, and
+ * the tag sequence of a subdivision flag — stripping either would break an
+ * emoji the writer meant.
+ */
+export declare function findInvisibleCharacters(str: string): InvisibleCharacterRun[];
+/** What the "show special characters" display draws over a character. */
+export type InvisibleCharacterKind = 'space' | 'tab' | 'nbsp' | 'invisible';
+export interface InvisibleCharacterSegment {
+    text: string;
+    /** Absent: ordinary text, rendered as it is. */
+    kind?: InvisibleCharacterKind;
+}
+/**
+ * `str` cut so that every space, tab, no-break space and invisible character
+ * stands alone in its own segment, the rest kept in runs. `null` when there is
+ * nothing to mark, so the common case allocates nothing.
+ *
+ * The segments concatenate back to `str` exactly: the display keeps every
+ * character as it is and only draws over it.
+ */
+export declare function segmentInvisibleCharacters(str: string): InvisibleCharacterSegment[] | null;
+/**
+ * Whether THIS viewer asked to see the special characters. Provided by the
+ * editor (`InvisibleCharacters` in `@labre/affine-shared/services`), read by
+ * every `v-text` under the editor host; absent, nothing is marked.
+ */
+export interface InvisibleCharactersDisplay {
+    readonly showInvisibles$: ReadonlySignal<boolean>;
+}
+export declare const InvisibleCharactersDisplayIdentifier: import("../../../global/di/types.js").ServiceIdentifier<InvisibleCharactersDisplay> & (<U extends InvisibleCharactersDisplay = InvisibleCharactersDisplay>(variant: import("../../../global/di/types.js").ServiceVariant) => import("../../../global/di/types.js").ServiceIdentifier<U>);

package/dist/_pkgs/std/inline/utils/invisible-characters.js

@@ -0,0 +1,162 @@
+import { createIdentifier } from '../../../global/di/index.js';
+/**
+ * The characters a reader cannot see and a writer rarely typed: the ones an
+ * AI text generator, a copy from a web page or a "watermarking" tool leaves in
+ * a paragraph. `text.invisibles.remove` strips them and the "show special
+ * characters" display marks them.
+ *
+ * - U+200B zero width space, U+2060 word joiner, U+FEFF zero width no-break
+ *   space — a BOM inside a text is a watermark, never a byte order mark;
+ * - U+00AD soft hyphen, U+180E Mongolian vowel separator;
+ * - U+2061–U+2064 the invisible math operators;
+ * - U+E0000–U+E007F the tag characters ("ASCII smuggling");
+ * - U+200D zero width joiner — see {@link findInvisibleCharacters} for the
+ *   two contexts where it and the tags are kept.
+ *
+ * Deliberately NOT here: U+200C zero width non-joiner, which Persian and the
+ * Indic scripts need, and the no-break spaces U+00A0 and U+202F, which French
+ * typography needs before `: ; ! ?` and inside quotation marks.
+ */
+export const INVISIBLE_CHARACTERS = new Set([
+    0x200b,
+    0x200d,
+    0x2060,
+    0xfeff,
+    0x00ad,
+    0x180e,
+    0x2061,
+    0x2062,
+    0x2063,
+    0x2064,
+    ...Array.from({ length: 0x80 }, (_, i) => 0xe0000 + i),
+]);
+const ZWJ = 0x200d;
+const VARIATION_SELECTOR_16 = 0xfe0f;
+const BLACK_FLAG = 0x1f3f4;
+const CANCEL_TAG = 0xe007f;
+const EXTENDED_PICTOGRAPHIC = /\p{Extended_Pictographic}/u;
+function isPictographic(codePoint) {
+    return (codePoint !== undefined &&
+        EXTENDED_PICTOGRAPHIC.test(String.fromCodePoint(codePoint)));
+}
+function isSkinTone(codePoint) {
+    return codePoint >= 0x1f3fb && codePoint <= 0x1f3ff;
+}
+function codePointBefore(str, index) {
+    if (index <= 0)
+        return undefined;
+    const low = str.charCodeAt(index - 1);
+    if (low >= 0xdc00 && low <= 0xdfff && index >= 2) {
+        const high = str.charCodeAt(index - 2);
+        if (high >= 0xd800 && high <= 0xdbff)
+            return str.codePointAt(index - 2);
+    }
+    return low;
+}
+/**
+ * A ZWJ between two pictographs is the glue of an emoji sequence (woman
+ * technologist, heart on fire, family): the emoji before it may carry a
+ * variation selector or a skin tone.
+ */
+function joinsEmoji(str, index) {
+    let before = index;
+    let previous = codePointBefore(str, before);
+    while (previous !== undefined &&
+        (previous === VARIATION_SELECTOR_16 || isSkinTone(previous))) {
+        before -= previous > 0xffff ? 2 : 1;
+        previous = codePointBefore(str, before);
+    }
+    return isPictographic(previous) && isPictographic(str.codePointAt(index + 1));
+}
+/**
+ * The tags after a black flag, closed by CANCEL TAG, spell a subdivision
+ * flag (Scotland, Wales, England): answers the index just past the sequence, or `-1`.
+ */
+function endOfFlagTags(str, start) {
+    let index = start;
+    while (index < str.length) {
+        const codePoint = str.codePointAt(index);
+        if (codePoint < 0xe0020 || codePoint > 0xe007e)
+            break;
+        index += 2;
+    }
+    if (index === start || str.codePointAt(index) !== CANCEL_TAG)
+        return -1;
+    return index + 2;
+}
+/**
+ * Every character of {@link INVISIBLE_CHARACTERS} in `str`, one run per code
+ * point, in order. Kept, so never reported: a ZWJ joining two pictographs, and
+ * the tag sequence of a subdivision flag — stripping either would break an
+ * emoji the writer meant.
+ */
+export function findInvisibleCharacters(str) {
+    const runs = [];
+    let index = 0;
+    while (index < str.length) {
+        const codePoint = str.codePointAt(index);
+        const size = codePoint > 0xffff ? 2 : 1;
+        if (codePoint === BLACK_FLAG) {
+            const end = endOfFlagTags(str, index + size);
+            index = end === -1 ? index + size : end;
+            continue;
+        }
+        if (INVISIBLE_CHARACTERS.has(codePoint) &&
+            !(codePoint === ZWJ && joinsEmoji(str, index))) {
+            runs.push({ index, length: size });
+        }
+        index += size;
+    }
+    return runs;
+}
+const MAYBE_SPECIAL = /[ \t\u00A0\u202F\u00AD\u180E\u200B\u200D\u2060-\u2064\uFEFF]|\udb40[\udc00-\udc7f]/;
+function whitespaceKind(char) {
+    if (char === ' ')
+        return 'space';
+    if (char === '\t')
+        return 'tab';
+    if (char === '\u00A0' || char === '\u202F')
+        return 'nbsp';
+    return null;
+}
+/**
+ * `str` cut so that every space, tab, no-break space and invisible character
+ * stands alone in its own segment, the rest kept in runs. `null` when there is
+ * nothing to mark, so the common case allocates nothing.
+ *
+ * The segments concatenate back to `str` exactly: the display keeps every
+ * character as it is and only draws over it.
+ */
+export function segmentInvisibleCharacters(str) {
+    if (!MAYBE_SPECIAL.test(str))
+        return null;
+    const invisible = new Map();
+    for (const run of findInvisibleCharacters(str)) {
+        invisible.set(run.index, run.length);
+    }
+    const segments = [];
+    let plainStart = 0;
+    const flush = (end) => {
+        if (end > plainStart)
+            segments.push({ text: str.slice(plainStart, end) });
+    };
+    let index = 0;
+    while (index < str.length) {
+        const length = invisible.get(index);
+        const kind = length ? 'invisible' : whitespaceKind(str[index]);
+        if (!kind) {
+            index += 1;
+            continue;
+        }
+        const size = length ?? 1;
+        flush(index);
+        segments.push({ text: str.slice(index, index + size), kind });
+        index += size;
+        plainStart = index;
+    }
+    if (segments.length === 0)
+        return null;
+    flush(str.length);
+    return segments;
+}
+export const InvisibleCharactersDisplayIdentifier = createIdentifier('InvisibleCharactersDisplay');

package/dist/_pkgs/std/inline/utils/point-conversion.js

@@ -1,7 +1,7 @@
 import { BlockSuiteError, ErrorCode } from '../../../global/exceptions/index.js';
-import { INLINE_ROOT_ATTR, ZERO_WIDTH_FOR_EMPTY_LINE } from '../consts.js';
+import { INLINE_ROOT_ATTR } from '../consts.js';
 import { isInlineRoot, isNativeTextInVText, isVElement, isVLine, } from './guard.js';
-import { calculateTextLength, getTextNodesFromElement } from './text.js';
+import { calculateTextLength, getTextNodesFromElement, isPlaceholderText, } from './text.js';
 export function nativePointToTextPoint(node, offset) {
     if (isNativeTextInVText(node)) {
         return [node, offset];
@@ -44,7 +44,7 @@ export function textPointToDomPoint(text, offset, rootElement) {
     for (const text of texts.slice(0, goalIndex)) {
         index += calculateTextLength(text);
     }
-    if (text.wholeText !== ZERO_WIDTH_FOR_EMPTY_LINE) {
+    if (!isPlaceholderText(text)) {
         index += offset;
     }
     const textParentElement = text.parentElement;

package/dist/_pkgs/std/inline/utils/text.d.ts

@@ -1,2 +1,10 @@
+/**
+ * Whether `text` is a placeholder rather than text of the model: the
+ * zero-width character an empty line or an embed gap renders (`v-text`'s
+ * `empty`, rendered as `data-v-empty`). Decided by the attribute, never by
+ * the content: a zero-width space the user stored, alone in its run (or in
+ * its own span when special characters are shown), is one character long.
+ */
+export declare function isPlaceholderText(text: Text): boolean;
 export declare function calculateTextLength(text: Text): number;
 export declare function getTextNodesFromElement(element: Element): Text[];

package/dist/_pkgs/std/inline/utils/text.js

@@ -1,6 +1,15 @@
-import { ZERO_WIDTH_FOR_EMPTY_LINE } from '../consts.js';
+/**
+ * Whether `text` is a placeholder rather than text of the model: the
+ * zero-width character an empty line or an embed gap renders (`v-text`'s
+ * `empty`, rendered as `data-v-empty`). Decided by the attribute, never by
+ * the content: a zero-width space the user stored, alone in its run (or in
+ * its own span when special characters are shown), is one character long.
+ */
+export function isPlaceholderText(text) {
+    return text.parentElement?.dataset.vEmpty === 'true';
+}
 export function calculateTextLength(text) {
-    if (text.wholeText === ZERO_WIDTH_FOR_EMPTY_LINE) {
+    if (isPlaceholderText(text)) {
         return 0;
     }
     else {

package/dist/_pkgs/store/model/store/crud.d.ts

@@ -5,7 +5,35 @@ export declare class DocCRUD {
     private readonly _yBlocks;
     private readonly _schema;
     get root(): string | null;
+    /**
+     * In-memory index of the tree: `childId -> parentId` plus the root id,
+     * rebuilt lazily after any structural change. Nothing here is written to Yjs
+     * (ADR 0041).
+     *
+     * Why: `root` scanned every block and `getParent` walked the tree from the
+     * root, so a load path calling `getParent` once per block was quadratic
+     * (#507: 11 s for 4000 blocks under a query with `viewType: 'hidden'`, whose
+     * `setAncestorsToDisplayIfHidden` climbs the ancestors of every block). #508
+     * only skipped that walk for queries that cannot hide blocks; the index
+     * makes the walk itself linear.
+     *
+     * Invalidation contract:
+     * - every transaction, local, remote (`Y.applyUpdate`) or undo, reaches
+     *   `beforeObserverCalls` before any observer runs, so observers and
+     *   everything after them read a fresh index;
+     * - inside a transaction, before that event, only the mutators below write
+     *   the tree (`sys:children`, the blocks map): each drops the index before
+     *   its first write, so a throw half-way leaves no stale index, and again
+     *   after its last one, so a read in between cannot cache a half-written
+     *   tree. A new writer of `sys:children` must do the same.
+     */
+    private _index;
+    /** Once deaf to remote changes, every read rebuilds (the pre-#507 cost). */
+    private _live;
+    private readonly _onBeforeObserverCalls;
     constructor(_yBlocks: Y.Map<YBlock>, _schema: Schema);
+    dispose(): void;
+    private _ensureIndex;
     private _getSiblings;
     addBlock(id: string, flavour: string, initialProps?: Record<string, unknown>, parent?: string | null, parentIndex?: number): void;
     deleteBlock(id: string, options?: {