@hybridly/core 0.4.1 → 0.4.3

package/dist/index.cjs

@@ -1,16 +1,14 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
+const qs = require('qs');
 const utils = require('@hybridly/utils');
 const axios = require('axios');
 const superjson = require('superjson');
-const qs = require('qs');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
-const axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
-const qs__default = /*#__PURE__*/_interopDefaultLegacy(qs);
+const qs__default = /*#__PURE__*/_interopDefaultCompat(qs);
+const axios__default = /*#__PURE__*/_interopDefaultCompat(axios);
 
 const STORAGE_EXTERNAL_KEY = "hybridly:external";
 const HYBRIDLY_HEADER = "x-hybrid";
@@ -27,18 +25,18 @@ const SCROLL_REGION_ATTRIBUTE = "scroll-region";
 
 const constants = {
 	__proto__: null,
-	STORAGE_EXTERNAL_KEY: STORAGE_EXTERNAL_KEY,
-	HYBRIDLY_HEADER: HYBRIDLY_HEADER,
-	EXTERNAL_NAVIGATION_HEADER: EXTERNAL_NAVIGATION_HEADER,
-	PARTIAL_COMPONENT_HEADER: PARTIAL_COMPONENT_HEADER,
-	ONLY_DATA_HEADER: ONLY_DATA_HEADER,
+	CONTEXT_HEADER: CONTEXT_HEADER,
 	DIALOG_KEY_HEADER: DIALOG_KEY_HEADER,
 	DIALOG_REDIRECT_HEADER: DIALOG_REDIRECT_HEADER,
-	EXCEPT_DATA_HEADER: EXCEPT_DATA_HEADER,
-	CONTEXT_HEADER: CONTEXT_HEADER,
-	VERSION_HEADER: VERSION_HEADER,
 	ERROR_BAG_HEADER: ERROR_BAG_HEADER,
-	SCROLL_REGION_ATTRIBUTE: SCROLL_REGION_ATTRIBUTE
+	EXCEPT_DATA_HEADER: EXCEPT_DATA_HEADER,
+	EXTERNAL_NAVIGATION_HEADER: EXTERNAL_NAVIGATION_HEADER,
+	HYBRIDLY_HEADER: HYBRIDLY_HEADER,
+	ONLY_DATA_HEADER: ONLY_DATA_HEADER,
+	PARTIAL_COMPONENT_HEADER: PARTIAL_COMPONENT_HEADER,
+	SCROLL_REGION_ATTRIBUTE: SCROLL_REGION_ATTRIBUTE,
+	STORAGE_EXTERNAL_KEY: STORAGE_EXTERNAL_KEY,
+	VERSION_HEADER: VERSION_HEADER
 };
 
 class NotAHybridResponseError extends Error {
@@ -245,6 +243,7 @@ function setHistoryState(options = {}) {
   utils.debug.history("Setting history state:", {
     method,
     context
+    // serialized,
   });
   try {
     window.history[method](serialized, "", context.url);
@@ -360,10 +359,59 @@ function createSerializer(options) {
   };
 }
 
+function getUrlRegexForRoute(name) {
+  const routing = getRouting();
+  const definition = getRouteDefinition(name);
+  const path = definition.uri.replaceAll("/", "\\/");
+  const domain = definition.domain;
+  const protocolPrefix = routing.url.match(/^\w+:\/\//)?.[0];
+  const origin = domain ? `${protocolPrefix}${domain}${routing.port ? `:${routing.port}` : ""}`.replaceAll("/", "\\/") : routing.url.replaceAll("/", "\\/");
+  const urlPathRegexPattern = path.length > 0 ? `\\/${path.replace(/\/$/g, "")}` : "";
+  let urlRegexPattern = `^${origin.replaceAll(".", "\\.")}${urlPathRegexPattern}\\/?(\\?.*)?$`;
+  urlRegexPattern = urlRegexPattern.replace(/(\\\/?){([^}?]+)(\??)}/g, (_, slash, parameterName, optional) => {
+    const where = definition.wheres?.[parameterName];
+    let regexTemplate = where?.replace(/(^\^)|(\$$)/g, "") || "[^/?]+";
+    regexTemplate = `(?<${parameterName}>${regexTemplate})`;
+    if (optional) {
+      return `(${slash ? "\\/?" : ""}${regexTemplate})?`;
+    }
+    return (slash ? "\\/" : "") + regexTemplate;
+  });
+  return RegExp(urlRegexPattern);
+}
+function urlMatchesRoute(url, name, routeParameters) {
+  const parameters = routeParameters || {};
+  const definition = getRouting().routes[name];
+  if (!definition) {
+    return false;
+  }
+  const matches = getUrlRegexForRoute(name).exec(url);
+  if (!matches) {
+    return false;
+  }
+  for (const k in matches.groups) {
+    matches.groups[k] = typeof matches.groups[k] === "string" ? decodeURIComponent(matches.groups[k]) : matches.groups[k];
+  }
+  return Object.keys(parameters).every((parameterName) => {
+    let value = parameters[parameterName];
+    const bindingProperty = definition.bindings?.[parameterName];
+    if (bindingProperty && typeof value === "object") {
+      value = value[bindingProperty];
+    }
+    return matches.groups?.[parameterName] === value.toString();
+  });
+}
 function generateRouteFromName(name, parameters, absolute, shouldThrow) {
   const url = getUrlFromName(name, parameters, shouldThrow);
   return absolute === false ? url.toString().replace(url.origin, "") : url.toString();
 }
+function getNameFromUrl(url, parameters) {
+  const routing = getRouting();
+  const routes = Object.values(routing.routes).map((x) => x.name);
+  return routes.find((routeName) => {
+    return urlMatchesRoute(url, routeName, parameters);
+  });
+}
 function getUrlFromName(name, parameters, shouldThrow) {
   const routing = getRouting();
   const definition = getRouteDefinition(name);
@@ -376,32 +424,39 @@ function getUrlFromName(name, parameters, shouldThrow) {
   }));
   return url;
 }
-function getRouteTransformable(routeName, routeParameters, shouldThrow) {
+function getRouteParameterValue(routeName, parameterName, routeParameters) {
   const routing = getRouting();
+  const definition = getRouteDefinition(routeName);
+  const parameters = routeParameters || {};
+  const value = (() => {
+    const value2 = parameters[parameterName];
+    const bindingProperty = definition.bindings?.[parameterName];
+    if (bindingProperty && value2 != null && typeof value2 === "object") {
+      return value2[bindingProperty];
+    }
+    return value2;
+  })();
+  if (value) {
+    const where = definition.wheres?.[parameterName];
+    if (where && !new RegExp(where).test(value)) {
+      console.warn(`[hybridly:routing] Parameter [${parameterName}] does not match the required format [${where}] for route [${routeName}].`);
+    }
+    return value;
+  }
+  if (routing.defaults?.[parameterName]) {
+    return routing.defaults?.[parameterName];
+  }
+}
+function getRouteTransformable(routeName, routeParameters, shouldThrow) {
   const definition = getRouteDefinition(routeName);
   const parameters = routeParameters || {};
   const missing = Object.keys(parameters);
-  const replaceParameter = (match, parameterName) => {
-    const optional = /\?}$/.test(match);
-    const value = (() => {
-      const value2 = parameters[parameterName];
-      const bindingProperty = definition.bindings?.[parameterName];
-      if (bindingProperty && typeof value2 === "object") {
-        return value2[bindingProperty];
-      }
-      return value2;
-    })();
+  const replaceParameter = (match, parameterName, optional) => {
+    const value = getRouteParameterValue(routeName, parameterName, parameters);
     missing.splice(missing.indexOf(parameterName), 1);
     if (value) {
-      const where = definition.wheres?.[parameterName];
-      if (where && !new RegExp(where).test(value)) {
-        console.warn(`[hybridly:routing] Parameter [${parameterName}] does not match the required format [${where}] for route [${routeName}].`);
-      }
       return value;
     }
-    if (routing.defaults?.[parameterName]) {
-      return routing.defaults?.[parameterName];
-    }
     if (optional) {
       return "";
     }
@@ -410,8 +465,8 @@ function getRouteTransformable(routeName, routeParameters, shouldThrow) {
     }
     throw new MissingRouteParameter(parameterName, routeName);
   };
-  const path = definition.uri.replace(/{([^}?]+)\??}/g, replaceParameter);
-  const domain = definition.domain?.replace(/{([^}?]+)\??}/g, replaceParameter);
+  const path = definition.uri.replace(/{([^}?]+)(\??)}/g, replaceParameter);
+  const domain = definition.domain?.replace(/{([^}?]+)(\??)}/g, replaceParameter);
   const remaining = Object.keys(parameters).filter((key) => missing.includes(key)).reduce((obj, key) => ({
     ...obj,
     [key]: parameters[key]
@@ -441,30 +496,28 @@ function getRouting() {
   }
   return routing;
 }
-
-function isCurrentFromName(name, parameters, mode = "loose") {
-  const location = window.location;
-  const matchee = (() => {
-    try {
-      return makeUrl(generateRouteFromName(name, parameters, true, false));
-    } catch (error) {
-    }
-  })();
-  if (!matchee) {
-    return false;
-  }
-  if (mode === "strict") {
-    return location.href === matchee.href;
-  }
-  return location.href.startsWith(matchee.href);
-}
-
 function route(name, parameters, absolute) {
   return generateRouteFromName(name, parameters, absolute);
 }
-function current(name, parameters, mode = "loose") {
-  return isCurrentFromName(name, parameters, mode);
+
+function getCurrentUrl() {
+  if (typeof window === "undefined") {
+    return getInternalRouterContext().url;
+  }
+  return window.location.toString();
+}
+function currentRouteMatches(name, parameters) {
+  const namePattern = name.replaceAll(".", "\\.").replaceAll("*", ".*");
+  const possibleRoutes = Object.values(getRouting().routes).filter((x) => x.method.includes("GET") && RegExp(namePattern).test(x.name)).map((x) => x.name);
+  const currentUrl = getCurrentUrl();
+  return possibleRoutes.some((routeName) => {
+    return urlMatchesRoute(currentUrl, routeName, parameters);
+  });
+}
+function getCurrentRouteName() {
+  return getNameFromUrl(getCurrentUrl());
 }
+
 function updateRoutingConfiguration(routing) {
   if (!routing) {
     return;
@@ -655,6 +708,8 @@ const router = {
     const method = getRouteDefinition(name).method.at(0);
     return await performHybridNavigation({ url, ...options, method });
   },
+  matches: (name, parameters) => currentRouteMatches(name, parameters),
+  current: () => getCurrentRouteName(),
   dialog: {
     close: (options) => closeDialog(options)
   },
@@ -956,7 +1011,6 @@ function can(resource, action) {
 exports.can = can;
 exports.constants = constants;
 exports.createRouter = createRouter;
-exports.current = current;
 exports.definePlugin = definePlugin;
 exports.getRouterContext = getRouterContext;
 exports.makeUrl = makeUrl;