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 = `app_router_`;
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",
});