@fluentui/react-utilities 9.0.0-rc.1 → 9.0.0-rc.10

package/lib/ssr/SSRContext.d.ts

@@ -1,33 +0,0 @@
-import * as React from 'react';
-/**
- * To support SSR, the auto incrementing id counter is stored in a context. This allows it to be reset on every request
- * to ensure the client and server are consistent.
- *
- * @internal
- */
-export declare type SSRContextValue = {
-    current: number;
-};
-/**
- * Default context value to use in case there is no SSRProvider. This is fine for client-only apps.
- *
- * @internal
- */
-export declare const defaultSSRContextValue: SSRContextValue;
-export declare const SSRContext: React.Context<SSRContextValue>;
-/**
- * @internal
- */
-export declare function useSSRContext(): SSRContextValue;
-/**
- * When using SSR with Fluent UI, applications must be wrapped in an SSRProvider. This ensures that auto generated ids
- * are consistent between the client and server.
- *
- * @public
- */
-export declare const SSRProvider: React.FC;
-/**
- * Returns whether the component is currently being server side rendered or hydrated on the client. Can be used to delay
- * browser-specific rendering until after hydration. May cause re-renders on a client when is used within SSRProvider.
- */
-export declare function useIsSSR(): boolean;

package/lib/ssr/canUseDOM.d.ts

@@ -1,4 +0,0 @@
-/**
- * Verifies if an application can use DOM.
- */
-export declare function canUseDOM(): boolean;

package/lib/ssr/index.d.ts

@@ -1,2 +0,0 @@
-export * from './canUseDOM';
-export * from './SSRContext';

package/lib/utils/applyTriggerPropsToChildren.d.ts

@@ -1,5 +0,0 @@
-import * as React from 'react';
-/**
- * Apply the trigger props to the children, either by calling the render function, or cloning with the new props.
- */
-export declare const applyTriggerPropsToChildren: <TTriggerProps>(children: React.ReactElement<any, string | React.JSXElementConstructor<any>> | ((props: TTriggerProps) => React.ReactElement | null) | null | undefined, triggerProps: TTriggerProps) => React.ReactElement | null;

package/lib/utils/clamp.d.ts

@@ -1,8 +0,0 @@
-/**
- * Clamps `value` to a number between the min and max.
- *
- * @param value - the value to be clamped
- * @param min - the lowest valid value
- * @param max - the highest valid value
- */
-export declare const clamp: (value: number, min: number, max: number) => number;

package/lib/utils/getNativeElementProps.d.ts

@@ -1,31 +0,0 @@
-import * as React from 'react';
-/**
- * Given an element tagname and user props, filters the props to only allowed props for the given
- * element type.
- * @param tagName - Tag name (e.g. "div")
- * @param props - Props object
- * @param excludedPropNames - List of props to disallow
- */
-export declare function getNativeElementProps<TAttributes extends React.HTMLAttributes<any>>(tagName: string, props: {}, excludedPropNames?: string[]): TAttributes;
-/**
- * Splits the native props into ones that go to the `root` slot, and ones that go to the primary slot.
- *
- * This function is only for use with components that have a primary slot other than `root`.
- * Most components should use {@link getNativeElementProps} for their root slot if it is the primary slot.
- *
- * @returns An object containing the native props for the `root` and primary slots.
- */
-export declare const getPartitionedNativeProps: <Props extends Pick<React.HTMLAttributes<HTMLElement>, "style" | "className">, ExcludedPropKeys extends Extract<keyof Props, string> = never>({ primarySlotTagName, props, excludedPropNames, }: {
-    /** The primary slot's element type (e.g. 'div') */
-    primarySlotTagName: keyof JSX.IntrinsicElements;
-    /** The component's props object */
-    props: Props;
-    /** List of native props to exclude from the returned value */
-    excludedPropNames?: ExcludedPropKeys[] | undefined;
-}) => {
-    root: {
-        style: React.CSSProperties | undefined;
-        className: string | undefined;
-    };
-    primary: Omit<Props, ExcludedPropKeys>;
-};

package/lib/utils/getRTLSafeKey.d.ts

@@ -1,4 +0,0 @@
-/**
- * Finds and swaps a provided key for it's right to left format.
- */
-export declare const getRTLSafeKey: (key: string, dir: 'ltr' | 'rtl') => string;

package/lib/utils/getReactCallbackName.d.ts

@@ -1,25 +0,0 @@
-import * as React from 'react';
-interface ReactSyntheticEvent extends React.SyntheticEvent<unknown> {
-    _reactName?: string;
-    dispatchConfig?: {
-        registrationName: string;
-        phasedRegistrationNames: {
-            bubbled: string;
-            captured: string;
-        };
-    };
-}
-declare type NonUndefined<A> = A extends undefined ? never : A;
-declare type FunctionKeys<T extends object> = {
-    [K in keyof T]-?: NonUndefined<T[K]> extends Function ? K : never;
-}[keyof T];
-export declare type ReactCallbackName = FunctionKeys<React.DOMAttributes<unknown>>;
-/**
- * React.SyntheticEvent contains name of a callback that should be fired, this function returns it.
- *
- * Ideally, it should also distinguish regular and "capture" callbacks, but it's possible only with React 17 as
- * ".eventPhase" there has proper value, see https://github.com/facebook/react/pull/19244. In React 16 all events
- * are handled in bubble phase.
- */
-export declare function getReactCallbackName(event: ReactSyntheticEvent): ReactCallbackName | undefined;
-export {};

package/lib/utils/getTriggerChild.d.ts

@@ -1,22 +0,0 @@
-import * as React from 'react';
-/**
- * Gets the trigger element of a FluentTriggerComponent (such as Tooltip or MenuTrigger).
- *
- * In the case where the immediate child is itself a FluentTriggerComponent and/or React Fragment,
- * it returns the first descendant that is _not_ a FluentTriggerComponent or Fragment.
- * This allows multiple triggers to be stacked, and still apply their props to the actual trigger element.
- *
- * For example, the following returns `<div id="child" />`:
- * ```jsx
- * getTriggerChild(
- *   <Tooltip>
- *     <MenuTrigger>
- *       <div id="child" />
- *     </MenuTrigger>
- *   </Tooltip>
- * );
- * ```
- */
-export declare const getTriggerChild: (children: React.ReactNode) => React.ReactElement & {
-    ref?: React.Ref<unknown>;
-};

package/lib/utils/index.d.ts

@@ -1,9 +0,0 @@
-export * from './applyTriggerPropsToChildren';
-export * from './clamp';
-export * from './getNativeElementProps';
-export * from './getRTLSafeKey';
-export * from './getTriggerChild';
-export * from './isFluentTrigger';
-export * from './omit';
-export * from './properties';
-export * from './shouldPreventDefaultOnKeyDown';

package/lib/utils/isFluentTrigger.d.ts

@@ -1,22 +0,0 @@
-import * as React from 'react';
-/**
- * Allows a component to be tagged as a FluentUI trigger component.
- *
- * Triggers are special-case components: they attach event listeners and other props on their child,
- * and use them to trigger another component to show. Examples include `MenuTrigger` and `Tooltip`.
- *
- * A component can be tagged as a trigger as follows:
- * ```ts
- * const MyComponent: React.FC<MyComponentProps> & FluentTriggerComponent = ...;
- *
- * MyComponent.isFluentTriggerComponent = true; // MUST also set this to true
- * ```
- */
-export declare type FluentTriggerComponent = {
-    isFluentTriggerComponent?: boolean;
-};
-/**
- * Checks if a given element is a FluentUI trigger (e.g. `MenuTrigger` or `Tooltip`).
- * See the {@link FluentTriggerComponent} type for more info.
- */
-export declare const isFluentTrigger: (element: React.ReactElement) => boolean | undefined;

package/lib/utils/omit.d.ts

@@ -1,14 +0,0 @@
-/**
- * Tiny helper to do the minimal amount of work in duplicating an object but omitting some
- * props. This ends up faster than using object ...rest or reduce to filter.
- *
- * This behaves very much like filteredAssign, but does not merge many objects together,
- * uses an exclusion object map, and avoids spreads all for optimal performance.
- *
- * See perf test for background:
- * https://jsperf.com/omit-vs-rest-vs-reduce/1
- *
- * @param obj - The object to clone
- * @param exclusions - The array of keys to exclude
- */
-export declare function omit<TObj extends Record<string, any>, Exclusions extends (keyof TObj)[]>(obj: TObj, exclusions: Exclusions): Omit<TObj, Exclusions[number]>;

package/lib/utils/properties.d.ts

@@ -1,148 +0,0 @@
-/**
- * An array of events that are allowed on every html element type.
- *
- * @public
- */
-export declare const baseElementEvents: Record<string, number>;
-/**
- * An array of element attributes which are allowed on every html element type.
- *
- * @public
- */
-export declare const baseElementProperties: Record<string, number>;
-/**
- * An array of HTML element properties and events.
- *
- * @public
- */
-export declare const htmlElementProperties: Record<string, number>;
-/**
- * An array of LABEL tag properties and events.
- *
- * @public
- */
-export declare const labelProperties: Record<string, number>;
-/**
- * An array of AUDIO tag properties and events.
-
- * @public
- */
-export declare const audioProperties: Record<string, number>;
-/**
- * An array of VIDEO tag properties and events.
- *
- * @public
- */
-export declare const videoProperties: Record<string, number>;
-/**
- * An array of OL tag properties and events.
- *
- * @public
- */
-export declare const olProperties: Record<string, number>;
-/**
- * An array of LI tag properties and events.
- *
- * @public
- */
-export declare const liProperties: Record<string, number>;
-/**
- * An array of A tag properties and events.
- *
- * @public
- */
-export declare const anchorProperties: Record<string, number>;
-/**
- * An array of BUTTON tag properties and events.
- *
- * @public
- */
-export declare const buttonProperties: Record<string, number>;
-/**
- * An array of INPUT tag properties and events.
- *
- * @public
- */
-export declare const inputProperties: Record<string, number>;
-/**
- * An array of TEXTAREA tag properties and events.
- *
- * @public
- */
-export declare const textAreaProperties: Record<string, number>;
-/**
- * An array of SELECT tag properties and events.
- *
- * @public
- */
-export declare const selectProperties: Record<string, number>;
-export declare const optionProperties: Record<string, number>;
-/**
- * An array of TABLE tag properties and events.
- *
- * @public
- */
-export declare const tableProperties: Record<string, number>;
-/**
- * An array of TR tag properties and events.
- *
- * @public
- */
-export declare const trProperties: Record<string, number>;
-/**
- * An array of TH tag properties and events.
- *
- * @public
- */
-export declare const thProperties: Record<string, number>;
-/**
- * An array of TD tag properties and events.
- *
- * @public
- */
-export declare const tdProperties: Record<string, number>;
-export declare const colGroupProperties: Record<string, number>;
-export declare const colProperties: Record<string, number>;
-/**
- * An array of FORM tag properties and events.
- *
- * @public
- */
-export declare const formProperties: Record<string, number>;
-/**
- * An array of IFRAME tag properties and events.
- *
- * @public
- */
-export declare const iframeProperties: Record<string, number>;
-/**
- * An array of IMAGE tag properties and events.
- *
- * @public
- */
-export declare const imgProperties: Record<string, number>;
-/**
- * @deprecated Use imgProperties for img elements.
- */
-export declare const imageProperties: Record<string, number>;
-/**
- * An array of DIV tag properties and events.
- *
- * @public
- */
-export declare const divProperties: Record<string, number>;
-/**
- * Gets native supported props for an html element provided the allowance set. Use one of the property
- * sets defined (divProperties, buttonPropertes, etc) to filter out supported properties from a given
- * props set. Note that all data- and aria- prefixed attributes will be allowed.
- * NOTE: getNativeProps should always be applied first when adding props to a react component. The
- * non-native props should be applied second. This will prevent getNativeProps from overriding your custom props.
- * For example, if props passed to getNativeProps has an onClick function and getNativeProps is added to
- * the component after an onClick function is added, then the getNativeProps onClick will override it.
- *
- * @public
- * @param props - The unfiltered input props
- * @param allowedPropsNames - The array or record of allowed prop names.
- * @returns The filtered props
- */
-export declare function getNativeProps<T extends Record<string, any>>(props: Record<string, any>, allowedPropNames: string[] | Record<string, number>, excludedPropNames?: string[]): T;

package/lib/utils/shouldPreventDefaultOnKeyDown.d.ts

@@ -1,7 +0,0 @@
-import * as React from 'react';
-/**
- * Checks if the keyboard event should preventDefault() for Enter and Spacebar keys
- *
- * Useful for situations where a keydown needs to be transformed to a click event
- */
-export declare function shouldPreventDefaultOnKeyDown(e: KeyboardEvent | React.KeyboardEvent): boolean;

package/lib-commonjs/compose/getSlots.d.ts

@@ -1,30 +0,0 @@
-import * as React from 'react';
-import type { AsIntrinsicElement, ComponentState, ExtractSlotProps, SlotPropsRecord, UnionToIntersection } from './types';
-export declare type Slots<S extends SlotPropsRecord> = {
-    [K in keyof S]: ExtractSlotProps<S[K]> extends AsIntrinsicElement<infer As> ? As : ExtractSlotProps<S[K]> extends React.ComponentType<infer P> ? React.ElementType<NonNullable<P>> : React.ElementType<ExtractSlotProps<S[K]>>;
-};
-declare type ObjectSlotProps<S extends SlotPropsRecord> = {
-    [K in keyof S]-?: ExtractSlotProps<S[K]> extends AsIntrinsicElement<infer As> ? UnionToIntersection<JSX.IntrinsicElements[As]> : ExtractSlotProps<S[K]> extends React.ComponentType<infer P> ? P : never;
-};
-/**
- * Given the state and an array of slot names, will break out `slots` and `slotProps`
- * collections.
- *
- * The root is derived from a mix of `components` props and `as` prop.
- *
- * Slots will render as null if they are rendered as primitives with undefined children.
- *
- * The slotProps will always omit the `as` prop within them, and for slots that are string
- * primitives, the props will be filtered according to the slot type by the type system.
- * For example, if the slot is rendered `as: 'a'`, the props will be filtered for acceptable
- * anchor props. Note that this is only enforced at build time by Typescript -- there is no
- * runtime code filtering props in this function.
- *
- * @param state - State including slot definitions
- * @returns An object containing the `slots` map and `slotProps` map.
- */
-export declare function getSlots<R extends SlotPropsRecord>(state: ComponentState<R>): {
-    slots: Slots<R>;
-    slotProps: ObjectSlotProps<R>;
-};
-export {};

package/lib-commonjs/compose/index.d.ts

@@ -1,3 +0,0 @@
-export * from './getSlots';
-export * from './resolveShorthand';
-export * from './types';

package/lib-commonjs/compose/resolveShorthand.d.ts

@@ -1,16 +0,0 @@
-import type { ReplaceNullWithUndefined, SlotShorthandValue, UnknownSlotProps } from './types';
-export declare type ResolveShorthandOptions<Props, Required extends boolean = false> = {
-    required?: Required;
-    defaultProps?: Props;
-};
-export declare type ResolveShorthandFunction<Props extends UnknownSlotProps = UnknownSlotProps> = {
-    <P extends Props | null>(value: P | SlotShorthandValue | undefined, options?: ResolveShorthandOptions<P, true>): ReplaceNullWithUndefined<P>;
-    <P extends Props | null>(value: P | SlotShorthandValue | undefined, options?: ResolveShorthandOptions<P, boolean>): ReplaceNullWithUndefined<P> | undefined;
-};
-/**
- * Resolves shorthands into slot props, to ensure normalization of the signature
- * being passed down to getSlots method
- * @param value - the base shorthand props
- * @param options - options to resolve shorthand props
- */
-export declare const resolveShorthand: ResolveShorthandFunction;

package/lib-commonjs/compose/types.d.ts

@@ -1,155 +0,0 @@
-import * as React from 'react';
-export declare type SlotRenderFunction<Props> = (Component: React.ElementType<Props>, props: Omit<Props, 'children' | 'as'>) => React.ReactNode;
-/**
- * Matches any component's Slots type (such as ButtonSlots).
- *
- * This should ONLY be used in type templates as in `extends SlotPropsRecord`;
- * it shouldn't be used as a component's Slots type.
- */
-export declare type SlotPropsRecord = Record<string, UnknownSlotProps | SlotShorthandValue | null | undefined>;
-/**
- * The shorthand value of a slot allows specifying its child
- */
-export declare type SlotShorthandValue = React.ReactChild | React.ReactNodeArray | React.ReactPortal;
-/**
- * Matches any slot props type.
- *
- * This should ONLY be used in type templates as in `extends UnknownSlotProps`;
- * it shouldn't be used as the type of a slot.
- */
-export declare type UnknownSlotProps = Pick<React.HTMLAttributes<HTMLElement>, 'children' | 'className' | 'style'> & {
-    as?: keyof JSX.IntrinsicElements;
-};
-/**
- * Helper type for {@link Slot}. Adds shorthand types that are assignable to the slot's `children`.
- */
-declare type WithSlotShorthandValue<Props extends {
-    children?: unknown;
-}> = Props | Extract<SlotShorthandValue, Props['children']>;
-/**
- * Helper type for {@link Slot}. Takes the props we want to support for a slot and adds the ability for `children`
- * to be a render function that takes those props.
- */
-declare type WithSlotRenderFunction<Props extends {
-    children?: unknown;
-}> = Props & {
-    children?: Props['children'] | SlotRenderFunction<Props>;
-};
-/**
- * HTML element types that are not allowed to have children.
- *
- * Reference: https://developer.mozilla.org/en-US/docs/Glossary/Empty_element
- */
-declare type EmptyIntrisicElements = 'area' | 'base' | 'br' | 'col' | 'embed' | 'hr' | 'img' | 'input' | 'link' | 'meta' | 'param' | 'source' | 'track' | 'wbr';
-/**
- * Helper type for {@link Slot}. Modifies `JSX.IntrinsicElements[Type]`:
- * * Removes legacy string ref.
- * * Disallows children for empty tags like 'img'.
- */
-declare type IntrisicElementProps<Type extends keyof JSX.IntrinsicElements> = React.PropsWithRef<JSX.IntrinsicElements[Type]> & (Type extends EmptyIntrisicElements ? {
-    children?: never;
-} : {});
-/**
- * The props type and shorthand value for a slot. Type is either a single intrinsic element like `'div'`,
- * or a component like `typeof Button`.
- *
- * If a slot needs to support multiple intrinsic element types, use the `AlternateAs` param (see examples below).
- *
- * By default, slots can be set to `null` to prevent them from being rendered. If a slot must always be rendered,
- * wrap with `NonNullable` (see examples below).
- *
- * @example
- * ```
- * // Intrinsic element examples:
- * Slot<'div'> // Slot is always div
- * Slot<'button', 'a'> // Defaults to button, but allows as="a" with anchor-specific props
- * Slot<'span', 'div' | 'pre'> // Defaults to span, but allows as="div" or as="pre"
- * NonNullable<Slot<'div'>> // Slot that will always be rendered (can't be set to null by the user)
- *
- * // Component examples:
- * Slot<typeof Button> // Slot is always a Button, and accepts all of Button's Props
- * NonNullable<Slot<typeof Label>> // Slot is a Label and will always be rendered (can't be set to null by the user)
- * ```
- */
-export declare type Slot<Type extends keyof JSX.IntrinsicElements | React.ComponentType | UnknownSlotProps, AlternateAs extends keyof JSX.IntrinsicElements = never> = IsSingleton<Extract<Type, string>> extends true ? WithSlotShorthandValue<Type extends keyof JSX.IntrinsicElements ? {
-    as?: Type;
-} & WithSlotRenderFunction<IntrisicElementProps<Type>> : Type extends React.ComponentType<infer Props> ? WithSlotRenderFunction<Props> : Type> | {
-    [As in AlternateAs]: {
-        as: As;
-    } & WithSlotRenderFunction<IntrisicElementProps<As>>;
-}[AlternateAs] | null : 'Error: First parameter to Slot must not be not a union of types. See documentation of Slot type.';
-/**
- * Evaluates to true if the given type contains exactly one string, or false if it is a union of strings.
- *
- * ```
- * IsSingleton<'a'> // true
- * IsSingleton<'a' | 'b' | 'c'> // false
- * ```
- */
-export declare type IsSingleton<T extends string> = {
-    [K in T]: Exclude<T, K> extends never ? true : false;
-}[T];
-/**
- * Helper type for inferring the type of the as prop from a Props type.
- *
- * For example:
- * ```
- * type Example<T> = T extends AsIntrinsicElement<infer As> ? As : never;
- * ```
- */
-export declare type AsIntrinsicElement<As extends keyof JSX.IntrinsicElements> = {
-    as?: As;
-};
-/**
- * Converts a union type (`A | B | C`) to an intersection type (`A & B & C`)
- */
-export declare type UnionToIntersection<U> = (U extends unknown ? (x: U) => U : never) extends (x: infer I) => U ? I : never;
-/**
- * Removes the 'ref' prop from the given Props type, leaving unions intact (such as the discriminated union created by
- * IntrinsicSlotProps). This allows IntrinsicSlotProps to be used with React.forwardRef.
- *
- * The conditional "extends unknown" (always true) exploits a quirk in the way TypeScript handles conditional
- * types, to prevent unions from being expanded.
- */
-export declare type PropsWithoutRef<P> = 'ref' extends keyof P ? (P extends unknown ? Omit<P, 'ref'> : P) : P;
-/**
- * Removes SlotShorthandValue and null from the slot type, extracting just the slot's Props object.
- */
-export declare type ExtractSlotProps<S> = Exclude<S, SlotShorthandValue | null | undefined>;
-/**
- * Defines the Props type for a component given its slots and the definition of which one is the primary slot,
- * defaulting to root if one is not provided.
- */
-export declare type ComponentProps<Slots extends SlotPropsRecord, Primary extends keyof Slots = 'root'> = Omit<Slots, Primary & 'root'> & PropsWithoutRef<ExtractSlotProps<Slots[Primary]>>;
-/**
- * If type T includes `null`, remove it and add `undefined` instead.
- */
-export declare type ReplaceNullWithUndefined<T> = T extends null ? Exclude<T, null> | undefined : T;
-/**
- * Defines the State object of a component given its slots.
- */
-export declare type ComponentState<Slots extends SlotPropsRecord> = {
-    components: {
-        [Key in keyof Slots]-?: React.ComponentType<ExtractSlotProps<Slots[Key]>> | (ExtractSlotProps<Slots[Key]> extends AsIntrinsicElement<infer As> ? As : keyof JSX.IntrinsicElements);
-    };
-} & {
-    [Key in keyof Slots]: ReplaceNullWithUndefined<Exclude<Slots[Key], SlotShorthandValue | (Key extends 'root' ? null : never)>>;
-};
-/**
- * This is part of a hack to infer the element type from a native element *props* type.
- * The only place the original element is found in a native props type (at least that's workable
- * for inference) is in the event handlers, so some of the helper types use this event handler
- * name to infer the original element type.
- *
- * Notes:
- * - Using an extremely obscure event handler reduces the likelihood that its signature will be
- *   modified in any component's props.
- * - Inferring based on a single prop name instead of a larger type like `DOMAttributes<T>` should be
- *   less expensive for typescript to evaluate and is less likely to result in type expansion in .d.ts.
- */
-declare type ObscureEventName = 'onLostPointerCaptureCapture';
-/**
- * Return type for `React.forwardRef`, including inference of the proper typing for the ref.
- */
-export declare type ForwardRefComponent<Props> = ObscureEventName extends keyof Props ? Required<Props>[ObscureEventName] extends React.PointerEventHandler<infer Element> ? React.ForwardRefExoticComponent<Props & React.RefAttributes<Element>> : never : never;
-export {};

package/lib-commonjs/hooks/index.d.ts

@@ -1,16 +0,0 @@
-export * from './useControllableState';
-export * from './useBoolean';
-export * from './useConst';
-export * from './useEventCallback';
-export * from './useFirstMount';
-export * from './useId';
-export * from './useIsomorphicLayoutEffect';
-export * from './useMergedEventCallbacks';
-export * from './useMergedRefs';
-export * from './useMount';
-export * from './useOnClickOutside';
-export * from './useOnScrollOutside';
-export * from './usePrevious';
-export * from './useTimeout';
-export * from './useUnmount';
-export * from './useForceUpdate';

package/lib-commonjs/hooks/useBoolean.d.ts

@@ -1,17 +0,0 @@
-/** Updater callbacks returned by `useBoolean`. */
-export declare type UseBooleanCallbacks = {
-    /** Set the value to true. Always has the same identity. */
-    setTrue: () => void;
-    /** Set the value to false. Always has the same identity. */
-    setFalse: () => void;
-    /** Toggle the value. Always has the same identity. */
-    toggle: () => void;
-};
-/**
- * Hook to store a value and generate callbacks for setting the value to true or false.
- * The identity of the callbacks will always stay the same.
- *
- * @param initialState - Initial value
- * @returns Array with the current value and an object containing the updater callbacks.
- */
-export declare function useBoolean(initialState: boolean): [boolean, UseBooleanCallbacks];

package/lib-commonjs/hooks/useBoolean.js

@@ -1,39 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useBoolean = void 0;
-
-const React = /*#__PURE__*/require("react");
-
-const useConst_1 = /*#__PURE__*/require("./useConst");
-/**
- * Hook to store a value and generate callbacks for setting the value to true or false.
- * The identity of the callbacks will always stay the same.
- *
- * @param initialState - Initial value
- * @returns Array with the current value and an object containing the updater callbacks.
- */
-
-
-function useBoolean(initialState) {
-  const [value, setValue] = React.useState(initialState);
-  const setTrue = useConst_1.useConst(() => () => {
-    setValue(true);
-  });
-  const setFalse = useConst_1.useConst(() => () => {
-    setValue(false);
-  });
-  const toggle = useConst_1.useConst(() => () => {
-    setValue(currentValue => !currentValue);
-  });
-  return [value, {
-    setTrue,
-    setFalse,
-    toggle
-  }];
-}
-
-exports.useBoolean = useBoolean;
-//# sourceMappingURL=useBoolean.js.map

package/lib-commonjs/hooks/useBoolean.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/hooks/useBoolean.ts"],"names":[],"mappings":";;;;;;;AAAA,MAAA,KAAA,gBAAA,OAAA,CAAA,OAAA,CAAA;;AACA,MAAA,UAAA,gBAAA,OAAA,CAAA,YAAA,CAAA;AAYA;;;;;;AAMG;;;AACH,SAAgB,UAAhB,CAA2B,YAA3B,EAAgD;AAC9C,QAAM,CAAC,KAAD,EAAQ,QAAR,IAAoB,KAAK,CAAC,QAAN,CAAe,YAAf,CAA1B;AAEA,QAAM,OAAO,GAAG,UAAA,CAAA,QAAA,CAAS,MAAM,MAAK;AAClC,IAAA,QAAQ,CAAC,IAAD,CAAR;AACD,GAFe,CAAhB;AAGA,QAAM,QAAQ,GAAG,UAAA,CAAA,QAAA,CAAS,MAAM,MAAK;AACnC,IAAA,QAAQ,CAAC,KAAD,CAAR;AACD,GAFgB,CAAjB;AAGA,QAAM,MAAM,GAAG,UAAA,CAAA,QAAA,CAAS,MAAM,MAAK;AACjC,IAAA,QAAQ,CAAC,YAAY,IAAI,CAAC,YAAlB,CAAR;AACD,GAFc,CAAf;AAIA,SAAO,CAAC,KAAD,EAAQ;AAAE,IAAA,OAAF;AAAW,IAAA,QAAX;AAAqB,IAAA;AAArB,GAAR,CAAP;AACD;;AAdD,OAAA,CAAA,UAAA,GAAA,UAAA","sourceRoot":""}

package/lib-commonjs/hooks/useConst.d.ts

@@ -1,12 +0,0 @@
-/**
- * Hook to initialize and return a constant value. Unlike `React.useMemo`, this is guaranteed to
- * always return the same value (and if the initializer is a function, only call it once).
- * This is similar to setting a private member in a class constructor.
- *
- * If the value should ever change based on dependencies, use `React.useMemo` instead.
- *
- * @param initialValue - Initial value, or function to get the initial value. Similar to `useState`,
- * only the value/function passed in the first time this is called is respected.
- * @returns The value. The identity of this value will always be the same.
- */
-export declare function useConst<T>(initialValue: T | (() => T)): T;