@ariakit/core 0.0.1 → 0.1.0

package/esm/__chunks/ADRUFBEO.js

@@ -0,0 +1,12 @@
+import {
+  createDisclosureStore
+} from "./HCKYJLMC.js";
+
+// src/dialog/dialog-store.ts
+function createDialogStore(props = {}) {
+  return createDisclosureStore(props);
+}
+
+export {
+  createDialogStore
+};

package/esm/__chunks/DXA3K2FY.js

@@ -0,0 +1,30 @@
+import {
+  canUseDOM
+} from "./UVCATTRC.js";
+
+// src/utils/platform.ts
+function isTouchDevice() {
+  return canUseDOM && !!navigator.maxTouchPoints;
+}
+function isApple() {
+  if (!canUseDOM)
+    return false;
+  return /mac|iphone|ipad|ipod/i.test(navigator.platform);
+}
+function isSafari() {
+  return canUseDOM && isApple() && /apple/i.test(navigator.vendor);
+}
+function isFirefox() {
+  return canUseDOM && /firefox\//i.test(navigator.userAgent);
+}
+function isMac() {
+  return canUseDOM && navigator.platform.startsWith("Mac") && !isTouchDevice();
+}
+
+export {
+  isTouchDevice,
+  isApple,
+  isSafari,
+  isFirefox,
+  isMac
+};

package/esm/__chunks/HCKYJLMC.js

@@ -0,0 +1,71 @@
+import {
+  createStore
+} from "./UOJSZ35L.js";
+import {
+  defaultValue
+} from "./KLKI3AIB.js";
+
+// src/disclosure/disclosure-store.ts
+function createDisclosureStore(props = {}) {
+  const syncState = props.store?.getState();
+  const open = defaultValue(
+    props.open,
+    syncState?.open,
+    props.defaultOpen,
+    false
+  );
+  const animated = defaultValue(props.animated, syncState?.animated, false);
+  const initialState = {
+    open,
+    animated,
+    animating: !!animated && open,
+    mounted: open,
+    contentElement: defaultValue(syncState?.contentElement, null),
+    disclosureElement: defaultValue(syncState?.disclosureElement, null)
+  };
+  const disclosure = createStore(initialState, props.store);
+  disclosure.setup(
+    () => disclosure.sync(
+      (state) => {
+        if (state.animated)
+          return;
+        disclosure.setState("animating", false);
+      },
+      ["animated", "animating"]
+    )
+  );
+  disclosure.setup(
+    () => disclosure.sync(
+      (state, prev) => {
+        if (!state.animated)
+          return;
+        const mounting = state === prev;
+        const animating = mounting ? state.open : state.open !== prev.open;
+        disclosure.setState("animating", animating);
+      },
+      ["open", "animated"]
+    )
+  );
+  disclosure.setup(
+    () => disclosure.sync(
+      (state) => {
+        disclosure.setState("mounted", state.open || state.animating);
+      },
+      ["open", "animating"]
+    )
+  );
+  return {
+    ...disclosure,
+    setOpen: (value) => disclosure.setState("open", value),
+    show: () => disclosure.setState("open", true),
+    hide: () => disclosure.setState("open", false),
+    toggle: () => disclosure.setState("open", (open2) => !open2),
+    stopAnimation: () => disclosure.setState("animating", false),
+    setContentElement: (value) => disclosure.setState("contentElement", value),
+    setDisclosureElement: (value) => disclosure.setState("disclosureElement", value)
+  };
+}
+
+export {
+  createDisclosureStore
+};

package/esm/__chunks/KLKI3AIB.js

@@ -0,0 +1,146 @@
+// src/utils/misc.ts
+function noop(..._) {
+}
+function shallowEqual(a, b) {
+  if (a === b)
+    return true;
+  if (!a)
+    return false;
+  if (!b)
+    return false;
+  if (typeof a !== "object")
+    return false;
+  if (typeof b !== "object")
+    return false;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  const { length } = aKeys;
+  if (bKeys.length !== length)
+    return false;
+  for (const key of aKeys) {
+    if (a[key] !== b[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+function applyState(argument, currentValue) {
+  if (isUpdater(argument)) {
+    const value = isLazyValue(currentValue) ? currentValue() : currentValue;
+    return argument(value);
+  }
+  return argument;
+}
+function isUpdater(argument) {
+  return typeof argument === "function";
+}
+function isLazyValue(value) {
+  return typeof value === "function";
+}
+function isObject(arg) {
+  return typeof arg === "object" && arg != null;
+}
+function isEmpty(arg) {
+  if (Array.isArray(arg))
+    return !arg.length;
+  if (isObject(arg))
+    return !Object.keys(arg).length;
+  if (arg == null)
+    return true;
+  if (arg === "")
+    return true;
+  return false;
+}
+function isInteger(arg) {
+  if (typeof arg === "number") {
+    return Math.floor(arg) === arg;
+  }
+  return String(Math.floor(Number(arg))) === arg;
+}
+function hasOwnProperty(object, prop) {
+  return Object.prototype.hasOwnProperty.call(object, prop);
+}
+function chain(...fns) {
+  return (...args) => {
+    for (const fn of fns) {
+      if (typeof fn === "function") {
+        fn(...args);
+      }
+    }
+  };
+}
+function cx(...args) {
+  return args.filter(Boolean).join(" ") || void 0;
+}
+function normalizeString(str) {
+  return str.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+}
+function omit(object, keys) {
+  const result = { ...object };
+  for (const key of keys) {
+    if (hasOwnProperty(result, key)) {
+      delete result[key];
+    }
+  }
+  return result;
+}
+function pick(object, paths) {
+  const result = {};
+  for (const key of paths) {
+    if (hasOwnProperty(object, key)) {
+      result[key] = object[key];
+    }
+  }
+  return result;
+}
+function identity(value) {
+  return value;
+}
+function beforePaint(cb = noop) {
+  const raf = requestAnimationFrame(cb);
+  return () => cancelAnimationFrame(raf);
+}
+function afterPaint(cb = noop) {
+  let raf = requestAnimationFrame(() => {
+    raf = requestAnimationFrame(cb);
+  });
+  return () => cancelAnimationFrame(raf);
+}
+function invariant(condition, message) {
+  if (condition)
+    return;
+  if (typeof message !== "string")
+    throw new Error("Invariant failed");
+  throw new Error(message);
+}
+function getKeys(obj) {
+  return Object.keys(obj);
+}
+function defaultValue(...values) {
+  for (const value of values) {
+    if (value !== void 0)
+      return value;
+  }
+  return void 0;
+}
+
+export {
+  noop,
+  shallowEqual,
+  applyState,
+  isObject,
+  isEmpty,
+  isInteger,
+  hasOwnProperty,
+  chain,
+  cx,
+  normalizeString,
+  omit,
+  pick,
+  identity,
+  beforePaint,
+  afterPaint,
+  invariant,
+  getKeys,
+  defaultValue
+};

package/esm/__chunks/L7KN5AYP.js

@@ -0,0 +1,169 @@
+import {
+  createStore
+} from "./UOJSZ35L.js";
+import {
+  chain,
+  defaultValue
+} from "./KLKI3AIB.js";
+import {
+  getDocument
+} from "./UVCATTRC.js";
+
+// src/collection/collection-store.ts
+function isElementPreceding(a, b) {
+  return Boolean(
+    b.compareDocumentPosition(a) & Node.DOCUMENT_POSITION_PRECEDING
+  );
+}
+function sortBasedOnDOMPosition(items) {
+  const pairs = items.map((item, index) => [index, item]);
+  let isOrderDifferent = false;
+  pairs.sort(([indexA, a], [indexB, b]) => {
+    const elementA = a.element;
+    const elementB = b.element;
+    if (elementA === elementB)
+      return 0;
+    if (!elementA || !elementB)
+      return 0;
+    if (isElementPreceding(elementA, elementB)) {
+      if (indexA > indexB) {
+        isOrderDifferent = true;
+      }
+      return -1;
+    }
+    if (indexA < indexB) {
+      isOrderDifferent = true;
+    }
+    return 1;
+  });
+  if (isOrderDifferent) {
+    return pairs.map(([_, item]) => item);
+  }
+  return items;
+}
+function getCommonParent(items) {
+  const firstItem = items.find((item) => !!item.element);
+  const lastItem = [...items].reverse().find((item) => !!item.element);
+  let parentElement = firstItem?.element?.parentElement;
+  while (parentElement && lastItem?.element) {
+    const parent = parentElement;
+    if (lastItem && parent.contains(lastItem.element)) {
+      return parentElement;
+    }
+    parentElement = parentElement.parentElement;
+  }
+  return getDocument(parentElement).body;
+}
+function createCollectionStore(props = {}) {
+  const itemsMap = /* @__PURE__ */ new Map();
+  const syncState = props.store?.getState();
+  const initialState = {
+    items: defaultValue(props.items, syncState?.items, props.defaultItems, []),
+    renderedItems: defaultValue(syncState?.renderedItems, [])
+  };
+  const privateStore = createStore({
+    renderedItems: initialState.renderedItems
+  });
+  const collection = createStore(initialState, props.store);
+  const sortItems = () => {
+    const state = privateStore.getState();
+    const renderedItems = sortBasedOnDOMPosition(state.renderedItems);
+    privateStore.setState("renderedItems", renderedItems);
+    collection.setState("renderedItems", renderedItems);
+  };
+  collection.setup(() => {
+    return privateStore.syncBatch(
+      (state) => {
+        let firstRun = true;
+        let raf = 0;
+        raf = requestAnimationFrame(sortItems);
+        if (typeof IntersectionObserver !== "function")
+          return;
+        const callback = () => {
+          if (firstRun) {
+            firstRun = false;
+            return;
+          }
+          cancelAnimationFrame(raf);
+          raf = requestAnimationFrame(sortItems);
+        };
+        const root = getCommonParent(state.renderedItems);
+        const observer = new IntersectionObserver(callback, { root });
+        state.renderedItems.forEach((item) => {
+          if (item.element) {
+            observer.observe(item.element);
+          }
+        });
+        return () => {
+          cancelAnimationFrame(raf);
+          observer.disconnect();
+        };
+      },
+      ["renderedItems"]
+    );
+  });
+  const mergeItem = (item, setItems, canDeleteFromMap = false) => {
+    let prevItem;
+    setItems((items) => {
+      const index = itemsMap.get(item.id) && items.findIndex(({ id }) => id === item.id);
+      const nextItems = items.slice();
+      if (index && index >= 0) {
+        prevItem = items[index];
+        const nextItem = { ...prevItem, ...item };
+        nextItems[index] = nextItem;
+        itemsMap.set(item.id, nextItem);
+      } else {
+        nextItems.push(item);
+        itemsMap.set(item.id, item);
+      }
+      return nextItems;
+    });
+    const unmergeItem = () => {
+      setItems((items) => {
+        if (!prevItem) {
+          if (canDeleteFromMap) {
+            itemsMap.delete(item.id);
+          }
+          return items.filter(({ id }) => id !== item.id);
+        }
+        const index = items.findIndex(({ id }) => id === item.id);
+        if (index === -1)
+          return items;
+        const nextItems = items.slice();
+        nextItems[index] = prevItem;
+        itemsMap.set(item.id, prevItem);
+        return nextItems;
+      });
+    };
+    return unmergeItem;
+  };
+  const registerItem = (item) => mergeItem(item, (getItems) => collection.setState("items", getItems), true);
+  return {
+    ...collection,
+    registerItem,
+    renderItem: (item) => chain(
+      registerItem(item),
+      mergeItem(
+        item,
+        (getItems) => privateStore.setState("renderedItems", getItems)
+      )
+    ),
+    item: (id) => {
+      if (!id)
+        return null;
+      let item = itemsMap.get(id);
+      if (!item) {
+        const { items } = collection.getState();
+        item = items.find((item2) => item2.id === id);
+        if (item) {
+          itemsMap.set(id, item);
+        }
+      }
+      return item || null;
+    }
+  };
+}
+
+export {
+  createCollectionStore
+};

package/esm/__chunks/RX3ZUQ6U.js

@@ -0,0 +1,57 @@
+import {
+  createPopoverStore
+} from "./6UPCMUXT.js";
+import {
+  createStore
+} from "./UOJSZ35L.js";
+import {
+  defaultValue
+} from "./KLKI3AIB.js";
+
+// src/hovercard/hovercard-store.ts
+function createHovercardStore(props = {}) {
+  const syncState = props.store?.getState();
+  const timeout = defaultValue(props.timeout, syncState?.timeout, 500);
+  const popover = createPopoverStore({
+    ...props,
+    placement: defaultValue(
+      props.placement,
+      syncState?.placement,
+      "bottom"
+    )
+  });
+  const initialState = {
+    ...popover.getState(),
+    timeout,
+    showTimeout: defaultValue(
+      props.showTimeout,
+      syncState?.showTimeout,
+      timeout
+    ),
+    hideTimeout: defaultValue(
+      props.hideTimeout,
+      syncState?.hideTimeout,
+      timeout
+    ),
+    autoFocusOnShow: defaultValue(syncState?.autoFocusOnShow, false)
+  };
+  const hovercard = createStore(initialState, popover, props.store);
+  hovercard.setup(
+    () => hovercard.sync(
+      (state) => {
+        hovercard.setState("showTimeout", (value) => value ?? state.timeout);
+        hovercard.setState("hideTimeout", (value) => value ?? state.timeout);
+      },
+      ["timeout"]
+    )
+  );
+  return {
+    ...popover,
+    ...hovercard,
+    setAutoFocusOnShow: (value) => hovercard.setState("autoFocusOnShow", value)
+  };
+}
+
+export {
+  createHovercardStore
+};

package/esm/__chunks/UOJSZ35L.js

@@ -0,0 +1,143 @@
+import {
+  applyState,
+  chain,
+  getKeys,
+  hasOwnProperty,
+  noop,
+  omit,
+  pick
+} from "./KLKI3AIB.js";
+
+// src/utils/store.ts
+function createStore(initialState, ...stores) {
+  let state = initialState;
+  let prevStateBatch = state;
+  let lastUpdate = Symbol();
+  let updating = false;
+  let initialized = false;
+  const updatedKeys = /* @__PURE__ */ new Set();
+  const setups = /* @__PURE__ */ new Set();
+  const listeners = /* @__PURE__ */ new Set();
+  const listenersBatch = /* @__PURE__ */ new Set();
+  const disposables = /* @__PURE__ */ new WeakMap();
+  const listenerKeys = /* @__PURE__ */ new WeakMap();
+  const setup = (callback) => {
+    setups.add(callback);
+    return () => setups.delete(callback);
+  };
+  const init = () => {
+    if (initialized)
+      return noop;
+    if (!stores.length)
+      return noop;
+    initialized = true;
+    const desyncs = getKeys(state).map(
+      (key) => chain(
+        ...stores.map((store) => {
+          const storeState = store?.getState?.();
+          if (!storeState)
+            return;
+          if (!hasOwnProperty(storeState, key))
+            return;
+          return store?.sync?.((state2) => setState(key, state2[key]), [key]);
+        })
+      )
+    );
+    const teardowns = [];
+    setups.forEach((setup2) => teardowns.push(setup2()));
+    const cleanups = stores.map((store) => store?.init?.());
+    return chain(...desyncs, ...teardowns, ...cleanups, () => {
+      initialized = false;
+    });
+  };
+  const sub = (listener, keys, batch = false) => {
+    const set = batch ? listenersBatch : listeners;
+    set.add(listener);
+    listenerKeys.set(listener, keys);
+    return () => {
+      disposables.get(listener)?.();
+      disposables.delete(listener);
+      listenerKeys.delete(listener);
+      set.delete(listener);
+    };
+  };
+  const subscribe = (listener, keys) => sub(listener, keys);
+  const sync = (listener, keys) => {
+    disposables.set(listener, listener(state, state));
+    return sub(listener, keys);
+  };
+  const syncBatch = (listener, keys) => {
+    if (!updating) {
+      disposables.set(listener, listener(state, prevStateBatch));
+    }
+    return sub(listener, keys, true);
+  };
+  const getState = () => state;
+  const setState = (key, value) => {
+    if (!hasOwnProperty(state, key))
+      return;
+    const nextValue = applyState(value, state[key]);
+    if (nextValue === state[key])
+      return;
+    stores.forEach((store) => {
+      store?.setState?.(key, nextValue);
+    });
+    const prevState = state;
+    state = { ...state, [key]: nextValue };
+    const thisUpdate = Symbol();
+    lastUpdate = thisUpdate;
+    updating = true;
+    updatedKeys.add(key);
+    const run = (listener, prev, uKeys) => {
+      const keys = listenerKeys.get(listener);
+      const updated = (k) => uKeys ? uKeys.has(k) : k === key;
+      if (!keys || keys.some(updated)) {
+        disposables.get(listener)?.();
+        disposables.set(listener, listener(state, prev));
+      }
+    };
+    listeners.forEach((listener) => run(listener, prevState));
+    queueMicrotask(() => {
+      if (lastUpdate !== thisUpdate)
+        return;
+      updating = false;
+      const snapshot = state;
+      listenersBatch.forEach((listener) => {
+        run(listener, prevStateBatch, updatedKeys);
+      });
+      prevStateBatch = snapshot;
+      queueMicrotask(() => {
+        updatedKeys.clear();
+      });
+    });
+  };
+  const pick2 = (...keys) => createStore(pick(state, keys), finalStore);
+  const omit2 = (...keys) => createStore(omit(state, keys), finalStore);
+  const finalStore = {
+    setup,
+    init,
+    subscribe,
+    sync,
+    syncBatch,
+    getState,
+    setState,
+    pick: pick2,
+    omit: omit2
+  };
+  return finalStore;
+}
+function mergeStore(...stores) {
+  const initialState = stores.reduce((state, store2) => {
+    const nextState = store2?.getState?.();
+    if (!nextState)
+      return state;
+    return { ...state, ...nextState };
+  }, {});
+  const store = createStore(initialState, ...stores);
+  return store;
+}
+
+export {
+  createStore,
+  mergeStore
+};