@servicetitan/anvil2 1.44.2 → 1.45.1

package/dist/internal/hooks/useNumberField/useNumberField.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Configuration options for the useNumberField hook
+ */
+export type UseNumberFieldConfig = {
+    /**
+     * The label for the number field.
+     * Important for accessibility and button labeling.
+     */
+    label?: string;
+    /**
+     * The minimum value for the number field.
+     * @default 0
+     */
+    minValue?: number;
+    /**
+     * The maximum value for the number field.
+     * @default 100000000000000
+     */
+    maxValue?: number;
+    /**
+     * The step value for the number field.
+     * @default 1
+     */
+    step?: number;
+    /**
+     * The controlled value for the number field.
+     */
+    value?: number | null;
+    /**
+     * The default (uncontrolled) value for the number field.
+     */
+    defaultValue?: number | null;
+    /**
+     * The maximum number of decimal places for the number field.
+     * @default 0
+     */
+    maximumFractionDigits?: number;
+    /**
+     * The minimum number of decimal places for the number field.
+     * @default 0
+     */
+    minimumFractionDigits?: number;
+    /**
+     * A callback that is called when the value changes.
+     * @param value The new numeric value or null if invalid/empty
+     */
+    onChange?: (value: number | null) => void;
+};
+/**
+ * Return value from the useNumberField hook
+ */
+export type UseNumberFieldReturnValue = {
+    /** The current numeric value of the number field. */
+    value: number | null;
+    /** A ref that should be attached to the input element. */
+    inputRef: React.RefObject<HTMLInputElement>;
+    /** The props to pass to the input element. */
+    inputProps: React.InputHTMLAttributes<HTMLInputElement>;
+    /** The props to pass to the increment button. */
+    incrementButtonProps: React.ButtonHTMLAttributes<HTMLButtonElement>;
+    /** The props to pass to the decrement button. */
+    decrementButtonProps: React.ButtonHTMLAttributes<HTMLButtonElement>;
+};
+/**
+ * Custom hook that provides the functionality for number input fields with increment and decrement controls.
+ *
+ * This hook handles:
+ * - Precise decimal arithmetic using Big.js
+ * - Number formatting with thousand separators and decimal precision
+ * - Input validation and value clamping
+ * - Keyboard navigation (arrows, PageUp/Down, Home/End)
+ * - Platform-specific input modes for mobile devices
+ * - Accessibility attributes and button states
+ * - Controlled and uncontrolled value management
+ *
+ * @param config - Configuration options for the number field
+ * @returns Object containing the current value, input ref, and props for input and buttons
+ *
+ * @example
+ * const { value, inputRef, inputProps, incrementButtonProps, decrementButtonProps } = useNumberField({
+ *   label: "Quantity",
+ *   minValue: 0,
+ *   maxValue: 100,
+ *   step: 1,
+ *   onChange: (value) => console.log(value)
+ * });
+ */
+export declare const useNumberField: (config: UseNumberFieldConfig) => {
+    value: number | null;
+    inputRef: import('react').RefCallback<HTMLElement> | null;
+    inputProps: {
+        value: string;
+        onChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+        inputMode: import('./internal/useNumberFieldInputMode').InputMode;
+        "aria-valuenow": number | undefined;
+        "aria-valuemin": number;
+        "aria-valuemax": number;
+        min: number;
+        max: number;
+        step: number;
+        role: string;
+        pattern: string;
+        type: string;
+        autoComplete: string;
+    };
+    incrementButtonProps: {
+        onClick: () => void;
+        disabled: boolean | undefined;
+        tabIndex: number;
+        "aria-label": string;
+    };
+    decrementButtonProps: {
+        onClick: () => void;
+        disabled: boolean | undefined;
+        tabIndex: number;
+        "aria-label": string;
+    };
+};

package/dist/internal/hooks/useOnClickOutside/index.d.ts

@@ -0,0 +1 @@
+export { useOnClickOutside } from './useOnClickOutside';

package/dist/internal/hooks/useOnClickOutside/useOnClickOutside.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Props for the useOnClickOutside hook
+ */
+type UseOnClickOutsideProps = {
+    /**
+     * Callback when clicking outside targets
+     */
+    onOutsidePress?: (e: globalThis.MouseEvent) => void;
+    /**
+     * Callback when closing (after outside press)
+     */
+    onClose?: () => void;
+    /**
+     * Array of target elements to monitor
+     */
+    targets: (HTMLElement | undefined)[];
+};
+/**
+ * Custom hook for detecting clicks outside of specified target elements.
+ *
+ * Features:
+ * - Detects clicks outside of multiple target elements
+ * - Supports both mousedown and mouseup event handling
+ * - Provides separate callbacks for outside press and close actions
+ * - Handles SSR environments gracefully
+ * - Automatically cleans up event listeners
+ * - Uses composedPath for accurate event target detection
+ * - Supports optional callbacks for flexible usage
+ *
+ * @param props - Configuration object containing targets and optional callbacks
+ * @returns void
+ */
+export declare const useOnClickOutside: ({ onOutsidePress, targets, onClose, }: UseOnClickOutsideProps) => void;
+export {};

package/dist/internal/hooks/useOpenCloseTransitionStates/index.d.ts

@@ -0,0 +1 @@
+export * from './useOpenCloseTransitionStates';

package/dist/internal/hooks/useOpenCloseTransitionStates/useOpenCloseTransitionStates.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Possible states for open/close transitions
+ */
+export type OpenCloseTransitionStates = "opening" | "open" | "closing" | "closed";
+/**
+ * Effects configuration for open/close transition states
+ * @property {() => void} [onOpenAnimationStart] - Callback when opening animation starts
+ * @property {() => void} [onCloseAnimationStart] - Callback when closing animation starts
+ * @property {() => void} [onOpenAnimationComplete] - Callback when opening animation completes
+ * @property {() => void} [onCloseAnimationComplete] - Callback when closing animation completes
+ * @property {number | (() => number)} [durationMs] - Duration of the animation in milliseconds (or a function that returns the duration)
+ */
+export type OpenCloseTransitionStateEffects = {
+    /**
+     * Callback when opening animation starts
+     */
+    onOpenAnimationStart?: () => void;
+    /**
+     * Callback when closing animation starts
+     */
+    onCloseAnimationStart?: () => void;
+    /**
+     * Callback when opening animation completes
+     */
+    onOpenAnimationComplete?: () => void;
+    /**
+     * Callback when closing animation completes
+     */
+    onCloseAnimationComplete?: () => void;
+};
+export type OpenCloseTransitionState = {
+    state: OpenCloseTransitionStates;
+    beginClosing: () => void;
+    isOpenOrOpening: boolean;
+    isClosedOrClosing: boolean;
+};
+export type OpenCloseTransitionStateOptions = {
+    durationMs: number | (() => number);
+    onOpenAnimationStart?: () => void;
+    onCloseAnimationStart?: () => void;
+    onOpenAnimationComplete?: () => void;
+    onCloseAnimationComplete?: () => void;
+};
+/**
+ * Custom hook for managing open/close transition states and animations.
+ *
+ * @param openProp - The open prop controlling visibility
+ * @param options - Additional, optional options including callbacks for animation start, complete, and initialization
+ * @returns Object containing state, control functions, and utility flags
+ */
+export declare const useOpenCloseTransitionStates: (openProp: boolean | undefined, options?: OpenCloseTransitionStateOptions) => OpenCloseTransitionState;

package/dist/internal/hooks/useOptionallyControlledState/index.d.ts

@@ -0,0 +1 @@
+export { useOptionallyControlledState } from './useOptionallyControlledState';

package/dist/internal/hooks/useOptionallyControlledState/useOptionallyControlledState.d.ts

@@ -0,0 +1,59 @@
+import { SetStateAction, Dispatch } from 'react';
+/**
+ * Props for the useOptionallyControlledState hook
+ */
+type UseOptionallyControlledStateProps<T> = {
+    /**
+     * The controlled value of the state.
+     * When provided, the component becomes controlled.
+     */
+    controlledValue?: T;
+    /**
+     * The default value of the state.
+     * Used when the component is uncontrolled.
+     */
+    defaultValue?: T;
+    /**
+     * A function that is called when the value changes.
+     * @param value The new value
+     */
+    onChange?: (value: T) => void;
+};
+/**
+ * Custom hook for managing optionally controlled state.
+ *
+ * Features:
+ * - Supports both controlled and uncontrolled state management
+ * - Automatically switches between controlled and uncontrolled modes
+ * - Provides consistent API regardless of control mode
+ * - Handles onChange callbacks for both modes
+ * - Uses useCallback for optimized setter function
+ * - Supports generic types for flexible state values
+ *
+ * @param props - Configuration object containing controlled value, default value, and onChange callback
+ * @returns Tuple containing current value and setter function
+ */
+/**
+ * Custom hook that manages state that can be either controlled or uncontrolled.
+ *
+ * This hook provides a unified interface for managing component state that can be
+ * controlled externally or managed internally. It automatically detects whether
+ * the component should be controlled based on the presence of a controlledValue.
+ *
+ * @param controlledValue - The controlled value (makes component controlled when provided)
+ * @param defaultValue - The default value for uncontrolled mode
+ * @param onChange - Callback function called when the value changes
+ * @returns Tuple containing the current value and a setter function
+ *
+ * @example
+ * const [value, setValue] = useOptionallyControlledState({
+ *   controlledValue: props.value,
+ *   defaultValue: 0,
+ *   onChange: props.onChange
+ * });
+ */
+export declare function useOptionallyControlledState<T>({ controlledValue, defaultValue, onChange, }: UseOptionallyControlledStateProps<T>): [
+    T,
+    Dispatch<SetStateAction<T | undefined>>
+];
+export {};

package/dist/internal/hooks/usePlatform/index.d.ts

@@ -0,0 +1 @@
+export { usePlatform } from './usePlatform';

package/dist/internal/hooks/usePlatform/usePlatform.d.ts

@@ -0,0 +1,65 @@
+export interface UsePlatformReturnValue {
+    /** True if the user is on an iPhone */
+    isIPhone: boolean;
+    /** True if the user is on an iPad */
+    isIPad: boolean;
+    /** True if the user is on any iOS device (iPhone or iPad) */
+    isIOS: boolean;
+    /** True if the user is on a Mac computer */
+    isMac: boolean;
+    /** True if the user is on any Apple device (iPhone, iPad, or Mac) */
+    isAppleDevice: boolean;
+    /** True if the browser is WebKit-based (Safari, Chrome, etc.) */
+    isWebKit: boolean;
+    /** True if the browser is Chrome */
+    isChrome: boolean;
+    /** True if the browser is Firefox */
+    isFirefox: boolean;
+    /** True if the user is on an Android device */
+    isAndroid: boolean;
+}
+/**
+ * Custom hook for detecting the user's platform and browser.
+ *
+ * This hook provides platform and browser detection capabilities for implementing
+ * platform-specific behavior in components. It detects:
+ * - iOS devices (iPhone, iPad)
+ * - macOS computers
+ * - Android devices
+ * - WebKit-based browsers (Safari, Chrome)
+ * - Specific browsers (Chrome, Firefox)
+ *
+ * @internal This hook is not exported because it hasn't been rigorously tested.
+ *
+ * @returns Object containing boolean flags for different platforms and browsers
+ *
+ * @example
+ * const {
+ *   isIPhone,
+ *   isIPad,
+ *   isIOS,
+ *   isMac,
+ *   isAppleDevice,
+ *   isWebKit,
+ *   isChrome,
+ *   isFirefox,
+ *   isAndroid
+ * } = usePlatform();
+ *
+ * if (isIOS) {
+ *   // Handle iOS-specific logic
+ * }
+ */
+export declare function usePlatform(): UsePlatformReturnValue;
+/**
+ * Detects the current platform and browser based on user agent and platform information.
+ *
+ * This function analyzes the navigator.userAgent and navigator.platform to determine
+ * the user's device type and browser. It handles edge cases like:
+ * - MSStream detection for Windows Phone
+ * - iPad detection using maxTouchPoints
+ * - WebKit vs Chrome differentiation
+ *
+ * @returns Object containing boolean flags for different platforms and browsers
+ */
+export declare function detectPlatform(): UsePlatformReturnValue;

package/dist/internal/hooks/usePopoverCloseDelayWorkaround/index.d.ts

@@ -0,0 +1 @@
+export * from './usePopoverCloseDelayWorkaround';

package/dist/internal/hooks/usePopoverCloseDelayWorkaround/usePopoverCloseDelayWorkaround.d.ts

@@ -0,0 +1 @@
+export declare const usePopoverCloseDelayWorkaround: (popoverOpen: boolean, delay?: number) => boolean;

package/dist/internal/hooks/usePopoverSupport/index.d.ts

@@ -0,0 +1 @@
+export * from './usePopoverSupport';

package/dist/internal/hooks/usePopoverSupport/usePopoverSupport.d.ts

@@ -0,0 +1 @@
+export declare function usePopoverSupport(): boolean | undefined;

package/dist/internal/hooks/usePopoverTransitionStates/index.d.ts

@@ -0,0 +1 @@
+export * from './usePopoverTransitionStates';

package/dist/internal/hooks/usePopoverTransitionStates/usePopoverTransitionStates.d.ts

@@ -0,0 +1,25 @@
+import { OpenCloseTransitionStateEffects } from '../useOpenCloseTransitionStates';
+/**
+ * Effects configuration for dialog transition states
+ * @property {() => void} [onOpenAnimationStart] - Callback when opening animation starts
+ * @property {() => void} [onCloseAnimationStart] - Callback when closing animation starts
+ * @property {() => void} [onOpenAnimationComplete] - Callback when opening animation completes
+ * @property {() => void} [onCloseAnimationComplete] - Callback when closing animation completes
+ */
+/**
+ * Custom hook for managing popover transition states and animations.
+ *
+ * Features:
+ * - Manages popover open/close transition states
+ * - Handles animation timing based on CSS animation duration
+ * - Provides callbacks for animation lifecycle events
+ * - Supports controlled popover state management
+ * - Automatically handles showPopover() and closePopover() calls
+ * - Provides utility flags for open/closed states
+ *
+ * @param popover - The popover element
+ * @param openProp - The open prop controlling popover visibility
+ * @param options - Additional, optional options including callbacks for animation start, complete, and initialization
+ * @returns Object containing popover state, control functions, and utility flags
+ */
+export declare const usePopoverTransitionStates: (popover: HTMLElement | undefined, openProp: boolean | undefined, options?: OpenCloseTransitionStateEffects) => import('..').OpenCloseTransitionState;

package/dist/internal/hooks/usePrevious/index.d.ts

@@ -0,0 +1 @@
+export * from './usePrevious';

package/dist/internal/hooks/usePrevious/usePrevious.d.ts

@@ -0,0 +1 @@
+export declare function usePrevious<T>(value: T, initialValue?: T): T | undefined;

package/dist/internal/hooks/useTypeAhead/index.d.ts

@@ -0,0 +1 @@
+export { useTypeAhead } from './useTypeAhead';

package/dist/internal/hooks/useTypeAhead/useTypeAhead.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Custom hook for implementing type-ahead functionality.
+ *
+ * Features:
+ * - Accumulates typed characters with automatic timeout clearing
+ * - Provides type-ahead string for keyboard navigation
+ * - Automatically resets after specified timeout period
+ * - Supports customizable timeout duration
+ * - Uses useEffect for automatic cleanup
+ * - Optimized for keyboard navigation in lists and menus
+ *
+ * @param timeout - Timeout duration in milliseconds before clearing the type-ahead string
+ * @returns Tuple containing current type-ahead string and function to update it
+ */
+export declare const useTypeAhead: (timeout?: number) => [string, (char: string) => void];

package/dist/internal/types/index.d.ts

@@ -0,0 +1 @@
+export * from './props.ts';

package/dist/internal/types/props.d.ts

@@ -0,0 +1,7 @@
+import { LabelProps } from '../components';
+export type FieldLabelProps = Pick<LabelProps, "moreInfo" | "required"> & {
+    /**
+     * Props passed to the internal label component.
+     */
+    labelProps?: Omit<LabelProps, "children" | "moreInfo" | "required" | "id" | "htmlFor">;
+};

package/dist/internal/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './generateChromaticStickersheetProps';

package/dist/makeZeroShortcutPreprocessor-CxsiGTRW.js

@@ -0,0 +1,47 @@
+const makeZeroShortcutPreprocessor = (templateString, separator) => {
+  const zeroShortcutPreprocessor = ({ elementState, data }, actionType) => {
+    if (actionType === "insert" && // the user is inserting a character
+    data === separator && // the user typed the separator character
+    elementState.selection[0] === elementState.selection[1]) {
+      const selectionIndex = elementState.selection[0];
+      const separatorPositions = templateString.split("").map((char, index) => char === separator ? index : null).filter((position) => position !== null).filter((position) => position > selectionIndex);
+      const noRemainingSegments = !separatorPositions.length;
+      const nothingEnteredYet = !elementState.value.length;
+      const previousCharacterIsNotADigit = !/^\d$/.test(
+        elementState.value.slice(-1)
+      );
+      const currentCharacterIsSeparator = templateString[selectionIndex] === separator;
+      if (noRemainingSegments || nothingEnteredYet || previousCharacterIsNotADigit || currentCharacterIsSeparator) {
+        return { elementState, data };
+      }
+      const firstIndexOfSegment = Math.max(
+        elementState.value.lastIndexOf(separator) + 1,
+        elementState.value.lastIndexOf(" ") + 1,
+        0
+      );
+      const lastIndexOfSegment = separatorPositions[0];
+      const digitsCurrentlyInSegment = elementState.value.slice(firstIndexOfSegment);
+      const targetNumberOfDigitsInSegment = templateString.slice(
+        firstIndexOfSegment,
+        lastIndexOfSegment
+      ).length;
+      const newSegment = digitsCurrentlyInSegment.padStart(
+        targetNumberOfDigitsInSegment,
+        "0"
+      );
+      const newValue = `${elementState.value.slice(0, firstIndexOfSegment)}${newSegment}`;
+      return {
+        elementState: {
+          value: newValue + data,
+          selection: [newValue.length, newValue.length]
+        },
+        data
+      };
+    }
+    return { elementState, data };
+  };
+  return zeroShortcutPreprocessor;
+};
+
+export { makeZeroShortcutPreprocessor as m };
+//# sourceMappingURL=makeZeroShortcutPreprocessor-CxsiGTRW.js.map

package/dist/makeZeroShortcutPreprocessor-CxsiGTRW.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeZeroShortcutPreprocessor-CxsiGTRW.js","sources":["../src/components/DateFieldSingle/internal/maskito/makeZeroShortcutPreprocessor.ts"],"sourcesContent":["import { MaskitoPreprocessor } from \"@maskito/core\";\nimport { SelectionRange } from \"@maskito/core/src/lib/types\";\n\n/**\n * This is a custom-written preprocessor to handle the zero shortcut on slash.\n * e.g: 1/ -> 01/ and 01/1/ -> 01/01/\n *\n * @param templateString - A string representing the mask. e.g. \"dd/mm/yyyy\" or \"__/__/____\"\n * @param separator - The separator to use for segments of the date. Must match the separator in the template string.\n * @returns A MaskitoPreprocessor function.\n */\nexport const makeZeroShortcutPreprocessor: (\n  templateString: string,\n  separator: string,\n) => MaskitoPreprocessor = (templateString, separator) => {\n  const zeroShortcutPreprocessor: MaskitoPreprocessor = (\n    { elementState, data },\n    actionType,\n  ) => {\n    // Only process when user is inserting a separator character\n    if (\n      actionType === \"insert\" && // the user is inserting a character\n      data === separator && // the user typed the separator character\n      elementState.selection[0] === elementState.selection[1] // only entering a single character\n    ) {\n      const selectionIndex = elementState.selection[0];\n\n      // Find all separator positions in the template AFTER the current cursor position\n      // This helps us determine the boundaries of the current segment\n      const separatorPositions: number[] = templateString\n        .split(\"\")\n        .map((char, index) => (char === separator ? index : null))\n        .filter((position) => position !== null)\n        .filter((position) => position > selectionIndex);\n\n      // Early exit conditions - don't apply zero padding in these cases\n      const noRemainingSegments = !separatorPositions.length;\n      const nothingEnteredYet = !elementState.value.length;\n      const previousCharacterIsNotADigit = !/^\\d$/.test(\n        elementState.value.slice(-1),\n      );\n      const currentCharacterIsSeparator =\n        templateString[selectionIndex] === separator;\n\n      if (\n        noRemainingSegments ||\n        nothingEnteredYet ||\n        previousCharacterIsNotADigit ||\n        currentCharacterIsSeparator\n      ) {\n        return { elementState, data };\n      }\n\n      // Find the start of the current segment by looking for the last separator or space (for date ranges)\n      // This determines where the current number segment begins\n      const firstIndexOfSegment = Math.max(\n        elementState.value.lastIndexOf(separator) + 1,\n        elementState.value.lastIndexOf(\" \") + 1,\n        0,\n      );\n\n      // Find the end of the current segment (next separator position)\n      const lastIndexOfSegment = separatorPositions[0];\n\n      // Extract the digits currently entered in this segment\n      const digitsCurrentlyInSegment =\n        elementState.value.slice(firstIndexOfSegment);\n\n      // Calculate how many digits this segment should have based on the template\n      // e.g., if template is \"dd/mm/yyyy\", the first segment should have 2 digits\n      const targetNumberOfDigitsInSegment = templateString.slice(\n        firstIndexOfSegment,\n        lastIndexOfSegment,\n      ).length;\n\n      // Pad the current segment with leading zeros to reach the target length\n      // e.g., \"1\" becomes \"01\" for a 2-digit segment\n      const newSegment = digitsCurrentlyInSegment.padStart(\n        targetNumberOfDigitsInSegment,\n        \"0\",\n      );\n\n      // Construct the new value by replacing the current segment with the padded version\n      const newValue = `${elementState.value.slice(0, firstIndexOfSegment)}${newSegment}`;\n\n      // Return the updated state with the padded segment and separator\n      // Position cursor after the separator\n      return {\n        elementState: {\n          value: newValue + data,\n          selection: [newValue.length, newValue.length] as SelectionRange,\n        },\n        data,\n      };\n    }\n    // If conditions aren't met, return unchanged state\n    return { elementState, data };\n  };\n  return zeroShortcutPreprocessor;\n};\n"],"names":[],"mappings":"AAWa,MAAA,4BAAA,GAGc,CAAC,cAAA,EAAgB,SAAc,KAAA;AACxD,EAAA,MAAM,2BAAgD,CACpD,EAAE,YAAc,EAAA,IAAA,IAChB,UACG,KAAA;AAEH,IAAA,IACE,UAAe,KAAA,QAAA;AAAA,IACf,IAAS,KAAA,SAAA;AAAA,IACT,aAAa,SAAU,CAAA,CAAC,MAAM,YAAa,CAAA,SAAA,CAAU,CAAC,CACtD,EAAA;AACA,MAAM,MAAA,cAAA,GAAiB,YAAa,CAAA,SAAA,CAAU,CAAC,CAAA;AAI/C,MAAM,MAAA,kBAAA,GAA+B,cAClC,CAAA,KAAA,CAAM,EAAE,CAAA,CACR,IAAI,CAAC,IAAA,EAAM,KAAW,KAAA,IAAA,KAAS,SAAY,GAAA,KAAA,GAAQ,IAAK,CACxD,CAAA,MAAA,CAAO,CAAC,QAAA,KAAa,QAAa,KAAA,IAAI,EACtC,MAAO,CAAA,CAAC,QAAa,KAAA,QAAA,GAAW,cAAc,CAAA;AAGjD,MAAM,MAAA,mBAAA,GAAsB,CAAC,kBAAmB,CAAA,MAAA;AAChD,MAAM,MAAA,iBAAA,GAAoB,CAAC,YAAA,CAAa,KAAM,CAAA,MAAA;AAC9C,MAAM,MAAA,4BAAA,GAA+B,CAAC,MAAO,CAAA,IAAA;AAAA,QAC3C,YAAA,CAAa,KAAM,CAAA,KAAA,CAAM,EAAE;AAAA,OAC7B;AACA,MAAM,MAAA,2BAAA,GACJ,cAAe,CAAA,cAAc,CAAM,KAAA,SAAA;AAErC,MACE,IAAA,mBAAA,IACA,iBACA,IAAA,4BAAA,IACA,2BACA,EAAA;AACA,QAAO,OAAA,EAAE,cAAc,IAAK,EAAA;AAAA;AAK9B,MAAA,MAAM,sBAAsB,IAAK,CAAA,GAAA;AAAA,QAC/B,YAAa,CAAA,KAAA,CAAM,WAAY,CAAA,SAAS,CAAI,GAAA,CAAA;AAAA,QAC5C,YAAa,CAAA,KAAA,CAAM,WAAY,CAAA,GAAG,CAAI,GAAA,CAAA;AAAA,QACtC;AAAA,OACF;AAGA,MAAM,MAAA,kBAAA,GAAqB,mBAAmB,CAAC,CAAA;AAG/C,MAAA,MAAM,wBACJ,GAAA,YAAA,CAAa,KAAM,CAAA,KAAA,CAAM,mBAAmB,CAAA;AAI9C,MAAA,MAAM,gCAAgC,cAAe,CAAA,KAAA;AAAA,QACnD,mBAAA;AAAA,QACA;AAAA,OACA,CAAA,MAAA;AAIF,MAAA,MAAM,aAAa,wBAAyB,CAAA,QAAA;AAAA,QAC1C,6BAAA;AAAA,QACA;AAAA,OACF;AAGA,MAAM,MAAA,QAAA,GAAW,GAAG,YAAa,CAAA,KAAA,CAAM,MAAM,CAAG,EAAA,mBAAmB,CAAC,CAAA,EAAG,UAAU,CAAA,CAAA;AAIjF,MAAO,OAAA;AAAA,QACL,YAAc,EAAA;AAAA,UACZ,OAAO,QAAW,GAAA,IAAA;AAAA,UAClB,SAAW,EAAA,CAAC,QAAS,CAAA,MAAA,EAAQ,SAAS,MAAM;AAAA,SAC9C;AAAA,QACA;AAAA,OACF;AAAA;AAGF,IAAO,OAAA,EAAE,cAAc,IAAK,EAAA;AAAA,GAC9B;AACA,EAAO,OAAA,wBAAA;AACT;;;;"}

package/dist/providers/AnvilProvider/AnvilProvider.d.ts

@@ -1,10 +1,33 @@
-import { HammerProviderProps, HammerProviderContextProps } from '@servicetitan/hammer-react';
-export interface AnvilProviderProps extends HammerProviderProps {
+import { ThemeProviderProps } from '../ThemeProvider';
+import { ComponentPropsWithoutRef, Dispatch, ReactNode, SetStateAction } from 'react';
+import { LayoutUtilProps } from '../../types';
+import { ITranslations } from '../LocalizationProvider/LocalizationProvider';
+import { BreakpointReturnProps } from '../../hooks/useBreakpoint';
+export type AnvilProviderProps = ComponentPropsWithoutRef<"div"> & LayoutUtilProps & {
+    children?: ReactNode;
+    themeData?: {
+        theme?: ThemeProviderProps["theme"];
+        mode?: ThemeProviderProps["mode"];
+    };
+    localizationData?: {
+        locale?: ITranslations["locale"];
+        dir?: ITranslations["dir"];
+        translations?: ITranslations["translations"];
+    };
+} & {
     trackingIdData?: {
         scope?: string;
         optOut?: boolean;
     };
-}
-export { HammerProviderContextProps as AnvilProviderContextProps };
-export declare const AnvilProviderContext: import('react').Context<HammerProviderContextProps>;
-export declare const AnvilProvider: ({ children, trackingIdData, ...props }: AnvilProviderProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type AnvilProviderContextProps = {
+    breakpoint?: BreakpointReturnProps;
+};
+export declare const AnvilProviderContext: import('react').Context<AnvilProviderContextProps>;
+export declare const TooltipLegacyGroupContext: import('react').Context<{
+    disableDelayGroup: Dispatch<SetStateAction<boolean>>;
+} | null>;
+export declare const useTooltipLegacyGroup: () => {
+    disableDelayGroup: Dispatch<SetStateAction<boolean>>;
+};
+export declare const AnvilProvider: (props: AnvilProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/providers/LocalizationProvider/LocalizationContext.d.ts

@@ -0,0 +1,6 @@
+export type TranslationContext = {
+    locale: string;
+    t(value: string): string;
+};
+export declare const LocalizationContext: import('react').Context<TranslationContext>;
+export declare const useLocalizationContext: () => TranslationContext;

package/dist/providers/LocalizationProvider/LocalizationProvider.d.ts

@@ -0,0 +1,17 @@
+import { default as React, ReactNode, ComponentPropsWithoutRef } from 'react';
+import { LayoutUtilProps } from '../../types';
+type LocalizationProviderProps = ComponentPropsWithoutRef<"div"> & LayoutUtilProps & {
+    children: ReactNode;
+    translationData: ITranslations;
+};
+export type TranslationResult = string | Translations | undefined;
+export interface Translations {
+    [key: string]: TranslationResult;
+}
+export interface ITranslations {
+    dir: "ltr" | "rtl";
+    locale?: string;
+    translations: Translations;
+}
+export declare const LocalizationProvider: React.FC<LocalizationProviderProps>;
+export {};

package/dist/providers/LocalizationProvider/LocalizationStoryWrapper.d.ts

@@ -0,0 +1,6 @@
+import { FC, ReactNode } from 'react';
+interface WrapperProps {
+    children: ReactNode;
+}
+export declare const Wrapper: FC<WrapperProps>;
+export {};

package/dist/providers/LocalizationProvider/index.d.ts

@@ -1 +1,2 @@
-export { LocalizationProvider, LocalizationProvider as default, type ITranslations, LocalizationContext, useLocalizationContext, type TranslationContext, } from '@servicetitan/hammer-react';
+export { LocalizationProvider, type ITranslations, } from './LocalizationProvider';
+export { LocalizationContext, useLocalizationContext, type TranslationContext, } from './LocalizationContext';

package/dist/providers/LocalizationProvider/useTranslations.d.ts

@@ -0,0 +1,4 @@
+import { ITranslations } from './LocalizationProvider';
+export declare const useTranslations: (translations: ITranslations["translations"]) => {
+    translations: (key: string) => string;
+};

package/dist/providers/PortalProvider/PortalProvider.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+export type PortalProviderContextProps = {
+    root?: HTMLElement | React.MutableRefObject<HTMLElement | null> | null;
+};
+export declare const PortalProviderContext: import('react').Context<PortalProviderContextProps>;
+export type PortalProviderProps = {
+    root?: HTMLElement | React.MutableRefObject<HTMLElement | null> | null;
+    children?: ReactNode;
+};
+export declare const PortalProvider: (props: PortalProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/providers/PortalProvider/index.d.ts

@@ -1 +1 @@
-export { PortalProvider, PortalProvider as default, type ProtalProviderProps as PortalProviderProps, PortalProviderContext, type PortalProviderContextProps, } from '@servicetitan/hammer-react';
+export { type PortalProviderContextProps, PortalProviderContext, type PortalProviderProps, PortalProvider, } from './PortalProvider';

package/dist/providers/ThemeProvider/ThemeProvider.d.ts

@@ -1,4 +1,14 @@
-import { ThemeProviderProps as HammerThemeProviderProps, ThemeProviderContextProps as HammerThemeProviderContextProps } from '@servicetitan/hammer-react';
-export type ThemeProviderProps = Omit<HammerThemeProviderProps, "prefix">;
-export type ThemeProviderContextProps = HammerThemeProviderContextProps;
-export declare const ThemeProvider: (props: ThemeProviderProps) => import("react/jsx-runtime").JSX.Element;
+import { ComponentPropsWithoutRef, FC, ReactNode } from 'react';
+import { LayoutUtilProps } from '../../types';
+import { Token } from '@servicetitan/hammer-token';
+export type CustomThemeType = {
+    primitive?: Partial<Token["primitive"]>;
+    semantic?: Partial<Token["semantic"]>;
+    component?: Partial<Token["component"]>;
+};
+export type ThemeProviderProps = Omit<ComponentPropsWithoutRef<"div">, "prefix"> & LayoutUtilProps & {
+    theme?: CustomThemeType;
+    mode?: "light" | "dark";
+    children?: ReactNode;
+};
+export declare const ThemeProvider: FC<ThemeProviderProps>;

package/dist/providers/ThemeProvider/index.d.ts

@@ -1 +1,7 @@
-export { ThemeProvider, ThemeProvider as default, type ThemeProviderProps, type ThemeProviderContextProps, } from './ThemeProvider';
+export { ThemeProvider, type ThemeProviderProps, type CustomThemeType, } from './ThemeProvider';
+export { 
+/**
+ * @deprecated internal context type
+ */
+type ThemeProviderContextProps, } from './internal/ThemeProviderContext';
+export { useTheme } from './useTheme';

package/dist/providers/ThemeProvider/internal/ThemeProviderContext.d.ts

@@ -0,0 +1,6 @@
+import { CustomThemeType } from '../ThemeProvider';
+export type ThemeProviderContextProps = {
+    theme?: CustomThemeType;
+    mode?: "light" | "dark";
+};
+export declare const ThemeProviderContext: import('react').Context<ThemeProviderContextProps>;

package/dist/providers/ThemeProvider/useTheme.d.ts

@@ -0,0 +1 @@
+export declare const useTheme: () => import('.').ThemeProviderContextProps;

package/dist/types/MaxLengthCounterProps.d.ts

@@ -0,0 +1,8 @@
+import { HelperProps } from '../internal/components/Helper';
+export type MaxLengthCounterProps = {
+    showCounter: true;
+    maxLength: HelperProps["maxLength"];
+} | {
+    showCounter?: false;
+    maxLength?: HelperProps["maxLength"];
+};