@appinternalleads/ui 0.2.0

package/src/components/onboarding/receipt-printer/engine.ts

@@ -0,0 +1,351 @@
+import type { StateChipTone } from '../../../ds';
+import {
+  FIELD_KEY, RECEIPT_MAX_AMOUNT, RECEIPT_MAX_FIELDS, RECEIPT_MAX_ITEMS, RECEIPT_MAX_LENGTH, RECEIPT_MAX_QUANTITY,
+  type ReceiptCurrency, type ReceiptField, type ReceiptItemField, type ReceiptPaymentMethod, type ReceiptPrinterScene,
+  type ReceiptPrinterSettings, type ReceiptValues,
+} from './contract';
+
+/**
+ * **The Receipt Printer engine** — pure: the form as typed, its checks, the print lifecycle, and the
+ * receipt's printed lines. Nothing here knows the receipt is drawn by Rive; the stage is handed
+ * `ReceiptLines` and a phase, and reports back when the paper is at rest.
+ *
+ * A print ends `printed` only when BOTH halves are done — the host's `print` operation and the
+ * paper's feed — and `failed` when the operation fails, whichever finishes first. Every step is
+ * keyed by `job`, so a late answer from a superseded print (reset, then print again) is ignored.
+ */
+
+/** One item line as typed — text until checked, so "1.5" in Qty can be said to be wrong. */
+export type ReceiptItemDraft = Record<ReceiptItemField, string>;
+/**
+ * One of the host's fields as it stands in the form: its value as typed, and its definition, which
+ * the "Edit fields" mode can change. `keyTouched`: the key was typed by hand, so it no longer
+ * follows the label.
+ */
+export type ReceiptFieldDraft = { key: string; label: string; value: string; heading: boolean; keyTouched: boolean };
+/** The form as typed. */
+export type ReceiptDraft = Record<ReceiptField, string> & { fields: ReceiptFieldDraft[]; items: ReceiptItemDraft[] };
+/** Problems by field: `date`, `fields.1.value`, or `items.2.amount` for a line. */
+export type ReceiptErrors = Record<string, string>;
+export type PrintRun = 'editing' | 'printing' | 'printed' | 'failed';
+
+/** One printed item line. */
+export type ReceiptLine = { line: string; amount: string };
+
+/** What the printer prints — the Rive file's `Receipt` view model, and its `items` list. */
+export type ReceiptLines = {
+  /** The heading field's value — printed large at the top. Empty when no field is the heading. */
+  title: string;
+  /** The badge's initial. */
+  badge: string;
+  total: string;
+  /** The date, the payment method and "(PAID)". */
+  meta: string;
+  /** The other fields, as label/value rows. */
+  details: { label: string; value: string }[];
+  items: ReceiptLine[];
+  paymentMethod: string;
+  message: string;
+  paymentLabel: string;
+  totalLabel: string;
+};
+
+export type ReceiptPrinterState = {
+  draft: ReceiptDraft;
+  /** Errors show once Print has been pressed, never while a person is still filling the form in. */
+  checked: boolean;
+  run: PrintRun;
+  /** The receipt being printed, or last printed. Editing the form does not change it; printing again does. */
+  printed: ReceiptLines | null;
+  /** Increments with every print; the stage and the operation answer for one job. */
+  job: number;
+  fed: boolean;
+  acknowledged: boolean;
+  failMessage?: string;
+};
+
+export type ReceiptPrinterSeed = Partial<ReceiptPrinterState>;
+
+export type ReceiptPrinterAction =
+  | { type: 'field'; field: ReceiptField; value: string }
+  | { type: 'fieldValue'; index: number; value: string }
+  | { type: 'fieldDef'; index: number; label?: string; key?: string; heading?: boolean }
+  | { type: 'addField' }
+  | { type: 'removeField'; index: number }
+  | { type: 'item'; index: number; field: ReceiptItemField; value: string }
+  | { type: 'addItem' }
+  | { type: 'removeItem'; index: number }
+  | { type: 'print'; config: ReceiptPrinterSettings }
+  | { type: 'fed'; job: number }
+  | { type: 'acknowledged'; job: number }
+  | { type: 'failed'; job: number; message?: string }
+  | { type: 'reset'; config: ReceiptPrinterSettings };
+
+/* ── The config's lists, safely ───────────────────────────────────────────────────────────── */
+
+export const currenciesOf = (c: ReceiptPrinterSettings): ReceiptCurrency[] =>
+  (Array.isArray(c.currencies) ? c.currencies : []).filter(x => x && typeof x.code === 'string' && x.code.trim() !== '');
+export const methodsOf = (c: ReceiptPrinterSettings): ReceiptPaymentMethod[] =>
+  (Array.isArray(c.paymentMethods) ? c.paymentMethods : []).filter(x => x && typeof x.id === 'string' && x.id.trim() !== '');
+
+/** A config with nothing to choose from shows the empty scene rather than a form that cannot be sent. */
+export const hasChoices = (c: ReceiptPrinterSettings) => currenciesOf(c).length > 0 && methodsOf(c).length > 0;
+
+const text = (v: unknown) => (typeof v === 'string' ? v : typeof v === 'number' && Number.isFinite(v) ? String(v) : '');
+/** A label from the config, or its default when a config left it out or blank. */
+const word = (v: unknown, fallback: string) => (typeof v === 'string' && v.trim() ? v : fallback);
+
+export const blankItem = (): ReceiptItemDraft => ({ name: '', quantity: '1', amount: '' });
+
+/** A key from a label: "Book name" → `bookName`, "Order #" → `order`. Unique among `taken`. */
+export function keyFromLabel(label: string, taken: string[]): string {
+  const words = label.normalize('NFKD').replace(/[^\w\s]/g, ' ').trim().split(/[\s_]+/).filter(Boolean);
+  let base = words.map((w, i) => (i === 0 ? w.toLowerCase() : w[0]!.toUpperCase() + w.slice(1).toLowerCase())).join('').replace(/^[^A-Za-z]+/, '');
+  if (!base) base = 'field';
+  base = base.slice(0, 28);
+  let key = base;
+  for (let n = 2; taken.includes(key); n++) key = `${base}${n}`;
+  return key;
+}
+
+/** The fields as the host wrote them, as form drafts. */
+export function fieldDrafts(c: ReceiptPrinterSettings): ReceiptFieldDraft[] {
+  const defs = (Array.isArray(c.fields) ? c.fields : []).slice(0, RECEIPT_MAX_FIELDS);
+  const first = defs.findIndex(f => f?.heading === true);
+  return defs.map((f, i) => ({ key: text(f?.key), label: text(f?.label), value: text(f?.value), heading: i === first, keyTouched: true }));
+}
+
+/** The form's starting text, from the config — a currency or method the lists lack falls back to the first. */
+export function initialDraft(c: ReceiptPrinterSettings): ReceiptDraft {
+  const currencies = currenciesOf(c);
+  const methods = methodsOf(c);
+  const items = (Array.isArray(c.items) ? c.items : []).slice(0, RECEIPT_MAX_ITEMS)
+    .map(it => ({ name: text(it?.name), quantity: text(it?.quantity) || '1', amount: text(it?.amount) }));
+  return {
+    fields: fieldDrafts(c),
+    items: items.length ? items : [blankItem()],
+    currency: currencies.some(x => x.code === c.currency) ? c.currency : currencies[0]?.code ?? '',
+    paymentMethod: methods.some(x => x.id === c.paymentMethod) ? c.paymentMethod : methods[0]?.id ?? '',
+    date: text(c.date),
+    message: text(c.message),
+  };
+}
+
+/* ── Checking the form ────────────────────────────────────────────────────────────────────── */
+
+
+const DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
+
+function validDate(s: string): boolean {
+  const m = DATE.exec(s);
+  if (!m) return false;
+  const [y, mo, d] = [Number(m[1]), Number(m[2]), Number(m[3])];
+  const probe = new Date(Date.UTC(y, mo - 1, d));
+  return probe.getUTCFullYear() === y && probe.getUTCMonth() === mo - 1 && probe.getUTCDate() === d;
+}
+
+/** Decimal places typed in an amount — "8.50" has two. */
+const decimalsOf = (s: string) => (s.includes('.') ? s.split('.')[1]!.length : 0);
+
+/** The form's problems, one message per field, in plain words. Empty when it can print. */
+export function formErrors(draft: ReceiptDraft, c: ReceiptPrinterSettings): ReceiptErrors {
+  const e: ReceiptErrors = {};
+  if (draft.message.trim().length > RECEIPT_MAX_LENGTH.message) e.message = `Keep it to ${RECEIPT_MAX_LENGTH.message} characters — it has to fit the receipt.`;
+  const keys = new Set<string>();
+  draft.fields.forEach((f, i) => {
+    const label = f.label.trim();
+    if (!label) e[`fields.${i}.label`] = 'Give the field a label.';
+    else if (label.length > RECEIPT_MAX_LENGTH.fieldLabel) e[`fields.${i}.label`] = `Keep the label to ${RECEIPT_MAX_LENGTH.fieldLabel} characters.`;
+    if (!FIELD_KEY.test(f.key)) e[`fields.${i}.key`] = 'A key starts with a letter and uses letters, digits and _.';
+    else if (keys.has(f.key)) e[`fields.${i}.key`] = `${f.key} is already a key.`;
+    keys.add(f.key);
+    const v = f.value.trim();
+    const max = f.heading ? RECEIPT_MAX_LENGTH.heading : RECEIPT_MAX_LENGTH.fieldValue;
+    if (!v) e[`fields.${i}.value`] = `Enter ${label ? label.toLowerCase() : 'a value'}.`;
+    else if (v.length > max) e[`fields.${i}.value`] = `Keep it to ${max} characters — it has to fit the receipt.`;
+  });
+  const currency = currenciesOf(c).find(x => x.code === draft.currency);
+  if (!draft.items.length) e.items = 'Add at least one item.';
+  if (draft.items.length > RECEIPT_MAX_ITEMS) e.items = `A receipt prints at most ${RECEIPT_MAX_ITEMS} lines.`;
+  draft.items.forEach((it, i) => {
+    const name = it.name.trim();
+    if (!name) e[`items.${i}.name`] = 'Enter what was paid for.';
+    else if (name.length > RECEIPT_MAX_LENGTH.itemName!) e[`items.${i}.name`] = `Keep it to ${RECEIPT_MAX_LENGTH.itemName} characters — it has to fit the receipt.`;
+    const q = it.quantity.trim();
+    if (!/^\d+$/.test(q) || Number(q) < 1 || Number(q) > RECEIPT_MAX_QUANTITY) e[`items.${i}.quantity`] = `Enter a whole number from 1 to ${RECEIPT_MAX_QUANTITY}.`;
+    const a = it.amount.trim();
+    if (!/^\d+(\.\d+)?$/.test(a) || Number(a) <= 0) e[`items.${i}.amount`] = 'Enter an amount above zero.';
+    else if (Number(a) > RECEIPT_MAX_AMOUNT) e[`items.${i}.amount`] = `Enter an amount up to ${RECEIPT_MAX_AMOUNT.toLocaleString('en-US')}.`;
+    else if (currency && decimalsOf(a) > currency.decimals) {
+      e[`items.${i}.amount`] = currency.decimals === 0 ? `${currency.code} has no minor unit — enter a whole amount.` : `${currency.code} has ${currency.decimals} decimal places at most.`;
+    }
+  });
+  if (!currency) e.currency = 'Choose a currency.';
+  if (!methodsOf(c).some(x => x.id === draft.paymentMethod)) e.paymentMethod = 'Choose how it was paid.';
+  if (!validDate(draft.date.trim())) e.date = 'Enter a date as YYYY-MM-DD, like 2026-09-27.';
+  return e;
+}
+
+/** The checked form as values — only call it once `formErrors` is empty. */
+export function valuesOf(draft: ReceiptDraft): ReceiptValues {
+  return {
+    fields: Object.fromEntries(draft.fields.map(f => [f.key, f.value.trim()])),
+    items: draft.items.map(it => ({ name: it.name.trim(), quantity: Number(it.quantity.trim()), amount: Number(it.amount.trim()) })),
+    currency: draft.currency,
+    paymentMethod: draft.paymentMethod,
+    date: draft.date.trim(),
+    message: draft.message.trim(),
+  };
+}
+
+/* ── The printed lines ────────────────────────────────────────────────────────────────────── */
+
+const MONTHS = ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC'];
+
+/** `2026-09-27` → `27 SEP 2026`. */
+export function receiptDate(iso: string): string {
+  const m = DATE.exec(iso);
+  return m ? `${Number(m[3])} ${MONTHS[Number(m[2]) - 1] ?? ''} ${m[1]}` : iso;
+}
+
+/** `₹1,240.00`, `¥7,500` — grouped, and to the currency's own minor unit. Deterministic: no locale. */
+export function formatMoney(value: number, currency: ReceiptCurrency | undefined): string {
+  const decimals = currency?.decimals ?? 2;
+  const [whole, frac] = (Math.round(value * 10 ** decimals) / 10 ** decimals).toFixed(decimals).split('.');
+  return `${currency?.symbol ?? ''}${whole!.replace(/\B(?=(\d{3})+(?!\d))/g, ',')}${frac ? `.${frac}` : ''}`;
+}
+
+/**
+ * The receipt, line by line, from checked values and the fields' definitions. The heading field
+ * prints large at the top; the rest print as label/value rows. The total is every line's
+ * quantity × amount.
+ */
+export function receiptLines(v: ReceiptValues, c: ReceiptPrinterSettings, defs: ReceiptFieldDraft[] = fieldDrafts(c)): ReceiptLines {
+  const currency = currenciesOf(c).find(x => x.code === v.currency);
+  const method = methodsOf(c).find(x => x.id === v.paymentMethod)?.label ?? v.paymentMethod;
+  const minor = 10 ** (currency?.decimals ?? 2);
+  /* Summed in the minor unit, so ₹0.10 + ₹0.20 is ₹0.30, not ₹0.30000000000000004. */
+  const total = v.items.reduce((sum, it) => sum + Math.round(it.quantity * it.amount * minor), 0) / minor;
+  const paid = word(c.paidLabel, '') ? ` (${c.paidLabel.toUpperCase()})` : '';
+  const heading = defs.find(f => f.heading);
+  const title = heading ? v.fields[heading.key] ?? '' : '';
+  return {
+    title: title.toUpperCase(),
+    badge: (title.match(/[\p{L}\p{N}]/u)?.[0] ?? '•').toUpperCase(),
+    total: formatMoney(total, currency),
+    meta: `${receiptDate(v.date)} | ${method.toUpperCase()}${paid}`,
+    details: defs.filter(f => !f.heading).map(f => ({ label: f.label, value: v.fields[f.key] ?? '' })),
+    items: v.items.map(it => ({ line: `${it.quantity}X ${it.name}`, amount: formatMoney(it.quantity * it.amount, currency) })),
+    paymentMethod: method,
+    message: v.message.toUpperCase(),
+    paymentLabel: word(c.paymentLabel, 'Payment'),
+    totalLabel: word(c.totalLabel, 'TOTAL'),
+  };
+}
+
+/**
+ * **What the idle printer shows while the form is being filled in** — the lines as they would
+ * print, from whatever is valid so far. The torn tip carries the message, so typing it shows it,
+ * and the printer is already as tall as the receipt will be.
+ */
+export function previewLines(draft: ReceiptDraft, c: ReceiptPrinterSettings): ReceiptLines {
+  const n = (s: string, fallback: number) => (s.trim() !== '' && Number.isFinite(Number(s)) ? Number(s) : fallback);
+  const v = valuesOf(draft);
+  return receiptLines({ ...v, items: v.items.map((it, i) => ({ ...it, quantity: n(draft.items[i]!.quantity, 1), amount: n(draft.items[i]!.amount, 0) })) }, c, draft.fields);
+}
+
+/* ── The lifecycle ────────────────────────────────────────────────────────────────────────── */
+
+export function initialReceiptPrinter(c: ReceiptPrinterSettings, seed: ReceiptPrinterSeed = {}): ReceiptPrinterState {
+  return { draft: initialDraft(c), checked: false, run: 'editing', printed: null, job: 0, fed: false, acknowledged: false, ...seed };
+}
+
+/** A demo scene as a seed. `printing` and `printed` carry the preset's own receipt. */
+export function receiptPrinterSeed(c: ReceiptPrinterSettings, scene: ReceiptPrinterScene): ReceiptPrinterSeed {
+  const draft = initialDraft(c);
+  const lines = Object.keys(formErrors(draft, c)).length ? previewLines(draft, c) : receiptLines(valuesOf(draft), c, draft.fields);
+  if (scene === 'invalid') return { draft: { ...draft, fields: draft.fields.map((f, i) => (i === draft.fields.length - 1 ? { ...f, value: '' } : f)), items: draft.items.map((it, i) => (i === 0 ? { ...it, amount: '0' } : it)) }, checked: true };
+  if (scene === 'printing') return { run: 'printing', printed: lines, job: 1 };
+  if (scene === 'printed') return { run: 'printed', printed: lines, job: 1, fed: true, acknowledged: true };
+  if (scene === 'failed') return { run: 'failed', printed: lines, job: 1, fed: true, failMessage: undefined };
+  return {};
+}
+
+const settle = (s: ReceiptPrinterState): ReceiptPrinterState => (s.fed && s.acknowledged ? { ...s, run: 'printed' } : s);
+const editable = (s: ReceiptPrinterState) => s.run !== 'printing';
+
+export function reduceReceiptPrinter(s: ReceiptPrinterState, a: ReceiptPrinterAction): ReceiptPrinterState {
+  switch (a.type) {
+    /* Nothing is edited mid-print: the fields are disabled, and this holds even if one is not. */
+    case 'field': return editable(s) ? { ...s, draft: { ...s.draft, [a.field]: a.value } } : s;
+    case 'fieldValue': return editable(s) && s.draft.fields[a.index]
+      ? { ...s, draft: { ...s.draft, fields: s.draft.fields.map((f, i) => (i === a.index ? { ...f, value: a.value } : f)) } } : s;
+    case 'fieldDef': {
+      if (!editable(s) || !s.draft.fields[a.index]) return s;
+      const taken = s.draft.fields.filter((_, i) => i !== a.index).map(f => f.key);
+      const fields = s.draft.fields.map((f, i) => {
+        if (i !== a.index) return a.heading ? { ...f, heading: false } : f;
+        const next = { ...f };
+        if (a.label !== undefined) { next.label = a.label; if (!f.keyTouched) next.key = keyFromLabel(a.label, taken); }
+        if (a.key !== undefined) { next.key = a.key; next.keyTouched = true; }
+        if (a.heading !== undefined) next.heading = a.heading;
+        return next;
+      });
+      return { ...s, draft: { ...s.draft, fields } };
+    }
+    case 'addField': {
+      if (!editable(s) || s.draft.fields.length >= RECEIPT_MAX_FIELDS) return s;
+      const key = keyFromLabel('field', s.draft.fields.map(f => f.key));
+      return { ...s, draft: { ...s.draft, fields: [...s.draft.fields, { key, label: '', value: '', heading: false, keyTouched: false }] } };
+    }
+    case 'removeField': return editable(s) ? { ...s, draft: { ...s.draft, fields: s.draft.fields.filter((_, i) => i !== a.index) } } : s;
+    case 'item': return editable(s) && s.draft.items[a.index]
+      ? { ...s, draft: { ...s.draft, items: s.draft.items.map((it, i) => (i === a.index ? { ...it, [a.field]: a.value } : it)) } } : s;
+    case 'addItem': return editable(s) && s.draft.items.length < RECEIPT_MAX_ITEMS ? { ...s, draft: { ...s.draft, items: [...s.draft.items, blankItem()] } } : s;
+    /* The last line stays: a receipt prints at least one. */
+    case 'removeItem': return editable(s) && s.draft.items.length > 1 ? { ...s, draft: { ...s.draft, items: s.draft.items.filter((_, i) => i !== a.index) } } : s;
+    case 'print': {
+      /* One print at a time — a second press while printing is ignored, not queued. */
+      if (s.run === 'printing') return s;
+      if (Object.keys(formErrors(s.draft, a.config)).length) return { ...s, checked: true };
+      return {
+        ...s, checked: true, run: 'printing', printed: receiptLines(valuesOf(s.draft), a.config, s.draft.fields),
+        job: s.job + 1, fed: false, acknowledged: false, failMessage: undefined,
+      };
+    }
+    case 'fed': return s.run === 'printing' && a.job === s.job ? settle({ ...s, fed: true }) : s;
+    case 'acknowledged': return s.run === 'printing' && a.job === s.job ? settle({ ...s, acknowledged: true }) : s;
+    case 'failed': return s.run === 'printing' && a.job === s.job ? { ...s, run: 'failed', failMessage: a.message } : s;
+    case 'reset': return { ...initialReceiptPrinter(a.config), job: s.job };
+  }
+}
+
+/** Where the paper is. A failed print retracts, so the next attempt feeds from the start. */
+export type PrinterPhase = 'idle' | 'printing' | 'printed';
+export const printerPhase = (run: PrintRun): PrinterPhase => (run === 'printing' ? 'printing' : run === 'printed' ? 'printed' : 'idle');
+
+export function receiptPrinterView(c: ReceiptPrinterSettings, s: ReceiptPrinterState) {
+  const errors = s.checked && s.run !== 'printing' ? formErrors(s.draft, c) : {};
+  const count = Object.keys(errors).length;
+  const scene: ReceiptPrinterScene = s.run === 'printing' ? 'printing' : s.run === 'printed' ? 'printed' : s.run === 'failed' ? 'failed' : count ? 'invalid' : 'default';
+  return {
+    scene,
+    errors,
+    errorCount: count,
+    busy: s.run === 'printing',
+    /** Printed lines while printing or printed; otherwise a live preview of the form. */
+    lines: s.run === 'editing' || !s.printed ? previewLines(s.draft, c) : s.printed,
+    phase: printerPhase(s.run),
+    canAddItem: s.run !== 'printing' && s.draft.items.length < RECEIPT_MAX_ITEMS,
+    canRemoveItem: s.run !== 'printing' && s.draft.items.length > 1,
+    canAddField: s.run !== 'printing' && s.draft.fields.length < RECEIPT_MAX_FIELDS,
+    chip: s.run === 'printed' ? { tone: 'success' as StateChipTone, label: c.printedChip }
+      : s.run === 'failed' ? { tone: 'attention' as StateChipTone, label: 'Didn’t print' }
+      : count ? { tone: 'attention' as StateChipTone, label: count === 1 ? '1 to fix' : `${count} to fix` }
+      : undefined,
+    hint: s.run === 'printing' ? c.printingHint : s.run === 'printed' ? c.printedHint : count ? c.invalidHint : c.readyHint,
+    primaryLabel: s.run === 'printing' ? c.printingLabel : s.run === 'printed' || s.run === 'failed' ? c.againLabel : c.printLabel,
+    /** Reset appears once there is something to reset. */
+    canReset: s.run !== 'printing' && (s.run !== 'editing' || s.checked || JSON.stringify(s.draft) !== JSON.stringify(initialDraft(c))),
+  };
+}

package/src/components/onboarding/receipt-printer/index.ts

@@ -0,0 +1,14 @@
+export {
+  FIELD_KEY, RECEIPT_FIELDS, RECEIPT_MAX_AMOUNT, RECEIPT_MAX_FIELDS, RECEIPT_MAX_ITEMS, RECEIPT_MAX_LENGTH, RECEIPT_MAX_QUANTITY, RECEIPT_PRINTER_IN_FLIGHT, RECEIPT_PRINTER_PRESETS, RECEIPT_PRINTER_SCENES,
+  validateReceiptPrinter,
+  type ReceiptCurrency, type ReceiptField, type ReceiptFieldDef, type ReceiptFormLabels, type ReceiptItem, type ReceiptItemField, type ReceiptPaperLabels, type ReceiptPaymentMethod, type ReceiptPrinterScene, type ReceiptPrinterSettings, type ReceiptValues,
+} from './contract';
+export {
+  blankItem, fieldDrafts, formErrors, keyFromLabel, formatMoney, initialDraft, initialReceiptPrinter, previewLines, receiptDate, receiptLines, receiptPrinterSeed, receiptPrinterView,
+  reduceReceiptPrinter, printerPhase, valuesOf,
+  type PrintRun, type ReceiptDraft, type ReceiptFieldDraft, type ReceiptItemDraft, type ReceiptLine, type ReceiptErrors, type ReceiptLines, type ReceiptPrinterAction, type ReceiptPrinterSeed, type ReceiptPrinterState, type PrinterPhase,
+} from './engine';
+export {
+  ReceiptPrinter, receiptSpeech, type ReceiptPrinterOperations, type ReceiptPrinterProps, type ReceiptPrinterSize,
+} from './ReceiptPrinterView';
+export { stageAspect, type ReceiptStageProps } from './ReceiptStage.types';