@gamecrafters/base-ui 0.0.1

package/build/components/tree-view/index.d.ts

@@ -0,0 +1,37 @@
+import TreeViewDirectoryIcon from "./TreeViewDirectoryIcon";
+import TreeViewErrorDialog from "./TreeViewErrorDialog";
+import TreeViewItem from "./TreeViewItem";
+import TreeViewLeadingAction from "./TreeViewLeadingAction";
+import TreeViewLeadingVisual from "./TreeViewLeadingVisual";
+import TreeViewSubTree from "./TreeViewSubTree";
+import TreeViewTrailingVisual from "./TreeViewTrailingVisual";
+export declare const TreeView: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & {
+    children?: React.ReactNode;
+    flat?: boolean;
+    truncate?: boolean;
+    className?: string;
+} & import("react").RefAttributes<any>> & {
+    Item: <As extends React.ElementType = "li">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").PropsWithoutRef<import("react").ComponentProps<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements> extends As ? "li" : As>>, "as" | "onSelect"> & {
+        id: string;
+        children?: React.ReactNode;
+        current?: boolean;
+        defaultExpanded?: boolean;
+        expanded?: boolean | null;
+        onExpandedChange?: (expanded: boolean) => void;
+        onSelect?: (event: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>) => void;
+        containIntrinsicSize?: string;
+        secondaryActions?: import("./TreeView.types").TreeViewSecondaryAction[];
+        className?: string;
+    } & {
+        as?: As | undefined;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    SubTree: typeof TreeViewSubTree;
+    LeadingAction: typeof TreeViewLeadingAction;
+    LeadingVisual: typeof TreeViewLeadingVisual;
+    TrailingVisual: typeof TreeViewTrailingVisual;
+    DirectoryIcon: typeof TreeViewDirectoryIcon;
+    ErrorDialog: typeof TreeViewErrorDialog;
+};
+export { TreeViewItem, TreeViewSubTree, TreeViewLeadingAction, TreeViewLeadingVisual, TreeViewTrailingVisual, TreeViewDirectoryIcon, TreeViewErrorDialog, };
+export { TreeViewRootContext, TreeViewItemContext } from "./TreeViewContext";
+export * from "./TreeView.types";

package/build/components/tree-view/treeNavigation.d.ts

@@ -0,0 +1,8 @@
+export declare const getAccessibleName: (element: Element) => string;
+export declare const getItemState: (element: HTMLElement) => "end" | "closed" | "open";
+export declare const getFirstChildItem: (element: HTMLElement) => HTMLElement | undefined;
+export declare const getParentItem: (element: HTMLElement) => HTMLElement | undefined;
+export declare const getFirstItem: (element: HTMLElement) => HTMLElement | undefined;
+export declare const getLastItem: (element: HTMLElement) => HTMLElement | undefined;
+export declare const getVisibleItem: (element: HTMLElement, direction: "next" | "previous") => HTMLElement | undefined;
+export declare const getNextFocusableItem: (element: HTMLElement, key: string) => HTMLElement | undefined;

package/build/components/tree-view/useRovingTabIndex.d.ts

@@ -0,0 +1,5 @@
+import type * as React from "react";
+export type RovingTabIndexOptions = {
+    containerRef: React.RefObject<HTMLElement | null>;
+};
+export declare const useRovingTabIndex: ({ containerRef }: RovingTabIndexOptions) => void;

package/build/components/tree-view/useTypeahead.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+export type TypeaheadOptions = {
+    containerRef: React.RefObject<HTMLElement | null>;
+    onFocusChange: (element: HTMLElement) => void;
+};
+export declare const useTypeahead: ({ containerRef, onFocusChange }: TypeaheadOptions) => void;

package/build/components/truncate/Truncate.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+export declare const DEFAULT_TRUNCATE_MAX_WIDTH = 125;
+declare const _default: <As extends React.ElementType = "div">(props: import("../../utilities/polymorphic").DistributiveOmit<React.ComponentPropsWithRef<React.ElementType extends As ? "div" : As> & {
+    title: string;
+    maxWidth?: number | string;
+    inline?: boolean;
+    expandable?: boolean;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/truncate/Truncate.types.d.ts

@@ -0,0 +1,9 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+export type TruncateProps<As extends React.ElementType = "div"> = PolymorphicProps<As, "div", {
+    title: string;
+    maxWidth?: number | string;
+    inline?: boolean;
+    expandable?: boolean;
+    className?: string;
+}>;

package/build/components/truncate/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Truncate, DEFAULT_TRUNCATE_MAX_WIDTH } from "./Truncate";
+export * from "./Truncate.types";

package/build/components/upload/Upload.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+import type { UploadSize, UploadSource, UploadValidationStatus } from "./Upload.types";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "onSelect"> & {
+    size?: UploadSize;
+    accept?: string;
+    multiple?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    maxSize?: number;
+    validationStatus?: UploadValidationStatus;
+    onSelect?: (files: File[], source: UploadSource) => void;
+    onReject?: (rejections: import("./Upload.types").UploadRejection[], source: UploadSource) => void;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/upload/Upload.types.d.ts

@@ -0,0 +1,51 @@
+import type * as React from "react";
+export type UploadSize = "small" | "medium" | "large";
+export type UploadValidationStatus = "error" | "success";
+export type UploadSource = "input" | "drop";
+export type UploadRejectionReason = "type" | "size" | "count";
+export type UploadRejection = {
+    file: File;
+    reason: UploadRejectionReason;
+};
+export type UploadItemStatus = "pending" | "uploading" | "success" | "error";
+export type UploadProps = Omit<React.ComponentPropsWithoutRef<"div">, "onSelect"> & {
+    size?: UploadSize;
+    accept?: string;
+    multiple?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    maxSize?: number;
+    validationStatus?: UploadValidationStatus;
+    onSelect?: (files: File[], source: UploadSource) => void;
+    onReject?: (rejections: UploadRejection[], source: UploadSource) => void;
+    className?: string;
+};
+export type UploadIconProps = React.ComponentPropsWithoutRef<"span"> & {
+    icon?: React.ElementType;
+    className?: string;
+};
+export type UploadLabelProps = React.ComponentPropsWithoutRef<"span"> & {
+    className?: string;
+};
+export type UploadDescriptionProps = React.ComponentPropsWithoutRef<"span"> & {
+    className?: string;
+};
+export type UploadListProps = React.ComponentPropsWithoutRef<"ul"> & {
+    className?: string;
+};
+export type UploadItemProps = React.ComponentPropsWithoutRef<"li"> & {
+    name: string;
+    fileSize?: number;
+    status?: UploadItemStatus;
+    progress?: number;
+    description?: React.ReactNode;
+    icon?: React.ElementType;
+    onRemove?: (event: React.MouseEvent<HTMLButtonElement>) => void;
+    removeLabel?: string;
+    className?: string;
+};
+export type UploadContextValue = {
+    labelId?: string;
+    descriptionId?: string;
+};

package/build/components/upload/UploadContext.d.ts

@@ -0,0 +1,2 @@
+import type { UploadContextValue } from "./Upload.types";
+export declare const UploadContext: import("react").Context<UploadContextValue>;

package/build/components/upload/UploadDescription.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/upload/UploadIcon.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    icon?: React.ElementType;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/upload/UploadItem.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & {
+    name: string;
+    fileSize?: number;
+    status?: import("./Upload.types").UploadItemStatus;
+    progress?: number;
+    description?: React.ReactNode;
+    icon?: React.ElementType;
+    onRemove?: (event: React.MouseEvent<HTMLButtonElement>) => void;
+    removeLabel?: string;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/upload/UploadLabel.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/upload/UploadList.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/upload/files.d.ts

@@ -0,0 +1,13 @@
+import type { UploadRejection } from "./Upload.types";
+export declare const formatFileSize: (bytes: number) => string;
+export declare const isFileAccepted: (file: File, accept?: string) => boolean;
+export type FileTriage = {
+    accepted: File[];
+    rejected: UploadRejection[];
+};
+export type FileTriageOptions = {
+    accept?: string;
+    maxSize?: number;
+    multiple?: boolean;
+};
+export declare const triageFiles: (files: File[], options: FileTriageOptions) => FileTriage;

package/build/components/upload/index.d.ts

@@ -0,0 +1,48 @@
+import UploadDescription from "./UploadDescription";
+import UploadIcon from "./UploadIcon";
+import UploadItem from "./UploadItem";
+import UploadLabel from "./UploadLabel";
+import UploadList from "./UploadList";
+export declare const Upload: ((props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "onSelect"> & {
+    size?: import("./Upload.types").UploadSize;
+    accept?: string;
+    multiple?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    maxSize?: number;
+    validationStatus?: import("./Upload.types").UploadValidationStatus;
+    onSelect?: (files: File[], source: import("./Upload.types").UploadSource) => void;
+    onReject?: (rejections: import("./Upload.types").UploadRejection[], source: import("./Upload.types").UploadSource) => void;
+    className?: string;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Icon: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        icon?: React.ElementType;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Label: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Description: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    List: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Item: (props: Omit<import("react").DetailedHTMLProps<import("react").LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & {
+        name: string;
+        fileSize?: number;
+        status?: import("./Upload.types").UploadItemStatus;
+        progress?: number;
+        description?: React.ReactNode;
+        icon?: React.ElementType;
+        onRemove?: (event: React.MouseEvent<HTMLButtonElement>) => void;
+        removeLabel?: string;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { UploadIcon, UploadLabel, UploadDescription, UploadList, UploadItem };
+export { UploadContext } from "./UploadContext";
+export { formatFileSize, isFileAccepted, triageFiles } from "./files";
+export type { FileTriage, FileTriageOptions } from "./files";
+export * from "./Upload.types";

package/build/hooks/useFocusTrap.d.ts

@@ -0,0 +1,8 @@
+import type * as React from "react";
+export type FocusTrapOptions = {
+    containerRef: React.RefObject<HTMLElement | null>;
+    initialFocusRef?: React.RefObject<HTMLElement | null>;
+    returnFocusRef?: React.RefObject<HTMLElement | null>;
+    disabled?: boolean;
+};
+export declare const useFocusTrap: ({ containerRef, initialFocusRef, returnFocusRef, disabled, }: FocusTrapOptions) => void;

package/build/hooks/useFocusZone.d.ts

@@ -0,0 +1,10 @@
+import type * as React from "react";
+export type FocusZoneDirection = "vertical" | "horizontal";
+export type FocusZoneOptions = {
+    containerRef: React.RefObject<HTMLElement | null>;
+    direction?: FocusZoneDirection;
+    wrap?: boolean;
+    disabled?: boolean;
+    focusableFilter?: (element: HTMLElement) => boolean;
+};
+export declare const useFocusZone: ({ containerRef, direction, wrap, disabled, focusableFilter, }: FocusZoneOptions) => void;

package/build/hooks/useId.d.ts

@@ -0,0 +1 @@
+export declare const useId: (id?: string) => string;

package/build/hooks/useIsClipped.d.ts

@@ -0,0 +1,7 @@
+import type * as React from "react";
+export type IsClippedOptions = {
+    ref: React.RefObject<HTMLElement | null>;
+    rootRef: React.RefObject<HTMLElement | null>;
+    disabled?: boolean;
+};
+export declare const useIsClipped: ({ ref, rootRef, disabled }: IsClippedOptions) => boolean;

package/build/hooks/useIsomorphicLayoutEffect.d.ts

@@ -0,0 +1,2 @@
+import { useEffect } from "react";
+export declare const useIsomorphicLayoutEffect: typeof useEffect;

package/build/hooks/useMergedRefs.d.ts

@@ -0,0 +1,8 @@
+import type { ForwardedRef, Ref as StandardRef } from "react";
+export declare const useMergedRefs: <T>(refA: Ref<T | null>, refB: Ref<T | null>) => (value: T | null) => (() => void) | undefined;
+type CleanupFunction = () => void;
+type React19RefCallback<T> = {
+    bivarianceHack(instance: T): void | CleanupFunction;
+}["bivarianceHack"];
+type Ref<T> = ForwardedRef<T> | React19RefCallback<T> | StandardRef<T> | undefined;
+export {};

package/build/hooks/useOnEscapePress.d.ts

@@ -0,0 +1,2 @@
+export type EscapeHandler = (event: KeyboardEvent) => void;
+export declare const useOnEscapePress: (onEscape: EscapeHandler) => void;

package/build/hooks/useOverflow.d.ts

@@ -0,0 +1,2 @@
+import type * as React from "react";
+export declare const useOverflow: <T extends HTMLElement>(ref: React.RefObject<T | null>) => boolean;

package/build/hooks/useResponsive.d.ts

@@ -0,0 +1,18 @@
+export type MediaQueryFeatures = {
+    [key: string]: boolean | undefined;
+};
+export type ResponsiveValue<TRegular, TNarrow = TRegular, TWide = TRegular> = {
+    narrow?: TNarrow;
+    regular?: TRegular;
+    wide?: TWide;
+};
+export type FlattenResponsiveValue<T> = (T extends ResponsiveValue<infer TRegular, infer TNarrow, infer TWide> ? TRegular | TNarrow | TWide : never) | Exclude<T, ResponsiveValue<any>>;
+export declare const MatchMediaContext: import("react").Context<MediaQueryFeatures>;
+export declare const viewportRanges: {
+    narrow: string;
+    regular: string;
+    wide: string;
+};
+export declare const isResponsiveValue: (value: any) => value is ResponsiveValue<any>;
+export declare const useMedia: (mediaQueryString: string, defaultState?: boolean) => boolean;
+export declare const useResponsiveValue: <T, F>(value: T, fallback: F) => FlattenResponsiveValue<T> | F;

package/build/hooks/useScrollLock.d.ts

@@ -0,0 +1 @@
+export declare const useScrollLock: (disabled?: boolean) => void;

package/build/hooks/useSlots.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+type Props = any;
+type ComponentMatcher = React.ElementType<Props>;
+type ComponentAndPropsMatcher = [ComponentMatcher, (props: Props) => boolean];
+export type SlotConfig = Record<string, ComponentMatcher | ComponentAndPropsMatcher>;
+type SlotElements<Config extends SlotConfig> = {
+    [Property in keyof Config]: SlotValue<Config, Property>;
+};
+type SlotValue<Config, Property extends keyof Config> = Config[Property] extends React.ElementType ? React.ReactElement<React.ComponentPropsWithoutRef<Config[Property]>, Config[Property]> : Config[Property] extends readonly [
+    infer ElementType extends React.ElementType,
+    infer _testFn
+] ? React.ReactElement<React.ComponentPropsWithoutRef<ElementType>, ElementType> : never;
+export declare const useSlots: <Config extends SlotConfig>(children: React.ReactNode, config: Config) => [Partial<SlotElements<Config>>, React.ReactNode[]];
+export {};

package/build/hooks/useSyncedState.d.ts

@@ -0,0 +1,4 @@
+export declare const useSyncedState: <T>(initialValue: T | (() => T), { isPropUpdateDisabled, isEqual }?: {
+    isPropUpdateDisabled?: boolean | undefined;
+    isEqual?: ((value1: any, value2: any) => boolean) | undefined;
+}) => readonly [T, import("react").Dispatch<import("react").SetStateAction<T>>];