@gaia-ai/addon-gaia-ui 0.9.2 → 0.11.0

package/dist/src/Entity/team/Screen/team-users.d.ts

@@ -0,0 +1,76 @@
+import type { VNode } from '@opentui/core';
+import { AsyncScreen } from '../../../Screen/async-screen.js';
+import type { FullScreenChrome } from '../../../Screen/full-screen.js';
+import type { ScreenContext } from '../../../Screen/screen.js';
+import { type UserListRow } from '../../user/Data/users.js';
+/** The crew as rows, or the reason there are none. */
+interface CrewList {
+    rows: UserListRow[];
+    /**
+     * Present only when the crew could not be ESTABLISHED — a refused membership
+     * read, a team that did not resolve, a refused user collection. Never set for
+     * a crew that is genuinely empty: that is `rows: []`, and the table's own
+     * `emptyMessage` says it.
+     */
+    error?: string;
+    /**
+     * No crew was named at all, which is NOT a failure — see
+     * {@link TeamUsersScreen.load}. Kept apart from `error` so the two are not
+     * reported in the same words: one says a read went wrong, the other says
+     * nothing has been chosen yet.
+     */
+    unscoped?: boolean;
+}
+/**
+ * ONE crew's people — the team level's `Users` tab.
+ *
+ * `fallback` points at the crews list: Escape lands where the operator came from,
+ * which after the ruling is Teams and no longer a root Users tab.
+ */
+export declare class TeamUsersScreen extends AsyncScreen<CrewList> {
+    readonly frameId = "team-users";
+    topTab(): {
+        readonly level: "team";
+        readonly tab: "users";
+    };
+    reload(context: ScreenContext): void;
+    /**
+     * `id: 'users'` — the id GAIA-377's user-level screens already fall back to.
+     *
+     * There is exactly ONE users list now and this is it, so it keeps the id rather
+     * than taking a new one and stranding three `fallback: { routeId: 'users' }`
+     * declarations on a route that no longer exists (`Router.navigate` throws
+     * `unknown route` for one of those, on Escape, with no history). Those three
+     * carry no `teamId`, which is what {@link TeamUsersScreen.load} answers for.
+     */
+    static readonly route: {
+        id: string;
+        path: string;
+        tab: {
+            id: string;
+            label: string;
+            scope: string;
+            order: number;
+        };
+        fallback: {
+            routeId: string;
+        };
+    };
+    readonly id: string;
+    private readonly cursor;
+    get selectedIndex(): number;
+    set selectedIndex(value: number);
+    get rows(): readonly UserListRow[];
+    /** Whether the ready value is a CREW at all, rather than a notice about one. */
+    private get drawable();
+    protected load(context: ScreenContext): Promise<CrewList>;
+    protected renderLoading(): string[];
+    protected renderReady(result: CrewList): VNode;
+    protected chrome(context: ScreenContext): FullScreenChrome;
+    protected actions(): import("../../../Component/footer-actions/index.js").ActionItem[];
+    activate(index: number, context: ScreenContext): boolean;
+    select(index: number, context: ScreenContext): boolean;
+    handleInput(input: string, context: ScreenContext): boolean;
+    reset(): void;
+}
+export {};

package/dist/src/Entity/team/Screen/team-users.js

@@ -0,0 +1,215 @@
+import { actionItem } from '../../../Component/footer-actions/index.js';
+import { sectionRowNode, } from '../../../Component/section-list/index.js';
+import { ListCursor } from '../../../lib/cursor.js';
+import { columnNode } from '../../../lib/vnode.js';
+import { AsyncScreen } from '../../../Screen/async-screen.js';
+import { listRowIds, listTableTree } from '../../collection.js';
+import { closedPerRun, formatClosedPerRun, loadStatistics, } from '../../statistics/Data/statistics.js';
+import { listUsers, TEAM_MEMBER_TABLE, } from '../../user/Data/users.js';
+import { listTeamMemberIds } from '../Data/members.js';
+import { TeamsScreen } from './teams-screen.js';
+// GAIA-391 AC4 (second round) — the crew's people, on the TEAM level.
+//
+// This is where GAIA-377's `users` root tab went, by operator ruling: a person is
+// reached through the crew they are in (Teams → one crew → Users → one person),
+// so the users LIST is team-scoped and the user LEVEL below it is untouched.
+//
+// Three reads, because the answer needs three things and no two of them come
+// from one resource:
+//
+//   - WHO is in the crew        `og_membership` (`Data/members.ts`)
+//   - what those people are     the `user` collection — labels and uids
+//   - what they have done        the team-scoped statistics' `by_user`
+//
+// The composition lives HERE rather than in `Data/`, and that is the boundary
+// rule rather than taste: `Entity/*/Data/` may not reach into another slice
+// (`tests/boundary.test.ts` G2), and `user` and `statistics` are two other
+// slices. A screen crossing slices is ordinary; a data module doing it would need
+// two new `ALLOWED_CROSS_SLICE` entries.
+/** Rows that are plain text, keyed under one name: a failure state. */
+const plainRows = (key, lines) => lines.map((text, index) => ({ key: `${key}-${index}`, text, bold: false }));
+/** What this screen says when it was opened without a crew to open. */
+const NO_CREW = 'Open a crew from Teams to see who is in it.';
+/** One member's row: identity from the collection, figures from the document. */
+function rowOf(user, statistics) {
+    const monthOf = (rows) => (rows ?? []).find((row) => row.id === user.id)?.month ?? 0;
+    const tickets30d = statistics === null ? 0 : monthOf(statistics.tickets.byUser);
+    const runs30d = statistics === null ? 0 : monthOf(statistics.runs.byUser);
+    return {
+        id: user.id,
+        label: user.label,
+        tickets30d,
+        runs30d,
+        closedPerRun30d: formatClosedPerRun(closedPerRun({ day: 0, week: 0, month: tickets30d }, { day: 0, week: 0, month: runs30d }).month),
+    };
+}
+/**
+ * ONE crew's people — the team level's `Users` tab.
+ *
+ * `fallback` points at the crews list: Escape lands where the operator came from,
+ * which after the ruling is Teams and no longer a root Users tab.
+ */
+export class TeamUsersScreen extends AsyncScreen {
+    frameId = 'team-users';
+    topTab() {
+        return { level: 'team', tab: 'users' };
+    }
+    reload(context) {
+        this.retry(context);
+    }
+    /**
+     * `id: 'users'` — the id GAIA-377's user-level screens already fall back to.
+     *
+     * There is exactly ONE users list now and this is it, so it keeps the id rather
+     * than taking a new one and stranding three `fallback: { routeId: 'users' }`
+     * declarations on a route that no longer exists (`Router.navigate` throws
+     * `unknown route` for one of those, on Escape, with no history). Those three
+     * carry no `teamId`, which is what {@link TeamUsersScreen.load} answers for.
+     */
+    static route = {
+        id: 'users',
+        path: '/teams/:teamId/users',
+        tab: { id: 'users', label: 'Users', scope: 'team', order: 20 },
+        fallback: { routeId: TeamsScreen.route.id },
+    };
+    id = TeamUsersScreen.route.id;
+    cursor = new ListCursor();
+    get selectedIndex() {
+        return this.cursor.index;
+    }
+    set selectedIndex(value) {
+        this.cursor.index = value;
+    }
+    get rows() {
+        return this.drawable ? (this.readyValue?.rows ?? []) : [];
+    }
+    /** Whether the ready value is a CREW at all, rather than a notice about one. */
+    get drawable() {
+        const result = this.readyValue;
+        return (result !== undefined && result.error === undefined && !result.unscoped);
+    }
+    async load(context) {
+        if (!context.services)
+            throw new Error('Team users requires services');
+        const teamId = context.params?.teamId;
+        // Reached without a crew — the shape the user level's `fallback` produces,
+        // because a person's route carries `userId` and never a `teamId`. A notice
+        // rather than a throw: there is nothing wrong here, there is just no crew
+        // chosen yet, and the operator needs to be told where to choose one.
+        if (!teamId)
+            return { rows: [], unscoped: true };
+        const client = context.services.client;
+        const [members, users, statistics] = await Promise.all([
+            listTeamMemberIds(client, teamId),
+            listUsers(client),
+            loadStatistics(client, undefined, undefined, teamId),
+        ]);
+        // Either failure leaves the crew unknown, and an unknown crew must not be
+        // drawn as an empty one: without the memberships there is nobody to keep,
+        // and without the collection there is nobody to name.
+        if (members.ids === null)
+            return {
+                rows: [],
+                // `listTeamMemberIds` always names a reason beside a null crew, but the
+                // type does not promise it — so a missing one becomes a stated unknown
+                // rather than a screen with a blank explanation.
+                error: members.error ?? 'the crew could not be established',
+            };
+        if (users.error !== undefined)
+            return { rows: [], error: users.error };
+        const crew = new Set(members.ids);
+        const figures = statistics.kind === 'ok' ? statistics.statistics : null;
+        return {
+            rows: users.rows
+                // Anonymous (0) and Drupal uid 1 are never operator rows — the rule the
+                // root list carried, kept where the list now lives.
+                .filter((user) => crew.has(user.id) && user.uid !== 0 && user.uid !== 1)
+                .map((user) => rowOf(user, figures)),
+        };
+    }
+    renderLoading() {
+        return ['Loading crew…'];
+    }
+    renderReady(result) {
+        const notice = (key, lines) => columnNode('team-users', ...plainRows(key, lines).map((row) => sectionRowNode('team-users', row)));
+        if (result.unscoped)
+            return notice('team-users-unscoped', [NO_CREW]);
+        if (result.error !== undefined)
+            return notice('team-users-error', [
+                'Could not read the crew.',
+                '',
+                result.error,
+            ]);
+        return listTableTree(TEAM_MEMBER_TABLE, result.rows, undefined, {
+            selectedIndex: this.selectedIndex,
+        });
+    }
+    chrome(context) {
+        const rows = this.rows;
+        const result = this.readyValue;
+        const name = context.params?.teamName ?? context.params?.teamId ?? 'team';
+        if (result?.unscoped)
+            return {
+                selectable: 0,
+                selectedIndex: 0,
+                rowIds: [],
+                title: 'GAIA crew',
+                meta: 'no crew chosen',
+            };
+        if (result?.error !== undefined)
+            return {
+                selectable: 0,
+                selectedIndex: 0,
+                rowIds: [],
+                title: `${name} · users`,
+                meta: 'crew unavailable',
+            };
+        return {
+            selectable: rows.length,
+            selectedIndex: this.selectedIndex,
+            rowIds: listRowIds(TEAM_MEMBER_TABLE, rows),
+            title: `${name} · users`,
+            meta: `${rows.length} member(s)`,
+        };
+    }
+    actions() {
+        return [
+            actionItem('team-users-enter', 'Enter', 'open'),
+            actionItem('team-users-tab', 'Tab', 'tabs'),
+        ];
+    }
+    activate(index, context) {
+        const row = this.rows[index];
+        if (!row || !context.navigate)
+            return false;
+        context.navigate('user.overview', {
+            userId: row.id,
+            userName: row.label,
+        });
+        return true;
+    }
+    select(index, context) {
+        if (index < 0 || index >= this.rows.length)
+            return false;
+        this.selectedIndex = index;
+        context.requestDraw();
+        return true;
+    }
+    handleInput(input, context) {
+        if (super.handleInput(input, context))
+            return true;
+        if (this.readyValue === undefined)
+            return false;
+        if (this.cursor.handle(input, this.rows.length)) {
+            context.requestDraw();
+            return true;
+        }
+        if (input === 'enter')
+            return this.activate(this.selectedIndex, context);
+        return false;
+    }
+    reset() {
+        this.cursor.reset();
+        super.reset();
+    }
+}

package/dist/src/Entity/team/Screen/teams-screen.d.ts

@@ -0,0 +1,116 @@
+import type { VNode } from '@opentui/core';
+import { AsyncScreen } from '../../../Screen/async-screen.js';
+import type { FullScreenChrome } from '../../../Screen/full-screen.js';
+import type { ScreenContext } from '../../../Screen/screen.js';
+import { type StatisticsResult } from '../../statistics/Data/statistics.js';
+import { type ResolvedTeam } from '../Data/team.js';
+import { type TeamListResult, type TeamListRow } from '../Data/teams.js';
+/**
+ * The Teams list — a ROOT tab, which is what makes it reachable.
+ *
+ * Root rather than project level, by the argument GAIA-232 used for Conductors: a
+ * team cuts ACROSS customer projects (it is the level that does, per GAIA-321), so
+ * "which crews are there" must be answerable without first choosing a project.
+ *
+ * `order: 50` puts it last, after Users. People, then the crews they are in — and
+ * appending rather than inserting keeps every exact-bar assertion in the vitest
+ * and Bun suites reading one unchanged prefix.
+ */
+export declare class TeamsScreen extends AsyncScreen<TeamListResult> {
+    readonly frameId = "teams";
+    topTab(): {
+        readonly level: "root";
+        readonly tab: "teams";
+    };
+    reload(context: ScreenContext): void;
+    static readonly route: {
+        id: string;
+        path: string;
+        tab: {
+            id: string;
+            label: string;
+            scope: string;
+            order: number;
+        };
+    };
+    readonly id: string;
+    private readonly cursor;
+    get selectedIndex(): number;
+    set selectedIndex(value: number);
+    saveState(): {
+        selectedIndex: number;
+    };
+    restoreState(token: unknown): void;
+    get rows(): readonly TeamListRow[];
+    protected load(context: ScreenContext): Promise<TeamListResult>;
+    protected renderLoading(): string[];
+    protected renderReady(result: TeamListResult): VNode;
+    protected chrome(context: ScreenContext): FullScreenChrome;
+    protected actions(): import("../../../Component/footer-actions/index.js").ActionItem[];
+    activate(index: number, context: ScreenContext): boolean;
+    select(index: number, context: ScreenContext): boolean;
+    handleInput(input: string, context: ScreenContext): boolean;
+    reset(): void;
+}
+/**
+ * What one team's page is made of: who the crew is, and what it did.
+ *
+ * Carried as one value because the screen draws both, and because keeping the
+ * resolved identity beside the figures is what stops the header from falling back
+ * to a uuid when only the statistics read failed.
+ */
+interface TeamOverview {
+    team: ResolvedTeam;
+    statistics: StatisticsResult;
+}
+/**
+ * ONE team's report: the crew's identity plus the team-scoped statistics, read
+ * through the `?team_id=` the control plane has served since GAIA-321.
+ *
+ * `fallback` points at the list, so Escape from a deep link lands somewhere real
+ * rather than on the default route — the rule `UserOverviewScreen` follows.
+ */
+export declare class TeamOverviewScreen extends AsyncScreen<TeamOverview> {
+    readonly frameId = "team-overview";
+    /**
+     * GAIA-391 AC4 (second round) — the team level's landing tab.
+     *
+     * The earlier round declared no `tab` here and argued a team owns no LEVEL
+     * because "there is nothing under it to tab between". The operator's ruling is
+     * the opposite: the users level is under it, so the crew has a bar of its own
+     * (Overview · Users) and this screen is its first entry.
+     */
+    topTab(): {
+        readonly level: "team";
+        readonly tab: "overview";
+    };
+    reload(context: ScreenContext): void;
+    static readonly route: {
+        id: string;
+        path: string;
+        tab: {
+            id: string;
+            label: string;
+            scope: string;
+            order: number;
+        };
+        fallback: {
+            routeId: string;
+        };
+    };
+    readonly id: string;
+    /**
+     * The crew's identity AND its figures, read in parallel.
+     *
+     * Two reads because they answer two questions and fail independently: a
+     * control plane that cannot serve statistics still knows who is in the team,
+     * and the header must not fall back to a uuid because a count timed out.
+     */
+    protected load(context: ScreenContext): Promise<TeamOverview>;
+    protected renderLoading(): string[];
+    private readyRows;
+    protected renderReady(result: TeamOverview): VNode;
+    protected chrome(context: ScreenContext): FullScreenChrome;
+    protected actions(): import("../../../Component/footer-actions/index.js").ActionItem[];
+}
+export {};