@jobber/components 6.85.2 → 6.86.0

package/dist/Autocomplete/tests/Autocomplete.setup.d.ts

@@ -0,0 +1,38 @@
+import React from "react";
+import { type AutocompleteRebuiltProps, type MenuItem, type OptionLike } from "../Autocomplete.types";
+export declare function Wrapper<T extends OptionLike>({ initialValue, initialInputValue, onChange, onInputChange, onBlur, onFocus, menu, openOnFocus, filterOptions, emptyActions, customRenderOption, customRenderAction, customRenderSection, customRenderInput, customRenderHeader, customRenderFooter, loading, customRenderLoading, emptyStateMessage, ref, readOnly, UNSAFE_className, UNSAFE_styles, debounce, }: {
+    readonly initialValue?: T;
+    readonly initialInputValue?: string;
+    readonly onChange?: (v: T | undefined) => void;
+    readonly onInputChange?: (v: string) => void;
+    readonly onBlur?: () => void;
+    readonly onFocus?: () => void;
+    readonly menu?: MenuItem<T>[];
+    readonly openOnFocus?: boolean;
+    readonly filterOptions?: false | ((opts: T[], input: string) => T[]);
+    readonly emptyActions?: AutocompleteRebuiltProps<T, false>["emptyActions"];
+    readonly customRenderOption?: AutocompleteRebuiltProps<T, false>["customRenderOption"];
+    readonly customRenderAction?: AutocompleteRebuiltProps<T, false>["customRenderAction"];
+    readonly customRenderInput?: AutocompleteRebuiltProps<T, false>["customRenderInput"];
+    readonly customRenderHeader?: AutocompleteRebuiltProps<T, false>["customRenderHeader"];
+    readonly customRenderFooter?: AutocompleteRebuiltProps<T, false>["customRenderFooter"];
+    readonly customRenderSection?: AutocompleteRebuiltProps<T, false>["customRenderSection"];
+    readonly loading?: boolean;
+    readonly customRenderLoading?: React.ReactNode;
+    readonly emptyStateMessage?: React.ReactNode;
+    readonly ref?: React.Ref<HTMLInputElement | HTMLTextAreaElement>;
+    readonly UNSAFE_className?: AutocompleteRebuiltProps<T, false>["UNSAFE_className"];
+    readonly UNSAFE_styles?: AutocompleteRebuiltProps<T, false>["UNSAFE_styles"];
+    readonly readOnly?: boolean;
+    readonly debounce?: number;
+}): React.JSX.Element;
+export declare function FreeFormWrapper({ initialValue, initialInputValue, onChange, onInputChange, menu, openOnFocus, inputEqualsOption, debounce, }: {
+    readonly initialValue?: OptionLike;
+    readonly initialInputValue?: string;
+    readonly onChange?: (v: OptionLike | undefined) => void;
+    readonly onInputChange?: (v: string) => void;
+    readonly menu?: MenuItem<OptionLike>[];
+    readonly openOnFocus?: boolean;
+    readonly inputEqualsOption?: (input: string, option: OptionLike) => boolean;
+    readonly debounce?: number;
+}): React.JSX.Element;

package/dist/Autocomplete/useAutocomplete.d.ts

@@ -0,0 +1,66 @@
+import type React from "react";
+import type { ActionConfig, ActionOrigin, AutocompleteRebuiltProps, MenuAction, MenuSection, OptionLike } from "./Autocomplete.types";
+export type RenderItem<T extends OptionLike, S extends object = Record<string, unknown>, A extends object = Record<string, unknown>> = {
+    kind: "option";
+    value: T;
+} | {
+    kind: "action";
+    action: MenuAction<A>;
+    origin?: ActionOrigin;
+} | {
+    kind: "section";
+    section: MenuSection<T, S, A>;
+};
+export declare function useAutocomplete<Value extends OptionLike, Multiple extends boolean = false, SectionExtra extends object = Record<string, unknown>, ActionExtra extends object = Record<string, unknown>>(props: AutocompleteRebuiltProps<Value, Multiple, SectionExtra, ActionExtra>): {
+    renderable: RenderItem<Value, SectionExtra, ActionExtra>[];
+    optionCount: number;
+    persistentsHeaders: import("./Autocomplete.types").MenuHeader<ActionExtra>[];
+    persistentsFooters: import("./Autocomplete.types").MenuFooter<ActionExtra>[];
+    headerInteractiveCount: number;
+    middleNavigableCount: number;
+    getOptionLabel: (opt: Value) => string;
+    isOptionSelected: (opt: Value) => boolean;
+    refs: {
+        reference: React.MutableRefObject<import("@floating-ui/react-dom").ReferenceType | null>;
+        floating: React.MutableRefObject<HTMLElement | null>;
+        setReference: (node: import("@floating-ui/react-dom").ReferenceType | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    } & import("@floating-ui/react").ExtendedRefs<import("@floating-ui/react").ReferenceType>;
+    floatingStyles: React.CSSProperties;
+    context: {
+        x: number;
+        y: number;
+        placement: import("@floating-ui/utils").Placement;
+        strategy: import("@floating-ui/utils").Strategy;
+        middlewareData: import("@floating-ui/core").MiddlewareData;
+        isPositioned: boolean;
+        update: () => void;
+        floatingStyles: React.CSSProperties;
+        open: boolean;
+        onOpenChange: (open: boolean, event?: Event, reason?: import("@floating-ui/react").OpenChangeReason) => void;
+        events: import("@floating-ui/react").FloatingEvents;
+        dataRef: React.MutableRefObject<import("@floating-ui/react").ContextData>;
+        nodeId: string | undefined;
+        floatingId: string | undefined;
+        refs: import("@floating-ui/react").ExtendedRefs<import("@floating-ui/react").ReferenceType>;
+        elements: import("@floating-ui/react").ExtendedElements<import("@floating-ui/react").ReferenceType>;
+    };
+    getReferenceProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement>) => Record<string, unknown>;
+    getItemProps: (userProps?: Omit<React.HTMLProps<HTMLElement>, "selected" | "active"> & {
+        active?: boolean;
+        selected?: boolean;
+    }) => Record<string, unknown>;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    activeIndex: number | null;
+    setActiveIndex: (index: number | null) => void;
+    listRef: React.MutableRefObject<(HTMLElement | null)[]>;
+    onSelection: (option: Value) => void;
+    onAction: (action: ActionConfig) => void;
+    onInputChangeFromUser: (val: string) => void;
+    onInputBlur: () => void;
+    onInputFocus: () => void;
+    onInputKeyDown: (event: React.KeyboardEvent) => void;
+    setReferenceElement: (el: HTMLElement | null) => void;
+};

package/dist/Autocomplete/utils/menuModel.d.ts

@@ -0,0 +1,14 @@
+import type React from "react";
+import type { ActionConfig, MenuFooter, MenuHeader, MenuItem, MenuOptions, MenuSection, OptionLike } from "../Autocomplete.types";
+import type { RenderItem } from "../useAutocomplete";
+export declare function flattenMenu<Value extends OptionLike, S extends object, A extends object>(menu: MenuItem<Value, S, A>[]): {
+    optionItems: Value[];
+    sections: (MenuSection<Value, S, A> | MenuOptions<Value, A>)[];
+    persistentsHeaders: MenuHeader<A>[];
+    persistentsFooters: MenuFooter<A>[];
+};
+export declare function buildItemsForGroup<Value extends OptionLike, S extends object, A extends object>(group: MenuSection<Value, S, A> | MenuOptions<Value, A>, optionsFilter?: (opts: Value[]) => Value[]): Array<RenderItem<Value, S, A>>;
+export declare function buildRenderableList<Value extends OptionLike, S extends object, A extends object>(sections: Array<MenuSection<Value, S, A> | MenuOptions<Value, A>>, optionsFilter?: (opts: Value[]) => Value[]): RenderItem<Value, S, A>[];
+export declare function getNavigableItemAtIndex<Value extends OptionLike, S extends object, A extends object>(activeIndex: number | null, renderable: Array<RenderItem<Value, S, A>>): RenderItem<Value, S, A> | null;
+export declare function findNavigableIndexForValue<Value extends OptionLike, S extends object, A extends object>(renderable: Array<RenderItem<Value, S, A>>, equals: (a: Value, b: Value) => boolean, selectedValue: Value): number | null;
+export declare function invokeActiveItemOnEnter<Value extends OptionLike, S extends object, A extends object>(event: React.KeyboardEvent, activeIndex: number | null, renderable: Array<RenderItem<Value, S, A>>, onSelect: (option: Value) => void, onAction: (action: ActionConfig) => void): void;