@ark-ui/solid 4.1.0 → 4.2.1

package/dist/chunk/OBGOP5NZ.js

@@ -0,0 +1,126 @@
+import { useFieldContext } from './B2OPFF7J.js';
+import { createSplitProps } from './ZMHI4GDJ.js';
+import { ark } from './EPLBB4QN.js';
+import { useLocaleContext } from './HPDOBQ3V.js';
+import { useEnvironmentContext } from './QODB3C3M.js';
+import { createContext } from './I5UG2QUO.js';
+import { __export } from './ESLJRKWD.js';
+import { createComponent, mergeProps as mergeProps$1 } from 'solid-js/web';
+import { mergeProps, useMachine, normalizeProps } from '@zag-js/solid';
+import { createMemo, createUniqueId } from 'solid-js';
+import * as rating from '@zag-js/rating-group';
+export { anatomy } from '@zag-js/rating-group';
+
+// src/components/rating-group/use-rating-group-context.ts
+var [RatingGroupProvider, useRatingGroupContext] = createContext({
+  hookName: "useRatingGroupContext",
+  providerName: "<RatingGroupProvider />"
+});
+
+// src/components/rating-group/rating-group-context.tsx
+var RatingGroupContext = (props) => props.children(useRatingGroupContext());
+var RatingGroupControl = (props) => {
+  const ratingGroup = useRatingGroupContext();
+  const mergedProps = mergeProps(() => ratingGroup().getControlProps(), props);
+  return createComponent(ark.div, mergedProps);
+};
+var RatingGroupHiddenInput = (props) => {
+  const ratingGroup = useRatingGroupContext();
+  const mergedProps = mergeProps(() => ratingGroup().getHiddenInputProps(), props);
+  const field = useFieldContext();
+  return createComponent(ark.input, mergeProps$1({
+    get ["aria-describedby"]() {
+      return field?.().ariaDescribedby;
+    }
+  }, mergedProps));
+};
+
+// src/components/rating-group/use-rating-group-item-context.ts
+var [RatingGroupItemProvider, useRatingGroupItemContext] = createContext({
+  hookName: "useRatingGroupItemContext",
+  providerName: "<RatingGroupItemProvider />"
+});
+
+// src/components/rating-group/rating-group-item.tsx
+var RatingGroupItem = (props) => {
+  const [itemProps, localProps] = createSplitProps()(props, ["index"]);
+  const api = useRatingGroupContext();
+  const mergedProps = mergeProps(() => api().getItemProps(itemProps), localProps);
+  const itemState = createMemo(() => api().getItemState(itemProps));
+  return createComponent(RatingGroupItemProvider, {
+    value: itemState,
+    get children() {
+      return createComponent(ark.span, mergedProps);
+    }
+  });
+};
+
+// src/components/rating-group/rating-group-item-context.tsx
+var RatingGroupItemContext = (props) => props.children(useRatingGroupItemContext());
+var RatingGroupLabel = (props) => {
+  const api = useRatingGroupContext();
+  const mergedProps = mergeProps(() => api().getLabelProps(), props);
+  return createComponent(ark.label, mergedProps);
+};
+var useRatingGroup = (props) => {
+  const locale = useLocaleContext();
+  const environment = useEnvironmentContext();
+  const id = createUniqueId();
+  const field = useFieldContext();
+  const context = createMemo(() => ({
+    id,
+    ids: {
+      label: field?.().ids.label,
+      hiddenInput: field?.().ids.control
+    },
+    disabled: field?.().disabled,
+    readOnly: field?.().readOnly,
+    required: field?.().required,
+    dir: locale().dir,
+    getRootNode: environment().getRootNode,
+    value: props.defaultValue,
+    ...props
+  }));
+  const [state, send] = useMachine(rating.machine(context()), { context });
+  return createMemo(() => rating.connect(state, send, normalizeProps));
+};
+
+// src/components/rating-group/rating-group-root.tsx
+var RatingGroupRoot = (props) => {
+  const [useRatingProps, localProps] = createSplitProps()(props, ["allowHalf", "autoFocus", "count", "defaultValue", "disabled", "form", "id", "ids", "name", "onHoverChange", "onValueChange", "readOnly", "required", "translations", "value"]);
+  const api = useRatingGroup(useRatingProps);
+  const mergedProps = mergeProps(() => api().getRootProps(), localProps);
+  return createComponent(RatingGroupProvider, {
+    value: api,
+    get children() {
+      return createComponent(ark.div, mergedProps);
+    }
+  });
+};
+var RatingGroupRootProvider = (props) => {
+  const [{
+    value: ratingGroup
+  }, localProps] = createSplitProps()(props, ["value"]);
+  const mergedProps = mergeProps(() => ratingGroup().getRootProps(), localProps);
+  return createComponent(RatingGroupProvider, {
+    value: ratingGroup,
+    get children() {
+      return createComponent(ark.div, mergedProps);
+    }
+  });
+};
+
+// src/components/rating-group/rating-group.ts
+var rating_group_exports = {};
+__export(rating_group_exports, {
+  Context: () => RatingGroupContext,
+  Control: () => RatingGroupControl,
+  HiddenInput: () => RatingGroupHiddenInput,
+  Item: () => RatingGroupItem,
+  ItemContext: () => RatingGroupItemContext,
+  Label: () => RatingGroupLabel,
+  Root: () => RatingGroupRoot,
+  RootProvider: () => RatingGroupRootProvider
+});
+
+export { RatingGroupContext, RatingGroupControl, RatingGroupHiddenInput, RatingGroupItem, RatingGroupItemContext, RatingGroupLabel, RatingGroupRoot, RatingGroupRootProvider, rating_group_exports, useRatingGroup, useRatingGroupContext, useRatingGroupItemContext };

package/dist/chunk/OMSDY5OI.jsx

@@ -0,0 +1,180 @@
+import {
+  PresenceProvider,
+  splitPresenceProps,
+  usePresence,
+  usePresenceContext
+} from "./E72NMPSK.jsx";
+import {
+  createSplitProps
+} from "./6WEDGJKQ.jsx";
+import {
+  ark
+} from "./UFYZ7HLU.jsx";
+import {
+  useLocaleContext
+} from "./3QQZKR3F.jsx";
+import {
+  useEnvironmentContext
+} from "./5O4RWSWO.jsx";
+import {
+  createContext
+} from "./NMGUCD2L.jsx";
+import {
+  __export
+} from "./7IUG3E2V.jsx";
+
+// src/components/tooltip/tooltip-arrow.tsx
+import { mergeProps } from "@zag-js/solid";
+
+// src/components/tooltip/use-tooltip-context.ts
+var [TooltipProvider, useTooltipContext] = createContext({
+  hookName: "useTooltipContext",
+  providerName: "<TooltipProvider />"
+});
+
+// src/components/tooltip/tooltip-arrow.tsx
+var TooltipArrow = (props) => {
+  const tooltip2 = useTooltipContext();
+  const mergedProps = mergeProps(() => tooltip2().getArrowProps(), props);
+  return <ark.div {...mergedProps} />;
+};
+
+// src/components/tooltip/tooltip-arrow-tip.tsx
+import { mergeProps as mergeProps2 } from "@zag-js/solid";
+var TooltipArrowTip = (props) => {
+  const api = useTooltipContext();
+  const mergedProps = mergeProps2(() => api().getArrowTipProps(), props);
+  return <ark.div {...mergedProps} />;
+};
+
+// src/components/tooltip/tooltip-content.tsx
+import { mergeProps as mergeProps3 } from "@zag-js/solid";
+import { Show } from "solid-js";
+var TooltipContent = (props) => {
+  const api = useTooltipContext();
+  const presenceApi = usePresenceContext();
+  const mergedProps = mergeProps3(
+    () => api().getContentProps(),
+    () => presenceApi().presenceProps,
+    props
+  );
+  return <Show when={!presenceApi().unmounted}>
+      <ark.div {...mergedProps} />
+    </Show>;
+};
+
+// src/components/tooltip/tooltip-context.tsx
+var TooltipContext = (props) => props.children(useTooltipContext());
+
+// src/components/tooltip/tooltip-positioner.tsx
+import { mergeProps as mergeProps4 } from "@zag-js/solid";
+import { Show as Show2 } from "solid-js";
+var TooltipPositioner = (props) => {
+  const api = useTooltipContext();
+  const presenceApi = usePresenceContext();
+  const mergedProps = mergeProps4(() => api().getPositionerProps(), props);
+  return <Show2 when={!presenceApi().unmounted}>
+      <ark.div {...mergedProps} />
+    </Show2>;
+};
+
+// src/components/tooltip/tooltip-root.tsx
+import { mergeProps as mergeProps5 } from "@zag-js/solid";
+
+// src/components/tooltip/use-tooltip.ts
+import { normalizeProps, useMachine } from "@zag-js/solid";
+import * as tooltip from "@zag-js/tooltip";
+import { createMemo, createUniqueId } from "solid-js";
+var useTooltip = (props) => {
+  const locale = useLocaleContext();
+  const environment = useEnvironmentContext();
+  const id = createUniqueId();
+  const context = createMemo(() => ({
+    id,
+    dir: locale().dir,
+    getRootNode: environment().getRootNode,
+    open: props.defaultOpen,
+    "open.controlled": props.open !== void 0,
+    ...props
+  }));
+  const [state, send] = useMachine(tooltip.machine(context()), { context });
+  return createMemo(() => tooltip.connect(state, send, normalizeProps));
+};
+
+// src/components/tooltip/tooltip-root.tsx
+var TooltipRoot = (props) => {
+  const [presenceProps, tooltipProps] = splitPresenceProps(props);
+  const [useTooltipProps, localProps] = createSplitProps()(tooltipProps, [
+    "aria-label",
+    "closeDelay",
+    "closeOnClick",
+    "closeOnEscape",
+    "closeOnPointerDown",
+    "closeOnScroll",
+    "defaultOpen",
+    "disabled",
+    "id",
+    "ids",
+    "interactive",
+    "onOpenChange",
+    "open",
+    "openDelay",
+    "positioning"
+  ]);
+  const api = useTooltip(useTooltipProps);
+  const apiPresence = usePresence(mergeProps5(presenceProps, () => ({ present: api().open })));
+  return <TooltipProvider value={api}>
+      <PresenceProvider value={apiPresence}>{localProps.children}</PresenceProvider>
+    </TooltipProvider>;
+};
+
+// src/components/tooltip/tooltip-root-provider.tsx
+import { mergeProps as mergeProps6 } from "@zag-js/solid";
+var TooltipRootProvider = (props) => {
+  const [presenceProps, tooltipProps] = splitPresenceProps(props);
+  const presence = usePresence(
+    mergeProps6(presenceProps, () => ({ present: tooltipProps.value().open }))
+  );
+  return <TooltipProvider value={tooltipProps.value}>
+      <PresenceProvider value={presence}>{tooltipProps.children}</PresenceProvider>
+    </TooltipProvider>;
+};
+
+// src/components/tooltip/tooltip-trigger.tsx
+import { mergeProps as mergeProps7 } from "@zag-js/solid";
+var TooltipTrigger = (props) => {
+  const api = useTooltipContext();
+  const mergedProps = mergeProps7(() => api().getTriggerProps(), props);
+  return <ark.button {...mergedProps} />;
+};
+
+// src/components/tooltip/tooltip.anatomy.ts
+import { anatomy } from "@zag-js/tooltip";
+
+// src/components/tooltip/tooltip.ts
+var tooltip_exports = {};
+__export(tooltip_exports, {
+  Arrow: () => TooltipArrow,
+  ArrowTip: () => TooltipArrowTip,
+  Content: () => TooltipContent,
+  Context: () => TooltipContext,
+  Positioner: () => TooltipPositioner,
+  Root: () => TooltipRoot,
+  RootProvider: () => TooltipRootProvider,
+  Trigger: () => TooltipTrigger
+});
+
+export {
+  useTooltipContext,
+  TooltipArrow,
+  TooltipArrowTip,
+  TooltipContent,
+  TooltipContext,
+  TooltipPositioner,
+  useTooltip,
+  TooltipRoot,
+  TooltipRootProvider,
+  TooltipTrigger,
+  anatomy,
+  tooltip_exports
+};

package/dist/chunk/OYTB5QWY.js

@@ -0,0 +1,102 @@
+import { createSplitProps } from './ZMHI4GDJ.js';
+import { ark } from './EPLBB4QN.js';
+import { useEnvironmentContext } from './QODB3C3M.js';
+import { createContext } from './I5UG2QUO.js';
+import { __export } from './ESLJRKWD.js';
+import { createComponent, mergeProps as mergeProps$1 } from 'solid-js/web';
+import { mergeProps, useMachine, normalizeProps } from '@zag-js/solid';
+import * as timer from '@zag-js/timer';
+export { anatomy } from '@zag-js/timer';
+import { createUniqueId, createMemo } from 'solid-js';
+
+// src/components/timer/use-timer-context.ts
+var [TimerProvider, useTimerContext] = createContext({
+  hookName: "useTimerContext",
+  providerName: "<TimerProvider />"
+});
+
+// src/components/timer/timer-action-trigger.tsx
+var TimerActionTrigger = (props) => {
+  const timer2 = useTimerContext();
+  const mergedProps = mergeProps(() => timer2().getActionTriggerProps(props), props);
+  return createComponent(ark.button, mergedProps);
+};
+
+// src/components/timer/timer-context.tsx
+var TimerContext = (props) => props.children(useTimerContext());
+var TimerItem = (props) => {
+  const [itemProps, localProps] = createSplitProps()(props, ["type"]);
+  const timer2 = useTimerContext();
+  const mergedProps = mergeProps(() => timer2().getItemProps(itemProps), localProps);
+  return createComponent(ark.div, mergeProps$1(mergedProps, {
+    get children() {
+      return timer2().formattedTime[itemProps.type];
+    }
+  }));
+};
+var TimerArea = (props) => {
+  const timer2 = useTimerContext();
+  const mergedProps = mergeProps(() => timer2().getAreaProps(), props);
+  return createComponent(ark.div, mergedProps);
+};
+var TimerControl = (props) => {
+  const timer2 = useTimerContext();
+  const mergedProps = mergeProps(() => timer2().getControlProps(), props);
+  return createComponent(ark.div, mergedProps);
+};
+var useTimer = (props) => {
+  const env = useEnvironmentContext();
+  const id = createUniqueId();
+  const context = createMemo(() => ({
+    id,
+    getRootNode: env().getRootNode,
+    ...props
+  }));
+  const [state, send] = useMachine(timer.machine(context()), { context });
+  return createMemo(() => timer.connect(state, send, normalizeProps));
+};
+
+// src/components/timer/timer-root.tsx
+var TimerRoot = (props) => {
+  const [useTimerProps, localProps] = createSplitProps()(props, ["id", "ids", "autoStart", "interval", "countdown", "startMs", "targetMs", "onComplete", "onTick"]);
+  const timer2 = useTimer(useTimerProps);
+  const mergedProps = mergeProps(() => timer2().getRootProps(), localProps);
+  return createComponent(TimerProvider, {
+    value: timer2,
+    get children() {
+      return createComponent(ark.div, mergedProps);
+    }
+  });
+};
+var TimerRootProvider = (props) => {
+  const [{
+    value: timer2
+  }, localProps] = createSplitProps()(props, ["value"]);
+  const mergedProps = mergeProps(() => timer2().getRootProps(), localProps);
+  return createComponent(TimerProvider, {
+    value: timer2,
+    get children() {
+      return createComponent(ark.div, mergedProps);
+    }
+  });
+};
+var TimerSeparator = (props) => {
+  const timer2 = useTimerContext();
+  const mergedProps = mergeProps(() => timer2().getSeparatorProps(), props);
+  return createComponent(ark.div, mergedProps);
+};
+
+// src/components/timer/timer.ts
+var timer_exports = {};
+__export(timer_exports, {
+  ActionTrigger: () => TimerActionTrigger,
+  Area: () => TimerArea,
+  Context: () => TimerContext,
+  Control: () => TimerControl,
+  Item: () => TimerItem,
+  Root: () => TimerRoot,
+  RootProvider: () => TimerRootProvider,
+  Separator: () => TimerSeparator
+});
+
+export { TimerActionTrigger, TimerArea, TimerContext, TimerControl, TimerItem, TimerRoot, TimerRootProvider, TimerSeparator, timer_exports, useTimer, useTimerContext };

package/dist/chunk/PIUV7KP7.js

@@ -0,0 +1,28 @@
+import { ListCollection } from '@zag-js/collection';
+
+// src/components/collection.ts
+
+// ../../node_modules/@zag-js/store/dist/index.mjs
+function getGlobal() {
+  if (typeof globalThis !== "undefined") return globalThis;
+  if (typeof self !== "undefined") return self;
+  if (typeof window !== "undefined") return window;
+  if (typeof global !== "undefined") return global;
+}
+function makeGlobal(key, value) {
+  const g = getGlobal();
+  if (!g) return value();
+  g[key] || (g[key] = value());
+  return g[key];
+}
+makeGlobal("__zag__proxyStateMap", () => /* @__PURE__ */ new WeakMap());
+var refSet = makeGlobal("__zag__refSet", () => /* @__PURE__ */ new WeakSet());
+function ref(obj) {
+  refSet.add(obj);
+  return obj;
+}
+
+// src/components/collection.ts
+var createListCollection = (options) => ref(new ListCollection(options));
+
+export { createListCollection };

package/dist/chunk/Q3GD7QM3.js

@@ -0,0 +1,128 @@
+import { usePresence, PresenceProvider } from './LCESUDZB.js';
+import { useRenderStrategyContext, splitRenderStrategyProps, RenderStrategyProvider } from './L7OSYHVR.js';
+import { createSplitProps } from './ZMHI4GDJ.js';
+import { ark } from './EPLBB4QN.js';
+import { useLocaleContext } from './HPDOBQ3V.js';
+import { useEnvironmentContext } from './QODB3C3M.js';
+import { createContext } from './I5UG2QUO.js';
+import { __export } from './ESLJRKWD.js';
+import { createComponent } from 'solid-js/web';
+import { mergeProps, useMachine, normalizeProps } from '@zag-js/solid';
+import { Show, createUniqueId, createMemo } from 'solid-js';
+import * as tabs from '@zag-js/tabs';
+export { anatomy } from '@zag-js/tabs';
+
+// src/components/tabs/use-tabs-context.ts
+var [TabsProvider, useTabsContext] = createContext({
+  hookName: "useTabsContext",
+  providerName: "<TabsProvider />"
+});
+
+// src/components/tabs/tab-content.tsx
+var TabContent = (props) => {
+  const [contentProps, localProps] = createSplitProps()(props, ["value"]);
+  const api = useTabsContext();
+  const renderStrategyProps = useRenderStrategyContext();
+  const presenceApi = usePresence(mergeProps(renderStrategyProps, () => ({
+    present: api().value === contentProps.value,
+    immediate: true
+  })));
+  const mergedProps = mergeProps(() => api().getContentProps(contentProps), () => presenceApi().presenceProps, localProps);
+  return createComponent(PresenceProvider, {
+    value: presenceApi,
+    get children() {
+      return createComponent(Show, {
+        get when() {
+          return !presenceApi().unmounted;
+        },
+        get children() {
+          return createComponent(ark.div, mergedProps);
+        }
+      });
+    }
+  });
+};
+var TabIndicator = (props) => {
+  const api = useTabsContext();
+  const mergedProps = mergeProps(() => api().getIndicatorProps(), props);
+  return createComponent(ark.div, mergedProps);
+};
+var TabList = (props) => {
+  const api = useTabsContext();
+  const mergedProps = mergeProps(() => api().getListProps(), props);
+  return createComponent(ark.div, mergedProps);
+};
+var TabTrigger = (props) => {
+  const [triggerProps, localProps] = createSplitProps()(props, ["disabled", "value"]);
+  const api = useTabsContext();
+  const mergedProps = mergeProps(() => api().getTriggerProps(triggerProps), localProps);
+  return createComponent(ark.button, mergedProps);
+};
+
+// src/components/tabs/tabs-context.tsx
+var TabsContext = (props) => props.children(useTabsContext());
+var useTabs = (props) => {
+  const locale = useLocaleContext();
+  const environment = useEnvironmentContext();
+  const id = createUniqueId();
+  const context = createMemo(() => ({
+    id,
+    dir: locale().dir,
+    getRootNode: environment().getRootNode,
+    value: props.defaultValue,
+    ...props
+  }));
+  const [state, send] = useMachine(tabs.machine(context()), { context });
+  return createMemo(() => tabs.connect(state, send, normalizeProps));
+};
+
+// src/components/tabs/tabs-root.tsx
+var TabsRoot = (props) => {
+  const [renderStrategyProps, tabsProps] = splitRenderStrategyProps(props);
+  const [useTabsProps, restProps] = createSplitProps()(tabsProps, ["activationMode", "composite", "defaultValue", "deselectable", "id", "ids", "loopFocus", "onFocusChange", "onValueChange", "orientation", "translations", "value"]);
+  const api = useTabs(useTabsProps);
+  const mergedProps = mergeProps(() => api().getRootProps(), restProps);
+  return createComponent(TabsProvider, {
+    value: api,
+    get children() {
+      return createComponent(RenderStrategyProvider, {
+        value: renderStrategyProps,
+        get children() {
+          return createComponent(ark.div, mergedProps);
+        }
+      });
+    }
+  });
+};
+var TabsRootProvider = (props) => {
+  const [renderStrategyProps, tabsProps] = splitRenderStrategyProps(props);
+  const [{
+    value: tabs2
+  }, localprops] = createSplitProps()(tabsProps, ["value"]);
+  const mergedProps = mergeProps(() => tabs2().getRootProps(), localprops);
+  return createComponent(TabsProvider, {
+    value: tabs2,
+    get children() {
+      return createComponent(RenderStrategyProvider, {
+        value: renderStrategyProps,
+        get children() {
+          return createComponent(ark.div, mergedProps);
+        }
+      });
+    }
+  });
+};
+
+// src/components/tabs/tabs.ts
+var tabs_exports = {};
+__export(tabs_exports, {
+  Content: () => TabContent,
+  Context: () => TabsContext,
+  Indicator: () => TabIndicator,
+  List: () => TabList,
+  Root: () => TabsRoot,
+  RootProvider: () => TabsRootProvider,
+  Trigger: () => TabTrigger
+});
+
+export { TabContent, TabIndicator, TabList, TabTrigger, TabsContext, TabsRoot, TabsRootProvider, tabs_exports, useTabs, useTabsContext };