@plasmicapp/data-sources 0.1.126 → 0.1.127

package/dist/data-sources.cjs.development.js

@@ -1,1171 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-var query = require('@plasmicapp/query');
-var React = _interopDefault(require('react'));
-var dataSourcesContext = require('@plasmicapp/data-sources-context');
-var ph = require('@plasmicapp/host');
-var fetch = _interopDefault(require('@plasmicapp/isomorphic-unfetch'));
-var stringify = _interopDefault(require('fast-stringify'));
-
-function _regeneratorRuntime() {
-  _regeneratorRuntime = function () {
-    return e;
-  };
-  var t,
-    e = {},
-    r = Object.prototype,
-    n = r.hasOwnProperty,
-    o = Object.defineProperty || function (t, e, r) {
-      t[e] = r.value;
-    },
-    i = "function" == typeof Symbol ? Symbol : {},
-    a = i.iterator || "@@iterator",
-    c = i.asyncIterator || "@@asyncIterator",
-    u = i.toStringTag || "@@toStringTag";
-  function define(t, e, r) {
-    return Object.defineProperty(t, e, {
-      value: r,
-      enumerable: !0,
-      configurable: !0,
-      writable: !0
-    }), t[e];
-  }
-  try {
-    define({}, "");
-  } catch (t) {
-    define = function (t, e, r) {
-      return t[e] = r;
-    };
-  }
-  function wrap(t, e, r, n) {
-    var i = e && e.prototype instanceof Generator ? e : Generator,
-      a = Object.create(i.prototype),
-      c = new Context(n || []);
-    return o(a, "_invoke", {
-      value: makeInvokeMethod(t, r, c)
-    }), a;
-  }
-  function tryCatch(t, e, r) {
-    try {
-      return {
-        type: "normal",
-        arg: t.call(e, r)
-      };
-    } catch (t) {
-      return {
-        type: "throw",
-        arg: t
-      };
-    }
-  }
-  e.wrap = wrap;
-  var h = "suspendedStart",
-    l = "suspendedYield",
-    f = "executing",
-    s = "completed",
-    y = {};
-  function Generator() {}
-  function GeneratorFunction() {}
-  function GeneratorFunctionPrototype() {}
-  var p = {};
-  define(p, a, function () {
-    return this;
-  });
-  var d = Object.getPrototypeOf,
-    v = d && d(d(values([])));
-  v && v !== r && n.call(v, a) && (p = v);
-  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
-  function defineIteratorMethods(t) {
-    ["next", "throw", "return"].forEach(function (e) {
-      define(t, e, function (t) {
-        return this._invoke(e, t);
-      });
-    });
-  }
-  function AsyncIterator(t, e) {
-    function invoke(r, o, i, a) {
-      var c = tryCatch(t[r], t, o);
-      if ("throw" !== c.type) {
-        var u = c.arg,
-          h = u.value;
-        return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
-          invoke("next", t, i, a);
-        }, function (t) {
-          invoke("throw", t, i, a);
-        }) : e.resolve(h).then(function (t) {
-          u.value = t, i(u);
-        }, function (t) {
-          return invoke("throw", t, i, a);
-        });
-      }
-      a(c.arg);
-    }
-    var r;
-    o(this, "_invoke", {
-      value: function (t, n) {
-        function callInvokeWithMethodAndArg() {
-          return new e(function (e, r) {
-            invoke(t, n, e, r);
-          });
-        }
-        return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
-      }
-    });
-  }
-  function makeInvokeMethod(e, r, n) {
-    var o = h;
-    return function (i, a) {
-      if (o === f) throw new Error("Generator is already running");
-      if (o === s) {
-        if ("throw" === i) throw a;
-        return {
-          value: t,
-          done: !0
-        };
-      }
-      for (n.method = i, n.arg = a;;) {
-        var c = n.delegate;
-        if (c) {
-          var u = maybeInvokeDelegate(c, n);
-          if (u) {
-            if (u === y) continue;
-            return u;
-          }
-        }
-        if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
-          if (o === h) throw o = s, n.arg;
-          n.dispatchException(n.arg);
-        } else "return" === n.method && n.abrupt("return", n.arg);
-        o = f;
-        var p = tryCatch(e, r, n);
-        if ("normal" === p.type) {
-          if (o = n.done ? s : l, p.arg === y) continue;
-          return {
-            value: p.arg,
-            done: n.done
-          };
-        }
-        "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
-      }
-    };
-  }
-  function maybeInvokeDelegate(e, r) {
-    var n = r.method,
-      o = e.iterator[n];
-    if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
-    var i = tryCatch(o, e.iterator, r.arg);
-    if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
-    var a = i.arg;
-    return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
-  }
-  function pushTryEntry(t) {
-    var e = {
-      tryLoc: t[0]
-    };
-    1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
-  }
-  function resetTryEntry(t) {
-    var e = t.completion || {};
-    e.type = "normal", delete e.arg, t.completion = e;
-  }
-  function Context(t) {
-    this.tryEntries = [{
-      tryLoc: "root"
-    }], t.forEach(pushTryEntry, this), this.reset(!0);
-  }
-  function values(e) {
-    if (e || "" === e) {
-      var r = e[a];
-      if (r) return r.call(e);
-      if ("function" == typeof e.next) return e;
-      if (!isNaN(e.length)) {
-        var o = -1,
-          i = function next() {
-            for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
-            return next.value = t, next.done = !0, next;
-          };
-        return i.next = i;
-      }
-    }
-    throw new TypeError(typeof e + " is not iterable");
-  }
-  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
-    value: GeneratorFunctionPrototype,
-    configurable: !0
-  }), o(GeneratorFunctionPrototype, "constructor", {
-    value: GeneratorFunction,
-    configurable: !0
-  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
-    var e = "function" == typeof t && t.constructor;
-    return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
-  }, e.mark = function (t) {
-    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
-  }, e.awrap = function (t) {
-    return {
-      __await: t
-    };
-  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
-    return this;
-  }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
-    void 0 === i && (i = Promise);
-    var a = new AsyncIterator(wrap(t, r, n, o), i);
-    return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
-      return t.done ? t.value : a.next();
-    });
-  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
-    return this;
-  }), define(g, "toString", function () {
-    return "[object Generator]";
-  }), e.keys = function (t) {
-    var e = Object(t),
-      r = [];
-    for (var n in e) r.push(n);
-    return r.reverse(), function next() {
-      for (; r.length;) {
-        var t = r.pop();
-        if (t in e) return next.value = t, next.done = !1, next;
-      }
-      return next.done = !0, next;
-    };
-  }, e.values = values, Context.prototype = {
-    constructor: Context,
-    reset: function (e) {
-      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
-    },
-    stop: function () {
-      this.done = !0;
-      var t = this.tryEntries[0].completion;
-      if ("throw" === t.type) throw t.arg;
-      return this.rval;
-    },
-    dispatchException: function (e) {
-      if (this.done) throw e;
-      var r = this;
-      function handle(n, o) {
-        return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
-      }
-      for (var o = this.tryEntries.length - 1; o >= 0; --o) {
-        var i = this.tryEntries[o],
-          a = i.completion;
-        if ("root" === i.tryLoc) return handle("end");
-        if (i.tryLoc <= this.prev) {
-          var c = n.call(i, "catchLoc"),
-            u = n.call(i, "finallyLoc");
-          if (c && u) {
-            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
-            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
-          } else if (c) {
-            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
-          } else {
-            if (!u) throw new Error("try statement without catch or finally");
-            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
-          }
-        }
-      }
-    },
-    abrupt: function (t, e) {
-      for (var r = this.tryEntries.length - 1; r >= 0; --r) {
-        var o = this.tryEntries[r];
-        if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
-          var i = o;
-          break;
-        }
-      }
-      i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
-      var a = i ? i.completion : {};
-      return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
-    },
-    complete: function (t, e) {
-      if ("throw" === t.type) throw t.arg;
-      return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
-    },
-    finish: function (t) {
-      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
-        var r = this.tryEntries[e];
-        if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
-      }
-    },
-    catch: function (t) {
-      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
-        var r = this.tryEntries[e];
-        if (r.tryLoc === t) {
-          var n = r.completion;
-          if ("throw" === n.type) {
-            var o = n.arg;
-            resetTryEntry(r);
-          }
-          return o;
-        }
-      }
-      throw new Error("illegal catch attempt");
-    },
-    delegateYield: function (e, r, n) {
-      return this.delegate = {
-        iterator: values(e),
-        resultName: r,
-        nextLoc: n
-      }, "next" === this.method && (this.arg = t), y;
-    }
-  }, e;
-}
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-  try {
-    var info = gen[key](arg);
-    var value = info.value;
-  } catch (error) {
-    reject(error);
-    return;
-  }
-  if (info.done) {
-    resolve(value);
-  } else {
-    Promise.resolve(value).then(_next, _throw);
-  }
-}
-function _asyncToGenerator(fn) {
-  return function () {
-    var self = this,
-      args = arguments;
-    return new Promise(function (resolve, reject) {
-      var gen = fn.apply(self, args);
-      function _next(value) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-      }
-      function _throw(err) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-      }
-      _next(undefined);
-    });
-  };
-}
-function _extends() {
-  _extends = Object.assign ? Object.assign.bind() : function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-    return target;
-  };
-  return _extends.apply(this, arguments);
-}
-
-var DEFAULT_HOST = 'https://data.plasmic.app';
-var UNAUTHORIZED_MESSAGE = 'You do not have permission to perform this operation. Login to get access or contact the app owner to get access.';
-function executePlasmicDataOp(_x, _x2) {
-  return _executePlasmicDataOp2.apply(this, arguments);
-}
-function _executePlasmicDataOp2() {
-  _executePlasmicDataOp2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(op, opts) {
-    var func, res;
-    return _regeneratorRuntime().wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          func = getConfig('__PLASMIC_EXECUTE_DATA_OP', _executePlasmicDataOp);
-          _context.next = 3;
-          return query.wrapLoadingFetcher(func)(op, opts);
-        case 3:
-          res = _context.sent;
-          return _context.abrupt("return", res);
-        case 5:
-        case "end":
-          return _context.stop();
-      }
-    }, _callee);
-  }));
-  return _executePlasmicDataOp2.apply(this, arguments);
-}
-function _executePlasmicDataOp(_x3, _x4) {
-  return _executePlasmicDataOp3.apply(this, arguments);
-}
-function _executePlasmicDataOp3() {
-  _executePlasmicDataOp3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(op, opts) {
-    var _op$userArgs;
-    var host, url, resp, text;
-    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-      while (1) switch (_context2.prev = _context2.next) {
-        case 0:
-          if (!op.roleId) {
-            _context2.next = 4;
-            break;
-          }
-          if (!(!(opts != null && opts.user) || !opts.user.roleIds.includes(op.roleId))) {
-            _context2.next = 4;
-            break;
-          }
-          console.error(UNAUTHORIZED_MESSAGE);
-          throw new Error(UNAUTHORIZED_MESSAGE);
-        case 4:
-          host = getConfig('__PLASMIC_DATA_HOST', DEFAULT_HOST);
-          url = host + "/api/v1/server-data/sources/" + op.sourceId + "/execute";
-          _context2.next = 8;
-          return fetch(url, {
-            method: 'POST',
-            headers: _extends({
-              'Content-Type': 'application/json'
-            }, (opts == null ? void 0 : opts.userAuthToken) && {
-              'x-plasmic-data-user-auth-token': opts.userAuthToken
-            }),
-            body: stringify({
-              opId: op.opId,
-              userArgs: (_op$userArgs = op.userArgs) != null ? _op$userArgs : {},
-              paginate: opts == null ? void 0 : opts.paginate
-            })
-          });
-        case 8:
-          resp = _context2.sent;
-          if (!(resp.status !== 200)) {
-            _context2.next = 14;
-            break;
-          }
-          _context2.next = 12;
-          return resp.text();
-        case 12:
-          text = _context2.sent;
-          throw new Error(text);
-        case 14:
-          _context2.next = 16;
-          return resp.json();
-        case 16:
-          return _context2.abrupt("return", _context2.sent);
-        case 17:
-        case "end":
-          return _context2.stop();
-      }
-    }, _callee2);
-  }));
-  return _executePlasmicDataOp3.apply(this, arguments);
-}
-function getConfig(key, defaultValue) {
-  if (typeof globalThis === 'undefined') {
-    return defaultValue;
-  } else {
-    var _globalThis$key;
-    return (_globalThis$key = globalThis[key]) != null ? _globalThis$key : defaultValue;
-  }
-}
-
-function swallow(f) {
-  try {
-    return f();
-  } catch (_unused) {
-    return undefined;
-  }
-}
-function pick(obj) {
-  var res = {};
-  for (var _len = arguments.length, keys = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-    keys[_key - 1] = arguments[_key];
-  }
-  for (var _i = 0, _keys = keys; _i < _keys.length; _i++) {
-    var key = _keys[_i];
-    if (key in obj) {
-      res[key] = obj[key];
-    }
-  }
-  return res;
-}
-var tuple = function tuple() {
-  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-    args[_key2] = arguments[_key2];
-  }
-  return args;
-};
-function mkIdMap(xs) {
-  return new Map(xs.map(function (x) {
-    return tuple(x.id, x);
-  }));
-}
-function withoutNils(xs) {
-  return xs.filter(function (x) {
-    return x != null;
-  });
-}
-
-function makeCacheKey(dataOp, opts) {
-  var queryDependencies = JSON.stringify({
-    sourceId: dataOp.sourceId,
-    opId: dataOp.opId,
-    args: dataOp.userArgs,
-    userAuthToken: opts == null ? void 0 : opts.userAuthToken,
-    paginate: opts == null ? void 0 : opts.paginate
-  });
-  return dataOp.cacheKey ? "" + dataOp.cacheKey + queryDependencies : queryDependencies;
-}
-/**
- * Returns a function that can be used to invalidate Plasmic query groups.
- */
-function usePlasmicInvalidate() {
-  // NOTE: we use `revalidateIfStale: false` with SWR.
-  // One quirk of this is that if you supply fallback data to swr,
-  // that data doesn't get entered into the cache if `revalidateIfStale: false`,
-  // so you won't see it if you iterate over keys of the cache. That's why
-  // we have usePlasmicInvalidate() which will iterate over both the cache
-  // and the fallback data.
-  var _usePlasmicDataConfig = query.usePlasmicDataConfig(),
-    cache = _usePlasmicDataConfig.cache,
-    fallback = _usePlasmicDataConfig.fallback,
-    mutate = _usePlasmicDataConfig.mutate;
-  return /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(invalidatedKeys) {
-      var getKeysToInvalidate, keys, invalidateKey;
-      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-        while (1) switch (_context2.prev = _context2.next) {
-          case 0:
-            getKeysToInvalidate = function getKeysToInvalidate() {
-              if (!invalidatedKeys) {
-                return [];
-              }
-              var allKeys = Array.from(new Set([].concat(Array.from(cache.keys()), fallback ? Object.keys(fallback) : []))).filter(function (key) {
-                return typeof key === 'string';
-              });
-              if (invalidatedKeys.includes('plasmic_refresh_all')) {
-                return allKeys;
-              }
-              return allKeys.filter(function (key) {
-                return invalidatedKeys.some(function (k) {
-                  return key.includes(".$." + k + ".$.");
-                });
-              });
-            };
-            keys = getKeysToInvalidate();
-            if (!(keys.length === 0)) {
-              _context2.next = 4;
-              break;
-            }
-            return _context2.abrupt("return");
-          case 4:
-            invalidateKey = /*#__PURE__*/function () {
-              var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(key) {
-                var studioInvalidate;
-                return _regeneratorRuntime().wrap(function _callee$(_context) {
-                  while (1) switch (_context.prev = _context.next) {
-                    case 0:
-                      studioInvalidate = globalThis.__PLASMIC_MUTATE_DATA_OP;
-                      if (!studioInvalidate) {
-                        _context.next = 4;
-                        break;
-                      }
-                      _context.next = 4;
-                      return studioInvalidate(key);
-                    case 4:
-                      return _context.abrupt("return", mutate(key));
-                    case 5:
-                    case "end":
-                      return _context.stop();
-                  }
-                }, _callee);
-              }));
-              return function invalidateKey(_x2) {
-                return _ref2.apply(this, arguments);
-              };
-            }();
-            _context2.next = 7;
-            return Promise.all(keys.map(function (key) {
-              return invalidateKey(key);
-            }));
-          case 7:
-            return _context2.abrupt("return", _context2.sent);
-          case 8:
-          case "end":
-            return _context2.stop();
-        }
-      }, _callee2);
-    }));
-    return function (_x) {
-      return _ref.apply(this, arguments);
-    };
-  }();
-}
-var enableLoadingBoundaryKey = 'plasmicInternalEnableLoadingBoundary';
-function mkUndefinedDataProxy(promiseRef, fetchAndUpdateCache) {
-  var fetchAndUpdatePromise = undefined;
-  return new Proxy({}, {
-    get: function get(_target, prop) {
-      if (prop === 'isPlasmicUndefinedDataProxy') {
-        return true;
-      }
-      if (!fetchAndUpdateCache) {
-        // There's no key so no fetch to kick off yet; when computing key,
-        // we encountered some thrown exception (that's not an undefined data promise),
-        // and so we can't fetch yet. This might be dependent on a $state or $prop value
-        // that's currently undefined, etc.  We will act like an undefined data object,
-        // and trigger the usual fallback behavior
-        return undefined;
-      }
-      var doFetchAndUpdate = function doFetchAndUpdate() {
-        // We hold onto the promise last returned by fetchAndUpdateCache()
-        // and keep reusing it until it is resolved. The reason is that the
-        // Promise thrown here will be used as a dependency for memoized
-        // fetchAndUpdateCache, which is a dependency on the memoized returned value
-        // from usePlasmicDataOp(). If we have a fetch that's taking a long time,
-        // we want to make sure that our memoized returned value is stable,
-        // so that we don't keep calling setDollarQueries() (otherwise, for each
-        // render, we find an unstable result, and call setDollarQueries(),
-        // resulting in an infinite loop while fetch is happening).
-        if (!fetchAndUpdatePromise) {
-          fetchAndUpdatePromise = fetchAndUpdateCache()["finally"](function () {
-            fetchAndUpdatePromise = undefined;
-          });
-        }
-        return fetchAndUpdatePromise;
-      };
-      var promise =
-      // existing fetch
-      promiseRef.fetchingPromise ||
-      // No existing fetch, so kick off a fetch
-      doFetchAndUpdate();
-      promise.plasmicType = 'PlasmicUndefinedDataError';
-      promise.message = "Cannot read property " + String(prop) + " - data is still loading";
-      throw promise;
-    }
-  });
-}
-function isPlasmicUndefinedDataErrorPromise(x) {
-  return !!x && typeof x === 'object' && x.plasmicType === 'PlasmicUndefinedDataError';
-}
-var reactMajorVersion = + /*#__PURE__*/React.version.split('.')[0];
-/**
- * This returns either:
- * * DataOp to perform
- * * undefined/null, if no data op can be performed
- * * PlasmicUndefinedDataErrorPromise, if when trying to evaluate the DataOp to perform,
- *   we encounter a PlasmicUndefinedDataErrorPromise, so this operation cannot be
- *   performed until that promise is resolved.
- */
-function resolveDataOp(dataOp) {
-  if (typeof dataOp === 'function') {
-    try {
-      return dataOp();
-    } catch (err) {
-      if (isPlasmicUndefinedDataErrorPromise(err)) {
-        return err;
-      }
-      return null;
-    }
-  } else {
-    return dataOp;
-  }
-}
-/**
- * Fetches can be kicked off two ways -- normally, by useSWR(), or by some
- * expression accessing the `$queries.*` proxy when not ready yet. We need
- * a global cache for proxy-invoked caches, so that different components
- * with the same key can share the same fetch.
- *
- * The life cycle for this cache is short -- only the duration of a
- * proxy-invoked fetch, and once the fetch is done. That's because we really
- * just want SWR to be managing the cache, not us! Once the data is in SWR,
- * we will use SWR for getting data.
- */
-var PRE_FETCHES = /*#__PURE__*/new Map();
-function usePlasmicDataOp(dataOp, opts) {
-  var _ph$useDataEnv;
-  var resolvedDataOp = resolveDataOp(dataOp);
-  var ctx = dataSourcesContext.usePlasmicDataSourceContext();
-  var enableLoadingBoundary = !!(ph.useDataEnv != null && (_ph$useDataEnv = ph.useDataEnv()) != null && _ph$useDataEnv[enableLoadingBoundaryKey]);
-  var _usePlasmicDataConfig2 = query.usePlasmicDataConfig(),
-    mutate = _usePlasmicDataConfig2.mutate,
-    cache = _usePlasmicDataConfig2.cache;
-  // Cannot perform this operation
-  var isNullDataOp = !resolvedDataOp;
-  // This operation depends on another data query to resolve first
-  var isWaitingOnDependentQuery = isPlasmicUndefinedDataErrorPromise(resolvedDataOp);
-  var key = !resolvedDataOp || isPlasmicUndefinedDataErrorPromise(resolvedDataOp) ? null : makeCacheKey(resolvedDataOp, {
-    paginate: opts == null ? void 0 : opts.paginate,
-    userAuthToken: ctx == null ? void 0 : ctx.userAuthToken
-  });
-  var fetchingData = React.useMemo(function () {
-    return {
-      fetchingPromise: undefined
-    };
-  }, [key]);
-  var fetcher = React.useMemo(function () {
-    return function () {
-      // If we are in this function, that means SWR cache missed.
-      if (!key) {
-        throw new Error("Fetcher should never be called without a proper key");
-      }
-      // dataOp is guaranteed to be a DataOp, and not an undefined promise or null
-      if (fetchingData.fetchingPromise) {
-        // Fetch is already underway from this hook
-        return fetchingData.fetchingPromise;
-      }
-      if (key && PRE_FETCHES.has(key)) {
-        // Some other usePlasmicDataOp() hook elsewhere has already
-        // started this fetch as well; re-use it here.
-        var existing = PRE_FETCHES.get(key);
-        fetchingData.fetchingPromise = existing;
-        return existing;
-      }
-      // Else we really need to kick off this fetch now...
-      var fetcherFn = function fetcherFn() {
-        return executePlasmicDataOp(resolvedDataOp, {
-          userAuthToken: (ctx == null ? void 0 : ctx.userAuthToken) || undefined,
-          user: ctx == null ? void 0 : ctx.user,
-          paginate: opts == null ? void 0 : opts.paginate
-        });
-      };
-      var fetcherPromise = fetcherFn();
-      fetchingData.fetchingPromise = fetcherPromise;
-      if (key) {
-        PRE_FETCHES.set(key, fetcherPromise);
-        // Once we have a result, we rely on swr to perform the caching,
-        // so remove from our cache as quickly as possible.
-        fetcherPromise.then(function () {
-          PRE_FETCHES["delete"](key);
-        }, function () {
-          PRE_FETCHES["delete"](key);
-        });
-      }
-      return fetcherPromise;
-    };
-  }, [key, fetchingData]);
-  var dependentKeyDataErrorPromise = isPlasmicUndefinedDataErrorPromise(resolvedDataOp) ? resolvedDataOp : undefined;
-  var fetchAndUpdateCache = React.useMemo(function () {
-    if (!key && !dependentKeyDataErrorPromise) {
-      // If there's no key, and no data query we're waiting for, then there's
-      // no way to perform a fetch
-      return undefined;
-    }
-    return function () {
-      // This function is called when the undefined data proxy is invoked.
-      // USUALLY, this means the data is not available in SWR yet, and
-      // we need to kick off a fetch.
-      if (fetchingData.fetchingPromise) {
-        // No need to update cache as the exist promise call site will do it
-        return fetchingData.fetchingPromise;
-      }
-      if (dependentKeyDataErrorPromise) {
-        // We can't actually fetch yet, because we couldn't even evaluate the dataOp
-        // to fetch for, because we depend on unfetched data. Once _that_
-        // dataOp we depend on is finished, then we can try again.  So we
-        // will throw and wait for _that_ promise to be resolved instead.
-        return dependentKeyDataErrorPromise;
-      }
-      if (!key) {
-        throw new Error("Expected key to be non-null");
-      }
-      // SOMETIMES, SWR actually _does_ have the cache, but we still end up
-      // here.  That's because of how we update $queries, which takes two
-      // cycles; each time we render, we build a `new$Queries`, and
-      // `set$Queries(new$Queries)`.  So once the data is ready, at the
-      // first render, we will have data in `new$Queries` but not `$queries`,
-      // but we will still finish rendering that pass, which means any `$queries`
-      // access will still end up here.  So we look into the SWR cache and
-      // return any data that's here.
-      var cached = cache.get(key);
-      if (cached) {
-        return Promise.resolve(cached);
-      }
-      var cachedError = cache.get("$swr$" + key);
-      if (cachedError) {
-        return Promise.reject(cachedError.error);
-      }
-      // Now, upon this proxy.get() miss, we want to kick off the fetch. We can't
-      // wait for useSWR() to kick off the fetch, because upon data miss we are
-      // throwing a promise, and useSWR() won't kick off the fetch till the effect,
-      // so it will never get a chance to fetch.  Instead, we fetch, and then we
-      // put the fetched data into the SWR cache, so that next time useSWR() is called,
-      // it will just find it in the cache.
-      //
-      // However, we don't want to fetch SYNCHRONOUSLY RIGHT NOW, becase we are in
-      // the rendering phase (presumably, we're here because some component is trying
-      // to read fetched data while rendering).  Doing a fetch right now would invoke
-      // the fetcher, which is wrapped by @plasmicapp/query to tracking loading state,
-      // and upon loading state toggled to true, it will fire loading event listeners,
-      // and for example, our antd's <GlobalLoadingIndicator /> will listen to this
-      // event and immediately ask antd to show the loading indicator, which mutates
-      // antd component's state.  It is NOT LEGAL to call setState() on some other
-      // component's state during rendering phase!
-      //
-      // We therefore will delay kicking off the fetch by a tick, so that we will safely
-      // start the fetch outside of React rendering phase.
-      var fetcherPromise = new Promise(function (resolve, reject) {
-        setTimeout(function () {
-          fetcher().then(resolve, reject);
-        }, 1);
-      });
-      fetcherPromise.then(function (data) {
-        // Insert the fetched data into the SWR cache
-        mutate(key, data);
-      })["catch"](function (err) {
-        var _cache$get;
-        // Cache the error here to avoid infinite loop
-        var keyInfo = key ? '$swr$' + key : '';
-        cache.set(keyInfo, _extends({}, (_cache$get = cache.get(keyInfo)) != null ? _cache$get : {}, {
-          error: err
-        }));
-      });
-      return fetcherPromise;
-    };
-  }, [fetcher, fetchingData, cache, key, dependentKeyDataErrorPromise]);
-  var res = query.useMutablePlasmicQueryData(key, fetcher, {
-    shouldRetryOnError: false,
-    // If revalidateIfStale is true, then if there's a cache entry with a key,
-    // but no mounted hook with that key yet, and when the hook mounts with the key,
-    // swr will revalidate. This may be reasonable behavior, but for us, this
-    // happens all the time -- we prepopulate the cache with proxy-invoked fetch,
-    // sometimes before swr had a chance to run the effect.  So we turn off
-    // revalidateIfStale here, and just let the user manage invalidation.
-    revalidateIfStale: false
-  });
-  var data = res.data,
-    error = res.error,
-    isLoading = res.isLoading;
-  if (fetchingData.fetchingPromise != null && data !== undefined) {
-    // Clear the fetching promise as the actual data is now used (so
-    // revalidation is possible)
-    fetchingData.fetchingPromise = undefined;
-  }
-  return React.useMemo(function () {
-    var result = _extends({}, data != null ? data : {}, pick(res, 'isLoading', 'error'));
-    if (!(opts != null && opts.noUndefinedDataProxy) && reactMajorVersion >= 18 && enableLoadingBoundary && (isLoading || isNullDataOp || isWaitingOnDependentQuery) && result.data === undefined && result.schema === undefined && result.error === undefined) {
-      result.data = mkUndefinedDataProxy(fetchingData, fetchAndUpdateCache);
-      result.schema = mkUndefinedDataProxy(fetchingData, fetchAndUpdateCache);
-    }
-    return result;
-  }, [isNullDataOp, isWaitingOnDependentQuery, data, error, isLoading, opts == null ? void 0 : opts.noUndefinedDataProxy, enableLoadingBoundary, fetchingData, fetchAndUpdateCache]);
-}
-function usePlasmicDataMutationOp(dataOp) {
-  var ctx = dataSourcesContext.usePlasmicDataSourceContext();
-  var userToken = ctx == null ? void 0 : ctx.userAuthToken;
-  var getRealDataOp = React.useCallback( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
-    var tryGetRealDataOp;
-    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
-      while (1) switch (_context4.prev = _context4.next) {
-        case 0:
-          tryGetRealDataOp = /*#__PURE__*/function () {
-            var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
-              var resolved;
-              return _regeneratorRuntime().wrap(function _callee3$(_context3) {
-                while (1) switch (_context3.prev = _context3.next) {
-                  case 0:
-                    resolved = resolveDataOp(dataOp);
-                    if (resolved) {
-                      _context3.next = 5;
-                      break;
-                    }
-                    return _context3.abrupt("return", null);
-                  case 5:
-                    if (!isPlasmicUndefinedDataErrorPromise(resolved)) {
-                      _context3.next = 11;
-                      break;
-                    }
-                    _context3.next = 8;
-                    return resolved;
-                  case 8:
-                    return _context3.abrupt("return", tryGetRealDataOp());
-                  case 11:
-                    return _context3.abrupt("return", resolved);
-                  case 12:
-                  case "end":
-                    return _context3.stop();
-                }
-              }, _callee3);
-            }));
-            return function tryGetRealDataOp() {
-              return _ref4.apply(this, arguments);
-            };
-          }();
-          _context4.next = 3;
-          return tryGetRealDataOp();
-        case 3:
-          return _context4.abrupt("return", _context4.sent);
-        case 4:
-        case "end":
-          return _context4.stop();
-      }
-    }, _callee4);
-  })), [dataOp]);
-  return React.useCallback( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
-    var _yield$getRealDataOp;
-    var _ref6, sourceId, opId, userArgs;
-    return _regeneratorRuntime().wrap(function _callee5$(_context5) {
-      while (1) switch (_context5.prev = _context5.next) {
-        case 0:
-          _context5.next = 2;
-          return getRealDataOp();
-        case 2:
-          _context5.t0 = _yield$getRealDataOp = _context5.sent;
-          if (!(_context5.t0 != null)) {
-            _context5.next = 7;
-            break;
-          }
-          _context5.t1 = _yield$getRealDataOp;
-          _context5.next = 8;
-          break;
-        case 7:
-          _context5.t1 = {};
-        case 8:
-          _ref6 = _context5.t1;
-          sourceId = _ref6.sourceId;
-          opId = _ref6.opId;
-          userArgs = _ref6.userArgs;
-          if (!(!sourceId || !opId)) {
-            _context5.next = 14;
-            break;
-          }
-          return _context5.abrupt("return", undefined);
-        case 14:
-          return _context5.abrupt("return", executePlasmicDataOp({
-            sourceId: sourceId,
-            opId: opId,
-            userArgs: userArgs
-          }, {
-            userAuthToken: userToken || undefined,
-            user: ctx == null ? void 0 : ctx.user
-          }));
-        case 15:
-        case "end":
-          return _context5.stop();
-      }
-    }, _callee5);
-  })), [getRealDataOp, userToken]);
-}
-
-function Fetcher(props) {
-  var _children;
-  var dataOp = props.dataOp,
-    children = props.children,
-    name = props.name,
-    pageIndex = props.pageIndex,
-    pageSize = props.pageSize;
-  var data = usePlasmicDataOp(dataOp, _extends({}, !!pageIndex && !!pageSize && {
-    paginate: {
-      pageIndex: pageIndex,
-      pageSize: pageSize
-    }
-  }));
-  var $queries = React.useMemo(function () {
-    var _extends2;
-    return _extends({}, props.queries, (_extends2 = {}, _extends2[name != null ? name : 'data'] = data, _extends2));
-  }, [props.queries, name, data]);
-  return (_children = children == null ? void 0 : children($queries)) != null ? _children : null;
-}
-var FetcherMeta = {
-  name: 'plasmic-data-source-fetcher',
-  displayName: 'Data Fetcher',
-  props: {
-    dataOp: {
-      type: 'dataSourceOp',
-      displayName: 'Data'
-    },
-    name: {
-      type: 'string',
-      displayName: 'Variable name'
-    },
-    children: {
-      type: 'slot',
-      renderPropParams: ['$queries']
-    },
-    pageSize: {
-      type: 'number',
-      advanced: true,
-      displayName: 'Page size',
-      description: 'Only fetch in batches of this size; for pagination'
-    },
-    pageIndex: {
-      type: 'number',
-      advanced: true,
-      displayName: 'Page index',
-      description: '0-based index of the paginated page to fetch'
-    }
-  },
-  importPath: '@plasmicapp/react-web/lib/data-sources',
-  importName: 'Fetcher',
-  alwaysAutoName: true,
-  styleSections: false
-};
-
-function normalizeData(rawData) {
-  var _rawData$schema;
-  if (!rawData) {
-    return undefined;
-  }
-  var dataArray = tryGetDataArray(rawData);
-  if (!dataArray) {
-    return undefined;
-  }
-  var schema = (_rawData$schema = rawData.schema) != null ? _rawData$schema : tryGetSchema(dataArray);
-  if (!schema) {
-    return undefined;
-  }
-  return {
-    data: dataArray,
-    schema: schema
-  };
-}
-function tryGetDataArray(rawData) {
-  if (rawData == null || typeof rawData !== 'object') {
-    return undefined;
-  }
-  if (Array.isArray(rawData)) {
-    if (isArrayOfObjects(rawData)) {
-      return rawData;
-    } else {
-      // TODO: array of primitives? Maybe we can wrap this?
-      return undefined;
-    }
-  }
-  if (rawData == null) {
-    return undefined;
-  }
-  if ('data' in rawData && typeof rawData.data === 'object') {
-    if (Array.isArray(rawData.data) && isArrayOfObjects(rawData.data)) {
-      return rawData.data;
-    } else if (rawData.data != null) {
-      return [rawData.data];
-    } else {
-      return undefined;
-    }
-  }
-  if ('isLoading' in rawData || 'error' in rawData) {
-    return undefined;
-  }
-  // Maybe a singleton record?
-  return [rawData];
-}
-function isArrayOfObjects(arr) {
-  return arr.every(function (x) {
-    return typeof x === 'object' && !Array.isArray(x);
-  });
-}
-function tryGetSchema(data) {
-  var fieldMap = {};
-  data.forEach(function (entry) {
-    if (entry && typeof entry === 'object') {
-      Array.from(Object.entries(entry)).forEach(function (_ref) {
-        var k = _ref[0],
-          v = _ref[1];
-        var inferredType = typeof v === 'string' ? 'string' : typeof v === 'boolean' ? 'boolean' : typeof v === 'number' ? 'number' : 'unknown';
-        if (fieldMap[k] && fieldMap[k] !== inferredType) {
-          fieldMap[k] = 'unknown';
-        } else {
-          fieldMap[k] = inferredType;
-        }
-      });
-    }
-  });
-  return {
-    id: 'inferred',
-    fields: Object.entries(fieldMap).map(function (_ref2) {
-      var f = _ref2[0],
-        t = _ref2[1];
-      return {
-        id: f,
-        type: t,
-        readOnly: false
-      };
-    })
-  };
-}
-var mkShortId = function mkShortId() {
-  return "" + Math.random();
-};
-function deriveFieldConfigs(specifiedFieldsPartial, schema, makeDefaultConfig) {
-  var _schema$fields;
-  var schemaFields = (_schema$fields = schema == null ? void 0 : schema.fields) != null ? _schema$fields : [];
-  var fieldById = mkIdMap(schemaFields);
-  var specifiedFieldIds = new Set(withoutNils(specifiedFieldsPartial.map(function (f) {
-    return f.fieldId;
-  })));
-  var keptSpecifiedFields = specifiedFieldsPartial.flatMap(function (f) {
-    if (!f.fieldId) {
-      return [_extends({
-        key: mkShortId()
-      }, makeDefaultConfig(undefined), f)];
-    }
-    var field = fieldById.get(f.fieldId);
-    // Drop configs with fieldIds no longer in the data.
-    if (!field) {
-      return [];
-    }
-    return [_extends({
-      key: mkShortId()
-    }, makeDefaultConfig(field), f)];
-  });
-  var newVirtualFields = schemaFields.filter(function (f) {
-    return !specifiedFieldIds.has(f.id);
-  }).map(function (f) {
-    return _extends({
-      key: mkShortId()
-    }, makeDefaultConfig(f));
-  });
-  var mergedFields = [].concat(keptSpecifiedFields, newVirtualFields);
-  var minimalFullLengthFields = [].concat(specifiedFieldsPartial, newVirtualFields.map(function (f) {
-    return {
-      key: f.key,
-      fieldId: f.fieldId
-    };
-  }));
-  return {
-    mergedFields: mergedFields,
-    minimalFullLengthFields: minimalFullLengthFields
-  };
-}
-
-function usePrevious(value) {
-  var prevValue = React.useRef(undefined);
-  React.useEffect(function () {
-    prevValue.current = value;
-    return function () {
-      prevValue.current = undefined;
-    };
-  });
-  return prevValue.current;
-}
-/**
- * @deprecated Prefer using `usePlasmicDataOp` directly instead.
- */
-function useDependencyAwareQuery(_ref) {
-  var $queries = _ref.$queries,
-    getDataOp = _ref.getDataOp,
-    setDollarQueries = _ref.setDollarQueries,
-    name = _ref.name,
-    pageIndex = _ref.pageIndex,
-    pageSize = _ref.pageSize;
-  var data = usePlasmicDataOp(swallow(getDataOp), _extends({}, !!pageIndex && !!pageSize && {
-    paginate: {
-      pageIndex: pageIndex,
-      pageSize: pageSize
-    }
-  }));
-  var finalName = name != null ? name : 'data';
-  var prevName = usePrevious(finalName);
-  React.useEffect(function () {
-    if (!(finalName in $queries) || $queries[finalName] !== data) {
-      var _extends2;
-      var $queries2 = _extends({}, $queries, (_extends2 = {}, _extends2[finalName] = data, _extends2));
-      if (prevName && finalName !== prevName && prevName in $queries) {
-        delete $queries2[prevName];
-      }
-      setDollarQueries($queries2);
-    }
-  }, [finalName, prevName, data, $queries, setDollarQueries]);
-}
-
-Object.defineProperty(exports, 'usePlasmicDataConfig', {
-  enumerable: true,
-  get: function () {
-    return query.usePlasmicDataConfig;
-  }
-});
-exports.Fetcher = Fetcher;
-exports.FetcherMeta = FetcherMeta;
-exports.deriveFieldConfigs = deriveFieldConfigs;
-exports.executePlasmicDataOp = executePlasmicDataOp;
-exports.makeCacheKey = makeCacheKey;
-exports.normalizeData = normalizeData;
-exports.useDependencyAwareQuery = useDependencyAwareQuery;
-exports.usePlasmicDataMutationOp = usePlasmicDataMutationOp;
-exports.usePlasmicDataOp = usePlasmicDataOp;
-exports.usePlasmicInvalidate = usePlasmicInvalidate;
-//# sourceMappingURL=data-sources.cjs.development.js.map