@dsh-workbench/shared 0.1.0

package/dist/api/facts.js

@@ -0,0 +1,146 @@
+export const FACT_SCOPE_SUFFIX = '*';
+export function unitFactScope(unit) {
+    return `${unit}${FACT_SCOPE_SUFFIX}`;
+}
+export function isFactScope(name) {
+    return name.length > 1 && name.endsWith(FACT_SCOPE_SUFFIX);
+}
+export function scopePrefixOf(name) {
+    return isFactScope(name) ? name.slice(0, -FACT_SCOPE_SUFFIX.length) : name;
+}
+export function createFactChannel(options) {
+    const entries = new Map();
+    let epoch = null;
+    let stopTransport = null;
+    let hostRev = 0;
+    let generation = 0;
+    const entryOf = (fact) => {
+        const existing = entries.get(fact);
+        if (existing !== undefined)
+            return existing;
+        const created = { rev: 0, listeners: new Set() };
+        entries.set(fact, created);
+        return created;
+    };
+    const targetsOf = (fact) => {
+        if (!isFactScope(fact)) {
+            const entry = entries.get(fact);
+            return entry === undefined ? [] : [entry];
+        }
+        const prefix = scopePrefixOf(fact);
+        const matched = [];
+        for (const [name, entry] of entries) {
+            if (name === prefix || name.startsWith(`${prefix}/`))
+                matched.push(entry);
+        }
+        return matched;
+    };
+    const mark = (fact, rev) => {
+        if (!isFactScope(fact)) {
+            entryOf(fact).rev = rev;
+            return;
+        }
+        for (const entry of targetsOf(fact))
+            entry.rev = rev;
+    };
+    const notify = (facts) => {
+        for (const fact of facts) {
+            for (const entry of targetsOf(fact)) {
+                for (const listener of [...entry.listeners])
+                    listener();
+            }
+        }
+    };
+    const ensureTransport = () => {
+        if (stopTransport !== null)
+            return;
+        stopTransport = options.transport.start({
+            onFrame: (frame) => channel.applyFrame(frame),
+            cursor: () => hostRev,
+        });
+    };
+    const releaseTransport = () => {
+        if (stopTransport === null)
+            return;
+        stopTransport();
+        stopTransport = null;
+    };
+    const channel = {
+        revisionOf: (fact) => entries.get(fact)?.rev ?? 0,
+        subscribe(fact, listener) {
+            const entry = entryOf(fact);
+            entry.listeners.add(listener);
+            ensureTransport();
+            return () => {
+                entry.listeners.delete(listener);
+                if (channel.subscriberCount() === 0)
+                    releaseTransport();
+            };
+        },
+        subscriberCount() {
+            let count = 0;
+            for (const entry of entries.values())
+                count += entry.listeners.size;
+            return count;
+        },
+        refresh(fact) {
+            generation += 1;
+            if (fact === undefined) {
+                for (const entry of entries.values())
+                    entry.rev = generation;
+                notify(entries.keys());
+                return;
+            }
+            mark(fact, generation);
+            notify([fact]);
+        },
+        applyFrame(frame) {
+            const nextEpoch = frame.epoch ?? null;
+            const first = epoch === null;
+            const epochChanged = epoch !== null && nextEpoch !== null && epoch !== nextEpoch;
+            if (nextEpoch !== null)
+                epoch = nextEpoch;
+            hostRev = epochChanged ? frame.rev : Math.max(hostRev, frame.rev);
+            if (first) {
+                generation += 1;
+                for (const fact of frame.facts)
+                    mark(fact, generation);
+                return;
+            }
+            if (epochChanged) {
+                generation += 1;
+                for (const entry of entries.values())
+                    entry.rev = generation;
+                notify(entries.keys());
+                return;
+            }
+            if (frame.facts.length === 0)
+                return;
+            generation += 1;
+            for (const fact of frame.facts)
+                mark(fact, generation);
+            notify(frame.facts);
+        },
+    };
+    return channel;
+}
+export function parseFactFrame(data) {
+    if (typeof data !== 'string')
+        return null;
+    try {
+        const parsed = JSON.parse(data);
+        if (typeof parsed.rev !== 'number')
+            return null;
+        return {
+            ...(typeof parsed.epoch === 'string' ? { epoch: parsed.epoch } : {}),
+            rev: parsed.rev,
+            facts: Array.isArray(parsed.facts) ? parsed.facts.filter((f) => typeof f === 'string') : [],
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function factOfRoute(route) {
+    return route;
+}

package/dist/api/host-write.d.ts

@@ -0,0 +1,12 @@
+import type { ApiResponse } from './workbench-client';
+export type WriteChannel = 'prefs' | 'actions' | 'provision';
+export declare function writeRoute(channel: WriteChannel, resource: string): string;
+export type WriteOutcome<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly message: string;
+    readonly detail?: string;
+};
+export declare function writeOutcomeOf<T>(response: ApiResponse<T> | null, networkText: string): WriteOutcome<T>;

package/dist/api/host-write.js

@@ -0,0 +1,17 @@
+export function writeRoute(channel, resource) {
+    if (channel === 'provision')
+        return 'provision';
+    return `${channel}/${resource}`;
+}
+export function writeOutcomeOf(response, networkText) {
+    if (response === null)
+        return { ok: false, message: networkText };
+    if (!response.ok) {
+        const box = response;
+        const own = typeof box.error?.message === 'string' && box.error.message !== '' ? box.error.message : undefined;
+        const fallback = typeof box.text === 'string' && box.text !== '' ? box.text : networkText;
+        const detail = typeof box.error?.detail === 'string' ? box.error.detail : undefined;
+        return { ok: false, message: own ?? fallback, ...(detail === undefined ? {} : { detail }) };
+    }
+    return { ok: true, value: response };
+}

package/dist/api/long-task.d.ts

@@ -0,0 +1,18 @@
+export type LongTaskStatus = 'running' | 'needs-login' | 'ok' | 'failed';
+export interface LongTaskStep {
+    readonly kind: 'start' | 'succeed' | 'fail' | 'info' | 'warn';
+    readonly text: string;
+    readonly loginUrl?: string | undefined;
+}
+export declare function runsRouteOf(unit: string): string;
+export interface LongTasksPayload {
+    readonly runs: readonly Readonly<Record<string, unknown>>[];
+}
+export declare const LONG_TASK_POLL_MS = 1500;
+export declare const LONG_TASK_IDLE_MS = 10000;
+export declare function longTaskPollMs(live: boolean, override?: number | undefined): number;
+export declare function longTaskRunsOf<T>(state: {
+    readonly phase?: string | undefined;
+    readonly value?: LongTasksPayload | undefined;
+}): readonly T[];
+export declare function longTaskDot(status: LongTaskStatus): 'ongoing' | 'done' | 'error' | 'idle';

package/dist/api/long-task.js

@@ -0,0 +1,22 @@
+export function runsRouteOf(unit) {
+    return `${unit}/runs`;
+}
+export const LONG_TASK_POLL_MS = 1500;
+export const LONG_TASK_IDLE_MS = 10_000;
+export function longTaskPollMs(live, override) {
+    if (override !== undefined)
+        return override;
+    return live ? LONG_TASK_POLL_MS : LONG_TASK_IDLE_MS;
+}
+export function longTaskRunsOf(state) {
+    return (state.value?.runs ?? []);
+}
+export function longTaskDot(status) {
+    if (status === 'ok')
+        return 'done';
+    if (status === 'failed')
+        return 'error';
+    if (status === 'running' || status === 'needs-login')
+        return 'ongoing';
+    return 'idle';
+}

package/dist/api/unit-board.d.ts

@@ -0,0 +1,14 @@
+import type { ModuleBlocker } from './blocker';
+import type { CapabilityPayload } from './workbench-contract';
+import type { ApiError } from './workbench-client';
+export type GateMode = 'capability' | 'none';
+export interface UnitGate {
+    readonly gated: boolean;
+}
+export declare function gateOf(capability: CapabilityPayload | null, mode: GateMode): UnitGate;
+export interface UnitBlockers {
+    readonly blocker?: ModuleBlocker;
+    readonly notice?: ModuleBlocker;
+}
+export declare function splitBlocker(candidates: readonly (ModuleBlocker | undefined)[]): UnitBlockers;
+export declare function probeKeyOf(error: ApiError | undefined): string | null;

package/dist/api/unit-board.js

@@ -0,0 +1,29 @@
+export function gateOf(capability, mode) {
+    if (mode === 'none')
+        return { gated: true };
+    if (capability === null)
+        return { gated: true };
+    return { gated: capability.status === 'ok' || capability.status === 'unchecked' };
+}
+export function splitBlocker(candidates) {
+    let blocker;
+    let notice;
+    for (const candidate of candidates) {
+        if (candidate === undefined)
+            continue;
+        if (candidate.severity === 'block') {
+            blocker ??= candidate;
+            continue;
+        }
+        notice ??= candidate;
+    }
+    return {
+        ...(blocker === undefined ? {} : { blocker }),
+        ...(blocker !== undefined || notice === undefined ? {} : { notice }),
+    };
+}
+export function probeKeyOf(error) {
+    if (error === undefined)
+        return null;
+    return error.code === '' ? 'unknown' : error.code;
+}

package/dist/api/unit.d.ts

@@ -0,0 +1,54 @@
+export interface UnitCard {
+    readonly titleKey: string;
+    readonly order: number;
+    readonly enabledByDefault: boolean;
+}
+export interface UnitTool {
+    readonly name: string;
+    readonly writes: boolean;
+}
+export interface UnitHostNeeds {
+    readonly inject: readonly string[];
+    readonly optional?: readonly string[];
+}
+export type PluginSource = {
+    readonly kind: 'git';
+    readonly url: string;
+} | {
+    readonly kind: 'local';
+    readonly env: string;
+} | {
+    readonly kind: 'npm';
+    readonly package: string;
+    readonly registryEnv: string;
+    readonly registryDefault?: string;
+};
+export interface UnitPluginNeed {
+    readonly name: string;
+    readonly commands?: readonly string[];
+    readonly installSource?: PluginSource;
+}
+export interface UnitLibNeed {
+    readonly name: string;
+    readonly version?: string | undefined;
+    readonly registryEnv: string;
+    readonly registryDefault: string;
+    readonly purpose: string;
+}
+export interface UnitEnvNeeds {
+    readonly command?: string;
+    readonly plugins?: readonly UnitPluginNeed[];
+    readonly libs?: readonly UnitLibNeed[];
+}
+export interface PluginRelease {
+    readonly installed: string;
+    readonly latest?: string;
+}
+export interface UnitManifest {
+    readonly id: string;
+    readonly kind: 'board' | 'ui';
+    readonly card: UnitCard | null;
+    readonly tools: readonly UnitTool[];
+    readonly host: UnitHostNeeds;
+    readonly env?: UnitEnvNeeds;
+}

package/dist/api/unit.js

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

package/dist/api/workbench-client.d.ts

@@ -0,0 +1,19 @@
+export interface ApiError {
+    readonly code: string;
+    readonly message: string;
+    readonly detail?: string;
+    readonly hint?: string;
+    readonly helpUrl?: string;
+}
+export type ApiResponse<T> = ({
+    readonly ok: true;
+} & T) | {
+    readonly ok: false;
+    readonly error: ApiError;
+};
+export type Query = Record<string, string | number | boolean | undefined>;
+export interface ApiGetOptions {
+    readonly signal?: AbortSignal | undefined;
+}
+export declare function apiGet<T>(route: string, query?: Query, options?: ApiGetOptions): Promise<ApiResponse<T>>;
+export declare function apiPost<T>(route: string, body: Record<string, unknown>): Promise<ApiResponse<T>>;

package/dist/api/workbench-client.js

@@ -0,0 +1,33 @@
+import { API_PREFIX } from '../config/constants.js';
+export async function apiGet(route, query = {}, options = {}) {
+    const { signal } = options;
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+        if (value !== undefined)
+            search.set(key, String(value));
+    }
+    const suffix = search.toString();
+    const response = await fetch(`${API_PREFIX}/${route}${suffix ? `?${suffix}` : ''}`, {
+        method: 'GET',
+        headers: { accept: 'application/json' },
+        ...(signal === undefined ? {} : { signal }),
+    });
+    if (!response.ok) {
+        return {
+            ok: false,
+            error: { code: 'http', message: `宿主返回 HTTP ${response.status}` },
+        };
+    }
+    return (await response.json());
+}
+export async function apiPost(route, body) {
+    const response = await fetch(`${API_PREFIX}/${route}`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', accept: 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        return { ok: false, error: { code: 'http', message: `宿主返回 HTTP ${response.status}` } };
+    }
+    return (await response.json());
+}

package/dist/api/workbench-contract.d.ts

@@ -0,0 +1,32 @@
+import type { PluginRelease } from '../api/unit.js';
+export type ProvisionAction = 'install' | 'update' | 'uninstall' | 'update-dependency';
+export interface PluginStatePayload {
+    readonly name: string;
+    readonly status: 'ok' | 'outdated' | 'missing';
+    readonly missing: readonly string[];
+    readonly install?: 'ready' | 'not-declared' | 'env-missing' | 'malformed';
+    readonly command?: string;
+    readonly release?: PluginRelease;
+}
+export interface CapabilityPayload {
+    readonly unit: string;
+    readonly status: 'ok' | 'missing-commands' | 'missing-plugin' | 'unchecked';
+    readonly plugin?: string;
+    readonly required: readonly string[];
+    readonly missing: readonly string[];
+    readonly detail: string;
+    readonly command?: string;
+    readonly fix?: 'install' | 'update';
+    readonly plugins?: readonly PluginStatePayload[];
+    readonly released?: boolean;
+    readonly install?: 'ready' | 'not-declared' | 'env-missing' | 'malformed';
+    readonly libs?: readonly LibStatePayload[];
+}
+export interface LibStatePayload {
+    readonly name: string;
+    readonly purpose: string;
+    readonly status: 'ok' | 'outdated' | 'missing' | 'unsatisfied';
+    readonly installed?: string;
+    readonly latest?: string;
+    readonly command?: string;
+}

package/dist/api/workbench-contract.js

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

package/dist/components/ApprovalDetail.d.ts

@@ -0,0 +1,27 @@
+import type { Translate } from '../api/dsh-client.js';
+import type { UnitClientFace } from '../components/board-module.js';
+interface ToolCallRoot {
+    readonly callId?: string;
+    readonly name?: string;
+    readonly phase?: string;
+    readonly argsRaw?: string;
+}
+interface ChatSnapshot {
+    readonly nodes?: {
+        values(): Iterable<{
+            readonly kind?: string;
+            readonly data?: {
+                readonly root?: ToolCallRoot;
+            };
+        }>;
+    };
+}
+type UseChat = <T>(selector: (snapshot: ChatSnapshot) => T) => T | undefined;
+export interface ApprovalDetailProps {
+    readonly callId?: string;
+    readonly useChat?: UseChat;
+    readonly units?: readonly UnitClientFace[];
+    readonly t?: Translate;
+}
+export declare function ApprovalDetail(props: ApprovalDetailProps): JSX.Element | null;
+export {};

package/dist/components/ApprovalDetail.js

@@ -0,0 +1,33 @@
+import { h } from '../lib/react.js';
+function callOf(snapshot, callId) {
+    if (callId === undefined)
+        return undefined;
+    for (const node of snapshot.nodes?.values() ?? []) {
+        const root = node.kind === 'tool-call' ? node.data?.root : undefined;
+        if (root?.callId !== callId || root.phase !== 'start')
+            continue;
+        return { ...(root.name === undefined ? {} : { name: root.name }), argsRaw: root.argsRaw ?? '' };
+    }
+    return undefined;
+}
+function parseArgs(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'object' && parsed !== null ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function ApprovalDetail(props) {
+    const useChat = props.useChat ?? (() => undefined);
+    const call = useChat((snapshot) => callOf(snapshot, props.callId));
+    const t = props.t ?? ((key) => key);
+    const args = parseArgs(call?.argsRaw ?? '');
+    const input = { tool: call?.name ?? '', args };
+    const command = typeof args.command === 'string' ? args.command : '';
+    const owner = (props.units ?? []).find((face) => face.approval?.tools.includes(input.tool) === true);
+    if (owner?.approval !== undefined)
+        return h(owner.approval.render, { input: input, t: t });
+    return command === '' ? null : h("code", { className: "wb-approvalCommand" }, command);
+}

package/dist/components/CardHead.d.ts

@@ -0,0 +1,16 @@
+import type { ReactNode } from '../lib/react.js';
+import type { Translate } from '../api/dsh-client.js';
+export interface CardHeadProps {
+    readonly t: Translate;
+    readonly title: string;
+    readonly meta?: ReactNode | undefined;
+    readonly refreshing: boolean;
+    readonly onRefresh: () => void;
+    readonly gear?: string | undefined;
+    readonly gearOpen?: boolean | undefined;
+    readonly onToggleGear?: (() => void) | undefined;
+    readonly platformHref?: string | undefined;
+    readonly platform?: string | undefined;
+    readonly platformTitle?: string | undefined;
+}
+export declare function CardHead({ t, title, meta, refreshing, onRefresh, gear, gearOpen, onToggleGear, platformHref, platform, platformTitle, }: CardHeadProps): JSX.Element;

package/dist/components/CardHead.js

@@ -0,0 +1,14 @@
+import { IconRefresh, IconRightUp, IconSettings } from '../components/icons.js';
+import { h } from '../lib/react.js';
+export function CardHead({ t, title, meta, refreshing, onRefresh, gear, gearOpen, onToggleGear, platformHref, platform, platformTitle, }) {
+    const refreshLabel = refreshing ? t('rightbar.refreshing') : t('rightbar.refresh');
+    return (h("header", { className: "wb-cardHead" },
+        h("h2", { className: "wb-cardTitle" }, title),
+        meta === undefined ? null : h("span", { className: "wb-cardMeta" }, meta),
+        platformHref === undefined || platform === undefined ? null : (h("a", { className: "wb-iconButton wb-cardOpen", href: platformHref, target: "_blank", rel: "noreferrer noopener", title: platformTitle ?? platform, "aria-label": platform },
+            h(IconRightUp, { size: 14 }))),
+        h("button", { type: "button", className: `wb-iconButton wb-cardRefresh${refreshing ? ' wb-spinning' : ''}`, "aria-label": refreshLabel, title: refreshLabel, disabled: refreshing, onClick: onRefresh },
+            h(IconRefresh, { size: 14 })),
+        gear === undefined || onToggleGear === undefined ? null : (h("button", { type: "button", className: `wb-iconButton wb-cardGear${gearOpen === true ? ' wb-iconButtonActive' : ''}`, "aria-label": gear, "aria-expanded": gearOpen === true, title: gear, onClick: onToggleGear },
+            h(IconSettings, { size: 15 })))));
+}

package/dist/components/ChoiceGroup.d.ts

@@ -0,0 +1,14 @@
+import type { ReactNode } from '../lib/react.js';
+export interface ChoiceGroupOption {
+    readonly value: string;
+    readonly label: ReactNode;
+}
+export interface ChoiceGroupProps {
+    readonly label: string;
+    readonly name: string;
+    readonly value: string;
+    readonly options: readonly ChoiceGroupOption[];
+    readonly disabled?: boolean | undefined;
+    readonly onChange: (next: string) => void;
+}
+export declare function ChoiceGroup({ label, name, value, options, disabled, onChange }: ChoiceGroupProps): JSX.Element;

package/dist/components/ChoiceGroup.js

@@ -0,0 +1,7 @@
+import { Fragment, h } from '../lib/react.js';
+export function ChoiceGroup({ label, name, value, options, disabled, onChange }) {
+    return (h("div", { className: "wb-choiceMenu", role: "radiogroup", "aria-label": label }, options.map((option) => (h(Fragment, { key: option.value },
+        h("label", { className: "wb-choiceOption" },
+            h("input", { className: "wb-radio", type: "radio", name: name, checked: option.value === value, disabled: disabled === true, onChange: () => onChange(option.value) }),
+            h("span", { className: "wb-choiceLabel" }, option.label)))))));
+}

package/dist/components/LongTaskRow.d.ts

@@ -0,0 +1,16 @@
+import { type LongTaskStatus } from '../api/long-task.js';
+export interface LongTaskRowLink {
+    readonly href: string;
+    readonly text: string;
+}
+export interface LongTaskRowProps {
+    readonly status: LongTaskStatus;
+    readonly headline: string;
+    readonly problem?: string | undefined;
+    readonly links?: readonly LongTaskRowLink[] | undefined;
+    readonly steps?: readonly string[] | undefined;
+    readonly raw?: string | undefined;
+    readonly stepsTitle?: string | undefined;
+    readonly rawTitle?: string | undefined;
+}
+export declare function LongTaskRow(props: LongTaskRowProps): JSX.Element;

package/dist/components/LongTaskRow.js

@@ -0,0 +1,28 @@
+import { longTaskDot } from '../api/long-task.js';
+import { Fragment, h } from '../lib/react.js';
+import { IconRightUp } from './icons';
+import { StateDot } from './StateDot';
+function RowLink({ href, text }) {
+    return (h("a", { className: "wb-linkButton wb-longTaskLink", href: href, target: "_blank", rel: "noreferrer noopener" },
+        text,
+        h(IconRightUp, { size: 12 })));
+}
+export function LongTaskRow(props) {
+    const failed = props.status === 'failed';
+    const problem = props.problem ?? '';
+    const raw = (props.raw ?? '').trim();
+    const steps = props.steps ?? [];
+    return (h("div", { className: "wb-longTask" },
+        h("p", { className: "wb-longTaskHead" },
+            h(StateDot, { state: longTaskDot(props.status), size: 10 }),
+            h("span", { className: "wb-longTaskHeadline" }, props.headline),
+            (props.links ?? []).map((link) => (h(RowLink, { href: link.href, key: `${link.text}@${link.href}`, text: link.text })))),
+        problem === '' ? null : h("p", { className: "wb-longTaskProblem" }, problem),
+        !failed ? null : (h(Fragment, null,
+            steps.length === 0 || props.stepsTitle === undefined ? null : (h("details", { className: "wb-longTaskDump" },
+                h("summary", null, props.stepsTitle),
+                h("pre", null, steps.join('\n')))),
+            raw === '' || props.rawTitle === undefined ? null : (h("details", { className: "wb-longTaskDump" },
+                h("summary", null, props.rawTitle),
+                h("pre", null, raw)))))));
+}

package/dist/components/MockStrip.d.ts

@@ -0,0 +1,14 @@
+export declare function MockStrip({ mocks, index, onPick, note, real, }: {
+    readonly mocks: readonly {
+        readonly id: string;
+        readonly label: string;
+    }[];
+    readonly index: number;
+    readonly onPick: (next: number) => void;
+    readonly note?: string;
+    readonly real?: {
+        readonly label: string;
+        readonly active: boolean;
+        readonly onPick: () => void;
+    } | undefined;
+}): JSX.Element;

package/dist/components/MockStrip.js

@@ -0,0 +1,7 @@
+import { h } from '../lib/react.js';
+export function MockStrip({ mocks, index, onPick, note, real, }) {
+    return (h("div", { className: "wb-mockStrip" },
+        h("span", { className: "wb-mockNote" }, note ?? '夹具：只切状态，不发请求'),
+        real === undefined ? null : (h("button", { type: "button", className: `wb-mockChip${real.active ? ' wb-mockChipOn' : ''}`, onClick: real.onPick }, real.label)),
+        mocks.map((mock, at) => (h("button", { key: mock.id, type: "button", className: `wb-mockChip${at === index ? ' wb-mockChipOn' : ''}`, onClick: () => onPick(at) }, mock.label)))));
+}

package/dist/components/ResourceStates.d.ts

@@ -0,0 +1,18 @@
+import type { ReactNode } from 'react';
+export declare function SkeletonRows({ rows }: {
+    rows?: number;
+}): JSX.Element;
+export interface CenteredStateProps {
+    icon: ReactNode;
+    title: string;
+    hint?: string;
+    detail?: string;
+    action?: ReactNode;
+    compact?: boolean;
+}
+export declare function CenteredState({ icon, title, hint, detail, action, compact }: CenteredStateProps): JSX.Element;
+export declare function EmptyState({ text, icon, compact }: {
+    text: string;
+    icon?: ReactNode;
+    compact?: boolean;
+}): JSX.Element;

package/dist/components/ResourceStates.js

@@ -0,0 +1,17 @@
+import { h } from '../lib/react.js';
+export function SkeletonRows({ rows = 4 }) {
+    return (h("div", { className: "wb-skeleton", "aria-hidden": "true" }, Array.from({ length: rows }, (_, index) => (h("span", { key: index, className: "wb-skeletonRow" },
+        h("span", { className: "wb-skeletonBar wb-skeletonBarTitle" }),
+        h("span", { className: "wb-skeletonBar wb-skeletonBarMeta" }))))));
+}
+export function CenteredState({ icon, title, hint, detail, action, compact = false }) {
+    return (h("div", { className: compact ? 'wb-centered wb-centeredCompact' : 'wb-centered', role: "status" },
+        icon === null ? null : (h("span", { className: "wb-centeredHero", "aria-hidden": "true" }, icon)),
+        h("div", { className: "wb-centeredTitle" }, title),
+        hint === undefined ? null : h("div", { className: "wb-centeredHint" }, hint),
+        detail === undefined ? null : h("div", { className: "wb-centeredDetail" }, detail),
+        action === undefined ? null : h("div", { className: "wb-centeredAction" }, action)));
+}
+export function EmptyState({ text, icon = null, compact = false }) {
+    return h(CenteredState, { icon: icon, title: text, compact: compact });
+}

package/dist/components/SaveBar.d.ts

@@ -0,0 +1,12 @@
+export interface SaveBarProps {
+    readonly busy: boolean;
+    readonly disabled?: boolean | undefined;
+    readonly labels: {
+        readonly cancel: string;
+        readonly save: string;
+        readonly saving: string;
+    };
+    readonly onCancel: () => void;
+    readonly onSave: () => void;
+}
+export declare function SaveBar({ busy, disabled, labels, onCancel, onSave }: SaveBarProps): JSX.Element;