one/dist/cjs/router/routeMask.js

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

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 routeMask_exports = {};
__export(routeMask_exports, {
  buildMaskedPath: () => buildMaskedPath,
  createRouteMask: () => createRouteMask,
  decodeUnmask: () => decodeUnmask,
  encodeUnmask: () => encodeUnmask,
  findMatchingMask: () => findMatchingMask,
  matchRouteMask: () => matchRouteMask,
  parseUnmaskFromPath: () => parseUnmaskFromPath
});
module.exports = __toCommonJS(routeMask_exports);
function createRouteMask(options) {
  const {
    from,
    to,
    params = !0,
    unmaskOnReload = !1,
    useSearchParam = !1
  } = options, fromParams = [], fromRegexStr = from.split("/").map((segment) => {
    if (segment.startsWith("[...") && segment.endsWith("]")) {
      const paramName = segment.slice(4, -1);
      return fromParams.push(paramName), "(.+)";
    }
    if (segment.startsWith("$...")) {
      const paramName = segment.slice(4);
      return fromParams.push(paramName), "(.+)";
    }
    if (segment.startsWith("[") && segment.endsWith("]")) {
      const paramName = segment.slice(1, -1);
      return fromParams.push(paramName), "([^/]+)";
    }
    if (segment.startsWith("$")) {
      const paramName = segment.slice(1);
      return fromParams.push(paramName), "([^/]+)";
    }
    return segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
  }).join("/");
  return {
    from,
    to,
    params,
    unmaskOnReload,
    useSearchParam,
    _fromRegex: new RegExp(`^${fromRegexStr}$`),
    _fromParams: fromParams
  };
}
function matchRouteMask(pathname, mask) {
  const match = pathname.match(mask._fromRegex);
  if (!match) return null;
  const params = {};
  return mask._fromParams.forEach((paramName, index) => {
    params[paramName] = match[index + 1];
  }), params;
}
function buildMaskedPath(mask, matchedParams) {
  let params;
  return mask.params === !1 ? params = {} : typeof mask.params == "function" ? params = mask.params(matchedParams) : params = matchedParams, mask.to.split("/").map((segment) => {
    if (segment.startsWith("[...") && segment.endsWith("]")) {
      const paramName = segment.slice(4, -1);
      return params[paramName] ?? "";
    }
    if (segment.startsWith("$...")) {
      const paramName = segment.slice(4);
      return params[paramName] ?? "";
    }
    if (segment.startsWith("[") && segment.endsWith("]")) {
      const paramName = segment.slice(1, -1);
      return params[paramName] ?? "";
    }
    if (segment.startsWith("$")) {
      const paramName = segment.slice(1);
      return params[paramName] ?? "";
    }
    return segment;
  }).join("/");
}
function encodeUnmask(path) {
  return btoa(path).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
}
function decodeUnmask(encoded) {
  const base64 = encoded.replace(/-/g, "+").replace(/_/g, "/");
  return atob(base64);
}
const UNMASK_SEPARATOR = "__";
function parseUnmaskFromPath(pathname) {
  const lastSlash = pathname.lastIndexOf("/"), lastSegment = pathname.slice(lastSlash + 1), separatorIndex = lastSegment.indexOf(UNMASK_SEPARATOR);
  if (separatorIndex === -1) return null;
  const encoded = lastSegment.slice(separatorIndex + UNMASK_SEPARATOR.length);
  if (!encoded) return null;
  try {
    return decodeUnmask(encoded);
  } catch {
    return null;
  }
}
function findMatchingMask(pathname, routeMasks) {
  for (const mask of routeMasks) {
    const matchedParams = matchRouteMask(pathname, mask);
    if (matchedParams) {
      const maskedPath = buildMaskedPath(mask, matchedParams), useSearchParam = mask.useSearchParam ?? !1;
      return {
        // If useSearchParam is true, append base64-encoded actual path as pathname postfix
        // e.g. /photos/3__L3Bob3Rvcy8zL21vZGFs
        maskedPath: useSearchParam ? `${maskedPath}${UNMASK_SEPARATOR}${encodeUnmask(pathname)}` : maskedPath,
        unmaskOnReload: mask.unmaskOnReload ?? !1,
        useSearchParam,
        actualPath: pathname
      };
    }
  }
}
//# sourceMappingURL=routeMask.js.map