one/dist/cjs/router/routeMask.cjs

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
      };
    }
  }
}