shutro-erp 0.3.5 → 0.3.7

package/dist/approvals/module.js

@@ -0,0 +1,473 @@
+/**
+ * The data layer of the Approvals app (RFC 0025). The engine's models (`approval.policy`, `approval.level`,
+ * `approval.request`, `approval.vote`) are in `shutro-erp/permissions`; this module adds **generic requests** (step 4):
+ * categories (Business trip, Payment, Equipment…) saying which fields a request has and what it leads to, and the
+ * requests themselves, decided through the category's own policy — a policy on `approval.ask` whose condition is the
+ * category, made when the category's first request is submitted (or from the category), its levels edited like any
+ * policy's. On approval, the category's **outcome** runs: nothing here; apps add theirs (`approvals_purchase`: a
+ * request for quotation from the lines).
+ */
+import { contactsShutro } from '../contacts/index.js';
+import { approvalGuard, decidersOf, permissionsShutro, requestApprovals, requestsOf, } from '../permissions/index.js';
+import { orm } from '../server/orm.js';
+import { check, compute, defineModel, defineModule, f, method, record, records, } from './.kosh/bindings.js';
+const ALL = ['read', 'write', 'create', 'unlink', 'export', 'import'];
+const me = { $env: 'uid' };
+const ZERO = orm.toDecimal(0);
+/** Whether a request of the category shows a field, and whether it must be filled. */
+const PRESENCE = { none: 'Not asked', optional: 'Optional', required: 'Required' };
+/** The presence fields of a category, by the request field they govern. */
+export const ASKED = {
+    amount: 'askAmount',
+    period: 'askPeriod',
+    partner: 'askPartner',
+    location: 'askLocation',
+    quantity: 'askQuantity',
+    lines: 'askLines',
+    attachment: 'askAttachment',
+};
+const asksOf = (env, ids) => env.model('approval.ask').browse(ids);
+/** The outcomes the installed apps offer, by code (`approval.ask.outcomes()`, which they extend). */
+export async function outcomesOffered(env) {
+    return asksOf(env, []).outcomes();
+}
+/** A kind of request, its fields and its outcome. */
+export const ApprovalCategory = defineModel('approval.category', {
+    label: 'Request category',
+    recName: 'name',
+    order: ['sequence asc', 'name asc'],
+    archivable: true,
+    access: { 'base.user': ['read'], 'approvals.manager': ALL },
+    fields: {
+        name: f.char({ required: true, translate: true }),
+        code: f.char({ size: 32 }),
+        /** Empty: every company's. */
+        company: f.many2one('res.company', { ondelete: 'cascade' }),
+        sequence: f.integer({ required: true, default: 10 }),
+        description: f.text({ translate: true, help: 'Shown to whoever asks: what to give and why.' }),
+        askAmount: f.selection(PRESENCE, {
+            required: true,
+            default: 'optional',
+            label: 'Amount',
+            help: 'Whether a request of this category asks for an amount: not asked, optional or required.',
+        }),
+        askPeriod: f.selection(PRESENCE, {
+            required: true,
+            default: 'none',
+            label: 'Period',
+            help: 'Whether a request of this category asks for a period, from and until: not asked, optional or required.',
+        }),
+        askPartner: f.selection(PRESENCE, {
+            required: true,
+            default: 'none',
+            label: 'Contact',
+            help: 'Whether a request of this category asks for a contact: not asked, optional or required.',
+        }),
+        askLocation: f.selection(PRESENCE, {
+            required: true,
+            default: 'none',
+            label: 'Location',
+            help: 'Whether a request of this category asks for a location: not asked, optional or required.',
+        }),
+        askQuantity: f.selection(PRESENCE, {
+            required: true,
+            default: 'none',
+            label: 'Quantity',
+            help: 'Whether a request of this category asks for a quantity: not asked, optional or required.',
+        }),
+        askLines: f.selection(PRESENCE, {
+            required: true,
+            default: 'none',
+            label: 'Lines',
+            help: 'Whether a request of this category asks for lines with quantities and prices: not asked, optional or required.',
+        }),
+        askAttachment: f.selection(PRESENCE, {
+            required: true,
+            default: 'none',
+            label: 'Attachment',
+            help: 'Required: the request is submitted only with a file attached.',
+        }),
+        /** What an approved request leads to: one of the outcomes the installed apps offer (empty: nothing). */
+        outcome: f.char({
+            size: 32,
+            label: 'On approval',
+            help: 'Empty: nothing more. `purchase`: a request for quotation from the lines (with Purchase).',
+        }),
+        /** Its policy on requests (made when the first request is submitted; its levels are edited there). */
+        policy: f.many2one('approval.policy', { ondelete: 'set null', label: 'Approval policy' }),
+        requestCount: f.integer({
+            label: 'Requests',
+            ...compute('approval.category', 'requestCount', ['asks'], (categories) => {
+                for (const c of categories)
+                    c.requestCount = c.asks.length;
+            }),
+        }),
+        asks: f.one2many('approval.ask', 'category'),
+    },
+    sqlConstraints: {
+        oneCode: { unique: ['company', 'code'], message: 'Another category has this code.' },
+    },
+    constraints: {
+        // An outcome is one an installed app offers.
+        knownOutcome: {
+            ...check('approval.category', ['outcome'], async (categories) => {
+                const offered = await outcomesOffered(categories.env);
+                return categories
+                    .filter((c) => c.outcome !== null && c.outcome !== '' && !offered.has(c.outcome))
+                    .map((c) => c.id);
+            }),
+            message: 'No installed app offers this outcome.',
+        },
+    },
+});
+const STATES = {
+    draft: 'Draft',
+    submitted: 'Waiting for approval',
+    approved: 'Approved',
+    refused: 'Refused',
+    cancelled: 'Cancelled',
+};
+/** A request of a category: what is asked, by whom, with its fields, lines and outcome. */
+export const ApprovalAsk = defineModel('approval.ask', {
+    label: 'Request',
+    recName: 'title',
+    order: ['id desc'],
+    companyScoped: { required: true },
+    tracking: ['state', 'amount', 'dateFrom', 'dateTo'],
+    access: { 'base.user': ['read', 'write', 'create'], 'approvals.manager': ALL },
+    rules: {
+        // One's own requests (deciders see them through the inbox, as the system); changed while a draft or refused.
+        own: { groups: ['base.user'], perms: ['read'], domain: { requester: me } },
+        // Who may decide it reads it (named when it is submitted).
+        deciding: { groups: ['base.user'], perms: ['read'], domain: { deciders: { any: { id: me } } } },
+        ownDraft: {
+            groups: ['base.user'],
+            perms: ['write', 'create'],
+            domain: { requester: me, state: { in: ['draft', 'refused'] } },
+        },
+        managers: {
+            groups: ['approvals.manager'],
+            perms: ['read', 'write', 'create', 'unlink'],
+            domain: {},
+        },
+    },
+    fields: {
+        name: f.char({ readonly: true, sequence: 'approval.ask', label: 'Number' }),
+        category: f.many2one('approval.category', { required: true, ondelete: 'restrict' }),
+        title: f.char({ required: true, label: 'What for' }),
+        requester: f.many2one('res.users', {
+            required: true,
+            default: (env) => env.userId,
+            ondelete: 'restrict',
+            label: 'Asked by',
+        }),
+        description: f.text(),
+        amount: f.decimal({ scale: 2 }),
+        dateFrom: f.date({ label: 'From' }),
+        dateTo: f.date({ label: 'Until' }),
+        partner: f.many2one('res.partner', { ondelete: 'set null', label: 'Contact' }),
+        location: f.char(),
+        quantity: f.decimal({ scale: 3 }),
+        lines: f.one2many('approval.ask.line', 'ask'),
+        linesTotal: f.decimal({
+            scale: 2,
+            store: true,
+            label: 'Lines total',
+            help: 'The sum of the lines’ subtotals.',
+            ...compute('approval.ask', 'linesTotal', ['lines.subtotal'], (asks) => {
+                for (const a of asks)
+                    a.linesTotal = [...a.lines].reduce((s, l) => s.plus(l.subtotal ?? 0), ZERO);
+            }),
+        }),
+        /** The document the outcome made (`purchase.order` 12…), shown on the request. */
+        resultModel: f.char({ label: 'Made' }),
+        resultId: f.integer(),
+        resultName: f.char({ label: 'Made document' }),
+        approvedAt: f.datetime({ label: 'Approved on' }),
+        /** What the category asks for (the form shows and marks the fields by them). */
+        askAmount: f.selection(PRESENCE, {
+            store: true,
+            help: 'Whether this request asks for an amount, as its category says.',
+            ...compute('approval.ask', 'askAmount', ['category.askAmount'], (asks) => {
+                for (const a of asks)
+                    a.askAmount = a.category?.askAmount ?? 'none';
+            }),
+        }),
+        askPeriod: f.selection(PRESENCE, {
+            store: true,
+            help: 'Whether this request asks for a period, as its category says.',
+            ...compute('approval.ask', 'askPeriod', ['category.askPeriod'], (asks) => {
+                for (const a of asks)
+                    a.askPeriod = a.category?.askPeriod ?? 'none';
+            }),
+        }),
+        askPartner: f.selection(PRESENCE, {
+            store: true,
+            help: 'Whether this request asks for a contact, as its category says.',
+            ...compute('approval.ask', 'askPartner', ['category.askPartner'], (asks) => {
+                for (const a of asks)
+                    a.askPartner = a.category?.askPartner ?? 'none';
+            }),
+        }),
+        askLocation: f.selection(PRESENCE, {
+            store: true,
+            help: 'Whether this request asks for a location, as its category says.',
+            ...compute('approval.ask', 'askLocation', ['category.askLocation'], (asks) => {
+                for (const a of asks)
+                    a.askLocation = a.category?.askLocation ?? 'none';
+            }),
+        }),
+        askQuantity: f.selection(PRESENCE, {
+            store: true,
+            help: 'Whether this request asks for a quantity, as its category says.',
+            ...compute('approval.ask', 'askQuantity', ['category.askQuantity'], (asks) => {
+                for (const a of asks)
+                    a.askQuantity = a.category?.askQuantity ?? 'none';
+            }),
+        }),
+        askLines: f.selection(PRESENCE, {
+            store: true,
+            help: 'Whether this request asks for lines, as its category says.',
+            ...compute('approval.ask', 'askLines', ['category.askLines'], (asks) => {
+                for (const a of asks)
+                    a.askLines = a.category?.askLines ?? 'none';
+            }),
+        }),
+        askAttachment: f.selection(PRESENCE, {
+            store: true,
+            help: 'Whether this request asks for an attached file, as its category says.',
+            ...compute('approval.ask', 'askAttachment', ['category.askAttachment'], (asks) => {
+                for (const a of asks)
+                    a.askAttachment = a.category?.askAttachment ?? 'none';
+            }),
+        }),
+        /** Who may decide it: its levels' approvers and their delegates, when it was submitted. */
+        deciders: f.many2many('res.users', {
+            relation: 'approval_ask_decider_rel',
+            label: 'Decided by',
+        }),
+        state: f.state({
+            states: STATES,
+            initial: 'draft',
+            help: 'Submitted to the category’s approvers; approved, its outcome runs.',
+            transitions: {
+                submit: {
+                    from: ['draft', 'refused'],
+                    to: 'submitted',
+                    guard: records('approval.ask', async (asks) => missingFields(asks.env, asks.ids)),
+                    message: 'Fill in what the category asks for (and attach a file when it is required).',
+                    before: records('approval.ask', async (asks) => {
+                        // The category's policy exists before the engine looks for it.
+                        const env = asks.env;
+                        const categories = new Set();
+                        for (const a of await asks.load(['category']))
+                            categories.add(a.category.id);
+                        await env.asSuperuser({ reason: 'request category policy' }, async (su) => {
+                            for (const c of categories)
+                                await ensureCategoryPolicy(su, c);
+                        });
+                    }),
+                    after: records('approval.ask', async (asks) => {
+                        await requestApprovals(asks);
+                        const env = asks.env;
+                        const today = new Date().toISOString().slice(0, 10);
+                        await env.asSuperuser({ reason: 'request deciders' }, async (su) => {
+                            for (const id of asks.ids) {
+                                const people = new Set();
+                                for (const r of await requestsOf(su, 'approval.ask', id))
+                                    if (r.state === 'pending')
+                                        for (const u of await decidersOf(su, r, today))
+                                            people.add(u);
+                                await su
+                                    .model('approval.ask')
+                                    .browse([id])
+                                    .write({ deciders: { set: [...people] } });
+                            }
+                        });
+                    }),
+                },
+                approve: {
+                    from: ['submitted'],
+                    to: 'approved',
+                    guard: records('approval.ask', (asks) => approvalGuard(asks)),
+                    message: 'Waiting for approvals.',
+                    // Run as the system by the engine: the outcome of each request's category.
+                    after: records('approval.ask', async (asks) => {
+                        const env = asks.env;
+                        await env
+                            .model('approval.ask')
+                            .browse(asks.ids)
+                            .write({ approvedAt: new Date() });
+                        await asksOf(env, asks.ids).runOutcome();
+                        for (const id of asks.ids)
+                            await env.emit('approval.ask.approved', { id });
+                    }),
+                },
+                refuse: { from: ['submitted'], to: 'refused' },
+                redraft: { from: ['submitted', 'refused', 'cancelled'], to: 'draft' },
+                cancel: { from: ['draft', 'submitted', 'refused'], to: 'cancelled' },
+            },
+        }),
+    },
+    sqlConstraints: {
+        amountPositive: {
+            check: orm.sql `amount IS NULL OR amount >= 0`,
+            message: 'An amount is not negative.',
+        },
+        period: {
+            check: orm.sql `date_from IS NULL OR date_to IS NULL OR date_to >= date_from`,
+            message: 'A period ends on or after it starts.',
+        },
+    },
+    methods: {
+        /** The outcomes the installed apps offer, by code. None here; apps add theirs. */
+        outcomes: method('approval.ask', async () => new Map()),
+        /**
+         * Runs the outcome of each approved request's category (as the system). Nothing here; an app that offers an
+         * outcome makes its document for the requests of that outcome and writes `resultModel` / `resultId`.
+         */
+        runOutcome: method('approval.ask', async () => undefined),
+    },
+});
+/** A line of a request: what, how many, at what price. Apps add theirs (a product, with Purchase). */
+export const ApprovalAskLine = defineModel('approval.ask.line', {
+    label: 'Request line',
+    order: ['ask asc', 'sequence asc', 'id asc'],
+    access: { 'base.user': ['read', 'write', 'create', 'unlink'], 'approvals.manager': ALL },
+    fields: {
+        ask: f.many2one('approval.ask', { required: true, ondelete: 'cascade' }),
+        sequence: f.integer({ required: true, default: 10 }),
+        name: f.char({ required: true, label: 'Description' }),
+        quantity: f.decimal({ scale: 3, required: true, default: '1' }),
+        priceUnit: f.decimal({ scale: 2, required: true, default: '0', label: 'Unit price' }),
+        subtotal: f.decimal({
+            scale: 2,
+            store: true,
+            help: 'The quantity times the unit price.',
+            ...compute('approval.ask.line', 'subtotal', ['quantity', 'priceUnit'], (lines) => {
+                for (const l of lines)
+                    l.subtotal = l.quantity.times(l.priceUnit).toDecimalPlaces(2);
+            }),
+        }),
+    },
+    sqlConstraints: {
+        positive: {
+            check: orm.sql `quantity > 0 AND price_unit >= 0`,
+            message: 'A line asks for a positive quantity at a price not below zero.',
+        },
+    },
+});
+/** The requests (of `ids`) missing a field their category requires. */
+export async function missingFields(env, ids) {
+    const bad = [];
+    for (const a of await env
+        .model('approval.ask')
+        .browse(ids)
+        .load({ category: true, lines: ['id'] })) {
+        const c = a.category;
+        const required = (key) => c[ASKED[key]] === 'required';
+        const empty = (required('amount') && a.amount === null) ||
+            (required('period') && (a.dateFrom === null || a.dateTo === null)) ||
+            (required('partner') && a.partner === null) ||
+            (required('location') && (a.location ?? '').trim() === '') ||
+            (required('quantity') && a.quantity === null) ||
+            (required('lines') && a.lines.length === 0);
+        if (empty) {
+            bad.push(a.id);
+            continue;
+        }
+        if (required('attachment')) {
+            const files = await env.asSuperuser({ reason: 'request attachments' }, (su) => su.model('storage.attachment').search({
+                where: { resModel: 'approval.ask', resId: a.id },
+                limit: 1,
+            }));
+            if (files.ids.length === 0)
+                bad.push(a.id);
+        }
+    }
+    return bad;
+}
+/**
+ * The category's policy on requests (as the system): made when missing — its condition the category, one level
+ * decided by the requester's manager (an Approvals manager without one) —, kept as it is when it exists.
+ */
+export async function ensureCategoryPolicy(su, category) {
+    const [c] = await su
+        .model('approval.category')
+        .browse([category])
+        .load(['name', 'policy', 'company']);
+    if (c === undefined)
+        throw new Error(`approval.category ${category} is missing`);
+    if (c.policy !== null)
+        return c.policy.id;
+    const policy = await su.model('approval.policy').create([
+        {
+            name: `Requests: ${String(c.name)}`,
+            targetModel: 'approval.ask',
+            condition: { category },
+            company: c.company?.id ?? null,
+            onApproved: 'approve',
+            onRejected: 'refuse',
+            onSentBack: 'redraft',
+            onWithdrawn: 'redraft',
+        },
+    ]);
+    const id = policy.ids[0];
+    await su.model('approval.level').create([
+        {
+            policy: id,
+            sequence: 10,
+            name: 'Manager',
+            approverKind: 'manager',
+            approverRole: 'approvals.manager',
+        },
+    ]);
+    await su
+        .model('approval.category')
+        .browse([category])
+        .write({ policy: id });
+    return id;
+}
+export const approvalsShutro = defineModule({
+    name: 'approvals',
+    version: '0.2.0',
+    depends: [permissionsShutro, contactsShutro],
+    sequences: [orm.defineSequence({ code: 'approval.ask', prefix: 'REQ-', padding: 5 })],
+    models: [ApprovalCategory, ApprovalAsk, ApprovalAskLine],
+    // The categories every installation starts with (theirs to change afterwards).
+    data: [
+        record('approval.category', 'category_trip', {
+            name: 'Business trip',
+            code: 'TRIP',
+            sequence: 10,
+            description: 'Where, when and the estimated cost.',
+            askAmount: 'required',
+            askPeriod: 'required',
+            askLocation: 'required',
+        }, { noupdate: true }),
+        record('approval.category', 'category_payment', {
+            name: 'Payment',
+            code: 'PAY',
+            sequence: 20,
+            description: 'To whom, how much and why; attach the invoice or quotation.',
+            askAmount: 'required',
+            askPartner: 'required',
+            askAttachment: 'required',
+        }, { noupdate: true }),
+        record('approval.category', 'category_purchase', {
+            name: 'Purchase request',
+            code: 'PR',
+            sequence: 30,
+            description: 'What to buy: the lines, and the vendor when known.',
+            askAmount: 'none',
+            askPartner: 'optional',
+            askLines: 'required',
+        }, { noupdate: true }),
+        record('approval.category', 'category_general', {
+            name: 'General',
+            code: 'GEN',
+            sequence: 90,
+            description: 'Anything else that needs a decision.',
+        }, { noupdate: true }),
+    ],
+});

package/dist/approvals/web/Config.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The policy and category editor's helpers (RFC 0025 step 4), node components of their forms:
+ * - `approvals.PolicyPreview`: which of the last 50 records each level of the policy would have asked about, so a
+ *   condition is checked before anyone submits; and "Sync waiting requests" (RFC 0027 §2.6);
+ * - `approvals.CategoryPolicy`: a request category's approval policy — made on demand when it has none, opened when
+ *   it has one (its levels are edited there).
+ * Shown to Approvals managers (the server decides).
+ */
+import { type NodeComponentProps } from '../../ui/index.js';
+import { type ReactElement } from 'react';
+export declare function PolicyPreview({ api, record, version }: NodeComponentProps): ReactElement | null;
+export declare function CategoryPolicy({ api, record, reload }: NodeComponentProps): ReactElement | null;

package/dist/approvals/web/Config.js

@@ -0,0 +1,60 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The policy and category editor's helpers (RFC 0025 step 4), node components of their forms:
+ * - `approvals.PolicyPreview`: which of the last 50 records each level of the policy would have asked about, so a
+ *   condition is checked before anyone submits; and "Sync waiting requests" (RFC 0027 §2.6);
+ * - `approvals.CategoryPolicy`: a request category's approval policy — made on demand when it has none, opened when
+ *   it has one (its levels are edited there).
+ * Shown to Approvals managers (the server decides).
+ */
+import { Alert, Button } from '../../ui/index.js';
+import { useMutation, useQuery } from '@tanstack/react-query';
+import { useState } from 'react';
+import { useTranslation } from 'react-i18next';
+export function PolicyPreview({ api, record, version }) {
+    const { t } = useTranslation('approvals');
+    const id = typeof record?.id === 'number' ? record.id : null;
+    const preview = useQuery({
+        queryKey: ['approvals.preview', id, version],
+        enabled: id !== null,
+        queryFn: () => api.call('GET', `/api/v1/approvals/policies/${String(id)}/preview`),
+    });
+    const [synced, setSynced] = useState(null);
+    const sync = useMutation({
+        mutationFn: () => api.call('POST', `/api/v1/approvals/policies/${String(id)}/sync`, {}),
+        onSuccess: (r) => setSynced(r.synced),
+    });
+    if (id === null || preview.isError)
+        return null;
+    if (preview.isPending)
+        return _jsx("p", { className: "text-sm text-muted-foreground", children: t('loading') });
+    const { records, levels, covers } = preview.data;
+    return (_jsxs("section", { "aria-label": t('preview.title'), className: "grid gap-1 rounded-md border border-border p-3", children: [_jsx("h3", { className: "text-sm font-semibold", children: t('preview.title') }), covers === undefined ? null : (_jsx("p", { className: "text-xs", children: covers.all
+                    ? t('preview.everyCompany')
+                    : covers.companies.length === 0
+                        ? t('preview.noCompany')
+                        : t('preview.covers', { companies: covers.companies.join(', ') }) })), _jsx("p", { className: "text-xs text-muted-foreground", children: t('preview.explain', { count: records }) }), _jsx("ul", { className: "grid gap-1 text-sm", children: levels.map((l) => (_jsxs("li", { className: "flex items-center justify-between gap-2", children: [_jsx("span", { children: l.name }), _jsx("span", { className: "tabular-nums text-muted-foreground", children: t('preview.matched', { matched: l.matched.length, count: records }) })] }, l.id))) }), _jsxs("div", { className: "flex flex-wrap items-center gap-2 pt-1", children: [_jsx(Button, { size: "sm", variant: "secondary", disabled: sync.isPending, onClick: () => sync.mutate(), children: t('preview.sync') }), synced === null ? null : (_jsx("span", { role: "status", className: "text-xs text-muted-foreground", children: t('preview.synced', { count: synced }) }))] })] }));
+}
+export function CategoryPolicy({ api, record, reload }) {
+    const { t } = useTranslation('approvals');
+    const [error, setError] = useState(null);
+    const id = typeof record?.id === 'number' ? record.id : null;
+    const make = useMutation({
+        mutationFn: () => api.call('POST', `/api/v1/approvals/categories/${String(id)}/policy`, {}),
+        onSuccess: (r) => {
+            setError(null);
+            reload();
+            window.location.assign(`/approvals/a/approvals.action_policies/${r.policy}`);
+        },
+        onError: (e) => setError(e.message),
+    });
+    if (id === null)
+        return null;
+    const policy = record?.['policy'];
+    const policyId = typeof policy === 'number'
+        ? policy
+        : typeof policy === 'object' && policy !== null
+            ? Number(policy.id)
+            : null;
+    return (_jsxs("div", { className: "grid gap-2", children: [error === null ? null : _jsx(Alert, { tone: "danger", children: error }), policyId === null ? (_jsx("div", { children: _jsx(Button, { busy: make.isPending, onClick: () => make.mutate(), children: t('category.setUp') }) })) : (_jsx("a", { className: "text-sm text-primary underline", href: `/approvals/a/approvals.action_policies/${policyId}`, children: t('category.editLevels') }))] }));
+}

package/dist/approvals/web/History.d.ts

@@ -0,0 +1,4 @@
+/** What I decided (RFC 0025 §3.1): each decision with the record, my answer, my comment and when. */
+import { type PageProps } from '../../ui/index.js';
+import type { ReactElement } from 'react';
+export declare function History({ api }: PageProps): ReactElement;

package/dist/approvals/web/History.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/** What I decided (RFC 0025 §3.1): each decision with the record, my answer, my comment and when. */
+import { Badge, EmptyState, useKosh } from '../../ui/index.js';
+import { useQuery } from '@tanstack/react-query';
+import { useTranslation } from 'react-i18next';
+import { cardsQuery, TONE } from './shared.js';
+export function History({ api }) {
+    const { t } = useTranslation('approvals');
+    const { format } = useKosh();
+    const cards = useQuery(cardsQuery(api, 'history'));
+    const rows = cards.data ?? [];
+    return (_jsxs("div", { className: "grid gap-4 p-4", children: [_jsx("h1", { className: "text-xl font-semibold", children: t('history.title') }), rows.length === 0 ? (_jsx(EmptyState, { title: cards.isLoading ? t('loading') : t('history.empty') })) : (_jsx("div", { className: "overflow-x-auto", children: _jsxs("table", { className: "w-full text-sm", children: [_jsx("thead", { className: "bg-muted", children: _jsxs("tr", { children: [_jsx("th", { className: "px-2 py-1 text-start", children: t('history.record') }), _jsx("th", { className: "px-2 py-1 text-start", children: t('history.level') }), _jsx("th", { className: "px-2 py-1 text-start", children: t('history.answer') }), _jsx("th", { className: "px-2 py-1 text-start", children: t('history.comment') }), _jsx("th", { className: "px-2 py-1 text-start", children: t('history.when') })] }) }), _jsx("tbody", { children: rows.map((c) => (_jsxs("tr", { className: "border-b", children: [_jsxs("td", { className: "px-2 py-1", children: [_jsx("span", { className: "font-medium", children: c.record.name }), ' ', _jsx("span", { className: "text-muted-foreground", children: c.record.label })] }), _jsx("td", { className: "px-2 py-1", children: c.levelName }), _jsx("td", { className: "px-2 py-1", children: _jsx(Badge, { tone: TONE[c.state], children: t(`state.${c.state}`) }) }), _jsx("td", { className: "px-2 py-1", children: c.comment ?? '' }), _jsx("td", { className: "px-2 py-1", children: c.decidedAt === null ? '' : format.datetime(c.decidedAt) })] }, c.id))) })] }) }))] }));
+}

package/dist/approvals/web/Inbox.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The Approvals inbox (RFC 0025 §3.1): what waits for me, as cards — the record and its app, who asked and how long
+ * ago, every level of the round as a step with its votes —, decided one by one (approve, reject or send back, with a
+ * comment; a reason is needed for the last two) or many at once. Keyboard: J / K move, A approves, R rejects, X
+ * selects. The server decides who may decide what; this page shows and sends.
+ */
+import { type PageProps } from '../../ui/index.js';
+import { type ReactElement } from 'react';
+export declare function Inbox({ api }: PageProps): ReactElement;