@ark-ui/solid 4.1.0 → 4.2.1

package/dist/chunk/IYVZTV3F.jsx

@@ -0,0 +1,218 @@
+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/slider/use-slider-context.ts
+var [SliderProvider, useSliderContext] = createContext({
+  hookName: "useSliderContext",
+  providerName: "<SliderProvider />"
+});
+
+// src/components/slider/slider-context.tsx
+var SliderContext = (props) => props.children(useSliderContext());
+
+// src/components/slider/slider-control.tsx
+import { mergeProps } from "@zag-js/solid";
+var SliderControl = (props) => {
+  const api = useSliderContext();
+  const mergedProps = mergeProps(() => api().getControlProps(), props);
+  return <ark.div {...mergedProps} />;
+};
+
+// src/components/slider/slider-hidden-input.tsx
+import { mergeProps as mergeProps2 } from "@zag-js/solid";
+
+// src/components/slider/use-slider-thumb-props-context.ts
+var [SliderThumbPropsProvider, useSliderThumbPropsContext] = createContext({
+  hookName: "useSliderThumbPropsContext",
+  providerName: "<SliderThumbPropsProvider />"
+});
+
+// src/components/slider/slider-hidden-input.tsx
+var SliderHiddenInput = (props) => {
+  const slider2 = useSliderContext();
+  const thumbProps = useSliderThumbPropsContext();
+  const mergedProps = mergeProps2(slider2().getHiddenInputProps(thumbProps), props);
+  return <ark.input {...mergedProps} />;
+};
+
+// src/components/slider/slider-label.tsx
+import { mergeProps as mergeProps3 } from "@zag-js/solid";
+var SliderLabel = (props) => {
+  const api = useSliderContext();
+  const mergedProps = mergeProps3(() => api().getLabelProps(), props);
+  return <ark.label {...mergedProps} />;
+};
+
+// src/components/slider/slider-marker.tsx
+import { mergeProps as mergeProps4 } from "@zag-js/solid";
+var SliderMarker = (props) => {
+  const [markerProps, localProps] = createSplitProps()(props, ["value"]);
+  const api = useSliderContext();
+  const mergedProps = mergeProps4(() => api().getMarkerProps(markerProps), localProps);
+  return <ark.span {...mergedProps} />;
+};
+
+// src/components/slider/slider-marker-group.tsx
+import { mergeProps as mergeProps5 } from "@zag-js/solid";
+var SliderMarkerGroup = (props) => {
+  const api = useSliderContext();
+  const mergedProps = mergeProps5(() => api().getMarkerGroupProps(), props);
+  return <ark.div {...mergedProps} />;
+};
+
+// src/components/slider/slider-range.tsx
+import { mergeProps as mergeProps6 } from "@zag-js/solid";
+var SliderRange = (props) => {
+  const api = useSliderContext();
+  const mergedProps = mergeProps6(() => api().getRangeProps(), props);
+  return <ark.div {...mergedProps} />;
+};
+
+// src/components/slider/slider-root.tsx
+import { mergeProps as mergeProps7 } from "@zag-js/solid";
+
+// src/components/slider/use-slider.ts
+import * as slider from "@zag-js/slider";
+import { normalizeProps, useMachine } from "@zag-js/solid";
+import { createMemo, createUniqueId } from "solid-js";
+var useSlider = (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(slider.machine(context()), { context });
+  return createMemo(() => slider.connect(state, send, normalizeProps));
+};
+
+// src/components/slider/slider-root.tsx
+var SliderRoot = (props) => {
+  const [useSliderProps, localProps] = createSplitProps()(props, [
+    "aria-label",
+    "aria-labelledby",
+    "defaultValue",
+    "disabled",
+    "form",
+    "getAriaValueText",
+    "id",
+    "ids",
+    "invalid",
+    "max",
+    "min",
+    "minStepsBetweenThumbs",
+    "name",
+    "onFocusChange",
+    "onValueChange",
+    "onValueChangeEnd",
+    "orientation",
+    "origin",
+    "readOnly",
+    "step",
+    "thumbAlignment",
+    "thumbAlignment",
+    "thumbSize",
+    "value"
+  ]);
+  const api = useSlider(useSliderProps);
+  const mergedProps = mergeProps7(() => api().getRootProps(), localProps);
+  return <SliderProvider value={api}>
+      <ark.div {...mergedProps} />
+    </SliderProvider>;
+};
+
+// src/components/slider/slider-root-provider.tsx
+import { mergeProps as mergeProps8 } from "@zag-js/solid";
+var SliderRootProvider = (props) => {
+  const [{ value: slider2 }, localProps] = createSplitProps()(props, ["value"]);
+  const mergedProps = mergeProps8(() => slider2().getRootProps(), localProps);
+  return <SliderProvider value={slider2}>
+      <ark.div {...mergedProps} />
+    </SliderProvider>;
+};
+
+// src/components/slider/slider-thumb.tsx
+import { mergeProps as mergeProps9 } from "@zag-js/solid";
+var SliderThumb = (props) => {
+  const [thumbProps, localProps] = createSplitProps()(props, ["index", "name"]);
+  const slider2 = useSliderContext();
+  const mergedProps = mergeProps9(() => slider2().getThumbProps(thumbProps), localProps);
+  return <SliderThumbPropsProvider value={thumbProps}>
+      <ark.div {...mergedProps} />
+    </SliderThumbPropsProvider>;
+};
+
+// src/components/slider/slider-track.tsx
+import { mergeProps as mergeProps10 } from "@zag-js/solid";
+var SliderTrack = (props) => {
+  const api = useSliderContext();
+  const mergedProps = mergeProps10(() => api().getTrackProps(), props);
+  return <ark.div {...mergedProps} />;
+};
+
+// src/components/slider/slider-value-text.tsx
+import { mergeProps as mergeProps11 } from "@zag-js/solid";
+var SliderValueText = (props) => {
+  const api = useSliderContext();
+  const mergedProps = mergeProps11(() => api().getValueTextProps(), props);
+  return <ark.span {...mergedProps}>{props.children || api().value.join(",")}</ark.span>;
+};
+
+// src/components/slider/slider.anatomy.ts
+import { anatomy } from "@zag-js/slider";
+
+// src/components/slider/slider.ts
+var slider_exports = {};
+__export(slider_exports, {
+  Context: () => SliderContext,
+  Control: () => SliderControl,
+  HiddenInput: () => SliderHiddenInput,
+  Label: () => SliderLabel,
+  Marker: () => SliderMarker,
+  MarkerGroup: () => SliderMarkerGroup,
+  Range: () => SliderRange,
+  Root: () => SliderRoot,
+  RootProvider: () => SliderRootProvider,
+  Thumb: () => SliderThumb,
+  Track: () => SliderTrack,
+  ValueText: () => SliderValueText
+});
+
+export {
+  useSliderContext,
+  SliderContext,
+  SliderControl,
+  SliderHiddenInput,
+  SliderLabel,
+  SliderMarker,
+  SliderMarkerGroup,
+  SliderRange,
+  useSlider,
+  SliderRoot,
+  SliderRootProvider,
+  SliderThumb,
+  SliderTrack,
+  SliderValueText,
+  anatomy,
+  slider_exports
+};

package/dist/chunk/JTHKX457.js

@@ -0,0 +1,130 @@
+import { EnvironmentProvider } from './QODB3C3M.js';
+import { createComponent, use, spread, insert, Portal, template } from 'solid-js/web';
+import { splitProps, createMemo, createSignal, createEffect, onCleanup, Show } from 'solid-js';
+
+// src/utils/compose-refs.ts
+var isRefFn = (ref) => typeof ref === "function";
+function setRef(ref, value) {
+  if (isRefFn(ref)) {
+    ref(value);
+  }
+}
+function composeRefs(...refs) {
+  return (node) => {
+    for (const ref of refs) {
+      setRef(ref, node);
+    }
+  };
+}
+var FrameContent = (props) => {
+  const {
+    onMount,
+    onUnmount,
+    children
+  } = props;
+  createEffect(() => {
+    onMount?.();
+    onCleanup(() => {
+      onUnmount?.();
+    });
+  });
+  return children;
+};
+
+// src/components/frame/frame.tsx
+var _tmpl$ = /* @__PURE__ */ template(`<iframe>`);
+var resetStyle = "<style>*,*::before,*::after { margin: 0; padding: 0; box-sizing: border-box; }</style>";
+var initialSrcDoc = `<html><head>${resetStyle}</head><body><div class="frame-root"></div></body></html>`;
+function getMountNode(frame) {
+  const doc = frame.contentWindow?.document;
+  if (!doc) return null;
+  return doc.body.querySelector(".frame-root") || doc.body;
+}
+var Frame = (props) => {
+  const [frameProps, localProps] = splitProps(props, ["children", "head", "onMount", "onUnmount", "srcdoc"]);
+  const srcdoc = createMemo(() => frameProps.srcdoc ?? initialSrcDoc);
+  const [frameRef, setFrameRef] = createSignal(null);
+  const [mountNode, setMountNode] = createSignal(null);
+  createEffect(() => {
+    const frame = frameRef();
+    if (!frame) return;
+    const doc = frame.contentWindow?.document;
+    if (!doc) return;
+    doc.open();
+    doc.write(srcdoc());
+    doc.close();
+    setMountNode(getMountNode(frame));
+  });
+  createEffect(() => {
+    const frame = frameRef();
+    if (!frame || !frame.contentDocument) return;
+    const win = frame.contentWindow;
+    if (!win) return;
+    const node = getMountNode(frame);
+    if (!node) return;
+    const exec = () => {
+      const rootEl = frame.contentDocument?.documentElement;
+      if (!rootEl) return;
+      frame.style.setProperty("--width", `${node.scrollWidth}px`);
+      frame.style.setProperty("--height", `${node.scrollHeight}px`);
+    };
+    const resizeObserver = new win.ResizeObserver(exec);
+    exec();
+    if (frame.contentDocument) {
+      resizeObserver.observe(node);
+    }
+    onCleanup(() => {
+      resizeObserver.disconnect();
+    });
+  });
+  return createComponent(EnvironmentProvider, {
+    value: () => frameRef()?.contentDocument ?? document,
+    get children() {
+      var _el$ = _tmpl$();
+      var _ref$ = composeRefs(setFrameRef, localProps.ref);
+      typeof _ref$ === "function" && use(_ref$, _el$);
+      spread(_el$, localProps, false, true);
+      insert(_el$, createComponent(Show, {
+        get when() {
+          return mountNode();
+        },
+        children: (node) => createComponent(Portal, {
+          get mount() {
+            return node();
+          },
+          get children() {
+            return createComponent(FrameContent, {
+              get onMount() {
+                return frameProps.onMount;
+              },
+              get onUnmount() {
+                return frameProps.onUnmount;
+              },
+              get children() {
+                return frameProps.children;
+              }
+            });
+          }
+        })
+      }), null);
+      insert(_el$, createComponent(Show, {
+        get when() {
+          return mountNode();
+        },
+        get children() {
+          return createComponent(Portal, {
+            get mount() {
+              return frameRef().contentDocument.head;
+            },
+            get children() {
+              return frameProps.head;
+            }
+          });
+        }
+      }), null);
+      return _el$;
+    }
+  });
+};
+
+export { Frame };

package/dist/chunk/KBVWLUJ7.jsx

@@ -0,0 +1,248 @@
+// src/components/collection.ts
+import { ListCollection } from "@zag-js/collection";
+
+// ../../node_modules/proxy-compare/dist/index.js
+var TRACK_MEMO_SYMBOL = Symbol();
+var GET_ORIGINAL_SYMBOL = Symbol();
+var getProto = Object.getPrototypeOf;
+var objectsToTrack = /* @__PURE__ */ new WeakMap();
+var isObjectToTrack = (obj) => obj && (objectsToTrack.has(obj) ? objectsToTrack.get(obj) : getProto(obj) === Object.prototype || getProto(obj) === Array.prototype);
+var getUntracked = (obj) => {
+  if (isObjectToTrack(obj)) {
+    return obj[GET_ORIGINAL_SYMBOL] || null;
+  }
+  return null;
+};
+var markToTrack = (obj, mark = true) => {
+  objectsToTrack.set(obj, mark);
+};
+
+// ../../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];
+}
+var isDev = () => true;
+var isObject = (x) => typeof x === "object" && x !== null;
+var proxyStateMap = makeGlobal("__zag__proxyStateMap", () => /* @__PURE__ */ new WeakMap());
+var refSet = makeGlobal("__zag__refSet", () => /* @__PURE__ */ new WeakSet());
+var isReactElement = (x) => typeof x === "object" && x !== null && "$$typeof" in x;
+var isVueElement = (x) => typeof x === "object" && x !== null && "__v_isVNode" in x;
+var isDOMElement = (x) => typeof x === "object" && x !== null && "nodeType" in x && typeof x.nodeName === "string";
+var isElement = (x) => isReactElement(x) || isVueElement(x) || isDOMElement(x);
+var buildProxyFunction = (objectIs = Object.is, newProxy = (target, handler) => new Proxy(target, handler), canProxy = (x) => isObject(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in x)) && !isElement(x) && !(x instanceof WeakMap) && !(x instanceof WeakSet) && !(x instanceof Error) && !(x instanceof Number) && !(x instanceof Date) && !(x instanceof String) && !(x instanceof RegExp) && !(x instanceof ArrayBuffer), defaultHandlePromise = (promise) => {
+  switch (promise.status) {
+    case "fulfilled":
+      return promise.value;
+    case "rejected":
+      throw promise.reason;
+    default:
+      throw promise;
+  }
+}, snapCache = /* @__PURE__ */ new WeakMap(), createSnapshot = (target, version, handlePromise = defaultHandlePromise) => {
+  const cache = snapCache.get(target);
+  if (cache?.[0] === version) {
+    return cache[1];
+  }
+  const snap = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target));
+  markToTrack(snap, true);
+  snapCache.set(target, [version, snap]);
+  Reflect.ownKeys(target).forEach((key) => {
+    const value = Reflect.get(target, key);
+    if (refSet.has(value)) {
+      markToTrack(value, false);
+      snap[key] = value;
+    } else if (value instanceof Promise) {
+      Object.defineProperty(snap, key, {
+        get() {
+          return handlePromise(value);
+        }
+      });
+    } else if (proxyStateMap.has(value)) {
+      snap[key] = snapshot(value, handlePromise);
+    } else {
+      snap[key] = value;
+    }
+  });
+  return Object.freeze(snap);
+}, proxyCache = /* @__PURE__ */ new WeakMap(), versionHolder = [1, 1], proxyFunction2 = (initialObject) => {
+  if (!isObject(initialObject)) {
+    throw new Error("object required");
+  }
+  const found = proxyCache.get(initialObject);
+  if (found) {
+    return found;
+  }
+  let version = versionHolder[0];
+  const listeners = /* @__PURE__ */ new Set();
+  const notifyUpdate = (op, nextVersion = ++versionHolder[0]) => {
+    if (version !== nextVersion) {
+      version = nextVersion;
+      listeners.forEach((listener) => listener(op, nextVersion));
+    }
+  };
+  let checkVersion = versionHolder[1];
+  const ensureVersion = (nextCheckVersion = ++versionHolder[1]) => {
+    if (checkVersion !== nextCheckVersion && !listeners.size) {
+      checkVersion = nextCheckVersion;
+      propProxyStates.forEach(([propProxyState]) => {
+        const propVersion = propProxyState[1](nextCheckVersion);
+        if (propVersion > version) {
+          version = propVersion;
+        }
+      });
+    }
+    return version;
+  };
+  const createPropListener = (prop) => (op, nextVersion) => {
+    const newOp = [...op];
+    newOp[1] = [prop, ...newOp[1]];
+    notifyUpdate(newOp, nextVersion);
+  };
+  const propProxyStates = /* @__PURE__ */ new Map();
+  const addPropListener = (prop, propProxyState) => {
+    if (isDev() && propProxyStates.has(prop)) {
+      throw new Error("prop listener already exists");
+    }
+    if (listeners.size) {
+      const remove = propProxyState[3](createPropListener(prop));
+      propProxyStates.set(prop, [propProxyState, remove]);
+    } else {
+      propProxyStates.set(prop, [propProxyState]);
+    }
+  };
+  const removePropListener = (prop) => {
+    const entry = propProxyStates.get(prop);
+    if (entry) {
+      propProxyStates.delete(prop);
+      entry[1]?.();
+    }
+  };
+  const addListener = (listener) => {
+    listeners.add(listener);
+    if (listeners.size === 1) {
+      propProxyStates.forEach(([propProxyState, prevRemove], prop) => {
+        if (isDev() && prevRemove) {
+          throw new Error("remove already exists");
+        }
+        const remove = propProxyState[3](createPropListener(prop));
+        propProxyStates.set(prop, [propProxyState, remove]);
+      });
+    }
+    const removeListener = () => {
+      listeners.delete(listener);
+      if (listeners.size === 0) {
+        propProxyStates.forEach(([propProxyState, remove], prop) => {
+          if (remove) {
+            remove();
+            propProxyStates.set(prop, [propProxyState]);
+          }
+        });
+      }
+    };
+    return removeListener;
+  };
+  const baseObject = Array.isArray(initialObject) ? [] : Object.create(Object.getPrototypeOf(initialObject));
+  const handler = {
+    deleteProperty(target, prop) {
+      const prevValue = Reflect.get(target, prop);
+      removePropListener(prop);
+      const deleted = Reflect.deleteProperty(target, prop);
+      if (deleted) {
+        notifyUpdate(["delete", [prop], prevValue]);
+      }
+      return deleted;
+    },
+    set(target, prop, value, receiver) {
+      const hasPrevValue = Reflect.has(target, prop);
+      const prevValue = Reflect.get(target, prop, receiver);
+      if (hasPrevValue && (objectIs(prevValue, value) || proxyCache.has(value) && objectIs(prevValue, proxyCache.get(value)))) {
+        return true;
+      }
+      removePropListener(prop);
+      if (isObject(value)) {
+        value = getUntracked(value) || value;
+      }
+      let nextValue = value;
+      if (Object.getOwnPropertyDescriptor(target, prop)?.set) ;
+      else if (value instanceof Promise) {
+        value.then((v) => {
+          Object.assign(value, { status: "fulfilled", value: v });
+          notifyUpdate(["resolve", [prop], v]);
+        }).catch((e) => {
+          Object.assign(value, { status: "rejected", reason: e });
+          notifyUpdate(["reject", [prop], e]);
+        });
+      } else {
+        if (!proxyStateMap.has(value) && canProxy(value)) {
+          nextValue = proxy(value);
+        }
+        const childProxyState = !refSet.has(nextValue) && proxyStateMap.get(nextValue);
+        if (childProxyState) {
+          addPropListener(prop, childProxyState);
+        }
+      }
+      Reflect.set(target, prop, nextValue, receiver);
+      notifyUpdate(["set", [prop], value, prevValue]);
+      return true;
+    }
+  };
+  const proxyObject = newProxy(baseObject, handler);
+  proxyCache.set(initialObject, proxyObject);
+  const proxyState = [baseObject, ensureVersion, createSnapshot, addListener];
+  proxyStateMap.set(proxyObject, proxyState);
+  Reflect.ownKeys(initialObject).forEach((key) => {
+    const desc = Object.getOwnPropertyDescriptor(initialObject, key);
+    if (desc.get || desc.set) {
+      Object.defineProperty(baseObject, key, desc);
+    } else {
+      proxyObject[key] = initialObject[key];
+    }
+  });
+  return proxyObject;
+}) => [
+  // public functions
+  proxyFunction2,
+  // shared state
+  proxyStateMap,
+  refSet,
+  // internal things
+  objectIs,
+  newProxy,
+  canProxy,
+  defaultHandlePromise,
+  snapCache,
+  createSnapshot,
+  proxyCache,
+  versionHolder
+];
+var [proxyFunction] = buildProxyFunction();
+function proxy(initialObject = {}) {
+  return proxyFunction(initialObject);
+}
+function snapshot(proxyObject, handlePromise) {
+  const proxyState = proxyStateMap.get(proxyObject);
+  if (isDev() && !proxyState) {
+  }
+  const [target, ensureVersion, createSnapshot] = proxyState;
+  return createSnapshot(target, ensureVersion(), handlePromise);
+}
+function ref(obj) {
+  refSet.add(obj);
+  return obj;
+}
+
+// src/components/collection.ts
+var createListCollection = (options) => ref(new ListCollection(options));
+
+export {
+  createListCollection
+};

package/dist/chunk/KGOB2IMX.jsx

@@ -0,0 +1,7 @@
+// src/utils/run-if-fn.ts
+var isFunction = (value) => typeof value === "function";
+var runIfFn = (valueOrFn, ...args) => isFunction(valueOrFn) ? valueOrFn(...args) : valueOrFn;
+
+export {
+  runIfFn
+};