@rightkit/workspace-ui 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.2.0 (unpublished)
+
+Taken on the recommended option of the shape review, pending the owner's confirmation.
+
+- BREAKING: the views render over a host the app supplies (`WorkspaceHostProvider`, `WorkspaceHost`) and import
+  nothing from `@rightkit/mail-ui`: no store, hooks, IPC, icons or account switcher of the mail app. Calls go
+  through the typed `WorkspaceClient`; shared state through the host's `useState` selector over the
+  `WorkspaceState` slices; errors, notices, dialogs, preferences, compose, downloads and view switches through
+  host actions; the account switcher is an optional host component.
+- Moved here from `@rightkit/mail-ui` (deleted there): the Drive, calendar, contacts and tasks navs, `useDrive`,
+  the calendar helpers (`calendarUtils`, `WEEKDAYS`), the avatar helpers (`colorFor`, `initialOf`) and the
+  workspace data model (`CalEvent`, `DriveFile`, `ContactFull`, `EventForm`, ...). mail-ui imports them from here.
+- Glyphs from `lucide-react` (`Icon`), not the mail app's icon set.
+- Emailing a contact opens a new message through `composeTo` without switching the host to its inbox first.
+- Dependencies: `@rightkit/mail-ui` removed; `lucide-react` added. New subpath exports `./client`, `./host`,
+  `./lib/avatar`, `./lib/calendarUtils`.
+
 ## 0.1.0
 
 - First release. Calendar, contacts, drive, tasks and meeting views for workspace-style apps.

package/README.md

@@ -1,36 +1,46 @@
 # @rightkit/workspace-ui
 
-Calendar, contacts, drive, tasks and meeting views for workspace-style apps.
+Calendar, contacts, drive, tasks and meeting views, and their navs, for workspace-style apps. The views hold no
+IPC, no store and no product name: they render over a typed client and state the host supplies.
 
 | Item | Value |
 |---|---|
 | Where it runs | App webview UI (React) |
-| Version | 0.1.0 |
+| Version | 0.2.0 |
 | License | MIT OR Apache-2.0 |
 
 ## Entry points
 
 | Import | Contents |
 |---|---|
-| `@rightkit/workspace-ui` | Every module whose exported names do not collide (generated barrel). |
-| `@rightkit/workspace-ui/<path>` | Any module under `src/` by path without extension, e.g. `@rightkit/workspace-ui/lib/vcard`. |
-| `@rightkit/workspace-ui/<path>.css` | Stylesheets shipped next to their components. |
+| `@rightkit/workspace-ui` | Views (`CalendarView`, `ContactsView`, `DriveView`, `TasksView`, `MeetView`, the calendar and Drive dialogs), navs (`CalendarNav`, `ContactsNav`, `DriveNav`, `TasksNav`), `useDrive`, the host contract, the data model, `Icon`, vCard and avatar helpers, calendar helpers. |
+| `@rightkit/workspace-ui/client` | The data model (`CalEvent`, `DriveFile`, `ContactFull`, ...) and `WorkspaceClient`. |
+| `@rightkit/workspace-ui/host` | `WorkspaceHost`, `WorkspaceHostProvider`, `useWorkspaceHost`, `useWorkspaceState`, `WorkspaceState`. |
+| `@rightkit/workspace-ui/lib/avatar` | `colorFor`, `initialOf` (coloured-initial avatars). |
+| `@rightkit/workspace-ui/lib/calendarUtils` | Day and week arithmetic, `rangeFor`, `eventDay`, `WEEKDAYS`. |
 
-## Depends on
-
-`@rightkit/mail-ui`
+## Host contract
 
-## Peer dependencies
+Render the views and navs inside one `<WorkspaceHostProvider host={host}>`. `host` is a `WorkspaceHost`:
 
-`react`
+| Field | What the host supplies |
+|---|---|
+| `client` | `WorkspaceClient`: every calendar, tasks, Drive, contacts and Meet call, plus `openExternal` and `saveTextDownload`, over the host's own transport. |
+| `useState` | A selector hook over the host's state holding the `WorkspaceState` slices (`calendars`, `events`, `drivePath`, `taskLists`, ... with `set*` setters, and `activeAccount`). A zustand store with those fields satisfies it directly, so the host's other UI can share them. |
+| `reportError`, `notify`, `dialog` | The host's error banner, toast, and confirm/prompt dialog. |
+| `savePreference` | Persists `shownCals`, `calView`, `driveViewMode`. |
+| `composeTo`, `linkIntoCompose` | Open a new message; put a Drive link into the open message (or a new one). |
+| `saveDownload` | Saves (and may scan) a Drive download. |
+| `openView` | Switches to another workspace view (Meet's "schedule" opens the calendar). |
+| `AccountSwitcher` | Optional; shown in each view's header. |
 
-## Host contract
+MailRight's host is `mailWorkspaceHost` in `@rightkit/mail-ui`.
 
-Hosts bundle this package with Vite (the build keeps extensionless relative imports and asset imports
-such as `?raw`). Tailwind hosts add `node_modules/@rightkit/workspace-ui/dist/**/*.js` to their content globs.
+Glyphs come from Lucide (`lucide-react`); the package imports no app's icon set. Hosts bundle the package with
+Vite; Tailwind hosts add `node_modules/@rightkit/workspace-ui/dist/**/*.js` to their content globs.
 
 ## Testing
 
 ```sh
-pnpm --dir packages/workspace-ui test
+pnpm --dir packages/workspace-ui typecheck
 ```

package/dist/client.d.ts

@@ -0,0 +1,190 @@
+export interface CalendarInfo {
+    id: string;
+    summary: string;
+    background_color: string;
+    primary: boolean;
+    access_role: string;
+}
+export interface Attendee {
+    email: string;
+    response_status: string;
+}
+export interface CalEvent {
+    id: string;
+    calendar_id: string;
+    summary: string;
+    description: string;
+    location: string;
+    start: string;
+    end: string;
+    all_day: boolean;
+    html_link: string;
+    meet_link: string;
+    organizer: string;
+    attendees: Attendee[];
+    my_response: string;
+    is_recurring: boolean;
+    recurring_event_id: string;
+}
+export interface EventInput {
+    summary: string;
+    description?: string;
+    location?: string;
+    startRfc3339: string;
+    endRfc3339: string;
+    allDay?: boolean;
+    timeZone: string;
+    attendees?: string[];
+    reminderMinutes?: number | null;
+    addMeet?: boolean;
+    recurrence?: string | null;
+}
+export interface TaskListInfo {
+    id: string;
+    title: string;
+}
+export interface TaskItem {
+    id: string;
+    title: string;
+    notes: string;
+    due: string;
+    status: string;
+    list_id: string;
+    list_title: string;
+}
+export interface DriveFile {
+    id: string;
+    name: string;
+    mime_type: string;
+    modified_time: string;
+    web_view_link: string;
+    size: string;
+    icon_link: string;
+    thumbnail_link: string;
+    is_folder: boolean;
+    parents: string[];
+}
+export interface DriveListing {
+    files: DriveFile[];
+    next_page_token: string;
+}
+export interface MeetSpace {
+    name: string;
+    meeting_uri: string;
+    meeting_code: string;
+}
+export interface BusySlot {
+    start: string;
+    end: string;
+}
+export interface FreeBusyResult {
+    calendar_id: string;
+    busy: BusySlot[];
+}
+export interface StorageQuota {
+    limit: string;
+    usage: string;
+    usage_in_drive: string;
+}
+export interface DrivePermission {
+    id: string;
+    role: string;
+    kind: string;
+    email: string;
+    display_name: string;
+}
+export interface Recipient {
+    name: string;
+    email: string;
+    photo_url: string;
+}
+export interface ContactFull {
+    resource_name: string;
+    etag: string;
+    display_name: string;
+    given_name: string;
+    family_name: string;
+    emails: string[];
+    phones: string[];
+    org: string;
+    photo_url: string;
+}
+export interface ContactGroup {
+    resource_name: string;
+    name: string;
+    member_count: number;
+}
+/** The event editor's form state (the calendar view's create/edit dialog). */
+export type EventForm = {
+    id?: string;
+    summary: string;
+    start: string;
+    end: string;
+    allDay: boolean;
+    attendees: string;
+    reminderMinutes: string;
+    addMeet: boolean;
+    recurrence: string;
+    recurEnd: "never" | "until" | "count";
+    recurUntil: string;
+    recurCount: string;
+    recurByday: string[];
+};
+/** The new-task form. */
+export type TaskCreate = {
+    title: string;
+    notes: string;
+};
+/** Duplicate contacts found by the dedupe tool: each primary with the entries that repeat it. */
+export type ContactDupes = {
+    primary: ContactFull;
+    dups: ContactFull[];
+}[];
+/** The Drive shelves the nav offers. */
+export type DriveShelf = "my" | "recent" | "shared" | "starred" | "trash";
+/**
+ * Every call the workspace views make. The host implements it over its own transport (MailRight: Tauri commands
+ * in `@rightkit/mail-ui/lib/ipc`); the views never name a command. `accountId` is the host's account key.
+ */
+export interface WorkspaceClient {
+    listCalendars(accountId: string): Promise<CalendarInfo[]>;
+    listEvents(accountId: string, calendarId: string, timeMin: string, timeMax: string): Promise<CalEvent[]>;
+    createEvent(accountId: string, calendarId: string, ev: EventInput): Promise<CalEvent>;
+    updateEvent(accountId: string, calendarId: string, eventId: string, ev: EventInput): Promise<void>;
+    deleteEvent(accountId: string, calendarId: string, eventId: string): Promise<void>;
+    truncateEventSeries(accountId: string, calendarId: string, recurringEventId: string, occurrenceStart: string): Promise<void>;
+    rsvpEvent(accountId: string, calendarId: string, eventId: string, selfEmail: string, response: string): Promise<void>;
+    freeBusy(accountId: string, calendarIds: string[], timeMin: string, timeMax: string): Promise<FreeBusyResult[]>;
+    listTasks(accountId: string, showCompleted?: boolean): Promise<TaskItem[]>;
+    listTaskLists(accountId: string): Promise<TaskListInfo[]>;
+    createTaskList(accountId: string, title: string): Promise<TaskListInfo>;
+    renameTaskList(accountId: string, listId: string, title: string): Promise<void>;
+    deleteTaskList(accountId: string, listId: string): Promise<void>;
+    clearCompletedTasks(accountId: string, listId: string): Promise<void>;
+    createTaskIn(accountId: string, listId: string, title: string, notes: string, due: string): Promise<void>;
+    setTaskStatus(accountId: string, listId: string, taskId: string, completed: boolean): Promise<void>;
+    deleteTask(accountId: string, listId: string, taskId: string): Promise<void>;
+    listDriveFiles(accountId: string, folderId?: string, query?: string, pageToken?: string, shelf?: string, mimeFilter?: string): Promise<DriveListing>;
+    driveStorageQuota(accountId: string): Promise<StorageQuota>;
+    driveUpload(accountId: string, filename: string, mimeType: string, data: number[], parentId?: string): Promise<DriveFile>;
+    /** Downloads to the host's download folder and resolves to the saved path. */
+    driveDownload(accountId: string, fileId: string, mimeType: string, filename: string): Promise<string>;
+    driveCreateFolder(accountId: string, name: string, parentId?: string): Promise<DriveFile>;
+    driveRename(accountId: string, fileId: string, newName: string): Promise<DriveFile>;
+    driveMove(accountId: string, fileId: string, newParent: string, oldParent?: string): Promise<DriveFile>;
+    driveTrash(accountId: string, fileId: string): Promise<void>;
+    driveShare(accountId: string, fileId: string, email: string, role: string): Promise<string>;
+    driveListPermissions(accountId: string, fileId: string): Promise<DrivePermission[]>;
+    driveRevokePermission(accountId: string, fileId: string, permissionId: string): Promise<void>;
+    searchRecipients(accountId: string, query: string): Promise<Recipient[]>;
+    listAllContacts(accountId: string): Promise<ContactFull[]>;
+    createContact(accountId: string, name: string, emails: string[], phones: string[]): Promise<void>;
+    updateContact(accountId: string, resourceName: string, etag: string, name: string, emails: string[], phones: string[]): Promise<void>;
+    deleteContact(accountId: string, resourceName: string): Promise<void>;
+    listContactGroups(accountId: string): Promise<ContactGroup[]>;
+    createMeet(accountId: string): Promise<MeetSpace>;
+    /** Opens a URL in the user's browser. */
+    openExternal(url: string): Promise<void>;
+    /** Saves text as a download and resolves to the saved path. */
+    saveTextDownload(filename: string, text: string): Promise<string>;
+}

package/dist/client.js

@@ -0,0 +1,2 @@
+// The workspace data model and the typed client the host supplies. No transport lives here.
+export {};

package/dist/hooks/useDrive.d.ts

@@ -0,0 +1,26 @@
+import type { DriveFile, DriveShelf } from "../client.js";
+export declare const FOLDER_MIME = "application/vnd.google-apps.folder";
+export declare function useDrive(): {
+    activeAccount: string | null;
+    driveShelf: DriveShelf;
+    drivePath: {
+        id: string;
+        name: string;
+    }[];
+    driveQuery: string;
+    driveType: string;
+    setDriveQuery: import("../host.js").FieldSetter<string>;
+    currentFolderId: () => string | undefined;
+    reload: (folderId: string | undefined, query: string, shelf?: DriveShelf, typeFilter?: string) => Promise<void>;
+    selectShelf: (shelf: DriveShelf) => void;
+    setTypeFilter: (t: string) => void;
+    openFolder: (f: DriveFile) => void;
+    breadcrumbTo: (idx: number) => void;
+    refresh: () => void;
+    download: (f: DriveFile) => void;
+    upload: (files: FileList | File[]) => Promise<void>;
+    newFolder: () => Promise<void>;
+    rename: (f: DriveFile) => Promise<void>;
+    trash: (f: DriveFile) => Promise<void>;
+    insertDriveLink: (f: DriveFile) => void;
+};

package/dist/hooks/useDrive.js

@@ -0,0 +1,158 @@
+import { useWorkspaceClient, useWorkspaceHost, useWorkspaceState } from "../host.js";
+// Shared Drive logic for DriveNav (the contextual sidebar) and DriveView (the
+// file grid). Reads/writes Drive state through the host state so both surfaces stay
+// in sync (shelf selection in the nav re-lists the grid, etc.). Transient modal
+// state (move/share pickers) stays local to DriveView since only it renders them.
+export const FOLDER_MIME = "application/vnd.google-apps.folder";
+export function useDrive() {
+    const { listDriveFiles, driveDownload, driveUpload, driveCreateFolder, driveRename, driveTrash } = useWorkspaceClient();
+    const showDialog = useWorkspaceHost().dialog;
+    const saveAndScan = useWorkspaceHost().saveDownload;
+    const linkIntoCompose = useWorkspaceHost().linkIntoCompose;
+    const activeAccount = useWorkspaceState((s) => s.activeAccount);
+    const setErr = useWorkspaceHost().reportError;
+    const showUndo = useWorkspaceHost().notify;
+    const driveType = useWorkspaceState((s) => s.driveType);
+    const setDriveType = useWorkspaceState((s) => s.setDriveType);
+    const driveQuery = useWorkspaceState((s) => s.driveQuery);
+    const setDriveQuery = useWorkspaceState((s) => s.setDriveQuery);
+    const driveShelf = useWorkspaceState((s) => s.driveShelf);
+    const setDriveShelf = useWorkspaceState((s) => s.setDriveShelf);
+    const drivePath = useWorkspaceState((s) => s.drivePath);
+    const setDrivePath = useWorkspaceState((s) => s.setDrivePath);
+    const setDriveToken = useWorkspaceState((s) => s.setDriveToken);
+    const setDriveFiles = useWorkspaceState((s) => s.setDriveFiles);
+    const setDriveBusy = useWorkspaceState((s) => s.setDriveBusy);
+    /** Current Drive folder id for write ops + reload (undefined = My Drive root). */
+    function currentFolderId() {
+        return driveShelf === "my" && drivePath.length ? drivePath[drivePath.length - 1].id : undefined;
+    }
+    async function reload(folderId, query, shelf = driveShelf, typeFilter = driveType) {
+        if (!activeAccount)
+            return;
+        setDriveBusy(true);
+        try {
+            const listing = await listDriveFiles(activeAccount, folderId, query || undefined, undefined, shelf === "my" ? undefined : shelf, typeFilter || undefined);
+            setDriveFiles(listing.files);
+            setDriveToken(listing.next_page_token);
+        }
+        catch (e) {
+            setErr(String(e));
+        }
+        finally {
+            setDriveBusy(false);
+        }
+    }
+    /** Switch Drive shelf (My Drive / Recent / Shared / Starred / Trash) — clears folder nav. */
+    function selectShelf(shelf) {
+        setDriveShelf(shelf);
+        setDrivePath([]);
+        setDriveQuery("");
+        reload(undefined, "", shelf, driveType);
+    }
+    function setTypeFilter(t) {
+        setDriveType(t);
+        reload(currentFolderId(), driveQuery, driveShelf, t);
+    }
+    function openFolder(f) {
+        setDriveShelf("my");
+        setDrivePath((p) => [...p, { id: f.id, name: f.name }]);
+        setDriveQuery("");
+        reload(f.id, "", "my", driveType);
+    }
+    function breadcrumbTo(idx) {
+        const next = idx < 0 ? [] : drivePath.slice(0, idx + 1);
+        setDrivePath(next);
+        setDriveQuery("");
+        reload(next.length ? next[next.length - 1].id : undefined, "", "my", driveType);
+    }
+    function refresh() {
+        reload(currentFolderId(), driveQuery, driveShelf, driveType);
+    }
+    function download(f) {
+        if (!activeAccount)
+            return;
+        saveAndScan(f.name, () => driveDownload(activeAccount, f.id, f.mime_type, f.name));
+    }
+    async function newFolder() {
+        if (!activeAccount)
+            return;
+        const name = await showDialog({ kind: "prompt", message: "New folder name" });
+        if (!name || !name.trim())
+            return;
+        driveCreateFolder(activeAccount, name.trim(), currentFolderId())
+            .then(() => {
+            showUndo("Folder created");
+            refresh();
+        })
+            .catch((e) => setErr(String(e)));
+    }
+    /** Upload one or more files into the current folder, then refresh. */
+    async function upload(files) {
+        if (!activeAccount)
+            return;
+        const list = Array.from(files);
+        if (list.length === 0)
+            return;
+        const parent = currentFolderId();
+        setDriveBusy(true);
+        let ok = 0;
+        for (const file of list) {
+            try {
+                const data = Array.from(new Uint8Array(await file.arrayBuffer()));
+                await driveUpload(activeAccount, file.name, file.type, data, parent);
+                ok++;
+            }
+            catch (e) {
+                setErr(String(e));
+                break;
+            }
+        }
+        setDriveBusy(false);
+        if (ok > 0) {
+            showUndo(`Uploaded ${ok} file${ok > 1 ? "s" : ""}`);
+            refresh();
+        }
+    }
+    async function rename(f) {
+        if (!activeAccount)
+            return;
+        const name = await showDialog({ kind: "prompt", message: "Rename to", initial: f.name });
+        if (!name || !name.trim() || name.trim() === f.name)
+            return;
+        driveRename(activeAccount, f.id, name.trim())
+            .then(() => {
+            showUndo("Renamed");
+            refresh();
+        })
+            .catch((e) => setErr(String(e)));
+    }
+    async function trash(f) {
+        if (!activeAccount)
+            return;
+        if ((await showDialog({ kind: "confirm", message: `Move "${f.name}" to Drive trash? You can restore it from Google Drive.` })) !== "ok")
+            return;
+        driveTrash(activeAccount, f.id)
+            .then(() => {
+            showUndo("Moved to Drive trash");
+            refresh();
+        })
+            .catch((e) => setErr(String(e)));
+    }
+    /** Insert a Drive file's share link into the compose body (open compose if needed). */
+    function insertDriveLink(f) {
+        const link = f.web_view_link;
+        if (!link) {
+            setErr("That item has no shareable link.");
+            return;
+        }
+        const html = `<a href="${link}">${f.name}</a>`;
+        showUndo(linkIntoCompose(html) === "inserted" ? `Linked ${f.name}` : `Linked ${f.name} into a new email`);
+    }
+    return {
+        activeAccount, driveShelf, drivePath, driveQuery, driveType,
+        setDriveQuery,
+        currentFolderId, reload, selectShelf, setTypeFilter, openFolder,
+        breadcrumbTo, refresh, download, upload, newFolder, rename, trash, insertDriveLink,
+    };
+}

package/dist/host.d.ts

@@ -0,0 +1,109 @@
+import { type ComponentType, type ReactNode } from "react";
+import type { CalEvent, CalendarInfo, ContactDupes, ContactGroup, DriveFile, DriveShelf, EventForm, StorageQuota, TaskCreate, TaskItem, TaskListInfo, WorkspaceClient } from "./client.js";
+/** The workspace slices of the host's state. */
+export interface WorkspaceFields {
+    calendars: CalendarInfo[];
+    selectedCal: string;
+    shownCals: string[];
+    calView: "month" | "week" | "day";
+    calCursor: number;
+    events: CalEvent[];
+    openEvent: CalEvent | null;
+    eventForm: EventForm | null;
+    freeBusyMsg: string;
+    calendarBusy: boolean;
+    /** A pending "new event" seed (Meet's "schedule for later" fills it, the calendar opens the form with it). */
+    eventSeed: {
+        summary: string;
+        withMeet: boolean;
+    } | null;
+    gtasks: TaskItem[];
+    taskLists: TaskListInfo[];
+    taskListId: string;
+    taskDue: string;
+    showCompletedTasks: boolean;
+    listMgrOpen: boolean;
+    taskFormOpen: boolean;
+    taskCreate: TaskCreate;
+    tasksBusy: boolean;
+    driveFiles: DriveFile[];
+    drivePath: {
+        id: string;
+        name: string;
+    }[];
+    driveQuery: string;
+    driveToken: string;
+    driveShelf: DriveShelf;
+    driveType: string;
+    driveViewMode: "grid" | "list";
+    driveQuota: StorageQuota | null;
+    drivePreview: DriveFile | null;
+    driveBusy: boolean;
+    contactGroups: ContactGroup[];
+    contactsQuery: string;
+    contactsBusy: boolean;
+    contactDupes: ContactDupes | null;
+}
+/** A setter that takes a value or an updater, like React's `setState`. */
+export type FieldSetter<T> = (v: T | ((prev: T) => T)) => void;
+/** `setX` for every field `x`. */
+export type WorkspaceSetters = {
+    [K in keyof WorkspaceFields as `set${Capitalize<K & string>}`]: FieldSetter<WorkspaceFields[K]>;
+};
+/** What `useState` selects from. `activeAccount` is the host's current account key (read only). */
+export type WorkspaceState = WorkspaceFields & WorkspaceSetters & {
+    activeAccount: string | null;
+};
+/** The preferences the views persist through the host. */
+export interface WorkspacePreferences {
+    shownCals: string[];
+    calView: "month" | "week" | "day";
+    driveViewMode: "grid" | "list";
+}
+export type WorkspaceDialog = {
+    kind: "confirm";
+    message: string;
+} | {
+    kind: "prompt";
+    message: string;
+    initial?: string;
+};
+/** The views a workspace view can ask the host to show. */
+export type WorkspaceView = "calendar" | "contacts" | "drive" | "tasks" | "meet";
+export interface WorkspaceHost {
+    client: WorkspaceClient;
+    /** Selector hook over the host's state. */
+    useState: <T>(selector: (s: WorkspaceState) => T) => T;
+    /** Shows an error to the user. */
+    reportError(message: string): void;
+    /** Shows a short notice (the host's toast). */
+    notify(message: string): void;
+    /** Confirm or prompt. Resolves to "ok" (confirm), the entered text (prompt), or null when cancelled. */
+    dialog(cfg: WorkspaceDialog): Promise<string | null>;
+    /** Persists a view preference. */
+    savePreference<K extends keyof WorkspacePreferences>(key: K, value: WorkspacePreferences[K]): void;
+    /** Opens a new message to `to` with `subject` and an HTML `body`. */
+    composeTo(to: string, subject: string, body: string): void;
+    /**
+     * Puts an HTML link into the message being written, or into a new message when none is open. Resolves to which
+     * one happened, so the view can say so.
+     */
+    linkIntoCompose(html: string): "inserted" | "new-message";
+    /** Runs a download the host saves (and may scan) under `label`. */
+    saveDownload(label: string, download: () => Promise<string>): void;
+    /** Switches the host to another workspace view. */
+    openView(view: WorkspaceView): void;
+    /** The host's account switcher, shown in each view's header. */
+    AccountSwitcher?: ComponentType;
+}
+/** Supplies the host to every workspace view and nav below it. */
+export declare function WorkspaceHostProvider({ host, children }: {
+    host: WorkspaceHost;
+    children?: ReactNode;
+}): import("react").JSX.Element;
+export declare function useWorkspaceHost(): WorkspaceHost;
+/** Selects from the host's workspace state. */
+export declare function useWorkspaceState<T>(selector: (s: WorkspaceState) => T): T;
+export declare function useWorkspaceClient(): WorkspaceClient;
+/** The host's account switcher, or nothing. */
+export declare function HostAccountSwitcher(): import("react").JSX.Element | null;

package/dist/host.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// The host contract of the workspace views (calendar, contacts, drive, tasks, meet and their navs).
+//
+// The package holds no IPC, no store and no product name. The host supplies, once, above the views:
+//  - `client`: every data call (`WorkspaceClient`), over the host's own transport;
+//  - `useState`: a selector hook over the host's state that holds the `WorkspaceState` slices (a zustand store
+//    with these fields and `set*` setters satisfies it directly), so the views and the host's navs share state;
+//  - the host actions the views trigger: errors, notices, dialogs, saved preferences, compose, downloads, view
+//    switches, and an optional account switcher.
+import { createContext, useContext } from "react";
+const HostContext = createContext(null);
+/** Supplies the host to every workspace view and nav below it. */
+export function WorkspaceHostProvider({ host, children }) {
+    return _jsx(HostContext.Provider, { value: host, children: children });
+}
+export function useWorkspaceHost() {
+    const host = useContext(HostContext);
+    if (!host)
+        throw new Error("@rightkit/workspace-ui: render the views inside <WorkspaceHostProvider host={...}>");
+    return host;
+}
+/** Selects from the host's workspace state. */
+export function useWorkspaceState(selector) {
+    return useWorkspaceHost().useState(selector);
+}
+export function useWorkspaceClient() {
+    return useWorkspaceHost().client;
+}
+/** The host's account switcher, or nothing. */
+export function HostAccountSwitcher() {
+    const Switcher = useWorkspaceHost().AccountSwitcher;
+    return Switcher ? _jsx(Switcher, {}) : null;
+}

package/dist/icons.d.ts

@@ -0,0 +1,34 @@
+import { type CSSProperties } from "react";
+import { type LucideIcon } from "lucide-react";
+declare const GLYPHS: {
+    calendar: LucideIcon;
+    check: LucideIcon;
+    "chevron-left": LucideIcon;
+    "chevron-right": LucideIcon;
+    clock: LucideIcon;
+    doc: LucideIcon;
+    draft: LucideIcon;
+    drive: LucideIcon;
+    folder: LucideIcon;
+    grid: LucideIcon;
+    image: LucideIcon;
+    list: LucideIcon;
+    more: LucideIcon;
+    people: LucideIcon;
+    "person-add": LucideIcon;
+    plus: LucideIcon;
+    star: LucideIcon;
+    tag: LucideIcon;
+    trash: LucideIcon;
+    upload: LucideIcon;
+    video: LucideIcon;
+};
+export type WorkspaceIconName = keyof typeof GLYPHS;
+/** A workspace glyph. Decorative (hidden from assistive technology); stroke follows the text colour. */
+export declare const Icon: import("react").MemoExoticComponent<({ name, size, className, style, }: {
+    name: WorkspaceIconName;
+    size?: number;
+    className?: string;
+    style?: CSSProperties;
+}) => import("react").JSX.Element>;
+export {};

package/dist/icons.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// The workspace views' glyphs, from Lucide (lucide-react). One name per glyph the views use, so a view names a
+// glyph without importing an app's icon set.
+import { memo } from "react";
+import { Calendar, Check, ChevronLeft, ChevronRight, Clock, Ellipsis, File, FileText, Folder, HardDrive, Image, LayoutGrid, List, Plus, Star, Tag, Trash2, Upload, UserPlus, Users, Video, } from "lucide-react";
+const GLYPHS = {
+    calendar: Calendar,
+    check: Check,
+    "chevron-left": ChevronLeft,
+    "chevron-right": ChevronRight,
+    clock: Clock,
+    doc: File,
+    draft: FileText,
+    drive: HardDrive,
+    folder: Folder,
+    grid: LayoutGrid,
+    image: Image,
+    list: List,
+    more: Ellipsis,
+    people: Users,
+    "person-add": UserPlus,
+    plus: Plus,
+    star: Star,
+    tag: Tag,
+    trash: Trash2,
+    upload: Upload,
+    video: Video,
+};
+/** A workspace glyph. Decorative (hidden from assistive technology); stroke follows the text colour. */
+export const Icon = memo(function Icon({ name, size = 16, className, style, }) {
+    const Glyph = GLYPHS[name];
+    return _jsx(Glyph, { size: size, className: className, style: style, strokeWidth: 1.75, "aria-hidden": "true", focusable: "false" });
+});