@pyck/react 0.0.1

package/dist/components/tabs/index.d.ts

@@ -0,0 +1,18 @@
+import * as react from "react";
+import { ComponentProps } from "react";
+import * as _pyck_styled_system_jsx0 from "@pyck/styled-system/jsx";
+import * as _pyck_styled_system_recipes0 from "@pyck/styled-system/recipes";
+import { Tabs } from "@ark-ui/react/tabs";
+
+//#region src/components/tabs/tabs.d.ts
+declare namespace tabs_d_exports {
+  export { Content, Indicator, List, Root, RootProps, Trigger };
+}
+type RootProps = ComponentProps<typeof Root>;
+declare const Root: _pyck_styled_system_jsx0.StyleContextProvider<react.ForwardRefExoticComponent<Tabs.RootProps & react.RefAttributes<HTMLDivElement>>, _pyck_styled_system_recipes0.TabsRecipe>;
+declare const Content: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<Tabs.ContentProps & react.RefAttributes<HTMLDivElement>>>;
+declare const List: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<Tabs.ListProps & react.RefAttributes<HTMLDivElement>>>;
+declare const Indicator: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<Tabs.IndicatorProps & react.RefAttributes<HTMLDivElement>>>;
+declare const Trigger: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<Tabs.TriggerProps & react.RefAttributes<HTMLButtonElement>>>;
+//#endregion
+export { tabs_d_exports as Tabs };

package/dist/components/tabs/index.js

@@ -0,0 +1,22 @@
+import { t as __exportAll } from "../../chunk-BYypO7fO.js";
+import { createStyleContext } from "@pyck/styled-system/jsx";
+import { tabs } from "@pyck/styled-system/recipes";
+import { Tabs } from "@ark-ui/react/tabs";
+
+//#region src/components/tabs/tabs.tsx
+var tabs_exports = /* @__PURE__ */ __exportAll({
+	Content: () => Content,
+	Indicator: () => Indicator,
+	List: () => List,
+	Root: () => Root,
+	Trigger: () => Trigger
+});
+const { withProvider, withContext } = createStyleContext(tabs);
+const Root = withProvider(Tabs.Root, "root");
+const Content = withContext(Tabs.Content, "content");
+const List = withContext(Tabs.List, "list");
+const Indicator = withContext(Tabs.Indicator, "indicator");
+const Trigger = withContext(Tabs.Trigger, "trigger");
+
+//#endregion
+export { tabs_exports as Tabs };

package/dist/components/tags-input/index.d.ts

@@ -0,0 +1,29 @@
+import * as react from "react";
+import { ComponentProps } from "react";
+import * as _pyck_styled_system_jsx0 from "@pyck/styled-system/jsx";
+import * as _pyck_styled_system_recipes0 from "@pyck/styled-system/recipes";
+import { TagsInput, TagsInputContext as Context } from "@ark-ui/react/tags-input";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/components/tags-input/tags-input.d.ts
+declare namespace tags_input_d_exports {
+  export { ClearTrigger, Context, Control, HiddenInput, Input, Item, ItemDeleteTrigger, ItemInput, ItemPreview, ItemProps, ItemText, Items, Label, Root, RootProps, RootProvider, TagsInputItemsProps };
+}
+type RootProps = ComponentProps<typeof Root>;
+type ItemProps = ComponentProps<typeof Item>;
+declare const Root: _pyck_styled_system_jsx0.StyleContextProvider<react.ForwardRefExoticComponent<TagsInput.RootProps & react.RefAttributes<HTMLDivElement>>, _pyck_styled_system_recipes0.TagsInputRecipe>;
+declare const RootProvider: _pyck_styled_system_jsx0.StyleContextProvider<react.ForwardRefExoticComponent<TagsInput.RootProviderProps & react.RefAttributes<HTMLDivElement>>, _pyck_styled_system_recipes0.TagsInputRecipe>;
+declare const ClearTrigger: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<TagsInput.ClearTriggerProps & react.RefAttributes<HTMLButtonElement>>>;
+declare const Control: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<TagsInput.ControlProps & react.RefAttributes<HTMLDivElement>>>;
+declare const HiddenInput: react.ForwardRefExoticComponent<TagsInput.HiddenInputProps & react.RefAttributes<HTMLInputElement>>;
+declare const Input: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<TagsInput.InputProps & react.RefAttributes<HTMLInputElement>>>;
+declare const Item: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<TagsInput.ItemProps & react.RefAttributes<HTMLDivElement>>>;
+declare const ItemDeleteTrigger: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<TagsInput.ItemDeleteTriggerProps & react.RefAttributes<HTMLButtonElement>>>;
+declare const ItemInput: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<TagsInput.ItemInputProps & react.RefAttributes<HTMLInputElement>>>;
+declare const ItemPreview: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<TagsInput.ItemPreviewProps & react.RefAttributes<HTMLDivElement>>>;
+declare const ItemText: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<TagsInput.ItemTextProps & react.RefAttributes<HTMLSpanElement>>>;
+declare const Label: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<TagsInput.LabelProps & react.RefAttributes<HTMLLabelElement>>>;
+interface TagsInputItemsProps extends Omit<ItemProps, 'value' | 'index'> {}
+declare const Items: (props: TagsInputItemsProps) => react_jsx_runtime0.JSX.Element[];
+//#endregion
+export { tags_input_d_exports as TagsInput };

package/dist/components/tags-input/index.js

@@ -0,0 +1,48 @@
+import { t as __exportAll } from "../../chunk-BYypO7fO.js";
+import { createStyleContext } from "@pyck/styled-system/jsx";
+import { tagsInput } from "@pyck/styled-system/recipes";
+import { XIcon } from "lucide-react";
+import { TagsInput, TagsInputContext as Context, useTagsInputContext } from "@ark-ui/react/tags-input";
+
+//#region src/components/tags-input/tags-input.tsx
+var tags_input_exports = /* @__PURE__ */ __exportAll({
+	ClearTrigger: () => ClearTrigger,
+	Context: () => Context,
+	Control: () => Control,
+	HiddenInput: () => HiddenInput,
+	Input: () => Input,
+	Item: () => Item,
+	ItemDeleteTrigger: () => ItemDeleteTrigger,
+	ItemInput: () => ItemInput,
+	ItemPreview: () => ItemPreview,
+	ItemText: () => ItemText,
+	Items: () => Items,
+	Label: () => Label,
+	Root: () => Root,
+	RootProvider: () => RootProvider
+});
+const { withProvider, withContext } = createStyleContext(tagsInput);
+const Root = withProvider(TagsInput.Root, "root");
+const RootProvider = withProvider(TagsInput.RootProvider, "root");
+const ClearTrigger = withContext(TagsInput.ClearTrigger, "clearTrigger", { defaultProps: { children: <XIcon /> } });
+const Control = withContext(TagsInput.Control, "control");
+const HiddenInput = TagsInput.HiddenInput;
+const Input = withContext(TagsInput.Input, "input");
+const Item = withContext(TagsInput.Item, "item");
+const ItemDeleteTrigger = withContext(TagsInput.ItemDeleteTrigger, "itemDeleteTrigger", { defaultProps: { children: <XIcon /> } });
+const ItemInput = withContext(TagsInput.ItemInput, "itemInput");
+const ItemPreview = withContext(TagsInput.ItemPreview, "itemPreview");
+const ItemText = withContext(TagsInput.ItemText, "itemText");
+const Label = withContext(TagsInput.Label, "label");
+const Items = (props) => {
+	return useTagsInputContext().value.map((item, index) => <Item key={item} index={index} value={item} {...props}>
+      <ItemPreview>
+        <ItemText>{item}</ItemText>
+        <ItemDeleteTrigger />
+      </ItemPreview>
+      <ItemInput />
+    </Item>);
+};
+
+//#endregion
+export { tags_input_exports as TagsInput };

package/dist/components/text/index.d.ts

@@ -0,0 +1,12 @@
+import { ComponentProps, ElementType } from "react";
+import { TextVariantProps } from "@pyck/styled-system/recipes";
+import { StyledComponent } from "@pyck/styled-system/types";
+
+//#region src/components/text/text.d.ts
+type Props = TextVariantProps & {
+  as?: ElementType;
+};
+type TextProps = ComponentProps<typeof Text>;
+declare const Text: StyledComponent<"p", Props>;
+//#endregion
+export { Text, type TextProps };

package/dist/components/text/index.js

@@ -0,0 +1,8 @@
+import { styled } from "@pyck/styled-system/jsx";
+import { text } from "@pyck/styled-system/recipes";
+
+//#region src/components/text/text.tsx
+const Text = styled("p", text);
+
+//#endregion
+export { Text };

package/dist/components/textarea/index.d.ts

@@ -0,0 +1,24 @@
+import * as react from "react";
+import { ComponentProps } from "react";
+import * as _pyck_styled_system_recipes0 from "@pyck/styled-system/recipes";
+import { FieldProps } from "@pyck/react/field";
+import { FieldPath, FieldValues } from "react-hook-form";
+import { Field as Field$1 } from "@ark-ui/react/field";
+import { TextareaProps as TextareaProps$1 } from "@pyck/react/textarea";
+import * as _pyck_styled_system_types0 from "@pyck/styled-system/types";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/components/textarea/textarea.d.ts
+type TextareaProps = ComponentProps<typeof Textarea>;
+declare const Textarea: _pyck_styled_system_types0.StyledComponent<react.ForwardRefExoticComponent<Field$1.TextareaProps & react.RefAttributes<HTMLTextAreaElement>>, _pyck_styled_system_recipes0.TextareaVariantProps>;
+//#endregion
+//#region src/components/textarea/textarea-field.d.ts
+interface TextareaFieldProps<T extends FieldValues = FieldValues> extends TextareaProps$1 {
+  name: FieldPath<T>;
+  label: FieldProps['label'];
+  helperText?: FieldProps['helperText'];
+  hideLabel?: FieldProps['hideLabel'];
+}
+declare const TextareaField: <T extends FieldValues>(props: TextareaFieldProps<T>) => react_jsx_runtime0.JSX.Element;
+//#endregion
+export { Textarea, TextareaField, type TextareaFieldProps, type TextareaProps };

package/dist/components/textarea/index.js

@@ -0,0 +1,22 @@
+import { styled } from "@pyck/styled-system/jsx";
+import { textarea } from "@pyck/styled-system/recipes";
+import { Field } from "@pyck/react/field";
+import { Controller, useFormContext } from "react-hook-form";
+import { Field as Field$1 } from "@ark-ui/react/field";
+import { Textarea as Textarea$1 } from "@pyck/react/textarea";
+
+//#region src/components/textarea/textarea.tsx
+const Textarea = styled(Field$1.Textarea, textarea);
+
+//#endregion
+//#region src/components/textarea/textarea-field.tsx
+const TextareaField = (props) => {
+	const { name, label, hideLabel, helperText, disabled, ...textareaProps } = props;
+	const { control } = useFormContext();
+	return <Controller name={name} control={control} render={({ field, fieldState }) => <Field label={label} helperText={helperText} hideLabel={hideLabel} disabled={field.disabled || disabled} invalid={!!fieldState.error} errorText={fieldState.error?.message}>
+          <Textarea$1 {...textareaProps} name={field.name} value={field.value} onChange={field.onChange} onBlur={field.onBlur} />
+        </Field>} />;
+};
+
+//#endregion
+export { Textarea, TextareaField };

package/dist/components/toast/index.d.ts

@@ -0,0 +1,25 @@
+import * as react from "react";
+import { ComponentProps, HTMLAttributes } from "react";
+import * as _pyck_styled_system_jsx0 from "@pyck/styled-system/jsx";
+import * as _pyck_styled_system_recipes0 from "@pyck/styled-system/recipes";
+import { CreateToasterReturn, Toast, ToastContext as Context } from "@ark-ui/react/toast";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/components/toast/toast.d.ts
+declare namespace toast_d_exports {
+  export { ActionTrigger, CloseTrigger, Context, Description, Indicator, Root, RootProps, Title };
+}
+type IndicatorProps = HTMLAttributes<SVGSVGElement>;
+type RootProps = ComponentProps<typeof Root>;
+declare const Root: _pyck_styled_system_jsx0.StyleContextProvider<react.ForwardRefExoticComponent<Toast.RootProps & react.RefAttributes<HTMLDivElement>>, _pyck_styled_system_recipes0.ToastRecipe>;
+declare const Title: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<Toast.TitleProps & react.RefAttributes<HTMLDivElement>>>;
+declare const Description: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<Toast.DescriptionProps & react.RefAttributes<HTMLDivElement>>>;
+declare const ActionTrigger: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<Toast.ActionTriggerProps & react.RefAttributes<HTMLButtonElement>>>;
+declare const CloseTrigger: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<Toast.CloseTriggerProps & react.RefAttributes<HTMLButtonElement>>>;
+declare const Indicator: react.ForwardRefExoticComponent<IndicatorProps & react.RefAttributes<SVGSVGElement>>;
+//#endregion
+//#region src/components/toast/toaster.d.ts
+declare const toaster: CreateToasterReturn;
+declare const Toaster: () => react_jsx_runtime0.JSX.Element;
+//#endregion
+export { toast_d_exports as Toast, Toaster, toaster };

package/dist/components/toast/index.js

@@ -0,0 +1,76 @@
+import { t as __exportAll } from "../../chunk-BYypO7fO.js";
+import { forwardRef } from "react";
+import { Stack, createStyleContext, styled } from "@pyck/styled-system/jsx";
+import { toast } from "@pyck/styled-system/recipes";
+import { CheckCircleIcon, CircleAlertIcon, CircleXIcon } from "lucide-react";
+import { Show } from "@pyck/react/show";
+import { Portal } from "@ark-ui/react/portal";
+import { CloseButton } from "@pyck/react/button";
+import { Icon } from "@pyck/react/icon";
+import { Spinner } from "@pyck/react/spinner";
+import { Toast, ToastContext as Context, Toaster as Toaster$1, createToaster, useToastContext } from "@ark-ui/react/toast";
+
+//#region src/components/toast/toast.tsx
+var toast_exports = /* @__PURE__ */ __exportAll({
+	ActionTrigger: () => ActionTrigger,
+	CloseTrigger: () => CloseTrigger,
+	Context: () => Context,
+	Description: () => Description,
+	Indicator: () => Indicator,
+	Root: () => Root,
+	Title: () => Title
+});
+const { withProvider, withContext } = createStyleContext(toast);
+const Root = withProvider(Toast.Root, "root");
+const Title = withContext(Toast.Title, "title");
+const Description = withContext(Toast.Description, "description");
+const ActionTrigger = withContext(Toast.ActionTrigger, "actionTrigger");
+const CloseTrigger = withContext(Toast.CloseTrigger, "closeTrigger");
+const iconMap = {
+	warning: CircleAlertIcon,
+	success: CheckCircleIcon,
+	error: CircleXIcon
+};
+const Indicator = forwardRef((props, ref) => {
+	const toast = useToastContext();
+	const StatusIcon = iconMap[toast.type];
+	if (!StatusIcon) return null;
+	return <Icon ref={ref} data-type={toast.type} {...props}>
+      <StatusIcon />
+    </Icon>;
+});
+
+//#endregion
+//#region src/components/toast/toaster.tsx
+const toaster = createToaster({
+	placement: "bottom-end",
+	pauseOnPageIdle: true,
+	duration: 4e3,
+	overlap: true,
+	max: 5
+});
+const StyledToaster = styled(Toaster$1);
+const Toaster = () => {
+	return <Portal>
+      <StyledToaster toaster={toaster} insetInline={{ mdDown: "4" }}>
+        {(toast) => <toast_exports.Root>
+            <Show when={toast.type === "loading"} fallback={<toast_exports.Indicator />}>
+              <Spinner />
+            </Show>
+            <Stack gap="3" alignItems="start">
+              <Stack gap="1">
+                {toast.title && <toast_exports.Title>{toast.title}</toast_exports.Title>}
+                {toast.description && <toast_exports.Description>{toast.description}</toast_exports.Description>}
+              </Stack>
+              {toast.action && <toast_exports.ActionTrigger>{toast.action.label}</toast_exports.ActionTrigger>}
+            </Stack>
+            {toast.closable && <toast_exports.CloseTrigger asChild>
+                <CloseButton size="sm" />
+              </toast_exports.CloseTrigger>}
+          </toast_exports.Root>}
+      </StyledToaster>
+    </Portal>;
+};
+
+//#endregion
+export { toast_exports as Toast, Toaster, toaster };

package/dist/components/toggle-group/index.d.ts

@@ -0,0 +1,16 @@
+import * as react from "react";
+import { ComponentProps } from "react";
+import * as _pyck_styled_system_jsx0 from "@pyck/styled-system/jsx";
+import * as _pyck_styled_system_recipes0 from "@pyck/styled-system/recipes";
+import { ToggleGroup, ToggleGroupContext as Context } from "@ark-ui/react/toggle-group";
+
+//#region src/components/toggle-group/toggle-group.d.ts
+declare namespace toggle_group_d_exports {
+  export { Context, Item, Root, RootProps, RootProvider };
+}
+type RootProps = ComponentProps<typeof Root>;
+declare const Root: _pyck_styled_system_jsx0.StyleContextProvider<react.ForwardRefExoticComponent<ToggleGroup.RootProps & react.RefAttributes<HTMLDivElement>>, _pyck_styled_system_recipes0.ToggleGroupRecipe>;
+declare const RootProvider: _pyck_styled_system_jsx0.StyleContextProvider<react.ForwardRefExoticComponent<ToggleGroup.RootProviderProps & react.RefAttributes<HTMLDivElement>>, _pyck_styled_system_recipes0.ToggleGroupRecipe>;
+declare const Item: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<ToggleGroup.ItemProps & react.RefAttributes<HTMLButtonElement>>>;
+//#endregion
+export { toggle_group_d_exports as ToggleGroup };

package/dist/components/toggle-group/index.js

@@ -0,0 +1,19 @@
+import { t as __exportAll } from "../../chunk-BYypO7fO.js";
+import { createStyleContext } from "@pyck/styled-system/jsx";
+import { toggleGroup } from "@pyck/styled-system/recipes";
+import { ToggleGroup, ToggleGroupContext as Context } from "@ark-ui/react/toggle-group";
+
+//#region src/components/toggle-group/toggle-group.tsx
+var toggle_group_exports = /* @__PURE__ */ __exportAll({
+	Context: () => Context,
+	Item: () => Item,
+	Root: () => Root,
+	RootProvider: () => RootProvider
+});
+const { withProvider, withContext } = createStyleContext(toggleGroup);
+const Root = withProvider(ToggleGroup.Root, "root");
+const RootProvider = withProvider(ToggleGroup.RootProvider, "root");
+const Item = withContext(ToggleGroup.Item, "item");
+
+//#endregion
+export { toggle_group_exports as ToggleGroup };

package/dist/components/tooltip/index.d.ts

@@ -0,0 +1,26 @@
+import * as react from "react";
+import { ComponentProps, ReactNode, RefObject } from "react";
+import * as _pyck_styled_system_jsx0 from "@pyck/styled-system/jsx";
+import * as _pyck_styled_system_recipes0 from "@pyck/styled-system/recipes";
+import { Tooltip as Tooltip$1 } from "@ark-ui/react/tooltip";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/components/tooltip/tooltip.d.ts
+type RootProps = ComponentProps<typeof Root>;
+type ContentProps = ComponentProps<typeof Content>;
+declare const Root: _pyck_styled_system_jsx0.StyleContextRootProvider<(props: Tooltip$1.RootProps) => react_jsx_runtime0.JSX.Element, _pyck_styled_system_recipes0.TooltipRecipe>;
+declare const Content: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<Tooltip$1.ContentProps & react.RefAttributes<HTMLDivElement>>>;
+//#endregion
+//#region src/components/tooltip/tooltip.closed.d.ts
+interface TooltipProps extends Omit<RootProps, 'content'> {
+  showArrow?: boolean;
+  portalled?: boolean;
+  portalRef?: RefObject<HTMLElement | null>;
+  children: ReactNode | undefined;
+  content: ReactNode | string;
+  contentProps?: ContentProps;
+  disabled?: boolean;
+}
+declare const Tooltip: react.ForwardRefExoticComponent<TooltipProps & react.RefAttributes<HTMLDivElement>>;
+//#endregion
+export { Tooltip, type TooltipProps };

package/dist/components/tooltip/index.js

@@ -0,0 +1,50 @@
+import { t as __exportAll } from "../../chunk-BYypO7fO.js";
+import { forwardRef } from "react";
+import { createStyleContext } from "@pyck/styled-system/jsx";
+import { tooltip } from "@pyck/styled-system/recipes";
+import { Portal } from "@ark-ui/react/portal";
+import { Tooltip as Tooltip$1, TooltipContext as Context } from "@ark-ui/react/tooltip";
+
+//#region src/components/tooltip/tooltip.tsx
+var tooltip_exports = /* @__PURE__ */ __exportAll({
+	Arrow: () => Arrow,
+	ArrowTip: () => ArrowTip,
+	Content: () => Content,
+	Context: () => Context,
+	Positioner: () => Positioner,
+	Root: () => Root,
+	Trigger: () => Trigger
+});
+const { withRootProvider, withContext } = createStyleContext(tooltip);
+const Root = withRootProvider(Tooltip$1.Root, { defaultProps: {
+	unmountOnExit: true,
+	lazyMount: true
+} });
+const Arrow = withContext(Tooltip$1.Arrow, "arrow");
+const ArrowTip = withContext(Tooltip$1.ArrowTip, "arrowTip");
+const Content = withContext(Tooltip$1.Content, "content");
+const Positioner = withContext(Tooltip$1.Positioner, "positioner");
+const Trigger = withContext(Tooltip$1.Trigger, "trigger");
+
+//#endregion
+//#region src/components/tooltip/tooltip.closed.tsx
+const Tooltip = forwardRef(function Tooltip(props, ref) {
+	const { showArrow, children, disabled, portalled = true, content, contentProps, portalRef, ...rootProps } = props;
+	if (disabled) return children;
+	return <tooltip_exports.Root {...rootProps}>
+      <tooltip_exports.Trigger asChild>{children}</tooltip_exports.Trigger>
+      <Portal disabled={!portalled} container={portalRef}>
+        <tooltip_exports.Positioner>
+          <tooltip_exports.Content ref={ref} {...contentProps}>
+            {showArrow && <tooltip_exports.Arrow>
+                <tooltip_exports.ArrowTip />
+              </tooltip_exports.Arrow>}
+            {content}
+          </tooltip_exports.Content>
+        </tooltip_exports.Positioner>
+      </Portal>
+    </tooltip_exports.Root>;
+});
+
+//#endregion
+export { Tooltip };

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

@@ -0,0 +1,37 @@
+import { TreeCollection } from "@ark-ui/react/collection";
+import * as react from "react";
+import { ComponentProps, RefAttributes } from "react";
+import * as _pyck_styled_system_jsx0 from "@pyck/styled-system/jsx";
+import { TreeViewVariantProps } from "@pyck/styled-system/recipes";
+import { TreeView, TreeViewContext as Context, TreeViewNodeProvider as NodeProvider, TreeViewNodeProviderProps as NodeProviderProps, TreeViewRootProps, createTreeCollection } from "@ark-ui/react/tree-view";
+import { Assign, HTMLStyledProps as HTMLStyledProps$1 } from "@pyck/styled-system/types";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/components/tree-view/tree-view.d.ts
+declare namespace tree_view_d_exports {
+  export { Branch, BranchContent, BranchControl, BranchIndentGuide, BranchIndicator, BranchText, Checkbox, Context, Item, ItemIndicator, ItemText, Label, NodeCheckbox, NodeCheckboxIndicator, NodeCheckboxProps, NodeProvider, NodeProviderProps, NodeRenameInput, Root, RootProps, Tree };
+}
+type StyleProps = TreeViewVariantProps & HTMLStyledProps$1<'div'>;
+type RootProps<T> = Assign<TreeViewRootProps<T>, StyleProps> & RefAttributes<HTMLDivElement>;
+type NodeCheckboxProps = ComponentProps<typeof NodeCheckbox>;
+declare const Root: TreeView.RootComponent<StyleProps>;
+declare const Branch: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<TreeView.BranchProps & RefAttributes<HTMLDivElement>>>;
+declare const BranchContent: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<TreeView.BranchContentProps & RefAttributes<HTMLDivElement>>>;
+declare const BranchControl: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<TreeView.BranchControlProps & RefAttributes<HTMLDivElement>>>;
+declare const BranchIndentGuide: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<TreeView.BranchIndentGuideProps & RefAttributes<HTMLDivElement>>>;
+declare const BranchText: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<TreeView.BranchTextProps & RefAttributes<HTMLSpanElement>>>;
+declare const Item: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<TreeView.ItemProps & RefAttributes<HTMLDivElement>>>;
+declare const ItemIndicator: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<TreeView.ItemIndicatorProps & RefAttributes<HTMLDivElement>>>;
+declare const ItemText: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<TreeView.ItemTextProps & RefAttributes<HTMLSpanElement>>>;
+declare const Label: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<TreeView.LabelProps & RefAttributes<HTMLHeadingElement>>>;
+declare const NodeCheckbox: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<TreeView.NodeCheckboxProps & RefAttributes<HTMLSpanElement>>>;
+declare const NodeRenameInput: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<TreeView.NodeRenameInputProps & RefAttributes<HTMLInputElement>>>;
+declare const Tree: _pyck_styled_system_jsx0.StyleContextConsumer<react.ForwardRefExoticComponent<TreeView.TreeProps & RefAttributes<HTMLDivElement>>>;
+declare const NodeCheckboxIndicator: {
+  (props: TreeView.NodeCheckboxIndicatorProps): react_jsx_runtime0.JSX.Element;
+  displayName: string;
+};
+declare const BranchIndicator: react.ForwardRefExoticComponent<Omit<HTMLStyledProps$1<"div">, "ref"> & RefAttributes<HTMLDivElement>>;
+declare const Checkbox: (props: NodeCheckboxProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+export { type TreeCollection, tree_view_d_exports as TreeView, createTreeCollection };

package/dist/components/tree-view/index.js

@@ -0,0 +1,63 @@
+import { t as __exportAll } from "../../chunk-BYypO7fO.js";
+import { forwardRef } from "react";
+import { createStyleContext } from "@pyck/styled-system/jsx";
+import { treeView } from "@pyck/styled-system/recipes";
+import { ChevronRightIcon } from "lucide-react";
+import { Show } from "@pyck/react/show";
+import { TreeView, TreeViewContext as Context, TreeViewNodeProvider as NodeProvider, createTreeCollection, useTreeViewNodeContext } from "@ark-ui/react/tree-view";
+import { Checkmark } from "@pyck/react/checkmark";
+
+//#region src/components/tree-view/tree-view.tsx
+var tree_view_exports = /* @__PURE__ */ __exportAll({
+	Branch: () => Branch,
+	BranchContent: () => BranchContent,
+	BranchControl: () => BranchControl,
+	BranchIndentGuide: () => BranchIndentGuide,
+	BranchIndicator: () => BranchIndicator,
+	BranchText: () => BranchText,
+	Checkbox: () => Checkbox,
+	Context: () => Context,
+	Item: () => Item,
+	ItemIndicator: () => ItemIndicator,
+	ItemText: () => ItemText,
+	Label: () => Label,
+	NodeCheckbox: () => NodeCheckbox,
+	NodeCheckboxIndicator: () => NodeCheckboxIndicator,
+	NodeProvider: () => NodeProvider,
+	NodeRenameInput: () => NodeRenameInput,
+	Root: () => Root,
+	Tree: () => Tree
+});
+const { withProvider, withContext } = createStyleContext(treeView);
+const Root = withProvider(TreeView.Root, "root");
+const Branch = withContext(TreeView.Branch, "branch");
+const BranchContent = withContext(TreeView.BranchContent, "branchContent");
+const BranchControl = withContext(TreeView.BranchControl, "branchControl");
+const BranchIndentGuide = withContext(TreeView.BranchIndentGuide, "branchIndentGuide");
+const BranchText = withContext(TreeView.BranchText, "branchText");
+const Item = withContext(TreeView.Item, "item");
+const ItemIndicator = withContext(TreeView.ItemIndicator, "itemIndicator");
+const ItemText = withContext(TreeView.ItemText, "itemText");
+const Label = withContext(TreeView.Label, "label");
+const NodeCheckbox = withContext(TreeView.NodeCheckbox, "nodeCheckbox");
+const NodeRenameInput = withContext(TreeView.NodeRenameInput, "nodeRenameInput");
+const Tree = withContext(TreeView.Tree, "tree");
+const NodeCheckboxIndicator = TreeView.NodeCheckboxIndicator;
+const StyledBranchIndicator = withContext(TreeView.BranchIndicator, "branchIndicator");
+const BranchIndicator = forwardRef(function BranchIndicator(props, ref) {
+	const node = useTreeViewNodeContext();
+	return <Show when={node.isBranch} fallback={<svg aria-hidden="true" focusable="false" />}>
+        <StyledBranchIndicator ref={ref} {...props}>
+          <ChevronRightIcon />
+        </StyledBranchIndicator>
+      </Show>;
+});
+const Checkbox = (props) => {
+	const node = useTreeViewNodeContext();
+	return <NodeCheckbox {...props}>
+      <Checkmark size="sm" checked={node.checked === true} indeterminate={node.checked === "indeterminate"} />
+    </NodeCheckbox>;
+};
+
+//#endregion
+export { tree_view_exports as TreeView, createTreeCollection };

package/dist/components/wrap/index.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from "react";
+
+//#region src/components/wrap/wrap.d.ts
+interface WrapProps {
+  when: boolean | undefined | null;
+  with: (children: ReactNode) => ReactNode;
+  children: ReactNode;
+}
+declare const Wrap: ({
+  when,
+  with: wrapper,
+  children
+}: WrapProps) => ReactNode;
+//#endregion
+export { Wrap, type WrapProps };

package/dist/components/wrap/index.js

@@ -0,0 +1,5 @@
+//#region src/components/wrap/wrap.tsx
+const Wrap = ({ when, with: wrapper, children }) => when ? wrapper(children) : children;
+
+//#endregion
+export { Wrap };

package/dist/display-date-value-CdfgVuB7.d.ts

@@ -0,0 +1,15 @@
+import { DateInput, Locale, getDateFormats } from "@pyck/react/utils";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/components/display-date-value/display-date-value.d.ts
+type DateFormatType = keyof ReturnType<typeof getDateFormats> | (string & {});
+interface DisplayDateValueProps {
+  value: DateInput;
+  format?: DateFormatType;
+  type?: 'date' | 'time' | 'datetime' | 'relative';
+  locale?: Locale;
+  copyable?: boolean;
+}
+declare const DisplayDateValue: (props: DisplayDateValueProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+export { DisplayDateValue as n, DisplayDateValueProps as r, DateFormatType as t };

package/dist/display-date-value-gTlidtNz.js

@@ -0,0 +1,21 @@
+import { t as DisplayValue } from "./display-value-BNKxQ99u.js";
+import { formatDate, formatDateTime, getDateFormats, isString } from "@pyck/react/utils";
+
+//#region src/components/display-date-value/display-date-value.tsx
+const DisplayDateValue = (props) => {
+	const { value, format, copyable, type = "date", locale: localeProp } = props;
+	const locale = localeProp ?? "en-US";
+	const formatValue = (date) => {
+		if (format && isString(format) && !isDateFormatKey(format, locale)) return formatDate(date, format, locale);
+		if (format && isDateFormatKey(format, locale)) return formatDate(date, getDateFormats(locale)[format], locale);
+		return formatDateTime(date, type, locale);
+	};
+	return <DisplayValue value={value} formatValue={formatValue} copyable={copyable} />;
+};
+const isDateFormatKey = (format, locale) => {
+	const formats = getDateFormats(locale);
+	return Object.keys(formats).includes(format);
+};
+
+//#endregion
+export { DisplayDateValue as t };

package/dist/display-value-BNKxQ99u.js

@@ -0,0 +1,37 @@
+import { HStack, VisuallyHidden } from "@pyck/styled-system/jsx";
+import { isString } from "@pyck/react/utils";
+import { Show } from "@pyck/react/show";
+import { Clipboard } from "@pyck/react/clipboard";
+import { Span } from "@pyck/react/span";
+import { Wrap } from "@pyck/react/wrap";
+
+//#region src/components/display-value/display-value.tsx
+const DisplayValue = (props) => {
+	const { value, copyable, formatValue } = props;
+	const formattedValue = isNotEmpty(value) ? formatValue?.(value) ?? String(value) : null;
+	return <Show when={formattedValue != null} fallback={<>
+          <Span color="fg.subtle" aria-hidden>
+            —
+          </Span>
+          <VisuallyHidden>No value</VisuallyHidden>
+        </>}>
+      <Wrap when={copyable} with={(children) => <Clipboard.Root value={formattedValue} timeout={400}>
+            <Clipboard.Trigger _hover={{ "& [data-part=\"indicator\"]": { opacity: 1 } }} _active={{ "& [data-part=\"indicator\"]": { opacity: 1 } }}>
+              <HStack>
+                <Clipboard.Indicator color="fg.subtle" opacity="0" />
+                <Span>{children}</Span>
+              </HStack>
+            </Clipboard.Trigger>
+          </Clipboard.Root>}>
+        {formattedValue}
+      </Wrap>
+    </Show>;
+};
+const isNotEmpty = (value) => {
+	if (value == null) return false;
+	if (isString(value) || Array.isArray(value)) return value.length > 0;
+	return true;
+};
+
+//#endregion
+export { DisplayValue as t };

package/dist/display-value-IyQT1429.d.ts

@@ -0,0 +1,11 @@
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/components/display-value/display-value.d.ts
+interface DisplayValueProps<T> {
+  value?: T | null | undefined;
+  formatValue?: (value: NonNullable<T>) => string | null | undefined;
+  copyable?: boolean;
+}
+declare const DisplayValue: <T>(props: DisplayValueProps<T>) => react_jsx_runtime0.JSX.Element;
+//#endregion
+export { DisplayValueProps as n, DisplayValue as t };