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

package/dist/views/production-run/features/output/use-production-run-record-output.d.ts

@@ -0,0 +1,245 @@
+import type { Ref } from 'vue';
+import type { FdoDecimal } from '@feedmepos/core/entity';
+import { type RecordProductionOutputResult } from '@/api/production-run';
+import { type ProductionRunUnitSnapshot } from '../../shared/model/production-run-unit-snapshot';
+/**
+ * The record-output dialog's session: one `operationKey`, its whole life.
+ *
+ * `complete` receipts stock for a batch in one write. The operation key is
+ * minted once per intent and held in memory for the life of the dialog
+ * session. An ambiguous response (a timeout, or an unrecognised failure) keeps
+ * that request frozen so a retry reconciles the refreshed run before resending
+ * only the same request — never a second one under a new key. Closing the
+ * dialog or reloading the page ends the session; recovering a write that may
+ * have landed after that point is a server-side concern, not this composable's.
+ */
+/**
+ * Past this, a backdate stops looking like late paperwork and starts looking
+ * like a mistyped year.
+ *
+ * A THRESHOLD, not an invariant — it warns, it does not refuse. See `warnings`
+ * below for why this one is soft while the other two produced-time rules are
+ * hard, and why moving it back into `validate()` would be a regression rather
+ * than a repair.
+ */
+export declare const PRODUCED_AT_MAX_BACKDATE_DAYS = 14;
+export type RecordOutputPhase = 
+/** No dialog session — nothing minted. */
+'idle' | 'editing' | 'submitting'
+/** The request may never have arrived. Same key is safe to resend. */
+ | 'timeout'
+/** Anything else that failed but did not close the door on the key. */
+ | 'failed'
+/**
+ * The run moved under us and the request cannot be resent as-is. Distinct
+ * from `'failed'`: there is nothing to retry, only something to re-read.
+ */
+ | 'stale' | 'saved';
+export type RecordOutputErrorCode = 'overCommitted' | 'negativeOutput' | 'producedAtFuture' | 'producedAtBeforeIssue' | 'wastageAmount' | 'wastageIngredient' | 'wastageItem' | 'wastageReason' | 'wastageRemark' | 'wastageRemarkTooLong' | 'measurementUnavailable' | 'measurementMismatch'
+/** No location is selected, so the request has no location to write to. */
+ | 'locationUnavailable';
+/**
+ * A rule the user may overrule, as distinct from one they may not.
+ *
+ * Deliberately its own union rather than a member of `RecordOutputErrorCode`
+ * with a severity beside it. The type is the statement: nothing that reaches
+ * `errors` can be acknowledged past, and nothing here refuses anything.
+ * `producedAtTooOld` sat in the error union until FM-149 was ruled, and keeping
+ * it there behind a flag would leave the next reader one boolean away from
+ * restoring a refusal that was removed on purpose.
+ */
+export type RecordOutputWarningCode = 'producedAtTooOld';
+/**
+ * A validation failure, as a code plus its parameters rather than a sentence.
+ *
+ * The composable is not a rendering surface and has no `t()`. Carrying the code
+ * keeps the copy in the four locale files where a translator can reach it, and
+ * keeps the spec asserting the RULE rather than an English string that a
+ * wording change would break.
+ *
+ * `field` is what the dialog scrolls to and marks — every error names one.
+ */
+export interface RecordOutputError {
+    field: string;
+    code: RecordOutputErrorCode;
+    params: Record<string, string | number>;
+}
+/**
+ * Same shape as an error, and pointedly not the same thing.
+ *
+ * Carries a code and its params for the identical reason (see above), but a
+ * warning names something the user is being ASKED about rather than told. It
+ * blocks the button only until it is acknowledged, and never populates
+ * `errors` — a validation banner headed "fix these" is the wrong sentence for
+ * a value that may well be correct.
+ */
+export interface RecordOutputWarning {
+    field: string;
+    code: RecordOutputWarningCode;
+    params: Record<string, string | number>;
+}
+export interface RecordOutputLine {
+    skuId: string;
+    name: string;
+    /** Unit abbrev from the issuance snapshot — the unit the movement was valued in. */
+    unit: string | null;
+    /**
+     * The same unit as the whole entity, which `FmUnitInput` needs to render and
+     * to police precision. The abbrev above stays for the plain-text lines that
+     * only interpolate it into a sentence.
+     */
+    unitRef: FdoInventoryUnit | null;
+    /** Frozen on the issuance, never re-read from the live catalogue. */
+    valuation: F_INVENTORY_VALUATION_METHODS | null;
+    /** Base units. */
+    committed: number;
+    /** Base units, across every batch already recorded. */
+    produced: number;
+    /** `committed - produced`, floored at 0. */
+    remaining: number;
+    /**
+     * This batch, BASE units. Every comparison on this run is in base units —
+     * committed, produced, remaining, the over-target guard — so this stays the
+     * one figure they read, whatever unit the user typed in.
+     */
+    amount: number;
+    /**
+     * What the user actually typed, verbatim, and the unit they typed it in.
+     *
+     * Sent on the wire as the pair the entity calls a unit of record: the amount
+     * is expressed IN `measurement`. Null is unresolved UI state and is never
+     * durable; the base choice carries an explicit base-UOM snapshot too. Held
+     * rather than derived back from `amount`, because converting to base and
+     * dividing out again is a rounding trip for no gain.
+     */
+    entered: FdoDecimal;
+    measurement: ProductionRunUnitSnapshot | null;
+}
+export interface RecordOutputWastageLine {
+    /** Stable list key — wastage lines have no server identity until written. */
+    key: string;
+    /** The output item being made when the loss happened. */
+    itemSkuId: string;
+    /** The ingredient that was lost. */
+    skuId: string | null;
+    /** Base units of the INGREDIENT — see `RecordOutputLine.amount`. */
+    amount: number;
+    /** The entered pair — see `RecordOutputLine.entered`. */
+    entered: FdoDecimal;
+    measurement: ProductionRunUnitSnapshot | null;
+    /** Snapshotted when the ingredient is chosen; required before submit. */
+    unitRef: FdoInventoryUnit | null;
+    reason: F_PRODUCTION_WASTAGE_REASON | null;
+    remark: string;
+}
+export interface RecordOutputOverTargetLine {
+    skuId: string;
+    name: string;
+    valuation: F_INVENTORY_VALUATION_METHODS;
+    amount: number;
+    remaining: number;
+    excess: number;
+    excessPercent: number;
+    unit: string | null;
+    /** The target was already met before this batch began. */
+    alreadyAtTarget: boolean;
+}
+export interface RecordOutputSubmitOutcome {
+    result: RecordProductionOutputResult | null;
+    /** Present when the attempt failed in a way the dialog must narrate. */
+    phase: RecordOutputPhase;
+}
+export interface RecordOutputIngredientContext {
+    unit: FdoInventoryUnit;
+    /** Frozen contributor edges for this issued ingredient. */
+    outputSkuIds: string[];
+}
+export interface UseProductionRunRecordOutput {
+    phase: Ref<RecordOutputPhase>;
+    operationKey: Ref<string | null>;
+    producedAt: Ref<string>;
+    lines: Ref<RecordOutputLine[]>;
+    /** Output SKUs deliberately left out of this batch; lines stay in memory for restore. */
+    excludedSkuIds: Ref<Set<string>>;
+    wastages: Ref<RecordOutputWastageLine[]>;
+    remark: Ref<string>;
+    /** True when the trimmed batch note exceeds FM-186's Unicode code-point limit. */
+    remarkExceeded: Ref<boolean>;
+    errors: Ref<RecordOutputError[]>;
+    /** A hard produced-time refusal, live while the operator edits the field. */
+    producedAtError: Ref<RecordOutputError | null>;
+    /** Live, not on submit — nothing here is a refusal, so nothing waits. */
+    warnings: Ref<RecordOutputWarning[]>;
+    /** Has the user confirmed the produced time CURRENTLY in the field? */
+    producedAtAcknowledged: Ref<boolean>;
+    /** A warning stands unanswered — the button waits, the user decides. */
+    needsAcknowledgement: Ref<boolean>;
+    failureMessage: Ref<string | null>;
+    /** The dialog is holding an in-memory request whose result is not yet known. */
+    isResume: Ref<boolean>;
+    /** The freshest run this session has seen — a 409 re-reads it silently. */
+    latestRun: Ref<FdoProductionRun | null>;
+    batchNumber: Ref<number>;
+    batchTotal: Ref<number>;
+    isOpen: Ref<boolean>;
+    isSubmitting: Ref<boolean>;
+    isTerminal: Ref<boolean>;
+    canSubmit: Ref<boolean>;
+    canRetry: Ref<boolean>;
+    /** True while a request is in flight or its outcome remains unresolved. */
+    isFrozen: Ref<boolean>;
+    reachesTarget: Ref<boolean>;
+    /** Any line exceeds its remaining commitment. */
+    overTarget: Ref<boolean>;
+    /** The lines over target, with the frozen valuation that decides the rule. */
+    overTargetLines: Ref<RecordOutputOverTargetLine[]>;
+    /** At least one over-target line is not weighted-average and must be refused. */
+    refusedOverTarget: Ref<boolean>;
+    earliestIssuedAt: Ref<string | null>;
+    open: (run: FdoProductionRun, ingredients?: Record<string, RecordOutputIngredientContext>) => void;
+    close: () => void;
+    addWastage: (itemSkuId?: string) => void;
+    /** Rebind asynchronously loaded issuance ingredients without reopening the operation. */
+    updateIngredientContext: (ingredients: Record<string, RecordOutputIngredientContext>) => void;
+    excludeOutput: (skuId: string) => void;
+    restoreExcludedOutputs: () => void;
+    selectWastageSku: (key: string, skuId: string | null) => void;
+    removeWastage: (key: string) => void;
+    clearErrors: () => void;
+    validate: () => RecordOutputError[];
+    submit: () => Promise<RecordOutputSubmitOutcome>;
+}
+/**
+ * `YYYY-MM-DDTHH:mm` in the browser's own zone — what `<input type="date">` and
+ * `<input type="time">` read and write. Kept local end to end and converted to
+ * an instant only at the API boundary, so a run recorded at 5:05 pm reads back
+ * as 5:05 pm rather than shifting by the offset.
+ */
+export declare function toLocalDateTimeInput(date: Date): string;
+/**
+ * Write an entered pair onto a line, and re-derive its base projection.
+ *
+ * The single place the two representations are allowed to diverge, so a caller
+ * cannot set one and forget the other — which is exactly how a base amount
+ * ends up sitting beside a non-null measurement.
+ */
+export declare function applyEntry(line: {
+    amount: number;
+    entered: FdoDecimal;
+    measurement: ProductionRunUnitSnapshot | null;
+}, entered: FdoDecimal, measurement: ProductionRunUnitSnapshot | null): void;
+/**
+ * Seed a line from a figure already in base units — the remaining commitment or
+ * zero — and record the base unit explicitly. A missing unit stays null and is
+ * refused before submission; null never means "base" for a durable quantity.
+ */
+export declare function applyBase(line: {
+    amount: number;
+    entered: FdoDecimal;
+    measurement: ProductionRunUnitSnapshot | null;
+    unitRef: FdoInventoryUnit | null;
+}, base: number, precision: number): void;
+export declare function toDecimal(value: number, precision?: number): FdoDecimal;
+/** Convert a stored decimal to the form's numeric projection. */
+export declare function fromDecimal(value: FdoDecimal): number;
+export declare function useProductionRunRecordOutput(): UseProductionRunRecordOutput;

package/dist/views/production-run/features/output/use-production-run-record-output.spec.d.ts

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

package/dist/views/production-run/features/planning/ProductionRunContributorBranch.spec.d.ts

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

package/dist/views/production-run/features/planning/ProductionRunContributorBranch.vue.d.ts

@@ -0,0 +1,25 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    entries: {
+        key: string;
+        label: string;
+        value: string;
+    }[];
+    itemRole?: "treeitem" | undefined;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    entries: {
+        key: string;
+        label: string;
+        value: string;
+    }[];
+    itemRole?: "treeitem" | undefined;
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/views/production-run/features/planning/ProductionRunDiscardDialog.spec.d.ts

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

package/dist/views/production-run/features/planning/ProductionRunDiscardDialog.vue.d.ts

@@ -0,0 +1,21 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    show: boolean;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:show": (value: boolean) => void;
+    discard: () => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    show: boolean;
+}>>> & Readonly<{
+    "onUpdate:show"?: ((value: boolean) => any) | undefined;
+    onDiscard?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/views/production-run/features/planning/ProductionRunDuplicateDialog.spec.d.ts

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

package/dist/views/production-run/features/planning/ProductionRunDuplicateDialog.vue.d.ts

@@ -0,0 +1,61 @@
+import type { WithRev } from '@/api/type';
+import type { ProductionRunDuplicateSourceState } from './use-production-run-duplicate-sources';
+import { type ProductionRunUnitSnapshot } from '../../shared/model/production-run-unit-snapshot';
+export interface ProductionRunDuplicateSelection {
+    sourceRunId: string;
+    skuIds: string[];
+    mode: 'add' | 'replace';
+    measurementOverrides: Record<string, ProductionRunUnitSnapshot>;
+}
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    show: boolean;
+    runs: WithRev<FdoProductionRun>[];
+    sourceState?: ProductionRunDuplicateSourceState | undefined;
+    catalog: FdoInventorySku[];
+    stockBySkuId?: Record<string, number | null> | undefined;
+    currentSkuIds: string[];
+    currentRunId?: string | undefined;
+}>, {
+    currentRunId: undefined;
+    stockBySkuId: () => {};
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:show": (value: boolean) => void;
+    "load-more": () => void;
+    select: (selection: ProductionRunDuplicateSelection) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    show: boolean;
+    runs: WithRev<FdoProductionRun>[];
+    sourceState?: ProductionRunDuplicateSourceState | undefined;
+    catalog: FdoInventorySku[];
+    stockBySkuId?: Record<string, number | null> | undefined;
+    currentSkuIds: string[];
+    currentRunId?: string | undefined;
+}>, {
+    currentRunId: undefined;
+    stockBySkuId: () => {};
+}>>> & Readonly<{
+    onSelect?: ((selection: ProductionRunDuplicateSelection) => any) | undefined;
+    "onUpdate:show"?: ((value: boolean) => any) | undefined;
+    "onLoad-more"?: (() => any) | undefined;
+}>, {
+    stockBySkuId: Record<string, number | null>;
+    currentRunId: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/views/production-run/features/planning/ProductionRunFormDialog.spec.d.ts

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