nexus-shared 3.2.0 → 4.0.0

package/dist/Helpers/NexusDriveAdapter.js

@@ -0,0 +1,207 @@
+import { readFetchResponse } from "./ApiResponses.js";
+import { getApiModules } from "./ApiModules.js";
+import { FileAdapter, fileOwnerKey, pictureLimits } from "./FileAdapter.js";
+import { NexusModule } from "../Interfaces/ApiInterfaces.js";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const text = (value) => (typeof value === "string" && value.trim() ? value : null);
+const count = (value, fallback = 0) => (typeof value === "number" && Number.isFinite(value) ? value : fallback);
+/** Drive's `EFileKinds` flags, and the MIME type of each. */
+const NEXUS_FILE_KINDS = [
+    [1, "image/png"],
+    [2, "image/jpeg"],
+    [4, "image/webp"],
+    [8, "application/pdf"],
+];
+/** The Drive refusal that says a ticket ran out (DRV_X011): asked again once, with a fresh ticket. */
+const TICKET_RAN_OUT = "DRV_X011";
+/**
+ * Why an owner's files are read only when its module refuses a write ticket with a 404 but a read ticket finds it: the
+ * owner is not in use now (pending, ended, in the trash or deleted). Its files stay where they are.
+ */
+export const OWNER_NOT_IN_USE_REASON = "This record is not in use now, so its files can be seen but not changed.";
+/** A ticket is used until this long before it runs out, so a slow upload never carries one that expires on the way. */
+const TICKET_MARGIN_MS = 60_000;
+/**
+ * The Nexus Drive (`Nexus.Drives`, `App/Api/File/...`) behind the owner modules' tickets (`App/Api/Files/...`).
+ * Register another with `defineFileAdapter` to keep files elsewhere.
+ */
+export class NexusDriveAdapter extends FileAdapter {
+    drive;
+    editorPointer;
+    tickets = new Map();
+    client;
+    fetcher;
+    constructor(options) {
+        super();
+        this.client = options.client;
+        this.fetcher = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+        this.drive = options.drive ?? NexusModule.Drive;
+        this.editorPointer = options.editorPointer ?? "nexus-image-editor.txt";
+    }
+    driveEndpoint(method, path, extras = {}) {
+        return { module: this.drive, path, method, ...extras };
+    }
+    /** A write ticket for the owner, kept while it is good. */
+    async writeTicket(owner, signal, fresh = false) {
+        const key = fileOwnerKey(owner);
+        const kept = this.tickets.get(key);
+        if (!fresh && kept && kept.until > Date.now())
+            return { ok: true, result: kept.ticket };
+        const answer = await this.client.send({ module: owner.module, path: "Files/Ticket/{category}/{ownerId}", method: "POST" }, {
+            params: { category: owner.category, ownerId: owner.ownerId },
+            signal,
+            toast: false,
+        });
+        const ticket = isRecord(answer.result) ? text(answer.result.ticket) : null;
+        if (!answer.ok || !ticket) {
+            this.tickets.delete(key);
+            return { ...answer, ok: false, result: undefined };
+        }
+        const expires = isRecord(answer.result) ? Date.parse(String(answer.result.expiresAt ?? "")) : NaN;
+        // Kept only when the backend's end is ahead of this clock by more than the margin; a clock that is ahead asks each time.
+        if (Number.isFinite(expires) && expires - TICKET_MARGIN_MS > Date.now())
+            this.tickets.set(key, { ticket, until: expires - TICKET_MARGIN_MS });
+        return { ...answer, result: ticket };
+    }
+    /** Calls Drive with the owner's write ticket, asking for a fresh one once when Drive says it ran out. */
+    async withTicket(owner, options, call) {
+        for (const fresh of [false, true]) {
+            const ticket = await this.writeTicket(owner, options.signal, fresh);
+            if (!ticket.ok)
+                return ticket;
+            const answer = await call(ticket.result);
+            if (answer.ok || answer.messageCode !== TICKET_RAN_OUT || fresh)
+                return answer;
+        }
+        return { ok: false };
+    }
+    /** A read ticket for several owners of one category. */
+    async readTicket(module, category, ownerIds, signal) {
+        const answer = await this.client.send({ module, path: "Files/Owners/{category}", method: "POST" }, {
+            params: { category },
+            body: { ownerIds },
+            signal,
+            toast: false,
+        });
+        const ticket = isRecord(answer.result) ? text(answer.result.ticket) : null;
+        return answer.ok && ticket ? { ...answer, result: ticket } : { ...answer, ok: false, result: undefined };
+    }
+    async list(owner, options = {}) {
+        const read = (ticket) => this.client.send(this.driveEndpoint("POST", "File/List"), { body: { ticket }, signal: options.signal, toast: false });
+        let answer = await this.withTicket(owner, options, read);
+        // No write ticket for this person (a key they do not hold, an owner they may only see): their files, read only, and
+        // the refusal's words as the reason. A 404 is an owner not in use - pending, ended, in the trash or deleted - that a
+        // read ticket still finds: "The record was not found." under its files would be untrue, so it says what it is.
+        let refused;
+        if (!answer.ok && (answer.status === 403 || answer.status === 404) && owner.ownerId !== "me" && !answer.aborted) {
+            refused = answer.status === 404 ? OWNER_NOT_IN_USE_REASON : answer.message;
+            const ticket = await this.readTicket(owner.module, owner.category, [owner.ownerId], options.signal);
+            if (ticket.ok)
+                answer = await read(ticket.result);
+        }
+        if (!answer.ok)
+            return answer;
+        const files = readOwnerFiles(answer.result);
+        if (refused && !files.category.canWrite)
+            files.readOnlyReason = refused;
+        return { ...answer, result: files };
+    }
+    async primaries(module, category, ownerIds, options = {}) {
+        if (ownerIds.length === 0)
+            return { ok: true, result: [] };
+        const ticket = await this.readTicket(module, category, ownerIds, options.signal);
+        if (!ticket.ok)
+            return { ...ticket, result: undefined };
+        const answer = await this.client.send(this.driveEndpoint("POST", "File/Primaries"), { body: { ticket: ticket.result }, signal: options.signal, toast: false });
+        if (!answer.ok)
+            return answer;
+        const files = ownerIds.map(() => null);
+        for (const item of Array.isArray(answer.result) ? answer.result : []) {
+            if (!isRecord(item))
+                continue;
+            const index = count(item.ownerIndex, -1);
+            if (index >= 0 && index < files.length)
+                files[index] = readStoredFile(item.file);
+        }
+        return { ...answer, result: files };
+    }
+    upload(owner, upload, options = {}) {
+        return this.withTicket(owner, options, async (ticket) => {
+            const form = new FormData();
+            form.append("ticket", ticket);
+            form.append("file", upload.file, upload.name);
+            if (upload.thumbnail)
+                form.append("thumbnail", upload.thumbnail, `thumbnail-${upload.name}`);
+            const answer = await this.client.send(this.driveEndpoint("POST", "File/Upload", { bodyType: "form-data" }), { body: form, signal: options.signal, toast: false, timeout: 120_000 });
+            const file = answer.ok ? readStoredFile(answer.result) : null;
+            return answer.ok && file ? { ...answer, result: file } : { ...answer, ok: answer.ok && file !== null, result: undefined };
+        });
+    }
+    setPrimary(owner, fileId, options = {}) {
+        return this.withTicket(owner, options, ticket => this.client.send(this.driveEndpoint("PUT", "File/SetPrimary"), { body: { ticket, id: fileId }, signal: options.signal, toast: false }));
+    }
+    rename(owner, fileId, name, options = {}) {
+        return this.withTicket(owner, options, ticket => this.client.send(this.driveEndpoint("PUT", "File/Rename"), { body: { ticket, id: fileId, fileDisplayName: name }, signal: options.signal, toast: false }));
+    }
+    remove(owner, fileId, options = {}) {
+        return this.withTicket(owner, options, ticket => this.client.send(this.driveEndpoint("DELETE", "File/Delete"), { body: { ticket, id: fileId }, signal: options.signal, toast: false }));
+    }
+    fileUrl(file, copy) {
+        return getApiModules().browserApiUrl(this.driveEndpoint("GET", "File/View/{id}/{size}"), { params: { id: file.id, size: copy === "thumbnail" ? "Thumbnail" : "Original" } });
+    }
+    /** Reads Drive's pointer file (`Assets/File/nexus-image-editor.txt`), which names the versioned module beside it. */
+    async editorModuleUrl(signal) {
+        const asset = (file) => getApiModules().browserApiUrl(this.driveEndpoint("GET", "Assets/File/{file}"), { params: { file } });
+        const response = await this.fetcher(asset(this.editorPointer), { signal, credentials: "same-origin", cache: "no-cache" });
+        if (!response.ok) {
+            const answer = await readFetchResponse(response);
+            throw new Error(answer.message ?? "The image editor could not be loaded.");
+        }
+        const name = (await response.text()).trim();
+        if (!/^[A-Za-z0-9][A-Za-z0-9._-]*\.m?js$/.test(name))
+            throw new Error("The image editor's address on the server is not valid.");
+        return new URL(asset(name), globalThis.location?.href ?? "http://localhost/").href;
+    }
+}
+/** Reads one of Drive's `FileResponseContract`s; null when it is not one. */
+export function readStoredFile(value) {
+    if (!isRecord(value))
+        return null;
+    const id = text(value.id);
+    if (!id)
+        return null;
+    return {
+        id,
+        name: text(value.fileDisplayName) ?? "File",
+        contentType: text(value.contentType) ?? "application/octet-stream",
+        size: count(value.fileSize),
+        width: typeof value.width === "number" ? value.width : null,
+        height: typeof value.height === "number" ? value.height : null,
+        hasThumbnail: value.hasThumbnail === true,
+        isPrimary: value.isPrimary === true,
+        createdAt: text(value.creationTime),
+    };
+}
+/** Reads Drive's `FileListResponseContract`. */
+export function readOwnerFiles(value) {
+    const answer = isRecord(value) ? value : {};
+    const kinds = count(answer.fileKinds);
+    const maxBytes = count(answer.maxFileBytes);
+    // A picture's limits, Drive's settings (`Nexus:Drive:Pictures`); an older Drive says none, and the defaults apply, so
+    // every picture is still made small before it is sent.
+    const pictures = pictureLimits({ maxBytes, pictureMaxSide: count(answer.pictureMaxSide), pictureQuality: count(answer.pictureQuality), pictureMaxBytes: count(answer.pictureMaxBytes) });
+    const category = {
+        code: text(answer.categoryCode) ?? "",
+        name: text(answer.displayName) ?? "Files",
+        types: NEXUS_FILE_KINDS.filter(([flag]) => (kinds & flag) !== 0).map(([, type]) => type),
+        maxBytes,
+        maxCount: count(answer.maxFileCount),
+        thumbnailSize: count(answer.thumbnailSize),
+        canWrite: answer.canWrite === true,
+        pictureMaxSide: pictures.maxSide,
+        pictureQuality: pictures.quality,
+        pictureMaxBytes: pictures.maxBytes,
+    };
+    const files = (Array.isArray(answer.files) ? answer.files : []).map(readStoredFile).filter((file) => file !== null);
+    return { category, files };
+}

package/dist/Helpers/NumberHelpers.d.ts

@@ -28,6 +28,25 @@ export declare function getNumberSymbols(locale?: string): NumberSymbols;
  * Returns "" for `null`, `undefined`, and `NaN`. Digits are always 0–9, and the minus sign is "-", so the text can be typed back.
  */
 export declare function formatNumber(value: number | null | undefined, options?: NumberFormatOptions): string;
+/** How `formatMoney` writes an amount. */
+export interface MoneyFormatOptions {
+    /** Written before the figures with a space: "Rs." gives "Rs. 1,250.00". None: the figures alone. */
+    currency?: string | null;
+    /** Digits after the decimal point, always shown. Default 2. */
+    decimals?: number;
+    /** Locale of the separators, as `formatNumber` takes it (`useNumberLocale()` for the person's). Default `en-US`. */
+    locale?: string;
+    /** What an empty amount (`null`, `undefined`, `NaN`) writes. Default "": a `0` amount is written as one. */
+    empty?: string;
+}
+/**
+ * Money as a company writes it: its currency, then the amount grouped with a fixed number of decimals, the same in a
+ * table's `money` column (`DataTableProps.currency`), a dashboard's figures and a printed receipt.
+ *
+ * @example formatMoney(1250, { currency: "Rs." }) // "Rs. 1,250.00"
+ * @example formatMoney(null, { currency: "Rs.", empty: "-" }) // "-"
+ */
+export declare function formatMoney(value: number | null | undefined, options?: MoneyFormatOptions): string;
 /**
  * Reads a number written in the locale's format: "1,250.50" gives 1250.5, and in `de-DE` "1.250,50" does.
  * Returns `null` for empty text (also a lone minus sign or decimal separator) and `NaN` for text that is not a number.
@@ -75,3 +94,79 @@ export interface StepOptions {
  * step 1 goes up to 3, and stay within `min` and `max`. An empty field starts at 0, or at the limit nearest to 0.
  */
 export declare function stepNumber(value: number | null, direction: 1 | -1, options?: StepOptions): number;
+/** The figures of a price (`priceAmounts`). Each may be missing. */
+export interface PriceAmountsInput {
+    /** The price of one. Missing: 0. */
+    price?: number | null;
+    /** How many. Missing: 1. */
+    quantity?: number | null;
+    /** The discount off the amount, in percent: `5` for 5 %. Missing: 0. */
+    discountPercentage?: number | null;
+    /** The VAT on what is left after the discount, in percent: `13` for 13 %. Missing: 0. */
+    vatPercentage?: number | null;
+}
+/** What a price comes to (`priceAmounts`), each figure at the money's places. */
+export interface PriceAmounts {
+    /** The price times the quantity. */
+    amount: number;
+    /** The discount off the amount. */
+    discountAmount: number;
+    /** The VAT on the amount less the discount. */
+    vatAmount: number;
+    /** The amount less the discount, plus the VAT: what is paid. */
+    netAmount: number;
+}
+/**
+ * What a price comes to, by the Nexus server's own rule (`SubscriberRenewals.Price`, 2026-06-20's `FN_CalculateAmount`):
+ * the amount is the price times the quantity; the discount comes off it; the VAT is on what is left; each rounded to
+ * `places` (default 2), half away from zero, so the lines add up to the net amount exactly as a receipt prints them. The
+ * sums are done on exact decimals, never on floating-point numbers, so a browser shows the server's figure to the paisa.
+ * A missing, null or NaN figure counts as 0, and a missing quantity as 1.
+ *
+ * @example priceAmounts({ price: 1000, discountPercentage: 5, vatPercentage: 13 }) // { amount: 1000, discountAmount: 50, vatAmount: 123.5, netAmount: 1073.5 }
+ * @example priceAmounts({ price: 500, quantity: 3, discountPercentage: 10, vatPercentage: 13 }).netAmount // 1525.5
+ */
+export declare function priceAmounts(input: PriceAmountsInput, places?: number): PriceAmounts;
+/** The fields a row of money keeps its figures in (`priceLadder`). Defaults: the server's `CounterAmounts`. */
+export interface PriceLadderKeys {
+    /** The price of one. Default `unitPrice`. */
+    rate?: string;
+    /** The price times the quantity. Default `amount`. */
+    amount?: string;
+    /** Default `discountPercentage`. */
+    discountPercentage?: string;
+    /** The discount off the amount. Default `discountAmount`. */
+    discount?: string;
+    /** Default `vatPercentage`. */
+    vatPercentage?: string;
+    /** The VAT on what is left. Default `vatAmount`. */
+    vat?: string;
+    /** What is paid. Default `netAmount`. */
+    total?: string;
+}
+/** One line of a money ladder (`priceLadder`): the row's field it reads, its words, and its figure. */
+export interface PriceLadderLine {
+    /** The row's field: `"vatAmount"`. */
+    key: string;
+    /** `"VAT (13%)"`. */
+    label: string;
+    value: number;
+}
+/** How `priceLadder` reads a row and words its lines. */
+export interface PriceLadderOptions {
+    /** The row's fields, where they are not the server's `CounterAmounts` names. */
+    keys?: PriceLadderKeys;
+    /** The locale a percentage is written in: the person's (`useNumberLocale()`). Default `en-US`. */
+    locale?: string;
+    /** The total's words. Default "Calculated amount". */
+    totalLabel?: string;
+}
+/**
+ * A receipt's money ladder as lines any page can draw: **Rate** (left out when the row has none), **Amount**,
+ * **Discount (5%)** and **VAT (13%)** (each left out at 0, as a receipt leaves them out), then the total, "Calculated
+ * amount". A percentage is written with up to 4 places and no trailing zeros (5, 2.5, 3.3333) in `locale`, so a
+ * person whose decimal mark is a comma reads "Discount (2,5%)". The figures are the row's own, never worked out here.
+ *
+ * @example priceLadder(line, { locale: useNumberLocale() }).map(item => `${item.label} ${formatMoney(item.value, { locale })}`)
+ */
+export declare function priceLadder(row: Readonly<Record<string, unknown>>, options?: PriceLadderOptions): PriceLadderLine[];

package/dist/Helpers/NumberHelpers.js

@@ -84,6 +84,21 @@ export function formatNumber(value, options = {}) {
     // The base locales write "," between groups and "." before decimals; a key's own marks take their places.
     return custom ? text.replace(/[,.]/g, mark => (mark === "," ? custom.group : custom.decimal)) : text;
 }
+/**
+ * Money as a company writes it: its currency, then the amount grouped with a fixed number of decimals, the same in a
+ * table's `money` column (`DataTableProps.currency`), a dashboard's figures and a printed receipt.
+ *
+ * @example formatMoney(1250, { currency: "Rs." }) // "Rs. 1,250.00"
+ * @example formatMoney(null, { currency: "Rs.", empty: "-" }) // "-"
+ */
+export function formatMoney(value, options = {}) {
+    const { currency, decimals = 2, locale, empty = "" } = options;
+    if (value === null || value === undefined || !Number.isFinite(value))
+        return empty;
+    const figures = formatNumber(value, { decimals, fixedDecimals: true, grouping: true, locale });
+    const before = (currency ?? "").trim();
+    return before ? `${before} ${figures}` : figures;
+}
 /**
  * Reads a number written in the locale's format: "1,250.50" gives 1250.5, and in `de-DE` "1.250,50" does.
  * Returns `null` for empty text (also a lone minus sign or decimal separator) and `NaN` for text that is not a number.
@@ -238,3 +253,114 @@ export function stepNumber(value, direction, options = {}) {
 function escapeRegExp(text) {
     return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+const BIG_ZERO = BigInt(0);
+const BIG_ONE = BigInt(1);
+const BIG_TWO = BigInt(2);
+const BIG_TEN = BigInt(10);
+/** A number as the exact decimal its shortest text writes (1.005 is 1.005, never 1.00499…): a figure that is not finite is `missing`. */
+function exactDecimal(value, missing) {
+    const figure = typeof value === "number" && Number.isFinite(value) ? value : missing;
+    const [mantissa = "0", exponent = "0"] = String(figure).toLowerCase().split("e");
+    const negative = mantissa.startsWith("-");
+    const [whole = "0", fraction = ""] = mantissa.replace("-", "").split(".");
+    let units = BigInt(`${whole}${fraction}`);
+    let scale = fraction.length - Number(exponent);
+    if (scale < 0) {
+        units *= BIG_TEN ** BigInt(-scale);
+        scale = 0;
+    }
+    return { units: negative ? -units : units, scale };
+}
+/** Rounded to `places`, half away from zero (0.005 is 0.01, -0.005 is -0.01), as .NET's `MidpointRounding.AwayFromZero`. */
+function roundExact(value, places) {
+    if (value.scale <= places)
+        return { units: value.units * BIG_TEN ** BigInt(places - value.scale), scale: places };
+    const divisor = BIG_TEN ** BigInt(value.scale - places);
+    const negative = value.units < BIG_ZERO;
+    const size = negative ? -value.units : value.units;
+    let units = size / divisor;
+    if ((size % divisor) * BIG_TWO >= divisor)
+        units += BIG_ONE;
+    return { units: negative ? -units : units, scale: places };
+}
+/** The exact decimal as a number: through its text, so 1073.50 is the number 1073.5 exactly as typed. */
+function exactNumber(value) {
+    const negative = value.units < BIG_ZERO;
+    const digits = (negative ? -value.units : value.units).toString().padStart(value.scale + 1, "0");
+    const text = value.scale ? `${digits.slice(0, -value.scale)}.${digits.slice(-value.scale)}` : digits;
+    return Number(`${negative ? "-" : ""}${text}`) || 0;
+}
+/**
+ * What a price comes to, by the Nexus server's own rule (`SubscriberRenewals.Price`, 2026-06-20's `FN_CalculateAmount`):
+ * the amount is the price times the quantity; the discount comes off it; the VAT is on what is left; each rounded to
+ * `places` (default 2), half away from zero, so the lines add up to the net amount exactly as a receipt prints them. The
+ * sums are done on exact decimals, never on floating-point numbers, so a browser shows the server's figure to the paisa.
+ * A missing, null or NaN figure counts as 0, and a missing quantity as 1.
+ *
+ * @example priceAmounts({ price: 1000, discountPercentage: 5, vatPercentage: 13 }) // { amount: 1000, discountAmount: 50, vatAmount: 123.5, netAmount: 1073.5 }
+ * @example priceAmounts({ price: 500, quantity: 3, discountPercentage: 10, vatPercentage: 13 }).netAmount // 1525.5
+ */
+export function priceAmounts(input, places = 2) {
+    const digits = Math.max(0, Math.min(MAX_NUMBER_DIGITS, Math.trunc(places) || 0));
+    const price = exactDecimal(input.price, 0);
+    const quantity = exactDecimal(input.quantity, 1);
+    const discountRate = exactDecimal(input.discountPercentage, 0);
+    const vatRate = exactDecimal(input.vatPercentage, 0);
+    // A percent of an exact decimal: the product, two places further down.
+    const percentOf = (base, rate) => ({ units: base.units * rate.units, scale: base.scale + rate.scale + 2 });
+    const amount = roundExact({ units: price.units * quantity.units, scale: price.scale + quantity.scale }, digits);
+    const discount = roundExact(percentOf(amount, discountRate), digits);
+    const vat = roundExact(percentOf({ units: amount.units - discount.units, scale: digits }, vatRate), digits);
+    const net = { units: amount.units - discount.units + vat.units, scale: digits };
+    return { amount: exactNumber(amount), discountAmount: exactNumber(discount), vatAmount: exactNumber(vat), netAmount: exactNumber(net) };
+}
+/** Most places a percentage keeps (12.3456 %), as a price list keeps it; trailing zeros are not written. */
+const PERCENT_PLACES = 4;
+/** A row's figure as a number: a number or the text of one; anything else is missing. */
+function figureOf(row, key) {
+    const value = row[key];
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : null;
+    if (typeof value === "string" && value.trim() !== "") {
+        const number = Number(value);
+        return Number.isFinite(number) ? number : null;
+    }
+    return null;
+}
+/**
+ * A receipt's money ladder as lines any page can draw: **Rate** (left out when the row has none), **Amount**,
+ * **Discount (5%)** and **VAT (13%)** (each left out at 0, as a receipt leaves them out), then the total, "Calculated
+ * amount". A percentage is written with up to 4 places and no trailing zeros (5, 2.5, 3.3333) in `locale`, so a
+ * person whose decimal mark is a comma reads "Discount (2,5%)". The figures are the row's own, never worked out here.
+ *
+ * @example priceLadder(line, { locale: useNumberLocale() }).map(item => `${item.label} ${formatMoney(item.value, { locale })}`)
+ */
+export function priceLadder(row, options = {}) {
+    const { keys = {}, locale, totalLabel = "Calculated amount" } = options;
+    const key = {
+        rate: keys.rate ?? "unitPrice",
+        amount: keys.amount ?? "amount",
+        discountPercentage: keys.discountPercentage ?? "discountPercentage",
+        discount: keys.discount ?? "discountAmount",
+        vatPercentage: keys.vatPercentage ?? "vatPercentage",
+        vat: keys.vat ?? "vatAmount",
+        total: keys.total ?? "netAmount",
+    };
+    const percent = (field, words) => {
+        const rate = figureOf(row, field);
+        return rate === null ? words : `${words} (${formatNumber(rate, { decimals: PERCENT_PLACES, locale })}%)`;
+    };
+    const lines = [];
+    const rate = figureOf(row, key.rate);
+    if (rate !== null)
+        lines.push({ key: key.rate, label: "Rate", value: rate });
+    lines.push({ key: key.amount, label: "Amount", value: figureOf(row, key.amount) ?? 0 });
+    const discount = figureOf(row, key.discount);
+    if (discount)
+        lines.push({ key: key.discount, label: percent(key.discountPercentage, "Discount"), value: discount });
+    const vat = figureOf(row, key.vat);
+    if (vat)
+        lines.push({ key: key.vat, label: percent(key.vatPercentage, "VAT"), value: vat });
+    lines.push({ key: key.total, label: totalLabel, value: figureOf(row, key.total) ?? 0 });
+    return lines;
+}

package/dist/Helpers/Permissions.js

@@ -1,6 +1,7 @@
 /*
  * Permissions: may the user call this endpoint? Components ask before they show a button or a list (the CRUD's Add,
- * Delete, and its Trash list), so a user sees only what they may do; the server still checks every call.
+ * Delete, and its Trash list, a table's spreadsheet items), so a user sees only what they may do; the server still
+ * checks every call.
  *
  * `Permissions` is the interface an app implements, for its own backend's rules; `NexusPermissions` reads the Nexus
  * backend's access actions. Register one with `definePermissions`. Until then everything is allowed, which suits an

package/dist/Helpers/QrCode.d.ts

@@ -0,0 +1,26 @@
+export type QrLevel = "L" | "M" | "Q" | "H";
+/** A finished QR code. Modules are addressed by column x and row y, from the top-left corner. */
+export interface QrCode {
+    /** 1 to 40: the code is 17 + 4 x version modules a side. */
+    readonly version: number;
+    /** Modules a side, without the quiet zone. */
+    readonly size: number;
+    readonly level: QrLevel;
+    /** The mask pattern, 0 to 7, that scored best. */
+    readonly mask: number;
+    /** Whether the module at column x, row y is dark. Outside the code, in its quiet zone, every module is light. */
+    isDark(x: number, y: number): boolean;
+}
+/**
+ * The text as a QR code at the level asked (M unless told), in the smallest version that holds it. Throws when the
+ * text is too long even for version 40: 2,953 bytes of UTF-8 at L, 2,331 at M, 1,663 at Q, 1,273 at H.
+ */
+export declare function encodeQr(text: string, level?: QrLevel): QrCode;
+/**
+ * The code as one SVG path in a square viewBox, with `border` light modules around it (4, the quiet zone the standard
+ * asks for). Each run of dark modules along a row is one rectangle.
+ */
+export declare function qrPath(code: QrCode, border?: number): {
+    viewBox: string;
+    d: string;
+};