@qwik.dev/router 2.0.0-beta.11 → 2.0.0-beta.14

package/lib/chunks/format-error.mjs

@@ -0,0 +1,137 @@
+import { l as normalizePath } from './fs.mjs';
+import fs from 'node:fs';
+
+const findLocation = (e) => {
+  const stack = e.stack;
+  if (typeof stack === "string") {
+    const lines = stack.split("\n").filter((l) => !l.includes("/node_modules/") && !l.includes("(node:"));
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i].replace("file:///", "/");
+      if (/^\s+at/.test(line)) {
+        const start = line.indexOf("/");
+        const end = line.lastIndexOf(")", start);
+        if (start > 0) {
+          const path = line.slice(start, end);
+          const parts = path.split(":");
+          const nu0 = safeParseInt(parts[parts.length - 1]);
+          const nu1 = safeParseInt(parts[parts.length - 2]);
+          if (typeof nu0 === "number" && typeof nu1 === "number") {
+            parts.length -= 2;
+            return {
+              file: parts.join(":"),
+              line: nu1,
+              column: nu0
+            };
+          } else if (typeof nu0 === "number") {
+            parts.length -= 1;
+            return {
+              file: parts.join(":"),
+              line: nu0,
+              column: void 0
+            };
+          } else {
+            return {
+              file: parts.join(":"),
+              line: void 0,
+              column: void 0
+            };
+          }
+        }
+      }
+    }
+  }
+  return void 0;
+};
+const safeParseInt = (nu) => {
+  try {
+    return parseInt(nu, 10);
+  } catch {
+    return void 0;
+  }
+};
+const splitRE = /\r?\n/;
+const range = 2;
+function posToNumber(source, pos) {
+  if (typeof pos === "number") {
+    return pos;
+  }
+  if (pos.lo != null) {
+    return pos.lo;
+  }
+  const lines = source.split(splitRE);
+  const { line, column } = pos;
+  let start = 0;
+  for (let i = 0; i < line - 1 && i < lines.length; i++) {
+    start += lines[i].length + 1;
+  }
+  return start + column;
+}
+function generateCodeFrame(source, start = 0, end) {
+  start = posToNumber(source, start);
+  end = end || start;
+  const lines = source.split(splitRE);
+  let count = 0;
+  const res = [];
+  for (let i = 0; i < lines.length; i++) {
+    count += lines[i].length + 1;
+    if (count >= start) {
+      for (let j = i - range; j <= i + range || end > count; j++) {
+        if (j < 0 || j >= lines.length) {
+          continue;
+        }
+        const line = j + 1;
+        res.push(`${line}${" ".repeat(Math.max(3 - String(line).length, 0))}|  ${lines[j]}`);
+        const lineLength = lines[j].length;
+        if (j === i) {
+          const pad = Math.max(start - (count - lineLength) + 1, 0);
+          const length = Math.max(1, end > count ? lineLength - pad : end - start);
+          res.push(`   |  ` + " ".repeat(pad) + "^".repeat(length));
+        } else if (j > i) {
+          if (end > count) {
+            const length = Math.max(Math.min(end - count, lineLength), 1);
+            res.push(`   |  ` + "^".repeat(length));
+          }
+          count += lineLength + 1;
+        }
+      }
+      break;
+    }
+  }
+  return res.join("\n");
+}
+function parseId(originalId) {
+  const [pathId, query] = originalId.split("?");
+  const queryStr = query || "";
+  return {
+    originalId,
+    pathId,
+    query: queryStr ? `?${query}` : "",
+    params: new URLSearchParams(queryStr)
+  };
+}
+
+function formatError(e) {
+  if (e instanceof Error) {
+    const err = e;
+    let loc = err.loc;
+    if (!err.frame && !err.plugin) {
+      if (!loc) {
+        loc = findLocation(err);
+      }
+      if (loc) {
+        err.loc = loc;
+        if (loc.file) {
+          err.id = normalizePath(err.loc.file);
+          try {
+            const code = fs.readFileSync(err.loc.file, "utf-8");
+            err.frame = generateCodeFrame(code, err.loc);
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  return e;
+}
+
+export { formatError as f, parseId as p };

package/lib/chunks/fs.mjs

@@ -0,0 +1,254 @@
+import { normalize, basename, dirname, relative } from 'node:path';
+
+function toTitleCase(str) {
+  return str.replace(/\w\S*/g, (txt) => {
+    return txt.charAt(0).toUpperCase() + txt.slice(1).toLowerCase();
+  });
+}
+function addError(ctx, e) {
+  ctx.diagnostics.push({
+    type: "error",
+    message: e ? String(e.stack || e) : "Error"
+  });
+}
+function addWarning(ctx, message) {
+  ctx.diagnostics.push({
+    type: "warn",
+    message: String(message)
+  });
+}
+function msToString(ms) {
+  if (ms < 1) {
+    return ms.toFixed(2) + " ms";
+  }
+  if (ms < 1e3) {
+    return ms.toFixed(1) + " ms";
+  }
+  if (ms < 6e4) {
+    return (ms / 1e3).toFixed(1) + " s";
+  }
+  return (ms / 6e4).toFixed(1) + " m";
+}
+
+function normalizePathname(pathname, basePathname) {
+  if (typeof pathname === "string") {
+    pathname = pathname.trim();
+    if (pathname !== "") {
+      try {
+        pathname = pathname.replace(/\/+/g, "/");
+        if (pathname.startsWith("/")) {
+          pathname = pathname.slice(1);
+        }
+        pathname = new URL(basePathname + pathname, `https://qwik.dev`).pathname;
+        if (pathname !== basePathname) {
+          if (!globalThis.__NO_TRAILING_SLASH__) {
+            if (!pathname.endsWith("/")) {
+              const segments = pathname.split("/");
+              const lastSegment = segments[segments.length - 1];
+              if (!lastSegment.includes(".")) {
+                pathname += "/";
+              }
+            }
+          } else {
+            if (pathname.endsWith("/")) {
+              pathname = pathname.slice(0, pathname.length - 1);
+            }
+          }
+        }
+        return pathname;
+      } catch (e) {
+        console.error(e);
+      }
+    }
+  }
+  return null;
+}
+function getPathnameForDynamicRoute(originalPathname, paramNames, params) {
+  let pathname = originalPathname;
+  if (paramNames && params) {
+    for (const paramName of paramNames) {
+      const paramKey = `[${paramName}]`;
+      const restParamKey = `[...${paramName}]`;
+      const paramValue = params[paramName];
+      pathname = pathname.replace(restParamKey, paramValue);
+      pathname = pathname.replace(paramKey, paramValue);
+    }
+  }
+  return pathname;
+}
+function isSameOriginUrl(url) {
+  if (typeof url === "string") {
+    url = url.trim();
+    if (url !== "") {
+      const firstChar = url.charAt(0);
+      if (firstChar !== "/" && firstChar !== ".") {
+        if (firstChar === "#") {
+          return false;
+        }
+        const i = url.indexOf(":");
+        if (i > -1) {
+          const protocol = url.slice(0, i).toLowerCase();
+          return !PROTOCOLS[protocol];
+        }
+      }
+      return true;
+    }
+  }
+  return false;
+}
+const PROTOCOLS = {
+  https: true,
+  http: true,
+  about: true,
+  javascript: true,
+  file: true
+};
+
+function parseRouteIndexName(extlessName) {
+  let layoutName = "";
+  const layoutStop = extlessName.endsWith("!");
+  if (layoutStop) {
+    extlessName = extlessName.slice(0, extlessName.length - 1);
+  }
+  const namedLayoutParts = extlessName.split("@");
+  if (namedLayoutParts.length > 1) {
+    namedLayoutParts.shift();
+    layoutName = namedLayoutParts.join("@");
+  }
+  return { layoutName, layoutStop };
+}
+function getPathnameFromDirPath(opts, dirPath) {
+  const relFilePath = relative(opts.routesDir, dirPath);
+  let pathname = normalizePath(relFilePath);
+  pathname = normalizePathname(pathname, opts.basePathname).split("/").filter((segment) => !isGroupedLayoutName(segment)).join("/");
+  if (pathname === "") {
+    return "/";
+  }
+  return pathname;
+}
+function getMenuPathname(opts, filePath) {
+  let pathname = normalizePath(relative(opts.routesDir, filePath));
+  pathname = `/` + normalizePath(dirname(pathname));
+  let result = normalizePathname(pathname, opts.basePathname);
+  if (!result.endsWith("/")) {
+    result += "/";
+  }
+  return result;
+}
+function getExtension(fileName) {
+  if (typeof fileName === "string") {
+    const parts = fileName.trim().toLowerCase().split(".");
+    if (parts.length > 1) {
+      const ext = parts.pop().split("?")[0].split("#")[0];
+      if (ext === "ts" && parts.pop() === "d") {
+        return ".d.ts";
+      }
+      return "." + ext;
+    }
+  }
+  return "";
+}
+function removeExtension(fileName) {
+  if (typeof fileName === "string") {
+    fileName = fileName.trim();
+    const ext = getExtension(fileName);
+    return fileName.slice(0, fileName.length - ext.length);
+  }
+  return "";
+}
+function normalizePath(path) {
+  return normalizePathSlash(normalize(path));
+}
+function normalizePathSlash(path) {
+  const isExtendedLengthPath = path.startsWith("\\\\?\\");
+  const hasNonAscii = /[^\u0000-\u0080]+/.test(path);
+  if (isExtendedLengthPath || hasNonAscii) {
+    return path;
+  }
+  path = path.replace(/\\/g, "/");
+  if (path.endsWith("/")) {
+    path = path.slice(0, path.length - 1);
+  }
+  return path;
+}
+function createFileId(routesDir, fsPath, explicitFileType) {
+  const ids = [];
+  for (let i = 0; i < 25; i++) {
+    let baseName = removeExtension(basename(fsPath));
+    baseName = baseName.replace(/[\W_]+/g, "");
+    if (baseName === "") {
+      baseName = "Q" + i;
+    } else if (!isNaN(baseName.charAt(0))) {
+      baseName = "Q" + baseName;
+    }
+    ids.push(toTitleCase(baseName));
+    fsPath = normalizePath(dirname(fsPath));
+    if (fsPath === routesDir) {
+      break;
+    }
+  }
+  if (ids.length > 1 && ids[0] === "Index") {
+    ids.shift();
+  }
+  return ids.reverse().join("").concat(explicitFileType || "");
+}
+const PAGE_MODULE_EXTS = {
+  ".tsx": true,
+  ".jsx": true
+};
+const MODULE_EXTS = {
+  ".ts": true,
+  ".js": true
+};
+const MARKDOWN_EXTS = {
+  ".md": true,
+  ".mdx": true
+};
+function isIndexModule(extlessName) {
+  return /^index(|!|@.+)$/.test(extlessName);
+}
+function isPluginModule(extlessName) {
+  return /^plugin(|@.+)$/.test(extlessName);
+}
+function isLayoutModule(extlessName) {
+  return /^layout(|!|-.+)$/.test(extlessName);
+}
+function isPageModuleExt(ext) {
+  return ext in PAGE_MODULE_EXTS;
+}
+function isModuleExt(ext) {
+  return ext in MODULE_EXTS;
+}
+function isMarkdownExt(ext) {
+  return ext in MARKDOWN_EXTS;
+}
+function isPageExt(ext) {
+  return ext in PAGE_MODULE_EXTS || ext in MARKDOWN_EXTS;
+}
+function isMenuFileName(fileName) {
+  return fileName === "menu.md";
+}
+function isServiceWorkerName(extlessName) {
+  return extlessName === "service-worker";
+}
+function isEntryName(extlessName) {
+  return extlessName === "entry";
+}
+function isErrorName(extlessName) {
+  return /^[45][0-9]{2}$/.test(extlessName);
+}
+function isGroupedLayoutName(dirName, warn = true) {
+  if (dirName.startsWith("__")) {
+    if (warn) {
+      console.warn(
+        `Grouped (pathless) layout "${dirName}" should use the "(${dirName.slice(
+          2
+        )})" directory name instead. Prefixing a directory with "__" has been deprecated and will be removed in future versions.`
+      );
+    }
+    return true;
+  }
+  return dirName.startsWith("(") && dirName.endsWith(")");
+}
+
+export { isErrorName as a, isLayoutModule as b, isEntryName as c, isMenuFileName as d, isServiceWorkerName as e, isPageModuleExt as f, getExtension as g, isModuleExt as h, isIndexModule as i, isMarkdownExt as j, isSameOriginUrl as k, normalizePath as l, getPathnameFromDirPath as m, normalizePathSlash as n, getMenuPathname as o, createFileId as p, parseRouteIndexName as q, removeExtension as r, isPluginModule as s, addError as t, addWarning as u, isPageExt as v, msToString as w, getPathnameForDynamicRoute as x };