@esmx/router 3.0.0-rc.18 → 3.0.0-rc.19

package/dist/route.mjs

@@ -0,0 +1,194 @@
+import { parseLocation } from "./location.mjs";
+import { parsedOptions } from "./options.mjs";
+import {
+  RouteType
+} from "./types.mjs";
+import { isNonEmptyPlainObject, isPlainObject } from "./util.mjs";
+export const NON_ENUMERABLE_PROPERTIES = [
+  // Private fields - internal implementation details
+  "_handled",
+  "_handle",
+  "_handleResult",
+  "_options",
+  // SSR-specific properties - meaningless in client environment
+  "req",
+  "res",
+  // Internal context - used by framework internally
+  "context",
+  // Status code - internal status information
+  "statusCode",
+  // Route behavior overrides - framework internal logic
+  "confirm",
+  // Layer configuration - used for layer routes
+  "layer"
+];
+export function applyRouteParams(match, toInput, base, to) {
+  if (!isPlainObject(toInput) || !isNonEmptyPlainObject(toInput.params) || !match.matches.length) {
+    return;
+  }
+  const lastMatch = match.matches[match.matches.length - 1];
+  const current = to.pathname.split("/");
+  const next = new URL(
+    lastMatch.compile(toInput.params).substring(1),
+    base
+  ).pathname.split("/");
+  next.forEach((item, index) => {
+    current[index] = item || current[index];
+  });
+  to.pathname = current.join("/");
+  Object.assign(match.params, toInput.params);
+}
+export class Route {
+  // Private fields for handle validation
+  _handled = false;
+  _handle = null;
+  _handleResult = null;
+  _options;
+  // Public properties
+  statusCode = null;
+  state;
+  keepScrollPosition;
+  /** Custom confirm handler that overrides default route-transition confirm logic */
+  confirm;
+  /** Layer configuration for layer routes */
+  layer;
+  // Read-only properties
+  type;
+  req;
+  res;
+  context;
+  url;
+  path;
+  fullPath;
+  hash;
+  params = {};
+  query = {};
+  queryArray = {};
+  meta;
+  matched;
+  config;
+  constructor(routeOptions = {}) {
+    var _a;
+    const {
+      toType = RouteType.push,
+      toInput = "/",
+      from = null,
+      options = parsedOptions()
+    } = routeOptions;
+    this._options = options;
+    this.type = toType;
+    this.req = options.req;
+    this.res = options.res;
+    this.context = options.context;
+    const base = options.base;
+    const to = options.normalizeURL(parseLocation(toInput, base), from);
+    const isSameOrigin = to.origin === base.origin;
+    const isSameBase = to.pathname.startsWith(base.pathname);
+    const match = isSameOrigin && isSameBase ? options.matcher(to, base) : null;
+    this.url = to;
+    this.path = match ? to.pathname.substring(base.pathname.length - 1) : to.pathname;
+    this.fullPath = (match ? this.path : to.pathname) + to.search + to.hash;
+    this.matched = match ? match.matches : Object.freeze([]);
+    this.keepScrollPosition = isPlainObject(toInput) ? Boolean(toInput.keepScrollPosition) : false;
+    this.confirm = isPlainObject(toInput) && toInput.confirm ? toInput.confirm : null;
+    this.layer = toType === RouteType.pushLayer && isPlainObject(toInput) && toInput.layer ? toInput.layer : null;
+    this.config = this.matched.length > 0 ? this.matched[this.matched.length - 1] : null;
+    this.meta = ((_a = this.config) == null ? void 0 : _a.meta) || {};
+    const state = {};
+    if (isPlainObject(toInput) && toInput.state) {
+      Object.assign(state, toInput.state);
+    }
+    this.state = state;
+    for (const key of new Set(to.searchParams.keys())) {
+      this.query[key] = to.searchParams.get(key);
+      this.queryArray[key] = to.searchParams.getAll(key);
+    }
+    this.hash = to.hash;
+    if (match) {
+      applyRouteParams(match, toInput, base, to);
+      Object.assign(this.params, match.params);
+    }
+    if (isPlainObject(toInput) && typeof toInput.statusCode === "number") {
+      this.statusCode = toInput.statusCode;
+    }
+    for (const property of NON_ENUMERABLE_PROPERTIES) {
+      Object.defineProperty(this, property, { enumerable: false });
+    }
+  }
+  get isPush() {
+    return this.type.startsWith("push");
+  }
+  // handle related getter/setter
+  get handle() {
+    return this._handle;
+  }
+  set handle(val) {
+    this.setHandle(val);
+  }
+  get handleResult() {
+    return this._handleResult;
+  }
+  set handleResult(val) {
+    this._handleResult = val;
+  }
+  /**
+   * Set handle function with validation logic wrapper
+   */
+  setHandle(val) {
+    if (typeof val !== "function") {
+      this._handle = null;
+      return;
+    }
+    const self = this;
+    this._handle = function handle(to, from, router) {
+      if (self._handled) {
+        throw new Error(
+          "Route handle hook can only be called once per navigation"
+        );
+      }
+      self._handled = true;
+      return val.call(this, to, from, router);
+    };
+  }
+  /**
+   * Apply navigation-generated state to current route
+   * Used by route handlers to add system state like pageId
+   * @param navigationState Navigation-generated state to apply
+   */
+  applyNavigationState(navigationState) {
+    Object.assign(this.state, navigationState);
+  }
+  /**
+   * Sync all properties of current route to target route object
+   * Used for route object updates in reactive systems
+   * @param targetRoute Target route object
+   */
+  syncTo(targetRoute) {
+    Object.assign(targetRoute, this);
+    for (const property of NON_ENUMERABLE_PROPERTIES) {
+      if (!(property in this && property in targetRoute)) continue;
+      const value = Reflect.get(this, property);
+      Reflect.set(targetRoute, property, value);
+    }
+  }
+  /**
+   * Clone current route instance
+   * Returns a new Route instance with same configuration and state
+   */
+  clone() {
+    const toInput = {
+      path: this.fullPath,
+      state: { ...this.state },
+      ...this.confirm && { confirm: this.confirm },
+      ...this.layer && { layer: this.layer },
+      ...this.statusCode !== null && { statusCode: this.statusCode }
+    };
+    const options = this._options;
+    const clonedRoute = new Route({
+      options,
+      toType: this.type,
+      toInput
+    });
+    return clonedRoute;
+  }
+}

package/dist/route.test.d.ts

@@ -0,0 +1 @@
+export {};