@ariakit/core 0.0.1 → 0.1.0

package/.eslintignore

@@ -0,0 +1,6 @@
+cjs
+esm
+ts
+umd
+coverage
+node_modules

package/CHANGELOG.md

@@ -0,0 +1,18 @@
+# @ariakit/core
+
+## 0.1.0
+
+### Minor Changes
+
+- Updated package names to include the `@ariakit` scope, providing a more distinct and specific namespace for our packages.
+
+  Additionally, we've made a change to the versioning system, moving from `v2.0.0-beta.x` to `v0.x.x`. This alteration means that although the library is still in beta, we can release breaking changes in minor versions without disrupting projects that don't set exact versions in their `package.json`.
+
+  ```diff
+  - npm i ariakit
+  + npm i @ariakit/react
+  ```
+
+### Patch Changes
+
+- Packages are now ESM by default (commonjs modules are still available with the `.cjs` extension).

package/checkbox/checkbox-store/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@ariakit/core/checkbox/checkbox-store",
+  "private": true,
+  "sideEffects": false,
+  "main": "../../cjs/checkbox/checkbox-store",
+  "module": "../../esm/checkbox/checkbox-store"
+}

package/cjs/__chunks/2YFRPUZP.cjs

@@ -0,0 +1,30 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _OFNGELMAcjs = require('./OFNGELMA.cjs');
+
+// src/utils/platform.ts
+function isTouchDevice() {
+  return _OFNGELMAcjs.canUseDOM && !!navigator.maxTouchPoints;
+}
+function isApple() {
+  if (!_OFNGELMAcjs.canUseDOM)
+    return false;
+  return /mac|iphone|ipad|ipod/i.test(navigator.platform);
+}
+function isSafari() {
+  return _OFNGELMAcjs.canUseDOM && isApple() && /apple/i.test(navigator.vendor);
+}
+function isFirefox() {
+  return _OFNGELMAcjs.canUseDOM && /firefox\//i.test(navigator.userAgent);
+}
+function isMac() {
+  return _OFNGELMAcjs.canUseDOM && navigator.platform.startsWith("Mac") && !isTouchDevice();
+}
+
+
+
+
+
+
+
+exports.isTouchDevice = isTouchDevice; exports.isApple = isApple; exports.isSafari = isSafari; exports.isFirefox = isFirefox; exports.isMac = isMac;

package/cjs/__chunks/3BBA3Z5G.cjs

@@ -0,0 +1,143 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+var _5D5Y5EI4cjs = require('./5D5Y5EI4.cjs');
+
+// 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 _5D5Y5EI4cjs.noop;
+    if (!stores.length)
+      return _5D5Y5EI4cjs.noop;
+    initialized = true;
+    const desyncs = _5D5Y5EI4cjs.getKeys.call(void 0, state).map(
+      (key) => _5D5Y5EI4cjs.chain.call(void 0, 
+        ...stores.map((store) => {
+          const storeState = _optionalChain([store, 'optionalAccess', _ => _.getState, 'optionalCall', _2 => _2()]);
+          if (!storeState)
+            return;
+          if (!_5D5Y5EI4cjs.hasOwnProperty.call(void 0, storeState, key))
+            return;
+          return _optionalChain([store, 'optionalAccess', _3 => _3.sync, 'optionalCall', _4 => _4((state2) => setState(key, state2[key]), [key])]);
+        })
+      )
+    );
+    const teardowns = [];
+    setups.forEach((setup2) => teardowns.push(setup2()));
+    const cleanups = stores.map((store) => _optionalChain([store, 'optionalAccess', _5 => _5.init, 'optionalCall', _6 => _6()]));
+    return _5D5Y5EI4cjs.chain.call(void 0, ...desyncs, ...teardowns, ...cleanups, () => {
+      initialized = false;
+    });
+  };
+  const sub = (listener, keys, batch = false) => {
+    const set = batch ? listenersBatch : listeners;
+    set.add(listener);
+    listenerKeys.set(listener, keys);
+    return () => {
+      _optionalChain([disposables, 'access', _7 => _7.get, 'call', _8 => _8(listener), 'optionalCall', _9 => _9()]);
+      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 (!_5D5Y5EI4cjs.hasOwnProperty.call(void 0, state, key))
+      return;
+    const nextValue = _5D5Y5EI4cjs.applyState.call(void 0, value, state[key]);
+    if (nextValue === state[key])
+      return;
+    stores.forEach((store) => {
+      _optionalChain([store, 'optionalAccess', _10 => _10.setState, 'optionalCall', _11 => _11(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)) {
+        _optionalChain([disposables, 'access', _12 => _12.get, 'call', _13 => _13(listener), 'optionalCall', _14 => _14()]);
+        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(_5D5Y5EI4cjs.pick.call(void 0, state, keys), finalStore);
+  const omit2 = (...keys) => createStore(_5D5Y5EI4cjs.omit.call(void 0, 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 = _optionalChain([store2, 'optionalAccess', _15 => _15.getState, 'optionalCall', _16 => _16()]);
+    if (!nextState)
+      return state;
+    return { ...state, ...nextState };
+  }, {});
+  const store = createStore(initialState, ...stores);
+  return store;
+}
+
+
+
+
+exports.createStore = createStore; exports.mergeStore = mergeStore;