@wular/pnext 0.1.6 → 0.1.8

package/src/resolve/imports.ts

@@ -10,6 +10,9 @@ import {
   tsConfigFileFor,
 } from './engine'
 import { onExtensionHostReset } from '../extensions'
+import { findWorkspaceRoot, readPackageJson, type PackageJson } from './package-json'
+
+export { findWorkspaceRoot }
 
 // `Bun` through globalThis: pnext ships TypeScript source, so app compilers without
 // bun-types typecheck this file and a bare `Bun` identifier would fail them.
@@ -45,6 +48,8 @@ export interface ExternalPackagePolicy {
    * transpile.
    */
   transpiled?: () => readonly string[]
+  /** Kept out of a release's server dependency graph beyond `external`: Next's built-in list. */
+  releaseExternal?: (packageName: string) => boolean
   /** ESM external mode for package exports interop. */
   esmExternals: () => boolean | 'loose'
 }
@@ -94,9 +99,14 @@ export function resolveExternalLoadTarget(context: ExternalLoadContext): string
   // `#imports` resolve from the importer's OWN package, so they are not
   // shareable across a resolution root; they stay uncached.
   if (context.specifier.startsWith('#')) return externalLoadResolver(context)
-  const key = `${context.target}\0${resolutionRootForFile(context.root, context.fromFile)}\0${context.specifier}`
+  // A node_modules importer resolves from its own directory, as Node does: a version nested under
+  // its package wins over the hoisted one.
+  const resolveContext = context.fromFile.includes(`${path.sep}node_modules${path.sep}`)
+    ? { ...context, root: path.dirname(context.fromFile) }
+    : context
+  const key = `${context.target}\0${resolutionRootForFile(resolveContext.root, context.fromFile)}\0${context.specifier}`
   if (externalLoadTargets.has(key)) return externalLoadTargets.get(key)
-  const target = externalLoadResolver(context)
+  const target = externalLoadResolver(resolveContext)
   externalLoadTargets.set(key, target)
   return target
 }
@@ -143,22 +153,6 @@ export function setTsConfigPath(file: string | undefined): void {
   clearVendorPackageResolutions()
 }
 
-interface PackageJson {
-  name?: string
-  type?: string
-  browser?: string
-  main?: string
-  module?: string
-  source?: string
-  exports?: PackageExport
-  imports?: Record<string, PackageExport>
-  dependencies?: Record<string, string>
-  devDependencies?: Record<string, string>
-  optionalDependencies?: Record<string, string>
-  peerDependencies?: Record<string, string>
-  workspaces?: string[] | { packages?: string[] }
-}
-
 // Compat (or any bundler extension) registers its bare-specifier to file aliases here (e.g. `next/form` ->
 // `src/compat/next/form.tsx`). Core's own route scanner has no static knowledge of those aliases otherwise,
 // so a server component importing a 'use client' compat module would never be walked into and its client
@@ -886,25 +880,6 @@ export function commonJsModuleHasDefaultExport(source: string, file: string) {
   )
 }
 
-export function findWorkspaceRoot(root: string) {
-  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 undefined
-    }
-    dir = parent
-  }
-}
-
 function isInside(root: string, file: string) {
   const relative = path.relative(root, file)
   return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative))
@@ -962,8 +937,6 @@ function readPnpmWorkspacePatterns(root: string) {
 }
 
 const tsConfigCache = new Map<string, TsConfig>()
-const packageJsonCache = new Map<string, PackageJson>()
-const workspaceRootCache = new Map<string, string | undefined>()
 const workspacePackageCache = new Map<string, Map<string, string>>()
 
 function readTsConfig(root: string) {
@@ -975,14 +948,6 @@ function readTsConfig(root: string) {
   return config
 }
 
-function readPackageJson(root: string) {
-  const existing = packageJsonCache.get(root)
-  if (existing) return existing
-  const config = readJson<PackageJson>(path.join(root, 'package.json')) ?? {}
-  packageJsonCache.set(root, config)
-  return config
-}
-
 function workspacePackages(root: string) {
   const existing = workspacePackageCache.get(root)
   if (existing) return existing
@@ -1027,11 +992,6 @@ export function workspacePackageRoots(root: string) {
   return [...workspacePackages(path.resolve(root)).values()].sort()
 }
 
-function readJson<T>(file: string) {
-  if (!existsSync(file)) return undefined
-  return JSON.parse(readFileSync(file, 'utf8')) as T
-}
-
 function readJsonc<T>(file: string) {
   if (!existsSync(file)) return undefined
   return JSON.parse(stripTrailingCommas(stripJsonComments(readFileSync(file, 'utf8')))) as T

package/src/resolve/package-json.ts

@@ -0,0 +1,56 @@
+// package.json reads and workspace-root discovery, which config loading needs without the resolver.
+import { existsSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+
+type PackageExport = unknown
+
+export interface PackageJson {
+  name?: string
+  type?: string
+  browser?: string
+  main?: string
+  module?: string
+  source?: string
+  exports?: PackageExport
+  imports?: Record<string, PackageExport>
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+  optionalDependencies?: Record<string, string>
+  peerDependencies?: Record<string, string>
+  workspaces?: string[] | { packages?: string[] }
+}
+
+const packageJsonCache = new Map<string, PackageJson>()
+const workspaceRootCache = new Map<string, string | undefined>()
+
+export function readPackageJson(root: string) {
+  const existing = packageJsonCache.get(root)
+  if (existing) return existing
+  const config = readJson<PackageJson>(path.join(root, 'package.json')) ?? {}
+  packageJsonCache.set(root, config)
+  return config
+}
+
+export function findWorkspaceRoot(root: string) {
+  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 undefined
+    }
+    dir = parent
+  }
+}
+
+function readJson<T>(file: string) {
+  if (!existsSync(file)) return undefined
+  return JSON.parse(readFileSync(file, 'utf8')) as T
+}

package/src/resolve/scan-facts.ts

@@ -76,6 +76,8 @@ export interface RewriteFacts {
   edges: SpecifierEdge[]
   imports: ImportStatement[]
   importMetas: { start: number; end: number }[]
+  /** `import()` calls whose argument is not a plain string literal. */
+  computedImports: { start: number; end: number }[]
   /**
    * The parse recovered from errors, so the record may be incomplete — folded
    * passes fall back to their textual form rather than silently under-rewrite.
@@ -146,6 +148,7 @@ const emptyRewriteFacts: RewriteFacts = {
   edges: [],
   imports: [],
   importMetas: [],
+  computedImports: [],
   unreliable: false,
 }
 
@@ -373,10 +376,14 @@ function parseFacts(file: string, source: string, lang: ParserLang) {
   imports.sort((a, b) => a.index - b.index)
 
   const dynamicImports: { specifier: string; index: number }[] = []
+  const computedImports: { start: number; end: number }[] = []
   for (const entry of result.module.dynamicImports) {
     const raw = source.slice(entry.moduleRequest.start, entry.moduleRequest.end)
     const specifier = literalSpecifier(raw)
-    if (specifier === undefined) continue
+    if (specifier === undefined) {
+      computedImports.push({ start: entry.start, end: entry.end })
+      continue
+    }
     dynamicImports.push({ specifier, index: entry.start })
     // The literal's own span, without the whitespace `moduleRequest` includes.
     const lead = raw.length - raw.trimStart().length
@@ -419,6 +426,7 @@ function parseFacts(file: string, source: string, lang: ParserLang) {
       edges,
       imports: importStatements,
       importMetas: result.module.importMetas.map(meta => ({ start: meta.start, end: meta.end })),
+      computedImports,
       unreliable: result.errors.length > 0,
     },
   }
@@ -581,6 +589,247 @@ function child(node: AstNode | undefined, key: string): AstNode | undefined {
   return isNode(value) ? value : undefined
 }
 
+/** A string literal argument: its cooked value and the span of its quoted text. */
+export interface LiteralSpan {
+  specifier: string
+  start: number
+  end: number
+}
+
+/** How a module refers to its own location (see `importMetaRefs`). */
+export interface ImportMetaRefs {
+  /** `new URL('<literal>', import.meta.url)`. */
+  urls: LiteralSpan[]
+  /** `import.meta.resolve('<literal>')`. */
+  resolves: LiteralSpan[]
+  /** Reads `import.meta.url`/`dirname`/`filename`/`resolve`, or takes `import.meta` whole. */
+  readsLocation: boolean
+  /** Spans of each `import()` whose argument is not a string literal. */
+  computedImports: { start: number; end: number }[]
+  /** The parse recovered from errors: callers keep their conservative answer. */
+  unreliable: boolean
+}
+
+const noMetaRefs: ImportMetaRefs = {
+  urls: [],
+  resolves: [],
+  readsLocation: false,
+  computedImports: [],
+  unreliable: false,
+}
+const metaRefMemo = new Map<string, ImportMetaRefs>()
+const locationMembers = new Set(['url', 'dirname', 'filename', 'resolve'])
+
+/** Every reference a module makes to its own location, from the AST: never a comment or a string. */
+export function importMetaRefs(file: string, source: string): ImportMetaRefs {
+  if (stylesheetOrData.test(file)) return noMetaRefs
+  if (!source.includes('import.meta') && !source.includes('import(')) return noMetaRefs
+  // The memoized module record answers computed imports and whether `import.meta` occurs at all;
+  // only a module that really uses it pays for the AST.
+  const record = rewriteFacts(file, source)
+  if (record.importMetas.length === 0)
+    return { ...noMetaRefs, computedImports: record.computedImports, unreliable: record.unreliable }
+  const lang = langForFile(file)
+  const key = `${lang}\0${source.length}\0${bun.hash(source).toString()}`
+  const cached = metaRefMemo.get(key)
+  if (cached) return cached
+  const result = parseSync(file, source, { lang })
+  const refs: ImportMetaRefs = {
+    ...noMetaRefs,
+    urls: [],
+    resolves: [],
+    computedImports: record.computedImports,
+  }
+  refs.unreliable = result.errors.length > 0
+  const isImportMeta = (node: AstNode | undefined) =>
+    node?.type === 'MetaProperty' &&
+    child(node, 'meta')?.name === 'import' &&
+    child(node, 'property')?.name === 'meta'
+  const memberName = (node: AstNode) =>
+    node.computed ? stringValue(child(node, 'property')) : (child(node, 'property')?.name as string)
+  const literal = (node: AstNode | undefined): LiteralSpan | undefined => {
+    if (!node) return undefined
+    const value =
+      stringValue(node) ??
+      (node.type === 'TemplateLiteral' && (node.expressions as unknown[]).length === 0
+        ? ((node.quasis as AstNode[])[0]?.value as { cooked?: string } | undefined)?.cooked
+        : undefined)
+    return value === undefined ? undefined : { specifier: value, start: node.start, end: node.end }
+  }
+  const visit = (value: unknown, parent: AstNode | undefined) => {
+    if (Array.isArray(value)) {
+      for (const item of value) visit(item, parent)
+      return
+    }
+    if (!isNode(value)) return
+    if (isImportMeta(value)) {
+      const member = parent?.type === 'MemberExpression' && parent.object === value
+      if (!member || locationMembers.has(memberName(parent) ?? '')) refs.readsLocation = true
+    } else if (value.type === 'NewExpression' && child(value, 'callee')?.name === 'URL') {
+      const [target, base] = value.arguments as AstNode[]
+      const span = literal(target)
+      if (span && base?.type === 'MemberExpression' && isImportMeta(child(base, 'object')))
+        if (memberName(base) === 'url') refs.urls.push(span)
+    } else if (value.type === 'CallExpression') {
+      const callee = child(value, 'callee')
+      if (callee?.type === 'MemberExpression' && isImportMeta(child(callee, 'object'))) {
+        const span = literal((value.arguments as AstNode[])[0])
+        if (span && memberName(callee) === 'resolve') refs.resolves.push(span)
+      }
+    }
+    for (const key in value) {
+      if (key !== 'start' && key !== 'end' && key !== 'type') visit(value[key], value)
+    }
+  }
+  visit(result.program, undefined)
+  metaRefMemo.set(key, refs)
+  return refs
+}
+
+/**
+ * Whether the module declares top-level state: a `const`/`let`/`var` initialized by `new`, or by a
+ * call through a plain name (not `require`, not `/* @__PURE__ *\/`), from the AST: never a line
+ * inside a string, and every declarator counts.
+ */
+export function hasModuleState(file: string, source: string): boolean {
+  const result = parseSync(file, source, { lang: langForFile(file) })
+  const pureEnds = new Set(
+    result.comments
+      .filter(comment => /^\s*[#@]__PURE__\s*$/.test(comment.value))
+      .map(comment => comment.end),
+  )
+  const annotatedPure = (node: AstNode) => {
+    for (let index = node.start - 1; index >= 0; index -= 1) {
+      if (pureEnds.has(index + 1)) return true
+      if (!/\s/.test(source[index]!)) return false
+    }
+    return false
+  }
+  const plainCallee = (node: AstNode | undefined): boolean =>
+    node?.type === 'Identifier' ||
+    (node?.type === 'MemberExpression' && !node.computed && plainCallee(child(node, 'object')))
+  const declarations = (result.program.body as unknown as AstNode[]).flatMap(statement => {
+    const declaration =
+      statement.type === 'ExportNamedDeclaration' ? child(statement, 'declaration') : statement
+    return declaration?.type === 'VariableDeclaration'
+      ? (declaration.declarations as AstNode[])
+      : []
+  })
+  return declarations.some(declarator => {
+    const init = unwrapExpression(child(declarator, 'init'))
+    if (init?.type === 'NewExpression') return true
+    if (init?.type !== 'CallExpression') return false
+    const callee = child(init, 'callee')
+    return plainCallee(callee) && callee?.name !== 'require' && !annotatedPure(init)
+  })
+}
+
+/** A string literal holding an absolute path or `file:` URL, and whether it is an object key. */
+export interface PathLiteral {
+  value: string
+  start: number
+  end: number
+  key: boolean
+}
+
+/** Absolute path literals in emitted code, from the AST; undefined when the parse recovered. */
+export function absolutePathLiterals(file: string, source: string): PathLiteral[] | undefined {
+  const result = parseSync(file, source, { lang: langForFile(file) })
+  if (result.errors.length > 0) return undefined
+  const found: PathLiteral[] = []
+  const visit = (value: unknown, parent: AstNode | undefined) => {
+    if (Array.isArray(value)) {
+      for (const item of value) visit(item, parent)
+      return
+    }
+    if (!isNode(value)) return
+    const literal = stringValue(value)
+    if (literal !== undefined && (literal.startsWith('/') || literal.startsWith('file:///'))) {
+      const key = parent?.type === 'Property' && parent.key === value && !parent.computed
+      found.push({ value: literal, start: value.start, end: value.end, key })
+    }
+    for (const key in value) {
+      if (key !== 'start' && key !== 'end' && key !== 'type') visit(value[key], value)
+    }
+  }
+  visit(result.program, undefined)
+  return found
+}
+
+/** Line comments (`// …`), from the parse; undefined when it recovered. */
+export function lineComments(file: string, source: string) {
+  const result = parseSync(file, source, { lang: langForFile(file) })
+  if (result.errors.length > 0) return undefined
+  return result.comments
+    .filter(comment => comment.type === 'Line')
+    .map(comment => ({ value: comment.value, start: comment.start, end: comment.end }))
+}
+
+/**
+ * Drop `type: "json"` attributes from the import declarations and `import()` calls whose target
+ * `compiled` claims: the target is JS, which a native load would parse as JSON.
+ */
+export function stripJsonImportAttributes(
+  source: string,
+  file: string,
+  compiled: (specifier: string) => boolean,
+) {
+  const result = parseSync(file, source, { lang: 'js', sourceType: 'module' })
+  if (result.errors.length > 0) return source
+  const edits: { start: number; end: number; value: string }[] = []
+  const visit = (node: AstNode) => {
+    const target = child(node, 'source')
+    const specifier = stringValue(target)
+    if (target && specifier !== undefined && compiled(specifier)) {
+      const attributes = node.attributes as AstNode[] | undefined
+      const options = child(node, 'options')
+      if (attributes?.length && attributes.every(jsonTypeAttribute)) {
+        const end = source.indexOf('}', attributes.at(-1)!.end) + 1
+        edits.push({ start: target.end, end, value: '' })
+      } else if (node.type === 'ImportExpression' && options && jsonImportOptions(options)) {
+        edits.push({ start: target.end, end: options.end, value: '' })
+      }
+    }
+    for (const value of Object.values(node)) {
+      if (isNode(value)) visit(value)
+      else if (Array.isArray(value)) for (const item of value) if (isNode(item)) visit(item)
+    }
+  }
+  visit(result.program as unknown as AstNode)
+  return edits.length > 0 ? spliceSource(source, edits) : source
+}
+
+function propertyName(node: AstNode | undefined) {
+  if (!node) return undefined
+  return node.type === 'Identifier' ? (node.name as string) : stringValue(node)
+}
+
+function jsonTypeAttribute(node: AstNode) {
+  return (
+    !node.computed &&
+    propertyName(child(node, 'key')) === 'type' &&
+    stringValue(child(node, 'value')) === 'json'
+  )
+}
+
+/** `{ with: { type: 'json' } }` (or `assert`) and nothing else. */
+function jsonImportOptions(options: AstNode) {
+  const [property, ...rest] = (options.properties as AstNode[] | undefined) ?? []
+  const attributes = child(property, 'value')
+  const entries = attributes?.properties as AstNode[] | undefined
+  return (
+    options.type === 'ObjectExpression' &&
+    !!property &&
+    rest.length === 0 &&
+    property.type === 'Property' &&
+    !property.computed &&
+    ['with', 'assert'].includes(propertyName(child(property, 'key')) ?? '') &&
+    attributes?.type === 'ObjectExpression' &&
+    !!entries?.length &&
+    entries.every(entry => entry.type === 'Property' && jsonTypeAttribute(entry))
+  )
+}
+
 function collectDynamicCalls(program: AstNode): DynamicCallFact[] {
   const calls: DynamicCallFact[] = []
   const visit = (value: unknown) => {

package/src/routing/href.ts

@@ -198,7 +198,16 @@ export function canonicalTrailingSlashPath(pathname: string, trailingSlash: bool
   if (/\.[^/]+$/.test(pathname)) return pathname
   const slashed = pathname.endsWith('/')
   if (trailingSlash ? slashed : !slashed) return pathname
-  return trailingSlash ? `${pathname.replace(/\/+$/, '')}/` : pathname.replace(/\/+$/, '') || '/'
+  // Collapsed, so a rewritten path can never read as protocol-relative (`//host`).
+  const bare = pathname.replace(/\/{2,}/g, '/').replace(/\/+$/, '')
+  return trailingSlash ? `${bare}/` : bare || '/'
+}
+
+/** Next 308s a path with repeated slashes to its collapsed form, for every method, before anything else. */
+export function repeatedSlashRedirect(url: URL): Response | null {
+  if (!url.pathname.includes('//')) return null
+  const target = `${url.pathname.replace(/\/{2,}/g, '/')}${url.search}`
+  return new Response(target, { status: 308, headers: { location: target } })
 }
 
 /**
@@ -210,13 +219,11 @@ export function canonicalTrailingSlashPath(pathname: string, trailingSlash: bool
 export function trailingSlashRedirect(
   config: { trailingSlash?: boolean; skipTrailingSlashRedirect?: boolean },
   url: URL,
-  method: string,
 ): Response | null {
   // skipTrailingSlashRedirect: the app serves both slashed and unslashed URLs
   // as-is, so no canonical redirect is ever emitted (route matching already
   // tolerates a trailing slash via normalizePathname).
   if (config.skipTrailingSlashRedirect) return null
-  if (method !== 'GET' && method !== 'HEAD') return null
   const pathname = url.pathname
   if (pathname === '/' || pathname === '') return null
   if (pathname.startsWith('/__pnext') || isBuildAssetPathname(pathname)) return null