Comparing version 2.0.0-beta.0 to 2.0.0-beta.1
35
index.js
'use strict'; | ||
var vanilla = require('valtio/vanilla'); | ||
var react = require('valtio/react'); | ||
Object.keys(vanilla).forEach(function (k) { | ||
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { | ||
enumerable: true, | ||
get: function () { return vanilla[k]; } | ||
}); | ||
}); | ||
Object.keys(react).forEach(function (k) { | ||
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { | ||
enumerable: true, | ||
get: function () { return react[k]; } | ||
}); | ||
}); | ||
var __defProp = Object.defineProperty; | ||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
var __getOwnPropNames = Object.getOwnPropertyNames; | ||
var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
var __copyProps = (to, from, except, desc) => { | ||
if (from && typeof from === "object" || typeof from === "function") { | ||
for (let key of __getOwnPropNames(from)) | ||
if (!__hasOwnProp.call(to, key) && key !== except) | ||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
} | ||
return to; | ||
}; | ||
var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default")); | ||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
var src_exports = {}; | ||
module.exports = __toCommonJS(src_exports); | ||
__reExport(src_exports, require("./vanilla.ts"), module.exports); | ||
__reExport(src_exports, require("./react.ts"), module.exports); |
{ | ||
"name": "valtio", | ||
"private": false, | ||
"version": "2.0.0-beta.0", | ||
"version": "2.0.0-beta.1", | ||
"publishConfig": { | ||
@@ -82,2 +82,5 @@ "tag": "next" | ||
}, | ||
"resolutions": { | ||
"@types/react": "18.2.56" | ||
}, | ||
"peerDependencies": { | ||
@@ -94,3 +97,4 @@ "@types/react": ">=18.0", | ||
} | ||
} | ||
}, | ||
"packageManager": "yarn@1.22.1" | ||
} |
104
react.js
'use strict'; | ||
var react = require('react'); | ||
var proxyCompare = require('proxy-compare'); | ||
var vanilla = require('valtio/vanilla'); | ||
var useAffectedDebugValue = function useAffectedDebugValue(state, affected) { | ||
var pathList = react.useRef(); | ||
react.useEffect(function () { | ||
pathList.current = proxyCompare.affectedToPathList(state, affected, true); | ||
var __defProp = Object.defineProperty; | ||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
var __getOwnPropNames = Object.getOwnPropertyNames; | ||
var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
var __export = (target, all) => { | ||
for (var name in all) | ||
__defProp(target, name, { get: all[name], enumerable: true }); | ||
}; | ||
var __copyProps = (to, from, except, desc) => { | ||
if (from && typeof from === "object" || typeof from === "function") { | ||
for (let key of __getOwnPropNames(from)) | ||
if (!__hasOwnProp.call(to, key) && key !== except) | ||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
} | ||
return to; | ||
}; | ||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
var react_exports = {}; | ||
__export(react_exports, { | ||
useSnapshot: () => useSnapshot | ||
}); | ||
module.exports = __toCommonJS(react_exports); | ||
var import_react = require("react"); | ||
var import_proxy_compare = require("proxy-compare"); | ||
var import_vanilla = require("./vanilla.ts"); | ||
const useAffectedDebugValue = (state, affected) => { | ||
const pathList = (0, import_react.useRef)(); | ||
(0, import_react.useEffect)(() => { | ||
pathList.current = (0, import_proxy_compare.affectedToPathList)(state, affected, true); | ||
}); | ||
react.useDebugValue(pathList.current); | ||
(0, import_react.useDebugValue)(pathList.current); | ||
}; | ||
var targetCache = new WeakMap(); | ||
const targetCache = /* @__PURE__ */ new WeakMap(); | ||
function useSnapshot(proxyObject, options) { | ||
var notifyInSync = options == null ? void 0 : options.sync; | ||
var lastSnapshot = react.useRef(); | ||
var lastAffected = react.useRef(); | ||
var inRender = true; | ||
var currSnapshot = react.useSyncExternalStore(react.useCallback(function (callback) { | ||
var unsub = vanilla.subscribe(proxyObject, callback, notifyInSync); | ||
callback(); | ||
return unsub; | ||
}, [proxyObject, notifyInSync]), function () { | ||
var nextSnapshot = vanilla.snapshot(proxyObject); | ||
try { | ||
if (!inRender && lastSnapshot.current && lastAffected.current && !proxyCompare.isChanged(lastSnapshot.current, nextSnapshot, lastAffected.current, new WeakMap())) { | ||
return lastSnapshot.current; | ||
const notifyInSync = options == null ? void 0 : options.sync; | ||
const affected = (0, import_react.useMemo)(() => /* @__PURE__ */ new WeakMap(), []); | ||
const lastSnapshot = (0, import_react.useRef)(); | ||
let inRender = true; | ||
const currSnapshot = (0, import_react.useSyncExternalStore)( | ||
(0, import_react.useCallback)( | ||
(callback) => { | ||
const unsub = (0, import_vanilla.subscribe)(proxyObject, callback, notifyInSync); | ||
callback(); | ||
return unsub; | ||
}, | ||
[proxyObject, notifyInSync] | ||
), | ||
() => { | ||
const nextSnapshot = (0, import_vanilla.snapshot)(proxyObject); | ||
try { | ||
if (!inRender && lastSnapshot.current && !(0, import_proxy_compare.isChanged)( | ||
lastSnapshot.current, | ||
nextSnapshot, | ||
affected, | ||
/* @__PURE__ */ new WeakMap() | ||
)) { | ||
return lastSnapshot.current; | ||
} | ||
} catch (e) { | ||
} | ||
} catch (e) {} | ||
return nextSnapshot; | ||
}, function () { | ||
return vanilla.snapshot(proxyObject); | ||
}); | ||
return nextSnapshot; | ||
}, | ||
() => (0, import_vanilla.snapshot)(proxyObject) | ||
); | ||
inRender = false; | ||
var currAffected = new WeakMap(); | ||
react.useEffect(function () { | ||
(0, import_react.useEffect)(() => { | ||
lastSnapshot.current = currSnapshot; | ||
lastAffected.current = currAffected; | ||
}); | ||
if (process.env.NODE_ENV !== 'production') { | ||
useAffectedDebugValue(currSnapshot, currAffected); | ||
if (process.env.NODE_ENV !== "production") { | ||
useAffectedDebugValue(currSnapshot, affected); | ||
} | ||
var proxyCache = react.useMemo(function () { | ||
return new WeakMap(); | ||
}, []); | ||
return proxyCompare.createProxy(currSnapshot, currAffected, proxyCache, targetCache); | ||
const proxyCache = (0, import_react.useMemo)(() => /* @__PURE__ */ new WeakMap(), []); | ||
return (0, import_proxy_compare.createProxy)(currSnapshot, affected, proxyCache, targetCache); | ||
} | ||
exports.useSnapshot = useSnapshot; |
'use strict'; | ||
var react$1 = require('react'); | ||
var react = require('valtio/react'); | ||
var DUMMY_SYMBOL = Symbol(); | ||
function useProxy(proxy, options) { | ||
var snapshot = react.useSnapshot(proxy, options); | ||
snapshot[DUMMY_SYMBOL]; | ||
var isRendering = true; | ||
react$1.useLayoutEffect(function () { | ||
isRendering = false; | ||
}); | ||
return new Proxy(proxy, { | ||
get: function get(target, prop) { | ||
return isRendering ? snapshot[prop] : target[prop]; | ||
} | ||
}); | ||
} | ||
exports.useProxy = useProxy; | ||
var __defProp = Object.defineProperty; | ||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
var __getOwnPropNames = Object.getOwnPropertyNames; | ||
var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
var __export = (target, all) => { | ||
for (var name in all) | ||
__defProp(target, name, { get: all[name], enumerable: true }); | ||
}; | ||
var __copyProps = (to, from, except, desc) => { | ||
if (from && typeof from === "object" || typeof from === "function") { | ||
for (let key of __getOwnPropNames(from)) | ||
if (!__hasOwnProp.call(to, key) && key !== except) | ||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
} | ||
return to; | ||
}; | ||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
var utils_exports = {}; | ||
__export(utils_exports, { | ||
useProxy: () => import_useProxy.useProxy | ||
}); | ||
module.exports = __toCommonJS(utils_exports); | ||
var import_useProxy = require("./utils/useProxy.ts"); |
35
utils.js
'use strict'; | ||
var utils = require('valtio/vanilla/utils'); | ||
var utils$1 = require('valtio/react/utils'); | ||
Object.keys(utils).forEach(function (k) { | ||
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { | ||
enumerable: true, | ||
get: function () { return utils[k]; } | ||
}); | ||
}); | ||
Object.keys(utils$1).forEach(function (k) { | ||
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { | ||
enumerable: true, | ||
get: function () { return utils$1[k]; } | ||
}); | ||
}); | ||
var __defProp = Object.defineProperty; | ||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
var __getOwnPropNames = Object.getOwnPropertyNames; | ||
var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
var __copyProps = (to, from, except, desc) => { | ||
if (from && typeof from === "object" || typeof from === "function") { | ||
for (let key of __getOwnPropNames(from)) | ||
if (!__hasOwnProp.call(to, key) && key !== except) | ||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
} | ||
return to; | ||
}; | ||
var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default")); | ||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
var utils_exports = {}; | ||
module.exports = __toCommonJS(utils_exports); | ||
__reExport(utils_exports, require("./vanilla/utils.ts"), module.exports); | ||
__reExport(utils_exports, require("./react/utils.ts"), module.exports); |
479
vanilla.js
'use strict'; | ||
var proxyCompare = require('proxy-compare'); | ||
var isObject = function isObject(x) { | ||
return typeof x === 'object' && x !== null; | ||
var __defProp = Object.defineProperty; | ||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
var __getOwnPropNames = Object.getOwnPropertyNames; | ||
var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
var __export = (target, all) => { | ||
for (var name in all) | ||
__defProp(target, name, { get: all[name], enumerable: true }); | ||
}; | ||
var proxyStateMap = new WeakMap(); | ||
var refSet = new WeakSet(); | ||
var buildProxyFunction = function buildProxyFunction(objectIs, newProxy, canProxy, snapCache, createSnapshot, proxyCache, versionHolder, _proxyFunction) { | ||
if (objectIs === void 0) { | ||
objectIs = Object.is; | ||
var __copyProps = (to, from, except, desc) => { | ||
if (from && typeof from === "object" || typeof from === "function") { | ||
for (let key of __getOwnPropNames(from)) | ||
if (!__hasOwnProp.call(to, key) && key !== except) | ||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
} | ||
if (newProxy === void 0) { | ||
newProxy = function newProxy(target, handler) { | ||
return new Proxy(target, handler); | ||
}; | ||
return to; | ||
}; | ||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
var vanilla_exports = {}; | ||
__export(vanilla_exports, { | ||
getVersion: () => getVersion, | ||
proxy: () => proxy, | ||
ref: () => ref, | ||
snapshot: () => snapshot, | ||
subscribe: () => subscribe, | ||
unstable_buildProxyFunction: () => unstable_buildProxyFunction | ||
}); | ||
module.exports = __toCommonJS(vanilla_exports); | ||
var import_proxy_compare = require("proxy-compare"); | ||
const isObject = (x) => typeof x === "object" && x !== null; | ||
const proxyStateMap = /* @__PURE__ */ new WeakMap(); | ||
const refSet = /* @__PURE__ */ new WeakSet(); | ||
const buildProxyFunction = (objectIs = Object.is, newProxy = (target, handler) => new Proxy(target, handler), canProxy = (x) => isObject(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in x)) && !(x instanceof WeakMap) && !(x instanceof WeakSet) && !(x instanceof Error) && !(x instanceof Number) && !(x instanceof Date) && !(x instanceof String) && !(x instanceof RegExp) && !(x instanceof ArrayBuffer), snapCache = /* @__PURE__ */ new WeakMap(), createSnapshot = (target, version) => { | ||
const cache = snapCache.get(target); | ||
if ((cache == null ? void 0 : cache[0]) === version) { | ||
return cache[1]; | ||
} | ||
if (canProxy === void 0) { | ||
canProxy = function canProxy(x) { | ||
return isObject(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in x)) && !(x instanceof WeakMap) && !(x instanceof WeakSet) && !(x instanceof Error) && !(x instanceof Number) && !(x instanceof Date) && !(x instanceof String) && !(x instanceof RegExp) && !(x instanceof ArrayBuffer); | ||
const snap = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target)); | ||
(0, import_proxy_compare.markToTrack)(snap, true); | ||
snapCache.set(target, [version, snap]); | ||
Reflect.ownKeys(target).forEach((key) => { | ||
if (Object.getOwnPropertyDescriptor(snap, key)) { | ||
return; | ||
} | ||
const value = Reflect.get(target, key); | ||
const { enumerable } = Reflect.getOwnPropertyDescriptor( | ||
target, | ||
key | ||
); | ||
const desc = { | ||
value, | ||
enumerable, | ||
// This is intentional to avoid copying with proxy-compare. | ||
// It's still non-writable, so it avoids assigning a value. | ||
configurable: true | ||
}; | ||
if (refSet.has(value)) { | ||
(0, import_proxy_compare.markToTrack)(value, false); | ||
} else if (proxyStateMap.has(value)) { | ||
const [target2, ensureVersion] = proxyStateMap.get( | ||
value | ||
); | ||
desc.value = createSnapshot(target2, ensureVersion()); | ||
} | ||
Object.defineProperty(snap, key, desc); | ||
}); | ||
return Object.preventExtensions(snap); | ||
}, proxyCache = /* @__PURE__ */ new WeakMap(), versionHolder = [1, 1], proxyFunction = (baseObject) => { | ||
if (!isObject(baseObject)) { | ||
throw new Error("object required"); | ||
} | ||
if (snapCache === void 0) { | ||
snapCache = new WeakMap(); | ||
const found = proxyCache.get(baseObject); | ||
if (found) { | ||
return found; | ||
} | ||
if (createSnapshot === void 0) { | ||
createSnapshot = function (_createSnapshot) { | ||
function createSnapshot(_x, _x2) { | ||
return _createSnapshot.apply(this, arguments); | ||
} | ||
createSnapshot.toString = function () { | ||
return _createSnapshot.toString(); | ||
}; | ||
return createSnapshot; | ||
}(function (target, version) { | ||
var cache = snapCache.get(target); | ||
if ((cache == null ? void 0 : cache[0]) === version) { | ||
return cache[1]; | ||
} | ||
var snap = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target)); | ||
proxyCompare.markToTrack(snap, true); | ||
snapCache.set(target, [version, snap]); | ||
Reflect.ownKeys(target).forEach(function (key) { | ||
if (Object.getOwnPropertyDescriptor(snap, key)) { | ||
return; | ||
let version = versionHolder[0]; | ||
const listeners = /* @__PURE__ */ new Set(); | ||
const notifyUpdate = (op, nextVersion = ++versionHolder[0]) => { | ||
if (version !== nextVersion) { | ||
version = nextVersion; | ||
listeners.forEach((listener) => listener(op, nextVersion)); | ||
} | ||
}; | ||
let checkVersion = versionHolder[1]; | ||
const ensureVersion = (nextCheckVersion = ++versionHolder[1]) => { | ||
if (checkVersion !== nextCheckVersion && !listeners.size) { | ||
checkVersion = nextCheckVersion; | ||
propProxyStates.forEach(([propProxyState]) => { | ||
const propVersion = propProxyState[1](nextCheckVersion); | ||
if (propVersion > version) { | ||
version = propVersion; | ||
} | ||
var value = Reflect.get(target, key); | ||
var _ref = Reflect.getOwnPropertyDescriptor(target, key), | ||
enumerable = _ref.enumerable; | ||
var desc = { | ||
value: value, | ||
enumerable: enumerable, | ||
configurable: true | ||
}; | ||
if (refSet.has(value)) { | ||
proxyCompare.markToTrack(value, false); | ||
} else if (proxyStateMap.has(value)) { | ||
var _ref2 = proxyStateMap.get(value), | ||
_target = _ref2[0], | ||
_ensureVersion = _ref2[1]; | ||
desc.value = createSnapshot(_target, _ensureVersion()); | ||
} | ||
Object.defineProperty(snap, key, desc); | ||
}); | ||
return Object.preventExtensions(snap); | ||
}); | ||
} | ||
if (proxyCache === void 0) { | ||
proxyCache = new WeakMap(); | ||
} | ||
if (versionHolder === void 0) { | ||
versionHolder = [1, 1]; | ||
} | ||
if (_proxyFunction === void 0) { | ||
_proxyFunction = function proxyFunction(baseObject) { | ||
if (!isObject(baseObject)) { | ||
throw new Error('object required'); | ||
} | ||
return version; | ||
}; | ||
const createPropListener = (prop) => (op, nextVersion) => { | ||
const newOp = [...op]; | ||
newOp[1] = [prop, ...newOp[1]]; | ||
notifyUpdate(newOp, nextVersion); | ||
}; | ||
const propProxyStates = /* @__PURE__ */ new Map(); | ||
const addPropListener = (prop, propValue) => { | ||
const propProxyState = !refSet.has(propValue) && proxyStateMap.get(propValue); | ||
if (propProxyState) { | ||
if (process.env.NODE_ENV !== "production" && propProxyStates.has(prop)) { | ||
throw new Error("prop listener already exists"); | ||
} | ||
var found = proxyCache.get(baseObject); | ||
if (found) { | ||
return found; | ||
if (listeners.size) { | ||
const remove = propProxyState[3](createPropListener(prop)); | ||
propProxyStates.set(prop, [propProxyState, remove]); | ||
} else { | ||
propProxyStates.set(prop, [propProxyState]); | ||
} | ||
var version = versionHolder[0]; | ||
var listeners = new Set(); | ||
var notifyUpdate = function notifyUpdate(op, nextVersion) { | ||
if (nextVersion === void 0) { | ||
nextVersion = ++versionHolder[0]; | ||
} | ||
}; | ||
const removePropListener = (prop) => { | ||
var _a; | ||
const entry = propProxyStates.get(prop); | ||
if (entry) { | ||
propProxyStates.delete(prop); | ||
(_a = entry[1]) == null ? void 0 : _a.call(entry); | ||
} | ||
}; | ||
const addListener = (listener) => { | ||
listeners.add(listener); | ||
if (listeners.size === 1) { | ||
propProxyStates.forEach(([propProxyState, prevRemove], prop) => { | ||
if (process.env.NODE_ENV !== "production" && prevRemove) { | ||
throw new Error("remove already exists"); | ||
} | ||
if (version !== nextVersion) { | ||
version = nextVersion; | ||
listeners.forEach(function (listener) { | ||
return listener(op, nextVersion); | ||
}); | ||
} | ||
}; | ||
var checkVersion = versionHolder[1]; | ||
var ensureVersion = function ensureVersion(nextCheckVersion) { | ||
if (nextCheckVersion === void 0) { | ||
nextCheckVersion = ++versionHolder[1]; | ||
} | ||
if (checkVersion !== nextCheckVersion && !listeners.size) { | ||
checkVersion = nextCheckVersion; | ||
propProxyStates.forEach(function (_ref3) { | ||
var propProxyState = _ref3[0]; | ||
var propVersion = propProxyState[1](nextCheckVersion); | ||
if (propVersion > version) { | ||
version = propVersion; | ||
} | ||
}); | ||
} | ||
return version; | ||
}; | ||
var createPropListener = function createPropListener(prop) { | ||
return function (op, nextVersion) { | ||
var newOp = [].concat(op); | ||
newOp[1] = [prop].concat(newOp[1]); | ||
notifyUpdate(newOp, nextVersion); | ||
}; | ||
}; | ||
var propProxyStates = new Map(); | ||
var addPropListener = function addPropListener(prop, propValue) { | ||
var propProxyState = !refSet.has(propValue) && proxyStateMap.get(propValue); | ||
if (propProxyState) { | ||
if (process.env.NODE_ENV !== 'production' && propProxyStates.has(prop)) { | ||
throw new Error('prop listener already exists'); | ||
} | ||
if (listeners.size) { | ||
var remove = propProxyState[3](createPropListener(prop)); | ||
propProxyStates.set(prop, [propProxyState, remove]); | ||
} else { | ||
const remove = propProxyState[3](createPropListener(prop)); | ||
propProxyStates.set(prop, [propProxyState, remove]); | ||
}); | ||
} | ||
const removeListener = () => { | ||
listeners.delete(listener); | ||
if (listeners.size === 0) { | ||
propProxyStates.forEach(([propProxyState, remove], prop) => { | ||
if (remove) { | ||
remove(); | ||
propProxyStates.set(prop, [propProxyState]); | ||
} | ||
}); | ||
} | ||
}; | ||
return removeListener; | ||
}; | ||
let initializing = true; | ||
const handler = { | ||
deleteProperty(target, prop) { | ||
const prevValue = Reflect.get(target, prop); | ||
removePropListener(prop); | ||
const deleted = Reflect.deleteProperty(target, prop); | ||
if (deleted) { | ||
notifyUpdate(["delete", [prop], prevValue]); | ||
} | ||
return deleted; | ||
}, | ||
set(target, prop, value, receiver) { | ||
const hasPrevValue = !initializing && Reflect.has(target, prop); | ||
const prevValue = Reflect.get(target, prop, receiver); | ||
if (hasPrevValue && (objectIs(prevValue, value) || proxyCache.has(value) && objectIs(prevValue, proxyCache.get(value)))) { | ||
return true; | ||
} | ||
removePropListener(prop); | ||
if (isObject(value)) { | ||
value = (0, import_proxy_compare.getUntracked)(value) || value; | ||
} | ||
let nextValue = value; | ||
if (value instanceof Promise) { | ||
value.then((v) => { | ||
value.status = "fulfilled"; | ||
value.value = v; | ||
notifyUpdate(["resolve", [prop], v]); | ||
}).catch((e) => { | ||
value.status = "rejected"; | ||
value.reason = e; | ||
notifyUpdate(["reject", [prop], e]); | ||
}); | ||
} else { | ||
if (!proxyStateMap.has(value) && canProxy(value)) { | ||
nextValue = proxyFunction(value); | ||
} | ||
}; | ||
var removePropListener = function removePropListener(prop) { | ||
var entry = propProxyStates.get(prop); | ||
if (entry) { | ||
var _entry$; | ||
propProxyStates.delete(prop); | ||
(_entry$ = entry[1]) == null || _entry$.call(entry); | ||
} | ||
}; | ||
var addListener = function addListener(listener) { | ||
listeners.add(listener); | ||
if (listeners.size === 1) { | ||
propProxyStates.forEach(function (_ref4, prop) { | ||
var propProxyState = _ref4[0], | ||
prevRemove = _ref4[1]; | ||
if (process.env.NODE_ENV !== 'production' && prevRemove) { | ||
throw new Error('remove already exists'); | ||
} | ||
var remove = propProxyState[3](createPropListener(prop)); | ||
propProxyStates.set(prop, [propProxyState, remove]); | ||
}); | ||
} | ||
var removeListener = function removeListener() { | ||
listeners.delete(listener); | ||
if (listeners.size === 0) { | ||
propProxyStates.forEach(function (_ref5, prop) { | ||
var propProxyState = _ref5[0], | ||
remove = _ref5[1]; | ||
if (remove) { | ||
remove(); | ||
propProxyStates.set(prop, [propProxyState]); | ||
} | ||
}); | ||
} | ||
}; | ||
return removeListener; | ||
}; | ||
var initializing = true; | ||
var handler = { | ||
deleteProperty: function deleteProperty(target, prop) { | ||
var prevValue = Reflect.get(target, prop); | ||
removePropListener(prop); | ||
var deleted = Reflect.deleteProperty(target, prop); | ||
if (deleted) { | ||
notifyUpdate(['delete', [prop], prevValue]); | ||
} | ||
return deleted; | ||
}, | ||
set: function set(target, prop, value, receiver) { | ||
var hasPrevValue = !initializing && Reflect.has(target, prop); | ||
var prevValue = Reflect.get(target, prop, receiver); | ||
if (hasPrevValue && (objectIs(prevValue, value) || proxyCache.has(value) && objectIs(prevValue, proxyCache.get(value)))) { | ||
return true; | ||
} | ||
removePropListener(prop); | ||
if (isObject(value)) { | ||
value = proxyCompare.getUntracked(value) || value; | ||
} | ||
var nextValue = value; | ||
if (value instanceof Promise) { | ||
value.then(function (v) { | ||
value.status = 'fulfilled'; | ||
value.value = v; | ||
notifyUpdate(['resolve', [prop], v]); | ||
}).catch(function (e) { | ||
value.status = 'rejected'; | ||
value.reason = e; | ||
notifyUpdate(['reject', [prop], e]); | ||
}); | ||
} else { | ||
if (!proxyStateMap.has(value) && canProxy(value)) { | ||
nextValue = _proxyFunction(value); | ||
} | ||
addPropListener(prop, nextValue); | ||
} | ||
Reflect.set(target, prop, nextValue, receiver); | ||
notifyUpdate(['set', [prop], value, prevValue]); | ||
return true; | ||
} | ||
}; | ||
var proxyObject = newProxy(baseObject, handler); | ||
proxyCache.set(baseObject, proxyObject); | ||
var proxyState = [baseObject, ensureVersion, createSnapshot, addListener]; | ||
proxyStateMap.set(proxyObject, proxyState); | ||
Reflect.ownKeys(baseObject).forEach(function (key) { | ||
var desc = Object.getOwnPropertyDescriptor(baseObject, key); | ||
if ('value' in desc && desc.writable) { | ||
proxyObject[key] = baseObject[key]; | ||
} | ||
}); | ||
initializing = false; | ||
return proxyObject; | ||
}; | ||
} | ||
return [_proxyFunction, proxyStateMap, refSet, objectIs, newProxy, canProxy, snapCache, createSnapshot, proxyCache, versionHolder]; | ||
}; | ||
var _buildProxyFunction = buildProxyFunction(), | ||
defaultProxyFunction = _buildProxyFunction[0]; | ||
function proxy(baseObject) { | ||
if (baseObject === void 0) { | ||
baseObject = {}; | ||
} | ||
addPropListener(prop, nextValue); | ||
} | ||
Reflect.set(target, prop, nextValue, receiver); | ||
notifyUpdate(["set", [prop], value, prevValue]); | ||
return true; | ||
} | ||
}; | ||
const proxyObject = newProxy(baseObject, handler); | ||
proxyCache.set(baseObject, proxyObject); | ||
const proxyState = [ | ||
baseObject, | ||
ensureVersion, | ||
createSnapshot, | ||
addListener | ||
]; | ||
proxyStateMap.set(proxyObject, proxyState); | ||
Reflect.ownKeys(baseObject).forEach((key) => { | ||
const desc = Object.getOwnPropertyDescriptor( | ||
baseObject, | ||
key | ||
); | ||
if ("value" in desc && desc.writable) { | ||
proxyObject[key] = baseObject[key]; | ||
} | ||
}); | ||
initializing = false; | ||
return proxyObject; | ||
}) => [ | ||
// public functions | ||
proxyFunction, | ||
// shared state | ||
proxyStateMap, | ||
refSet, | ||
// internal things | ||
objectIs, | ||
newProxy, | ||
canProxy, | ||
snapCache, | ||
createSnapshot, | ||
proxyCache, | ||
versionHolder | ||
]; | ||
const [defaultProxyFunction] = buildProxyFunction(); | ||
function proxy(baseObject = {}) { | ||
return defaultProxyFunction(baseObject); | ||
} | ||
function getVersion(proxyObject) { | ||
var proxyState = proxyStateMap.get(proxyObject); | ||
const proxyState = proxyStateMap.get(proxyObject); | ||
return proxyState == null ? void 0 : proxyState[1](); | ||
} | ||
function subscribe(proxyObject, callback, notifyInSync) { | ||
var proxyState = proxyStateMap.get(proxyObject); | ||
if (process.env.NODE_ENV !== 'production' && !proxyState) { | ||
console.warn('Please use proxy object'); | ||
const proxyState = proxyStateMap.get(proxyObject); | ||
if (process.env.NODE_ENV !== "production" && !proxyState) { | ||
console.warn("Please use proxy object"); | ||
} | ||
var promise; | ||
var ops = []; | ||
var addListener = proxyState[3]; | ||
var isListenerActive = false; | ||
var listener = function listener(op) { | ||
let promise; | ||
const ops = []; | ||
const addListener = proxyState[3]; | ||
let isListenerActive = false; | ||
const listener = (op) => { | ||
ops.push(op); | ||
@@ -259,4 +252,4 @@ if (notifyInSync) { | ||
if (!promise) { | ||
promise = Promise.resolve().then(function () { | ||
promise = undefined; | ||
promise = Promise.resolve().then(() => { | ||
promise = void 0; | ||
if (isListenerActive) { | ||
@@ -268,5 +261,5 @@ callback(ops.splice(0)); | ||
}; | ||
var removeListener = addListener(listener); | ||
const removeListener = addListener(listener); | ||
isListenerActive = true; | ||
return function () { | ||
return () => { | ||
isListenerActive = false; | ||
@@ -277,10 +270,7 @@ removeListener(); | ||
function snapshot(proxyObject) { | ||
var proxyState = proxyStateMap.get(proxyObject); | ||
if (process.env.NODE_ENV !== 'production' && !proxyState) { | ||
console.warn('Please use proxy object'); | ||
const proxyState = proxyStateMap.get(proxyObject); | ||
if (process.env.NODE_ENV !== "production" && !proxyState) { | ||
console.warn("Please use proxy object"); | ||
} | ||
var _ref6 = proxyState, | ||
target = _ref6[0], | ||
ensureVersion = _ref6[1], | ||
createSnapshot = _ref6[2]; | ||
const [target, ensureVersion, createSnapshot] = proxyState; | ||
return createSnapshot(target, ensureVersion()); | ||
@@ -292,9 +282,2 @@ } | ||
} | ||
var unstable_buildProxyFunction = buildProxyFunction; | ||
exports.getVersion = getVersion; | ||
exports.proxy = proxy; | ||
exports.ref = ref; | ||
exports.snapshot = snapshot; | ||
exports.subscribe = subscribe; | ||
exports.unstable_buildProxyFunction = unstable_buildProxyFunction; | ||
const unstable_buildProxyFunction = buildProxyFunction; |
'use strict'; | ||
var vanilla = require('valtio/vanilla'); | ||
function subscribeKey(proxyObject, key, callback, notifyInSync) { | ||
var prevValue = proxyObject[key]; | ||
return vanilla.subscribe(proxyObject, function () { | ||
var nextValue = proxyObject[key]; | ||
if (!Object.is(prevValue, nextValue)) { | ||
callback(prevValue = nextValue); | ||
} | ||
}, notifyInSync); | ||
} | ||
function _defineAccessor(e, r, n, t) { | ||
var c = { | ||
configurable: !0, | ||
enumerable: !0 | ||
}; | ||
return c[e] = t, Object.defineProperty(r, n, c); | ||
} | ||
function _regeneratorRuntime() { | ||
_regeneratorRuntime = function () { | ||
return e; | ||
}; | ||
var t, | ||
e = {}, | ||
r = Object.prototype, | ||
n = r.hasOwnProperty, | ||
o = Object.defineProperty || function (t, e, r) { | ||
t[e] = r.value; | ||
}, | ||
i = "function" == typeof Symbol ? Symbol : {}, | ||
a = i.iterator || "@@iterator", | ||
c = i.asyncIterator || "@@asyncIterator", | ||
u = i.toStringTag || "@@toStringTag"; | ||
function define(t, e, r) { | ||
return Object.defineProperty(t, e, { | ||
value: r, | ||
enumerable: !0, | ||
configurable: !0, | ||
writable: !0 | ||
}), t[e]; | ||
} | ||
try { | ||
define({}, ""); | ||
} catch (t) { | ||
define = function (t, e, r) { | ||
return t[e] = r; | ||
}; | ||
} | ||
function wrap(t, e, r, n) { | ||
var i = e && e.prototype instanceof Generator ? e : Generator, | ||
a = Object.create(i.prototype), | ||
c = new Context(n || []); | ||
return o(a, "_invoke", { | ||
value: makeInvokeMethod(t, r, c) | ||
}), a; | ||
} | ||
function tryCatch(t, e, r) { | ||
try { | ||
return { | ||
type: "normal", | ||
arg: t.call(e, r) | ||
}; | ||
} catch (t) { | ||
return { | ||
type: "throw", | ||
arg: t | ||
}; | ||
} | ||
} | ||
e.wrap = wrap; | ||
var h = "suspendedStart", | ||
l = "suspendedYield", | ||
f = "executing", | ||
s = "completed", | ||
y = {}; | ||
function Generator() {} | ||
function GeneratorFunction() {} | ||
function GeneratorFunctionPrototype() {} | ||
var p = {}; | ||
define(p, a, function () { | ||
return this; | ||
}); | ||
var d = Object.getPrototypeOf, | ||
v = d && d(d(values([]))); | ||
v && v !== r && n.call(v, a) && (p = v); | ||
var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p); | ||
function defineIteratorMethods(t) { | ||
["next", "throw", "return"].forEach(function (e) { | ||
define(t, e, function (t) { | ||
return this._invoke(e, t); | ||
}); | ||
}); | ||
} | ||
function AsyncIterator(t, e) { | ||
function invoke(r, o, i, a) { | ||
var c = tryCatch(t[r], t, o); | ||
if ("throw" !== c.type) { | ||
var u = c.arg, | ||
h = u.value; | ||
return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) { | ||
invoke("next", t, i, a); | ||
}, function (t) { | ||
invoke("throw", t, i, a); | ||
}) : e.resolve(h).then(function (t) { | ||
u.value = t, i(u); | ||
}, function (t) { | ||
return invoke("throw", t, i, a); | ||
}); | ||
} | ||
a(c.arg); | ||
} | ||
var r; | ||
o(this, "_invoke", { | ||
value: function (t, n) { | ||
function callInvokeWithMethodAndArg() { | ||
return new e(function (e, r) { | ||
invoke(t, n, e, r); | ||
}); | ||
} | ||
return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); | ||
} | ||
}); | ||
} | ||
function makeInvokeMethod(e, r, n) { | ||
var o = h; | ||
return function (i, a) { | ||
if (o === f) throw new Error("Generator is already running"); | ||
if (o === s) { | ||
if ("throw" === i) throw a; | ||
return { | ||
value: t, | ||
done: !0 | ||
}; | ||
} | ||
for (n.method = i, n.arg = a;;) { | ||
var c = n.delegate; | ||
if (c) { | ||
var u = maybeInvokeDelegate(c, n); | ||
if (u) { | ||
if (u === y) continue; | ||
return u; | ||
} | ||
} | ||
if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) { | ||
if (o === h) throw o = s, n.arg; | ||
n.dispatchException(n.arg); | ||
} else "return" === n.method && n.abrupt("return", n.arg); | ||
o = f; | ||
var p = tryCatch(e, r, n); | ||
if ("normal" === p.type) { | ||
if (o = n.done ? s : l, p.arg === y) continue; | ||
return { | ||
value: p.arg, | ||
done: n.done | ||
}; | ||
} | ||
"throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg); | ||
} | ||
}; | ||
} | ||
function maybeInvokeDelegate(e, r) { | ||
var n = r.method, | ||
o = e.iterator[n]; | ||
if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y; | ||
var i = tryCatch(o, e.iterator, r.arg); | ||
if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y; | ||
var a = i.arg; | ||
return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y); | ||
} | ||
function pushTryEntry(t) { | ||
var e = { | ||
tryLoc: t[0] | ||
}; | ||
1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e); | ||
} | ||
function resetTryEntry(t) { | ||
var e = t.completion || {}; | ||
e.type = "normal", delete e.arg, t.completion = e; | ||
} | ||
function Context(t) { | ||
this.tryEntries = [{ | ||
tryLoc: "root" | ||
}], t.forEach(pushTryEntry, this), this.reset(!0); | ||
} | ||
function values(e) { | ||
if (e || "" === e) { | ||
var r = e[a]; | ||
if (r) return r.call(e); | ||
if ("function" == typeof e.next) return e; | ||
if (!isNaN(e.length)) { | ||
var o = -1, | ||
i = function next() { | ||
for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next; | ||
return next.value = t, next.done = !0, next; | ||
}; | ||
return i.next = i; | ||
} | ||
} | ||
throw new TypeError(typeof e + " is not iterable"); | ||
} | ||
return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", { | ||
value: GeneratorFunctionPrototype, | ||
configurable: !0 | ||
}), o(GeneratorFunctionPrototype, "constructor", { | ||
value: GeneratorFunction, | ||
configurable: !0 | ||
}), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) { | ||
var e = "function" == typeof t && t.constructor; | ||
return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name)); | ||
}, e.mark = function (t) { | ||
return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t; | ||
}, e.awrap = function (t) { | ||
return { | ||
__await: t | ||
}; | ||
}, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () { | ||
return this; | ||
}), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) { | ||
void 0 === i && (i = Promise); | ||
var a = new AsyncIterator(wrap(t, r, n, o), i); | ||
return e.isGeneratorFunction(r) ? a : a.next().then(function (t) { | ||
return t.done ? t.value : a.next(); | ||
}); | ||
}, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () { | ||
return this; | ||
}), define(g, "toString", function () { | ||
return "[object Generator]"; | ||
}), e.keys = function (t) { | ||
var e = Object(t), | ||
r = []; | ||
for (var n in e) r.push(n); | ||
return r.reverse(), function next() { | ||
for (; r.length;) { | ||
var t = r.pop(); | ||
if (t in e) return next.value = t, next.done = !1, next; | ||
} | ||
return next.done = !0, next; | ||
}; | ||
}, e.values = values, Context.prototype = { | ||
constructor: Context, | ||
reset: function (e) { | ||
if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t); | ||
}, | ||
stop: function () { | ||
this.done = !0; | ||
var t = this.tryEntries[0].completion; | ||
if ("throw" === t.type) throw t.arg; | ||
return this.rval; | ||
}, | ||
dispatchException: function (e) { | ||
if (this.done) throw e; | ||
var r = this; | ||
function handle(n, o) { | ||
return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o; | ||
} | ||
for (var o = this.tryEntries.length - 1; o >= 0; --o) { | ||
var i = this.tryEntries[o], | ||
a = i.completion; | ||
if ("root" === i.tryLoc) return handle("end"); | ||
if (i.tryLoc <= this.prev) { | ||
var c = n.call(i, "catchLoc"), | ||
u = n.call(i, "finallyLoc"); | ||
if (c && u) { | ||
if (this.prev < i.catchLoc) return handle(i.catchLoc, !0); | ||
if (this.prev < i.finallyLoc) return handle(i.finallyLoc); | ||
} else if (c) { | ||
if (this.prev < i.catchLoc) return handle(i.catchLoc, !0); | ||
} else { | ||
if (!u) throw new Error("try statement without catch or finally"); | ||
if (this.prev < i.finallyLoc) return handle(i.finallyLoc); | ||
} | ||
} | ||
} | ||
}, | ||
abrupt: function (t, e) { | ||
for (var r = this.tryEntries.length - 1; r >= 0; --r) { | ||
var o = this.tryEntries[r]; | ||
if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) { | ||
var i = o; | ||
break; | ||
} | ||
} | ||
i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null); | ||
var a = i ? i.completion : {}; | ||
return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a); | ||
}, | ||
complete: function (t, e) { | ||
if ("throw" === t.type) throw t.arg; | ||
return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y; | ||
}, | ||
finish: function (t) { | ||
for (var e = this.tryEntries.length - 1; e >= 0; --e) { | ||
var r = this.tryEntries[e]; | ||
if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y; | ||
} | ||
}, | ||
catch: function (t) { | ||
for (var e = this.tryEntries.length - 1; e >= 0; --e) { | ||
var r = this.tryEntries[e]; | ||
if (r.tryLoc === t) { | ||
var n = r.completion; | ||
if ("throw" === n.type) { | ||
var o = n.arg; | ||
resetTryEntry(r); | ||
} | ||
return o; | ||
} | ||
} | ||
throw new Error("illegal catch attempt"); | ||
}, | ||
delegateYield: function (e, r, n) { | ||
return this.delegate = { | ||
iterator: values(e), | ||
resultName: r, | ||
nextLoc: n | ||
}, "next" === this.method && (this.arg = t), y; | ||
} | ||
}, e; | ||
} | ||
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { | ||
try { | ||
var info = gen[key](arg); | ||
var value = info.value; | ||
} catch (error) { | ||
reject(error); | ||
return; | ||
} | ||
if (info.done) { | ||
resolve(value); | ||
} else { | ||
Promise.resolve(value).then(_next, _throw); | ||
} | ||
} | ||
function _asyncToGenerator(fn) { | ||
return function () { | ||
var self = this, | ||
args = arguments; | ||
return new Promise(function (resolve, reject) { | ||
var gen = fn.apply(self, args); | ||
function _next(value) { | ||
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); | ||
} | ||
function _throw(err) { | ||
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); | ||
} | ||
_next(undefined); | ||
}); | ||
}; | ||
} | ||
function _extends() { | ||
_extends = Object.assign ? Object.assign.bind() : function (target) { | ||
for (var i = 1; i < arguments.length; i++) { | ||
var source = arguments[i]; | ||
for (var key in source) { | ||
if (Object.prototype.hasOwnProperty.call(source, key)) { | ||
target[key] = source[key]; | ||
} | ||
} | ||
} | ||
return target; | ||
}; | ||
return _extends.apply(this, arguments); | ||
} | ||
function _objectWithoutPropertiesLoose(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; | ||
} | ||
var currentCleanups; | ||
function watch(callback, options) { | ||
var alive = true; | ||
var cleanups = new Set(); | ||
var subscriptions = new Map(); | ||
var cleanup = function cleanup() { | ||
if (alive) { | ||
alive = false; | ||
cleanups.forEach(function (clean) { | ||
return clean(); | ||
}); | ||
cleanups.clear(); | ||
subscriptions.forEach(function (unsubscribe) { | ||
return unsubscribe(); | ||
}); | ||
subscriptions.clear(); | ||
} | ||
}; | ||
var revalidate = function () { | ||
var _ref = _asyncToGenerator(_regeneratorRuntime().mark(function _callee() { | ||
var proxiesToSubscribe, parent, promiseOrPossibleCleanup, couldBeCleanup; | ||
return _regeneratorRuntime().wrap(function _callee$(_context) { | ||
while (1) switch (_context.prev = _context.next) { | ||
case 0: | ||
if (alive) { | ||
_context.next = 2; | ||
break; | ||
} | ||
return _context.abrupt("return"); | ||
case 2: | ||
cleanups.forEach(function (clean) { | ||
return clean(); | ||
}); | ||
cleanups.clear(); | ||
proxiesToSubscribe = new Set(); | ||
parent = currentCleanups; | ||
currentCleanups = cleanups; | ||
_context.prev = 7; | ||
promiseOrPossibleCleanup = callback(function (proxyObject) { | ||
proxiesToSubscribe.add(proxyObject); | ||
if (alive && !subscriptions.has(proxyObject)) { | ||
var unsubscribe = vanilla.subscribe(proxyObject, revalidate, options == null ? void 0 : options.sync); | ||
subscriptions.set(proxyObject, unsubscribe); | ||
} | ||
return proxyObject; | ||
}); | ||
if (!(promiseOrPossibleCleanup && promiseOrPossibleCleanup instanceof Promise)) { | ||
_context.next = 15; | ||
break; | ||
} | ||
_context.next = 12; | ||
return promiseOrPossibleCleanup; | ||
case 12: | ||
_context.t0 = _context.sent; | ||
_context.next = 16; | ||
break; | ||
case 15: | ||
_context.t0 = promiseOrPossibleCleanup; | ||
case 16: | ||
couldBeCleanup = _context.t0; | ||
if (couldBeCleanup) { | ||
if (alive) { | ||
cleanups.add(couldBeCleanup); | ||
} else { | ||
cleanup(); | ||
} | ||
} | ||
case 18: | ||
_context.prev = 18; | ||
currentCleanups = parent; | ||
return _context.finish(18); | ||
case 21: | ||
subscriptions.forEach(function (unsubscribe, proxyObject) { | ||
if (!proxiesToSubscribe.has(proxyObject)) { | ||
subscriptions.delete(proxyObject); | ||
unsubscribe(); | ||
} | ||
}); | ||
case 22: | ||
case "end": | ||
return _context.stop(); | ||
} | ||
}, _callee, null, [[7,, 18, 21]]); | ||
})); | ||
return function revalidate() { | ||
return _ref.apply(this, arguments); | ||
}; | ||
}(); | ||
if (currentCleanups) { | ||
currentCleanups.add(cleanup); | ||
} | ||
revalidate(); | ||
return cleanup; | ||
} | ||
var _excluded = ["enabled", "name"]; | ||
var DEVTOOLS = Symbol(); | ||
function devtools(proxyObject, options) { | ||
var _ref = options || {}, | ||
enabled = _ref.enabled, | ||
_ref$name = _ref.name, | ||
name = _ref$name === void 0 ? '' : _ref$name, | ||
rest = _objectWithoutPropertiesLoose(_ref, _excluded); | ||
var extension; | ||
try { | ||
extension = (enabled != null ? enabled : process.env.NODE_ENV !== 'production') && window.__REDUX_DEVTOOLS_EXTENSION__; | ||
} catch (_unused) {} | ||
if (!extension) { | ||
if (process.env.NODE_ENV !== 'production' && enabled) { | ||
console.warn('[Warning] Please install/enable Redux devtools extension'); | ||
} | ||
return; | ||
} | ||
var isTimeTraveling = false; | ||
var devtools = extension.connect(_extends({ | ||
name: name | ||
}, rest)); | ||
var unsub1 = vanilla.subscribe(proxyObject, function (ops) { | ||
var action = ops.filter(function (_ref2) { | ||
_ref2[0]; | ||
var path = _ref2[1]; | ||
return path[0] !== DEVTOOLS; | ||
}).map(function (_ref3) { | ||
var op = _ref3[0], | ||
path = _ref3[1]; | ||
return op + ":" + path.map(String).join('.'); | ||
}).join(', '); | ||
if (!action) { | ||
return; | ||
} | ||
if (isTimeTraveling) { | ||
isTimeTraveling = false; | ||
} else { | ||
var snapWithoutDevtools = Object.assign({}, vanilla.snapshot(proxyObject)); | ||
delete snapWithoutDevtools[DEVTOOLS]; | ||
devtools.send({ | ||
type: action, | ||
updatedAt: new Date().toLocaleString() | ||
}, snapWithoutDevtools); | ||
} | ||
}); | ||
var unsub2 = devtools.subscribe(function (message) { | ||
var _message$payload3, _message$payload4; | ||
if (message.type === 'ACTION' && message.payload) { | ||
try { | ||
Object.assign(proxyObject, JSON.parse(message.payload)); | ||
} catch (e) { | ||
console.error('please dispatch a serializable value that JSON.parse() and proxy() support\n', e); | ||
} | ||
} | ||
if (message.type === 'DISPATCH' && message.state) { | ||
var _message$payload, _message$payload2; | ||
if (((_message$payload = message.payload) == null ? void 0 : _message$payload.type) === 'JUMP_TO_ACTION' || ((_message$payload2 = message.payload) == null ? void 0 : _message$payload2.type) === 'JUMP_TO_STATE') { | ||
isTimeTraveling = true; | ||
var state = JSON.parse(message.state); | ||
Object.assign(proxyObject, state); | ||
} | ||
proxyObject[DEVTOOLS] = message; | ||
} else if (message.type === 'DISPATCH' && ((_message$payload3 = message.payload) == null ? void 0 : _message$payload3.type) === 'COMMIT') { | ||
devtools.init(vanilla.snapshot(proxyObject)); | ||
} else if (message.type === 'DISPATCH' && ((_message$payload4 = message.payload) == null ? void 0 : _message$payload4.type) === 'IMPORT_STATE') { | ||
var _message$payload$next, _message$payload$next2; | ||
var actions = (_message$payload$next = message.payload.nextLiftedState) == null ? void 0 : _message$payload$next.actionsById; | ||
var computedStates = ((_message$payload$next2 = message.payload.nextLiftedState) == null ? void 0 : _message$payload$next2.computedStates) || []; | ||
isTimeTraveling = true; | ||
computedStates.forEach(function (_ref4, index) { | ||
var state = _ref4.state; | ||
var action = actions[index] || 'No action found'; | ||
Object.assign(proxyObject, state); | ||
if (index === 0) { | ||
devtools.init(vanilla.snapshot(proxyObject)); | ||
} else { | ||
devtools.send(action, vanilla.snapshot(proxyObject)); | ||
} | ||
}); | ||
} | ||
}); | ||
devtools.init(vanilla.snapshot(proxyObject)); | ||
return function () { | ||
unsub1(); | ||
unsub2 == null || unsub2(); | ||
}; | ||
} | ||
var isObject = function isObject(x) { | ||
return typeof x === 'object' && x !== null; | ||
var __defProp = Object.defineProperty; | ||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
var __getOwnPropNames = Object.getOwnPropertyNames; | ||
var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
var __export = (target, all) => { | ||
for (var name in all) | ||
__defProp(target, name, { get: all[name], enumerable: true }); | ||
}; | ||
var defaultRefSet; | ||
var getDefaultRefSet = function getDefaultRefSet() { | ||
if (!defaultRefSet) { | ||
defaultRefSet = vanilla.unstable_buildProxyFunction()[2]; | ||
var __copyProps = (to, from, except, desc) => { | ||
if (from && typeof from === "object" || typeof from === "function") { | ||
for (let key of __getOwnPropNames(from)) | ||
if (!__hasOwnProp.call(to, key) && key !== except) | ||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
} | ||
return defaultRefSet; | ||
return to; | ||
}; | ||
var deepClone = function deepClone(obj, getRefSet) { | ||
if (getRefSet === void 0) { | ||
getRefSet = getDefaultRefSet; | ||
} | ||
if (!isObject(obj) || getRefSet().has(obj)) { | ||
return obj; | ||
} | ||
var baseObject = Array.isArray(obj) ? [] : Object.create(Object.getPrototypeOf(obj)); | ||
Reflect.ownKeys(obj).forEach(function (key) { | ||
baseObject[key] = deepClone(obj[key], getRefSet); | ||
}); | ||
return baseObject; | ||
}; | ||
function proxySet(initialValues) { | ||
var _proxy; | ||
var set = vanilla.proxy((_proxy = { | ||
data: Array.from(new Set(initialValues)), | ||
has: function has(value) { | ||
return this.data.indexOf(value) !== -1; | ||
}, | ||
add: function add(value) { | ||
var hasProxy = false; | ||
if (typeof value === 'object' && value !== null) { | ||
hasProxy = this.data.indexOf(vanilla.proxy(value)) !== -1; | ||
} | ||
if (this.data.indexOf(value) === -1 && !hasProxy) { | ||
this.data.push(value); | ||
} | ||
return this; | ||
}, | ||
delete: function _delete(value) { | ||
var index = this.data.indexOf(value); | ||
if (index === -1) { | ||
return false; | ||
} | ||
this.data.splice(index, 1); | ||
return true; | ||
}, | ||
clear: function clear() { | ||
this.data.splice(0); | ||
}, | ||
get size() { | ||
return this.data.length; | ||
}, | ||
forEach: function forEach(cb) { | ||
var _this = this; | ||
this.data.forEach(function (value) { | ||
cb(value, value, _this); | ||
}); | ||
} | ||
}, _defineAccessor("get", _proxy, Symbol.toStringTag, function () { | ||
return 'Set'; | ||
}), _proxy.toJSON = function toJSON() { | ||
return new Set(this.data); | ||
}, _proxy[Symbol.iterator] = function () { | ||
return this.data[Symbol.iterator](); | ||
}, _proxy.values = function values() { | ||
return this.data.values(); | ||
}, _proxy.keys = function keys() { | ||
return this.data.values(); | ||
}, _proxy.entries = function entries() { | ||
return new Set(this.data).entries(); | ||
}, _proxy)); | ||
Object.defineProperties(set, { | ||
data: { | ||
enumerable: false | ||
}, | ||
size: { | ||
enumerable: false | ||
}, | ||
toJSON: { | ||
enumerable: false | ||
} | ||
}); | ||
Object.seal(set); | ||
return set; | ||
} | ||
function proxyMap(entries) { | ||
var _proxy; | ||
var map = vanilla.proxy((_proxy = { | ||
data: Array.from(entries || []), | ||
has: function has(key) { | ||
return this.data.some(function (p) { | ||
return p[0] === key; | ||
}); | ||
}, | ||
set: function set(key, value) { | ||
var record = this.data.find(function (p) { | ||
return p[0] === key; | ||
}); | ||
if (record) { | ||
record[1] = value; | ||
} else { | ||
this.data.push([key, value]); | ||
} | ||
return this; | ||
}, | ||
get: function get(key) { | ||
var _this$data$find; | ||
return (_this$data$find = this.data.find(function (p) { | ||
return p[0] === key; | ||
})) == null ? void 0 : _this$data$find[1]; | ||
}, | ||
delete: function _delete(key) { | ||
var index = this.data.findIndex(function (p) { | ||
return p[0] === key; | ||
}); | ||
if (index === -1) { | ||
return false; | ||
} | ||
this.data.splice(index, 1); | ||
return true; | ||
}, | ||
clear: function clear() { | ||
this.data.splice(0); | ||
}, | ||
get size() { | ||
return this.data.length; | ||
}, | ||
toJSON: function toJSON() { | ||
return new Map(this.data); | ||
}, | ||
forEach: function forEach(cb) { | ||
var _this = this; | ||
this.data.forEach(function (p) { | ||
cb(p[1], p[0], _this); | ||
}); | ||
}, | ||
keys: function keys() { | ||
return this.data.map(function (p) { | ||
return p[0]; | ||
}).values(); | ||
}, | ||
values: function values() { | ||
return this.data.map(function (p) { | ||
return p[1]; | ||
}).values(); | ||
}, | ||
entries: function entries() { | ||
return new Map(this.data).entries(); | ||
} | ||
}, _defineAccessor("get", _proxy, Symbol.toStringTag, function () { | ||
return 'Map'; | ||
}), _proxy[Symbol.iterator] = function () { | ||
return this.entries(); | ||
}, _proxy)); | ||
Object.defineProperties(map, { | ||
data: { | ||
enumerable: false | ||
}, | ||
size: { | ||
enumerable: false | ||
}, | ||
toJSON: { | ||
enumerable: false | ||
} | ||
}); | ||
Object.seal(map); | ||
return map; | ||
} | ||
exports.deepClone = deepClone; | ||
exports.devtools = devtools; | ||
exports.proxyMap = proxyMap; | ||
exports.proxySet = proxySet; | ||
exports.subscribeKey = subscribeKey; | ||
exports.watch = watch; | ||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
var utils_exports = {}; | ||
__export(utils_exports, { | ||
deepClone: () => import_deepClone.deepClone, | ||
devtools: () => import_devtools.devtools, | ||
proxyMap: () => import_proxyMap.proxyMap, | ||
proxySet: () => import_proxySet.proxySet, | ||
subscribeKey: () => import_subscribeKey.subscribeKey, | ||
watch: () => import_watch.watch | ||
}); | ||
module.exports = __toCommonJS(utils_exports); | ||
var import_subscribeKey = require("./utils/subscribeKey.ts"); | ||
var import_watch = require("./utils/watch.ts"); | ||
var import_devtools = require("./utils/devtools.ts"); | ||
var import_deepClone = require("./utils/deepClone.ts"); | ||
var import_proxySet = require("./utils/proxySet.ts"); | ||
var import_proxyMap = require("./utils/proxyMap.ts"); |
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
5
70382
1339