GitFOSS

/* InstantRouter */var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;

var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {
  enumerable: true,
  configurable: true,
  writable: true,
  value
}) : obj[key] = value;

var __spreadValues = (a, b) => {
  for (var prop in b || (b = {})) if (__hasOwnProp.call(b, prop)) __defNormalProp(a, prop, b[prop]);

  if (__getOwnPropSymbols) for (var prop of __getOwnPropSymbols(b)) {
    if (__propIsEnum.call(b, prop)) __defNormalProp(a, prop, b[prop]);
  }
  return a;
};

var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));

var __name = (target, value) => __defProp(target, "name", {
  value,
  configurable: true
});

var __async = (__this, __arguments, generator) => {
  return new Promise((resolve, reject) => {
    var fulfilled = value => {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    };

    var rejected = value => {
      try {
        step(generator.throw(value));
      } catch (e) {
        reject(e);
      }
    };

    var step = x => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);

    step((generator = generator.apply(__this, __arguments)).next());
  });
}; // node_modules/@ethicdevs/react-monolith/dist/core/instant-router.js


var domParser = new DOMParser();

function fetchAnchorHref(anchorHref, currentLocationHref, method = "get", body = void 0, headers = void 0) {
  return __async(this, null, function* () {
    const url = method.toLowerCase() === "get" && body != null ? `${anchorHref}?${body}` : anchorHref;
    const res = yield fetch(url, {
      method,
      body: method.toLowerCase() !== "get" ? body : void 0,
      headers: __spreadProps(__spreadValues(__spreadValues({}, headers || {}), anchorHref !== currentLocationHref ? {
        referer: currentLocationHref
      } : {}), {
        accept: "text/html",
        "accept-charset": "utf-8",
        "x-requested-with": "XMLHttpRequest"
      })
    });
    return res;
  });
}

__name(fetchAnchorHref, "fetchAnchorHref");

function fetchAndPushState(targetHref, refererHref, method = "get", body = void 0, headers = void 0, withAutoScroll = true) {
  return __async(this, null, function* () {
    let targetHtml = null;

    try {
      document.dispatchEvent(new CustomEvent(ClientSideRouterEvents.LOADING, {
        detail: {
          request: {
            method,
            url: targetHref,
            body,
            headers,
            referer: refererHref
          }
        }
      }));
      let res = yield fetchAnchorHref(targetHref, refererHref, method, body, headers);

      if (res.status >= 301 && res.status <= 308) {
        const locationHeaderHref = res.headers.get("location");

        if (locationHeaderHref != null) {
          targetHref = locationHeaderHref;
          res = yield fetchAnchorHref(targetHref, refererHref, method, body, headers);
        }
      } else {
        targetHtml = yield res.text();
        targetHref = res.url;
      }

      document.dispatchEvent(new CustomEvent(ClientSideRouterEvents.LOADED, {
        detail: {
          request: {
            method,
            url: targetHref,
            body,
            headers,
            referer: refererHref
          },
          response: {
            html: targetHtml
          }
        }
      }));
    } catch (err) {
      const error = err;
      document.dispatchEvent(new CustomEvent(ClientSideRouterEvents.LOAD_ERROR, {
        detail: {
          request: {
            method,
            url: targetHref,
            body,
            headers,
            referer: refererHref
          },
          response: {
            error
          }
        }
      }));
    }

    if (targetHtml == null) {
      document.dispatchEvent(new CustomEvent(ClientSideRouterEvents.LOAD_ERROR, {
        detail: {
          request: {
            method,
            url: targetHref,
            body,
            headers,
            referer: refererHref
          },
          response: {
            error: new Error("Could not retrieve HTML to display, it was null.")
          }
        }
      }));
      return () => void 0;
    }

    const targetDoc = domParser.parseFromString(targetHtml, "text/html");
    const {
      body: targetBody,
      head: targetHead,
      title: targetTitle
    } = targetDoc;
    const targetStyles = [];
    targetHead.childNodes.forEach(node => {
      if (node.nodeType === 1 && node.nodeName.toLowerCase() === "style") {
        targetStyles.push(node);
      }
    });
    return () => {
      var _a;

      try {
        document.dispatchEvent(new CustomEvent(ClientSideRouterEvents.NAVIGATING, {
          detail: {
            request: {
              url: targetHref,
              referer: refererHref,
              body: targetBody,
              head: targetHead,
              title: targetTitle
            }
          }
        }));
        document.title = targetTitle;
        document.body.innerHTML = targetBody.innerHTML || document.body.innerHTML;

        if (document.scrollingElement != null && withAutoScroll === true) {
          document.scrollingElement.scrollTo({
            behavior: "smooth",
            top: 0
          });
        }

        if (typeof window.history !== "undefined" && targetHref !== ((_a = history.state) === null || _a === void 0 ? void 0 : _a.targetHref) && targetHref !== refererHref) {
          const targetUrl = new URL(targetHref);
          window.history.pushState({
            targetHref
          }, "", method.toLowerCase() === "get" && body != null ? [targetUrl.pathname, body].join("?") : targetUrl.pathname);
        }

        document.dispatchEvent(new CustomEvent(ClientSideRouterEvents.NAVIGATED, {
          detail: {
            request: {
              url: targetHref,
              referer: refererHref,
              body: targetBody,
              head: targetHead,
              title: targetTitle
            },
            response: true
          }
        }));
      } catch (err) {
        const error = err;
        document.dispatchEvent(new CustomEvent(ClientSideRouterEvents.NAVIGATION_ERROR, {
          detail: {
            request: {
              url: targetHref,
              referer: refererHref,
              body: targetBody,
              head: targetHead,
              title: targetTitle
            },
            response: {
              error
            }
          }
        }));
      }
    };
  });
}

__name(fetchAndPushState, "fetchAndPushState");

function clientSideRouter() {
  return __async(this, arguments, function* (opts = {
    fetchAnchorsOn: "mousedown"
  }) {
    const pageHref = window.location.href;

    function onClientSideRouterMouseDown(ev) {
      return __async(this, null, function* () {
        const targetEl = ev.target;

        if (ev == null || ev.button !== 0 || targetEl == null || targetEl.tagName.toLowerCase() !== "a" || "href" in targetEl === false || targetEl.href == null || targetEl.href.trim() === "") {
          return false;
        }

        const targetDataset = targetEl.dataset;
        const baseUrl = new URL(document.baseURI);
        const targetUrl = new URL(targetEl.href, document.baseURI);
        const isExternalUrl = baseUrl.origin !== targetUrl.origin;

        if (isExternalUrl || targetDataset["externalLink"] === "true") {
          return false;
        }

        const targetHash = targetUrl.hash;
        const isHashChange = !!(targetHash != null && targetHash.trim() !== "" && targetHash.startsWith("#"));

        if (isHashChange) {
          const hashEl = document.querySelector(targetHash);

          if (hashEl != null) {
            ev.preventDefault();

            if (targetDataset["smoothScroll"] !== "disabled") {
              hashEl.scrollIntoView({
                behavior: "smooth"
              });
            }

            window.location.hash = targetHash;
            return true;
          }

          return false;
        }

        let doNavigate = null;
        let pollWaitFetchDoneIntervalId = null;

        const navigateOrWait = /* @__PURE__ */__name(() => {
          if (doNavigate != null) {
            doNavigate();

            if (pollWaitFetchDoneIntervalId != null) {
              clearTimeout(pollWaitFetchDoneIntervalId);
              pollWaitFetchDoneIntervalId = null;
            }

            if (targetEl != null && onClickHandler != null) {
              targetEl.removeEventListener("click", onClickHandler);
              onClickHandler = null;
            }
          } else {
            pollWaitFetchDoneIntervalId = setTimeout(() => {
              if (pollWaitFetchDoneIntervalId != null) {
                clearTimeout(pollWaitFetchDoneIntervalId);
                pollWaitFetchDoneIntervalId = null;
              }

              navigateOrWait();
            }, 10);
          }
        }, "navigateOrWait");

        let onClickHandler = /* @__PURE__ */__name(subEv => {
          subEv.preventDefault();
          navigateOrWait();
          return true;
        }, "onClickHandler");

        try {
          targetEl.addEventListener("click", onClickHandler);
          doNavigate = yield fetchAndPushState(targetEl.href, pageHref, void 0, void 0, void 0, targetDataset["smoothScroll"] !== "disabled");
        } catch (_) {
          targetEl.removeEventListener("click", onClickHandler);
          onClickHandler = null;
          doNavigate = /* @__PURE__ */__name(() => {
            window.location.href = targetEl.href;
          }, "doNavigate");
        }

        return true;
      });
    }

    __name(onClientSideRouterMouseDown, "onClientSideRouterMouseDown");

    function onClientSideRouterSubmit(ev) {
      return __async(this, null, function* () {
        const targetEl = ev.target;

        if (targetEl == null || targetEl.tagName.toLowerCase() !== "form") {
          return false;
        }

        const targetAction = targetEl.action;
        const targetMethod = targetEl.method;

        if (targetAction == null || targetAction.trim() === "" || targetMethod == null || ["get", "post"].includes(targetMethod.toLowerCase()) === false) {
          return false;
        }

        ev.preventDefault();
        const headers = {
          "content-type": "application/x-www-form-urlencoded"
        };
        const targetFormData = new FormData(targetEl);
        let targetFormDataEntries = {};
        targetFormData.forEach((v, k) => {
          targetFormDataEntries = __spreadProps(__spreadValues({}, targetFormDataEntries), {
            [k]: v
          });
        });
        const bodyFormEncoded = Object.entries(targetFormDataEntries).map(([k, v]) => `${k}=${v}`).join("&");

        let doNavigate = /* @__PURE__ */__name(() => {
          window.location.href = targetAction;
        }, "doNavigate");

        try {
          doNavigate = yield fetchAndPushState(targetAction, pageHref, targetMethod, bodyFormEncoded, headers);
        } catch (_) {}

        doNavigate();
        return true;
      });
    }

    __name(onClientSideRouterSubmit, "onClientSideRouterSubmit");

    document.addEventListener(opts.fetchAnchorsOn, onClientSideRouterMouseDown);
    document.addEventListener("submit", onClientSideRouterSubmit);
    window.addEventListener("popstate", event => setTimeout(() => __async(this, null, function* () {
      if (event.state) {
        if (event.state.targetHref != null) {
          let doNavigate = /* @__PURE__ */__name(() => {
            window.location.href = event.state.targetHref;
          }, "doNavigate");

          try {
            doNavigate = yield fetchAndPushState(event.state.targetHref, pageHref, void 0, void 0, void 0, false);
          } catch (_) {}

          doNavigate();
          return true;
        }

        return false;
      } else {
        return false;
      }
    }), 0));
  });
}

__name(clientSideRouter, "clientSideRouter");

var ClientSideRouterEventPrefix = `instantroute_`;
var ClientSideRouterEvents = {
  LOADING: `${ClientSideRouterEventPrefix}loading`,
  LOADED: `${ClientSideRouterEventPrefix}loaded`,
  LOAD_ERROR: `${ClientSideRouterEventPrefix}load_error`,
  NAVIGATING: `${ClientSideRouterEventPrefix}navigating`,
  NAVIGATED: `${ClientSideRouterEventPrefix}navigated`,
  NAVIGATION_ERROR: `${ClientSideRouterEventPrefix}navigation_error`
};
window.location["hardReplace"] = window.location.replace;
window.location.replace = /* @__PURE__ */__name(function replace(url) {
  const pageHref = window.location.href;
  fetchAndPushState(url.toString(), pageHref).then(doNavigate => doNavigate()).catch(() => {
    window.location["hardReplace"](url.toString());
  });
}, "replace");
clientSideRouter({
  fetchAnchorsOn: "mousedown"
});