one/dist/cjs/router/routeMask.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 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) {
  var {
      from,
      to,
      params = !0,
      unmaskOnReload = !1,
      useSearchParam = !1
    } = options,
    fromParams = [],
    fromRegexStr = from.split("/").map(function (segment) {
      if (segment.startsWith("[...") && segment.endsWith("]")) {
        var paramName = segment.slice(4, -1);
        return fromParams.push(paramName), "(.+)";
      }
      if (segment.startsWith("$...")) {
        var paramName1 = segment.slice(4);
        return fromParams.push(paramName1), "(.+)";
      }
      if (segment.startsWith("[") && segment.endsWith("]")) {
        var paramName2 = segment.slice(1, -1);
        return fromParams.push(paramName2), "([^/]+)";
      }
      if (segment.startsWith("$")) {
        var paramName3 = segment.slice(1);
        return fromParams.push(paramName3), "([^/]+)";
      }
      return segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
    }).join("/");
  return {
    from,
    to,
    params,
    unmaskOnReload,
    useSearchParam,
    _fromRegex: new RegExp(`^${fromRegexStr}$`),
    _fromParams: fromParams
  };
}
function matchRouteMask(pathname, mask) {
  var match = pathname.match(mask._fromRegex);
  if (!match) return null;
  var params = {};
  return mask._fromParams.forEach(function (paramName, index) {
    params[paramName] = match[index + 1];
  }), params;
}
function buildMaskedPath(mask, matchedParams) {
  var params;
  return mask.params === !1 ? params = {} : typeof mask.params == "function" ? params = mask.params(matchedParams) : params = matchedParams, mask.to.split("/").map(function (segment) {
    if (segment.startsWith("[...") && segment.endsWith("]")) {
      var _params_paramName,
        paramName = segment.slice(4, -1);
      return (_params_paramName = params[paramName]) !== null && _params_paramName !== void 0 ? _params_paramName : "";
    }
    if (segment.startsWith("$...")) {
      var _params_paramName1,
        paramName1 = segment.slice(4);
      return (_params_paramName1 = params[paramName1]) !== null && _params_paramName1 !== void 0 ? _params_paramName1 : "";
    }
    if (segment.startsWith("[") && segment.endsWith("]")) {
      var _params_paramName2,
        paramName2 = segment.slice(1, -1);
      return (_params_paramName2 = params[paramName2]) !== null && _params_paramName2 !== void 0 ? _params_paramName2 : "";
    }
    if (segment.startsWith("$")) {
      var _params_paramName3,
        paramName3 = segment.slice(1);
      return (_params_paramName3 = params[paramName3]) !== null && _params_paramName3 !== void 0 ? _params_paramName3 : "";
    }
    return segment;
  }).join("/");
}
function encodeUnmask(path) {
  return btoa(path).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
}
function decodeUnmask(encoded) {
  var base64 = encoded.replace(/-/g, "+").replace(/_/g, "/");
  return atob(base64);
}
var UNMASK_SEPARATOR = "__";
function parseUnmaskFromPath(pathname) {
  var lastSlash = pathname.lastIndexOf("/"),
    lastSegment = pathname.slice(lastSlash + 1),
    separatorIndex = lastSegment.indexOf(UNMASK_SEPARATOR);
  if (separatorIndex === -1) return null;
  var encoded = lastSegment.slice(separatorIndex + UNMASK_SEPARATOR.length);
  if (!encoded) return null;
  try {
    return decodeUnmask(encoded);
  } catch {
    return null;
  }
}
function findMatchingMask(pathname, routeMasks) {
  var _iteratorNormalCompletion = !0,
    _didIteratorError = !1,
    _iteratorError = void 0;
  try {
    for (var _iterator = routeMasks[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
      var mask = _step.value,
        matchedParams = matchRouteMask(pathname, mask);
      if (matchedParams) {
        var _mask_useSearchParam,
          _mask_unmaskOnReload,
          maskedPath = buildMaskedPath(mask, matchedParams),
          useSearchParam = (_mask_useSearchParam = mask.useSearchParam) !== null && _mask_useSearchParam !== void 0 ? _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 = mask.unmaskOnReload) !== null && _mask_unmaskOnReload !== void 0 ? _mask_unmaskOnReload : !1,
          useSearchParam,
          actualPath: pathname
        };
      }
    }
  } catch (err) {
    _didIteratorError = !0, _iteratorError = err;
  } finally {
    try {
      !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
    } finally {
      if (_didIteratorError) throw _iteratorError;
    }
  }
}
//# sourceMappingURL=routeMask.native.js.map