@mistriwork/engine 0.0.0-stage → 1.0.0-rc.10

package/dist/shared/mentionLookup.js

@@ -0,0 +1,64 @@
+/**
+ * Who an @ names, as a rich text column or input declares it:
+ * `mentions: { from, by, labelColumn }`. `by` is what is stored (the span's
+ * `data-id`, which a `notify` rule finds); `labelColumn` is what the list and the
+ * mention say — one column, or a record label template of the people's own
+ * columns, `'{first_name} {last_name}'` (recordLabel.ts's grammar), so two
+ * Morgans read as "Morgan Hughes" and "Morgan Tran".
+ *
+ * One reading for the browser, which asks, and the server, which checks the
+ * declaration: the query an @ sends, and the name a row is said by.
+ */
+import { columnKind } from './schema.js';
+import { quoteValue } from './query.js';
+import { isLabelTemplate, parseLabelTemplate } from './recordLabel.js';
+import { mentionLabelColumns } from './mentionLabel.js';
+import { MENTION_QUERY_WORDS } from './richText.js';
+/** A person's name as the label says it, from their row: the column, or the template filled and its spaces tidied. */
+export function mentionLabelText(source, row) {
+    const label = source.labelColumn ?? source.by;
+    const said = (value) => (value === null || value === undefined ? '' : String(value));
+    if (!isLabelTemplate(label))
+        return said(row[label]);
+    const parsed = parseLabelTemplate(label);
+    if ('problem' in parsed)
+        return '';
+    return parsed.parts
+        .map((part) => ('text' in part ? part.text : said(row[part.path])))
+        .join('')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+/* A column a word can be looked for in: text the engine compares as text. A UUID is not one — Postgres has no
+   ILIKE for it, and nobody types a key's first letters — nor is JSON. */
+const searchable = (column) => !column?.type || (columnKind(column.type) === 'text' && !/uuid|json/i.test(column.type));
+/** The most words of what was typed that are each looked for; the rest narrow nothing. */
+const MOST_WORDS = MENTION_QUERY_WORDS;
+/**
+ * The query an @ sends for what was typed after it: the people whose label's
+ * words — any of them, by its start, in any case — or whose `by` value start
+ * with each typed word, shown by the label's columns and sorted by them.
+ * `columns` are the resource's, where the catalog has them, so a key or a
+ * number is not searched as text.
+ */
+export function mentionQuery(source, typed, columns, 
+/** Read beside the label, never looked in: a team's key its link rows name. */
+also = []) {
+    const read = mentionLabelColumns(source.labelColumn ?? source.by);
+    const shown = 'problem' in read ? [source.by] : read.columns;
+    const column = (name) => columns?.find((c) => c.name === name);
+    const looked = [...new Set([...shown, source.by])].filter((name) => searchable(column(name)));
+    /* A word's start: the value's, or after a space in it ("Mary Ann"). The language spreads the ands over the ors,
+       which it caps, so the words looked for are few. */
+    const words = typed
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean)
+        .slice(0, looked.length > 4 ? 1 : MOST_WORDS);
+    const filter = looked.length
+        ? words.map((word) => `(${looked.flatMap((name) => [`${name} startswith ${quoteValue(word)}`, `${name} contains ${quoteValue(` ${word}`)}`]).join(' or ')})`)
+        : [];
+    return [source.from, filter.join(' and '), `show ${[...new Set([source.by, ...shown, ...also])].join(', ')}`, `sort ${shown.join(', ')}`]
+        .filter(Boolean)
+        .join(' ');
+}

package/dist/shared/menuCounts.d.ts

@@ -0,0 +1,16 @@
+export interface CountedMachine {
+    column: string;
+    states: readonly {
+        value: string;
+        final?: true;
+    }[];
+    groups?: Readonly<Record<string, readonly string[]>>;
+}
+/**
+ * Whether a menu row counts its list, and whether that count is late. `count` is the list's own say
+ * (`count: true` or `false`), which wins. `segments` are the list's resource's, by name, to their conditions.
+ */
+export declare function menuCount(written: string, machine: CountedMachine | undefined, count?: boolean, segments?: Readonly<Record<string, string>>): {
+    counted: boolean;
+    late: boolean;
+};

package/dist/shared/menuCounts.js

@@ -0,0 +1,74 @@
+/**
+ * Which menu rows carry a count (ui.shell.counts), on both sides: the client's menu (sidebarModel.ts) and the
+ * server's first paint, which asks for the same counts before the menu draws (firstPaintRooms.ts).
+ *
+ * A count beside a list says work is waiting. A number beside every list made the menu a column of figures —
+ * Products 218, Customers 40, Stock 900 — in which the one that mattered did not stand out, and a catalog's size
+ * is not news. So a list is counted where its standing condition says it is work:
+ *
+ * - (a) its machine's states that are not final: `status = to_pick`, `status != shipped` where shipped is the one
+ *   final state, `status in (draft, sent)`, `status is open`, or a group of open states (`status is onBench`);
+ * - (b) a date at or before today: `ship_by <= today`, `due before today`;
+ * - (c) the reader: `owner = me`.
+ *
+ * A plain filter (`status = active`) is not work. An author says otherwise for one list with its `count`.
+ * A count of (b), work past its date, is said in the danger's ink; no other count is an alarm.
+ *
+ * A list's query may name its resource's segments (appSegments.ts): `query: 'open'` is read as the conditions
+ * the segment names, so it is counted exactly as the same conditions written inline are.
+ */
+import { expandSegments } from './query.js';
+const PAST = /(?:<=?|\bbefore)\s*(?:today|now)\b/i;
+const ME = /(?:^|[\s(,=])me(?=$|[\s),])/;
+const escape = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const words = (list) => list
+    .split(',')
+    .map((word) => word.trim().replace(/^["']|["']$/g, ''))
+    .filter(Boolean);
+/** Whether a condition is of work past its date. */
+function pastDue(condition) {
+    return PAST.test(condition);
+}
+/** Whether the condition picks out only states its machine has not finished with. */
+function openStates(condition, machine) {
+    if (!machine)
+        return false;
+    const final = new Set(machine.states.filter((state) => state.final).map((state) => state.value));
+    const open = (value) => machine.states.some((state) => state.value === value) && !final.has(value);
+    // The machine's own column, never a path through a reference to another table's column of that name.
+    const column = `(?<![\\w.])${escape(machine.column)}`;
+    const value = `["']?([\\w-]+)["']?`;
+    /* `status is open` is the machine's own name for its unfinished states (query.ts). */
+    if (new RegExp(`${column}\\s+is\\s+open\\b`, 'i').test(condition) && machine.states.some((state) => !final.has(state.value)))
+        return true;
+    /* A group the machine names (`status is onBench`) is work when every state it holds is. */
+    for (const [, group] of condition.matchAll(new RegExp(`${column}\\s+is\\s+(\\w+)\\b`, 'gi'))) {
+        const held = machine.groups && Object.hasOwn(machine.groups, group) ? machine.groups[group] : undefined;
+        if (held?.length && held.every(open))
+            return true;
+    }
+    for (const [, state] of condition.matchAll(new RegExp(`${column}\\s*=\\s*${value}`, 'g')))
+        if (open(state))
+            return true;
+    for (const [, list] of condition.matchAll(new RegExp(`${column}\\s+in\\s*\\(([^)]*)\\)`, 'gi')))
+        if (words(list).length && words(list).every(open))
+            return true;
+    const left = new Set();
+    for (const [, state] of condition.matchAll(new RegExp(`${column}\\s*!=\\s*${value}`, 'g')))
+        left.add(state);
+    for (const [, list] of condition.matchAll(new RegExp(`${column}\\s+not\\s+in\\s*\\(([^)]*)\\)`, 'gi')))
+        words(list).forEach((w) => left.add(w));
+    return final.size > 0 && left.size > 0 && [...final].every((state) => left.has(state));
+}
+/**
+ * Whether a menu row counts its list, and whether that count is late. `count` is the list's own say
+ * (`count: true` or `false`), which wins. `segments` are the list's resource's, by name, to their conditions.
+ */
+export function menuCount(written, machine, count, segments) {
+    const condition = expandSegments(written, segments).text;
+    const late = pastDue(condition);
+    if (count !== undefined)
+        return { counted: count, late: count && late };
+    const counted = late || ME.test(condition) || openStates(condition, machine);
+    return { counted, late: counted && late };
+}

package/dist/shared/model.d.ts

@@ -0,0 +1,79 @@
+/**
+ * The end of a switch over a closed union: a compile error where a new
+ * member has no case, and a throw where one arrives at run time anyway.
+ * A `default` that quietly answered "nothing" is how a new section kind
+ * once skipped a role check.
+ */
+export declare function assertNever(value: never, what?: string): never;
+/**
+ * Refuse a key the location does not have, naming the ones it does.
+ *
+ * An unknown key used to vanish: `lable`, `qeury`, `navigation` all parsed
+ * to an emptier app with no word said, which for a manifest written by an
+ * agent — no editor squiggle, no schema check — is the worst failure mode a
+ * config surface has. The header promises nothing is silently skipped; this
+ * is what keeps the promise at every level. Keys beginning with `$` or `_`
+ * are annotations (`$schema`, `_comment`) and pass: JSON has no comments and
+ * a manifest is allowed to explain itself.
+ *
+ * A key the location declares ahead of its feature is in `refused`, and is
+ * refused with the reason instead of the list. Any other is offered the key
+ * it is a near miss of, or the place it belongs (unknownKey).
+ */
+export declare function allowKeys(obj: Record<string, unknown>, allowed: readonly string[], at: string, refused?: Readonly<Record<string, string>>): void;
+export declare const setKeyHomes: (homes: (key: string) => readonly string[]) => void;
+export declare const keyHomesOf: (key: string) => readonly string[];
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+/**
+ * A plain data object, or a refusal: own enumerable data properties only, on
+ * no borrowed prototype. The places a getter could run code during a parse,
+ * or an inherited value could stand in for an authored one — the root, the
+ * resource blocks and their ceilings — are read only after this.
+ */
+export declare function plainRecord(raw: unknown, at: string, what: string): Record<string, unknown>;
+/** A trimmed non-empty string, or undefined when absent; anything else is refused. */
+export declare function optionalText(o: Record<string, unknown>, key: string, at: string): string | undefined;
+export declare const RESERVED_NAMES: Set<string>;
+/** A view key: its address — `{id}:` before a list's question, `@dash-{id}`, `@form-{id}`, `/form/{id}`. */
+export declare const VIEW_KEY: RegExp;
+/** A page key: the page id (`@{id}` when its name does not say it unambiguously). */
+export declare const PAGE_KEY: RegExp;
+/**
+ * A table or column name as a person would say it: `work_order` → "Work
+ * order", `shippedOn` → "Shipped on". The nav used to serve the raw name
+ * when the author wrote no label, so the sidebar read `work_order` beside
+ * a breadcrumb that had already humanised it. Mirror of `humanName` in the
+ * client (core.js), for the one place the server labels something.
+ */
+export declare function humanName(name: string): string;
+/** What one of a resource's records is called, and more than one, as they read mid-sentence: `noun` on its block.
+    appNoun.ts says it where each place needs it. */
+export interface AppNoun {
+    one: string;
+    many: string;
+}
+/** What a stored value is called wherever the platform words it: a tone chip, a picker, a filter, a board's lane and row heads. */
+export declare function vocabularyWord(text: string): string;
+/**
+ * The word a display rule says a stored value as: the author's own
+ * (`values`), the value made words where the rule says `humanize`
+ * (`IN_REVIEW` → "In review"), or undefined where the rule says neither.
+ * Own keys only, as everywhere a stored value names a key. One rule for a
+ * cell (the client's valueModel) and a record's computed name
+ * (appRecordLabels.ts).
+ */
+export declare function displayWord(rule: {
+    values?: Record<string, string>;
+    humanize?: boolean;
+} | null | undefined, text: string): string | undefined;
+export type DisplayTone = 'good' | 'warn' | 'bad' | 'info' | 'neutral';
+export declare const DISPLAY_TONES: readonly ['good', 'warn', 'bad', 'info', 'neutral'];
+/** What a masked value is drawn as (`masked: true`): short, and the same for every value, so its length says nothing either. */
+export declare const MASK = "\u2022\u2022\u2022\u2022\u2022\u2022";
+export declare const CHART_SHAPES: readonly ['line', 'bar', 'donut', 'stacked'];
+/** How a measured section says its figures where its measure has no column rule to say them: `duration` reads
+    the figure as seconds ("10h 2m"), as a `duration` column rule does. */
+export declare const FIGURE_FORMATS: readonly ['percent', 'number', 'money', 'duration'];
+export type FigureFormat = (typeof FIGURE_FORMATS)[number];
+/** The refusal's list of them, to finish its own sentence. */
+export declare const FIGURE_FORMAT_WORDS = "\"percent\" (a figure 0\u2013100), \"number\", \"money\" or \"duration\" (a figure in seconds)";

package/dist/shared/model.js

@@ -0,0 +1,153 @@
+/**
+ * The helpers every model parser and rule reads, whichever product it
+ * belongs to: what a closed union's last case says, a key refused by name,
+ * a plain object, a name said the way a person says it.
+ */
+import { unknownKey } from './suggest.js';
+/**
+ * The end of a switch over a closed union: a compile error where a new
+ * member has no case, and a throw where one arrives at run time anyway.
+ * A `default` that quietly answered "nothing" is how a new section kind
+ * once skipped a role check.
+ */
+export function assertNever(value, what = 'case') {
+    throw new Error(`Unknown ${what}: ${JSON.stringify(value?.kind ?? value)}.`);
+}
+/**
+ * Refuse a key the location does not have, naming the ones it does.
+ *
+ * An unknown key used to vanish: `lable`, `qeury`, `navigation` all parsed
+ * to an emptier app with no word said, which for a manifest written by an
+ * agent — no editor squiggle, no schema check — is the worst failure mode a
+ * config surface has. The header promises nothing is silently skipped; this
+ * is what keeps the promise at every level. Keys beginning with `$` or `_`
+ * are annotations (`$schema`, `_comment`) and pass: JSON has no comments and
+ * a manifest is allowed to explain itself.
+ *
+ * A key the location declares ahead of its feature is in `refused`, and is
+ * refused with the reason instead of the list. Any other is offered the key
+ * it is a near miss of, or the place it belongs (unknownKey).
+ */
+export function allowKeys(obj, allowed, at, refused = {}) {
+    for (const key of Object.keys(obj)) {
+        if (allowed.includes(key) || /^[$_]/.test(key))
+            continue;
+        if (Object.hasOwn(refused, key))
+            throw new Error(`${at} has "${key}", which ${refused[key]}.`);
+        throw new Error(`${at} ${unknownKey(key, allowed, keyHomes(key))}.`);
+    }
+}
+/* Where else a key is taken, for a refusal to name. app.ts sets it to the
+   App parsers' own key lists, read on the first refusal (appKeyHomes.ts): a
+   hook, because every parser imports this module and the lists cannot be
+   imported back into it. Absent, a refusal names no home. */
+let keyHomes = () => [];
+export const setKeyHomes = (homes) => {
+    keyHomes = homes;
+};
+export const keyHomesOf = (key) => keyHomes(key);
+export const isRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+/**
+ * A plain data object, or a refusal: own enumerable data properties only, on
+ * no borrowed prototype. The places a getter could run code during a parse,
+ * or an inherited value could stand in for an authored one — the root, the
+ * resource blocks and their ceilings — are read only after this.
+ */
+export function plainRecord(raw, at, what) {
+    if (!isRecord(raw) || ![Object.prototype, null].includes(Object.getPrototypeOf(raw)))
+        throw new Error(`${at} is not ${what}.`);
+    for (const key of Reflect.ownKeys(raw)) {
+        const descriptor = Object.getOwnPropertyDescriptor(raw, key);
+        if (typeof key !== 'string' || !('value' in descriptor) || !descriptor.enumerable) {
+            throw new Error(`${at} must be plain data: "${String(key)}" is not a data property.`);
+        }
+    }
+    return raw;
+}
+/** A trimmed non-empty string, or undefined when absent; anything else is refused. */
+export function optionalText(o, key, at) {
+    const value = o[key];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' || !value.trim())
+        throw new Error(`${at} has a "${key}" that is not a non-empty string.`);
+    return value.trim();
+}
+export const RESERVED_NAMES = new Set([...Object.getOwnPropertyNames(Object.prototype), 'prototype']);
+/** A view key: its address — `{id}:` before a list's question, `@dash-{id}`, `@form-{id}`, `/form/{id}`. */
+export const VIEW_KEY = /^[a-z0-9][a-z0-9-]{0,63}$/;
+/** A page key: the page id (`@{id}` when its name does not say it unambiguously). */
+export const PAGE_KEY = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+/**
+ * A table or column name as a person would say it: `work_order` → "Work
+ * order", `shippedOn` → "Shipped on". The nav used to serve the raw name
+ * when the author wrote no label, so the sidebar read `work_order` beside
+ * a breadcrumb that had already humanised it. Mirror of `humanName` in the
+ * client (core.js), for the one place the server labels something.
+ */
+export function humanName(name) {
+    if (!name || /\s/.test(name))
+        return name;
+    /* A table is named by its schema too (`billing.order_line`), and a reader of the page it heads was never told which
+       schema it came from: the name after the last dot is the one that is said. */
+    const bare = name.includes('.') ? name.slice(name.lastIndexOf('.') + 1) : name;
+    if (!bare)
+        return name;
+    const words = bare
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .split(/_+/)
+        .filter(Boolean);
+    if (!words.length)
+        return name;
+    return words
+        .map((word, i) => {
+        const lower = word.toLowerCase();
+        if (HUMAN_CAPS.has(lower))
+            return lower.toUpperCase();
+        return i === 0 ? lower.charAt(0).toUpperCase() + lower.slice(1) : lower;
+    })
+        .join(' ');
+}
+/* The same set as the client's CAPS, kept identical by test/mirrors.test.ts. */
+const HUMAN_CAPS = new Set(['id', 'url', 'uuid', 'sku', 'api', 'ip', 'iso', 'sla']);
+/* A stored vocabulary word (`in_progress`, `in progress`, `no-show`) is said
+   the way its picker and a workflow strip say it ("In progress", "No-show"),
+   whichever joiner the schema spelled it with: underscores alone left a column
+   reading "Done" above "in progress". A code (`RNO`), a mixed-case name or
+   anything with punctuation stays as stored. */
+const VOCABULARY_WORD = /^[a-z][a-z0-9]*(?:(?:_+| |-)[a-z0-9]+)*$/;
+/** What a stored value is called wherever the platform words it: a tone chip, a picker, a filter, a board's lane and row heads. */
+export function vocabularyWord(text) {
+    return VOCABULARY_WORD.test(text) ? humanName(text.replaceAll(' ', '_')) : text;
+}
+/**
+ * The word a display rule says a stored value as: the author's own
+ * (`values`), the value made words where the rule says `humanize`
+ * (`IN_REVIEW` → "In review"), or undefined where the rule says neither.
+ * Own keys only, as everywhere a stored value names a key. One rule for a
+ * cell (the client's valueModel) and a record's computed name
+ * (appRecordLabels.ts).
+ */
+export function displayWord(rule, text) {
+    if (rule?.values && Object.hasOwn(rule.values, text))
+        return rule.values[text];
+    if (rule?.humanize && text.trim()) {
+        const plain = /^[A-Z0-9_]+$/.test(text) ? text.toLowerCase() : text;
+        const word = vocabularyWord(plain);
+        return word !== plain ? word : humanName(plain);
+    }
+    return undefined;
+}
+/* `neutral` exists for the "*" rule: a vocabulary is all pills or no pills,
+   and the values the author has nothing to say about wear a pill that says
+   nothing in particular rather than falling back to bare text beside the
+   coloured ones. */
+export const DISPLAY_TONES = ['good', 'warn', 'bad', 'info', 'neutral'];
+/** What a masked value is drawn as (`masked: true`): short, and the same for every value, so its length says nothing either. */
+export const MASK = '••••••';
+export const CHART_SHAPES = ['line', 'bar', 'donut', 'stacked'];
+/** How a measured section says its figures where its measure has no column rule to say them: `duration` reads
+    the figure as seconds ("10h 2m"), as a `duration` column rule does. */
+export const FIGURE_FORMATS = ['percent', 'number', 'money', 'duration'];
+/** The refusal's list of them, to finish its own sentence. */
+export const FIGURE_FORMAT_WORDS = '"percent" (a figure 0–100), "number", "money" or "duration" (a figure in seconds)';

package/dist/shared/money.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Money kept as a whole number of minor units — cents, paise, fils, yen — the
+ * way a payment provider and most commerce schemas keep it, declared on the
+ * column's display rule: `total: { format: 'money', minor: true }`.
+ *
+ * The figure's decimals are the currency's own, as Intl knows them: two for
+ * USD and INR, none for JPY and KRW, three for KWD and BHD. So 1999 is $19.99,
+ * ¥1,999 and 1.999 KWD, and nothing about a currency is spelled twice. The
+ * conversions are text to text, never through a float: an amount past 2^53
+ * comes back from an adapter as a string and stays exact.
+ *
+ * Browser-safe, and drawn with every list, so it holds only what saying an
+ * amount needs; reading a typed one back (a money box, a CSV import) is
+ * moneyEntry.ts, loaded with what takes one.
+ */
+/** The decimals a currency is written with (ISO 4217's minor unit, as Intl has it); 2 for a code Intl does not know. */
+export declare function currencyDigits(currency: string): number;
+/**
+ * A stored amount of minor units as the major figure's exact decimal text —
+ * 1999 → "19.99" in USD, "1999" in JPY, "1.999" in KWD — or undefined when
+ * the value is not a whole number of them (an average, say), which the caller
+ * then divides as a number.
+ */
+export declare function minorToMajor(value: unknown, currency: string): string | undefined;
+/**
+ * A minor-unit value as the figure a money format draws: the exact major text
+ * where it is a whole number of minor units, else the number divided (a
+ * total's average). Undefined for no number at all.
+ */
+export declare function minorFigure(value: unknown, currency: string): string | number | undefined;
+/**
+ * The path a shown money column's currency is read from, where its rule says
+ * `currency: { column }`: a column of the table the value was read from, so
+ * `order_id.total` shown on a line reads `order_id.currency_code`, as a
+ * second line does (subtitlePath.ts).
+ */
+export declare function currencyPath(rule: {
+    currencyColumn?: string;
+} | null | undefined, shown: string): string | undefined;
+/** A rule's currency for one row: the row's own column where the rule names one and the row holds a code, else the rule's or the App's. */
+export declare function rowCurrency(rule: {
+    currency?: string;
+    currencyColumn?: string;
+} | null | undefined, row: Readonly<Record<string, unknown>> | undefined, fallback: string, shown?: string): string;

package/dist/shared/money.js

@@ -0,0 +1,81 @@
+/**
+ * Money kept as a whole number of minor units — cents, paise, fils, yen — the
+ * way a payment provider and most commerce schemas keep it, declared on the
+ * column's display rule: `total: { format: 'money', minor: true }`.
+ *
+ * The figure's decimals are the currency's own, as Intl knows them: two for
+ * USD and INR, none for JPY and KRW, three for KWD and BHD. So 1999 is $19.99,
+ * ¥1,999 and 1.999 KWD, and nothing about a currency is spelled twice. The
+ * conversions are text to text, never through a float: an amount past 2^53
+ * comes back from an adapter as a string and stays exact.
+ *
+ * Browser-safe, and drawn with every list, so it holds only what saying an
+ * amount needs; reading a typed one back (a money box, a CSV import) is
+ * moneyEntry.ts, loaded with what takes one.
+ */
+const digitsByCurrency = new Map();
+/** The decimals a currency is written with (ISO 4217's minor unit, as Intl has it); 2 for a code Intl does not know. */
+export function currencyDigits(currency) {
+    const code = currency.toUpperCase();
+    let digits = digitsByCurrency.get(code);
+    if (digits === undefined) {
+        try {
+            digits = new Intl.NumberFormat('en', { style: 'currency', currency: code }).resolvedOptions().maximumFractionDigits ?? 2;
+        }
+        catch {
+            digits = 2;
+        }
+        digitsByCurrency.set(code, digits);
+    }
+    return digits;
+}
+/**
+ * A stored amount of minor units as the major figure's exact decimal text —
+ * 1999 → "19.99" in USD, "1999" in JPY, "1.999" in KWD — or undefined when
+ * the value is not a whole number of them (an average, say), which the caller
+ * then divides as a number.
+ */
+export function minorToMajor(value, currency) {
+    const m = /^(-?)0*(\d+)$/.exec(typeof value === 'number'
+        ? Number.isSafeInteger(value)
+            ? String(value)
+            : ''
+        : typeof value === 'string' || typeof value === 'bigint'
+            ? String(value).trim()
+            : '');
+    if (!m)
+        return undefined;
+    const digits = currencyDigits(currency);
+    const whole = m[2].padStart(digits + 1, '0');
+    return (/[1-9]/.test(whole) ? m[1] : '') + (digits ? `${whole.slice(0, -digits)}.${whole.slice(-digits)}` : whole);
+}
+/**
+ * A minor-unit value as the figure a money format draws: the exact major text
+ * where it is a whole number of minor units, else the number divided (a
+ * total's average). Undefined for no number at all.
+ */
+export function minorFigure(value, currency) {
+    const exact = minorToMajor(value, currency);
+    if (exact !== undefined)
+        return exact;
+    const n = typeof value === 'number' ? value : typeof value === 'string' && value.trim() ? Number(value) : NaN;
+    return Number.isFinite(n) ? n / 10 ** currencyDigits(currency) : undefined;
+}
+/**
+ * The path a shown money column's currency is read from, where its rule says
+ * `currency: { column }`: a column of the table the value was read from, so
+ * `order_id.total` shown on a line reads `order_id.currency_code`, as a
+ * second line does (subtitlePath.ts).
+ */
+export function currencyPath(rule, shown) {
+    if (!rule?.currencyColumn)
+        return undefined;
+    const hop = shown.lastIndexOf('.');
+    return hop < 0 ? rule.currencyColumn : `${shown.slice(0, hop + 1)}${rule.currencyColumn}`;
+}
+/** A rule's currency for one row: the row's own column where the rule names one and the row holds a code, else the rule's or the App's. */
+export function rowCurrency(rule, row, fallback, shown = '') {
+    const path = currencyPath(rule, shown);
+    const own = path && row ? row[path] : undefined;
+    return typeof own === 'string' && /^[A-Za-z]{3}$/.test(own.trim()) ? own.trim().toUpperCase() : (rule?.currency ?? fallback);
+}

package/dist/shared/moneyEntry.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A major amount — a number, or decimal text with a point ("19.99", "-5",
+ * ".5") — as the whole number of minor units it is, or undefined when it is
+ * no amount or says more decimals than the currency has: 19.999 dollars is a
+ * typo, not a value to round.
+ */
+export declare function majorToMinor(major: number | string, currency: string): number | undefined;

package/dist/shared/moneyEntry.js

@@ -0,0 +1,27 @@
+/**
+ * An amount a person types, or a CSV cell holds, read back as the whole number
+ * of minor units a `minor: true` money column stores (money.ts says why). A
+ * module of its own so it loads with what takes a typed amount — a money box,
+ * an import — and not with every list that only says one.
+ */
+import { currencyDigits } from './money.js';
+/**
+ * A major amount — a number, or decimal text with a point ("19.99", "-5",
+ * ".5") — as the whole number of minor units it is, or undefined when it is
+ * no amount or says more decimals than the currency has: 19.999 dollars is a
+ * typo, not a value to round.
+ */
+export function majorToMinor(major, currency) {
+    const text = typeof major === 'number' ? (Number.isFinite(major) ? String(major) : '') : major.trim();
+    const m = /^([-+]?)(\d*)(?:\.(\d*))?$/.exec(text);
+    if (!m || (!m[2] && !m[3]))
+        return undefined;
+    const digits = currencyDigits(currency);
+    const fraction = (m[3] ?? '').replace(/0+$/, '');
+    if (fraction.length > digits)
+        return undefined;
+    const n = Number(`${m[2] || '0'}${fraction.padEnd(digits, '0')}`);
+    if (!Number.isSafeInteger(n))
+        return undefined;
+    return m[1] === '-' && n !== 0 ? -n : n;
+}