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

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

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

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

@@ -0,0 +1,15 @@
+export declare function useProductionRunDisclosure(): {
+    hovered: import("vue").Ref<boolean, boolean>;
+    focused: import("vue").Ref<boolean, boolean>;
+    pinned: import("vue").Ref<boolean, boolean>;
+    transientOpen: import("vue").ComputedRef<boolean>;
+    open: import("vue").ComputedRef<boolean>;
+    enterTrigger: () => void;
+    leaveTrigger: () => void;
+    focusTrigger: () => void;
+    blurTrigger: () => void;
+    dismissTransient: () => void;
+    dismiss: () => void;
+    togglePinned: () => void;
+    onPopoverChanged: (value: boolean) => void;
+};

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

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

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

@@ -0,0 +1,19 @@
+import { type Ref } from 'vue';
+import type { WithRev } from '@/api/type';
+interface ProductionRunDuplicateSourceOptions {
+    list: () => Promise<WithRev<FdoProductionRun>[]>;
+    runId: () => string;
+    locationId: () => string | null | undefined;
+}
+/**
+ * Lazily load the runs an edit may copy from without letting one opening of the
+ * editor settle another. Run and location equality are necessary but not
+ * sufficient: close then reopen on the same document has the same pair, so a
+ * generation is the durable boundary between those two intents.
+ */
+export declare function useProductionRunDuplicateSources(options: ProductionRunDuplicateSourceOptions): {
+    sources: Ref<WithRev<FdoProductionRun>[]>;
+    load: () => Promise<void>;
+    invalidate: () => void;
+};
+export {};

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

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

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

@@ -0,0 +1,92 @@
+import type { FdoDinero } from '@feedmepos/core/entity';
+/**
+ * Why the run's cost is or is not knowable, as one value.
+ *
+ * The flags below each answer a different question, and a consumer that needs
+ * a single answer was left to infer one — which is how the close confirmation
+ * came to read "no ingredients named" as "the pool could not be split", a
+ * conclusion that is also consistent with no pool at all and with a negative
+ * valuation. Anything choosing one message, or deciding whether a money figure
+ * may be shown, discriminates on this and never on the shape of another field.
+ *
+ * Ordered by precedence: an unavailable pool is not also uncosted, and a
+ * negative valuation outranks an unsplittable one because it is the more
+ * serious claim about the same number. `uncostedSkuIds` stays populated
+ * underneath, so a surface with room for both can still say both.
+ */
+export type ProductionRunCostState = 
+/** No pool at all — not issued, or the adjustment could not be read. */
+'unavailable'
+/** The pool came out below zero; nothing is missing, the number is wrong. */
+ | 'negative-valuation'
+/** Priced in full, but it cannot be divided between the outputs. */
+ | 'unattributable'
+/** Some consumed ingredient carried no cost, so the pool under-counts. */
+ | 'uncosted'
+/** Every figure on the summary is real. The ONLY state that may show money. */
+ | 'known';
+export interface ProductionRunCostSummary {
+    /** `fromCostBalances − toCostBalances` over the issue adjustment. */
+    pool: FdoDinero | null;
+    /** Issued cost that has become output cost: `pool × produced ÷ committed`. */
+    absorbed: FdoDinero | null;
+    /** The pool not absorbed into output. NOT a write-off — close moves nothing. */
+    open: FdoDinero | null;
+    /** Absorbed output cost per sku, derived by the same core rule as `absorbed`. */
+    absorbedBySku: Record<string, FdoDinero> | null;
+    /**
+     * `share ÷ committed` PER SKU. Constant by construction within a sku — a short
+     * run does not make each unit dearer — but not comparable across skus, which
+     * is why there is no single number here.
+     */
+    perUnitBySku: Record<string, FdoDinero> | null;
+    /** One share per batch, in stored order. Telescoping: their sum IS `absorbed`. */
+    batchShares: FdoDinero[] | null;
+    /**
+     * The pool exists, every issued ingredient contributed to it, and the total
+     * is a cost rather than a credit. False for ANY of those, because each ends
+     * the same way for a reader: the figures on this page cannot be trusted.
+     */
+    isCostKnown: boolean;
+    /**
+     * The issued pool came out below zero.
+     *
+     * Issuing ingredients cannot cost a negative amount. It happens anyway when
+     * the location is overdrawn — FIFO values a deduction against layers that are
+     * not there and the arithmetic runs past zero. Distinguished from `uncosted`
+     * because the cause and the wording differ: nothing is missing here, the
+     * number is wrong.
+     */
+    isValuationNegative: boolean;
+    /**
+     * A pool exists but cannot be divided between the outputs, so no figure that
+     * depends on the split can be stated.
+     *
+     * The third distinct reason a cost is unknown, and the one with no named
+     * subject: `uncostedSkuIds` is about ingredients that contributed nothing,
+     * this is about outputs that can be attributed nothing. It happens when an
+     * output has no bindings, or when a recipe names an ingredient the movement
+     * never touched. Without it a reader is told "all ingredients costed" beside
+     * a withheld total, which is true and useless — every ingredient IS costed;
+     * the split is what failed.
+     */
+    isPoolUnattributable: boolean;
+    /** Ingredients consumed by the issuance that carried no cost — the pool under-counts by their value. */
+    uncostedSkuIds: string[];
+    /** The single discriminant. `isCostKnown` is `costState === 'known'` by construction. */
+    costState: ProductionRunCostState;
+}
+/**
+ * Every read-time money figure for a run, from the run and its issue
+ * adjustment.
+ *
+ * **Every money field is null when `pool` is null**, and that is the whole
+ * point of the shape. An uncostable issuance (a run whose items have no convert
+ * bindings, or lines with no cost balance on either side) produces no pool, and
+ * a derived `RM 0.00` would assert the ingredients were free — a different, and
+ * false, claim. `—` is the honest render; `null` is what makes it reachable.
+ *
+ * Pass `issueAdjustment: null` for a run that has not issued: same answer, same
+ * reason.
+ */
+export declare function productionRunCostSummary(run: FdoProductionRun, issueAdjustment: FdoInventoryAdjustment | null): ProductionRunCostSummary;

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

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

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

@@ -0,0 +1,277 @@
+import { type Ref } from 'vue';
+import type { WithRev } from '@/api/type';
+import { type ProductionRunFailure } from '@/api/production-run-error';
+import { productionRunDisplayName } from './production-run-list';
+import { type ProductionRunQuantityModel, type ProductionRunUnitSnapshot } from '../components/production-run-unit-snapshot';
+export interface ProductionRunPlannerItem {
+    /** The controller key, which is the sku id. */
+    key: string;
+    skuId: string;
+    name: string;
+    code: string;
+    /** Base unit abbreviation — what on-hand and the ingredient tree are stated in. */
+    baseUnit: string;
+    /** The unit the quantity is currently entered in. */
+    enteredUnit: string;
+    onHand: number | null;
+    /** The requested quantity converted to the sku's base unit. */
+    baseQuantity: number;
+    sku: FdoInventorySku;
+    model: ProductionRunQuantityModel;
+    bindingCount: number;
+    bindingLines: {
+        id: string;
+        name: string;
+        amount: number;
+        unit: string;
+    }[];
+}
+/**
+ * Outputs that will draw no ingredients: a valid positive authored quantity,
+ * and nothing bound.
+ *
+ * Both halves are load-bearing. Deriving this from "contributes to no commit
+ * row" instead — which is what the planner and the Prepare dialog each did
+ * independently — conflates it with a quantity of zero, since a zero-quantity
+ * item produces no rows either. That made "No quantities set" unreachable
+ * through the planner: any selected item, unquantified, was reported as
+ * committing nothing.
+ *
+ * This classification deliberately reads the raw authored amount rather than
+ * `baseQuantity`. Base conversion is zero when a unit snapshot is missing or
+ * stale, but that is a separate validation failure: it must not hide the fact
+ * that a positively quantified output has no ingredient bindings. Submission
+ * remains gated on a valid matching snapshot below.
+ */
+export declare function unboundOutputNames(items: ProductionRunPlannerItem[]): string[];
+export interface ProductionRunCommitContributor {
+    itemSkuId: string;
+    name: string;
+    /** How much of this ingredient one base unit of the item consumes. */
+    perUnit: number;
+    sourceQuantity: number;
+    sourceUnit: string;
+    amount: number;
+}
+export interface ProductionRunCommitRow {
+    skuId: string;
+    name: string;
+    unit: string;
+    /** Total drawn by the whole plan, as a positive number. */
+    need: number;
+    /**
+     * On-hand now, and after this plan commits. **Null when the balance could not
+     * be resolved** — the sku has no row in the stock document at all.
+     *
+     * Null is not zero and the view must not collapse them (FM-140): rendering an
+     * unresolved balance as `0` invents a shortage the kitchen may not have, and
+     * an "after" figure derived from it is equally fictional. `—` is the honest
+     * render.
+     */
+    current: number | null;
+    after: number | null;
+    status: 'ok' | 'low' | 'shortage' | 'unknown';
+    contributors: ProductionRunCommitContributor[];
+}
+export interface ProductionRunShortage {
+    name: string;
+    /** How far below zero the projected balance lands. */
+    over: number;
+    unit: string;
+}
+/**
+ * One sku the seeded document listed more than once, and the single line those
+ * lines were combined into.
+ *
+ * A fact about the seed, frozen at `seedFrom`: it says what the DOCUMENT held,
+ * so later edits to the combined line must not rewrite it. Quantities are
+ * resolved to plain numbers here, each beside the unit it was stored in — the
+ * point of showing them is that they read back the way the run was written.
+ */
+export interface ProductionRunDuplicateMerge {
+    skuId: string;
+    name: string;
+    /** The stored lines, in document order, each in the unit it was saved with. */
+    sources: {
+        amount: number;
+        unit: string;
+    }[];
+    /** What they add up to, or null when the sources name different base-unit families. */
+    amount: number | null;
+    unit: string | null;
+}
+export interface ProductionRunCreateResult {
+    run: WithRev<FdoProductionRun>;
+    /** False when the run was created but `request` failed — a draft exists. */
+    requested: boolean;
+    failure: ProductionRunFailure | null;
+}
+export declare function useProductionRunForm(): {
+    loading: Ref<boolean, boolean>;
+    loadFailure: Ref<{
+        kind: import("@/api/production-run-error").ProductionRunFailureKind;
+        message: string;
+        retrySameKey: boolean;
+        mustReload: boolean;
+        shortages: {
+            skuId: string;
+            baseUnit: {
+                name: string;
+                id: string;
+                abbrev: string;
+                conversion: {
+                    amount: number;
+                    precision: number;
+                };
+                baseUnitId: string;
+            };
+            projectedBalance: {
+                amount: number;
+                precision: number;
+            };
+        }[];
+    } | null, ProductionRunFailure | {
+        kind: import("@/api/production-run-error").ProductionRunFailureKind;
+        message: string;
+        retrySameKey: boolean;
+        mustReload: boolean;
+        shortages: {
+            skuId: string;
+            baseUnit: {
+                name: string;
+                id: string;
+                abbrev: string;
+                conversion: {
+                    amount: number;
+                    precision: number;
+                };
+                baseUnitId: string;
+            };
+            projectedBalance: {
+                amount: number;
+                precision: number;
+            };
+        }[];
+    } | null>;
+    submitting: Ref<boolean, boolean>;
+    dirty: Ref<boolean, boolean>;
+    runName: Ref<string, string>;
+    instructions: Ref<string, string>;
+    items: import("vue").ComputedRef<ProductionRunPlannerItem[]>;
+    commits: import("vue").ComputedRef<ProductionRunCommitRow[]>;
+    shortages: import("vue").ComputedRef<ProductionRunShortage[]>;
+    candidates: import("vue").ComputedRef<{
+        sku: {
+            trackingMeasurement?: string | null | undefined;
+            isInactive?: boolean | null | undefined;
+            convert?: {
+                measurement?: string | null | undefined;
+                inventoryBindings?: {
+                    measurement?: {
+                        name: string;
+                        id: string;
+                        abbrev: string;
+                        conversion: {
+                            amount: number;
+                            precision: number;
+                        };
+                    } | null | undefined;
+                    rules?: Record<string, any> | null | undefined;
+                    alternatives?: {
+                        default?: boolean | null | undefined;
+                        trackingMeasurement?: string | null | undefined;
+                        priority?: number | null | undefined;
+                        _id: string;
+                    }[] | null | undefined;
+                    type: "RECIPE" | "SKU" | "SKU_GROUP";
+                    amount: {
+                        amount: number;
+                        precision: number;
+                    };
+                    id: string;
+                }[] | null | undefined;
+            } | null | undefined;
+            valuation?: "FIFO" | "LIFO" | "FEFO" | "WAVG" | null | undefined;
+            defaultCost?: {
+                measurement?: {
+                    name: string;
+                    id: string;
+                    abbrev: string;
+                    conversion: {
+                        amount: number;
+                        precision: number;
+                    };
+                } | null | undefined;
+                costPerUnit: {
+                    currency: "AED" | "AFN" | "ALL" | "AMD" | "ANG" | "AOA" | "ARS" | "AUD" | "AWG" | "AZN" | "BAM" | "BBD" | "BDT" | "BGN" | "BHD" | "BIF" | "BMD" | "BND" | "BOB" | "BOV" | "BRL" | "BSD" | "BTN" | "BWP" | "BYN" | "BZD" | "CAD" | "CDF" | "CHE" | "CHF" | "CHW" | "CLF" | "CLP" | "CNY" | "COP" | "COU" | "CRC" | "CUC" | "CUP" | "CVE" | "CZK" | "DJF" | "DKK" | "DOP" | "DZD" | "EGP" | "ERN" | "ETB" | "EUR" | "FJD" | "FKP" | "GBP" | "GEL" | "GHS" | "GIP" | "GMD" | "GNF" | "GTQ" | "GYD" | "HKD" | "HNL" | "HRK" | "HTG" | "HUF" | "IDR" | "ILS" | "INR" | "IQD" | "IRR" | "ISK" | "JMD" | "JOD" | "JPY" | "KES" | "KGS" | "KHR" | "KMF" | "KPW" | "KRW" | "KWD" | "KYD" | "KZT" | "LAK" | "LBP" | "LKR" | "LRD" | "LSL" | "LYD" | "MAD" | "MDL" | "MGA" | "MKD" | "MMK" | "MNT" | "MOP" | "MRU" | "MUR" | "MVR" | "MWK" | "MXN" | "MXV" | "MYR" | "MZN" | "NAD" | "NGN" | "NIO" | "NOK" | "NPR" | "NZD" | "OMR" | "PAB" | "PEN" | "PGK" | "PHP" | "PKR" | "PLN" | "PYG" | "QAR" | "RON" | "RSD" | "RUB" | "RWF" | "SAR" | "SBD" | "SCR" | "SDG" | "SEK" | "SGD" | "SHP" | "SLL" | "SOS" | "SRD" | "SSP" | "STN" | "SVC" | "SYP" | "SZL" | "THB" | "TJS" | "TMT" | "TND" | "TOP" | "TRY" | "TTD" | "TWD" | "TZS" | "UAH" | "UGX" | "USD" | "USN" | "UYI" | "UYU" | "UYW" | "UZS" | "VES" | "VND" | "VUV" | "WST" | "XAF" | "XAG" | "XAU" | "XBA" | "XBB" | "XBC" | "XBD" | "XCD" | "XDR" | "XOF" | "XPD" | "XPF" | "XPT" | "XSU" | "XTS" | "XUA" | "XXX" | "YER" | "ZAR" | "ZMW" | "ZWL";
+                    amount: number;
+                    precision: number;
+                };
+            } | null | undefined;
+            operationalGroup?: string | null | undefined;
+            thresholds?: {
+                low: number;
+                mid: number;
+            } | null | undefined;
+            customAttributes?: Record<string, any> | null | undefined;
+            unit: {
+                _id: string;
+                name: string;
+                abbrev: string;
+                precision: number;
+                measurements: {
+                    name: string;
+                    id: string;
+                    abbrev: string;
+                    conversion: {
+                        amount: number;
+                        precision: number;
+                    };
+                }[];
+            };
+            code: string;
+            _id: string;
+            name: string;
+        };
+        hasBindings: boolean;
+        onHand: number;
+    }[]>;
+    projectionFailed: Ref<boolean, boolean>;
+    duplicateMerges: Ref<{
+        skuId: string;
+        name: string;
+        sources: {
+            amount: number;
+            unit: string;
+        }[];
+        amount: number | null;
+        unit: string | null;
+    }[], ProductionRunDuplicateMerge[] | {
+        skuId: string;
+        name: string;
+        sources: {
+            amount: number;
+            unit: string;
+        }[];
+        amount: number | null;
+        unit: string | null;
+    }[]>;
+    canSubmit: import("vue").ComputedRef<boolean>;
+    canRequest: import("vue").ComputedRef<boolean>;
+    load: () => Promise<boolean>;
+    refreshStock: () => Promise<void>;
+    retryProjection: () => void;
+    reset: () => void;
+    seedFrom: (run: FdoProductionRun) => void;
+    addItems: (skuIds: string[]) => void;
+    removeItem: (key: string) => void;
+    clearAll: () => void;
+    duplicateItems: (source: FdoProductionRun, skuIds: string[], mode: 'add' | 'replace', measurementOverrides?: Record<string, ProductionRunUnitSnapshot>) => void;
+    updateItemModel: (key: string, model: ProductionRunQuantityModel) => void;
+    updateRunName: (value: string) => void;
+    updateInstructions: (value: string) => void;
+    createDraft: () => Promise<WithRev<FdoProductionRun>>;
+    updateDraft: (id: string) => Promise<WithRev<FdoProductionRun>>;
+    createAndRequest: () => Promise<ProductionRunCreateResult>;
+    displayName: typeof productionRunDisplayName;
+};

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

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