Skip to content

The Open Standard for Generative UI

6.8 KB
Raw Blame
import {
  artifactViewId,
  useActiveDetailedView,
  useArtifactCategories,
  useArtifactList,
  useDetailedView,
  useDetailedViewStore,
  type ArtifactEntry,
} from "@openuidev/react-headless";
import clsx from "clsx";
import { useEffect, type ReactNode } from "react";
import { useLayoutContext } from "../../context/LayoutContext";
import {
  formatArtifactUpdatedAt,
  useArtifactIcon,
  useArtifactTypeLabel,
} from "./ArtifactBrowserPage";
import { useAgentInterfaceLabels } from "./_shared/labelsContext";
import { useAgentInterfaceStore } from "./_shared/store";

export interface WorkspaceProps {
  className?: string;
  /** Mode C — replaces the entire rail (you own the chrome and visibility). */
  children?: ReactNode;
}

/**
 * Per-thread workspace rail (right edge of the layout) listing the artifacts
 * registered in the active thread.
 *
 * - Renders nothing while the registry is empty — drop-in users without
 *   artifact renderers never see it. Visibility is controlled by the header
 *   workspace toggle.
 * - Lists every registered artifact, grouped into one section per
 *   `artifactCategories` entry configured on `<AgentInterface>`; a single
 *   "Artifacts" section lists everything when no categories are configured.
 *   There are no tabs or filtering — the rail shows it all.
 * - Item click activates the corresponding DetailedView; the rail closes while
 *   a DetailedView is open.
 * - Rendered only in the thread view — hidden on Route pages and the
 *   artifact browser. Hidden on mobile.
 *
 * Modes: A (omit → default above) and C (children replace the rail).
 *
 * @category Components
 */
export const Workspace = ({ className, children }: WorkspaceProps) => {
  if (children != null) return <>{children}</>;
  return <DefaultWorkspace className={className} />;
};

const DefaultWorkspace = ({ className }: { className?: string }) => {
  const { isWorkspaceOpen, setIsWorkspaceOpen } = useAgentInterfaceStore((state) => ({
    isWorkspaceOpen: state.isWorkspaceOpen,
    setIsWorkspaceOpen: state.setIsWorkspaceOpen,
  }));
  const { isDetailedViewActive } = useActiveDetailedView();
  const { layout } = useLayoutContext();
  const categories = useArtifactCategories();
  const all = useArtifactList();
  const { workspaceToggle } = useAgentInterfaceLabels();
  const entries = latestPerId(all);
  const shouldShowWorkspace = isWorkspaceOpen && !isDetailedViewActive;

  useEffect(() => {
    if (isDetailedViewActive && isWorkspaceOpen) {
      setIsWorkspaceOpen(false);
    }
  }, [isDetailedViewActive, isWorkspaceOpen, setIsWorkspaceOpen]);

  // Nothing renders while the registry is empty; the header controls open state.
  if (entries.length === 0) return null;

  return (
    <>
      {layout === "mobile" && (
        <div
          className={clsx("openui-agent-workspace-sidebar__overlay", {
            "openui-agent-workspace-sidebar__overlay--collapsed": !shouldShowWorkspace,
          })}
          onClick={() => setIsWorkspaceOpen(false)}
        />
      )}
      <div
        className={clsx(
          "openui-agent-workspace-sidebar",
          { "openui-agent-workspace-sidebar--collapsed": !shouldShowWorkspace },
          className,
        )}
      >
        <div className="openui-agent-workspace-sidebar__header">
          <h2 className="openui-agent-workspace-sidebar__title">{workspaceToggle}</h2>
        </div>
        <div className="openui-agent-workspace-sidebar__content">
          {categories.length > 0 ? (
            <WorkspaceSections categories={categories} entries={entries} />
          ) : (
            <WorkspaceSection entries={entries} />
          )}
        </div>
      </div>
    </>
  );
};

const WorkspaceSections = ({
  categories,
  entries,
}: {
  categories: ReturnType<typeof useArtifactCategories>;
  entries: ReadonlyArray<ArtifactEntry>;
}) => {
  // Show every category that has registered entries — no tab filtering.
  const visibleCategories = categories.filter((category) =>
    entries.some((entry) => entryMatchesCategory(entry, category)),
  );
  // Entries matching no configured category are still shown (never dropped),
  // in a fallback section after the categorized ones.
  const uncategorized = entries.filter(
    (entry) => !categories.some((category) => entryMatchesCategory(entry, category)),
  );

  return (
    <>
      {visibleCategories.map((category) => (
        <WorkspaceSection
          key={category.name}
          entries={entries.filter((entry) => entryMatchesCategory(entry, category))}
        />
      ))}
      {uncategorized.length > 0 && (
        <WorkspaceSection key="__uncategorized__" entries={uncategorized} />
      )}
    </>
  );
};

const WorkspaceSection = ({
  entries,
  emptyHint,
}: {
  entries: ReadonlyArray<ArtifactEntry>;
  emptyHint?: string;
}) => {
  if (entries.length === 0) {
    if (!emptyHint) return null;
    return <div className="openui-agent-workspace-sidebar__section-empty">{emptyHint}</div>;
  }

  return (
    <ul className="openui-agent-workspace-sidebar__list">
      {entries.map((entry) => (
        <WorkspaceItem key={entry.id} entry={entry} />
      ))}
    </ul>
  );
};

const WorkspaceItem = ({ entry }: { entry: ArtifactEntry }) => {
  const viewId = artifactViewId(entry.id, entry.version);
  const { isActive } = useDetailedView(viewId);
  const store = useDetailedViewStore();
  const onClick = () => store.getState().setActiveDetailedView(viewId);
  const icon = useArtifactIcon(entry.type);
  const updatedAt = formatArtifactUpdatedAt(entry.updatedAt);
  const metadata = [useArtifactTypeLabel(entry.type), updatedAt].filter(Boolean).join(" · ");

  return (
    <li>
      <button
        type="button"
        onClick={onClick}
        aria-pressed={isActive}
        className={clsx("openui-agent-workspace-sidebar__item", {
          "openui-agent-workspace-sidebar__item--active": isActive,
        })}
      >
        <span className="openui-agent-workspace-sidebar__item-icon">{icon}</span>
        <span className="openui-agent-workspace-sidebar__item-body">
          <span className="openui-agent-workspace-sidebar__item-label">{entry.heading}</span>
          {metadata && (
            <span className="openui-agent-workspace-sidebar__item-meta">{metadata}</span>
          )}
        </span>
      </button>
    </li>
  );
};

/** Picks the latest version (highest version number, kept as the last element after sort). */
function latestPerId<T extends { id: string; version: number }>(
  registry: Record<string, T[]>,
): T[] {
  return Object.values(registry)
    .map((versions) => versions[versions.length - 1])
    .filter((entry): entry is T => entry !== undefined);
}

type ArtifactCategory = ReturnType<typeof useArtifactCategories>[number];

function entryMatchesCategory(entry: ArtifactEntry, category: ArtifactCategory) {
  return category.filter.type.includes(entry.type);
}