@formicoidea/labre-core 0.30.1 → 0.31.0

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/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;

package/dist/_pkgs/store/reactive/flat-native-y/index.d.ts

@@ -1,8 +1,8 @@
 import type { Subject } from 'rxjs';
 import { type Map as YMap } from 'yjs';
-import { BaseReactiveYData } from '../base-reactive-data';
-import type { ProxyOptions, UnRecord } from '../types';
-import type { OnChange } from './types';
+import { BaseReactiveYData } from '../base-reactive-data.js';
+import type { ProxyOptions, UnRecord } from '../types.js';
+import type { OnChange } from './types.js';
 export declare class ReactiveFlatYMap extends BaseReactiveYData<UnRecord, YMap<unknown>> {
     protected readonly _ySource: YMap<unknown>;
     private readonly _onDispose;

package/dist/_pkgs/store/reactive/flat-native-y/index.js

@@ -1,12 +1,12 @@
 import { signal } from '@preact/signals-core';
 import { Array as YArray } from 'yjs';
-import { BaseReactiveYData } from '../base-reactive-data';
-import { Boxed } from '../boxed';
-import { ReactiveYArray } from '../proxy';
-import { Text } from '../text';
-import { initializeData } from './initialize';
-import { createProxy } from './proxy';
-import { getYEventHandler } from './y-event-handler';
+import { BaseReactiveYData } from '../base-reactive-data.js';
+import { Boxed } from '../boxed.js';
+import { ReactiveYArray } from '../proxy.js';
+import { Text } from '../text/index.js';
+import { initializeData } from './initialize.js';
+import { createProxy } from './proxy.js';
+import { getYEventHandler } from './y-event-handler.js';
 export class ReactiveFlatYMap extends BaseReactiveYData {
     constructor(_ySource, _onDispose, _onChange) {
         super();

package/dist/_pkgs/store/reactive/flat-native-y/initialize.d.ts

@@ -1,5 +1,5 @@
-import type { UnRecord } from '../types';
-import type { CreateProxyOptions } from './types';
+import type { UnRecord } from '../types.js';
+import type { CreateProxyOptions } from './types.js';
 type InitializeDataOptions = Pick<CreateProxyOptions, 'transform' | 'yMap'> & {
     getProxy: (source: UnRecord, root: UnRecord, path?: string) => UnRecord;
 };

package/dist/_pkgs/store/reactive/flat-native-y/initialize.js

@@ -1,8 +1,8 @@
 import { BlockSuiteError } from '../../../global/exceptions/index.js';
 import { Array as YArray, Map as YMap, Text as YText } from 'yjs';
-import { Boxed } from '../boxed';
-import { Text } from '../text';
-import { keyWithoutPrefix } from './utils';
+import { Boxed } from '../boxed.js';
+import { Text } from '../text/index.js';
+import { keyWithoutPrefix } from './utils.js';
 // Create default data object from yjs map
 export const initializeData = ({ getProxy, transform, yMap, }) => {
     const root = {};

package/dist/_pkgs/store/reactive/flat-native-y/proxy.d.ts

@@ -1,3 +1,3 @@
-import type { UnRecord } from '../types';
-import type { CreateProxyOptions } from './types';
+import type { UnRecord } from '../types.js';
+import type { CreateProxyOptions } from './types.js';
 export declare function createProxy(options: CreateProxyOptions): UnRecord;

package/dist/_pkgs/store/reactive/flat-native-y/proxy.js

@@ -1,9 +1,9 @@
 import { signal } from '@preact/signals-core';
-import { isPureObject } from '../is-pure-object';
-import { native2Y } from '../native-y';
-import { signalUpdater } from './signal-updater';
-import { bindOnChangeIfNeed, getFirstKey, isProxy, keyWithPrefix, markProxy, } from './utils';
-import { yMapUpdater } from './y-map-updater';
+import { isPureObject } from '../is-pure-object.js';
+import { native2Y } from '../native-y.js';
+import { signalUpdater } from './signal-updater.js';
+import { bindOnChangeIfNeed, getFirstKey, isProxy, keyWithPrefix, markProxy, } from './utils.js';
+import { yMapUpdater } from './y-map-updater.js';
 export function createProxy(options) {
     const { base } = options;
     if (isProxy(base)) {

package/dist/_pkgs/store/reactive/flat-native-y/signal-updater.d.ts

@@ -1,4 +1,4 @@
-import type { CreateProxyOptions } from './types';
+import type { CreateProxyOptions } from './types.js';
 type UpdateSignalOptions = Pick<CreateProxyOptions, 'shouldByPassSignal' | 'root' | 'onChange' | 'byPassSignalUpdate' | 'basePath' | 'shouldByPassYjs'> & {
     firstKey: string;
     value: unknown;

package/dist/_pkgs/store/reactive/flat-native-y/signal-updater.js

@@ -1,4 +1,4 @@
-import { isPureObject } from '../is-pure-object';
+import { isPureObject } from '../is-pure-object.js';
 export function signalUpdater({ root, firstKey, shouldByPassSignal, byPassSignalUpdate, onChange, basePath, value, handleNestedUpdate, shouldByPassYjs, }) {
     const isRoot = !basePath;
     if (shouldByPassSignal()) {

package/dist/_pkgs/store/reactive/flat-native-y/types.d.ts

@@ -1,6 +1,6 @@
 import type { Subject } from 'rxjs';
 import type { Map as YMap } from 'yjs';
-import type { UnRecord } from '../types';
+import type { UnRecord } from '../types.js';
 export type OnChange = (key: string, isLocal: boolean) => void;
 export type Transform = (key: string, value: unknown, origin: unknown) => unknown;
 export type CreateProxyOptions = {

package/dist/_pkgs/store/reactive/flat-native-y/utils.d.ts

@@ -1,4 +1,4 @@
-import type { UnRecord } from '../types';
+import type { UnRecord } from '../types.js';
 export declare const keyWithoutPrefix: (key: string) => string;
 export declare const keyWithPrefix: (key: string) => string;
 export declare function isProxy(value: unknown): boolean;

package/dist/_pkgs/store/reactive/flat-native-y/utils.js

@@ -1,6 +1,6 @@
-import { SYS_KEYS } from '../../consts';
-import { Boxed } from '../boxed';
-import { Text } from '../text';
+import { SYS_KEYS } from '../../consts.js';
+import { Boxed } from '../boxed.js';
+import { Text } from '../text/index.js';
 export const keyWithoutPrefix = (key) => key.replace(/(prop|sys):/, '');
 export const keyWithPrefix = (key) => SYS_KEYS.has(key) ? `sys:${key}` : `prop:${key}`;
 const proxySymbol = Symbol('proxy');

package/dist/_pkgs/store/reactive/flat-native-y/y-event-handler.d.ts

@@ -1,5 +1,5 @@
 import type { Map as YMap, YMapEvent } from 'yjs';
-import type { UnRecord } from '../types';
+import type { UnRecord } from '../types.js';
 type YEventHandlerOptions = {
     event: YMapEvent<unknown>;
     yMap: YMap<unknown>;

package/dist/_pkgs/store/reactive/flat-native-y/y-event-handler.js

@@ -1,5 +1,5 @@
-import { y2Native } from '../native-y';
-import { deleteEmptyObject, getFirstKey, isEmptyObject, keyWithoutPrefix, } from './utils';
+import { y2Native } from '../native-y.js';
+import { deleteEmptyObject, getFirstKey, isEmptyObject, keyWithoutPrefix, } from './utils.js';
 // update proxy when yjs map changes
 export const getYEventHandler = (options) => {
     const { event } = options;

package/dist/_pkgs/store/reactive/flat-native-y/y-map-updater.d.ts

@@ -1,4 +1,4 @@
-import type { CreateProxyOptions } from './types';
+import type { CreateProxyOptions } from './types.js';
 type YMapOptions = Pick<CreateProxyOptions, 'shouldByPassYjs' | 'yMap' | 'initialized' | 'onChange'> & {
     fullPath: string;
     value: unknown;

package/dist/_pkgs/store/reactive/flat-native-y/y-map-updater.js

@@ -1,6 +1,6 @@
-import { isPureObject } from '../is-pure-object';
-import { native2Y } from '../native-y';
-import { bindOnChangeIfNeed, getFirstKey, keyWithoutPrefix, keyWithPrefix, } from './utils';
+import { isPureObject } from '../is-pure-object.js';
+import { native2Y } from '../native-y.js';
+import { bindOnChangeIfNeed, getFirstKey, keyWithoutPrefix, keyWithPrefix, } from './utils.js';
 export function yMapUpdater({ shouldByPassYjs, yMap, initialized, onChange, fullPath, value, }) {
     const firstKey = getFirstKey(fullPath);
     if (shouldByPassYjs()) {

package/dist/_pkgs/store/reactive/memory.d.ts

@@ -1,3 +1,3 @@
-import type { BaseReactiveYData } from './base-reactive-data';
+import type { BaseReactiveYData } from './base-reactive-data.js';
 export declare const proxies: WeakMap<any, BaseReactiveYData<any, any>>;
 export declare const flatProxies: WeakMap<any, BaseReactiveYData<any, any>>;

package/dist/_pkgs/store/reactive/stash-pop.js

@@ -1,4 +1,4 @@
-import { proxies } from './memory';
+import { proxies } from './memory.js';
 export function stashProp(yAbstract, prop) {
     const proxy = proxies.get(yAbstract);
     proxy?.stash(prop);

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

@@ -1,3 +1,3 @@
-export * from './attributes';
-export * from './text';
-export * from './types';
+export * from './attributes.js';
+export * from './text.js';
+export * from './types.js';

package/dist/_pkgs/store/reactive/text/index.js

@@ -1,3 +1,3 @@
-export * from './attributes';
-export * from './text';
-export * from './types';
+export * from './attributes.js';
+export * from './text.js';
+export * from './types.js';

package/dist/_pkgs/store/reactive/text/text.d.ts

@@ -1,7 +1,7 @@
 import { type Signal } from '@preact/signals-core';
 import * as Y from 'yjs';
-import type { BaseTextAttributes } from './attributes';
-import type { DeltaInsert, DeltaOperation, OnTextChange } from './types';
+import type { BaseTextAttributes } from './attributes.js';
+import type { DeltaInsert, DeltaOperation, OnTextChange } from './types.js';
 /**
  * Text is an abstraction of Y.Text.
  * It provides useful methods to manipulate the text content.

package/dist/_pkgs/store/reactive/text/types.d.ts

@@ -1,5 +1,5 @@
 import type * as Y from 'yjs';
-import type { BaseTextAttributes } from './attributes';
+import type { BaseTextAttributes } from './attributes.js';
 export interface OptionalAttributes {
     attributes?: Record<string, any>;
 }