@widgetic/editor 4.0.9 → 4.0.11

package/dist/composition/compositionApi.js

@@ -0,0 +1,289 @@
+/**
+ * The calls an embedded composition editor makes to the Widgetic API, over `fetch`.
+ *
+ * Why not the generated SDK: the editor runs in a customer's browser and may only call a short list of routes
+ * (those an editor session allows), the list is fixed, and it must work with whatever token the host page gives it.
+ * A client of its own keeps the editor small and independent of the SDK's release cycle, and it keeps the few
+ * rules that matter in one place:
+ *
+ *   - the token is asked from the host page before each request (`getAccessToken('initial')`); when the API
+ *     answers 401 it is asked again (`'expired'`) and the request is sent once more with a token that is new;
+ *   - a save carries an `Idempotency-Key` (the API requires one on every PUT from a session), kept the same when
+ *     the request is sent again after a 401, so one save is never applied twice;
+ *   - only the fields editing changes can be sent (`SaveCompositionBody`); a session is refused any other;
+ *   - every failure is a `CompositionApiError` with the API's own code, so the host can tell an ended session
+ *     (`EDITOR_SESSION_EXPIRED`...) from a missing composition (`NOT_FOUND`) from a widget that was never
+ *     published (`WIDGET_NOT_PUBLISHED`);
+ *   - a request that gets no answer does not hang the editor: it fails with `TIMEOUT` after a set time.
+ */
+import { unwrapApiData } from './compositionHelpers.js';
+export const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+/** What the API accepts as an idempotency key. */
+const IDEMPOTENCY_KEY_PATTERN = /^[A-Za-z0-9_-]{8,50}$/;
+/** A request to the API that did not give the answer wanted. */
+export class CompositionApiError extends Error {
+    /** The HTTP status; `0` when no answer arrived (network, timeout, abort, or no token to send). */
+    status;
+    /** The API's error code (`NOT_FOUND`, `EDITOR_SESSION_EXPIRED`...), or one of {@link ClientErrorCode}. */
+    code;
+    /** The API's correlation id for the failed request, to quote in a support request. */
+    correlationId;
+    constructor(message, details) {
+        super(message);
+        this.name = 'CompositionApiError';
+        this.status = details.status;
+        this.code = details.code;
+        this.correlationId = details.correlationId;
+    }
+    /** True when the editor session cannot be used any more: the host page has to give a new one. */
+    get sessionEnded() {
+        return this.status === 401 || this.code === 'TOKEN_UNAVAILABLE';
+    }
+    /** True when sending the same request again later may work: nothing was refused, the network or the server failed. */
+    get retryable() {
+        return (this.code === 'NETWORK' ||
+            this.code === 'TIMEOUT' ||
+            this.status === 429 ||
+            this.status >= 500);
+    }
+}
+const STATUS_CODES = {
+    400: 'VALIDATION_ERROR',
+    401: 'UNAUTHORIZED',
+    403: 'FORBIDDEN',
+    404: 'NOT_FOUND',
+    409: 'CONFLICT',
+    429: 'RATE_LIMITED'
+};
+/** A code for an error status the API gave no code with. */
+function codeForStatus(status) {
+    return STATUS_CODES[status] ?? (status >= 500 ? 'SERVER_ERROR' : 'HTTP_ERROR');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** A key that is unique, not secret: the page's `crypto.randomUUID`, else random bytes, else the clock and `Math.random`. */
+export function createRandomIdempotencyKey() {
+    const cryptoApi = globalThis.crypto;
+    if (cryptoApi && typeof cryptoApi.randomUUID === 'function')
+        return cryptoApi.randomUUID();
+    if (cryptoApi && typeof cryptoApi.getRandomValues === 'function') {
+        const bytes = cryptoApi.getRandomValues(new Uint8Array(16));
+        return Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('');
+    }
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 12)}-${Math.random().toString(36).slice(2, 12)}`;
+}
+/** Only the part of the address that is safe to log: no query string, which could carry a token. */
+function addressForLog(url) {
+    return url.split('?')[0];
+}
+/** A wait the way a person reads it: "30 ms", "1 second", "30 seconds". */
+function describeWait(milliseconds) {
+    if (milliseconds < 1000)
+        return `${milliseconds} ms`;
+    const seconds = Math.round(milliseconds / 1000);
+    return seconds === 1 ? '1 second' : `${seconds} seconds`;
+}
+/** Stops a request that the caller has already cancelled, before the page is asked for a token or the network used. */
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw new CompositionApiError('The request was cancelled.', { status: 0, code: 'ABORTED' });
+    }
+}
+/** Builds the client. `apiBasePath` and `getAccessToken` are required. */
+export function createCompositionApi(options) {
+    if (typeof options?.apiBasePath !== 'string' || options.apiBasePath.trim() === '') {
+        throw new TypeError('createCompositionApi needs the API address (apiBasePath)');
+    }
+    if (typeof options.getAccessToken !== 'function') {
+        throw new TypeError('createCompositionApi needs a getAccessToken function');
+    }
+    const apiBasePath = options.apiBasePath.trim().replace(/\/+$/, '');
+    const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    const createIdempotencyKey = options.createIdempotencyKey ?? createRandomIdempotencyKey;
+    /** Asks the host page for a token (telling it which one the API refused, when that is why); a failure to give one is its own error. */
+    async function tokenFor(reason, refusedToken) {
+        let token;
+        try {
+            token =
+                refusedToken === undefined
+                    ? await options.getAccessToken(reason)
+                    : await options.getAccessToken(reason, refusedToken);
+        }
+        catch (error) {
+            console.error('[CompositionApi] The page could not give an access token:', error);
+            throw new CompositionApiError(`Could not get an access token from the page: ${error instanceof Error ? error.message : String(error)}`, { status: 0, code: 'TOKEN_UNAVAILABLE' });
+        }
+        if (typeof token !== 'string' || token.trim() === '') {
+            throw new CompositionApiError('The page gave no access token.', {
+                status: 0,
+                code: 'TOKEN_UNAVAILABLE'
+            });
+        }
+        return token;
+    }
+    /**
+     * One attempt: sends the request with `token` and reads the whole answer, all within the time limit and the
+     * caller's abort signal. The limit covers the answer's body as well as its start, so a server that stalls
+     * half way cannot hold the editor.
+     */
+    async function attempt(method, url, token, extras) {
+        throwIfAborted(extras.signal);
+        const fetchImplementation = options.fetch ?? globalThis.fetch.bind(globalThis);
+        const controller = new AbortController();
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, requestTimeoutMs);
+        const forwardAbort = () => controller.abort();
+        extras.signal?.addEventListener('abort', forwardAbort, { once: true });
+        const headers = {
+            Accept: 'application/json',
+            Authorization: `Bearer ${token}`
+        };
+        if (extras.body !== undefined)
+            headers['Content-Type'] = 'application/json';
+        if (extras.idempotencyKey)
+            headers['Idempotency-Key'] = extras.idempotencyKey;
+        try {
+            const response = await fetchImplementation(url, {
+                method,
+                headers,
+                body: extras.body !== undefined ? JSON.stringify(extras.body) : undefined,
+                // The token is the credential; the page's cookies for the API's domain play no part.
+                credentials: 'omit',
+                // What a composition holds changes with every save; never serve it from a cache.
+                cache: 'no-store',
+                signal: controller.signal
+            });
+            const text = await response.text();
+            return { status: response.status, ok: response.ok, text };
+        }
+        catch (error) {
+            if (timedOut) {
+                throw new CompositionApiError(`The API did not answer within ${describeWait(requestTimeoutMs)}.`, {
+                    status: 0,
+                    code: 'TIMEOUT'
+                });
+            }
+            if (extras.signal?.aborted || (error instanceof Error && error.name === 'AbortError')) {
+                throw new CompositionApiError('The request was cancelled.', { status: 0, code: 'ABORTED' });
+            }
+            console.warn(`[CompositionApi] ${method} ${addressForLog(url)} failed:`, error);
+            throw new CompositionApiError('Could not reach the Widgetic API. Check the connection and try again.', {
+                status: 0,
+                code: 'NETWORK'
+            });
+        }
+        finally {
+            clearTimeout(timer);
+            extras.signal?.removeEventListener('abort', forwardAbort);
+        }
+    }
+    /** The payload of a good answer, or the error the API described. */
+    function interpret(answer) {
+        // `undefined` stands for "no JSON in it": an empty body, or text that is not JSON (JSON never parses to `undefined`).
+        let parsed;
+        try {
+            parsed = JSON.parse(answer.text);
+        }
+        catch {
+            // Not JSON: `parsed` stays undefined.
+        }
+        if (!answer.ok) {
+            const failure = isRecord(parsed) && isRecord(parsed.error) ? parsed.error : null;
+            const code = typeof failure?.code === 'string' && failure.code !== ''
+                ? failure.code
+                : codeForStatus(answer.status);
+            const message = typeof failure?.message === 'string' && failure.message !== ''
+                ? failure.message
+                : `The API answered ${answer.status}.`;
+            const correlationId = typeof failure?.correlationId === 'string' ? failure.correlationId : undefined;
+            throw new CompositionApiError(message, { status: answer.status, code, correlationId });
+        }
+        if (parsed === undefined) {
+            throw new CompositionApiError('The API gave an answer that is not JSON.', {
+                status: answer.status,
+                code: 'INVALID_RESPONSE'
+            });
+        }
+        return unwrapApiData(parsed);
+    }
+    /**
+     * A request with the page's token. When the API refuses the token (401) the page is asked for another, and the
+     * request is sent again once with it, unless the page gives the same one back: that would only be refused again.
+     */
+    async function request(method, path, extras = {}) {
+        const url = `${apiBasePath}${path}`;
+        throwIfAborted(extras.signal);
+        const firstToken = await tokenFor('initial');
+        let answer = await attempt(method, url, firstToken, extras);
+        if (answer.status === 401) {
+            console.warn(`[CompositionApi] ${method} ${addressForLog(url)} was refused (401); asking the page for a new token`);
+            throwIfAborted(extras.signal);
+            const newToken = await tokenFor('expired', firstToken);
+            if (newToken !== firstToken)
+                answer = await attempt(method, url, newToken, extras);
+        }
+        return interpret(answer);
+    }
+    function compositionPath(compositionId, suffix = '') {
+        if (typeof compositionId !== 'string' || compositionId.trim() === '') {
+            throw new TypeError('A composition id is needed');
+        }
+        return `/compositions/${encodeURIComponent(compositionId)}${suffix}`;
+    }
+    function invalidResponse(message) {
+        return new CompositionApiError(message, { status: 200, code: 'INVALID_RESPONSE' });
+    }
+    return {
+        async getComposition(compositionId, requestOptions = {}) {
+            const record = await request('GET', compositionPath(compositionId), requestOptions);
+            if (!isRecord(record) || typeof record.id !== 'string')
+                throw invalidResponse('The API gave no composition.');
+            return record;
+        },
+        async getPreview(compositionId, requestOptions = {}) {
+            const preview = await request('GET', compositionPath(compositionId, '/preview'), requestOptions);
+            if (!isRecord(preview) || typeof preview.previewUrl !== 'string') {
+                throw invalidResponse('The API gave no preview address.');
+            }
+            // The address goes into a frame: only a web address may.
+            let address;
+            try {
+                address = new URL(preview.previewUrl);
+            }
+            catch {
+                throw invalidResponse('The API gave a preview address that is not valid.');
+            }
+            if (address.protocol !== 'https:' && address.protocol !== 'http:') {
+                throw invalidResponse('The API gave a preview address that is not a web address.');
+            }
+            return {
+                compositionId: typeof preview.compositionId === 'string' ? preview.compositionId : compositionId,
+                widgetId: typeof preview.widgetId === 'string' ? preview.widgetId : '',
+                version: typeof preview.version === 'number' ? preview.version : 0,
+                previewUrl: address.href
+            };
+        },
+        async getContentSchema(compositionId, requestOptions = {}) {
+            return request('GET', compositionPath(compositionId, '/schema/content'), requestOptions);
+        },
+        async getDesignSchema(compositionId, requestOptions = {}) {
+            return request('GET', compositionPath(compositionId, '/schema/design'), requestOptions);
+        },
+        async saveComposition(compositionId, body, saveOptions = {}) {
+            const idempotencyKey = saveOptions.idempotencyKey ?? createIdempotencyKey();
+            if (!IDEMPOTENCY_KEY_PATTERN.test(idempotencyKey)) {
+                throw new TypeError('An idempotency key is 8 to 50 letters, digits, dashes or underscores');
+            }
+            const record = await request('PUT', compositionPath(compositionId), {
+                body,
+                signal: saveOptions.signal,
+                idempotencyKey
+            });
+            return isRecord(record) ? record : {};
+        }
+    };
+}

package/dist/composition/compositionEditorController.d.ts

@@ -0,0 +1,254 @@
+/**
+ * The state and the behaviour of an embedded composition editor, with no user interface in it.
+ *
+ * It loads a composition and what is needed to edit it (the widget's preview address and its two schemas),
+ * keeps the values being edited, tells the preview page what changed, and saves: when asked, and by itself a
+ * moment after the last edit. A Svelte component draws it; a test can drive it with a fake API and fake timers.
+ *
+ * The rules that keep a customer's work safe live here:
+ *
+ *   - "Unsaved changes" is counted, not flagged. Every edit raises a revision; a save remembers the revision it
+ *     saved. An edit made while a save is on its way therefore stays unsaved when the save returns (the page
+ *     this was taken from cleared the flag and lost track of it).
+ *   - There is one save on the way at a time. A save asked for meanwhile waits for it, then saves what is new.
+ *   - What is sent is a copy taken when the save starts, so edits made while it travels cannot change it, and
+ *     sending it again after a 401 sends exactly the same thing.
+ *   - A save that fails leaves everything unsaved and says so. An autosave that fails because of the network or
+ *     the server is tried again a few times, further and further apart; a failure that retrying cannot fix
+ *     (the session ended, the field is refused) is not.
+ *   - The embed settings the composition already has (anything set by the site or by the partner's own backend)
+ *     are sent back with the new size, never replaced by it.
+ *   - The size that is saved is the one the user gave the preview (by dragging its corner or typing it in), and
+ *     nothing else. Looking at the preview as on a phone changes how it is drawn, not what is saved, and the
+ *     size a small box forces on the preview is not the user's choice, so it is never saved either (the page this
+ *     was taken from saved both, so opening a composition in a small window, or trying the mobile view, changed
+ *     the size of the widget embedded on a site).
+ *   - After `dispose()` nothing more happens: no request goes out, and answers still on their way are ignored.
+ */
+import type { CompositionApi } from './compositionApi.js';
+import { type JsonRecord } from './compositionHelpers.js';
+/** Time to wait after the last edit before saving by itself. */
+export declare const DEFAULT_AUTOSAVE_DELAY_MS = 2500;
+/** How long to wait before trying an autosave again after it failed for a reason that may pass: first, second, third time. */
+export declare const DEFAULT_AUTOSAVE_RETRY_DELAYS_MS: readonly number[];
+export declare const DEFAULT_PREVIEW_WIDTH = 800;
+export declare const DEFAULT_PREVIEW_HEIGHT = 600;
+/** The size the preview is drawn at in its mobile view. */
+export declare const MOBILE_PREVIEW_WIDTH = 480;
+export declare const MOBILE_PREVIEW_HEIGHT = 600;
+/** The smallest size, in pixels, the preview can be given. */
+export declare const MIN_PREVIEW_SIZE = 50;
+export type EditorPhase = 'idle' | 'loading' | 'ready' | 'failed';
+/** `'desktop'` draws the preview at the size that is saved; `'mobile'` at a phone's. */
+export type DeviceView = 'desktop' | 'mobile';
+/** Why a request failed, in terms an interface can act on. */
+export interface EditorFailure {
+    message: string;
+    /** The API's error code, or one of the client's (`NETWORK`, `TIMEOUT`, `TOKEN_UNAVAILABLE`...). */
+    code: string;
+    /** The HTTP status; `0` when there was no answer. */
+    status: number;
+    /** Trying the same thing again later may work. */
+    retryable: boolean;
+    /** The session cannot be used any more: the host page has to give a new one. */
+    sessionEnded: boolean;
+    correlationId?: string;
+}
+export interface CompositionEditorState {
+    phase: EditorPhase;
+    compositionId: string;
+    name: string;
+    widgetId: string;
+    /** The widget build to show, or `null` when there is none (see `previewError`). */
+    preview: {
+        previewUrl: string;
+        widgetId: string;
+        version: number;
+    } | null;
+    /** Why there is no preview, in words for a person; the settings can still be edited. */
+    previewError: string | null;
+    designSchema: any;
+    contentSchema: any;
+    schemasLoading: boolean;
+    /** Why there is nothing to edit, in words for a person. */
+    schemasError: string | null;
+    designValues: JsonRecord;
+    contentValues: JsonRecord;
+    contentItems: any[];
+    /** The size the preview is drawn at, in pixels. In the mobile view that is a phone's, not the size that is saved. */
+    previewWidth: number;
+    previewHeight: number;
+    /** The size saved with the composition (`embedSettings.width` and `height`): the one the widget gets where it is embedded. */
+    embedWidth: number;
+    embedHeight: number;
+    deviceView: DeviceView;
+    /** There are edits no save has taken yet. */
+    dirty: boolean;
+    saving: boolean;
+    /** The last save failed (cleared when the next one starts). */
+    saveError: EditorFailure | null;
+    /** The composition could not be loaded (`phase` is then `failed`). */
+    loadError: EditorFailure | null;
+    lastSavedAt: number | null;
+}
+export type CompositionEditorEvent = {
+    type: 'ready';
+} | {
+    type: 'dirty';
+    dirty: boolean;
+} | {
+    type: 'saved';
+    composition: JsonRecord;
+    savedAt: number;
+} | {
+    type: 'error';
+    during: 'load' | 'schemas' | 'save';
+    failure: EditorFailure;
+    fatal: boolean;
+};
+/** What the preview page is told when something changed. */
+export interface PreviewMessage {
+    type: 'widgetic:update';
+    design?: Record<string, string>;
+    content?: JsonRecord;
+    contentItems?: unknown[];
+}
+/** A change of one property, as the props editor reports it. */
+export interface PropertyChange {
+    schema: string;
+    propertyId: string;
+    value: unknown;
+    itemId?: string;
+}
+export type SaveReason = 'manual' | 'autosave' | 'flush';
+export interface TimerFunctions {
+    setTimeout: (callback: () => void, milliseconds: number) => unknown;
+    clearTimeout: (handle: unknown) => void;
+}
+export interface CompositionEditorOptions {
+    compositionId: string;
+    api: CompositionApi;
+    /** Wait this long after the last edit before saving by itself; `0` turns autosave off. Default: 2.5 seconds. */
+    autosaveDelayMs?: number;
+    /** Waits before trying a failed autosave again; none means never. Default: 5, 15 and 45 seconds. */
+    autosaveRetryDelaysMs?: readonly number[];
+    /** Timer functions, so tests can run time by hand. Default: the page's. */
+    timers?: TimerFunctions;
+    /** The clock, in milliseconds. Default: `Date.now`. */
+    now?: () => number;
+    /** Called with every message the preview page should be sent. */
+    onPreviewMessage?: (message: PreviewMessage) => void;
+    /** Writes the editor's own notes (a failure worth knowing about). Default: the console. */
+    logger?: Pick<Console, 'warn' | 'error'>;
+}
+/** What went wrong, from whatever was thrown. */
+export declare function describeFailure(error: unknown): EditorFailure;
+/** A failure in words for the person using the editor. */
+export declare function failureMessage(failure: EditorFailure, doing: 'load' | 'save'): string;
+export declare class CompositionEditorController {
+    private readonly options;
+    private readonly timers;
+    private readonly now;
+    private readonly logger;
+    private readonly autosaveDelayMs;
+    private readonly autosaveRetryDelaysMs;
+    private readonly abortController;
+    private readonly stateListeners;
+    private readonly eventListeners;
+    private state;
+    /** Counts the edits made. */
+    private revision;
+    /** The revision the last successful save took. */
+    private savedRevision;
+    /** How many autosaves in a row have failed. */
+    private failedAutosaves;
+    /** The embed settings the composition has, sent back with the size on every save. */
+    private storedEmbedSettings;
+    private autosaveTimer;
+    /** What `getPropsEditorContentSchema` and `getPropsEditorContentValues` last made, and from what. */
+    private propsEditorSchemaCache;
+    private propsEditorValuesCache;
+    private loadPromise;
+    private savePromise;
+    private disposed;
+    constructor(options: CompositionEditorOptions);
+    /** The state now. It is never changed in place: a change makes a new object. */
+    getState(): CompositionEditorState;
+    /** Svelte store contract: calls `listener` with the state now, and again after every change. */
+    subscribe(listener: (state: CompositionEditorState) => void): () => void;
+    /** Calls `listener` with every event: `ready`, `dirty`, `saved`, `error`. */
+    onEvent(listener: (event: CompositionEditorEvent) => void): () => void;
+    /** Loads the composition, its preview address and its schemas. Asking again while it loads waits for the same load. */
+    load(): Promise<void>;
+    private runLoad;
+    private failLoad;
+    /**
+     * Turns the answers for the two schemas into what the editor draws, and into words when there is nothing to draw.
+     * A schema whose request failed is the `previous` one when there is one (asking again must not lose what is there).
+     */
+    private readSchemas;
+    /** Tells the watchers that there is nothing to edit, when that is so. */
+    private reportMissingSchemas;
+    /** Asks for the two schemas again (after they failed to load). Values already edited are kept. */
+    reloadSchemas(): Promise<void>;
+    /**
+     * The content schema the props editor draws: the widget's, with the composition's items merged into it.
+     * The same object comes back until the schema or the items change, so a component can hand it down without
+     * the props editor being told of a change that is none.
+     */
+    getPropsEditorContentSchema(): any;
+    /** The values the props editor starts from: the content values, and the items by id. The same object comes back until they change. */
+    getPropsEditorContentValues(): JsonRecord;
+    /** Tells the preview page everything it needs to look like the composition (once its page has loaded). */
+    syncPreview(): void;
+    private buildPreviewSnapshot;
+    /** One property was changed in the props editor. */
+    changeProperty(change: PropertyChange): void;
+    /** The content items (slides, rows, cards...) were changed in the props editor. */
+    changeContentItems(items: unknown[]): void;
+    /**
+     * The user gave the preview a size, by dragging its corner or typing it in. That is the size saved with the
+     * composition, and the preview is drawn at it (in the desktop view). A size that is not the user's choice
+     * (the one a small box forces on the preview) must not be passed here.
+     */
+    setPreviewSize(width: number, height: number): void;
+    /**
+     * The mobile and desktop buttons: the preview is drawn at a phone's size, or back at the saved size. That is a
+     * way of looking, not an edit: nothing becomes unsaved, and a save still sends the size the user gave the preview.
+     */
+    setDeviceView(deviceView: DeviceView): void;
+    /**
+     * The page saved the composition's embed settings itself (a page can have its own screen for them), so the ones
+     * this editor loaded, and sends back with every save, are out of date. From now on a save carries these, with the
+     * size the preview has, and the desktop view is drawn at the size they name. Nothing becomes unsaved: the page
+     * saved them already. Call it when no save of the editor is on its way (after `flush()`): the answer to a save
+     * that is replaces them.
+     */
+    adoptEmbedSettings(settings: unknown): void;
+    /** An edit was made: there is something new to save, the wait for the next autosave starts again, and so does the count of failures. */
+    private markEdited;
+    private hasUnsavedChanges;
+    /**
+     * Saves what has been edited. Resolves `true` when there is nothing unsaved afterwards, `false` when the save
+     * failed (see `saveError`) or the editor is not ready.
+     */
+    save(reason?: SaveReason): Promise<boolean>;
+    /**
+     * Saves everything that is unsaved, now, and waits until it is. Resolves `true` when nothing is left unsaved,
+     * `false` when a save failed. For closing the editor.
+     */
+    flush(): Promise<boolean>;
+    private runSave;
+    /** What a save sends: a copy of the values as they are now, so later edits cannot change it. */
+    private buildSaveBody;
+    /** Starts the wait for an autosave of what is unsaved (for callers that have something unsaved). */
+    private scheduleAutosave;
+    /** After an autosave failed for a reason that may pass: try again later, but only so many times. */
+    private scheduleAutosaveRetry;
+    private clearAutosaveTimer;
+    /** Stops everything: timers, requests on their way, and any answer that arrives later. Unsaved edits are lost; `flush()` first to keep them. */
+    dispose(): void;
+    /** Makes the next state out of the changes, tells the watchers, and says when the unsaved flag turned over. */
+    private patch;
+    private emit;
+}