@burdenoff/microfe-movethewheels 2026.1017.11 → 2026.1017.13

package/dist/generated/pallet-preview-operations.d.ts

@@ -0,0 +1,273 @@
+import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
+/** Internal type. DO NOT USE DIRECTLY. */
+type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+/** Internal type. DO NOT USE DIRECTLY. */
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
+};
+import type * as Types from './pallet-preview-operations';
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+};
+export type MtwPalletAdditionalPackingInput = {
+    massG?: InputMaybe<Scalars['String']['input']>;
+    source?: InputMaybe<MtwPalletMeasurementSourceInput>;
+};
+export type MtwPalletBaseInput = {
+    heightMm?: InputMaybe<Scalars['Int']['input']>;
+    lengthMm?: InputMaybe<Scalars['Int']['input']>;
+    maxPayloadMassG?: InputMaybe<Scalars['String']['input']>;
+    source?: InputMaybe<MtwPalletMeasurementSourceInput>;
+    tareMassG?: InputMaybe<Scalars['String']['input']>;
+    widthMm?: InputMaybe<Scalars['Int']['input']>;
+};
+export type MtwPalletBound = {
+    __typename?: 'MtwPalletBound';
+    reason: Scalars['String']['output'];
+    status: MtwPalletBoundStatus;
+};
+export type MtwPalletBoundStatus = 'FAIL' | 'PASS' | 'UNKNOWN';
+export type MtwPalletBounds = {
+    __typename?: 'MtwPalletBounds';
+    loadedPalletGrossMass: MtwPalletBound;
+    palletFootprintWithinLoadEnvelope: MtwPalletBound;
+    palletPayloadMass: MtwPalletBound;
+    permittedUprightYaw: MtwPalletBound;
+    placedContainment: MtwPalletBound;
+    placedNonOverlap: MtwPalletBound;
+    reportedSingleLayerHeight: MtwPalletBound;
+};
+export type MtwPalletClassification = 'GEOMETRIC_PROPOSAL_ONLY';
+export type MtwPalletClearanceInput = {
+    betweenPackagesMm?: InputMaybe<Scalars['Int']['input']>;
+    perimeterMm?: InputMaybe<Scalars['Int']['input']>;
+    source?: InputMaybe<MtwPalletMeasurementSourceInput>;
+    topMm?: InputMaybe<Scalars['Int']['input']>;
+};
+/** Read-only supplied-measurement geometry; no persistence, stock change or release authority. */
+export type MtwPalletGeometryPreview = {
+    __typename?: 'MtwPalletGeometryPreview';
+    bounds: MtwPalletBounds;
+    classification: MtwPalletClassification;
+    layoutStatus: MtwPalletLayoutStatus;
+    method: MtwPalletMethod;
+    placedQuantity: Scalars['Int']['output'];
+    placements: Array<MtwPalletPlacement>;
+    requestedGrossMassG?: Maybe<Scalars['String']['output']>;
+    requestedPayloadMassG?: Maybe<Scalars['String']['output']>;
+    requestedQuantity: Scalars['Int']['output'];
+    sources: MtwPalletSources;
+    units: MtwPalletUnits;
+    unplaced: Array<MtwPalletUnplaced>;
+    unsupported: MtwPalletUnsupported;
+};
+export type MtwPalletGeometryPreviewInput = {
+    additionalPacking: MtwPalletAdditionalPackingInput;
+    clearance: MtwPalletClearanceInput;
+    loadEnvelope?: InputMaybe<MtwPalletLoadEnvelopeInput>;
+    mode: MtwPalletMode;
+    packages: Array<MtwPalletPackageInput>;
+    pallet: MtwPalletBaseInput;
+    units: MtwPalletUnits;
+};
+export type MtwPalletLayoutStatus = 'NO_LAYOUT_FOUND_BY_METHOD' | 'PLACED_BY_METHOD' | 'UNKNOWN';
+export type MtwPalletLoadEnvelopeInput = {
+    lengthMm?: InputMaybe<Scalars['Int']['input']>;
+    maxGrossMassG?: InputMaybe<Scalars['String']['input']>;
+    maxHeightMm?: InputMaybe<Scalars['Int']['input']>;
+    source?: InputMaybe<MtwPalletMeasurementSourceInput>;
+    widthMm?: InputMaybe<Scalars['Int']['input']>;
+};
+export type MtwPalletMeasurementSource = {
+    __typename?: 'MtwPalletMeasurementSource';
+    reference: Scalars['String']['output'];
+    version: Scalars['String']['output'];
+};
+export type MtwPalletMeasurementSourceInput = {
+    reference: Scalars['String']['input'];
+    version: Scalars['String']['input'];
+};
+export type MtwPalletMethod = 'DETERMINISTIC_SINGLE_LAYER_SHELF_V1';
+export type MtwPalletMode = 'UPRIGHT_SINGLE_LAYER';
+export type MtwPalletPackageInput = {
+    allowedYawDegrees?: InputMaybe<Array<Scalars['Int']['input']>>;
+    grossMassG?: InputMaybe<Scalars['String']['input']>;
+    heightMm?: InputMaybe<Scalars['Int']['input']>;
+    id: Scalars['ID']['input'];
+    lengthMm?: InputMaybe<Scalars['Int']['input']>;
+    quantity: Scalars['Int']['input'];
+    source?: InputMaybe<MtwPalletMeasurementSourceInput>;
+    upright?: InputMaybe<Scalars['Boolean']['input']>;
+    widthMm?: InputMaybe<Scalars['Int']['input']>;
+};
+export type MtwPalletPackageSource = {
+    __typename?: 'MtwPalletPackageSource';
+    packageId: Scalars['ID']['output'];
+    source?: Maybe<MtwPalletMeasurementSource>;
+};
+export type MtwPalletPlacement = {
+    __typename?: 'MtwPalletPlacement';
+    heightMm?: Maybe<Scalars['Int']['output']>;
+    lengthMm: Scalars['Int']['output'];
+    packageId: Scalars['ID']['output'];
+    unit: Scalars['Int']['output'];
+    widthMm: Scalars['Int']['output'];
+    xMm: Scalars['Int']['output'];
+    yMm: Scalars['Int']['output'];
+    yawDegrees: Scalars['Int']['output'];
+    zMm?: Maybe<Scalars['Int']['output']>;
+};
+export type MtwPalletSources = {
+    __typename?: 'MtwPalletSources';
+    additionalPacking?: Maybe<MtwPalletMeasurementSource>;
+    clearance?: Maybe<MtwPalletMeasurementSource>;
+    loadEnvelope?: Maybe<MtwPalletMeasurementSource>;
+    packages: Array<MtwPalletPackageSource>;
+    pallet?: Maybe<MtwPalletMeasurementSource>;
+};
+export type MtwPalletUnits = 'MM_G';
+export type MtwPalletUnplaced = {
+    __typename?: 'MtwPalletUnplaced';
+    packageId: Scalars['ID']['output'];
+    quantity: Scalars['Int']['output'];
+};
+export type MtwPalletUnsupported = {
+    __typename?: 'MtwPalletUnsupported';
+    additionalPackingGeometry: MtwPalletUnsupportedStatus;
+    centreOfGravityAndStability: MtwPalletUnsupportedStatus;
+    handling: MtwPalletUnsupportedStatus;
+    loadingAndUnloadingPath: MtwPalletUnsupportedStatus;
+    securing: MtwPalletUnsupportedStatus;
+    segregationAndCargoCompatibility: MtwPalletUnsupportedStatus;
+    supportAndFloorContactLoads: MtwPalletUnsupportedStatus;
+};
+export type MtwPalletUnsupportedStatus = 'UNKNOWN';
+export type Query = {
+    __typename?: 'Query';
+    mtwPalletGeometryPreview: MtwPalletGeometryPreview;
+};
+export type QueryMtwPalletGeometryPreviewArgs = {
+    input: MtwPalletGeometryPreviewInput;
+};
+export type MtwPalletGeometryPreviewQueryVariables = Exact<{
+    input: Types.MtwPalletGeometryPreviewInput;
+}>;
+export type MtwPalletGeometryPreviewQuery = {
+    mtwPalletGeometryPreview: {
+        classification: Types.MtwPalletClassification;
+        method: Types.MtwPalletMethod;
+        units: Types.MtwPalletUnits;
+        layoutStatus: Types.MtwPalletLayoutStatus;
+        requestedQuantity: number;
+        placedQuantity: number;
+        requestedPayloadMassG: string | null;
+        requestedGrossMassG: string | null;
+        placements: Array<{
+            packageId: string;
+            unit: number;
+            yawDegrees: number;
+            xMm: number;
+            yMm: number;
+            zMm: number | null;
+            widthMm: number;
+            lengthMm: number;
+            heightMm: number | null;
+        }>;
+        unplaced: Array<{
+            packageId: string;
+            quantity: number;
+        }>;
+        bounds: {
+            placedContainment: {
+                status: Types.MtwPalletBoundStatus;
+                reason: string;
+            };
+            placedNonOverlap: {
+                status: Types.MtwPalletBoundStatus;
+                reason: string;
+            };
+            permittedUprightYaw: {
+                status: Types.MtwPalletBoundStatus;
+                reason: string;
+            };
+            reportedSingleLayerHeight: {
+                status: Types.MtwPalletBoundStatus;
+                reason: string;
+            };
+            palletPayloadMass: {
+                status: Types.MtwPalletBoundStatus;
+                reason: string;
+            };
+            palletFootprintWithinLoadEnvelope: {
+                status: Types.MtwPalletBoundStatus;
+                reason: string;
+            };
+            loadedPalletGrossMass: {
+                status: Types.MtwPalletBoundStatus;
+                reason: string;
+            };
+        };
+        unsupported: {
+            additionalPackingGeometry: Types.MtwPalletUnsupportedStatus;
+            handling: Types.MtwPalletUnsupportedStatus;
+            securing: Types.MtwPalletUnsupportedStatus;
+            centreOfGravityAndStability: Types.MtwPalletUnsupportedStatus;
+            supportAndFloorContactLoads: Types.MtwPalletUnsupportedStatus;
+            loadingAndUnloadingPath: Types.MtwPalletUnsupportedStatus;
+            segregationAndCargoCompatibility: Types.MtwPalletUnsupportedStatus;
+        };
+        sources: {
+            packages: Array<{
+                packageId: string;
+                source: {
+                    reference: string;
+                    version: string;
+                } | null;
+            }>;
+            pallet: {
+                reference: string;
+                version: string;
+            } | null;
+            loadEnvelope: {
+                reference: string;
+                version: string;
+            } | null;
+            additionalPacking: {
+                reference: string;
+                version: string;
+            } | null;
+            clearance: {
+                reference: string;
+                version: string;
+            } | null;
+        };
+    };
+};
+export declare const MtwPalletGeometryPreviewDocument: DocumentNode<MtwPalletGeometryPreviewQuery, MtwPalletGeometryPreviewQueryVariables>;
+export {};

package/dist/hooks/usePalletPreview.js

@@ -0,0 +1,86 @@
+import { useMoveTheWheels as e } from "../providers/MoveTheWheelsProvider.js";
+import { executeGraphQL as t } from "../utils/graphqlClient.js";
+import { parsePalletPreview as n, validatePalletPreviewEnvelope as r } from "../utils/palletPreviewResponse.js";
+import { MtwPalletGeometryPreviewDocument as i } from "../src/generated/pallet-preview-operations.js";
+import { useCallback as a, useEffect as o, useLayoutEffect as s, useMemo as c, useRef as l, useState as u } from "react";
+import { print as d } from "graphql";
+//#region src/movethewheels/hooks/usePalletPreview.ts
+var f = d(i);
+function p() {
+	let { workspaceId: i, tenantId: d, currentUser: p, apiGatewayUrl: m, authToken: h, workspaceToken: g } = e(), _ = c(() => ({
+		workspaceId: i,
+		tenantId: d,
+		actorId: p?.id,
+		apiGatewayUrl: m,
+		authToken: h,
+		workspaceToken: g
+	}), [
+		i,
+		d,
+		p?.id,
+		m,
+		h,
+		g
+	]), v = l(_);
+	s(() => {
+		v.current = _;
+	}, [_]);
+	let y = l(0), b = l(null), [x, S] = u(null), C = a(() => {
+		y.current++, b.current?.abort(), b.current = null, S(null);
+	}, []);
+	o(() => (C(), () => {
+		y.current++, b.current?.abort(), b.current = null;
+	}), [_, C]);
+	let w = a(async (e) => {
+		if (v.current !== _ || b.current || !_.workspaceId || !_.actorId) return;
+		e = structuredClone(e);
+		let i = new AbortController();
+		b.current = i;
+		let a = ++y.current;
+		S({
+			context: _,
+			generation: a,
+			loading: !0,
+			result: null,
+			input: e,
+			failed: !1
+		});
+		try {
+			let o = n(await t({
+				..._,
+				signal: i.signal,
+				validateResponse: r
+			}, f, { input: e }), e);
+			!i.signal.aborted && v.current === _ && y.current === a && S({
+				context: _,
+				generation: a,
+				loading: !1,
+				result: o,
+				input: e,
+				failed: !1
+			});
+		} catch {
+			!i.signal.aborted && v.current === _ && y.current === a && S({
+				context: _,
+				generation: a,
+				loading: !1,
+				result: null,
+				input: e,
+				failed: !0
+			});
+		} finally {
+			b.current === i && (b.current = null);
+		}
+	}, [_]), T = x?.context === _;
+	return {
+		run: w,
+		invalidate: C,
+		ready: !!_.workspaceId && !!_.actorId,
+		loading: T ? x.loading : !1,
+		result: T ? x.result : null,
+		input: T ? x.input : null,
+		failed: T ? x.failed : !1
+	};
+}
+//#endregion
+export { p as usePalletPreview };

package/dist/movethewheels/components/pallet-preview/PalletPreviewResults.d.ts

@@ -0,0 +1,6 @@
+import { MtwPalletGeometryPreviewInput } from '../../../generated/pallet-preview-operations';
+import { PalletPreview } from '../../utils/palletPreviewResponse';
+export declare function PalletPreviewResults({ result, input, }: {
+    result: PalletPreview;
+    input: MtwPalletGeometryPreviewInput;
+}): import('react').JSX.Element;

package/dist/movethewheels/hooks/usePalletPreview.d.ts

@@ -0,0 +1,98 @@
+import { MtwPalletGeometryPreviewInput } from '../../generated/pallet-preview-operations';
+export declare function usePalletPreview(): {
+    run: (input: MtwPalletGeometryPreviewInput) => Promise<void>;
+    invalidate: () => void;
+    ready: boolean;
+    loading: boolean;
+    result: {
+        classification: import('../../generated/pallet-preview-operations').MtwPalletClassification;
+        method: import('../../generated/pallet-preview-operations').MtwPalletMethod;
+        units: import('../../generated/pallet-preview-operations').MtwPalletUnits;
+        layoutStatus: import('../../generated/pallet-preview-operations').MtwPalletLayoutStatus;
+        requestedQuantity: number;
+        placedQuantity: number;
+        requestedPayloadMassG: string | null;
+        requestedGrossMassG: string | null;
+        placements: Array<{
+            packageId: string;
+            unit: number;
+            yawDegrees: number;
+            xMm: number;
+            yMm: number;
+            zMm: number | null;
+            widthMm: number;
+            lengthMm: number;
+            heightMm: number | null;
+        }>;
+        unplaced: Array<{
+            packageId: string;
+            quantity: number;
+        }>;
+        bounds: {
+            placedContainment: {
+                status: import('../../generated/pallet-preview-operations').MtwPalletBoundStatus;
+                reason: string;
+            };
+            placedNonOverlap: {
+                status: import('../../generated/pallet-preview-operations').MtwPalletBoundStatus;
+                reason: string;
+            };
+            permittedUprightYaw: {
+                status: import('../../generated/pallet-preview-operations').MtwPalletBoundStatus;
+                reason: string;
+            };
+            reportedSingleLayerHeight: {
+                status: import('../../generated/pallet-preview-operations').MtwPalletBoundStatus;
+                reason: string;
+            };
+            palletPayloadMass: {
+                status: import('../../generated/pallet-preview-operations').MtwPalletBoundStatus;
+                reason: string;
+            };
+            palletFootprintWithinLoadEnvelope: {
+                status: import('../../generated/pallet-preview-operations').MtwPalletBoundStatus;
+                reason: string;
+            };
+            loadedPalletGrossMass: {
+                status: import('../../generated/pallet-preview-operations').MtwPalletBoundStatus;
+                reason: string;
+            };
+        };
+        unsupported: {
+            additionalPackingGeometry: import('../../generated/pallet-preview-operations').MtwPalletUnsupportedStatus;
+            handling: import('../../generated/pallet-preview-operations').MtwPalletUnsupportedStatus;
+            securing: import('../../generated/pallet-preview-operations').MtwPalletUnsupportedStatus;
+            centreOfGravityAndStability: import('../../generated/pallet-preview-operations').MtwPalletUnsupportedStatus;
+            supportAndFloorContactLoads: import('../../generated/pallet-preview-operations').MtwPalletUnsupportedStatus;
+            loadingAndUnloadingPath: import('../../generated/pallet-preview-operations').MtwPalletUnsupportedStatus;
+            segregationAndCargoCompatibility: import('../../generated/pallet-preview-operations').MtwPalletUnsupportedStatus;
+        };
+        sources: {
+            packages: Array<{
+                packageId: string;
+                source: {
+                    reference: string;
+                    version: string;
+                } | null;
+            }>;
+            pallet: {
+                reference: string;
+                version: string;
+            } | null;
+            loadEnvelope: {
+                reference: string;
+                version: string;
+            } | null;
+            additionalPacking: {
+                reference: string;
+                version: string;
+            } | null;
+            clearance: {
+                reference: string;
+                version: string;
+            } | null;
+        };
+    } | null;
+    input: MtwPalletGeometryPreviewInput | null;
+    failed: boolean;
+};

package/dist/movethewheels/pages/PalletPreviewPage.d.ts

@@ -0,0 +1 @@
+export default function PalletPreviewPage(): import('react').JSX.Element;

package/dist/movethewheels/utils/graphqlClient.d.ts

@@ -7,6 +7,10 @@ interface GraphQLRequestOptions {
     workspaceId?: string;
     tenantId?: string;
     actorId?: string;
+    /** Optional caller-owned cancellation; omitted preserves legacy retry behavior. */
+    signal?: AbortSignal;
+    /** Optional owning read-envelope guard; no effect on existing callers. */
+    validateResponse?: (value: unknown) => void;
 }
 export declare function resolveGraphqlUrl(apiGatewayUrl?: string): string;
 export declare function executeGraphQL<TData>(options: GraphQLRequestOptions, query: string, variables?: Record<string, unknown>, attemptPolicy?: GraphQLAttemptPolicy, holdRefusalField?: VehicleHoldMutation): Promise<TData>;

package/dist/movethewheels/utils/palletPreviewInput.d.ts

@@ -0,0 +1,54 @@
+import { MtwPalletGeometryPreviewInput } from '../../generated/pallet-preview-operations';
+export interface SourceDraft {
+    reference: string;
+    version: string;
+}
+export interface PackageDraft {
+    key: number;
+    id: string;
+    quantity: string;
+    source: SourceDraft;
+    widthMm: string;
+    lengthMm: string;
+    heightMm: string;
+    grossMassG: string;
+    yaw: 'UNKNOWN' | 'NONE' | '0' | '90' | 'BOTH';
+    upright: 'UNKNOWN' | 'YES' | 'NO';
+}
+export interface PalletPreviewDraft {
+    packages: PackageDraft[];
+    pallet: {
+        source: SourceDraft;
+        widthMm: string;
+        lengthMm: string;
+        heightMm: string;
+        tareMassG: string;
+        maxPayloadMassG: string;
+    };
+    includeEnvelope: boolean;
+    loadEnvelope: {
+        source: SourceDraft;
+        widthMm: string;
+        lengthMm: string;
+        maxHeightMm: string;
+        maxGrossMassG: string;
+    };
+    additionalPacking: {
+        source: SourceDraft;
+        massG: string;
+    };
+    clearance: {
+        source: SourceDraft;
+        perimeterMm: string;
+        betweenPackagesMm: string;
+        topMm: string;
+    };
+}
+export declare const newPalletPackage: (key: number) => PackageDraft;
+export declare function newPalletPreviewDraft(): PalletPreviewDraft;
+export declare class PalletInputError extends Error {
+    readonly field: string;
+    readonly kind: 'WHOLE' | 'MASS' | 'SOURCE' | 'IDENTITY' | 'COUNT';
+    constructor(field: string, kind: 'WHOLE' | 'MASS' | 'SOURCE' | 'IDENTITY' | 'COUNT');
+}
+export declare function palletPreviewInput(draft: PalletPreviewDraft): MtwPalletGeometryPreviewInput;

package/dist/movethewheels/utils/palletPreviewResponse.d.ts

@@ -0,0 +1,7 @@
+import { MtwPalletGeometryPreviewInput, MtwPalletGeometryPreviewQuery } from '../../generated/pallet-preview-operations';
+export type PalletPreview = MtwPalletGeometryPreviewQuery['mtwPalletGeometryPreview'];
+export declare const PALLET_BOUND_KEYS: readonly ["placedContainment", "placedNonOverlap", "permittedUprightYaw", "reportedSingleLayerHeight", "palletPayloadMass", "palletFootprintWithinLoadEnvelope", "loadedPalletGrossMass"];
+export declare const PALLET_UNKNOWN_KEYS: readonly ["additionalPackingGeometry", "handling", "securing", "centreOfGravityAndStability", "supportAndFloorContactLoads", "loadingAndUnloadingPath", "segregationAndCargoCompatibility"];
+/** New preview only: malformed or mixed envelopes never become a current result. */
+export declare function validatePalletPreviewEnvelope(value: unknown): void;
+export declare function parsePalletPreview(data: unknown, input: MtwPalletGeometryPreviewInput): PalletPreview;