@startsimpli/ui 0.4.77 → 0.4.79

package/src/components/activity/index.ts

@@ -0,0 +1,51 @@
+/**
+ * @startsimpli/ui/activity — the shared, filterable activity feed
+ * (startsim-768w.19.5).
+ *
+ * A primitive (the generalised `ActivityTimeline`, exported from the package
+ * root) plus the page-level composer `ActivityFeedPanel`, so an app that wants
+ * a "what happened here" surface holds theme classNames and a thin wrapper
+ * instead of its own timeline — rule #9.
+ *
+ * Nothing in here knows which event types exist. Visibility was decided by the
+ * endpoint; the feed renders what it receives, humanising an action it has
+ * never seen rather than dropping or mislabelling it.
+ */
+export { ActivityFeedPanel, type ActivityFeedPanelProps } from './ActivityFeedPanel';
+export {
+  ACTIVITY_FEED_PANEL_DEFAULTS,
+  type ActivityFeedPanelClassNames,
+} from './activity-feed-panel-default-class-names';
+
+export {
+  ActivityFilterBar,
+  activityFilterCount,
+  type ActivityFilterBarProps,
+} from './ActivityFilterBar';
+export {
+  ACTIVITY_FILTER_BAR_DEFAULTS,
+  type ActivityFilterBarClassNames,
+} from './activity-filter-bar-default-class-names';
+
+export {
+  TONE_DOT,
+  SOURCE_NOTE,
+  actionOf,
+  humanizeAction,
+  activityLabel,
+  activityTone,
+  activityHead,
+  toActivityTimelineItems,
+  deriveActivityFilterOptions,
+} from './activity-events';
+
+export type {
+  ActivityClient,
+  ActivityEvent,
+  ActivityEventActor,
+  ActivityFilterOption,
+  ActivityFilterOptions,
+  ActivityFilterValue,
+  ActivityPage,
+  ActivityQuery,
+} from './types';

package/src/components/activity/types.ts

@@ -0,0 +1,94 @@
+/**
+ * @startsimpli/ui/activity — the shapes the shared activity feed renders.
+ *
+ * Structural on purpose: packages/ui imports no API client, so these mirror the
+ * event-stream row without depending on @startsimpli/api. `FoundryActivityEvent`
+ * is assignable to `ActivityEvent`, and so is any other append-only trail with
+ * an action + a timestamp.
+ *
+ * THE UI DECIDES NOTHING ABOUT VISIBILITY. The stream endpoint already filtered
+ * by the caller's resolved permission level, so every row that arrives here is
+ * renderable and there is no vocabulary of known types anywhere below.
+ */
+
+export interface ActivityEventActor {
+  id?: string;
+  email?: string | null;
+  name?: string | null;
+  avatarUrl?: string | null;
+}
+
+/** One row of an append-only event stream. Only `id` + `created_at` are
+ *  required; everything else is per-type detail the renderer treats as
+ *  optional so an unknown type still renders. */
+export interface ActivityEvent {
+  id: string;
+  /** The raw event type as the server names it, e.g. `member_invited`. */
+  action?: string;
+  /** Alias of `action` for streams that name it `type`. */
+  type?: string;
+  target_type?: string;
+  target_id?: string;
+  metadata?: Record<string, unknown>;
+  actor?: ActivityEventActor | null;
+  actor_email?: string | null;
+  /** Lifecycle detail — present on state transitions, null on everything else. */
+  state?: string | null;
+  previous_state?: string | null;
+  source?: string;
+  reason?: string;
+  error?: string;
+  run_id?: string;
+  run_kind?: string;
+  created_at: string;
+}
+
+/** Narrowing the user asked for. Every field can only SUBTRACT from the rows
+ *  the caller's level already permits — a filter is a preference, never an
+ *  access decision. */
+export interface ActivityFilterValue {
+  /** Actor user id or email. */
+  actor?: string;
+  /** One action, or several comma-separated. */
+  action?: string;
+  /** ISO-8601 lower bound on the timestamp (inclusive). */
+  since?: string;
+  /** ISO-8601 upper bound on the timestamp (inclusive). */
+  until?: string;
+  /** Free text. */
+  q?: string;
+}
+
+export interface ActivityQuery extends ActivityFilterValue {
+  page?: number;
+  pageSize?: number;
+  // Index signature so this satisfies an API client's query-params type
+  // (mirrors `FoundryActivityParams`) — the injected client is the app's own.
+  [key: string]: unknown;
+}
+
+export interface ActivityPage {
+  count: number;
+  next?: string | null;
+  previous?: string | null;
+  results: ActivityEvent[];
+}
+
+/**
+ * The one call the feed needs. The consuming app injects its authed client
+ * (`(p) => api.foundry.activity(slug, p)`), which is what keeps @startsimpli/api
+ * out of packages/ui and the app wrapper under ten lines.
+ */
+export interface ActivityClient {
+  list(params: ActivityQuery): Promise<ActivityPage>;
+}
+
+export interface ActivityFilterOption {
+  value: string;
+  label: string;
+}
+
+export interface ActivityFilterOptions {
+  actors: ActivityFilterOption[];
+  actions: ActivityFilterOption[];
+}

package/src/components/index.ts

@@ -154,8 +154,16 @@ export * from './pipeline'
 export * from './calendar'
 
 // Activity components (timeline, quick log, log dialog)
-export { ActivityTimeline } from './ActivityTimeline'
-export type { ActivityTimelineProps, ActivityTimelineItem } from './ActivityTimeline'
+export { ActivityTimeline, actorInitials, dayHeading } from './ActivityTimeline'
+export type {
+  ActivityTimelineProps,
+  ActivityTimelineItem,
+  ActivityTimelineActor,
+  ActivityTone,
+} from './ActivityTimeline'
+// The shared, filterable activity feed: filter bar + page-level composer over
+// any append-only event stream (startsim-768w.19.5).
+export * from './activity'
 export { QuickLogButtons } from './QuickLogButtons'
 export type { QuickLogButtonsProps, QuickLogAction } from './QuickLogButtons'
 export { LogActivityDialog } from './LogActivityDialog'

package/src/components/team/MembersSection.tsx

@@ -36,6 +36,8 @@ export interface MembersSectionProps {
   onChangeRole?: (userId: string, role: TeamRole) => void | Promise<void>
   onRemove?: (userId: string) => void | Promise<void>
   onResendInvite?: (userId: string) => void | Promise<void>
+  /** Suspend/restore a membership without deleting it (soft exit). */
+  onSetActive?: (userId: string, isActive: boolean) => void | Promise<void>
   /** When set, the invite dialog is rendered next to the heading. */
   onInvite?: (input: { email: string; teamId: string; role: TeamRole }) => Promise<InvitationLite | void>
   onInvited?: (invitation: InvitationLite | void) => void
@@ -43,8 +45,9 @@ export interface MembersSectionProps {
   availableRoles?: TeamRole[]
   inviteRoles?: TeamRole[]
   defaultInviteRole?: TeamRole
-  /** Header copy. `description` receives the member count. */
-  title?: string
+  /** Header copy. A node so a host can badge/icon the heading without
+   *  re-assembling the header row. `description` receives the member count. */
+  title?: React.ReactNode
   description?: (count: number) => React.ReactNode
   /** Set false when the host already renders a card header. */
   showHeader?: boolean
@@ -70,6 +73,7 @@ export function MembersSection({
   onChangeRole,
   onRemove,
   onResendInvite,
+  onSetActive,
   onInvite,
   onInvited,
   availableRoles,
@@ -123,6 +127,7 @@ export function MembersSection({
           onChangeRole={onChangeRole}
           onRemove={onRemove}
           onResendInvite={onResendInvite}
+          onSetActive={onSetActive}
           emptyState={emptyState}
           classNames={classNames?.table}
         />

package/src/components/team/MembersTable.tsx

@@ -46,6 +46,12 @@ export interface MembersTableProps {
    * only alongside `canManage` — an expired invite is otherwise a dead end.
    */
   onResendInvite?: (userId: string) => void | Promise<void>
+  /**
+   * Suspend or restore a membership without deleting it — the soft exit next to
+   * Remove. Offered only alongside `canManage`. Rows render Deactivate while
+   * active and Restore once `isActive === false`.
+   */
+  onSetActive?: (userId: string, isActive: boolean) => void | Promise<void>
   /** Custom empty-state slot. Defaults to a generic "No members yet" cell. */
   emptyState?: React.ReactNode
   /**
@@ -113,6 +119,7 @@ export function MembersTable({
   onChangeRole,
   onRemove,
   onResendInvite,
+  onSetActive,
   emptyState,
   showStatus,
   showLastActive,
@@ -244,6 +251,15 @@ export function MembersTable({
                         Resend invite
                       </button>
                     )}
+                    {onSetActive && (
+                      <button
+                        type="button"
+                        className={cls.deactivateButton}
+                        onClick={() => onSetActive(m.userId, m.isActive === false)}
+                      >
+                        {m.isActive === false ? 'Restore' : 'Deactivate'}
+                      </button>
+                    )}
                     {onRemove && (
                       <button
                         type="button"

package/src/components/team/__tests__/member-lifecycle.test.tsx

@@ -91,6 +91,33 @@ describe('MembersTable — invite lifecycle', () => {
     expect(screen.queryByRole('button', { name: /resend/i })).not.toBeInTheDocument()
   })
 
+  // The soft exit next to Remove. The table already paints a `deactivated`
+  // pill, but nothing could ever produce one: Remove (hard-delete) was the only
+  // way out of a foundry, so suspending someone meant destroying their role,
+  // attribution and history (startsim-768w.19.2).
+  it('offers deactivate on an active row and calls it with (userId, false)', () => {
+    const onSetActive = jest.fn()
+    render(<MembersTable members={rows} canManage onSetActive={onSetActive} />)
+    const buttons = screen.getAllByRole('button', { name: /deactivate/i })
+    expect(buttons).toHaveLength(3)
+    fireEvent.click(buttons[0])
+    expect(onSetActive).toHaveBeenCalledWith('u1', false)
+  })
+
+  it('offers restore — not deactivate — on an already deactivated row', () => {
+    const onSetActive = jest.fn()
+    const deactivated: MemberRow[] = [{ ...rows[1], isActive: false }]
+    render(<MembersTable members={deactivated} canManage onSetActive={onSetActive} />)
+    expect(screen.queryByRole('button', { name: /deactivate/i })).not.toBeInTheDocument()
+    fireEvent.click(screen.getByRole('button', { name: /restore/i }))
+    expect(onSetActive).toHaveBeenCalledWith('u2', true)
+  })
+
+  it('shows no deactivate affordance without canManage', () => {
+    render(<MembersTable members={rows} onSetActive={jest.fn()} />)
+    expect(screen.queryByRole('button', { name: /deactivate/i })).not.toBeInTheDocument()
+  })
+
   it('stays backwards compatible with rows that carry no lifecycle fields', () => {
     const legacy: MemberRow[] = [
       { id: 'm1', userId: 'u1', teamId: 't1', role: 'admin', joinedAt: '2026-01-01' },
@@ -118,6 +145,13 @@ describe('MembersSection — the page-level composer', () => {
     expect(onResendInvite).toHaveBeenCalledWith('u2')
   })
 
+  it('forwards a deactivate from the composer', () => {
+    const onSetActive = jest.fn()
+    render(<MembersSection members={rows} canManage onSetActive={onSetActive} />)
+    fireEvent.click(screen.getAllByRole('button', { name: /deactivate/i })[1])
+    expect(onSetActive).toHaveBeenCalledWith('u2', false)
+  })
+
   it('surfaces an error line when a mutation failed', () => {
     render(
       <MembersSection members={rows} canManage error="Couldn't update that member" />

package/src/components/team/members-table-default-class-names.ts

@@ -34,6 +34,8 @@ export interface MembersTableClassNames {
   invitedBy?: string
   /** Resend-invite action on a pending/expired row. */
   resendButton?: string
+  /** Deactivate / Restore action — the soft exit next to the hard Remove. */
+  deactivateButton?: string
 }
 
 export const MEMBERS_TABLE_DEFAULTS: Required<MembersTableClassNames> = {
@@ -70,4 +72,6 @@ export const MEMBERS_TABLE_DEFAULTS: Required<MembersTableClassNames> = {
   invitedBy: 'text-xs text-muted-foreground/80',
   resendButton:
     'rounded-md border border-border px-2 py-1 text-xs text-muted-foreground transition-colors hover:border-primary/40 hover:bg-primary/10 hover:text-primary disabled:opacity-50',
+  deactivateButton:
+    'rounded-md border border-border px-2 py-1 text-xs text-muted-foreground transition-colors hover:border-foreground/30 hover:bg-muted hover:text-foreground disabled:opacity-50',
 }