@wular/pnext 0.1.6 → 0.1.8

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

@@ -0,0 +1,92 @@
+// @bun
+import {
+  compileSource,
+  evaluateConditions,
+  loadNextConfig,
+  parseConditions,
+  splitDestination,
+  substitute
+} from "./index-he6n2bvp.js";
+
+// src/compat/next/redirects.ts
+async function loadCompatRedirects(root) {
+  const config = await loadNextConfig(root);
+  const producer = config?.redirects;
+  if (typeof producer !== "function")
+    return [];
+  let value;
+  try {
+    value = await producer();
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(value))
+    return [];
+  const redirects = [];
+  for (const entry of value) {
+    if (!entry?.source || !entry.destination)
+      continue;
+    const has = parseConditions(entry.has);
+    const missing = parseConditions(entry.missing);
+    if (has === null || missing === null)
+      continue;
+    const compiled = compileSource(entry.source);
+    if (!compiled)
+      continue;
+    const status = typeof entry.statusCode === "number" ? entry.statusCode : entry.permanent ? 308 : 307;
+    redirects.push({
+      ...compiled,
+      destination: entry.destination,
+      has,
+      missing,
+      status,
+      outsideBasePath: entry.basePath === false
+    });
+  }
+  return redirects;
+}
+function resolveCompatRedirect(redirects, pathname, ctx) {
+  const context = ctx ?? {
+    host: "",
+    headers: new Headers,
+    cookies: {},
+    query: new URLSearchParams
+  };
+  for (const redirect of redirects) {
+    const match = redirect.regex.exec(pathname);
+    if (!match)
+      continue;
+    const params = {};
+    redirect.paramNames.forEach((name, index) => {
+      params[name] = match[index + 1] ?? "";
+    });
+    const conditionParams = evaluateConditions(redirect, context);
+    if (conditionParams === null)
+      continue;
+    Object.assign(params, conditionParams);
+    const [destPath, destQuery] = splitDestination(redirect.destination);
+    const { pathname: resolvedPath, used: usedInPath } = substitute(destPath, params);
+    const query = new URLSearchParams;
+    let usedInQuery = false;
+    if (destQuery) {
+      for (const [key, rawValue] of new URLSearchParams(destQuery).entries()) {
+        const { pathname: value, used } = substitute(rawValue, params);
+        if (used)
+          usedInQuery = true;
+        query.set(key, value);
+      }
+    }
+    if (usedInPath.size === 0 && !usedInQuery) {
+      for (const [name, value] of Object.entries(params)) {
+        if (!query.has(name))
+          query.append(name, value);
+      }
+    }
+    const search = query.toString();
+    const location = search ? `${resolvedPath}${resolvedPath.includes("?") ? "&" : "?"}${search}` : resolvedPath;
+    return { location, status: redirect.status };
+  }
+  return;
+}
+
+export { loadCompatRedirects, resolveCompatRedirect };

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

@@ -0,0 +1,87 @@
+// @bun
+import { join as __pnextJoin } from "node:path";
+const __PNEXT_PACKAGE_ROOT__ = __pnextJoin(import.meta.dirname, "../../..");
+// src/cli/boot/named-bin.ts
+import {
+  chmodSync,
+  constants as fsConstants,
+  copyFileSync,
+  existsSync,
+  linkSync,
+  mkdirSync,
+  readdirSync,
+  renameSync,
+  rmSync
+} from "fs";
+import { createRequire } from "module";
+import os from "os";
+import path from "path";
+var namedBinaryName = "pnext";
+var cliCommands = new Set(["dev", "build", "start", "analyze", "typegen"]);
+function commandBinaryName(command) {
+  if (command && cliCommands.has(command))
+    return `${namedBinaryName}-${command}`;
+  return namedBinaryName;
+}
+function namedBunBinary(name = namedBinaryName) {
+  if (process.platform === "win32")
+    return process.execPath;
+  if (path.basename(process.execPath) === name)
+    return process.execPath;
+  return namedExecutable(process.execPath, `bun-${Bun.version}`, name);
+}
+function nameEsbuildProcess() {
+  if (process.platform === "win32")
+    return;
+  if (process.env.ESBUILD_BINARY_PATH)
+    return;
+  try {
+    const require2 = createRequire(Bun.pathToFileURL(__PNEXT_PACKAGE_ROOT__ + "/src/cli/boot/named-bin.ts").href);
+    const { version } = require2("esbuild/package.json");
+    const binPath = require2.resolve(`@esbuild/${process.platform}-${process.arch}/bin/esbuild`);
+    const named = namedExecutable(binPath, `esbuild-${version}`, "pnext-esbuild");
+    if (named !== binPath)
+      process.env.ESBUILD_BINARY_PATH = named;
+  } catch {}
+}
+function namedExecutable(sourcePath, versionDir, name) {
+  try {
+    const binRoot = path.join(cacheRoot(), "bin");
+    const dir = path.join(binRoot, versionDir);
+    const named = path.join(dir, name);
+    if (!existsSync(named)) {
+      mkdirSync(dir, { recursive: true });
+      const staging = path.join(dir, `.${name}-${process.pid}`);
+      rmSync(staging, { force: true });
+      try {
+        linkSync(sourcePath, staging);
+      } catch {
+        copyFileSync(sourcePath, staging, fsConstants.COPYFILE_FICLONE);
+        chmodSync(staging, 493);
+      }
+      renameSync(staging, named);
+      removeStaleVersions(binRoot, path.basename(dir));
+    }
+    return named;
+  } catch {
+    return sourcePath;
+  }
+}
+function removeStaleVersions(binRoot, keep) {
+  const toolPrefix = keep.slice(0, keep.indexOf("-") + 1);
+  try {
+    for (const entry of readdirSync(binRoot)) {
+      if (entry === keep || !entry.startsWith(toolPrefix))
+        continue;
+      rmSync(path.join(binRoot, entry), { recursive: true, force: true });
+    }
+  } catch {}
+}
+function cacheRoot() {
+  const xdg = process.env.XDG_CACHE_HOME;
+  if (xdg)
+    return path.join(xdg, "pnext");
+  return path.join(os.homedir(), ".cache", "pnext");
+}
+
+export { commandBinaryName, namedBunBinary, nameEsbuildProcess, cacheRoot };

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

@@ -0,0 +1,152 @@
+// @bun
+import {
+  nextCompatEnabled
+} from "./index-web361b8.js";
+import {
+  cssModuleScopePath,
+  ensureDir,
+  readText
+} from "./index-4da76t62.js";
+import {
+  productionRelease
+} from "./index-hdbwtdv2.js";
+import {
+  getCssExtensions
+} from "./index-zqpqyg8p.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/utils/asset-hash.ts
+import { createHash } from "crypto";
+function assetContentHash(bytes) {
+  return createHash("sha256").update(bytes).digest("hex").slice(0, 16);
+}
+function hashedAssetName(name, bytes) {
+  const hash = assetContentHash(bytes);
+  const dot = name.lastIndexOf(".");
+  return dot <= 0 ? `${name}-${hash}` : `${name.slice(0, dot)}-${hash}${name.slice(dot)}`;
+}
+
+// src/css/assets.ts
+import { existsSync } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import path from "path";
+var build;
+async function globalCssHref(config) {
+  const sources = productionRelease(config)?.globalCss ?? (await (build ??= import("./build-c991dv65.js"))).globalCssSources(config);
+  return sources.length > 0 ? assetHref(config, "global.css") : undefined;
+}
+var emittedAssets = new Map;
+function recordEmittedAsset(outPath, logical, emitted) {
+  const names = emittedAssets.get(outPath) ?? new Map;
+  names.set(logical, emitted);
+  emittedAssets.set(outPath, names);
+}
+function publishEmittedAssets(outPath, names) {
+  if (!names)
+    return;
+  for (const [logical, emitted] of Object.entries(names))
+    recordEmittedAsset(outPath, logical, emitted);
+}
+function emittedAssetNames(outPath) {
+  return Object.fromEntries(emittedAssets.get(outPath) ?? []);
+}
+function clearEmittedAssets(outPath) {
+  emittedAssets.delete(outPath);
+}
+function emittedAssetName(config, name) {
+  if (!config?.outPath)
+    return name;
+  return emittedAssets.get(config.outPath)?.get(name) ?? name;
+}
+function assetPathname(config, name) {
+  const emitted = emittedAssetName(config, name);
+  return nextCompatEnabled(config ?? {}) ? `/_next/static/${emitted}` : `/assets/${emitted}`;
+}
+function assetHref(config, name) {
+  return withAssetPrefix(config, assetPathname(config, name));
+}
+function routeCssAssetNames(route) {
+  if (route.cssImports.length === 0)
+    return [];
+  return route.cssAssets?.length ? route.cssAssets : [`${route.id}.css`];
+}
+function routeCssHref(route, config) {
+  const assets = routeCssAssetNames(route);
+  if (assets.length === 0)
+    return;
+  return assets.map((asset) => assetHref(config, asset));
+}
+async function emitFontCssStylesheet(config, routeId, fontCss, baseAsset, options) {
+  const outDir = path.join(config.outPath, options.dev ? "cache" : "static", "assets");
+  await ensureDir(outDir);
+  const baseFile = baseAsset ? path.join(outDir, baseAsset) : undefined;
+  const baseCss = baseFile && existsSync(baseFile) ? await readFile(baseFile, "utf8") : "";
+  const contents = [fontCss, baseCss].filter(Boolean).join(`
+`);
+  const logicalName = baseAsset ? baseAsset.replace(/-[0-9a-f]{16}(?=\.css$)/, "") : `${routeId}.css`;
+  const name = hashedAssetName(logicalName, contents);
+  const file = path.join(outDir, name);
+  if (!existsSync(file) || await readFile(file, "utf8") !== contents)
+    await writeFile(file, contents);
+  return name;
+}
+function withAssetPrefix(config, href) {
+  const prefix = config?.assetPrefix;
+  if (!prefix)
+    return href;
+  return `${prefix.replace(/\/$/, "")}${href}`;
+}
+var cssRuntimeRegistered = false;
+function registerCssRuntime() {
+  if (cssRuntimeRegistered)
+    return;
+  cssRuntimeRegistered = true;
+  Bun.plugin({
+    name: "pnext-css-runtime",
+    setup(plugin) {
+      plugin.onLoad({ filter: /\.(?:css|scss|sass)$/ }, async ({ path: file }) => isCssModuleFile(file) ? {
+        exports: { default: await cssModuleMapping(file) },
+        loader: "object"
+      } : {
+        contents: "export default undefined;",
+        loader: "js"
+      });
+    }
+  });
+}
+function isCssModuleFile(file) {
+  return /\.module\.(?:css|scss|sass)$/.test(file);
+}
+async function cssModuleMapping(file) {
+  const compatMapping = getCssExtensions().resolveCssModule(file);
+  if (compatMapping)
+    return compatMapping;
+  const source = await readText(file);
+  const classNames = cssClassNames(source);
+  return Object.fromEntries([...classNames].map((className) => [className, cssModuleClassName(file, className)]));
+}
+function cssClassNames(source) {
+  const classNames = new Set;
+  const classPattern = /(^|[^\\])\.(-?[_a-zA-Z][\w-]*)/g;
+  let match;
+  while (match = classPattern.exec(source)) {
+    if (match[2])
+      classNames.add(match[2]);
+  }
+  return classNames;
+}
+function cssModuleClassName(file, className) {
+  const base = path.basename(file).replace(/\.module\.css$/, "").replace(/[^_a-zA-Z0-9]/g, "_");
+  const hash = pathHash(cssModuleScopePath(file));
+  return `${base}_${className}_${hash}`;
+}
+function pathHash(file) {
+  let hash = 5381;
+  for (const char of file)
+    hash = (hash << 5) + hash ^ char.charCodeAt(0);
+  return (hash >>> 0).toString(36).slice(0, 5);
+}
+
+export { assetContentHash, hashedAssetName, globalCssHref, recordEmittedAsset, publishEmittedAssets, emittedAssetNames, clearEmittedAssets, emittedAssetName, assetPathname, assetHref, routeCssAssetNames, routeCssHref, emitFontCssStylesheet, withAssetPrefix, registerCssRuntime, isCssModuleFile, cssModuleMapping, cssClassNames, cssModuleClassName };