@tangle-network/agent-app 0.60.184 → 0.60.185

package/dist/settings-react/use-setting-field.d.ts

@@ -0,0 +1,70 @@
+/**
+ * One setting's save behaviour: the control shows the person's value at once,
+ * the write goes through `useConfirmedMutation`, and the row says what
+ * happened — "Saving…" only after the pending delay, "Saved" only on a
+ * confirmed write and only for two seconds, the server's own sentence and a
+ * Retry when it refused. The control keeps the person's value on a failure.
+ * Writes go one at a time: a change made while one is in flight waits for it,
+ * and only the newest waiting value is sent, so the server ends on the
+ * person's last choice. A confirmed write the person has not edited since
+ * shows the value the server kept, so a name it trims reads as saved.
+ */
+import { type ReactNode } from 'react';
+import { type AsyncLoadContext, type MutationOutcome } from '../web-react/async';
+/**
+ * - `idle`: the control shows the saved value.
+ * - `unsaved`: an edit is waiting for blur or Enter (`commitOn: 'blur'`).
+ * - `invalid`: the edit fails `validate`; nothing is sent.
+ * - `saving`: the write is in flight.
+ * - `saved`: the write was confirmed in the last two seconds.
+ * - `failed`: the write was refused; the edit stays for a retry.
+ */
+export type SettingFieldState = 'idle' | 'unsaved' | 'invalid' | 'saving' | 'saved' | 'failed';
+export interface UseSettingFieldOptions<T> {
+    /** The value the server holds. A new value replaces the draft unless the person is editing it. */
+    saved: T;
+    /**
+     * Writes the value and resolves with the value the server kept, which the control then shows:
+     * `confirmSettingResponse(fetch(...), () => next)` for a route that answers `{ success: true }`
+     * or 204, a `parse` that reads the kept value from a route that answers with the record, or
+     * `confirmWrite`/`rejectWrite` from `web-react/async`. A refusal's message is what the row shows.
+     */
+    save: (next: T, context: AsyncLoadContext) => Promise<MutationOutcome<T>>;
+    /** `change` (default) saves on every change: selects, switches, segmented choices. `blur` saves on `commit()`: text. */
+    commitOn?: 'change' | 'blur';
+    /**
+     * With `commitOn: 'change'`, waits this long after the last change before saving. A change
+     * still waiting when the field unmounts, as on a section switch, is sent then.
+     */
+    debounceMs?: number;
+    /** Returns the sentence that says what to fix, or null. Checked on every change; an invalid value is never sent. */
+    validate?: (draft: T) => string | null;
+    /**
+     * Defaults to structural equality over primitives, arrays and plain objects, so a `saved`
+     * record built inline on each render is not a new server value. Other objects compare by
+     * identity: pass one for them, such as `(a, b) => a.getTime() === b.getTime()` for a Date.
+     */
+    isEqual?: (a: T, b: T) => boolean;
+    /** Fires with the confirmed value. */
+    onSaved?: (value: T) => void;
+}
+/** Spread into `SettingsRow`: the status after the label, the error that replaces the description, and Retry. */
+export interface SettingFieldRowProps {
+    status?: ReactNode;
+    error?: ReactNode;
+    onRetry?: () => void;
+}
+export interface SettingField<T> {
+    draft: T;
+    /** Shows the value at once; with `commitOn: 'change'` it also saves it. */
+    setDraft: (next: T) => void;
+    /** Saves the draft (or `next`) unless it is invalid or already saved. Use it on blur and Enter. */
+    commit: (next?: T) => void;
+    /** Puts the saved value back and clears any error. */
+    revert: () => void;
+    state: SettingFieldState;
+    /** The validation or failure sentence, or null. */
+    error: string | null;
+    rowProps: SettingFieldRowProps;
+}
+export declare function useSettingField<T>({ saved, save, commitOn, debounceMs, validate, isEqual, onSaved, }: UseSettingFieldOptions<T>): SettingField<T>;

package/dist/stories/settings/settings-backend.d.ts

@@ -0,0 +1,66 @@
+/**
+ * An in-browser settings API for the settings page story and its browser
+ * proof. It answers real `Request`s with real `Response`s in the shape a
+ * product's settings routes use — `{ error: { code, message, field?,
+ * retryAfterSeconds? } }` on a refusal — so the page's typed-outcome path is
+ * the one a product runs. `control` holds or refuses the next write, which is
+ * how the proof photographs "Saving…" and a failed save.
+ */
+export type ViewerRole = 'owner' | 'admin';
+export interface DemoWorkspace {
+    name: string;
+    timezone: string;
+    charts: boolean;
+    instructions: string;
+    dailyRun: boolean;
+    digest: boolean;
+    approvalEmail: 'each' | 'daily' | 'never';
+    approvalText: 'each' | 'daily' | 'never';
+    caps: {
+        perDay: number | null;
+        total: number | null;
+    };
+}
+export interface DemoMember {
+    id: string;
+    userId: string | null;
+    role: 'viewer' | 'editor' | 'admin' | 'owner';
+    name: string | null;
+    email: string | null;
+    acceptedAt: number | null;
+}
+export interface DemoInvitation {
+    id: string;
+    email: string;
+    permissions: 'viewer' | 'editor' | 'admin';
+    status: 'pending' | 'accepted' | 'expired' | 'revoked';
+    emailStatus: 'not_sent' | 'sent' | 'failed';
+    expiresAt: string;
+    acceptedAt?: string | null;
+    inviteUrl: string;
+}
+export interface DemoBackend {
+    fetch: typeof fetch;
+    control: {
+        /** The next write waits until `release()`. */
+        holdNext(): void;
+        release(): void;
+        /** The next write is refused with this status and typed error. */
+        failNext(status: number, error: {
+            code: string;
+            message: string;
+            field?: string;
+            retryAfterSeconds?: number;
+        }): void;
+    };
+    /** Every write the backend accepted, for the proof's checks. */
+    writes: Array<{
+        method: string;
+        path: string;
+        body: unknown;
+    }>;
+}
+export declare function createSettingsBackend({ viewer, latencyMs }?: {
+    viewer?: ViewerRole;
+    latencyMs?: number;
+}): DemoBackend;

package/dist/stories/settings/settings-demo.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A project settings page built only from `settings-react` and the ui
+ * settings atoms, over the in-browser backend: every row autosaves, confirms
+ * or groups its save the way the settings contract says. The story renders it
+ * and `scripts/prove-settings-pages.mjs` drives it in a real browser.
+ */
+import type { DemoBackend, ViewerRole } from './settings-backend';
+export type DemoSectionId = 'general' | 'agent' | 'notifications' | 'limits' | 'team';
+export interface SettingsDemoProps {
+    backend: DemoBackend;
+    viewer?: ViewerRole;
+    initialSection?: DemoSectionId;
+    /** How long a section's "loader" takes, so the optimistic nav and progress line show. */
+    routeDelayMs?: number;
+}
+export declare function SettingsDemo({ backend: api, viewer, initialSection, routeDelayMs }: SettingsDemoProps): import("react").JSX.Element;

package/dist/stories/settings/team-panels-demo.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The teams panels that Tax, Legal and GTM render today, each in a card the
+ * way those pages draw them, so the story and the browser proof can check
+ * that the role picker, Remove and Invite stay inside the card at phone width.
+ * As `admin` the viewer is Amir, an admin whose own row offers no role change
+ * or removal.
+ */
+declare const VIEWERS: {
+    readonly owner: {
+        readonly currentRole: 'owner';
+        readonly currentUserId: 'usr-dana';
+    };
+    readonly admin: {
+        readonly currentRole: 'admin';
+        readonly currentUserId: 'usr-amir';
+    };
+};
+export declare function TeamPanelsDemo({ viewer }: {
+    viewer?: keyof typeof VIEWERS;
+}): import("react").JSX.Element;
+export {};

package/dist/studio-react/index.js

@@ -39,7 +39,7 @@ import {
 } from "../chunk-6PRQ45QE.js";
 import {
   useInfiniteScroll
-} from "../chunk-EQRVOMMS.js";
+} from "../chunk-KMIDRUUH.js";
 import "../chunk-A2GG4D4A.js";
 import "../chunk-SJWIZT7B.js";
 import {
@@ -51,7 +51,7 @@ import {
   POPOVER_SURFACE_ATTR,
   PopoverSurface,
   usePopover
-} from "../chunk-TJ4DYKF2.js";
+} from "../chunk-XG6FODYO.js";
 import {
   ProviderLogo
 } from "../chunk-RASGKEAL.js";

package/dist/teams-react/components/InviteForm.d.ts

@@ -3,8 +3,8 @@
  * address is checked with the same rule the invitations API enforces, so
  * Invite stays disabled until the address could be delivered to, and the
  * reason appears under the field once the person leaves it or tries to send.
- * On a narrow card the role and Invite wrap below the field together instead
- * of being pushed past the card's edge.
+ * On a narrow card the field, the role and Invite stack, the role at full
+ * width so its longest name fits, and nothing passes the card's edge.
  */
 import type { WorkspaceRole } from '../../teams/roles';
 interface InviteFormProps {

package/dist/teams-react/components/MembersPanel.d.ts

@@ -5,10 +5,14 @@
  * `./teams/members-api`), so this imports no app router, fetch client, or toast.
  * Styled with the shipped Tangle Quiet tokens (`var(--*)`).
  *
- * Role gating mirrors the API: only admins/owners see role selects and the
- * remove control; inherited org owners and explicit owners are not editable
- * here (org-level concern). The invite role select offers `admin` only to
- * admins/owners.
+ * Role gating mirrors the API and `MembersSection` (`canManageMember`): only
+ * admins/owners see role selects and the remove control; inherited org owners,
+ * explicit owners and the viewer's own row are not editable here. The invite
+ * role select offers `admin` only to admins/owners.
+ *
+ * Below 36rem of panel a member's role picker takes its own full-width line
+ * under the name, and Remove stays beside the name, so the longest capability
+ * name fits and nothing passes the card's edge.
  */
 import type { MembersPanelProps } from '../contracts';
-export declare function MembersPanel({ members, currentRole, onInvite, onChangeRole, onRemove, onNotice, showInviteForm, }: MembersPanelProps): import("react").JSX.Element;
+export declare function MembersPanel({ members, currentRole, currentUserId, onInvite, onChangeRole, onRemove, onNotice, showInviteForm, }: MembersPanelProps): import("react").JSX.Element;

package/dist/teams-react/components/RoleSelect.d.ts

@@ -1,17 +1,19 @@
 /**
- * Shared role dropdown for the teams panels — the popover-listbox pattern the
- * design system requires in place of a native `<select>` (same contract as the
- * design-canvas Toolbar's SelectControl: bordered trigger, chevron glyph, and a
- * `role="listbox"` panel on the L3 popover surface with click-outside /
- * Escape-to-close). Both panels assign from the same workspace-role set, so the
- * options live here too.
+ * The role picker both team panels and the settings sections share: the ui
+ * `Select`, with each role named by what it lets a person do and, in the open
+ * list, one line on what it adds, so choosing one never needs a help page.
+ * The trigger shows the name alone and fills its container; give the
+ * container the width.
  */
-import type { WorkspaceRole } from '../../teams/roles';
+import { type WorkspaceRole } from '../../teams/roles';
+/** Each workspace role in the words a person decides by. */
+export declare const ROLE_CAPABILITY: Record<WorkspaceRole, string>;
 export interface RoleSelectProps {
     value: WorkspaceRole;
     onChange(role: WorkspaceRole): void;
     /** Accessible name (no visible label — the panels label the row). */
     ariaLabel: string;
+    id?: string;
     disabled?: boolean;
 }
-export declare function RoleSelect({ value, onChange, ariaLabel, disabled }: RoleSelectProps): import("react").JSX.Element;
+export declare function RoleSelect({ value, onChange, ariaLabel, id, disabled }: RoleSelectProps): import("react").JSX.Element;

package/dist/teams-react/components/invitation-detail.d.ts

@@ -0,0 +1,8 @@
+/** The line under an invitation's address, shared by `InvitationsPanel` and the settings `InvitationsSection`. */
+import type { InvitationView } from '../contracts';
+/**
+ * The line under the address: what the invitee can do, then only what is true
+ * of this invitation now. Every status says itself in words, so a past
+ * invitation reads as joined, expired or revoked without a badge.
+ */
+export declare function invitationDetail(invitation: InvitationView): string;

package/dist/teams-react/components/member-access.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Who may change a member's access, and the words for a role shown as text.
+ * `MembersPanel` and the settings `MembersSection` both read these, so the two
+ * member lists apply one rule.
+ */
+import { type WorkspaceRole } from '../../teams/roles';
+import type { MemberView } from '../contracts';
+/**
+ * Whether the viewer can change this member's role or remove them: an admin
+ * can, except for an owner, an inherited organization admin, or their own row,
+ * so no one demotes or removes themselves from a list.
+ */
+export declare function canManageMember(member: MemberView, currentRole: WorkspaceRole, currentUserId?: string | null): boolean;
+/** True on the viewer's own row. */
+export declare function isCurrentMember(member: MemberView, currentUserId?: string | null): boolean;
+/** A role shown as text rather than a picker. */
+export declare function memberRoleLabel(member: MemberView): string;

package/dist/teams-react/contracts.d.ts

@@ -24,6 +24,8 @@ export interface MembersPanelProps {
     members: MemberView[];
     /** The viewer's effective role — gates which controls are interactive. */
     currentRole: WorkspaceRole;
+    /** The viewer's user id, so their own row offers no role change or removal, as in `MembersSection`. */
+    currentUserId?: string | null;
     /** Invite a member; resolve with the shareable invite URL (or void). */
     onInvite(input: {
         email: string;