surrealdb.react/dist/index.es.js

A ReactJS wrapper for surrealdb.js

import require$$0, { createContext, useState, useCallback, useEffect, useContext } from "react";
var jsxRuntime = { exports: {} };
var reactJsxRuntime_production_min = {};
/*
object-assign
(c) Sindre Sorhus
@license MIT
*/
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var hasOwnProperty = Object.prototype.hasOwnProperty;
var propIsEnumerable = Object.prototype.propertyIsEnumerable;
function toObject(val) {
  if (val === null || val === void 0) {
    throw new TypeError("Object.assign cannot be called with null or undefined");
  }
  return Object(val);
}
function shouldUseNative() {
  try {
    if (!Object.assign) {
      return false;
    }
    var test1 = new String("abc");
    test1[5] = "de";
    if (Object.getOwnPropertyNames(test1)[0] === "5") {
      return false;
    }
    var test2 = {};
    for (var i = 0; i < 10; i++) {
      test2["_" + String.fromCharCode(i)] = i;
    }
    var order2 = Object.getOwnPropertyNames(test2).map(function(n2) {
      return test2[n2];
    });
    if (order2.join("") !== "0123456789") {
      return false;
    }
    var test3 = {};
    "abcdefghijklmnopqrst".split("").forEach(function(letter) {
      test3[letter] = letter;
    });
    if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") {
      return false;
    }
    return true;
  } catch (err) {
    return false;
  }
}
shouldUseNative() ? Object.assign : function(target, source) {
  var from;
  var to = toObject(target);
  var symbols;
  for (var s = 1; s < arguments.length; s++) {
    from = Object(arguments[s]);
    for (var key in from) {
      if (hasOwnProperty.call(from, key)) {
        to[key] = from[key];
      }
    }
    if (getOwnPropertySymbols) {
      symbols = getOwnPropertySymbols(from);
      for (var i = 0; i < symbols.length; i++) {
        if (propIsEnumerable.call(from, symbols[i])) {
          to[symbols[i]] = from[symbols[i]];
        }
      }
    }
  }
  return to;
};
/** @license React v17.0.2
 * react-jsx-runtime.production.min.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
var f = require$$0, g = 60103;
reactJsxRuntime_production_min.Fragment = 60107;
if (typeof Symbol === "function" && Symbol.for) {
  var h = Symbol.for;
  g = h("react.element");
  reactJsxRuntime_production_min.Fragment = h("react.fragment");
}
var m = f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, n = Object.prototype.hasOwnProperty, p = { key: true, ref: true, __self: true, __source: true };
function q(c, a, k) {
  var b, d = {}, e = null, l = null;
  k !== void 0 && (e = "" + k);
  a.key !== void 0 && (e = "" + a.key);
  a.ref !== void 0 && (l = a.ref);
  for (b in a)
    n.call(a, b) && !p.hasOwnProperty(b) && (d[b] = a[b]);
  if (c && c.defaultProps)
    for (b in a = c.defaultProps, a)
      d[b] === void 0 && (d[b] = a[b]);
  return { $$typeof: g, type: c, key: e, ref: l, props: d, _owner: m.current };
}
reactJsxRuntime_production_min.jsx = q;
reactJsxRuntime_production_min.jsxs = q;
{
  jsxRuntime.exports = reactJsxRuntime_production_min;
}
const jsx = jsxRuntime.exports.jsx;
const SurrealContext = createContext({
  database: void 0,
  isReady: false,
  hasError: false,
  errorMessage: ""
});
let initialQuery = false;
const DatabaseProvider = ({
  children,
  database,
  options
}) => {
  if (!database)
    throw new Error("DatabaseProvider requires an initialized instance of SurrealDB.");
  const {
    user,
    pass,
    database: db,
    namespace
  } = options;
  const [isReady, setIsReady] = useState(false);
  const [hasError, setHasError] = useState(false);
  const [errorMessage, setErrorMessage] = useState("");
  const init = useCallback(async () => {
    await database.signin({
      user,
      pass
    });
    await database.use(namespace, db);
    setIsReady(true);
  }, []);
  useEffect(() => {
    if (initialQuery)
      return;
    initialQuery = true;
    init().catch((err) => {
      setHasError(true);
      setErrorMessage(err.message);
    });
  }, []);
  return /* @__PURE__ */ jsx(SurrealContext.Provider, {
    value: {
      database,
      isReady,
      hasError,
      errorMessage
    },
    children
  });
};
const useSurreal = () => {
  const {
    database,
    isReady,
    hasError,
    errorMessage
  } = useContext(SurrealContext);
  return {
    database,
    isReady,
    hasError,
    errorMessage
  };
};
const useQuery = (query, args = {}, options = { immediate: true }) => {
  const { database, isReady } = useContext(SurrealContext);
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);
  const [time, setTime] = useState(null);
  const [status, setStatus] = useState("PENDING");
  const refetch = useCallback(async (refetchArgs = {}) => {
    if (isReady) {
      setStatus("INFLIGHT");
      const response = await (database == null ? void 0 : database.query(query, Object.keys(refetchArgs).length ? refetchArgs : args));
      if (response.length) {
        setTime(response[0].time);
        if (response[0].status === "OK") {
          setData(response[0].result);
          setStatus("OK");
          setLoading(false);
          setError(false);
          return response[0].result;
        } else if (response[0].status === "ERR" && response[0].detail) {
          setStatus("ERR");
          setLoading(false);
          setError(response[0].detail);
        }
      }
    } else {
      setLoading(false);
      setError("Database is not ready.");
    }
  }, [query, isReady]);
  useEffect(() => {
    if (isReady && status === "PENDING" && options.immediate !== false) {
      refetch();
    }
  }, [isReady]);
  return { data, loading, error, refetch, status, time };
};
export { DatabaseProvider, SurrealContext, useQuery, useSurreal };