@happyvertical/smrt-planner 0.0.0-stage → 0.0.2

package/dist/data/fakes.js

@@ -0,0 +1,443 @@
+import { isLineModel } from "./derived.js";
+import { GENERIC_PACK, getSamplePack, getSampleTaxRate, } from "./packs.js";
+/** Deterministic PRNG (mulberry32): the same seed always yields the same run. */
+export function createRandom(seed) {
+    let state = seed >>> 0;
+    return () => {
+        state = (state + 0x6d2b79f5) >>> 0;
+        let t = state;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** FNV-1a hash of a string, for seeding. */
+export function hashString(value) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < value.length; i++) {
+        hash ^= value.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}
+const MONEY_NAME = /(price|amount|cost|total|balance|fee|tax|revenue|budget|salary|wage|subtotal|discount|spend|payout|commission|credit|debit|charge|refund|fare|rent)/i;
+const NOT_MONEY_NAME = /(count|quantity|qty|percent|ratio|level)/i;
+/**
+ * Money is stored as integer minor units (cents). A field is money when it is
+ * an integer whose name says so; everything else numeric is a plain number.
+ */
+export function isMoneyField(field) {
+    return (field.type === 'integer' &&
+        MONEY_NAME.test(field.name) &&
+        !NOT_MONEY_NAME.test(field.name));
+}
+const WORDS = [
+    'Harbor',
+    'Maple',
+    'Summit',
+    'Cedar',
+    'Willow',
+    'Copper',
+    'Juniper',
+    'Atlas',
+    'Meadow',
+    'Granite',
+    'Lantern',
+    'Orchard',
+    'Saffron',
+    'Timber',
+    'Velvet',
+    'Beacon',
+];
+const NOUNS = [
+    'Goods',
+    'Supply',
+    'Studio',
+    'Works',
+    'Market',
+    'Collective',
+    'Trading',
+    'Labs',
+];
+/**
+ * Things a shop sells, with a price in cents. Sample products and SKUs take
+ * their names from here by row index, and a line item pointing at product `n`
+ * reads as that product, so a picked product and a sample line agree.
+ */
+export const PRODUCT_CATALOG = GENERIC_PACK.products;
+const FIRST = ['Ada', 'Grace', 'Alan', 'Linus', 'Mae', 'Jun', 'Priya', 'Omar'];
+const LAST = ['Nguyen', 'Garcia', 'Okafor', 'Silva', 'Kim', 'Haddad', 'Rossi'];
+const SENTENCES = [
+    'Reviewed and approved by the team.',
+    'Waiting on a reply from the customer.',
+    'Imported from the previous system.',
+    'Scheduled for the next cycle.',
+    'Flagged for follow-up next week.',
+];
+/** Fixed clock so seeded timestamps never change between runs. */
+export const EPOCH = Date.UTC(2026, 0, 1);
+const YEAR = 365 * 24 * 60 * 60 * 1000;
+function pick(random, list) {
+    return list[Math.floor(random() * list.length)];
+}
+/** Pick by weight; values without a weight count 0, and all-zero falls back to uniform. */
+function pickWeighted(random, values, weights) {
+    const total = values.reduce((sum, v) => sum + (weights[v] ?? 0), 0);
+    if (total <= 0)
+        return pick(random, values);
+    let at = random() * total;
+    for (const value of values) {
+        at -= weights[value] ?? 0;
+        if (at < 0)
+            return value;
+    }
+    return values[values.length - 1];
+}
+/** A UUID-shaped id derived from a seed string. */
+export function fakeId(seed) {
+    const random = createRandom(hashString(seed));
+    const hex = (n) => Array.from({ length: n }, () => Math.floor(random() * 16).toString(16)).join('');
+    return `${hex(8)}-${hex(4)}-4${hex(3)}-a${hex(3)}-${hex(12)}`;
+}
+const TERMS = [
+    'Net 30',
+    'Net 15',
+    'Net 60',
+    'Due on receipt',
+    '50% deposit, balance on delivery',
+];
+const CHANNELS = ['web', 'retail', 'phone', 'marketplace', 'wholesale'];
+const PERIODS = ['monthly', 'quarterly', 'annual'];
+/** Fractions a tax rate takes: 0%, 5%, 8.25%, 13% and 20%. */
+export const TAX_RATES = [0, 0.05, 0.0825, 0.13, 0.2];
+function fakeText(field, random, modelName = '') {
+    const name = field.name.toLowerCase();
+    if (/terms/.test(name))
+        return pick(random, getSamplePack().terms ?? TERMS);
+    if (/channel/.test(name))
+        return pick(random, CHANNELS);
+    if (/period/.test(name))
+        return pick(random, PERIODS);
+    if (/^(unit|uom)$/.test(name))
+        return pick(random, ['each', 'hour', 'box']);
+    if (/email/.test(name)) {
+        return `${pick(random, FIRST).toLowerCase()}@example.com`;
+    }
+    if (/(^|_)(url|link|website|href)/.test(name) || /url$/.test(name)) {
+        return `https://example.com/${pick(random, WORDS).toLowerCase()}`;
+    }
+    if (/phone/.test(name)) {
+        return `+1-555-01${Math.floor(random() * 90 + 10)}`;
+    }
+    // Notes are about a person or a job; a description says what a thing is.
+    // Each has its own vocabulary: a class is never described by a member's note.
+    if (/(notes?|comment|message)/.test(name)) {
+        const pack = getSamplePack();
+        const own = modelName === 'Customer'
+            ? pack.customerNotes
+            : modelName === 'Vendor'
+                ? pack.vendorNotes
+                : undefined;
+        return pick(random, own ?? pack.notes ?? SENTENCES);
+    }
+    if (/(description|summary|body|content|bio)/.test(name)) {
+        return pick(random, getSamplePack().descriptions?.[modelName] ?? SENTENCES);
+    }
+    if (/(firstname|first_name)/.test(name))
+        return pick(random, FIRST);
+    if (/(lastname|last_name|surname)/.test(name))
+        return pick(random, LAST);
+    // Tax and business registration numbers are identifiers, never names.
+    if (/(tax_?id|vat|^ein$|abn|gst|registration)/.test(name)) {
+        return `${Math.floor(random() * 90 + 10)}-${Math.floor(random() * 9_000_000 + 1_000_000)}`;
+    }
+    if (/(code|sku|barcode|number|reference)/.test(name)) {
+        return `${pick(random, WORDS).slice(0, 3).toUpperCase()}-${Math.floor(random() * 9000 + 1000)}`;
+    }
+    if (/(status|state|stage)/.test(name)) {
+        return pick(random, ['active', 'pending', 'archived', 'draft']);
+    }
+    if (/(currency)/.test(name))
+        return 'USD';
+    if (/(person|owner|author|contact|assignee|worker)/.test(name)) {
+        return `${pick(random, FIRST)} ${pick(random, LAST)}`;
+    }
+    return `${pick(random, WORDS)} ${pick(random, NOUNS)}`;
+}
+/**
+ * Sample rows per model where the default count does not fit: every Customer
+ * and Vendor gets its own Profile, so the lists show different names.
+ * Customers use Profiles 0-7, Vendors 8-12 and the pack's instructors 13 on
+ * (`sampleRowCount` adds them).
+ */
+const PROFILE_MODEL = '@happyvertical/smrt-profiles:Profile';
+export const SAMPLE_ROW_COUNTS = {
+    '@happyvertical/smrt-profiles:Profile': 13,
+    '@happyvertical/smrt-commerce:Vendor': 5,
+};
+/** Sample rows for a model: the pack's count, else the shared one, else `fallback`. */
+export function sampleRowCount(modelId, fallback) {
+    // Profiles: customers, then vendors, then the pack's instructors.
+    if (modelId === PROFILE_MODEL) {
+        return ((getSamplePack().rowCounts?.[modelId] ??
+            SAMPLE_ROW_COUNTS[modelId] ??
+            fallback) + (getSamplePack().instructors?.length ?? 0));
+    }
+    return (getSamplePack().rowCounts?.[modelId] ??
+        SAMPLE_ROW_COUNTS[modelId] ??
+        fallback);
+}
+/**
+ * Which row of the target a sample relation points at. Rows are seeded with
+ * ids from `(model, index)`, so pointing at index `n` points at a real row.
+ */
+function relatedIndex(field, context) {
+    const instructors = getSamplePack().instructors;
+    if (field.name === 'organizerId' && instructors?.length) {
+        // Organizers lead classes and jobs; they are staff, never customers.
+        return 13 + (context.index % instructors.length);
+    }
+    if (field.name === 'profileId') {
+        if (context.modelId.endsWith(':Vendor'))
+            return 8 + (context.index % 5);
+        // Sign-ups and the like point at a customer's Profile, whatever their
+        // own row index (child rows are numbered up to 996).
+        return context.modelId.endsWith(':Customer')
+            ? context.index
+            : context.index % 8;
+    }
+    return context.index % 5;
+}
+/** One fake value for a field. Money is an integer number of minor units. */
+export function fakeValue(field, random, context) {
+    // A declared enumeration: only its values are valid.
+    if (field.enum && field.enum.length > 0) {
+        const weights = getSamplePack().weights?.[`${context.modelId.split(':').pop()}.${field.name}`];
+        return weights
+            ? pickWeighted(random, field.enum, weights)
+            : pick(random, field.enum);
+    }
+    switch (field.type) {
+        case 'boolean':
+            return random() < 0.7;
+        case 'integer': {
+            if (isMoneyField(field))
+                return (Math.floor(random() * 4950) + 50) * 10;
+            if (/(quantity|qty|count|stock|on_?hand)/i.test(field.name)) {
+                return Math.floor(random() * 200);
+            }
+            if (/(level|sortorder|position|order)/i.test(field.name)) {
+                return Math.floor(random() * 5);
+            }
+            return Math.floor(random() * 100);
+        }
+        case 'decimal':
+            if (/taxrate|vatrate/i.test(field.name)) {
+                // A cookbook's default rate (0: untaxed) beats a random one.
+                const rate = getSampleTaxRate();
+                return rate ?? pick(random, TAX_RATES);
+            }
+            if (/discountrate/i.test(field.name))
+                return pick(random, [0, 0.05, 0.1]);
+            if (/(quantity|qty)/i.test(field.name))
+                return 1 + Math.floor(random() * 5);
+            return Math.round(random() * 10000) / 100;
+        case 'datetime':
+            return new Date(EPOCH - Math.floor(random() * YEAR)).toISOString();
+        case 'json':
+            return Array.isArray(field.default) ? [] : {};
+        case 'foreignKey':
+        case 'crossPackageRef':
+            return fakeId(`${field.related ?? field.name}:${relatedIndex(field, context)}`);
+        default:
+            return fakeText(field, random, context.modelId.split(':').pop());
+    }
+}
+/** Fields a person edits: everything the framework does not manage. */
+export function editableFields(model) {
+    return model.fields.filter((f) => !f.system);
+}
+export const DAY = 24 * 60 * 60 * 1000;
+function dateStage(name) {
+    const n = name.toLowerCase();
+    if (/^last/.test(n))
+        return null;
+    if (/(expir|enddate|endat|endsat|endedat|ends|until|closed|cancel|periodend|effectiveto|windowend|trialends|void|revoked)/.test(n))
+        return 'end';
+    if (/(due|deadline|schedul|renew|nextrun|estimated|expected|payable)/.test(n))
+        return 'due';
+    if (/(updated|modified|paid|ship|deliver|settled|resolved|completed|approved|confirmed|received|accepted|reviewed|verified|published|posted|viewed|decided|finalized)/.test(n))
+        return 'event';
+    if (/(issue|startdate|startat|startsat|startedat|periodstart|effectivedate|effectivefrom|windowstart|sentat|occurredat|requestedat|submittedat|^date$|^timestamp$|publish_date|balancefrom)/.test(n))
+        return 'start';
+    return null;
+}
+/**
+ * Makes a record's dates agree with each other: issued/start first, then what
+ * happens to it, then due, then expiry/end. Deterministic, as every offset
+ * comes from the record's own random stream.
+ */
+function orderDates(model, record, random) {
+    const dated = model.fields
+        .filter((f) => !f.system && f.type === 'datetime' && !f.enum)
+        .flatMap((field) => {
+        const stage = dateStage(field.name);
+        return stage ? [{ field, stage }] : [];
+    });
+    if (dated.length === 0)
+        return;
+    const first = dated.find((d) => d.stage === 'start');
+    const anchor = first
+        ? Date.parse(String(record[first.field.name]))
+        : EPOCH - Math.floor(random() * YEAR);
+    const event = Math.min(anchor + (1 + Math.floor(random() * 20)) * DAY, EPOCH);
+    const due = Math.max(event, anchor) + (14 + Math.floor(random() * 32)) * DAY;
+    const end = due + (30 + Math.floor(random() * 150)) * DAY;
+    const at = { start: anchor, event, due, end };
+    for (const { field, stage } of dated) {
+        record[field.name] = new Date(at[stage]).toISOString();
+    }
+}
+const has = (model, name) => model.fields.some((f) => f.name === name);
+/**
+ * Products and SKUs are called things ("Canvas tote"), not companies, and a
+ * line item describes the item it sells rather than quoting a status.
+ */
+function nameThings(model, record, index, random) {
+    // Most payments went through; the rest are pending, failed or refunded.
+    const status = model.fields.find((f) => f.name === 'status');
+    if (model.id.endsWith(':Payment') &&
+        status?.enum?.includes('completed') &&
+        random() < 0.6) {
+        record.status = 'completed';
+    }
+    const pack = getSamplePack();
+    nameFromPack(model, record, index, pack);
+    const item = pack.products[index % pack.products.length];
+    if (!item)
+        return;
+    if (/:(Product|Sku)$/.test(model.id)) {
+        if (has(model, 'name'))
+            record.name = item.name;
+        if (has(model, 'price'))
+            record.price = item.price;
+        if (model.id.endsWith(':Product')) {
+            if (has(model, 'description')) {
+                // The generic template belongs to the generic pack only.
+                const fallback = pack.id === GENERIC_PACK.id
+                    ? `${item.name}, made in small batches.`
+                    : item.name;
+                record.description = item.description ?? fallback;
+            }
+            if (item.category && has(model, 'category')) {
+                record.category = item.category;
+            }
+            if (item.productType && has(model, 'productType')) {
+                record.productType = item.productType;
+            }
+        }
+        return;
+    }
+    if (isLineModel(model) && has(model, 'description')) {
+        const lines = pack.lines ?? pack.products.map((p) => ({ description: p.name }));
+        const line = lines[Math.floor(random() * lines.length)];
+        if (line)
+            record.description = line.description;
+    }
+}
+/**
+ * Names a pack supplies for whole models: customers and vendors (their
+ * Profiles), events and their types and series, places and their types. Packs without them leave the
+ * generic words in place.
+ */
+function nameFromPack(model, record, index, pack) {
+    const at = (list, i) => list?.length ? list[i % list.length] : undefined;
+    if (model.id.endsWith(':Profile') && has(model, 'name')) {
+        // Customers use Profiles 0-7, Vendors 8-12, instructors 13 on (see
+        // SAMPLE_ROW_COUNTS).
+        const name = index < 8
+            ? at(pack.customers, index)
+            : index < 13
+                ? at(pack.vendors, index - 8)
+                : at(pack.instructors, index - 13);
+        if (name) {
+            record.name = name;
+            if (has(model, 'email')) {
+                const local = name
+                    .toLowerCase()
+                    .replace(/[^a-z0-9]+/g, '.')
+                    .replace(/^\.+|\.+$/g, '');
+                record.email = `${local}@example.com`;
+            }
+        }
+        return;
+    }
+    const short = model.id.split(':').pop() ?? '';
+    if (short === 'EventParticipant') {
+        // A sign-up points at a member's Profile; every fifth is the instructor.
+        const instructors = pack.instructors;
+        const teaches = Boolean(instructors?.length) && index % 5 === 0;
+        if (has(model, 'profileId')) {
+            record.profileId = fakeId(`${PROFILE_MODEL}:${teaches && instructors
+                ? 13 + (Math.floor(index / 5) % instructors.length)
+                : index % 8}`);
+        }
+        if (has(model, 'role'))
+            record.role = teaches ? 'instructor' : 'attendee';
+        return;
+    }
+    if (has(model, 'allDay') && typeof record.startDate === 'string') {
+        // Events happen at a time of day: on the hour, between 6 and 20 h, for an hour.
+        const day = Date.parse(record.startDate) - (Date.parse(record.startDate) % DAY);
+        const start = day + (6 + (index % 15)) * 60 * 60 * 1000;
+        record.startDate = new Date(start).toISOString();
+        if (has(model, 'endDate')) {
+            record.endDate = new Date(start + 60 * 60 * 1000).toISOString();
+        }
+    }
+    const names = {
+        Event: pack.eventNames,
+        EventType: pack.eventTypes,
+        EventSeries: pack.seriesNames,
+        Place: pack.placeNames,
+        PlaceType: pack.placeTypes,
+    };
+    const list = names[short];
+    const name = at(list, index);
+    if (name && has(model, 'name'))
+        record.name = name;
+    // A description list lines up with the names: entry n describes name n.
+    const description = at(pack.descriptions?.[short], index);
+    if (description && list && has(model, 'description')) {
+        record.description = description;
+    }
+}
+/**
+ * The line a sample line item reads as when the pack describes lines apart
+ * from products (labour, fabrication, passes); `undefined` for packs whose
+ * lines are their products.
+ */
+export function packLine(index) {
+    const lines = getSamplePack().lines;
+    return lines?.length ? lines[index % lines.length] : undefined;
+}
+/** A single seeded record for a model. */
+export function fakeRecord(model, index, seed) {
+    const random = createRandom(hashString(`${seed}:${model.id}:${index}`));
+    const record = { id: fakeId(`${model.id}:${index}`) };
+    for (const field of model.fields) {
+        if (field.system)
+            continue;
+        record[field.name] = fakeValue(field, random, {
+            modelId: model.id,
+            index,
+        });
+    }
+    orderDates(model, record, createRandom(hashString(`${seed}:${model.id}:${index}:dates`)));
+    nameThings(model, record, index, random);
+    return record;
+}
+/** `count` seeded records for a model. */
+export function fakeRecords(model, count, seed = 1) {
+    return Array.from({ length: count }, (_, i) => fakeRecord(model, i, seed));
+}

package/dist/data/format.d.ts

@@ -0,0 +1,48 @@
+import type { CatalogField } from '../catalog/types.ts';
+/** Integer minor units (cents) as a display string, e.g. `1999` -> `$19.99`. */
+export declare function formatMoney(minorUnits: number): string;
+/** Key of a related record in the label map a list view loads. */
+export declare const labelKey: (modelId: string, id: unknown) => string;
+/**
+ * Display text for one cell of a generated list view. A related record shows
+ * its label from `labels` (see `relationLabels`), and only falls back to a
+ * short id when the record is gone.
+ */
+export declare function formatValue(field: CatalogField & {
+    showTime?: boolean;
+}, value: unknown, labels?: ReadonlyMap<string, string>): string;
+/** Parse a money input given in major units (`"19.99"`) to integer cents. */
+export declare function parseMoney(input: string): number;
+/** Humanize `productCount` / `product_count` as `Product count`. */
+export declare function humanize(name: string): string;
+/** English plural of a model's label: "Agreement" -> "Agreements". */
+export declare function pluralize(label: string): string;
+/**
+ * Singular of a menu label's last word: "Sales Orders" -> "Sales Order",
+ * "Currencies" -> "Currency". A label that is not plural is left as it is.
+ */
+export declare function singularize(label: string): string;
+/** What New creates for a menu entry: its declared noun, else the label's singular. */
+export declare function navNoun(label: string, noun?: string): string;
+/**
+ * What a New button or form heading names. A page with one way to create a
+ * record uses the menu entry's noun ("part", "member"); with several forms
+ * (Simple, Clothing) each keeps its own label.
+ */
+export declare function createNoun(formLabel: string, noun: string | undefined, onlyForm: boolean): string;
+/** "1 record", "8 records". */
+export declare function recordCount(count: number): string;
+/**
+ * A field's label: its humanized name, except a relation, which names the
+ * record it points at ("Product", not "Product id").
+ */
+export declare function fieldLabel(field: CatalogField): string;
+/** A fraction as a percentage: `0.0825` -> `8.25%`. */
+export declare function formatPercent(fraction: number): string;
+/** Rates stored as fractions (0.05 is 5%); other `*Rate` fields are unknown. */
+export declare const isFractionRate: (field: CatalogField) => boolean;
+/**
+ * Text for an enum value: `qc_hold` is "Qc hold", and a short code such as
+ * `dtc` stays an acronym ("DTC"). The stored value never changes.
+ */
+export declare function enumLabel(value: string): string;

package/dist/data/format.js

@@ -0,0 +1,121 @@
+import { isMoneyField } from "./fakes.js";
+const currency = new Intl.NumberFormat('en-US', {
+    style: 'currency',
+    currency: 'USD',
+});
+/** Integer minor units (cents) as a display string, e.g. `1999` -> `$19.99`. */
+export function formatMoney(minorUnits) {
+    return currency.format(minorUnits / 100);
+}
+/** Key of a related record in the label map a list view loads. */
+export const labelKey = (modelId, id) => `${modelId}:${String(id)}`;
+/**
+ * Display text for one cell of a generated list view. A related record shows
+ * its label from `labels` (see `relationLabels`), and only falls back to a
+ * short id when the record is gone.
+ */
+export function formatValue(field, value, labels) {
+    if (value === null || value === undefined || value === '')
+        return '';
+    if (isMoneyField(field) && typeof value === 'number') {
+        return formatMoney(value);
+    }
+    if (field.enum?.includes(String(value)))
+        return enumLabel(String(value));
+    if (isFractionRate(field) && typeof value === 'number') {
+        return formatPercent(value);
+    }
+    switch (field.type) {
+        case 'boolean':
+            return value ? 'Yes' : 'No';
+        case 'datetime':
+            // A list of things that happen at a time (classes) shows it too.
+            return field.showTime
+                ? String(value).slice(0, 16).replace('T', ' ')
+                : String(value).slice(0, 10);
+        case 'foreignKey':
+        case 'crossPackageRef':
+            return ((field.related && labels?.get(labelKey(field.related, value))) ||
+                String(value).slice(0, 8));
+        case 'json':
+            return JSON.stringify(value);
+        default:
+            return String(value);
+    }
+}
+/** Parse a money input given in major units (`"19.99"`) to integer cents. */
+export function parseMoney(input) {
+    const value = Number.parseFloat(input);
+    return Number.isFinite(value) ? Math.round(value * 100) : 0;
+}
+/** Humanize `productCount` / `product_count` as `Product count`. */
+export function humanize(name) {
+    const spaced = name
+        .replace(/_/g, ' ')
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .toLowerCase();
+    return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+/** English plural of a model's label: "Agreement" -> "Agreements". */
+export function pluralize(label) {
+    if (/[^aeiou]y$/i.test(label))
+        return `${label.slice(0, -1)}ies`;
+    if (/(s|x|z|ch|sh)$/i.test(label))
+        return `${label}es`;
+    return `${label}s`;
+}
+/**
+ * Singular of a menu label's last word: "Sales Orders" -> "Sales Order",
+ * "Currencies" -> "Currency". A label that is not plural is left as it is.
+ */
+export function singularize(label) {
+    if (/(series|species)$/i.test(label))
+        return label;
+    if (/[^aeiou]ies$/i.test(label))
+        return `${label.slice(0, -3)}y`;
+    if (/(ss|x|z|ch|sh)es$/i.test(label))
+        return label.slice(0, -2);
+    if (/[^s]s$/i.test(label))
+        return label.slice(0, -1);
+    return label;
+}
+/** What New creates for a menu entry: its declared noun, else the label's singular. */
+export function navNoun(label, noun) {
+    return (noun?.trim() || singularize(label)).toLowerCase();
+}
+/**
+ * What a New button or form heading names. A page with one way to create a
+ * record uses the menu entry's noun ("part", "member"); with several forms
+ * (Simple, Clothing) each keeps its own label.
+ */
+export function createNoun(formLabel, noun, onlyForm) {
+    return onlyForm && noun?.trim() ? noun.trim() : formLabel.toLowerCase();
+}
+/** "1 record", "8 records". */
+export function recordCount(count) {
+    return `${count} ${count === 1 ? 'record' : 'records'}`;
+}
+/**
+ * A field's label: its humanized name, except a relation, which names the
+ * record it points at ("Product", not "Product id").
+ */
+export function fieldLabel(field) {
+    const isRelation = field.type === 'foreignKey' || field.type === 'crossPackageRef';
+    const name = isRelation && /[a-z]Id$/.test(field.name)
+        ? field.name.slice(0, -2)
+        : field.name;
+    return humanize(name);
+}
+/** A fraction as a percentage: `0.0825` -> `8.25%`. */
+export function formatPercent(fraction) {
+    return `${Number((fraction * 100).toFixed(2))}%`;
+}
+/** Rates stored as fractions (0.05 is 5%); other `*Rate` fields are unknown. */
+export const isFractionRate = (field) => field.type === 'decimal' && /^(tax|discount|vat)Rate$/.test(field.name);
+/**
+ * Text for an enum value: `qc_hold` is "Qc hold", and a short code such as
+ * `dtc` stays an acronym ("DTC"). The stored value never changes.
+ */
+export function enumLabel(value) {
+    return /^[a-z]{1,3}$/.test(value) ? value.toUpperCase() : humanize(value);
+}

package/dist/data/labels.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Labels for related records, and the searches the relation selectors run.
+ * Everything goes through the `DataSource`, so live collections replace the
+ * fakes without touching a view.
+ *
+ * A record is labelled by its own `display.label` field (the first of `name`,
+ * `title`, `label`, `code` when undeclared; see `display.ts`). A
+ * Customer or Vendor has none: its name lives on its Profile, so it is joined
+ * to one (the "ship a selector instead" case of happyvertical/smrt#3599).
+ */
+import type { RelationOption } from '@happyvertical/smrt-svelte/forms';
+import type { CatalogField, CatalogModel } from '../catalog/types.ts';
+import type { CustomerDisplayData, VendorDisplayData } from '../upstream/partyTypes.ts';
+import type { DataSource, ModelRecord } from './source.ts';
+export declare const PROFILE = "@happyvertical/smrt-profiles:Profile";
+export declare const CUSTOMER = "@happyvertical/smrt-commerce:Customer";
+export declare const VENDOR = "@happyvertical/smrt-commerce:Vendor";
+/** The first eight characters of an id: what is left when nothing names it. */
+export declare function shortId(id: unknown): string;
+/** Does the model get its name from a Profile (`profileId` referencing one)? */
+export declare function isProfileLabelled(model: CatalogModel): boolean;
+/** The text that names one record. Never an empty string. */
+export declare function recordLabel(source: DataSource, model: CatalogModel, record: ModelRecord, depth?: number): Promise<string>;
+/**
+ * The labels of every record the `fields` of `rows` point at, keyed by
+ * {@link labelKey}. A pointer to a record that is gone has no entry, so a view
+ * falls back to a short id rather than showing nothing.
+ */
+export declare function relationLabels(source: DataSource, fields: readonly CatalogField[], rows: readonly ModelRecord[]): Promise<Map<string, string>>;
+/** Generic relation search: records of `target` whose label matches. */
+export declare function searchRelated(source: DataSource, target: CatalogModel, query: string): Promise<RelationOption[]>;
+/** One related record as an option, or null when it is gone. */
+export declare function resolveRelated(source: DataSource, target: CatalogModel, id: string): Promise<{
+    id: string;
+    label: string;
+} | null>;
+/** A Customer row joined to its Profile, as the commerce party DTO. */
+export declare function customerData(source: DataSource, record: ModelRecord): Promise<CustomerDisplayData>;
+/** A Vendor row joined to its Profile, as the commerce party DTO. */
+export declare function vendorData(source: DataSource, record: ModelRecord): Promise<VendorDisplayData>;
+/** Customers whose profile name (or email) matches, joined to their Profiles. */
+export declare function searchCustomers(source: DataSource, query: string): Promise<CustomerDisplayData[]>;
+export declare function resolveCustomer(source: DataSource, id: string): Promise<CustomerDisplayData | null>;
+export declare function searchVendors(source: DataSource, query: string): Promise<VendorDisplayData[]>;
+export declare function resolveVendor(source: DataSource, id: string): Promise<VendorDisplayData | null>;