react-principal
Version:
A state management with react context for apps which using hooks.
105 lines • 4.17 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (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.prototype.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) {
const stateKeys = getKeys(context._currentValue);
// default observe to whole state
const observeKeys = (0, react_1.useRef)(new Set(stateKeys));
const observeBit = getBits(stateKeys, [...observeKeys.current].sort());
const state = readContext(context, observeBit);
return new Proxy(state, {
get(target, key) {
if (key in target) {
observeKeys.current.add(key);
return target[key];
}
},
});
}
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__) {
const prevKeys = getKeys(prev);
if (prevKeys.length !== keys.length) {
let missedStates = prevKeys.filter((v) => !keys.includes(v));
missedStates = [
...missedStates,
...keys.filter((v) => !prevKeys.includes(v)),
];
(0, invariant_1.default)(prevKeys.length === keys.length, `expected the number of states will not change, ${missedStates} is missed`);
}
(0, 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 (0, react_1.createContext)(defaultValue, calculateChangedBits);
}
exports.createObserveContext = createObserveContext;
//# sourceMappingURL=observe.js.map