@columenlabs/lumen-ui 0.0.0-stage → 0.2.0

package/dist/view-model.js

@@ -0,0 +1,316 @@
+import { CONTAINS_KEY, whyBlank, } from '@columenlabs/lumen-ui-types/views';
+import { formulaFields } from './view-formulas.js';
+/** A chip's classes per tone, on the theme's tokens so light and dark both read. */
+export const CHIP_TONE = {
+    gain: 'border-transparent bg-gain/15 text-gain',
+    loss: 'border-transparent bg-loss/15 text-loss',
+    info: 'border-transparent bg-info/15 text-info',
+    muted: 'border-transparent bg-muted text-muted-foreground',
+    // Two neutral kinds side by side (backfill and incremental jobs), on the chart palette.
+    sky: 'border-transparent bg-chart-6/15 text-chart-6',
+    amber: 'border-transparent bg-chart-3/15 text-chart-3',
+};
+/** A run's state as a chip, the same on every app: done green, failed
+ *  red, running blue, queued, waiting and canceled grey. */
+export const RUN_STATE_TONE = {
+    done: 'gain',
+    failed: 'loss',
+    running: 'info',
+    queued: 'muted',
+    waiting: 'muted',
+    canceled: 'muted',
+};
+/** The formulas group: a view's own formula columns. */
+export const FORMULAS_GROUP = '_formulas';
+/** Whether a Summary counts the domain's cash rows: its own choice, else only when it covers
+ *  every row (no filter of its own, no linked chips). */
+export const summaryCash = (card, narrowed) => card.cash ?? !narrowed;
+/**
+ * What a row can open: the domain's own sub-groups, else every groupable field as a second level
+ * of grouping (the assistant frame tab groups by class, then by unit). The field's
+ * rows sharing a value fold into one rolled-up line that opens them.
+ */
+/** The picker's name: a domain's own sub-groups open rows, field ones group a second level. */
+export function subgroupLabel(domain) {
+    return domain.subgroups ? 'Each row opens' : 'Sub-group';
+}
+export function subgroupsOf(domain) {
+    if (domain.subgroups)
+        return domain.subgroups;
+    return domain.fields
+        .filter((f) => f.groupable)
+        .map((f) => ({
+        key: f.key,
+        label: f.label,
+        icon: f.icon,
+        under: (row) => {
+            const v = f.value(row);
+            return v === null || v === '' ? '—' : String(v);
+        },
+        always: true,
+    }));
+}
+/** The sub-group a view opens: its own pick, else the domain's first; null for none. */
+export function subgroupOf(domain, key) {
+    if (key === null)
+        return null;
+    // A view that says nothing opens the domain's first own sub-group; field ones only when picked.
+    if (key === undefined)
+        return domain.subgroups?.[0] ?? null;
+    return subgroupsOf(domain).find((s) => s.key === key) ?? null;
+}
+/** Rolls values up; nulls are skipped and an empty set is null (count is 0). */
+export function rollUp(values, agg) {
+    const have = values.filter((v) => v !== null);
+    if (agg === 'count')
+        return have.length;
+    if (agg === 'distinct')
+        return new Set(have.map(String)).size;
+    if (!have.length)
+        return null;
+    if (agg === 'first')
+        return have[0] ?? null;
+    if (agg === 'last')
+        return have[have.length - 1] ?? null;
+    const xs = have.filter((v) => typeof v === 'number');
+    if (!xs.length)
+        return null;
+    if (agg === 'sum')
+        return xs.reduce((a, b) => a + b, 0);
+    if (agg === 'mean')
+        return xs.reduce((a, b) => a + b, 0) / xs.length;
+    if (agg === 'min')
+        return Math.min(...xs);
+    return Math.max(...xs);
+}
+/** A view's chip fields and where each shows; views saved before chips existed have none. */
+export const chipsOf = (c) => c.chips ?? [];
+/** Whether views over the domain may add formula columns: every domain but one that opts out. */
+export const takesFormulas = (domain) => domain.formulas !== false;
+/** A view's formula columns; views saved before formulas existed have none. */
+export const formulasOf = (c) => c.formulas ?? [];
+/** Fields listed under Columns but not shown, for their Filter and Group ticks; views saved before it have none. */
+export const hiddenOf = (c) => c.hidden ?? [];
+/** A view's own tiles; views saved before tiles existed have none. */
+export const tilesOf = (c) => c.tiles ?? [];
+/**
+ * The fields a view shows: the domain's plus its formula columns (where the domain takes formulas),
+ * each number field in the format the view picked for it (`formats`).
+ */
+export function withViewFields(domain, c) {
+    const own = takesFormulas(domain) && formulasOf(c).length ? formulaFields(formulasOf(c)) : [];
+    const picked = c.formats ?? {};
+    const aggs = c.aggs ?? {};
+    if (!own.length && !Object.keys(picked).length && !Object.keys(aggs).length)
+        return domain;
+    const mine = new Set(own.map((f) => f.key));
+    // A text formula groups like any text field: each row's value is the formula
+    // over that row alone. One that reads group_sum or total_sum depends on the rows shown, so it
+    // cannot pick its own group.
+    const rowValue = (f) => (r) => computedOf(full, [r], null).value(f, r);
+    const fields = [...domain.fields, ...own].map((f) => {
+        if (f.format === 'text') {
+            if (!mine.has(f.key) || !f.formula)
+                return f;
+            if (/\b(group_sum|total_sum)\s*\(/.test(f.formula))
+                return { ...f, groupNote: 'Reads group_sum or total_sum, so it changes with the group.' };
+            const g = { ...f, groupable: true };
+            g.value = rowValue(g);
+            return g;
+        }
+        const format = picked[f.key];
+        const agg = mine.has(f.key) ? undefined : aggs[f.key];
+        const g = format ? { ...f, format } : f;
+        if (!agg)
+            return g;
+        return agg === 'none'
+            ? { ...g, noRollup: true }
+            : { ...g, aggregate: agg, rollFormula: false, noRollup: false };
+    });
+    const full = { ...domain, fields };
+    return full;
+}
+/** Whether group and Total rows show a value for the field. */
+export const rollsUp = (f) => !f.noRollup && (!!f.aggregate || !!f.rollFormula || f.share?.within === 'total');
+/** A number field's Total pick as Edit view shows it: the view's, else the field's own. */
+export function totalAggOf(f) {
+    if (f.noRollup)
+        return 'none';
+    if (f.aggregate)
+        return f.aggregate;
+    return f.rollFormula || f.share ? 'own' : 'none';
+}
+export const pick = (fields, keys) => keys.length
+    ? keys.map((k) => fields.find((f) => f.key === k)).filter((f) => !!f)
+    : fields;
+/** A field the filter box can offer: one marked filterable, or any number field. */
+export const canFilter = (f) => !!f.filterable || f.format !== 'text';
+/** The fields a view's filter box offers: the ones it lists, else every field marked filterable. */
+export const filterFieldsOf = (fields, keys) => keys.length ? pick(fields.filter(canFilter), keys) : fields.filter((f) => f.filterable);
+/** A view's filters with `tokens` as the ones it opens with, offering every field they use. */
+export function withSavedFilters(fields, filters, tokens) {
+    const offered = filterFieldsOf(fields, filters.fields).map((f) => f.key);
+    const missing = [...new Set(tokens.map((t) => t.key))].filter((k) => k !== CONTAINS_KEY && !offered.includes(k));
+    return { fields: missing.length ? [...offered, ...missing] : filters.fields, default: tokens };
+}
+export const label = (v) => (v === null ? '—' : String(v));
+/**
+ * Values over the shown rows: plain fields as read, share fields and formula columns worked out
+ * against the row's group (every shown row when not grouped) and every shown row.
+ */
+export function computedOf(domain, rows, groupBy) {
+    const byKey = new Map(domain.fields.map((f) => [f.key, f]));
+    // A formula reads fields by name (`symbol.price`, a formula's bare key); sums go by field key.
+    const byName = nameIndex(domain);
+    // An app's own `compute` may read its fields by bare key (`v('day_pl')`), the assistant's formulas by name.
+    const field = (k) => byName.get(k) ?? byKey.get(k);
+    const keyOf = (name) => field(name)?.key ?? '';
+    const groups = new Map();
+    if (groupBy)
+        for (const r of rows) {
+            const k = label(groupBy.value(r));
+            const g = groups.get(k);
+            if (g)
+                g.push(r);
+            else
+                groups.set(k, [r]);
+        }
+    const groupOf = (r) => (groupBy ? (groups.get(label(groupBy.value(r))) ?? []) : rows);
+    const sums = new Map();
+    const sum = (rs, key) => {
+        const m = sums.get(rs) ?? new Map();
+        sums.set(rs, m);
+        const f = byKey.get(key);
+        if (!m.has(key))
+            m.set(key, f ? rs.reduce((a, r) => a + num(value(f, r)), 0) : 0);
+        return m.get(key) ?? 0;
+    };
+    const pct = (part, whole) => (whole ? (part / whole) * 100 : null);
+    // A formula that reaches itself (a draft) reads null rather than looping.
+    const busy = new Set();
+    // Each worked-out value once per row: sorting, filtering, roll-ups and cells all read it.
+    const seen = new Map();
+    function value(f, r) {
+        if (!f.share && !f.compute)
+            return f.value(r);
+        const m = seen.get(f.key) ?? new Map();
+        seen.set(f.key, m);
+        if (m.has(r))
+            return m.get(r) ?? null;
+        const v = worked(f, r);
+        if (!busy.size)
+            m.set(r, v);
+        return v;
+    }
+    function worked(f, r) {
+        if (f.share) {
+            const base = byKey.get(f.share.of);
+            if (!base)
+                return null;
+            const whole = f.share.within === 'group' ? groupOf(r) : rows;
+            return pct(num(value(base, r)), sum(whole, f.share.of));
+        }
+        if (!f.compute)
+            return f.value(r);
+        if (busy.has(f.key))
+            return null;
+        busy.add(f.key);
+        try {
+            return f.compute(r, {
+                value: (k) => {
+                    const x = field(k);
+                    return x ? value(x, r) : null;
+                },
+                groupSum: (k) => sum(groupOf(r), keyOf(k)),
+                totalSum: (k) => sum(rows, keyOf(k)),
+            });
+        }
+        finally {
+            busy.delete(f.key);
+        }
+    }
+    /**
+     * A set of rows' roll-up: a `total` share is their share of every shown row,
+     * an `aggregate` rolls the rows' values, and a formula with none runs over the rows' roll-ups of
+     * its inputs (a ratio input is itself recomputed; an input with no roll-up reads null).
+     */
+    const rolled = new Map();
+    function roll(f, rs) {
+        if (f.noRollup)
+            return null;
+        if (f.aggregate)
+            return rollUp(rs.map((r) => value(f, r)), f.aggregate);
+        if (f.share)
+            return f.share.within === 'total' ? pct(sum(rs, f.share.of), sum(rows, f.share.of)) : null;
+        if (!f.rollFormula || !f.compute)
+            return null;
+        const m = rolled.get(rs) ?? new Map();
+        rolled.set(rs, m);
+        if (m.has(f.key))
+            return m.get(f.key) ?? null;
+        if (busy.has(f.key))
+            return null;
+        busy.add(f.key);
+        try {
+            const v = f.compute(rs[0], {
+                value: (k) => {
+                    const x = field(k);
+                    return x ? roll(x, rs) : null;
+                },
+                groupSum: (k) => sum(rs, keyOf(k)),
+                totalSum: (k) => sum(rows, keyOf(k)),
+            });
+            m.set(f.key, v);
+            return v;
+        }
+        finally {
+            busy.delete(f.key);
+        }
+    }
+    return { value, roll };
+}
+/**
+ * Each formula column that is blank on some of the rows, and why (a blank
+ * column said nothing): `blank on 24 of 24 rows: dew_point_f is empty`. The editor shows it under
+ * the formula, and the assistant reads it after each card move.
+ */
+export function formulaBlanks(domain, rows) {
+    const out = new Map();
+    const formulas = domain.fields.filter((f) => f.formula && f.compute);
+    if (!formulas.length || !rows.length)
+        return out;
+    const c = computedOf(domain, rows, null);
+    const byName = nameIndex(domain);
+    const read = (k, r) => {
+        const f = byName.get(k);
+        return f ? c.value(f, r) : null;
+    };
+    const total = (k) => rows.reduce((a, r) => a + num(read(k, r)), 0);
+    for (const f of formulas) {
+        const blank = rows.filter((r) => {
+            const v = c.value(f, r);
+            return v === null || v === '';
+        });
+        const first = blank[0];
+        if (first === undefined)
+            continue;
+        const why = whyBlank(f.formula ?? '', {
+            value: (k) => read(k, first),
+            groupSum: total,
+            totalSum: total,
+        });
+        out.set(f.key, `blank on ${blank.length} of ${rows.length} rows${why ? `: ${why}` : ''}`);
+    }
+    return out;
+}
+export const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
+/** A field's group id: its own, else the domain's first group ('' when the domain has none). */
+export const groupOf = (domain, f) => f.group ?? domain.groups?.[0]?.id ?? '';
+/**
+ * A field's name in formulas: the one it was made with (a join's
+ * `symbol.price`, a frame's `frame.<frame>.<column>`, a linked domain's `tax_lots.count`), a
+ * formula's bare key, else `<domain>.<key>` for the domain's own.
+ */
+export const fieldName = (domain, f) => f.name ?? (groupOf(domain, f) === FORMULAS_GROUP ? f.key : `${domain.id}.${f.key}`);
+/** Each field by its name in formulas. */
+export const nameIndex = (domain) => new Map(domain.fields.map((f) => [fieldName(domain, f), f]));

package/dist/whats-new.d.ts

@@ -0,0 +1,3 @@
+export declare function WhatsNew({ api }: {
+    api: string;
+}): import("react").JSX.Element | null;

package/dist/whats-new.js

@@ -0,0 +1,53 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// What's new (in Lumen for
+// every app): the version in the status bar opens the release notes, newest
+// first, each release's Key takeaways only. An app turns it on with LumenShell's `releases`, its
+// releases API (`GET ?limit=&before=` answering `{releases}`), which leaves out what the person can't
+// open; a host that answers 404 (self-host an app) keeps the version hidden.
+import { useInfiniteQuery } from '@tanstack/react-query';
+import { useState } from 'react';
+import Markdown from 'react-markdown';
+import { DrawerSection } from './drawer-section.js';
+import { LumenDrawer } from './lumen-drawer.js';
+import { usePrefs } from './prefs.js';
+import { Badge } from './ui/badge.js';
+import { Button } from './ui/button.js';
+/** Each takeaway's type chips, in this order, in the shell's status tones. */
+const TYPES = {
+    feature: { label: 'Feature', variant: 'info' },
+    improvement: { label: 'Improvement', variant: 'success' },
+    fix: { label: 'Fix', variant: 'warning' },
+    performance: { label: 'Performance', variant: 'secondary' },
+    security: { label: 'Security', variant: 'destructive' },
+};
+const ORDER = Object.keys(TYPES);
+const PAGE = 20;
+async function page(api, before) {
+    const q = new URLSearchParams({ limit: String(PAGE) });
+    if (before)
+        q.set('before', before);
+    const r = await fetch(`${api}?${q}`, { credentials: 'include' });
+    if (r.status === 404)
+        return null;
+    if (!r.ok)
+        throw new Error(`releases ${r.status}`);
+    return (await r.json()).releases;
+}
+export function WhatsNew({ api }) {
+    const [open, setOpen] = useState(false);
+    const { timeZone } = usePrefs();
+    const q = useInfiniteQuery({
+        queryKey: ['edgeshell', 'releases', api],
+        queryFn: ({ pageParam }) => page(api, pageParam),
+        initialPageParam: null,
+        getNextPageParam: (last) => last && last.length === PAGE ? last.at(-1)?.published_at : undefined,
+        staleTime: 30 * 60_000,
+        retry: false,
+    });
+    const releases = q.data?.pages.flatMap((p) => p ?? []) ?? [];
+    const latest = releases[0];
+    if (!latest)
+        return null;
+    const day = (at) => new Date(at).toLocaleDateString('en-US', { month: 'short', day: 'numeric', timeZone });
+    return (_jsxs(_Fragment, { children: [_jsx(Button, { variant: "ghost", size: "sm", className: "num h-6 px-1.5 text-muted-foreground text-xs", onClick: () => setOpen(true), title: "What's new", children: latest.tag }), _jsx(LumenDrawer, { open: open, onClose: () => setOpen(false), title: "What's new", description: "Key takeaways of each release, newest first", footerStart: `${releases.length} releases`, footer: _jsxs(_Fragment, { children: [q.hasNextPage && (_jsx(Button, { variant: "outline", size: "sm", disabled: q.isFetchingNextPage, onClick: () => q.fetchNextPage(), children: "Show more" })), _jsx(Button, { size: "sm", onClick: () => setOpen(false), children: "Close" })] }), children: releases.map((r, i) => (_jsx(DrawerSection, { title: r.tag, hint: day(r.published_at), defaultOpen: i === 0, children: r.takeaways.length ? (_jsx("ul", { className: "list-disc space-y-1.5 py-1 pr-1 pl-5 text-sm leading-relaxed [&_strong]:font-semibold", children: r.takeaways.map((t) => (_jsxs("li", { children: [t.types.length > 0 && (_jsx("span", { className: "mr-1.5 inline-flex flex-wrap gap-1 align-middle", children: ORDER.filter((k) => t.types.includes(k)).map((k) => (_jsx(Badge, { variant: TYPES[k].variant, className: "px-1.5", children: TYPES[k].label }, k))) })), _jsx(Markdown, { allowedElements: ['strong', 'em', 'code'], unwrapDisallowed: true, children: t.text })] }, t.text))) })) : (_jsx("p", { className: "py-1 pl-1 text-muted-foreground text-sm", children: "Nothing new for you in this one." })) }, r.tag))) })] }));
+}

package/dist/widget-controls.d.ts

@@ -0,0 +1,9 @@
+import { type ViewCard } from '@columenlabs/lumen-ui-types/views';
+type Controls = ViewCard['controls'];
+export declare function WidgetControlsEditor({ kind, style, controls, onChange, }: {
+    kind: ViewCard['kind'];
+    style?: string;
+    controls: Controls;
+    onChange: (controls: Controls) => void;
+}): import("react").JSX.Element | null;
+export {};

package/dist/widget-controls.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// Edit widget ▸ Controls: one switch per control the widget's kind has, each starting from the kind's
+// default. A switch back to the default drops the key, so a saved widget keeps only its choices.
+import { CONTROL_DEFAULTS, WIDGET_CONTROL_NAMES, controlOn, viewCardKinds, } from '@columenlabs/lumen-ui-types/views';
+import { useAssistantName } from './assistant-context.js';
+import { Label } from './ui/label.js';
+import { Switch } from './ui/switch.js';
+export function WidgetControlsEditor({ kind, style, controls, onChange, }) {
+    const type = viewCardKinds.includes(kind) ? kind : null;
+    const assistant = useAssistantName('assistant');
+    if (!type)
+        return null;
+    const keys = Object.keys(CONTROL_DEFAULTS[type]);
+    const set = (k, on) => {
+        const next = { ...controls };
+        if (on === CONTROL_DEFAULTS[type][k])
+            delete next[k];
+        else
+            next[k] = on;
+        onChange(Object.keys(next).length ? next : undefined);
+    };
+    return (_jsx("div", { className: "grid grid-cols-2 gap-x-4 gap-y-2 sm:grid-cols-3", children: keys.map((k) => {
+            const id = `control-${k}`;
+            return (_jsxs("div", { className: "flex items-center gap-2", children: [_jsx(Switch, { id: id, size: "sm", checked: controlOn({ kind, style, controls }, k), onCheckedChange: (on) => set(k, on) }), _jsx(Label, { htmlFor: id, className: "font-normal", children: k === 'ask' ? `Ask ${assistant}` : WIDGET_CONTROL_NAMES[k] })] }, k));
+        }) }));
+}