@feedmepos/mf-inventory-portal 1.7.13-dev.3 → 1.7.13-dev.6

package/dist/views/production-run/components/production-run-deduction-parity.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/views/production-run/components/production-run-prepare-sheet.d.ts

@@ -0,0 +1,17 @@
+import type { PrepareRunReview } from './PrepareRunDialogProps';
+export interface ProductionRunPrepareSheetDocument {
+    title: string;
+    runNo: FdoProductionRun['runNo'];
+    instructions: string | null;
+    locationName: string | null;
+    updatedAt: string;
+    review: PrepareRunReview;
+}
+/** Remove exactly one hand-off; never scan or mutate unrelated browser storage. */
+export declare function removePrepareSheet(id: string, storage?: Storage): void;
+/** Store one print hand-off without putting its operational contents in the URL. */
+export declare function storePrepareSheet(document: ProductionRunPrepareSheetDocument, storage?: Storage, now?: number): string;
+/** Consume the hand-off once. Malformed, missing and expired entries all fail closed. */
+export declare function readPrepareSheet(id: string, storage?: Storage, now?: number): ProductionRunPrepareSheetDocument;
+export declare function prepareSheetUrl(id: string, currentHref?: string): URL;
+export declare function openPrepareSheet(document: ProductionRunPrepareSheetDocument): void;

package/dist/views/production-run/components/production-run-typography-contract.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/views/production-run/components/production-run-unit-snapshot.d.ts

@@ -0,0 +1,39 @@
+import type { FmUnitInputModel } from '@/components/FmUnitInputProps';
+/**
+ * Production stores the unit-of-record with every durable quantity. The shared
+ * unit input represents the base-unit choice as `null`; Production cannot,
+ * because a stored null would ask a future SKU definition to reinterpret an
+ * old number.
+ *
+ * This local spelling is the rebase seam for PR 1's generated
+ * `FdoProductionUnitSnapshot`.
+ */
+export interface ProductionRunUnitSnapshot extends FdoUnitMeasurement {
+    baseUnitId: string;
+}
+export interface ProductionRunQuantityModel extends Omit<FmUnitInputModel, 'measurement'> {
+    measurement: ProductionRunUnitSnapshot | null;
+}
+export declare function baseUnitSnapshot(unit: FdoInventoryUnit): ProductionRunUnitSnapshot;
+export declare function measurementSnapshot(unit: FdoInventoryUnit, measurement: FdoUnitMeasurement): ProductionRunUnitSnapshot;
+/**
+ * Runtime guard for persisted retry intents. Storage outlives the build that
+ * wrote it, so presence of `baseUnitId` alone is not enough: a malformed or
+ * zero conversion would either crash hydration or change the movement on
+ * resend.
+ */
+export declare function isProductionRunUnitSnapshot(value: unknown): value is ProductionRunUnitSnapshot;
+/** Same stored unit identity, allowing equivalent fixed-point spellings. */
+export declare function productionRunUnitSnapshotsEqual(left: ProductionRunUnitSnapshot, right: ProductionRunUnitSnapshot): boolean;
+/**
+ * A structurally valid snapshot must also belong to the frozen SKU unit it is
+ * being used with. Matching the id without the conversion would reinterpret a
+ * historical number after a unit is redefined under the same id.
+ */
+export declare function productionRunSnapshotMatchesUnit(snapshot: ProductionRunUnitSnapshot, unit: FdoInventoryUnit): boolean;
+/**
+ * Resolve a durable Production snapshot against the current unit definition.
+ * Missing or legacy generic measurements stay unresolved: inferring today's
+ * base would silently reinterpret the stored number.
+ */
+export declare function storedProductionRunUnitSnapshot(stored: unknown, unit: FdoInventoryUnit): ProductionRunUnitSnapshot | null;

package/dist/views/production-run/composables/production-run-display.d.ts

@@ -0,0 +1,272 @@
+import type { FCurrency, FdoDecimal, FdoDinero } from '@feedmepos/core/entity';
+import type { ProductionRunCostState } from './use-production-run-economics';
+/**
+ * Pure display derivation for the production run view. Kept out of the .vue
+ * files so the "nothing yet is not failure" and reveal-by-status rules are
+ * testable — see production-run-display.spec.ts.
+ *
+ * There is no status normalisation anywhere in here. A run document is correct
+ * by construction: `FdoProductionRun` is a NEW entity with no pre-enum
+ * ancestors, so a lookup keyed on `status` may index the table directly.
+ */
+/** The em dash used for "we cannot say yet". NEVER `0`, never `RM 0.00`, never `0%`. */
+export declare const NOT_YET = "\u2014";
+/**
+ * One timestamp form across the Production listing, header and output cards.
+ *
+ * A malformed stored string stays visible verbatim: replacing corrupt data
+ * with `—` would make the document look merely incomplete. An invalid `Date`
+ * has no source text to preserve, so it uses the ordinary unavailable marker.
+ */
+export declare function formatProductionTimestamp(value: Date | string): string;
+export interface QuantityFormat {
+    /**
+     * Decimal places this quantity is meaningful to — `FdoInventoryUnit.precision`,
+     * read through `getAllowedPrecision` so the answer agrees with what the entry
+     * inputs allow. Null when the unit could not be resolved.
+     *
+     * It is a property of the UNIT, not of this screen: a kilogram base unit
+     * carrying a gram measurement is meaningful to 0.001, a unit counted in
+     * pieces to 1. A single hard-coded figure is wrong for one of them whichever
+     * figure is picked.
+     */
+    precision?: number | null;
+    /**
+     * The value is a positive MAGNITUDE leaving stock, so the sign is this
+     * function's to draw.
+     *
+     * Owned here rather than as a `−` in the template because the sign and the
+     * rounding are one decision: a template minus in front of a rounded-away
+     * quantity is exactly the `−0 kg` this function exists to prevent, and a
+     * template minus in front of a true zero says stock leaves when none does.
+     */
+    deduction?: boolean;
+}
+/**
+ * Quantity, trailing zeros trimmed, at the precision its unit is meaningful to.
+ * `1` not `1.00`, `0.35` stays `0.35`.
+ *
+ * **A non-zero quantity is never rendered as zero** (ISSUE-001). Three branches,
+ * and getting any two of them confused is the defect:
+ *
+ * 1. **Exactly zero** → `0`. Nothing moves, and that is worth saying plainly.
+ * 2. **Non-zero but below the unit's smallest increment** → a BOUND, `<0.001`.
+ *    A one-piece run can draw 0.0004 kg of an ingredient; `0` told the reader
+ *    nothing would move and then stock moved. The bound is signed, so a
+ *    deduction reads `−<0.001 kg` rather than losing the direction with the
+ *    digits.
+ * 3. **Anything else** → the figure, rounded to the unit's places.
+ */
+export declare function formatQuantity(value: number | FdoDecimal, unit?: string | null, options?: QuantityFormat): string;
+/**
+ * Money at the currency's own minor unit, or `—` when unknowable. Currency is
+ * passed in (not read from a store) so this stays pure; callers use
+ * `getCurrency()` from `@/helper/country`.
+ */
+export declare function formatMoney(value: FdoDecimal | null | undefined, currency: FCurrency): string;
+/**
+ * Money from a plain number.
+ *
+ * Some figures on this page are summed or subtotalled in the component and so
+ * arrive as raw floats rather than bridge decimals. They still have to become
+ * an `FdoDecimal` before they can be formatted, and the scale that conversion
+ * picks is a money decision, not a display one: three call sites each wrote
+ * `{ amount: Math.round(value * 100), precision: 2 }`, which fixes every
+ * currency at two places and puts a decimal point on đồng.
+ *
+ * The scale comes from the currency, so the rounding here agrees with the
+ * rounding core already applied (`_absorptionScale`) instead of quietly
+ * disagreeing with it at the last step.
+ */
+export declare function formatMoneyFromNumber(value: number | null | undefined, currency: FCurrency): string;
+/** Percent at whole numbers, or `—` when nothing is produced yet. */
+export declare function formatPercent(value: FdoDecimal | null | undefined): string;
+/** `1 ingredient uncosted` / `3 ingredients uncosted`, or null when all are costed. */
+export declare function uncostedNote(uncostedSkuIds: string[]): string | null;
+export declare function pluralise(count: number, singular: string, plural?: string): string;
+/**
+ * Committed minus produced, floored at 0 — what the run still owes.
+ *
+ * Overproduction is legal (the kitchen made more than it committed to), and it
+ * leaves NOTHING unaccounted, so it clamps to 0 rather than reading as a
+ * negative remainder in close/shortfall copy.
+ */
+export declare function remainingQuantity(committed: FdoDecimal, produced: FdoDecimal): number;
+/**
+ * The base unit shared by EVERY production item, or null when they differ or
+ * cannot be resolved.
+ *
+ * Aggregate quantities (committed/produced totals) sum base amounts across
+ * skus, which is only meaningful when the skus share a unit. When they do not,
+ * callers render the total WITHOUT a unit rather than mislabelling `4 kg` on a
+ * run that made kg and litres. Per-item figures are always unit-correct.
+ *
+ * A run carries no sku snapshot on `items` — a DRAFT or REQUESTING run is a
+ * plan, so display resolves against live inventory. Issuance lines DO carry a
+ * snapshot and it wins: it is the unit the movement was actually valued in.
+ * With neither available (an unissued run in a view that has not loaded
+ * inventory) the answer is null, and the caller drops the unit.
+ */
+export declare function sharedUnitAbbrev(run: FdoProductionRun, resolveSku?: (skuId: string) => FdoInventorySku | null | undefined): string | null;
+/**
+ * Whether the outputs resolve to MORE THAN ONE unit.
+ *
+ * Deliberately distinct from `sharedUnitAbbrev` returning null, which also
+ * happens when a unit is merely unknown — a DRAFT whose skus are not in any
+ * issuance yet. Blanking a total needs the stronger claim: not "we cannot name
+ * the unit" but "there are two, so no single total exists". Grams cannot be
+ * added to bottles; grams can be added to grams we have not named.
+ */
+export declare function outputUnitsDiffer(run: FdoProductionRun, resolveSku?: (skuId: string) => FdoInventorySku | null | undefined): boolean;
+/**
+ * `_id` where the unit has one; the abbrev is only a fallback for fixtures.
+ *
+ * Exported so every production surface decides "same unit" the same way as
+ * {@link outputUnitsDiffer}. A second copy of this rule is how two surfaces
+ * eventually disagree about whether a run's quantities are addable.
+ */
+export declare function unitKey(unit: FdoInventoryUnit): string;
+export interface ProductionOutputBatchItem {
+    skuId: string;
+    /** Base units — a batch line's stored amount is in its own `measurement`. */
+    amount: number;
+}
+export interface ProductionOutputBatch {
+    id: string;
+    adjustmentId: string;
+    /** 1-based, in the chronological order shown. Not a traceability lot code. */
+    index: number;
+    /** When the kitchen actually finished this batch — user-entered. */
+    producedAt: string;
+    /** When the system recorded it — server clock, never client-supplied. */
+    recordedAt: string;
+    /** True when output was keyed in after the fact; the gap is what a variance investigation asks about. */
+    isBackdated: boolean;
+    recordedBy: string;
+    items: ProductionOutputBatchItem[];
+    /** Why this particular production event had the result it did. */
+    remark: string | null;
+    wastages: (FdoProductionWastageLine & {
+        remark?: string | null;
+    })[];
+}
+export declare function productionOutputBatches(run: FdoProductionRun): ProductionOutputBatch[];
+/**
+ * The FIXED wastage-reason vocabulary (`F_PRODUCTION_WASTAGE_REASON`), in the
+ * order the picker shows it. Deliberately NOT the business's adjustment-template
+ * reasons — production loss categories are universal, so the picker works the
+ * same in every location and needs no fetch.
+ */
+export declare const PRODUCTION_WASTAGE_REASONS: F_PRODUCTION_WASTAGE_REASON[];
+/** Display labels for the fixed vocabulary — the enum values stay UPPER in data. */
+/**
+ * The i18n key for a wastage reason.
+ *
+ * The words used to live here as a literal map, which put five user-facing
+ * strings somewhere a translator cannot reach — the module is
+ * English-only-by-construction rather than merely untranslated. The vocabulary
+ * itself is fixed and cross-business (so it stays comparable across locations);
+ * only its rendering is a locale concern.
+ */
+export declare function wastageReasonKey(reason: F_PRODUCTION_WASTAGE_REASON | string): string;
+/**
+ * Enum value → display label. Null when there is no reason at all, so callers
+ * can skip the segment entirely.
+ */
+export declare function formatWastageReason(reason: string | null | undefined): string | null;
+/**
+ * The ingredient SKU ids CONSUMED by an issue adjustment.
+ *
+ * `FfProductionRunEconomics` cannot tell "this ingredient had no cost on hand"
+ * from "this run has no bindings, so zero cost is correct" — an uncosted
+ * ingredient contributes nothing to the pool, and so does an absent one.
+ * Feeding it the ids actually issued is what lights up the amber uncosted state.
+ */
+export declare function issuedIngredientSkuIdsOf(adjustment: FdoInventoryAdjustment | null | undefined): string[];
+export type CloseConsequence = 
+/** Issued, with an unproduced remainder: that share of the pool stays unabsorbed. */
+'leaves-unabsorbed'
+/** Nothing was ever issued for the remainder, so nothing is at stake. */
+ | 'nothing-issued'
+/** Everything committed was produced — closing only stops further output. */
+ | 'fully-produced';
+/**
+ * What closing this run actually does — the single source for the confirm copy.
+ *
+ * `'leaves-unabsorbed'`, deliberately NOT "writes off". Close writes no
+ * adjustment and moves no stock: the cost left stock at issuance, only the
+ * absorbed share was carried into the output item's value, and the remainder
+ * simply stays as unabsorbed issued cost. Naming it a write-off on an
+ * irreversible confirm dialog states an accounting event that does not happen.
+ *
+ * A run with no issuance has no pool at all, so there is nothing to leave
+ * behind — that is `'nothing-issued'`, which the run lifecycle only reaches
+ * through cancel, never through close.
+ */
+export declare function closeConsequence(run: FdoProductionRun, atTarget: boolean): CloseConsequence;
+/** The i18n key the close confirmation renders, and what to interpolate into it. */
+export interface CloseMessage {
+    /** Relative to `inventory.production.run.dialog.close`. */
+    key: string;
+    /** `names` for the uncosted case; `amount` only ever for `leavesUnabsorbed`. */
+    params: Record<string, string>;
+    /** True only when a real money figure may be shown. */
+    showsAmount: boolean;
+}
+/**
+ * What the close confirmation says, chosen from the cost STATE.
+ *
+ * Two defects live in the obvious version of this, and both put a wrong
+ * statement on an irreversible action.
+ *
+ * The first is inferring the reason from `uncostedNames.length`: an empty list
+ * is equally consistent with an unsplittable pool, a negative valuation and no
+ * pool at all, so the sentence explaining why the figure is missing named the
+ * wrong cause — or, before that, interpolated the empty list and rendered
+ * "because  has no cost on record".
+ *
+ * The second is subtler. `open` is non-null whenever the pool splits, INCLUDING
+ * when the cost is not known — an uncosted or negative pool still subtracts to
+ * a number. So a dialog keyed on `unabsorbed === null` showed a confident
+ * "leaves RM X unabsorbed" for exactly the pools the cost rail was withholding
+ * one screen away. The amount is gated on the state, never on its own nullness.
+ */
+export declare function closeMessage(input: {
+    consequence: CloseConsequence;
+    costState: ProductionRunCostState;
+    unabsorbed: FdoDinero | null;
+    uncostedNames: string[];
+}): CloseMessage;
+/**
+ * Has the run stopped producing for good?
+ *
+ * The line between "no output yet" and "no output, final". Shared because the
+ * listing and the detail page must answer it identically — they disagreed once,
+ * and a run closed with nothing showed 0% in one place and `—` in the other.
+ */
+export declare function hasStopped(run: FdoProductionRun): boolean;
+/**
+ * How a stopped run ended, in terms of what it made — never of which status it
+ * carries.
+ *
+ * Closure is one terminal now, at target or short, because reaching the
+ * committed quantity is a measurement and stopping is a decision. So the
+ * outcome is DERIVED from committed versus produced, both already on the
+ * document. Storing it would create durable state able to disagree with its own
+ * inputs, and a closed run's batches are immutable, so there is nothing to gain
+ * by caching it.
+ *
+ * `null` while the run can still produce — an open run has no outcome yet, and
+ * a cancelled run never committed to one.
+ */
+export declare function closureOutcome(run: FdoProductionRun): 'target-reached' | 'below-target' | null;
+export type ProductionRunTerminalOutputOutcome = 'below-target' | 'at-target' | 'above-target';
+/**
+ * A stopped run's output outcome, compared per sku.
+ *
+ * Cross-output totals are deliberately absent. Five kilograms above target
+ * cannot cancel one litre below target, and mixed-unit runs have no meaningful
+ * aggregate percentage. A run is above target only when every commitment was
+ * met and at least one was exceeded; any short item keeps the outcome below.
+ */
+export declare function terminalOutputOutcome(run: FdoProductionRun): ProductionRunTerminalOutputOutcome | null;

package/dist/views/production-run/composables/production-run-display.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/views/production-run/composables/production-run-list.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Pure derivation for the production-run listing. Kept out of the .vue so the
+ * tab grouping, search, lifecycle sorting and display identity are testable.
+ */
+export type ProductionRunTabKey = 'all' | 'drafts' | 'active' | 'history';
+export interface ProductionRunTabDef {
+    key: ProductionRunTabKey;
+    label: string;
+}
+/**
+ * Tabs are grouped by operator intent, not one per lifecycle value.
+ *
+ * Reaching the committed quantity is a measurement, not a place a run goes. A
+ * run kept open at target is still active; History holds only runs that have
+ * stopped. Together the three filtered tabs partition All exactly.
+ */
+export declare const PRODUCTION_RUN_TABS: ProductionRunTabDef[];
+/** Lifecycle order for the status column; alphabetical order is operational noise. */
+export declare const STATUS_ORDER: {
+    readonly DRAFT: 0;
+    readonly REQUESTING: 1;
+    readonly PREPARING: 2;
+    readonly CLOSED: 3;
+    readonly CANCEL: 4;
+};
+/** Reject an obsolete or corrupt status instead of silently sorting it as NaN. */
+export declare function productionRunStatusOrder(status: F_PRODUCTION_RUN_STATUS): number;
+export declare function matchesProductionRunTab(run: FdoProductionRun, tab: ProductionRunTabKey): boolean;
+export declare function productionRunTabCounts(runs: FdoProductionRun[]): Record<ProductionRunTabKey, number>;
+/** Last audited event on the run, for the Updated column. */
+export declare function productionRunLastActivity(run: FdoProductionRun): {
+    action: F_PRODUCTION_RUN_ACTION;
+    at: string;
+} | null;
+/** `runName` when supplied, otherwise the translated fallback plus durable run number. */
+export declare function productionRunDisplayName(run: FdoProductionRun, untitledName: string): string;
+/**
+ * Locale-independent sort identity shared by whole-list paging and FmTable.
+ *
+ * Named runs sort by their stored name. Unnamed runs sort by the durable run
+ * number rather than by translated presentation copy, so changing locale
+ * cannot move a row or produce a different page boundary.
+ */
+export declare function productionRunNameSortValue(run: FdoProductionRun): string;
+/** Search the run's durable identity and the live names of its output items. */
+export declare function matchesProductionRunSearch(run: FdoProductionRun, search: string, resolveSku?: (skuId: string) => FdoInventorySku | null | undefined): boolean;

package/dist/views/production-run/composables/production-run-list.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/views/production-run/composables/production-run-request-confirmation.d.ts

@@ -0,0 +1,20 @@
+/**
+ * One confirmation contract for every Draft handoff entry point.
+ *
+ * The form, listing and detail page can all submit the same lifecycle event.
+ * Keeping the copy and button semantics here prevents one surface from
+ * becoming an unconfirmed shortcut around the others.
+ */
+export declare function productionRunRequestConfirmation(t: (key: string) => string): {
+    title: string;
+    message: string;
+    primaryActions: {
+        text: string;
+        close: boolean;
+    };
+    secondaryActions: {
+        text: string;
+        close: boolean;
+        variant: "tertiary";
+    };
+};

package/dist/views/production-run/composables/use-production-run-actions.d.ts

@@ -0,0 +1,37 @@
+import { type MaybeRefOrGetter } from 'vue';
+/** Lifecycle actions a user can trigger (create is not an edge on an existing run). */
+export type ProductionRunLifecycleAction = Exclude<F_PRODUCTION_RUN_ACTION, 'create'>;
+/**
+ * Single source for action labels, so the row button, the row menu and the run
+ * footer cannot drift into three names for one action.
+ */
+export declare const PRODUCTION_RUN_ACTION_LABELS: Record<ProductionRunLifecycleAction, string>;
+export interface ProductionRunAction {
+    action: ProductionRunLifecycleAction;
+    label: string;
+}
+/**
+ * Every action legal on the run RIGHT NOW, straight from the
+ * `FfProductionRunWorkflow` legality table — which reads status **and** data,
+ * so a run that has issued offers no cancel and a drifted document offers
+ * nothing at all. Views render this list; adding a status or an edge touches
+ * the core table, not view code.
+ *
+ * There is no normalisation and no try/catch here on purpose. Run documents are
+ * correct by construction — `FdoProductionRun` is a new entity with no pre-enum
+ * ancestors — so a status the bridge cannot decode is a real defect, and
+ * swallowing it would hide the defect behind an empty menu.
+ */
+export declare function productionRunActionsFor(run: FdoProductionRun): ProductionRunAction[];
+/** Reactive wrapper for components holding the run in a ref/prop/getter. */
+export declare function useProductionRunActions(run: MaybeRefOrGetter<FdoProductionRun | null | undefined>): import("vue").ComputedRef<ProductionRunAction[]>;
+/**
+ * The `.fm-status-badge-*` modifier for a run status, paired with the base
+ * `fm-status-badge` class by the caller (see `draftStatusToClassName`).
+ *
+ * The shared modifiers are palette names rather than Production statuses.
+ * REQUESTING is the informational hand-off, while PREPARING is the warning-
+ * toned work-in-flight state. Keeping that mapping here makes the list and
+ * detail surfaces agree without changing the shared badge styles.
+ */
+export declare function productionRunStatusBadge(status: F_PRODUCTION_RUN_STATUS): "fm-status-badge-draft" | "fm-status-badge-receiving" | "fm-status-badge-requesting" | "fm-status-badge-close" | "fm-status-badge-cancel";

package/dist/views/production-run/composables/use-production-run-actions.spec.d.ts

@@ -0,0 +1 @@
+export {};