mainbase-ui 1.2.5 → 3.37.0

package/dist/types/components/carousel/namespace.d.ts

@@ -0,0 +1,2 @@
+export { CarouselAutoplayTrigger as AutoplayTrigger, CarouselControl as Control, CarouselIndicator as Indicator, CarouselIndicatorGroup as IndicatorGroup, CarouselItem as Item, CarouselItemGroup as ItemGroup, CarouselNextTrigger as NextTrigger, CarouselPrevTrigger as PrevTrigger, CarouselRoot as Root, CarouselRootProvider as RootProvider, CarouselPropsProvider as PropsProvider, CarouselContext as Context, CarouselIndicators as Indicators, CarouselAutoplayIndicator as AutoplayIndicator, CarouselProgressText as ProgressText, } from "./carousel";
+export type { CarouselAutoplayTriggerProps as AutoplayTriggerProps, CarouselControlProps as ControlProps, CarouselIndicatorProps as IndicatorProps, CarouselIndicatorGroupProps as IndicatorGroupProps, CarouselItemProps as ItemProps, CarouselItemGroupProps as ItemGroupProps, CarouselNextTriggerProps as NextTriggerProps, CarouselPrevTriggerProps as PrevTriggerProps, CarouselRootProps as RootProps, CarouselRootProviderProps as RootProviderProps, CarouselAutoplayStatusDetails as AutoplayStatusDetails, CarouselDragStatusDetails as DragStatusDetails, CarouselPageChangeDetails as PageChangeDetails, CarouselIndicatorsProps as IndicatorsProps, CarouselAutoplayIndicatorProps as AutoplayIndicatorProps, CarouselProgressTextProps as ProgressTextProps, } from "./carousel";

package/dist/types/components/center/center.d.ts

@@ -0,0 +1,12 @@
+import { type HTMLMainbaseProps } from "../../styled-system";
+export interface CenterProps extends HTMLMainbaseProps<"div"> {
+}
+/**
+ * React component used to horizontally and vertically center its child.
+ * It uses the popular `display: flex` centering technique.
+ *
+ * @see Docs https://mainbase-ui.com/docs/components/center
+ */
+export declare const Center: import("../..").MainbaseComponent<"div", {
+    inline?: import("../..").ConditionalValue<boolean | undefined>;
+}>;

package/dist/types/components/center/index.d.ts

@@ -0,0 +1,2 @@
+export { Center } from "./center";
+export type { CenterProps } from "./center";

package/dist/types/components/checkbox/checkbox.d.ts

@@ -0,0 +1,35 @@
+import type { Assign } from "@ark-ui/react";
+import { Checkbox as ArkCheckbox } from "@ark-ui/react/checkbox";
+import { type HTMLMainbaseProps, type SlotRecipeProps, type UnstyledProp } from "../../styled-system";
+declare const useCheckboxStyles: () => Record<string, import("../..").SystemStyleObject>;
+export { useCheckboxStyles };
+export interface CheckboxRootProviderBaseProps extends Assign<ArkCheckbox.RootProviderBaseProps, SlotRecipeProps<"checkbox">>, UnstyledProp {
+}
+export interface CheckboxRootProviderProps extends HTMLMainbaseProps<"div", CheckboxRootProviderBaseProps> {
+}
+export declare const CheckboxRootProvider: import("react").ForwardRefExoticComponent<CheckboxRootProviderProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface CheckboxRootBaseProps extends Assign<ArkCheckbox.RootBaseProps, SlotRecipeProps<"checkbox">>, UnstyledProp {
+}
+export interface CheckboxRootProps extends HTMLMainbaseProps<"label", CheckboxRootBaseProps> {
+}
+export declare const CheckboxRoot: import("react").ForwardRefExoticComponent<CheckboxRootProps & import("react").RefAttributes<HTMLLabelElement>>;
+export declare const CheckboxPropsProvider: React.Provider<CheckboxRootBaseProps>;
+export interface CheckboxLabelProps extends HTMLMainbaseProps<"span", ArkCheckbox.LabelBaseProps>, UnstyledProp {
+}
+export declare const CheckboxLabel: import("react").ForwardRefExoticComponent<CheckboxLabelProps & import("react").RefAttributes<HTMLElement>>;
+export interface CheckboxIndicatorProps extends HTMLMainbaseProps<"svg"> {
+    checked?: React.ReactElement | undefined;
+    indeterminate?: React.ReactElement | undefined;
+}
+export declare const CheckboxIndicator: import("react").ForwardRefExoticComponent<CheckboxIndicatorProps & import("react").RefAttributes<SVGSVGElement>>;
+export interface CheckboxControlProps extends HTMLMainbaseProps<"div", ArkCheckbox.ControlBaseProps>, UnstyledProp {
+}
+export declare const CheckboxControl: import("react").ForwardRefExoticComponent<CheckboxControlProps & import("react").RefAttributes<HTMLElement>>;
+export interface CheckboxGroupProps extends HTMLMainbaseProps<"div", ArkCheckbox.GroupBaseProps> {
+}
+export type CheckboxGroupComponent = React.ForwardRefExoticComponent<CheckboxGroupProps & React.RefAttributes<HTMLDivElement>>;
+export declare const CheckboxGroup: CheckboxGroupComponent;
+export declare const CheckboxContext: (props: ArkCheckbox.ContextProps) => import("react").ReactNode;
+export declare const CheckboxHiddenInput: import("react").ForwardRefExoticComponent<ArkCheckbox.HiddenInputProps & import("react").RefAttributes<HTMLInputElement>>;
+export interface CheckboxCheckedChangeDetails extends ArkCheckbox.CheckedChangeDetails {
+}

package/dist/types/components/checkbox/index.d.ts

@@ -0,0 +1,5 @@
+export { CheckboxControl, CheckboxIndicator, CheckboxLabel, CheckboxRoot, CheckboxRootProvider, CheckboxPropsProvider, CheckboxContext, CheckboxGroup, CheckboxHiddenInput, useCheckboxStyles, } from "./checkbox";
+export type { CheckboxControlProps, CheckboxIndicatorProps, CheckboxLabelProps, CheckboxRootProps, CheckboxRootProviderProps, CheckboxGroupProps, CheckboxGroupComponent, CheckboxCheckedChangeDetails, } from "./checkbox";
+export { useCheckbox, useCheckboxContext, useCheckboxGroup, useCheckboxGroupContext, } from "@ark-ui/react/checkbox";
+export type { UseCheckboxProps, UseCheckboxReturn, UseCheckboxGroupProps, UseCheckboxGroupReturn, } from "@ark-ui/react/checkbox";
+export * as Checkbox from "./namespace";

package/dist/types/components/checkbox/namespace.d.ts

@@ -0,0 +1,2 @@
+export { CheckboxContext as Context, CheckboxControl as Control, CheckboxGroup as Group, CheckboxHiddenInput as HiddenInput, CheckboxIndicator as Indicator, CheckboxLabel as Label, CheckboxPropsProvider as PropsProvider, CheckboxRoot as Root, CheckboxRootProvider as RootProvider, } from "./checkbox";
+export type { CheckboxCheckedChangeDetails as CheckedChangeDetails, CheckboxRootProviderProps as RootProviderProps, CheckboxControlProps as ControlProps, CheckboxGroupProps as GroupProps, CheckboxIndicatorProps as IndicatorProps, CheckboxLabelProps as LabelProps, CheckboxRootProps as RootProps, } from "./checkbox";

package/dist/types/components/checkbox-card/checkbox-card.d.ts

@@ -0,0 +1,38 @@
+import type { Assign } from "@ark-ui/react";
+import { Checkbox as ArkCheckbox } from "@ark-ui/react/checkbox";
+import { type HTMLMainbaseProps, type SlotRecipeProps, type UnstyledProp } from "../../styled-system";
+declare const useCheckboxCardStyles: () => Record<string, import("../..").SystemStyleObject>;
+export { useCheckboxCardStyles };
+export interface CheckboxCardRootProviderBaseProps extends Assign<ArkCheckbox.RootProviderBaseProps, SlotRecipeProps<"checkboxCard">>, UnstyledProp {
+}
+export interface CheckboxCardRootProviderProps extends HTMLMainbaseProps<"label", CheckboxCardRootProviderBaseProps> {
+}
+export declare const CheckboxCardRootProvider: import("react").ForwardRefExoticComponent<CheckboxCardRootProviderProps & import("react").RefAttributes<HTMLLabelElement>>;
+export interface CheckboxCardRootBaseProps extends Assign<ArkCheckbox.RootBaseProps, SlotRecipeProps<"checkboxCard">>, UnstyledProp {
+}
+export interface CheckboxCardRootProps extends HTMLMainbaseProps<"label", CheckboxCardRootBaseProps> {
+}
+export declare const CheckboxCardRoot: import("react").ForwardRefExoticComponent<CheckboxCardRootProps & import("react").RefAttributes<HTMLLabelElement>>;
+export declare const CheckboxCardRootPropsProvider: React.Provider<CheckboxCardRootBaseProps>;
+export interface CheckboxCardLabelProps extends HTMLMainbaseProps<"span", ArkCheckbox.LabelBaseProps>, UnstyledProp {
+}
+export declare const CheckboxCardLabel: import("react").ForwardRefExoticComponent<CheckboxCardLabelProps & import("react").RefAttributes<HTMLElement>>;
+export interface CheckboxCardDescriptionProps extends HTMLMainbaseProps<"div"> {
+}
+export declare const CheckboxCardDescription: import("react").ForwardRefExoticComponent<CheckboxCardDescriptionProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface CheckboxCardControlProps extends HTMLMainbaseProps<"div", ArkCheckbox.ControlBaseProps>, UnstyledProp {
+}
+export declare const CheckboxCardControl: import("react").ForwardRefExoticComponent<CheckboxCardControlProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface CheckboxCardContentProps extends HTMLMainbaseProps<"div">, UnstyledProp {
+}
+export declare const CheckboxCardContent: import("react").ForwardRefExoticComponent<CheckboxCardContentProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface CheckboxCardIndicatorProps extends HTMLMainbaseProps<"svg"> {
+}
+export declare const CheckboxCardIndicator: import("react").ForwardRefExoticComponent<CheckboxCardIndicatorProps & import("react").RefAttributes<SVGSVGElement>>;
+export interface CheckboxCardAddonProps extends HTMLMainbaseProps<"div">, UnstyledProp {
+}
+export declare const CheckboxCardAddon: import("react").ForwardRefExoticComponent<CheckboxCardAddonProps & import("react").RefAttributes<HTMLElement>>;
+export declare const CheckboxCardContext: (props: ArkCheckbox.ContextProps) => import("react").ReactNode;
+export declare const CheckboxCardHiddenInput: import("react").ForwardRefExoticComponent<ArkCheckbox.HiddenInputProps & import("react").RefAttributes<HTMLInputElement>>;
+export interface CheckboxCardCheckedChangeDetails extends ArkCheckbox.CheckedChangeDetails {
+}

package/dist/types/components/checkbox-card/index.d.ts

@@ -0,0 +1,5 @@
+export { CheckboxCardAddon, CheckboxCardControl, CheckboxCardIndicator, CheckboxCardLabel, CheckboxCardRoot, CheckboxCardRootProvider, CheckboxCardContext, CheckboxCardContent, CheckboxCardHiddenInput, CheckboxCardRootPropsProvider, CheckboxCardDescription, useCheckboxCardStyles, } from "./checkbox-card";
+export type { CheckboxCardAddonProps, CheckboxCardControlProps, CheckboxCardIndicatorProps, CheckboxCardLabelProps, CheckboxCardRootProps, CheckboxCardRootProviderProps, CheckboxCardCheckedChangeDetails, CheckboxCardContentProps, CheckboxCardDescriptionProps, } from "./checkbox-card";
+export { useCheckbox as useCheckboxCard, useCheckboxContext as useCheckboxCardContext, } from "@ark-ui/react/checkbox";
+export type { UseCheckboxProps as UseCheckboxCardProps, UseCheckboxReturn as UseCheckboxCardReturn, } from "@ark-ui/react/checkbox";
+export * as CheckboxCard from "./namespace";

package/dist/types/components/checkbox-card/namespace.d.ts

@@ -0,0 +1,2 @@
+export { CheckboxCardAddon as Addon, CheckboxCardContext as Context, CheckboxCardControl as Control, CheckboxCardContent as Content, CheckboxCardHiddenInput as HiddenInput, CheckboxCardIndicator as Indicator, CheckboxCardLabel as Label, CheckboxCardRoot as Root, CheckboxCardRootPropsProvider as RootPropsProvider, CheckboxCardRootProvider as RootProvider, CheckboxCardDescription as Description, } from "./checkbox-card";
+export type { CheckboxCardAddonProps as AddonProps, CheckboxCardCheckedChangeDetails as CheckedChangeDetails, CheckboxCardControlProps as ControlProps, CheckboxCardContentProps as ContentProps, CheckboxCardIndicatorProps as IndicatorProps, CheckboxCardLabelProps as LabelProps, CheckboxCardRootProps as RootProps, CheckboxCardRootProviderProps as RootProviderProps, CheckboxCardDescriptionProps as DescriptionProps, } from "./checkbox-card";

package/dist/types/components/checkmark/checkmark.d.ts

@@ -0,0 +1,16 @@
+import { type HTMLMainbaseProps, type RecipeProps, type UnstyledProp } from "../../styled-system";
+export interface CheckmarkProps extends HTMLMainbaseProps<"svg", RecipeProps<"checkmark">>, UnstyledProp {
+    /**
+     * Whether the checkmark is checked
+     */
+    checked?: boolean | undefined;
+    /**
+     * Whether the checkmark is indeterminate
+     */
+    indeterminate?: boolean | undefined;
+    /**
+     * Whether the checkmark is disabled
+     */
+    disabled?: boolean | undefined;
+}
+export declare const Checkmark: import("react").ForwardRefExoticComponent<CheckmarkProps & import("react").RefAttributes<SVGSVGElement>>;

package/dist/types/components/checkmark/index.d.ts

@@ -0,0 +1,2 @@
+export { Checkmark } from "./checkmark";
+export type { CheckmarkProps } from "./checkmark";

package/dist/types/components/circle/index.d.ts

@@ -0,0 +1,4 @@
+import { type SquareProps } from "../square";
+export interface CircleProps extends SquareProps {
+}
+export declare const Circle: import("react").ForwardRefExoticComponent<SquareProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/client-only/client-only.d.ts

@@ -0,0 +1,14 @@
+export interface ClientOnlyProps {
+    /**
+     * The content to render on the client side.
+     *
+     * **Note:** Use the function pattern when accessing browser-only APIs.
+     */
+    children: React.ReactNode | (() => React.ReactNode);
+    /**
+     * The fallback content to render while the component is mounting on the client
+     * side.
+     */
+    fallback?: React.ReactNode | undefined;
+}
+export declare const ClientOnly: (props: ClientOnlyProps) => import("react").JSX.Element;

package/dist/types/components/client-only/index.d.ts

@@ -0,0 +1,2 @@
+export { ClientOnly } from "./client-only";
+export type { ClientOnlyProps } from "./client-only";

package/dist/types/components/clipboard/clipboard.d.ts

@@ -0,0 +1,38 @@
+import type { Assign } from "@ark-ui/react";
+import { Clipboard as ArkClipboard } from "@ark-ui/react/clipboard";
+import { type HTMLMainbaseProps, type SlotRecipeProps, type UnstyledProp } from "../../styled-system";
+declare const useClipboardStyles: () => Record<string, import("../..").SystemStyleObject>;
+export { useClipboardStyles };
+export interface ClipboardRootProviderBaseProps extends Assign<ArkClipboard.RootProviderBaseProps, SlotRecipeProps<"clipboard">>, UnstyledProp {
+}
+export interface ClipboardRootProviderProps extends HTMLMainbaseProps<"div", ClipboardRootProviderBaseProps> {
+}
+export declare const ClipboardRootProvider: import("react").ForwardRefExoticComponent<ClipboardRootProviderProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface ClipboardRootBaseProps extends Assign<ArkClipboard.RootBaseProps, SlotRecipeProps<"clipboard">>, UnstyledProp {
+}
+export interface ClipboardRootProps extends HTMLMainbaseProps<"div", ClipboardRootBaseProps> {
+}
+export declare const ClipboardRoot: import("react").ForwardRefExoticComponent<ClipboardRootProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const ClipboardPropsProvider: React.Provider<ClipboardRootBaseProps>;
+export interface ClipboardTriggerProps extends HTMLMainbaseProps<"button", ArkClipboard.TriggerProps>, UnstyledProp {
+}
+export declare const ClipboardTrigger: import("react").ForwardRefExoticComponent<ClipboardTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+export interface ClipboardControlProps extends HTMLMainbaseProps<"div", ArkClipboard.ControlProps>, UnstyledProp {
+}
+export declare const ClipboardControl: import("react").ForwardRefExoticComponent<ClipboardControlProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface ClipboardIndicatorProps extends HTMLMainbaseProps<"div", ArkClipboard.IndicatorProps>, UnstyledProp {
+}
+export declare const ClipboardIndicator: import("react").ForwardRefExoticComponent<ClipboardIndicatorProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface ClipboardInputProps extends HTMLMainbaseProps<"input", ArkClipboard.InputProps>, UnstyledProp {
+}
+export declare const ClipboardInput: import("react").ForwardRefExoticComponent<ClipboardInputProps & import("react").RefAttributes<HTMLInputElement>>;
+export interface ClipboardLabelProps extends HTMLMainbaseProps<"label", ArkClipboard.LabelProps>, UnstyledProp {
+}
+export declare const ClipboardLabel: import("react").ForwardRefExoticComponent<ClipboardLabelProps & import("react").RefAttributes<HTMLLabelElement>>;
+export declare const ClipboardContext: (props: ArkClipboard.ContextProps) => import("react").ReactNode;
+export interface ClipboardCopyStatusDetails extends ArkClipboard.CopyStatusDetails {
+}
+export interface ClipboardValueTextProps extends HTMLMainbaseProps<"div", ArkClipboard.ValueTextProps>, UnstyledProp {
+}
+export declare const ClipboardValueText: import("react").ForwardRefExoticComponent<ClipboardValueTextProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const ClipboardCopyText: import("react").ForwardRefExoticComponent<ClipboardIndicatorProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/components/clipboard/index.d.ts

@@ -0,0 +1,5 @@
+export { ClipboardControl, ClipboardIndicator, ClipboardRoot, ClipboardRootProvider, ClipboardPropsProvider, ClipboardTrigger, ClipboardInput, ClipboardLabel, ClipboardValueText, ClipboardContext, ClipboardCopyText, useClipboardStyles, } from "./clipboard";
+export type { ClipboardControlProps, ClipboardIndicatorProps, ClipboardRootProps, ClipboardRootProviderProps, ClipboardLabelProps, ClipboardValueTextProps, ClipboardTriggerProps, ClipboardInputProps, ClipboardCopyStatusDetails, } from "./clipboard";
+export { useClipboard, useClipboardContext } from "@ark-ui/react/clipboard";
+export type { UseClipboardProps, UseClipboardReturn, } from "@ark-ui/react/clipboard";
+export * as Clipboard from "./namespace";

package/dist/types/components/clipboard/namespace.d.ts

@@ -0,0 +1,2 @@
+export { ClipboardControl as Control, ClipboardIndicator as Indicator, ClipboardRoot as Root, ClipboardRootProvider as RootProvider, ClipboardPropsProvider as PropsProvider, ClipboardTrigger as Trigger, ClipboardLabel as Label, ClipboardInput as Input, ClipboardContext as Context, ClipboardValueText as ValueText, ClipboardCopyText as CopyText, } from "./clipboard";
+export type { ClipboardControlProps as ControlProps, ClipboardRootProviderProps as RootProviderProps, ClipboardIndicatorProps as IndicatorProps, ClipboardRootProps as RootProps, ClipboardLabelProps as LabelProps, ClipboardTriggerProps as TriggerProps, ClipboardInputProps as InputProps, ClipboardCopyStatusDetails as CopyStatusDetails, ClipboardValueTextProps as ValueTextProps, } from "./clipboard";

package/dist/types/components/code/code.d.ts

@@ -0,0 +1,7 @@
+import { type HTMLMainbaseProps, type RecipeProps, type UnstyledProp } from "../../styled-system";
+export interface CodeBaseProps extends RecipeProps<"code">, UnstyledProp {
+}
+export interface CodeProps extends HTMLMainbaseProps<"code", CodeBaseProps> {
+}
+export declare const Code: import("react").ForwardRefExoticComponent<CodeProps & import("react").RefAttributes<HTMLElement>>;
+export declare const CodePropsProvider: React.Provider<CodeBaseProps>;

package/dist/types/components/code/index.d.ts

@@ -0,0 +1,2 @@
+export { Code, CodePropsProvider } from "./code";
+export type { CodeProps } from "./code";

package/dist/types/components/code-block/adapters.d.ts

@@ -0,0 +1,33 @@
+import type { CodeBlockAdapter } from "./types";
+export declare const plainTextAdapter: CodeBlockAdapter;
+interface ShikiHighlighterBase {
+    codeToHtml: (code: string, options: any) => string;
+    dispose?: () => void;
+}
+type ShikiHighlighterBaseOptions<T extends ShikiHighlighterBase> = Parameters<T["codeToHtml"]>[1];
+export interface ShikiAdapterOptions<T extends ShikiHighlighterBase> {
+    load: () => Promise<T>;
+    loadSync?: () => T;
+    highlightOptions?: ShikiHighlighterBaseOptions<T>;
+    theme: string | Record<string, string>;
+}
+export declare function createShikiAdapter<T extends ShikiHighlighterBase>(opts: ShikiAdapterOptions<T>): CodeBlockAdapter;
+interface HighlightJsHighlightResult {
+    value: string;
+}
+interface HighlightJsHighlighterBase {
+    highlight: (...args: any[]) => HighlightJsHighlightResult;
+    listLanguages: () => string[];
+    unregisterLanguage: (language: string) => void;
+}
+interface HighlightJsHighlighterBaseOptions {
+    language: string;
+    ignoreIllegals?: boolean;
+}
+export interface HighlightJsAdapterOptions<T extends HighlightJsHighlighterBase> {
+    load: () => Promise<T>;
+    loadSync?: () => T;
+    highlightOptions?: HighlightJsHighlighterBaseOptions;
+}
+export declare function createHighlightJsAdapter<T extends HighlightJsHighlighterBase>(opts: HighlightJsAdapterOptions<T>): CodeBlockAdapter;
+export {};

package/dist/types/components/code-block/code-block-adapter-context.d.ts

@@ -0,0 +1,4 @@
+import type { UseCodeHighlightReturn } from "./use-code-highlight";
+export interface UseCodeBlockAdapterContext extends UseCodeHighlightReturn {
+}
+export declare const CodeBlockAdapterContextProvider: import("react").Provider<UseCodeBlockAdapterContext>, useCodeBlockAdapterContext: () => UseCodeBlockAdapterContext;

package/dist/types/components/code-block/code-block-adapter-provider.d.ts

@@ -0,0 +1,6 @@
+import { type UseCodeHighlightProps } from "./use-code-highlight";
+export interface CodeBlockAdapterProviderProps {
+    children: React.ReactNode;
+    value: UseCodeHighlightProps;
+}
+export declare function CodeBlockAdapterProvider(props: CodeBlockAdapterProviderProps): import("react").JSX.Element;

package/dist/types/components/code-block/code-block-context.d.ts

@@ -0,0 +1,13 @@
+import { type UseClipboardReturn } from "@ark-ui/react/clipboard";
+import type { CodeBlockHighlighterProps } from "./types";
+export interface CodeBlockCollapsible {
+    contentId: string;
+    collapsed: boolean;
+    setCollapsed: (collapsed: boolean) => void;
+    toggleCollapsed: () => void;
+}
+export interface UseCodeBlockContext extends CodeBlockHighlighterProps {
+    collapsible: CodeBlockCollapsible;
+    clipboard: UseClipboardReturn;
+}
+export declare const CodeBlockContextProvider: import("react").Provider<UseCodeBlockContext>, useCodeBlockContext: () => UseCodeBlockContext;

package/dist/types/components/code-block/code-block.d.ts

@@ -0,0 +1,85 @@
+import { type Assign } from "@ark-ui/react";
+import { type HTMLMainbaseProps, type SlotRecipeProps, type UnstyledProp } from "../../styled-system";
+import { type UseCodeBlockContext } from "./code-block-context";
+import type { CodeBlockColorScheme, CodeBlockHighlighterProps } from "./types";
+declare const useCodeBlockStyles: () => Record<string, import("../..").SystemStyleObject>;
+export { useCodeBlockStyles };
+interface SharedRootProps extends CodeBlockHighlighterProps {
+    /**
+     * The maximum number of lines to show.
+     * @default undefined
+     */
+    maxLines?: number | undefined;
+    /**
+     * The fallback color scheme for the code block.
+     * @default "dark"
+     */
+    defaultColorScheme?: CodeBlockColorScheme | undefined;
+    /**
+     * The timeout for the copy action.
+     * @default 1000
+     */
+    copyTimeout?: number | undefined;
+    /**
+     * The callback function that is called when the copy action is completed.
+     */
+    onCopy?: VoidFunction | undefined;
+}
+export interface CodeBlockRootBaseProps extends Assign<Omit<HTMLMainbaseProps<"div">, "lang" | keyof SharedRootProps>, SlotRecipeProps<"codeBlock">>, UnstyledProp, SharedRootProps {
+}
+export interface CodeBlockRootProps extends CodeBlockRootBaseProps {
+    children: React.ReactNode;
+}
+export declare const CodeBlockRoot: import("react").ForwardRefExoticComponent<CodeBlockRootProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const CodeBlockPropsProvider: React.Provider<CodeBlockRootBaseProps>;
+export interface CodeBlockContentProps extends HTMLMainbaseProps<"div"> {
+}
+export declare const CodeBlockContent: import("react").ForwardRefExoticComponent<CodeBlockContentProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface CodeBlockTitleProps extends HTMLMainbaseProps<"div"> {
+}
+export declare const CodeBlockTitle: import("react").ForwardRefExoticComponent<CodeBlockTitleProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface CodeBlockHeaderProps extends HTMLMainbaseProps<"div"> {
+}
+export declare const CodeBlockHeader: import("react").ForwardRefExoticComponent<CodeBlockHeaderProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface CodeBlockCodeProps extends HTMLMainbaseProps<"pre"> {
+}
+export declare const CodeBlockCode: import("react").ForwardRefExoticComponent<CodeBlockCodeProps & import("react").RefAttributes<HTMLPreElement>>;
+export interface CodeBlockCodeTextProps extends HTMLMainbaseProps<"code"> {
+}
+export declare const CodeBlockCodeText: import("react").ForwardRefExoticComponent<CodeBlockCodeTextProps & import("react").RefAttributes<HTMLElement>>;
+export interface CodeBlockCopyTriggerProps extends HTMLMainbaseProps<"button"> {
+}
+export declare const CodeBlockCopyTrigger: import("react").ForwardRefExoticComponent<CodeBlockCopyTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+interface BaseCopyIndicatorBaseProps {
+    copied?: React.ReactNode;
+    children?: React.ReactNode;
+}
+export interface CodeBlockCopyIndicatorProps extends Assign<HTMLMainbaseProps<"span">, BaseCopyIndicatorBaseProps> {
+}
+export declare const CodeBlockCopyIndicator: import("react").ForwardRefExoticComponent<CodeBlockCopyIndicatorProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface CodeBlockCollapseTriggerProps extends HTMLMainbaseProps<"button"> {
+}
+export declare const CodeBlockCollapseTrigger: import("react").ForwardRefExoticComponent<CodeBlockCollapseTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+interface BaseCollapseIndicatorBaseProps {
+    collapsed?: React.ReactNode;
+    children?: React.ReactNode;
+}
+export interface CodeBlockCollapseIndicatorProps extends Assign<HTMLMainbaseProps<"span">, BaseCollapseIndicatorBaseProps> {
+}
+export declare const CodeBlockCollapseIndicator: import("react").ForwardRefExoticComponent<CodeBlockCollapseIndicatorProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface CodeBlockCollapseTextProps extends HTMLMainbaseProps<"span"> {
+}
+export declare const CodeBlockCollapseText: import("react").ForwardRefExoticComponent<CodeBlockCollapseTextProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface CodeBlockFooterProps extends HTMLMainbaseProps<"div"> {
+}
+export declare const CodeBlockFooter: import("react").ForwardRefExoticComponent<CodeBlockFooterProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface CodeBlockControlProps extends HTMLMainbaseProps<"div"> {
+}
+export declare const CodeBlockControl: import("react").ForwardRefExoticComponent<CodeBlockControlProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface CodeBlockOverlayProps extends HTMLMainbaseProps<"div"> {
+}
+export declare const CodeBlockOverlay: import("react").ForwardRefExoticComponent<CodeBlockOverlayProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface CodeBlockContextProps {
+    children(ctx: UseCodeBlockContext): React.ReactNode;
+}
+export declare const CodeBlockContext: (props: CodeBlockContextProps) => import("react").ReactNode;

package/dist/types/components/code-block/index.d.ts

@@ -0,0 +1,6 @@
+export { CodeBlockAdapterProvider } from "./code-block-adapter-provider";
+export { CodeBlockRoot, CodeBlockContent, CodeBlockHeader, CodeBlockTitle, CodeBlockCode, CodeBlockCodeText, CodeBlockCopyTrigger, CodeBlockCopyIndicator, CodeBlockContext, CodeBlockFooter, CodeBlockCollapseTrigger, CodeBlockCollapseIndicator, CodeBlockControl, CodeBlockCollapseText, CodeBlockOverlay, } from "./code-block";
+export type { CodeBlockRootProps, CodeBlockContentProps, CodeBlockHeaderProps, CodeBlockTitleProps, CodeBlockCodeProps, CodeBlockCodeTextProps, CodeBlockCopyTriggerProps, CodeBlockCopyIndicatorProps, CodeBlockContextProps, CodeBlockFooterProps, CodeBlockCollapseTriggerProps, CodeBlockCollapseIndicatorProps, CodeBlockControlProps, CodeBlockCollapseTextProps, CodeBlockOverlayProps, } from "./code-block";
+export type { CodeBlockAdapter } from "./types";
+export * from "./adapters";
+export * as CodeBlock from "./namespace";

package/dist/types/components/code-block/namespace.d.ts

@@ -0,0 +1,3 @@
+export { CodeBlockAdapterProvider as AdapterProvider } from "./code-block-adapter-provider";
+export { CodeBlockRoot as Root, CodeBlockContent as Content, CodeBlockHeader as Header, CodeBlockTitle as Title, CodeBlockCode as Code, CodeBlockCodeText as CodeText, CodeBlockCopyTrigger as CopyTrigger, CodeBlockCopyIndicator as CopyIndicator, CodeBlockContext as Context, CodeBlockFooter as Footer, CodeBlockCollapseTrigger as CollapseTrigger, CodeBlockCollapseIndicator as CollapseIndicator, CodeBlockControl as Control, CodeBlockCollapseText as CollapseText, CodeBlockOverlay as Overlay, } from "./code-block";
+export type { CodeBlockRootProps as RootProps, CodeBlockContentProps as ContentProps, CodeBlockHeaderProps as HeaderProps, CodeBlockTitleProps as TitleProps, CodeBlockCodeProps as CodeProps, CodeBlockCodeTextProps as CodeTextProps, CodeBlockCopyTriggerProps as CopyTriggerProps, CodeBlockCopyIndicatorProps as CopyIndicatorProps, CodeBlockContextProps as ContextProps, CodeBlockFooterProps as FooterProps, CodeBlockCollapseTriggerProps as CollapseTriggerProps, CodeBlockCollapseIndicatorProps as CollapseIndicatorProps, CodeBlockControlProps as ControlProps, CodeBlockCollapseTextProps as CollapseTextProps, CodeBlockOverlayProps as OverlayProps, } from "./code-block";

package/dist/types/components/code-block/types.d.ts

@@ -0,0 +1,67 @@
+export type CodeBlockColorScheme = "light" | "dark" | (string & {});
+export interface CodeBlockHighlightMeta {
+    /**
+     * The lines to highlight.
+     */
+    highlightLines?: number[] | undefined;
+    /**
+     * Whether to show line numbers.
+     */
+    showLineNumbers?: boolean | undefined;
+    /**
+     * Whether to wrap the code.
+     */
+    wordWrap?: boolean | undefined;
+    /**
+     * The lines to remove.
+     */
+    removedLineNumbers?: number[] | undefined;
+    /**
+     * The lines to add.
+     */
+    addedLineNumbers?: number[] | undefined;
+    /**
+     * The lines to focus.
+     */
+    focusedLineNumbers?: number[] | undefined;
+    /**
+     * The color scheme to use.
+     */
+    colorScheme?: CodeBlockColorScheme | undefined;
+}
+export interface CodeBlockHighlighterProps {
+    /**
+     * The code to highlight.
+     */
+    code: string;
+    /**
+     * The language of the code.
+     */
+    language?: string | undefined;
+    /**
+     * The meta data for the code.
+     */
+    meta?: CodeBlockHighlightMeta | undefined;
+}
+export type CodeBlockHighlighter = (props: CodeBlockHighlighterProps) => {
+    code: string;
+    highlighted: boolean;
+};
+export interface CodeBlockAdapter {
+    /**
+     * Load the context for the code block.
+     */
+    loadContext?: (() => Promise<any>) | undefined;
+    /**
+     * Load the context for the code block synchronously.
+     */
+    loadContextSync?: (() => any) | undefined;
+    /**
+     * Get the highlighter for the code block.
+     */
+    getHighlighter: (ctx: any) => CodeBlockHighlighter;
+    /**
+     * Unload the context for the code block.
+     */
+    unloadContext?: ((ctx: any) => void) | undefined;
+}

package/dist/types/components/code-block/use-code-highlight.d.ts

@@ -0,0 +1,7 @@
+import type { CodeBlockAdapter, CodeBlockHighlighter } from "./types";
+export interface UseCodeHighlightProps extends CodeBlockAdapter {
+}
+export interface UseCodeHighlightReturn extends CodeBlockAdapter {
+    highlight: CodeBlockHighlighter | undefined;
+}
+export declare function useCodeHighlight(props: UseCodeHighlightProps): UseCodeHighlightReturn;

package/dist/types/components/collapsible/collapsible.d.ts

@@ -0,0 +1,28 @@
+import type { Assign } from "@ark-ui/react";
+import { Collapsible as ArkCollapsible } from "@ark-ui/react/collapsible";
+import { type HTMLMainbaseProps, type SlotRecipeProps, type UnstyledProp } from "../../styled-system";
+declare const useCollapsibleStyles: () => Record<string, import("../..").SystemStyleObject>;
+export { useCollapsibleStyles };
+export interface CollapsibleRootProviderBaseProps extends Assign<ArkCollapsible.RootProviderBaseProps, SlotRecipeProps<"collapsible">>, UnstyledProp {
+}
+export interface CollapsibleRootProviderProps extends HTMLMainbaseProps<"div", CollapsibleRootProviderBaseProps> {
+}
+export declare const CollapsibleRootProvider: import("react").ForwardRefExoticComponent<CollapsibleRootProviderProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface CollapsibleRootBaseProps extends Assign<ArkCollapsible.RootBaseProps, SlotRecipeProps<"collapsible">>, UnstyledProp {
+}
+export interface CollapsibleRootProps extends HTMLMainbaseProps<"div", CollapsibleRootBaseProps> {
+}
+export declare const CollapsibleRoot: import("react").ForwardRefExoticComponent<CollapsibleRootProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const CollapsiblePropsProvider: React.Provider<CollapsibleRootBaseProps>;
+export interface CollapsibleTriggerProps extends HTMLMainbaseProps<"button", ArkCollapsible.TriggerBaseProps>, UnstyledProp {
+}
+export declare const CollapsibleTrigger: import("react").ForwardRefExoticComponent<CollapsibleTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+export interface CollapsibleContentProps extends HTMLMainbaseProps<"div", ArkCollapsible.ContentBaseProps>, UnstyledProp {
+}
+export declare const CollapsibleContent: import("react").ForwardRefExoticComponent<CollapsibleContentProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface CollapsibleIndicatorProps extends HTMLMainbaseProps<"div", ArkCollapsible.IndicatorBaseProps>, UnstyledProp {
+}
+export declare const CollapsibleIndicator: import("react").ForwardRefExoticComponent<CollapsibleIndicatorProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const CollapsibleContext: (props: ArkCollapsible.ContextProps) => import("react").ReactNode;
+export interface CollapsibleOpenChangeDetails extends ArkCollapsible.OpenChangeDetails {
+}

package/dist/types/components/collapsible/index.d.ts

@@ -0,0 +1,5 @@
+export { CollapsibleContent, CollapsibleContext, CollapsibleIndicator, CollapsiblePropsProvider, CollapsibleRoot, CollapsibleRootProvider, CollapsibleTrigger, useCollapsibleStyles, } from "./collapsible";
+export type { CollapsibleContentProps, CollapsibleIndicatorProps, CollapsibleOpenChangeDetails, CollapsibleRootProps, CollapsibleRootProviderProps, CollapsibleTriggerProps, } from "./collapsible";
+export { useCollapsible, useCollapsibleContext, } from "@ark-ui/react/collapsible";
+export type { UseCollapsibleProps, UseCollapsibleReturn, } from "@ark-ui/react/collapsible";
+export * as Collapsible from "./namespace";

package/dist/types/components/collapsible/namespace.d.ts

@@ -0,0 +1,2 @@
+export { CollapsibleContent as Content, CollapsibleContext as Context, CollapsibleIndicator as Indicator, CollapsiblePropsProvider as PropsProvider, CollapsibleRoot as Root, CollapsibleRootProvider as RootProvider, CollapsibleTrigger as Trigger, } from "./collapsible";
+export type { CollapsibleContentProps as ContentProps, CollapsibleIndicatorProps as IndicatorProps, CollapsibleOpenChangeDetails as OpenChangeDetails, CollapsibleRootProps as RootProps, CollapsibleRootProviderProps as RootProviderProps, CollapsibleTriggerProps as TriggerProps, } from "./collapsible";