@lapis-notes/api 0.1.0

package/dist/daily-document-provider.js

@@ -0,0 +1,176 @@
+import { DateTime } from "luxon";
+import { EventDispatcher } from "./events";
+import { parseYaml } from "./utils";
+export const DEFAULT_DAILY_NOTES_FOLDER = "daily";
+export const DEFAULT_DAILY_NOTES_DATE_FORMAT = "yyyy-MM-dd";
+function validateProvider(provider) {
+    if (!provider.id.trim()) {
+        throw new Error("Daily document provider id must not be empty.");
+    }
+    if (!Number.isFinite(provider.priority ?? 0)) {
+        throw new Error(`Daily document provider ${provider.id} must use a finite priority.`);
+    }
+}
+/** Public registry for the host-owned daily Markdown document policy. */
+export class DailyDocumentProviderRegistry extends EventDispatcher {
+    providers = new Map();
+    register(provider) {
+        validateProvider(provider);
+        const id = provider.id.trim();
+        if (this.providers.has(id)) {
+            throw new Error(`Daily document provider already registered: ${id}`);
+        }
+        const registered = { ...provider, id };
+        this.providers.set(id, registered);
+        this.emit("changed", { providerId: id, reason: "registered" });
+        let disposed = false;
+        return {
+            id,
+            dispose: () => {
+                if (disposed)
+                    return;
+                disposed = true;
+                if (this.providers.get(id) !== registered)
+                    return;
+                this.providers.delete(id);
+                this.emit("changed", { providerId: id, reason: "unregistered" });
+            },
+        };
+    }
+    getAll() {
+        return [...this.providers.values()];
+    }
+    resolve() {
+        const providers = this.getAll().sort((left, right) => (right.priority ?? 0) - (left.priority ?? 0) ||
+            left.id.localeCompare(right.id));
+        const selected = providers[0];
+        if (!selected) {
+            throw new Error("No daily document provider is registered.");
+        }
+        const conflicting = providers[1];
+        if (conflicting &&
+            (conflicting.priority ?? 0) === (selected.priority ?? 0)) {
+            throw new Error(`Ambiguous daily document providers: ${selected.id}, ${conflicting.id}`);
+        }
+        return selected;
+    }
+}
+const DAILY_NOTES_CONFIGURATION_SCHEMA = {
+    id: "dailyNotes",
+    title: "Daily notes",
+    type: "object",
+    properties: {
+        folder: {
+            type: "string",
+            default: DEFAULT_DAILY_NOTES_FOLDER,
+            title: "Folder",
+            description: "Vault folder used when a daily note must be created.",
+        },
+        dateFormat: {
+            type: "string",
+            default: DEFAULT_DAILY_NOTES_DATE_FORMAT,
+            title: "Filename date format",
+            description: "Luxon date format used for new daily-note filenames. It must produce one safe filename segment.",
+        },
+    },
+};
+function assertLocalDate(date) {
+    const parsed = DateTime.fromISO(date, { zone: "utc", setZone: true });
+    if (!/^\d{4}-\d{2}-\d{2}$/u.test(date) || !parsed.isValid) {
+        throw new Error(`Invalid local date: ${date}`);
+    }
+    return parsed;
+}
+export function formatDailyDocumentFilename(date, format) {
+    const trimmedFormat = format.trim();
+    if (!trimmedFormat) {
+        throw new Error("Daily-note date format must not be empty.");
+    }
+    const formatted = assertLocalDate(date).toFormat(trimmedFormat);
+    if (!formatted ||
+        formatted === "." ||
+        formatted === ".." ||
+        /[/\\\u0000-\u001f:]/u.test(formatted)) {
+        throw new Error(`Daily-note date format must produce one safe filename segment; received ${JSON.stringify(formatted)}.`);
+    }
+    return `${formatted}.md`;
+}
+function normalizeDailyNotesFolder(folder) {
+    const normalized = folder
+        .trim()
+        .replaceAll("\\", "/")
+        .replace(/^\/+|\/+$/gu, "");
+    if (!normalized ||
+        normalized
+            .split("/")
+            .some((segment) => !segment || segment === "." || segment === "..") ||
+        /[\u0000-\u001f:]/u.test(normalized)) {
+        throw new Error(`Invalid daily-note folder: ${JSON.stringify(folder)}.`);
+    }
+    return normalized;
+}
+function frontmatterFromContent(content) {
+    const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/u.exec(content);
+    return match ? parseYaml(match[1]) : null;
+}
+async function dailyFrontmatter(app, file) {
+    const cached = (await app.metadataCache.getFileCacheAsync(file))?.frontmatter;
+    if (cached)
+        return cached;
+    return frontmatterFromContent(await app.vault.read(file));
+}
+function isCanonicalDailyFrontmatter(frontmatter, date) {
+    return frontmatter?.type === "daily-note" && frontmatter.date === date;
+}
+function dailyDocumentContent(date) {
+    return `---\ntype: daily-note\ndate: ${date}\n---\n\n# ${date}\n`;
+}
+/**
+ * Install Lapis' default daily-note policy and its generated settings controls.
+ * Hosts call this before loading configuration and dispose it with the App.
+ */
+export function registerDefaultDailyDocumentProvider(app) {
+    app.configuration.schema.register(DAILY_NOTES_CONFIGURATION_SCHEMA);
+    const locate = async (date) => {
+        assertLocalDate(date);
+        const matches = [];
+        for (const file of app.vault.getMarkdownFiles()) {
+            if (isCanonicalDailyFrontmatter(await dailyFrontmatter(app, file), date)) {
+                matches.push(file);
+            }
+        }
+        if (matches.length > 1) {
+            throw new Error(`Multiple daily notes declare date ${date}: ${matches.map((file) => file.path).join(", ")}`);
+        }
+        return matches[0] ?? null;
+    };
+    const registration = app.dailyDocumentProviders.register({
+        id: "lapis:daily-notes",
+        locate,
+        ensure: async (date) => {
+            const existing = await locate(date);
+            if (existing)
+                return existing;
+            const configuration = app.configuration.getConfiguration();
+            const folder = normalizeDailyNotesFolder(configuration.get("dailyNotes.folder", DEFAULT_DAILY_NOTES_FOLDER));
+            const filename = formatDailyDocumentFilename(date, configuration.get("dailyNotes.dateFormat", DEFAULT_DAILY_NOTES_DATE_FORMAT));
+            const path = `${folder}/${filename}`;
+            const occupied = app.vault.getFileByPath(path);
+            if (occupied) {
+                const frontmatter = await dailyFrontmatter(app, occupied);
+                if (isCanonicalDailyFrontmatter(frontmatter, date))
+                    return occupied;
+                throw new Error(`Cannot create daily note for ${date}: ${path} already exists without matching daily-note front matter.`);
+            }
+            await app.vault.mkpath(folder);
+            return app.vault.create(path, dailyDocumentContent(date));
+        },
+    });
+    return {
+        id: registration.id,
+        dispose: () => {
+            registration.dispose();
+            app.configuration.schema.unregister(DAILY_NOTES_CONFIGURATION_SCHEMA);
+        },
+    };
+}

package/dist/design-core-button-types.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Mirror of `@lapismd/design-core/shadcn/button` public variant/size unions.
+ * Kept as a plain .ts module so `tsc --noEmit` does not need to parse
+ * design-core's `<script module>` exports from `button.svelte`.
+ */
+export type ButtonVariant = "default" | "outline" | "secondary" | "ghost" | "destructive" | "link";
+export type ButtonSize = "default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg";

package/dist/design-core-button-types.js

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

package/dist/diagnostics.d.ts

@@ -0,0 +1,93 @@
+import type { WorkspaceDiagnosticsManager as DesignDiagnosticsManager } from "@lapismd/design-core/workspace/problems";
+import type { WorkspaceMenu } from "@lapismd/design-core/workspace/core";
+import type { Menu } from "./menu.svelte";
+export type DiagnosticSeverity = "error" | "warning" | "information" | "hint";
+export interface DiagnosticPosition {
+    line: number;
+    character: number;
+}
+export interface DiagnosticRange {
+    start: DiagnosticPosition;
+    end: DiagnosticPosition;
+}
+export type DiagnosticTag = "unnecessary" | "deprecated";
+export interface DiagnosticResource {
+    uri: string;
+    label?: string;
+    detail?: string;
+    icon?: string;
+}
+export interface DiagnosticRelatedInformation {
+    resource: DiagnosticResource;
+    range?: DiagnosticRange;
+    message: string;
+}
+export interface WorkspaceDiagnostic {
+    message: string;
+    severity: DiagnosticSeverity;
+    range?: DiagnosticRange;
+    source?: string;
+    code?: string | number | {
+        value: string | number;
+        target?: string;
+    };
+    tags?: readonly DiagnosticTag[];
+    relatedInformation?: readonly DiagnosticRelatedInformation[];
+}
+export interface WorkspaceDiagnosticEntry {
+    key: string;
+    collectionId: string;
+    collectionLabel: string;
+    resource: DiagnosticResource | null;
+    diagnostic: WorkspaceDiagnostic;
+}
+export interface DiagnosticCollectionOptions {
+    label?: string;
+    buildItemMenu?: (menu: Menu, entry: WorkspaceDiagnosticEntry) => void;
+}
+export type DiagnosticCollectionUpdate = readonly [
+    resource: DiagnosticResource | null,
+    diagnostics: readonly WorkspaceDiagnostic[] | undefined
+];
+export interface DiagnosticCollection extends Iterable<readonly [DiagnosticResource | null, readonly WorkspaceDiagnostic[]]> {
+    readonly id: string;
+    readonly label: string;
+    readonly disposed: boolean;
+    set(resource: DiagnosticResource | null, diagnostics: readonly WorkspaceDiagnostic[] | undefined): void;
+    set(entries: Iterable<DiagnosticCollectionUpdate>): void;
+    get(resource: DiagnosticResource | null): readonly WorkspaceDiagnostic[] | undefined;
+    has(resource: DiagnosticResource | null): boolean;
+    delete(resource: DiagnosticResource | null): boolean;
+    clear(): void;
+    forEach(callback: (resource: DiagnosticResource | null, diagnostics: readonly WorkspaceDiagnostic[], collection: DiagnosticCollection) => void): void;
+    dispose(): void;
+}
+export interface DiagnosticsSnapshot {
+    entries: readonly WorkspaceDiagnosticEntry[];
+    counts: Readonly<Record<DiagnosticSeverity, number>>;
+}
+type AppendMenu = (target: WorkspaceMenu, source: Menu) => void;
+/** Lapis-owned façade over Design Core's application-independent manager. */
+export declare class DiagnosticsManager {
+    private readonly manager;
+    private readonly createMenu;
+    private readonly appendMenu;
+    constructor(manager: DesignDiagnosticsManager, createMenu: () => Menu, appendMenu: AppendMenu);
+    get size(): number;
+    createCollection(id: string, options?: DiagnosticCollectionOptions): DiagnosticCollection;
+    getCollection(id: string): DiagnosticCollection | undefined;
+    subscribe(subscriber: (snapshot: DiagnosticsSnapshot) => void): () => void;
+    snapshot(): DiagnosticsSnapshot;
+}
+export declare function bindRuntimePluginDiagnostics(plugins: {
+    on(name: "plugin-error", listener: (id: string, message: string) => void): unknown;
+    on(name: "plugin-enabled", listener: (plugin: {
+        manifest: {
+            id: string;
+        };
+    }) => void): unknown;
+    offref(ref: unknown): void;
+}, diagnostics: Pick<DiagnosticsManager, "createCollection">): () => void;
+export declare function diagnosticResourceForPath(path: string): DiagnosticResource;
+export declare function pathFromDiagnosticResource(resource: DiagnosticResource): string | null;
+export {};

package/dist/diagnostics.js

@@ -0,0 +1,84 @@
+/** Lapis-owned façade over Design Core's application-independent manager. */
+export class DiagnosticsManager {
+    manager;
+    createMenu;
+    appendMenu;
+    constructor(manager, createMenu, appendMenu) {
+        this.manager = manager;
+        this.createMenu = createMenu;
+        this.appendMenu = appendMenu;
+    }
+    get size() {
+        return this.manager.size;
+    }
+    createCollection(id, options = {}) {
+        const designOptions = {
+            label: options.label,
+            buildItemMenu: options.buildItemMenu
+                ? (target, entry) => {
+                    const menu = this.createMenu();
+                    options.buildItemMenu?.(menu, entry);
+                    this.appendMenu(target, menu);
+                }
+                : undefined,
+        };
+        return this.manager.createCollection(id, designOptions);
+    }
+    getCollection(id) {
+        return this.manager.getCollection(id);
+    }
+    subscribe(subscriber) {
+        return this.manager.subscribe((snapshot) => subscriber(snapshot));
+    }
+    snapshot() {
+        return this.manager.snapshot();
+    }
+}
+export function bindRuntimePluginDiagnostics(plugins, diagnostics) {
+    const collection = diagnostics.createCollection("lapis:runtime", {
+        label: "Runtime",
+    });
+    const pluginFailures = new Map();
+    const publish = () => {
+        if (collection.disposed)
+            return;
+        collection.set(null, [...pluginFailures.values()]);
+    };
+    const errorRef = plugins.on("plugin-error", (id, message) => {
+        pluginFailures.set(id, {
+            message,
+            severity: "error",
+            source: "Plugin",
+            code: id,
+        });
+        publish();
+    });
+    const enabledRef = plugins.on("plugin-enabled", (plugin) => {
+        if (!pluginFailures.delete(plugin.manifest.id))
+            return;
+        publish();
+    });
+    return () => {
+        plugins.offref(errorRef);
+        plugins.offref(enabledRef);
+    };
+}
+export function diagnosticResourceForPath(path) {
+    const normalized = path.replace(/^\/+/, "");
+    return {
+        uri: `vault:///${encodeURI(normalized)}`,
+        label: normalized.split("/").at(-1) ?? normalized,
+        detail: normalized,
+        icon: "file-text",
+    };
+}
+export function pathFromDiagnosticResource(resource) {
+    if (!resource.uri.startsWith("vault:///"))
+        return null;
+    try {
+        return decodeURI(resource.uri.slice("vault:///".length));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/dialog-portal.d.ts

@@ -0,0 +1,3 @@
+export declare function dialogPortalPropsForDocument(doc: Document): {
+    to: HTMLElement;
+};

package/dist/dialog-portal.js

@@ -0,0 +1,3 @@
+export function dialogPortalPropsForDocument(doc) {
+    return { to: doc.body };
+}

package/dist/docs-api.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Curated entry point for the public plugin API reference published on
+ * lapis.md.
+ *
+ * Keep this list focused on the supported plugin-author surface rather than the
+ * package's full internal export barrel.
+ */
+export { App, createDefaultAppSafeModeState, RenderContext, SecretStorage, } from "./context.svelte";
+export type { AppSafeModeFailure, AppSafeModeState, AppStateProperties, } from "./context.svelte";
+export { getApplicationCompatibility, installApplicationCompatibility, resolveApplication, } from "./application-compatibility";
+export { provideApplicationState, useApplicationState, } from "./application-state.svelte";
+export { Plugin, resolvePluginDataPath } from "./plugin";
+export type { PluginManifest, PluginRuntimeOptions, PluginSource, } from "./plugin";
+export type { LapisExtensionContributions, LapisExtensionKind, LapisExtensionManifest, LapisExtensionPermission, LapisExtensionRuntimeHost, LapisPluginClassification, } from "./lapis-extension";
+export { PluginManager } from "./plugin-manager";
+export { AppUrlService } from "./app-url";
+export { FileManager } from "./file-manager";
+export { AppSettings, ButtonComponent, DropdownComponent, Modal, PluginSettingTab, ProgressBarComponent, SearchComponent, Setting, SliderComponent, TextAreaComponent, TextComponent, ToggleComponent, } from "./settings.svelte";
+export { Menu, MenuItem, MenuSeparator } from "./menu.svelte";
+export { CommandManager, Keymap, Scope } from "./command.svelte";
+export type { Command, Hotkey, HotkeyAssignment, HotkeyConflict, KeymapContext, KeymapEventHandler, KeymapInfo, } from "./command.svelte";
+export { Component, FileView, ItemView, TextFileView, View, } from "./view.svelte";
+export type { ViewState, ViewStateResult } from "./view.svelte";
+export { Notice, Workspace, WorkspaceLeaf, WorkspaceSidebarGroup, WorkspaceSidedock, WorkspaceSplit, WorkspaceTabs, } from "./workspace.svelte";
+export type { OpenViewState, WorkspaceHintTarget } from "./workspace.svelte";
+export { AbstractInputSuggest, EditorSuggest, FuzzySuggestModal, PopoverSuggest, SuggestModal, } from "./suggest";
+export type { EditorSuggestContext, EditorSuggestTriggerInfo } from "./suggest";
+export { Editor } from "./editor.svelte";
+export type { EditorChange, EditorPosition, EditorRange, EditorRangeOrCaret, EditorScrollInfo, EditorSelection, EditorSelectionOrCaret, EditorTransaction, MarkdownFileInfo, } from "./editor.svelte";
+export { MarkdownRenderChild } from "./markdown";
+export type { MarkdownDirectiveRenderer, MarkdownPostProcessor, MarkdownPostProcessorContext, MarkdownViewMenuItemProvider, } from "./markdown";
+export type { MarkdownCodeMirrorExtensionContext, MarkdownContributionMode, MarkdownExtensionContribution, MarkdownSurfaceContext, } from "./markdown-extension-registry";
+export type { MarkdownFileSurfaceActivation, MarkdownFileSurfaceHandle, MarkdownFileSurfaceOptions, MarkdownFileSurfaceProvider, } from "./markdown-file-surface-registry";
+export { MetadataCache } from "./cache.svelte";
+export type { CachedMetadata } from "./cache.svelte";
+export { TAbstractFile, TFile, TFolder, Vault } from "./storage";
+export type { DataAdapter, VaultAdapter, VaultAdapterCapabilities, VaultIdentityAdapter, VaultProfile, VaultProfileDemoMetadata, VaultSession, } from "./storage";
+export { normalizePath } from "./storage/path";
+export { addIcon } from "./icons/index";
+export { NotificationManager, NotificationProgressHandle, } from "./notifications";
+export type { NotifyOptions, NotificationProgressOptions, NotificationProgressReport, NotificationProgressSnapshot, NotificationProgressToken, } from "./notifications";
+export { EventDispatcher } from "./events";
+export { LanguageServiceManager } from "./language-service";
+export type { LanguageServiceCompletionItem, LanguageServiceDiagnostic, LanguageServiceHover, LanguageServiceLocation, LanguageServiceProvider, LanguageServiceProviderCapabilities, LanguageServiceProviderMetadata, } from "./language-service";

package/dist/docs-api.js

@@ -0,0 +1,29 @@
+/**
+ * Curated entry point for the public plugin API reference published on
+ * lapis.md.
+ *
+ * Keep this list focused on the supported plugin-author surface rather than the
+ * package's full internal export barrel.
+ */
+export { App, createDefaultAppSafeModeState, RenderContext, SecretStorage, } from "./context.svelte";
+export { getApplicationCompatibility, installApplicationCompatibility, resolveApplication, } from "./application-compatibility";
+export { provideApplicationState, useApplicationState, } from "./application-state.svelte";
+export { Plugin, resolvePluginDataPath } from "./plugin";
+export { PluginManager } from "./plugin-manager";
+export { AppUrlService } from "./app-url";
+export { FileManager } from "./file-manager";
+export { AppSettings, ButtonComponent, DropdownComponent, Modal, PluginSettingTab, ProgressBarComponent, SearchComponent, Setting, SliderComponent, TextAreaComponent, TextComponent, ToggleComponent, } from "./settings.svelte";
+export { Menu, MenuItem, MenuSeparator } from "./menu.svelte";
+export { CommandManager, Keymap, Scope } from "./command.svelte";
+export { Component, FileView, ItemView, TextFileView, View, } from "./view.svelte";
+export { Notice, Workspace, WorkspaceLeaf, WorkspaceSidebarGroup, WorkspaceSidedock, WorkspaceSplit, WorkspaceTabs, } from "./workspace.svelte";
+export { AbstractInputSuggest, EditorSuggest, FuzzySuggestModal, PopoverSuggest, SuggestModal, } from "./suggest";
+export { Editor } from "./editor.svelte";
+export { MarkdownRenderChild } from "./markdown";
+export { MetadataCache } from "./cache.svelte";
+export { TAbstractFile, TFile, TFolder, Vault } from "./storage";
+export { normalizePath } from "./storage/path";
+export { addIcon } from "./icons/index";
+export { NotificationManager, NotificationProgressHandle, } from "./notifications";
+export { EventDispatcher } from "./events";
+export { LanguageServiceManager } from "./language-service";

package/dist/editor-view-registry.d.ts

@@ -0,0 +1,35 @@
+import { EventDispatcher } from "./events";
+export type EditorViewPriority = "default" | "option" | "exclusive";
+export type EditorViewContribution = {
+    id: string;
+    viewType?: string;
+    label: string;
+    description?: string;
+    filenamePatterns?: string[];
+    priority?: EditorViewPriority;
+    pluginId?: string;
+    source?: "core" | "plugin" | "manifest" | "compat";
+    activationEvent?: string;
+};
+export type RegisteredEditorViewContribution = EditorViewContribution & {
+    viewType: string;
+    filenamePatterns: string[];
+    priority: EditorViewPriority;
+};
+export type EditorViewRegistryChange = {
+    id: string;
+    action: "registered" | "updated" | "unregistered";
+};
+export declare class EditorViewRegistry extends EventDispatcher<{
+    changed: [change: EditorViewRegistryChange];
+}> {
+    private readonly views;
+    register(contribution: EditorViewContribution): () => void;
+    upsert(contribution: EditorViewContribution): () => void;
+    update(id: string, contribution: Partial<EditorViewContribution>): boolean;
+    removeFilenamePatterns(id: string, patterns: readonly string[]): boolean;
+    unregister(id: string): boolean;
+    get(id: string): RegisteredEditorViewContribution | undefined;
+    getByViewType(viewType: string): RegisteredEditorViewContribution[];
+    getAll(): RegisteredEditorViewContribution[];
+}

package/dist/editor-view-registry.js

@@ -0,0 +1,112 @@
+import { EventDispatcher } from "./events";
+function normalizeString(value) {
+    return value.trim();
+}
+function uniqueStrings(values = []) {
+    return [...new Set(values.map(normalizeString).filter(Boolean))];
+}
+function normalizeContribution(contribution) {
+    const id = normalizeString(contribution.id);
+    if (!id) {
+        throw new Error("Editor view contribution id must not be empty.");
+    }
+    const label = normalizeString(contribution.label);
+    if (!label) {
+        throw new Error(`Editor view contribution ${id} label must not be empty.`);
+    }
+    return {
+        ...contribution,
+        id,
+        viewType: normalizeString(contribution.viewType ?? id),
+        label,
+        filenamePatterns: uniqueStrings(contribution.filenamePatterns),
+        priority: contribution.priority ?? "option",
+    };
+}
+function mergeContribution(current, next) {
+    const normalized = normalizeContribution({ ...current, ...next });
+    return {
+        ...current,
+        ...normalized,
+        filenamePatterns: uniqueStrings([
+            ...current.filenamePatterns,
+            ...normalized.filenamePatterns,
+        ]),
+    };
+}
+export class EditorViewRegistry extends EventDispatcher {
+    views = new Map();
+    register(contribution) {
+        const normalized = normalizeContribution(contribution);
+        if (this.views.has(normalized.id)) {
+            console.warn(`Editor view ${normalized.id} is already registered.`);
+            return () => { };
+        }
+        this.views.set(normalized.id, normalized);
+        this.emit("changed", { id: normalized.id, action: "registered" });
+        return () => {
+            this.unregister(normalized.id);
+        };
+    }
+    upsert(contribution) {
+        const normalized = normalizeContribution(contribution);
+        const existing = this.views.get(normalized.id);
+        if (!existing) {
+            return this.register(normalized);
+        }
+        const merged = mergeContribution(existing, normalized);
+        this.views.set(merged.id, merged);
+        this.emit("changed", { id: merged.id, action: "updated" });
+        return () => { };
+    }
+    update(id, contribution) {
+        const existing = this.views.get(id);
+        if (!existing) {
+            return false;
+        }
+        const merged = mergeContribution(existing, {
+            ...existing,
+            ...contribution,
+            id: existing.id,
+            label: contribution.label ?? existing.label,
+        });
+        this.views.set(existing.id, merged);
+        this.emit("changed", { id: existing.id, action: "updated" });
+        return true;
+    }
+    removeFilenamePatterns(id, patterns) {
+        const existing = this.views.get(id);
+        if (!existing) {
+            return false;
+        }
+        const removedPatterns = new Set(uniqueStrings(patterns));
+        const filenamePatterns = existing.filenamePatterns.filter((pattern) => !removedPatterns.has(pattern));
+        if (filenamePatterns.length === existing.filenamePatterns.length) {
+            return false;
+        }
+        if (filenamePatterns.length === 0 && existing.source === "compat") {
+            this.views.delete(id);
+            this.emit("changed", { id, action: "unregistered" });
+            return true;
+        }
+        this.views.set(id, { ...existing, filenamePatterns });
+        this.emit("changed", { id, action: "updated" });
+        return true;
+    }
+    unregister(id) {
+        const deleted = this.views.delete(id);
+        if (deleted) {
+            this.emit("changed", { id, action: "unregistered" });
+        }
+        return deleted;
+    }
+    get(id) {
+        return this.views.get(id);
+    }
+    getByViewType(viewType) {
+        return this.getAll().filter((view) => view.viewType === viewType);
+    }
+    getAll() {
+        return [...this.views.values()].sort((left, right) => left.label.localeCompare(right.label));
+    }
+}