@wular/pnext 0.1.5 → 0.1.7

package/dist/server/_chunks/index-11sfk4hb.js

@@ -0,0 +1,170 @@
+// @bun
+import {
+  rewriteFacts
+} from "./index-z4z9zv3b.js";
+import {
+  loadNative
+} from "./index-7wc9n8be.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/compat/next/link-transform.ts
+var parseSync = (...args) => loadNative(() => __require("oxc-parser")).parseSync(...args);
+var marker = "__pnextLegacyChildKind";
+function rewriteLegacyLinkValidation(source, file) {
+  if (!source.includes("Link") && !source.includes("legacyBehavior"))
+    return source;
+  const imports = rewriteFacts(file, source).imports;
+  const directLink = imports.some((statement) => statement.specifier === "next/link") && source.includes("legacyBehavior");
+  const asyncLinkWrapper = imports.some((statement) => statement.bindings.some((binding) => !binding.type && binding.local.endsWith("Link"))) && /<[A-Za-z_$][\w$]*Link\b/.test(source) && /\basync\s+function\b/.test(source);
+  if (!directLink && !asyncLinkWrapper)
+    return source;
+  const program = parseSync(file, source, { lang: langForFile(file) }).program;
+  const linkNames = new Set;
+  const asyncNames = new Set;
+  const functionNames = new Set;
+  const lazyNames = new Set;
+  const edits = [];
+  const isClient = program.body.some((statement) => statement.type === "ExpressionStatement" && statement.directive === "use client");
+  for (const statement of program.body) {
+    if (statement.type === "ImportDeclaration" && sourceValue(statement) === "next/link") {
+      for (const specifier of statement.specifiers ?? []) {
+        const local = identifierName(specifier.local);
+        if (!local)
+          continue;
+        if (specifier.type === "ImportDefaultSpecifier")
+          linkNames.add(local);
+        else if (identifierName(specifier.imported) === "Link")
+          linkNames.add(local);
+      }
+    }
+    if (statement.type === "FunctionDeclaration") {
+      const name = identifierName(statement.id);
+      if (name) {
+        functionNames.add(name);
+        if (statement.async === true)
+          asyncNames.add(name);
+      }
+    }
+    if (statement.type === "VariableDeclaration") {
+      for (const declarator of statement.declarations ?? []) {
+        const name = identifierName(declarator.id);
+        const init = declarator.init;
+        if (!name || !init)
+          continue;
+        if (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression") {
+          functionNames.add(name);
+          if (init.async === true)
+            asyncNames.add(name);
+        }
+        if (isLazyCall(init))
+          lazyNames.add(name);
+      }
+    }
+  }
+  walk(program.body, (node) => {
+    if (node.type !== "JSXElement")
+      return;
+    const element = node;
+    if (element.closingElement === null)
+      return;
+    annotate(element);
+  });
+  function annotate(element) {
+    const opening = element.openingElement;
+    if (opening.name.type !== "JSXIdentifier" || hasMarker(opening))
+      return;
+    const parent = opening.name.name ?? "";
+    const isLink = linkNames.has(parent);
+    if (!isLink && !parent.endsWith("Link"))
+      return;
+    const children = element.children.filter(isMeaningfulChild);
+    if (children.length !== 1)
+      return;
+    const kind = childKind(children[0]);
+    if (!kind || !isLink && kind !== "server-async")
+      return;
+    const annotatedKind = !isLink ? "server-async-through-client" : isClient && kind === "lazy" ? "client-lazy" : kind;
+    edits.push({ at: opening.name.end, text: ` ${marker}="${annotatedKind}"` });
+  }
+  function childKind(child) {
+    let name;
+    if (child.type === "JSXElement") {
+      const opening = child.openingElement;
+      if (opening.name.type === "JSXIdentifier")
+        name = opening.name.name;
+    } else if (child.type === "JSXExpressionContainer") {
+      const expression = child.expression;
+      if (expression?.type === "Identifier")
+        name = expression.name;
+    }
+    if (!name)
+      return;
+    if (lazyNames.has(name))
+      return "lazy";
+    if (asyncNames.has(name))
+      return "server-async";
+    if (!isClient && functionNames.has(name))
+      return "server-sync";
+    return;
+  }
+  if (edits.length === 0)
+    return source;
+  let output = source;
+  for (const edit of edits.sort((a, b) => b.at - a.at)) {
+    output = output.slice(0, edit.at) + edit.text + output.slice(edit.at);
+  }
+  return output;
+}
+function isMeaningfulChild(child) {
+  if (child.type === "JSXText") {
+    return typeof child.value === "string" && child.value.trim().length > 0;
+  }
+  if (child.type === "JSXExpressionContainer") {
+    return child.expression?.type !== "JSXEmptyExpression";
+  }
+  return true;
+}
+function hasMarker(opening) {
+  return opening.attributes.some((attribute) => attribute.type === "JSXAttribute" && attribute.name?.name === marker);
+}
+function isLazyCall(expression) {
+  if (expression.type !== "CallExpression")
+    return false;
+  const callee = expression.callee;
+  if (!callee)
+    return false;
+  if (callee.type === "Identifier")
+    return callee.name === "lazy";
+  return callee.type === "MemberExpression" && identifierName(callee.property) === "lazy";
+}
+function identifierName(node) {
+  const named = node;
+  return typeof named?.name === "string" ? named.name : undefined;
+}
+function sourceValue(statement) {
+  const literal = statement.source;
+  return typeof literal?.value === "string" ? literal.value : undefined;
+}
+function walk(node, visit) {
+  if (Array.isArray(node)) {
+    for (const item of node)
+      walk(item, visit);
+    return;
+  }
+  if (!node || typeof node !== "object")
+    return;
+  const candidate = node;
+  if (typeof candidate.type === "string")
+    visit(candidate);
+  for (const key in candidate) {
+    if (key !== "type")
+      walk(candidate[key], visit);
+  }
+}
+function langForFile(file) {
+  return /\.[cm]?ts$/.test(file) ? "ts" : "tsx";
+}
+
+export { rewriteLegacyLinkValidation };

package/dist/server/_chunks/index-20ppawv7.js

@@ -0,0 +1,297 @@
+// @bun
+import { join as __pnextJoin } from "node:path";
+const __PNEXT_PACKAGE_ROOT__ = __pnextJoin(import.meta.dirname, "../../..");
+import {
+  frozenDirListing
+} from "./index-tqn2qnnn.js";
+
+// src/utils/fs.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { mkdir, readdir, rename, rm, stat, readFile, writeFile } from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+var atomicWriteSequence = 0;
+async function writeFileAtomic(file, contents, tempDirectory) {
+  const suffix = `${process.pid.toString(36)}.${(++atomicWriteSequence).toString(36)}.tmp`;
+  let temp = tempDirectory ? path.join(tempDirectory, `.${path.basename(path.dirname(file))}-${path.basename(file)}.${suffix}`) : `${file}.${suffix}`;
+  try {
+    await writeFile(temp, contents);
+  } catch (error) {
+    if (!tempDirectory)
+      throw error;
+    temp = `${file}.${suffix}`;
+    await writeFile(temp, contents);
+  }
+  try {
+    await rename(temp, file);
+  } catch (error) {
+    if (!existsSync(file))
+      throw error;
+  }
+}
+async function listFiles(root) {
+  if (!existsSync(root))
+    return [];
+  const entries = await readdir(root, { withFileTypes: true });
+  const branches = await Promise.all(entries.map((entry) => {
+    const entryPath = path.join(root, entry.name);
+    if (entry.isDirectory())
+      return listFiles(entryPath);
+    return Promise.resolve(entry.isFile() ? [entryPath] : []);
+  }));
+  return branches.flat();
+}
+var dirListings;
+function withDirCache(run) {
+  if (dirListings)
+    return run();
+  dirListings = new Map;
+  try {
+    return run();
+  } finally {
+    dirListings = undefined;
+  }
+}
+function readDirListing(dir) {
+  const frozen = frozenDirListing(dir);
+  if (frozen)
+    return frozen;
+  const cached = dirListings?.get(dir);
+  if (cached)
+    return cached;
+  let listing;
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    listing = {
+      files: new Set(entries.filter((entry) => !entry.isDirectory()).map((entry) => entry.name)),
+      dirs: entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort()
+    };
+  } catch {
+    listing = { files: new Set, dirs: [] };
+  }
+  dirListings?.set(dir, listing);
+  return listing;
+}
+var maxExactNameMisses = 1024;
+function exactNameIndex(dir) {
+  let entries = [];
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {}
+  const entry = entries.find((item) => !item.isSymbolicLink() && hasCase(item.name));
+  const probe = entry ? path.join(dir, entry.name) : dir;
+  const name = path.basename(probe);
+  if (!hasCase(name))
+    return;
+  return existsSync(path.join(path.dirname(probe), flipCase(name))) ? { dirs: new Map, misses: new Set } : undefined;
+}
+function flipCase(name) {
+  return name === name.toUpperCase() ? name.toLowerCase() : name.toUpperCase();
+}
+function hasCase(name) {
+  return flipCase(name) !== name;
+}
+function hasExactName(names, root, relative) {
+  let dir = root;
+  for (const name of relative.split(path.sep)) {
+    const file = `${dir}${path.sep}${name}`;
+    const listing = dirNames(names, dir);
+    if (!listing)
+      return false;
+    if (!listing.has(name)) {
+      if (names.misses.has(file))
+        return false;
+      const fresh = dirNames(names, dir, true);
+      if (!fresh?.has(name)) {
+        if (fresh) {
+          if (names.misses.size >= maxExactNameMisses)
+            names.misses.clear();
+          names.misses.add(file);
+        }
+        return false;
+      }
+    }
+    dir = file;
+  }
+  return true;
+}
+function dirNames(names, dir, refresh = false) {
+  let entries = refresh ? undefined : names.dirs.get(dir);
+  if (!entries) {
+    try {
+      entries = new Set(readdirSync(dir));
+    } catch {
+      return;
+    }
+    names.dirs.set(dir, entries);
+  }
+  return entries;
+}
+function listFilesSync(root) {
+  if (!existsSync(root))
+    return [];
+  const out = [];
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    const entryPath = path.join(root, entry.name);
+    if (entry.isDirectory())
+      out.push(...listFilesSync(entryPath));
+    else if (entry.isFile())
+      out.push(entryPath);
+  }
+  return out;
+}
+async function ensureEmptyDir(dir, keep = []) {
+  if (keep.length === 0) {
+    await rm(dir, { recursive: true, force: true });
+    await mkdir(dir, { recursive: true });
+    return;
+  }
+  await mkdir(dir, { recursive: true });
+  const preserved = new Set(keep);
+  const entries = await readdir(dir).catch(() => []);
+  await Promise.all(entries.filter((entry) => !preserved.has(entry)).map((entry) => rm(path.join(dir, entry), { recursive: true, force: true })));
+}
+async function ensureDir(dir) {
+  await mkdir(dir, { recursive: true });
+}
+async function writeText(file, value) {
+  await ensureDir(path.dirname(file));
+  await writeFile(file, value);
+}
+async function readText(file) {
+  return readFile(file, "utf8");
+}
+function toPosixPath(value) {
+  return value.split(path.sep).join("/");
+}
+function cssModuleScopePath(file) {
+  const normalized = toPosixPath(file);
+  const appIndex = normalized.lastIndexOf("/app/");
+  if (appIndex !== -1)
+    return normalized.slice(appIndex + 1);
+  let dir = path.dirname(file);
+  let fallback;
+  while (true) {
+    const packageFile = path.join(dir, "package.json");
+    if (existsSync(packageFile) || existsSync(path.join(dir, "pnext.config.ts")) || existsSync(path.join(dir, "node_modules"))) {
+      const relative = toPosixPath(path.relative(dir, file));
+      try {
+        const { name } = JSON.parse(readFileSync(packageFile, "utf8"));
+        if (typeof name === "string")
+          return `${name}/${relative}`;
+      } catch {}
+      fallback ??= relative;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir)
+      return fallback ?? path.basename(file);
+    dir = parent;
+  }
+}
+function pnextVersionRange() {
+  const pkgPath = fileURLToPath(new URL("../../package.json", Bun.pathToFileURL(__PNEXT_PACKAGE_ROOT__ + "/src/utils/fs.ts").href));
+  const { version } = JSON.parse(readFileSync(pkgPath, "utf8"));
+  return `^${version}`;
+}
+function pnextOptionalDependencyRange(name) {
+  const pkgPath = fileURLToPath(new URL("../../package.json", Bun.pathToFileURL(__PNEXT_PACKAGE_ROOT__ + "/src/utils/fs.ts").href));
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+  return pkg.optionalDependencies?.[name];
+}
+function includeTypes(config, files, defaults) {
+  if (!("include" in config)) {
+    config.include = [...files, ...defaults];
+    return files;
+  }
+  const include = config.include;
+  if (!Array.isArray(include))
+    return [];
+  const added = files.filter((file) => !include.includes(file));
+  include.push(...added);
+  return added;
+}
+var frameworkRoot = path.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/utils", "..", "..");
+var frameworkPrefix = "pnext:";
+function serializeBuildManifest(data) {
+  const { root, appDir, outDir } = data;
+  const relative = (file) => {
+    const inRoot = toPosixPath(path.relative(root, file));
+    if (!inRoot.startsWith(".."))
+      return inRoot;
+    const inFramework = toPosixPath(path.relative(frameworkRoot, file));
+    return inFramework.startsWith("..") ? inRoot : `${frameworkPrefix}${inFramework}`;
+  };
+  const stored = {
+    ...mapSourcePaths(data, relative),
+    root: toPosixPath(path.relative(outDir, root)) || ".",
+    appDir: toPosixPath(path.relative(root, appDir)),
+    outDir: "."
+  };
+  return `${JSON.stringify(stored, null, 2)}
+`;
+}
+function resolveManifest(data, outPath, root) {
+  if (path.isAbsolute(data.root))
+    return data;
+  const absolute = (file) => file.startsWith(frameworkPrefix) ? path.join(frameworkRoot, file.slice(frameworkPrefix.length)) : path.join(root, file);
+  return {
+    ...mapSourcePaths(data, absolute),
+    root,
+    appDir: absolute(data.appDir),
+    outDir: outPath
+  };
+}
+var sourcePathFields = [
+  "file",
+  "sourceFiles",
+  "cssImports",
+  "templateFiles",
+  "forbiddenFiles",
+  "unauthorizedFiles",
+  "slotDirs",
+  "slotDir",
+  "syntheticSlotDir",
+  "childrenDefault",
+  "serverActionFile",
+  "globalErrorFile"
+];
+function mapSourcePaths(data, map) {
+  function owner(value) {
+    if (!value)
+      return value;
+    const mapped2 = { ...value };
+    for (const key of sourcePathFields) {
+      const field = value[key];
+      if (field !== undefined)
+        mapped2[key] = Array.isArray(field) ? field.map(map) : map(field);
+    }
+    return mapped2;
+  }
+  const mapped = owner(data);
+  mapped.routes = data.routes.map((route) => ({
+    ...owner(route),
+    clientReferences: route.clientReferences.map(owner),
+    ...route.interception && { interception: owner(route.interception) }
+  }));
+  if (data.staticMetadataFiles)
+    mapped.staticMetadataFiles = data.staticMetadataFiles.map(owner);
+  if (data.staticRouteMetadata) {
+    mapped.staticRouteMetadata = Object.fromEntries(Object.entries(data.staticRouteMetadata).map(([route, entry]) => [
+      route,
+      {
+        ...entry,
+        favicon: owner(entry.favicon),
+        manifest: owner(entry.manifest),
+        icons: entry.icons.map(owner),
+        appleIcons: entry.appleIcons.map(owner),
+        rootIcons: entry.rootIcons.map(owner)
+      }
+    ]));
+  }
+  if (data.staticModuleMetadata) {
+    mapped.staticModuleMetadata = Object.fromEntries(Object.entries(data.staticModuleMetadata).map(([file, metadata]) => [map(file), metadata]));
+  }
+  return mapped;
+}
+
+export { writeFileAtomic, listFiles, withDirCache, readDirListing, exactNameIndex, hasExactName, listFilesSync, ensureEmptyDir, ensureDir, writeText, readText, toPosixPath, cssModuleScopePath, pnextVersionRange, pnextOptionalDependencyRange, includeTypes, serializeBuildManifest, resolveManifest };