@apollo/client 3.6.1 → 3.6.4

package/react/parser/parser.cjs.native.js

@@ -0,0 +1,103 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var globals = require('../../utilities/globals');
+
+exports.DocumentType = void 0;
+(function (DocumentType) {
+    DocumentType[DocumentType["Query"] = 0] = "Query";
+    DocumentType[DocumentType["Mutation"] = 1] = "Mutation";
+    DocumentType[DocumentType["Subscription"] = 2] = "Subscription";
+})(exports.DocumentType || (exports.DocumentType = {}));
+var cache = new Map();
+function operationName(type) {
+    var name;
+    switch (type) {
+        case exports.DocumentType.Query:
+            name = 'Query';
+            break;
+        case exports.DocumentType.Mutation:
+            name = 'Mutation';
+            break;
+        case exports.DocumentType.Subscription:
+            name = 'Subscription';
+            break;
+    }
+    return name;
+}
+function parser(document) {
+    var cached = cache.get(document);
+    if (cached)
+        return cached;
+    var variables, type, name;
+    __DEV__ ? globals.invariant(!!document && !!document.kind, "Argument of ".concat(document, " passed to parser was not a valid GraphQL ") +
+        "DocumentNode. You may need to use 'graphql-tag' or another method " +
+        "to convert your operation into a document") : globals.invariant(!!document && !!document.kind, 30);
+    var fragments = [];
+    var queries = [];
+    var mutations = [];
+    var subscriptions = [];
+    for (var _i = 0, _a = document.definitions; _i < _a.length; _i++) {
+        var x = _a[_i];
+        if (x.kind === 'FragmentDefinition') {
+            fragments.push(x);
+            continue;
+        }
+        if (x.kind === 'OperationDefinition') {
+            switch (x.operation) {
+                case 'query':
+                    queries.push(x);
+                    break;
+                case 'mutation':
+                    mutations.push(x);
+                    break;
+                case 'subscription':
+                    subscriptions.push(x);
+                    break;
+            }
+        }
+    }
+    __DEV__ ? globals.invariant(!fragments.length ||
+        (queries.length || mutations.length || subscriptions.length), "Passing only a fragment to 'graphql' is not yet supported. " +
+        "You must include a query, subscription or mutation as well") : globals.invariant(!fragments.length ||
+        (queries.length || mutations.length || subscriptions.length), 31);
+    __DEV__ ? globals.invariant(queries.length + mutations.length + subscriptions.length <= 1, "react-apollo only supports a query, subscription, or a mutation per HOC. " +
+        "".concat(document, " had ").concat(queries.length, " queries, ").concat(subscriptions.length, " ") +
+        "subscriptions and ".concat(mutations.length, " mutations. ") +
+        "You can use 'compose' to join multiple operation types to a component") : globals.invariant(queries.length + mutations.length + subscriptions.length <= 1, 32);
+    type = queries.length ? exports.DocumentType.Query : exports.DocumentType.Mutation;
+    if (!queries.length && !mutations.length)
+        type = exports.DocumentType.Subscription;
+    var definitions = queries.length
+        ? queries
+        : mutations.length
+            ? mutations
+            : subscriptions;
+    __DEV__ ? globals.invariant(definitions.length === 1, "react-apollo only supports one definition per HOC. ".concat(document, " had ") +
+        "".concat(definitions.length, " definitions. ") +
+        "You can use 'compose' to join multiple operation types to a component") : globals.invariant(definitions.length === 1, 33);
+    var definition = definitions[0];
+    variables = definition.variableDefinitions || [];
+    if (definition.name && definition.name.kind === 'Name') {
+        name = definition.name.value;
+    }
+    else {
+        name = 'data';
+    }
+    var payload = { name: name, type: type, variables: variables };
+    cache.set(document, payload);
+    return payload;
+}
+function verifyDocumentType(document, type) {
+    var operation = parser(document);
+    var requiredOperationName = operationName(type);
+    var usedOperationName = operationName(operation.type);
+    __DEV__ ? globals.invariant(operation.type === type, "Running a ".concat(requiredOperationName, " requires a graphql ") +
+        "".concat(requiredOperationName, ", but a ").concat(usedOperationName, " was used instead.")) : globals.invariant(operation.type === type, 34);
+}
+
+exports.operationName = operationName;
+exports.parser = parser;
+exports.verifyDocumentType = verifyDocumentType;
+//# sourceMappingURL=parser.cjs.map

package/react/react.cjs.native.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../utilities/globals');
+var context = require('./context');
+var hooks = require('./hooks');
+var parser = require('./parser');
+
+
+
+exports.ApolloConsumer = context.ApolloConsumer;
+exports.ApolloProvider = context.ApolloProvider;
+exports.getApolloContext = context.getApolloContext;
+exports.resetApolloContext = context.resetApolloContext;
+exports.DocumentType = parser.DocumentType;
+exports.operationName = parser.operationName;
+exports.parser = parser.parser;
+for (var k in hooks) {
+	if (k !== 'default' && !exports.hasOwnProperty(k)) exports[k] = hooks[k];
+}
+//# sourceMappingURL=react.cjs.map

package/react/ssr/ssr.cjs.native.js

@@ -0,0 +1,150 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var React = require('react');
+var context = require('../context');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        for (var k in e) {
+            n[k] = e[k];
+        }
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+function makeDefaultQueryInfo() {
+    return {
+        seen: false,
+        observable: null
+    };
+}
+var RenderPromises = (function () {
+    function RenderPromises() {
+        this.queryPromises = new Map();
+        this.queryInfoTrie = new Map();
+        this.stopped = false;
+    }
+    RenderPromises.prototype.stop = function () {
+        if (!this.stopped) {
+            this.queryPromises.clear();
+            this.queryInfoTrie.clear();
+            this.stopped = true;
+        }
+    };
+    RenderPromises.prototype.registerSSRObservable = function (observable) {
+        if (this.stopped)
+            return;
+        this.lookupQueryInfo(observable.options).observable = observable;
+    };
+    RenderPromises.prototype.getSSRObservable = function (props) {
+        return this.lookupQueryInfo(props).observable;
+    };
+    RenderPromises.prototype.addQueryPromise = function (queryInstance, finish) {
+        if (!this.stopped) {
+            var info = this.lookupQueryInfo(queryInstance.getOptions());
+            if (!info.seen) {
+                this.queryPromises.set(queryInstance.getOptions(), new Promise(function (resolve) {
+                    resolve(queryInstance.fetchData());
+                }));
+                return null;
+            }
+        }
+        return finish ? finish() : null;
+    };
+    RenderPromises.prototype.addObservableQueryPromise = function (obsQuery) {
+        return this.addQueryPromise({
+            getOptions: function () { return obsQuery.options; },
+            fetchData: function () { return new Promise(function (resolve) {
+                var sub = obsQuery.subscribe({
+                    next: function (result) {
+                        if (!result.loading) {
+                            resolve();
+                            sub.unsubscribe();
+                        }
+                    },
+                    error: function () {
+                        resolve();
+                        sub.unsubscribe();
+                    },
+                    complete: function () {
+                        resolve();
+                    },
+                });
+            }); },
+        });
+    };
+    RenderPromises.prototype.hasPromises = function () {
+        return this.queryPromises.size > 0;
+    };
+    RenderPromises.prototype.consumeAndAwaitPromises = function () {
+        var _this = this;
+        var promises = [];
+        this.queryPromises.forEach(function (promise, queryInstance) {
+            _this.lookupQueryInfo(queryInstance).seen = true;
+            promises.push(promise);
+        });
+        this.queryPromises.clear();
+        return Promise.all(promises);
+    };
+    RenderPromises.prototype.lookupQueryInfo = function (props) {
+        var queryInfoTrie = this.queryInfoTrie;
+        var query = props.query, variables = props.variables;
+        var varMap = queryInfoTrie.get(query) || new Map();
+        if (!queryInfoTrie.has(query))
+            queryInfoTrie.set(query, varMap);
+        var variablesString = JSON.stringify(variables);
+        var info = varMap.get(variablesString) || makeDefaultQueryInfo();
+        if (!varMap.has(variablesString))
+            varMap.set(variablesString, info);
+        return info;
+    };
+    return RenderPromises;
+}());
+
+function getDataFromTree(tree, context) {
+    if (context === void 0) { context = {}; }
+    return getMarkupFromTree({
+        tree: tree,
+        context: context,
+        renderFunction: require('react-dom/server').renderToStaticMarkup
+    });
+}
+function getMarkupFromTree(_a) {
+    var tree = _a.tree, _b = _a.context, context$1 = _b === void 0 ? {} : _b, _c = _a.renderFunction, renderFunction = _c === void 0 ? require('react-dom/server').renderToStaticMarkup : _c;
+    var renderPromises = new RenderPromises();
+    function process() {
+        var ApolloContext = context.getApolloContext();
+        return new Promise(function (resolve) {
+            var element = React__namespace.createElement(ApolloContext.Provider, { value: tslib.__assign(tslib.__assign({}, context$1), { renderPromises: renderPromises }) }, tree);
+            resolve(renderFunction(element));
+        }).then(function (html) {
+            return renderPromises.hasPromises()
+                ? renderPromises.consumeAndAwaitPromises().then(process)
+                : html;
+        }).finally(function () {
+            renderPromises.stop();
+        });
+    }
+    return Promise.resolve().then(process);
+}
+
+function renderToStringWithData(component) {
+    return getMarkupFromTree({
+        tree: component,
+        renderFunction: require('react-dom/server').renderToString
+    });
+}
+
+exports.RenderPromises = RenderPromises;
+exports.getDataFromTree = getDataFromTree;
+exports.getMarkupFromTree = getMarkupFromTree;
+exports.renderToStringWithData = renderToStringWithData;
+//# sourceMappingURL=ssr.cjs.map

package/testing/core/core.cjs.native.js

@@ -0,0 +1,288 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var globals = require('../../utilities/globals');
+var graphql = require('graphql');
+var equality = require('@wry/equality');
+var core = require('../../link/core');
+var utilities = require('../../utilities');
+var core$1 = require('../../core');
+var cache = require('../../cache');
+
+function requestToKey(request, addTypename) {
+    var queryString = request.query &&
+        graphql.print(addTypename ? utilities.addTypenameToDocument(request.query) : request.query);
+    var requestKey = { query: queryString };
+    return JSON.stringify(requestKey);
+}
+var MockLink = (function (_super) {
+    tslib.__extends(MockLink, _super);
+    function MockLink(mockedResponses, addTypename) {
+        if (addTypename === void 0) { addTypename = true; }
+        var _this = _super.call(this) || this;
+        _this.addTypename = true;
+        _this.mockedResponsesByKey = {};
+        _this.addTypename = addTypename;
+        if (mockedResponses) {
+            mockedResponses.forEach(function (mockedResponse) {
+                _this.addMockedResponse(mockedResponse);
+            });
+        }
+        return _this;
+    }
+    MockLink.prototype.addMockedResponse = function (mockedResponse) {
+        var normalizedMockedResponse = this.normalizeMockedResponse(mockedResponse);
+        var key = requestToKey(normalizedMockedResponse.request, this.addTypename);
+        var mockedResponses = this.mockedResponsesByKey[key];
+        if (!mockedResponses) {
+            mockedResponses = [];
+            this.mockedResponsesByKey[key] = mockedResponses;
+        }
+        mockedResponses.push(normalizedMockedResponse);
+    };
+    MockLink.prototype.request = function (operation) {
+        var _this = this;
+        this.operation = operation;
+        var key = requestToKey(operation, this.addTypename);
+        var unmatchedVars = [];
+        var requestVariables = operation.variables || {};
+        var mockedResponses = this.mockedResponsesByKey[key];
+        var responseIndex = mockedResponses ? mockedResponses.findIndex(function (res, index) {
+            var mockedResponseVars = res.request.variables || {};
+            if (equality.equal(requestVariables, mockedResponseVars)) {
+                return true;
+            }
+            unmatchedVars.push(mockedResponseVars);
+            return false;
+        }) : -1;
+        var response = responseIndex >= 0
+            ? mockedResponses[responseIndex]
+            : void 0;
+        var configError;
+        if (!response) {
+            configError = new Error("No more mocked responses for the query: ".concat(graphql.print(operation.query), "\nExpected variables: ").concat(utilities.stringifyForDisplay(operation.variables), "\n").concat(unmatchedVars.length > 0 ? "\nFailed to match ".concat(unmatchedVars.length, " mock").concat(unmatchedVars.length === 1 ? "" : "s", " for this query, which had the following variables:\n").concat(unmatchedVars.map(function (d) { return "  ".concat(utilities.stringifyForDisplay(d)); }).join('\n'), "\n") : ""));
+        }
+        else {
+            mockedResponses.splice(responseIndex, 1);
+            var newData = response.newData;
+            if (newData) {
+                response.result = newData();
+                mockedResponses.push(response);
+            }
+            if (!response.result && !response.error) {
+                configError = new Error("Mocked response should contain either result or error: ".concat(key));
+            }
+        }
+        return new utilities.Observable(function (observer) {
+            var timer = setTimeout(function () {
+                if (configError) {
+                    try {
+                        if (_this.onError(configError, observer) !== false) {
+                            throw configError;
+                        }
+                    }
+                    catch (error) {
+                        observer.error(error);
+                    }
+                }
+                else if (response) {
+                    if (response.error) {
+                        observer.error(response.error);
+                    }
+                    else {
+                        if (response.result) {
+                            observer.next(typeof response.result === 'function'
+                                ? response.result()
+                                : response.result);
+                        }
+                        observer.complete();
+                    }
+                }
+            }, response && response.delay || 0);
+            return function () {
+                clearTimeout(timer);
+            };
+        });
+    };
+    MockLink.prototype.normalizeMockedResponse = function (mockedResponse) {
+        var newMockedResponse = utilities.cloneDeep(mockedResponse);
+        var queryWithoutConnection = utilities.removeConnectionDirectiveFromDocument(newMockedResponse.request.query);
+        __DEV__ ? globals.invariant(queryWithoutConnection, "query is required") : globals.invariant(queryWithoutConnection, 35);
+        newMockedResponse.request.query = queryWithoutConnection;
+        var query = utilities.removeClientSetsFromDocument(newMockedResponse.request.query);
+        if (query) {
+            newMockedResponse.request.query = query;
+        }
+        return newMockedResponse;
+    };
+    return MockLink;
+}(core.ApolloLink));
+function mockSingleLink() {
+    var mockedResponses = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        mockedResponses[_i] = arguments[_i];
+    }
+    var maybeTypename = mockedResponses[mockedResponses.length - 1];
+    var mocks = mockedResponses.slice(0, mockedResponses.length - 1);
+    if (typeof maybeTypename !== 'boolean') {
+        mocks = mockedResponses;
+        maybeTypename = true;
+    }
+    return new MockLink(mocks, maybeTypename);
+}
+
+var MockSubscriptionLink = (function (_super) {
+    tslib.__extends(MockSubscriptionLink, _super);
+    function MockSubscriptionLink() {
+        var _this = _super.call(this) || this;
+        _this.unsubscribers = [];
+        _this.setups = [];
+        _this.observers = [];
+        return _this;
+    }
+    MockSubscriptionLink.prototype.request = function (operation) {
+        var _this = this;
+        this.operation = operation;
+        return new utilities.Observable(function (observer) {
+            _this.setups.forEach(function (x) { return x(); });
+            _this.observers.push(observer);
+            return function () {
+                _this.unsubscribers.forEach(function (x) { return x(); });
+            };
+        });
+    };
+    MockSubscriptionLink.prototype.simulateResult = function (result, complete) {
+        var _this = this;
+        if (complete === void 0) { complete = false; }
+        setTimeout(function () {
+            var observers = _this.observers;
+            if (!observers.length)
+                throw new Error('subscription torn down');
+            observers.forEach(function (observer) {
+                if (result.result && observer.next)
+                    observer.next(result.result);
+                if (result.error && observer.error)
+                    observer.error(result.error);
+                if (complete && observer.complete)
+                    observer.complete();
+            });
+        }, result.delay || 0);
+    };
+    MockSubscriptionLink.prototype.simulateComplete = function () {
+        var observers = this.observers;
+        if (!observers.length)
+            throw new Error('subscription torn down');
+        observers.forEach(function (observer) {
+            if (observer.complete)
+                observer.complete();
+        });
+    };
+    MockSubscriptionLink.prototype.onSetup = function (listener) {
+        this.setups = this.setups.concat([listener]);
+    };
+    MockSubscriptionLink.prototype.onUnsubscribe = function (listener) {
+        this.unsubscribers = this.unsubscribers.concat([listener]);
+    };
+    return MockSubscriptionLink;
+}(core.ApolloLink));
+function mockObservableLink() {
+    return new MockSubscriptionLink();
+}
+
+function createMockClient(data, query, variables) {
+    if (variables === void 0) { variables = {}; }
+    return new core$1.ApolloClient({
+        link: mockSingleLink({
+            request: { query: query, variables: variables },
+            result: { data: data },
+        }).setOnError(function (error) { throw error; }),
+        cache: new cache.InMemoryCache({ addTypename: false }),
+    });
+}
+
+function subscribeAndCount(reject, observable, cb) {
+    var queue = Promise.resolve();
+    var handleCount = 0;
+    var subscription = utilities.asyncMap(observable, function (result) {
+        return queue = queue.then(function () {
+            return cb(++handleCount, result);
+        }).catch(error);
+    }).subscribe({ error: error });
+    function error(e) {
+        subscription.unsubscribe();
+        reject(e);
+    }
+    return subscription;
+}
+
+function wrap(key) {
+    return function (message, callback, timeout) { return (key ? it[key] : it)(message, function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) { return callback.call(_this, resolve, reject); });
+    }, timeout); };
+}
+var wrappedIt = wrap();
+var itAsync = Object.assign(function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return wrappedIt.apply(this, args);
+}, {
+    only: wrap("only"),
+    skip: wrap("skip"),
+    todo: wrap("todo"),
+});
+
+function wrapTestFunction(fn, consoleMethodName) {
+    return function () {
+        var _this = this;
+        var args = arguments;
+        var spy = jest.spyOn(console, consoleMethodName);
+        spy.mockImplementation(function () { });
+        return new Promise(function (resolve) {
+            resolve(fn === null || fn === void 0 ? void 0 : fn.apply(_this, args));
+        }).finally(function () {
+            expect(spy).toMatchSnapshot();
+            spy.mockReset();
+        });
+    };
+}
+function withErrorSpy(it) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    args[1] = wrapTestFunction(args[1], "error");
+    return it.apply(void 0, args);
+}
+function withWarningSpy(it) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    args[1] = wrapTestFunction(args[1], "warn");
+    return it.apply(void 0, args);
+}
+function withLogSpy(it) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    args[1] = wrapTestFunction(args[1], "log");
+    return it.apply(void 0, args);
+}
+
+exports.MockLink = MockLink;
+exports.MockSubscriptionLink = MockSubscriptionLink;
+exports.createMockClient = createMockClient;
+exports.itAsync = itAsync;
+exports.mockObservableLink = mockObservableLink;
+exports.mockSingleLink = mockSingleLink;
+exports.subscribeAndCount = subscribeAndCount;
+exports.withErrorSpy = withErrorSpy;
+exports.withLogSpy = withLogSpy;
+exports.withWarningSpy = withWarningSpy;
+//# sourceMappingURL=core.cjs.map

package/testing/core/mocking/mockQueryManager.js

@@ -1,7 +1,7 @@
 import { QueryManager } from "../../../core/QueryManager.js";
 import { mockSingleLink } from "./mockLink.js";
 import { InMemoryCache } from "../../../cache/index.js";
-export default (function (reject) {
+export default (function(reject) {
     var mockedResponses = [];
     for (var _i = 1; _i < arguments.length; _i++) {
         mockedResponses[_i - 1] = arguments[_i];

package/testing/core/mocking/mockWatchQuery.js

@@ -1,6 +1,6 @@
 import { __spreadArray } from "tslib";
 import mockQueryManager from "./mockQueryManager.js";
-export default (function (reject) {
+export default (function(reject) {
     var mockedResponses = [];
     for (var _i = 1; _i < arguments.length; _i++) {
         mockedResponses[_i - 1] = arguments[_i];

package/testing/core/wrap.js

@@ -1,4 +1,4 @@
-export default (function (reject, cb) { return function () {
+export default (function(reject, cb) { return function () {
     var args = [];
     for (var _i = 0; _i < arguments.length; _i++) {
         args[_i] = arguments[_i];

package/testing/testing.cjs.native.js

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../utilities/globals');
+var tslib = require('tslib');
+var React = require('react');
+var core$1 = require('../core');
+var cache = require('../cache');
+var context = require('../react/context');
+var core = require('./core');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        for (var k in e) {
+            n[k] = e[k];
+        }
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+var MockedProvider = (function (_super) {
+    tslib.__extends(MockedProvider, _super);
+    function MockedProvider(props) {
+        var _this = _super.call(this, props) || this;
+        var _a = _this.props, mocks = _a.mocks, addTypename = _a.addTypename, defaultOptions = _a.defaultOptions, cache$1 = _a.cache, resolvers = _a.resolvers, link = _a.link;
+        var client = new core$1.ApolloClient({
+            cache: cache$1 || new cache.InMemoryCache({ addTypename: addTypename }),
+            defaultOptions: defaultOptions,
+            link: link || new core.MockLink(mocks || [], addTypename),
+            resolvers: resolvers,
+        });
+        _this.state = { client: client };
+        return _this;
+    }
+    MockedProvider.prototype.render = function () {
+        var _a = this.props, children = _a.children, childProps = _a.childProps;
+        return React__namespace.isValidElement(children) ? (React__namespace.createElement(context.ApolloProvider, { client: this.state.client }, React__namespace.cloneElement(React__namespace.Children.only(children), tslib.__assign({}, childProps)))) : null;
+    };
+    MockedProvider.prototype.componentWillUnmount = function () {
+        this.state.client.stop();
+    };
+    MockedProvider.defaultProps = {
+        addTypename: true
+    };
+    return MockedProvider;
+}(React__namespace.Component));
+
+exports.MockedProvider = MockedProvider;
+for (var k in core) {
+    if (k !== 'default' && !exports.hasOwnProperty(k)) exports[k] = core[k];
+}
+//# sourceMappingURL=testing.cjs.map

package/utilities/common/canUse.d.ts

@@ -1,4 +1,6 @@
 export declare const canUseWeakMap: boolean;
 export declare const canUseWeakSet: boolean;
 export declare const canUseSymbol: boolean;
+export declare const canUseDOM: boolean;
+export declare const canUseLayoutEffect: boolean;
 //# sourceMappingURL=canUse.d.ts.map

package/utilities/common/canUse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canUse.d.ts","sourceRoot":"","sources":["../../../src/utilities/common/canUse.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,SAGzB,CAAC;AAEF,eAAO,MAAM,aAAa,SAAgC,CAAC;AAE3D,eAAO,MAAM,YAAY,SAES,CAAC"}
+{"version":3,"file":"canUse.d.ts","sourceRoot":"","sources":["../../../src/utilities/common/canUse.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,SAEwB,CAAC;AAEnD,eAAO,MAAM,aAAa,SAAgC,CAAC;AAE3D,eAAO,MAAM,YAAY,SAES,CAAC;AAEnC,eAAO,MAAM,SAAS,SAC4C,CAAC;AAmBnE,eAAO,MAAM,kBAAkB,SAA2B,CAAC"}

package/utilities/common/canUse.js

@@ -1,6 +1,10 @@
-export var canUseWeakMap = typeof WeakMap === 'function' && !(typeof navigator === 'object' &&
-    navigator.product === 'ReactNative');
+import { maybe } from "../globals/index.js";
+export var canUseWeakMap = typeof WeakMap === 'function' &&
+    maybe(function () { return navigator.product; }) !== 'ReactNative';
 export var canUseWeakSet = typeof WeakSet === 'function';
 export var canUseSymbol = typeof Symbol === 'function' &&
     typeof Symbol.for === 'function';
+export var canUseDOM = typeof maybe(function () { return window.document.createElement; }) === "function";
+var usingJSDOM = maybe(function () { return navigator.userAgent.indexOf("jsdom") >= 0; }) || false;
+export var canUseLayoutEffect = canUseDOM && !usingJSDOM;
 //# sourceMappingURL=canUse.js.map