inital upload
This commit is contained in:
jackbeeby
@@ -0,0 +1,58 @@
|
||||
# React + TypeScript + Vite
|
||||
|
||||
This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
|
||||
|
||||
Currently, two official plugins are available:
|
||||
|
||||
- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) for Fast Refresh
|
||||
- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
|
||||
|
||||
## Expanding the ESLint configuration
|
||||
|
||||
If you are developing a production application, we recommend updating the configuration to enable type-aware lint rules:
|
||||
|
||||
```js
|
||||
export default tseslint.config({
|
||||
extends: [
|
||||
// Remove ...tseslint.configs.recommended and replace with this
|
||||
...tseslint.configs.recommendedTypeChecked,
|
||||
// Alternatively, use this for stricter rules
|
||||
...tseslint.configs.strictTypeChecked,
|
||||
// Optionally, add this for stylistic rules
|
||||
...tseslint.configs.stylisticTypeChecked,
|
||||
],
|
||||
languageOptions: {
|
||||
// other options...
|
||||
parserOptions: {
|
||||
project: ['./tsconfig.node.json', './tsconfig.app.json'],
|
||||
tsconfigRootDir: import.meta.dirname,
|
||||
},
|
||||
},
|
||||
})
|
||||
```
|
||||
|
||||
You can also install [eslint-plugin-react-x](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x) and [eslint-plugin-react-dom](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-dom) for React-specific lint rules:
|
||||
|
||||
```js
|
||||
// eslint.config.js
|
||||
import reactX from 'eslint-plugin-react-x'
|
||||
import reactDom from 'eslint-plugin-react-dom'
|
||||
|
||||
export default tseslint.config({
|
||||
plugins: {
|
||||
// Add the react-x and react-dom plugins
|
||||
'react-x': reactX,
|
||||
'react-dom': reactDom,
|
||||
},
|
||||
rules: {
|
||||
// other rules...
|
||||
// Enable its recommended typescript rules
|
||||
...reactX.configs['recommended-typescript'].rules,
|
||||
...reactDom.configs.recommended.rules,
|
||||
},
|
||||
})
|
||||
```
|
||||
|
||||
|
||||
//run the code
|
||||
npm run dev
|
||||
@@ -0,0 +1,28 @@
|
||||
import js from '@eslint/js'
|
||||
import globals from 'globals'
|
||||
import reactHooks from 'eslint-plugin-react-hooks'
|
||||
import reactRefresh from 'eslint-plugin-react-refresh'
|
||||
import tseslint from 'typescript-eslint'
|
||||
|
||||
export default tseslint.config(
|
||||
{ ignores: ['dist'] },
|
||||
{
|
||||
extends: [js.configs.recommended, ...tseslint.configs.recommended],
|
||||
files: ['**/*.{ts,tsx}'],
|
||||
languageOptions: {
|
||||
ecmaVersion: 2020,
|
||||
globals: globals.browser,
|
||||
},
|
||||
plugins: {
|
||||
'react-hooks': reactHooks,
|
||||
'react-refresh': reactRefresh,
|
||||
},
|
||||
rules: {
|
||||
...reactHooks.configs.recommended.rules,
|
||||
'react-refresh/only-export-components': [
|
||||
'warn',
|
||||
{ allowConstantExport: true },
|
||||
],
|
||||
},
|
||||
},
|
||||
)
|
||||
+13
@@ -0,0 +1,13 @@
|
||||
<!doctype html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="UTF-8" />
|
||||
<link rel="icon" type="image/svg+xml" href="/vite.svg" />
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
||||
<title>Photography Form</title>
|
||||
</head>
|
||||
<body>
|
||||
<div id="root"></div>
|
||||
<script type="module" src="/src/main.tsx"></script>
|
||||
</body>
|
||||
</html>
|
||||
+1
@@ -0,0 +1 @@
|
||||
../acorn/bin/acorn
|
||||
+1
@@ -0,0 +1 @@
|
||||
../autoprefixer/bin/autoprefixer
|
||||
+1
@@ -0,0 +1 @@
|
||||
../browserslist/cli.js
|
||||
+1
@@ -0,0 +1 @@
|
||||
../esbuild/bin/esbuild
|
||||
+1
@@ -0,0 +1 @@
|
||||
../eslint/bin/eslint.js
|
||||
+1
@@ -0,0 +1 @@
|
||||
../jiti/lib/jiti-cli.mjs
|
||||
+1
@@ -0,0 +1 @@
|
||||
../js-yaml/bin/js-yaml.js
|
||||
+1
@@ -0,0 +1 @@
|
||||
../jsesc/bin/jsesc
|
||||
+1
@@ -0,0 +1 @@
|
||||
../json5/lib/cli.js
|
||||
+1
@@ -0,0 +1 @@
|
||||
../loose-envify/cli.js
|
||||
+1
@@ -0,0 +1 @@
|
||||
../mkdirp/dist/cjs/src/bin.js
|
||||
+1
@@ -0,0 +1 @@
|
||||
../nanoid/bin/nanoid.cjs
|
||||
+1
@@ -0,0 +1 @@
|
||||
../which/bin/node-which
|
||||
+1
@@ -0,0 +1 @@
|
||||
../@babel/parser/bin/babel-parser.js
|
||||
+1
@@ -0,0 +1 @@
|
||||
../rollup/dist/bin/rollup
|
||||
+1
@@ -0,0 +1 @@
|
||||
../semver/bin/semver.js
|
||||
+1
@@ -0,0 +1 @@
|
||||
../typescript/bin/tsc
|
||||
+1
@@ -0,0 +1 @@
|
||||
../typescript/bin/tsserver
|
||||
+1
@@ -0,0 +1 @@
|
||||
../update-browserslist-db/cli.js
|
||||
+1
@@ -0,0 +1 @@
|
||||
../vite/bin/vite.js
|
||||
+4123
File diff suppressed because it is too large
Load Diff
+19432
File diff suppressed because it is too large
Load Diff
+7
File diff suppressed because one or more lines are too long
+52
@@ -0,0 +1,52 @@
|
||||
{
|
||||
"hash": "84680814",
|
||||
"configHash": "a807acb7",
|
||||
"lockfileHash": "eeecb14e",
|
||||
"browserHash": "244f1789",
|
||||
"optimized": {
|
||||
"react": {
|
||||
"src": "../../react/index.js",
|
||||
"file": "react.js",
|
||||
"fileHash": "41682dca",
|
||||
"needsInterop": true
|
||||
},
|
||||
"react-dom": {
|
||||
"src": "../../react-dom/index.js",
|
||||
"file": "react-dom.js",
|
||||
"fileHash": "65560d0c",
|
||||
"needsInterop": true
|
||||
},
|
||||
"react/jsx-dev-runtime": {
|
||||
"src": "../../react/jsx-dev-runtime.js",
|
||||
"file": "react_jsx-dev-runtime.js",
|
||||
"fileHash": "40ce395a",
|
||||
"needsInterop": true
|
||||
},
|
||||
"react/jsx-runtime": {
|
||||
"src": "../../react/jsx-runtime.js",
|
||||
"file": "react_jsx-runtime.js",
|
||||
"fileHash": "4b70b3af",
|
||||
"needsInterop": true
|
||||
},
|
||||
"@apollo/client": {
|
||||
"src": "../../@apollo/client/index.js",
|
||||
"file": "@apollo_client.js",
|
||||
"fileHash": "7618a452",
|
||||
"needsInterop": false
|
||||
},
|
||||
"react-dom/client": {
|
||||
"src": "../../react-dom/client.js",
|
||||
"file": "react-dom_client.js",
|
||||
"fileHash": "59ee2ed8",
|
||||
"needsInterop": true
|
||||
}
|
||||
},
|
||||
"chunks": {
|
||||
"chunk-T37TWCKW": {
|
||||
"file": "chunk-T37TWCKW.js"
|
||||
},
|
||||
"chunk-QH6HOCAD": {
|
||||
"file": "chunk-QH6HOCAD.js"
|
||||
}
|
||||
}
|
||||
}
|
||||
+996
@@ -0,0 +1,996 @@
|
||||
var __create = Object.create;
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __getProtoOf = Object.getPrototypeOf;
|
||||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||||
var __commonJS = (cb, mod) => function __require() {
|
||||
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
||||
};
|
||||
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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
||||
// If the importer is in node compatibility mode or this is not an ESM
|
||||
// file that has been converted to a CommonJS file using a Babel-
|
||||
// compatible transform (i.e. "__esModule" has not been set), then set
|
||||
// "default" to the CommonJS "module.exports" for node compatibility.
|
||||
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
||||
mod
|
||||
));
|
||||
|
||||
// node_modules/react/cjs/react.development.js
|
||||
var require_react_development = __commonJS({
|
||||
"node_modules/react/cjs/react.development.js"(exports, module) {
|
||||
"use strict";
|
||||
(function() {
|
||||
function defineDeprecationWarning(methodName, info) {
|
||||
Object.defineProperty(Component.prototype, methodName, {
|
||||
get: function() {
|
||||
console.warn(
|
||||
"%s(...) is deprecated in plain JavaScript React classes. %s",
|
||||
info[0],
|
||||
info[1]
|
||||
);
|
||||
}
|
||||
});
|
||||
}
|
||||
function getIteratorFn(maybeIterable) {
|
||||
if (null === maybeIterable || "object" !== typeof maybeIterable)
|
||||
return null;
|
||||
maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
|
||||
return "function" === typeof maybeIterable ? maybeIterable : null;
|
||||
}
|
||||
function warnNoop(publicInstance, callerName) {
|
||||
publicInstance = (publicInstance = publicInstance.constructor) && (publicInstance.displayName || publicInstance.name) || "ReactClass";
|
||||
var warningKey = publicInstance + "." + callerName;
|
||||
didWarnStateUpdateForUnmountedComponent[warningKey] || (console.error(
|
||||
"Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.",
|
||||
callerName,
|
||||
publicInstance
|
||||
), didWarnStateUpdateForUnmountedComponent[warningKey] = true);
|
||||
}
|
||||
function Component(props, context, updater) {
|
||||
this.props = props;
|
||||
this.context = context;
|
||||
this.refs = emptyObject;
|
||||
this.updater = updater || ReactNoopUpdateQueue;
|
||||
}
|
||||
function ComponentDummy() {
|
||||
}
|
||||
function PureComponent(props, context, updater) {
|
||||
this.props = props;
|
||||
this.context = context;
|
||||
this.refs = emptyObject;
|
||||
this.updater = updater || ReactNoopUpdateQueue;
|
||||
}
|
||||
function testStringCoercion(value) {
|
||||
return "" + value;
|
||||
}
|
||||
function checkKeyStringCoercion(value) {
|
||||
try {
|
||||
testStringCoercion(value);
|
||||
var JSCompiler_inline_result = false;
|
||||
} catch (e) {
|
||||
JSCompiler_inline_result = true;
|
||||
}
|
||||
if (JSCompiler_inline_result) {
|
||||
JSCompiler_inline_result = console;
|
||||
var JSCompiler_temp_const = JSCompiler_inline_result.error;
|
||||
var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
|
||||
JSCompiler_temp_const.call(
|
||||
JSCompiler_inline_result,
|
||||
"The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
|
||||
JSCompiler_inline_result$jscomp$0
|
||||
);
|
||||
return testStringCoercion(value);
|
||||
}
|
||||
}
|
||||
function getComponentNameFromType(type) {
|
||||
if (null == type) return null;
|
||||
if ("function" === typeof type)
|
||||
return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
|
||||
if ("string" === typeof type) return type;
|
||||
switch (type) {
|
||||
case REACT_FRAGMENT_TYPE:
|
||||
return "Fragment";
|
||||
case REACT_PROFILER_TYPE:
|
||||
return "Profiler";
|
||||
case REACT_STRICT_MODE_TYPE:
|
||||
return "StrictMode";
|
||||
case REACT_SUSPENSE_TYPE:
|
||||
return "Suspense";
|
||||
case REACT_SUSPENSE_LIST_TYPE:
|
||||
return "SuspenseList";
|
||||
case REACT_ACTIVITY_TYPE:
|
||||
return "Activity";
|
||||
}
|
||||
if ("object" === typeof type)
|
||||
switch ("number" === typeof type.tag && console.error(
|
||||
"Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
|
||||
), type.$$typeof) {
|
||||
case REACT_PORTAL_TYPE:
|
||||
return "Portal";
|
||||
case REACT_CONTEXT_TYPE:
|
||||
return (type.displayName || "Context") + ".Provider";
|
||||
case REACT_CONSUMER_TYPE:
|
||||
return (type._context.displayName || "Context") + ".Consumer";
|
||||
case REACT_FORWARD_REF_TYPE:
|
||||
var innerType = type.render;
|
||||
type = type.displayName;
|
||||
type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
|
||||
return type;
|
||||
case REACT_MEMO_TYPE:
|
||||
return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
|
||||
case REACT_LAZY_TYPE:
|
||||
innerType = type._payload;
|
||||
type = type._init;
|
||||
try {
|
||||
return getComponentNameFromType(type(innerType));
|
||||
} catch (x) {
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
function getTaskName(type) {
|
||||
if (type === REACT_FRAGMENT_TYPE) return "<>";
|
||||
if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE)
|
||||
return "<...>";
|
||||
try {
|
||||
var name = getComponentNameFromType(type);
|
||||
return name ? "<" + name + ">" : "<...>";
|
||||
} catch (x) {
|
||||
return "<...>";
|
||||
}
|
||||
}
|
||||
function getOwner() {
|
||||
var dispatcher = ReactSharedInternals.A;
|
||||
return null === dispatcher ? null : dispatcher.getOwner();
|
||||
}
|
||||
function UnknownOwner() {
|
||||
return Error("react-stack-top-frame");
|
||||
}
|
||||
function hasValidKey(config) {
|
||||
if (hasOwnProperty.call(config, "key")) {
|
||||
var getter = Object.getOwnPropertyDescriptor(config, "key").get;
|
||||
if (getter && getter.isReactWarning) return false;
|
||||
}
|
||||
return void 0 !== config.key;
|
||||
}
|
||||
function defineKeyPropWarningGetter(props, displayName) {
|
||||
function warnAboutAccessingKey() {
|
||||
specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error(
|
||||
"%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
|
||||
displayName
|
||||
));
|
||||
}
|
||||
warnAboutAccessingKey.isReactWarning = true;
|
||||
Object.defineProperty(props, "key", {
|
||||
get: warnAboutAccessingKey,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
function elementRefGetterWithDeprecationWarning() {
|
||||
var componentName = getComponentNameFromType(this.type);
|
||||
didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error(
|
||||
"Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
|
||||
));
|
||||
componentName = this.props.ref;
|
||||
return void 0 !== componentName ? componentName : null;
|
||||
}
|
||||
function ReactElement(type, key, self, source, owner, props, debugStack, debugTask) {
|
||||
self = props.ref;
|
||||
type = {
|
||||
$$typeof: REACT_ELEMENT_TYPE,
|
||||
type,
|
||||
key,
|
||||
props,
|
||||
_owner: owner
|
||||
};
|
||||
null !== (void 0 !== self ? self : null) ? Object.defineProperty(type, "ref", {
|
||||
enumerable: false,
|
||||
get: elementRefGetterWithDeprecationWarning
|
||||
}) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
|
||||
type._store = {};
|
||||
Object.defineProperty(type._store, "validated", {
|
||||
configurable: false,
|
||||
enumerable: false,
|
||||
writable: true,
|
||||
value: 0
|
||||
});
|
||||
Object.defineProperty(type, "_debugInfo", {
|
||||
configurable: false,
|
||||
enumerable: false,
|
||||
writable: true,
|
||||
value: null
|
||||
});
|
||||
Object.defineProperty(type, "_debugStack", {
|
||||
configurable: false,
|
||||
enumerable: false,
|
||||
writable: true,
|
||||
value: debugStack
|
||||
});
|
||||
Object.defineProperty(type, "_debugTask", {
|
||||
configurable: false,
|
||||
enumerable: false,
|
||||
writable: true,
|
||||
value: debugTask
|
||||
});
|
||||
Object.freeze && (Object.freeze(type.props), Object.freeze(type));
|
||||
return type;
|
||||
}
|
||||
function cloneAndReplaceKey(oldElement, newKey) {
|
||||
newKey = ReactElement(
|
||||
oldElement.type,
|
||||
newKey,
|
||||
void 0,
|
||||
void 0,
|
||||
oldElement._owner,
|
||||
oldElement.props,
|
||||
oldElement._debugStack,
|
||||
oldElement._debugTask
|
||||
);
|
||||
oldElement._store && (newKey._store.validated = oldElement._store.validated);
|
||||
return newKey;
|
||||
}
|
||||
function isValidElement(object) {
|
||||
return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
|
||||
}
|
||||
function escape(key) {
|
||||
var escaperLookup = { "=": "=0", ":": "=2" };
|
||||
return "$" + key.replace(/[=:]/g, function(match) {
|
||||
return escaperLookup[match];
|
||||
});
|
||||
}
|
||||
function getElementKey(element, index) {
|
||||
return "object" === typeof element && null !== element && null != element.key ? (checkKeyStringCoercion(element.key), escape("" + element.key)) : index.toString(36);
|
||||
}
|
||||
function noop$1() {
|
||||
}
|
||||
function resolveThenable(thenable) {
|
||||
switch (thenable.status) {
|
||||
case "fulfilled":
|
||||
return thenable.value;
|
||||
case "rejected":
|
||||
throw thenable.reason;
|
||||
default:
|
||||
switch ("string" === typeof thenable.status ? thenable.then(noop$1, noop$1) : (thenable.status = "pending", thenable.then(
|
||||
function(fulfilledValue) {
|
||||
"pending" === thenable.status && (thenable.status = "fulfilled", thenable.value = fulfilledValue);
|
||||
},
|
||||
function(error) {
|
||||
"pending" === thenable.status && (thenable.status = "rejected", thenable.reason = error);
|
||||
}
|
||||
)), thenable.status) {
|
||||
case "fulfilled":
|
||||
return thenable.value;
|
||||
case "rejected":
|
||||
throw thenable.reason;
|
||||
}
|
||||
}
|
||||
throw thenable;
|
||||
}
|
||||
function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
|
||||
var type = typeof children;
|
||||
if ("undefined" === type || "boolean" === type) children = null;
|
||||
var invokeCallback = false;
|
||||
if (null === children) invokeCallback = true;
|
||||
else
|
||||
switch (type) {
|
||||
case "bigint":
|
||||
case "string":
|
||||
case "number":
|
||||
invokeCallback = true;
|
||||
break;
|
||||
case "object":
|
||||
switch (children.$$typeof) {
|
||||
case REACT_ELEMENT_TYPE:
|
||||
case REACT_PORTAL_TYPE:
|
||||
invokeCallback = true;
|
||||
break;
|
||||
case REACT_LAZY_TYPE:
|
||||
return invokeCallback = children._init, mapIntoArray(
|
||||
invokeCallback(children._payload),
|
||||
array,
|
||||
escapedPrefix,
|
||||
nameSoFar,
|
||||
callback
|
||||
);
|
||||
}
|
||||
}
|
||||
if (invokeCallback) {
|
||||
invokeCallback = children;
|
||||
callback = callback(invokeCallback);
|
||||
var childKey = "" === nameSoFar ? "." + getElementKey(invokeCallback, 0) : nameSoFar;
|
||||
isArrayImpl(callback) ? (escapedPrefix = "", null != childKey && (escapedPrefix = childKey.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array, escapedPrefix, "", function(c) {
|
||||
return c;
|
||||
})) : null != callback && (isValidElement(callback) && (null != callback.key && (invokeCallback && invokeCallback.key === callback.key || checkKeyStringCoercion(callback.key)), escapedPrefix = cloneAndReplaceKey(
|
||||
callback,
|
||||
escapedPrefix + (null == callback.key || invokeCallback && invokeCallback.key === callback.key ? "" : ("" + callback.key).replace(
|
||||
userProvidedKeyEscapeRegex,
|
||||
"$&/"
|
||||
) + "/") + childKey
|
||||
), "" !== nameSoFar && null != invokeCallback && isValidElement(invokeCallback) && null == invokeCallback.key && invokeCallback._store && !invokeCallback._store.validated && (escapedPrefix._store.validated = 2), callback = escapedPrefix), array.push(callback));
|
||||
return 1;
|
||||
}
|
||||
invokeCallback = 0;
|
||||
childKey = "" === nameSoFar ? "." : nameSoFar + ":";
|
||||
if (isArrayImpl(children))
|
||||
for (var i = 0; i < children.length; i++)
|
||||
nameSoFar = children[i], type = childKey + getElementKey(nameSoFar, i), invokeCallback += mapIntoArray(
|
||||
nameSoFar,
|
||||
array,
|
||||
escapedPrefix,
|
||||
type,
|
||||
callback
|
||||
);
|
||||
else if (i = getIteratorFn(children), "function" === typeof i)
|
||||
for (i === children.entries && (didWarnAboutMaps || console.warn(
|
||||
"Using Maps as children is not supported. Use an array of keyed ReactElements instead."
|
||||
), didWarnAboutMaps = true), children = i.call(children), i = 0; !(nameSoFar = children.next()).done; )
|
||||
nameSoFar = nameSoFar.value, type = childKey + getElementKey(nameSoFar, i++), invokeCallback += mapIntoArray(
|
||||
nameSoFar,
|
||||
array,
|
||||
escapedPrefix,
|
||||
type,
|
||||
callback
|
||||
);
|
||||
else if ("object" === type) {
|
||||
if ("function" === typeof children.then)
|
||||
return mapIntoArray(
|
||||
resolveThenable(children),
|
||||
array,
|
||||
escapedPrefix,
|
||||
nameSoFar,
|
||||
callback
|
||||
);
|
||||
array = String(children);
|
||||
throw Error(
|
||||
"Objects are not valid as a React child (found: " + ("[object Object]" === array ? "object with keys {" + Object.keys(children).join(", ") + "}" : array) + "). If you meant to render a collection of children, use an array instead."
|
||||
);
|
||||
}
|
||||
return invokeCallback;
|
||||
}
|
||||
function mapChildren(children, func, context) {
|
||||
if (null == children) return children;
|
||||
var result = [], count = 0;
|
||||
mapIntoArray(children, result, "", "", function(child) {
|
||||
return func.call(context, child, count++);
|
||||
});
|
||||
return result;
|
||||
}
|
||||
function lazyInitializer(payload) {
|
||||
if (-1 === payload._status) {
|
||||
var ctor = payload._result;
|
||||
ctor = ctor();
|
||||
ctor.then(
|
||||
function(moduleObject) {
|
||||
if (0 === payload._status || -1 === payload._status)
|
||||
payload._status = 1, payload._result = moduleObject;
|
||||
},
|
||||
function(error) {
|
||||
if (0 === payload._status || -1 === payload._status)
|
||||
payload._status = 2, payload._result = error;
|
||||
}
|
||||
);
|
||||
-1 === payload._status && (payload._status = 0, payload._result = ctor);
|
||||
}
|
||||
if (1 === payload._status)
|
||||
return ctor = payload._result, void 0 === ctor && console.error(
|
||||
"lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n const MyComponent = lazy(() => import('./MyComponent'))\n\nDid you accidentally put curly braces around the import?",
|
||||
ctor
|
||||
), "default" in ctor || console.error(
|
||||
"lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n const MyComponent = lazy(() => import('./MyComponent'))",
|
||||
ctor
|
||||
), ctor.default;
|
||||
throw payload._result;
|
||||
}
|
||||
function resolveDispatcher() {
|
||||
var dispatcher = ReactSharedInternals.H;
|
||||
null === dispatcher && console.error(
|
||||
"Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem."
|
||||
);
|
||||
return dispatcher;
|
||||
}
|
||||
function noop() {
|
||||
}
|
||||
function enqueueTask(task) {
|
||||
if (null === enqueueTaskImpl)
|
||||
try {
|
||||
var requireString = ("require" + Math.random()).slice(0, 7);
|
||||
enqueueTaskImpl = (module && module[requireString]).call(
|
||||
module,
|
||||
"timers"
|
||||
).setImmediate;
|
||||
} catch (_err) {
|
||||
enqueueTaskImpl = function(callback) {
|
||||
false === didWarnAboutMessageChannel && (didWarnAboutMessageChannel = true, "undefined" === typeof MessageChannel && console.error(
|
||||
"This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."
|
||||
));
|
||||
var channel = new MessageChannel();
|
||||
channel.port1.onmessage = callback;
|
||||
channel.port2.postMessage(void 0);
|
||||
};
|
||||
}
|
||||
return enqueueTaskImpl(task);
|
||||
}
|
||||
function aggregateErrors(errors) {
|
||||
return 1 < errors.length && "function" === typeof AggregateError ? new AggregateError(errors) : errors[0];
|
||||
}
|
||||
function popActScope(prevActQueue, prevActScopeDepth) {
|
||||
prevActScopeDepth !== actScopeDepth - 1 && console.error(
|
||||
"You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. "
|
||||
);
|
||||
actScopeDepth = prevActScopeDepth;
|
||||
}
|
||||
function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
|
||||
var queue = ReactSharedInternals.actQueue;
|
||||
if (null !== queue)
|
||||
if (0 !== queue.length)
|
||||
try {
|
||||
flushActQueue(queue);
|
||||
enqueueTask(function() {
|
||||
return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
|
||||
});
|
||||
return;
|
||||
} catch (error) {
|
||||
ReactSharedInternals.thrownErrors.push(error);
|
||||
}
|
||||
else ReactSharedInternals.actQueue = null;
|
||||
0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve(returnValue);
|
||||
}
|
||||
function flushActQueue(queue) {
|
||||
if (!isFlushing) {
|
||||
isFlushing = true;
|
||||
var i = 0;
|
||||
try {
|
||||
for (; i < queue.length; i++) {
|
||||
var callback = queue[i];
|
||||
do {
|
||||
ReactSharedInternals.didUsePromise = false;
|
||||
var continuation = callback(false);
|
||||
if (null !== continuation) {
|
||||
if (ReactSharedInternals.didUsePromise) {
|
||||
queue[i] = callback;
|
||||
queue.splice(0, i);
|
||||
return;
|
||||
}
|
||||
callback = continuation;
|
||||
} else break;
|
||||
} while (1);
|
||||
}
|
||||
queue.length = 0;
|
||||
} catch (error) {
|
||||
queue.splice(0, i + 1), ReactSharedInternals.thrownErrors.push(error);
|
||||
} finally {
|
||||
isFlushing = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
|
||||
var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler");
|
||||
Symbol.for("react.provider");
|
||||
var REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator, didWarnStateUpdateForUnmountedComponent = {}, ReactNoopUpdateQueue = {
|
||||
isMounted: function() {
|
||||
return false;
|
||||
},
|
||||
enqueueForceUpdate: function(publicInstance) {
|
||||
warnNoop(publicInstance, "forceUpdate");
|
||||
},
|
||||
enqueueReplaceState: function(publicInstance) {
|
||||
warnNoop(publicInstance, "replaceState");
|
||||
},
|
||||
enqueueSetState: function(publicInstance) {
|
||||
warnNoop(publicInstance, "setState");
|
||||
}
|
||||
}, assign = Object.assign, emptyObject = {};
|
||||
Object.freeze(emptyObject);
|
||||
Component.prototype.isReactComponent = {};
|
||||
Component.prototype.setState = function(partialState, callback) {
|
||||
if ("object" !== typeof partialState && "function" !== typeof partialState && null != partialState)
|
||||
throw Error(
|
||||
"takes an object of state variables to update or a function which returns an object of state variables."
|
||||
);
|
||||
this.updater.enqueueSetState(this, partialState, callback, "setState");
|
||||
};
|
||||
Component.prototype.forceUpdate = function(callback) {
|
||||
this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
|
||||
};
|
||||
var deprecatedAPIs = {
|
||||
isMounted: [
|
||||
"isMounted",
|
||||
"Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
|
||||
],
|
||||
replaceState: [
|
||||
"replaceState",
|
||||
"Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
|
||||
]
|
||||
}, fnName;
|
||||
for (fnName in deprecatedAPIs)
|
||||
deprecatedAPIs.hasOwnProperty(fnName) && defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
|
||||
ComponentDummy.prototype = Component.prototype;
|
||||
deprecatedAPIs = PureComponent.prototype = new ComponentDummy();
|
||||
deprecatedAPIs.constructor = PureComponent;
|
||||
assign(deprecatedAPIs, Component.prototype);
|
||||
deprecatedAPIs.isPureReactComponent = true;
|
||||
var isArrayImpl = Array.isArray, REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = {
|
||||
H: null,
|
||||
A: null,
|
||||
T: null,
|
||||
S: null,
|
||||
V: null,
|
||||
actQueue: null,
|
||||
isBatchingLegacy: false,
|
||||
didScheduleLegacyUpdate: false,
|
||||
didUsePromise: false,
|
||||
thrownErrors: [],
|
||||
getCurrentStack: null,
|
||||
recentlyCreatedOwnerStacks: 0
|
||||
}, hasOwnProperty = Object.prototype.hasOwnProperty, createTask = console.createTask ? console.createTask : function() {
|
||||
return null;
|
||||
};
|
||||
deprecatedAPIs = {
|
||||
"react-stack-bottom-frame": function(callStackForError) {
|
||||
return callStackForError();
|
||||
}
|
||||
};
|
||||
var specialPropKeyWarningShown, didWarnAboutOldJSXRuntime;
|
||||
var didWarnAboutElementRef = {};
|
||||
var unknownOwnerDebugStack = deprecatedAPIs["react-stack-bottom-frame"].bind(deprecatedAPIs, UnknownOwner)();
|
||||
var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
|
||||
var didWarnAboutMaps = false, userProvidedKeyEscapeRegex = /\/+/g, reportGlobalError = "function" === typeof reportError ? reportError : function(error) {
|
||||
if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
|
||||
var event = new window.ErrorEvent("error", {
|
||||
bubbles: true,
|
||||
cancelable: true,
|
||||
message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error),
|
||||
error
|
||||
});
|
||||
if (!window.dispatchEvent(event)) return;
|
||||
} else if ("object" === typeof process && "function" === typeof process.emit) {
|
||||
process.emit("uncaughtException", error);
|
||||
return;
|
||||
}
|
||||
console.error(error);
|
||||
}, didWarnAboutMessageChannel = false, enqueueTaskImpl = null, actScopeDepth = 0, didWarnNoAwaitAct = false, isFlushing = false, queueSeveralMicrotasks = "function" === typeof queueMicrotask ? function(callback) {
|
||||
queueMicrotask(function() {
|
||||
return queueMicrotask(callback);
|
||||
});
|
||||
} : enqueueTask;
|
||||
deprecatedAPIs = Object.freeze({
|
||||
__proto__: null,
|
||||
c: function(size) {
|
||||
return resolveDispatcher().useMemoCache(size);
|
||||
}
|
||||
});
|
||||
exports.Children = {
|
||||
map: mapChildren,
|
||||
forEach: function(children, forEachFunc, forEachContext) {
|
||||
mapChildren(
|
||||
children,
|
||||
function() {
|
||||
forEachFunc.apply(this, arguments);
|
||||
},
|
||||
forEachContext
|
||||
);
|
||||
},
|
||||
count: function(children) {
|
||||
var n = 0;
|
||||
mapChildren(children, function() {
|
||||
n++;
|
||||
});
|
||||
return n;
|
||||
},
|
||||
toArray: function(children) {
|
||||
return mapChildren(children, function(child) {
|
||||
return child;
|
||||
}) || [];
|
||||
},
|
||||
only: function(children) {
|
||||
if (!isValidElement(children))
|
||||
throw Error(
|
||||
"React.Children.only expected to receive a single React element child."
|
||||
);
|
||||
return children;
|
||||
}
|
||||
};
|
||||
exports.Component = Component;
|
||||
exports.Fragment = REACT_FRAGMENT_TYPE;
|
||||
exports.Profiler = REACT_PROFILER_TYPE;
|
||||
exports.PureComponent = PureComponent;
|
||||
exports.StrictMode = REACT_STRICT_MODE_TYPE;
|
||||
exports.Suspense = REACT_SUSPENSE_TYPE;
|
||||
exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
|
||||
exports.__COMPILER_RUNTIME = deprecatedAPIs;
|
||||
exports.act = function(callback) {
|
||||
var prevActQueue = ReactSharedInternals.actQueue, prevActScopeDepth = actScopeDepth;
|
||||
actScopeDepth++;
|
||||
var queue = ReactSharedInternals.actQueue = null !== prevActQueue ? prevActQueue : [], didAwaitActCall = false;
|
||||
try {
|
||||
var result = callback();
|
||||
} catch (error) {
|
||||
ReactSharedInternals.thrownErrors.push(error);
|
||||
}
|
||||
if (0 < ReactSharedInternals.thrownErrors.length)
|
||||
throw popActScope(prevActQueue, prevActScopeDepth), callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
|
||||
if (null !== result && "object" === typeof result && "function" === typeof result.then) {
|
||||
var thenable = result;
|
||||
queueSeveralMicrotasks(function() {
|
||||
didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error(
|
||||
"You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"
|
||||
));
|
||||
});
|
||||
return {
|
||||
then: function(resolve, reject) {
|
||||
didAwaitActCall = true;
|
||||
thenable.then(
|
||||
function(returnValue) {
|
||||
popActScope(prevActQueue, prevActScopeDepth);
|
||||
if (0 === prevActScopeDepth) {
|
||||
try {
|
||||
flushActQueue(queue), enqueueTask(function() {
|
||||
return recursivelyFlushAsyncActWork(
|
||||
returnValue,
|
||||
resolve,
|
||||
reject
|
||||
);
|
||||
});
|
||||
} catch (error$0) {
|
||||
ReactSharedInternals.thrownErrors.push(error$0);
|
||||
}
|
||||
if (0 < ReactSharedInternals.thrownErrors.length) {
|
||||
var _thrownError = aggregateErrors(
|
||||
ReactSharedInternals.thrownErrors
|
||||
);
|
||||
ReactSharedInternals.thrownErrors.length = 0;
|
||||
reject(_thrownError);
|
||||
}
|
||||
} else resolve(returnValue);
|
||||
},
|
||||
function(error) {
|
||||
popActScope(prevActQueue, prevActScopeDepth);
|
||||
0 < ReactSharedInternals.thrownErrors.length ? (error = aggregateErrors(
|
||||
ReactSharedInternals.thrownErrors
|
||||
), ReactSharedInternals.thrownErrors.length = 0, reject(error)) : reject(error);
|
||||
}
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
var returnValue$jscomp$0 = result;
|
||||
popActScope(prevActQueue, prevActScopeDepth);
|
||||
0 === prevActScopeDepth && (flushActQueue(queue), 0 !== queue.length && queueSeveralMicrotasks(function() {
|
||||
didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error(
|
||||
"A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"
|
||||
));
|
||||
}), ReactSharedInternals.actQueue = null);
|
||||
if (0 < ReactSharedInternals.thrownErrors.length)
|
||||
throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
|
||||
return {
|
||||
then: function(resolve, reject) {
|
||||
didAwaitActCall = true;
|
||||
0 === prevActScopeDepth ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
|
||||
return recursivelyFlushAsyncActWork(
|
||||
returnValue$jscomp$0,
|
||||
resolve,
|
||||
reject
|
||||
);
|
||||
})) : resolve(returnValue$jscomp$0);
|
||||
}
|
||||
};
|
||||
};
|
||||
exports.cache = function(fn) {
|
||||
return function() {
|
||||
return fn.apply(null, arguments);
|
||||
};
|
||||
};
|
||||
exports.captureOwnerStack = function() {
|
||||
var getCurrentStack = ReactSharedInternals.getCurrentStack;
|
||||
return null === getCurrentStack ? null : getCurrentStack();
|
||||
};
|
||||
exports.cloneElement = function(element, config, children) {
|
||||
if (null === element || void 0 === element)
|
||||
throw Error(
|
||||
"The argument must be a React element, but you passed " + element + "."
|
||||
);
|
||||
var props = assign({}, element.props), key = element.key, owner = element._owner;
|
||||
if (null != config) {
|
||||
var JSCompiler_inline_result;
|
||||
a: {
|
||||
if (hasOwnProperty.call(config, "ref") && (JSCompiler_inline_result = Object.getOwnPropertyDescriptor(
|
||||
config,
|
||||
"ref"
|
||||
).get) && JSCompiler_inline_result.isReactWarning) {
|
||||
JSCompiler_inline_result = false;
|
||||
break a;
|
||||
}
|
||||
JSCompiler_inline_result = void 0 !== config.ref;
|
||||
}
|
||||
JSCompiler_inline_result && (owner = getOwner());
|
||||
hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key);
|
||||
for (propName in config)
|
||||
!hasOwnProperty.call(config, propName) || "key" === propName || "__self" === propName || "__source" === propName || "ref" === propName && void 0 === config.ref || (props[propName] = config[propName]);
|
||||
}
|
||||
var propName = arguments.length - 2;
|
||||
if (1 === propName) props.children = children;
|
||||
else if (1 < propName) {
|
||||
JSCompiler_inline_result = Array(propName);
|
||||
for (var i = 0; i < propName; i++)
|
||||
JSCompiler_inline_result[i] = arguments[i + 2];
|
||||
props.children = JSCompiler_inline_result;
|
||||
}
|
||||
props = ReactElement(
|
||||
element.type,
|
||||
key,
|
||||
void 0,
|
||||
void 0,
|
||||
owner,
|
||||
props,
|
||||
element._debugStack,
|
||||
element._debugTask
|
||||
);
|
||||
for (key = 2; key < arguments.length; key++)
|
||||
owner = arguments[key], isValidElement(owner) && owner._store && (owner._store.validated = 1);
|
||||
return props;
|
||||
};
|
||||
exports.createContext = function(defaultValue) {
|
||||
defaultValue = {
|
||||
$$typeof: REACT_CONTEXT_TYPE,
|
||||
_currentValue: defaultValue,
|
||||
_currentValue2: defaultValue,
|
||||
_threadCount: 0,
|
||||
Provider: null,
|
||||
Consumer: null
|
||||
};
|
||||
defaultValue.Provider = defaultValue;
|
||||
defaultValue.Consumer = {
|
||||
$$typeof: REACT_CONSUMER_TYPE,
|
||||
_context: defaultValue
|
||||
};
|
||||
defaultValue._currentRenderer = null;
|
||||
defaultValue._currentRenderer2 = null;
|
||||
return defaultValue;
|
||||
};
|
||||
exports.createElement = function(type, config, children) {
|
||||
for (var i = 2; i < arguments.length; i++) {
|
||||
var node = arguments[i];
|
||||
isValidElement(node) && node._store && (node._store.validated = 1);
|
||||
}
|
||||
i = {};
|
||||
node = null;
|
||||
if (null != config)
|
||||
for (propName in didWarnAboutOldJSXRuntime || !("__self" in config) || "key" in config || (didWarnAboutOldJSXRuntime = true, console.warn(
|
||||
"Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform"
|
||||
)), hasValidKey(config) && (checkKeyStringCoercion(config.key), node = "" + config.key), config)
|
||||
hasOwnProperty.call(config, propName) && "key" !== propName && "__self" !== propName && "__source" !== propName && (i[propName] = config[propName]);
|
||||
var childrenLength = arguments.length - 2;
|
||||
if (1 === childrenLength) i.children = children;
|
||||
else if (1 < childrenLength) {
|
||||
for (var childArray = Array(childrenLength), _i = 0; _i < childrenLength; _i++)
|
||||
childArray[_i] = arguments[_i + 2];
|
||||
Object.freeze && Object.freeze(childArray);
|
||||
i.children = childArray;
|
||||
}
|
||||
if (type && type.defaultProps)
|
||||
for (propName in childrenLength = type.defaultProps, childrenLength)
|
||||
void 0 === i[propName] && (i[propName] = childrenLength[propName]);
|
||||
node && defineKeyPropWarningGetter(
|
||||
i,
|
||||
"function" === typeof type ? type.displayName || type.name || "Unknown" : type
|
||||
);
|
||||
var propName = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
|
||||
return ReactElement(
|
||||
type,
|
||||
node,
|
||||
void 0,
|
||||
void 0,
|
||||
getOwner(),
|
||||
i,
|
||||
propName ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
|
||||
propName ? createTask(getTaskName(type)) : unknownOwnerDebugTask
|
||||
);
|
||||
};
|
||||
exports.createRef = function() {
|
||||
var refObject = { current: null };
|
||||
Object.seal(refObject);
|
||||
return refObject;
|
||||
};
|
||||
exports.forwardRef = function(render) {
|
||||
null != render && render.$$typeof === REACT_MEMO_TYPE ? console.error(
|
||||
"forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))."
|
||||
) : "function" !== typeof render ? console.error(
|
||||
"forwardRef requires a render function but was given %s.",
|
||||
null === render ? "null" : typeof render
|
||||
) : 0 !== render.length && 2 !== render.length && console.error(
|
||||
"forwardRef render functions accept exactly two parameters: props and ref. %s",
|
||||
1 === render.length ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."
|
||||
);
|
||||
null != render && null != render.defaultProps && console.error(
|
||||
"forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?"
|
||||
);
|
||||
var elementType = { $$typeof: REACT_FORWARD_REF_TYPE, render }, ownName;
|
||||
Object.defineProperty(elementType, "displayName", {
|
||||
enumerable: false,
|
||||
configurable: true,
|
||||
get: function() {
|
||||
return ownName;
|
||||
},
|
||||
set: function(name) {
|
||||
ownName = name;
|
||||
render.name || render.displayName || (Object.defineProperty(render, "name", { value: name }), render.displayName = name);
|
||||
}
|
||||
});
|
||||
return elementType;
|
||||
};
|
||||
exports.isValidElement = isValidElement;
|
||||
exports.lazy = function(ctor) {
|
||||
return {
|
||||
$$typeof: REACT_LAZY_TYPE,
|
||||
_payload: { _status: -1, _result: ctor },
|
||||
_init: lazyInitializer
|
||||
};
|
||||
};
|
||||
exports.memo = function(type, compare) {
|
||||
null == type && console.error(
|
||||
"memo: The first argument must be a component. Instead received: %s",
|
||||
null === type ? "null" : typeof type
|
||||
);
|
||||
compare = {
|
||||
$$typeof: REACT_MEMO_TYPE,
|
||||
type,
|
||||
compare: void 0 === compare ? null : compare
|
||||
};
|
||||
var ownName;
|
||||
Object.defineProperty(compare, "displayName", {
|
||||
enumerable: false,
|
||||
configurable: true,
|
||||
get: function() {
|
||||
return ownName;
|
||||
},
|
||||
set: function(name) {
|
||||
ownName = name;
|
||||
type.name || type.displayName || (Object.defineProperty(type, "name", { value: name }), type.displayName = name);
|
||||
}
|
||||
});
|
||||
return compare;
|
||||
};
|
||||
exports.startTransition = function(scope) {
|
||||
var prevTransition = ReactSharedInternals.T, currentTransition = {};
|
||||
ReactSharedInternals.T = currentTransition;
|
||||
currentTransition._updatedFibers = /* @__PURE__ */ new Set();
|
||||
try {
|
||||
var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S;
|
||||
null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
|
||||
"object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && returnValue.then(noop, reportGlobalError);
|
||||
} catch (error) {
|
||||
reportGlobalError(error);
|
||||
} finally {
|
||||
null === prevTransition && currentTransition._updatedFibers && (scope = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < scope && console.warn(
|
||||
"Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."
|
||||
)), ReactSharedInternals.T = prevTransition;
|
||||
}
|
||||
};
|
||||
exports.unstable_useCacheRefresh = function() {
|
||||
return resolveDispatcher().useCacheRefresh();
|
||||
};
|
||||
exports.use = function(usable) {
|
||||
return resolveDispatcher().use(usable);
|
||||
};
|
||||
exports.useActionState = function(action, initialState, permalink) {
|
||||
return resolveDispatcher().useActionState(
|
||||
action,
|
||||
initialState,
|
||||
permalink
|
||||
);
|
||||
};
|
||||
exports.useCallback = function(callback, deps) {
|
||||
return resolveDispatcher().useCallback(callback, deps);
|
||||
};
|
||||
exports.useContext = function(Context) {
|
||||
var dispatcher = resolveDispatcher();
|
||||
Context.$$typeof === REACT_CONSUMER_TYPE && console.error(
|
||||
"Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?"
|
||||
);
|
||||
return dispatcher.useContext(Context);
|
||||
};
|
||||
exports.useDebugValue = function(value, formatterFn) {
|
||||
return resolveDispatcher().useDebugValue(value, formatterFn);
|
||||
};
|
||||
exports.useDeferredValue = function(value, initialValue) {
|
||||
return resolveDispatcher().useDeferredValue(value, initialValue);
|
||||
};
|
||||
exports.useEffect = function(create, createDeps, update) {
|
||||
null == create && console.warn(
|
||||
"React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?"
|
||||
);
|
||||
var dispatcher = resolveDispatcher();
|
||||
if ("function" === typeof update)
|
||||
throw Error(
|
||||
"useEffect CRUD overload is not enabled in this build of React."
|
||||
);
|
||||
return dispatcher.useEffect(create, createDeps);
|
||||
};
|
||||
exports.useId = function() {
|
||||
return resolveDispatcher().useId();
|
||||
};
|
||||
exports.useImperativeHandle = function(ref, create, deps) {
|
||||
return resolveDispatcher().useImperativeHandle(ref, create, deps);
|
||||
};
|
||||
exports.useInsertionEffect = function(create, deps) {
|
||||
null == create && console.warn(
|
||||
"React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?"
|
||||
);
|
||||
return resolveDispatcher().useInsertionEffect(create, deps);
|
||||
};
|
||||
exports.useLayoutEffect = function(create, deps) {
|
||||
null == create && console.warn(
|
||||
"React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?"
|
||||
);
|
||||
return resolveDispatcher().useLayoutEffect(create, deps);
|
||||
};
|
||||
exports.useMemo = function(create, deps) {
|
||||
return resolveDispatcher().useMemo(create, deps);
|
||||
};
|
||||
exports.useOptimistic = function(passthrough, reducer) {
|
||||
return resolveDispatcher().useOptimistic(passthrough, reducer);
|
||||
};
|
||||
exports.useReducer = function(reducer, initialArg, init) {
|
||||
return resolveDispatcher().useReducer(reducer, initialArg, init);
|
||||
};
|
||||
exports.useRef = function(initialValue) {
|
||||
return resolveDispatcher().useRef(initialValue);
|
||||
};
|
||||
exports.useState = function(initialState) {
|
||||
return resolveDispatcher().useState(initialState);
|
||||
};
|
||||
exports.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) {
|
||||
return resolveDispatcher().useSyncExternalStore(
|
||||
subscribe,
|
||||
getSnapshot,
|
||||
getServerSnapshot
|
||||
);
|
||||
};
|
||||
exports.useTransition = function() {
|
||||
return resolveDispatcher().useTransition();
|
||||
};
|
||||
exports.version = "19.1.0";
|
||||
"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
|
||||
})();
|
||||
}
|
||||
});
|
||||
|
||||
// node_modules/react/index.js
|
||||
var require_react = __commonJS({
|
||||
"node_modules/react/index.js"(exports, module) {
|
||||
if (false) {
|
||||
module.exports = null;
|
||||
} else {
|
||||
module.exports = require_react_development();
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
export {
|
||||
__commonJS,
|
||||
__toESM,
|
||||
require_react
|
||||
};
|
||||
/*! Bundled license information:
|
||||
|
||||
react/cjs/react.development.js:
|
||||
(**
|
||||
* @license React
|
||||
* react.development.js
|
||||
*
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*)
|
||||
*/
|
||||
//# sourceMappingURL=chunk-QH6HOCAD.js.map
|
||||
+7
File diff suppressed because one or more lines are too long
+278
@@ -0,0 +1,278 @@
|
||||
import {
|
||||
__commonJS,
|
||||
require_react
|
||||
} from "./chunk-QH6HOCAD.js";
|
||||
|
||||
// node_modules/react-dom/cjs/react-dom.development.js
|
||||
var require_react_dom_development = __commonJS({
|
||||
"node_modules/react-dom/cjs/react-dom.development.js"(exports) {
|
||||
"use strict";
|
||||
(function() {
|
||||
function noop() {
|
||||
}
|
||||
function testStringCoercion(value) {
|
||||
return "" + value;
|
||||
}
|
||||
function createPortal$1(children, containerInfo, implementation) {
|
||||
var key = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
|
||||
try {
|
||||
testStringCoercion(key);
|
||||
var JSCompiler_inline_result = false;
|
||||
} catch (e) {
|
||||
JSCompiler_inline_result = true;
|
||||
}
|
||||
JSCompiler_inline_result && (console.error(
|
||||
"The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
|
||||
"function" === typeof Symbol && Symbol.toStringTag && key[Symbol.toStringTag] || key.constructor.name || "Object"
|
||||
), testStringCoercion(key));
|
||||
return {
|
||||
$$typeof: REACT_PORTAL_TYPE,
|
||||
key: null == key ? null : "" + key,
|
||||
children,
|
||||
containerInfo,
|
||||
implementation
|
||||
};
|
||||
}
|
||||
function getCrossOriginStringAs(as, input) {
|
||||
if ("font" === as) return "";
|
||||
if ("string" === typeof input)
|
||||
return "use-credentials" === input ? input : "";
|
||||
}
|
||||
function getValueDescriptorExpectingObjectForWarning(thing) {
|
||||
return null === thing ? "`null`" : void 0 === thing ? "`undefined`" : "" === thing ? "an empty string" : 'something with type "' + typeof thing + '"';
|
||||
}
|
||||
function getValueDescriptorExpectingEnumForWarning(thing) {
|
||||
return null === thing ? "`null`" : void 0 === thing ? "`undefined`" : "" === thing ? "an empty string" : "string" === typeof thing ? JSON.stringify(thing) : "number" === typeof thing ? "`" + thing + "`" : 'something with type "' + typeof thing + '"';
|
||||
}
|
||||
function resolveDispatcher() {
|
||||
var dispatcher = ReactSharedInternals.H;
|
||||
null === dispatcher && console.error(
|
||||
"Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem."
|
||||
);
|
||||
return dispatcher;
|
||||
}
|
||||
"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
|
||||
var React = require_react(), Internals = {
|
||||
d: {
|
||||
f: noop,
|
||||
r: function() {
|
||||
throw Error(
|
||||
"Invalid form element. requestFormReset must be passed a form that was rendered by React."
|
||||
);
|
||||
},
|
||||
D: noop,
|
||||
C: noop,
|
||||
L: noop,
|
||||
m: noop,
|
||||
X: noop,
|
||||
S: noop,
|
||||
M: noop
|
||||
},
|
||||
p: 0,
|
||||
findDOMNode: null
|
||||
}, REACT_PORTAL_TYPE = Symbol.for("react.portal"), ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
|
||||
"function" === typeof Map && null != Map.prototype && "function" === typeof Map.prototype.forEach && "function" === typeof Set && null != Set.prototype && "function" === typeof Set.prototype.clear && "function" === typeof Set.prototype.forEach || console.error(
|
||||
"React depends on Map and Set built-in types. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills"
|
||||
);
|
||||
exports.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = Internals;
|
||||
exports.createPortal = function(children, container) {
|
||||
var key = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null;
|
||||
if (!container || 1 !== container.nodeType && 9 !== container.nodeType && 11 !== container.nodeType)
|
||||
throw Error("Target container is not a DOM element.");
|
||||
return createPortal$1(children, container, null, key);
|
||||
};
|
||||
exports.flushSync = function(fn) {
|
||||
var previousTransition = ReactSharedInternals.T, previousUpdatePriority = Internals.p;
|
||||
try {
|
||||
if (ReactSharedInternals.T = null, Internals.p = 2, fn)
|
||||
return fn();
|
||||
} finally {
|
||||
ReactSharedInternals.T = previousTransition, Internals.p = previousUpdatePriority, Internals.d.f() && console.error(
|
||||
"flushSync was called from inside a lifecycle method. React cannot flush when React is already rendering. Consider moving this call to a scheduler task or micro task."
|
||||
);
|
||||
}
|
||||
};
|
||||
exports.preconnect = function(href, options) {
|
||||
"string" === typeof href && href ? null != options && "object" !== typeof options ? console.error(
|
||||
"ReactDOM.preconnect(): Expected the `options` argument (second) to be an object but encountered %s instead. The only supported option at this time is `crossOrigin` which accepts a string.",
|
||||
getValueDescriptorExpectingEnumForWarning(options)
|
||||
) : null != options && "string" !== typeof options.crossOrigin && console.error(
|
||||
"ReactDOM.preconnect(): Expected the `crossOrigin` option (second argument) to be a string but encountered %s instead. Try removing this option or passing a string value instead.",
|
||||
getValueDescriptorExpectingObjectForWarning(options.crossOrigin)
|
||||
) : console.error(
|
||||
"ReactDOM.preconnect(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
|
||||
getValueDescriptorExpectingObjectForWarning(href)
|
||||
);
|
||||
"string" === typeof href && (options ? (options = options.crossOrigin, options = "string" === typeof options ? "use-credentials" === options ? options : "" : void 0) : options = null, Internals.d.C(href, options));
|
||||
};
|
||||
exports.prefetchDNS = function(href) {
|
||||
if ("string" !== typeof href || !href)
|
||||
console.error(
|
||||
"ReactDOM.prefetchDNS(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
|
||||
getValueDescriptorExpectingObjectForWarning(href)
|
||||
);
|
||||
else if (1 < arguments.length) {
|
||||
var options = arguments[1];
|
||||
"object" === typeof options && options.hasOwnProperty("crossOrigin") ? console.error(
|
||||
"ReactDOM.prefetchDNS(): Expected only one argument, `href`, but encountered %s as a second argument instead. This argument is reserved for future options and is currently disallowed. It looks like the you are attempting to set a crossOrigin property for this DNS lookup hint. Browsers do not perform DNS queries using CORS and setting this attribute on the resource hint has no effect. Try calling ReactDOM.prefetchDNS() with just a single string argument, `href`.",
|
||||
getValueDescriptorExpectingEnumForWarning(options)
|
||||
) : console.error(
|
||||
"ReactDOM.prefetchDNS(): Expected only one argument, `href`, but encountered %s as a second argument instead. This argument is reserved for future options and is currently disallowed. Try calling ReactDOM.prefetchDNS() with just a single string argument, `href`.",
|
||||
getValueDescriptorExpectingEnumForWarning(options)
|
||||
);
|
||||
}
|
||||
"string" === typeof href && Internals.d.D(href);
|
||||
};
|
||||
exports.preinit = function(href, options) {
|
||||
"string" === typeof href && href ? null == options || "object" !== typeof options ? console.error(
|
||||
"ReactDOM.preinit(): Expected the `options` argument (second) to be an object with an `as` property describing the type of resource to be preinitialized but encountered %s instead.",
|
||||
getValueDescriptorExpectingEnumForWarning(options)
|
||||
) : "style" !== options.as && "script" !== options.as && console.error(
|
||||
'ReactDOM.preinit(): Expected the `as` property in the `options` argument (second) to contain a valid value describing the type of resource to be preinitialized but encountered %s instead. Valid values for `as` are "style" and "script".',
|
||||
getValueDescriptorExpectingEnumForWarning(options.as)
|
||||
) : console.error(
|
||||
"ReactDOM.preinit(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
|
||||
getValueDescriptorExpectingObjectForWarning(href)
|
||||
);
|
||||
if ("string" === typeof href && options && "string" === typeof options.as) {
|
||||
var as = options.as, crossOrigin = getCrossOriginStringAs(as, options.crossOrigin), integrity = "string" === typeof options.integrity ? options.integrity : void 0, fetchPriority = "string" === typeof options.fetchPriority ? options.fetchPriority : void 0;
|
||||
"style" === as ? Internals.d.S(
|
||||
href,
|
||||
"string" === typeof options.precedence ? options.precedence : void 0,
|
||||
{
|
||||
crossOrigin,
|
||||
integrity,
|
||||
fetchPriority
|
||||
}
|
||||
) : "script" === as && Internals.d.X(href, {
|
||||
crossOrigin,
|
||||
integrity,
|
||||
fetchPriority,
|
||||
nonce: "string" === typeof options.nonce ? options.nonce : void 0
|
||||
});
|
||||
}
|
||||
};
|
||||
exports.preinitModule = function(href, options) {
|
||||
var encountered = "";
|
||||
"string" === typeof href && href || (encountered += " The `href` argument encountered was " + getValueDescriptorExpectingObjectForWarning(href) + ".");
|
||||
void 0 !== options && "object" !== typeof options ? encountered += " The `options` argument encountered was " + getValueDescriptorExpectingObjectForWarning(options) + "." : options && "as" in options && "script" !== options.as && (encountered += " The `as` option encountered was " + getValueDescriptorExpectingEnumForWarning(options.as) + ".");
|
||||
if (encountered)
|
||||
console.error(
|
||||
"ReactDOM.preinitModule(): Expected up to two arguments, a non-empty `href` string and, optionally, an `options` object with a valid `as` property.%s",
|
||||
encountered
|
||||
);
|
||||
else
|
||||
switch (encountered = options && "string" === typeof options.as ? options.as : "script", encountered) {
|
||||
case "script":
|
||||
break;
|
||||
default:
|
||||
encountered = getValueDescriptorExpectingEnumForWarning(encountered), console.error(
|
||||
'ReactDOM.preinitModule(): Currently the only supported "as" type for this function is "script" but received "%s" instead. This warning was generated for `href` "%s". In the future other module types will be supported, aligning with the import-attributes proposal. Learn more here: (https://github.com/tc39/proposal-import-attributes)',
|
||||
encountered,
|
||||
href
|
||||
);
|
||||
}
|
||||
if ("string" === typeof href)
|
||||
if ("object" === typeof options && null !== options) {
|
||||
if (null == options.as || "script" === options.as)
|
||||
encountered = getCrossOriginStringAs(
|
||||
options.as,
|
||||
options.crossOrigin
|
||||
), Internals.d.M(href, {
|
||||
crossOrigin: encountered,
|
||||
integrity: "string" === typeof options.integrity ? options.integrity : void 0,
|
||||
nonce: "string" === typeof options.nonce ? options.nonce : void 0
|
||||
});
|
||||
} else null == options && Internals.d.M(href);
|
||||
};
|
||||
exports.preload = function(href, options) {
|
||||
var encountered = "";
|
||||
"string" === typeof href && href || (encountered += " The `href` argument encountered was " + getValueDescriptorExpectingObjectForWarning(href) + ".");
|
||||
null == options || "object" !== typeof options ? encountered += " The `options` argument encountered was " + getValueDescriptorExpectingObjectForWarning(options) + "." : "string" === typeof options.as && options.as || (encountered += " The `as` option encountered was " + getValueDescriptorExpectingObjectForWarning(options.as) + ".");
|
||||
encountered && console.error(
|
||||
'ReactDOM.preload(): Expected two arguments, a non-empty `href` string and an `options` object with an `as` property valid for a `<link rel="preload" as="..." />` tag.%s',
|
||||
encountered
|
||||
);
|
||||
if ("string" === typeof href && "object" === typeof options && null !== options && "string" === typeof options.as) {
|
||||
encountered = options.as;
|
||||
var crossOrigin = getCrossOriginStringAs(
|
||||
encountered,
|
||||
options.crossOrigin
|
||||
);
|
||||
Internals.d.L(href, encountered, {
|
||||
crossOrigin,
|
||||
integrity: "string" === typeof options.integrity ? options.integrity : void 0,
|
||||
nonce: "string" === typeof options.nonce ? options.nonce : void 0,
|
||||
type: "string" === typeof options.type ? options.type : void 0,
|
||||
fetchPriority: "string" === typeof options.fetchPriority ? options.fetchPriority : void 0,
|
||||
referrerPolicy: "string" === typeof options.referrerPolicy ? options.referrerPolicy : void 0,
|
||||
imageSrcSet: "string" === typeof options.imageSrcSet ? options.imageSrcSet : void 0,
|
||||
imageSizes: "string" === typeof options.imageSizes ? options.imageSizes : void 0,
|
||||
media: "string" === typeof options.media ? options.media : void 0
|
||||
});
|
||||
}
|
||||
};
|
||||
exports.preloadModule = function(href, options) {
|
||||
var encountered = "";
|
||||
"string" === typeof href && href || (encountered += " The `href` argument encountered was " + getValueDescriptorExpectingObjectForWarning(href) + ".");
|
||||
void 0 !== options && "object" !== typeof options ? encountered += " The `options` argument encountered was " + getValueDescriptorExpectingObjectForWarning(options) + "." : options && "as" in options && "string" !== typeof options.as && (encountered += " The `as` option encountered was " + getValueDescriptorExpectingObjectForWarning(options.as) + ".");
|
||||
encountered && console.error(
|
||||
'ReactDOM.preloadModule(): Expected two arguments, a non-empty `href` string and, optionally, an `options` object with an `as` property valid for a `<link rel="modulepreload" as="..." />` tag.%s',
|
||||
encountered
|
||||
);
|
||||
"string" === typeof href && (options ? (encountered = getCrossOriginStringAs(
|
||||
options.as,
|
||||
options.crossOrigin
|
||||
), Internals.d.m(href, {
|
||||
as: "string" === typeof options.as && "script" !== options.as ? options.as : void 0,
|
||||
crossOrigin: encountered,
|
||||
integrity: "string" === typeof options.integrity ? options.integrity : void 0
|
||||
})) : Internals.d.m(href));
|
||||
};
|
||||
exports.requestFormReset = function(form) {
|
||||
Internals.d.r(form);
|
||||
};
|
||||
exports.unstable_batchedUpdates = function(fn, a) {
|
||||
return fn(a);
|
||||
};
|
||||
exports.useFormState = function(action, initialState, permalink) {
|
||||
return resolveDispatcher().useFormState(action, initialState, permalink);
|
||||
};
|
||||
exports.useFormStatus = function() {
|
||||
return resolveDispatcher().useHostTransitionStatus();
|
||||
};
|
||||
exports.version = "19.1.0";
|
||||
"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
|
||||
})();
|
||||
}
|
||||
});
|
||||
|
||||
// node_modules/react-dom/index.js
|
||||
var require_react_dom = __commonJS({
|
||||
"node_modules/react-dom/index.js"(exports, module) {
|
||||
if (false) {
|
||||
checkDCE();
|
||||
module.exports = null;
|
||||
} else {
|
||||
module.exports = require_react_dom_development();
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
export {
|
||||
require_react_dom
|
||||
};
|
||||
/*! Bundled license information:
|
||||
|
||||
react-dom/cjs/react-dom.development.js:
|
||||
(**
|
||||
* @license React
|
||||
* react-dom.development.js
|
||||
*
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*)
|
||||
*/
|
||||
//# sourceMappingURL=chunk-T37TWCKW.js.map
|
||||
+7
File diff suppressed because one or more lines are too long
+3
@@ -0,0 +1,3 @@
|
||||
{
|
||||
"type": "module"
|
||||
}
|
||||
+5
@@ -0,0 +1,5 @@
|
||||
import {
|
||||
require_react_dom
|
||||
} from "./chunk-T37TWCKW.js";
|
||||
import "./chunk-QH6HOCAD.js";
|
||||
export default require_react_dom();
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": [],
|
||||
"sourcesContent": [],
|
||||
"mappings": "",
|
||||
"names": []
|
||||
}
|
||||
+18098
File diff suppressed because it is too large
Load Diff
+7
File diff suppressed because one or more lines are too long
+4
@@ -0,0 +1,4 @@
|
||||
import {
|
||||
require_react
|
||||
} from "./chunk-QH6HOCAD.js";
|
||||
export default require_react();
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"version": 3,
|
||||
"sources": [],
|
||||
"sourcesContent": [],
|
||||
"mappings": "",
|
||||
"names": []
|
||||
}
|
||||
+279
@@ -0,0 +1,279 @@
|
||||
import {
|
||||
__commonJS,
|
||||
require_react
|
||||
} from "./chunk-QH6HOCAD.js";
|
||||
|
||||
// node_modules/react/cjs/react-jsx-dev-runtime.development.js
|
||||
var require_react_jsx_dev_runtime_development = __commonJS({
|
||||
"node_modules/react/cjs/react-jsx-dev-runtime.development.js"(exports) {
|
||||
"use strict";
|
||||
(function() {
|
||||
function getComponentNameFromType(type) {
|
||||
if (null == type) return null;
|
||||
if ("function" === typeof type)
|
||||
return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
|
||||
if ("string" === typeof type) return type;
|
||||
switch (type) {
|
||||
case REACT_FRAGMENT_TYPE:
|
||||
return "Fragment";
|
||||
case REACT_PROFILER_TYPE:
|
||||
return "Profiler";
|
||||
case REACT_STRICT_MODE_TYPE:
|
||||
return "StrictMode";
|
||||
case REACT_SUSPENSE_TYPE:
|
||||
return "Suspense";
|
||||
case REACT_SUSPENSE_LIST_TYPE:
|
||||
return "SuspenseList";
|
||||
case REACT_ACTIVITY_TYPE:
|
||||
return "Activity";
|
||||
}
|
||||
if ("object" === typeof type)
|
||||
switch ("number" === typeof type.tag && console.error(
|
||||
"Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
|
||||
), type.$$typeof) {
|
||||
case REACT_PORTAL_TYPE:
|
||||
return "Portal";
|
||||
case REACT_CONTEXT_TYPE:
|
||||
return (type.displayName || "Context") + ".Provider";
|
||||
case REACT_CONSUMER_TYPE:
|
||||
return (type._context.displayName || "Context") + ".Consumer";
|
||||
case REACT_FORWARD_REF_TYPE:
|
||||
var innerType = type.render;
|
||||
type = type.displayName;
|
||||
type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
|
||||
return type;
|
||||
case REACT_MEMO_TYPE:
|
||||
return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
|
||||
case REACT_LAZY_TYPE:
|
||||
innerType = type._payload;
|
||||
type = type._init;
|
||||
try {
|
||||
return getComponentNameFromType(type(innerType));
|
||||
} catch (x) {
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
function testStringCoercion(value) {
|
||||
return "" + value;
|
||||
}
|
||||
function checkKeyStringCoercion(value) {
|
||||
try {
|
||||
testStringCoercion(value);
|
||||
var JSCompiler_inline_result = false;
|
||||
} catch (e) {
|
||||
JSCompiler_inline_result = true;
|
||||
}
|
||||
if (JSCompiler_inline_result) {
|
||||
JSCompiler_inline_result = console;
|
||||
var JSCompiler_temp_const = JSCompiler_inline_result.error;
|
||||
var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
|
||||
JSCompiler_temp_const.call(
|
||||
JSCompiler_inline_result,
|
||||
"The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
|
||||
JSCompiler_inline_result$jscomp$0
|
||||
);
|
||||
return testStringCoercion(value);
|
||||
}
|
||||
}
|
||||
function getTaskName(type) {
|
||||
if (type === REACT_FRAGMENT_TYPE) return "<>";
|
||||
if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE)
|
||||
return "<...>";
|
||||
try {
|
||||
var name = getComponentNameFromType(type);
|
||||
return name ? "<" + name + ">" : "<...>";
|
||||
} catch (x) {
|
||||
return "<...>";
|
||||
}
|
||||
}
|
||||
function getOwner() {
|
||||
var dispatcher = ReactSharedInternals.A;
|
||||
return null === dispatcher ? null : dispatcher.getOwner();
|
||||
}
|
||||
function UnknownOwner() {
|
||||
return Error("react-stack-top-frame");
|
||||
}
|
||||
function hasValidKey(config) {
|
||||
if (hasOwnProperty.call(config, "key")) {
|
||||
var getter = Object.getOwnPropertyDescriptor(config, "key").get;
|
||||
if (getter && getter.isReactWarning) return false;
|
||||
}
|
||||
return void 0 !== config.key;
|
||||
}
|
||||
function defineKeyPropWarningGetter(props, displayName) {
|
||||
function warnAboutAccessingKey() {
|
||||
specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error(
|
||||
"%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
|
||||
displayName
|
||||
));
|
||||
}
|
||||
warnAboutAccessingKey.isReactWarning = true;
|
||||
Object.defineProperty(props, "key", {
|
||||
get: warnAboutAccessingKey,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
function elementRefGetterWithDeprecationWarning() {
|
||||
var componentName = getComponentNameFromType(this.type);
|
||||
didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error(
|
||||
"Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
|
||||
));
|
||||
componentName = this.props.ref;
|
||||
return void 0 !== componentName ? componentName : null;
|
||||
}
|
||||
function ReactElement(type, key, self, source, owner, props, debugStack, debugTask) {
|
||||
self = props.ref;
|
||||
type = {
|
||||
$$typeof: REACT_ELEMENT_TYPE,
|
||||
type,
|
||||
key,
|
||||
props,
|
||||
_owner: owner
|
||||
};
|
||||
null !== (void 0 !== self ? self : null) ? Object.defineProperty(type, "ref", {
|
||||
enumerable: false,
|
||||
get: elementRefGetterWithDeprecationWarning
|
||||
}) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
|
||||
type._store = {};
|
||||
Object.defineProperty(type._store, "validated", {
|
||||
configurable: false,
|
||||
enumerable: false,
|
||||
writable: true,
|
||||
value: 0
|
||||
});
|
||||
Object.defineProperty(type, "_debugInfo", {
|
||||
configurable: false,
|
||||
enumerable: false,
|
||||
writable: true,
|
||||
value: null
|
||||
});
|
||||
Object.defineProperty(type, "_debugStack", {
|
||||
configurable: false,
|
||||
enumerable: false,
|
||||
writable: true,
|
||||
value: debugStack
|
||||
});
|
||||
Object.defineProperty(type, "_debugTask", {
|
||||
configurable: false,
|
||||
enumerable: false,
|
||||
writable: true,
|
||||
value: debugTask
|
||||
});
|
||||
Object.freeze && (Object.freeze(type.props), Object.freeze(type));
|
||||
return type;
|
||||
}
|
||||
function jsxDEVImpl(type, config, maybeKey, isStaticChildren, source, self, debugStack, debugTask) {
|
||||
var children = config.children;
|
||||
if (void 0 !== children)
|
||||
if (isStaticChildren)
|
||||
if (isArrayImpl(children)) {
|
||||
for (isStaticChildren = 0; isStaticChildren < children.length; isStaticChildren++)
|
||||
validateChildKeys(children[isStaticChildren]);
|
||||
Object.freeze && Object.freeze(children);
|
||||
} else
|
||||
console.error(
|
||||
"React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
|
||||
);
|
||||
else validateChildKeys(children);
|
||||
if (hasOwnProperty.call(config, "key")) {
|
||||
children = getComponentNameFromType(type);
|
||||
var keys = Object.keys(config).filter(function(k) {
|
||||
return "key" !== k;
|
||||
});
|
||||
isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
|
||||
didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error(
|
||||
'A props object containing a "key" prop is being spread into JSX:\n let props = %s;\n <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n let props = %s;\n <%s key={someKey} {...props} />',
|
||||
isStaticChildren,
|
||||
children,
|
||||
keys,
|
||||
children
|
||||
), didWarnAboutKeySpread[children + isStaticChildren] = true);
|
||||
}
|
||||
children = null;
|
||||
void 0 !== maybeKey && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
|
||||
hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key);
|
||||
if ("key" in config) {
|
||||
maybeKey = {};
|
||||
for (var propName in config)
|
||||
"key" !== propName && (maybeKey[propName] = config[propName]);
|
||||
} else maybeKey = config;
|
||||
children && defineKeyPropWarningGetter(
|
||||
maybeKey,
|
||||
"function" === typeof type ? type.displayName || type.name || "Unknown" : type
|
||||
);
|
||||
return ReactElement(
|
||||
type,
|
||||
children,
|
||||
self,
|
||||
source,
|
||||
getOwner(),
|
||||
maybeKey,
|
||||
debugStack,
|
||||
debugTask
|
||||
);
|
||||
}
|
||||
function validateChildKeys(node) {
|
||||
"object" === typeof node && null !== node && node.$$typeof === REACT_ELEMENT_TYPE && node._store && (node._store.validated = 1);
|
||||
}
|
||||
var React = require_react(), REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler");
|
||||
Symbol.for("react.provider");
|
||||
var REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, hasOwnProperty = Object.prototype.hasOwnProperty, isArrayImpl = Array.isArray, createTask = console.createTask ? console.createTask : function() {
|
||||
return null;
|
||||
};
|
||||
React = {
|
||||
"react-stack-bottom-frame": function(callStackForError) {
|
||||
return callStackForError();
|
||||
}
|
||||
};
|
||||
var specialPropKeyWarningShown;
|
||||
var didWarnAboutElementRef = {};
|
||||
var unknownOwnerDebugStack = React["react-stack-bottom-frame"].bind(
|
||||
React,
|
||||
UnknownOwner
|
||||
)();
|
||||
var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
|
||||
var didWarnAboutKeySpread = {};
|
||||
exports.Fragment = REACT_FRAGMENT_TYPE;
|
||||
exports.jsxDEV = function(type, config, maybeKey, isStaticChildren, source, self) {
|
||||
var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
|
||||
return jsxDEVImpl(
|
||||
type,
|
||||
config,
|
||||
maybeKey,
|
||||
isStaticChildren,
|
||||
source,
|
||||
self,
|
||||
trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
|
||||
trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
|
||||
);
|
||||
};
|
||||
})();
|
||||
}
|
||||
});
|
||||
|
||||
// node_modules/react/jsx-dev-runtime.js
|
||||
var require_jsx_dev_runtime = __commonJS({
|
||||
"node_modules/react/jsx-dev-runtime.js"(exports, module) {
|
||||
if (false) {
|
||||
module.exports = null;
|
||||
} else {
|
||||
module.exports = require_react_jsx_dev_runtime_development();
|
||||
}
|
||||
}
|
||||
});
|
||||
export default require_jsx_dev_runtime();
|
||||
/*! Bundled license information:
|
||||
|
||||
react/cjs/react-jsx-dev-runtime.development.js:
|
||||
(**
|
||||
* @license React
|
||||
* react-jsx-dev-runtime.development.js
|
||||
*
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*)
|
||||
*/
|
||||
//# sourceMappingURL=react_jsx-dev-runtime.js.map
|
||||
+7
File diff suppressed because one or more lines are too long
+292
@@ -0,0 +1,292 @@
|
||||
import {
|
||||
__commonJS,
|
||||
require_react
|
||||
} from "./chunk-QH6HOCAD.js";
|
||||
|
||||
// node_modules/react/cjs/react-jsx-runtime.development.js
|
||||
var require_react_jsx_runtime_development = __commonJS({
|
||||
"node_modules/react/cjs/react-jsx-runtime.development.js"(exports) {
|
||||
"use strict";
|
||||
(function() {
|
||||
function getComponentNameFromType(type) {
|
||||
if (null == type) return null;
|
||||
if ("function" === typeof type)
|
||||
return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
|
||||
if ("string" === typeof type) return type;
|
||||
switch (type) {
|
||||
case REACT_FRAGMENT_TYPE:
|
||||
return "Fragment";
|
||||
case REACT_PROFILER_TYPE:
|
||||
return "Profiler";
|
||||
case REACT_STRICT_MODE_TYPE:
|
||||
return "StrictMode";
|
||||
case REACT_SUSPENSE_TYPE:
|
||||
return "Suspense";
|
||||
case REACT_SUSPENSE_LIST_TYPE:
|
||||
return "SuspenseList";
|
||||
case REACT_ACTIVITY_TYPE:
|
||||
return "Activity";
|
||||
}
|
||||
if ("object" === typeof type)
|
||||
switch ("number" === typeof type.tag && console.error(
|
||||
"Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
|
||||
), type.$$typeof) {
|
||||
case REACT_PORTAL_TYPE:
|
||||
return "Portal";
|
||||
case REACT_CONTEXT_TYPE:
|
||||
return (type.displayName || "Context") + ".Provider";
|
||||
case REACT_CONSUMER_TYPE:
|
||||
return (type._context.displayName || "Context") + ".Consumer";
|
||||
case REACT_FORWARD_REF_TYPE:
|
||||
var innerType = type.render;
|
||||
type = type.displayName;
|
||||
type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
|
||||
return type;
|
||||
case REACT_MEMO_TYPE:
|
||||
return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
|
||||
case REACT_LAZY_TYPE:
|
||||
innerType = type._payload;
|
||||
type = type._init;
|
||||
try {
|
||||
return getComponentNameFromType(type(innerType));
|
||||
} catch (x) {
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
function testStringCoercion(value) {
|
||||
return "" + value;
|
||||
}
|
||||
function checkKeyStringCoercion(value) {
|
||||
try {
|
||||
testStringCoercion(value);
|
||||
var JSCompiler_inline_result = false;
|
||||
} catch (e) {
|
||||
JSCompiler_inline_result = true;
|
||||
}
|
||||
if (JSCompiler_inline_result) {
|
||||
JSCompiler_inline_result = console;
|
||||
var JSCompiler_temp_const = JSCompiler_inline_result.error;
|
||||
var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
|
||||
JSCompiler_temp_const.call(
|
||||
JSCompiler_inline_result,
|
||||
"The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
|
||||
JSCompiler_inline_result$jscomp$0
|
||||
);
|
||||
return testStringCoercion(value);
|
||||
}
|
||||
}
|
||||
function getTaskName(type) {
|
||||
if (type === REACT_FRAGMENT_TYPE) return "<>";
|
||||
if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE)
|
||||
return "<...>";
|
||||
try {
|
||||
var name = getComponentNameFromType(type);
|
||||
return name ? "<" + name + ">" : "<...>";
|
||||
} catch (x) {
|
||||
return "<...>";
|
||||
}
|
||||
}
|
||||
function getOwner() {
|
||||
var dispatcher = ReactSharedInternals.A;
|
||||
return null === dispatcher ? null : dispatcher.getOwner();
|
||||
}
|
||||
function UnknownOwner() {
|
||||
return Error("react-stack-top-frame");
|
||||
}
|
||||
function hasValidKey(config) {
|
||||
if (hasOwnProperty.call(config, "key")) {
|
||||
var getter = Object.getOwnPropertyDescriptor(config, "key").get;
|
||||
if (getter && getter.isReactWarning) return false;
|
||||
}
|
||||
return void 0 !== config.key;
|
||||
}
|
||||
function defineKeyPropWarningGetter(props, displayName) {
|
||||
function warnAboutAccessingKey() {
|
||||
specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error(
|
||||
"%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
|
||||
displayName
|
||||
));
|
||||
}
|
||||
warnAboutAccessingKey.isReactWarning = true;
|
||||
Object.defineProperty(props, "key", {
|
||||
get: warnAboutAccessingKey,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
function elementRefGetterWithDeprecationWarning() {
|
||||
var componentName = getComponentNameFromType(this.type);
|
||||
didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error(
|
||||
"Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
|
||||
));
|
||||
componentName = this.props.ref;
|
||||
return void 0 !== componentName ? componentName : null;
|
||||
}
|
||||
function ReactElement(type, key, self, source, owner, props, debugStack, debugTask) {
|
||||
self = props.ref;
|
||||
type = {
|
||||
$$typeof: REACT_ELEMENT_TYPE,
|
||||
type,
|
||||
key,
|
||||
props,
|
||||
_owner: owner
|
||||
};
|
||||
null !== (void 0 !== self ? self : null) ? Object.defineProperty(type, "ref", {
|
||||
enumerable: false,
|
||||
get: elementRefGetterWithDeprecationWarning
|
||||
}) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
|
||||
type._store = {};
|
||||
Object.defineProperty(type._store, "validated", {
|
||||
configurable: false,
|
||||
enumerable: false,
|
||||
writable: true,
|
||||
value: 0
|
||||
});
|
||||
Object.defineProperty(type, "_debugInfo", {
|
||||
configurable: false,
|
||||
enumerable: false,
|
||||
writable: true,
|
||||
value: null
|
||||
});
|
||||
Object.defineProperty(type, "_debugStack", {
|
||||
configurable: false,
|
||||
enumerable: false,
|
||||
writable: true,
|
||||
value: debugStack
|
||||
});
|
||||
Object.defineProperty(type, "_debugTask", {
|
||||
configurable: false,
|
||||
enumerable: false,
|
||||
writable: true,
|
||||
value: debugTask
|
||||
});
|
||||
Object.freeze && (Object.freeze(type.props), Object.freeze(type));
|
||||
return type;
|
||||
}
|
||||
function jsxDEVImpl(type, config, maybeKey, isStaticChildren, source, self, debugStack, debugTask) {
|
||||
var children = config.children;
|
||||
if (void 0 !== children)
|
||||
if (isStaticChildren)
|
||||
if (isArrayImpl(children)) {
|
||||
for (isStaticChildren = 0; isStaticChildren < children.length; isStaticChildren++)
|
||||
validateChildKeys(children[isStaticChildren]);
|
||||
Object.freeze && Object.freeze(children);
|
||||
} else
|
||||
console.error(
|
||||
"React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
|
||||
);
|
||||
else validateChildKeys(children);
|
||||
if (hasOwnProperty.call(config, "key")) {
|
||||
children = getComponentNameFromType(type);
|
||||
var keys = Object.keys(config).filter(function(k) {
|
||||
return "key" !== k;
|
||||
});
|
||||
isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
|
||||
didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error(
|
||||
'A props object containing a "key" prop is being spread into JSX:\n let props = %s;\n <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n let props = %s;\n <%s key={someKey} {...props} />',
|
||||
isStaticChildren,
|
||||
children,
|
||||
keys,
|
||||
children
|
||||
), didWarnAboutKeySpread[children + isStaticChildren] = true);
|
||||
}
|
||||
children = null;
|
||||
void 0 !== maybeKey && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
|
||||
hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key);
|
||||
if ("key" in config) {
|
||||
maybeKey = {};
|
||||
for (var propName in config)
|
||||
"key" !== propName && (maybeKey[propName] = config[propName]);
|
||||
} else maybeKey = config;
|
||||
children && defineKeyPropWarningGetter(
|
||||
maybeKey,
|
||||
"function" === typeof type ? type.displayName || type.name || "Unknown" : type
|
||||
);
|
||||
return ReactElement(
|
||||
type,
|
||||
children,
|
||||
self,
|
||||
source,
|
||||
getOwner(),
|
||||
maybeKey,
|
||||
debugStack,
|
||||
debugTask
|
||||
);
|
||||
}
|
||||
function validateChildKeys(node) {
|
||||
"object" === typeof node && null !== node && node.$$typeof === REACT_ELEMENT_TYPE && node._store && (node._store.validated = 1);
|
||||
}
|
||||
var React = require_react(), REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler");
|
||||
Symbol.for("react.provider");
|
||||
var REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, hasOwnProperty = Object.prototype.hasOwnProperty, isArrayImpl = Array.isArray, createTask = console.createTask ? console.createTask : function() {
|
||||
return null;
|
||||
};
|
||||
React = {
|
||||
"react-stack-bottom-frame": function(callStackForError) {
|
||||
return callStackForError();
|
||||
}
|
||||
};
|
||||
var specialPropKeyWarningShown;
|
||||
var didWarnAboutElementRef = {};
|
||||
var unknownOwnerDebugStack = React["react-stack-bottom-frame"].bind(
|
||||
React,
|
||||
UnknownOwner
|
||||
)();
|
||||
var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
|
||||
var didWarnAboutKeySpread = {};
|
||||
exports.Fragment = REACT_FRAGMENT_TYPE;
|
||||
exports.jsx = function(type, config, maybeKey, source, self) {
|
||||
var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
|
||||
return jsxDEVImpl(
|
||||
type,
|
||||
config,
|
||||
maybeKey,
|
||||
false,
|
||||
source,
|
||||
self,
|
||||
trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
|
||||
trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
|
||||
);
|
||||
};
|
||||
exports.jsxs = function(type, config, maybeKey, source, self) {
|
||||
var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
|
||||
return jsxDEVImpl(
|
||||
type,
|
||||
config,
|
||||
maybeKey,
|
||||
true,
|
||||
source,
|
||||
self,
|
||||
trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
|
||||
trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
|
||||
);
|
||||
};
|
||||
})();
|
||||
}
|
||||
});
|
||||
|
||||
// node_modules/react/jsx-runtime.js
|
||||
var require_jsx_runtime = __commonJS({
|
||||
"node_modules/react/jsx-runtime.js"(exports, module) {
|
||||
if (false) {
|
||||
module.exports = null;
|
||||
} else {
|
||||
module.exports = require_react_jsx_runtime_development();
|
||||
}
|
||||
}
|
||||
});
|
||||
export default require_jsx_runtime();
|
||||
/*! Bundled license information:
|
||||
|
||||
react/cjs/react-jsx-runtime.development.js:
|
||||
(**
|
||||
* @license React
|
||||
* react-jsx-runtime.development.js
|
||||
*
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*)
|
||||
*/
|
||||
//# sourceMappingURL=react_jsx-runtime.js.map
|
||||
+7
File diff suppressed because one or more lines are too long
+202
@@ -0,0 +1,202 @@
|
||||
|
||||
Apache License
|
||||
Version 2.0, January 2004
|
||||
http://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction,
|
||||
and distribution as defined by Sections 1 through 9 of this document.
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by
|
||||
the copyright owner that is granting the License.
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all
|
||||
other entities that control, are controlled by, or are under common
|
||||
control with that entity. For the purposes of this definition,
|
||||
"control" means (i) the power, direct or indirect, to cause the
|
||||
direction or management of such entity, whether by contract or
|
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity
|
||||
exercising permissions granted by this License.
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications,
|
||||
including but not limited to software source code, documentation
|
||||
source, and configuration files.
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical
|
||||
transformation or translation of a Source form, including but
|
||||
not limited to compiled object code, generated documentation,
|
||||
and conversions to other media types.
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or
|
||||
Object form, made available under the License, as indicated by a
|
||||
copyright notice that is included in or attached to the work
|
||||
(an example is provided in the Appendix below).
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object
|
||||
form, that is based on (or derived from) the Work and for which the
|
||||
editorial revisions, annotations, elaborations, or other modifications
|
||||
represent, as a whole, an original work of authorship. For the purposes
|
||||
of this License, Derivative Works shall not include works that remain
|
||||
separable from, or merely link (or bind by name) to the interfaces of,
|
||||
the Work and Derivative Works thereof.
|
||||
|
||||
"Contribution" shall mean any work of authorship, including
|
||||
the original version of the Work and any modifications or additions
|
||||
to that Work or Derivative Works thereof, that is intentionally
|
||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||
or by an individual or Legal Entity authorized to submit on behalf of
|
||||
the copyright owner. For the purposes of this definition, "submitted"
|
||||
means any form of electronic, verbal, or written communication sent
|
||||
to the Licensor or its representatives, including but not limited to
|
||||
communication on electronic mailing lists, source code control systems,
|
||||
and issue tracking systems that are managed by, or on behalf of, the
|
||||
Licensor for the purpose of discussing and improving the Work, but
|
||||
excluding communication that is conspicuously marked or otherwise
|
||||
designated in writing by the copyright owner as "Not a Contribution."
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||
on behalf of whom a Contribution has been received by Licensor and
|
||||
subsequently incorporated within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
copyright license to reproduce, prepare Derivative Works of,
|
||||
publicly display, publicly perform, sublicense, and distribute the
|
||||
Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
(except as stated in this section) patent license to make, have made,
|
||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||
where such license applies only to those patent claims licensable
|
||||
by such Contributor that are necessarily infringed by their
|
||||
Contribution(s) alone or by combination of their Contribution(s)
|
||||
with the Work to which such Contribution(s) was submitted. If You
|
||||
institute patent litigation against any entity (including a
|
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||
or a Contribution incorporated within the Work constitutes direct
|
||||
or contributory patent infringement, then any patent licenses
|
||||
granted to You under this License for that Work shall terminate
|
||||
as of the date such litigation is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the
|
||||
Work or Derivative Works thereof in any medium, with or without
|
||||
modifications, and in Source or Object form, provided that You
|
||||
meet the following conditions:
|
||||
|
||||
(a) You must give any other recipients of the Work or
|
||||
Derivative Works a copy of this License; and
|
||||
|
||||
(b) You must cause any modified files to carry prominent notices
|
||||
stating that You changed the files; and
|
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works
|
||||
that You distribute, all copyright, patent, trademark, and
|
||||
attribution notices from the Source form of the Work,
|
||||
excluding those notices that do not pertain to any part of
|
||||
the Derivative Works; and
|
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its
|
||||
distribution, then any Derivative Works that You distribute must
|
||||
include a readable copy of the attribution notices contained
|
||||
within such NOTICE file, excluding those notices that do not
|
||||
pertain to any part of the Derivative Works, in at least one
|
||||
of the following places: within a NOTICE text file distributed
|
||||
as part of the Derivative Works; within the Source form or
|
||||
documentation, if provided along with the Derivative Works; or,
|
||||
within a display generated by the Derivative Works, if and
|
||||
wherever such third-party notices normally appear. The contents
|
||||
of the NOTICE file are for informational purposes only and
|
||||
do not modify the License. You may add Your own attribution
|
||||
notices within Derivative Works that You distribute, alongside
|
||||
or as an addendum to the NOTICE text from the Work, provided
|
||||
that such additional attribution notices cannot be construed
|
||||
as modifying the License.
|
||||
|
||||
You may add Your own copyright statement to Your modifications and
|
||||
may provide additional or different license terms and conditions
|
||||
for use, reproduction, or distribution of Your modifications, or
|
||||
for any such Derivative Works as a whole, provided Your use,
|
||||
reproduction, and distribution of the Work otherwise complies with
|
||||
the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||
any Contribution intentionally submitted for inclusion in the Work
|
||||
by You to the Licensor shall be under the terms and conditions of
|
||||
this License, without any additional terms or conditions.
|
||||
Notwithstanding the above, nothing herein shall supersede or modify
|
||||
the terms of any separate license agreement you may have executed
|
||||
with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade
|
||||
names, trademarks, service marks, or product names of the Licensor,
|
||||
except as required for reasonable and customary use in describing the
|
||||
origin of the Work and reproducing the content of the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||
agreed to in writing, Licensor provides the Work (and each
|
||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||
implied, including, without limitation, any warranties or conditions
|
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||
appropriateness of using or redistributing the Work and assume any
|
||||
risks associated with Your exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory,
|
||||
whether in tort (including negligence), contract, or otherwise,
|
||||
unless required by applicable law (such as deliberate and grossly
|
||||
negligent acts) or agreed to in writing, shall any Contributor be
|
||||
liable to You for damages, including any direct, indirect, special,
|
||||
incidental, or consequential damages of any character arising as a
|
||||
result of this License or out of the use or inability to use the
|
||||
Work (including but not limited to damages for loss of goodwill,
|
||||
work stoppage, computer failure or malfunction, or any and all
|
||||
other commercial damages or losses), even if such Contributor
|
||||
has been advised of the possibility of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing
|
||||
the Work or Derivative Works thereof, You may choose to offer,
|
||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||
or other liability obligations and/or rights consistent with this
|
||||
License. However, in accepting such obligations, You may act only
|
||||
on Your own behalf and on Your sole responsibility, not on behalf
|
||||
of any other Contributor, and only if You agree to indemnify,
|
||||
defend, and hold each Contributor harmless for any liability
|
||||
incurred by, or claims asserted against, such Contributor by reason
|
||||
of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
APPENDIX: How to apply the Apache License to your work.
|
||||
|
||||
To apply the Apache License to your work, attach the following
|
||||
boilerplate notice, with the fields enclosed by brackets "[]"
|
||||
replaced with your own identifying information. (Don't include
|
||||
the brackets!) The text should be enclosed in the appropriate
|
||||
comment syntax for the file format. We also recommend that a
|
||||
file or class name and description of purpose be included on the
|
||||
same "printed page" as the copyright notice for easier
|
||||
identification within third-party archives.
|
||||
|
||||
Copyright [yyyy] [name of copyright owner]
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
+218
@@ -0,0 +1,218 @@
|
||||
# @ampproject/remapping
|
||||
|
||||
> Remap sequential sourcemaps through transformations to point at the original source code
|
||||
|
||||
Remapping allows you to take the sourcemaps generated through transforming your code and "remap"
|
||||
them to the original source locations. Think "my minified code, transformed with babel and bundled
|
||||
with webpack", all pointing to the correct location in your original source code.
|
||||
|
||||
With remapping, none of your source code transformations need to be aware of the input's sourcemap,
|
||||
they only need to generate an output sourcemap. This greatly simplifies building custom
|
||||
transformations (think a find-and-replace).
|
||||
|
||||
## Installation
|
||||
|
||||
```sh
|
||||
npm install @ampproject/remapping
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
```typescript
|
||||
function remapping(
|
||||
map: SourceMap | SourceMap[],
|
||||
loader: (file: string, ctx: LoaderContext) => (SourceMap | null | undefined),
|
||||
options?: { excludeContent: boolean, decodedMappings: boolean }
|
||||
): SourceMap;
|
||||
|
||||
// LoaderContext gives the loader the importing sourcemap, tree depth, the ability to override the
|
||||
// "source" location (where child sources are resolved relative to, or the location of original
|
||||
// source), and the ability to override the "content" of an original source for inclusion in the
|
||||
// output sourcemap.
|
||||
type LoaderContext = {
|
||||
readonly importer: string;
|
||||
readonly depth: number;
|
||||
source: string;
|
||||
content: string | null | undefined;
|
||||
}
|
||||
```
|
||||
|
||||
`remapping` takes the final output sourcemap, and a `loader` function. For every source file pointer
|
||||
in the sourcemap, the `loader` will be called with the resolved path. If the path itself represents
|
||||
a transformed file (it has a sourcmap associated with it), then the `loader` should return that
|
||||
sourcemap. If not, the path will be treated as an original, untransformed source code.
|
||||
|
||||
```js
|
||||
// Babel transformed "helloworld.js" into "transformed.js"
|
||||
const transformedMap = JSON.stringify({
|
||||
file: 'transformed.js',
|
||||
// 1st column of 2nd line of output file translates into the 1st source
|
||||
// file, line 3, column 2
|
||||
mappings: ';CAEE',
|
||||
sources: ['helloworld.js'],
|
||||
version: 3,
|
||||
});
|
||||
|
||||
// Uglify minified "transformed.js" into "transformed.min.js"
|
||||
const minifiedTransformedMap = JSON.stringify({
|
||||
file: 'transformed.min.js',
|
||||
// 0th column of 1st line of output file translates into the 1st source
|
||||
// file, line 2, column 1.
|
||||
mappings: 'AACC',
|
||||
names: [],
|
||||
sources: ['transformed.js'],
|
||||
version: 3,
|
||||
});
|
||||
|
||||
const remapped = remapping(
|
||||
minifiedTransformedMap,
|
||||
(file, ctx) => {
|
||||
|
||||
// The "transformed.js" file is an transformed file.
|
||||
if (file === 'transformed.js') {
|
||||
// The root importer is empty.
|
||||
console.assert(ctx.importer === '');
|
||||
// The depth in the sourcemap tree we're currently loading.
|
||||
// The root `minifiedTransformedMap` is depth 0, and its source children are depth 1, etc.
|
||||
console.assert(ctx.depth === 1);
|
||||
|
||||
return transformedMap;
|
||||
}
|
||||
|
||||
// Loader will be called to load transformedMap's source file pointers as well.
|
||||
console.assert(file === 'helloworld.js');
|
||||
// `transformed.js`'s sourcemap points into `helloworld.js`.
|
||||
console.assert(ctx.importer === 'transformed.js');
|
||||
// This is a source child of `transformed`, which is a source child of `minifiedTransformedMap`.
|
||||
console.assert(ctx.depth === 2);
|
||||
return null;
|
||||
}
|
||||
);
|
||||
|
||||
console.log(remapped);
|
||||
// {
|
||||
// file: 'transpiled.min.js',
|
||||
// mappings: 'AAEE',
|
||||
// sources: ['helloworld.js'],
|
||||
// version: 3,
|
||||
// };
|
||||
```
|
||||
|
||||
In this example, `loader` will be called twice:
|
||||
|
||||
1. `"transformed.js"`, the first source file pointer in the `minifiedTransformedMap`. We return the
|
||||
associated sourcemap for it (its a transformed file, after all) so that sourcemap locations can
|
||||
be traced through it into the source files it represents.
|
||||
2. `"helloworld.js"`, our original, unmodified source code. This file does not have a sourcemap, so
|
||||
we return `null`.
|
||||
|
||||
The `remapped` sourcemap now points from `transformed.min.js` into locations in `helloworld.js`. If
|
||||
you were to read the `mappings`, it says "0th column of the first line output line points to the 1st
|
||||
column of the 2nd line of the file `helloworld.js`".
|
||||
|
||||
### Multiple transformations of a file
|
||||
|
||||
As a convenience, if you have multiple single-source transformations of a file, you may pass an
|
||||
array of sourcemap files in the order of most-recent transformation sourcemap first. Note that this
|
||||
changes the `importer` and `depth` of each call to our loader. So our above example could have been
|
||||
written as:
|
||||
|
||||
```js
|
||||
const remapped = remapping(
|
||||
[minifiedTransformedMap, transformedMap],
|
||||
() => null
|
||||
);
|
||||
|
||||
console.log(remapped);
|
||||
// {
|
||||
// file: 'transpiled.min.js',
|
||||
// mappings: 'AAEE',
|
||||
// sources: ['helloworld.js'],
|
||||
// version: 3,
|
||||
// };
|
||||
```
|
||||
|
||||
### Advanced control of the loading graph
|
||||
|
||||
#### `source`
|
||||
|
||||
The `source` property can overridden to any value to change the location of the current load. Eg,
|
||||
for an original source file, it allows us to change the location to the original source regardless
|
||||
of what the sourcemap source entry says. And for transformed files, it allows us to change the
|
||||
relative resolving location for child sources of the loaded sourcemap.
|
||||
|
||||
```js
|
||||
const remapped = remapping(
|
||||
minifiedTransformedMap,
|
||||
(file, ctx) => {
|
||||
|
||||
if (file === 'transformed.js') {
|
||||
// We pretend the transformed.js file actually exists in the 'src/' directory. When the nested
|
||||
// source files are loaded, they will now be relative to `src/`.
|
||||
ctx.source = 'src/transformed.js';
|
||||
return transformedMap;
|
||||
}
|
||||
|
||||
console.assert(file === 'src/helloworld.js');
|
||||
// We could futher change the source of this original file, eg, to be inside a nested directory
|
||||
// itself. This will be reflected in the remapped sourcemap.
|
||||
ctx.source = 'src/nested/transformed.js';
|
||||
return null;
|
||||
}
|
||||
);
|
||||
|
||||
console.log(remapped);
|
||||
// {
|
||||
// …,
|
||||
// sources: ['src/nested/helloworld.js'],
|
||||
// };
|
||||
```
|
||||
|
||||
|
||||
#### `content`
|
||||
|
||||
The `content` property can be overridden when we encounter an original source file. Eg, this allows
|
||||
you to manually provide the source content of the original file regardless of whether the
|
||||
`sourcesContent` field is present in the parent sourcemap. It can also be set to `null` to remove
|
||||
the source content.
|
||||
|
||||
```js
|
||||
const remapped = remapping(
|
||||
minifiedTransformedMap,
|
||||
(file, ctx) => {
|
||||
|
||||
if (file === 'transformed.js') {
|
||||
// transformedMap does not include a `sourcesContent` field, so usually the remapped sourcemap
|
||||
// would not include any `sourcesContent` values.
|
||||
return transformedMap;
|
||||
}
|
||||
|
||||
console.assert(file === 'helloworld.js');
|
||||
// We can read the file to provide the source content.
|
||||
ctx.content = fs.readFileSync(file, 'utf8');
|
||||
return null;
|
||||
}
|
||||
);
|
||||
|
||||
console.log(remapped);
|
||||
// {
|
||||
// …,
|
||||
// sourcesContent: [
|
||||
// 'console.log("Hello world!")',
|
||||
// ],
|
||||
// };
|
||||
```
|
||||
|
||||
### Options
|
||||
|
||||
#### excludeContent
|
||||
|
||||
By default, `excludeContent` is `false`. Passing `{ excludeContent: true }` will exclude the
|
||||
`sourcesContent` field from the returned sourcemap. This is mainly useful when you want to reduce
|
||||
the size out the sourcemap.
|
||||
|
||||
#### decodedMappings
|
||||
|
||||
By default, `decodedMappings` is `false`. Passing `{ decodedMappings: true }` will leave the
|
||||
`mappings` field in a [decoded state](https://github.com/rich-harris/sourcemap-codec) instead of
|
||||
encoding into a VLQ string.
|
||||
+197
@@ -0,0 +1,197 @@
|
||||
import { decodedMappings, traceSegment, TraceMap } from '@jridgewell/trace-mapping';
|
||||
import { GenMapping, maybeAddSegment, setSourceContent, setIgnore, toDecodedMap, toEncodedMap } from '@jridgewell/gen-mapping';
|
||||
|
||||
const SOURCELESS_MAPPING = /* #__PURE__ */ SegmentObject('', -1, -1, '', null, false);
|
||||
const EMPTY_SOURCES = [];
|
||||
function SegmentObject(source, line, column, name, content, ignore) {
|
||||
return { source, line, column, name, content, ignore };
|
||||
}
|
||||
function Source(map, sources, source, content, ignore) {
|
||||
return {
|
||||
map,
|
||||
sources,
|
||||
source,
|
||||
content,
|
||||
ignore,
|
||||
};
|
||||
}
|
||||
/**
|
||||
* MapSource represents a single sourcemap, with the ability to trace mappings into its child nodes
|
||||
* (which may themselves be SourceMapTrees).
|
||||
*/
|
||||
function MapSource(map, sources) {
|
||||
return Source(map, sources, '', null, false);
|
||||
}
|
||||
/**
|
||||
* A "leaf" node in the sourcemap tree, representing an original, unmodified source file. Recursive
|
||||
* segment tracing ends at the `OriginalSource`.
|
||||
*/
|
||||
function OriginalSource(source, content, ignore) {
|
||||
return Source(null, EMPTY_SOURCES, source, content, ignore);
|
||||
}
|
||||
/**
|
||||
* traceMappings is only called on the root level SourceMapTree, and begins the process of
|
||||
* resolving each mapping in terms of the original source files.
|
||||
*/
|
||||
function traceMappings(tree) {
|
||||
// TODO: Eventually support sourceRoot, which has to be removed because the sources are already
|
||||
// fully resolved. We'll need to make sources relative to the sourceRoot before adding them.
|
||||
const gen = new GenMapping({ file: tree.map.file });
|
||||
const { sources: rootSources, map } = tree;
|
||||
const rootNames = map.names;
|
||||
const rootMappings = decodedMappings(map);
|
||||
for (let i = 0; i < rootMappings.length; i++) {
|
||||
const segments = rootMappings[i];
|
||||
for (let j = 0; j < segments.length; j++) {
|
||||
const segment = segments[j];
|
||||
const genCol = segment[0];
|
||||
let traced = SOURCELESS_MAPPING;
|
||||
// 1-length segments only move the current generated column, there's no source information
|
||||
// to gather from it.
|
||||
if (segment.length !== 1) {
|
||||
const source = rootSources[segment[1]];
|
||||
traced = originalPositionFor(source, segment[2], segment[3], segment.length === 5 ? rootNames[segment[4]] : '');
|
||||
// If the trace is invalid, then the trace ran into a sourcemap that doesn't contain a
|
||||
// respective segment into an original source.
|
||||
if (traced == null)
|
||||
continue;
|
||||
}
|
||||
const { column, line, name, content, source, ignore } = traced;
|
||||
maybeAddSegment(gen, i, genCol, source, line, column, name);
|
||||
if (source && content != null)
|
||||
setSourceContent(gen, source, content);
|
||||
if (ignore)
|
||||
setIgnore(gen, source, true);
|
||||
}
|
||||
}
|
||||
return gen;
|
||||
}
|
||||
/**
|
||||
* originalPositionFor is only called on children SourceMapTrees. It recurses down into its own
|
||||
* child SourceMapTrees, until we find the original source map.
|
||||
*/
|
||||
function originalPositionFor(source, line, column, name) {
|
||||
if (!source.map) {
|
||||
return SegmentObject(source.source, line, column, name, source.content, source.ignore);
|
||||
}
|
||||
const segment = traceSegment(source.map, line, column);
|
||||
// If we couldn't find a segment, then this doesn't exist in the sourcemap.
|
||||
if (segment == null)
|
||||
return null;
|
||||
// 1-length segments only move the current generated column, there's no source information
|
||||
// to gather from it.
|
||||
if (segment.length === 1)
|
||||
return SOURCELESS_MAPPING;
|
||||
return originalPositionFor(source.sources[segment[1]], segment[2], segment[3], segment.length === 5 ? source.map.names[segment[4]] : name);
|
||||
}
|
||||
|
||||
function asArray(value) {
|
||||
if (Array.isArray(value))
|
||||
return value;
|
||||
return [value];
|
||||
}
|
||||
/**
|
||||
* Recursively builds a tree structure out of sourcemap files, with each node
|
||||
* being either an `OriginalSource` "leaf" or a `SourceMapTree` composed of
|
||||
* `OriginalSource`s and `SourceMapTree`s.
|
||||
*
|
||||
* Every sourcemap is composed of a collection of source files and mappings
|
||||
* into locations of those source files. When we generate a `SourceMapTree` for
|
||||
* the sourcemap, we attempt to load each source file's own sourcemap. If it
|
||||
* does not have an associated sourcemap, it is considered an original,
|
||||
* unmodified source file.
|
||||
*/
|
||||
function buildSourceMapTree(input, loader) {
|
||||
const maps = asArray(input).map((m) => new TraceMap(m, ''));
|
||||
const map = maps.pop();
|
||||
for (let i = 0; i < maps.length; i++) {
|
||||
if (maps[i].sources.length > 1) {
|
||||
throw new Error(`Transformation map ${i} must have exactly one source file.\n` +
|
||||
'Did you specify these with the most recent transformation maps first?');
|
||||
}
|
||||
}
|
||||
let tree = build(map, loader, '', 0);
|
||||
for (let i = maps.length - 1; i >= 0; i--) {
|
||||
tree = MapSource(maps[i], [tree]);
|
||||
}
|
||||
return tree;
|
||||
}
|
||||
function build(map, loader, importer, importerDepth) {
|
||||
const { resolvedSources, sourcesContent, ignoreList } = map;
|
||||
const depth = importerDepth + 1;
|
||||
const children = resolvedSources.map((sourceFile, i) => {
|
||||
// The loading context gives the loader more information about why this file is being loaded
|
||||
// (eg, from which importer). It also allows the loader to override the location of the loaded
|
||||
// sourcemap/original source, or to override the content in the sourcesContent field if it's
|
||||
// an unmodified source file.
|
||||
const ctx = {
|
||||
importer,
|
||||
depth,
|
||||
source: sourceFile || '',
|
||||
content: undefined,
|
||||
ignore: undefined,
|
||||
};
|
||||
// Use the provided loader callback to retrieve the file's sourcemap.
|
||||
// TODO: We should eventually support async loading of sourcemap files.
|
||||
const sourceMap = loader(ctx.source, ctx);
|
||||
const { source, content, ignore } = ctx;
|
||||
// If there is a sourcemap, then we need to recurse into it to load its source files.
|
||||
if (sourceMap)
|
||||
return build(new TraceMap(sourceMap, source), loader, source, depth);
|
||||
// Else, it's an unmodified source file.
|
||||
// The contents of this unmodified source file can be overridden via the loader context,
|
||||
// allowing it to be explicitly null or a string. If it remains undefined, we fall back to
|
||||
// the importing sourcemap's `sourcesContent` field.
|
||||
const sourceContent = content !== undefined ? content : sourcesContent ? sourcesContent[i] : null;
|
||||
const ignored = ignore !== undefined ? ignore : ignoreList ? ignoreList.includes(i) : false;
|
||||
return OriginalSource(source, sourceContent, ignored);
|
||||
});
|
||||
return MapSource(map, children);
|
||||
}
|
||||
|
||||
/**
|
||||
* A SourceMap v3 compatible sourcemap, which only includes fields that were
|
||||
* provided to it.
|
||||
*/
|
||||
class SourceMap {
|
||||
constructor(map, options) {
|
||||
const out = options.decodedMappings ? toDecodedMap(map) : toEncodedMap(map);
|
||||
this.version = out.version; // SourceMap spec says this should be first.
|
||||
this.file = out.file;
|
||||
this.mappings = out.mappings;
|
||||
this.names = out.names;
|
||||
this.ignoreList = out.ignoreList;
|
||||
this.sourceRoot = out.sourceRoot;
|
||||
this.sources = out.sources;
|
||||
if (!options.excludeContent) {
|
||||
this.sourcesContent = out.sourcesContent;
|
||||
}
|
||||
}
|
||||
toString() {
|
||||
return JSON.stringify(this);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Traces through all the mappings in the root sourcemap, through the sources
|
||||
* (and their sourcemaps), all the way back to the original source location.
|
||||
*
|
||||
* `loader` will be called every time we encounter a source file. If it returns
|
||||
* a sourcemap, we will recurse into that sourcemap to continue the trace. If
|
||||
* it returns a falsey value, that source file is treated as an original,
|
||||
* unmodified source file.
|
||||
*
|
||||
* Pass `excludeContent` to exclude any self-containing source file content
|
||||
* from the output sourcemap.
|
||||
*
|
||||
* Pass `decodedMappings` to receive a SourceMap with decoded (instead of
|
||||
* VLQ encoded) mappings.
|
||||
*/
|
||||
function remapping(input, loader, options) {
|
||||
const opts = typeof options === 'object' ? options : { excludeContent: !!options, decodedMappings: false };
|
||||
const tree = buildSourceMapTree(input, loader);
|
||||
return new SourceMap(traceMappings(tree), opts);
|
||||
}
|
||||
|
||||
export { remapping as default };
|
||||
//# sourceMappingURL=remapping.mjs.map
|
||||
+1
File diff suppressed because one or more lines are too long
+202
@@ -0,0 +1,202 @@
|
||||
(function (global, factory) {
|
||||
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('@jridgewell/trace-mapping'), require('@jridgewell/gen-mapping')) :
|
||||
typeof define === 'function' && define.amd ? define(['@jridgewell/trace-mapping', '@jridgewell/gen-mapping'], factory) :
|
||||
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.remapping = factory(global.traceMapping, global.genMapping));
|
||||
})(this, (function (traceMapping, genMapping) { 'use strict';
|
||||
|
||||
const SOURCELESS_MAPPING = /* #__PURE__ */ SegmentObject('', -1, -1, '', null, false);
|
||||
const EMPTY_SOURCES = [];
|
||||
function SegmentObject(source, line, column, name, content, ignore) {
|
||||
return { source, line, column, name, content, ignore };
|
||||
}
|
||||
function Source(map, sources, source, content, ignore) {
|
||||
return {
|
||||
map,
|
||||
sources,
|
||||
source,
|
||||
content,
|
||||
ignore,
|
||||
};
|
||||
}
|
||||
/**
|
||||
* MapSource represents a single sourcemap, with the ability to trace mappings into its child nodes
|
||||
* (which may themselves be SourceMapTrees).
|
||||
*/
|
||||
function MapSource(map, sources) {
|
||||
return Source(map, sources, '', null, false);
|
||||
}
|
||||
/**
|
||||
* A "leaf" node in the sourcemap tree, representing an original, unmodified source file. Recursive
|
||||
* segment tracing ends at the `OriginalSource`.
|
||||
*/
|
||||
function OriginalSource(source, content, ignore) {
|
||||
return Source(null, EMPTY_SOURCES, source, content, ignore);
|
||||
}
|
||||
/**
|
||||
* traceMappings is only called on the root level SourceMapTree, and begins the process of
|
||||
* resolving each mapping in terms of the original source files.
|
||||
*/
|
||||
function traceMappings(tree) {
|
||||
// TODO: Eventually support sourceRoot, which has to be removed because the sources are already
|
||||
// fully resolved. We'll need to make sources relative to the sourceRoot before adding them.
|
||||
const gen = new genMapping.GenMapping({ file: tree.map.file });
|
||||
const { sources: rootSources, map } = tree;
|
||||
const rootNames = map.names;
|
||||
const rootMappings = traceMapping.decodedMappings(map);
|
||||
for (let i = 0; i < rootMappings.length; i++) {
|
||||
const segments = rootMappings[i];
|
||||
for (let j = 0; j < segments.length; j++) {
|
||||
const segment = segments[j];
|
||||
const genCol = segment[0];
|
||||
let traced = SOURCELESS_MAPPING;
|
||||
// 1-length segments only move the current generated column, there's no source information
|
||||
// to gather from it.
|
||||
if (segment.length !== 1) {
|
||||
const source = rootSources[segment[1]];
|
||||
traced = originalPositionFor(source, segment[2], segment[3], segment.length === 5 ? rootNames[segment[4]] : '');
|
||||
// If the trace is invalid, then the trace ran into a sourcemap that doesn't contain a
|
||||
// respective segment into an original source.
|
||||
if (traced == null)
|
||||
continue;
|
||||
}
|
||||
const { column, line, name, content, source, ignore } = traced;
|
||||
genMapping.maybeAddSegment(gen, i, genCol, source, line, column, name);
|
||||
if (source && content != null)
|
||||
genMapping.setSourceContent(gen, source, content);
|
||||
if (ignore)
|
||||
genMapping.setIgnore(gen, source, true);
|
||||
}
|
||||
}
|
||||
return gen;
|
||||
}
|
||||
/**
|
||||
* originalPositionFor is only called on children SourceMapTrees. It recurses down into its own
|
||||
* child SourceMapTrees, until we find the original source map.
|
||||
*/
|
||||
function originalPositionFor(source, line, column, name) {
|
||||
if (!source.map) {
|
||||
return SegmentObject(source.source, line, column, name, source.content, source.ignore);
|
||||
}
|
||||
const segment = traceMapping.traceSegment(source.map, line, column);
|
||||
// If we couldn't find a segment, then this doesn't exist in the sourcemap.
|
||||
if (segment == null)
|
||||
return null;
|
||||
// 1-length segments only move the current generated column, there's no source information
|
||||
// to gather from it.
|
||||
if (segment.length === 1)
|
||||
return SOURCELESS_MAPPING;
|
||||
return originalPositionFor(source.sources[segment[1]], segment[2], segment[3], segment.length === 5 ? source.map.names[segment[4]] : name);
|
||||
}
|
||||
|
||||
function asArray(value) {
|
||||
if (Array.isArray(value))
|
||||
return value;
|
||||
return [value];
|
||||
}
|
||||
/**
|
||||
* Recursively builds a tree structure out of sourcemap files, with each node
|
||||
* being either an `OriginalSource` "leaf" or a `SourceMapTree` composed of
|
||||
* `OriginalSource`s and `SourceMapTree`s.
|
||||
*
|
||||
* Every sourcemap is composed of a collection of source files and mappings
|
||||
* into locations of those source files. When we generate a `SourceMapTree` for
|
||||
* the sourcemap, we attempt to load each source file's own sourcemap. If it
|
||||
* does not have an associated sourcemap, it is considered an original,
|
||||
* unmodified source file.
|
||||
*/
|
||||
function buildSourceMapTree(input, loader) {
|
||||
const maps = asArray(input).map((m) => new traceMapping.TraceMap(m, ''));
|
||||
const map = maps.pop();
|
||||
for (let i = 0; i < maps.length; i++) {
|
||||
if (maps[i].sources.length > 1) {
|
||||
throw new Error(`Transformation map ${i} must have exactly one source file.\n` +
|
||||
'Did you specify these with the most recent transformation maps first?');
|
||||
}
|
||||
}
|
||||
let tree = build(map, loader, '', 0);
|
||||
for (let i = maps.length - 1; i >= 0; i--) {
|
||||
tree = MapSource(maps[i], [tree]);
|
||||
}
|
||||
return tree;
|
||||
}
|
||||
function build(map, loader, importer, importerDepth) {
|
||||
const { resolvedSources, sourcesContent, ignoreList } = map;
|
||||
const depth = importerDepth + 1;
|
||||
const children = resolvedSources.map((sourceFile, i) => {
|
||||
// The loading context gives the loader more information about why this file is being loaded
|
||||
// (eg, from which importer). It also allows the loader to override the location of the loaded
|
||||
// sourcemap/original source, or to override the content in the sourcesContent field if it's
|
||||
// an unmodified source file.
|
||||
const ctx = {
|
||||
importer,
|
||||
depth,
|
||||
source: sourceFile || '',
|
||||
content: undefined,
|
||||
ignore: undefined,
|
||||
};
|
||||
// Use the provided loader callback to retrieve the file's sourcemap.
|
||||
// TODO: We should eventually support async loading of sourcemap files.
|
||||
const sourceMap = loader(ctx.source, ctx);
|
||||
const { source, content, ignore } = ctx;
|
||||
// If there is a sourcemap, then we need to recurse into it to load its source files.
|
||||
if (sourceMap)
|
||||
return build(new traceMapping.TraceMap(sourceMap, source), loader, source, depth);
|
||||
// Else, it's an unmodified source file.
|
||||
// The contents of this unmodified source file can be overridden via the loader context,
|
||||
// allowing it to be explicitly null or a string. If it remains undefined, we fall back to
|
||||
// the importing sourcemap's `sourcesContent` field.
|
||||
const sourceContent = content !== undefined ? content : sourcesContent ? sourcesContent[i] : null;
|
||||
const ignored = ignore !== undefined ? ignore : ignoreList ? ignoreList.includes(i) : false;
|
||||
return OriginalSource(source, sourceContent, ignored);
|
||||
});
|
||||
return MapSource(map, children);
|
||||
}
|
||||
|
||||
/**
|
||||
* A SourceMap v3 compatible sourcemap, which only includes fields that were
|
||||
* provided to it.
|
||||
*/
|
||||
class SourceMap {
|
||||
constructor(map, options) {
|
||||
const out = options.decodedMappings ? genMapping.toDecodedMap(map) : genMapping.toEncodedMap(map);
|
||||
this.version = out.version; // SourceMap spec says this should be first.
|
||||
this.file = out.file;
|
||||
this.mappings = out.mappings;
|
||||
this.names = out.names;
|
||||
this.ignoreList = out.ignoreList;
|
||||
this.sourceRoot = out.sourceRoot;
|
||||
this.sources = out.sources;
|
||||
if (!options.excludeContent) {
|
||||
this.sourcesContent = out.sourcesContent;
|
||||
}
|
||||
}
|
||||
toString() {
|
||||
return JSON.stringify(this);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Traces through all the mappings in the root sourcemap, through the sources
|
||||
* (and their sourcemaps), all the way back to the original source location.
|
||||
*
|
||||
* `loader` will be called every time we encounter a source file. If it returns
|
||||
* a sourcemap, we will recurse into that sourcemap to continue the trace. If
|
||||
* it returns a falsey value, that source file is treated as an original,
|
||||
* unmodified source file.
|
||||
*
|
||||
* Pass `excludeContent` to exclude any self-containing source file content
|
||||
* from the output sourcemap.
|
||||
*
|
||||
* Pass `decodedMappings` to receive a SourceMap with decoded (instead of
|
||||
* VLQ encoded) mappings.
|
||||
*/
|
||||
function remapping(input, loader, options) {
|
||||
const opts = typeof options === 'object' ? options : { excludeContent: !!options, decodedMappings: false };
|
||||
const tree = buildSourceMapTree(input, loader);
|
||||
return new SourceMap(traceMappings(tree), opts);
|
||||
}
|
||||
|
||||
return remapping;
|
||||
|
||||
}));
|
||||
//# sourceMappingURL=remapping.umd.js.map
|
||||
+1
File diff suppressed because one or more lines are too long
+14
@@ -0,0 +1,14 @@
|
||||
import type { MapSource as MapSourceType } from './source-map-tree';
|
||||
import type { SourceMapInput, SourceMapLoader } from './types';
|
||||
/**
|
||||
* Recursively builds a tree structure out of sourcemap files, with each node
|
||||
* being either an `OriginalSource` "leaf" or a `SourceMapTree` composed of
|
||||
* `OriginalSource`s and `SourceMapTree`s.
|
||||
*
|
||||
* Every sourcemap is composed of a collection of source files and mappings
|
||||
* into locations of those source files. When we generate a `SourceMapTree` for
|
||||
* the sourcemap, we attempt to load each source file's own sourcemap. If it
|
||||
* does not have an associated sourcemap, it is considered an original,
|
||||
* unmodified source file.
|
||||
*/
|
||||
export default function buildSourceMapTree(input: SourceMapInput | SourceMapInput[], loader: SourceMapLoader): MapSourceType;
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
import SourceMap from './source-map';
|
||||
import type { SourceMapInput, SourceMapLoader, Options } from './types';
|
||||
export type { SourceMapSegment, EncodedSourceMap, EncodedSourceMap as RawSourceMap, DecodedSourceMap, SourceMapInput, SourceMapLoader, LoaderContext, Options, } from './types';
|
||||
export type { SourceMap };
|
||||
/**
|
||||
* Traces through all the mappings in the root sourcemap, through the sources
|
||||
* (and their sourcemaps), all the way back to the original source location.
|
||||
*
|
||||
* `loader` will be called every time we encounter a source file. If it returns
|
||||
* a sourcemap, we will recurse into that sourcemap to continue the trace. If
|
||||
* it returns a falsey value, that source file is treated as an original,
|
||||
* unmodified source file.
|
||||
*
|
||||
* Pass `excludeContent` to exclude any self-containing source file content
|
||||
* from the output sourcemap.
|
||||
*
|
||||
* Pass `decodedMappings` to receive a SourceMap with decoded (instead of
|
||||
* VLQ encoded) mappings.
|
||||
*/
|
||||
export default function remapping(input: SourceMapInput | SourceMapInput[], loader: SourceMapLoader, options?: boolean | Options): SourceMap;
|
||||
+45
@@ -0,0 +1,45 @@
|
||||
import { GenMapping } from '@jridgewell/gen-mapping';
|
||||
import type { TraceMap } from '@jridgewell/trace-mapping';
|
||||
export declare type SourceMapSegmentObject = {
|
||||
column: number;
|
||||
line: number;
|
||||
name: string;
|
||||
source: string;
|
||||
content: string | null;
|
||||
ignore: boolean;
|
||||
};
|
||||
export declare type OriginalSource = {
|
||||
map: null;
|
||||
sources: Sources[];
|
||||
source: string;
|
||||
content: string | null;
|
||||
ignore: boolean;
|
||||
};
|
||||
export declare type MapSource = {
|
||||
map: TraceMap;
|
||||
sources: Sources[];
|
||||
source: string;
|
||||
content: null;
|
||||
ignore: false;
|
||||
};
|
||||
export declare type Sources = OriginalSource | MapSource;
|
||||
/**
|
||||
* MapSource represents a single sourcemap, with the ability to trace mappings into its child nodes
|
||||
* (which may themselves be SourceMapTrees).
|
||||
*/
|
||||
export declare function MapSource(map: TraceMap, sources: Sources[]): MapSource;
|
||||
/**
|
||||
* A "leaf" node in the sourcemap tree, representing an original, unmodified source file. Recursive
|
||||
* segment tracing ends at the `OriginalSource`.
|
||||
*/
|
||||
export declare function OriginalSource(source: string, content: string | null, ignore: boolean): OriginalSource;
|
||||
/**
|
||||
* traceMappings is only called on the root level SourceMapTree, and begins the process of
|
||||
* resolving each mapping in terms of the original source files.
|
||||
*/
|
||||
export declare function traceMappings(tree: MapSource): GenMapping;
|
||||
/**
|
||||
* originalPositionFor is only called on children SourceMapTrees. It recurses down into its own
|
||||
* child SourceMapTrees, until we find the original source map.
|
||||
*/
|
||||
export declare function originalPositionFor(source: Sources, line: number, column: number, name: string): SourceMapSegmentObject | null;
|
||||
+18
@@ -0,0 +1,18 @@
|
||||
import type { GenMapping } from '@jridgewell/gen-mapping';
|
||||
import type { DecodedSourceMap, EncodedSourceMap, Options } from './types';
|
||||
/**
|
||||
* A SourceMap v3 compatible sourcemap, which only includes fields that were
|
||||
* provided to it.
|
||||
*/
|
||||
export default class SourceMap {
|
||||
file?: string | null;
|
||||
mappings: EncodedSourceMap['mappings'] | DecodedSourceMap['mappings'];
|
||||
sourceRoot?: string;
|
||||
names: string[];
|
||||
sources: (string | null)[];
|
||||
sourcesContent?: (string | null)[];
|
||||
version: 3;
|
||||
ignoreList: number[] | undefined;
|
||||
constructor(map: GenMapping, options: Options);
|
||||
toString(): string;
|
||||
}
|
||||
+15
@@ -0,0 +1,15 @@
|
||||
import type { SourceMapInput } from '@jridgewell/trace-mapping';
|
||||
export type { SourceMapSegment, DecodedSourceMap, EncodedSourceMap, } from '@jridgewell/trace-mapping';
|
||||
export type { SourceMapInput };
|
||||
export declare type LoaderContext = {
|
||||
readonly importer: string;
|
||||
readonly depth: number;
|
||||
source: string;
|
||||
content: string | null | undefined;
|
||||
ignore: boolean | undefined;
|
||||
};
|
||||
export declare type SourceMapLoader = (file: string, ctx: LoaderContext) => SourceMapInput | null | undefined | void;
|
||||
export declare type Options = {
|
||||
excludeContent?: boolean;
|
||||
decodedMappings?: boolean;
|
||||
};
|
||||
+75
@@ -0,0 +1,75 @@
|
||||
{
|
||||
"name": "@ampproject/remapping",
|
||||
"version": "2.3.0",
|
||||
"description": "Remap sequential sourcemaps through transformations to point at the original source code",
|
||||
"keywords": [
|
||||
"source",
|
||||
"map",
|
||||
"remap"
|
||||
],
|
||||
"main": "dist/remapping.umd.js",
|
||||
"module": "dist/remapping.mjs",
|
||||
"types": "dist/types/remapping.d.ts",
|
||||
"exports": {
|
||||
".": [
|
||||
{
|
||||
"types": "./dist/types/remapping.d.ts",
|
||||
"browser": "./dist/remapping.umd.js",
|
||||
"require": "./dist/remapping.umd.js",
|
||||
"import": "./dist/remapping.mjs"
|
||||
},
|
||||
"./dist/remapping.umd.js"
|
||||
],
|
||||
"./package.json": "./package.json"
|
||||
},
|
||||
"files": [
|
||||
"dist"
|
||||
],
|
||||
"author": "Justin Ridgewell <jridgewell@google.com>",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git+https://github.com/ampproject/remapping.git"
|
||||
},
|
||||
"license": "Apache-2.0",
|
||||
"engines": {
|
||||
"node": ">=6.0.0"
|
||||
},
|
||||
"scripts": {
|
||||
"build": "run-s -n build:*",
|
||||
"build:rollup": "rollup -c rollup.config.js",
|
||||
"build:ts": "tsc --project tsconfig.build.json",
|
||||
"lint": "run-s -n lint:*",
|
||||
"lint:prettier": "npm run test:lint:prettier -- --write",
|
||||
"lint:ts": "npm run test:lint:ts -- --fix",
|
||||
"prebuild": "rm -rf dist",
|
||||
"prepublishOnly": "npm run preversion",
|
||||
"preversion": "run-s test build",
|
||||
"test": "run-s -n test:lint test:only",
|
||||
"test:debug": "node --inspect-brk node_modules/.bin/jest --runInBand",
|
||||
"test:lint": "run-s -n test:lint:*",
|
||||
"test:lint:prettier": "prettier --check '{src,test}/**/*.ts'",
|
||||
"test:lint:ts": "eslint '{src,test}/**/*.ts'",
|
||||
"test:only": "jest --coverage",
|
||||
"test:watch": "jest --coverage --watch"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@rollup/plugin-typescript": "8.3.2",
|
||||
"@types/jest": "27.4.1",
|
||||
"@typescript-eslint/eslint-plugin": "5.20.0",
|
||||
"@typescript-eslint/parser": "5.20.0",
|
||||
"eslint": "8.14.0",
|
||||
"eslint-config-prettier": "8.5.0",
|
||||
"jest": "27.5.1",
|
||||
"jest-config": "27.5.1",
|
||||
"npm-run-all": "4.1.5",
|
||||
"prettier": "2.6.2",
|
||||
"rollup": "2.70.2",
|
||||
"ts-jest": "27.1.4",
|
||||
"tslib": "2.4.0",
|
||||
"typescript": "4.6.3"
|
||||
},
|
||||
"dependencies": {
|
||||
"@jridgewell/gen-mapping": "^0.3.5",
|
||||
"@jridgewell/trace-mapping": "^0.3.24"
|
||||
}
|
||||
}
|
||||
+8
@@ -0,0 +1,8 @@
|
||||
# Changesets
|
||||
|
||||
Hello and welcome! This folder has been automatically generated by `@changesets/cli`, a build tool that works
|
||||
with multi-package repos, or single-package repos to help you version and publish your code. You can
|
||||
find the full documentation for it [in our repository](https://github.com/changesets/changesets)
|
||||
|
||||
We have a quick list of common questions to get you started engaging with this project in
|
||||
[our documentation](https://github.com/changesets/changesets/blob/main/docs/common-questions.md)
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
{
|
||||
"$schema": "https://unpkg.com/@changesets/config@2.2.0/schema.json",
|
||||
"changelog": [
|
||||
"@changesets/changelog-github",
|
||||
{ "repo": "apollographql/apollo-client" }
|
||||
],
|
||||
"commit": false,
|
||||
"fixed": [],
|
||||
"linked": [],
|
||||
"access": "public",
|
||||
"baseBranch": "main",
|
||||
"updateInternalDependencies": "patch",
|
||||
"ignore": []
|
||||
}
|
||||
+4719
File diff suppressed because it is too large
Load Diff
+22
@@ -0,0 +1,22 @@
|
||||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2022 Apollo Graph, Inc. (Formerly Meteor Development Group, Inc.)
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
|
||||
+57
@@ -0,0 +1,57 @@
|
||||
<div align="center">
|
||||
|
||||
<p>
|
||||
<a href="https://www.apollographql.com/"><img src="https://raw.githubusercontent.com/apollographql/apollo-client-devtools/main/assets/apollo-wordmark.svg" height="100" alt="Apollo Client"></a>
|
||||
</p>
|
||||
<h1>Apollo Client</h1>
|
||||
|
||||
[](https://badge.fury.io/js/%40apollo%2Fclient) [](https://circleci.com/gh/apollographql/apollo-client) [](https://community.apollographql.com)
|
||||
|
||||
</div>
|
||||
|
||||
---
|
||||
|
||||
**Announcement:**
|
||||
Join 1000+ engineers at GraphQL Summit 2025 by Apollo for talks, workshops, and office hours. Oct 6-8, 2025 in San Francisco. [Get your pass here ->](https://www.apollographql.com/graphql-summit-2025?utm_campaign=2025-03-04_graphql-summit-github-announcement&utm_medium=github&utm_source=apollo-server)
|
||||
|
||||
---
|
||||
|
||||
Apollo Client is a fully-featured caching GraphQL client with integrations for React, Angular, and more. It allows you to easily build UI components that fetch data via GraphQL.
|
||||
|
||||
Apollo Client aims to comply with the [Working Draft of the GraphQL specification](https://spec.graphql.org/draft/).
|
||||
|
||||
| ☑️ Apollo Client User Survey |
|
||||
| :----- |
|
||||
| What do you like best about Apollo Client? What needs to be improved? Please tell us by taking a [one-minute survey](https://docs.google.com/forms/d/e/1FAIpQLSczNDXfJne3ZUOXjk9Ursm9JYvhTh1_nFTDfdq3XBAFWCzplQ/viewform?usp=pp_url&entry.1170701325=Apollo+Client&entry.204965213=Readme). Your responses will help us understand Apollo Client usage and allow us to serve you better. |
|
||||
|
||||
## Documentation
|
||||
|
||||
All Apollo Client documentation, including React integration articles and helpful recipes, can be found at: <br/>
|
||||
[https://www.apollographql.com/docs/react/](https://www.apollographql.com/docs/react/)
|
||||
|
||||
The Apollo Client API reference can be found at: <br/>
|
||||
[https://www.apollographql.com/docs/react/api/apollo-client/](https://www.apollographql.com/docs/react/api/apollo-client/)
|
||||
|
||||
Learn how to use Apollo Client with self-paced hands-on training on Odyssey, Apollo's official learning platform: <br/>
|
||||
[https://odyssey.apollographql.com/](https://odyssey.apollographql.com/)
|
||||
|
||||
## Maintainers
|
||||
|
||||
|Name|Username|
|
||||
|---|---|
|
||||
|Jeff Auriemma|[@bignimbus](https://github.com/bignimbus)|
|
||||
|Jerel Miller|[@jerelmiller](https://github.com/jerelmiller)|
|
||||
|Lenz Weber-Tronic|[@phryneas](https://github.com/phryneas)|
|
||||
|
||||
## Who is Apollo?
|
||||
|
||||
[Apollo](https://apollographql.com/) builds open-source tools and commercial services to make application development easier, better, and accessible to more people. We help you ship faster with:
|
||||
|
||||
- [GraphOS](https://www.apollographql.com/graphos) - The platform for building, managing, and scaling a supergraph: a unified network of your organization's microservices and their data sources—all composed into a single distributed API.
|
||||
- [Apollo Federation](https://www.apollographql.com/federation) – The industry-standard open architecture for building a distributed graph. Use Apollo’s gateway to compose a unified graph from multiple subgraphs, determine a query plan, and route requests across your services.
|
||||
- [Apollo Client](https://github.com/apollographql/apollo-client) – The most popular GraphQL client for the web. Apollo also builds and maintains [Apollo iOS](https://github.com/apollographql/apollo-ios) and [Apollo Kotlin](https://github.com/apollographql/apollo-kotlin).
|
||||
- [Apollo Server](https://github.com/apollographql/apollo-server) – A production-ready JavaScript GraphQL server that connects to any microservice, API, or database. Compatible with all popular JavaScript frameworks and deployable in serverless environments.
|
||||
|
||||
## Learn how to build with Apollo
|
||||
|
||||
Check out the [Odyssey](https://odyssey.apollographql.com/) learning platform, the perfect place to start your GraphQL journey with videos and interactive code challenges. Join the [Apollo Community](https://community.apollographql.com/) to interact with and get technical help from the GraphQL community.
|
||||
+9474
File diff suppressed because it is too large
Load Diff
+1
File diff suppressed because one or more lines are too long
+1
File diff suppressed because one or more lines are too long
+2691
File diff suppressed because it is too large
Load Diff
+1
File diff suppressed because one or more lines are too long
+2691
File diff suppressed because it is too large
Load Diff
+1
@@ -0,0 +1 @@
|
||||
export * from "./index.d.ts";
|
||||
+126
@@ -0,0 +1,126 @@
|
||||
import type { DocumentNode, FragmentDefinitionNode, InlineFragmentNode } from "graphql";
|
||||
import type { StoreObject, Reference, DeepPartial, NoInfer } from "../../utilities/index.js";
|
||||
import { Observable } from "../../utilities/index.js";
|
||||
import type { DataProxy } from "./types/DataProxy.js";
|
||||
import type { Cache } from "./types/Cache.js";
|
||||
import { getApolloCacheMemoryInternals } from "../../utilities/caching/getMemoryInternals.js";
|
||||
import type { OperationVariables, TypedDocumentNode } from "../../core/types.js";
|
||||
import type { MissingTree } from "./types/common.js";
|
||||
import type { FragmentType, MaybeMasked, Unmasked } from "../../masking/index.js";
|
||||
export type Transaction<T> = (c: ApolloCache<T>) => void;
|
||||
/**
|
||||
* Watched fragment options.
|
||||
*/
|
||||
export interface WatchFragmentOptions<TData, TVars> {
|
||||
/**
|
||||
* A GraphQL fragment document parsed into an AST with the `gql`
|
||||
* template literal.
|
||||
*
|
||||
* @docGroup 1. Required options
|
||||
*/
|
||||
fragment: DocumentNode | TypedDocumentNode<TData, TVars>;
|
||||
/**
|
||||
* An object containing a `__typename` and primary key fields
|
||||
* (such as `id`) identifying the entity object from which the fragment will
|
||||
* be retrieved, or a `{ __ref: "..." }` reference, or a `string` ID
|
||||
* (uncommon).
|
||||
*
|
||||
* @docGroup 1. Required options
|
||||
*/
|
||||
from: StoreObject | Reference | FragmentType<NoInfer<TData>> | string;
|
||||
/**
|
||||
* Any variables that the GraphQL fragment may depend on.
|
||||
*
|
||||
* @docGroup 2. Cache options
|
||||
*/
|
||||
variables?: TVars;
|
||||
/**
|
||||
* The name of the fragment defined in the fragment document.
|
||||
*
|
||||
* Required if the fragment document includes more than one fragment,
|
||||
* optional otherwise.
|
||||
*
|
||||
* @docGroup 2. Cache options
|
||||
*/
|
||||
fragmentName?: string;
|
||||
/**
|
||||
* If `true`, `watchFragment` returns optimistic results.
|
||||
*
|
||||
* The default value is `true`.
|
||||
*
|
||||
* @docGroup 2. Cache options
|
||||
*/
|
||||
optimistic?: boolean;
|
||||
}
|
||||
/**
|
||||
* Watched fragment results.
|
||||
*/
|
||||
export type WatchFragmentResult<TData> = {
|
||||
data: MaybeMasked<TData>;
|
||||
complete: true;
|
||||
missing?: never;
|
||||
} | {
|
||||
data: DeepPartial<MaybeMasked<TData>>;
|
||||
complete: false;
|
||||
missing: MissingTree;
|
||||
};
|
||||
export declare abstract class ApolloCache<TSerialized> implements DataProxy {
|
||||
readonly assumeImmutableResults: boolean;
|
||||
abstract read<TData = any, TVariables = any>(query: Cache.ReadOptions<TVariables, TData>): Unmasked<TData> | null;
|
||||
abstract write<TData = any, TVariables = any>(write: Cache.WriteOptions<TData, TVariables>): Reference | undefined;
|
||||
abstract diff<T>(query: Cache.DiffOptions): Cache.DiffResult<T>;
|
||||
abstract watch<TData = any, TVariables = any>(watch: Cache.WatchOptions<TData, TVariables>): () => void;
|
||||
abstract reset(options?: Cache.ResetOptions): Promise<void>;
|
||||
abstract evict(options: Cache.EvictOptions): boolean;
|
||||
/**
|
||||
* Replaces existing state in the cache (if any) with the values expressed by
|
||||
* `serializedState`.
|
||||
*
|
||||
* Called when hydrating a cache (server side rendering, or offline storage),
|
||||
* and also (potentially) during hot reloads.
|
||||
*/
|
||||
abstract restore(serializedState: TSerialized): ApolloCache<TSerialized>;
|
||||
/**
|
||||
* Exposes the cache's complete state, in a serializable format for later restoration.
|
||||
*/
|
||||
abstract extract(optimistic?: boolean): TSerialized;
|
||||
abstract removeOptimistic(id: string): void;
|
||||
fragmentMatches?(fragment: InlineFragmentNode, typename: string): boolean;
|
||||
lookupFragment(fragmentName: string): FragmentDefinitionNode | null;
|
||||
batch<U>(options: Cache.BatchOptions<this, U>): U;
|
||||
abstract performTransaction(transaction: Transaction<TSerialized>, optimisticId?: string | null): void;
|
||||
recordOptimisticTransaction(transaction: Transaction<TSerialized>, optimisticId: string): void;
|
||||
transformDocument(document: DocumentNode): DocumentNode;
|
||||
transformForLink(document: DocumentNode): DocumentNode;
|
||||
identify(object: StoreObject | Reference): string | undefined;
|
||||
gc(): string[];
|
||||
modify<Entity extends Record<string, any> = Record<string, any>>(options: Cache.ModifyOptions<Entity>): boolean;
|
||||
readQuery<QueryType, TVariables = any>(options: Cache.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): Unmasked<QueryType> | null;
|
||||
/**
|
||||
* Watches the cache store of the fragment according to the options specified and returns an `Observable`. We can subscribe to this `Observable` and receive updated results through an observer when the cache store changes.
|
||||
*
|
||||
* You must pass in a GraphQL document with a single fragment or a document with multiple fragments that represent what you are reading. If you pass in a document with multiple fragments then you must also specify a `fragmentName`.
|
||||
*
|
||||
* @param options - An object of type `WatchFragmentOptions` that allows the cache to identify the fragment and optionally specify whether to react to optimistic updates.
|
||||
*
|
||||
* @since
|
||||
*
|
||||
* 3.10.0
|
||||
*/
|
||||
watchFragment<TData = any, TVars = OperationVariables>(options: WatchFragmentOptions<TData, TVars>): Observable<WatchFragmentResult<TData>>;
|
||||
private getFragmentDoc;
|
||||
readFragment<FragmentType, TVariables = any>(options: Cache.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): Unmasked<FragmentType> | null;
|
||||
writeQuery<TData = any, TVariables = any>({ id, data, ...options }: Cache.WriteQueryOptions<TData, TVariables>): Reference | undefined;
|
||||
writeFragment<TData = any, TVariables = any>({ id, data, fragment, fragmentName, ...options }: Cache.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
|
||||
updateQuery<TData = any, TVariables = any>(options: Cache.UpdateQueryOptions<TData, TVariables>, update: (data: Unmasked<TData> | null) => Unmasked<TData> | null | void): Unmasked<TData> | null;
|
||||
updateFragment<TData = any, TVariables = any>(options: Cache.UpdateFragmentOptions<TData, TVariables>, update: (data: Unmasked<TData> | null) => Unmasked<TData> | null | void): Unmasked<TData> | null;
|
||||
/**
|
||||
* @experimental
|
||||
* @internal
|
||||
* This is not a stable API - it is used in development builds to expose
|
||||
* information to the DevTools.
|
||||
* Use at your own risk!
|
||||
*/
|
||||
getMemoryInternals?: typeof getApolloCacheMemoryInternals;
|
||||
}
|
||||
//# sourceMappingURL=cache.d.ts.map
|
||||
+167
@@ -0,0 +1,167 @@
|
||||
import { __assign, __rest } from "tslib";
|
||||
import { wrap } from "optimism";
|
||||
import { Observable, cacheSizes, getFragmentDefinition, getFragmentQueryDocument, mergeDeepArray, } from "../../utilities/index.js";
|
||||
import { WeakCache } from "@wry/caches";
|
||||
import { getApolloCacheMemoryInternals } from "../../utilities/caching/getMemoryInternals.js";
|
||||
import { equalByQuery } from "../../core/equalByQuery.js";
|
||||
import { invariant } from "../../utilities/globals/index.js";
|
||||
import { maskFragment } from "../../masking/index.js";
|
||||
var ApolloCache = /** @class */ (function () {
|
||||
function ApolloCache() {
|
||||
this.assumeImmutableResults = false;
|
||||
// Make sure we compute the same (===) fragment query document every
|
||||
// time we receive the same fragment in readFragment.
|
||||
this.getFragmentDoc = wrap(getFragmentQueryDocument, {
|
||||
max: cacheSizes["cache.fragmentQueryDocuments"] ||
|
||||
1000 /* defaultCacheSizes["cache.fragmentQueryDocuments"] */,
|
||||
cache: WeakCache,
|
||||
});
|
||||
}
|
||||
// Function used to lookup a fragment when a fragment definition is not part
|
||||
// of the GraphQL document. This is useful for caches, such as InMemoryCache,
|
||||
// that register fragments ahead of time so they can be referenced by name.
|
||||
ApolloCache.prototype.lookupFragment = function (fragmentName) {
|
||||
return null;
|
||||
};
|
||||
// Transactional API
|
||||
// The batch method is intended to replace/subsume both performTransaction
|
||||
// and recordOptimisticTransaction, but performTransaction came first, so we
|
||||
// provide a default batch implementation that's just another way of calling
|
||||
// performTransaction. Subclasses of ApolloCache (such as InMemoryCache) can
|
||||
// override the batch method to do more interesting things with its options.
|
||||
ApolloCache.prototype.batch = function (options) {
|
||||
var _this = this;
|
||||
var optimisticId = typeof options.optimistic === "string" ? options.optimistic
|
||||
: options.optimistic === false ? null
|
||||
: void 0;
|
||||
var updateResult;
|
||||
this.performTransaction(function () { return (updateResult = options.update(_this)); }, optimisticId);
|
||||
return updateResult;
|
||||
};
|
||||
ApolloCache.prototype.recordOptimisticTransaction = function (transaction, optimisticId) {
|
||||
this.performTransaction(transaction, optimisticId);
|
||||
};
|
||||
// Optional API
|
||||
// Called once per input document, allowing the cache to make static changes
|
||||
// to the query, such as adding __typename fields.
|
||||
ApolloCache.prototype.transformDocument = function (document) {
|
||||
return document;
|
||||
};
|
||||
// Called before each ApolloLink request, allowing the cache to make dynamic
|
||||
// changes to the query, such as filling in missing fragment definitions.
|
||||
ApolloCache.prototype.transformForLink = function (document) {
|
||||
return document;
|
||||
};
|
||||
ApolloCache.prototype.identify = function (object) {
|
||||
return;
|
||||
};
|
||||
ApolloCache.prototype.gc = function () {
|
||||
return [];
|
||||
};
|
||||
ApolloCache.prototype.modify = function (options) {
|
||||
return false;
|
||||
};
|
||||
// DataProxy API
|
||||
ApolloCache.prototype.readQuery = function (options, optimistic) {
|
||||
if (optimistic === void 0) { optimistic = !!options.optimistic; }
|
||||
return this.read(__assign(__assign({}, options), { rootId: options.id || "ROOT_QUERY", optimistic: optimistic }));
|
||||
};
|
||||
/** {@inheritDoc @apollo/client!ApolloClient#watchFragment:member(1)} */
|
||||
ApolloCache.prototype.watchFragment = function (options) {
|
||||
var _this = this;
|
||||
var fragment = options.fragment, fragmentName = options.fragmentName, from = options.from, _a = options.optimistic, optimistic = _a === void 0 ? true : _a, otherOptions = __rest(options, ["fragment", "fragmentName", "from", "optimistic"]);
|
||||
var query = this.getFragmentDoc(fragment, fragmentName);
|
||||
// While our TypeScript types do not allow for `undefined` as a valid
|
||||
// `from`, its possible `useFragment` gives us an `undefined` since it
|
||||
// calls` cache.identify` and provides that value to `from`. We are
|
||||
// adding this fix here however to ensure those using plain JavaScript
|
||||
// and using `cache.identify` themselves will avoid seeing the obscure
|
||||
// warning.
|
||||
var id = typeof from === "undefined" || typeof from === "string" ?
|
||||
from
|
||||
: this.identify(from);
|
||||
var dataMasking = !!options[Symbol.for("apollo.dataMasking")];
|
||||
if (globalThis.__DEV__ !== false) {
|
||||
var actualFragmentName = fragmentName || getFragmentDefinition(fragment).name.value;
|
||||
if (!id) {
|
||||
globalThis.__DEV__ !== false && invariant.warn(1, actualFragmentName);
|
||||
}
|
||||
}
|
||||
var diffOptions = __assign(__assign({}, otherOptions), { returnPartialData: true, id: id, query: query, optimistic: optimistic });
|
||||
var latestDiff;
|
||||
return new Observable(function (observer) {
|
||||
return _this.watch(__assign(__assign({}, diffOptions), { immediate: true, callback: function (diff) {
|
||||
var data = dataMasking ?
|
||||
maskFragment(diff.result, fragment, _this, fragmentName)
|
||||
: diff.result;
|
||||
if (
|
||||
// Always ensure we deliver the first result
|
||||
latestDiff &&
|
||||
equalByQuery(query, { data: latestDiff.result }, { data: data },
|
||||
// TODO: Fix the type on WatchFragmentOptions so that TVars
|
||||
// extends OperationVariables
|
||||
options.variables)) {
|
||||
return;
|
||||
}
|
||||
var result = {
|
||||
data: data,
|
||||
complete: !!diff.complete,
|
||||
};
|
||||
if (diff.missing) {
|
||||
result.missing = mergeDeepArray(diff.missing.map(function (error) { return error.missing; }));
|
||||
}
|
||||
latestDiff = __assign(__assign({}, diff), { result: data });
|
||||
observer.next(result);
|
||||
} }));
|
||||
});
|
||||
};
|
||||
ApolloCache.prototype.readFragment = function (options, optimistic) {
|
||||
if (optimistic === void 0) { optimistic = !!options.optimistic; }
|
||||
return this.read(__assign(__assign({}, options), { query: this.getFragmentDoc(options.fragment, options.fragmentName), rootId: options.id, optimistic: optimistic }));
|
||||
};
|
||||
ApolloCache.prototype.writeQuery = function (_a) {
|
||||
var id = _a.id, data = _a.data, options = __rest(_a, ["id", "data"]);
|
||||
return this.write(Object.assign(options, {
|
||||
dataId: id || "ROOT_QUERY",
|
||||
result: data,
|
||||
}));
|
||||
};
|
||||
ApolloCache.prototype.writeFragment = function (_a) {
|
||||
var id = _a.id, data = _a.data, fragment = _a.fragment, fragmentName = _a.fragmentName, options = __rest(_a, ["id", "data", "fragment", "fragmentName"]);
|
||||
return this.write(Object.assign(options, {
|
||||
query: this.getFragmentDoc(fragment, fragmentName),
|
||||
dataId: id,
|
||||
result: data,
|
||||
}));
|
||||
};
|
||||
ApolloCache.prototype.updateQuery = function (options, update) {
|
||||
return this.batch({
|
||||
update: function (cache) {
|
||||
var value = cache.readQuery(options);
|
||||
var data = update(value);
|
||||
if (data === void 0 || data === null)
|
||||
return value;
|
||||
cache.writeQuery(__assign(__assign({}, options), { data: data }));
|
||||
return data;
|
||||
},
|
||||
});
|
||||
};
|
||||
ApolloCache.prototype.updateFragment = function (options, update) {
|
||||
return this.batch({
|
||||
update: function (cache) {
|
||||
var value = cache.readFragment(options);
|
||||
var data = update(value);
|
||||
if (data === void 0 || data === null)
|
||||
return value;
|
||||
cache.writeFragment(__assign(__assign({}, options), { data: data }));
|
||||
return data;
|
||||
},
|
||||
});
|
||||
};
|
||||
return ApolloCache;
|
||||
}());
|
||||
export { ApolloCache };
|
||||
if (globalThis.__DEV__ !== false) {
|
||||
ApolloCache.prototype.getMemoryInternals = getApolloCacheMemoryInternals;
|
||||
}
|
||||
//# sourceMappingURL=cache.js.map
|
||||
+1
File diff suppressed because one or more lines are too long
+63
@@ -0,0 +1,63 @@
|
||||
import { DataProxy } from "./DataProxy.js";
|
||||
import type { AllFieldsModifier, Modifiers } from "./common.js";
|
||||
import type { ApolloCache } from "../cache.js";
|
||||
import type { Unmasked } from "../../../masking/index.js";
|
||||
export declare namespace Cache {
|
||||
type WatchCallback<TData = any> = (diff: Cache.DiffResult<TData>, lastDiff?: Cache.DiffResult<TData>) => void;
|
||||
interface ReadOptions<TVariables = any, TData = any> extends DataProxy.Query<TVariables, TData> {
|
||||
rootId?: string;
|
||||
previousResult?: any;
|
||||
optimistic: boolean;
|
||||
returnPartialData?: boolean;
|
||||
/**
|
||||
* @deprecated
|
||||
* Using `canonizeResults` can result in memory leaks so we generally do not
|
||||
* recommend using this option anymore.
|
||||
* A future version of Apollo Client will contain a similar feature without
|
||||
* the risk of memory leaks.
|
||||
*/
|
||||
canonizeResults?: boolean;
|
||||
}
|
||||
interface WriteOptions<TResult = any, TVariables = any> extends Omit<DataProxy.Query<TVariables, TResult>, "id">, Omit<DataProxy.WriteOptions<TResult>, "data"> {
|
||||
dataId?: string;
|
||||
result: Unmasked<TResult>;
|
||||
}
|
||||
interface DiffOptions<TData = any, TVariables = any> extends Omit<ReadOptions<TVariables, TData>, "rootId"> {
|
||||
}
|
||||
interface WatchOptions<TData = any, TVariables = any> extends DiffOptions<TData, TVariables> {
|
||||
watcher?: object;
|
||||
immediate?: boolean;
|
||||
callback: WatchCallback<TData>;
|
||||
lastDiff?: DiffResult<TData>;
|
||||
}
|
||||
interface EvictOptions {
|
||||
id?: string;
|
||||
fieldName?: string;
|
||||
args?: Record<string, any>;
|
||||
broadcast?: boolean;
|
||||
}
|
||||
interface ResetOptions {
|
||||
discardWatches?: boolean;
|
||||
}
|
||||
interface ModifyOptions<Entity extends Record<string, any> = Record<string, any>> {
|
||||
id?: string;
|
||||
fields: Modifiers<Entity> | AllFieldsModifier<Entity>;
|
||||
optimistic?: boolean;
|
||||
broadcast?: boolean;
|
||||
}
|
||||
interface BatchOptions<TCache extends ApolloCache<any>, TUpdateResult = void> {
|
||||
update(cache: TCache): TUpdateResult;
|
||||
optimistic?: string | boolean;
|
||||
removeOptimistic?: string;
|
||||
onWatchUpdated?: (this: TCache, watch: Cache.WatchOptions, diff: Cache.DiffResult<any>, lastDiff?: Cache.DiffResult<any> | undefined) => any;
|
||||
}
|
||||
export import DiffResult = DataProxy.DiffResult;
|
||||
export import ReadQueryOptions = DataProxy.ReadQueryOptions;
|
||||
export import ReadFragmentOptions = DataProxy.ReadFragmentOptions;
|
||||
export import WriteQueryOptions = DataProxy.WriteQueryOptions;
|
||||
export import WriteFragmentOptions = DataProxy.WriteFragmentOptions;
|
||||
export import UpdateQueryOptions = DataProxy.UpdateQueryOptions;
|
||||
export import UpdateFragmentOptions = DataProxy.UpdateFragmentOptions;
|
||||
export import Fragment = DataProxy.Fragment;
|
||||
}
|
||||
//# sourceMappingURL=Cache.d.ts.map
|
||||
+4
@@ -0,0 +1,4 @@
|
||||
export var Cache;
|
||||
(function (Cache) {
|
||||
})(Cache || (Cache = {}));
|
||||
//# sourceMappingURL=Cache.js.map
|
||||
+1
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"Cache.js","sourceRoot":"","sources":["../../../../src/cache/core/types/Cache.ts"],"names":[],"mappings":"AAKA,MAAM,KAAW,KAAK,CA8GrB;AA9GD,WAAiB,KAAK;AA8GtB,CAAC,EA9GgB,KAAK,KAAL,KAAK,QA8GrB","sourcesContent":["import { DataProxy } from \"./DataProxy.js\";\nimport type { AllFieldsModifier, Modifiers } from \"./common.js\";\nimport type { ApolloCache } from \"../cache.js\";\nimport type { Unmasked } from \"../../../masking/index.js\";\n\nexport namespace Cache {\n export type WatchCallback<TData = any> = (\n diff: Cache.DiffResult<TData>,\n lastDiff?: Cache.DiffResult<TData>\n ) => void;\n\n export interface ReadOptions<TVariables = any, TData = any>\n extends DataProxy.Query<TVariables, TData> {\n rootId?: string;\n previousResult?: any;\n optimistic: boolean;\n returnPartialData?: boolean;\n /**\n * @deprecated\n * Using `canonizeResults` can result in memory leaks so we generally do not\n * recommend using this option anymore.\n * A future version of Apollo Client will contain a similar feature without\n * the risk of memory leaks.\n */\n canonizeResults?: boolean;\n }\n\n export interface WriteOptions<TResult = any, TVariables = any>\n extends Omit<DataProxy.Query<TVariables, TResult>, \"id\">,\n Omit<DataProxy.WriteOptions<TResult>, \"data\"> {\n dataId?: string;\n result: Unmasked<TResult>;\n }\n\n export interface DiffOptions<TData = any, TVariables = any>\n extends Omit<ReadOptions<TVariables, TData>, \"rootId\"> {\n // The DiffOptions interface is currently just an alias for\n // ReadOptions, though DiffOptions used to be responsible for\n // declaring the returnPartialData option.\n }\n\n export interface WatchOptions<TData = any, TVariables = any>\n extends DiffOptions<TData, TVariables> {\n watcher?: object;\n immediate?: boolean;\n callback: WatchCallback<TData>;\n lastDiff?: DiffResult<TData>;\n }\n\n export interface EvictOptions {\n id?: string;\n fieldName?: string;\n args?: Record<string, any>;\n broadcast?: boolean;\n }\n\n // Although you can call cache.reset() without options, its behavior can be\n // configured by passing a Cache.ResetOptions object.\n export interface ResetOptions {\n discardWatches?: boolean;\n }\n\n export interface ModifyOptions<\n Entity extends Record<string, any> = Record<string, any>,\n > {\n id?: string;\n fields: Modifiers<Entity> | AllFieldsModifier<Entity>;\n optimistic?: boolean;\n broadcast?: boolean;\n }\n\n export interface BatchOptions<\n TCache extends ApolloCache<any>,\n TUpdateResult = void,\n > {\n // Same as the first parameter of performTransaction, except the cache\n // argument will have the subclass type rather than ApolloCache.\n update(cache: TCache): TUpdateResult;\n\n // Passing a string for this option creates a new optimistic layer, with the\n // given string as its layer.id, just like passing a string for the\n // optimisticId parameter of performTransaction. Passing true is the same as\n // passing undefined to performTransaction (running the batch operation\n // against the current top layer of the cache), and passing false is the\n // same as passing null (running the operation against root/non-optimistic\n // cache data).\n optimistic?: string | boolean;\n\n // If you specify the ID of an optimistic layer using this option, that\n // layer will be removed as part of the batch transaction, triggering at\n // most one broadcast for both the transaction and the removal of the layer.\n // Note: this option is needed because calling cache.removeOptimistic during\n // the transaction function may not be not safe, since any modifications to\n // cache layers may be discarded after the transaction finishes.\n removeOptimistic?: string;\n\n // If you want to find out which watched queries were invalidated during\n // this batch operation, pass this optional callback function. Returning\n // false from the callback will prevent broadcasting this result.\n onWatchUpdated?: (\n this: TCache,\n watch: Cache.WatchOptions,\n diff: Cache.DiffResult<any>,\n lastDiff?: Cache.DiffResult<any> | undefined\n ) => any;\n }\n\n export import DiffResult = DataProxy.DiffResult;\n export import ReadQueryOptions = DataProxy.ReadQueryOptions;\n export import ReadFragmentOptions = DataProxy.ReadFragmentOptions;\n export import WriteQueryOptions = DataProxy.WriteQueryOptions;\n export import WriteFragmentOptions = DataProxy.WriteFragmentOptions;\n export import UpdateQueryOptions = DataProxy.UpdateQueryOptions;\n export import UpdateFragmentOptions = DataProxy.UpdateFragmentOptions;\n export import Fragment = DataProxy.Fragment;\n}\n"]}
|
||||
+150
@@ -0,0 +1,150 @@
|
||||
import type { DocumentNode } from "graphql";
|
||||
import type { TypedDocumentNode } from "@graphql-typed-document-node/core";
|
||||
import type { MissingFieldError } from "./common.js";
|
||||
import type { Reference } from "../../../utilities/index.js";
|
||||
import type { Unmasked } from "../../../masking/index.js";
|
||||
export declare namespace DataProxy {
|
||||
interface Query<TVariables, TData> {
|
||||
/**
|
||||
* The GraphQL query shape to be used constructed using the `gql` template
|
||||
* string tag from `graphql-tag`. The query will be used to determine the
|
||||
* shape of the data to be read.
|
||||
*/
|
||||
query: DocumentNode | TypedDocumentNode<TData, TVariables>;
|
||||
/**
|
||||
* Any variables that the GraphQL query may depend on.
|
||||
*/
|
||||
variables?: TVariables;
|
||||
/**
|
||||
* The root id to be used. Defaults to "ROOT_QUERY", which is the ID of the
|
||||
* root query object. This property makes writeQuery capable of writing data
|
||||
* to any object in the cache.
|
||||
*/
|
||||
id?: string;
|
||||
}
|
||||
interface Fragment<TVariables, TData> {
|
||||
/**
|
||||
* The root id to be used. This id should take the same form as the
|
||||
* value returned by your `dataIdFromObject` function. If a value with your
|
||||
* id does not exist in the store, `null` will be returned.
|
||||
*/
|
||||
id?: string;
|
||||
/**
|
||||
* A GraphQL document created using the `gql` template string tag from
|
||||
* `graphql-tag` with one or more fragments which will be used to determine
|
||||
* the shape of data to read. If you provide more than one fragment in this
|
||||
* document then you must also specify `fragmentName` to select a single.
|
||||
*/
|
||||
fragment: DocumentNode | TypedDocumentNode<TData, TVariables>;
|
||||
/**
|
||||
* The name of the fragment in your GraphQL document to be used. If you do
|
||||
* not provide a `fragmentName` and there is only one fragment in your
|
||||
* `fragment` document then that fragment will be used.
|
||||
*/
|
||||
fragmentName?: string;
|
||||
/**
|
||||
* Any variables that your GraphQL fragments depend on.
|
||||
*/
|
||||
variables?: TVariables;
|
||||
}
|
||||
interface ReadQueryOptions<TData, TVariables> extends Query<TVariables, TData> {
|
||||
/**
|
||||
* Whether to return incomplete data rather than null.
|
||||
* Defaults to false.
|
||||
*/
|
||||
returnPartialData?: boolean;
|
||||
/**
|
||||
* Whether to read from optimistic or non-optimistic cache data. If
|
||||
* this named option is provided, the optimistic parameter of the
|
||||
* readQuery method can be omitted. Defaults to false.
|
||||
*/
|
||||
optimistic?: boolean;
|
||||
/**
|
||||
* Whether to canonize cache results before returning them. Canonization takes some extra time, but it speeds up future deep equality comparisons. Defaults to false.
|
||||
*
|
||||
* @deprecated
|
||||
*
|
||||
* Using `canonizeResults` can result in memory leaks so we generally do not recommend using this option anymore. A future version of Apollo Client will contain a similar feature without the risk of memory leaks.
|
||||
*/
|
||||
canonizeResults?: boolean;
|
||||
}
|
||||
interface ReadFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData> {
|
||||
/**
|
||||
* Whether to return incomplete data rather than null.
|
||||
* Defaults to false.
|
||||
*/
|
||||
returnPartialData?: boolean;
|
||||
/**
|
||||
* Whether to read from optimistic or non-optimistic cache data. If
|
||||
* this named option is provided, the optimistic parameter of the
|
||||
* readQuery method can be omitted. Defaults to false.
|
||||
*/
|
||||
optimistic?: boolean;
|
||||
/**
|
||||
* Whether to canonize cache results before returning them. Canonization takes some extra time, but it speeds up future deep equality comparisons. Defaults to false.
|
||||
*
|
||||
* @deprecated
|
||||
*
|
||||
* Using `canonizeResults` can result in memory leaks so we generally do not recommend using this option anymore. A future version of Apollo Client will contain a similar feature without the risk of memory leaks.
|
||||
*/
|
||||
canonizeResults?: boolean;
|
||||
}
|
||||
interface WriteOptions<TData> {
|
||||
/**
|
||||
* The data you will be writing to the store.
|
||||
*/
|
||||
data: Unmasked<TData>;
|
||||
/**
|
||||
* Whether to notify query watchers (default: true).
|
||||
*/
|
||||
broadcast?: boolean;
|
||||
/**
|
||||
* When true, ignore existing field data rather than merging it with
|
||||
* incoming data (default: false).
|
||||
*/
|
||||
overwrite?: boolean;
|
||||
}
|
||||
interface WriteQueryOptions<TData, TVariables> extends Query<TVariables, TData>, WriteOptions<TData> {
|
||||
}
|
||||
interface WriteFragmentOptions<TData, TVariables> extends Fragment<TVariables, TData>, WriteOptions<TData> {
|
||||
}
|
||||
interface UpdateQueryOptions<TData, TVariables> extends Omit<ReadQueryOptions<TData, TVariables> & WriteQueryOptions<TData, TVariables>, "data"> {
|
||||
}
|
||||
interface UpdateFragmentOptions<TData, TVariables> extends Omit<ReadFragmentOptions<TData, TVariables> & WriteFragmentOptions<TData, TVariables>, "data"> {
|
||||
}
|
||||
type DiffResult<T> = {
|
||||
result?: T;
|
||||
complete?: boolean;
|
||||
missing?: MissingFieldError[];
|
||||
fromOptimisticTransaction?: boolean;
|
||||
};
|
||||
}
|
||||
/**
|
||||
* A proxy to the normalized data living in our store. This interface allows a
|
||||
* user to read and write denormalized data which feels natural to the user
|
||||
* whilst in the background this data is being converted into the normalized
|
||||
* store format.
|
||||
*/
|
||||
export interface DataProxy {
|
||||
/**
|
||||
* Reads a GraphQL query from the root query id.
|
||||
*/
|
||||
readQuery<QueryType, TVariables = any>(options: DataProxy.ReadQueryOptions<QueryType, TVariables>, optimistic?: boolean): Unmasked<QueryType> | null;
|
||||
/**
|
||||
* Reads a GraphQL fragment from any arbitrary id. If there is more than
|
||||
* one fragment in the provided document then a `fragmentName` must be
|
||||
* provided to select the correct fragment.
|
||||
*/
|
||||
readFragment<FragmentType, TVariables = any>(options: DataProxy.ReadFragmentOptions<FragmentType, TVariables>, optimistic?: boolean): Unmasked<FragmentType> | null;
|
||||
/**
|
||||
* Writes a GraphQL query to the root query id.
|
||||
*/
|
||||
writeQuery<TData = any, TVariables = any>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
|
||||
/**
|
||||
* Writes a GraphQL fragment to any arbitrary id. If there is more than
|
||||
* one fragment in the provided document then a `fragmentName` must be
|
||||
* provided to select the correct fragment.
|
||||
*/
|
||||
writeFragment<TData = any, TVariables = any>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
|
||||
}
|
||||
//# sourceMappingURL=DataProxy.d.ts.map
|
||||
+2
@@ -0,0 +1,2 @@
|
||||
export {};
|
||||
//# sourceMappingURL=DataProxy.js.map
|
||||
+1
File diff suppressed because one or more lines are too long
+64
@@ -0,0 +1,64 @@
|
||||
import type { DocumentNode, FieldNode } from "graphql";
|
||||
import type { Reference, StoreObject, StoreValue, isReference, AsStoreObject, DeepPartial } from "../../../utilities/index.js";
|
||||
import type { StorageType } from "../../inmemory/policies.js";
|
||||
export type SafeReadonly<T> = T extends object ? Readonly<T> : T;
|
||||
export type MissingTree = string | {
|
||||
readonly [key: string]: MissingTree;
|
||||
};
|
||||
export declare class MissingFieldError extends Error {
|
||||
readonly message: string;
|
||||
readonly path: MissingTree | Array<string | number>;
|
||||
readonly query: DocumentNode;
|
||||
readonly variables?: Record<string, any> | undefined;
|
||||
constructor(message: string, path: MissingTree | Array<string | number>, query: DocumentNode, variables?: Record<string, any> | undefined);
|
||||
readonly missing: MissingTree;
|
||||
}
|
||||
export interface FieldSpecifier {
|
||||
typename?: string;
|
||||
fieldName: string;
|
||||
field?: FieldNode;
|
||||
args?: Record<string, any>;
|
||||
variables?: Record<string, any>;
|
||||
}
|
||||
export interface ReadFieldOptions extends FieldSpecifier {
|
||||
from?: StoreObject | Reference;
|
||||
}
|
||||
export interface ReadFieldFunction {
|
||||
<V = StoreValue>(options: ReadFieldOptions): SafeReadonly<V> | undefined;
|
||||
<V = StoreValue>(fieldName: string, from?: StoreObject | Reference): SafeReadonly<V> | undefined;
|
||||
}
|
||||
export type ToReferenceFunction = (objOrIdOrRef: StoreObject | string | Reference, mergeIntoStore?: boolean) => Reference | undefined;
|
||||
export type CanReadFunction = (value: StoreValue) => boolean;
|
||||
declare const _deleteModifier: unique symbol;
|
||||
export interface DeleteModifier {
|
||||
[_deleteModifier]: true;
|
||||
}
|
||||
declare const _invalidateModifier: unique symbol;
|
||||
export interface InvalidateModifier {
|
||||
[_invalidateModifier]: true;
|
||||
}
|
||||
declare const _ignoreModifier: unique symbol;
|
||||
export interface IgnoreModifier {
|
||||
[_ignoreModifier]: true;
|
||||
}
|
||||
export type ModifierDetails = {
|
||||
DELETE: DeleteModifier;
|
||||
INVALIDATE: InvalidateModifier;
|
||||
fieldName: string;
|
||||
storeFieldName: string;
|
||||
readField: ReadFieldFunction;
|
||||
canRead: CanReadFunction;
|
||||
isReference: typeof isReference;
|
||||
toReference: ToReferenceFunction;
|
||||
storage: StorageType;
|
||||
};
|
||||
export type Modifier<T> = (value: T, details: ModifierDetails) => DeepPartial<T> | DeleteModifier | InvalidateModifier | undefined;
|
||||
type StoreObjectValueMaybeReference<StoreVal> = StoreVal extends Array<Record<string, any>> ? StoreVal extends Array<infer Item> ? [
|
||||
Item
|
||||
] extends [Record<string, any>] ? ReadonlyArray<AsStoreObject<Item> | Reference> : never : never : StoreVal extends Record<string, any> ? AsStoreObject<StoreVal> | Reference : StoreVal;
|
||||
export type AllFieldsModifier<Entity extends Record<string, any>> = Modifier<Entity[keyof Entity] extends infer Value ? StoreObjectValueMaybeReference<Exclude<Value, undefined>> : never>;
|
||||
export type Modifiers<T extends Record<string, any> = Record<string, unknown>> = Partial<{
|
||||
[FieldName in keyof T]: Modifier<StoreObjectValueMaybeReference<Exclude<T[FieldName], undefined>>>;
|
||||
}>;
|
||||
export {};
|
||||
//# sourceMappingURL=common.d.ts.map
|
||||
+29
@@ -0,0 +1,29 @@
|
||||
import { __extends } from "tslib";
|
||||
var MissingFieldError = /** @class */ (function (_super) {
|
||||
__extends(MissingFieldError, _super);
|
||||
function MissingFieldError(message, path, query, variables) {
|
||||
var _a;
|
||||
// 'Error' breaks prototype chain here
|
||||
var _this = _super.call(this, message) || this;
|
||||
_this.message = message;
|
||||
_this.path = path;
|
||||
_this.query = query;
|
||||
_this.variables = variables;
|
||||
if (Array.isArray(_this.path)) {
|
||||
_this.missing = _this.message;
|
||||
for (var i = _this.path.length - 1; i >= 0; --i) {
|
||||
_this.missing = (_a = {}, _a[_this.path[i]] = _this.missing, _a);
|
||||
}
|
||||
}
|
||||
else {
|
||||
_this.missing = _this.path;
|
||||
}
|
||||
// We're not using `Object.setPrototypeOf` here as it isn't fully supported
|
||||
// on Android (see issue #3236).
|
||||
_this.__proto__ = MissingFieldError.prototype;
|
||||
return _this;
|
||||
}
|
||||
return MissingFieldError;
|
||||
}(Error));
|
||||
export { MissingFieldError };
|
||||
//# sourceMappingURL=common.js.map
|
||||
+1
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../../src/cache/core/types/common.ts"],"names":[],"mappings":";AA4BA;IAAuC,qCAAK;IAC1C,2BACkB,OAAe,EACf,IAA0C,EAC1C,KAAmB,EACnB,SAA+B;;QAE/C,sCAAsC;QACtC,YAAA,MAAK,YAAC,OAAO,CAAC,SAAC;QANC,aAAO,GAAP,OAAO,CAAQ;QACf,UAAI,GAAJ,IAAI,CAAsC;QAC1C,WAAK,GAAL,KAAK,CAAc;QACnB,eAAS,GAAT,SAAS,CAAsB;QAK/C,IAAI,KAAK,CAAC,OAAO,CAAC,KAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YAC7B,KAAI,CAAC,OAAO,GAAG,KAAI,CAAC,OAAO,CAAC;YAC5B,KAAK,IAAI,CAAC,GAAG,KAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;gBAC/C,KAAI,CAAC,OAAO,aAAK,GAAC,KAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAG,KAAI,CAAC,OAAO,KAAE,CAAC;YAClD,CAAC;QACH,CAAC;aAAM,CAAC;YACN,KAAI,CAAC,OAAO,GAAG,KAAI,CAAC,IAAI,CAAC;QAC3B,CAAC;QAED,2EAA2E;QAC3E,gCAAgC;QAC/B,KAAY,CAAC,SAAS,GAAG,iBAAiB,CAAC,SAAS,CAAC;;IACxD,CAAC;IAGH,wBAAC;AAAD,CAAC,AAzBD,CAAuC,KAAK,GAyB3C","sourcesContent":["import type { DocumentNode, FieldNode } from \"graphql\";\n\nimport type {\n Reference,\n StoreObject,\n StoreValue,\n isReference,\n AsStoreObject,\n DeepPartial,\n} from \"../../../utilities/index.js\";\n\nimport type { StorageType } from \"../../inmemory/policies.js\";\n\n// The Readonly<T> type only really works for object types, since it marks\n// all of the object's properties as readonly, but there are many cases when\n// a generic type parameter like TExisting might be a string or some other\n// primitive type, in which case we need to avoid wrapping it with Readonly.\n// SafeReadonly<string> collapses to just string, which makes string\n// assignable to SafeReadonly<any>, whereas string is not assignable to\n// Readonly<any>, somewhat surprisingly.\nexport type SafeReadonly<T> = T extends object ? Readonly<T> : T;\n\nexport type MissingTree =\n | string\n | {\n readonly [key: string]: MissingTree;\n };\n\nexport class MissingFieldError extends Error {\n constructor(\n public readonly message: string,\n public readonly path: MissingTree | Array<string | number>,\n public readonly query: DocumentNode,\n public readonly variables?: Record<string, any>\n ) {\n // 'Error' breaks prototype chain here\n super(message);\n\n if (Array.isArray(this.path)) {\n this.missing = this.message;\n for (let i = this.path.length - 1; i >= 0; --i) {\n this.missing = { [this.path[i]]: this.missing };\n }\n } else {\n this.missing = this.path;\n }\n\n // We're not using `Object.setPrototypeOf` here as it isn't fully supported\n // on Android (see issue #3236).\n (this as any).__proto__ = MissingFieldError.prototype;\n }\n\n public readonly missing: MissingTree;\n}\n\nexport interface FieldSpecifier {\n typename?: string;\n fieldName: string;\n field?: FieldNode;\n args?: Record<string, any>;\n variables?: Record<string, any>;\n}\n\nexport interface ReadFieldOptions extends FieldSpecifier {\n from?: StoreObject | Reference;\n}\n\nexport interface ReadFieldFunction {\n <V = StoreValue>(options: ReadFieldOptions): SafeReadonly<V> | undefined;\n <V = StoreValue>(\n fieldName: string,\n from?: StoreObject | Reference\n ): SafeReadonly<V> | undefined;\n}\n\nexport type ToReferenceFunction = (\n objOrIdOrRef: StoreObject | string | Reference,\n mergeIntoStore?: boolean\n) => Reference | undefined;\n\nexport type CanReadFunction = (value: StoreValue) => boolean;\n\ndeclare const _deleteModifier: unique symbol;\nexport interface DeleteModifier {\n [_deleteModifier]: true;\n}\ndeclare const _invalidateModifier: unique symbol;\nexport interface InvalidateModifier {\n [_invalidateModifier]: true;\n}\ndeclare const _ignoreModifier: unique symbol;\nexport interface IgnoreModifier {\n [_ignoreModifier]: true;\n}\n\nexport type ModifierDetails = {\n DELETE: DeleteModifier;\n INVALIDATE: InvalidateModifier;\n fieldName: string;\n storeFieldName: string;\n readField: ReadFieldFunction;\n canRead: CanReadFunction;\n isReference: typeof isReference;\n toReference: ToReferenceFunction;\n storage: StorageType;\n};\n\nexport type Modifier<T> = (\n value: T,\n details: ModifierDetails\n) => DeepPartial<T> | DeleteModifier | InvalidateModifier | undefined;\n\ntype StoreObjectValueMaybeReference<StoreVal> =\n StoreVal extends Array<Record<string, any>> ?\n StoreVal extends Array<infer Item> ?\n [Item] extends [Record<string, any>] ?\n ReadonlyArray<AsStoreObject<Item> | Reference>\n : never\n : never\n : StoreVal extends Record<string, any> ? AsStoreObject<StoreVal> | Reference\n : StoreVal;\n\nexport type AllFieldsModifier<Entity extends Record<string, any>> = Modifier<\n Entity[keyof Entity] extends infer Value ?\n StoreObjectValueMaybeReference<Exclude<Value, undefined>>\n : never\n>;\n\nexport type Modifiers<T extends Record<string, any> = Record<string, unknown>> =\n Partial<{\n [FieldName in keyof T]: Modifier<\n StoreObjectValueMaybeReference<Exclude<T[FieldName], undefined>>\n >;\n }>;\n"]}
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
import "../utilities/globals/index.js";
|
||||
export type { Transaction, WatchFragmentOptions, WatchFragmentResult, } from "./core/cache.js";
|
||||
export { ApolloCache } from "./core/cache.js";
|
||||
export { Cache } from "./core/types/Cache.js";
|
||||
export type { DataProxy } from "./core/types/DataProxy.js";
|
||||
export type { MissingTree, Modifier, Modifiers, ModifierDetails, ReadFieldOptions, } from "./core/types/common.js";
|
||||
export { MissingFieldError } from "./core/types/common.js";
|
||||
export type { Reference } from "../utilities/index.js";
|
||||
export { isReference, makeReference, canonicalStringify, } from "../utilities/index.js";
|
||||
export { EntityStore } from "./inmemory/entityStore.js";
|
||||
export { fieldNameFromStoreName, defaultDataIdFromObject, } from "./inmemory/helpers.js";
|
||||
export { InMemoryCache } from "./inmemory/inMemoryCache.js";
|
||||
export type { ReactiveVar } from "./inmemory/reactiveVars.js";
|
||||
export { makeVar, cacheSlot } from "./inmemory/reactiveVars.js";
|
||||
export type { TypePolicies, TypePolicy, FieldPolicy, FieldReadFunction, FieldMergeFunction, FieldFunctionOptions, PossibleTypesMap, } from "./inmemory/policies.js";
|
||||
export { Policies } from "./inmemory/policies.js";
|
||||
export type { FragmentRegistryAPI } from "./inmemory/fragmentRegistry.js";
|
||||
export { createFragmentRegistry } from "./inmemory/fragmentRegistry.js";
|
||||
export type * from "./inmemory/types.js";
|
||||
//# sourceMappingURL=index.d.ts.map
|
||||
+12
@@ -0,0 +1,12 @@
|
||||
import "../utilities/globals/index.js";
|
||||
export { ApolloCache } from "./core/cache.js";
|
||||
export { Cache } from "./core/types/Cache.js";
|
||||
export { MissingFieldError } from "./core/types/common.js";
|
||||
export { isReference, makeReference, canonicalStringify, } from "../utilities/index.js";
|
||||
export { EntityStore } from "./inmemory/entityStore.js";
|
||||
export { fieldNameFromStoreName, defaultDataIdFromObject, } from "./inmemory/helpers.js";
|
||||
export { InMemoryCache } from "./inmemory/inMemoryCache.js";
|
||||
export { makeVar, cacheSlot } from "./inmemory/reactiveVars.js";
|
||||
export { Policies } from "./inmemory/policies.js";
|
||||
export { createFragmentRegistry } from "./inmemory/fragmentRegistry.js";
|
||||
//# sourceMappingURL=index.js.map
|
||||
+1
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/cache/index.ts"],"names":[],"mappings":"AAAA,OAAO,+BAA+B,CAAC;AAOvC,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAS9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAG3D,OAAO,EACL,WAAW,EACX,aAAa,EACb,kBAAkB,GACnB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EACL,sBAAsB,EACtB,uBAAuB,GACxB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAG5D,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAWhE,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAGlD,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC","sourcesContent":["import \"../utilities/globals/index.js\";\n\nexport type {\n Transaction,\n WatchFragmentOptions,\n WatchFragmentResult,\n} from \"./core/cache.js\";\nexport { ApolloCache } from \"./core/cache.js\";\nexport { Cache } from \"./core/types/Cache.js\";\nexport type { DataProxy } from \"./core/types/DataProxy.js\";\nexport type {\n MissingTree,\n Modifier,\n Modifiers,\n ModifierDetails,\n ReadFieldOptions,\n} from \"./core/types/common.js\";\nexport { MissingFieldError } from \"./core/types/common.js\";\n\nexport type { Reference } from \"../utilities/index.js\";\nexport {\n isReference,\n makeReference,\n canonicalStringify,\n} from \"../utilities/index.js\";\n\nexport { EntityStore } from \"./inmemory/entityStore.js\";\nexport {\n fieldNameFromStoreName,\n defaultDataIdFromObject,\n} from \"./inmemory/helpers.js\";\n\nexport { InMemoryCache } from \"./inmemory/inMemoryCache.js\";\n\nexport type { ReactiveVar } from \"./inmemory/reactiveVars.js\";\nexport { makeVar, cacheSlot } from \"./inmemory/reactiveVars.js\";\n\nexport type {\n TypePolicies,\n TypePolicy,\n FieldPolicy,\n FieldReadFunction,\n FieldMergeFunction,\n FieldFunctionOptions,\n PossibleTypesMap,\n} from \"./inmemory/policies.js\";\nexport { Policies } from \"./inmemory/policies.js\";\n\nexport type { FragmentRegistryAPI } from \"./inmemory/fragmentRegistry.js\";\nexport { createFragmentRegistry } from \"./inmemory/fragmentRegistry.js\";\n\nexport type * from \"./inmemory/types.js\";\n"]}
|
||||
+92
@@ -0,0 +1,92 @@
|
||||
import { Trie } from "@wry/trie";
|
||||
import type { StoreValue, StoreObject, Reference } from "../../utilities/index.js";
|
||||
import type { NormalizedCache, NormalizedCacheObject } from "./types.js";
|
||||
import type { Policies, StorageType } from "./policies.js";
|
||||
import type { Cache } from "../core/types/Cache.js";
|
||||
import type { SafeReadonly, Modifier, Modifiers, ToReferenceFunction, CanReadFunction } from "../core/types/common.js";
|
||||
import type { DocumentNode, FieldNode, SelectionSetNode } from "graphql";
|
||||
export declare abstract class EntityStore implements NormalizedCache {
|
||||
readonly policies: Policies;
|
||||
readonly group: CacheGroup;
|
||||
protected data: NormalizedCacheObject;
|
||||
constructor(policies: Policies, group: CacheGroup);
|
||||
abstract addLayer(layerId: string, replay: (layer: EntityStore) => any): Layer;
|
||||
abstract removeLayer(layerId: string): EntityStore;
|
||||
toObject(): NormalizedCacheObject;
|
||||
has(dataId: string): boolean;
|
||||
get(dataId: string, fieldName: string): StoreValue;
|
||||
protected lookup(dataId: string, dependOnExistence?: boolean): StoreObject | undefined;
|
||||
merge(older: string | StoreObject, newer: StoreObject | string): void;
|
||||
modify(dataId: string, fields: Modifier<any> | Modifiers<Record<string, any>>): boolean;
|
||||
delete(dataId: string, fieldName?: string, args?: Record<string, any>): boolean;
|
||||
evict(options: Cache.EvictOptions, limit: EntityStore): boolean;
|
||||
clear(): void;
|
||||
extract(): NormalizedCacheObject;
|
||||
replace(newData: NormalizedCacheObject | null): void;
|
||||
abstract getStorage(idOrObj: string | StoreObject, ...storeFieldNames: (string | number)[]): StorageType;
|
||||
private rootIds;
|
||||
retain(rootId: string): number;
|
||||
release(rootId: string): number;
|
||||
getRootIdSet(ids?: Set<string>): Set<string>;
|
||||
gc(): string[];
|
||||
private refs;
|
||||
findChildRefIds(dataId: string): Record<string, true>;
|
||||
/** overload for `InMemoryCache.maybeBroadcastWatch` */
|
||||
makeCacheKey(document: DocumentNode, callback: Cache.WatchCallback<any>, details: string): object;
|
||||
/** overload for `StoreReader.executeSelectionSet` */
|
||||
makeCacheKey(selectionSet: SelectionSetNode, parent: string | StoreObject, varString: string | undefined, canonizeResults: boolean): object;
|
||||
/** overload for `StoreReader.executeSubSelectedArray` */
|
||||
makeCacheKey(field: FieldNode, array: readonly any[], varString: string | undefined): object;
|
||||
/** @deprecated This is only meant for internal usage,
|
||||
* in your own code please use a `Trie` instance instead. */
|
||||
makeCacheKey(...args: any[]): object;
|
||||
getFieldValue: <T = StoreValue>(objectOrReference: StoreObject | Reference | undefined, storeFieldName: string) => SafeReadonly<T>;
|
||||
canRead: CanReadFunction;
|
||||
toReference: ToReferenceFunction;
|
||||
}
|
||||
export type FieldValueGetter = EntityStore["getFieldValue"];
|
||||
declare class CacheGroup {
|
||||
readonly caching: boolean;
|
||||
private parent;
|
||||
private d;
|
||||
keyMaker: Trie<object>;
|
||||
constructor(caching: boolean, parent?: CacheGroup | null);
|
||||
resetCaching(): void;
|
||||
depend(dataId: string, storeFieldName: string): void;
|
||||
dirty(dataId: string, storeFieldName: string): void;
|
||||
}
|
||||
export declare function maybeDependOnExistenceOfEntity(store: NormalizedCache, entityId: string): void;
|
||||
export declare namespace EntityStore {
|
||||
class Root extends EntityStore {
|
||||
constructor({ policies, resultCaching, seed, }: {
|
||||
policies: Policies;
|
||||
resultCaching?: boolean;
|
||||
seed?: NormalizedCacheObject;
|
||||
});
|
||||
readonly stump: Stump;
|
||||
addLayer(layerId: string, replay: (layer: EntityStore) => any): Layer;
|
||||
removeLayer(): Root;
|
||||
readonly storageTrie: Trie<StorageType>;
|
||||
getStorage(): StorageType;
|
||||
}
|
||||
}
|
||||
declare class Layer extends EntityStore {
|
||||
readonly id: string;
|
||||
readonly parent: EntityStore;
|
||||
readonly replay: (layer: EntityStore) => any;
|
||||
readonly group: CacheGroup;
|
||||
constructor(id: string, parent: EntityStore, replay: (layer: EntityStore) => any, group: CacheGroup);
|
||||
addLayer(layerId: string, replay: (layer: EntityStore) => any): Layer;
|
||||
removeLayer(layerId: string): EntityStore;
|
||||
toObject(): NormalizedCacheObject;
|
||||
findChildRefIds(dataId: string): Record<string, true>;
|
||||
getStorage(): StorageType;
|
||||
}
|
||||
declare class Stump extends Layer {
|
||||
constructor(root: EntityStore.Root);
|
||||
removeLayer(): this;
|
||||
merge(older: string | StoreObject, newer: string | StoreObject): void;
|
||||
}
|
||||
export declare function supportsResultCaching(store: any): store is EntityStore;
|
||||
export {};
|
||||
//# sourceMappingURL=entityStore.d.ts.map
|
||||
+671
@@ -0,0 +1,671 @@
|
||||
import { __assign, __extends, __rest } from "tslib";
|
||||
import { invariant } from "../../utilities/globals/index.js";
|
||||
import { dep } from "optimism";
|
||||
import { equal } from "@wry/equality";
|
||||
import { Trie } from "@wry/trie";
|
||||
import { isReference, makeReference, DeepMerger, maybeDeepFreeze, canUseWeakMap, isNonNullObject, } from "../../utilities/index.js";
|
||||
import { hasOwn, fieldNameFromStoreName } from "./helpers.js";
|
||||
var DELETE = Object.create(null);
|
||||
var delModifier = function () { return DELETE; };
|
||||
var INVALIDATE = Object.create(null);
|
||||
var EntityStore = /** @class */ (function () {
|
||||
function EntityStore(policies, group) {
|
||||
var _this = this;
|
||||
this.policies = policies;
|
||||
this.group = group;
|
||||
this.data = Object.create(null);
|
||||
// Maps root entity IDs to the number of times they have been retained, minus
|
||||
// the number of times they have been released. Retained entities keep other
|
||||
// entities they reference (even indirectly) from being garbage collected.
|
||||
this.rootIds = Object.create(null);
|
||||
// Lazily tracks { __ref: <dataId> } strings contained by this.data[dataId].
|
||||
this.refs = Object.create(null);
|
||||
// Bound function that can be passed around to provide easy access to fields
|
||||
// of Reference objects as well as ordinary objects.
|
||||
this.getFieldValue = function (objectOrReference, storeFieldName) {
|
||||
return maybeDeepFreeze(isReference(objectOrReference) ?
|
||||
_this.get(objectOrReference.__ref, storeFieldName)
|
||||
: objectOrReference && objectOrReference[storeFieldName]);
|
||||
};
|
||||
// Returns true for non-normalized StoreObjects and non-dangling
|
||||
// References, indicating that readField(name, objOrRef) has a chance of
|
||||
// working. Useful for filtering out dangling references from lists.
|
||||
this.canRead = function (objOrRef) {
|
||||
return isReference(objOrRef) ?
|
||||
_this.has(objOrRef.__ref)
|
||||
: typeof objOrRef === "object";
|
||||
};
|
||||
// Bound function that converts an id or an object with a __typename and
|
||||
// primary key fields to a Reference object. If called with a Reference object,
|
||||
// that same Reference object is returned. Pass true for mergeIntoStore to persist
|
||||
// an object into the store.
|
||||
this.toReference = function (objOrIdOrRef, mergeIntoStore) {
|
||||
if (typeof objOrIdOrRef === "string") {
|
||||
return makeReference(objOrIdOrRef);
|
||||
}
|
||||
if (isReference(objOrIdOrRef)) {
|
||||
return objOrIdOrRef;
|
||||
}
|
||||
var id = _this.policies.identify(objOrIdOrRef)[0];
|
||||
if (id) {
|
||||
var ref = makeReference(id);
|
||||
if (mergeIntoStore) {
|
||||
_this.merge(id, objOrIdOrRef);
|
||||
}
|
||||
return ref;
|
||||
}
|
||||
};
|
||||
}
|
||||
// Although the EntityStore class is abstract, it contains concrete
|
||||
// implementations of the various NormalizedCache interface methods that
|
||||
// are inherited by the Root and Layer subclasses.
|
||||
EntityStore.prototype.toObject = function () {
|
||||
return __assign({}, this.data);
|
||||
};
|
||||
EntityStore.prototype.has = function (dataId) {
|
||||
return this.lookup(dataId, true) !== void 0;
|
||||
};
|
||||
EntityStore.prototype.get = function (dataId, fieldName) {
|
||||
this.group.depend(dataId, fieldName);
|
||||
if (hasOwn.call(this.data, dataId)) {
|
||||
var storeObject = this.data[dataId];
|
||||
if (storeObject && hasOwn.call(storeObject, fieldName)) {
|
||||
return storeObject[fieldName];
|
||||
}
|
||||
}
|
||||
if (fieldName === "__typename" &&
|
||||
hasOwn.call(this.policies.rootTypenamesById, dataId)) {
|
||||
return this.policies.rootTypenamesById[dataId];
|
||||
}
|
||||
if (this instanceof Layer) {
|
||||
return this.parent.get(dataId, fieldName);
|
||||
}
|
||||
};
|
||||
EntityStore.prototype.lookup = function (dataId, dependOnExistence) {
|
||||
// The has method (above) calls lookup with dependOnExistence = true, so
|
||||
// that it can later be invalidated when we add or remove a StoreObject for
|
||||
// this dataId. Any consumer who cares about the contents of the StoreObject
|
||||
// should not rely on this dependency, since the contents could change
|
||||
// without the object being added or removed.
|
||||
if (dependOnExistence)
|
||||
this.group.depend(dataId, "__exists");
|
||||
if (hasOwn.call(this.data, dataId)) {
|
||||
return this.data[dataId];
|
||||
}
|
||||
if (this instanceof Layer) {
|
||||
return this.parent.lookup(dataId, dependOnExistence);
|
||||
}
|
||||
if (this.policies.rootTypenamesById[dataId]) {
|
||||
return Object.create(null);
|
||||
}
|
||||
};
|
||||
EntityStore.prototype.merge = function (older, newer) {
|
||||
var _this = this;
|
||||
var dataId;
|
||||
// Convert unexpected references to ID strings.
|
||||
if (isReference(older))
|
||||
older = older.__ref;
|
||||
if (isReference(newer))
|
||||
newer = newer.__ref;
|
||||
var existing = typeof older === "string" ? this.lookup((dataId = older)) : older;
|
||||
var incoming = typeof newer === "string" ? this.lookup((dataId = newer)) : newer;
|
||||
// If newer was a string ID, but that ID was not defined in this store,
|
||||
// then there are no fields to be merged, so we're done.
|
||||
if (!incoming)
|
||||
return;
|
||||
invariant(typeof dataId === "string", 2);
|
||||
var merged = new DeepMerger(storeObjectReconciler).merge(existing, incoming);
|
||||
// Even if merged === existing, existing may have come from a lower
|
||||
// layer, so we always need to set this.data[dataId] on this level.
|
||||
this.data[dataId] = merged;
|
||||
if (merged !== existing) {
|
||||
delete this.refs[dataId];
|
||||
if (this.group.caching) {
|
||||
var fieldsToDirty_1 = Object.create(null);
|
||||
// If we added a new StoreObject where there was previously none, dirty
|
||||
// anything that depended on the existence of this dataId, such as the
|
||||
// EntityStore#has method.
|
||||
if (!existing)
|
||||
fieldsToDirty_1.__exists = 1;
|
||||
// Now invalidate dependents who called getFieldValue for any fields
|
||||
// that are changing as a result of this merge.
|
||||
Object.keys(incoming).forEach(function (storeFieldName) {
|
||||
if (!existing ||
|
||||
existing[storeFieldName] !== merged[storeFieldName]) {
|
||||
// Always dirty the full storeFieldName, which may include
|
||||
// serialized arguments following the fieldName prefix.
|
||||
fieldsToDirty_1[storeFieldName] = 1;
|
||||
// Also dirty fieldNameFromStoreName(storeFieldName) if it's
|
||||
// different from storeFieldName and this field does not have
|
||||
// keyArgs configured, because that means the cache can't make
|
||||
// any assumptions about how field values with the same field
|
||||
// name but different arguments might be interrelated, so it
|
||||
// must err on the side of invalidating all field values that
|
||||
// share the same short fieldName, regardless of arguments.
|
||||
var fieldName = fieldNameFromStoreName(storeFieldName);
|
||||
if (fieldName !== storeFieldName &&
|
||||
!_this.policies.hasKeyArgs(merged.__typename, fieldName)) {
|
||||
fieldsToDirty_1[fieldName] = 1;
|
||||
}
|
||||
// If merged[storeFieldName] has become undefined, and this is the
|
||||
// Root layer, actually delete the property from the merged object,
|
||||
// which is guaranteed to have been created fresh in this method.
|
||||
if (merged[storeFieldName] === void 0 && !(_this instanceof Layer)) {
|
||||
delete merged[storeFieldName];
|
||||
}
|
||||
}
|
||||
});
|
||||
if (fieldsToDirty_1.__typename &&
|
||||
!(existing && existing.__typename) &&
|
||||
// Since we return default root __typename strings
|
||||
// automatically from store.get, we don't need to dirty the
|
||||
// ROOT_QUERY.__typename field if merged.__typename is equal
|
||||
// to the default string (usually "Query").
|
||||
this.policies.rootTypenamesById[dataId] === merged.__typename) {
|
||||
delete fieldsToDirty_1.__typename;
|
||||
}
|
||||
Object.keys(fieldsToDirty_1).forEach(function (fieldName) {
|
||||
return _this.group.dirty(dataId, fieldName);
|
||||
});
|
||||
}
|
||||
}
|
||||
};
|
||||
EntityStore.prototype.modify = function (dataId, fields) {
|
||||
var _this = this;
|
||||
var storeObject = this.lookup(dataId);
|
||||
if (storeObject) {
|
||||
var changedFields_1 = Object.create(null);
|
||||
var needToMerge_1 = false;
|
||||
var allDeleted_1 = true;
|
||||
var sharedDetails_1 = {
|
||||
DELETE: DELETE,
|
||||
INVALIDATE: INVALIDATE,
|
||||
isReference: isReference,
|
||||
toReference: this.toReference,
|
||||
canRead: this.canRead,
|
||||
readField: function (fieldNameOrOptions, from) {
|
||||
return _this.policies.readField(typeof fieldNameOrOptions === "string" ?
|
||||
{
|
||||
fieldName: fieldNameOrOptions,
|
||||
from: from || makeReference(dataId),
|
||||
}
|
||||
: fieldNameOrOptions, { store: _this });
|
||||
},
|
||||
};
|
||||
Object.keys(storeObject).forEach(function (storeFieldName) {
|
||||
var fieldName = fieldNameFromStoreName(storeFieldName);
|
||||
var fieldValue = storeObject[storeFieldName];
|
||||
if (fieldValue === void 0)
|
||||
return;
|
||||
var modify = typeof fields === "function" ? fields : (fields[storeFieldName] || fields[fieldName]);
|
||||
if (modify) {
|
||||
var newValue = modify === delModifier ? DELETE : (modify(maybeDeepFreeze(fieldValue), __assign(__assign({}, sharedDetails_1), { fieldName: fieldName, storeFieldName: storeFieldName, storage: _this.getStorage(dataId, storeFieldName) })));
|
||||
if (newValue === INVALIDATE) {
|
||||
_this.group.dirty(dataId, storeFieldName);
|
||||
}
|
||||
else {
|
||||
if (newValue === DELETE)
|
||||
newValue = void 0;
|
||||
if (newValue !== fieldValue) {
|
||||
changedFields_1[storeFieldName] = newValue;
|
||||
needToMerge_1 = true;
|
||||
fieldValue = newValue;
|
||||
if (globalThis.__DEV__ !== false) {
|
||||
var checkReference = function (ref) {
|
||||
if (_this.lookup(ref.__ref) === undefined) {
|
||||
globalThis.__DEV__ !== false && invariant.warn(3, ref);
|
||||
return true;
|
||||
}
|
||||
};
|
||||
if (isReference(newValue)) {
|
||||
checkReference(newValue);
|
||||
}
|
||||
else if (Array.isArray(newValue)) {
|
||||
// Warn about writing "mixed" arrays of Reference and non-Reference objects
|
||||
var seenReference = false;
|
||||
var someNonReference = void 0;
|
||||
for (var _i = 0, newValue_1 = newValue; _i < newValue_1.length; _i++) {
|
||||
var value = newValue_1[_i];
|
||||
if (isReference(value)) {
|
||||
seenReference = true;
|
||||
if (checkReference(value))
|
||||
break;
|
||||
}
|
||||
else {
|
||||
// Do not warn on primitive values, since those could never be represented
|
||||
// by a reference. This is a valid (albeit uncommon) use case.
|
||||
if (typeof value === "object" && !!value) {
|
||||
var id = _this.policies.identify(value)[0];
|
||||
// check if object could even be referenced, otherwise we are not interested in it for this warning
|
||||
if (id) {
|
||||
someNonReference = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (seenReference && someNonReference !== undefined) {
|
||||
globalThis.__DEV__ !== false && invariant.warn(4, someNonReference);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (fieldValue !== void 0) {
|
||||
allDeleted_1 = false;
|
||||
}
|
||||
});
|
||||
if (needToMerge_1) {
|
||||
this.merge(dataId, changedFields_1);
|
||||
if (allDeleted_1) {
|
||||
if (this instanceof Layer) {
|
||||
this.data[dataId] = void 0;
|
||||
}
|
||||
else {
|
||||
delete this.data[dataId];
|
||||
}
|
||||
this.group.dirty(dataId, "__exists");
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
};
|
||||
// If called with only one argument, removes the entire entity
|
||||
// identified by dataId. If called with a fieldName as well, removes all
|
||||
// fields of that entity whose names match fieldName according to the
|
||||
// fieldNameFromStoreName helper function. If called with a fieldName
|
||||
// and variables, removes all fields of that entity whose names match fieldName
|
||||
// and whose arguments when cached exactly match the variables passed.
|
||||
EntityStore.prototype.delete = function (dataId, fieldName, args) {
|
||||
var _a;
|
||||
var storeObject = this.lookup(dataId);
|
||||
if (storeObject) {
|
||||
var typename = this.getFieldValue(storeObject, "__typename");
|
||||
var storeFieldName = fieldName && args ?
|
||||
this.policies.getStoreFieldName({ typename: typename, fieldName: fieldName, args: args })
|
||||
: fieldName;
|
||||
return this.modify(dataId, storeFieldName ? (_a = {},
|
||||
_a[storeFieldName] = delModifier,
|
||||
_a) : delModifier);
|
||||
}
|
||||
return false;
|
||||
};
|
||||
EntityStore.prototype.evict = function (options, limit) {
|
||||
var evicted = false;
|
||||
if (options.id) {
|
||||
if (hasOwn.call(this.data, options.id)) {
|
||||
evicted = this.delete(options.id, options.fieldName, options.args);
|
||||
}
|
||||
if (this instanceof Layer && this !== limit) {
|
||||
evicted = this.parent.evict(options, limit) || evicted;
|
||||
}
|
||||
// Always invalidate the field to trigger rereading of watched
|
||||
// queries, even if no cache data was modified by the eviction,
|
||||
// because queries may depend on computed fields with custom read
|
||||
// functions, whose values are not stored in the EntityStore.
|
||||
if (options.fieldName || evicted) {
|
||||
this.group.dirty(options.id, options.fieldName || "__exists");
|
||||
}
|
||||
}
|
||||
return evicted;
|
||||
};
|
||||
EntityStore.prototype.clear = function () {
|
||||
this.replace(null);
|
||||
};
|
||||
EntityStore.prototype.extract = function () {
|
||||
var _this = this;
|
||||
var obj = this.toObject();
|
||||
var extraRootIds = [];
|
||||
this.getRootIdSet().forEach(function (id) {
|
||||
if (!hasOwn.call(_this.policies.rootTypenamesById, id)) {
|
||||
extraRootIds.push(id);
|
||||
}
|
||||
});
|
||||
if (extraRootIds.length) {
|
||||
obj.__META = { extraRootIds: extraRootIds.sort() };
|
||||
}
|
||||
return obj;
|
||||
};
|
||||
EntityStore.prototype.replace = function (newData) {
|
||||
var _this = this;
|
||||
Object.keys(this.data).forEach(function (dataId) {
|
||||
if (!(newData && hasOwn.call(newData, dataId))) {
|
||||
_this.delete(dataId);
|
||||
}
|
||||
});
|
||||
if (newData) {
|
||||
var __META = newData.__META, rest_1 = __rest(newData, ["__META"]);
|
||||
Object.keys(rest_1).forEach(function (dataId) {
|
||||
_this.merge(dataId, rest_1[dataId]);
|
||||
});
|
||||
if (__META) {
|
||||
__META.extraRootIds.forEach(this.retain, this);
|
||||
}
|
||||
}
|
||||
};
|
||||
EntityStore.prototype.retain = function (rootId) {
|
||||
return (this.rootIds[rootId] = (this.rootIds[rootId] || 0) + 1);
|
||||
};
|
||||
EntityStore.prototype.release = function (rootId) {
|
||||
if (this.rootIds[rootId] > 0) {
|
||||
var count = --this.rootIds[rootId];
|
||||
if (!count)
|
||||
delete this.rootIds[rootId];
|
||||
return count;
|
||||
}
|
||||
return 0;
|
||||
};
|
||||
// Return a Set<string> of all the ID strings that have been retained by
|
||||
// this layer/root *and* any layers/roots beneath it.
|
||||
EntityStore.prototype.getRootIdSet = function (ids) {
|
||||
if (ids === void 0) { ids = new Set(); }
|
||||
Object.keys(this.rootIds).forEach(ids.add, ids);
|
||||
if (this instanceof Layer) {
|
||||
this.parent.getRootIdSet(ids);
|
||||
}
|
||||
else {
|
||||
// Official singleton IDs like ROOT_QUERY and ROOT_MUTATION are
|
||||
// always considered roots for garbage collection, regardless of
|
||||
// their retainment counts in this.rootIds.
|
||||
Object.keys(this.policies.rootTypenamesById).forEach(ids.add, ids);
|
||||
}
|
||||
return ids;
|
||||
};
|
||||
// The goal of garbage collection is to remove IDs from the Root layer of the
|
||||
// store that are no longer reachable starting from any IDs that have been
|
||||
// explicitly retained (see retain and release, above). Returns an array of
|
||||
// dataId strings that were removed from the store.
|
||||
EntityStore.prototype.gc = function () {
|
||||
var _this = this;
|
||||
var ids = this.getRootIdSet();
|
||||
var snapshot = this.toObject();
|
||||
ids.forEach(function (id) {
|
||||
if (hasOwn.call(snapshot, id)) {
|
||||
// Because we are iterating over an ECMAScript Set, the IDs we add here
|
||||
// will be visited in later iterations of the forEach loop only if they
|
||||
// were not previously contained by the Set.
|
||||
Object.keys(_this.findChildRefIds(id)).forEach(ids.add, ids);
|
||||
// By removing IDs from the snapshot object here, we protect them from
|
||||
// getting removed from the root store layer below.
|
||||
delete snapshot[id];
|
||||
}
|
||||
});
|
||||
var idsToRemove = Object.keys(snapshot);
|
||||
if (idsToRemove.length) {
|
||||
var root_1 = this;
|
||||
while (root_1 instanceof Layer)
|
||||
root_1 = root_1.parent;
|
||||
idsToRemove.forEach(function (id) { return root_1.delete(id); });
|
||||
}
|
||||
return idsToRemove;
|
||||
};
|
||||
EntityStore.prototype.findChildRefIds = function (dataId) {
|
||||
if (!hasOwn.call(this.refs, dataId)) {
|
||||
var found_1 = (this.refs[dataId] = Object.create(null));
|
||||
var root = this.data[dataId];
|
||||
if (!root)
|
||||
return found_1;
|
||||
var workSet_1 = new Set([root]);
|
||||
// Within the store, only arrays and objects can contain child entity
|
||||
// references, so we can prune the traversal using this predicate:
|
||||
workSet_1.forEach(function (obj) {
|
||||
if (isReference(obj)) {
|
||||
found_1[obj.__ref] = true;
|
||||
// In rare cases, a { __ref } Reference object may have other fields.
|
||||
// This often indicates a mismerging of References with StoreObjects,
|
||||
// but garbage collection should not be fooled by a stray __ref
|
||||
// property in a StoreObject (ignoring all the other fields just
|
||||
// because the StoreObject looks like a Reference). To avoid this
|
||||
// premature termination of findChildRefIds recursion, we fall through
|
||||
// to the code below, which will handle any other properties of obj.
|
||||
}
|
||||
if (isNonNullObject(obj)) {
|
||||
Object.keys(obj).forEach(function (key) {
|
||||
var child = obj[key];
|
||||
// No need to add primitive values to the workSet, since they cannot
|
||||
// contain reference objects.
|
||||
if (isNonNullObject(child)) {
|
||||
workSet_1.add(child);
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
return this.refs[dataId];
|
||||
};
|
||||
EntityStore.prototype.makeCacheKey = function () {
|
||||
return this.group.keyMaker.lookupArray(arguments);
|
||||
};
|
||||
return EntityStore;
|
||||
}());
|
||||
export { EntityStore };
|
||||
// A single CacheGroup represents a set of one or more EntityStore objects,
|
||||
// typically the Root store in a CacheGroup by itself, and all active Layer
|
||||
// stores in a group together. A single EntityStore object belongs to only
|
||||
// one CacheGroup, store.group. The CacheGroup is responsible for tracking
|
||||
// dependencies, so store.group is helpful for generating unique keys for
|
||||
// cached results that need to be invalidated when/if those dependencies
|
||||
// change. If we used the EntityStore objects themselves as cache keys (that
|
||||
// is, store rather than store.group), the cache would become unnecessarily
|
||||
// fragmented by all the different Layer objects. Instead, the CacheGroup
|
||||
// approach allows all optimistic Layer objects in the same linked list to
|
||||
// belong to one CacheGroup, with the non-optimistic Root object belonging
|
||||
// to another CacheGroup, allowing resultCaching dependencies to be tracked
|
||||
// separately for optimistic and non-optimistic entity data.
|
||||
var CacheGroup = /** @class */ (function () {
|
||||
function CacheGroup(caching, parent) {
|
||||
if (parent === void 0) { parent = null; }
|
||||
this.caching = caching;
|
||||
this.parent = parent;
|
||||
this.d = null;
|
||||
this.resetCaching();
|
||||
}
|
||||
CacheGroup.prototype.resetCaching = function () {
|
||||
this.d = this.caching ? dep() : null;
|
||||
this.keyMaker = new Trie(canUseWeakMap);
|
||||
};
|
||||
CacheGroup.prototype.depend = function (dataId, storeFieldName) {
|
||||
if (this.d) {
|
||||
this.d(makeDepKey(dataId, storeFieldName));
|
||||
var fieldName = fieldNameFromStoreName(storeFieldName);
|
||||
if (fieldName !== storeFieldName) {
|
||||
// Fields with arguments that contribute extra identifying
|
||||
// information to the fieldName (thus forming the storeFieldName)
|
||||
// depend not only on the full storeFieldName but also on the
|
||||
// short fieldName, so the field can be invalidated using either
|
||||
// level of specificity.
|
||||
this.d(makeDepKey(dataId, fieldName));
|
||||
}
|
||||
if (this.parent) {
|
||||
this.parent.depend(dataId, storeFieldName);
|
||||
}
|
||||
}
|
||||
};
|
||||
CacheGroup.prototype.dirty = function (dataId, storeFieldName) {
|
||||
if (this.d) {
|
||||
this.d.dirty(makeDepKey(dataId, storeFieldName),
|
||||
// When storeFieldName === "__exists", that means the entity identified
|
||||
// by dataId has either disappeared from the cache or was newly added,
|
||||
// so the result caching system would do well to "forget everything it
|
||||
// knows" about that object. To achieve that kind of invalidation, we
|
||||
// not only dirty the associated result cache entry, but also remove it
|
||||
// completely from the dependency graph. For the optimism implementation
|
||||
// details, see https://github.com/benjamn/optimism/pull/195.
|
||||
storeFieldName === "__exists" ? "forget" : "setDirty");
|
||||
}
|
||||
};
|
||||
return CacheGroup;
|
||||
}());
|
||||
function makeDepKey(dataId, storeFieldName) {
|
||||
// Since field names cannot have '#' characters in them, this method
|
||||
// of joining the field name and the ID should be unambiguous, and much
|
||||
// cheaper than JSON.stringify([dataId, fieldName]).
|
||||
return storeFieldName + "#" + dataId;
|
||||
}
|
||||
export function maybeDependOnExistenceOfEntity(store, entityId) {
|
||||
if (supportsResultCaching(store)) {
|
||||
// We use this pseudo-field __exists elsewhere in the EntityStore code to
|
||||
// represent changes in the existence of the entity object identified by
|
||||
// entityId. This dependency gets reliably dirtied whenever an object with
|
||||
// this ID is deleted (or newly created) within this group, so any result
|
||||
// cache entries (for example, StoreReader#executeSelectionSet results) that
|
||||
// depend on __exists for this entityId will get dirtied as well, leading to
|
||||
// the eventual recomputation (instead of reuse) of those result objects the
|
||||
// next time someone reads them from the cache.
|
||||
store.group.depend(entityId, "__exists");
|
||||
}
|
||||
}
|
||||
(function (EntityStore) {
|
||||
// Refer to this class as EntityStore.Root outside this namespace.
|
||||
var Root = /** @class */ (function (_super) {
|
||||
__extends(Root, _super);
|
||||
function Root(_a) {
|
||||
var policies = _a.policies, _b = _a.resultCaching, resultCaching = _b === void 0 ? true : _b, seed = _a.seed;
|
||||
var _this = _super.call(this, policies, new CacheGroup(resultCaching)) || this;
|
||||
_this.stump = new Stump(_this);
|
||||
_this.storageTrie = new Trie(canUseWeakMap);
|
||||
if (seed)
|
||||
_this.replace(seed);
|
||||
return _this;
|
||||
}
|
||||
Root.prototype.addLayer = function (layerId, replay) {
|
||||
// Adding an optimistic Layer on top of the Root actually adds the Layer
|
||||
// on top of the Stump, so the Stump always comes between the Root and
|
||||
// any Layer objects that we've added.
|
||||
return this.stump.addLayer(layerId, replay);
|
||||
};
|
||||
Root.prototype.removeLayer = function () {
|
||||
// Never remove the root layer.
|
||||
return this;
|
||||
};
|
||||
Root.prototype.getStorage = function () {
|
||||
return this.storageTrie.lookupArray(arguments);
|
||||
};
|
||||
return Root;
|
||||
}(EntityStore));
|
||||
EntityStore.Root = Root;
|
||||
})(EntityStore || (EntityStore = {}));
|
||||
// Not exported, since all Layer instances are created by the addLayer method
|
||||
// of the EntityStore.Root class.
|
||||
var Layer = /** @class */ (function (_super) {
|
||||
__extends(Layer, _super);
|
||||
function Layer(id, parent, replay, group) {
|
||||
var _this = _super.call(this, parent.policies, group) || this;
|
||||
_this.id = id;
|
||||
_this.parent = parent;
|
||||
_this.replay = replay;
|
||||
_this.group = group;
|
||||
replay(_this);
|
||||
return _this;
|
||||
}
|
||||
Layer.prototype.addLayer = function (layerId, replay) {
|
||||
return new Layer(layerId, this, replay, this.group);
|
||||
};
|
||||
Layer.prototype.removeLayer = function (layerId) {
|
||||
var _this = this;
|
||||
// Remove all instances of the given id, not just the first one.
|
||||
var parent = this.parent.removeLayer(layerId);
|
||||
if (layerId === this.id) {
|
||||
if (this.group.caching) {
|
||||
// Dirty every ID we're removing. Technically we might be able to avoid
|
||||
// dirtying fields that have values in higher layers, but we don't have
|
||||
// easy access to higher layers here, and we're about to recreate those
|
||||
// layers anyway (see parent.addLayer below).
|
||||
Object.keys(this.data).forEach(function (dataId) {
|
||||
var ownStoreObject = _this.data[dataId];
|
||||
var parentStoreObject = parent["lookup"](dataId);
|
||||
if (!parentStoreObject) {
|
||||
// The StoreObject identified by dataId was defined in this layer
|
||||
// but will be undefined in the parent layer, so we can delete the
|
||||
// whole entity using this.delete(dataId). Since we're about to
|
||||
// throw this layer away, the only goal of this deletion is to dirty
|
||||
// the removed fields.
|
||||
_this.delete(dataId);
|
||||
}
|
||||
else if (!ownStoreObject) {
|
||||
// This layer had an entry for dataId but it was undefined, which
|
||||
// means the entity was deleted in this layer, and it's about to
|
||||
// become undeleted when we remove this layer, so we need to dirty
|
||||
// all fields that are about to be reexposed.
|
||||
_this.group.dirty(dataId, "__exists");
|
||||
Object.keys(parentStoreObject).forEach(function (storeFieldName) {
|
||||
_this.group.dirty(dataId, storeFieldName);
|
||||
});
|
||||
}
|
||||
else if (ownStoreObject !== parentStoreObject) {
|
||||
// If ownStoreObject is not exactly the same as parentStoreObject,
|
||||
// dirty any fields whose values will change as a result of this
|
||||
// removal.
|
||||
Object.keys(ownStoreObject).forEach(function (storeFieldName) {
|
||||
if (!equal(ownStoreObject[storeFieldName], parentStoreObject[storeFieldName])) {
|
||||
_this.group.dirty(dataId, storeFieldName);
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
return parent;
|
||||
}
|
||||
// No changes are necessary if the parent chain remains identical.
|
||||
if (parent === this.parent)
|
||||
return this;
|
||||
// Recreate this layer on top of the new parent.
|
||||
return parent.addLayer(this.id, this.replay);
|
||||
};
|
||||
Layer.prototype.toObject = function () {
|
||||
return __assign(__assign({}, this.parent.toObject()), this.data);
|
||||
};
|
||||
Layer.prototype.findChildRefIds = function (dataId) {
|
||||
var fromParent = this.parent.findChildRefIds(dataId);
|
||||
return hasOwn.call(this.data, dataId) ? __assign(__assign({}, fromParent), _super.prototype.findChildRefIds.call(this, dataId)) : fromParent;
|
||||
};
|
||||
Layer.prototype.getStorage = function () {
|
||||
var p = this.parent;
|
||||
while (p.parent)
|
||||
p = p.parent;
|
||||
return p.getStorage.apply(p,
|
||||
// @ts-expect-error
|
||||
arguments);
|
||||
};
|
||||
return Layer;
|
||||
}(EntityStore));
|
||||
// Represents a Layer permanently installed just above the Root, which allows
|
||||
// reading optimistically (and registering optimistic dependencies) even when
|
||||
// no optimistic layers are currently active. The stump.group CacheGroup object
|
||||
// is shared by any/all Layer objects added on top of the Stump.
|
||||
var Stump = /** @class */ (function (_super) {
|
||||
__extends(Stump, _super);
|
||||
function Stump(root) {
|
||||
return _super.call(this, "EntityStore.Stump", root, function () { }, new CacheGroup(root.group.caching, root.group)) || this;
|
||||
}
|
||||
Stump.prototype.removeLayer = function () {
|
||||
// Never remove the Stump layer.
|
||||
return this;
|
||||
};
|
||||
Stump.prototype.merge = function (older, newer) {
|
||||
// We never want to write any data into the Stump, so we forward any merge
|
||||
// calls to the Root instead. Another option here would be to throw an
|
||||
// exception, but the toReference(object, true) function can sometimes
|
||||
// trigger Stump writes (which used to be Root writes, before the Stump
|
||||
// concept was introduced).
|
||||
return this.parent.merge(older, newer);
|
||||
};
|
||||
return Stump;
|
||||
}(Layer));
|
||||
function storeObjectReconciler(existingObject, incomingObject, property) {
|
||||
var existingValue = existingObject[property];
|
||||
var incomingValue = incomingObject[property];
|
||||
// Wherever there is a key collision, prefer the incoming value, unless
|
||||
// it is deeply equal to the existing value. It's worth checking deep
|
||||
// equality here (even though blindly returning incoming would be
|
||||
// logically correct) because preserving the referential identity of
|
||||
// existing data can prevent needless rereading and rerendering.
|
||||
return equal(existingValue, incomingValue) ? existingValue : incomingValue;
|
||||
}
|
||||
export function supportsResultCaching(store) {
|
||||
// When result caching is disabled, store.depend will be null.
|
||||
return !!(store instanceof EntityStore && store.group.caching);
|
||||
}
|
||||
//# sourceMappingURL=entityStore.js.map
|
||||
+1
File diff suppressed because one or more lines are too long
+1
@@ -0,0 +1 @@
|
||||
//# sourceMappingURL=fixPolyfills.d.ts.map
|
||||
+10
@@ -0,0 +1,10 @@
|
||||
"use strict";
|
||||
// Most JavaScript environments do not need the workarounds implemented in
|
||||
// fixPolyfills.native.ts, so importing fixPolyfills.ts merely imports
|
||||
// this empty module, adding nothing to bundle sizes or execution times.
|
||||
// When bundling for React Native, we substitute fixPolyfills.native.js
|
||||
// for fixPolyfills.js (see the "react-native" section of package.json),
|
||||
// to work around problems with Map and Set polyfills in older versions of
|
||||
// React Native (which should have been fixed in react-native@0.59.0):
|
||||
// https://github.com/apollographql/apollo-client/pull/5962
|
||||
//# sourceMappingURL=fixPolyfills.js.map
|
||||
+1
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"fixPolyfills.js","sourceRoot":"","sources":["../../../src/cache/inmemory/fixPolyfills.ts"],"names":[],"mappings":";AAAA,0EAA0E;AAC1E,sEAAsE;AACtE,wEAAwE;AACxE,uEAAuE;AACvE,wEAAwE;AACxE,0EAA0E;AAC1E,sEAAsE;AACtE,2DAA2D","sourcesContent":["// Most JavaScript environments do not need the workarounds implemented in\n// fixPolyfills.native.ts, so importing fixPolyfills.ts merely imports\n// this empty module, adding nothing to bundle sizes or execution times.\n// When bundling for React Native, we substitute fixPolyfills.native.js\n// for fixPolyfills.js (see the \"react-native\" section of package.json),\n// to work around problems with Map and Set polyfills in older versions of\n// React Native (which should have been fixed in react-native@0.59.0):\n// https://github.com/apollographql/apollo-client/pull/5962\n"]}
|
||||
+2
@@ -0,0 +1,2 @@
|
||||
export {};
|
||||
//# sourceMappingURL=fixPolyfills.native.d.ts.map
|
||||
+61
@@ -0,0 +1,61 @@
|
||||
// Make sure Map.prototype.set returns the Map instance, per spec.
|
||||
// https://github.com/apollographql/apollo-client/issues/4024
|
||||
var testMap = new Map();
|
||||
if (testMap.set(1, 2) !== testMap) {
|
||||
var set_1 = testMap.set;
|
||||
Map.prototype.set = function () {
|
||||
var args = [];
|
||||
for (var _i = 0; _i < arguments.length; _i++) {
|
||||
args[_i] = arguments[_i];
|
||||
}
|
||||
set_1.apply(this, args);
|
||||
return this;
|
||||
};
|
||||
}
|
||||
// Make sure Set.prototype.add returns the Set instance, per spec.
|
||||
var testSet = new Set();
|
||||
if (testSet.add(3) !== testSet) {
|
||||
var add_1 = testSet.add;
|
||||
Set.prototype.add = function () {
|
||||
var args = [];
|
||||
for (var _i = 0; _i < arguments.length; _i++) {
|
||||
args[_i] = arguments[_i];
|
||||
}
|
||||
add_1.apply(this, args);
|
||||
return this;
|
||||
};
|
||||
}
|
||||
var frozen = {};
|
||||
if (typeof Object.freeze === "function") {
|
||||
Object.freeze(frozen);
|
||||
}
|
||||
try {
|
||||
// If non-extensible objects can't be stored as keys in a Map, make sure we
|
||||
// do not freeze/seal/etc. an object without first attempting to put it in a
|
||||
// Map. For example, this gives the React Native Map polyfill a chance to tag
|
||||
// objects before they become non-extensible:
|
||||
// https://github.com/facebook/react-native/blob/98a6f19d7c/Libraries/vendor/core/Map.js#L44-L50
|
||||
// https://github.com/apollographql/react-apollo/issues/2442#issuecomment-426489517
|
||||
testMap.set(frozen, frozen).delete(frozen);
|
||||
}
|
||||
catch (_a) {
|
||||
var wrap = function (method) {
|
||||
return (method &&
|
||||
(function (obj) {
|
||||
try {
|
||||
// If .set succeeds, also call .delete to avoid leaking memory.
|
||||
testMap.set(obj, obj).delete(obj);
|
||||
}
|
||||
finally {
|
||||
// If .set or .delete fails, the exception will be silently swallowed
|
||||
// by this return-from-finally statement:
|
||||
return method.call(Object, obj);
|
||||
}
|
||||
}));
|
||||
};
|
||||
Object.freeze = wrap(Object.freeze);
|
||||
Object.seal = wrap(Object.seal);
|
||||
Object.preventExtensions = wrap(Object.preventExtensions);
|
||||
}
|
||||
export {};
|
||||
//# sourceMappingURL=fixPolyfills.native.js.map
|
||||
+1
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"fixPolyfills.native.js","sourceRoot":"","sources":["../../../src/cache/inmemory/fixPolyfills.native.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,6DAA6D;AAC7D,IAAM,OAAO,GAAG,IAAI,GAAG,EAAE,CAAC;AAC1B,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,OAAO,EAAE,CAAC;IAC1B,IAAA,KAAG,GAAK,OAAO,IAAZ,CAAa;IACxB,GAAG,CAAC,SAAS,CAAC,GAAG,GAAG;QAAU,cAAO;aAAP,UAAO,EAAP,qBAAO,EAAP,IAAO;YAAP,yBAAO;;QACnC,KAAG,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACtB,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;AACJ,CAAC;AAED,kEAAkE;AAClE,IAAM,OAAO,GAAG,IAAI,GAAG,EAAE,CAAC;AAC1B,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,OAAO,EAAE,CAAC;IACvB,IAAA,KAAG,GAAK,OAAO,IAAZ,CAAa;IACxB,GAAG,CAAC,SAAS,CAAC,GAAG,GAAG;QAAU,cAAO;aAAP,UAAO,EAAP,qBAAO,EAAP,IAAO;YAAP,yBAAO;;QACnC,KAAG,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACtB,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;AACJ,CAAC;AAED,IAAM,MAAM,GAAG,EAAE,CAAC;AAClB,IAAI,OAAO,MAAM,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;IACxC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AACxB,CAAC;AAED,IAAI,CAAC;IACH,2EAA2E;IAC3E,4EAA4E;IAC5E,6EAA6E;IAC7E,6CAA6C;IAC7C,gGAAgG;IAChG,mFAAmF;IACnF,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AAC7C,CAAC;AAAC,WAAM,CAAC;IACP,IAAM,IAAI,GAAG,UAA6B,MAAS;QACjD,OAAO,CACL,MAAM;YACL,CAAC,UAAC,GAAG;gBACJ,IAAI,CAAC;oBACH,+DAA+D;oBAC/D,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBACpC,CAAC;wBAAS,CAAC;oBACT,qEAAqE;oBACrE,yCAAyC;oBACzC,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;gBAClC,CAAC;YACH,CAAC,CAAO,CACT,CAAC;IACJ,CAAC,CAAC;IACF,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACpC,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAChC,MAAM,CAAC,iBAAiB,GAAG,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;AAC5D,CAAC","sourcesContent":["// Make sure Map.prototype.set returns the Map instance, per spec.\n// https://github.com/apollographql/apollo-client/issues/4024\nconst testMap = new Map();\nif (testMap.set(1, 2) !== testMap) {\n const { set } = testMap;\n Map.prototype.set = function (...args) {\n set.apply(this, args);\n return this;\n };\n}\n\n// Make sure Set.prototype.add returns the Set instance, per spec.\nconst testSet = new Set();\nif (testSet.add(3) !== testSet) {\n const { add } = testSet;\n Set.prototype.add = function (...args) {\n add.apply(this, args);\n return this;\n };\n}\n\nconst frozen = {};\nif (typeof Object.freeze === \"function\") {\n Object.freeze(frozen);\n}\n\ntry {\n // If non-extensible objects can't be stored as keys in a Map, make sure we\n // do not freeze/seal/etc. an object without first attempting to put it in a\n // Map. For example, this gives the React Native Map polyfill a chance to tag\n // objects before they become non-extensible:\n // https://github.com/facebook/react-native/blob/98a6f19d7c/Libraries/vendor/core/Map.js#L44-L50\n // https://github.com/apollographql/react-apollo/issues/2442#issuecomment-426489517\n testMap.set(frozen, frozen).delete(frozen);\n} catch {\n const wrap = <M extends <T>(obj: T) => T>(method: M): M => {\n return (\n method &&\n (((obj) => {\n try {\n // If .set succeeds, also call .delete to avoid leaking memory.\n testMap.set(obj, obj).delete(obj);\n } finally {\n // If .set or .delete fails, the exception will be silently swallowed\n // by this return-from-finally statement:\n return method.call(Object, obj);\n }\n }) as M)\n );\n };\n Object.freeze = wrap(Object.freeze);\n Object.seal = wrap(Object.seal);\n Object.preventExtensions = wrap(Object.preventExtensions);\n}\n\nexport {};\n"]}
|
||||
+9
@@ -0,0 +1,9 @@
|
||||
import type { DocumentNode, FragmentDefinitionNode } from "graphql";
|
||||
export interface FragmentRegistryAPI {
|
||||
register(...fragments: DocumentNode[]): this;
|
||||
lookup(fragmentName: string): FragmentDefinitionNode | null;
|
||||
transform<D extends DocumentNode>(document: D): D;
|
||||
resetCaches(): void;
|
||||
}
|
||||
export declare function createFragmentRegistry(...fragments: DocumentNode[]): FragmentRegistryAPI;
|
||||
//# sourceMappingURL=fragmentRegistry.d.ts.map
|
||||
+140
@@ -0,0 +1,140 @@
|
||||
import { __assign, __spreadArray } from "tslib";
|
||||
import { visit } from "graphql";
|
||||
import { wrap } from "optimism";
|
||||
import { cacheSizes, getFragmentDefinitions, } from "../../utilities/index.js";
|
||||
import { WeakCache } from "@wry/caches";
|
||||
// As long as createFragmentRegistry is not imported or used, the
|
||||
// FragmentRegistry example implementation provided below should not be bundled
|
||||
// (by tree-shaking bundlers like Rollup), because the implementation of
|
||||
// InMemoryCache refers only to the TypeScript interface FragmentRegistryAPI,
|
||||
// never the concrete implementation FragmentRegistry (which is deliberately not
|
||||
// exported from this module).
|
||||
export function createFragmentRegistry() {
|
||||
var fragments = [];
|
||||
for (var _i = 0; _i < arguments.length; _i++) {
|
||||
fragments[_i] = arguments[_i];
|
||||
}
|
||||
return new (FragmentRegistry.bind.apply(FragmentRegistry, __spreadArray([void 0], fragments, false)))();
|
||||
}
|
||||
var FragmentRegistry = /** @class */ (function () {
|
||||
// Call `createFragmentRegistry` instead of invoking the
|
||||
// FragmentRegistry constructor directly. This reserves the constructor for
|
||||
// future configuration of the FragmentRegistry.
|
||||
function FragmentRegistry() {
|
||||
var fragments = [];
|
||||
for (var _i = 0; _i < arguments.length; _i++) {
|
||||
fragments[_i] = arguments[_i];
|
||||
}
|
||||
this.registry = Object.create(null);
|
||||
this.resetCaches();
|
||||
if (fragments.length) {
|
||||
this.register.apply(this, fragments);
|
||||
}
|
||||
}
|
||||
FragmentRegistry.prototype.register = function () {
|
||||
var _this = this;
|
||||
var fragments = [];
|
||||
for (var _i = 0; _i < arguments.length; _i++) {
|
||||
fragments[_i] = arguments[_i];
|
||||
}
|
||||
var definitions = new Map();
|
||||
fragments.forEach(function (doc) {
|
||||
getFragmentDefinitions(doc).forEach(function (node) {
|
||||
definitions.set(node.name.value, node);
|
||||
});
|
||||
});
|
||||
definitions.forEach(function (node, name) {
|
||||
if (node !== _this.registry[name]) {
|
||||
_this.registry[name] = node;
|
||||
_this.invalidate(name);
|
||||
}
|
||||
});
|
||||
return this;
|
||||
};
|
||||
// Overridden in the resetCaches method below.
|
||||
FragmentRegistry.prototype.invalidate = function (name) { };
|
||||
FragmentRegistry.prototype.resetCaches = function () {
|
||||
var proto = FragmentRegistry.prototype;
|
||||
this.invalidate = (this.lookup = wrap(proto.lookup.bind(this), {
|
||||
makeCacheKey: function (arg) { return arg; },
|
||||
max: cacheSizes["fragmentRegistry.lookup"] ||
|
||||
1000 /* defaultCacheSizes["fragmentRegistry.lookup"] */,
|
||||
})).dirty; // This dirty function is bound to the wrapped lookup method.
|
||||
this.transform = wrap(proto.transform.bind(this), {
|
||||
cache: WeakCache,
|
||||
max: cacheSizes["fragmentRegistry.transform"] ||
|
||||
2000 /* defaultCacheSizes["fragmentRegistry.transform"] */,
|
||||
});
|
||||
this.findFragmentSpreads = wrap(proto.findFragmentSpreads.bind(this), {
|
||||
cache: WeakCache,
|
||||
max: cacheSizes["fragmentRegistry.findFragmentSpreads"] ||
|
||||
4000 /* defaultCacheSizes["fragmentRegistry.findFragmentSpreads"] */,
|
||||
});
|
||||
};
|
||||
/*
|
||||
* Note:
|
||||
* This method is only memoized so it can serve as a dependency to `tranform`,
|
||||
* so calling `invalidate` will invalidate cache entries for `transform`.
|
||||
*/
|
||||
FragmentRegistry.prototype.lookup = function (fragmentName) {
|
||||
return this.registry[fragmentName] || null;
|
||||
};
|
||||
FragmentRegistry.prototype.transform = function (document) {
|
||||
var _this = this;
|
||||
var defined = new Map();
|
||||
getFragmentDefinitions(document).forEach(function (def) {
|
||||
defined.set(def.name.value, def);
|
||||
});
|
||||
var unbound = new Set();
|
||||
var enqueue = function (spreadName) {
|
||||
if (!defined.has(spreadName)) {
|
||||
unbound.add(spreadName);
|
||||
}
|
||||
};
|
||||
var enqueueChildSpreads = function (node) {
|
||||
return Object.keys(_this.findFragmentSpreads(node)).forEach(enqueue);
|
||||
};
|
||||
enqueueChildSpreads(document);
|
||||
var missing = [];
|
||||
var map = Object.create(null);
|
||||
// This Set forEach loop can be extended during iteration by adding
|
||||
// additional strings to the unbound set.
|
||||
unbound.forEach(function (fragmentName) {
|
||||
var knownFragmentDef = defined.get(fragmentName);
|
||||
if (knownFragmentDef) {
|
||||
enqueueChildSpreads((map[fragmentName] = knownFragmentDef));
|
||||
}
|
||||
else {
|
||||
missing.push(fragmentName);
|
||||
var def = _this.lookup(fragmentName);
|
||||
if (def) {
|
||||
enqueueChildSpreads((map[fragmentName] = def));
|
||||
}
|
||||
}
|
||||
});
|
||||
if (missing.length) {
|
||||
var defsToAppend_1 = [];
|
||||
missing.forEach(function (name) {
|
||||
var def = map[name];
|
||||
if (def) {
|
||||
defsToAppend_1.push(def);
|
||||
}
|
||||
});
|
||||
if (defsToAppend_1.length) {
|
||||
document = __assign(__assign({}, document), { definitions: document.definitions.concat(defsToAppend_1) });
|
||||
}
|
||||
}
|
||||
return document;
|
||||
};
|
||||
FragmentRegistry.prototype.findFragmentSpreads = function (root) {
|
||||
var spreads = Object.create(null);
|
||||
visit(root, {
|
||||
FragmentSpread: function (node) {
|
||||
spreads[node.name.value] = node;
|
||||
},
|
||||
});
|
||||
return spreads;
|
||||
};
|
||||
return FragmentRegistry;
|
||||
}());
|
||||
//# sourceMappingURL=fragmentRegistry.js.map
|
||||
+1
File diff suppressed because one or more lines are too long
+28
@@ -0,0 +1,28 @@
|
||||
import type { DocumentNode, SelectionSetNode } from "graphql";
|
||||
import type { NormalizedCache, InMemoryCacheConfig } from "./types.js";
|
||||
import type { KeyFieldsContext } from "./policies.js";
|
||||
import type { FragmentRegistryAPI } from "./fragmentRegistry.js";
|
||||
import type { Reference, StoreValue, StoreObject, FragmentMap, FragmentMapFunction } from "../../utilities/index.js";
|
||||
import { DeepMerger, isArray } from "../../utilities/index.js";
|
||||
export declare const hasOwn: (v: PropertyKey) => boolean;
|
||||
export declare function isNullish(value: any): value is null | undefined;
|
||||
export { isArray };
|
||||
export declare function defaultDataIdFromObject({ __typename, id, _id }: Readonly<StoreObject>, context?: KeyFieldsContext): string | undefined;
|
||||
export declare function normalizeConfig(config: InMemoryCacheConfig): {
|
||||
dataIdFromObject: typeof defaultDataIdFromObject;
|
||||
addTypename: boolean;
|
||||
resultCaching: boolean;
|
||||
canonizeResults: boolean;
|
||||
} & InMemoryCacheConfig;
|
||||
export declare function shouldCanonizeResults(config: Pick<InMemoryCacheConfig, "canonizeResults">): boolean;
|
||||
export declare function getTypenameFromStoreObject(store: NormalizedCache, objectOrReference: StoreObject | Reference): string | undefined;
|
||||
export declare const TypeOrFieldNameRegExp: RegExp;
|
||||
export declare function fieldNameFromStoreName(storeFieldName: string): string;
|
||||
export declare function selectionSetMatchesResult(selectionSet: SelectionSetNode, result: Record<string, any>, variables?: Record<string, any>): boolean;
|
||||
export declare function storeValueIsStoreObject(value: StoreValue): value is StoreObject;
|
||||
export declare function makeProcessedFieldsMerger(): DeepMerger<any[]>;
|
||||
export declare function extractFragmentContext(document: DocumentNode, fragments?: FragmentRegistryAPI): {
|
||||
fragmentMap: FragmentMap;
|
||||
lookupFragment: FragmentMapFunction;
|
||||
};
|
||||
//# sourceMappingURL=helpers.d.ts.map
|
||||
+96
@@ -0,0 +1,96 @@
|
||||
import { isReference, isField, DeepMerger, resultKeyNameFromField, shouldInclude, isNonNullObject, compact, createFragmentMap, getFragmentDefinitions, isArray, } from "../../utilities/index.js";
|
||||
export var hasOwn = Object.prototype.hasOwnProperty;
|
||||
export function isNullish(value) {
|
||||
return value === null || value === void 0;
|
||||
}
|
||||
export { isArray };
|
||||
export function defaultDataIdFromObject(_a, context) {
|
||||
var __typename = _a.__typename, id = _a.id, _id = _a._id;
|
||||
if (typeof __typename === "string") {
|
||||
if (context) {
|
||||
context.keyObject =
|
||||
!isNullish(id) ? { id: id }
|
||||
: !isNullish(_id) ? { _id: _id }
|
||||
: void 0;
|
||||
}
|
||||
// If there is no object.id, fall back to object._id.
|
||||
if (isNullish(id) && !isNullish(_id)) {
|
||||
id = _id;
|
||||
}
|
||||
if (!isNullish(id)) {
|
||||
return "".concat(__typename, ":").concat(typeof id === "number" || typeof id === "string" ?
|
||||
id
|
||||
: JSON.stringify(id));
|
||||
}
|
||||
}
|
||||
}
|
||||
var defaultConfig = {
|
||||
dataIdFromObject: defaultDataIdFromObject,
|
||||
addTypename: true,
|
||||
resultCaching: true,
|
||||
// Thanks to the shouldCanonizeResults helper, this should be the only line
|
||||
// you have to change to reenable canonization by default in the future.
|
||||
canonizeResults: false,
|
||||
};
|
||||
export function normalizeConfig(config) {
|
||||
return compact(defaultConfig, config);
|
||||
}
|
||||
export function shouldCanonizeResults(config) {
|
||||
var value = config.canonizeResults;
|
||||
return value === void 0 ? defaultConfig.canonizeResults : value;
|
||||
}
|
||||
export function getTypenameFromStoreObject(store, objectOrReference) {
|
||||
return isReference(objectOrReference) ?
|
||||
store.get(objectOrReference.__ref, "__typename")
|
||||
: objectOrReference && objectOrReference.__typename;
|
||||
}
|
||||
export var TypeOrFieldNameRegExp = /^[_a-z][_0-9a-z]*/i;
|
||||
export function fieldNameFromStoreName(storeFieldName) {
|
||||
var match = storeFieldName.match(TypeOrFieldNameRegExp);
|
||||
return match ? match[0] : storeFieldName;
|
||||
}
|
||||
export function selectionSetMatchesResult(selectionSet, result, variables) {
|
||||
if (isNonNullObject(result)) {
|
||||
return isArray(result) ?
|
||||
result.every(function (item) {
|
||||
return selectionSetMatchesResult(selectionSet, item, variables);
|
||||
})
|
||||
: selectionSet.selections.every(function (field) {
|
||||
if (isField(field) && shouldInclude(field, variables)) {
|
||||
var key = resultKeyNameFromField(field);
|
||||
return (hasOwn.call(result, key) &&
|
||||
(!field.selectionSet ||
|
||||
selectionSetMatchesResult(field.selectionSet, result[key], variables)));
|
||||
}
|
||||
// If the selection has been skipped with @skip(true) or
|
||||
// @include(false), it should not count against the matching. If
|
||||
// the selection is not a field, it must be a fragment (inline or
|
||||
// named). We will determine if selectionSetMatchesResult for that
|
||||
// fragment when we get to it, so for now we return true.
|
||||
return true;
|
||||
});
|
||||
}
|
||||
return false;
|
||||
}
|
||||
export function storeValueIsStoreObject(value) {
|
||||
return isNonNullObject(value) && !isReference(value) && !isArray(value);
|
||||
}
|
||||
export function makeProcessedFieldsMerger() {
|
||||
return new DeepMerger();
|
||||
}
|
||||
export function extractFragmentContext(document, fragments) {
|
||||
// FragmentMap consisting only of fragments defined directly in document, not
|
||||
// including other fragments registered in the FragmentRegistry.
|
||||
var fragmentMap = createFragmentMap(getFragmentDefinitions(document));
|
||||
return {
|
||||
fragmentMap: fragmentMap,
|
||||
lookupFragment: function (name) {
|
||||
var def = fragmentMap[name];
|
||||
if (!def && fragments) {
|
||||
def = fragments.lookup(name);
|
||||
}
|
||||
return def || null;
|
||||
},
|
||||
};
|
||||
}
|
||||
//# sourceMappingURL=helpers.js.map
|
||||
+1
File diff suppressed because one or more lines are too long
+65
@@ -0,0 +1,65 @@
|
||||
import "./fixPolyfills.js";
|
||||
import type { DocumentNode, FragmentDefinitionNode, InlineFragmentNode } from "graphql";
|
||||
import { ApolloCache } from "../core/cache.js";
|
||||
import type { Cache } from "../core/types/Cache.js";
|
||||
import type { StoreObject, Reference } from "../../utilities/index.js";
|
||||
import type { InMemoryCacheConfig, NormalizedCacheObject } from "./types.js";
|
||||
import { makeVar } from "./reactiveVars.js";
|
||||
import { Policies } from "./policies.js";
|
||||
import type { OperationVariables } from "../../core/index.js";
|
||||
import { getInMemoryCacheMemoryInternals } from "../../utilities/caching/getMemoryInternals.js";
|
||||
type BroadcastOptions = Pick<Cache.BatchOptions<InMemoryCache>, "optimistic" | "onWatchUpdated">;
|
||||
export declare class InMemoryCache extends ApolloCache<NormalizedCacheObject> {
|
||||
private data;
|
||||
private optimisticData;
|
||||
protected config: InMemoryCacheConfig;
|
||||
private watches;
|
||||
private addTypename;
|
||||
private storeReader;
|
||||
private storeWriter;
|
||||
private addTypenameTransform;
|
||||
private maybeBroadcastWatch;
|
||||
readonly assumeImmutableResults = true;
|
||||
readonly policies: Policies;
|
||||
readonly makeVar: typeof makeVar;
|
||||
constructor(config?: InMemoryCacheConfig);
|
||||
private init;
|
||||
private resetResultCache;
|
||||
restore(data: NormalizedCacheObject): this;
|
||||
extract(optimistic?: boolean): NormalizedCacheObject;
|
||||
read<T>(options: Cache.ReadOptions): T | null;
|
||||
write(options: Cache.WriteOptions): Reference | undefined;
|
||||
modify<Entity extends Record<string, any> = Record<string, any>>(options: Cache.ModifyOptions<Entity>): boolean;
|
||||
diff<TData, TVariables extends OperationVariables = any>(options: Cache.DiffOptions<TData, TVariables>): Cache.DiffResult<TData>;
|
||||
watch<TData = any, TVariables = any>(watch: Cache.WatchOptions<TData, TVariables>): () => void;
|
||||
gc(options?: {
|
||||
resetResultCache?: boolean;
|
||||
resetResultIdentities?: boolean;
|
||||
}): string[];
|
||||
retain(rootId: string, optimistic?: boolean): number;
|
||||
release(rootId: string, optimistic?: boolean): number;
|
||||
identify(object: StoreObject | Reference): string | undefined;
|
||||
evict(options: Cache.EvictOptions): boolean;
|
||||
reset(options?: Cache.ResetOptions): Promise<void>;
|
||||
removeOptimistic(idToRemove: string): void;
|
||||
private txCount;
|
||||
batch<TUpdateResult>(options: Cache.BatchOptions<InMemoryCache, TUpdateResult>): TUpdateResult;
|
||||
performTransaction(update: (cache: InMemoryCache) => any, optimisticId?: string | null): any;
|
||||
transformDocument(document: DocumentNode): DocumentNode;
|
||||
fragmentMatches(fragment: InlineFragmentNode, typename: string): boolean;
|
||||
lookupFragment(fragmentName: string): FragmentDefinitionNode | null;
|
||||
protected broadcastWatches(options?: BroadcastOptions): void;
|
||||
private addFragmentsToDocument;
|
||||
private addTypenameToDocument;
|
||||
private broadcastWatch;
|
||||
/**
|
||||
* @experimental
|
||||
* @internal
|
||||
* This is not a stable API - it is used in development builds to expose
|
||||
* information to the DevTools.
|
||||
* Use at your own risk!
|
||||
*/
|
||||
getMemoryInternals?: typeof getInMemoryCacheMemoryInternals;
|
||||
}
|
||||
export {};
|
||||
//# sourceMappingURL=inMemoryCache.d.ts.map
|
||||
+479
@@ -0,0 +1,479 @@
|
||||
import { __assign, __extends } from "tslib";
|
||||
import { invariant } from "../../utilities/globals/index.js";
|
||||
// Make builtins like Map and Set safe to use with non-extensible objects.
|
||||
import "./fixPolyfills.js";
|
||||
import { wrap } from "optimism";
|
||||
import { equal } from "@wry/equality";
|
||||
import { ApolloCache } from "../core/cache.js";
|
||||
import { MissingFieldError } from "../core/types/common.js";
|
||||
import { addTypenameToDocument, isReference, DocumentTransform, canonicalStringify, print, cacheSizes, } from "../../utilities/index.js";
|
||||
import { StoreReader } from "./readFromStore.js";
|
||||
import { StoreWriter } from "./writeToStore.js";
|
||||
import { EntityStore, supportsResultCaching } from "./entityStore.js";
|
||||
import { makeVar, forgetCache, recallCache } from "./reactiveVars.js";
|
||||
import { Policies } from "./policies.js";
|
||||
import { hasOwn, normalizeConfig, shouldCanonizeResults } from "./helpers.js";
|
||||
import { getInMemoryCacheMemoryInternals } from "../../utilities/caching/getMemoryInternals.js";
|
||||
var InMemoryCache = /** @class */ (function (_super) {
|
||||
__extends(InMemoryCache, _super);
|
||||
function InMemoryCache(config) {
|
||||
if (config === void 0) { config = {}; }
|
||||
var _this = _super.call(this) || this;
|
||||
_this.watches = new Set();
|
||||
_this.addTypenameTransform = new DocumentTransform(addTypenameToDocument);
|
||||
// Override the default value, since InMemoryCache result objects are frozen
|
||||
// in development and expected to remain logically immutable in production.
|
||||
_this.assumeImmutableResults = true;
|
||||
_this.makeVar = makeVar;
|
||||
_this.txCount = 0;
|
||||
_this.config = normalizeConfig(config);
|
||||
_this.addTypename = !!_this.config.addTypename;
|
||||
_this.policies = new Policies({
|
||||
cache: _this,
|
||||
dataIdFromObject: _this.config.dataIdFromObject,
|
||||
possibleTypes: _this.config.possibleTypes,
|
||||
typePolicies: _this.config.typePolicies,
|
||||
});
|
||||
_this.init();
|
||||
return _this;
|
||||
}
|
||||
InMemoryCache.prototype.init = function () {
|
||||
// Passing { resultCaching: false } in the InMemoryCache constructor options
|
||||
// will completely disable dependency tracking, which will improve memory
|
||||
// usage but worsen the performance of repeated reads.
|
||||
var rootStore = (this.data = new EntityStore.Root({
|
||||
policies: this.policies,
|
||||
resultCaching: this.config.resultCaching,
|
||||
}));
|
||||
// When no optimistic writes are currently active, cache.optimisticData ===
|
||||
// cache.data, so there are no additional layers on top of the actual data.
|
||||
// When an optimistic update happens, this.optimisticData will become a
|
||||
// linked list of EntityStore Layer objects that terminates with the
|
||||
// original this.data cache object.
|
||||
this.optimisticData = rootStore.stump;
|
||||
this.resetResultCache();
|
||||
};
|
||||
InMemoryCache.prototype.resetResultCache = function (resetResultIdentities) {
|
||||
var _this = this;
|
||||
var previousReader = this.storeReader;
|
||||
var fragments = this.config.fragments;
|
||||
// The StoreWriter is mostly stateless and so doesn't really need to be
|
||||
// reset, but it does need to have its writer.storeReader reference updated,
|
||||
// so it's simpler to update this.storeWriter as well.
|
||||
this.storeWriter = new StoreWriter(this, (this.storeReader = new StoreReader({
|
||||
cache: this,
|
||||
addTypename: this.addTypename,
|
||||
resultCacheMaxSize: this.config.resultCacheMaxSize,
|
||||
canonizeResults: shouldCanonizeResults(this.config),
|
||||
canon: resetResultIdentities ? void 0 : (previousReader && previousReader.canon),
|
||||
fragments: fragments,
|
||||
})), fragments);
|
||||
this.maybeBroadcastWatch = wrap(function (c, options) {
|
||||
return _this.broadcastWatch(c, options);
|
||||
}, {
|
||||
max: this.config.resultCacheMaxSize ||
|
||||
cacheSizes["inMemoryCache.maybeBroadcastWatch"] ||
|
||||
5000 /* defaultCacheSizes["inMemoryCache.maybeBroadcastWatch"] */,
|
||||
makeCacheKey: function (c) {
|
||||
// Return a cache key (thus enabling result caching) only if we're
|
||||
// currently using a data store that can track cache dependencies.
|
||||
var store = c.optimistic ? _this.optimisticData : _this.data;
|
||||
if (supportsResultCaching(store)) {
|
||||
var optimistic = c.optimistic, id = c.id, variables = c.variables;
|
||||
return store.makeCacheKey(c.query,
|
||||
// Different watches can have the same query, optimistic
|
||||
// status, rootId, and variables, but if their callbacks are
|
||||
// different, the (identical) result needs to be delivered to
|
||||
// each distinct callback. The easiest way to achieve that
|
||||
// separation is to include c.callback in the cache key for
|
||||
// maybeBroadcastWatch calls. See issue #5733.
|
||||
c.callback, canonicalStringify({ optimistic: optimistic, id: id, variables: variables }));
|
||||
}
|
||||
},
|
||||
});
|
||||
// Since we have thrown away all the cached functions that depend on the
|
||||
// CacheGroup dependencies maintained by EntityStore, we should also reset
|
||||
// all CacheGroup dependency information.
|
||||
new Set([this.data.group, this.optimisticData.group]).forEach(function (group) {
|
||||
return group.resetCaching();
|
||||
});
|
||||
};
|
||||
InMemoryCache.prototype.restore = function (data) {
|
||||
this.init();
|
||||
// Since calling this.init() discards/replaces the entire StoreReader, along
|
||||
// with the result caches it maintains, this.data.replace(data) won't have
|
||||
// to bother deleting the old data.
|
||||
if (data)
|
||||
this.data.replace(data);
|
||||
return this;
|
||||
};
|
||||
InMemoryCache.prototype.extract = function (optimistic) {
|
||||
if (optimistic === void 0) { optimistic = false; }
|
||||
return (optimistic ? this.optimisticData : this.data).extract();
|
||||
};
|
||||
InMemoryCache.prototype.read = function (options) {
|
||||
var
|
||||
// Since read returns data or null, without any additional metadata
|
||||
// about whether/where there might have been missing fields, the
|
||||
// default behavior cannot be returnPartialData = true (like it is
|
||||
// for the diff method), since defaulting to true would violate the
|
||||
// integrity of the T in the return type. However, partial data may
|
||||
// be useful in some cases, so returnPartialData:true may be
|
||||
// specified explicitly.
|
||||
_a = options.returnPartialData,
|
||||
// Since read returns data or null, without any additional metadata
|
||||
// about whether/where there might have been missing fields, the
|
||||
// default behavior cannot be returnPartialData = true (like it is
|
||||
// for the diff method), since defaulting to true would violate the
|
||||
// integrity of the T in the return type. However, partial data may
|
||||
// be useful in some cases, so returnPartialData:true may be
|
||||
// specified explicitly.
|
||||
returnPartialData = _a === void 0 ? false : _a;
|
||||
try {
|
||||
return (this.storeReader.diffQueryAgainstStore(__assign(__assign({}, options), { store: options.optimistic ? this.optimisticData : this.data, config: this.config, returnPartialData: returnPartialData })).result || null);
|
||||
}
|
||||
catch (e) {
|
||||
if (e instanceof MissingFieldError) {
|
||||
// Swallow MissingFieldError and return null, so callers do not need to
|
||||
// worry about catching "normal" exceptions resulting from incomplete
|
||||
// cache data. Unexpected errors will be re-thrown. If you need more
|
||||
// information about which fields were missing, use cache.diff instead,
|
||||
// and examine diffResult.missing.
|
||||
return null;
|
||||
}
|
||||
throw e;
|
||||
}
|
||||
};
|
||||
InMemoryCache.prototype.write = function (options) {
|
||||
try {
|
||||
++this.txCount;
|
||||
return this.storeWriter.writeToStore(this.data, options);
|
||||
}
|
||||
finally {
|
||||
if (!--this.txCount && options.broadcast !== false) {
|
||||
this.broadcastWatches();
|
||||
}
|
||||
}
|
||||
};
|
||||
InMemoryCache.prototype.modify = function (options) {
|
||||
if (hasOwn.call(options, "id") && !options.id) {
|
||||
// To my knowledge, TypeScript does not currently provide a way to
|
||||
// enforce that an optional property?:type must *not* be undefined
|
||||
// when present. That ability would be useful here, because we want
|
||||
// options.id to default to ROOT_QUERY only when no options.id was
|
||||
// provided. If the caller attempts to pass options.id with a
|
||||
// falsy/undefined value (perhaps because cache.identify failed), we
|
||||
// should not assume the goal was to modify the ROOT_QUERY object.
|
||||
// We could throw, but it seems natural to return false to indicate
|
||||
// that nothing was modified.
|
||||
return false;
|
||||
}
|
||||
var store = ((options.optimistic) // Defaults to false.
|
||||
) ?
|
||||
this.optimisticData
|
||||
: this.data;
|
||||
try {
|
||||
++this.txCount;
|
||||
return store.modify(options.id || "ROOT_QUERY", options.fields);
|
||||
}
|
||||
finally {
|
||||
if (!--this.txCount && options.broadcast !== false) {
|
||||
this.broadcastWatches();
|
||||
}
|
||||
}
|
||||
};
|
||||
InMemoryCache.prototype.diff = function (options) {
|
||||
return this.storeReader.diffQueryAgainstStore(__assign(__assign({}, options), { store: options.optimistic ? this.optimisticData : this.data, rootId: options.id || "ROOT_QUERY", config: this.config }));
|
||||
};
|
||||
InMemoryCache.prototype.watch = function (watch) {
|
||||
var _this = this;
|
||||
if (!this.watches.size) {
|
||||
// In case we previously called forgetCache(this) because
|
||||
// this.watches became empty (see below), reattach this cache to any
|
||||
// reactive variables on which it previously depended. It might seem
|
||||
// paradoxical that we're able to recall something we supposedly
|
||||
// forgot, but the point of calling forgetCache(this) is to silence
|
||||
// useless broadcasts while this.watches is empty, and to allow the
|
||||
// cache to be garbage collected. If, however, we manage to call
|
||||
// recallCache(this) here, this cache object must not have been
|
||||
// garbage collected yet, and should resume receiving updates from
|
||||
// reactive variables, now that it has a watcher to notify.
|
||||
recallCache(this);
|
||||
}
|
||||
this.watches.add(watch);
|
||||
if (watch.immediate) {
|
||||
this.maybeBroadcastWatch(watch);
|
||||
}
|
||||
return function () {
|
||||
// Once we remove the last watch from this.watches, cache.broadcastWatches
|
||||
// no longer does anything, so we preemptively tell the reactive variable
|
||||
// system to exclude this cache from future broadcasts.
|
||||
if (_this.watches.delete(watch) && !_this.watches.size) {
|
||||
forgetCache(_this);
|
||||
}
|
||||
// Remove this watch from the LRU cache managed by the
|
||||
// maybeBroadcastWatch OptimisticWrapperFunction, to prevent memory
|
||||
// leaks involving the closure of watch.callback.
|
||||
_this.maybeBroadcastWatch.forget(watch);
|
||||
};
|
||||
};
|
||||
InMemoryCache.prototype.gc = function (options) {
|
||||
var _a;
|
||||
canonicalStringify.reset();
|
||||
print.reset();
|
||||
this.addTypenameTransform.resetCache();
|
||||
(_a = this.config.fragments) === null || _a === void 0 ? void 0 : _a.resetCaches();
|
||||
var ids = this.optimisticData.gc();
|
||||
if (options && !this.txCount) {
|
||||
if (options.resetResultCache) {
|
||||
this.resetResultCache(options.resetResultIdentities);
|
||||
}
|
||||
else if (options.resetResultIdentities) {
|
||||
this.storeReader.resetCanon();
|
||||
}
|
||||
}
|
||||
return ids;
|
||||
};
|
||||
// Call this method to ensure the given root ID remains in the cache after
|
||||
// garbage collection, along with its transitive child entities. Note that
|
||||
// the cache automatically retains all directly written entities. By default,
|
||||
// the retainment persists after optimistic updates are removed. Pass true
|
||||
// for the optimistic argument if you would prefer for the retainment to be
|
||||
// discarded when the top-most optimistic layer is removed. Returns the
|
||||
// resulting (non-negative) retainment count.
|
||||
InMemoryCache.prototype.retain = function (rootId, optimistic) {
|
||||
return (optimistic ? this.optimisticData : this.data).retain(rootId);
|
||||
};
|
||||
// Call this method to undo the effect of the retain method, above. Once the
|
||||
// retainment count falls to zero, the given ID will no longer be preserved
|
||||
// during garbage collection, though it may still be preserved by other safe
|
||||
// entities that refer to it. Returns the resulting (non-negative) retainment
|
||||
// count, in case that's useful.
|
||||
InMemoryCache.prototype.release = function (rootId, optimistic) {
|
||||
return (optimistic ? this.optimisticData : this.data).release(rootId);
|
||||
};
|
||||
// Returns the canonical ID for a given StoreObject, obeying typePolicies
|
||||
// and keyFields (and dataIdFromObject, if you still use that). At minimum,
|
||||
// the object must contain a __typename and any primary key fields required
|
||||
// to identify entities of that type. If you pass a query result object, be
|
||||
// sure that none of the primary key fields have been renamed by aliasing.
|
||||
// If you pass a Reference object, its __ref ID string will be returned.
|
||||
InMemoryCache.prototype.identify = function (object) {
|
||||
if (isReference(object))
|
||||
return object.__ref;
|
||||
try {
|
||||
return this.policies.identify(object)[0];
|
||||
}
|
||||
catch (e) {
|
||||
globalThis.__DEV__ !== false && invariant.warn(e);
|
||||
}
|
||||
};
|
||||
InMemoryCache.prototype.evict = function (options) {
|
||||
if (!options.id) {
|
||||
if (hasOwn.call(options, "id")) {
|
||||
// See comment in modify method about why we return false when
|
||||
// options.id exists but is falsy/undefined.
|
||||
return false;
|
||||
}
|
||||
options = __assign(__assign({}, options), { id: "ROOT_QUERY" });
|
||||
}
|
||||
try {
|
||||
// It's unlikely that the eviction will end up invoking any other
|
||||
// cache update operations while it's running, but {in,de}crementing
|
||||
// this.txCount still seems like a good idea, for uniformity with
|
||||
// the other update methods.
|
||||
++this.txCount;
|
||||
// Pass this.data as a limit on the depth of the eviction, so evictions
|
||||
// during optimistic updates (when this.data is temporarily set equal to
|
||||
// this.optimisticData) do not escape their optimistic Layer.
|
||||
return this.optimisticData.evict(options, this.data);
|
||||
}
|
||||
finally {
|
||||
if (!--this.txCount && options.broadcast !== false) {
|
||||
this.broadcastWatches();
|
||||
}
|
||||
}
|
||||
};
|
||||
InMemoryCache.prototype.reset = function (options) {
|
||||
var _this = this;
|
||||
this.init();
|
||||
canonicalStringify.reset();
|
||||
if (options && options.discardWatches) {
|
||||
// Similar to what happens in the unsubscribe function returned by
|
||||
// cache.watch, applied to all current watches.
|
||||
this.watches.forEach(function (watch) { return _this.maybeBroadcastWatch.forget(watch); });
|
||||
this.watches.clear();
|
||||
forgetCache(this);
|
||||
}
|
||||
else {
|
||||
// Calling this.init() above unblocks all maybeBroadcastWatch caching, so
|
||||
// this.broadcastWatches() triggers a broadcast to every current watcher
|
||||
// (letting them know their data is now missing). This default behavior is
|
||||
// convenient because it means the watches do not have to be manually
|
||||
// reestablished after resetting the cache. To prevent this broadcast and
|
||||
// cancel all watches, pass true for options.discardWatches.
|
||||
this.broadcastWatches();
|
||||
}
|
||||
return Promise.resolve();
|
||||
};
|
||||
InMemoryCache.prototype.removeOptimistic = function (idToRemove) {
|
||||
var newOptimisticData = this.optimisticData.removeLayer(idToRemove);
|
||||
if (newOptimisticData !== this.optimisticData) {
|
||||
this.optimisticData = newOptimisticData;
|
||||
this.broadcastWatches();
|
||||
}
|
||||
};
|
||||
InMemoryCache.prototype.batch = function (options) {
|
||||
var _this = this;
|
||||
var update = options.update, _a = options.optimistic, optimistic = _a === void 0 ? true : _a, removeOptimistic = options.removeOptimistic, onWatchUpdated = options.onWatchUpdated;
|
||||
var updateResult;
|
||||
var perform = function (layer) {
|
||||
var _a = _this, data = _a.data, optimisticData = _a.optimisticData;
|
||||
++_this.txCount;
|
||||
if (layer) {
|
||||
_this.data = _this.optimisticData = layer;
|
||||
}
|
||||
try {
|
||||
return (updateResult = update(_this));
|
||||
}
|
||||
finally {
|
||||
--_this.txCount;
|
||||
_this.data = data;
|
||||
_this.optimisticData = optimisticData;
|
||||
}
|
||||
};
|
||||
var alreadyDirty = new Set();
|
||||
if (onWatchUpdated && !this.txCount) {
|
||||
// If an options.onWatchUpdated callback is provided, we want to call it
|
||||
// with only the Cache.WatchOptions objects affected by options.update,
|
||||
// but there might be dirty watchers already waiting to be broadcast that
|
||||
// have nothing to do with the update. To prevent including those watchers
|
||||
// in the post-update broadcast, we perform this initial broadcast to
|
||||
// collect the dirty watchers, so we can re-dirty them later, after the
|
||||
// post-update broadcast, allowing them to receive their pending
|
||||
// broadcasts the next time broadcastWatches is called, just as they would
|
||||
// if we never called cache.batch.
|
||||
this.broadcastWatches(__assign(__assign({}, options), { onWatchUpdated: function (watch) {
|
||||
alreadyDirty.add(watch);
|
||||
return false;
|
||||
} }));
|
||||
}
|
||||
if (typeof optimistic === "string") {
|
||||
// Note that there can be multiple layers with the same optimistic ID.
|
||||
// When removeOptimistic(id) is called for that id, all matching layers
|
||||
// will be removed, and the remaining layers will be reapplied.
|
||||
this.optimisticData = this.optimisticData.addLayer(optimistic, perform);
|
||||
}
|
||||
else if (optimistic === false) {
|
||||
// Ensure both this.data and this.optimisticData refer to the root
|
||||
// (non-optimistic) layer of the cache during the update. Note that
|
||||
// this.data could be a Layer if we are currently executing an optimistic
|
||||
// update function, but otherwise will always be an EntityStore.Root
|
||||
// instance.
|
||||
perform(this.data);
|
||||
}
|
||||
else {
|
||||
// Otherwise, leave this.data and this.optimisticData unchanged and run
|
||||
// the update with broadcast batching.
|
||||
perform();
|
||||
}
|
||||
if (typeof removeOptimistic === "string") {
|
||||
this.optimisticData = this.optimisticData.removeLayer(removeOptimistic);
|
||||
}
|
||||
// Note: if this.txCount > 0, then alreadyDirty.size === 0, so this code
|
||||
// takes the else branch and calls this.broadcastWatches(options), which
|
||||
// does nothing when this.txCount > 0.
|
||||
if (onWatchUpdated && alreadyDirty.size) {
|
||||
this.broadcastWatches(__assign(__assign({}, options), { onWatchUpdated: function (watch, diff) {
|
||||
var result = onWatchUpdated.call(this, watch, diff);
|
||||
if (result !== false) {
|
||||
// Since onWatchUpdated did not return false, this diff is
|
||||
// about to be broadcast to watch.callback, so we don't need
|
||||
// to re-dirty it with the other alreadyDirty watches below.
|
||||
alreadyDirty.delete(watch);
|
||||
}
|
||||
return result;
|
||||
} }));
|
||||
// Silently re-dirty any watches that were already dirty before the update
|
||||
// was performed, and were not broadcast just now.
|
||||
if (alreadyDirty.size) {
|
||||
alreadyDirty.forEach(function (watch) { return _this.maybeBroadcastWatch.dirty(watch); });
|
||||
}
|
||||
}
|
||||
else {
|
||||
// If alreadyDirty is empty or we don't have an onWatchUpdated
|
||||
// function, we don't need to go to the trouble of wrapping
|
||||
// options.onWatchUpdated.
|
||||
this.broadcastWatches(options);
|
||||
}
|
||||
return updateResult;
|
||||
};
|
||||
InMemoryCache.prototype.performTransaction = function (update, optimisticId) {
|
||||
return this.batch({
|
||||
update: update,
|
||||
optimistic: optimisticId || optimisticId !== null,
|
||||
});
|
||||
};
|
||||
InMemoryCache.prototype.transformDocument = function (document) {
|
||||
return this.addTypenameToDocument(this.addFragmentsToDocument(document));
|
||||
};
|
||||
InMemoryCache.prototype.fragmentMatches = function (fragment, typename) {
|
||||
return this.policies.fragmentMatches(fragment, typename);
|
||||
};
|
||||
InMemoryCache.prototype.lookupFragment = function (fragmentName) {
|
||||
var _a;
|
||||
return ((_a = this.config.fragments) === null || _a === void 0 ? void 0 : _a.lookup(fragmentName)) || null;
|
||||
};
|
||||
InMemoryCache.prototype.broadcastWatches = function (options) {
|
||||
var _this = this;
|
||||
if (!this.txCount) {
|
||||
this.watches.forEach(function (c) { return _this.maybeBroadcastWatch(c, options); });
|
||||
}
|
||||
};
|
||||
InMemoryCache.prototype.addFragmentsToDocument = function (document) {
|
||||
var fragments = this.config.fragments;
|
||||
return fragments ? fragments.transform(document) : document;
|
||||
};
|
||||
InMemoryCache.prototype.addTypenameToDocument = function (document) {
|
||||
if (this.addTypename) {
|
||||
return this.addTypenameTransform.transformDocument(document);
|
||||
}
|
||||
return document;
|
||||
};
|
||||
// This method is wrapped by maybeBroadcastWatch, which is called by
|
||||
// broadcastWatches, so that we compute and broadcast results only when
|
||||
// the data that would be broadcast might have changed. It would be
|
||||
// simpler to check for changes after recomputing a result but before
|
||||
// broadcasting it, but this wrapping approach allows us to skip both
|
||||
// the recomputation and the broadcast, in most cases.
|
||||
InMemoryCache.prototype.broadcastWatch = function (c, options) {
|
||||
var lastDiff = c.lastDiff;
|
||||
// Both WatchOptions and DiffOptions extend ReadOptions, and DiffOptions
|
||||
// currently requires no additional properties, so we can use c (a
|
||||
// WatchOptions object) as DiffOptions, without having to allocate a new
|
||||
// object, and without having to enumerate the relevant properties (query,
|
||||
// variables, etc.) explicitly. There will be some additional properties
|
||||
// (lastDiff, callback, etc.), but cache.diff ignores them.
|
||||
var diff = this.diff(c);
|
||||
if (options) {
|
||||
if (c.optimistic && typeof options.optimistic === "string") {
|
||||
diff.fromOptimisticTransaction = true;
|
||||
}
|
||||
if (options.onWatchUpdated &&
|
||||
options.onWatchUpdated.call(this, c, diff, lastDiff) === false) {
|
||||
// Returning false from the onWatchUpdated callback will prevent
|
||||
// calling c.callback(diff) for this watcher.
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (!lastDiff || !equal(lastDiff.result, diff.result)) {
|
||||
c.callback((c.lastDiff = diff), lastDiff);
|
||||
}
|
||||
};
|
||||
return InMemoryCache;
|
||||
}(ApolloCache));
|
||||
export { InMemoryCache };
|
||||
if (globalThis.__DEV__ !== false) {
|
||||
InMemoryCache.prototype.getMemoryInternals = getInMemoryCacheMemoryInternals;
|
||||
}
|
||||
//# sourceMappingURL=inMemoryCache.js.map
|
||||
+1
File diff suppressed because one or more lines are too long
+9
@@ -0,0 +1,9 @@
|
||||
import type { KeySpecifier, KeyFieldsFunction, KeyArgsFunction } from "./policies.js";
|
||||
export declare function keyFieldsFnFromSpecifier(specifier: KeySpecifier): KeyFieldsFunction;
|
||||
export declare function keyArgsFnFromSpecifier(specifier: KeySpecifier): KeyArgsFunction;
|
||||
export declare function collectSpecifierPaths(specifier: KeySpecifier, extractor: (path: string[]) => any): Record<string, any>;
|
||||
export declare function getSpecifierPaths(spec: KeySpecifier): string[][];
|
||||
declare function extractKey<TObj extends Record<string, any>, TKey extends string>(object: TObj, key: TKey): TObj[TKey] | undefined;
|
||||
export declare function extractKeyPath(object: Record<string, any>, path: string[], extract?: typeof extractKey): any;
|
||||
export {};
|
||||
//# sourceMappingURL=key-extractor.d.ts.map
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user