@cube-nl/dmp-sdk 1.1.0-rc.1 → 1.1.0-rc.2

package/dist/ui/blocks/table.js

@@ -1,4 +1,5 @@
 import { CARD_CSS, PeriodFollower, requiredAttr, wholeAttr } from '../aggregate-block.js';
+import { AuthorError } from '../author-error.js';
 import { exampleBadge, stateFor } from '../block.js';
 import { downloadCsv, toCsv } from '../csv.js';
 import { clear, h } from '../dom.js';
@@ -20,8 +21,8 @@ th,td{padding:.5rem .75rem;text-align:start;border-bottom:1px solid var(--cube-c
 th{font-weight:600;white-space:nowrap}
 th button{min-height:auto;padding:0;border:0;background:none;color:inherit;font:inherit;font-weight:600}
 th button:hover{background:none;text-decoration:underline}
-th[aria-sort=ascending] button::after{content:" ▲";content:" ▲"/""}
-th[aria-sort=descending] button::after{content:" ▼";content:" ▼"/""}
+th[aria-sort=ascending] .arrow::after{content:" ▲"}
+th[aria-sort=descending] .arrow::after{content:" ▼"}
 .num{text-align:end;white-space:nowrap}
 tbody tr{cursor:pointer}
 tbody tr:hover{background:var(--cube-color-primary-subtle)}
@@ -51,13 +52,19 @@ function merge(target, field, value) {
     const current = target[field];
     target[field] = isOps(current) && isOps(value) ? { ...current, ...value } : value;
 }
-/** -1, 0 or 1; numbers as numbers, anything else (ISO dates) as text. */
+/** -1, 0 or 1; numbers (also a number written as text) as numbers, anything else (ISO dates) as text. */
 function compare(a, b) {
-    if (typeof a === 'number' && typeof b === 'number')
-        return Math.sign(a - b);
-    const x = String(a);
-    const y = String(b);
-    return x < y ? -1 : x > y ? 1 : 0;
+    const x = toNumber(a);
+    const y = toNumber(b);
+    if (x !== null && y !== null)
+        return Math.sign(x - y);
+    const p = String(a);
+    const q = String(b);
+    return p < q ? -1 : p > q ? 1 : 0;
+}
+/** Whether a base value leaves a "contains" (ilike) control nothing: a fixed value, or an ilike of its own. */
+function textFixed(base) {
+    return base !== undefined && (!isOps(base) || 'ilike' in base);
 }
 /**
  * What the controls ask for, within the base (the `filter` attribute and the followed period): a bound takes the
@@ -112,6 +119,8 @@ export function tableBlock(Base, scope) {
         chosen = null;
         shownIds = null;
         updates = 0;
+        /** The builder warnings given already: a reload does not repeat them. */
+        warned = new Set();
         shownFields() {
             return this.context?.columns.map((column) => column.name) ?? [];
         }
@@ -200,7 +209,7 @@ export function tableBlock(Base, scope) {
                 named.push(['search', search]);
             for (const [attribute, field] of named) {
                 if (!schema.filterable.includes(field)) {
-                    throw new TypeError(NL.invalid.notFilterable(this.localName, attribute, field));
+                    throw new AuthorError(NL.invalid.notFilterable(this.localName, attribute, field));
                 }
             }
         }
@@ -213,7 +222,7 @@ export function tableBlock(Base, scope) {
                 return doc.querySelector(selector);
             }
             catch {
-                throw new TypeError(NL.invalid.selector(this.localName, 'detail', selector));
+                throw new AuthorError(NL.invalid.selector(this.localName, 'detail', selector));
             }
         }
         /** The list query of the controls as they are now. */
@@ -289,7 +298,7 @@ export function tableBlock(Base, scope) {
             catch (error) {
                 if (run !== this.updates || error?.name === 'AbortError')
                     return;
-                this.showRowsState(fetchState(error));
+                this.showRowsState(stateFor(error));
             }
         }
         later(resetPage) {
@@ -309,11 +318,13 @@ export function tableBlock(Base, scope) {
             const tools = [];
             const searchField = this.attr('search')?.trim() ?? '';
             if (searchField !== '') {
+                if (textFixed(context.base[searchField]))
+                    this.warnFixed('search', searchField);
                 const input = h(doc, 'input', { type: 'search' });
                 tools.push(this.control(input, SEARCH, NL.search, true));
             }
             for (const column of filterColumns)
-                tools.push(this.filterControl(column));
+                tools.push(this.filterControl(column, context.base[column.name]));
             if (this.flag('export')) {
                 this.exportButton = h(doc, 'button', {
                     type: 'button',
@@ -344,7 +355,9 @@ export function tableBlock(Base, scope) {
             const thead = h(doc, 'thead', {}, h(doc, 'tr', {}, ...context.columns.map((column) => {
                 const sortable = schema?.sortable.includes(column.name) === true;
                 const th = h(doc, 'th', { scope: 'col', class: NUMERIC.includes(column.format) ? 'num' : null }, sortable
-                    ? h(doc, 'button', { type: 'button', onclick: () => this.sortOn(column.name) }, column.label)
+                    ? h(doc, 'button', { type: 'button', onclick: () => this.sortOn(column.name) }, column.label, 
+                    // The arrow is decoration: aria-sort already says the direction.
+                    h(doc, 'span', { class: 'arrow', 'aria-hidden': 'true' }))
                     : column.label, ...(this.exampleField(context.session, context.resource, column.name)
                     ? [' ', exampleBadge(doc)]
                     : []));
@@ -376,13 +389,28 @@ export function tableBlock(Base, scope) {
             });
             return h(doc, 'div', { class: 'control' }, h(doc, 'label', { for: id }, label), control);
         }
-        /** The control for one `filters` field, and its part of the query. */
-        filterControl(column) {
+        /**
+         * The `filter` attribute keeps what it fixes (the base wins), so a control on such a field changes nothing:
+         * the builder is told once, in the console.
+         */
+        warnFixed(attribute, field) {
+            const name = this.localName;
+            const message = `${name}: filter already fixes "${field}", so ${attribute} on it changes nothing.`;
+            if (this.warned.has(message))
+                return;
+            this.warned.add(message);
+            console.warn(message);
+        }
+        /** The control for one `filters` field, and its part of the query; `base` is what the base holds for it. */
+        filterControl(column, base) {
             const name = column.name;
             const value = (key) => this.values.get(key)?.trim() ?? '';
             const choices = choicesFor(column);
             const boolean = choices === null && column.format === 'boolean';
             if (choices !== null || boolean) {
+                // `within` keeps an operator base over the chosen value.
+                if (isOps(base))
+                    this.warnFixed('filters', name);
                 const options = choices ?? [{ value: 'true', label: NL.yes }, { value: 'false', label: NL.no }];
                 const select = h(doc, 'select', {}, h(doc, 'option', { value: '' }, NL.all), ...options.map((option) => h(doc, 'option', { value: option.value }, option.label)));
                 const numeric = NUMERIC.includes(column.format);
@@ -396,6 +424,8 @@ export function tableBlock(Base, scope) {
             }
             const dates = column.format === 'date' || column.format === 'datetime';
             if (!dates && !NUMERIC.includes(column.format)) {
+                if (textFixed(base))
+                    this.warnFixed('filters', name);
                 this.parts.set(name, () => (value(name) === '' ? null : { ilike: `%${value(name)}%` }));
                 return this.control(h(doc, 'input', { type: 'text' }), name, column.label, true);
             }
@@ -472,6 +502,10 @@ export function tableBlock(Base, scope) {
                 return;
             }
             const tbody = h(doc, 'tbody', {}, ...response.data.map((row) => this.row(context, row)));
+            // Roving tabindex: one row is in the Tab order, the chosen one if shown, else the first.
+            if (tbody.querySelector('tr[tabindex="0"]') === null) {
+                tbody.firstElementChild?.setAttribute('tabindex', '0');
+            }
             table.replaceChild(tbody, table.querySelector('tbody'));
             frame.appendChild(table);
             if (this.pager !== null)
@@ -500,16 +534,28 @@ export function tableBlock(Base, scope) {
             const example = (column) => this.exampleField(context.session, context.resource, column.name);
             const chosen = this.chosen !== null && String(row.id ?? '') === this.chosen;
             const tr = h(doc, 'tr', {
-                tabindex: '0',
+                tabindex: chosen ? '0' : '-1',
                 class: chosen ? 'chosen' : null,
                 'aria-current': chosen ? 'true' : null,
                 onclick: choose,
                 onkeydown: ((event) => {
-                    if (event.key !== 'Enter' && event.key !== ' ')
+                    if (event.altKey || event.ctrlKey || event.metaKey)
+                        return;
+                    if (event.key === 'Enter' || event.key === ' ') {
+                        // Space would scroll the page.
+                        event.preventDefault();
+                        choose();
+                        return;
+                    }
+                    const target = this.rowFor(tr, event.key);
+                    if (target === undefined)
                         return;
-                    // Space would scroll the page.
                     event.preventDefault();
-                    choose();
+                    if (target === null)
+                        return;
+                    tr.setAttribute('tabindex', '-1');
+                    target.setAttribute('tabindex', '0');
+                    target.focus();
                 }),
             }, ...context.columns.map((column) => {
                 const classes = [NUMERIC.includes(column.format) && 'num', example(column) && 'example'];
@@ -517,11 +563,28 @@ export function tableBlock(Base, scope) {
             }));
             return tr;
         }
+        /** The row an arrow, Home or End key moves to: null at an end, undefined for any other key. */
+        rowFor(tr, key) {
+            const body = tr.parentElement;
+            switch (key) {
+                case 'ArrowDown':
+                    return tr.nextElementSibling;
+                case 'ArrowUp':
+                    return tr.previousElementSibling;
+                case 'Home':
+                    return body?.firstElementChild;
+                case 'End':
+                    return body?.lastElementChild;
+                default:
+                    return undefined;
+            }
+        }
         select(context, row, tr) {
             const id = row.id ?? null;
             this.chosen = id === null ? null : String(id);
             for (const other of Array.from(tr.parentElement?.children ?? [])) {
                 other.classList.toggle('chosen', other === tr);
+                other.setAttribute('tabindex', other === tr ? '0' : '-1');
                 if (other === tr)
                     other.setAttribute('aria-current', 'true');
                 else
@@ -601,7 +664,3 @@ export function tableBlock(Base, scope) {
     return CubeTable;
 }
 let controlIds = 0;
-/** The state for a failed request: the browser's own (English) text of a network failure is never shown. */
-function fetchState(error) {
-    return error instanceof TypeError ? { kind: 'error', detail: null } : stateFor(error);
-}

package/dist/ui/dom.js

@@ -1,4 +1,5 @@
 // The UI builds every node through these helpers: no HTML string is ever parsed, so row data cannot become markup.
+import { AuthorError } from './author-error.js';
 import { NL } from './texts.js';
 const SVG_NS = 'http://www.w3.org/2000/svg';
 /**
@@ -37,7 +38,7 @@ export function svg(doc, tag, attrs = {}, ...children) {
 function refuseUnsafe(name, setsAttribute) {
     const lower = name.toLowerCase();
     if (lower === 'style' || (setsAttribute && lower.startsWith('on'))) {
-        throw new TypeError(NL.invalid.attribute(name));
+        throw new AuthorError(NL.invalid.attribute(name));
     }
 }
 export function clear(node) {

package/dist/ui/format.js

@@ -1,3 +1,4 @@
+import { AuthorError } from './author-error.js';
 import { NL } from './texts.js';
 /** The formats that hold a number: right-aligned, read and written as numbers. */
 export const NUMERIC_FORMATS = ['number', 'integer', 'currency', 'percent'];
@@ -132,7 +133,7 @@ export function parseMeasure(measure) {
     const m = MEASURE.exec(measure.trim());
     const fn = m?.[1];
     if (fn === undefined || (fn !== 'count' && m?.[2] === undefined)) {
-        throw new TypeError(NL.invalid.measure(measure));
+        throw new AuthorError(NL.invalid.measure(measure));
     }
     return { fn, field: m?.[2] ?? null };
 }
@@ -142,7 +143,7 @@ export function parseDimension(by) {
     const field = m?.[1];
     const truncation = m?.[2];
     if (field === undefined || (truncation !== undefined && !TRUNCATIONS.includes(truncation))) {
-        throw new TypeError(NL.invalid.dimension(by));
+        throw new AuthorError(NL.invalid.dimension(by));
     }
     return { field, truncation: truncation ?? null };
 }

package/dist/ui/manifest.js

@@ -628,11 +628,13 @@ export const BLOCK_SPECS = {
         },
         children: ['cube-input', 'cube-result'],
         properties: {
-            formula: '(values) => results, a synchronous function: an async one gives a Promise, which shows "—". '
+            formula: '(values) => results, a synchronous function: an async one is refused with an error. '
                 + 'Set from a script, never as an attribute: a string is refused, nothing is '
                 + 'evaluated. values has each cube-input by name: a number, a text, a boolean, or null when empty '
                 + 'or invalid. Return an object by cube-result name, or one number or text when there is a single '
-                + 'cube-result. null, undefined, NaN and Infinity show "—".',
+                + 'cube-result. null, undefined, NaN and Infinity show "—"; an object as the value of a number, '
+                + 'integer, currency or percent result shows "—" like NaN. Names of cube-inputs, and of '
+                + 'cube-results, must be unique.',
             values: 'Read-only: the values the formula got last.',
             results: 'Read-only: the results shown last, by cube-result name (null for "—").',
         },
@@ -792,7 +794,7 @@ export const BLOCK_SPECS = {
                 type: 'string',
                 required: false,
                 summary: 'The order of the cards in each column: a field that is sortable on the resource, with - in '
-                    + 'front for descending.',
+                    + 'front for descending; a moved card takes its place in that order; without sort it goes on top.',
                 example: '-due_on',
             },
             filter: {

package/dist/ui/query.js

@@ -1,3 +1,4 @@
+import { AuthorError } from './author-error.js';
 import { parseDimension, isoDate, parseLocalDate } from './format.js';
 import { NL } from './texts.js';
 const LOOKUP = /^([a-z][a-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)$/;
@@ -15,7 +16,7 @@ export function blockFilter(el) {
         filter = null;
     }
     if (filter === null || typeof filter !== 'object' || Array.isArray(filter)) {
-        throw new TypeError(NL.invalid.json(el.localName, 'filter'));
+        throw new AuthorError(NL.invalid.json(el.localName, 'filter'));
     }
     return filter;
 }
@@ -28,7 +29,7 @@ function isPeriod(value) {
 export function periodFilter(field, range) {
     const to = parseLocalDate(range.to);
     if (to === null)
-        throw new TypeError(NL.invalid.periodEnd(range.to));
+        throw new AuthorError(NL.invalid.periodEnd(range.to));
     to.setDate(to.getDate() + 1);
     return { [field]: { gte: range.from, lt: isoDate(to) } };
 }
@@ -42,12 +43,12 @@ export async function resolvePeriodSource(host, selector) {
     const source = host.ownerDocument.querySelector(selector);
     const registry = (host.ownerDocument.defaultView ?? window).customElements;
     if (source === null || registry.get(source.localName) === undefined) {
-        throw new TypeError(NL.invalid.periodSource(selector));
+        throw new AuthorError(NL.invalid.periodSource(selector));
     }
     const picker = source;
     await picker.updateComplete;
     if (!isPeriod(picker.value))
-        throw new TypeError(NL.invalid.periodSource(selector));
+        throw new AuthorError(NL.invalid.periodSource(selector));
     return picker;
 }
 /** The date field a period filters on: explicit, else the field of a truncated `by`. */
@@ -59,7 +60,7 @@ export function dateFieldFor(dateField, by, tag) {
         if (dimension.truncation !== null)
             return dimension.field;
     }
-    throw new TypeError(NL.invalid.dateField(tag));
+    throw new AuthorError(NL.invalid.dateField(tag));
 }
 /**
  * Labels for ids from `<resource>.<field>`: one list per 200 ids. An id without a row, or whose list was refused
@@ -70,7 +71,7 @@ export async function lookupLabels(session, lookup, ids, signal) {
     const resource = match?.[1];
     const field = match?.[2];
     if (resource === undefined || field === undefined)
-        throw new TypeError(NL.invalid.lookup(lookup));
+        throw new AuthorError(NL.invalid.lookup(lookup));
     const unique = [...new Set(ids.filter((id) => id !== null && id !== undefined).map((id) => id))];
     const labels = new Map();
     for (let start = 0; start < unique.length; start += LOOKUP_CHUNK) {

package/dist/ui/texts.d.ts

@@ -107,6 +107,16 @@ export declare const NL: {
             readonly 'ja/nee': "Ja/nee";
         };
     };
+    readonly trial: {
+        readonly banner: (time: string | null, leest: readonly string[]) => string;
+        readonly expired: "Deze proefversie is verlopen. Vraag in je gesprek om een nieuwe.";
+        readonly closed: "Deze proefversie is gesloten.";
+        readonly refreshing: "Nieuwe versie wordt geladen…";
+        readonly wider: "Er is een nieuwe versie die meer gegevens leest.";
+        readonly load: "Laden";
+        readonly elsewhere: "Laad de pagina opnieuw.";
+        readonly reload: "Opnieuw laden";
+    };
     readonly invalid: {
         readonly json: (tag: string, name: string) => string;
         readonly number: (tag: string, name: string) => string;
@@ -116,6 +126,8 @@ export declare const NL: {
         readonly value: (tag: string, name: string, value: string) => string;
         readonly formula: "cube-calc: formula moet een functie zijn";
         readonly calcSingle: "cube-calc: formula gaf één waarde, maar er zijn meer cube-results; geef een object met hun namen";
+        readonly duplicate: (tag: string, value: string) => string;
+        readonly calcAsync: "cube-calc: formula gaf een Promise; geef de uitkomst direct terug, niet async";
         readonly dateField: (tag: string) => string;
         readonly compare: (tag: string) => string;
         readonly periodSource: (selector: string) => string;

package/dist/ui/texts.js

@@ -100,6 +100,20 @@ export const NL = {
         none: 'Er ontbreekt niets: alles in dit voorstel bestaat al in de DMP.',
         types: { tekst: 'Tekst', getal: 'Getal', bedrag: 'Bedrag', datum: 'Datum', keuze: 'Keuze', 'ja/nee': 'Ja/nee' },
     },
+    trial: {
+        banner: (time, leest) => ['Proefversie', 'alleen jij', 'alleen lezen']
+            .concat(time === null ? [] : [`verloopt om ${time}`])
+            .concat(leest.length === 0 ? [] : [`leest: ${leest.join(', ')}`])
+            .concat('Plak geen gegevens uit deze proefversie in je AI-gesprek.')
+            .join(' · '),
+        expired: 'Deze proefversie is verlopen. Vraag in je gesprek om een nieuwe.',
+        closed: 'Deze proefversie is gesloten.',
+        refreshing: 'Nieuwe versie wordt geladen…',
+        wider: 'Er is een nieuwe versie die meer gegevens leest.',
+        load: 'Laden',
+        elsewhere: 'Laad de pagina opnieuw.',
+        reload: 'Opnieuw laden',
+    },
     invalid: {
         json: (tag, name) => `${tag}: ${name} is geen geldige JSON`,
         number: (tag, name) => `${tag}: ${name} is geen geldig getal`,
@@ -109,6 +123,8 @@ export const NL = {
         value: (tag, name, value) => `${tag}: ${name} "${value}" is geen geldige waarde`,
         formula: 'cube-calc: formula moet een functie zijn',
         calcSingle: 'cube-calc: formula gaf één waarde, maar er zijn meer cube-results; geef een object met hun namen',
+        duplicate: (tag, value) => `${tag}: name "${value}" komt twee keer voor`,
+        calcAsync: 'cube-calc: formula gaf een Promise; geef de uitkomst direct terug, niet async',
         dateField: (tag) => `${tag}: date-field ontbreekt bij period`,
         compare: (tag) => `${tag}: compare werkt alleen samen met period`,
         periodSource: (selector) => `Geen periodekiezer gevonden voor "${selector}"`,

package/dist/ui/trial-banner.d.ts

@@ -0,0 +1,25 @@
+import type { TrialConfig } from '../trial.js';
+/** What the banner needs from the window: the page's own, or a test's with fake timers and a fake fetch. */
+export interface TrialScope {
+    document: Document;
+    CSSStyleSheet: typeof CSSStyleSheet;
+    setTimeout: typeof setTimeout;
+    clearTimeout: typeof clearTimeout;
+    fetch: typeof fetch;
+    location: Pick<Location, 'assign' | 'reload'>;
+    /** Without it a status request has no timeout. */
+    AbortController?: typeof AbortController;
+    /** Default `Date.now`. */
+    now?: () => number;
+}
+/** Spec section 7: every 5 s while the page is visible, every 60 s while it is hidden. */
+export declare const POLL_VISIBLE_MS = 5000;
+export declare const POLL_HIDDEN_MS = 60000;
+/** A status request that hangs this long is given up as a network error, so the polling goes on. */
+export declare const STATUS_TIMEOUT_MS = 10000;
+/**
+ * Puts `cube-trial-banner` at the top of `<body>` and polls the trial's status: it says what the page is, ends when
+ * the trial does, and follows a newer version (by itself only when that one reads nothing more).
+ * Returns a function that stops the polling.
+ */
+export declare function showTrialBanner(scope: TrialScope, config: TrialConfig): () => void;

package/dist/ui/trial-banner.js

@@ -0,0 +1,180 @@
+import { clear, h } from './dom.js';
+import { BASE_CSS } from './styles.js';
+import { NL } from './texts.js';
+/** Spec section 7: every 5 s while the page is visible, every 60 s while it is hidden. */
+export const POLL_VISIBLE_MS = 5000;
+export const POLL_HIDDEN_MS = 60000;
+/** A status request that hangs this long is given up as a network error, so the polling goes on. */
+export const STATUS_TIMEOUT_MS = 10000;
+const CSS = `
+.banner{display:flex;flex-wrap:wrap;align-items:center;gap:.75rem;padding:.5rem 1rem;
+border-bottom:1px solid var(--cube-color-border);border-left:4px solid var(--cube-color-warning);
+background:var(--cube-color-surface);font-size:.875rem}
+.banner p{margin:0;flex:1 1 16rem}
+.banner[data-state=expired],.banner[data-state=closed]{border-left-color:var(--cube-color-danger)}
+`;
+/**
+ * Puts `cube-trial-banner` at the top of `<body>` and polls the trial's status: it says what the page is, ends when
+ * the trial does, and follows a newer version (by itself only when that one reads nothing more).
+ * Returns a function that stops the polling.
+ */
+export function showTrialBanner(scope, config) {
+    const doc = scope.document;
+    const now = scope.now ?? Date.now;
+    const expiresAt = Date.parse(config.expiresAt);
+    const known = Number.isFinite(expiresAt);
+    const time = known
+        ? new Intl.DateTimeFormat('nl-NL', { hour: '2-digit', minute: '2-digit' }).format(new Date(expiresAt))
+        : null;
+    const host = doc.createElement('cube-trial-banner');
+    const root = host.attachShadow({ mode: 'open' });
+    const sheets = [BASE_CSS, CSS].map((css) => {
+        const sheet = new scope.CSSStyleSheet();
+        sheet.replaceSync(css);
+        return sheet;
+    });
+    const message = h(doc, 'p', {}, NL.trial.banner(time, config.leest));
+    const region = h(doc, 'div', { class: 'banner', role: 'status', 'aria-live': 'polite' }, message);
+    let timer = null;
+    let ended = false;
+    let inFlight = false;
+    let abort = null;
+    root.adoptedStyleSheets = sheets;
+    root.appendChild(region);
+    const insert = () => {
+        doc.body.insertBefore(host, doc.body.firstChild);
+    };
+    const visible = () => doc.visibilityState !== 'hidden';
+    const stop = () => {
+        ended = true;
+        abort?.abort();
+        if (timer !== null)
+            scope.clearTimeout(timer);
+        timer = null;
+        doc.removeEventListener('visibilitychange', onVisibility);
+    };
+    const end = (state, action) => {
+        stop();
+        // The app may have replaced <body>'s children: without the banner the end state would go unseen.
+        if (!host.isConnected && doc.body !== null)
+            insert();
+        region.setAttribute('data-state', state);
+        clear(message);
+        message.appendChild(doc.createTextNode(NL.trial[state]));
+        if (action !== undefined) {
+            region.appendChild(h(doc, 'button', { type: 'button', onclick: action[1] }, action[0]));
+        }
+    };
+    const schedule = () => {
+        if (ended)
+            return;
+        if (timer !== null)
+            scope.clearTimeout(timer);
+        const interval = visible() ? POLL_VISIBLE_MS : POLL_HIDDEN_MS;
+        timer = scope.setTimeout(tick, known ? Math.max(0, Math.min(interval, expiresAt - now())) : interval);
+    };
+    const tick = async () => {
+        timer = null;
+        if (ended)
+            return;
+        // The hour is over: no request needed to know it.
+        if (known && now() >= expiresAt) {
+            end('expired');
+            return;
+        }
+        inFlight = true;
+        const controller = scope.AbortController === undefined ? null : new scope.AbortController();
+        abort = controller;
+        const timeout = controller === null ? null : scope.setTimeout(() => controller.abort(), STATUS_TIMEOUT_MS);
+        try {
+            const response = await scope.fetch(config.statusUrl, {
+                headers: { Accept: 'application/json', Authorization: `Bearer ${config.token}` },
+                cache: 'no-store',
+                ...(controller === null ? {} : { signal: controller.signal }),
+            });
+            await answer(response);
+        }
+        catch {
+            // Offline for a moment, or the request hung and was aborted: try again on the next beat.
+            schedule();
+        }
+        finally {
+            inFlight = false;
+            abort = null;
+            if (timeout !== null)
+                scope.clearTimeout(timeout);
+        }
+    };
+    const answer = async (response) => {
+        if (ended)
+            return;
+        if (response.ok || response.status === 429 || response.status >= 500) {
+            schedule();
+            return;
+        }
+        let problem = {};
+        try {
+            const body = await response.json();
+            if (body !== null && typeof body === 'object')
+                problem = body;
+        }
+        catch {
+            // No problem body: treated as closed below.
+        }
+        const code = problem.code;
+        let newerUrl = null;
+        if (code === 'trial_expired') {
+            end('expired');
+        }
+        else if (code === 'trial_elsewhere') {
+            end('elsewhere', [NL.trial.reload, () => scope.location.reload()]);
+        }
+        else if (code === 'trial_replaced' && (newerUrl = trustedNewer(problem.newer, config.dmpUrl)) !== null) {
+            const newer = newerUrl.href;
+            if (problem.wider === false) {
+                end('refreshing');
+                scope.location.assign(newer);
+            }
+            else {
+                // Reads more than the open one: only the maker's click may widen what this tab reads.
+                end('wider', [NL.trial.load, () => scope.location.assign(newer)]);
+            }
+        }
+        else {
+            end('closed');
+        }
+    };
+    function onVisibility() {
+        if (ended || inFlight)
+            return;
+        if (!visible()) {
+            schedule();
+            return;
+        }
+        // Back in view: ask right away instead of waiting out the hidden interval.
+        if (timer !== null)
+            scope.clearTimeout(timer);
+        void tick();
+    }
+    doc.addEventListener('visibilitychange', onVisibility);
+    if (doc.body === null) {
+        doc.addEventListener('DOMContentLoaded', insert, { once: true });
+    }
+    else {
+        insert();
+    }
+    schedule();
+    return stop;
+}
+/** Only the DMP's own open route: same origin as `dmpUrl`, under `/apps/proef/`. */
+function trustedNewer(newer, dmpUrl) {
+    if (typeof newer !== 'string')
+        return null;
+    try {
+        const url = new URL(newer);
+        return url.origin === new URL(dmpUrl).origin && url.pathname.startsWith('/apps/proef/') ? url : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/ui/write.d.ts

@@ -12,8 +12,8 @@ export declare function attemptFor(earlier: Attempt | null, fingerprint: string)
 export declare function showAlert(doc: Document, target: HTMLElement, message: string, action?: HTMLElement | null): void;
 /**
  * Shows why a write failed: a 422 on the fields it names, with the form-level line, and the messages for fields
- * without an editor listed in the alert (`label` names them); anything else as one line. Never the browser's own
- * (English) text of a network failure: stateFor would show a TypeError's message.
+ * without an editor listed in the alert (`label` names them); anything else as one line. Only the kind of stateFor
+ * is used: the alert never shows an error's own text.
  */
 export declare function showWriteFailure(doc: Document, alert: HTMLElement, error: unknown, editors: Editor[], label: (field: string) => string): void;
 /** Who is signed in, as a key: null when nobody is. A write must not go out as somebody who signed in since. */

package/dist/ui/write.js

@@ -29,8 +29,8 @@ export function showAlert(doc, target, message, action) {
 }
 /**
  * Shows why a write failed: a 422 on the fields it names, with the form-level line, and the messages for fields
- * without an editor listed in the alert (`label` names them); anything else as one line. Never the browser's own
- * (English) text of a network failure: stateFor would show a TypeError's message.
+ * without an editor listed in the alert (`label` names them); anything else as one line. Only the kind of stateFor
+ * is used: the alert never shows an error's own text.
  */
 export function showWriteFailure(doc, alert, error, editors, label) {
     const errors = fieldErrors(error);

package/dist/version.d.ts

@@ -1,4 +1,4 @@
 /** This package's version. A test holds it equal to package.json's. */
-export declare const VERSION = "1.1.0-rc.1";
+export declare const VERSION = "1.1.0-rc.2";
 /** The `"sdk"` value a `cube-app.json` manifest names for the API `CubeApp` offers here. */
 export declare const MANIFEST_SDK = "1";

package/dist/version.js

@@ -1,4 +1,4 @@
 /** This package's version. A test holds it equal to package.json's. */
-export const VERSION = '1.1.0-rc.1';
+export const VERSION = '1.1.0-rc.2';
 /** The `"sdk"` value a `cube-app.json` manifest names for the API `CubeApp` offers here. */
 export const MANIFEST_SDK = '1';