react-principal/lib/observe.js

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.createObserveContext = exports.useObserveContext = exports.calculateChangedBits = void 0;
const react_1 = __importStar(require("react"));
//@ts-ignore
const invariant_1 = __importDefault(require("invariant"));
const utils_1 = require("./utils");
function useObserveContext(context, nextObserveState) {
    const stateKeys = getKeys(context._currentValue);
    // default observe to whole state
    let observeKeys = stateKeys;
    if (nextObserveState) {
        if (utils_1.__DEV__) {
            invariant_1.default(Array.isArray(nextObserveState), `useState: nextObserveState expected to be an Array of string but ${typeof nextObserveState} was received`);
            nextObserveState.forEach((observeKey) => {
                invariant_1.default(stateKeys.includes(observeKey), `useState: nextObserveState expected to be an Array of state keys but ${observeKey} is not one of the state`);
            });
        }
        observeKeys = nextObserveState.sort();
    }
    const observeBit = getBits(stateKeys, observeKeys);
    return readContext(context, observeBit);
}
exports.useObserveContext = useObserveContext;
function getKeys(obj) {
    return Object.keys(obj).sort();
}
function calculateChangedBits(prev, next) {
    let changed = {};
    const keys = getKeys(next);
    if (utils_1.__DEV__) {
        invariant_1.default(keys.length < 32, `expected return state have property least than 32 but has ${keys.length} property`);
    }
    keys.forEach((key) => {
        if (prev[key] !== next[key]) {
            changed[key] = next[key];
        }
    });
    const changedKeys = getKeys(changed);
    const result = getBits(keys, changedKeys);
    return result;
}
exports.calculateChangedBits = calculateChangedBits;
function getBits(keys, usage) {
    let result = 0;
    keys.forEach((key, index) => {
        if (usage.includes(key)) {
            // eslint-disable-next-line no-bitwise
            result |= 1 << index % 31;
        }
    });
    return result;
}
const ReactCurrentDispatcher = 
// @ts-ignore
react_1.default.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
    .ReactCurrentDispatcher;
function readContext(Context, observedBits) {
    const dispatcher = ReactCurrentDispatcher.current;
    if (dispatcher === null) {
        throw new Error("react-principal: useState and useDispatch may only be called from within a " +
            "component's render. They are not supported in event handlers or " +
            "lifecycle methods.");
    }
    return dispatcher.readContext(Context, observedBits);
}
function createObserveContext(defaultValue) {
    return react_1.createContext(defaultValue, calculateChangedBits);
}
exports.createObserveContext = createObserveContext;
//# sourceMappingURL=observe.js.map