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

package/dist/options.mjs

@@ -0,0 +1,88 @@
+import { createMatcher } from "./matcher.mjs";
+import { RouterMode } from "./types.mjs";
+import { isBrowser } from "./util.mjs";
+function getBaseUrl(options) {
+  let sourceUrl;
+  if (options.base) {
+    sourceUrl = options.base;
+  } else if (isBrowser) {
+    sourceUrl = location.origin;
+  } else if (options.req) {
+    const { req } = options;
+    const protocol = req.headers["x-forwarded-proto"] || req.headers["x-forwarded-protocol"] || (req.socket && "encrypted" in req.socket && req.socket.encrypted ? "https" : "http");
+    const host = req.headers["x-forwarded-host"] || req.headers.host || req.headers["x-real-ip"] || "localhost";
+    const port = req.headers["x-forwarded-port"];
+    const path = req.url || "";
+    sourceUrl = `${protocol}://${host}${port ? `:${port}` : ""}${path}`;
+  } else {
+    sourceUrl = "https://www.esmnext.com/";
+  }
+  let base;
+  try {
+    base = new URL(".", sourceUrl);
+  } catch (e) {
+    console.warn(
+      `Failed to parse base URL '${sourceUrl}', using default: https://www.esmnext.com/`
+    );
+    base = new URL("https://www.esmnext.com/");
+  }
+  base.search = base.hash = "";
+  return base;
+}
+export function parsedOptions(options = {}) {
+  const base = getBaseUrl(options);
+  const routes = Array.from(options.routes ?? []);
+  return Object.freeze({
+    rootStyle: options.rootStyle || false,
+    root: options.root || "",
+    context: options.context || {},
+    req: options.req || null,
+    res: options.res || null,
+    layer: options.layer || false,
+    zIndex: options.zIndex || 1e4,
+    base,
+    mode: isBrowser ? options.mode ?? RouterMode.history : RouterMode.memory,
+    routes,
+    apps: typeof options.apps === "function" ? options.apps : Object.assign({}, options.apps),
+    matcher: createMatcher(routes),
+    normalizeURL: options.normalizeURL ?? ((url) => url),
+    fallback: options.fallback ?? fallback,
+    handleBackBoundary: options.handleBackBoundary ?? (() => {
+    }),
+    handleLayerClose: options.handleLayerClose ?? (() => {
+    })
+  });
+}
+export function fallback(to, from, router) {
+  const href = to.url.href;
+  if (!isBrowser && (router == null ? void 0 : router.res)) {
+    let statusCode = 302;
+    const validRedirectCodes = [300, 301, 302, 303, 304, 307, 308];
+    if (to.statusCode && validRedirectCodes.includes(to.statusCode)) {
+      statusCode = to.statusCode;
+    } else if (to.statusCode) {
+      console.warn(
+        `Invalid redirect status code ${to.statusCode}, using default 302`
+      );
+    }
+    router.res.statusCode = statusCode;
+    router.res.setHeader("Location", href);
+    router.res.end();
+    return;
+  }
+  if (isBrowser) {
+    if (to.isPush) {
+      try {
+        const newWindow = window.open(href);
+        if (!newWindow) {
+          location.href = href;
+        } else {
+          newWindow.opener = null;
+        }
+        return newWindow;
+      } catch {
+      }
+    }
+    location.href = href;
+  }
+}

package/dist/route-task.d.ts

@@ -0,0 +1,40 @@
+import { Route } from './route';
+import type { Router } from './router';
+import type { RouteConfirmHook } from './types';
+/**
+ * Controls the execution and cancellation of a route task.
+ */
+export declare class RouteTaskController {
+    private _aborted;
+    /**
+     * Aborts the current task.
+     */
+    abort(): void;
+    shouldCancel(name: string): boolean;
+}
+export interface RouteTaskOptions {
+    to: Route;
+    from: Route | null;
+    tasks: RouteTask[];
+    router: Router;
+    /**
+     * Optional route task controller.
+     * Used to control the execution and cancellation of the task.
+     */
+    controller?: RouteTaskController;
+}
+export declare function createRouteTask(opts: RouteTaskOptions): Promise<Route>;
+export declare enum RouteTaskType {
+    fallback = "fallback",
+    override = "override",
+    asyncComponent = "asyncComponent",
+    beforeEach = "beforeEach",
+    beforeEnter = "beforeEnter",
+    beforeUpdate = "beforeUpdate",
+    beforeLeave = "beforeLeave",
+    confirm = "confirm"
+}
+export interface RouteTask {
+    name: string;
+    task: RouteConfirmHook;
+}

package/dist/route-task.mjs

@@ -0,0 +1,75 @@
+import {
+  RouteNavigationAbortedError,
+  RouteSelfRedirectionError,
+  RouteTaskCancelledError,
+  RouteTaskExecutionError
+} from "./error.mjs";
+import { Route } from "./route.mjs";
+import { isUrlEqual, isValidConfirmHookResult } from "./util.mjs";
+export class RouteTaskController {
+  _aborted = false;
+  /**
+   * Aborts the current task.
+   */
+  abort() {
+    this._aborted = true;
+  }
+  shouldCancel(name) {
+    if (this._aborted) {
+      return true;
+    }
+    return false;
+  }
+}
+export async function createRouteTask(opts) {
+  const { to, from, tasks, controller, router } = opts;
+  for (const task of tasks) {
+    if (controller == null ? void 0 : controller.shouldCancel(task.name)) {
+      throw new RouteTaskCancelledError(task.name, to, from);
+    }
+    let result = null;
+    try {
+      result = await task.task(to, from, router);
+    } catch (e) {
+      throw new RouteTaskExecutionError(task.name, to, from, e);
+    }
+    if (controller == null ? void 0 : controller.shouldCancel(task.name)) {
+      throw new RouteTaskCancelledError(task.name, to, from);
+    }
+    if (!isValidConfirmHookResult(result)) continue;
+    if (typeof result === "function") {
+      to.handle = result;
+      return to;
+    }
+    if (result === false) {
+      throw new RouteNavigationAbortedError(task.name, to, from);
+    }
+    const nextTo = new Route({
+      options: router.parsedOptions,
+      toType: to.type,
+      toInput: result,
+      from: to.url
+    });
+    if (isUrlEqual(nextTo.url, to.url)) {
+      throw new RouteSelfRedirectionError(to.fullPath, to, from);
+    }
+    return createRouteTask({
+      ...opts,
+      to: nextTo,
+      from: to,
+      controller
+    });
+  }
+  return to;
+}
+export var RouteTaskType = /* @__PURE__ */ ((RouteTaskType2) => {
+  RouteTaskType2["fallback"] = "fallback";
+  RouteTaskType2["override"] = "override";
+  RouteTaskType2["asyncComponent"] = "asyncComponent";
+  RouteTaskType2["beforeEach"] = "beforeEach";
+  RouteTaskType2["beforeEnter"] = "beforeEnter";
+  RouteTaskType2["beforeUpdate"] = "beforeUpdate";
+  RouteTaskType2["beforeLeave"] = "beforeLeave";
+  RouteTaskType2["confirm"] = "confirm";
+  return RouteTaskType2;
+})(RouteTaskType || {});

package/dist/route-task.test.d.ts

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