@hachej/boring-ui-kit 0.1.110 → 0.2.0

package/dist/text-buffer.js

@@ -0,0 +1,315 @@
+import { PublicationNotDispatchedError, parsePublicationResult, publicationDigest } from '@hachej/boring-files/publication';
+import { createTextDrafts } from './text-drafts.js';
+import { randomUUID } from '@hachej/boring-files/platform';
+export function freeze(value) {
+    if (value !== null && typeof value === 'object') {
+        Object.freeze(value);
+        for (const nested of Object.values(value))
+            freeze(nested);
+    }
+    return value;
+}
+function sameLocator(left, right) {
+    return left.resource.providerId === right.resource.providerId && left.resource.path === right.resource.path
+        && left.view.kind === right.view.kind
+        && (left.view.kind === 'published' || (right.view.kind === 'working' && left.view.viewId === right.view.viewId));
+}
+export function sameBase(left, right) {
+    return sameLocator(left.target, right.target) && left.kind === right.kind
+        && (left.kind === 'absent' || (right.kind === 'revision' && left.target.revision === right.target.revision));
+}
+export function createTextBuffer(options) {
+    const { instanceId, epoch, client } = options;
+    if (!instanceId || !epoch)
+        throw new TypeError('Viewer instance and epoch are required');
+    const identity = freeze({ ...options.identity });
+    if ([identity.scopeId, identity.principalId, identity.initiatorId].some(value => typeof value !== 'string' || !value))
+        throw new TypeError('Expected authenticated identity is required');
+    const initial = options.source;
+    const base = initial.kind === 'saved'
+        ? { kind: 'revision', target: structuredClone(initial.snapshot.ref) }
+        : { kind: 'absent', target: structuredClone(initial.target) };
+    let savedText = initial.kind === 'saved' ? options.readText(initial.snapshot) : '';
+    let state = freeze({ identity, text: initial.kind === 'saved' ? savedText : initial.text ?? '', base, bufferVersion: 0, readOnly: options.readOnly === true, dirty: initial.kind === 'new', lifecycle: 'active', save: { kind: 'idle' }, remote: null, recovery: { kind: 'disabled' } });
+    const listeners = new Set();
+    let attempt;
+    /** A save whose lookup found no receipt. Refresh, Discard and Abandon may release it and keep the local text as a draft. */
+    let unreceipted;
+    let refreshSequence = 0;
+    let drafts;
+    function update(next) {
+        state = freeze(next);
+        drafts?.capture();
+        notify();
+    }
+    function notify() {
+        for (const listener of [...listeners]) {
+            try {
+                listener();
+            }
+            catch (error) {
+                queueMicrotask(() => { if (options.onListenerError)
+                    options.onListenerError(error);
+                else
+                    throw error; });
+            }
+        }
+    }
+    function selection() {
+        return freeze({ target: { instanceId, epoch, subject: { scopeId: identity.scopeId, base: state.base, bufferVersion: state.bufferVersion } } });
+    }
+    function selected(value) {
+        return value.target.instanceId === instanceId && value.target.epoch === epoch
+            && value.target.subject.scopeId === identity.scopeId
+            && value.target.subject.bufferVersion === state.bufferVersion && sameBase(value.target.subject.base, state.base);
+    }
+    function unknown(current, reason) {
+        return { kind: 'unknown', operationId: current.request.operationId, reason };
+    }
+    function acknowledged(receipt, current, digest) {
+        if (receipt.operationId !== current.request.operationId || receipt.argumentDigest !== digest || !receipt.evidenceRef
+            || receipt.principalId !== identity.principalId || receipt.scopeId !== identity.scopeId
+            || receipt.initiatorId !== identity.initiatorId || receipt.changes.length !== 1)
+            return undefined;
+        const change = receipt.changes[0];
+        const expected = current.selection.target.subject.base;
+        if (!change || !change.after || !change.after.revision || !sameLocator(change.after, expected.target))
+            return undefined;
+        if (expected.kind === 'absent')
+            return change.kind === 'create' && change.before === null ? change.after : undefined;
+        return change.kind === 'replace' && change.before !== null && sameLocator(change.before, expected.target)
+            && change.before.revision === expected.target.revision ? change.after : undefined;
+    }
+    async function settle(current, value) {
+        let outcome;
+        try {
+            outcome = parsePublicationResult(value);
+        }
+        catch {
+            outcome = unknown(current, 'Publication returned a malformed acknowledgement');
+        }
+        if (outcome.kind === 'partial' || (outcome.kind === 'unknown' && outcome.operationId !== current.request.operationId)) {
+            outcome = unknown(current, 'Publication returned an outcome for a different operation or atomicity');
+        }
+        let result;
+        if (outcome.kind === 'committed') {
+            let ref;
+            try {
+                ref = acknowledged(outcome.receipt, current, await current.digest);
+            }
+            catch {
+                ref = undefined;
+            }
+            result = ref
+                ? { kind: 'saved', selection: current.selection, ref: structuredClone(ref), receipt: structuredClone(outcome.receipt) }
+                : unknown(current, 'Publication acknowledgement does not match the selected buffer');
+        }
+        else
+            result = outcome;
+        if (result.kind === 'saved')
+            drafts?.acknowledge(current.draft, current.text);
+        if (state.lifecycle !== 'disposed')
+            options.sync?.();
+        if (attempt !== current)
+            return result;
+        if (result.kind !== 'unknown')
+            attempt = undefined;
+        if (state.lifecycle === 'disposed')
+            return result;
+        if (result.kind === 'saved') {
+            savedText = current.text;
+            update({ ...state, base: { kind: 'revision', target: result.ref }, dirty: state.text !== savedText, save: { kind: 'settled', result }, remote: null });
+        }
+        else
+            update({ ...state, save: { kind: 'settled', result } });
+        return result;
+    }
+    const flush = (value, signal) => {
+        if (state.lifecycle === 'disposed')
+            return Promise.resolve({ kind: 'unavailable', reason: 'Viewer is disposed' });
+        if (state.readOnly)
+            return Promise.resolve({ kind: 'denied', reason: 'Viewer is read-only' });
+        if (attempt) {
+            const previous = attempt.selection.target;
+            if (previous.instanceId === value.target.instanceId && previous.epoch === value.target.epoch
+                && previous.subject.scopeId === value.target.subject.scopeId
+                && previous.subject.bufferVersion === value.target.subject.bufferVersion && sameBase(previous.subject.base, value.target.subject.base))
+                return attempt.promise;
+            return Promise.resolve(unknown(attempt, 'Reconcile or await the earlier save before saving another buffer'));
+        }
+        if (!selected(value))
+            return Promise.resolve({ kind: 'conflict', current: state.base.kind === 'revision' ? [state.base.target] : [], reason: 'Save selection is stale or belongs to another viewer' });
+        const publish = client.publish?.bind(client);
+        if (!publish)
+            return Promise.resolve({ kind: 'unavailable', reason: 'Publication is unavailable' });
+        if (signal?.aborted)
+            return Promise.resolve({ kind: 'denied', reason: 'Save was cancelled before publication' });
+        const captured = structuredClone(value);
+        const selectedBase = captured.target.subject.base;
+        const bytes = new TextEncoder().encode(state.text);
+        if (new TextDecoder('utf-8', { ignoreBOM: true }).decode(bytes) !== state.text)
+            return Promise.resolve({ kind: 'denied', reason: 'Document text contains invalid Unicode' });
+        const request = {
+            operationId: randomUUID(), atomicity: 'all-or-nothing',
+            changes: [selectedBase.kind === 'absent'
+                    ? { kind: 'create', target: selectedBase.target, expected: { kind: 'absent' }, bytes, mediaType: options.mediaType }
+                    : { kind: 'replace', target: selectedBase.target, bytes, mediaType: options.mediaType }],
+        };
+        const current = {
+            selection: freeze(captured), text: state.text, request, digest: publicationDigest(request), draft: drafts?.capture(),
+            promise: Promise.resolve().then(async () => {
+                try {
+                    await current.digest;
+                }
+                catch {
+                    return settle(current, { kind: 'unavailable', reason: 'Publication request could not be prepared' });
+                }
+                let outcome;
+                try {
+                    outcome = await publish(request, signal);
+                }
+                catch (error) {
+                    outcome = error instanceof PublicationNotDispatchedError && error.operationId === request.operationId
+                        ? { kind: 'unavailable', reason: error.message }
+                        : unknown(current, 'Publication acknowledgement was lost');
+                }
+                return settle(current, outcome);
+            }),
+        };
+        attempt = current;
+        update({ ...state, save: { kind: 'pending', operationId: request.operationId } });
+        return current.promise;
+    };
+    const reconcile = async () => {
+        const current = attempt;
+        if (!current)
+            return state.save.kind === 'settled' ? state.save.result : { kind: 'unavailable', reason: 'No save needs reconciliation' };
+        await current.promise;
+        if (attempt !== current)
+            return current.promise;
+        if (!client.lookup)
+            return unknown(current, 'Operation lookup is unavailable');
+        let outcome;
+        try {
+            outcome = await client.lookup(current.request.operationId);
+        }
+        catch {
+            return unknown(current, 'Operation lookup failed');
+        }
+        if (outcome && typeof outcome === 'object' && 'kind' in outcome && outcome.kind === 'not-found') {
+            if (attempt === current)
+                unreceipted = current;
+            return unknown(current, 'No retained receipt; the save must not be replayed blindly. Refresh or discard to keep the text as a draft.');
+        }
+        return settle(current, outcome);
+    };
+    async function refresh(discard) {
+        if (state.lifecycle === 'disposed')
+            return { kind: 'unavailable', reason: 'Viewer is disposed' };
+        const released = attempt !== undefined && attempt === unreceipted ? attempt : undefined;
+        if (attempt !== released)
+            return { kind: 'unavailable', reason: 'A save must be acknowledged before refreshing' };
+        const sequence = ++refreshSequence;
+        const previousBase = state.base;
+        const previousVersion = state.bufferVersion;
+        const read = await client.read({ target: previousBase.target, revision: { kind: 'latest' } });
+        if (!disposed())
+            options.sync?.();
+        if (disposed() || sequence !== refreshSequence || attempt !== released || !sameBase(previousBase, state.base))
+            return read;
+        if (read.kind !== 'available' && read.kind !== 'missing')
+            return read;
+        if (read.kind === 'available' && !sameLocator(read.snapshot.ref, previousBase.target))
+            return { kind: 'unavailable', reason: 'Read returned a different resource' };
+        const remote = read.kind === 'available' ? { kind: 'revision', target: structuredClone(read.snapshot.ref) } : { kind: 'absent', target: previousBase.target };
+        if (released) {
+            attempt = undefined;
+            unreceipted = undefined;
+            update({ ...state, save: { kind: 'idle' } });
+        }
+        // A document that was saved and is now missing is deleted remotely. Never turn it into empty content.
+        if (read.kind === 'missing' && previousBase.kind === 'revision') {
+            update({ ...state, remote });
+            return read;
+        }
+        if (sameBase(remote, state.base) && !discard) {
+            if (state.remote !== null)
+                update({ ...state, remote: null });
+            return read;
+        }
+        if (state.dirty && (!discard || state.bufferVersion !== previousVersion)) {
+            update({ ...state, remote });
+            return read;
+        }
+        let decoded;
+        try {
+            decoded = read.kind === 'available' ? options.readText(read.snapshot) : options.emptyText ?? '';
+            if (disposed() || sequence !== refreshSequence || attempt || !sameBase(previousBase, state.base) || state.bufferVersion !== previousVersion)
+                return read;
+            options.replaceText?.(decoded);
+            if (disposed() || sequence !== refreshSequence || attempt || !sameBase(previousBase, state.base) || state.bufferVersion !== previousVersion)
+                return read;
+        }
+        catch {
+            return { kind: 'unavailable', reason: 'Remote document could not be decoded or validated' };
+        }
+        const discardedDraft = discard ? drafts?.currentRef() : undefined;
+        savedText = decoded;
+        update({ ...state, text: savedText, base: remote, bufferVersion: state.bufferVersion + 1, dirty: remote.kind === 'absent', remote: null, save: { kind: 'idle' } });
+        if (discardedDraft)
+            drafts?.remove(discardedDraft);
+        return read;
+    }
+    /** Give up waiting for an unknown save and refresh, keeping the draft. The save is never reported committed and never replayed. */
+    const abandon = async () => {
+        const current = attempt;
+        if (!current || state.save.kind !== 'settled' || state.save.result.kind !== 'unknown')
+            return { kind: 'unavailable', reason: 'No unconfirmed save to abandon' };
+        unreceipted = current;
+        return refresh(false);
+    };
+    function disposed() { return state.lifecycle === 'disposed'; }
+    function observe(text, force = false) {
+        if (disposed())
+            throw new Error('Viewer is disposed');
+        if (typeof text !== 'string')
+            throw new TypeError('Document text must be a string');
+        if (force || text !== state.text)
+            update({ ...state, text, bufferVersion: state.bufferVersion + 1, dirty: state.base.kind === 'absent' || text !== savedText });
+    }
+    drafts = createTextDrafts({
+        binding: options.drafts, emptyText: options.emptyText ?? '', snapshot: () => state, selection, selected, sameBase, sameLocator,
+        pending: () => attempt !== undefined, read: () => client.read({ target: state.base.target, revision: { kind: 'latest' } }),
+        sync: () => options.sync?.(),
+        changed: recovery => { state = freeze({ ...state, recovery }); notify(); },
+        restore: (text, guard) => {
+            options.replaceText?.(text);
+            if (!guard())
+                return false;
+            update({ ...state, text, bufferVersion: state.bufferVersion + 1, dirty: true, save: { kind: 'idle' }, remote: null });
+            return true;
+        },
+    });
+    state = freeze({ ...state, recovery: drafts.state() });
+    if (state.dirty && state.text)
+        drafts.capture();
+    return {
+        ...drafts.actions,
+        getSnapshot: () => state,
+        subscribe: (listener) => { if (disposed())
+            return () => { }; listeners.add(listener); return () => { listeners.delete(listener); }; },
+        edit: (text, force = false) => {
+            if (disposed())
+                throw new Error('Viewer is disposed');
+            if (state.readOnly)
+                throw new Error('Viewer is read-only');
+            observe(text, force);
+        },
+        observe, selection, refresh, abandon, reconcile, flush,
+        dispose: () => { if (!disposed()) {
+            drafts?.dispose();
+            update({ ...state, lifecycle: 'disposed' });
+            listeners.clear();
+        } },
+    };
+}

package/dist/text-draft-controls.d.ts

@@ -0,0 +1,9 @@
+import type { TextDraftActions, TextDraftRecoveryState } from './text-draft-types.js';
+export interface TextDraftControlsProps {
+    readonly recovery: TextDraftRecoveryState;
+    readonly actions: TextDraftActions;
+    readonly readOnly?: boolean;
+    readonly blocked?: boolean;
+}
+export declare function TextDraftControls({ recovery, actions, readOnly, blocked }: TextDraftControlsProps): import("react").JSX.Element | null;
+//# sourceMappingURL=text-draft-controls.d.ts.map

package/dist/text-draft-controls.js

@@ -0,0 +1,33 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useLayoutEffect, useRef, useState } from 'react';
+export function TextDraftControls({ recovery, actions, readOnly = false, blocked = false }) {
+    const owner = useRef({ actions, busy: false });
+    const [pending, setPending] = useState(false);
+    const [notice, setNotice] = useState();
+    useLayoutEffect(() => { owner.current = { actions, busy: false }; setPending(false); setNotice(undefined); return () => { if (owner.current?.actions === actions)
+        owner.current = undefined; }; }, [actions]);
+    if (recovery.kind === 'disabled')
+        return null;
+    const active = recovery.kind === 'active';
+    const run = (action) => {
+        if (!owner.current || owner.current.busy || owner.current.actions !== actions)
+            return;
+        const capturedOwner = owner.current;
+        capturedOwner.busy = true;
+        setPending(true);
+        setNotice(undefined);
+        void Promise.resolve().then(action).then(result => {
+            if (owner.current === capturedOwner)
+                setNotice(result.reason ?? (result.kind === 'restored' ? 'Draft restored locally. Save to publish it.' : result.kind === 'discarded' ? 'Stored draft discarded. Current edits are unchanged.' : undefined));
+        }, () => { if (owner.current === capturedOwner)
+            setNotice('Draft storage unavailable. Current edits are unchanged.'); }).finally(() => { if (owner.current === capturedOwner) {
+            capturedOwner.busy = false;
+            setPending(false);
+        } ; });
+    };
+    const discovery = active ? recovery.discovery : undefined;
+    const checkpoint = active ? recovery.checkpoint : undefined;
+    const status = !active ? `Draft recovery ${recovery.kind}` : discovery?.kind === 'checking' ? 'Checking stored drafts' : checkpoint?.kind === 'pending' ? 'Storing draft' : checkpoint?.kind === 'stored' ? 'Draft stored for recovery. Storage is not a save receipt.' : checkpoint?.kind === 'failed' ? 'Draft recovery storage unavailable' : 'Draft recovery enabled';
+    return _jsxs("section", { "data-boring": "text-draft-controls", "aria-label": "Draft recovery", children: [_jsx("p", { role: "status", children: status }), _jsx("button", { type: "button", disabled: !active || pending || blocked || discovery?.kind === 'checking', onClick: () => run(actions.checkDrafts), children: "Check stored drafts" }), _jsx("button", { type: "button", disabled: !active || pending || readOnly, onClick: () => run(actions.checkpointDraft), children: "Store draft for recovery" }), discovery?.kind === 'empty' && _jsx("p", { children: "No stored drafts" }), discovery && 'reason' in discovery && _jsx("p", { role: "alert", children: discovery.reason }), checkpoint?.kind === 'failed' && _jsx("p", { role: "alert", children: checkpoint.result.reason }), discovery?.kind === 'offered' && _jsxs(_Fragment, { children: [discovery.truncated && _jsx("p", { children: "More stored drafts exist than this listing shows." }), discovery.choices.map(choice => _jsxs("div", { role: "group", "aria-label": "Stored draft", children: [_jsx("p", { children: choice.compatibility === 'conflict' ? 'Saved revision changed. Review this draft separately.' : 'Stored draft matches the checked saved revision.' }), _jsxs("details", { children: [_jsx("summary", { children: "Review stored draft" }), _jsx("pre", { children: choice.text })] }), _jsx("button", { type: "button", disabled: pending || blocked || readOnly || choice.compatibility !== 'exact', onClick: () => run(() => actions.restoreDraft(choice.selection)), children: "Restore draft" }), _jsx("button", { type: "button", disabled: pending || blocked, onClick: () => run(() => actions.discardDraft(choice.selection)), children: "Discard stored draft" })] }, `${choice.selection.offerId}:${choice.selection.draft.writerId}:${choice.selection.draft.sequence}`))] }), notice && _jsx("p", { role: "alert", children: notice })] });
+}

package/dist/text-draft-types.d.ts

@@ -0,0 +1,111 @@
+import type { ResourceAccess, ResourceExpectation, ResourceLocator } from '@hachej/boring-files';
+import type { SaveSelection } from './resources.js';
+export interface TextDraftKey {
+    readonly identity: Pick<ResourceAccess, 'principalId' | 'scopeId' | 'initiatorId'>;
+    readonly providerInstanceId: string;
+    readonly target: ResourceLocator;
+    readonly format: string;
+}
+export interface TextDraftRef {
+    readonly key: TextDraftKey;
+    readonly base: ResourceExpectation;
+    readonly writerId: string;
+    readonly sequence: number;
+}
+export interface TextDraft {
+    readonly version: 1;
+    readonly ref: TextDraftRef;
+    readonly text: string;
+    readonly createdAt: number;
+    readonly expiresAt: number;
+}
+export type TextDraftFailure = {
+    readonly kind: 'denied' | 'expired' | 'unavailable' | 'unknown';
+    readonly reason: string;
+};
+export interface TextDraftStore {
+    readonly list: (key: TextDraftKey, limit: number) => Promise<{
+        readonly kind: 'available';
+        readonly drafts: readonly TextDraft[];
+        readonly truncated: boolean;
+    } | TextDraftFailure>;
+    readonly write: (draft: TextDraft) => Promise<{
+        readonly kind: 'stored' | 'superseded';
+    } | TextDraftFailure>;
+    readonly remove: (ref: TextDraftRef) => Promise<{
+        readonly kind: 'removed' | 'missing' | 'superseded';
+    } | TextDraftFailure>;
+}
+export interface TextDraftOptions {
+    readonly store: TextDraftStore;
+    readonly providerInstanceId: string;
+    readonly signal: AbortSignal;
+    readonly expiresAt: number;
+    readonly retentionMs: number;
+    readonly maxBytes?: number;
+    readonly maxDrafts?: number;
+}
+export interface TextDraftBinding extends TextDraftOptions {
+    readonly format: string;
+    readonly validateText?: (text: string) => void;
+}
+export interface TextDraftChoiceSelection {
+    readonly offerId: string;
+    readonly draft: TextDraftRef;
+    readonly viewer: SaveSelection;
+    readonly observedCurrent: ResourceExpectation;
+}
+export interface TextDraftChoice {
+    readonly selection: TextDraftChoiceSelection;
+    readonly text: string;
+    readonly createdAt: number;
+    readonly expiresAt: number;
+    readonly compatibility: 'exact' | 'conflict';
+}
+export type TextDraftDiscovery = {
+    readonly kind: 'idle' | 'checking' | 'empty';
+} | {
+    readonly kind: 'offered';
+    readonly choices: readonly TextDraftChoice[];
+    readonly truncated: boolean;
+} | TextDraftFailure;
+export type TextDraftCheckpoint = {
+    readonly kind: 'idle';
+} | {
+    readonly kind: 'pending' | 'stored';
+    readonly ref: TextDraftRef;
+} | {
+    readonly kind: 'failed';
+    readonly ref: TextDraftRef;
+    readonly operation: 'write' | 'remove';
+    readonly result: TextDraftFailure;
+};
+export type TextDraftRecoveryState = {
+    readonly kind: 'disabled' | 'revoked' | 'expired' | 'disposed';
+} | {
+    readonly kind: 'active';
+    readonly checkpoint: TextDraftCheckpoint;
+    readonly discovery: TextDraftDiscovery;
+};
+export type TextDraftChoiceFailure = TextDraftFailure | {
+    readonly kind: 'conflict';
+    readonly reason: string;
+};
+export type TextDraftCheckpointResult = {
+    readonly kind: 'stored';
+    readonly ref: TextDraftRef;
+} | {
+    readonly kind: 'clean' | 'superseded';
+} | TextDraftFailure;
+export interface TextDraftActions {
+    readonly checkDrafts: () => Promise<TextDraftDiscovery>;
+    readonly checkpointDraft: () => Promise<TextDraftCheckpointResult>;
+    readonly restoreDraft: (choice: TextDraftChoiceSelection) => Promise<{
+        readonly kind: 'restored';
+        readonly selection: SaveSelection;
+    } | TextDraftChoiceFailure>;
+    readonly discardDraft: (choice: TextDraftChoiceSelection) => Promise<{
+        readonly kind: 'discarded';
+    } | TextDraftChoiceFailure>;
+}
+//# sourceMappingURL=text-draft-types.d.ts.map

package/dist/text-draft-types.js

@@ -0,0 +1 @@
+export {};

package/dist/text-drafts.d.ts

@@ -0,0 +1,29 @@
+import type { ReadResult, ResourceExpectation, ResourceLocator } from '@hachej/boring-files';
+import type { SaveSelection } from './resources.js';
+import type { TextBufferState } from './text-buffer-state.js';
+import type { TextDraftActions, TextDraftBinding, TextDraftChoiceFailure, TextDraftRecoveryState, TextDraftRef } from './text-draft-types.js';
+interface Owner {
+    readonly binding: TextDraftBinding | undefined;
+    readonly emptyText: string;
+    readonly snapshot: () => TextBufferState;
+    readonly selection: () => SaveSelection;
+    readonly selected: (selection: SaveSelection) => boolean;
+    readonly sameBase: (left: ResourceExpectation, right: ResourceExpectation) => boolean;
+    readonly sameLocator: (left: ResourceLocator, right: ResourceLocator) => boolean;
+    readonly pending: () => boolean;
+    readonly read: () => Promise<ReadResult>;
+    readonly sync: () => void;
+    readonly changed: (state: TextDraftRecoveryState) => void;
+    readonly restore: (text: string, guard: () => boolean) => boolean;
+}
+export declare function createTextDrafts(owner: Owner): {
+    actions: TextDraftActions;
+    capture: () => TextDraftRef | undefined;
+    remove: (ref: TextDraftRef) => Promise<TextDraftChoiceFailure | undefined>;
+    currentRef: () => TextDraftRef | undefined;
+    state: () => TextDraftRecoveryState;
+    acknowledge: (ref: TextDraftRef | undefined, text: string) => void;
+    dispose: () => void;
+};
+export {};
+//# sourceMappingURL=text-drafts.d.ts.map