alistair/dist/react/index.cjs

'use strict';

var chunkN25S62HC_cjs = require('../chunk-N25S62HC.cjs');
var chunk7JYVLPRQ_cjs = require('../chunk-7JYVLPRQ.cjs');
var react = require('react');
var jsxRuntime = require('react/jsx-runtime');

function _interopNamespace(e) {
  if (e && e.__esModule) return e;
  var n = Object.create(null);
  if (e) {
    Object.keys(e).forEach(function (k) {
      if (k !== 'default') {
        var d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(n, k, d.get ? d : {
          enumerable: true,
          get: function () { return e[k]; }
        });
      }
    });
  }
  n.default = e;
  return Object.freeze(n);
}

var react__namespace = /*#__PURE__*/_interopNamespace(react);

// Copyright 2026 Alistair Smith https://github.com/alii/alistair
function createStrictContext(defaultValue = null) {
  const context = react__namespace.createContext(defaultValue);
  function Provider({ value, children }) {
    return /* @__PURE__ */ jsxRuntime.jsx(context.Provider, { value, children });
  }
  function useContext2() {
    const value = react__namespace.useContext(context);
    if (value === null) {
      throw new Error("useContext() must be used within a <Provider />");
    }
    return value;
  }
  return {
    useContext: useContext2,
    Provider
  };
}
function createStoreContext() {
  const context = createStrictContext();
  const identity = (value) => value;
  function Provider({ value, children }) {
    const store = chunkN25S62HC_cjs.useLazyRef(() => {
      let val = value;
      const listeners = /* @__PURE__ */ new Set();
      const notify = () => {
        for (const listener of listeners) {
          listener();
        }
      };
      const set = (next) => {
        val = next;
        notify();
      };
      const subscribe = (listener) => {
        listeners.add(listener);
        return () => {
          listeners.delete(listener);
        };
      };
      const get = () => val;
      return {
        subscribe,
        set,
        get
      };
    });
    react__namespace.useEffect(() => {
      store.current.set(value);
    }, [value]);
    return /* @__PURE__ */ jsxRuntime.jsx(context.Provider, { value: store.current, children });
  }
  function useSelectContext(selector = identity, dependencies = []) {
    const store = context.useContext();
    const cache = react__namespace.useMemo(
      () => ({ current: null }),
      dependencies
    );
    const subscribe = react__namespace.useCallback(
      (listener) => store.subscribe(listener),
      dependencies
    );
    const getSnapshot = () => {
      const state = store.get();
      if (cache.current && cache.current[0] === state) {
        return cache.current[1];
      }
      const next = selector(state);
      cache.current = [state, next];
      return next;
    };
    const slice = react__namespace.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
    react__namespace.useDebugValue(slice);
    return slice;
  }
  return {
    Provider,
    useSelectContext
  };
}
function useCacheSelector() {
  const cache = chunkN25S62HC_cjs.useLazyRef(() => /* @__PURE__ */ new WeakMap());
  return (compute) => {
    const stable = chunk7JYVLPRQ_cjs.useEvent(compute);
    return react__namespace.useCallback(
      (prev) => {
        const cached = cache.current.get(prev);
        if (cached !== undefined) {
          return cached;
        }
        const next = stable(prev);
        cache.current.set(prev, next);
        return next;
      },
      [stable]
    );
  };
}

exports.createStoreContext = createStoreContext;
exports.createStrictContext = createStrictContext;
exports.useCacheSelector = useCacheSelector;