@lapismd/design-core 0.1.0

package/src/shared/workspace/problems/diagnostics-manager.svelte.ts

@@ -0,0 +1,326 @@
+import {
+  WorkspaceEventDispatcher,
+  type WorkspaceEventRef,
+} from "../core/event-dispatcher.js";
+import type { WorkspaceMenu } from "../core/workspace-menu.js";
+import type {
+  WorkspaceDiagnostic,
+  WorkspaceDiagnosticCollection,
+  WorkspaceDiagnosticCollectionOptions,
+  WorkspaceDiagnosticCollectionUpdate,
+  WorkspaceDiagnosticEntry,
+  WorkspaceDiagnosticResource,
+  WorkspaceDiagnosticsManagerSnapshot,
+  WorkspaceDiagnosticsSubscriber,
+} from "./types.js";
+
+interface StoredResourceDiagnostics {
+  resource: WorkspaceDiagnosticResource | null;
+  diagnostics: readonly WorkspaceDiagnostic[];
+}
+
+interface WorkspaceDiagnosticsManagerEventMap {
+  change: [snapshot: WorkspaceDiagnosticsManagerSnapshot];
+}
+
+/** Application-independent, ephemeral diagnostic collection registry. */
+export class WorkspaceDiagnosticsManager {
+  entries = $state<WorkspaceDiagnosticEntry[]>([]);
+
+  readonly #collections = new Map<string, ManagedDiagnosticCollection>();
+  readonly #events =
+    new WorkspaceEventDispatcher<WorkspaceDiagnosticsManagerEventMap>();
+
+  get counts() {
+    return countDiagnostics(this.entries);
+  }
+
+  get size(): number {
+    return this.entries.length;
+  }
+
+  createCollection(
+    id: string,
+    options: WorkspaceDiagnosticCollectionOptions = {},
+  ): WorkspaceDiagnosticCollection {
+    const normalizedId = id.trim();
+    if (!normalizedId) {
+      throw new Error("Diagnostic collections require a non-empty id");
+    }
+    if (this.#collections.has(normalizedId)) {
+      throw new Error(`Duplicate diagnostic collection id "${normalizedId}"`);
+    }
+    const collection = new ManagedDiagnosticCollection(
+      normalizedId,
+      options,
+      () => this.#publish(),
+      () => {
+        this.#collections.delete(normalizedId);
+        this.#publish();
+      },
+    );
+    this.#collections.set(normalizedId, collection);
+    this.#publish();
+    return collection;
+  }
+
+  getCollection(id: string): WorkspaceDiagnosticCollection | undefined {
+    return this.#collections.get(id);
+  }
+
+  buildItemMenu(menu: WorkspaceMenu, entry: WorkspaceDiagnosticEntry): void {
+    this.#collections.get(entry.collectionId)?.buildItemMenu(menu, entry);
+  }
+
+  subscribe(subscriber: WorkspaceDiagnosticsSubscriber): () => void {
+    const ref = this.#events.on("change", subscriber);
+    subscriber(this.snapshot());
+    return () => this.#events.offref(ref);
+  }
+
+  onChange(
+    subscriber: WorkspaceDiagnosticsSubscriber,
+  ): WorkspaceEventRef<WorkspaceDiagnosticsManagerEventMap, "change"> {
+    return this.#events.on("change", subscriber);
+  }
+
+  offref(
+    ref: WorkspaceEventRef<WorkspaceDiagnosticsManagerEventMap, "change">,
+  ): void {
+    this.#events.offref(ref);
+  }
+
+  snapshot(): WorkspaceDiagnosticsManagerSnapshot {
+    const entries = Object.freeze(this.entries.map(cloneEntry));
+    return Object.freeze({
+      entries,
+      counts: Object.freeze(countDiagnostics(entries)),
+    });
+  }
+
+  dispose(): void {
+    for (const collection of [...this.#collections.values()]) {
+      collection.dispose();
+    }
+    this.entries = [];
+    this.#events.clear();
+  }
+
+  #publish(): void {
+    const entries: WorkspaceDiagnosticEntry[] = [];
+    for (const collection of this.#collections.values()) {
+      collection.appendEntries(entries);
+    }
+    this.entries = entries;
+    this.#events.trigger("change", this.snapshot());
+  }
+}
+
+class ManagedDiagnosticCollection implements WorkspaceDiagnosticCollection {
+  readonly label: string;
+  disposed = false;
+
+  readonly #entries = new Map<string, StoredResourceDiagnostics>();
+  readonly #buildItemMenu?: WorkspaceDiagnosticCollectionOptions["buildItemMenu"];
+
+  constructor(
+    readonly id: string,
+    options: WorkspaceDiagnosticCollectionOptions,
+    readonly onChange: () => void,
+    readonly onDispose: () => void,
+  ) {
+    this.label = options.label?.trim() || id;
+    this.#buildItemMenu = options.buildItemMenu;
+  }
+
+  set(
+    resourceOrEntries:
+      | WorkspaceDiagnosticResource
+      | null
+      | Iterable<WorkspaceDiagnosticCollectionUpdate>,
+    diagnostics?: readonly WorkspaceDiagnostic[],
+  ): void {
+    this.#assertActive();
+    if (isCollectionUpdateIterable(resourceOrEntries)) {
+      for (const [resource, nextDiagnostics] of resourceOrEntries) {
+        this.#setOne(resource, nextDiagnostics);
+      }
+      this.onChange();
+      return;
+    }
+    this.#setOne(resourceOrEntries, diagnostics);
+    this.onChange();
+  }
+
+  get(
+    resource: WorkspaceDiagnosticResource | null,
+  ): readonly WorkspaceDiagnostic[] | undefined {
+    this.#assertActive();
+    return this.#entries.get(resourceKey(resource))?.diagnostics;
+  }
+
+  has(resource: WorkspaceDiagnosticResource | null): boolean {
+    this.#assertActive();
+    return this.#entries.has(resourceKey(resource));
+  }
+
+  delete(resource: WorkspaceDiagnosticResource | null): boolean {
+    this.#assertActive();
+    const deleted = this.#entries.delete(resourceKey(resource));
+    if (deleted) this.onChange();
+    return deleted;
+  }
+
+  clear(): void {
+    this.#assertActive();
+    if (this.#entries.size === 0) return;
+    this.#entries.clear();
+    this.onChange();
+  }
+
+  forEach(
+    callback: (
+      resource: WorkspaceDiagnosticResource | null,
+      diagnostics: readonly WorkspaceDiagnostic[],
+      collection: WorkspaceDiagnosticCollection,
+    ) => void,
+  ): void {
+    this.#assertActive();
+    for (const value of this.#entries.values()) {
+      callback(cloneResource(value.resource), value.diagnostics, this);
+    }
+  }
+
+  *[Symbol.iterator](): Iterator<
+    readonly [
+      WorkspaceDiagnosticResource | null,
+      readonly WorkspaceDiagnostic[],
+    ]
+  > {
+    this.#assertActive();
+    for (const value of this.#entries.values()) {
+      yield [cloneResource(value.resource), value.diagnostics] as const;
+    }
+  }
+
+  dispose(): void {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.#entries.clear();
+    this.onDispose();
+  }
+
+  buildItemMenu(menu: WorkspaceMenu, entry: WorkspaceDiagnosticEntry): void {
+    if (!this.disposed) this.#buildItemMenu?.(menu, cloneEntry(entry));
+  }
+
+  appendEntries(target: WorkspaceDiagnosticEntry[]): void {
+    if (this.disposed) return;
+    for (const [key, value] of this.#entries) {
+      value.diagnostics.forEach((diagnostic, index) => {
+        target.push(
+          Object.freeze({
+            key: `${this.id}:${key}:${index}`,
+            collectionId: this.id,
+            collectionLabel: this.label,
+            resource: cloneResource(value.resource),
+            diagnostic,
+          }),
+        );
+      });
+    }
+  }
+
+  #setOne(
+    resource: WorkspaceDiagnosticResource | null,
+    diagnostics: readonly WorkspaceDiagnostic[] | undefined,
+  ): void {
+    const key = resourceKey(resource);
+    if (!diagnostics) {
+      this.#entries.delete(key);
+      return;
+    }
+    const cloned = Object.freeze(diagnostics.map(cloneDiagnostic));
+    this.#entries.set(key, {
+      resource: cloneResource(resource),
+      diagnostics: cloned,
+    });
+  }
+
+  #assertActive(): void {
+    if (this.disposed) {
+      throw new Error(`Diagnostic collection "${this.id}" is disposed`);
+    }
+  }
+}
+
+function isCollectionUpdateIterable(
+  value:
+    | WorkspaceDiagnosticResource
+    | null
+    | Iterable<WorkspaceDiagnosticCollectionUpdate>,
+): value is Iterable<WorkspaceDiagnosticCollectionUpdate> {
+  return Boolean(
+    value &&
+      typeof value === "object" &&
+      !("uri" in value) &&
+      Symbol.iterator in value,
+  );
+}
+
+function resourceKey(resource: WorkspaceDiagnosticResource | null): string {
+  return resource ? resource.uri : "\u0000workspace";
+}
+
+function cloneResource(
+  resource: WorkspaceDiagnosticResource | null,
+): WorkspaceDiagnosticResource | null {
+  return resource ? Object.freeze({ ...resource }) : null;
+}
+
+function cloneDiagnostic(diagnostic: WorkspaceDiagnostic): WorkspaceDiagnostic {
+  return Object.freeze({
+    ...diagnostic,
+    range: diagnostic.range
+      ? Object.freeze({
+          start: Object.freeze({ ...diagnostic.range.start }),
+          end: Object.freeze({ ...diagnostic.range.end }),
+        })
+      : undefined,
+    code:
+      diagnostic.code && typeof diagnostic.code === "object"
+        ? Object.freeze({ ...diagnostic.code })
+        : diagnostic.code,
+    tags: diagnostic.tags ? Object.freeze([...diagnostic.tags]) : undefined,
+    relatedInformation: diagnostic.relatedInformation
+      ? Object.freeze(
+          diagnostic.relatedInformation.map((related) =>
+            Object.freeze({
+              ...related,
+              resource: Object.freeze({ ...related.resource }),
+              range: related.range
+                ? Object.freeze({
+                    start: Object.freeze({ ...related.range.start }),
+                    end: Object.freeze({ ...related.range.end }),
+                  })
+                : undefined,
+            }),
+          ),
+        )
+      : undefined,
+  });
+}
+
+function cloneEntry(entry: WorkspaceDiagnosticEntry): WorkspaceDiagnosticEntry {
+  return Object.freeze({
+    ...entry,
+    resource: cloneResource(entry.resource),
+    diagnostic: cloneDiagnostic(entry.diagnostic),
+  });
+}
+
+function countDiagnostics(entries: readonly WorkspaceDiagnosticEntry[]) {
+  const counts = { error: 0, warning: 0, information: 0, hint: 0 };
+  for (const entry of entries) counts[entry.diagnostic.severity] += 1;
+  return counts;
+}

package/src/shared/workspace/problems/index.ts

@@ -0,0 +1,43 @@
+export { default as WorkspaceProblems } from "./WorkspaceProblems.svelte";
+export { WorkspaceDiagnosticsManager } from "./diagnostics-manager.svelte.js";
+export {
+  WorkspaceProblemsController,
+  diagnosticCodeValue,
+  diagnosticLocationLabel,
+  formatProblem,
+  formatProblems,
+  serializeProblem,
+  type WorkspaceProblemsGroup,
+} from "./problems-controller.svelte.js";
+export {
+  ProblemsPlugin,
+  PROBLEMS_PLUGIN_ID,
+  PROBLEMS_STATUS_ITEM_ID,
+  PROBLEMS_VIEW_TYPE,
+  SHOW_PROBLEMS_COMMAND_ID,
+  problemsPlugin,
+  type ProblemsPluginOptions,
+} from "./problems-plugin.js";
+export type {
+  WorkspaceDiagnostic,
+  WorkspaceDiagnosticBuildItemMenu,
+  WorkspaceDiagnosticCode,
+  WorkspaceDiagnosticCodeTarget,
+  WorkspaceDiagnosticCollection,
+  WorkspaceDiagnosticCollectionOptions,
+  WorkspaceDiagnosticCollectionUpdate,
+  WorkspaceDiagnosticEntry,
+  WorkspaceDiagnosticLocation,
+  WorkspaceDiagnosticPosition,
+  WorkspaceDiagnosticRange,
+  WorkspaceDiagnosticRelatedInformation,
+  WorkspaceDiagnosticResource,
+  WorkspaceDiagnosticSeverity,
+  WorkspaceDiagnosticTag,
+  WorkspaceDiagnosticsManagerSnapshot,
+  WorkspaceDiagnosticsSubscriber,
+  WorkspaceProblemsCopyAdapter,
+  WorkspaceProblemsControllerOptions,
+  WorkspaceProblemsNavigationAdapter,
+  WorkspaceProblemsViewMode,
+} from "./types.js";

package/src/shared/workspace/problems/problems-controller.svelte.ts

@@ -0,0 +1,346 @@
+import { SvelteSet } from "svelte/reactivity";
+import { WorkspaceMenu } from "../core/workspace-menu.js";
+import type { WorkspaceDiagnosticsManager } from "./diagnostics-manager.svelte.js";
+import type {
+  WorkspaceDiagnostic,
+  WorkspaceDiagnosticEntry,
+  WorkspaceDiagnosticLocation,
+  WorkspaceDiagnosticRelatedInformation,
+  WorkspaceDiagnosticResource,
+  WorkspaceDiagnosticSeverity,
+  WorkspaceProblemsControllerOptions,
+  WorkspaceProblemsViewMode,
+} from "./types.js";
+
+export interface WorkspaceProblemsGroup {
+  key: string;
+  label: string;
+  detail?: string;
+  icon?: string;
+  resource: WorkspaceDiagnosticResource | null;
+  entries: WorkspaceDiagnosticEntry[];
+}
+
+const severityOrder: Record<WorkspaceDiagnosticSeverity, number> = {
+  error: 0,
+  warning: 1,
+  information: 2,
+  hint: 3,
+};
+
+export class WorkspaceProblemsController {
+  query = $state("");
+  viewMode = $state<WorkspaceProblemsViewMode>("tree");
+  enabledSeverities = new SvelteSet<WorkspaceDiagnosticSeverity>([
+    "error",
+    "warning",
+    "information",
+    "hint",
+  ]);
+  collapsedGroups = new SvelteSet<string>();
+
+  readonly #navigation?: WorkspaceProblemsControllerOptions["navigation"];
+  readonly #clipboard?: WorkspaceProblemsControllerOptions["clipboard"];
+
+  constructor(
+    readonly diagnostics: WorkspaceDiagnosticsManager,
+    options: WorkspaceProblemsControllerOptions = {},
+  ) {
+    this.#navigation = options.navigation;
+    this.#clipboard = options.clipboard;
+    this.viewMode = options.defaultViewMode ?? "tree";
+  }
+
+  get counts() {
+    return this.diagnostics.counts;
+  }
+
+  get totalCount(): number {
+    return this.groups.reduce(
+      (total, group) => total + group.entries.length,
+      0,
+    );
+  }
+
+  get visibleEntries(): WorkspaceDiagnosticEntry[] {
+    return this.groups.flatMap((group) => group.entries);
+  }
+
+  get groups(): WorkspaceProblemsGroup[] {
+    const query = this.query.trim().toLocaleLowerCase();
+    const grouped = new Map<string, WorkspaceProblemsGroup>();
+    for (const entry of this.diagnostics.entries) {
+      if (!this.enabledSeverities.has(entry.diagnostic.severity)) continue;
+      if (query && !matchesQuery(entry, query)) continue;
+      const key = entry.resource?.uri ?? "workspace";
+      let group = grouped.get(key);
+      if (!group) {
+        group = {
+          key,
+          label: entry.resource?.label || entry.resource?.uri || "Workspace",
+          detail: entry.resource?.detail,
+          icon: entry.resource?.icon,
+          resource: entry.resource,
+          entries: [],
+        };
+        grouped.set(key, group);
+      }
+      group.entries.push(entry);
+    }
+    for (const group of grouped.values()) {
+      group.entries.sort(compareEntries);
+    }
+    return [...grouped.values()].sort((left, right) => {
+      if (left.resource === null) return right.resource === null ? 0 : -1;
+      if (right.resource === null) return 1;
+      return left.label.localeCompare(right.label, undefined, {
+        numeric: true,
+        sensitivity: "base",
+      });
+    });
+  }
+
+  setQuery(value: string): void {
+    this.query = value;
+  }
+
+  setViewMode(mode: WorkspaceProblemsViewMode): void {
+    this.viewMode = mode;
+  }
+
+  toggleViewMode(): void {
+    this.viewMode = this.viewMode === "tree" ? "table" : "tree";
+  }
+
+  toggleSeverity(severity: WorkspaceDiagnosticSeverity): void {
+    if (this.enabledSeverities.has(severity)) {
+      this.enabledSeverities.delete(severity);
+    } else {
+      this.enabledSeverities.add(severity);
+    }
+  }
+
+  isSeverityEnabled(severity: WorkspaceDiagnosticSeverity): boolean {
+    return this.enabledSeverities.has(severity);
+  }
+
+  toggleGroup(key: string): void {
+    if (this.collapsedGroups.has(key)) this.collapsedGroups.delete(key);
+    else this.collapsedGroups.add(key);
+  }
+
+  isGroupCollapsed(key: string): boolean {
+    return this.collapsedGroups.has(key);
+  }
+
+  collapseAll(): void {
+    const groups = this.groups;
+    const allCollapsed =
+      groups.length > 0 &&
+      groups.every((group) => this.isGroupCollapsed(group.key));
+    if (allCollapsed) {
+      this.collapsedGroups.clear();
+      return;
+    }
+    for (const group of groups) this.collapsedGroups.add(group.key);
+  }
+
+  canNavigate(entry: WorkspaceDiagnosticEntry): boolean {
+    return Boolean(entry.resource && this.#navigation);
+  }
+
+  async open(entry: WorkspaceDiagnosticEntry): Promise<boolean> {
+    if (!entry.resource || !this.#navigation) return false;
+    await this.#navigation.open({
+      resource: entry.resource,
+      range: entry.diagnostic.range,
+      diagnostic: entry.diagnostic,
+    });
+    return true;
+  }
+
+  async openRelated(
+    entry: WorkspaceDiagnosticEntry,
+    related: WorkspaceDiagnosticRelatedInformation,
+  ): Promise<boolean> {
+    if (!this.#navigation) return false;
+    await this.#navigation.open({
+      resource: related.resource,
+      range: related.range,
+      diagnostic: entry.diagnostic,
+      related,
+    });
+    return true;
+  }
+
+  createGroupMenu(group: WorkspaceProblemsGroup): WorkspaceMenu {
+    const menu = new WorkspaceMenu();
+    menu.addItem((item) =>
+      item
+        .setTitle("Copy Message")
+        .setIcon("copy")
+        .onClick(() =>
+          this.copy(
+            "Problem message",
+            group.entries.map((entry) => entry.diagnostic.message).join("\n"),
+          ),
+        ),
+    );
+    menu.addItem((item) =>
+      item
+        .setTitle("Copy Problem")
+        .setIcon("copy")
+        .onClick(() => this.copy("Problem", formatProblems(group.entries))),
+    );
+    return menu;
+  }
+
+  createItemMenu(entry: WorkspaceDiagnosticEntry): WorkspaceMenu {
+    const menu = new WorkspaceMenu();
+    menu.addItem((item) =>
+      item
+        .setTitle("Copy Message")
+        .setIcon("copy")
+        .onClick(() => this.copy("Problem message", entry.diagnostic.message)),
+    );
+    menu.addItem((item) =>
+      item
+        .setTitle("Copy Problem")
+        .setIcon("copy")
+        .onClick(() => this.copy("Problem", formatProblem(entry))),
+    );
+    const before = menu.entries.length;
+    this.diagnostics.buildItemMenu(menu, entry);
+    if (
+      menu.entries.length > before &&
+      menu.entries[before]?.kind !== "separator"
+    ) {
+      menu.entries.splice(before, 0, { kind: "separator" });
+    }
+    return menu;
+  }
+
+  createQuickFixMenu(entry: WorkspaceDiagnosticEntry): WorkspaceMenu | null {
+    const menu = new WorkspaceMenu();
+    this.diagnostics.buildItemMenu(menu, entry);
+    return menu.entries.length > 0 ? menu : null;
+  }
+
+  async copy(label: string, value: string): Promise<void> {
+    if (this.#clipboard) {
+      await this.#clipboard.writeText(label, value);
+      return;
+    }
+    if (typeof navigator !== "undefined" && navigator.clipboard?.writeText) {
+      await navigator.clipboard.writeText(value);
+    }
+  }
+}
+
+function compareEntries(
+  left: WorkspaceDiagnosticEntry,
+  right: WorkspaceDiagnosticEntry,
+): number {
+  const severity =
+    severityOrder[left.diagnostic.severity] -
+    severityOrder[right.diagnostic.severity];
+  if (severity !== 0) return severity;
+  const leftPosition = left.diagnostic.range?.start;
+  const rightPosition = right.diagnostic.range?.start;
+  if (leftPosition && !rightPosition) return -1;
+  if (!leftPosition && rightPosition) return 1;
+  if (leftPosition && rightPosition) {
+    const line = leftPosition.line - rightPosition.line;
+    if (line !== 0) return line;
+    const character = leftPosition.character - rightPosition.character;
+    if (character !== 0) return character;
+  }
+  return left.diagnostic.message.localeCompare(right.diagnostic.message);
+}
+
+function matchesQuery(entry: WorkspaceDiagnosticEntry, query: string): boolean {
+  const code = diagnosticCodeValue(entry.diagnostic);
+  return [
+    entry.diagnostic.message,
+    entry.diagnostic.source,
+    code,
+    entry.resource?.label,
+    entry.resource?.detail,
+    entry.resource?.uri,
+  ].some((value) => value?.toLocaleLowerCase().includes(query));
+}
+
+export function diagnosticCodeValue(
+  diagnostic: WorkspaceDiagnostic,
+): string | undefined {
+  if (diagnostic.code === undefined) return undefined;
+  return typeof diagnostic.code === "object"
+    ? String(diagnostic.code.value)
+    : String(diagnostic.code);
+}
+
+const problemSeverityNumber: Record<WorkspaceDiagnosticSeverity, number> = {
+  hint: 1,
+  information: 2,
+  warning: 4,
+  error: 8,
+};
+
+export function formatProblem(entry: WorkspaceDiagnosticEntry): string {
+  return formatProblems([entry]);
+}
+
+export function formatProblems(
+  entries: readonly WorkspaceDiagnosticEntry[],
+): string {
+  return JSON.stringify(entries.map(serializeProblem), null, "\t");
+}
+
+export function serializeProblem(
+  entry: WorkspaceDiagnosticEntry,
+): Record<string, unknown> {
+  const range = entry.diagnostic.range;
+  const problem: Record<string, unknown> = {
+    resource: serializedProblemResource(entry.resource),
+    owner: entry.collectionId,
+    severity: problemSeverityNumber[entry.diagnostic.severity],
+    message: entry.diagnostic.message,
+    source: entry.diagnostic.source || entry.collectionLabel,
+  };
+  const code = serializeProblemCode(entry.diagnostic.code);
+  if (code !== undefined) problem.code = code;
+  if (range) {
+    problem.startLineNumber = range.start.line + 1;
+    problem.startColumn = range.start.character + 1;
+    problem.endLineNumber = range.end.line + 1;
+    problem.endColumn = range.end.character + 1;
+  }
+  return problem;
+}
+
+function serializedProblemResource(
+  resource: WorkspaceDiagnosticResource | null,
+): string {
+  if (!resource) return "Workspace";
+  return resource.detail?.trim() || resource.uri;
+}
+
+function serializeProblemCode(
+  code: WorkspaceDiagnostic["code"],
+): { value: string | number; target?: string } | undefined {
+  if (code === undefined) return undefined;
+  if (typeof code === "object") {
+    return code.target
+      ? { value: code.value, target: code.target }
+      : { value: code.value };
+  }
+  return { value: code };
+}
+
+export function diagnosticLocationLabel(
+  location: WorkspaceDiagnosticLocation,
+): string {
+  const label = location.resource.label || location.resource.uri;
+  const start = location.range?.start;
+  return start ? `${label}:${start.line + 1}:${start.character + 1}` : label;
+}