@react-md/core 1.0.0-next.16 → 1.0.0-next.18

package/src/useLocalStorage.ts

@@ -69,7 +69,7 @@ export interface LocalStorageHookOptions<T> {
 /**
  * @since 6.0.0
  */
-export const defaultLocalStorageSerializer = <T>(value: T): string =>
+export const defaultLocalStorageSerializer = (value: unknown): string =>
   typeof value === "string" ? value : `${value}`;
 
 /** @since 6.0.0 */
@@ -135,7 +135,7 @@ export const getItemFromStorage = <T>(
     key,
     fallback,
     storage = localStorage,
-    deserializer = JSON.parse,
+    deserializer = JSON.parse as LocalStorageDeserializer<T>,
   } = options;
   if (!key) {
     return fallback;
@@ -144,7 +144,7 @@ export const getItemFromStorage = <T>(
   try {
     const value = storage.getItem(key);
     return !value ? fallback : deserializer(value);
-  } catch (e) {
+  } catch {
     return fallback;
   }
 };
@@ -255,7 +255,7 @@ export interface LocalStorageHookReturnValue<T> {
   /**
    * Remove the item from local storage.
    */
-  remove(): void;
+  remove: () => void;
 
   /**
    * Manually persist the current {@link value} into local storage. This is only
@@ -291,7 +291,7 @@ export interface LocalStorageHookReturnValue<T> {
    * }
    * ```
    */
-  persist(): void;
+  persist: () => void;
 }
 
 /**
@@ -456,7 +456,7 @@ export function useLocalStorage<T>(
   const serializer =
     options.serializer ??
     (raw ? defaultLocalStorageSerializer : JSON.stringify);
-  const deserializer =
+  const deserializer: LocalStorageDeserializer<T> =
     options.deserializer ??
     (raw && typeof initialValue === "string" ? identity : JSON.parse);
 

package/src/useMutationObserver.ts

@@ -14,7 +14,7 @@ export interface MutationObserverHookOptions<E extends HTMLElement>
    */
   disabled?: boolean;
 
-  onObserved(mutation: MutationRecord): void;
+  onObserved: (mutation: MutationRecord) => void;
 }
 
 /**

package/src/useOrientation.ts

@@ -40,7 +40,9 @@ export const getOrientationType = (): OrientationType => {
 export function useOrientation(): OrientationType {
   const [orientation, setOrientation] = useState(getOrientationType);
   useEffect(() => {
-    const handler = (): void => setOrientation(getOrientationType());
+    const handler = (): void => {
+      setOrientation(getOrientationType());
+    };
 
     const { orientation } = window.screen;
     if (orientation) {

package/src/usePageInactive.ts

@@ -36,7 +36,7 @@ export interface PageInactiveOptions {
    * This will be called whenever the page activity changes based on the
    * {@link PageInactiveType}.
    */
-  onChange(active: boolean): void;
+  onChange: (active: boolean) => void;
 
   /**
    * This will be fired whenever the {@link disabled} state is `true` which can
@@ -47,7 +47,7 @@ export interface PageInactiveOptions {
    *
    * @defaultValue `() => {}`
    */
-  onDisabledCleanup?(): void;
+  onDisabledCleanup?: () => void;
 }
 
 /**

package/src/useReadonlySet.ts

@@ -0,0 +1,122 @@
+"use client";
+import { useCallback, useState } from "react";
+import { type UseStateSetter, type UseStateInitializer } from "./types.js";
+
+/**
+ * @since 6.0.0
+ */
+export interface ReadonlySetOptions<T> {
+  /**
+   * Sets the behavior for when the
+   * {@link ReadonlySetImplementation.toggleValue} is triggered and mostly for
+   * internal usage. The default behavior (`"multiple"`) is to work how most
+   * would expect:
+   * - If the item does not exist in the set, add it.
+   * - If the item exists in the set, remove it.
+   *
+   * Setting this to `"single"` makes it so that only a single item can be in
+   * the set at once and will toggle like normal:
+   * - If the item does not exist in the set, return a new set only including
+   *   the item.
+   * - If the item exists in the set, return an empty set.
+   * An example usage is the `useExpansionPanels` to allow only a single panel
+   * to be expanded at a time.
+   *
+   * Setting this to `"single-select"` makes it so that only a single item can
+   * be in the set at once but will not toggle:
+   * - If the item does not exist in the set, return a new set only including
+   *   the item.
+   * - If the item exists in the set, do nothing
+   * An example usage is the `useTreeSelection` to always require at least one
+   * tree item to be selected. It is impossible to deselect an item.
+   *
+   * @defaultValue `"multiple"`
+   */
+  toggleType?: "single" | "multiple" | "single-select";
+  defaultValue?: UseStateInitializer<ReadonlySet<T> | readonly T[]>;
+}
+
+/**
+ * @since 6.0.0
+ */
+export interface ReadonlySetImplementation<T> {
+  value: ReadonlySet<T>;
+  setValue: UseStateSetter<ReadonlySet<T>>;
+  toggleValue: (item: T) => void;
+}
+
+/**
+ * This is most likely an internal only hook to manage state for a
+ * `ReadonlySet`. You most likely want to use one of the other hooks that
+ * leverage this instead:
+ *
+ * - `useCheckboxGroup`
+ * - `useExpansionPanels`
+ * - `useTreeSelection`
+ * - `useTreeExpansion`
+ * - etc
+ *
+ * @example Simple Example
+ * ```tsx
+ * import { cnb } from "cnbuilder";
+ * import { useReadonlySet } from "@react-md/core/useReadonlySet";
+ *
+ * function Example() {
+ *   const { value, toggleValue } = useReadonlySet();
+ *
+ *   return (
+ *     <>
+ *       {someList.map((item) => (
+ *         <div key={item.id} className={cnb(value.has(item.id) && styles.selected)}>
+ *           {item.name}
+ *           <Button onClick={() => toggleValue(item.id)}>Button</Button>
+ *         </div>
+ *       ))}
+ *     </>
+ *   );
+ * }
+ * ```
+ * @since 6.0.0
+ */
+export function useReadonlySet<T>(
+  options: ReadonlySetOptions<T> = {}
+): ReadonlySetImplementation<T> {
+  const { defaultValue, toggleType = "multiple" } = options;
+  const [value, setValue] = useState<ReadonlySet<T>>(() => {
+    const initial =
+      defaultValue instanceof Function ? defaultValue() : (defaultValue ?? []);
+
+    return new Set(initial);
+  });
+
+  const toggleValue = useCallback(
+    (item: T) => {
+      setValue((prevValue) => {
+        const exists = prevValue.has(item);
+        if (toggleType === "single") {
+          return new Set(exists ? [] : [item]);
+        }
+
+        if (toggleType === "single-select") {
+          return exists ? prevValue : new Set([item]);
+        }
+
+        const nextValue = new Set(prevValue);
+        if (exists) {
+          nextValue.delete(item);
+        } else {
+          nextValue.add(item);
+        }
+
+        return nextValue;
+      });
+    },
+    [toggleType]
+  );
+
+  return {
+    value,
+    setValue,
+    toggleValue,
+  };
+}

package/src/useResizeListener.ts

@@ -33,7 +33,7 @@ export interface ResizeListenerOptions extends AddEventListenerOptions {
    * This function will be called whenever the resize event is fired on the
    * `window`. This should be wrapped in `useCallback`.
    */
-  onUpdate(event: Event): void;
+  onUpdate: (event: Event) => void;
 }
 
 /**

package/src/useResizeObserver.ts

@@ -194,6 +194,25 @@ export interface ResizeObserverHookOptions<E extends HTMLElement> {
  * For most cases you can use the {@link useElementSize} instead, but this hook
  * can be used for more complex behavior with the {@link ResizeObserverEntry}.
  *
+ * @example Simple Example
+ * ```tsx
+ * import { useResizeObserver } from "@react-md/core/useResizeObserver";
+ * import { useCallback, useState, type ReactElement } from "react";
+ *
+ * function Example(): ReactElement {
+ *   const elementRef = useResizeObserver({
+ *     onUpdate: useCallback((entry) => {
+ *       const element = entry.target;
+ *       const { height, width } = entry.contentRect;
+ *       const { inlineSize, blockSize } = entry.borderBoxSize[0]O
+ *       // do something
+ *     }, []),
+ *   });
+ *
+ *   return <div ref={elementRef}>{...whatever...}</div>
+ * }
+ * ```
+ *
  * @since 2.3.0
  * @since 6.0.0 The API was updated to match the `useIntersectionObserver`
  * implementation -- accepts only a single object parameter and returns a

package/src/useThrottledFunction.ts

@@ -1,15 +1,8 @@
 "use client";
 import { useEffect, useMemo, useRef } from "react";
-import { type AnyFunction, type CancelableFunction } from "./types.js";
+import { type AnyFunction, type ThrottledFunction } from "./types.js";
 import { useIsomorphicLayoutEffect } from "./useIsomorphicLayoutEffect.js";
 
-/**
- * @since 6.0.0
- */
-export type ThrottledFunction<F extends AnyFunction> = CancelableFunction<
-  (...args: Parameters<F>) => ReturnType<F>
->;
-
 /**
  * Creates a function that will only be called once every X milliseconds.
  *
@@ -113,19 +106,23 @@ export function useThrottledFunction<F extends AnyFunction>(
       const remaining = wait - (now - lastCalledTime.current);
       if (remaining <= 0 || remaining > wait) {
         lastCalledTime.current = now;
+
         result.current = funcRef.current(...args.current);
       } else if (!timeout.current) {
         timeout.current = window.setTimeout(() => {
           lastCalledTime.current = Date.now();
           timeout.current = undefined;
           // should exist by this time
+
           result.current = funcRef.current(...(args.current as Parameters<F>));
         }, remaining);
       }
 
       return result.current as ReturnType<F>;
     };
-    throttled.cancel = () => window.clearTimeout(timeout.current);
+    throttled.cancel = () => {
+      window.clearTimeout(timeout.current);
+    };
 
     return throttled;
   }, [wait]);

package/src/useToggle.ts

@@ -8,9 +8,9 @@ import { type UseStateInitializer, type UseStateSetter } from "./types.js";
 export interface ToggleImplementation {
   toggled: boolean;
   setToggled: UseStateSetter<boolean>;
-  toggle(): void;
-  enable(): void;
-  disable(): void;
+  toggle: () => void;
+  enable: () => void;
+  disable: () => void;
 }
 
 /**

package/src/utils/RenderRecursively.tsx

@@ -95,9 +95,9 @@ export interface RenderRecursivelyProps<
    * ```
    *
    * @see {@link getRecursiveItemKey}
-   * @defaultValue `({ index, depth }) => ${depth}-${index}`.
+   * @defaultValue `` ({ index, depth }) => `${depth}-${index}` ``
    */
-  getItemKey?(options: RecursiveItemKeyOptions<Item>): string;
+  getItemKey?: (options: RecursiveItemKeyOptions<Item>) => string;
 }
 
 /**

package/src/utils/alphaNumericSort.ts

@@ -25,9 +25,9 @@ export interface AlphaNumericSortOptions<T> {
    *
    * const items: Item[] = [{ name: 'Hello' }, { name: 'World' }];
    *
-   * `alphaNumericSort(items, {
-   *   extractor: item => item.name,
-   * })`
+   * alphaNumericSort(items, {
+   *   extractor: (item) => item.name,
+   * });
    * ```
    *
    * For javascript developers, this will throw an error in dev mode if an
@@ -58,7 +58,7 @@ export interface AlphaNumericSortOptions<T> {
    * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator/Collator
    * @defaultValue `new Intl.Collator("en-US", { numeric: true, caseFirst: "upper" }).compare`
    */
-  compare?(a: string, b: string): number;
+  compare?: (a: string, b: string) => number;
 
   /**
    * Setting this to `true` will return the list in descending order instead of
@@ -95,7 +95,7 @@ export function alphaNumericSort<T extends string>(
  * const items: Item[] = [{ name: "World" }, { name: "Hello" }];
  *
  * const sorted = alphaNumericSort(items, {
- *   extractor: item => item.name,
+ *   extractor: (item) => item.name,
  * });
  * // sorted == [{ name: "Hello" }, { name: "World" }]
  * ```

package/src/utils/bem.ts

@@ -26,7 +26,7 @@ export type BEMResult = (
  * Applies the BEM styled class name to an element.
  *
  * @example Simple Example
- * ```jsx
+ * ```tsx
  * import { bem } from "@react-md/core":
  *
  * const styles = bem("my-component"):

package/src/utils/debounce.ts

@@ -0,0 +1,22 @@
+import { type AnyFunction, type DebouncedFunction } from "../types.js";
+
+/**
+ * @since 6.0.0
+ */
+export function debounce<F extends AnyFunction>(
+  fn: F,
+  duration: number
+): DebouncedFunction<F> {
+  let timeout: NodeJS.Timeout | undefined;
+  const debounced: DebouncedFunction<F> = (...args) => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => {
+      fn(...args);
+    }, duration);
+  };
+  debounced.cancel = () => {
+    clearTimeout(timeout);
+  };
+
+  return debounced;
+}

package/src/utils/throttle.ts

@@ -0,0 +1,38 @@
+import { type AnyFunction, type ThrottledFunction } from "../types.js";
+
+/**
+ * @since 6.0.0
+ */
+export function throttle<F extends AnyFunction>(
+  fn: F,
+  wait: number
+): ThrottledFunction<F> {
+  let args: Parameters<F>;
+  let result: ReturnType<F>;
+  let timeout: NodeJS.Timeout | undefined;
+  let lastCalledTime = 0;
+
+  const throttled: ThrottledFunction<F> = (...nextArgs) => {
+    args = nextArgs;
+
+    const now = Date.now();
+    const remaining = wait - (now - lastCalledTime);
+    if (remaining <= 0 || remaining > wait) {
+      lastCalledTime = now;
+      result = fn(...args);
+    } else if (!timeout) {
+      timeout = setTimeout(() => {
+        lastCalledTime = Date.now();
+        timeout = undefined;
+        result = fn(...args);
+      }, remaining);
+    }
+
+    return result;
+  };
+  throttled.cancel = () => {
+    clearTimeout(timeout);
+  };
+
+  return throttled;
+}

package/src/utils/wait.ts

@@ -14,4 +14,8 @@
  * @since 6.0.0
  */
 export const wait = (ms: number): Promise<void> =>
-  new Promise((resolve) => setTimeout(() => resolve(), ms));
+  new Promise((resolve) =>
+    setTimeout(() => {
+      resolve();
+    }, ms)
+  );

package/src/window-splitter/WindowSplitter.tsx

@@ -1,51 +1,10 @@
-import { cnb } from "cnbuilder";
 import { forwardRef, type ButtonHTMLAttributes } from "react";
 import { type LabelRequiredForA11y } from "../types.js";
-import { bem } from "../utils/bem.js";
+import { windowSplitter } from "./styles.js";
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 import { type useWindowSplitter } from "./useWindowSplitter.js";
 
-const styles = bem("rmd-window-splitter");
-
-/**
- * @since 6.0.0
- */
-export interface WindowSplitterClassNameOptions {
-  className?: string;
-  dragging?: boolean;
-  reversed?: boolean;
-  vertical?: boolean;
-  disableFixed?: boolean;
-}
-
-/**
- * @since 6.0.0
- */
-export function windowSplitter(
-  options: WindowSplitterClassNameOptions = {}
-): string {
-  const {
-    vertical = false,
-    dragging,
-    reversed,
-    disableFixed,
-    className,
-  } = options;
-
-  return cnb(
-    styles({
-      h: !vertical,
-      hr: !vertical && reversed,
-      v: vertical,
-      vr: vertical && reversed,
-      a: disableFixed,
-      dragging,
-    }),
-    className
-  );
-}
-
 /**
  * @since 6.0.0
  * @see {@link https://www.w3.org/WAI/ARIA/apg/patterns/windowsplitter/}
@@ -85,7 +44,43 @@ export type WindowSplitterProps = LabelRequiredForA11y<BaseWindowSplitterProps>;
  * The `WindowSplitter` should be used with the `useWindowSplitter` hook to
  * resize parts of a layout.
  *
- * @see {@link useWindowSplitter} for an example usage
+ * See the `useResizableLayout` hook if the entire page layout should be
+ * resizable.
+ *
+ * @example Simple Example
+ * ```tsx
+ * "use client";
+ * import { WindowSplitter } from "@react-md/core/window-splitter/WindowSplitter";
+ * import { useWindowSplitter } from "@react-md/core/window-splitter/useWindowSplitter";
+ * import { useId, type ReactElement } from "react";
+ *
+ * export function Example(): ReactElement {
+ *   const panelId = useId();
+ *   const { value, splitterProps } = useWindowSplitter({
+ *     min: 120,
+ *     max: 380,
+ *   });
+ *
+ *   return (
+ *     <div
+ *       style={{
+ *         "--rmd-window-splitter-position": `${value}px`,
+ *         display: "grid",
+ *         gridTemplateColumns: "var(--rmd-window-splitter-position, 120px) 1fr",
+ *       }}
+ *     >
+ *       <div>Panel 1</div>
+ *       <WindowSplitter
+ *         {...splitterProps}
+ *         aria-controls={panelId}
+ *         aria-labelledby={panelId}
+ *       />
+ *       <div>Panel 2</div>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
  * @since 6.0.0
  */
 export const WindowSplitter = forwardRef<

package/src/window-splitter/styles.ts

@@ -0,0 +1,42 @@
+import { cnb } from "cnbuilder";
+import { bem } from "../utils/bem.js";
+
+const styles = bem("rmd-window-splitter");
+
+/**
+ * @since 6.0.0
+ */
+export interface WindowSplitterClassNameOptions {
+  className?: string;
+  dragging?: boolean;
+  reversed?: boolean;
+  vertical?: boolean;
+  disableFixed?: boolean;
+}
+
+/**
+ * @since 6.0.0
+ */
+export function windowSplitter(
+  options: WindowSplitterClassNameOptions = {}
+): string {
+  const {
+    vertical = false,
+    dragging,
+    reversed,
+    disableFixed,
+    className,
+  } = options;
+
+  return cnb(
+    styles({
+      h: !vertical,
+      hr: !vertical && reversed,
+      v: vertical,
+      vr: vertical && reversed,
+      a: disableFixed,
+      dragging,
+    }),
+    className
+  );
+}

package/dist/autocomplete/FilterAutocompleteOptions.d.ts

@@ -1,8 +0,0 @@
-import { type ReactElement, type RefObject } from "react";
-import { type EditableHTMLElement } from "../form/utils.js";
-import { type AutocompleteOptionsProps } from "./types.js";
-export interface FilterAutocompleteOptionsProps<T> extends AutocompleteOptionsProps<T> {
-    query: string;
-    comboboxRef: RefObject<EditableHTMLElement>;
-}
-export declare function FilterAutocompleteOptions<T>(props: FilterAutocompleteOptionsProps<T>): ReactElement;

package/dist/autocomplete/FilterAutocompleteOptions.js

@@ -1,57 +0,0 @@
-"use client";
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useMemo } from "react";
-import { triggerManualChangeEvent } from "../form/utils.js";
-import { ListSubheader } from "../list/ListSubheader.js";
-import { MenuItem } from "../menu/MenuItem.js";
-import { defaultAutocompleteExtractor, defaultAutocompleteFilter, defaultAutocompleteOptionProps } from "./defaults.js";
-const noop = ()=>{
-// do nothing
-};
-export function FilterAutocompleteOptions(props) {
-    const { query, filter = defaultAutocompleteFilter, options, extractor = defaultAutocompleteExtractor, whitespace = "keep", comboboxRef, disableFilter, onAutocomplete = noop, getOptionProps = defaultAutocompleteOptionProps, clearOnAutocomplete, noOptionsChildren = /*#__PURE__*/ _jsx(ListSubheader, {
-        children: "No Options"
-    }) } = props;
-    const filtered = useMemo(()=>{
-        if (disableFilter) {
-            return options;
-        }
-        return filter({
-            list: options,
-            query,
-            extractor,
-            whitespace
-        });
-    }, [
-        disableFilter,
-        extractor,
-        filter,
-        options,
-        query,
-        whitespace
-    ]);
-    return /*#__PURE__*/ _jsxs(_Fragment, {
-        children: [
-            !filtered.length && noOptionsChildren,
-            filtered.map((option, index)=>{
-                const label = extractor(option);
-                const optionProps = getOptionProps({
-                    index,
-                    option
-                });
-                return /*#__PURE__*/ _jsx(MenuItem, {
-                    role: "option",
-                    ...optionProps,
-                    onClick: (event)=>{
-                        optionProps?.onClick?.(event);
-                        triggerManualChangeEvent(comboboxRef.current, clearOnAutocomplete ? "" : label);
-                        onAutocomplete(option);
-                    },
-                    children: optionProps?.children ?? label
-                }, label);
-            })
-        ]
-    });
-}
-
-//# sourceMappingURL=FilterAutocompleteOptions.js.map

package/dist/autocomplete/FilterAutocompleteOptions.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/autocomplete/FilterAutocompleteOptions.tsx"],"sourcesContent":["\"use client\";\nimport { useMemo, type ReactElement, type RefObject } from \"react\";\nimport {\n  triggerManualChangeEvent,\n  type EditableHTMLElement,\n} from \"../form/utils.js\";\nimport { ListSubheader } from \"../list/ListSubheader.js\";\nimport { MenuItem } from \"../menu/MenuItem.js\";\nimport {\n  defaultAutocompleteExtractor,\n  defaultAutocompleteFilter,\n  defaultAutocompleteOptionProps,\n} from \"./defaults.js\";\nimport { type AutocompleteOptionsProps } from \"./types.js\";\n\nconst noop = (): void => {\n  // do nothing\n};\n\nexport interface FilterAutocompleteOptionsProps<T>\n  extends AutocompleteOptionsProps<T> {\n  query: string;\n  comboboxRef: RefObject<EditableHTMLElement>;\n}\n\nexport function FilterAutocompleteOptions<T>(\n  props: FilterAutocompleteOptionsProps<T>\n): ReactElement {\n  const {\n    query,\n    filter = defaultAutocompleteFilter,\n    options,\n    extractor = defaultAutocompleteExtractor,\n    whitespace = \"keep\",\n    comboboxRef,\n    disableFilter,\n    onAutocomplete = noop,\n    getOptionProps = defaultAutocompleteOptionProps,\n    clearOnAutocomplete,\n    noOptionsChildren = <ListSubheader>No Options</ListSubheader>,\n  } = props;\n  const filtered = useMemo(() => {\n    if (disableFilter) {\n      return options;\n    }\n\n    return filter({\n      list: options,\n      query,\n      extractor,\n      whitespace,\n    });\n  }, [disableFilter, extractor, filter, options, query, whitespace]);\n\n  return (\n    <>\n      {!filtered.length && noOptionsChildren}\n      {filtered.map((option, index) => {\n        const label = extractor(option);\n        const optionProps = getOptionProps({\n          index,\n          option,\n        });\n\n        return (\n          <MenuItem\n            key={label}\n            role=\"option\"\n            {...optionProps}\n            onClick={(event) => {\n              optionProps?.onClick?.(event);\n\n              triggerManualChangeEvent(\n                comboboxRef.current,\n                clearOnAutocomplete ? \"\" : label\n              );\n              onAutocomplete(option);\n            }}\n          >\n            {optionProps?.children ?? label}\n          </MenuItem>\n        );\n      })}\n    </>\n  );\n}\n"],"names":["useMemo","triggerManualChangeEvent","ListSubheader","MenuItem","defaultAutocompleteExtractor","defaultAutocompleteFilter","defaultAutocompleteOptionProps","noop","FilterAutocompleteOptions","props","query","filter","options","extractor","whitespace","comboboxRef","disableFilter","onAutocomplete","getOptionProps","clearOnAutocomplete","noOptionsChildren","filtered","list","length","map","option","index","label","optionProps","role","onClick","event","current","children"],"mappings":"AAAA;;AACA,SAASA,OAAO,QAA2C,QAAQ;AACnE,SACEC,wBAAwB,QAEnB,mBAAmB;AAC1B,SAASC,aAAa,QAAQ,2BAA2B;AACzD,SAASC,QAAQ,QAAQ,sBAAsB;AAC/C,SACEC,4BAA4B,EAC5BC,yBAAyB,EACzBC,8BAA8B,QACzB,gBAAgB;AAGvB,MAAMC,OAAO;AACX,aAAa;AACf;AAQA,OAAO,SAASC,0BACdC,KAAwC;IAExC,MAAM,EACJC,KAAK,EACLC,SAASN,yBAAyB,EAClCO,OAAO,EACPC,YAAYT,4BAA4B,EACxCU,aAAa,MAAM,EACnBC,WAAW,EACXC,aAAa,EACbC,iBAAiBV,IAAI,EACrBW,iBAAiBZ,8BAA8B,EAC/Ca,mBAAmB,EACnBC,kCAAoB,KAAClB;kBAAc;MAA0B,EAC9D,GAAGO;IACJ,MAAMY,WAAWrB,QAAQ;QACvB,IAAIgB,eAAe;YACjB,OAAOJ;QACT;QAEA,OAAOD,OAAO;YACZW,MAAMV;YACNF;YACAG;YACAC;QACF;IACF,GAAG;QAACE;QAAeH;QAAWF;QAAQC;QAASF;QAAOI;KAAW;IAEjE,qBACE;;YACG,CAACO,SAASE,MAAM,IAAIH;YACpBC,SAASG,GAAG,CAAC,CAACC,QAAQC;gBACrB,MAAMC,QAAQd,UAAUY;gBACxB,MAAMG,cAAcV,eAAe;oBACjCQ;oBACAD;gBACF;gBAEA,qBACE,KAACtB;oBAEC0B,MAAK;oBACJ,GAAGD,WAAW;oBACfE,SAAS,CAACC;wBACRH,aAAaE,UAAUC;wBAEvB9B,yBACEc,YAAYiB,OAAO,EACnBb,sBAAsB,KAAKQ;wBAE7BV,eAAeQ;oBACjB;8BAECG,aAAaK,YAAYN;mBAbrBA;YAgBX;;;AAGN"}

package/dist/dialog/DialogContainer.d.ts

@@ -1,14 +0,0 @@
-import { type HTMLAttributes, type ReactElement, type ReactNode } from "react";
-/**
- * @since 6.0.0
- * @internal
- */
-export interface DialogContainerProps extends HTMLAttributes<HTMLDivElement> {
-    enabled: boolean;
-    children: ReactNode;
-}
-/**
- * @since 6.0.0
- * @internal
- */
-export declare function DialogContainer(props: DialogContainerProps): ReactElement;