@wular/pnext 0.1.5 → 0.1.7

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

@@ -0,0 +1,241 @@
+// @bun
+import { join as __pnextJoin } from "node:path";
+const __PNEXT_PACKAGE_ROOT__ = __pnextJoin(import.meta.dirname, "../../..");
+// src/runtime/production.ts
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { mkdir, rename, rm, writeFile } from "fs/promises";
+import path from "path";
+import { pathToFileURL } from "url";
+var BUILD_INDEX_VERSION = 1;
+var LOCATOR_FILE = "release-locator.json";
+var releases = new WeakMap;
+var WORK_UNIT_STORAGE = Symbol.for("pnext.workUnitStorage");
+function buildIndexFile(outPath) {
+  return path.join(outPath, "server", "build-index.json");
+}
+function releaseModuleKey(layer, target, file) {
+  return `${layer}:${target}:${file}`;
+}
+function productionRelease(config) {
+  return releases.get(config);
+}
+function servedRelease() {
+  const units = globalThis[WORK_UNIT_STORAGE];
+  return units?.getStore()?.release;
+}
+function servedConventions() {
+  return servedRelease()?.conventions;
+}
+function frozenDirListing(dir) {
+  const facts = servedConventions();
+  if (!facts || !isInsideDir(facts.appPath, dir))
+    return;
+  return facts.dirs.get(dir) ?? { files: new Set, dirs: [] };
+}
+function conventionFileExists(file) {
+  return frozenDirListing(path.dirname(file))?.files.has(path.basename(file)) ?? existsSync(file);
+}
+function releaseModuleHref(release, layer, target, file) {
+  const href = release.modules.get(releaseModuleKey(layer, target, path.resolve(file)));
+  if (!href) {
+    throw new Error(`pnext: ${file} (${layer}, ${target}) is not in this build's release. Run 'pnext build' again.`);
+  }
+  return href;
+}
+function attachRelease(config, index = readBuildIndex(config.outPath)) {
+  const existing = releases.get(config);
+  if (existing)
+    return existing;
+  const fromRoot = (file) => path.resolve(config.root, file);
+  const modules = new Map;
+  for (const [key, artifact] of Object.entries(index.modules)) {
+    const second = key.indexOf(":", key.indexOf(":") + 1);
+    modules.set(`${key.slice(0, second + 1)}${releaseSourceFile(key.slice(second + 1), config.root, config.workspaceRoot)}`, pathToFileURL(path.resolve(config.outPath, artifact)).href);
+  }
+  const dirs = new Map;
+  for (const [dir, names] of Object.entries(index.conventions)) {
+    dirs.set(fromRoot(dir), {
+      files: new Set(names.filter((name) => !name.endsWith("/"))),
+      dirs: names.filter((name) => name.endsWith("/")).map((name) => name.slice(0, -1))
+    });
+  }
+  const release = {
+    modules,
+    conventions: {
+      appPath: config.appPath,
+      dirs,
+      client: new Set(index.clientConventions.map(fromRoot)),
+      documentLayouts: new Set(index.documentLayouts.map(fromRoot))
+    },
+    globalCss: index.globalCss.map(fromRoot),
+    proxy: index.proxy ? { ...index.proxy, file: fromRoot(index.proxy.file) } : {},
+    ...index.compat ? { compat: index.compat } : {},
+    ...index.instrumentation ? {
+      instrumentation: {
+        file: path.resolve(config.outPath, index.instrumentation.file),
+        ...index.instrumentation.edge ? { edge: path.resolve(config.outPath, index.instrumentation.edge) } : {}
+      }
+    } : {},
+    ...index.fonts ? {
+      fonts: Object.fromEntries(Object.entries(index.fonts).map(([key, font]) => [
+        key,
+        { ...font, files: font.files.map((file) => path.resolve(config.outPath, file)) }
+      ]))
+    } : {}
+  };
+  releases.set(config, release);
+  return release;
+}
+var conventionBases = new Set([
+  "page",
+  "route",
+  "layout",
+  "template",
+  "loading",
+  "error",
+  "not-found",
+  "default",
+  "forbidden",
+  "unauthorized",
+  "global-error",
+  "global-not-found"
+]);
+var metadataBase = /^(?:robots|sitemap|manifest|favicon|(?:apple-)?icon\d*|opengraph-image\d*|twitter-image\d*)$/;
+var codeFile = /\.(?:[cm]?[jt]sx?|mdx?)$/;
+function capturedFile(name) {
+  const base = /^[^.]+/.exec(name)?.[0] ?? name;
+  return conventionBases.has(base) || metadataBase.test(base);
+}
+function servedAppFiles(facts) {
+  return [...facts.dirs].flatMap(([dir, listing]) => [...listing.files].map((name) => path.join(dir, name)));
+}
+function captureConventions(root, appPath) {
+  const conventions = {};
+  const files = [];
+  const visit = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    const names = [];
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name.startsWith("."))
+          continue;
+        names.push(`${entry.name}/`);
+        visit(path.join(dir, entry.name));
+      } else if (capturedFile(entry.name)) {
+        names.push(entry.name);
+        if (codeFile.test(entry.name))
+          files.push(path.join(dir, entry.name));
+      }
+    }
+    conventions[toPosix(path.relative(root, dir)) || "."] = names.sort();
+  };
+  visit(appPath);
+  return { conventions, files };
+}
+var frameworkRoot = path.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/runtime", "..", "..");
+function releaseSourceKey(file, root, workspaceRoot) {
+  const inRoot = path.relative(root, file);
+  if (!inRoot.startsWith("..") && !path.isAbsolute(inRoot))
+    return `r:${toPosix(inRoot)}`;
+  const inWorkspace = path.relative(workspaceRoot, file);
+  if (!inWorkspace.startsWith("..") && !path.isAbsolute(inWorkspace))
+    return `w:${toPosix(inWorkspace)}`;
+  const inFramework = path.relative(frameworkRoot, file);
+  if (!inFramework.startsWith("..") && !path.isAbsolute(inFramework))
+    return `f:${toPosix(inFramework)}`;
+  return `r:${toPosix(inRoot)}`;
+}
+function releaseSourceFile(key, root, workspaceRoot) {
+  const value = key.slice(2);
+  if (key.startsWith("r:"))
+    return path.join(root, value);
+  if (key.startsWith("w:"))
+    return path.resolve(workspaceRoot, value);
+  if (key.startsWith("f:"))
+    return path.resolve(frameworkRoot, value);
+  return path.join(root, value);
+}
+function toPosix(file) {
+  return file.split(path.sep).join("/");
+}
+function isInsideDir(root, file) {
+  return file === root || file.startsWith(`${root}${path.sep}`);
+}
+function readBuildIndex(outPath) {
+  const file = buildIndexFile(outPath);
+  let index;
+  try {
+    index = JSON.parse(readFileSync(file, "utf8"));
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+    throw new Error("No production build found. Run 'pnext build' first.");
+  }
+  if (index.version !== BUILD_INDEX_VERSION) {
+    throw new Error(`pnext: ${file} is from another pnext version. Run 'pnext build' again.`);
+  }
+  return index;
+}
+function locateRelease(root, defaultOutDir) {
+  const outPath = path.join(root, defaultOutDir);
+  try {
+    const { outDir } = JSON.parse(readFileSync(path.join(outPath, LOCATOR_FILE), "utf8"));
+    return path.resolve(root, outDir);
+  } catch {
+    return existsSync(buildIndexFile(outPath)) ? outPath : undefined;
+  }
+}
+function serializeReleaseConfig(config) {
+  const relative = (file) => path.relative(config.root, file) || ".";
+  return JSON.parse(JSON.stringify({
+    ...config,
+    root: ".",
+    workspaceRoot: relative(config.workspaceRoot),
+    appPath: relative(config.appPath),
+    publicPath: relative(config.publicPath),
+    outPath: relative(config.outPath),
+    outRootPath: relative(config.outRootPath),
+    typesPath: relative(config.typesPath),
+    checksPath: relative(config.checksPath)
+  }, (_key, value) => value instanceof RegExp ? { $regexp: [value.source, value.flags] } : value));
+}
+function releaseConfig(serialized, root, outPath) {
+  const config = JSON.parse(JSON.stringify(serialized), (_key, value) => {
+    const pattern = value?.$regexp;
+    return pattern ? new RegExp(pattern[0], pattern[1]) : value;
+  });
+  const fromRoot = (file) => path.resolve(root, file);
+  const fromOut = (file) => path.resolve(outPath, path.relative(config.outPath, file));
+  return {
+    ...config,
+    root,
+    workspaceRoot: fromRoot(config.workspaceRoot),
+    appPath: fromRoot(config.appPath),
+    publicPath: fromRoot(config.publicPath),
+    outPath,
+    outRootPath: fromOut(config.outRootPath),
+    typesPath: fromOut(config.typesPath),
+    checksPath: fromOut(config.checksPath)
+  };
+}
+async function writeBuildIndex(config, index, defaultOutDir) {
+  const file = buildIndexFile(config.outPath);
+  const temporary = `${file}.${process.pid}.tmp`;
+  await writeFile(temporary, JSON.stringify(index));
+  await rename(temporary, file);
+  const defaultOut = path.join(config.root, defaultOutDir);
+  if (path.resolve(config.outPath) === path.resolve(defaultOut))
+    return;
+  await mkdir(defaultOut, { recursive: true });
+  const locator = path.join(defaultOut, LOCATOR_FILE);
+  await writeFile(`${locator}.${process.pid}.tmp`, JSON.stringify({ outDir: path.relative(config.root, config.outPath) }));
+  await rename(`${locator}.${process.pid}.tmp`, locator);
+  await rm(buildIndexFile(defaultOut), { force: true });
+}
+
+export { BUILD_INDEX_VERSION, buildIndexFile, releaseModuleKey, productionRelease, servedRelease, servedConventions, frozenDirListing, conventionFileExists, releaseModuleHref, attachRelease, servedAppFiles, captureConventions, releaseSourceKey, releaseSourceFile, readBuildIndex, locateRelease, serializeReleaseConfig, releaseConfig, writeBuildIndex };

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

@@ -0,0 +1,128 @@
+// @bun
+import {
+  findProxyFile
+} from "./index-kq8kpzye.js";
+import {
+  loadNative
+} from "./index-7wc9n8be.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/routing/proxy-config.ts
+import { readFileSync } from "fs";
+import path from "path";
+var parseSync = (...args) => loadNative(() => __require("oxc-parser")).parseSync(...args);
+function releasedProxy(config) {
+  const file = findProxyFile(config);
+  if (!file)
+    return;
+  try {
+    return { file, config: staticProxyConfig(file, readFileSync(file, "utf8")) };
+  } catch {
+    return { file };
+  }
+}
+function staticProxyConfig(file, source) {
+  const result = parseSync(file, source, { lang: parserLang(file) });
+  if (result.errors.length > 0)
+    return;
+  for (const statement of result.program.body) {
+    if (statement.type !== "ExportNamedDeclaration")
+      continue;
+    const declaration = statement.declaration;
+    if (declaration?.type !== "VariableDeclaration")
+      continue;
+    for (const declarator of declaration.declarations ?? []) {
+      if (declarator.id?.type !== "Identifier" || declarator.id.name !== "config")
+        continue;
+      const value = staticValue(declarator.init);
+      return isProxyConfigShape(value) ? value : undefined;
+    }
+  }
+  return;
+}
+function parserLang(file) {
+  const ext = path.extname(file);
+  if (ext === ".tsx")
+    return "tsx";
+  if (ext === ".jsx")
+    return "jsx";
+  return ext === ".js" || ext === ".mjs" ? "js" : "ts";
+}
+function staticValue(node) {
+  if (!node)
+    return;
+  switch (node.type) {
+    case "TSAsExpression":
+    case "TSSatisfiesExpression":
+    case "TSNonNullExpression":
+      return staticValue(node.expression);
+    case "Literal":
+    case "StringLiteral":
+    case "NumericLiteral":
+    case "BooleanLiteral":
+      return node.value === null ? undefined : node.value;
+    case "TemplateLiteral":
+      return node.expressions?.length === 0 ? node.quasis?.[0]?.value?.cooked ?? undefined : undefined;
+    case "ArrayExpression": {
+      const items = [];
+      for (const element of node.elements ?? []) {
+        const value = staticValue(element);
+        if (value === undefined)
+          return;
+        items.push(value);
+      }
+      return items;
+    }
+    case "ObjectExpression": {
+      const object = {};
+      for (const property of node.properties ?? []) {
+        if (property.type !== "Property" && property.type !== "ObjectProperty")
+          return;
+        if (property.computed)
+          return;
+        const key = property.key?.type === "Identifier" ? property.key.name : property.key?.value;
+        if (typeof key !== "string")
+          return;
+        const value = staticValue(property.value);
+        if (value === undefined)
+          return;
+        object[key] = value;
+      }
+      return object;
+    }
+    default:
+      return;
+  }
+}
+function isProxyConfigShape(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const matcher = value.matcher;
+  if (matcher === undefined)
+    return true;
+  const items = Array.isArray(matcher) ? matcher : [matcher];
+  return items.every((item) => {
+    if (typeof item === "string")
+      return true;
+    if (typeof item !== "object" || item === null)
+      return false;
+    const { source, has, missing } = item;
+    if (typeof source !== "string")
+      return false;
+    return [has, missing].every((list) => list === undefined || Array.isArray(list) && list.every(isConditionShape));
+  });
+}
+function isConditionShape(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const { type, key, value: expected } = value;
+  if (type !== "header" && type !== "query" && type !== "cookie" && type !== "host")
+    return false;
+  if (key !== undefined && typeof key !== "string")
+    return false;
+  return expected === undefined || typeof expected === "string";
+}
+
+export { releasedProxy, staticProxyConfig };

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

@@ -0,0 +1,132 @@
+// @bun
+// src/compat/ppr/root-params-scan.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import path from "path";
+var LAYOUT_BASENAMES = ["layout.tsx", "layout.ts", "layout.jsx", "layout.js"];
+function isRootLayoutSource(source) {
+  return /<html[\s>]/.test(source);
+}
+function paramNameOfSegment(segment) {
+  const optional = /^\[\[\.\.\.(.+)\]\]$/.exec(segment);
+  if (optional)
+    return optional[1];
+  const catchAll = /^\[\.\.\.(.+)\]$/.exec(segment);
+  if (catchAll)
+    return catchAll[1];
+  const dynamic = /^\[(.+)\]$/.exec(segment);
+  if (dynamic)
+    return dynamic[1];
+  return;
+}
+function findLayoutFile(dir) {
+  for (const base of LAYOUT_BASENAMES) {
+    const candidate = path.join(dir, base);
+    if (existsSync(candidate))
+      return candidate;
+  }
+  return;
+}
+function scanRootParams(appPath) {
+  const rootParams = new Set;
+  if (!existsSync(appPath))
+    return rootParams;
+  const walk = (dir, paramsAbove) => {
+    const layoutFile = findLayoutFile(dir);
+    if (layoutFile) {
+      let source = "";
+      try {
+        source = readFileSync(layoutFile, "utf8");
+      } catch {
+        source = "";
+      }
+      if (isRootLayoutSource(source)) {
+        for (const name of paramsAbove)
+          rootParams.add(name);
+      }
+    }
+    let children = [];
+    try {
+      children = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const child of children) {
+      const childPath = path.join(dir, child);
+      let isDir = false;
+      try {
+        isDir = statSync(childPath).isDirectory();
+      } catch {
+        isDir = false;
+      }
+      if (!isDir)
+        continue;
+      if (child.startsWith("@"))
+        continue;
+      const param = paramNameOfSegment(child);
+      walk(childPath, param ? [...paramsAbove, param] : paramsAbove);
+    }
+  };
+  walk(appPath, []);
+  return rootParams;
+}
+function scanRootParamTypes(appPath) {
+  const roots = [];
+  if (!existsSync(appPath))
+    return new Map;
+  const walk = (dir, paramsAbove) => {
+    const layoutFile = findLayoutFile(dir);
+    if (layoutFile) {
+      let source = "";
+      try {
+        source = readFileSync(layoutFile, "utf8");
+      } catch {
+        source = "";
+      }
+      if (isRootLayoutSource(source)) {
+        const params = new Map;
+        for (const { name, segment } of paramsAbove) {
+          params.set(name, segment.startsWith("[[...") ? ["string[]", "undefined"] : segment.startsWith("[...") ? ["string[]"] : ["string"]);
+        }
+        roots.push(params);
+      }
+    }
+    let children = [];
+    try {
+      children = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const child of children) {
+      const childPath = path.join(dir, child);
+      let isDir = false;
+      try {
+        isDir = statSync(childPath).isDirectory();
+      } catch {
+        isDir = false;
+      }
+      if (!isDir)
+        continue;
+      if (child.startsWith("@"))
+        continue;
+      const param = paramNameOfSegment(child);
+      walk(childPath, param ? [...paramsAbove, { name: param, segment: child }] : paramsAbove);
+    }
+  };
+  walk(appPath, []);
+  const combined = new Map;
+  for (const params of roots) {
+    for (const [name, types] of params) {
+      const set = combined.get(name) ?? new Set;
+      for (const type of types)
+        set.add(type);
+      combined.set(name, set);
+    }
+  }
+  for (const [name, set] of combined) {
+    if (roots.some((params) => !params.has(name)))
+      set.add("undefined");
+  }
+  return combined;
+}
+
+export { scanRootParams, scanRootParamTypes };