@wular/pnext 0.1.6 → 0.1.7

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

@@ -0,0 +1,194 @@
+// @bun
+import {
+  scanRoutes
+} from "./index-8k7pfejn.js";
+import {
+  ensureDir,
+  includeTypes,
+  toPosixPath,
+  writeFileAtomic
+} from "./index-20ppawv7.js";
+import {
+  bootstrapCompatBoot,
+  generateCompatRouteTypes
+} from "./index-5gyr4emz.js";
+import {
+  loadConfig
+} from "./index-x93hv0sc.js";
+
+// src/cli/typegen.ts
+import { existsSync } from "fs";
+import { readFile, rm, writeFile } from "fs/promises";
+import path from "path";
+async function typegenProject(root) {
+  const config = await loadConfig(root);
+  await bootstrapCompatBoot(config);
+  const routes = await scanRoutes(config.appPath, config.workspaceRoot);
+  const result = await writeTypegen(config, routes);
+  await generateCompatRouteTypes(config, routes);
+  return result;
+}
+async function writeTypegen(config, allRoutes) {
+  const routes = allRoutes.filter((route) => !route.interception && !route.synthetic);
+  const file = path.join(config.typesPath, "pnext.gen.d.ts");
+  const source = typegenSource(routes);
+  await writeIfChanged(file, source);
+  await writeCoreEnv(config, file, allRoutes);
+  const aliases = await writeRouteAliases(config, routes);
+  const checks = await writeChecks(config, routes);
+  return { file, routes: routes.length, checks, aliases };
+}
+function typegenSource(routes) {
+  const entries = routes.map((route) => routeEntry(route)).join(`
+`);
+  return `// This file is generated by PNext. Do not edit.
+import '@wular/pnext';
+
+declare module '@wular/pnext' {
+  interface PNextRoutes {
+${entries}
+  }
+}
+`;
+}
+function routeEntry(route) {
+  return `    '${routeKey(route.route)}': {
+      kind: '${route.kind}';
+      params: ${paramsType(route)};
+      mode: '${route.mode}';
+      hydrated: ${route.client ? "true" : "false"};
+    };`;
+}
+async function writeChecks(config, routes) {
+  const checksDir = config.checksPath;
+  await rm(path.join(config.typesPath, "checks"), { recursive: true, force: true });
+  await rm(checksDir, { recursive: true, force: true });
+  await ensureDir(checksDir);
+  const checked = routes.filter((route) => !route.metadataRoute);
+  await Promise.all(checked.map((route) => {
+    const file = path.join(checksDir, `${route.id}.check.ts`);
+    return writeIfChanged(file, checkSource(checksDir, route));
+  }));
+  return checked.length;
+}
+async function writeRouteAliases(config, routes) {
+  const aliasesDir = path.join(config.typesPath, "app");
+  await rm(aliasesDir, { recursive: true, force: true });
+  await ensureDir(aliasesDir);
+  await Promise.all(routes.map((route) => {
+    const file = path.join(aliasesDir, `${routeAliasPath(config, route)}.d.ts`);
+    return writeIfChanged(file, routeAliasSource(route));
+  }));
+  return routes.length;
+}
+function routeAliasSource(route) {
+  const routeType = routeKey(route.route);
+  return `// This file is generated by PNext. Do not edit.
+import type {
+  PageProps as PNextPageProps,
+  RouteContext as PNextRouteContext,
+  RouteParams as PNextRouteParams,
+  StaticParams as PNextStaticParams,
+} from '@wular/pnext';
+
+export type Params = PNextRouteParams<'${routeType}'>;
+export type PageProps = PNextPageProps<'${routeType}'>;
+export type RouteContext = PNextRouteContext<'${routeType}'>;
+export type StaticParams = PNextStaticParams<'${routeType}'>;
+`;
+}
+function routeAliasPath(config, route) {
+  const relative = toPosixPath(path.relative(config.appPath, route.file));
+  const extension = path.extname(relative);
+  return relative.slice(0, -extension.length);
+}
+function checkSource(checksDir, route) {
+  const routeImport = routeImportPath(checksDir, route.file);
+  const routeType = routeKey(route.route);
+  const moduleType = route.kind === "page" ? `PNextPageModule<'${routeType}'>` : `PNextRouteHandlerModule<'${routeType}'>`;
+  return `// This file is generated by PNext. Do not edit.
+import type { PNextPageModule, PNextRouteHandlerModule } from '@wular/pnext/internal';
+import * as routeModule from '${routeImport}';
+
+const check: ${moduleType} = routeModule;
+void check;
+`;
+}
+function routeImportPath(fromDir, file) {
+  const extension = path.extname(file);
+  const withoutExtension = file.slice(0, -extension.length);
+  const relative = toPosixPath(path.relative(fromDir, withoutExtension));
+  return relative.startsWith(".") ? relative : `./${relative}`;
+}
+function routeKey(route) {
+  return route.replace(/:([a-zA-Z0-9_]+)\*/g, "[...$1]").replace(/:([a-zA-Z0-9_]+)/g, "[$1]");
+}
+function paramsType(route) {
+  const entries = route.params.map((param) => `${JSON.stringify(param)}: string`);
+  if (route.catchAll)
+    entries.push(`${JSON.stringify(route.catchAll)}: string[]`);
+  return entries.length > 0 ? `{ ${entries.join("; ")} }` : "Record<string, never>";
+}
+async function writeIfChanged(file, source) {
+  try {
+    if (existsSync(file) && await readFile(file, "utf8") === source)
+      return;
+  } catch {}
+  await ensureDir(path.dirname(file));
+  await writeFile(file, source);
+}
+async function writeCoreEnv(config, typesFile, routes) {
+  if (config.compat?.next)
+    return;
+  const file = path.join(config.root, "tsconfig.json");
+  const exists = existsSync(file);
+  if (!exists && !routes.some((route) => route.sourceFiles.some((file2) => /\.[cm]?tsx?$/.test(file2))))
+    return;
+  const reference = toPosixPath(path.relative(config.root, typesFile));
+  await writeIfChanged(path.join(config.root, "pnext-env.d.ts"), `/// <reference types="@wular/pnext" />
+/// <reference path="${reference}" />
+
+// This file is generated by PNext. Do not edit.
+`);
+  if (!exists)
+    return;
+  let source;
+  let tsconfig;
+  try {
+    source = await readFile(file, "utf8");
+    tsconfig = Bun.JSONC.parse(source);
+  } catch {
+    return;
+  }
+  if (!tsconfig || !Array.isArray(tsconfig.include))
+    return;
+  const typesGlob = `${toPosixPath(path.relative(config.root, config.typesPath))}/**/*.ts`;
+  const added = includeTypes(tsconfig, ["pnext-env.d.ts", typesGlob], []);
+  if (added.length)
+    await writeFileAtomic(file, updateTypeSelection(source, added));
+}
+function updateTypeSelection(source, added) {
+  const tokens = [
+    ...source.matchAll(/"(?:\\[\s\S]|[^"\\])*"|\/\/[^\r\n]*|\/\*[\s\S]*?\*\/|[^\s]/g)
+  ].filter((token) => !token[0].startsWith("//") && !token[0].startsWith("/*"));
+  let depth = 0;
+  for (let index = 0;index < tokens.length; index++) {
+    const token = tokens[index];
+    if (depth === 1 && token[0].startsWith('"') && JSON.parse(token[0]) === "include" && tokens[index + 1]?.[0] === ":") {
+      let end = index + 3;
+      while (tokens[end]?.[0] !== "]")
+        end++;
+      const close = tokens[end];
+      const previous = tokens[end - 1][0];
+      const insertion = `${previous === "[" || previous === "," ? "" : ","} ${added.map((value) => JSON.stringify(value)).join(", ")}`;
+      return source.slice(0, close.index) + insertion + source.slice(close.index);
+    }
+    if (token[0] === "[" || token[0] === "{")
+      depth++;
+    if (token[0] === "]" || token[0] === "}")
+      depth--;
+  }
+  return source;
+}
+
+export { typegenProject, writeTypegen };

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

@@ -0,0 +1,283 @@
+// @bun
+// src/compat/segment/vary-params.ts
+import { AsyncLocalStorage } from "async_hooks";
+
+// src/compat/segment/vary-key.ts
+var SEARCH_PARAMS_SENTINEL = "?";
+
+// src/compat/segment/vary-params.ts
+function createSegmentVaryParamsAccumulator(kind = "page") {
+  const accumulator = {
+    kind,
+    varyParams: new Set,
+    status: "pending",
+    value: new Set,
+    then(onfulfilled) {
+      if (!onfulfilled)
+        return;
+      if (accumulator.status === "pending")
+        accumulator.resolvers.push(onfulfilled);
+      else
+        onfulfilled(accumulator.value);
+    },
+    resolvers: []
+  };
+  return accumulator;
+}
+var emptySet = new Set;
+var emptyVaryParamsAccumulator = {
+  kind: "page",
+  varyParams: emptySet,
+  status: "fulfilled",
+  value: emptySet,
+  then(onfulfilled) {
+    if (onfulfilled)
+      onfulfilled(emptySet);
+  },
+  resolvers: []
+};
+function createResponseVaryParamsAccumulator() {
+  return {
+    head: createSegmentVaryParamsAccumulator("head"),
+    rootParams: createSegmentVaryParamsAccumulator("root"),
+    segments: new Set
+  };
+}
+var VARY_PARAMS_GLOBALS = Symbol.for("pnext.compat.varyParamsGlobals");
+function varyGlobal(name, create) {
+  const root = globalThis;
+  const container = root[VARY_PARAMS_GLOBALS] ??= {};
+  if (!(name in container))
+    container[name] = create();
+  return container[name];
+}
+var varyStorage = varyGlobal("storage", () => new AsyncLocalStorage);
+function createVaryParamsAccumulator(kind = "page") {
+  const response = varyStorage.getStore();
+  if (!response)
+    return null;
+  const accumulator = createSegmentVaryParamsAccumulator(kind);
+  response.segments.add(accumulator);
+  return accumulator;
+}
+function getMetadataVaryParamsAccumulator() {
+  return varyStorage.getStore()?.head ?? null;
+}
+function getRootParamsVaryParamsAccumulator() {
+  return varyStorage.getStore()?.rootParams ?? null;
+}
+function accumulateVaryParam(accumulator, paramName) {
+  if (accumulator === emptyVaryParamsAccumulator)
+    return;
+  accumulator.varyParams.add(paramName);
+}
+function accumulateRootVaryParam(paramName) {
+  const accumulator = getRootParamsVaryParamsAccumulator();
+  if (accumulator !== null)
+    accumulateVaryParam(accumulator, paramName);
+}
+var VARY_TRACKING = Symbol.for("pnext.compat.varyTracking");
+function markVaryTracking(target, info) {
+  Object.defineProperty(target, VARY_TRACKING, {
+    value: info,
+    enumerable: false,
+    configurable: true
+  });
+}
+function varyTrackingInfo(value) {
+  if (typeof value !== "object" || value === null)
+    return null;
+  const info = value[VARY_TRACKING];
+  return info ?? null;
+}
+function createVaryingParams(accumulator, params, optionalCatchAllParamName = null) {
+  const originalParams = normalizeOptionalCatchAllParams(params, optionalCatchAllParamName);
+  const info = {
+    raw: originalParams,
+    kind: "params",
+    optionalCatchAllParam: optionalCatchAllParamName
+  };
+  if (optionalCatchAllParamName !== null) {
+    return new Proxy(originalParams, {
+      get(target, prop, receiver) {
+        if (prop === VARY_TRACKING)
+          return info;
+        if (typeof prop === "string" && (prop === optionalCatchAllParamName || Object.prototype.hasOwnProperty.call(target, prop))) {
+          accumulateVaryParam(accumulator, prop);
+        }
+        return Reflect.get(target, prop, receiver);
+      },
+      has(target, prop) {
+        if (prop === optionalCatchAllParamName) {
+          accumulateVaryParam(accumulator, optionalCatchAllParamName);
+        }
+        return Reflect.has(target, prop);
+      },
+      ownKeys(target) {
+        accumulateVaryParam(accumulator, optionalCatchAllParamName);
+        return Reflect.ownKeys(target);
+      }
+    });
+  }
+  const tracked = {};
+  for (const paramName in originalParams) {
+    Object.defineProperty(tracked, paramName, {
+      get() {
+        accumulateVaryParam(accumulator, paramName);
+        return originalParams[paramName];
+      },
+      enumerable: true,
+      configurable: true
+    });
+  }
+  markVaryTracking(tracked, info);
+  return tracked;
+}
+function normalizeOptionalCatchAllParams(params, optionalCatchAllParamName) {
+  if (optionalCatchAllParamName === null)
+    return params;
+  const value = params[optionalCatchAllParamName];
+  if (!Array.isArray(value) || value.length > 0)
+    return params;
+  const { [optionalCatchAllParamName]: _empty, ...rest } = params;
+  return rest;
+}
+function createVaryingSearchParams(accumulator, originalSearchParams) {
+  const info = {
+    raw: originalSearchParams,
+    kind: "searchParams",
+    optionalCatchAllParam: null
+  };
+  return new Proxy(originalSearchParams, {
+    get(target, prop, receiver) {
+      if (prop === VARY_TRACKING)
+        return info;
+      if (typeof prop === "string" && !isPromiseProbe(target, prop)) {
+        accumulateVaryParam(accumulator, SEARCH_PARAMS_SENTINEL);
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+    has(target, prop) {
+      if (typeof prop === "string")
+        accumulateVaryParam(accumulator, SEARCH_PARAMS_SENTINEL);
+      return Reflect.has(target, prop);
+    },
+    ownKeys(target) {
+      accumulateVaryParam(accumulator, SEARCH_PARAMS_SENTINEL);
+      return Reflect.ownKeys(target);
+    }
+  });
+}
+function isPromiseProbe(target, prop) {
+  return prop === "then" && !Object.prototype.hasOwnProperty.call(target, prop);
+}
+function finishAccumulatingVaryParams(response) {
+  const rootVaryParams = response.rootParams.varyParams;
+  finishSegmentAccumulator(response.head, rootVaryParams);
+  for (const segment of response.segments)
+    finishSegmentAccumulator(segment, rootVaryParams);
+  finishSegmentAccumulator(response.rootParams, emptySet);
+}
+function finishSegmentAccumulator(accumulator, rootVaryParams) {
+  if (accumulator.status !== "pending")
+    return;
+  const merged = new Set(accumulator.varyParams);
+  for (const param of rootVaryParams)
+    merged.add(param);
+  accumulator.value = merged;
+  accumulator.status = "fulfilled";
+  const resolvers = accumulator.resolvers;
+  accumulator.resolvers = [];
+  for (const resolve of resolvers)
+    resolve(merged);
+}
+function collectResponseVaryParams(response) {
+  finishAccumulatingVaryParams(response);
+  const body = new Set;
+  const page = new Set;
+  const layout = new Set;
+  for (const segment of response.segments) {
+    const target = segment.kind === "layout" ? layout : page;
+    for (const name of segment.value) {
+      body.add(name);
+      target.add(name);
+    }
+  }
+  const head = new Set(response.head.value);
+  return {
+    params: sortedParamNames(body),
+    page: sortedParamNames(page),
+    layout: sortedParamNames(layout),
+    head: sortedParamNames(head),
+    root: sortedParamNames(response.rootParams.value),
+    search: body.has(SEARCH_PARAMS_SENTINEL),
+    pageSearch: page.has(SEARCH_PARAMS_SENTINEL),
+    layoutSearch: layout.has(SEARCH_PARAMS_SENTINEL),
+    headSearch: head.has(SEARCH_PARAMS_SENTINEL)
+  };
+}
+function sortedParamNames(set) {
+  return [...set].filter((name) => name !== SEARCH_PARAMS_SENTINEL).sort();
+}
+async function withVaryParamsTracking(produce) {
+  const outer = varyStorage.getStore();
+  if (outer)
+    return { value: await produce(), vary: collectResponseVaryParams(outer) };
+  const response = createResponseVaryParamsAccumulator();
+  const value = await varyStorage.run(response, produce);
+  return { value, vary: collectResponseVaryParams(response) };
+}
+function encodeVaryNames(names, search) {
+  return search ? [...names, SEARCH_PARAMS_SENTINEL] : [...names];
+}
+function responseVaryParamsFromWire(wire) {
+  const split = (names) => ({
+    names: (names ?? []).filter((name) => name !== SEARCH_PARAMS_SENTINEL),
+    search: (names ?? []).includes(SEARCH_PARAMS_SENTINEL)
+  });
+  const body = split(wire.vary);
+  const layout = split(wire.layoutVary);
+  const page = split(wire.pageVary);
+  return {
+    params: body.names,
+    page: page.names,
+    layout: layout.names,
+    head: [],
+    root: [],
+    search: body.search,
+    pageSearch: page.search,
+    layoutSearch: layout.search,
+    headSearch: false
+  };
+}
+function varyNamesFor(vary, kind) {
+  switch (kind) {
+    case "head":
+      return encodeVaryNames(vary.head, vary.headSearch);
+    case "page":
+      return encodeVaryNames(vary.page, vary.pageSearch);
+    case "layout":
+      return encodeVaryNames(vary.layout, vary.layoutSearch);
+    default:
+      return encodeVaryNames(vary.params, vary.search);
+  }
+}
+
+// src/compat/static-params.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+var GSP_SCOPE = Symbol.for("pnext.generateStaticParamsScope");
+var globals = globalThis;
+var gspScope = globals[GSP_SCOPE] ??= new AsyncLocalStorage2;
+function generateStaticParamsScope() {
+  return gspScope.getStore();
+}
+function aliasGenerateStaticParams(module) {
+  if (typeof module.params === "function" || typeof module.generateStaticParams !== "function") {
+    return module;
+  }
+  const generate = module.generateStaticParams;
+  const params = (args) => gspScope.run({ provided: args?.params ?? {} }, () => generate(args));
+  return { ...module, params };
+}
+
+export { createVaryParamsAccumulator, getMetadataVaryParamsAccumulator, accumulateRootVaryParam, varyTrackingInfo, createVaryingParams, normalizeOptionalCatchAllParams, createVaryingSearchParams, withVaryParamsTracking, responseVaryParamsFromWire, varyNamesFor, generateStaticParamsScope, aliasGenerateStaticParams };

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

@@ -0,0 +1,22 @@
+// @bun
+// src/runtime/module-generations.ts
+import { fileURLToPath } from "url";
+var liveNames = new Map;
+var imported = new Set;
+var stale = 0;
+function noteModuleGeneration(key, outFile) {
+  const previous = liveNames.get(key);
+  if (previous !== outFile) {
+    liveNames.set(key, outFile);
+    if (previous !== undefined && imported.delete(previous))
+      stale += 1;
+  }
+}
+function noteModuleImported(href) {
+  imported.add(href.startsWith("file:") ? fileURLToPath(href) : href);
+}
+function moduleGenerationStats() {
+  return { live: imported.size, stale };
+}
+
+export { noteModuleGeneration, noteModuleImported, moduleGenerationStats };