@lapis-notes/api 0.1.3 → 0.2.0

package/dist/icons/registry.js

@@ -0,0 +1,154 @@
+import { convertParsedSVG, getIconData, iconToHTML, iconToSVG, parseSVGContent, replaceIDs, } from "@iconify/utils";
+import { resolveRegisteredIcon } from "./index";
+import { iconRevision, onIconsChanged } from "./changes";
+import { assertSafeIconSvg } from "./safe-svg";
+function loadPack(input) {
+    try {
+        return Promise.resolve("icons" in input ? input.icons : input.loader());
+    }
+    catch (error) {
+        return Promise.reject(error);
+    }
+}
+function namespace(owner) {
+    if (!owner.trim())
+        throw new Error("Icon owner must not be empty.");
+    return ("plugin-" +
+        [...new TextEncoder().encode(owner)]
+            .map((x) => x.toString(16).padStart(2, "0"))
+            .join(""));
+}
+function localName(id) {
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(id))
+        throw new Error("Use a lowercase icon name with hyphens.");
+    return id;
+}
+function render(data) {
+    const rendered = iconToSVG(data);
+    const svg = iconToHTML(replaceIDs(rendered.body), rendered.attributes);
+    assertSafeIconSvg(svg);
+    return svg;
+}
+/**
+ * App-owned artwork with an explicit compatibility fallback to legacy global
+ * icons.
+ */
+export class IconRegistry {
+    icons = new Map();
+    packs = new Map();
+    listeners = new Set();
+    cache = new Map();
+    revision = 0;
+    legacyRevision = iconRevision();
+    stopLegacy;
+    disposed = false;
+    subscribe = (listener) => {
+        if (this.disposed)
+            return () => { };
+        if (!this.stopLegacy)
+            this.stopLegacy = onIconsChanged(() => this.changed());
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+            if (!this.listeners.size) {
+                this.stopLegacy?.();
+                this.stopLegacy = undefined;
+            }
+        };
+    };
+    changed() {
+        this.revision++;
+        this.cache.clear();
+        this.legacyRevision = iconRevision();
+        for (const listener of [...this.listeners])
+            listener();
+    }
+    registerIcon(owner, id, svg) {
+        if (this.disposed)
+            throw new Error("Icon registry is disposed.");
+        assertSafeIconSvg(svg);
+        const parsed = parseSVGContent(svg);
+        const data = parsed && convertParsedSVG(parsed);
+        if (!data)
+            throw new Error("Invalid icon SVG.");
+        const name = `${namespace(owner)}:${localName(id)}`;
+        const entry = { svg: render(data) };
+        this.icons.set(name, entry);
+        this.changed();
+        return {
+            id: name,
+            dispose: () => {
+                if (this.icons.get(name) === entry) {
+                    this.icons.delete(name);
+                    this.changed();
+                }
+            },
+        };
+    }
+    registerIconPack(owner, input) {
+        if (this.disposed)
+            throw new Error("Icon registry is disposed.");
+        const prefix = `${namespace(owner)}-${localName(input.name)}`;
+        const entry = { input };
+        this.packs.set(prefix, entry);
+        this.changed();
+        return {
+            prefix,
+            dispose: () => {
+                if (this.packs.get(prefix) === entry) {
+                    this.packs.delete(prefix);
+                    this.changed();
+                }
+            },
+        };
+    }
+    resolveIcon(name) {
+        if (this.disposed)
+            return Promise.resolve({ status: "missing" });
+        if (this.legacyRevision !== iconRevision())
+            this.changed();
+        const cached = this.cache.get(name);
+        if (cached)
+            return cached;
+        const revision = this.revision;
+        const pending = this.lookup(name)
+            .then((result) => this.disposed || revision !== this.revision
+            ? { status: "missing" }
+            : result)
+            .catch(() => ({ status: "failed" }));
+        this.cache.set(name, pending);
+        return pending;
+    }
+    resolve = async (name) => {
+        const result = await this.resolveIcon(name);
+        return result.status === "found" ? result.svg : null;
+    };
+    async lookup(name) {
+        const icon = this.icons.get(name);
+        if (icon)
+            return { status: "found", svg: icon.svg };
+        const [prefix, id, ...extra] = name.split(":");
+        const pack = this.packs.get(prefix);
+        if (pack && id && extra.length === 0) {
+            pack.promise ??= loadPack(pack.input);
+            const data = getIconData(await pack.promise, id);
+            return data
+                ? { status: "found", svg: render(data) }
+                : { status: "missing" };
+        }
+        // Owned IDs never resolve through a different App's compatibility registry.
+        if (/^plugin-(?:[a-f0-9]{2})+(?:-[a-z0-9]+(?:-[a-z0-9]+)*)?:/u.test(name))
+            return { status: "missing" };
+        return resolveRegisteredIcon(name);
+    }
+    dispose() {
+        this.disposed = true;
+        this.stopLegacy?.();
+        this.stopLegacy = undefined;
+        this.icons.clear();
+        this.packs.clear();
+        this.cache.clear();
+        this.listeners.clear();
+        this.revision++;
+    }
+}

package/dist/icons/safe-svg.d.ts

@@ -0,0 +1,2 @@
+/** Reject executable/external content before a host displays plugin SVG markup. */
+export declare function assertSafeIconSvg(svg: string): void;

package/dist/icons/safe-svg.js

@@ -0,0 +1,44 @@
+/** Reject executable/external content before a host displays plugin SVG markup. */
+export function assertSafeIconSvg(svg) {
+    const tags = new Set([
+        "svg",
+        "g",
+        "path",
+        "rect",
+        "circle",
+        "ellipse",
+        "line",
+        "polyline",
+        "polygon",
+        "defs",
+        "lineargradient",
+        "radialgradient",
+        "stop",
+        "clippath",
+        "mask",
+        "pattern",
+        "symbol",
+        "use",
+        "title",
+        "desc",
+    ]);
+    if (/xml:base\s*=|<!|<\?|&#|\\|javascript\s*:|data\s*:/iu.test(svg))
+        throw new Error("Unsafe icon SVG.");
+    for (const match of svg.matchAll(/<\/?\s*([\w:-]+)/gu)) {
+        if (!tags.has(match[1].toLowerCase()))
+            throw new Error("Unsupported icon SVG element.");
+    }
+    if (/\s(?:on[\w:-]+)\s*=/iu.test(svg) ||
+        /@import|expression\s*\(/iu.test(svg))
+        throw new Error("Executable icon SVG.");
+    for (const match of svg.matchAll(/(?:\b(?:xlink:)?href\s*=\s*)(["'])(.*?)\1/giu)) {
+        if (!/^#[\w:.-]+$/u.test(match[2]))
+            throw new Error("External icon SVG reference.");
+    }
+    if (/\b(?:xlink:)?href\s*=\s*[^\s"']/iu.test(svg))
+        throw new Error("Unquoted icon SVG reference.");
+    for (const match of svg.matchAll(/url\s*\((.*?)\)/giu)) {
+        if (!/^\s*["']?#[\w:.-]+["']?\s*$/u.test(match[1]))
+            throw new Error("External icon SVG URL.");
+    }
+}

package/dist/index.d.ts

@@ -1,11 +1,15 @@
 import "./enhance";
 export * from "./editor.svelte";
+export * from "./file-editing-sessions";
+export { bindNativeEditingProblems } from "./native-editing-problems";
+export type { NativeEditingIntents } from "./native-editing-intents";
 export * from "./events";
 export * from "./components/editor/extensions/autocomplete";
 export * from "./components/editor/extensions/lint";
 export * from "./components/editor/language-service";
 export * from "./menu.svelte";
 export * from "./cache.svelte";
+export type { NativeBackgroundIndexing, NativeBackgroundIndexingObserver, NativeIndexingProgressPresentation, } from "./native-background-indexing";
 export * from "./plugin";
 export * from "./plugin-capability-facade";
 export * from "./sync-host";
@@ -53,7 +57,7 @@ export * from "./configuration-option-source-registry";
 export * from "./configuration-option-source-providers";
 export * from "./plugin-settings";
 export * from "./editor-view-registry";
-export * from "./glob";
+export { normalizeGlobPath, normalizeEditorAssociationGlob, validateEditorAssociationGlob, matchesEditorAssociationGlob, hasEditorAssociationGlobMagic, compareEditorAssociationPatternSpecificity, type EditorAssociationGlobOptions, type EditorAssociationGlobValidation, } from "./glob";
 export * from "./platform";
 export * from "./suggest";
 export * from "./markdown";
@@ -82,6 +86,7 @@ export * from "./promise-worker";
 export * from "./search";
 export * from "./search-query";
 export * from "./search-document-provider";
+export * from "./search-result-provider";
 export * from "./daily-document-provider";
 export * from "./loaders";
 export * from "./bases";

package/dist/index.js

@@ -1,5 +1,7 @@
 import "./enhance";
 export * from "./editor.svelte";
+export * from "./file-editing-sessions";
+export { bindNativeEditingProblems } from "./native-editing-problems";
 export * from "./events";
 export * from "./components/editor/extensions/autocomplete";
 export * from "./components/editor/extensions/lint";
@@ -53,7 +55,7 @@ export * from "./configuration-option-source-registry";
 export * from "./configuration-option-source-providers";
 export * from "./plugin-settings";
 export * from "./editor-view-registry";
-export * from "./glob";
+export { normalizeGlobPath, normalizeEditorAssociationGlob, validateEditorAssociationGlob, matchesEditorAssociationGlob, hasEditorAssociationGlobMagic, compareEditorAssociationPatternSpecificity, } from "./glob";
 export * from "./platform";
 export * from "./suggest";
 export * from "./markdown";
@@ -82,6 +84,7 @@ export * from "./promise-worker";
 export * from "./search";
 export * from "./search-query";
 export * from "./search-document-provider";
+export * from "./search-result-provider";
 export * from "./daily-document-provider";
 export * from "./loaders";
 export * from "./bases";

package/dist/lapis-extension.d.ts

@@ -54,6 +54,7 @@ export interface LapisEditorViewContribution {
     viewType?: string;
     label: string;
     description?: string;
+    fileIcon?: string;
     filenamePatterns: string[];
     priority?: "default" | "option" | "exclusive";
     pluginId?: string;
@@ -86,7 +87,7 @@ export interface LapisStatusBarItemContribution {
     id: string;
     text?: string;
     icon?: string;
-    alignment?: "left" | "right";
+    alignment?: "left" | "center" | "right";
     priority?: number;
     tooltip?: string;
     command?: string;
@@ -130,7 +131,10 @@ export interface LapisExtensionManifest {
         };
     };
     database?: {
-        /** Query-native access avoids the one-release full MetadataCache snapshot lease. */
+        /**
+         * Query-native access avoids the one-release full MetadataCache snapshot
+         * lease.
+         */
         metadataAccess?: "queries" | "snapshot";
     };
     permissions?: LapisExtensionPermission[];

package/dist/lapis-extension.js

@@ -566,6 +566,7 @@ function isEditorViewContribution(value) {
         Array.isArray(value.filenamePatterns) &&
         value.filenamePatterns.length > 0 &&
         value.filenamePatterns.every((entry) => typeof entry === "string") &&
+        (value.fileIcon === undefined || typeof value.fileIcon === "string") &&
         (value.viewType === undefined || typeof value.viewType === "string") &&
         (value.description === undefined ||
             typeof value.description === "string") &&
@@ -595,6 +596,7 @@ function isStatusBarItemContribution(value) {
         (typeof value.text === "string" || typeof value.icon === "string") &&
         (value.alignment === undefined ||
             value.alignment === "left" ||
+            value.alignment === "center" ||
             value.alignment === "right") &&
         (value.priority === undefined || typeof value.priority === "number") &&
         (value.tooltip === undefined || typeof value.tooltip === "string") &&

package/dist/metadata-store.d.ts

@@ -0,0 +1,23 @@
+/** Host persistence only; implementations retain authorization and lifecycle ownership. */
+export interface HostMetadataStore {
+    getMeta<T = unknown>(key: string): Promise<T | undefined>;
+    setMeta(key: string, value: unknown): Promise<void>;
+    transactMeta(transaction: AppDatabaseMetaTransaction): Promise<AppDatabaseMetaTransactionResult>;
+}
+export interface AppDatabaseMetaCheck {
+    key: string;
+    exists?: boolean;
+    value?: unknown;
+}
+export interface AppDatabaseMetaMutation {
+    key: string;
+    value?: unknown;
+    delete?: boolean;
+}
+export interface AppDatabaseMetaTransaction {
+    checks?: AppDatabaseMetaCheck[];
+    mutations: AppDatabaseMetaMutation[];
+}
+export interface AppDatabaseMetaTransactionResult {
+    applied: boolean;
+}

package/dist/metadata-store.js

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

package/dist/metadata.svelte.js

@@ -1,5 +1,7 @@
+import { FileTextStateWriter } from "./file-text-state-writer";
+import { TFile as VaultFile } from "./storage/fs";
 import { inferMetadataPropertyType, inferMetadataType, normalizeMetadataValue, } from "./metadata-value";
-import { joinPath, } from "./storage";
+import { joinPath, normalizePath, } from "./storage";
 import { debounce, get, has, set, unset } from "lodash-es";
 import { onMount } from "svelte";
 function notifyMetadataTypeError(message) {
@@ -21,6 +23,8 @@ export class MetadataTypeManager {
     propertiesLoading = $state(false);
     queryError = $state(null);
     propertiesGeneration = 0;
+    typesBaseline;
+    typesWriter;
     valueGenerations = new Map();
     schedulePropertiesRefresh = debounce(() => void this.updateProperties(), 50);
     constructor(app) {
@@ -40,6 +44,7 @@ export class MetadataTypeManager {
                 this.app.metadataCache.offref(metadataHandler);
                 this.app.metadataCache.offref(indexHandler);
                 this.schedulePropertiesRefresh.cancel();
+                this.typesWriter?.dispose();
             };
         });
         this.load();
@@ -112,8 +117,13 @@ export class MetadataTypeManager {
     load() {
         const promises = [];
         const file = this.app.vault.getFileByPath(joinPath(this.app.props.configPath, "../", "types.json"));
+        if (!file && !this.typesWriter)
+            this.typesBaseline = null;
         if (file) {
             promises.push(this.app.vault.read(file).then((data) => {
+                if (this.typesWriter)
+                    return;
+                this.typesBaseline = data;
                 try {
                     const typeData = JSON.parse(data);
                     if ("types" in typeData) {
@@ -166,12 +176,43 @@ export class MetadataTypeManager {
             return "unknown";
         return type === "checkbox" ? "checkbox" : "unknown";
     }
-    save = debounce(() => {
+    saveLegacy = debounce(() => {
         const file = this.app.vault.getFileByPath(joinPath(this.app.props.configPath, "../", "types.json"));
         if (file) {
             return this.app.vault.modify(file, JSON.stringify(this.toJSON(), null, 2));
         }
     }, 500);
+    save = () => {
+        if (!this.app.vault.supportsConditionalTextWrites) {
+            this.saveLegacy();
+            return;
+        }
+        void this.getTypesWriter().set(JSON.stringify(this.toJSON(), null, 2))
+            .catch((error) => notifyMetadataTypeError(`Failed to save types.json: ${error}`));
+    };
+    getTypesWriter() {
+        if (this.typesWriter)
+            return this.typesWriter;
+        const path = normalizePath(joinPath(this.app.props.configPath, "../", "types.json"));
+        const file = this.app.vault.getFileByPath(path) ??
+            new VaultFile(path, { ctime: 0, mtime: 0, size: 0 }, null);
+        this.typesWriter ??= new FileTextStateWriter(this.app, file, this.typesBaseline ?? null, (text) => {
+            for (const key of Object.keys(this.types))
+                delete this.types[key];
+            try {
+                const value = JSON.parse(text || '{"types":{}}');
+                for (const [name, type] of Object.entries(value.types ?? {})) {
+                    if (typeof type === "string")
+                        this.types[name] = { name, type: type };
+                }
+            }
+            catch (error) {
+                notifyMetadataTypeError(`Failed to load types.json: ${error}`);
+            }
+            void this.updateProperties();
+        });
+        return this.typesWriter;
+    }
     toJSON() {
         const types = {};
         Object.values(this.types).forEach((t) => {
@@ -182,6 +223,8 @@ export class MetadataTypeManager {
         };
     }
     setType(field, type) {
+        if (this.app.vault.supportsConditionalTextWrites)
+            this.getTypesWriter().assertEditable();
         this.types[field] = { name: field, type };
         this.properties[field] ||= {
             name: field,

package/dist/native-background-indexing.d.ts

@@ -0,0 +1,48 @@
+import type { App } from "./context.svelte";
+import type { IndexProjectionRegistration } from "./storage/index-projection";
+import type { ContributionStatus, IndexingCommand, IndexingStatus, IndexingValue, SearchIndexingSelection } from "./native-indexing-protocol";
+export type * from "./native-indexing-protocol";
+/** An explicitly supplied, already admitted native vault transport. */
+export interface NativeBackgroundIndexing {
+    call(command: IndexingCommand): Promise<IndexingValue>;
+}
+export interface NativeIndexingProgressPresentation {
+    title: string;
+    source: string;
+    readyMessage: string;
+}
+/** One App-owned observation boundary; native work outlives renderer detach. */
+export interface NativeBackgroundIndexingObserver {
+    readonly detached: boolean;
+    selectSearch(selection: SearchIndexingSelection): Promise<ContributionStatus>;
+    disableSearch(): Promise<void>;
+    getStatus(): Promise<IndexingStatus | null>;
+    refresh(rebuild: boolean, presentation?: NativeIndexingProgressPresentation): Promise<IndexingStatus>;
+}
+/** App-owned observer and declaration adapter; never an indexing writer. */
+export declare class NativeBackgroundIndexingSession implements NativeBackgroundIndexingObserver {
+    private readonly app;
+    private readonly port;
+    private isDetached;
+    private searchDeclared;
+    private searchVersion;
+    private searchControl;
+    private readonly pending;
+    private readonly contributions;
+    private readonly observers;
+    constructor(app: App, port: NativeBackgroundIndexing);
+    get detached(): boolean;
+    selectSearch(selection: SearchIndexingSelection): Promise<ContributionStatus>;
+    disableSearch(): Promise<void>;
+    getStatus(): Promise<IndexingStatus | null>;
+    registerProcessor(owner: string, extension: string): void;
+    registerProjection(owner: string, id: string, registration: IndexProjectionRegistration): void;
+    private register;
+    private callSearch;
+    ready(owner?: string): Promise<void>;
+    disable(owner: string): Promise<void>;
+    getContributionStatuses(): ContributionStatus[];
+    load(): Promise<void>;
+    refresh(rebuild: boolean, presentation?: NativeIndexingProgressPresentation): Promise<IndexingStatus>;
+    dispose(): void;
+}

package/dist/native-background-indexing.js

@@ -0,0 +1,208 @@
+/** App-owned observer and declaration adapter; never an indexing writer. */
+export class NativeBackgroundIndexingSession {
+    app;
+    port;
+    isDetached = false;
+    searchDeclared = false;
+    searchVersion = 0;
+    searchControl = Promise.resolve();
+    pending = new Map();
+    contributions = new Map();
+    observers = new Set();
+    constructor(app, port) {
+        this.app = app;
+        this.port = port;
+    }
+    get detached() {
+        return this.isDetached;
+    }
+    async selectSearch(selection) {
+        if (this.detached)
+            throw new Error("Native indexing observer is detached");
+        this.searchVersion += 1;
+        this.searchDeclared = true;
+        const contribution = await this.register("search", {
+            kind: "select_search",
+            selection,
+        });
+        if (!contribution || contribution.projection_id !== "search")
+            throw new Error("Native Search selection is unavailable");
+        return contribution;
+    }
+    async disableSearch() {
+        if (this.detached)
+            return;
+        // Controls share one order even when selection's response is uncertain.
+        const version = ++this.searchVersion;
+        await this.callSearch({ kind: "disable_search" });
+        if (version !== this.searchVersion)
+            return;
+        this.searchDeclared = false;
+        this.contributions.delete("search");
+        this.pending.delete("search");
+    }
+    async getStatus() {
+        return this.detached
+            ? null
+            : (await this.port.call({ kind: "status" })).status;
+    }
+    registerProcessor(owner, extension) {
+        this.register(owner, {
+            kind: "register_processor",
+            owner_plugin_id: owner,
+            extension,
+        });
+    }
+    registerProjection(owner, id, registration) {
+        this.register(owner, {
+            kind: "register_projection",
+            contribution: {
+                projection_id: id,
+                owner_plugin_id: owner,
+                schema_version: registration.version,
+                configuration_hash: registration.configurationHash ?? "",
+                path_prefix: registration.source?.pathPrefix ?? null,
+            },
+        });
+    }
+    register(owner, command) {
+        const request = owner === "search" ? this.callSearch(command) : this.port.call(command);
+        const operation = request.then(({ contribution }) => {
+            if (!contribution || this.detached)
+                return contribution;
+            this.contributions.set(contribution.projection_id, {
+                owner,
+                status: contribution,
+            });
+            if (contribution.placement === "client_dependent") {
+                this.app.notifications.notify({
+                    title: "Indexing unavailable",
+                    source: owner,
+                    severity: "warning",
+                    message: `${contribution.projection_id}: ${contribution.message ?? "Requires a client processor"}`,
+                });
+            }
+            return contribution;
+        });
+        this.pending.set(owner, [...(this.pending.get(owner) ?? []), operation]);
+        // Activation/load observes failures; do not create an unhandled rejection
+        // while a synchronous plugin declaration is still returning its query handle.
+        void operation.catch(() => { });
+        return operation;
+    }
+    callSearch(command) {
+        const operation = this.searchControl.then(() => {
+            if (this.detached)
+                throw new Error("Native indexing observer is detached");
+            return this.port.call(command);
+        });
+        this.searchControl = operation.then(() => undefined, () => undefined);
+        return operation;
+    }
+    async ready(owner) {
+        const operations = owner
+            ? (this.pending.get(owner) ?? [])
+            : [...this.pending.values()].flat();
+        await Promise.all(operations);
+    }
+    async disable(owner) {
+        if (this.detached)
+            return;
+        if (owner === "search" && this.searchDeclared)
+            await this.disableSearch();
+        await this.ready(owner);
+        for (const [id, contribution] of this.contributions) {
+            if (contribution.owner !== owner)
+                continue;
+            if (id === "search") {
+                await this.disableSearch();
+            }
+            else if (contribution.status.placement === "native" &&
+                !id.startsWith("processor:")) {
+                await this.port.call({ kind: "disable_projection", projection_id: id });
+            }
+            this.contributions.delete(id);
+        }
+        this.pending.delete(owner);
+    }
+    getContributionStatuses() {
+        return [...this.contributions.values()].map(({ status }) => ({
+            ...status,
+        }));
+    }
+    async load() {
+        const selected = await this.port.call({ kind: "select_metadata" });
+        if (!selected.status)
+            throw new Error("Native metadata owner was not selected");
+        await this.ready();
+        // Search declares after metadata-loaded. Its owning plugin can already be
+        // enabled; a replacement App without that plugin must retire the old owner.
+        if (!this.searchDeclared &&
+            !this.app.plugins.plugins.get("search")?.enabled)
+            await this.disableSearch();
+        await this.ready();
+        await this.refresh(false);
+    }
+    async refresh(rebuild, presentation) {
+        if (this.detached)
+            throw new Error("Native indexing observer is detached");
+        return this.app.notifications.withProgress({
+            title: presentation?.title ??
+                (rebuild ? "Rebuilding metadata cache" : "Loading metadata cache"),
+            source: presentation?.source ?? "Metadata",
+            location: "status",
+            persistOnError: true,
+        }, async (progress) => {
+            let observing = false;
+            const report = (status) => {
+                if (!status || this.detached)
+                    return;
+                progress.report({
+                    current: status.processed,
+                    total: status.total,
+                    message: status.error ??
+                        (status.active
+                            ? `Indexing ${status.phase}`
+                            : status.pending > 0
+                                ? "Indexing pending changes"
+                                : (presentation?.readyMessage ?? "Metadata index ready")),
+                });
+            };
+            const observe = async () => {
+                if (observing || this.detached)
+                    return;
+                observing = true;
+                try {
+                    report((await this.port.call({ kind: "status" })).status);
+                }
+                catch {
+                    /* The accepted refresh owns its definitive outcome. */
+                }
+                finally {
+                    observing = false;
+                }
+            };
+            const timer = setInterval(() => void observe(), 100);
+            this.observers.add(timer);
+            try {
+                const result = await this.port.call({ kind: "refresh", rebuild });
+                if (!result.status)
+                    throw new Error("Native metadata owner is unavailable");
+                report(result.status);
+                if (result.status.error)
+                    throw new Error(result.status.error);
+                return result.status;
+            }
+            finally {
+                clearInterval(timer);
+                this.observers.delete(timer);
+            }
+        });
+    }
+    dispose() {
+        this.isDetached = true;
+        for (const timer of this.observers)
+            clearInterval(timer);
+        this.observers.clear();
+    }
+}