@lapis-notes/workspace 0.1.0 → 0.2.1

package/dist/plugin-management/plugin-registry-controller.svelte.d.ts

@@ -0,0 +1,29 @@
+import { type App, type InstalledPluginRecord, type PluginCatalogEntry, type PluginDownloadStatsSummary, type PluginRegistrySourceState, type PluginUpdateInfo } from "@lapis-notes/api";
+import type { PluginRegistryActionFeedback } from "./plugin-registry-detail";
+export declare const registryErrorMessage: (error: unknown) => string;
+export declare function getPluginRegistryController(app: App): PluginRegistryController;
+/** One shared read model and action flow for the browser and Settings. */
+export declare class PluginRegistryController {
+    readonly app: App;
+    catalogEntries: PluginCatalogEntry[];
+    installed: InstalledPluginRecord[];
+    updates: PluginUpdateInfo[];
+    downloadStats: PluginDownloadStatsSummary | null;
+    registrySources: readonly PluginRegistrySourceState[];
+    lastError: Error | null;
+    initialLoading: boolean;
+    refreshing: boolean;
+    runningAction: string | null;
+    actionFeedback: PluginRegistryActionFeedback | null;
+    pluginLifecycleRevision: number;
+    private references;
+    private disposers;
+    private generation;
+    private refreshTask;
+    constructor(app: App);
+    retain(): () => void;
+    refresh(force: boolean): Promise<void>;
+    runPluginAction(actionId: string, pluginId: string, title: string, action: (signal: AbortSignal) => Promise<unknown>): Promise<void>;
+    install(entry: PluginCatalogEntry, version?: string): Promise<void>;
+    update(update: PluginUpdateInfo): Promise<void>;
+}

package/dist/plugin-management/plugin-registry-controller.svelte.js

@@ -0,0 +1,154 @@
+import { isAbortError, Notice, PluginDistributionError, withPluginInstallProgress, } from "@lapis-notes/api";
+export const registryErrorMessage = (error) => error instanceof PluginDistributionError
+    ? `${error.code}: ${error.message}`
+    : error instanceof Error
+        ? error.message
+        : String(error);
+const controllers = new WeakMap();
+export function getPluginRegistryController(app) {
+    let controller = controllers.get(app);
+    if (!controller) {
+        controller = new PluginRegistryController(app);
+        controllers.set(app, controller);
+    }
+    return controller;
+}
+/** One shared read model and action flow for the browser and Settings. */
+export class PluginRegistryController {
+    app;
+    catalogEntries = $state([]);
+    installed = $state([]);
+    updates = $state([]);
+    downloadStats = $state(null);
+    registrySources = $state([]);
+    lastError = $state(null);
+    initialLoading = $state(true);
+    refreshing = $state(false);
+    runningAction = $state(null);
+    actionFeedback = $state(null);
+    pluginLifecycleRevision = $state(0);
+    references = 0;
+    disposers = [];
+    generation = 0;
+    refreshTask = null;
+    constructor(app) {
+        this.app = app;
+        this.registrySources = app.pluginDistribution.listSources();
+    }
+    retain() {
+        if (this.references++ === 0) {
+            for (const name of ["plugin-enabled", "plugin-disabled"]) {
+                const ref = this.app.plugins.on(name, () => {
+                    this.pluginLifecycleRevision += 1;
+                });
+                this.disposers.push(() => this.app.plugins.offref(ref));
+            }
+        }
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            if (--this.references === 0) {
+                this.disposers.splice(0).forEach((dispose) => dispose());
+                this.generation += 1;
+                this.refreshTask = null;
+                this.refreshing = false;
+            }
+        };
+    }
+    async refresh(force) {
+        if (this.refreshTask) {
+            await this.refreshTask;
+            if (!force)
+                return;
+        }
+        const generation = this.generation;
+        this.refreshing = true;
+        const task = (async () => {
+            try {
+                this.lastError = null;
+                if (force || !this.catalogEntries.length)
+                    await this.app.pluginDistribution.refreshCatalog({ force });
+                const catalogEntries = this.app.pluginDistribution.search({
+                    channel: "all",
+                });
+                const [installed, updates, downloadStats] = await Promise.all([
+                    this.app.pluginDistribution.listInstalled(),
+                    this.app.pluginDistribution.listUpdates(),
+                    this.app.pluginDistribution
+                        .getDownloadStats?.({ force })
+                        .catch(() => null) ?? null,
+                ]);
+                if (generation !== this.generation)
+                    return;
+                this.catalogEntries = catalogEntries;
+                this.installed = installed;
+                this.updates = updates;
+                this.downloadStats = downloadStats;
+            }
+            catch (error) {
+                if (generation === this.generation)
+                    this.lastError =
+                        error instanceof Error ? error : new Error(String(error));
+            }
+            finally {
+                if (generation === this.generation) {
+                    this.registrySources = this.app.pluginDistribution.listSources();
+                    this.initialLoading = false;
+                    this.refreshing = false;
+                }
+            }
+        })();
+        this.refreshTask = task;
+        await task;
+        if (this.refreshTask === task)
+            this.refreshTask = null;
+    }
+    async runPluginAction(actionId, pluginId, title, action) {
+        if (this.runningAction)
+            return;
+        this.runningAction = actionId;
+        this.actionFeedback = { pluginId, state: "running", message: title };
+        try {
+            await withPluginInstallProgress(this.app, { pluginId, title }, action);
+            await this.refresh(false);
+            this.actionFeedback = {
+                pluginId,
+                state: "success",
+                message: actionId.startsWith("update:")
+                    ? "Update installed"
+                    : "Installed",
+            };
+        }
+        catch (error) {
+            if (isAbortError(error)) {
+                this.actionFeedback = null;
+                await this.refresh(false);
+                return;
+            }
+            this.actionFeedback = {
+                pluginId,
+                state: "error",
+                message: registryErrorMessage(error),
+            };
+            new Notice(`Plugin registry action failed: ${registryErrorMessage(error)}`, undefined, this.app);
+        }
+        finally {
+            this.runningAction = null;
+        }
+    }
+    install(entry, version) {
+        return this.runPluginAction(`install:${entry.id}`, entry.id, `Installing ${entry.name}`, (signal) => this.app.pluginDistribution.install(entry.id, {
+            version,
+            enable: true,
+            requireOfficial: entry.channel === "official",
+            signal,
+        }));
+    }
+    update(update) {
+        return this.runPluginAction(`update:${update.id}`, update.id, `Updating ${update.name}`, (signal) => this.app.pluginDistribution.update(update.id, update.targetVersion, {
+            signal,
+        }));
+    }
+}

package/dist/plugin-management/plugin-registry-detail-session.svelte.d.ts

@@ -0,0 +1,18 @@
+import { type App, type PluginCatalogDetail, type PluginCatalogEntry } from "@lapis-notes/api";
+import type { PluginMarkdownState } from "./plugin-registry-detail";
+/** Surface-owned detail requests; a late response cannot replace a newer route. */
+export declare class PluginRegistryDetailSession {
+    readonly app: App;
+    entryId: string | null;
+    detail: PluginCatalogDetail | null;
+    loading: boolean;
+    overview: PluginMarkdownState;
+    changelog: PluginMarkdownState;
+    private generation;
+    private entry;
+    constructor(app: App);
+    dispose(): void;
+    select(entry: PluginCatalogEntry): Promise<void>;
+    retry(kind: "overview" | "changelog"): Promise<void>;
+    private load;
+}

package/dist/plugin-management/plugin-registry-detail-session.svelte.js

@@ -0,0 +1,106 @@
+import { fetchVerifiedPluginMarkdown, } from "@lapis-notes/api";
+import { registryErrorMessage } from "./plugin-registry-controller.svelte";
+import { fetchPluginReadmeMarkdown, resolveReadmeRelativeUrls, } from "./plugin-readme";
+/** Surface-owned detail requests; a late response cannot replace a newer route. */
+export class PluginRegistryDetailSession {
+    app;
+    entryId = $state(null);
+    detail = $state(null);
+    loading = $state(false);
+    overview = $state({ status: "idle" });
+    changelog = $state({ status: "idle" });
+    generation = 0;
+    entry = null;
+    constructor(app) {
+        this.app = app;
+    }
+    dispose() {
+        this.generation += 1;
+        this.loading = false;
+    }
+    async select(entry) {
+        const generation = ++this.generation;
+        this.entry = entry;
+        this.entryId = entry.id;
+        this.detail = null;
+        this.loading = true;
+        this.overview = { status: "loading" };
+        this.changelog = { status: "loading" };
+        try {
+            const detail = await this.app.pluginDistribution.getPluginDetail(entry.id);
+            if (generation !== this.generation)
+                return;
+            this.detail = detail;
+            if (detail?.schemaVersion === 2) {
+                this.overview = { status: "missing" };
+                this.changelog = { status: "missing" };
+                return;
+            }
+            await Promise.all([
+                this.load("overview", entry, detail, generation),
+                this.load("changelog", entry, detail, generation),
+            ]);
+        }
+        catch (error) {
+            if (generation !== this.generation)
+                return;
+            this.overview = { status: "error", message: registryErrorMessage(error) };
+            this.changelog = { status: "missing" };
+        }
+        finally {
+            if (generation === this.generation)
+                this.loading = false;
+        }
+    }
+    async retry(kind) {
+        if (!this.entry)
+            return;
+        this[kind] = { status: "loading" };
+        await this.load(kind, this.entry, this.detail, this.generation);
+    }
+    async load(kind, entry, detail, generation) {
+        const reference = detail?.content?.[kind];
+        const set = (state) => {
+            if (generation === this.generation)
+                this[kind] = state;
+        };
+        if (reference) {
+            try {
+                const markdown = await fetchVerifiedPluginMarkdown(reference);
+                set({
+                    status: "loaded",
+                    url: reference.url,
+                    sourceUrl: reference.sourceUrl,
+                    markdown: resolveReadmeRelativeUrls(markdown, reference.url),
+                });
+            }
+            catch (error) {
+                set({
+                    status: "error",
+                    message: registryErrorMessage(error),
+                    sourceUrl: reference.sourceUrl,
+                });
+            }
+            return;
+        }
+        const readmeUrl = detail?.readmeUrl ?? entry.readmeUrl;
+        if (kind === "changelog" || !readmeUrl) {
+            set({ status: "missing" });
+            return;
+        }
+        try {
+            const markdown = await fetchPluginReadmeMarkdown(readmeUrl, {
+                pluginId: entry.id,
+                detailUrl: entry.detail,
+            });
+            set({ status: "loaded", url: readmeUrl, sourceUrl: readmeUrl, markdown });
+        }
+        catch (error) {
+            set({
+                status: "error",
+                message: registryErrorMessage(error),
+                sourceUrl: readmeUrl,
+            });
+        }
+    }
+}

package/dist/plugin-management/plugin-registry-detail.d.ts

@@ -0,0 +1,17 @@
+export type PluginMarkdownState = {
+    status: "idle" | "loading" | "missing";
+} | {
+    status: "loaded";
+    url: string;
+    sourceUrl: string;
+    markdown: string;
+} | {
+    status: "error";
+    message: string;
+    sourceUrl?: string;
+};
+export type PluginRegistryActionFeedback = {
+    pluginId: string;
+    state: "running" | "success" | "error";
+    message: string;
+};

package/dist/plugin-management/plugin-registry-detail.js

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

package/dist/plugin-management/plugins-view.svelte.d.ts

@@ -0,0 +1,41 @@
+import { ItemView, type WorkspaceLeaf } from "@lapis-notes/api";
+import { type PluginBrowserNavigation } from "./PluginBrowser.svelte";
+/** App-owned browser view; registration lives in the private default profile. */
+export declare class PluginsView extends ItemView {
+    private disposeHeader;
+    private component;
+    readonly navigation: PluginBrowserNavigation;
+    constructor(leaf: WorkspaceLeaf);
+    getViewType(): string;
+    getDisplayText(): string;
+    getBreadcrumbs(): ReturnType<ItemView["getBreadcrumbs"]>;
+    getState(): {
+        route: {
+            page: "landing" | "directory";
+        } | {
+            page: "plugin";
+            pluginId: string;
+            version?: string;
+        };
+        directory: {
+            query: string;
+            categories: string[];
+            platforms: string[];
+            statuses: string[];
+            officialOnly: boolean;
+            updatesOnly: boolean;
+            installation: "all" | "installed" | "available";
+            sort: string;
+            view: "grid" | "list";
+        };
+        returnPage: "directory" | "landing";
+        scrollTop: number;
+    };
+    setState(state: Record<string, unknown>): Promise<void>;
+    showPlugin(pluginId: string, version?: string): void;
+    home(): void;
+    load(): void;
+    unload(): void;
+    protected onOpen(): Promise<void>;
+    protected onClose(): Promise<void>;
+}

package/dist/plugin-management/plugins-view.svelte.js

@@ -0,0 +1,109 @@
+import { ItemView } from "@lapis-notes/api";
+import { getPluginRegistryController } from "./plugin-registry-controller.svelte";
+import { mount, unmount } from "svelte";
+import PluginBrowser, {} from "./PluginBrowser.svelte";
+import { defaultDirectoryState, restoreBrowserState, } from "./plugin-browser-model";
+/** App-owned browser view; registration lives in the private default profile. */
+export class PluginsView extends ItemView {
+    disposeHeader = null;
+    component = null;
+    navigation = $state({
+        route: { page: "landing" },
+        directory: defaultDirectoryState(),
+        returnPage: "landing",
+        scrollTop: 0,
+    });
+    constructor(leaf) {
+        super(leaf);
+        this.icon = "package";
+    }
+    getViewType() {
+        return "plugins";
+    }
+    getDisplayText() {
+        if (this.navigation.route.page === "plugin") {
+            const pluginId = this.navigation.route.pluginId;
+            return (getPluginRegistryController(this.app).catalogEntries.find((entry) => entry.id === pluginId)?.name ?? "Plugins");
+        }
+        return "Plugins";
+    }
+    getBreadcrumbs() {
+        if (this.navigation.route.page === "landing")
+            return [];
+        const crumbs = [
+            { id: "registry", label: "Registry", onSelect: () => this.home() },
+        ];
+        if (this.navigation.route.page === "plugin")
+            crumbs.push({
+                id: "plugins",
+                label: "Plugins",
+                onSelect: () => {
+                    this.navigation.route = { page: this.navigation.returnPage };
+                    this.app.workspace.requestSaveLayout();
+                },
+            });
+        return crumbs;
+    }
+    getState() {
+        return {
+            route: { ...this.navigation.route },
+            directory: structuredClone($state.snapshot(this.navigation.directory)),
+            returnPage: this.navigation.returnPage,
+            scrollTop: this.navigation.scrollTop,
+        };
+    }
+    async setState(state) {
+        Object.assign(this.navigation, restoreBrowserState(state));
+        this.navigation.returnPage =
+            state.returnPage === "directory" ? "directory" : "landing";
+        this.navigation.scrollTop =
+            typeof state.scrollTop === "number" && Number.isFinite(state.scrollTop)
+                ? Math.max(0, state.scrollTop)
+                : 0;
+    }
+    showPlugin(pluginId, version) {
+        if (this.navigation.route.page !== "plugin")
+            this.navigation.returnPage = this.navigation.route.page;
+        this.navigation.route = {
+            page: "plugin",
+            pluginId,
+            ...(version !== undefined ? { version } : {}),
+        };
+        this.app.workspace.requestSaveLayout();
+    }
+    home() {
+        this.navigation.route = { page: "landing" };
+        this.navigation.scrollTop = 0;
+        this.app.workspace.requestSaveLayout();
+    }
+    load() {
+        this.unload();
+        this.containerEl.replaceChildren();
+        const registry = getPluginRegistryController(this.app);
+        this.actions = [];
+        this.addAction("refresh-cw", "Refresh plugins", () => void registry.refresh(true));
+        this.disposeHeader = $effect.root(() => {
+            $effect(() => {
+                this.actions[0].disabled = registry.refreshing;
+            });
+        });
+        this.component = mount(PluginBrowser, {
+            target: this.containerEl,
+            props: {
+                app: this.app,
+                navigation: this.navigation,
+                onstatechange: () => this.app.workspace.requestSaveLayout(),
+            },
+        });
+    }
+    unload() {
+        this.disposeHeader?.();
+        this.disposeHeader = null;
+        this.actions = [];
+        if (this.component)
+            void unmount(this.component);
+        this.component = null;
+    }
+    async onOpen() { }
+    async onClose() { }
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@lapis-notes/workspace",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Lapis Notes workspace shell backed by design-core",
-  "license": "AGPL-3.0-or-later",
+  "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lapismd/lapis-notes.git",
@@ -38,8 +38,8 @@
     }
   },
   "dependencies": {
-    "@lapis-notes/api": "^0.1.0",
-    "@lapismd/design-core": "^0.1.0",
+    "@lapis-notes/api": "^0.1.2",
+    "@lapismd/design-core": "^0.3.2",
     "@lucide/svelte": "^0.523.0"
   },
   "peerDependencies": {
@@ -52,7 +52,7 @@
     "fake-indexeddb": "^6.2.5",
     "jsdom": "^26.1.0",
     "publint": "^0.3.12",
-    "svelte": "^5.38.2",
+    "svelte": "5.56.10",
     "svelte-check": "^4.3.1",
     "tslib": "^2.8.1",
     "typescript": "~5.8.3",