@oracle/oraclejet-preact 14.0.0

package/types/hooks/UNSAFE_useAnimation/index.d.ts

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

package/types/hooks/UNSAFE_useAnimation/useAnimation.d.ts

@@ -0,0 +1,41 @@
+import { UseAnimationCssProperties } from './animationUtils';
+export declare type UseAnimationConfig<V extends string, E extends HTMLElement> = {
+    animationStates: Partial<Record<AnimationStateKey<V>, ((node: E) => AnimationConfig) | AnimationConfig>>;
+    isAnimatedOnMount?: boolean;
+    onAnimationEnd?: ({ animationState }: {
+        animationState: V;
+    }) => void;
+};
+declare type AnimationStateKey<PA extends string> = ExtractAnimationStates<PA | `${PA} => ${PA}`>;
+declare type ExtractAnimationStates<StateString extends string> = StateString extends `${infer From} => ${infer To}` ? KeyWithPreviousAndCurrentState<From, To> : StateString;
+declare type KeyWithPreviousAndCurrentState<PreviousState extends string, CurrentState extends string> = {
+    b: PreviousState;
+} extends {
+    b: CurrentState;
+} ? never : `${PreviousState} => ${CurrentState}`;
+declare type AnimationConfig = {
+    from?: UseAnimationCssProperties;
+    to: UseAnimationCssProperties;
+    end?: UseAnimationCssProperties;
+    options?: AnimationOptions;
+};
+declare type AnimationOptions = {
+    delay?: number;
+    duration?: number;
+    easing?: 'linear' | 'ease' | 'ease-in' | 'ease-out' | 'ease-in-out' | [number, number, number, number];
+};
+declare type PermittedAnimationState<V extends string> = Exclude<V, `${string}=>${string}`>;
+/**
+ * Hook to animate single components.
+ * It allows n number of animation states.
+ * @param animationState
+ * @param animationConfig
+ * @returns
+ */
+export declare function useAnimation<V extends string, E extends HTMLElement = HTMLElement>(animationState: PermittedAnimationState<V>, { animationStates, isAnimatedOnMount, onAnimationEnd }: UseAnimationConfig<PermittedAnimationState<V>, E>): {
+    nodeRef: (node: E | null) => void;
+    controller: {
+        cancel: () => void;
+    };
+};
+export {};

package/types/hooks/UNSAFE_useBreakpointValues/index.d.ts

@@ -0,0 +1 @@
+export { useBreakpointValues } from "./useBreakpointValues";

package/types/hooks/UNSAFE_useBreakpointValues/useBreakpointValues.d.ts

@@ -0,0 +1,6 @@
+import { Breakpoints, defaultBreakpoints } from '../UNSAFE_useBreakpoints';
+declare type DefaultBreakpoints = keyof typeof defaultBreakpoints;
+declare type DefaultType<T> = Record<DefaultBreakpoints, T>;
+declare type Responsive<V> = Partial<DefaultType<V>>;
+export declare function useBreakpointValues<V>(breakpointValues: Responsive<V>, breakpoints?: Breakpoints): V;
+export {};

package/types/hooks/UNSAFE_useBreakpoints/index.d.ts

@@ -0,0 +1 @@
+export { defaultBreakpoints, Breakpoints, useBreakpoints } from "./useBreakpoints";

package/types/hooks/UNSAFE_useBreakpoints/useBreakpoints.d.ts

@@ -0,0 +1,8 @@
+export declare const defaultBreakpoints: {
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+};
+export declare type Breakpoints = Record<string, string>;
+export declare function useBreakpoints(breakpoints?: Breakpoints): Record<string, boolean>;

package/types/hooks/UNSAFE_useClearIcon/index.d.ts

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

package/types/hooks/UNSAFE_useClearIcon/useClearIcon.d.ts

@@ -0,0 +1,13 @@
+import { ComponentChildren } from 'preact';
+export declare type UseClearIconProps = {
+    clearIcon?: ComponentChildren;
+    display?: 'always' | 'conditionally' | 'never';
+    hasValue?: boolean;
+    isEnabled?: boolean;
+    isFocused?: boolean;
+    isHover?: boolean;
+};
+/**
+ * A custom hook that handles showing/hiding clear icon
+ */
+export declare function useClearIcon({ clearIcon, display, hasValue, isEnabled, isFocused, isHover }: UseClearIconProps): ComponentChildren;

package/types/hooks/UNSAFE_useColorScheme/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+export { useColorScheme } from './useColorScheme';

package/types/hooks/UNSAFE_useColorScheme/useColorScheme.d.ts

@@ -0,0 +1 @@
+export declare function useColorScheme(): "dark" | "light";

package/types/hooks/UNSAFE_useContainerBreakpointValues/index.d.ts

@@ -0,0 +1 @@
+export { useContainerBreakpointValues } from "./useContainerBreakpointValues";

package/types/hooks/UNSAFE_useContainerBreakpointValues/useContainerBreakpointValues.d.ts

@@ -0,0 +1,9 @@
+import { defaultBreakpoints, Breakpoints } from '../UNSAFE_useBreakpoints';
+declare type DefaultBreakpoints = keyof typeof defaultBreakpoints;
+declare type DefaultType<T> = Record<DefaultBreakpoints, T>;
+declare type Responsive<V> = Partial<DefaultType<V>>;
+export declare function useContainerBreakpointValues<V>(breakpointValues: Responsive<V>, breakpoints?: Breakpoints): {
+    breakpoint: V;
+    ref: (node: HTMLElement) => void;
+};
+export {};

package/types/hooks/UNSAFE_useContainerBreakpoints/index.d.ts

@@ -0,0 +1 @@
+export { useContainerBreakpoints } from "./useContainerBreakpoints";

package/types/hooks/UNSAFE_useContainerBreakpoints/useContainerBreakpoints.d.ts

@@ -0,0 +1,5 @@
+import { Breakpoints } from '../UNSAFE_useBreakpoints';
+export declare function useContainerBreakpoints(breakpoints?: Breakpoints): {
+    breakpointMatches: Record<string, boolean>;
+    ref: (node: HTMLElement) => void;
+};

package/types/hooks/UNSAFE_useCurrentValueReducer/index.d.ts

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

package/types/hooks/UNSAFE_useCurrentValueReducer/useCurrentValueReducer.d.ts

@@ -0,0 +1,31 @@
+import { ComponentProps } from 'preact';
+import { TextFieldInput } from '../../UNSAFE_TextField';
+declare type TextFieldInputProps = ComponentProps<typeof TextFieldInput>;
+declare type UseCurrentValueProps = {
+    value?: TextFieldInputProps['value'];
+};
+declare type CurrentValueDispatchAction = {
+    type: 'input' | 'commit';
+    payload?: string;
+};
+/**
+ * This hook takes an Object with a value, and returns currentCommitValue and dispatch.
+ *
+ * Whenever you call onInput, call dispatch({ type: 'input', payload: value });
+ * For example:
+ * dispatch({ type: 'input', payload: detail.value });
+ * onInput?.(detail);
+ * And similarly whenever you call onCommit, call dispatch({ type: 'commit', payload: value });
+ *
+ * The state is used to determine if the component's value property was programmatically
+ * changed or just changed from an onInput listener to update the value back
+ * to what the user typed in which is required for a controlled component.
+ *
+ * @param param0 The props for the useCurrentValueReducer hook
+ * @returns
+ */
+export declare function useCurrentValueReducer({ value }: UseCurrentValueProps): {
+    currentCommitValue: string | undefined;
+    dispatch: (action: CurrentValueDispatchAction) => void;
+};
+export {};

package/types/hooks/UNSAFE_useDebounce/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+export { useDebounce } from './useDebounce';

package/types/hooks/UNSAFE_useDebounce/useDebounce.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A custom hook that debounces a value and only returns the latest value
+ * if there is no interaction for the specified delay
+ *
+ * @param value The value to be debounced
+ * @param delay The delay for the debouncing
+ */
+export declare function useDebounce<V>(value: V, delay: number): V;

package/types/hooks/UNSAFE_useFloating/index.d.ts

@@ -0,0 +1 @@
+export { useFloating, autoPlacement, flip, hide, offset, shift, limitShift, size, inline, detectOverflow, Placement, Offset, Coords, VirtualElement, Rect, RtlSide, PositionData } from './useFloating';

package/types/hooks/UNSAFE_useFloating/useFloating.d.ts

@@ -0,0 +1,106 @@
+/**
+ * @license
+ * MIT License
+ *
+ * Copyright (c) 2021 Floating UI contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { MutableRef } from 'preact/hooks';
+import { ComputePositionConfig } from '@floating-ui/core';
+import { MiddlewareData, Middleware, Placement as FloatingPlacement } from '@floating-ui/dom';
+export { autoPlacement, flip, hide, shift, limitShift, size, inline, detectOverflow } from '@floating-ui/dom';
+export declare type Coords = {
+    [key in Axis]: number;
+};
+/**
+ * Where to place the floating element relative to its reference element.
+ * The top, bottom, right and left are physical positions of the floating element
+ * The start, end are logical positions and will adapt to the writing direction (e.g. RTL) as expected.
+ * The -[*] and -[*] are alignments on the cross axis.
+ * For example start-top means place the floating element to the left (in LTR) from the reference element and align their top edges
+ * There are several synonyms for placements:
+ * - right-top, right-start and end-top in LTR (start-top in RTL)
+ * - left-top, left-start and start-top in LTR (end-top in RTL)
+ * - right-bottom, right-end and end-bottom in LTR (start-bottom in RTL)
+ * - left-bottom, left-end and start-bottom in LTR (end-bottom in RTL)
+ */
+export declare type Placement = 'top' | 'top-start' | 'top-end' | 'top-start-corner' | 'top-end-corner' | 'start' | 'start-top' | 'start-bottom' | 'start-top-corner' | 'start-bottom-corner' | 'bottom' | 'bottom-start' | 'bottom-end' | 'bottom-start-corner' | 'bottom-end-corner' | 'end' | 'end-top' | 'end-bottom' | 'end-top-corner' | 'end-bottom-corner';
+declare type Side = 'top' | 'right' | 'bottom' | 'left';
+export declare type RtlSide = 'top' | 'right' | 'bottom' | 'left' | 'start' | 'end';
+declare type Axis = 'x' | 'y';
+declare type Length = 'width' | 'height';
+declare type Strategy = 'absolute' | 'fixed';
+declare type Dimensions = {
+    [key in Length]: number;
+};
+declare type SideObject = {
+    [key in Side]: number;
+};
+export declare type Rect = Coords & Dimensions;
+export declare type OffsetValue = number | {
+    mainAxis?: number;
+    crossAxis?: number;
+};
+export declare type OffsetFunction = (args: {
+    floating: Rect;
+    reference: Rect;
+    placement: FloatingPlacement;
+}) => OffsetValue;
+export declare type Offset = OffsetValue | OffsetFunction;
+export declare const offset: (value?: Offset) => Middleware;
+export declare type ClientRectObject = Rect & SideObject;
+export declare type VirtualElement = {
+    getBoundingClientRect(): ClientRectObject;
+    contextElement?: any;
+};
+declare type ReferenceType = Element | VirtualElement;
+declare type UseFloatingProps<RT extends ReferenceType = ReferenceType> = Omit<Partial<ComputePositionConfig>, 'platform' | 'placement'> & {
+    placement: Placement;
+    whileElementsMounted?: (reference: RT, floating: HTMLElement, update: () => void) => void | (() => void);
+    onPosition?: (data: PositionData) => void;
+};
+declare type UseFloatingData = {
+    placement: FloatingPlacement;
+    strategy: Strategy;
+    middlewareData: MiddlewareData;
+    x: number | null;
+    y: number | null;
+};
+export declare type PositionData = {
+    placement: Placement;
+    origPlacement: Placement;
+    x: number | null;
+    y: number | null;
+    arrow?: Partial<Coords> & {
+        centerOffset: number;
+    };
+    offset?: Coords;
+    origOffset?: Offset;
+};
+declare type UseFloatingReturn<RT extends ReferenceType = ReferenceType> = UseFloatingData & {
+    update: () => void;
+    reference: (node: RT | null) => void;
+    floating: (node: HTMLElement | null) => void;
+    refs: {
+        reference: MutableRef<RT | null>;
+        floating: MutableRef<HTMLElement | null>;
+    };
+};
+export declare function useFloating<RT extends ReferenceType = ReferenceType>({ middleware, placement, strategy, onPosition, whileElementsMounted }: UseFloatingProps): UseFloatingReturn<RT>;

package/types/hooks/UNSAFE_useFocus/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+export { useFocus } from './useFocus';

package/types/hooks/UNSAFE_useFocus/useFocus.d.ts

@@ -0,0 +1,11 @@
+export declare type FocusOptions = {
+    isDisabled?: boolean;
+};
+/**
+ * Get status on whether target has focus or not
+ * @returns
+ */
+export declare function useFocus(settings?: FocusOptions): {
+    isFocus: boolean;
+    focusProps: Record<string, any>;
+};

package/types/hooks/UNSAFE_useFocusWithin/index.d.ts

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

package/types/hooks/UNSAFE_useFocusWithin/useFocusWithin.d.ts

@@ -0,0 +1,21 @@
+declare type FocusEvents = {
+    onBlurWithin?: (e: FocusEvent) => void;
+    onFocusWithin?: (e: FocusEvent) => void;
+};
+declare type UseFocusWithinProps = FocusEvents & {
+    isDisabled?: boolean;
+};
+export declare function useFocusWithin({ isDisabled, onBlurWithin, onFocusWithin }?: UseFocusWithinProps): {
+    isFocused: boolean;
+    focusProps: {
+        onfocusin?: undefined;
+        onfocusout?: undefined;
+    };
+} | {
+    isFocused: boolean;
+    focusProps: {
+        onfocusin: (event: FocusEvent) => void;
+        onfocusout: (event: FocusEvent) => void;
+    };
+};
+export {};

package/types/hooks/UNSAFE_useFocusableTextField/index.d.ts

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

package/types/hooks/UNSAFE_useFocusableTextField/useFocusableTextField.d.ts

@@ -0,0 +1,36 @@
+import { Ref } from 'preact';
+import { useFocusWithin } from '../UNSAFE_useFocusWithin';
+export declare type FocusableHandle = {
+    focus: () => void;
+    blur: () => void;
+};
+declare type UseFocusWithinProps = Parameters<typeof useFocusWithin>[0];
+declare type UseFocusableTextFieldProps = UseFocusWithinProps & {
+    /**
+     * flag indicating whether the field is readonly
+     */
+    isReadonly?: boolean;
+    /**
+     * An optional ref to add imperative handles
+     */
+    ref?: Ref<FocusableHandle>;
+};
+/**
+ * A custom hook that handles the focus when the text field
+ * is toggled between readonly and enabled
+ * @typedef E represents the type of the enabled element
+ * @typedef R represents the type of the readonly element
+ */
+export declare function useFocusableTextField<E extends HTMLElement, R extends HTMLElement>({ isReadonly, ref, ...useFocusWithinProps }: UseFocusableTextFieldProps): {
+    enabledElementRef: import("preact/hooks").Ref<E>;
+    readonlyElementRef: import("preact/hooks").Ref<R>;
+    isFocused: boolean;
+    focusProps: {
+        onfocusin?: undefined;
+        onfocusout?: undefined;
+    } | {
+        onfocusin: (event: FocusEvent) => void;
+        onfocusout: (event: FocusEvent) => void;
+    };
+};
+export {};

package/types/hooks/UNSAFE_useFormContext/FormContext.d.ts

@@ -0,0 +1,45 @@
+import { Size } from '../../utils/UNSAFE_size';
+/**
+ * Props of the FormContext
+ */
+declare type FormContextProps = {
+    /**
+     * Indicates whether the form layout is disabled.
+     */
+    isDisabled?: boolean;
+    /**
+     * Indicates whether the component is inside a form layout.
+     */
+    isFormLayout?: boolean;
+    /**
+     * Indicates whether the form layout is readonly.
+     */
+    isReadonly?: boolean;
+    /**
+     * Specifies the label position.
+     */
+    labelEdge?: 'inside' | 'start' | 'top';
+    /**
+     * Specifies the width of the start aligned label, ignored for top aligned.
+     */
+    labelStartWidth?: Size;
+    /**
+     * Specifies if start or top label text should wrap or truncate.
+     */
+    labelWrapping?: 'truncate' | 'wrap';
+    /**
+     * Specifies the text alignment of the value.
+     */
+    textAlign?: 'start' | 'end' | 'right';
+    /**
+     * Specifies the density of the user assistance presentation.
+     */
+    userAssistanceDensity?: 'reflow' | 'efficient';
+};
+declare const DefaultFormContext: FormContextProps;
+/**
+ * Context which the parent component can use to provide various FormLayout related
+ * information to descendant form controls.
+ */
+declare const FormContext: import("preact").Context<FormContextProps>;
+export { DefaultFormContext, FormContext, FormContextProps };

package/types/hooks/UNSAFE_useFormContext/index.d.ts

@@ -0,0 +1,3 @@
+export { FormContext } from './FormContext';
+export type { FormContextProps } from './FormContext';
+export { useFormContext } from './useFormContext';

package/types/hooks/UNSAFE_useFormContext/useFormContext.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Utility hook for consuming the FormContext
+ *
+ * @returns The value of closest FormContext provider
+ */
+declare function useFormContext(): import("./FormContext").FormContextProps;
+export { useFormContext };

package/types/hooks/UNSAFE_useFormFieldContext/FormFieldContext.d.ts

@@ -0,0 +1,73 @@
+declare type DisabledFormFieldContext = {
+    /**
+     * Indicates whether the component has value
+     */
+    hasValue?: boolean;
+    /**
+     * Indicates whether the component is in disabled state
+     */
+    isDisabled: true;
+    /**
+     * A disabled field can never have focus
+     */
+    isFocused?: false;
+    /**
+     * Indicates whether the component is in a loading state
+     */
+    isLoading?: boolean;
+    /**
+     * A disabled field can never be readonly
+     */
+    isReadonly?: false;
+};
+declare type EnabledFormFieldContext = {
+    /**
+     * Indicates whether the component has value
+     */
+    hasValue?: boolean;
+    /**
+     * Enabled field can never be disabled
+     */
+    isDisabled?: false;
+    /**
+     * Indicates whether the text field is in focused state
+     */
+    isFocused?: boolean;
+    /**
+     * Indicates whether the component is in a loading state
+     */
+    isLoading?: boolean;
+    /**
+     * Enabled field will not be readonly
+     */
+    isReadonly?: false;
+};
+declare type ReadonlyFormFieldContext = {
+    /**
+     * Indicates whether the component has value
+     */
+    hasValue?: boolean;
+    /**
+     * Readonly field can never be disabled
+     */
+    isDisabled?: false;
+    /**
+     * Indicates whether the text field is in focused state
+     */
+    isFocused?: boolean;
+    /**
+     * Indicates whether the component is in a loading state
+     */
+    isLoading?: boolean;
+    /**
+     * Indicates whether the component is in readonly state
+     */
+    isReadonly: true;
+};
+declare type FormFieldContextProps = DisabledFormFieldContext | EnabledFormFieldContext | ReadonlyFormFieldContext;
+/**
+ * Context which the parent component can use to provide various FormControl related
+ * information
+ */
+declare const FormFieldContext: import("preact").Context<FormFieldContextProps>;
+export { FormFieldContext, FormFieldContextProps };

package/types/hooks/UNSAFE_useFormFieldContext/index.d.ts

@@ -0,0 +1,3 @@
+export { FormFieldContext } from './FormFieldContext';
+export type { FormFieldContextProps } from './FormFieldContext';
+export { useFormFieldContext } from './useFormFieldContext';

package/types/hooks/UNSAFE_useFormFieldContext/useFormFieldContext.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Utility hook for consuming the FormFieldContext
+ *
+ * @returns The value of closest FormControl provider
+ */
+declare function useFormFieldContext(): import("./FormFieldContext").FormFieldContextProps;
+export { useFormFieldContext };

package/types/hooks/UNSAFE_useFormVariantContext/FormVariantContext.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Context which an ancestor component can use to provide a value for the 'variant' property
+ * of the descendant form fields.
+ */
+export declare const FormVariantContext: import("preact").Context<"default" | "embedded" | undefined>;

package/types/hooks/UNSAFE_useFormVariantContext/index.d.ts

@@ -0,0 +1,2 @@
+export { FormVariantContext } from './FormVariantContext';
+export { useFormVariantContext } from './useFormVariantContext';

package/types/hooks/UNSAFE_useFormVariantContext/useFormVariantContext.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Utility hook for consuming the FormVariantContext
+ *
+ * @returns The value of the closest FormVariantContext provider
+ */
+export declare function useFormVariantContext(): "default" | "embedded" | undefined;

package/types/hooks/UNSAFE_useHover/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+export { useHover } from './useHover';

package/types/hooks/UNSAFE_useHover/useHover.d.ts

@@ -0,0 +1,13 @@
+export declare type HoverOptions = {
+    isDisabled?: boolean;
+};
+/**
+ * Returns listeners and status for hover
+ * If only visual changes are required, :hover is faster.
+ *
+ * @returns
+ */
+export declare function useHover(settings?: HoverOptions): {
+    isHover: boolean;
+    hoverProps: Record<string, any>;
+};

package/types/hooks/UNSAFE_useId/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+export { useId } from './useId';

package/types/hooks/UNSAFE_useId/useId.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Generates random string that can be used as ID. Serves as replacement for
+ * getUniqueId() function from "ojs/ojvcomponent-preact", until React 18 is
+ * released with useId hook (https://github.com/preactjs/preact/issues/3373).
+ * 1. Pick a random number in the range between 0 (inclusive) and 1 (exclusive)
+ * 2. Convert the number to a base-36 string (using characters 0-9 and a-z)
+ * 3. Slice off the leading '0.' prefix
+ * 4. ids should always start with a letter, so prefix it with 'id'
+ */
+export declare const useId: () => string;

package/types/hooks/UNSAFE_useLengthFilter/index.d.ts

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

package/types/hooks/UNSAFE_useLengthFilter/useLengthFilter.d.ts

@@ -0,0 +1,20 @@
+import { ComponentProps } from 'preact';
+import { TextFieldInput } from '../../UNSAFE_TextField';
+import { CountUnit as _CountUnit } from '../../utils/UNSAFE_lengthFilter';
+export declare type CountUnit = _CountUnit;
+declare type PickedPropsFromTextFieldInput = Pick<ComponentProps<typeof TextFieldInput>, 'onCommit' | 'onInput' | 'value'>;
+declare type UseLengthFilterProps = PickedPropsFromTextFieldInput & {
+    maxLength?: number;
+    maxLengthUnit?: CountUnit;
+};
+/**
+ * A custom hook that applies the length filter to text field input
+ * @param param0 The props for the useLengthFilter hook
+ * @returns The filtered event handlers
+ */
+export declare function useLengthFilter({ maxLength, maxLengthUnit, onCommit, onInput, value }: UseLengthFilterProps): {
+    isMaxLengthExceeded: boolean;
+    valueLength: number | undefined;
+    onFilteredInput: (detail: import("../../utils/UNSAFE_valueUpdateDetail").ValueUpdateDetail<string>) => void;
+};
+export {};

package/types/hooks/UNSAFE_useLoadingIndicatorTimer/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+export { useLoadingIndicatorTimer } from './useLoadingIndicatorTimer';

package/types/hooks/UNSAFE_useLoadingIndicatorTimer/useLoadingIndicatorTimer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+/**
+ * Hook for a timer used to determine when to show a loading indicator.
+ * After the timer is started, the loading indicator should only be shown after a slight delay,
+ * when the timer expires.  A loading indicator should not be shown immediately because that
+ * could result in unwanted flashing in the UI.
+ * @param isLoading Specifies whether the calling code is in a loading state and the timer
+ * should be started: true to start it, false to stop it.
+ * @returns True if the timer expires, false if it was stopped before that.
+ */
+export declare function useLoadingIndicatorTimer(isLoading: boolean): boolean;