sevago-library 1.7.7 → 1.7.8

package/dist/src/components/elements/floating-action-hub/floating-action-hub.element.stories.d.ts

@@ -4,3 +4,4 @@ declare const meta: Meta<typeof FloatingActionHubElement>;
 export default meta;
 type Story = StoryObj<typeof FloatingActionHubElement>;
 export declare const Default: Story;
+export declare const PersistentBadge: Story;

package/dist/src/components/elements/floating-action-hub/floating-action-hub.interface.d.ts

@@ -1,5 +1,9 @@
 import { SxProps, Theme } from '@mui/material';
+import { ReactNode } from 'react';
 export interface FloatingActionHubItem {
+    alwaysVisible?: boolean;
+    badgeContent?: ReactNode;
+    badgeLabel?: string;
     backgroundColor?: string;
     color?: string;
     disabled?: boolean;

package/dist/src/components/elements/floating-tools/elements/floating-scale-history.element.d.ts

@@ -0,0 +1,8 @@
+import { FLOATING_SCALE_LABELS } from '../floating-scale.constant';
+import { UseFloatingScaleResult } from '../floating-scale.interface';
+interface FloatingScaleHistoryProps extends Pick<UseFloatingScaleResult, 'drops' | 'total' | 'applying' | 'removeDrop'> {
+    unit: string;
+    labels: typeof FLOATING_SCALE_LABELS;
+}
+export declare const FloatingScaleHistory: ({ drops, total, unit, applying, removeDrop, labels, }: FloatingScaleHistoryProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/elements/floating-tools/floating-scale-panel.element.d.ts

@@ -0,0 +1,2 @@
+import { FloatingScalePanelProps } from './floating-scale.interface';
+export declare const FloatingScalePanel: ({ state, open, onClose, onDisconnect, onConnect, options, }: FloatingScalePanelProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/src/components/elements/floating-tools/floating-scale.constant.d.ts

@@ -0,0 +1,58 @@
+import { FloatingScaleConfig } from './floating-scale.interface';
+import { Theme } from '@mui/material';
+export declare const FLOATING_SCALE_LABELS: {
+    title: string;
+    single: string;
+    accumulated: string;
+    connected: string;
+    disconnected: string;
+    connecting: string;
+    disconnecting: string;
+    connect: string;
+    disconnect: string;
+    removeLoad: string;
+    liveWeight: string;
+    target: string;
+    noTarget: string;
+    capture: string;
+    apply: string;
+    reset: string;
+    empty: string;
+    total: string;
+    drop: string;
+    dropCount: string;
+    maximum: string;
+    minimize: string;
+    expand: string;
+    close: string;
+    remove: string;
+    missingProvider: string;
+    unsupported: string;
+    applied: string;
+    applyError: string;
+    waiting: string;
+    moving: string;
+    stable: string;
+    stale: string;
+    overload: string;
+    invalid: string;
+    negative: string;
+    configError: string;
+};
+export declare const FLOATING_SCALE_DEFAULTS: FloatingScaleConfig;
+export declare const FLOATING_SCALE_PANEL_SX: {
+    readonly position: "fixed";
+    readonly right: "16px";
+    readonly bottom: 88;
+    readonly width: 360;
+    readonly maxWidth: "calc(100vw - 2 * 16px)";
+    readonly maxHeight: "calc(100dvh - 112px)";
+    readonly overflow: "hidden";
+    readonly zIndex: (theme: Theme) => number;
+    readonly padding: "16px";
+    readonly gap: "8px";
+    readonly backgroundColor: string;
+    readonly border: `1px solid ${string}`;
+    readonly borderRadius: "12px";
+    readonly boxShadow: "0 4px 20px rgba(0, 0, 0, 0.12)";
+};

package/dist/src/components/elements/floating-tools/floating-scale.enum.d.ts

@@ -0,0 +1,16 @@
+export declare enum FloatingScaleReadingStatus {
+    Waiting = "waiting",
+    Moving = "moving",
+    Stable = "stable",
+    Stale = "stale",
+    Overload = "overload",
+    Invalid = "invalid",
+    Negative = "negative",
+    ConfigError = "configError"
+}
+export declare enum FloatingScaleFeedback {
+    Applied = "applied",
+    ApplyError = "applyError"
+}
+export declare const FloatingScaleReadingStatusTitle: Record<FloatingScaleReadingStatus, string>;
+export declare const FloatingScaleFeedbackTitle: Record<FloatingScaleFeedback, string>;

package/dist/src/components/elements/floating-tools/floating-scale.interface.d.ts

@@ -0,0 +1,58 @@
+import { WebSerialScaleMode, WebSerialScaleReading, WebSerialScaleSharedContextValue, WebSerialScaleWeighingAudit } from '../../web-serial-scale';
+import { FloatingScaleFeedback, FloatingScaleReadingStatus } from './floating-scale.enum';
+export interface FloatingScaleConfig {
+    unit: string;
+    maxWeight: number;
+    stableDurationMs: number;
+    stableTolerance: number;
+    staleAfterMs: number;
+}
+export interface FloatingScaleOptions {
+    /** Readings and all thresholds must use this same unit. No unit conversion is performed. */
+    unit?: string;
+    maxWeight?: number;
+    stableDurationMs?: number;
+    stableTolerance?: number;
+    staleAfterMs?: number;
+    deviceId?: string;
+    deviceLabel?: string;
+    operatorId?: string;
+    labels?: Partial<typeof import('./floating-scale.constant').FLOATING_SCALE_LABELS>;
+    onApply?: (audit: WebSerialScaleWeighingAudit) => void | Promise<void>;
+}
+export interface FloatingScaleDrop {
+    id: number;
+    units: bigint;
+    reading: WebSerialScaleReading;
+}
+export interface FloatingScaleSample {
+    value: number;
+    time: number;
+}
+export interface UseFloatingScaleResult {
+    scale?: WebSerialScaleSharedContextValue;
+    config: FloatingScaleConfig;
+    mode: WebSerialScaleMode;
+    setMode: (mode: WebSerialScaleMode) => void;
+    drops: FloatingScaleDrop[];
+    total: number;
+    displayWeight: string;
+    readingStatus: FloatingScaleReadingStatus;
+    locked: boolean;
+    applying: boolean;
+    feedback?: FloatingScaleFeedback;
+    canCapture: boolean;
+    canApply: boolean;
+    capture: () => void;
+    apply: () => Promise<void>;
+    removeDrop: (id: number) => void;
+    reset: () => void;
+}
+export interface FloatingScalePanelProps {
+    state: UseFloatingScaleResult;
+    open: boolean;
+    onClose: () => void;
+    onDisconnect: () => void;
+    onConnect: () => void;
+    options?: FloatingScaleOptions;
+}

package/dist/src/components/elements/floating-tools/floating-scale.util.d.ts

@@ -0,0 +1,3 @@
+/** Decimal arithmetic for the library's four-decimal scale protocol; never sum binary floats. */
+export declare const scaleWeightUnits: (weight: number) => bigint;
+export declare const formatScaleWeight: (units: bigint) => string;

package/dist/src/components/elements/floating-tools/floating-tools.argtypes.d.ts

@@ -0,0 +1,3 @@
+import { ArgTypes } from '@storybook/react';
+import { FloatingToolsElementProps } from './floating-tools.element';
+export declare const floatingToolsArgTypes: Partial<ArgTypes<FloatingToolsElementProps>>;

package/dist/src/components/elements/floating-tools/floating-tools.element.d.ts

@@ -1,11 +1,13 @@
 import { AxiosInstance } from 'axios';
 import { FC } from 'react';
 import { FloatingActionHubItem } from '../floating-action-hub';
+import { FloatingScaleOptions } from './floating-scale.interface';
 export interface FloatingToolsElementProps {
     axiosProductManagement?: AxiosInstance;
     enableFinishGoodGallery?: boolean;
     enableScale?: boolean;
     items?: FloatingActionHubItem[];
     scaleAutoConnectAuthorized?: boolean;
+    scaleOptions?: FloatingScaleOptions;
 }
 export declare const FloatingToolsElement: FC<FloatingToolsElementProps>;

package/dist/src/components/elements/floating-tools/floating-tools.element.stories.d.ts

@@ -0,0 +1,6 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { FloatingToolsElement } from './floating-tools.element';
+declare const meta: Meta<typeof FloatingToolsElement>;
+export default meta;
+type Story = StoryObj<typeof FloatingToolsElement>;
+export declare const RealScale: Story;

package/dist/src/components/elements/floating-tools/index.d.ts

@@ -1 +1,2 @@
 export * from './floating-tools.element';
+export type { FloatingScaleOptions } from './floating-scale.interface';

package/dist/src/components/elements/floating-tools/use-floating-scale.hook.d.ts

@@ -0,0 +1,2 @@
+import { FloatingScaleOptions, UseFloatingScaleResult } from './floating-scale.interface';
+export declare const useFloatingScale: (options: FloatingScaleOptions, enabled?: boolean) => UseFloatingScaleResult;

package/dist/src/components/elements/text-field/text-field-weight-number.element.d.ts

@@ -1,9 +1,13 @@
 import { default as React } from 'react';
+import { WebSerialScaleReading, WebSerialScaleWeighingAudit } from '../../web-serial-scale';
 import { TextFieldNumberElementProps } from './text-field-number/text-field-number.element';
 export interface TextFieldWeightNumberElementProps extends TextFieldNumberElementProps {
     enabled?: boolean;
     showWeightAdornment?: boolean;
     weightAdornmentLabel?: React.ReactNode;
     onEnterConfirm?: (weight: number) => void | Promise<void>;
+    onWeighingApply?: (reading: WebSerialScaleReading) => void | Promise<void>;
+    weighingAudit?: WebSerialScaleWeighingAudit;
+    getWeighingAuditTooltip?: (audit: WebSerialScaleWeighingAudit) => React.ReactNode;
 }
 export declare const TextFieldWeightNumberElement: React.FC<TextFieldWeightNumberElementProps>;

package/dist/src/components/elements/text-field/text-field-weight-number.element.stories.d.ts

@@ -4,7 +4,7 @@ declare const meta: Meta<typeof TextFieldWeightNumberElement>;
 export default meta;
 type Story = StoryObj<typeof TextFieldWeightNumberElement>;
 export declare const Default: Story;
-export declare const WithSharedScaleProvider: Story;
+export declare const WithFloatingTools: Story;
 export declare const ScaleDisabled: Story;
 export declare const Disabled: Story;
 export declare const ErrorState: Story;

package/dist/src/components/web-serial-scale/web-serial-scale.enum.d.ts

@@ -5,6 +5,11 @@ export declare enum WebSerialScaleStatus {
     Disconnecting = "disconnecting",
     Error = "error"
 }
+export declare enum WebSerialScaleMode {
+    Single = "SINGLE",
+    Accumulated = "ACCUMULATED"
+}
+export declare const WebSerialScaleModeTitle: Record<WebSerialScaleMode, string>;
 export declare enum ParityWebSerialScaleSerial {
     None = "none",
     Even = "even",

package/dist/src/components/web-serial-scale/web-serial-scale.interface.d.ts

@@ -1,4 +1,4 @@
-import { ParityWebSerialScaleSerial, FlowControlWebSerialScaleEvent, WebSerialScaleStatus } from './web-serial-scale.enum';
+import { ParityWebSerialScaleSerial, FlowControlWebSerialScaleEvent, WebSerialScaleStatus, WebSerialScaleMode } from './web-serial-scale.enum';
 import { ReactNode } from 'react';
 export interface WebSerialScaleReading {
     rawLine?: string;
@@ -6,6 +6,24 @@ export interface WebSerialScaleReading {
     numericValue?: number;
     unit?: string;
     receivedAt?: number;
+    weighingAudit?: WebSerialScaleWeighingAudit;
+    overload?: boolean;
+}
+export interface WebSerialScaleWeighingDrop {
+    step: number;
+    weight: number;
+    timestamp: string;
+    raw_line?: string;
+}
+export interface WebSerialScaleWeighingAudit {
+    mode: WebSerialScaleMode;
+    scale_device_id?: string;
+    operator_id?: string;
+    target_field: string;
+    unit: string;
+    total_weight: number;
+    drops_count: number;
+    drops: WebSerialScaleWeighingDrop[];
 }
 export interface WebSerialScaleSerialOptions {
     baudRate: number;
@@ -33,10 +51,12 @@ export interface WebSerialScaleConnectOptions {
 }
 export interface WebSerialScaleTarget {
     name: string;
+    fieldName?: string;
     label?: string;
     description?: string;
     disabled?: boolean;
     onApply?: (reading: WebSerialScaleReading) => void | Promise<void>;
+    onConfirm?: (reading: WebSerialScaleReading) => void | Promise<void>;
 }
 export interface UseWebSerialScaleOptions {
     serialOptions: WebSerialScaleSerialOptions;
@@ -72,6 +92,10 @@ export interface WebSerialScaleTargetRegistration {
 }
 export interface WebSerialScaleSharedContextValue extends UseWebSerialScaleResult {
     registerTargets: (registration: WebSerialScaleTargetRegistration) => () => void;
+    activeTarget?: Omit<WebSerialScaleTarget, 'onApply' | 'onConfirm'>;
+    isManualApply: boolean;
+    registerManualController: () => () => void;
+    applyToActiveTarget: (reading: WebSerialScaleReading) => Promise<boolean>;
 }
 export interface WebSerialScaleProviderElementProps extends Omit<UseWebSerialScaleOptions, 'serialOptions' | 'onReading'> {
     children: ReactNode;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sevago-library",
-  "version": "1.7.7",
+  "version": "1.7.8",
   "description": "Sevago SSO Frontend Library - A comprehensive SSO solution with React components",
   "main": "dist/index.cjs.js",
   "module": "dist/index.esm.js",

package/dist/src/components/web-serial-scale/web-serial-scale.argtypes.d.ts

@@ -1,3 +0,0 @@
-import { ArgTypes } from '@storybook/react';
-import { WebSerialScaleControllerElementProps } from './web-serial-scale-controller.element';
-export declare const webSerialScaleArgTypes: Partial<ArgTypes<WebSerialScaleControllerElementProps>>;

package/dist/src/components/web-serial-scale/web-serial-scale.stories.d.ts

@@ -1,9 +0,0 @@
-import { Meta, StoryObj } from '@storybook/react';
-import { WebSerialScaleControllerElement } from './web-serial-scale-controller.element';
-declare const meta: Meta<typeof WebSerialScaleControllerElement>;
-export default meta;
-type Story = StoryObj<typeof WebSerialScaleControllerElement>;
-export declare const Default: Story;
-export declare const FieldFocusFlow: Story;
-export declare const WithUsbRequestFilter: Story;
-export declare const SharedScaleProviderFlow: Story;