@wular/pnext 0.1.5 → 0.1.7

package/dist/server/_chunks/index-p77b4kcx.js

@@ -0,0 +1,296 @@
+// @bun
+import {
+  readDirListing,
+  toPosixPath
+} from "./index-20ppawv7.js";
+
+// src/routing/slots.ts
+import path from "path";
+import { safeDecode } from "../../../src/utils/decode.ts";
+var pageExtensions = ["tsx", "ts", "jsx", "js", "mjs"];
+var interceptionMarkers = ["(..)(..)", "(...)", "(..)", "(.)"];
+var interceptionLevels = {
+  "(.)": 0,
+  "(..)": 1,
+  "(..)(..)": 2,
+  "(...)": Number.POSITIVE_INFINITY
+};
+function interceptionMarkerOf(segment) {
+  return interceptionMarkers.find((marker) => segment.startsWith(marker) && segment.length > marker.length);
+}
+function interceptionMarkerLevels(marker) {
+  return interceptionLevels[marker];
+}
+function isSlotSegment(name) {
+  return name.startsWith("@");
+}
+function isGroupSegment(name) {
+  return name.startsWith("(") && name.endsWith(")") && !interceptionMarkerOf(name);
+}
+function slotConventionFile(dir, base) {
+  const { files } = readDirListing(dir);
+  for (const extension of pageExtensions) {
+    if (files.has(`${base}.${extension}`))
+      return path.join(dir, `${base}.${extension}`);
+  }
+  return;
+}
+function childDirectories(dir) {
+  return readDirListing(dir).dirs;
+}
+function slotDirectoriesIn(dir) {
+  return childDirectories(dir).filter(isSlotSegment).map((name) => path.join(dir, name));
+}
+function consumedSegments(appPath, dir) {
+  const relative = path.relative(appPath, dir);
+  if (relative.startsWith(".."))
+    return 0;
+  let consumed = 0;
+  for (const name of relative.split(path.sep).filter(Boolean)) {
+    if (isGroupSegment(name) || isSlotSegment(name))
+      continue;
+    const marker = interceptionMarkerOf(name);
+    const bare = marker ? name.slice(marker.length) : name;
+    if (/^\[\[?\.\.\./.test(bare))
+      return Number.POSITIVE_INFINITY;
+    consumed += 1;
+  }
+  return consumed;
+}
+function matchSegments(dir, segments, options = {}, params = {}, dirs = []) {
+  const children = childDirectories(dir);
+  const groups = children.filter(isGroupSegment);
+  if (segments.length === 0) {
+    const page = slotConventionFile(dir, "page");
+    if (page)
+      return { file: page, dirs, params };
+    for (const group of groups) {
+      const match = matchSegments(path.join(dir, group), [], options, params, [...dirs, group]);
+      if (match)
+        return match;
+    }
+    for (const name of children) {
+      const param = optionalCatchAllName(bareName(name, options));
+      if (!param)
+        continue;
+      const match = matchSegments(path.join(dir, name), [], options, { ...params, [param]: [] }, [
+        ...dirs,
+        name
+      ]);
+      if (match)
+        return match;
+    }
+    if (options.markersAsSegments && (slotConventionFile(dir, "layout") || children.some(isSlotSegment))) {
+      return { dirs, params };
+    }
+    return null;
+  }
+  const [head, ...rest] = segments;
+  for (const name of children) {
+    if (bareName(name, options) !== head)
+      continue;
+    const match = matchSegments(path.join(dir, name), rest, options, params, [...dirs, name]);
+    if (match)
+      return match;
+  }
+  for (const group of groups) {
+    const match = matchSegments(path.join(dir, group), segments, options, params, [...dirs, group]);
+    if (match)
+      return match;
+  }
+  for (const name of children) {
+    const param = dynamicParamName(bareName(name, options));
+    if (!param)
+      continue;
+    const match = matchSegments(path.join(dir, name), rest, options, { ...params, [param]: safeDecode(head) }, [...dirs, name]);
+    if (match)
+      return match;
+  }
+  for (const name of children) {
+    const bare = bareName(name, options);
+    const param = catchAllName(bare) ?? optionalCatchAllName(bare);
+    if (!param)
+      continue;
+    const match = matchSegments(path.join(dir, name), [], options, { ...params, [param]: segments.map(safeDecode) }, [...dirs, name]);
+    if (match)
+      return match;
+  }
+  return null;
+}
+function bareName(name, options) {
+  if (isSlotSegment(name))
+    return "\x00";
+  const marker = interceptionMarkerOf(name);
+  if (!marker)
+    return name;
+  return options.markersAsSegments ? name.slice(marker.length) : "\x00";
+}
+function dynamicParamName(name) {
+  const match = /^\[([^\].]+)\]$/.exec(name);
+  return match?.[1];
+}
+function catchAllName(name) {
+  const match = /^\[\.\.\.([^\]]+)\]$/.exec(name);
+  return match?.[1];
+}
+function optionalCatchAllName(name) {
+  const match = /^\[\[\.\.\.([^\]]+)\]\]$/.exec(name);
+  return match?.[1];
+}
+function childrenDefaultFile(dir, segments) {
+  let current = dir;
+  let best = slotConventionFile(current, "default");
+  for (const segment of segments) {
+    const next = childSegmentDir(current, segment);
+    if (!next)
+      break;
+    current = next;
+    best = slotConventionFile(current, "default") ?? best;
+  }
+  return best;
+}
+function childSegmentDir(dir, segment) {
+  const children = childDirectories(dir);
+  if (children.includes(segment))
+    return path.join(dir, segment);
+  for (const group of children.filter(isGroupSegment)) {
+    const nested = childSegmentDir(path.join(dir, group), segment);
+    if (nested)
+      return nested;
+  }
+  const dynamic = children.find((name) => dynamicParamName(name));
+  if (dynamic)
+    return path.join(dir, dynamic);
+  return;
+}
+function slotInterceptorUnits(appPath, slotDir) {
+  const owner = routeTokensForDir(appPath, path.dirname(slotDir));
+  if (!owner)
+    return [];
+  const units = [];
+  collectInterceptorUnits(slotDir, owner, [], units);
+  return units;
+}
+function collectInterceptorUnits(dir, owner, inner, units) {
+  for (const name of childDirectories(dir)) {
+    const child = path.join(dir, name);
+    if (isSlotSegment(name) || isGroupSegment(name)) {
+      collectInterceptorUnits(child, owner, inner, units);
+      continue;
+    }
+    const marker = interceptionMarkerOf(name);
+    if (marker) {
+      const bare = name.slice(marker.length);
+      const levels = interceptionLevels[marker];
+      const context = [...owner, ...inner];
+      const kept = levels === Number.POSITIVE_INFINITY ? [] : context.slice(0, Math.max(0, context.length - levels));
+      const target = [...kept, segmentToken(bare)];
+      units.push({
+        dir: child,
+        targetSegments: target.map((token) => token.route),
+        targetPattern: target.map((token) => token.pattern).join("/"),
+        params: target.filter((token) => token.param).map((token) => ({ name: token.param, catchAll: Boolean(token.catchAll) })),
+        catchAllTail: Boolean(target[target.length - 1]?.catchAll)
+      });
+      continue;
+    }
+    collectInterceptorUnits(child, owner, [...inner, segmentToken(name)], units);
+  }
+}
+function routeTokensForDir(appPath, dir) {
+  const relative = path.relative(appPath, dir);
+  if (relative.startsWith(".."))
+    return;
+  let tokens = [];
+  for (const name of toPosixPath(relative).split("/").filter(Boolean)) {
+    if (isGroupSegment(name) || isSlotSegment(name))
+      continue;
+    const marker = interceptionMarkerOf(name);
+    if (marker) {
+      const levels = interceptionLevels[marker];
+      tokens = levels === Number.POSITIVE_INFINITY ? [] : tokens.slice(0, Math.max(0, tokens.length - levels));
+      tokens.push(segmentToken(name.slice(marker.length)));
+      continue;
+    }
+    tokens.push(segmentToken(name));
+  }
+  return tokens;
+}
+function segmentToken(name) {
+  const optional = optionalCatchAllName(name);
+  if (optional)
+    return { route: `:${optional}*`, pattern: "(.*)", param: optional, catchAll: true };
+  const catchAll = catchAllName(name);
+  if (catchAll)
+    return { route: `:${catchAll}*`, pattern: "(.*)", param: catchAll, catchAll: true };
+  const param = dynamicParamName(name);
+  if (param)
+    return { route: `:${param}`, pattern: "([^/]+)", param };
+  return { route: name, pattern: escapeRegex(name) };
+}
+function matchSlotInterceptor(appPath, slotDir, pathname) {
+  const segments = pathnameSegments(pathname);
+  const markerOwner = markerOwnerTokens(appPath, slotDir);
+  if (markerOwner) {
+    const params = matchTargetTokens(markerOwner, pathname);
+    if (params) {
+      const rest = markerOwner.at(-1)?.catchAll ? [] : segments.slice(markerOwner.length);
+      const inner = matchSegments(slotDir, rest, { markersAsSegments: true }, params, []);
+      if (inner)
+        return inner;
+    }
+  }
+  const units = slotInterceptorUnits(appPath, slotDir).sort((a, b) => Number(a.catchAllTail) - Number(b.catchAllTail) || b.targetSegments.length - a.targetSegments.length || a.params.length - b.params.length);
+  for (const unit of units) {
+    const regex = new RegExp(`^/${unit.targetPattern}(?:/(.*))?$`);
+    const match = regex.exec(pathname.replace(/\/+$/, "") || "/");
+    if (!match)
+      continue;
+    const params = {};
+    unit.params.forEach((param, index) => {
+      const value = match[index + 1] ?? "";
+      params[param.name] = param.catchAll ? value.split("/").filter(Boolean).map(safeDecode) : safeDecode(value);
+    });
+    const rest = unit.catchAllTail ? [] : segments.slice(unit.targetSegments.length);
+    const inner = matchSegments(unit.dir, rest, { markersAsSegments: true }, params, []);
+    if (inner) {
+      return {
+        file: inner.file,
+        dirs: [path.basename(unit.dir), ...inner.dirs],
+        params: inner.params
+      };
+    }
+  }
+  return null;
+}
+function markerOwnerTokens(appPath, slotDir) {
+  const relative = path.relative(appPath, slotDir);
+  if (relative.startsWith(".."))
+    return null;
+  const segments = toPosixPath(relative).split("/").filter(Boolean);
+  const markerIndex = segments.findIndex((segment) => Boolean(interceptionMarkerOf(segment)));
+  if (markerIndex === -1)
+    return null;
+  return routeTokensForDir(appPath, path.join(appPath, ...segments.slice(0, markerIndex + 1))) ?? null;
+}
+function matchTargetTokens(tokens, pathname) {
+  const pattern = tokens.map((token) => token.pattern).join("/");
+  const regex = new RegExp(`^/${pattern}(?:/.*)?$`);
+  const match = regex.exec(pathname.replace(/\/+$/, "") || "/");
+  if (!match)
+    return null;
+  const params = {};
+  tokens.filter((token) => token.param).forEach((token, index) => {
+    const value = match[index + 1] ?? "";
+    params[token.param] = token.catchAll ? value.split("/").filter(Boolean).map(safeDecode) : safeDecode(value);
+  });
+  return params;
+}
+function pathnameSegments(pathname) {
+  return pathname.split("?")[0].split("/").filter(Boolean);
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export { interceptionMarkerOf, interceptionMarkerLevels, isSlotSegment, isGroupSegment, slotConventionFile, slotDirectoriesIn, consumedSegments, matchSegments, childrenDefaultFile, matchSlotInterceptor, pathnameSegments };

package/dist/server/_chunks/index-pym1cezq.js

@@ -0,0 +1,39 @@
+// @bun
+// src/resolve/package-json.ts
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+var packageJsonCache = new Map;
+var workspaceRootCache = new Map;
+function readPackageJson(root) {
+  const existing = packageJsonCache.get(root);
+  if (existing)
+    return existing;
+  const config = readJson(path.join(root, "package.json")) ?? {};
+  packageJsonCache.set(root, config);
+  return config;
+}
+function findWorkspaceRoot(root) {
+  const key = path.resolve(root);
+  if (workspaceRootCache.has(key))
+    return workspaceRootCache.get(key);
+  let dir = key;
+  while (true) {
+    if (readPackageJson(dir).workspaces || existsSync(path.join(dir, "pnpm-workspace.yaml"))) {
+      workspaceRootCache.set(key, dir);
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      workspaceRootCache.set(key, undefined);
+      return;
+    }
+    dir = parent;
+  }
+}
+function readJson(file) {
+  if (!existsSync(file))
+    return;
+  return JSON.parse(readFileSync(file, "utf8"));
+}
+
+export { readPackageJson, findWorkspaceRoot };

package/dist/server/_chunks/index-q738kkhj.js

@@ -0,0 +1,100 @@
+// @bun
+import {
+  bold,
+  cyan,
+  dim,
+  green
+} from "./index-6kp9r0d9.js";
+
+// src/cli/serve/ui.ts
+import { networkInterfaces } from "os";
+function browserHost(hostname) {
+  if (hostname === "::" || hostname === "::1")
+    return "[::1]";
+  if (["0.0.0.0", "127.0.0.1"].includes(hostname))
+    return "localhost";
+  return hostname;
+}
+function printServerReady({ mode, hostname, port, elapsedMs }) {
+  const rows = [["Local:", cyan(`http://${browserHost(hostname)}:${port}`)]];
+  const lan = hostname === "::" ? "[::]" : wildcard(hostname) ? lanAddress() : undefined;
+  if (lan)
+    rows.push(["Network:", cyan(`http://${lan}:${port}`)]);
+  const ready = elapsedMs === undefined ? `${green("\u2713")} ${bold("Ready")}` : `${green("\u2713")} ${bold("Ready")} ${dim(`in ${Math.round(elapsedMs)}ms`)}`;
+  const pad = Math.max(...rows.map(([label]) => label.length));
+  console.log("");
+  console.log(`\u26A1 ${bold("pnext")} ${dim(mode)}`);
+  for (const [label, value] of rows) {
+    console.log(`  ${dim("-")} ${dim(label.padEnd(pad))}  ${value}`);
+  }
+  console.log("");
+  console.log(ready);
+  console.log("");
+}
+function wildcard(hostname) {
+  return hostname === "0.0.0.0" || hostname === "::";
+}
+async function ensurePortFree(port, hostname, options = {}) {
+  const attempts = options.attempts ?? 1;
+  const delayMs = options.delayMs ?? 300;
+  const candidates = wildcard(hostname) || hostname === "localhost" ? ["127.0.0.1", "::1"] : [hostname];
+  for (const candidate of candidates) {
+    let inUse = await portInUse(candidate, port);
+    for (let attempt = 1;inUse && attempt < attempts; attempt += 1) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+      inUse = await portInUse(candidate, port);
+    }
+    if (inUse) {
+      throw new Error(`Port ${port} is already in use on ${candidate} (another pnext dev/start or process). ` + `Stop it or pass --port. To find it:` + `  lsof -nP -iTCP:${port} -sTCP:LISTEN`);
+    }
+  }
+}
+function portInUse(hostname, port) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(false), 300);
+    Bun.connect({
+      hostname,
+      port,
+      socket: {
+        open(socket) {
+          clearTimeout(timer);
+          socket.end();
+          resolve(true);
+        },
+        data() {},
+        connectError() {
+          clearTimeout(timer);
+          resolve(false);
+        },
+        error() {
+          clearTimeout(timer);
+          resolve(false);
+        }
+      }
+    }).catch(() => {
+      clearTimeout(timer);
+      resolve(false);
+    });
+  });
+}
+function lanAddress() {
+  for (const addresses of Object.values(networkInterfaces())) {
+    for (const address of addresses ?? []) {
+      if (address.family === "IPv4" && !address.internal)
+        return address.address;
+    }
+  }
+  return;
+}
+function openBrowser(url) {
+  const browser = process.env.BROWSER;
+  if (browser === "none" || process.env.CI || false)
+    return;
+  const browserArgs = process.env.BROWSER_ARGS?.split(/\s+/).filter(Boolean) ?? [];
+  const command = browser ? process.platform === "darwin" ? ["open", "-a", browser, ...browserArgs, url] : [browser, ...browserArgs, url] : process.platform === "darwin" ? ["open", url] : process.platform === "win32" ? ["cmd", "/c", "start", "", url] : ["xdg-open", url];
+  try {
+    Bun.spawn(command, { stdout: "ignore", stderr: "ignore", stdin: "ignore" }).unref();
+  } catch {}
+}
+
+export { browserHost, printServerReady, ensurePortFree, openBrowser };

package/dist/server/_chunks/index-qjj6gddn.js

@@ -0,0 +1,54 @@
+// @bun
+// src/utils/code.ts
+function escapeRegex(value) {
+  return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}
+function specifierSniffTokens(keys) {
+  const heads = [
+    ...new Set([...keys].map((key) => {
+      const head = key.split("/").slice(0, key.startsWith("@") ? 2 : 1).join("/");
+      return head.replace(/\*.*$/, "");
+    }))
+  ];
+  return heads.filter((head) => !heads.some((other) => other !== head && head.startsWith(other)));
+}
+function uniqueIdentifier(source, base, ...used) {
+  const usedNames = new Set(used);
+  let name = base;
+  let index = 0;
+  while (source.includes(name) || usedNames.has(name)) {
+    index += 1;
+    name = `${base}${index}`;
+  }
+  return name;
+}
+function isIdentifier(value) {
+  return /^[A-Za-z_$][\w$]*$/.test(value);
+}
+function esbuildEntryExportNames(code) {
+  const scope = entryCommonJsScope(code);
+  const assignments = [
+    ...scope.matchAll(/module\.exports\s*=\s*(?:[A-Za-z_$][\w$]*\s*\(\s*)?([A-Za-z_$][\w$]*)\s*\)?\s*[;\n]/g)
+  ];
+  const entryVar = assignments.at(-1)?.[1];
+  if (!entryVar)
+    return [];
+  const exportCall = new RegExp(`[A-Za-z_$][\\w$]*\\(\\s*${escapeRegex(entryVar)}\\s*,\\s*\\{([\\s\\S]*?)\\}\\s*\\)`).exec(scope);
+  if (!exportCall?.[1])
+    return [];
+  return [
+    ...exportCall[1].matchAll(/(?:^|,)\s*(?:["']([^"']+)["']|([A-Za-z_$][\w$]*))\s*:\s*\(\s*\)\s*=>/g)
+  ].map((match) => match[1] ?? match[2]).filter((name) => Boolean(name && isIdentifier(name)));
+}
+function entryCommonJsScope(code) {
+  const wrapper = /(^|\n)export default ([A-Za-z_$][\w$]*)\(\)/.exec(code)?.[2];
+  if (!wrapper)
+    return code;
+  const start = code.lastIndexOf(`var ${wrapper} = `);
+  return start === -1 ? code : code.slice(start);
+}
+function stripComments(source) {
+  return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
+}
+
+export { escapeRegex, specifierSniffTokens, uniqueIdentifier, isIdentifier, esbuildEntryExportNames, stripComments };

package/dist/server/_chunks/index-qm6kmhqs.js

@@ -0,0 +1,110 @@
+// @bun
+import {
+  getNextConfig
+} from "./index-6e4fqv30.js";
+
+// src/compat/mdx/compile.ts
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import path from "path";
+import { pathToFileURL } from "url";
+var cachedModule;
+async function loadMdx() {
+  if (cachedModule !== undefined)
+    return cachedModule;
+  try {
+    const specifier = "@mdx-js/mdx";
+    cachedModule = await import(specifier);
+  } catch {
+    cachedModule = null;
+  }
+  return cachedModule;
+}
+function mdxOptionsFromConfig() {
+  const config = getNextConfig();
+  return config.mdxOptions ?? {};
+}
+function resolveMdxComponents(root) {
+  const bases = [root, path.join(root, "src")];
+  const names = [
+    "mdx-components.tsx",
+    "mdx-components.ts",
+    "mdx-components.jsx",
+    "mdx-components.js",
+    "mdx-components.mjs"
+  ];
+  for (const base of bases) {
+    for (const name of names) {
+      const candidate = path.join(base, name);
+      if (existsSync(candidate))
+        return candidate;
+    }
+  }
+  return;
+}
+function interopDefault(module) {
+  return module?.default ?? module;
+}
+var UNRESOLVED_PLUGIN = Symbol("pnext.mdx.unresolved-plugin");
+async function resolvePlugin(entry, resolveFrom) {
+  if (typeof entry === "function")
+    return entry;
+  if (typeof entry === "string") {
+    return loadPlugin(entry, resolveFrom);
+  }
+  if (Array.isArray(entry) && typeof entry[0] === "string") {
+    const tuple = entry;
+    const plugin = await loadPlugin(tuple[0], resolveFrom);
+    if (plugin === UNRESOLVED_PLUGIN)
+      return UNRESOLVED_PLUGIN;
+    return [plugin, ...tuple.slice(1)];
+  }
+  return entry;
+}
+async function loadPlugin(name, resolveFrom) {
+  let resolved;
+  try {
+    resolved = resolveFrom.resolve(name);
+  } catch {
+    console.warn(`pnext: MDX plugin '${name}' is configured but not installed; skipping it. Install it to apply this remark/rehype/recma plugin.`);
+    return UNRESOLVED_PLUGIN;
+  }
+  try {
+    return interopDefault(await import(pathToFileURL(resolved).href));
+  } catch (error) {
+    console.warn(`pnext: MDX plugin '${name}' failed to load and was skipped: ${error instanceof Error ? error.message : String(error)}. ` + "Ensure it is installed in the app\u2019s node_modules (not only Bun\u2019s auto-install cache).");
+    return UNRESOLVED_PLUGIN;
+  }
+}
+async function resolvePlugins(plugins, resolveFrom) {
+  const resolved = await Promise.all(plugins.map((entry) => resolvePlugin(entry, resolveFrom)));
+  return resolved.filter((entry) => entry !== UNRESOLVED_PLUGIN);
+}
+async function compileMdx(source, filePath, root) {
+  const mdx = await loadMdx();
+  if (!mdx) {
+    throw new Error("MDX support requires the '@mdx-js/mdx' package. Install it to render .mdx files.");
+  }
+  const userOptions = mdxOptionsFromConfig();
+  const provider = resolveMdxComponents(root);
+  const resolveFrom = createRequire(path.join(root, "noop.js"));
+  const [remarkPlugins, rehypePlugins, recmaPlugins] = await Promise.all([
+    resolvePlugins(userOptions.remarkPlugins ?? [], resolveFrom),
+    resolvePlugins(userOptions.rehypePlugins ?? [], resolveFrom),
+    resolvePlugins(userOptions.recmaPlugins ?? [], resolveFrom)
+  ]);
+  const compiled = await mdx.compile({ value: source, path: filePath }, {
+    jsx: true,
+    jsxImportSource: "preact",
+    format: "mdx",
+    development: false,
+    remarkPlugins,
+    rehypePlugins,
+    recmaPlugins,
+    ...userOptions.remarkRehypeOptions ? { remarkRehypeOptions: userOptions.remarkRehypeOptions } : {},
+    ...userOptions.providerImportSource ? { providerImportSource: userOptions.providerImportSource } : provider ? { providerImportSource: provider } : {}
+  });
+  return { code: compiled.toString() };
+}
+
+export { mdxOptionsFromConfig, resolveMdxComponents, compileMdx };