@feedmepos/mf-inventory-portal 1.7.15-dev.3 → 1.7.16-dev.0

package/dist/views/production-run/shared/model/production-run-display.d.ts

@@ -0,0 +1,187 @@
+import type { FdoDecimal } from '@feedmepos/core/entity';
+/**
+ * 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;
+/** Percent at whole numbers, or `—` when nothing is produced yet. */
+export declare function formatPercent(value: FdoDecimal | null | undefined): string;
+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 {
+    /** Present on current records; older display fixtures may omit it. */
+    stockApplicationStatus?: 'PENDING' | 'APPLIED' | null;
+    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;
+/**
+ * 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/shared/model/production-run-display.spec.d.ts

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

package/dist/views/production-run/shared/model/production-run-item-ingredients.d.ts

@@ -0,0 +1,22 @@
+export interface ProductionRunItemIngredientLine {
+    id: string;
+    name: string;
+    amount: number;
+    unit: string;
+}
+export interface ProductionRunItemIngredientBreakdown {
+    basisUnit: string;
+    lines: ProductionRunItemIngredientLine[];
+}
+/**
+ * Present one output's concrete resolved allocation per output base unit.
+ * This reads the whole current plan, so stock-driven alternative splits stay
+ * identical to the ingredient projection the operator is reviewing.
+ */
+export declare function resolvedIngredientLinesPerOutputBaseUnit(requirements: FdoProductionIngredientRequirements, outputSkuId: string, outputBaseAmount: number): ProductionRunItemIngredientLine[];
+/**
+ * Rebuild the per-output fact sheets from a durable requested plan. Recipe,
+ * binding and alternative definitions are deliberately absent: the request
+ * already froze the concrete ingredient identities, amounts and rate basis.
+ */
+export declare function frozenItemIngredientBreakdowns(plan: FdoProductionRun['plan']): Map<string, ProductionRunItemIngredientBreakdown>;

package/dist/views/production-run/shared/model/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/shared/model/production-run-list.spec.d.ts

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

package/dist/views/production-run/shared/model/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/shared/model/production-run-text-limit.d.ts

@@ -0,0 +1,22 @@
+import { type Ref } from 'vue';
+import { codePointLength } from '@feedmepos/zod-inventory';
+/**
+ * Portal-facing aliases of FM-186's durable ceilings. The values remain owned
+ * by zod-inventory so UI validation cannot drift from the HTTP/entity boundary.
+ */
+export declare const PRODUCTION_RUN_NAME_LIMIT = 100;
+export declare const PRODUCTION_INSTRUCTIONS_LIMIT = 2000;
+export declare const PRODUCTION_REMARK_LIMIT = 500;
+export { codePointLength };
+/**
+ * Production-specific counter/error state for one authored text field, held
+ * to a code-point ceiling. Deliberately does not truncate — a form must never
+ * cut off paste or IME composition input, only report that the box is over
+ * and block submission until it is fixed.
+ */
+export declare function useProductionRunTextLimit(value: Ref<string>, max: number): {
+    length: import("vue").ComputedRef<number>;
+    exceeded: import("vue").ComputedRef<boolean>;
+    helperText: import("vue").ComputedRef<string>;
+    helperState: import("vue").ComputedRef<"error" | "none">;
+};

package/dist/views/production-run/shared/model/production-run-text-limit.spec.d.ts

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

package/dist/views/production-run/shared/model/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/shared/model/use-production-run-actions.d.ts

@@ -0,0 +1,39 @@
+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;
+}
+/**
+ * Ordinary lifecycle actions come 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.
+ */
+/** An accepted output command is not yet proof of its stock application. */
+export declare function hasPendingProductionOutput(run: FdoProductionRun): boolean;
+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/shared/model/use-production-run-actions.spec.d.ts

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