@lapis-notes/workspace 0.2.1 → 0.3.1

package/dist/file-conflicts/ConflictReview.svelte

@@ -0,0 +1,153 @@
+<script lang="ts">
+  import { MergeEditor } from "@lapismd/design-core/diff";
+  import { Button } from "@lapismd/design-core/shadcn/button";
+  import FileCheckIcon from "@lucide/svelte/icons/file-check";
+  import Undo2Icon from "@lucide/svelte/icons/undo-2";
+  import ConflictReviewControls from "./ConflictReviewControls.svelte";
+  import RefreshCwIcon from "@lucide/svelte/icons/refresh-cw";
+  import type {
+    ConflictReviewState,
+    ConflictSelection,
+  } from "./conflict-review-state.svelte";
+
+  let {
+    model,
+    selection,
+  }: { model: ConflictReviewState; selection: ConflictSelection } = $props();
+  const conflict = $derived(
+    model.entries.find((entry) => entry.path === selection.path),
+  );
+  let options = $state({
+    wrap: false,
+    ignoreWhitespace: false,
+    ignoreCase: false,
+    syncHorizontalScroll: true,
+  });
+  const disabled = $derived(model.disabled() || model.busy !== null);
+</script>
+
+{#if conflict}
+  <section
+    class="conflict-review"
+    aria-label={`File conflict: ${conflict.path}`}
+    aria-busy={model.busy === conflict.path}
+  >
+    <div class="comparison">
+      {#key conflict}
+        {@const seed = selection.seed(conflict)}
+        <MergeEditor
+          path={conflict.path}
+          left={conflict.local}
+          base={seed}
+          right={conflict.external ?? ""}
+          leftLabel="Your version"
+          baseLabel="Merged version"
+          rightLabel="Disk version"
+          readOnly={disabled || conflict.external === undefined}
+          editable
+          editableSides={["base"]}
+          wrap={options.wrap}
+          ignoreWhitespace={options.ignoreWhitespace}
+          ignoreCase={options.ignoreCase}
+          syncHorizontalScroll={options.syncHorizontalScroll}
+          onResolvedChange={({ content }) => {
+            selection.result = content;
+          }}
+        >
+          {#snippet headerCenter()}
+            <ConflictReviewControls bind:options {disabled} />
+          {/snippet}
+        </MergeEditor>
+      {/key}
+    </div>
+    <footer>
+      <div class="explanation">
+        {#if model.error}<p role="alert">{model.error}</p>{/if}
+        {#if conflict.external === undefined}
+          <p role="status">
+            The disk version could not be read: {conflict.readError}
+          </p>
+        {:else if conflict.external === null}
+          <p>The file was deleted from disk.</p>
+        {:else}
+          <p>
+            Edit the centre or accept changes from either side, then save the
+            merged version.
+          </p>
+        {/if}
+      </div>
+      <div class="actions">
+        <Button
+          variant="ghost"
+          disabled={disabled || conflict.external === undefined}
+          onclick={() => model.recover(conflict.path, "use-external")}
+        >
+          <Undo2Icon aria-hidden="true" />Use disk version
+        </Button>
+        <Button
+          variant="outline"
+          disabled={disabled ||
+            conflict.external === undefined ||
+            selection.result === undefined}
+          onclick={() =>
+            model.recover(conflict.path, undefined, selection.result)}
+        >
+          <FileCheckIcon aria-hidden="true" />Save merged version
+        </Button>
+        <Button
+          variant="ghost"
+          {disabled}
+          onclick={() => model.recover(conflict.path)}
+        >
+          <RefreshCwIcon aria-hidden="true" />Check disk again
+        </Button>
+      </div>
+    </footer>
+  </section>
+{/if}
+
+<style>
+  .conflict-review {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+    min-height: 0;
+    color: var(--ui-workspace-view-foreground, var(--foreground));
+    background: var(--ui-workspace-view-background, var(--background));
+  }
+  .comparison {
+    --ui-diff-frame-border: 0;
+    --ui-diff-frame-radius: 0;
+    flex: 1;
+    min-height: 0;
+    overflow: hidden;
+  }
+  footer {
+    display: flex;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 0.75rem;
+    padding: 0.75rem 1rem;
+    border-top: 1px solid var(--ui-workspace-border);
+    background: var(--ui-workspace-background, var(--background));
+  }
+  .explanation {
+    flex: 1;
+    min-width: 12rem;
+    font-size: 0.8125rem;
+  }
+  p {
+    margin: 0;
+  }
+  .actions {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+  }
+  [role="alert"] {
+    color: var(--destructive);
+  }
+  :global(.dark) [role="alert"] {
+    color: color-mix(in srgb, var(--destructive) 60%, var(--foreground));
+  }
+</style>

package/dist/file-conflicts/ConflictReview.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { ConflictReviewState, ConflictSelection } from "./conflict-review-state.svelte";
+type $$ComponentProps = {
+    model: ConflictReviewState;
+    selection: ConflictSelection;
+};
+declare const ConflictReview: import("svelte").Component<$$ComponentProps, {}, "">;
+type ConflictReview = ReturnType<typeof ConflictReview>;
+export default ConflictReview;

package/dist/file-conflicts/ConflictReviewControls.svelte

@@ -0,0 +1,66 @@
+<script lang="ts">
+  import { Toggle } from "@lapismd/design-core/shadcn/toggle";
+  import * as Tooltip from "@lapismd/design-core/shadcn/tooltip";
+  import WrapText from "@lucide/svelte/icons/wrap-text";
+  import Space from "@lucide/svelte/icons/space";
+  import CaseSensitive from "@lucide/svelte/icons/case-sensitive";
+  import ArrowRightLeft from "@lucide/svelte/icons/arrow-right-left";
+
+  let {
+    options = $bindable(),
+    disabled = false,
+  }: {
+    options: {
+      wrap: boolean;
+      ignoreWhitespace: boolean;
+      ignoreCase: boolean;
+      syncHorizontalScroll: boolean;
+    };
+    disabled?: boolean;
+  } = $props();
+  const actions = [
+    { key: "wrap", label: "Wrap text", icon: WrapText },
+    { key: "ignoreWhitespace", label: "Ignore whitespace", icon: Space },
+    { key: "ignoreCase", label: "Ignore case", icon: CaseSensitive },
+    {
+      key: "syncHorizontalScroll",
+      label: "Synchronize horizontal scrolling",
+      icon: ArrowRightLeft,
+    },
+  ] as const;
+</script>
+
+<div class="merge-controls" role="group" aria-label="Merge editor settings">
+  <Tooltip.Provider>
+    {#each actions as action (action.key)}
+      <Tooltip.Root>
+        <Tooltip.Trigger>
+          {#snippet child({ props })}
+            <Toggle
+              {...props}
+              size="sm"
+              {disabled}
+              aria-label={action.label}
+              pressed={options[action.key]}
+              onPressedChange={(pressed) =>
+                (options = { ...options, [action.key]: pressed })}
+            >
+              <action.icon aria-hidden="true" />
+            </Toggle>
+          {/snippet}
+        </Tooltip.Trigger>
+        <Tooltip.Content side="bottom">{action.label}</Tooltip.Content>
+      </Tooltip.Root>
+    {/each}
+  </Tooltip.Provider>
+</div>
+
+<style>
+  .merge-controls {
+    --spacing: 0.1875rem;
+    --muted: color-mix(in srgb, var(--primary) 22%, var(--background));
+    display: flex;
+    align-items: center;
+    gap: 0.125rem;
+  }
+</style>

package/dist/file-conflicts/ConflictReviewControls.svelte.d.ts

@@ -0,0 +1,12 @@
+type $$ComponentProps = {
+    options: {
+        wrap: boolean;
+        ignoreWhitespace: boolean;
+        ignoreCase: boolean;
+        syncHorizontalScroll: boolean;
+    };
+    disabled?: boolean;
+};
+declare const ConflictReviewControls: import("svelte").Component<$$ComponentProps, {}, "options">;
+type ConflictReviewControls = ReturnType<typeof ConflictReviewControls>;
+export default ConflictReviewControls;

package/dist/file-conflicts/conflict-review-state.svelte.d.ts

@@ -0,0 +1,22 @@
+import { SvelteMap } from "svelte/reactivity";
+import type { FileTextConflict, FileTextConflictRegistry, FileTextResolution } from "@lapis-notes/api";
+export declare class ConflictSelection {
+    #private;
+    private readonly results;
+    path: string;
+    constructor(results: SvelteMap<string, string>);
+    get result(): string | undefined;
+    set result(value: string | undefined);
+    seed(conflict: FileTextConflict): string;
+}
+/** Presentation state only; every recovery still uses the writer-owned decision. */
+export declare class ConflictReviewState {
+    readonly registry: FileTextConflictRegistry;
+    readonly disabled: () => boolean;
+    readonly results: SvelteMap<string, string>;
+    entries: readonly FileTextConflict[];
+    busy: string | null;
+    error: string;
+    constructor(registry: FileTextConflictRegistry, disabled: () => boolean);
+    recover(path: string, choice?: FileTextResolution, merged?: string): Promise<void>;
+}

package/dist/file-conflicts/conflict-review-state.svelte.js

@@ -0,0 +1,59 @@
+import { SvelteMap } from "svelte/reactivity";
+export class ConflictSelection {
+    results;
+    path = $state("");
+    constructor(results) {
+        this.results = results;
+    }
+    get result() {
+        return this.results.get(this.path);
+    }
+    set result(value) {
+        if (value === undefined)
+            this.results.delete(this.path);
+        else
+            this.results.set(this.path, value);
+    }
+    #seeds = new WeakMap();
+    seed(conflict) {
+        if (!this.#seeds.has(conflict))
+            this.#seeds.set(conflict, this.result ?? conflict.baseline ?? "");
+        return this.#seeds.get(conflict);
+    }
+}
+/** Presentation state only; every recovery still uses the writer-owned decision. */
+export class ConflictReviewState {
+    registry;
+    disabled;
+    results = new SvelteMap();
+    entries = $state.raw([]);
+    busy = $state(null);
+    error = $state("");
+    constructor(registry, disabled) {
+        this.registry = registry;
+        this.disabled = disabled;
+    }
+    async recover(path, choice, merged) {
+        if (this.disabled() || this.busy !== null)
+            return;
+        const conflict = this.entries.find((entry) => entry.path === path);
+        if (!conflict)
+            return;
+        this.busy = path;
+        this.error = "";
+        try {
+            if (merged !== undefined)
+                await conflict.resolveMerged(merged);
+            else if (choice === undefined)
+                await conflict.refresh();
+            else
+                await conflict.resolve(choice);
+        }
+        catch (error) {
+            this.error = error instanceof Error ? error.message : String(error);
+        }
+        finally {
+            this.busy = null;
+        }
+    }
+}

package/dist/file-conflicts/conflict-review-view.d.ts

@@ -0,0 +1,19 @@
+import { View, type WorkspaceLeaf } from "@lapis-notes/api";
+import { ConflictSelection, type ConflictReviewState } from "./conflict-review-state.svelte";
+export declare const CONFLICT_REVIEW_VIEW = "desktop:file-conflict";
+export declare class ConflictReviewView extends View {
+    #private;
+    private readonly model;
+    readonly selection: ConflictSelection;
+    constructor(leaf: WorkspaceLeaf, model: ConflictReviewState);
+    getViewType(): string;
+    getDisplayText(): string;
+    getIcon(): string;
+    getClosePersistenceScope(): "layout";
+    getState(): Record<string, unknown>;
+    setState(state: Record<string, unknown>): Promise<void>;
+    protected onOpen(): Promise<void>;
+    protected onClose(): Promise<void>;
+    onload(): void;
+    onunload(): void;
+}

package/dist/file-conflicts/conflict-review-view.js

@@ -0,0 +1,50 @@
+import { View } from "@lapis-notes/api";
+import { mount, unmount } from "svelte";
+import ConflictReview from "./ConflictReview.svelte";
+import { ConflictSelection, } from "./conflict-review-state.svelte";
+export const CONFLICT_REVIEW_VIEW = "desktop:file-conflict";
+export class ConflictReviewView extends View {
+    model;
+    selection;
+    #component;
+    constructor(leaf, model) {
+        super(leaf);
+        this.model = model;
+        this.selection = new ConflictSelection(model.results);
+    }
+    getViewType() {
+        return CONFLICT_REVIEW_VIEW;
+    }
+    getDisplayText() {
+        return this.selection.path
+            ? `Resolve ${this.selection.path}`
+            : "File conflict";
+    }
+    getIcon() {
+        return "git-compare-arrows";
+    }
+    getClosePersistenceScope() {
+        return "layout";
+    }
+    getState() {
+        return { path: this.selection.path };
+    }
+    async setState(state) {
+        const path = typeof state.path === "string" ? state.path : "";
+        this.selection.path = path;
+        await super.setState(state);
+    }
+    async onOpen() { }
+    async onClose() { }
+    onload() {
+        this.#component = mount(ConflictReview, {
+            target: this.containerEl,
+            props: { model: this.model, selection: this.selection },
+        });
+    }
+    onunload() {
+        if (this.#component)
+            void unmount(this.#component);
+        this.#component = undefined;
+    }
+}

package/dist/file-conflicts/register-conflict-reviews.d.ts

@@ -0,0 +1,7 @@
+import type { App } from "@lapis-notes/api";
+export interface FileConflictReviewOptions {
+    /** Host-owned leave/startup inhibition, read on every action and render. */
+    disabled?: () => boolean;
+}
+/** One presentation owner per App, shared by early host and mounted shell leases. */
+export declare function bindFileConflictReviews(app: App, options?: FileConflictReviewOptions): () => void;

package/dist/file-conflicts/register-conflict-reviews.js

@@ -0,0 +1,132 @@
+import { SvelteSet } from "svelte/reactivity";
+import { getWorkspaceHostBinding } from "@lapis-notes/api/workspace-host";
+import { CONFLICT_REVIEW_VIEW, ConflictReviewView, } from "./conflict-review-view";
+import { ConflictReviewState } from "./conflict-review-state.svelte";
+const prefix = "lapis-file-conflict:";
+const bindings = new WeakMap();
+/** One presentation owner per App, shared by early host and mounted shell leases. */
+export function bindFileConflictReviews(app, options = {}) {
+    let binding = bindings.get(app);
+    if (!binding) {
+        const disabled = new SvelteSet();
+        binding = {
+            references: 0,
+            disabled,
+            dispose: registerConflictReviews(app, () => [...disabled].some((read) => read())),
+        };
+        bindings.set(app, binding);
+    }
+    const owned = binding;
+    const disabled = () => options.disabled?.() ?? false;
+    owned.disabled.add(disabled);
+    owned.references++;
+    let held = true;
+    return () => {
+        if (!held)
+            return;
+        held = false;
+        owned.disabled.delete(disabled);
+        if (--owned.references === 0) {
+            owned.dispose();
+            bindings.delete(app);
+        }
+    };
+}
+function registerConflictReviews(app, disabled) {
+    const registry = app.fileEditingSessions.textConflicts;
+    const model = new ConflictReviewState(registry, disabled);
+    const controller = getWorkspaceHostBinding(app.workspace).controller;
+    const collection = app.workspace.diagnostics.createCollection("desktop:file-conflicts", { label: "File conflicts" });
+    app.workspace.registerView(CONFLICT_REVIEW_VIEW, (leaf) => new ConflictReviewView(leaf, model));
+    const stopNavigation = app.workspace.registerDiagnosticOpener(async (location) => {
+        if (!location.resource.uri.startsWith(prefix))
+            return false;
+        if (!active)
+            return true;
+        const path = decodeURIComponent(location.resource.uri.slice(prefix.length));
+        if (!model.entries.some((entry) => entry.path === path))
+            return true;
+        let leaf = app.workspace
+            .getLeavesOfType(CONFLICT_REVIEW_VIEW)
+            .find((leaf) => leaf.view.getState().path === path);
+        if (!leaf) {
+            leaf = app.workspace.getLeaf("tab");
+            await leaf.setViewState({
+                type: CONFLICT_REVIEW_VIEW,
+                state: { path },
+            });
+        }
+        if (!active)
+            return true;
+        app.workspace.setActiveLeaf(leaf);
+        if (!active)
+            return true;
+        await app.workspace.revealLeaf(leaf);
+        if (!active)
+            return true;
+        app.workspace.requestSaveLayout({
+            source: "api",
+            operation: "open-file-conflict",
+        });
+        return true;
+    });
+    let active = true;
+    let paths = new Set();
+    const stopRegistry = registry.subscribe((entries) => {
+        model.entries = entries;
+        if (!entries.length)
+            model.error = "";
+        const current = new Set(entries.map((entry) => entry.path));
+        for (const path of paths)
+            if (!current.has(path)) {
+                collection.delete({ uri: prefix + encodeURIComponent(path) });
+                model.results.delete(path);
+            }
+        for (const entry of entries) {
+            collection.set({
+                uri: prefix + encodeURIComponent(entry.path),
+                label: entry.path,
+                icon: "file-warning",
+            }, [
+                {
+                    message: entry.external === undefined
+                        ? "The disk version could not be read. Review the retained draft."
+                        : entry.external === null
+                            ? "The file was deleted on disk. Review the retained draft."
+                            : "File changed on disk. Review your draft before saving.",
+                    severity: "error",
+                    source: "File conflicts",
+                    code: "write-conflict",
+                },
+            ]);
+        }
+        const added = [...current].some((path) => !paths.has(path));
+        paths = current;
+        for (const leaf of app.workspace.getLeavesOfType(CONFLICT_REVIEW_VIEW)) {
+            if (!current.has(String(leaf.view.getState().path)))
+                controller.workspace.closeLeaf(leaf.id);
+        }
+        if (added)
+            void controller
+                .start()
+                .then(async () => {
+                if (active)
+                    await controller.commands.execute("app-shell:show-problems");
+            })
+                .catch((error) => {
+                if (active)
+                    app.notifications.notify({
+                        severity: "error",
+                        source: "files",
+                        message: String(error),
+                    });
+            });
+    });
+    return () => {
+        active = false;
+        stopRegistry();
+        stopNavigation();
+        collection.dispose();
+        app.workspace.unregisterView(CONFLICT_REVIEW_VIEW);
+    };
+}

package/dist/index.d.ts

@@ -7,3 +7,9 @@ export { default as CommunityPluginsSettingsPage } from "./plugin-management/Com
 export { PluginsView } from "./plugin-management/plugins-view.svelte";
 export { default as PluginBrowser } from "./plugin-management/PluginBrowser.svelte";
 export { openPluginBrowser } from "./plugin-management/plugin-browser-navigation";
+export { default as DesktopVaultLauncher } from "./desktop/DesktopVaultLauncher.svelte";
+export { default as DesktopWorkspaceStartup } from "./desktop/DesktopWorkspaceStartup.svelte";
+export type { DesktopVaultLauncherHost, DesktopLauncherAppearance, LauncherStatus, } from "./desktop/desktop-vault-launcher";
+export { default as DesktopRecoveryBanner } from "./desktop/DesktopRecoveryBanner.svelte";
+export { bindFileConflictReviews } from "./file-conflicts/register-conflict-reviews";
+export type { FileConflictReviewOptions } from "./file-conflicts/register-conflict-reviews";

package/dist/index.js

@@ -6,3 +6,7 @@ export { default as CommunityPluginsSettingsPage } from "./plugin-management/Com
 export { PluginsView } from "./plugin-management/plugins-view.svelte";
 export { default as PluginBrowser } from "./plugin-management/PluginBrowser.svelte";
 export { openPluginBrowser } from "./plugin-management/plugin-browser-navigation";
+export { default as DesktopVaultLauncher } from "./desktop/DesktopVaultLauncher.svelte";
+export { default as DesktopWorkspaceStartup } from "./desktop/DesktopWorkspaceStartup.svelte";
+export { default as DesktopRecoveryBanner } from "./desktop/DesktopRecoveryBanner.svelte";
+export { bindFileConflictReviews } from "./file-conflicts/register-conflict-reviews";

package/dist/plugin-management/CorePluginsSettingsPage.svelte

@@ -1,6 +1,7 @@
 <script lang="ts">
   import type { WorkspaceSettingsPageProps } from "@lapismd/design-core/workspace/settings";
   import { onMount, tick, untrack } from "svelte";
+  import { getWorkspaceHostBinding } from "@lapis-notes/api/workspace-host";
   import { getPluginManagementContext } from "./plugin-management-context.svelte";
   import "./plugin-management.css";
   import PluginSettingsRow from "./PluginSettingsRow.svelte";
@@ -13,15 +14,34 @@
   let { controller }: WorkspaceSettingsPageProps = $props();
   const context = untrack(() => getPluginManagementContext(controller));
   const app = context.app;
+  const managed = untrack(
+    () => getWorkspaceHostBinding(app.workspace).controller.managedPlugins,
+  );
   let revision = $state(0);
   let expandedPluginIds = $state(new Set<string>());
   let entries = $derived.by(() => {
     revision;
-    const seen = new Set<string>();
-    return app.plugins.corePluginEntries.filter((entry) => {
-      if (seen.has(entry.manifest.id)) return false;
-      seen.add(entry.manifest.id);
-      return true;
+    const staticEntries = app.plugins.corePluginEntries;
+    return managed.states.map((entry) => {
+      const plugin =
+        entry.sourceId === "lapis"
+          ? staticEntries.find((plugin) => plugin.manifest.id === entry.id)
+          : undefined;
+      return {
+        ...entry,
+        manifest: {
+          id: entry.id,
+          name: entry.name,
+          description: entry.description,
+          version: plugin?.manifest.version,
+        },
+        errorMessage:
+          entry.error instanceof Error
+            ? entry.error.message
+            : entry.error == null
+              ? null
+              : String(entry.error),
+      };
     });
   });
 
@@ -34,8 +54,13 @@
     ) {
       return;
     }
-    const pluginId = context.reveal.entryId.slice("core:".length);
-    expandedPluginIds = new Set([...expandedPluginIds, pluginId]);
+    const target = context.reveal.entryId.slice("core:".length);
+    const entry = entries.find(
+      (entry) => entry.key === target || entry.id === target,
+    );
+    if (!entry) return;
+    const pluginId = entry.id;
+    expandedPluginIds = new Set([...expandedPluginIds, entry.key]);
     void tick().then(() => {
       document
         .querySelector(`[data-settings-plugin-id="${CSS.escape(pluginId)}"]`)
@@ -56,7 +81,6 @@
       app.plugins.offref(error);
     };
   });
-
 </script>
 
 <section
@@ -77,7 +101,7 @@
         No core plugins are registered.
       </p>
     {/if}
-    {#each entries as entry (entry.manifest.id)}
+    {#each entries as entry (entry.key)}
       <PluginSettingsRow
         pluginId={entry.manifest.id}
         name={entry.manifest.name}
@@ -92,18 +116,25 @@
         error={entry.errorMessage ?? undefined}
         enabled={entry.enabled}
         required={entry.required}
-        expanded={expandedPluginIds.has(entry.manifest.id)}
+        expanded={expandedPluginIds.has(entry.key)}
         hasOptions={Boolean(
           pluginSettingsSectionId(controller, entry.manifest.id),
         )}
-        diagnostics={pluginDiagnosticRows(app, entry.manifest.id)}
+        diagnostics={entry.sourceId === "lapis"
+          ? pluginDiagnosticRows(app, entry.manifest.id)
+          : [
+              { label: "State", value: entry.status },
+              { label: "Source", value: entry.sourceId },
+            ]}
         onOptions={() => openPluginSettings(controller, entry.manifest.id)}
-        onRestart={async () => {
-          await app.plugins.restartPlugin(entry.manifest.id);
-        }}
+        onRestart={entry.sourceId === "lapis"
+          ? async () => {
+              await app.plugins.restartPlugin(entry.manifest.id);
+            }
+          : undefined}
         onToggle={async (enabled) => {
-          if (enabled) await app.plugins.enablePlugin(entry.manifest.id);
-          else await app.plugins.disablePlugin(entry.manifest.id);
+          if (enabled) await managed.enable(entry.key);
+          else await managed.disable(entry.key);
         }}
       />
     {/each}