@formicoidea/labre-core 0.30.1 → 0.32.0

package/dist/_pkgs/store/impls/doc.js

@@ -0,0 +1,110 @@
+import * as Y from 'yjs';
+import { StoreContainer } from '../model/index.js';
+export class DocImpl {
+    get blobSync() {
+        return this.workspace.blobSync;
+    }
+    get workspace() {
+        return this._collection;
+    }
+    get isEmpty() {
+        return this._yBlocks.size === 0;
+    }
+    get loaded() {
+        return this._loaded;
+    }
+    get meta() {
+        return this.workspace.meta.getDocMeta(this.id);
+    }
+    get ready() {
+        return this._ready;
+    }
+    get spaceDoc() {
+        return this._ySpaceDoc;
+    }
+    get yBlocks() {
+        return this._yBlocks;
+    }
+    constructor({ id, collection, doc, awarenessStore }) {
+        this._initSubDoc = () => {
+            let subDoc = this.rootDoc.getMap('spaces').get(this.id);
+            if (!subDoc) {
+                subDoc = new Y.Doc({
+                    guid: this.id,
+                });
+                this.rootDoc.getMap('spaces').set(this.id, subDoc);
+                this._loaded = true;
+            }
+            else {
+                this._loaded = false;
+                this.rootDoc.on('subdocs', this._onSubdocEvent);
+            }
+            return subDoc;
+        };
+        this._onSubdocEvent = ({ loaded, }) => {
+            const result = Array.from(loaded).find(doc => doc.guid === this._ySpaceDoc.guid);
+            if (!result) {
+                return;
+            }
+            this.rootDoc.off('subdocs', this._onSubdocEvent);
+            this._loaded = true;
+        };
+        /** Indicate whether the block tree is ready */
+        this._ready = false;
+        this.id = id;
+        this.rootDoc = doc;
+        this.awarenessStore = awarenessStore;
+        this._ySpaceDoc = this._initSubDoc();
+        this._yBlocks = this._ySpaceDoc.getMap('blocks');
+        this._collection = collection;
+        this._storeContainer = new StoreContainer(this);
+    }
+    clear() {
+        this._yBlocks.clear();
+    }
+    get removeStore() {
+        return this._storeContainer.removeStore;
+    }
+    _destroy() {
+        this._ySpaceDoc.destroy();
+        this._loaded = false;
+    }
+    dispose() {
+        if (this.ready) {
+            this._yBlocks.clear();
+        }
+    }
+    getStore({ readonly, query, provider, extensions, id, } = {}) {
+        const storeExtensions = this.workspace.storeExtensions.concat(extensions ?? []);
+        let storeId;
+        if (id) {
+            storeId = id;
+        }
+        else if (readonly !== undefined || query) {
+            storeId = id;
+        }
+        else {
+            storeId = this.spaceDoc.guid;
+        }
+        return this._storeContainer.getStore({
+            id: storeId,
+            readonly,
+            query,
+            provider,
+            extensions: storeExtensions,
+        });
+    }
+    load(initFn) {
+        if (this.ready) {
+            return this;
+        }
+        this._ySpaceDoc.load();
+        initFn?.();
+        this._ready = true;
+        return this;
+    }
+    remove() {
+        this._destroy();
+        this.rootDoc.getMap('spaces').delete(this.id);
+    }
+}

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

@@ -0,0 +1,4 @@
+export { DocImpl } from './doc.js';
+export { type DocCollectionOptions, type WorkspaceOptions, } from './workspace-base.js';
+export { WorkspaceImpl } from './workspace.js';
+export { WorkspaceMetaImpl } from './workspace-meta.js';

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

@@ -0,0 +1,4 @@
+export { DocImpl } from './doc.js';
+export {} from './workspace-base.js';
+export { WorkspaceImpl } from './workspace.js';
+export { WorkspaceMetaImpl } from './workspace-meta.js';

package/dist/_pkgs/store/impls/workspace-base.d.ts

@@ -0,0 +1,81 @@
+import { AwarenessEngine, type AwarenessSource, BlobEngine, type BlobSource, DocEngine, type DocSource } from '../../sync/index.js';
+import { Subject } from 'rxjs';
+import * as Y from 'yjs';
+import type { Doc, ExtensionType, Workspace, WorkspaceMeta } from '../extension/index.js';
+import { type IdGenerator } from '../utils/id-generator.js';
+import { AwarenessStore } from '../yjs/index.js';
+import { DocImpl } from './doc.js';
+export type WorkspaceOptions = {
+    id?: string;
+    idGenerator?: IdGenerator;
+    docSources?: {
+        main: DocSource;
+        shadows?: DocSource[];
+    };
+    blobSources?: {
+        main: BlobSource;
+        shadows?: BlobSource[];
+    };
+    awarenessSources?: AwarenessSource[];
+};
+/** @deprecated Kept for backward compatibility; use {@link WorkspaceOptions}. */
+export type DocCollectionOptions = WorkspaceOptions;
+/**
+ * @internal
+ * The self-contained {@link Workspace} implementation shared by the public
+ * {@link WorkspaceImpl} and the test-only `TestWorkspace`. It owns its root
+ * `Y.Doc` and wires `DocEngine`/`AwarenessEngine`/`BlobEngine` from the given
+ * sources — defaulting to in-memory no-ops. Consumers that persist/sync do so
+ * on the exposed `Y.Doc`s (see `.doc` and `getDoc(...).spaceDoc`), or by
+ * passing real `docSources`/`blobSources`.
+ *
+ * Not part of any public entry point; import {@link WorkspaceImpl} instead.
+ */
+export declare class WorkspaceBase implements Workspace {
+    storeExtensions: ExtensionType[];
+    readonly awarenessStore: AwarenessStore;
+    readonly awarenessSync: AwarenessEngine;
+    readonly blobSync: BlobEngine;
+    readonly blockCollections: Map<string, DocImpl>;
+    readonly doc: Y.Doc;
+    readonly docSync: DocEngine;
+    readonly id: string;
+    readonly idGenerator: IdGenerator;
+    meta: WorkspaceMeta;
+    slots: {
+        docListUpdated: Subject<void>;
+    };
+    get docs(): Map<string, DocImpl>;
+    constructor({ id, idGenerator, awarenessSources, docSources, blobSources, }?: WorkspaceOptions);
+    private _bindDocMetaEvents;
+    private _hasDoc;
+    /**
+     * Verify that all data has been successfully saved to the primary storage.
+     * Return true if the data transfer is complete and it is secure to terminate the synchronization operation.
+     */
+    canGracefulStop(): void;
+    /**
+     * By default, only an empty doc will be created.
+     * If the `init` parameter is passed, a `surface`, `note`, and `paragraph` block
+     * will be created in the doc simultaneously.
+     */
+    createDoc(docId?: string): Doc;
+    dispose(): void;
+    /**
+     * Terminate the data sync process forcefully, which may cause data loss.
+     * It is advised to invoke `canGracefulStop` before calling this method.
+     */
+    forceStop(): void;
+    getBlockCollection(docId: string): DocImpl | null;
+    getDoc(docId: string): Doc | null;
+    removeDoc(docId: string): void;
+    /**
+     * Start the data sync process
+     */
+    start(): void;
+    /**
+     * Wait for all data has been successfully saved to the primary storage.
+     */
+    waitForGracefulStop(abort?: AbortSignal): Promise<void>;
+    waitForSynced(): Promise<unknown>;
+}

package/dist/_pkgs/store/impls/workspace-base.js

@@ -0,0 +1,143 @@
+import { BlockSuiteError, ErrorCode } from '../../global/exceptions/index.js';
+import { NoopLogger } from '../../global/utils/index.js';
+import { AwarenessEngine, BlobEngine, DocEngine, MemoryBlobSource, NoopDocSource, } from '../../sync/index.js';
+import { Subject } from 'rxjs';
+import { Awareness } from 'y-protocols/awareness.js';
+import * as Y from 'yjs';
+import { nanoid } from '../utils/id-generator.js';
+import { AwarenessStore } from '../yjs/index.js';
+import { DocImpl } from './doc.js';
+import { WorkspaceMetaImpl } from './workspace-meta.js';
+/**
+ * @internal
+ * The self-contained {@link Workspace} implementation shared by the public
+ * {@link WorkspaceImpl} and the test-only `TestWorkspace`. It owns its root
+ * `Y.Doc` and wires `DocEngine`/`AwarenessEngine`/`BlobEngine` from the given
+ * sources — defaulting to in-memory no-ops. Consumers that persist/sync do so
+ * on the exposed `Y.Doc`s (see `.doc` and `getDoc(...).spaceDoc`), or by
+ * passing real `docSources`/`blobSources`.
+ *
+ * Not part of any public entry point; import {@link WorkspaceImpl} instead.
+ */
+export class WorkspaceBase {
+    get docs() {
+        return this.blockCollections;
+    }
+    constructor({ id, idGenerator, awarenessSources = [], docSources = {
+        main: new NoopDocSource(),
+    }, blobSources = {
+        main: new MemoryBlobSource(),
+    }, } = {}) {
+        this.storeExtensions = [];
+        this.blockCollections = new Map();
+        this.slots = {
+            docListUpdated: new Subject(),
+        };
+        this.id = id || '';
+        this.doc = new Y.Doc({ guid: id });
+        this.awarenessStore = new AwarenessStore(new Awareness(this.doc));
+        const logger = new NoopLogger();
+        this.awarenessSync = new AwarenessEngine(this.awarenessStore.awareness, awarenessSources);
+        this.docSync = new DocEngine(this.doc, docSources.main, docSources.shadows ?? [], logger);
+        this.blobSync = new BlobEngine(blobSources.main, blobSources.shadows ?? [], logger);
+        this.idGenerator = idGenerator ?? nanoid;
+        this.meta = new WorkspaceMetaImpl(this.doc);
+        this._bindDocMetaEvents();
+    }
+    _bindDocMetaEvents() {
+        this.meta.docMetaAdded.subscribe(docId => {
+            const doc = new DocImpl({
+                id: docId,
+                collection: this,
+                doc: this.doc,
+                awarenessStore: this.awarenessStore,
+            });
+            this.blockCollections.set(doc.id, doc);
+        });
+        this.meta.docMetaUpdated.subscribe(() => this.slots.docListUpdated.next());
+        this.meta.docMetaRemoved.subscribe(id => {
+            const space = this.getBlockCollection(id);
+            if (!space)
+                return;
+            this.blockCollections.delete(id);
+            space.remove();
+        });
+    }
+    _hasDoc(docId) {
+        return this.docs.has(docId);
+    }
+    /**
+     * Verify that all data has been successfully saved to the primary storage.
+     * Return true if the data transfer is complete and it is secure to terminate the synchronization operation.
+     */
+    canGracefulStop() {
+        this.docSync.canGracefulStop();
+    }
+    /**
+     * By default, only an empty doc will be created.
+     * If the `init` parameter is passed, a `surface`, `note`, and `paragraph` block
+     * will be created in the doc simultaneously.
+     */
+    createDoc(docId) {
+        const id = docId ?? this.idGenerator();
+        if (this._hasDoc(id)) {
+            throw new BlockSuiteError(ErrorCode.DocCollectionError, 'doc already exists');
+        }
+        this.meta.addDocMeta({
+            id,
+            title: '',
+            createDate: Date.now(),
+            tags: [],
+        });
+        return this.getDoc(id);
+    }
+    dispose() {
+        this.awarenessStore.destroy();
+    }
+    /**
+     * Terminate the data sync process forcefully, which may cause data loss.
+     * It is advised to invoke `canGracefulStop` before calling this method.
+     */
+    forceStop() {
+        this.docSync.forceStop();
+        this.blobSync.stop();
+        this.awarenessSync.disconnect();
+    }
+    getBlockCollection(docId) {
+        const space = this.docs.get(docId);
+        return space ?? null;
+    }
+    getDoc(docId) {
+        const collection = this.getBlockCollection(docId);
+        return collection;
+    }
+    removeDoc(docId) {
+        const docMeta = this.meta.getDocMeta(docId);
+        if (!docMeta) {
+            throw new BlockSuiteError(ErrorCode.DocCollectionError, `doc meta not found: ${docId}`);
+        }
+        const blockCollection = this.getBlockCollection(docId);
+        if (!blockCollection)
+            return;
+        blockCollection.dispose();
+        this.meta.removeDocMeta(docId);
+        this.blockCollections.delete(docId);
+    }
+    /**
+     * Start the data sync process
+     */
+    start() {
+        this.docSync.start();
+        this.blobSync.start();
+        this.awarenessSync.connect();
+    }
+    /**
+     * Wait for all data has been successfully saved to the primary storage.
+     */
+    waitForGracefulStop(abort) {
+        return this.docSync.waitForGracefulStop(abort);
+    }
+    waitForSynced() {
+        return this.docSync.waitForSynced();
+    }
+}

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

@@ -0,0 +1,33 @@
+import { Subject } from 'rxjs';
+import type * as Y from 'yjs';
+import type { DocMeta, DocsPropertiesMeta, WorkspaceMeta } from '../extension/index.js';
+type DocCollectionMetaState = {
+    pages?: unknown[];
+    properties?: DocsPropertiesMeta;
+    name?: string;
+    avatar?: string;
+};
+export declare class WorkspaceMetaImpl implements WorkspaceMeta {
+    private readonly _handleDocCollectionMetaEvents;
+    private _prevDocs;
+    protected readonly _proxy: DocCollectionMetaState;
+    protected readonly _yMap: Y.Map<DocCollectionMetaState[keyof DocCollectionMetaState]>;
+    readonly doc: Y.Doc;
+    docMetaAdded: Subject<string>;
+    docMetaRemoved: Subject<string>;
+    docMetaUpdated: Subject<void>;
+    readonly id: string;
+    get docMetas(): DocMeta[];
+    get docs(): unknown[] | undefined;
+    get properties(): DocsPropertiesMeta;
+    get yDocs(): Y.Array<unknown>;
+    constructor(doc: Y.Doc);
+    private _handleDocMetaEvent;
+    addDocMeta(doc: DocMeta, index?: number): void;
+    getDocMeta(id: string): DocMeta | undefined;
+    initialize(): void;
+    removeDocMeta(id: string): void;
+    setDocMeta(id: string, props: Partial<DocMeta>): void;
+    setProperties(meta: DocsPropertiesMeta): void;
+}
+export {};

package/dist/_pkgs/store/impls/workspace-meta.js

@@ -0,0 +1,125 @@
+import { Subject } from 'rxjs';
+import { createYProxy } from '../reactive/proxy.js';
+export class WorkspaceMetaImpl {
+    get docMetas() {
+        if (!this._proxy.pages) {
+            return [];
+        }
+        return this._proxy.pages;
+    }
+    get docs() {
+        return this._proxy.pages;
+    }
+    get properties() {
+        const meta = this._proxy.properties;
+        if (!meta) {
+            return {
+                tags: {
+                    options: [],
+                },
+            };
+        }
+        return meta;
+    }
+    get yDocs() {
+        return this._yMap.get('pages');
+    }
+    constructor(doc) {
+        this._handleDocCollectionMetaEvents = (events) => {
+            events.forEach(e => {
+                const hasKey = (k) => e.target === this._yMap && e.changes.keys.has(k);
+                if (e.target === this.yDocs ||
+                    e.target.parent === this.yDocs ||
+                    hasKey('pages')) {
+                    this._handleDocMetaEvent();
+                }
+            });
+        };
+        this._prevDocs = new Set();
+        this.docMetaAdded = new Subject();
+        this.docMetaRemoved = new Subject();
+        this.docMetaUpdated = new Subject();
+        this.id = 'meta';
+        this.doc = doc;
+        const map = doc.getMap(this.id);
+        this._yMap = map;
+        this._proxy = createYProxy(map);
+        this._yMap.observeDeep(this._handleDocCollectionMetaEvents);
+    }
+    _handleDocMetaEvent() {
+        const { docMetas, _prevDocs } = this;
+        const newDocs = new Set();
+        docMetas.forEach(docMeta => {
+            if (!_prevDocs.has(docMeta.id)) {
+                this.docMetaAdded.next(docMeta.id);
+            }
+            newDocs.add(docMeta.id);
+        });
+        _prevDocs.forEach(prevDocId => {
+            const isRemoved = newDocs.has(prevDocId) === false;
+            if (isRemoved) {
+                this.docMetaRemoved.next(prevDocId);
+            }
+        });
+        this._prevDocs = newDocs;
+        this.docMetaUpdated.next();
+    }
+    addDocMeta(doc, index) {
+        this.doc.transact(() => {
+            if (!this.docs) {
+                return;
+            }
+            const docs = this.docs;
+            if (index === undefined) {
+                docs.push(doc);
+            }
+            else {
+                docs.splice(index, 0, doc);
+            }
+        }, this.doc.clientID);
+    }
+    getDocMeta(id) {
+        return this.docMetas.find(doc => doc.id === id);
+    }
+    initialize() {
+        if (!this._proxy.pages) {
+            this._proxy.pages = [];
+        }
+    }
+    removeDocMeta(id) {
+        // you cannot delete a doc if there's no doc
+        if (!this.docs) {
+            return;
+        }
+        const docMeta = this.docMetas;
+        const index = docMeta.findIndex((doc) => id === doc.id);
+        if (index === -1) {
+            return;
+        }
+        this.doc.transact(() => {
+            if (!this.docs) {
+                return;
+            }
+            this.docs.splice(index, 1);
+        }, this.doc.clientID);
+    }
+    setDocMeta(id, props) {
+        const docs = this.docs ?? [];
+        const index = docs.findIndex((doc) => id === doc.id);
+        this.doc.transact(() => {
+            if (!this.docs) {
+                return;
+            }
+            if (index === -1)
+                return;
+            const doc = this.docs[index];
+            Object.entries(props).forEach(([key, value]) => {
+                doc[key] = value;
+            });
+        }, this.doc.clientID);
+    }
+    setProperties(meta) {
+        this._proxy.properties = meta;
+        this.docMetaUpdated.next();
+    }
+}

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

@@ -0,0 +1,14 @@
+import { WorkspaceBase } from './workspace-base.js';
+/**
+ * The production {@link Workspace} implementation. Self-contained: it creates
+ * its own root `Y.Doc` and, by default, in-memory no-op sync engines — a host
+ * that persists/syncs does so on the exposed `Y.Doc`s (`.doc`,
+ * `getDoc(...).spaceDoc`) or by passing real `docSources`/`blobSources` to the
+ * constructor.
+ *
+ * Independent from the test-only `TestWorkspace` (both derive from the shared
+ * internal {@link WorkspaceBase}, neither extends the other) so test-only
+ * evolutions never reach production.
+ */
+export declare class WorkspaceImpl extends WorkspaceBase {
+}

package/dist/_pkgs/store/impls/workspace.js

@@ -0,0 +1,14 @@
+import { WorkspaceBase } from './workspace-base.js';
+/**
+ * The production {@link Workspace} implementation. Self-contained: it creates
+ * its own root `Y.Doc` and, by default, in-memory no-op sync engines — a host
+ * that persists/syncs does so on the exposed `Y.Doc`s (`.doc`,
+ * `getDoc(...).spaceDoc`) or by passing real `docSources`/`blobSources` to the
+ * constructor.
+ *
+ * Independent from the test-only `TestWorkspace` (both derive from the shared
+ * internal {@link WorkspaceBase}, neither extends the other) so test-only
+ * evolutions never reach production.
+ */
+export class WorkspaceImpl extends WorkspaceBase {
+}

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

@@ -1,8 +1,9 @@
-export * from './adapter';
-export * from './extension';
-export * from './model';
-export * from './reactive';
-export * from './schema';
-export * from './transformer';
-export { type IdGenerator, nanoid, uuidv4 } from './utils/id-generator';
-export * from './yjs';
+export * from './adapter/index.js';
+export * from './extension/index.js';
+export * from './impls/index.js';
+export * from './model/index.js';
+export * from './reactive/index.js';
+export * from './schema/index.js';
+export * from './transformer/index.js';
+export { type IdGenerator, nanoid, uuidv4 } from './utils/id-generator.js';
+export * from './yjs/index.js';

package/dist/_pkgs/store/index.js

@@ -1,11 +1,12 @@
-export * from './adapter';
-export * from './extension';
-export * from './model';
-export * from './reactive';
-export * from './schema';
-export * from './transformer';
-export { nanoid, uuidv4 } from './utils/id-generator';
-export * from './yjs';
+export * from './adapter/index.js';
+export * from './extension/index.js';
+export * from './impls/index.js';
+export * from './model/index.js';
+export * from './reactive/index.js';
+export * from './schema/index.js';
+export * from './transformer/index.js';
+export { nanoid, uuidv4 } from './utils/id-generator.js';
+export * from './yjs/index.js';
 const env = (typeof globalThis !== 'undefined'
     ? globalThis
     : typeof window !== 'undefined'

package/dist/_pkgs/store/model/block/flat-sync-controller.js

@@ -22,11 +22,12 @@ export class FlatSyncController {
             throw new BlockSuiteError(ErrorCode.ModelCRUDError, `schema for flavour: ${this.flavour} not found`);
         }
         const model = schema.model.toModel?.() ?? new BlockModel();
+        const defaultProps = schema.model.props?.(internalPrimitives);
         model.schema = schema;
         model.id = this.id;
         model.keys = Array.from(props);
         model.yBlock = this.yBlock;
-        const reactive = new ReactiveFlatYMap(this.yBlock, model.deleted, this.onChange);
+        const reactive = new ReactiveFlatYMap(this.yBlock, model.deleted, this.onChange, defaultProps);
         this._reactive = reactive;
         const proxy = reactive.proxy;
         model._props = proxy;
@@ -35,17 +36,6 @@ export class FlatSyncController {
         if (this.doc) {
             model.store = this.doc;
         }
-        const defaultProps = schema.model.props?.(internalPrimitives);
-        if (defaultProps) {
-            Object.entries(defaultProps).forEach(([key, value]) => {
-                if (key in proxy) {
-                    return;
-                }
-                if (value === undefined)
-                    return;
-                proxy[key] = value;
-            });
-        }
         return model;
     }
     _parseYBlock() {

package/dist/_pkgs/store/model/store/crud.js

@@ -190,10 +190,13 @@ export class DocCRUD {
         return findParent(root);
     }
     getPrev(id) {
-        return this._getSiblings(id, (index, parent) => parent
-            .get('sys:children')
-            .toArray()
-            .at(index - 1) ?? null);
+        return this._getSiblings(id, (index, parent) => {
+            // `at(-1)` would wrap around to the last child, so the first child has to
+            // be answered before indexing.
+            if (index === 0)
+                return null;
+            return parent.get('sys:children').toArray().at(index - 1) ?? null;
+        });
     }
     moveBlocks(blocksToMove, newParent, targetSibling = null, shouldInsertBeforeSibling = true) {
         if (blocksToMove.length > 1 &&

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

@@ -1,2 +1,2 @@
-import type { Store } from './store';
+import type { Store } from './store.js';
 export declare const StoreIdentifier: import("../../../global/di/types.js").ServiceIdentifier<Store> & (<U extends Store = Store>(variant: import("../../../global/di/types.js").ServiceVariant) => import("../../../global/di/types.js").ServiceIdentifier<U>);

package/dist/_pkgs/store/model/store-container.d.ts

@@ -1,5 +1,5 @@
-import type { Doc, GetStoreOptions, RemoveStoreOptions } from '../extension';
-import { Store } from './store';
+import type { Doc, GetStoreOptions, RemoveStoreOptions } from '../extension/index.js';
+import { Store } from './store/index.js';
 export declare class StoreContainer {
     readonly doc: Doc;
     private readonly _storeMap;

package/dist/_pkgs/store/model/store-container.js

@@ -1,5 +1,5 @@
-import { DocIdentifier } from '../extension/workspace';
-import { Store } from './store';
+import { DocIdentifier } from '../extension/workspace/index.js';
+import { Store } from './store/index.js';
 export class StoreContainer {
     constructor(doc) {
         this.doc = doc;

package/dist/_pkgs/store/reactive/base-reactive-data.d.ts

@@ -1,5 +1,5 @@
 import * as Y from 'yjs';
-import type { ProxyOptions } from './types';
+import type { ProxyOptions } from './types.js';
 export declare abstract class BaseReactiveYData<T, YSource extends Y.AbstractType<any>> {
     protected _getOrigin: (doc: Y.Doc) => {
         doc: Y.Doc;