one/dist/cjs/useLoader.native.js

One is a new React Framework that makes Vite serve both native and web.

"use strict";

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
    for (var name in all) __defProp(target, name, {
      get: all[name],
      enumerable: !0
    });
  },
  __copyProps = (to, from, except, desc) => {
    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
      get: () => from[key],
      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
    });
    return to;
  };
var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
  value: !0
}), mod);
var useLoader_exports = {};
__export(useLoader_exports, {
  refetchLoader: () => refetchLoader,
  useLoader: () => useLoader,
  useLoaderState: () => useLoaderState
});
module.exports = __toCommonJS(useLoader_exports);
var import_react = require("react"),
  import_hooks = require("./hooks.native.js"),
  import_router = require("./router/router.native.js"),
  import_cleanUrl = require("./utils/cleanUrl.native.js"),
  import_dynamicImport = require("./utils/dynamicImport.native.js"),
  import_weakKey = require("./utils/weakKey.native.js"),
  import_one_server_only = require("./vite/one-server-only.native.js");
function _instanceof(left, right) {
  return right != null && typeof Symbol < "u" && right[Symbol.hasInstance] ? !!right[Symbol.hasInstance](left) : left instanceof right;
}
var loaderState = {},
  subscribers = /* @__PURE__ */new Set();
function updateState(path, updates) {
  loaderState[path] = {
    ...loaderState[path],
    ...updates
  }, subscribers.forEach(function (callback) {
    callback();
  });
}
function subscribe(callback) {
  return subscribers.add(callback), function () {
    return subscribers.delete(callback);
  };
}
function getLoaderState(path, preloadedData2) {
  return loaderState[path] || (loaderState[path] = {
    data: preloadedData2,
    error: void 0,
    promise: void 0,
    state: "idle",
    hasLoadedOnce: !!preloadedData2
  }), loaderState[path];
}
async function refetchLoader(pathname2) {
  updateState(pathname2, {
    state: "loading",
    error: null
  });
  try {
    var cacheBust = `${Date.now()}`,
      loaderJSUrl2 = (0, import_cleanUrl.getLoaderPath)(pathname2, !0, cacheBust),
      module2 = await (0, import_dynamicImport.dynamicImport)(loaderJSUrl2),
      result2 = await module2.loader();
    updateState(pathname2, {
      data: result2,
      state: "idle",
      timestamp: Date.now(),
      hasLoadedOnce: !0
    });
  } catch (err) {
    throw updateState(pathname2, {
      error: err,
      state: "idle"
    }), err;
  }
}
function useLoaderState(loader) {
  var {
      loaderProps: loaderPropsFromServerContext,
      loaderData: loaderDataFromServerContext
    } = (0, import_one_server_only.useServerContext)() || {},
    params = (0, import_hooks.useParams)(),
    pathname = (0, import_hooks.usePathname)(),
    currentPath = pathname.replace(/\/index$/, "").replace(/\/$/, "") || "/";
  if (typeof window > "u" && loader) {
    var serverData = useAsyncFn(loader, loaderPropsFromServerContext || {
      path: pathname,
      params
    });
    return {
      data: serverData,
      refetch: async function () {},
      state: "idle"
    };
  }
  var serverContextPath = loaderPropsFromServerContext?.path,
    preloadedData = serverContextPath === currentPath ? loaderDataFromServerContext : void 0,
    loaderStateEntry = (0, import_react.useSyncExternalStore)(subscribe, function () {
      return getLoaderState(currentPath, preloadedData);
    }, function () {
      return getLoaderState(currentPath, preloadedData);
    }),
    refetch = (0, import_react.useCallback)(function () {
      return refetchLoader(currentPath);
    }, [currentPath]);
  if (!loader) return {
    refetch,
    state: loaderStateEntry.state
  };
  if (!loaderStateEntry.data && !loaderStateEntry.promise && !loaderStateEntry.hasLoadedOnce && loader) {
    var resolvedPreloadData = import_router.preloadedLoaderData[currentPath];
    if (resolvedPreloadData !== void 0) delete import_router.preloadedLoaderData[currentPath], delete import_router.preloadingLoader[currentPath], loaderStateEntry.data = resolvedPreloadData, loaderStateEntry.hasLoadedOnce = !0;else if (import_router.preloadingLoader[currentPath]) {
      var preloadPromise = import_router.preloadingLoader[currentPath],
        promise = preloadPromise.then(function (val) {
          delete import_router.preloadingLoader[currentPath], delete import_router.preloadedLoaderData[currentPath], updateState(currentPath, {
            data: val,
            hasLoadedOnce: !0,
            promise: void 0
          });
        }).catch(function (err) {
          console.error("Error running loader()", err), delete import_router.preloadingLoader[currentPath], updateState(currentPath, {
            error: err,
            promise: void 0
          });
        });
      loaderStateEntry.promise = promise;
    } else {
      var loadData = async function () {
          try {
            var loaderJSUrl = (0, import_cleanUrl.getLoaderPath)(currentPath, !0),
              nativeLoaderJSUrl = `${loaderJSUrl}?platform=ios`;
            try {
              var loaderJsCodeResp = await fetch(nativeLoaderJSUrl);
              if (!loaderJsCodeResp.ok) throw new Error(`Response not ok: ${loaderJsCodeResp.status}`);
              var loaderJsCode = await loaderJsCodeResp.text(),
                result = eval(`() => { var exports = {}; ${loaderJsCode}; return exports; }`)();
              if (typeof result.loader != "function") throw new Error("Loader code isn't exporting a `loader` function");
              var data = await result.loader();
              updateState(currentPath, {
                data,
                hasLoadedOnce: !0,
                promise: void 0
              });
              return;
            } catch (e) {
              updateState(currentPath, {
                data: {},
                promise: void 0
              });
              return;
            }
            var loaderJSUrl = (0, import_cleanUrl.getLoaderPath)(currentPath, !0),
              module = await (0, import_dynamicImport.dynamicImport)(loaderJSUrl),
              result = await module.loader();
            updateState(currentPath, {
              data: result,
              hasLoadedOnce: !0,
              promise: void 0
            });
          } catch (err) {
            updateState(currentPath, {
              error: err,
              promise: void 0
            });
          }
        },
        promise = loadData();
      loaderStateEntry.promise = promise;
    }
  }
  if (loader) {
    if (loaderStateEntry.error && !loaderStateEntry.hasLoadedOnce) throw loaderStateEntry.error;
    if (loaderStateEntry.data === void 0 && loaderStateEntry.promise && !loaderStateEntry.hasLoadedOnce) throw loaderStateEntry.promise;
    return {
      data: loaderStateEntry.data,
      refetch,
      state: loaderStateEntry.state
    };
  } else return {
    refetch,
    state: loaderStateEntry.state
  };
}
function useLoader(loader2) {
  var {
    data: data2
  } = useLoaderState(loader2);
  return data2;
}
var results = /* @__PURE__ */new Map(),
  started = /* @__PURE__ */new Map();
function useAsyncFn(val, props) {
  var key = (val ? (0, import_weakKey.weakKey)(val) : "") + JSON.stringify(props);
  if (val && !started.get(key)) {
    started.set(key, !0);
    var next = val(props);
    _instanceof(next, Promise) && (next = next.then(function (final) {
      results.set(key, final);
    }).catch(function (err) {
      console.error("Error running loader()", err), results.set(key, void 0);
    })), results.set(key, next);
  }
  var current = results.get(key);
  if (_instanceof(current, Promise)) throw current;
  return current;
}
//# sourceMappingURL=useLoader.native.js.map