2025-06-21 23:30:33 +03:00

317 lines
11 KiB
JavaScript

'use strict';
var proxyCompare = require('proxy-compare');
var isObject = function isObject(x) {
return typeof x === 'object' && x !== null;
};
var proxyStateMap = new WeakMap();
var refSet = new WeakSet();
var buildProxyFunction = function buildProxyFunction(objectIs, newProxy, canProxy, defaultHandlePromise, snapCache, createSnapshot, proxyCache, versionHolder, _proxyFunction) {
if (objectIs === void 0) {
objectIs = Object.is;
}
if (newProxy === void 0) {
newProxy = function newProxy(target, handler) {
return new Proxy(target, handler);
};
}
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);
};
}
if (defaultHandlePromise === void 0) {
defaultHandlePromise = function defaultHandlePromise(promise) {
switch (promise.status) {
case 'fulfilled':
return promise.value;
case 'rejected':
throw promise.reason;
default:
throw promise;
}
};
}
if (snapCache === void 0) {
snapCache = new WeakMap();
}
if (createSnapshot === void 0) {
createSnapshot = function (_createSnapshot) {
function createSnapshot(_x, _x2, _x3) {
return _createSnapshot.apply(this, arguments);
}
createSnapshot.toString = function () {
return _createSnapshot.toString();
};
return createSnapshot;
}(function (target, version, handlePromise) {
if (handlePromise === void 0) {
handlePromise = defaultHandlePromise;
}
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;
}
var value = Reflect.get(target, key);
var desc = {
value: value,
enumerable: true,
configurable: true
};
if (refSet.has(value)) {
proxyCompare.markToTrack(value, false);
} else if (value instanceof Promise) {
delete desc.value;
desc.get = function () {
return handlePromise(value);
};
} else if (proxyStateMap.has(value)) {
var _ref = proxyStateMap.get(value),
_target = _ref[0],
_ensureVersion = _ref[1];
desc.value = createSnapshot(_target, _ensureVersion(), handlePromise);
}
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(initialObject) {
if (!isObject(initialObject)) {
throw new Error('object required');
}
var found = proxyCache.get(initialObject);
if (found) {
return found;
}
var version = versionHolder[0];
var listeners = new Set();
var notifyUpdate = function notifyUpdate(op, nextVersion) {
if (nextVersion === void 0) {
nextVersion = ++versionHolder[0];
}
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 (_ref2) {
var propProxyState = _ref2[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, 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 {
propProxyStates.set(prop, [propProxyState]);
}
};
var removePropListener = function removePropListener(prop) {
var entry = propProxyStates.get(prop);
if (entry) {
var _entry$;
propProxyStates.delete(prop);
(_entry$ = entry[1]) == null ? void 0 : _entry$.call(entry);
}
};
var addListener = function addListener(listener) {
listeners.add(listener);
if (listeners.size === 1) {
propProxyStates.forEach(function (_ref3, prop) {
var propProxyState = _ref3[0],
prevRemove = _ref3[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 (_ref4, prop) {
var propProxyState = _ref4[0],
remove = _ref4[1];
if (remove) {
remove();
propProxyStates.set(prop, [propProxyState]);
}
});
}
};
return removeListener;
};
var baseObject = Array.isArray(initialObject) ? [] : Object.create(Object.getPrototypeOf(initialObject));
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 = 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);
}
var childProxyState = !refSet.has(nextValue) && proxyStateMap.get(nextValue);
if (childProxyState) {
addPropListener(prop, childProxyState);
}
}
Reflect.set(target, prop, nextValue, receiver);
notifyUpdate(['set', [prop], value, prevValue]);
return true;
}
};
var proxyObject = newProxy(baseObject, handler);
proxyCache.set(initialObject, proxyObject);
var proxyState = [baseObject, ensureVersion, createSnapshot, addListener];
proxyStateMap.set(proxyObject, proxyState);
Reflect.ownKeys(initialObject).forEach(function (key) {
var desc = Object.getOwnPropertyDescriptor(initialObject, key);
if ('value' in desc) {
proxyObject[key] = initialObject[key];
delete desc.value;
delete desc.writable;
}
Object.defineProperty(baseObject, key, desc);
});
return proxyObject;
};
}
return [_proxyFunction, proxyStateMap, refSet, objectIs, newProxy, canProxy, defaultHandlePromise, snapCache, createSnapshot, proxyCache, versionHolder];
};
var _buildProxyFunction = buildProxyFunction(),
defaultProxyFunction = _buildProxyFunction[0];
function proxy(initialObject) {
if (initialObject === void 0) {
initialObject = {};
}
return defaultProxyFunction(initialObject);
}
function getVersion(proxyObject) {
var 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');
}
var promise;
var ops = [];
var addListener = proxyState[3];
var isListenerActive = false;
var listener = function listener(op) {
ops.push(op);
if (notifyInSync) {
callback(ops.splice(0));
return;
}
if (!promise) {
promise = Promise.resolve().then(function () {
promise = undefined;
if (isListenerActive) {
callback(ops.splice(0));
}
});
}
};
var removeListener = addListener(listener);
isListenerActive = true;
return function () {
isListenerActive = false;
removeListener();
};
}
function snapshot(proxyObject, handlePromise) {
var proxyState = proxyStateMap.get(proxyObject);
if (process.env.NODE_ENV !== 'production' && !proxyState) {
console.warn('Please use proxy object');
}
var _ref5 = proxyState,
target = _ref5[0],
ensureVersion = _ref5[1],
createSnapshot = _ref5[2];
return createSnapshot(target, ensureVersion(), handlePromise);
}
function ref(obj) {
refSet.add(obj);
return obj;
}
var unstable_buildProxyFunction = buildProxyFunction;
exports.getVersion = getVersion;
exports.proxy = proxy;
exports.ref = ref;
exports.snapshot = snapshot;
exports.subscribe = subscribe;
exports.unstable_buildProxyFunction = unstable_buildProxyFunction;