context-state/dist/create-store.js

Like unstated-next, but Pro

'use strict';
function _array_like_to_array(arr, len) {
    if (len == null || len > arr.length) len = arr.length;
    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
    return arr2;
}
function _array_with_holes(arr) {
    if (Array.isArray(arr)) return arr;
}
function _iterable_to_array_limit(arr, i) {
    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
    if (_i == null) return;
    var _arr = [];
    var _n = true;
    var _d = false;
    var _s, _e;
    try {
        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
            _arr.push(_s.value);
            if (i && _arr.length === i) break;
        }
    } catch (err) {
        _d = true;
        _e = err;
    } finally{
        try {
            if (!_n && _i["return"] != null) _i["return"]();
        } finally{
            if (_d) throw _e;
        }
    }
    return _arr;
}
function _non_iterable_rest() {
    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _object_without_properties(source, excluded) {
    if (source == null) return {};
    var target = _object_without_properties_loose(source, excluded);
    var key, i;
    if (Object.getOwnPropertySymbols) {
        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
        for(i = 0; i < sourceSymbolKeys.length; i++){
            key = sourceSymbolKeys[i];
            if (excluded.indexOf(key) >= 0) continue;
            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
            target[key] = source[key];
        }
    }
    return target;
}
function _object_without_properties_loose(source, excluded) {
    if (source == null) return {};
    var target = {};
    var sourceKeys = Object.keys(source);
    var key, i;
    for(i = 0; i < sourceKeys.length; i++){
        key = sourceKeys[i];
        if (excluded.indexOf(key) >= 0) continue;
        target[key] = source[key];
    }
    return target;
}
function _sliced_to_array(arr, i) {
    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
}
function _unsupported_iterable_to_array(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return _array_like_to_array(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(n);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
}
var react = require('react');
var shim = require('use-sync-external-store/shim');
var publisher = require('./publisher.js');
var utils = require('./utils/index.js');
var defaults = require('./utils/defaults.js');
var jsxRuntime = require('react/jsx-runtime');
// src/create-store.tsx
var ErrorText = "[context-state]: Component must be wrapped with <Store.Provider>";
var fallbackPublisher = new publisher.Publisher(function() {});
function createStore(useHook, options) {
    var _defaults_defaults = defaults.defaults(options || {}, {
        eq: utils.shallowEqual,
        middlewares: []
    }), eq = _defaults_defaults.eq, middlewares = _defaults_defaults.middlewares;
    var StoreContext = react.createContext(fallbackPublisher);
    var Provider = react.memo(function(props) {
        var children = props.children, p = _object_without_properties(props, [
            "children"
        ]);
        var _react_useState = _sliced_to_array(react.useState(function() {
            return new publisher.Publisher(useHook);
        }), 1), publisher$1 = _react_useState[0];
        publisher$1.data = useHook(p);
        react.useEffect(function() {
            publisher$1.notify();
        });
        react.useEffect(function() {
            middlewares.forEach(function(mid) {
                var _mid_onInit;
                (_mid_onInit = mid.onInit) === null || _mid_onInit === void 0 ? void 0 : _mid_onInit.call(mid, publisher$1.data);
            });
        }, []);
        return /* @__PURE__ */ jsxRuntime.jsx(StoreContext.Provider, {
            value: publisher$1,
            children: props.children
        });
    });
    function useStore(selector) {
        if (!selector) {
            selector = function(store2) {
                return store2;
            };
        }
        var publisher = react.useContext(StoreContext);
        if (publisher === fallbackPublisher) {
            console.error(ErrorText);
        }
        var selected = Array.isArray(selector) ? utils.pick(publisher.data, selector) : selector(publisher.data);
        var store = shim.useSyncExternalStore(function(onStoreChange) {
            var listener = function(value) {
                if (!value) return;
                var nextSelected = Array.isArray(selector) ? utils.pick(value, selector) : selector(value);
                if (!eq(selected, nextSelected, utils.shallowEqual)) {
                    onStoreChange();
                    middlewares.forEach(function(mid) {
                        var _mid_onChange;
                        (_mid_onChange = mid.onChange) === null || _mid_onChange === void 0 ? void 0 : _mid_onChange.call(mid, value);
                    });
                }
            };
            publisher.subscribers.add(listener);
            return function() {
                publisher.subscribers["delete"](listener);
            };
        }, function() {
            return publisher.data;
        }, function() {
            return publisher.data;
        });
        return Array.isArray(selector) ? utils.pick(store, selector) : selector(store);
    }
    return {
        useStore: useStore,
        Provider: Provider
    };
}
exports.createStore = createStore;