@formicoidea/labre-core 0.30.1 → 0.32.0

package/dist/_pkgs/std/inline/services/event.js

@@ -1,3 +1,4 @@
+import { INLINE_ROOT_ATTR } from '../consts.js';
 import { isInEmbedElement, isInEmbedGap, isInEmptyLine, } from '../utils/index.js';
 import { isMaybeInlineRangeEqual } from '../utils/inline-range.js';
 import { transformInput } from '../utils/transform-input.js';
@@ -9,34 +10,105 @@ export class EventService {
         this.editor = editor;
         this._compositionInlineRange = null;
         this._isComposing = false;
+        this._getClosestInlineRoot = (node) => {
+            const el = node instanceof Element ? node : node.parentElement;
+            return el?.closest(`[${INLINE_ROOT_ATTR}]`) ?? null;
+        };
+        this._containsNode = (rootElement, node) => node === rootElement || rootElement.contains(node);
         this._isRangeCompletelyInRoot = (range) => {
             if (range.commonAncestorContainer.ownerDocument !== document)
                 return false;
             const rootElement = this.editor.rootElement;
             if (!rootElement)
                 return false;
-            const rootRange = document.createRange();
-            rootRange.selectNode(rootElement);
-            if (range.startContainer.compareDocumentPosition(range.endContainer) &
-                Node.DOCUMENT_POSITION_FOLLOWING) {
-                return (rootRange.comparePoint(range.startContainer, range.startOffset) >= 0 &&
-                    rootRange.comparePoint(range.endContainer, range.endOffset) <= 0);
-            }
-            else {
-                return (rootRange.comparePoint(range.endContainer, range.startOffset) >= 0 &&
-                    rootRange.comparePoint(range.startContainer, range.endOffset) <= 0);
-            }
+            // Avoid `Range.comparePoint` here — Firefox and Chrome have subtle
+            // differences around selection points in `contenteditable` and around
+            // comment marker nodes.
+            return (this._containsNode(rootElement, range.startContainer) &&
+                this._containsNode(rootElement, range.endContainer));
         };
-        this._onBeforeInput = (event) => {
+        this._onBeforeInput = async (event) => {
             const range = this.editor.rangeService.getNativeRange();
-            if (this.editor.isReadonly ||
-                this._isComposing ||
-                !range ||
-                !this._isRangeCompletelyInRoot(range))
+            if (this.editor.isReadonly || !range)
                 return;
-            let inlineRange = this.editor.toInlineRange(range);
-            if (!inlineRange)
+            const rootElement = this.editor.rootElement;
+            if (!rootElement)
+                return;
+            const startInRoot = this._containsNode(rootElement, range.startContainer);
+            const endInRoot = this._containsNode(rootElement, range.endContainer);
+            // Not this inline editor.
+            if (!startInRoot && !endInRoot)
                 return;
+            // If the selection spans into another inline editor, let the range binding
+            // handle it.
+            if (startInRoot !== endInRoot) {
+                const otherNode = startInRoot ? range.endContainer : range.startContainer;
+                const otherRoot = this._getClosestInlineRoot(otherNode);
+                if (otherRoot && otherRoot !== rootElement)
+                    return;
+            }
+            if (this._isComposing)
+                return;
+            // Always prevent native DOM mutations inside the inline editor. Browsers
+            // (notably Firefox) may remove Lit marker comment nodes during native
+            // edits, which crashes subsequent Lit updates with
+            // `ChildPart has no parentNode`.
+            event.preventDefault();
+            let inlineRange = this.editor.toInlineRange(range);
+            if (!inlineRange) {
+                // Some browsers may report selection points on non-text nodes inside
+                // `contenteditable`. Prefer the target range if available.
+                try {
+                    const targetRanges = event.getTargetRanges();
+                    if (targetRanges.length > 0) {
+                        const staticRange = targetRanges[0];
+                        const targetRange = document.createRange();
+                        targetRange.setStart(staticRange.startContainer, staticRange.startOffset);
+                        targetRange.setEnd(staticRange.endContainer, staticRange.endOffset);
+                        inlineRange = this.editor.toInlineRange(targetRange);
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }
+            if (!inlineRange && startInRoot !== endInRoot) {
+                // Clamp a partially-outside selection to this editor so native editing
+                // won't touch Lit marker nodes.
+                const pointRange = document.createRange();
+                if (startInRoot) {
+                    pointRange.setStart(range.startContainer, range.startOffset);
+                    pointRange.setEnd(range.startContainer, range.startOffset);
+                    const startPoint = this.editor.toInlineRange(pointRange);
+                    if (startPoint) {
+                        inlineRange = {
+                            index: startPoint.index,
+                            length: this.editor.yTextLength - startPoint.index,
+                        };
+                    }
+                }
+                else {
+                    pointRange.setStart(range.endContainer, range.endOffset);
+                    pointRange.setEnd(range.endContainer, range.endOffset);
+                    const endPoint = this.editor.toInlineRange(pointRange);
+                    if (endPoint) {
+                        inlineRange = {
+                            index: 0,
+                            length: endPoint.index,
+                        };
+                    }
+                }
+            }
+            if (!inlineRange) {
+                // Try to recover from an unexpected DOM/selection state by rebuilding the
+                // editor DOM and retrying the range conversion.
+                this.editor.rerenderWholeEditor();
+                await this.editor.waitForUpdate();
+                const newRange = this.editor.rangeService.getNativeRange();
+                inlineRange = newRange ? this.editor.toInlineRange(newRange) : null;
+                if (!inlineRange)
+                    return;
+            }
             let ifHandleTargetRange = true;
             if (event.inputType.startsWith('delete')) {
                 if (isInEmbedGap(range.commonAncestorContainer) &&
@@ -70,14 +142,15 @@ export class EventService {
                     range.setStart(staticRange.startContainer, staticRange.startOffset);
                     range.setEnd(staticRange.endContainer, staticRange.endOffset);
                     const targetInlineRange = this.editor.toInlineRange(range);
-                    if (!isMaybeInlineRangeEqual(inlineRange, targetInlineRange)) {
+                    // Ignore an un-resolvable target range to avoid swallowing the input.
+                    if (targetInlineRange &&
+                        !isMaybeInlineRangeEqual(inlineRange, targetInlineRange)) {
                         inlineRange = targetInlineRange;
                     }
                 }
             }
             if (!inlineRange)
                 return;
-            event.preventDefault();
             const ctx = {
                 inlineEditor: this.editor,
                 raw: event,
@@ -276,7 +349,9 @@ export class EventService {
                 console.error('Mount inline editor without event source ready');
                 return;
             }
-            this.editor.disposables.addFromEvent(eventSource, 'beforeinput', this._onBeforeInput);
+            this.editor.disposables.addFromEvent(eventSource, 'beforeinput', e => {
+                this._onBeforeInput(e).catch(console.error);
+            });
             this.editor.disposables.addFromEvent(eventSource, 'compositionstart', this._onCompositionStart);
             this.editor.disposables.addFromEvent(eventSource, 'compositionupdate', this._onCompositionUpdate);
             this.editor.disposables.addFromEvent(eventSource, 'compositionend', e => {

package/dist/_pkgs/std/utils/layer.js

@@ -3,11 +3,7 @@ import {} from '../gfx/model/gfx-block-model.js';
 import { GfxLocalElementModel } from '../gfx/model/surface/local-element-model.js';
 export function getLayerEndZIndex(layers, layerIndex) {
     const layer = layers[layerIndex];
-    return layer
-        ? layer.type === 'block'
-            ? layer.zIndex + layer.elements.length - 1
-            : layer.zIndex
-        : 0;
+    return layer ? layer.zIndex + layer.elements.length - 1 : 0;
 }
 export function updateLayersZIndex(layers, startIdx) {
     const startLayer = layers[startIdx];
@@ -15,7 +11,7 @@ export function updateLayersZIndex(layers, startIdx) {
     for (let i = startIdx; i < layers.length; ++i) {
         const curLayer = layers[i];
         curLayer.zIndex = curIndex;
-        curIndex += curLayer.type === 'block' ? curLayer.elements.length : 1;
+        curIndex += curLayer.elements.length;
     }
 }
 export function getElementIndex(indexable) {

package/dist/_pkgs/std/utils/tree.d.ts

@@ -20,6 +20,20 @@ import type { GfxGroupModel, GfxModel } from '../gfx/model/model.js';
  * The result should be `[G1, G4, E6]`
  */
 export declare function getTopElements(elements: GfxModel[]): GfxModel[];
+/**
+ * Add several children to a container in one go.
+ *
+ * A container that knows how to take a batch (`addChildren`) gets the whole
+ * list, so it can write them within a single transaction; anything else falls
+ * back to one `addChild` per element, which is exactly what the caller would
+ * have written by hand.
+ */
+export declare function batchAddChildren(container: GfxGroupCompatibleInterface, elements: GfxModel[]): void;
+/**
+ * Remove several children from a container in one go. See
+ * {@link batchAddChildren}.
+ */
+export declare function batchRemoveChildren(container: GfxGroupCompatibleInterface, elements: GfxModel[]): void;
 export declare function descendantElementsImpl(container: GfxGroupCompatibleInterface): GfxModel[];
 export declare function hasDescendantElementImpl(container: GfxGroupCompatibleInterface, element: GfxCompatibleInterface): boolean;
 /**

package/dist/_pkgs/std/utils/tree.js

@@ -18,16 +18,67 @@ import { isGfxGroupCompatibleModel, } from '../gfx/model/base.js';
  * The result should be `[G1, G4, E6]`
  */
 export function getTopElements(elements) {
-    const results = new Set(elements);
-    elements = [...new Set(elements)];
-    elements.forEach(e1 => {
-        elements.forEach(e2 => {
-            if (isGfxGroupCompatibleModel(e1) && e1.hasDescendant(e2)) {
-                results.delete(e2);
+    const uniqueElements = [...new Set(elements)];
+    const selected = new Set(uniqueElements);
+    const topElements = [];
+    // Walk each element UP to the root instead of asking every pair whether one
+    // contains the other: the pairwise form walked the whole subtree of every
+    // group for every other element in the list, which is what made a large
+    // selection expensive.
+    for (const element of uniqueElements) {
+        let ancestor = element.group;
+        let hasSelectedAncestor = false;
+        while (ancestor) {
+            if (selected.has(ancestor)) {
+                hasSelectedAncestor = true;
+                break;
             }
-        });
+            ancestor = ancestor.group;
+        }
+        if (!hasSelectedAncestor) {
+            topElements.push(element);
+        }
+    }
+    return topElements;
+}
+/**
+ * Add several children to a container in one go.
+ *
+ * A container that knows how to take a batch (`addChildren`) gets the whole
+ * list, so it can write them within a single transaction; anything else falls
+ * back to one `addChild` per element, which is exactly what the caller would
+ * have written by hand.
+ */
+export function batchAddChildren(container, elements) {
+    const uniqueElements = [...new Set(elements)];
+    if (uniqueElements.length === 0)
+        return;
+    const batchContainer = container;
+    if (batchContainer.addChildren) {
+        batchContainer.addChildren(uniqueElements);
+        return;
+    }
+    uniqueElements.forEach(element => {
+        container.addChild(element);
+    });
+}
+/**
+ * Remove several children from a container in one go. See
+ * {@link batchAddChildren}.
+ */
+export function batchRemoveChildren(container, elements) {
+    const uniqueElements = [...new Set(elements)];
+    if (uniqueElements.length === 0)
+        return;
+    const batchContainer = container;
+    if (batchContainer.removeChildren) {
+        batchContainer.removeChildren(uniqueElements);
+        return;
+    }
+    uniqueElements.forEach(element => {
+        // oxlint-disable-next-line unicorn/prefer-dom-node-remove
+        container.removeChild(element);
     });
-    return [...results];
 }
 function traverse(element, preCallback, postCallBack) {
     // avoid infinite loop caused by circular reference

package/dist/_pkgs/std/view/element/gfx-block-component.js

@@ -18,6 +18,12 @@ function updateTransform(element) {
     element.style.transformOrigin = '0 0';
     element.style.transform = element.getCSSTransform();
 }
+function updateZIndex(element) {
+    const zIndex = element.toZIndex();
+    if (element.style.zIndex !== zIndex) {
+        element.style.zIndex = zIndex;
+    }
+}
 function updateBlockVisibility(view) {
     if (view.transformState$.value === 'active') {
         view.style.visibility = 'visible';
@@ -40,11 +46,18 @@ function handleGfxConnection(instance) {
     instance.disposables.add(instance.store.slots.blockUpdated.subscribe(({ type, id }) => {
         if (id === instance.model.id && type === 'update') {
             updateTransform(instance);
+            updateZIndex(instance);
         }
     }));
+    // A reorder changes no property of this block, only the layer it sits in,
+    // so the stacking has to be read back from the layer manager.
+    instance.disposables.add(instance.gfx.layer.slots.layerUpdated.subscribe(() => {
+        updateZIndex(instance);
+    }));
     instance.disposables.add(effect(() => {
         updateBlockVisibility(instance);
         updateTransform(instance);
+        updateZIndex(instance);
     }));
 }
 export class GfxBlockComponent extends BlockComponent {
@@ -73,13 +86,17 @@ export class GfxBlockComponent extends BlockComponent {
     onBoxSelected(_) { }
     getCSSTransform() {
         const viewport = this.gfx.viewport;
-        const { translateX, translateY, zoom } = viewport;
+        const { translateX, translateY, zoom, viewScale } = viewport;
         const bound = Bound.deserialize(this.model.xywh);
-        const scaledX = bound.x * zoom;
-        const scaledY = bound.y * zoom;
+        // An outer container may scale the whole editor (`viewScale`). The block
+        // is placed inside that container, so the placement has to be stated in
+        // the container's already scaled space, otherwise the container applies
+        // its scale a second time and the block drifts away from the canvas.
+        const scaledX = (bound.x * zoom) / viewScale;
+        const scaledY = (bound.y * zoom) / viewScale;
         const deltaX = scaledX - bound.x;
         const deltaY = scaledY - bound.y;
-        return `translate(${translateX + deltaX}px, ${translateY + deltaY}px) scale(${zoom})`;
+        return `translate(${translateX / viewScale + deltaX}px, ${translateY / viewScale + deltaY}px) scale(${zoom / viewScale})`;
     }
     getRenderingRect() {
         const { xywh$ } = this.model;
@@ -159,16 +176,9 @@ export function toGfxBlockComponent(CustomBlock) {
             super.connectedCallback();
             handleGfxConnection(this);
         }
-        // eslint-disable-next-line sonarjs/no-identical-functions
         getCSSTransform() {
-            const viewport = this.gfx.viewport;
-            const { translateX, translateY, zoom } = viewport;
-            const bound = Bound.deserialize(this.model.xywh);
-            const scaledX = bound.x * zoom;
-            const scaledY = bound.y * zoom;
-            const deltaX = scaledX - bound.x;
-            const deltaY = scaledY - bound.y;
-            return `translate(${translateX + deltaX}px, ${translateY + deltaY}px) scale(${zoom})`;
+            // A converted block is placed exactly like a native one.
+            return GfxBlockComponent.prototype.getCSSTransform.call(this);
         }
         // eslint-disable-next-line sonarjs/no-identical-functions
         getRenderingRect() {

package/dist/_pkgs/store/extension/history/history-extension.d.ts

@@ -1,7 +1,7 @@
 import { Subject } from 'rxjs';
 import * as Y from 'yjs';
-import type { Store } from '../../model';
-import { StoreExtension } from '../store-extension';
+import type { Store } from '../../model/index.js';
+import { StoreExtension } from '../store-extension.js';
 export declare class HistoryExtension extends StoreExtension {
     static readonly key = "history";
     private readonly _history;

package/dist/_pkgs/store/extension/history/history-extension.js

@@ -1,7 +1,7 @@
 import { signal } from '@preact/signals-core';
 import { Subject } from 'rxjs';
 import * as Y from 'yjs';
-import { StoreExtension } from '../store-extension';
+import { StoreExtension } from '../store-extension.js';
 export class HistoryExtension extends StoreExtension {
     static { this.key = 'history'; }
     constructor(store) {

package/dist/_pkgs/store/extension/history/index.d.ts

@@ -1 +1 @@
-export * from './history-extension';
+export * from './history-extension.js';

package/dist/_pkgs/store/extension/history/index.js

@@ -1 +1 @@
-export * from './history-extension';
+export * from './history-extension.js';

package/dist/_pkgs/store/extension/index.d.ts

@@ -1,6 +1,6 @@
-export * from './extension';
-export * from './history';
-export * from './schema';
-export * from './selection';
-export * from './store-extension';
-export * from './workspace';
+export * from './extension.js';
+export * from './history/index.js';
+export * from './schema.js';
+export * from './selection/index.js';
+export * from './store-extension.js';
+export * from './workspace/index.js';

package/dist/_pkgs/store/extension/index.js

@@ -1,6 +1,6 @@
-export * from './extension';
-export * from './history';
-export * from './schema';
-export * from './selection';
-export * from './store-extension';
-export * from './workspace';
+export * from './extension.js';
+export * from './history/index.js';
+export * from './schema.js';
+export * from './selection/index.js';
+export * from './store-extension.js';
+export * from './workspace/index.js';

package/dist/_pkgs/store/extension/schema.d.ts

@@ -1,5 +1,5 @@
-import type { BlockSchemaType } from '../model/block/zod';
-import type { ExtensionType } from './extension';
+import type { BlockSchemaType } from '../model/block/zod.js';
+import type { ExtensionType } from './extension.js';
 export declare const BlockSchemaIdentifier: import("../../global/di/types.js").ServiceIdentifier<{
     version: number;
     model: {

package/dist/_pkgs/store/extension/selection/base.d.ts

@@ -1,4 +1,4 @@
-import type { SelectionConstructor } from './types';
+import type { SelectionConstructor } from './types.js';
 export type BaseSelectionOptions = {
     blockId: string;
 };

package/dist/_pkgs/store/extension/selection/identifier.d.ts

@@ -1,4 +1,4 @@
-import type { ExtensionType } from '../extension';
-import type { SelectionConstructor } from './types';
+import type { ExtensionType } from '../extension.js';
+import type { SelectionConstructor } from './types.js';
 export declare const SelectionIdentifier: import("../../../global/di/types.js").ServiceIdentifier<SelectionConstructor<import("./base.js").BaseSelection>> & (<U extends SelectionConstructor<import("./base.js").BaseSelection> = SelectionConstructor<import("./base.js").BaseSelection>>(variant: import("../../../global/di/types.js").ServiceVariant) => import("../../../global/di/types.js").ServiceIdentifier<U>);
 export declare function SelectionExtension(selectionCtor: SelectionConstructor): ExtensionType;

package/dist/_pkgs/store/extension/selection/index.d.ts

@@ -1,4 +1,4 @@
-export * from './base';
-export * from './identifier';
-export * from './selection-extension';
-export * from './types';
+export * from './base.js';
+export * from './identifier.js';
+export * from './selection-extension.js';
+export * from './types.js';

package/dist/_pkgs/store/extension/selection/index.js

@@ -1,4 +1,4 @@
-export * from './base';
-export * from './identifier';
-export * from './selection-extension';
-export * from './types';
+export * from './base.js';
+export * from './identifier.js';
+export * from './selection-extension.js';
+export * from './types.js';

package/dist/_pkgs/store/extension/selection/selection-extension.d.ts

@@ -1,7 +1,7 @@
 import { Subject } from 'rxjs';
-import { StoreExtension } from '../store-extension';
-import type { BaseSelection } from './base';
-import type { SelectionConstructor } from './types';
+import { StoreExtension } from '../store-extension.js';
+import type { BaseSelection } from './base.js';
+import type { SelectionConstructor } from './types.js';
 export declare class StoreSelectionExtension extends StoreExtension {
     static readonly key = "selection";
     private readonly _id;

package/dist/_pkgs/store/extension/selection/selection-extension.js

@@ -1,9 +1,9 @@
 import { BlockSuiteError, ErrorCode } from '../../../global/exceptions/index.js';
 import { computed, signal } from '@preact/signals-core';
 import { Subject } from 'rxjs';
-import { nanoid } from '../../utils/id-generator';
-import { StoreExtension } from '../store-extension';
-import { SelectionIdentifier } from './identifier';
+import { nanoid } from '../../utils/id-generator.js';
+import { StoreExtension } from '../store-extension.js';
+import { SelectionIdentifier } from './identifier.js';
 export class StoreSelectionExtension extends StoreExtension {
     constructor() {
         super(...arguments);

package/dist/_pkgs/store/extension/selection/types.d.ts

@@ -1,4 +1,4 @@
-import type { BaseSelection } from './base';
+import type { BaseSelection } from './base.js';
 export interface SelectionConstructor<T extends BaseSelection = BaseSelection> {
     type: string;
     group: string;

package/dist/_pkgs/store/extension/store-extension.d.ts

@@ -1,6 +1,6 @@
 import { type Container } from '../../global/di/index.js';
-import type { Store } from '../model/store';
-import { Extension } from './extension';
+import type { Store } from '../model/store/index.js';
+import { Extension } from './extension.js';
 export declare const StoreExtensionIdentifier: import("../../global/di/types.js").ServiceIdentifier<StoreExtension> & (<U extends StoreExtension = StoreExtension>(variant: import("../../global/di/types.js").ServiceVariant) => import("../../global/di/types.js").ServiceIdentifier<U>);
 export declare const storeExtensionSymbol: unique symbol;
 /**

package/dist/_pkgs/store/extension/store-extension.js

@@ -1,8 +1,8 @@
 var _a;
 import { createIdentifier } from '../../global/di/index.js';
 import { BlockSuiteError, ErrorCode } from '../../global/exceptions/index.js';
-import { StoreIdentifier } from '../model/store/identifier';
-import { Extension } from './extension';
+import { StoreIdentifier } from '../model/store/identifier.js';
+import { Extension } from './extension.js';
 export const StoreExtensionIdentifier = createIdentifier('StoreExtension');
 export const storeExtensionSymbol = Symbol('StoreExtension');
 /**

package/dist/_pkgs/store/extension/workspace/doc.d.ts

@@ -1,6 +1,6 @@
 import type * as Y from 'yjs';
-import type { Store, StoreOptions, YBlock } from '../../model';
-import type { AwarenessStore } from '../../yjs';
+import type { Store, StoreOptions, YBlock } from '../../model/index.js';
+import type { AwarenessStore } from '../../yjs/index.js';
 import type { Workspace } from './workspace.js';
 import type { DocMeta } from './workspace-meta.js';
 export type GetStoreOptions = Omit<StoreOptions, 'schema' | 'doc'>;

package/dist/_pkgs/store/extension/workspace/index.d.ts

@@ -1,3 +1,3 @@
-export * from './doc';
-export * from './workspace';
-export * from './workspace-meta';
+export * from './doc.js';
+export * from './workspace.js';
+export * from './workspace-meta.js';

package/dist/_pkgs/store/extension/workspace/index.js

@@ -1,3 +1,3 @@
-export * from './doc';
-export * from './workspace';
-export * from './workspace-meta';
+export * from './doc.js';
+export * from './workspace.js';
+export * from './workspace-meta.js';

package/dist/_pkgs/store/extension/workspace/workspace-meta.d.ts

@@ -16,6 +16,16 @@ export interface DocMeta {
     createDate: number;
     updatedDate?: number;
     favorite?: boolean;
+    /**
+     * Set by the host when the doc sits in its trash. The doc is still in the
+     * workspace — it loads and round-trips as usual — but references to it
+     * (linked-doc and synced-doc cards) render as deleted.
+     *
+     * Optional and absent from documents written before it existed: the meta map
+     * is stored key by key, so an older document simply reads `undefined` here
+     * and an older reader ignores the key.
+     */
+    trash?: boolean;
 }
 export interface WorkspaceMeta {
     get docMetas(): DocMeta[];

package/dist/_pkgs/store/extension/workspace/workspace.d.ts

@@ -2,7 +2,7 @@ import type { BlobEngine } from '../../../sync/index.js';
 import type { Subject } from 'rxjs';
 import type { Awareness } from 'y-protocols/awareness.js';
 import type * as Y from 'yjs';
-import type { IdGenerator } from '../../utils/id-generator';
+import type { IdGenerator } from '../../utils/id-generator.js';
 import type { Doc } from './doc.js';
 import type { WorkspaceMeta } from './workspace-meta.js';
 export interface Workspace {

package/dist/_pkgs/store/impls/doc.d.ts

@@ -0,0 +1,45 @@
+import * as Y from 'yjs';
+import type { Doc, GetStoreOptions, Workspace } from '../extension/index.js';
+import type { YBlock } from '../model/block/types.js';
+import type { AwarenessStore } from '../yjs/index.js';
+type DocOptions = {
+    id: string;
+    collection: Workspace;
+    doc: Y.Doc;
+    awarenessStore: AwarenessStore;
+};
+export declare class DocImpl implements Doc {
+    private readonly _collection;
+    private readonly _storeContainer;
+    private readonly _initSubDoc;
+    private _loaded;
+    private readonly _onSubdocEvent;
+    /** Indicate whether the block tree is ready */
+    private _ready;
+    protected readonly _yBlocks: Y.Map<YBlock>;
+    /**
+     * @internal Used for convenient access to the underlying Yjs map,
+     * can be used interchangeably with ySpace
+     */
+    protected readonly _ySpaceDoc: Y.Doc;
+    readonly awarenessStore: AwarenessStore;
+    readonly id: string;
+    readonly rootDoc: Y.Doc;
+    get blobSync(): import("../../sync/index.js").BlobEngine;
+    get workspace(): Workspace;
+    get isEmpty(): boolean;
+    get loaded(): boolean;
+    get meta(): import("../index.js").DocMeta | undefined;
+    get ready(): boolean;
+    get spaceDoc(): Y.Doc;
+    get yBlocks(): Y.Map<YBlock>;
+    constructor({ id, collection, doc, awarenessStore }: DocOptions);
+    clear(): void;
+    get removeStore(): ({ readonly, query, id }: import("../index.js").RemoveStoreOptions) => void;
+    private _destroy;
+    dispose(): void;
+    getStore({ readonly, query, provider, extensions, id, }?: GetStoreOptions): import("../index.js").Store;
+    load(initFn?: () => void): this;
+    remove(): void;
+}
+export {};