@tanstack/start-plugin-core 1.167.34 → 1.168.0

package/src/vite/start-compiler-plugin/plugin.ts

@@ -1,4 +1,3 @@
-import assert from 'node:assert'
 import { VIRTUAL_MODULES } from '@tanstack/start-server-core'
 import { resolve as resolvePath } from 'pathe'
 import {
@@ -12,7 +11,6 @@ import {
   createStartCompiler,
   mergeServerFnsById,
 } from '../../start-compiler/host'
-import { loadModuleForViteCompiler } from '../../start-compiler/load-module'
 import { generateServerFnResolverModule } from '../../start-compiler/server-fn-resolver-module'
 import { cleanId } from '../../start-compiler/utils'
 import { createVirtualModule } from '../createVirtualModule'
@@ -21,17 +19,116 @@ import {
   createViteDevServerFnModuleSpecifierEncoder,
   decodeViteDevServerModuleSpecifier,
 } from './module-specifier'
+import { mergeHotUpdateModules } from './hot-update'
 import type { CompileStartFrameworkOptions } from '../../types'
 import type {
   GenerateFunctionIdFnOptional,
   ServerFn,
 } from '../../start-compiler/types'
-import type { PluginOption } from 'vite'
+import type { EnvironmentModuleNode, PluginOption } from 'vite'
 
 // Re-export from shared constants for backwards compatibility
 export { SERVER_FN_LOOKUP }
 
 const validateServerFnIdVirtualModule = `virtual:tanstack-start-validate-server-fn-id`
+const TSS_SERVERFN_SPLIT_PARAM = 'tss-serverfn-split'
+
+type ModuleInvalidationEnvironment = {
+  moduleGraph: {
+    getModulesByFile: (file: string) => Set<EnvironmentModuleNode> | undefined
+    invalidateModule: (
+      mod: EnvironmentModuleNode,
+      seen?: Set<EnvironmentModuleNode>,
+    ) => void
+  }
+}
+
+function invalidateMatchingFileModules(
+  environment: ModuleInvalidationEnvironment,
+  ids: Iterable<string>,
+  shouldInvalidate: (mod: EnvironmentModuleNode) => boolean,
+) {
+  const seen = new Set<EnvironmentModuleNode>()
+  const invalidatedModules: Array<EnvironmentModuleNode> = []
+
+  for (const id of ids) {
+    const fileModules = environment.moduleGraph.getModulesByFile(cleanId(id))
+
+    if (!fileModules) {
+      continue
+    }
+
+    for (const fileModule of fileModules) {
+      if (!shouldInvalidate(fileModule)) {
+        continue
+      }
+
+      environment.moduleGraph.invalidateModule(fileModule, seen)
+      invalidatedModules.push(fileModule)
+    }
+  }
+
+  return invalidatedModules
+}
+
+function invalidateServerFnProviderModules(
+  environment: {
+    moduleGraph: {
+      getModulesByFile: (file: string) => Set<EnvironmentModuleNode> | undefined
+      invalidateModule: (
+        mod: EnvironmentModuleNode,
+        seen?: Set<EnvironmentModuleNode>,
+      ) => void
+    }
+  },
+  ids: Iterable<string>,
+) {
+  return invalidateMatchingFileModules(
+    environment,
+    ids,
+    (fileModule) => fileModule.id?.includes(TSS_SERVERFN_SPLIT_PARAM) ?? false,
+  )
+}
+
+function invalidateServerFnLookupModules(
+  environment: ModuleInvalidationEnvironment,
+  ids: Iterable<string>,
+) {
+  invalidateMatchingFileModules(
+    environment,
+    ids,
+    (fileModule) => fileModule.id?.includes(SERVER_FN_LOOKUP) ?? false,
+  )
+}
+
+function getServerFnProviderIds(ids: Iterable<string>) {
+  const providerIds = new Set<string>()
+
+  for (const id of ids) {
+    const cleanedId = cleanId(id)
+    providerIds.add(`${cleanedId}?${TSS_SERVERFN_SPLIT_PARAM}`)
+  }
+
+  return providerIds
+}
+
+function invalidateModuleNodes(
+  environment: {
+    moduleGraph: {
+      invalidateModule: (
+        mod: EnvironmentModuleNode,
+        seen?: Set<EnvironmentModuleNode>,
+      ) => void
+    }
+  },
+  modules: Iterable<EnvironmentModuleNode>,
+) {
+  const seen = new Set<EnvironmentModuleNode>()
+
+  for (const mod of modules) {
+    environment.moduleGraph.invalidateModule(mod, seen)
+  }
+}
 
 function getDevServerFnValidatorModule(): string {
   return `
@@ -148,16 +245,23 @@ export function startCompilerPlugin(
                   ? createViteDevServerFnModuleSpecifierEncoder(root)
                   : undefined,
               loadModule: async (id: string) => {
-                await loadModuleForViteCompiler({
-                  compiler: compiler!,
-                  mode: this.environment.mode,
-                  fetchModule:
-                    this.environment.mode === 'dev'
-                      ? this.environment.fetchModule.bind(this.environment)
-                      : undefined,
-                  loadModule: this.load.bind(this),
-                  id,
-                })
+                if (mode === 'build') {
+                  const loaded = await this.load({ id })
+                  const code = loaded.code ?? ''
+
+                  compiler!.ingestModule({ code, id })
+                  return
+                }
+
+                if (this.environment.mode !== 'dev') {
+                  this.error(
+                    `could not load module ${id}: unknown environment mode ${this.environment.mode}`,
+                  )
+                }
+
+                await this.environment.transformRequest(
+                  `${id}?${SERVER_FN_LOOKUP}`,
+                )
               },
 
               resolveId: async (source: string, importer?: string) => {
@@ -190,19 +294,85 @@ export function startCompilerPlugin(
 
       hotUpdate(ctx) {
         const compiler = compilers.get(this.environment.name)
+        const idsToInvalidate = new Set<string>()
+        const transitiveCompilerImportersToInvalidate = new Set<string>()
+        const importerModulesToInvalidate = new Set<EnvironmentModuleNode>()
 
         ctx.modules.forEach((m) => {
           if (m.id) {
+            idsToInvalidate.add(m.id)
             const deleted = compiler?.invalidateModule(m.id)
+
+            if (deleted) {
+              transitiveCompilerImportersToInvalidate.add(cleanId(m.id))
+            }
+
             if (deleted) {
               m.importers.forEach((importer) => {
                 if (importer.id) {
-                  compiler?.invalidateModule(importer.id)
+                  idsToInvalidate.add(importer.id)
+                  importerModulesToInvalidate.add(importer)
+                  transitiveCompilerImportersToInvalidate.add(
+                    cleanId(importer.id),
+                  )
                 }
               })
             }
           }
         })
+
+        const finishHotUpdate = async () => {
+          if (environment.type === 'server' && compiler) {
+            const pendingImporters = [
+              ...transitiveCompilerImportersToInvalidate,
+            ]
+            const seenImporters = new Set(pendingImporters)
+
+            while (pendingImporters.length > 0) {
+              const importerId = pendingImporters.pop()!
+              const nestedImporters =
+                await compiler.getTransitiveImporters(importerId)
+
+              for (const nestedImporterId of nestedImporters) {
+                if (seenImporters.has(nestedImporterId)) {
+                  continue
+                }
+
+                seenImporters.add(nestedImporterId)
+                pendingImporters.push(nestedImporterId)
+              }
+            }
+
+            for (const importerId of seenImporters) {
+              idsToInvalidate.add(importerId)
+              compiler.invalidateModule(importerId)
+            }
+          }
+
+          invalidateModuleNodes(this.environment, importerModulesToInvalidate)
+          invalidateServerFnLookupModules(this.environment, idsToInvalidate)
+
+          if (environment.type !== 'server') {
+            return
+          }
+
+          invalidateModuleNodes(this.environment, ctx.modules)
+
+          const providerIdsToInvalidate =
+            getServerFnProviderIds(idsToInvalidate)
+          for (const providerId of providerIdsToInvalidate) {
+            compiler?.invalidateModule(providerId)
+          }
+
+          const providerModules = invalidateServerFnProviderModules(
+            this.environment,
+            [...idsToInvalidate, ...providerIdsToInvalidate],
+          )
+
+          return mergeHotUpdateModules(ctx.modules, providerModules)
+        }
+
+        return finishHotUpdate()
       },
     }
   }
@@ -267,10 +437,15 @@ export function startCompilerPlugin(
                   // Trigger transform of the source file in this environment,
                   // which will compile createServerFn calls and populate
                   // serverFnsById as a side effect.
-                  // This plugin only runs in dev (apply: 'serve'), so mode
-                  // must be 'dev' — assert to narrow to DevEnvironment.
-                  assert(this.environment.mode === 'dev')
-                  await this.environment.fetchModule(absPath)
+                  if (this.environment.mode !== 'dev') {
+                    this.error(
+                      `could not validate server function ID ${fnId}: unknown environment mode ${this.environment.mode}`,
+                    )
+                  }
+
+                  await this.environment.transformRequest(
+                    `${absPath}?${SERVER_FN_LOOKUP}`,
+                  )
 
                   // Re-check after lazy compilation
                   if (serverFnsById[fnId]) {

package/src/vite/start-manifest-plugin/normalized-client-build.ts

@@ -42,6 +42,8 @@ export function normalizeViteClientBuild(
   const cssFilesBySourcePath = new Map<string, Array<string>>()
 
   for (const chunk of chunksByFileName.values()) {
+    const bundleEntry = clientBundle[chunk.fileName] as Rollup.OutputChunk
+
     if (chunk.isEntry) {
       if (entryChunkFileName) {
         throw new Error(
@@ -60,22 +62,19 @@ export function normalizeViteClientBuild(
       chunkFileNames.push(chunk.fileName)
     }
 
-    const bundleEntry = clientBundle[chunk.fileName]
-    if (bundleEntry?.type === 'chunk') {
-      for (const moduleId of bundleEntry.moduleIds) {
-        const queryIndex = moduleId.indexOf('?')
-        const sourcePath =
-          queryIndex >= 0 ? moduleId.slice(0, queryIndex) : moduleId
-        if (!sourcePath) continue
-
-        const existing = cssFilesBySourcePath.get(sourcePath)
-        cssFilesBySourcePath.set(
-          sourcePath,
-          existing
-            ? Array.from(new Set([...existing, ...chunk.css]))
-            : chunk.css.slice(),
-        )
-      }
+    for (const moduleId of bundleEntry.moduleIds) {
+      const queryIndex = moduleId.indexOf('?')
+      const sourcePath =
+        queryIndex >= 0 ? moduleId.slice(0, queryIndex) : moduleId
+      if (!sourcePath) continue
+
+      const existing = cssFilesBySourcePath.get(sourcePath)
+      cssFilesBySourcePath.set(
+        sourcePath,
+        existing
+          ? Array.from(new Set([...existing, ...chunk.css]))
+          : chunk.css.slice(),
+      )
     }
   }
 

package/src/vite/start-manifest-plugin/plugin.ts

@@ -1,53 +1,136 @@
 import { joinURL } from 'ufo'
 import { VIRTUAL_MODULES } from '@tanstack/start-server-core'
+import { rootRouteId } from '@tanstack/router-core'
 import { ENTRY_POINTS, START_ENVIRONMENT_NAMES } from '../../constants'
 import {
   buildStartManifest,
+  createManifestAssetResolvers,
+  normalizeViteClientBuild,
   serializeStartManifest,
 } from '../../start-manifest-plugin/manifestBuilder'
 import { createVirtualModule } from '../createVirtualModule'
 import type { GetConfigFn, NormalizedClientBuild } from '../../types'
-import type { PluginOption } from 'vite'
+import type { PluginOption, Rollup } from 'vite'
 
 export function startManifestPlugin(opts: {
-  getClientBuild: () => NormalizedClientBuild | undefined
   getConfig: GetConfigFn
 }): PluginOption {
-  return createVirtualModule({
-    name: 'tanstack-start:start-manifest-plugin',
-    moduleId: VIRTUAL_MODULES.startManifest,
-    enforce: 'pre',
-    load() {
-      const { resolvedStartConfig } = opts.getConfig()
-      if (this.environment.name !== START_ENVIRONMENT_NAMES.server) {
-        return 'export default {}'
-      }
-
-      if (this.environment.config.command === 'serve') {
-        return `export const tsrStartManifest = () => ({
-            routes: {},
-            clientEntry: '${joinURL(resolvedStartConfig.basePaths.publicBase, '@id', ENTRY_POINTS.client)}',
-          })`
-      }
-
-      const routeTreeRoutes = globalThis.TSS_ROUTES_MANIFEST
-      const clientBuild = opts.getClientBuild()
-      // TODO this needs further discussion with vite-rsc, this is a temporary workaround
-      // If the client bundle isn't available yet (e.g., during RSC scan builds),
-      // return a dummy manifest. The real manifest will be generated in the actual build.
-      if (!clientBuild) {
-        return `export const tsrStartManifest = () => ({
-              routes: {},
-              clientEntry: '${joinURL(resolvedStartConfig.basePaths.publicBase, '@id', ENTRY_POINTS.client)}',
-              })`
-      }
-      const startManifest = buildStartManifest({
-        clientBuild,
-        routeTreeRoutes,
-        basePath: resolvedStartConfig.basePaths.publicBase,
-      })
-
-      return `export const tsrStartManifest = () => (${serializeStartManifest(startManifest)})`
+  let clientBuild: NormalizedClientBuild | undefined
+  let cssCodeSplitDisabledFileName: string | undefined
+
+  return [
+    {
+      name: 'tanstack-start:start-manifest-capture-client-build',
+      applyToEnvironment(environment) {
+        return environment.name === START_ENVIRONMENT_NAMES.client
+      },
+      enforce: 'post',
+      generateBundle(_options, bundle) {
+        if (this.environment.name !== START_ENVIRONMENT_NAMES.client) {
+          throw new Error(
+            `Unexpected environment for client build capture: ${this.environment.name}`,
+          )
+        }
+
+        clientBuild = normalizeViteClientBuild(bundle)
+        cssCodeSplitDisabledFileName = getAssetFileNameByName(
+          bundle,
+          'style.css',
+        )
+      },
     },
-  })
+    createVirtualModule({
+      name: 'tanstack-start:start-manifest-plugin',
+      moduleId: VIRTUAL_MODULES.startManifest,
+      enforce: 'pre',
+      load() {
+        const { resolvedStartConfig } = opts.getConfig()
+        const clientEntry = joinURL(
+          resolvedStartConfig.basePaths.publicBase,
+          '@id',
+          ENTRY_POINTS.client,
+        )
+
+        if (this.environment.name !== START_ENVIRONMENT_NAMES.server) {
+          return getEmptyStartManifestModule(clientEntry)
+        }
+
+        if (this.environment.config.command === 'serve') {
+          return getEmptyStartManifestModule(clientEntry)
+        }
+
+        const routeTreeRoutes = globalThis.TSS_ROUTES_MANIFEST
+        // TODO this needs further discussion with vite-rsc, this is a temporary workaround
+        // If the client bundle isn't available yet (e.g., during RSC scan builds),
+        // return a dummy manifest. The real manifest will be generated in the actual build.
+        if (!clientBuild) {
+          return getEmptyStartManifestModule(clientEntry)
+        }
+        const startManifest = buildStartManifest({
+          clientBuild,
+          routeTreeRoutes,
+          basePath: resolvedStartConfig.basePaths.publicBase,
+          additionalRouteAssets: getViteAdditionalRouteAssets({
+            cssCodeSplitDisabledFileName,
+            basePath: resolvedStartConfig.basePaths.publicBase,
+            cssCodeSplit: this.environment.config.build.cssCodeSplit,
+          }),
+        })
+
+        return `export const tsrStartManifest = () => (${serializeStartManifest(startManifest)})`
+      },
+    }),
+  ]
+}
+
+function getViteAdditionalRouteAssets(options: {
+  cssCodeSplitDisabledFileName: string | undefined
+  basePath: string
+  cssCodeSplit: boolean | undefined
+}) {
+  if (options.cssCodeSplit !== false) {
+    return undefined
+  }
+
+  if (!options.cssCodeSplitDisabledFileName) {
+    throw new Error(
+      "TanStack Start could not find Vite's generated `style.css` manifest entry while `build.cssCodeSplit` is disabled",
+    )
+  }
+
+  const { getStylesheetAsset } = createManifestAssetResolvers(options.basePath)
+
+  return {
+    [rootRouteId]: [getStylesheetAsset(options.cssCodeSplitDisabledFileName)],
+  }
+}
+
+function getAssetFileNameByName(
+  bundle: Rollup.OutputBundle,
+  assetName: string,
+) {
+  for (const fileName in bundle) {
+    const bundleEntry = bundle[fileName]!
+
+    if (bundleEntry.type !== 'asset') {
+      continue
+    }
+
+    if (bundleEntry.name === assetName) {
+      return fileName
+    }
+
+    if ('names' in bundleEntry && bundleEntry.names.includes(assetName)) {
+      return fileName
+    }
+  }
+
+  return undefined
+}
+
+function getEmptyStartManifestModule(clientEntry: string) {
+  return `export const tsrStartManifest = () => ({
+      routes: {},
+      clientEntry: '${clientEntry}',
+    })`
 }

package/dist/esm/import-protection-plugin/ast.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ast.js","names":[],"sources":["../../../src/import-protection-plugin/ast.ts"],"sourcesContent":["import { parseAst } from '@tanstack/router-utils'\n\nexport type ParsedAst = ReturnType<typeof parseAst>\n\nexport function parseImportProtectionAst(code: string): ParsedAst {\n  return parseAst({ code })\n}\n"],"mappings":";;AAIA,SAAgB,yBAAyB,MAAyB;AAChE,QAAO,SAAS,EAAE,MAAM,CAAC"}

package/dist/esm/import-protection-plugin/constants.d.ts

@@ -1,6 +0,0 @@
-export declare const SERVER_FN_LOOKUP_QUERY = "?server-fn-module-lookup";
-export declare const IMPORT_PROTECTION_DEBUG: boolean;
-export declare const IMPORT_PROTECTION_DEBUG_FILTER: string | undefined;
-export declare const KNOWN_SOURCE_EXTENSIONS: Set<string>;
-/** Vite's browser-visible prefix for virtual modules (replaces `\0`). */
-export declare const VITE_BROWSER_VIRTUAL_PREFIX = "/@id/__x00__";

package/dist/esm/import-protection-plugin/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.js","names":[],"sources":["../../../src/import-protection-plugin/constants.ts"],"sourcesContent":["import { SERVER_FN_LOOKUP } from '../constants'\n\nexport const SERVER_FN_LOOKUP_QUERY = `?${SERVER_FN_LOOKUP}`\n\nexport const IMPORT_PROTECTION_DEBUG =\n  process.env.TSR_IMPORT_PROTECTION_DEBUG === '1' ||\n  process.env.TSR_IMPORT_PROTECTION_DEBUG === 'true'\n\nexport const IMPORT_PROTECTION_DEBUG_FILTER =\n  process.env.TSR_IMPORT_PROTECTION_DEBUG_FILTER\n\nexport const KNOWN_SOURCE_EXTENSIONS = new Set([\n  '.ts',\n  '.tsx',\n  '.mts',\n  '.cts',\n  '.js',\n  '.jsx',\n  '.mjs',\n  '.cjs',\n  '.json',\n])\n\n/** Vite's browser-visible prefix for virtual modules (replaces `\\0`). */\nexport const VITE_BROWSER_VIRTUAL_PREFIX = '/@id/__x00__'\n"],"mappings":";;AAEA,IAAa,yBAAyB,IAAI;AAE1C,IAAa,0BACX,QAAQ,IAAI,gCAAgC,OAC5C,QAAQ,IAAI,gCAAgC;AAE9C,IAAa,iCACX,QAAQ,IAAI;AAEd,IAAa,0BAA0B,IAAI,IAAI;CAC7C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;AAGF,IAAa,8BAA8B"}

package/dist/esm/import-protection-plugin/defaults.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"defaults.js","names":[],"sources":["../../../src/import-protection-plugin/defaults.ts"],"sourcesContent":["import type { ImportProtectionEnvRules } from '../schema'\nimport type { Pattern } from './utils'\n\nexport interface DefaultImportProtectionRules {\n  client: Required<ImportProtectionEnvRules>\n  server: Required<ImportProtectionEnvRules>\n}\n\nconst frameworks = ['react', 'solid', 'vue'] as const\n\n/**\n * Returns the default import protection rules.\n *\n * All three framework variants are always included so that, e.g., a React\n * project also denies `@tanstack/solid-start/server` imports.\n */\nexport function getDefaultImportProtectionRules(): DefaultImportProtectionRules {\n  const clientSpecifiers: Array<Pattern> = frameworks.map(\n    (fw) => `@tanstack/${fw}-start/server`,\n  )\n\n  return {\n    client: {\n      specifiers: clientSpecifiers,\n      files: ['**/*.server.*'],\n      excludeFiles: ['**/node_modules/**'],\n    },\n    server: {\n      specifiers: [],\n      files: ['**/*.client.*'],\n      excludeFiles: ['**/node_modules/**'],\n    },\n  }\n}\n\n/**\n * Marker module specifiers that restrict a file to a specific environment.\n */\nexport function getMarkerSpecifiers(): {\n  serverOnly: Array<string>\n  clientOnly: Array<string>\n} {\n  return {\n    serverOnly: frameworks.map((fw) => `@tanstack/${fw}-start/server-only`),\n    clientOnly: frameworks.map((fw) => `@tanstack/${fw}-start/client-only`),\n  }\n}\n"],"mappings":";AAQA,IAAM,aAAa;CAAC;CAAS;CAAS;CAAM;;;;;;;AAQ5C,SAAgB,kCAAgE;AAK9E,QAAO;EACL,QAAQ;GACN,YANqC,WAAW,KACjD,OAAO,aAAa,GAAG,eACzB;GAKG,OAAO,CAAC,gBAAgB;GACxB,cAAc,CAAC,qBAAqB;GACrC;EACD,QAAQ;GACN,YAAY,EAAE;GACd,OAAO,CAAC,gBAAgB;GACxB,cAAc,CAAC,qBAAqB;GACrC;EACF;;;;;AAMH,SAAgB,sBAGd;AACA,QAAO;EACL,YAAY,WAAW,KAAK,OAAO,aAAa,GAAG,oBAAoB;EACvE,YAAY,WAAW,KAAK,OAAO,aAAa,GAAG,oBAAoB;EACxE"}

package/dist/esm/import-protection-plugin/extensionlessAbsoluteIdResolver.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"extensionlessAbsoluteIdResolver.js","names":[],"sources":["../../../src/import-protection-plugin/extensionlessAbsoluteIdResolver.ts"],"sourcesContent":["import { basename, dirname, extname, isAbsolute } from 'node:path'\nimport { resolveModulePath } from 'exsolve'\n\nimport { KNOWN_SOURCE_EXTENSIONS } from './constants'\nimport { normalizeFilePath } from './utils'\n\nconst FILE_RESOLUTION_EXTENSIONS = [...KNOWN_SOURCE_EXTENSIONS]\n\ntype DepKey = `file:${string}` | `dir:${string}`\n\n/**\n * Canonicalize extensionless absolute IDs like `/src/foo.server` to the\n * physical file when possible.\n *\n * Keeps a small cache plus a reverse index so we can invalidate on HMR\n * updates without clearing the whole map.\n */\nexport class ExtensionlessAbsoluteIdResolver {\n  private entries = new Map<string, { value: string; deps: Set<DepKey> }>()\n  private keysByDep = new Map<DepKey, Set<string>>()\n\n  clear(): void {\n    this.entries.clear()\n    this.keysByDep.clear()\n  }\n\n  /**\n   * Invalidate any cached entries that might be affected by changes to `id`.\n   * We invalidate both the file and its containing directory.\n   */\n  invalidateByFile(id: string): void {\n    const file = normalizeFilePath(id)\n    this.invalidateDep(`file:${file}`)\n    if (isAbsolute(file)) {\n      this.invalidateDep(`dir:${dirname(file)}`)\n    }\n  }\n\n  resolve(id: string): string {\n    const key = normalizeFilePath(id)\n    const cached = this.entries.get(key)\n    if (cached) return cached.value\n\n    let result = key\n    let resolvedPhysical: string | undefined\n\n    if (isAbsolute(key)) {\n      const ext = extname(key)\n      if (!FILE_RESOLUTION_EXTENSIONS.includes(ext)) {\n        const resolved = resolveModulePath(`./${basename(key)}`, {\n          from: dirname(key),\n          extensions: FILE_RESOLUTION_EXTENSIONS,\n          try: true,\n        })\n        if (resolved) {\n          resolvedPhysical = resolved\n          result = normalizeFilePath(resolved)\n        }\n      }\n    }\n\n    const resolvedFile = resolvedPhysical\n      ? normalizeFilePath(resolvedPhysical)\n      : undefined\n\n    const deps = this.buildDepsForKey(key, resolvedFile)\n    this.entries.set(key, { value: result, deps })\n    this.indexDeps(key, deps)\n    return result\n  }\n\n  private invalidateDep(dep: DepKey): void {\n    const keys = this.keysByDep.get(dep)\n    if (!keys) return\n\n    // Copy because deleting keys mutates indexes.\n    for (const key of Array.from(keys)) {\n      this.deleteKey(key)\n    }\n  }\n\n  private buildDepsForKey(key: string, resolvedFile: string | undefined) {\n    const deps = new Set<DepKey>()\n    deps.add(`file:${key}`)\n\n    if (isAbsolute(key)) {\n      deps.add(`dir:${dirname(key)}`)\n    }\n    if (resolvedFile) {\n      deps.add(`file:${resolvedFile}`)\n    }\n\n    return deps\n  }\n\n  private indexDeps(key: string, deps: Set<DepKey>): void {\n    for (const dep of deps) {\n      let keys = this.keysByDep.get(dep)\n      if (!keys) {\n        keys = new Set<string>()\n        this.keysByDep.set(dep, keys)\n      }\n      keys.add(key)\n    }\n  }\n\n  private deleteKey(key: string): void {\n    const entry = this.entries.get(key)\n    this.entries.delete(key)\n    if (!entry) return\n\n    for (const dep of entry.deps) {\n      const keys = this.keysByDep.get(dep)\n      if (!keys) continue\n      keys.delete(key)\n      if (keys.size === 0) {\n        this.keysByDep.delete(dep)\n      }\n    }\n  }\n}\n"],"mappings":";;;;;AAMA,IAAM,6BAA6B,CAAC,GAAG,wBAAwB;;;;;;;;AAW/D,IAAa,kCAAb,MAA6C;CAC3C,0BAAkB,IAAI,KAAmD;CACzE,4BAAoB,IAAI,KAA0B;CAElD,QAAc;AACZ,OAAK,QAAQ,OAAO;AACpB,OAAK,UAAU,OAAO;;;;;;CAOxB,iBAAiB,IAAkB;EACjC,MAAM,OAAO,kBAAkB,GAAG;AAClC,OAAK,cAAc,QAAQ,OAAO;AAClC,MAAI,WAAW,KAAK,CAClB,MAAK,cAAc,OAAO,QAAQ,KAAK,GAAG;;CAI9C,QAAQ,IAAoB;EAC1B,MAAM,MAAM,kBAAkB,GAAG;EACjC,MAAM,SAAS,KAAK,QAAQ,IAAI,IAAI;AACpC,MAAI,OAAQ,QAAO,OAAO;EAE1B,IAAI,SAAS;EACb,IAAI;AAEJ,MAAI,WAAW,IAAI,EAAE;GACnB,MAAM,MAAM,QAAQ,IAAI;AACxB,OAAI,CAAC,2BAA2B,SAAS,IAAI,EAAE;IAC7C,MAAM,WAAW,kBAAkB,KAAK,SAAS,IAAI,IAAI;KACvD,MAAM,QAAQ,IAAI;KAClB,YAAY;KACZ,KAAK;KACN,CAAC;AACF,QAAI,UAAU;AACZ,wBAAmB;AACnB,cAAS,kBAAkB,SAAS;;;;EAK1C,MAAM,eAAe,mBACjB,kBAAkB,iBAAiB,GACnC,KAAA;EAEJ,MAAM,OAAO,KAAK,gBAAgB,KAAK,aAAa;AACpD,OAAK,QAAQ,IAAI,KAAK;GAAE,OAAO;GAAQ;GAAM,CAAC;AAC9C,OAAK,UAAU,KAAK,KAAK;AACzB,SAAO;;CAGT,cAAsB,KAAmB;EACvC,MAAM,OAAO,KAAK,UAAU,IAAI,IAAI;AACpC,MAAI,CAAC,KAAM;AAGX,OAAK,MAAM,OAAO,MAAM,KAAK,KAAK,CAChC,MAAK,UAAU,IAAI;;CAIvB,gBAAwB,KAAa,cAAkC;EACrE,MAAM,uBAAO,IAAI,KAAa;AAC9B,OAAK,IAAI,QAAQ,MAAM;AAEvB,MAAI,WAAW,IAAI,CACjB,MAAK,IAAI,OAAO,QAAQ,IAAI,GAAG;AAEjC,MAAI,aACF,MAAK,IAAI,QAAQ,eAAe;AAGlC,SAAO;;CAGT,UAAkB,KAAa,MAAyB;AACtD,OAAK,MAAM,OAAO,MAAM;GACtB,IAAI,OAAO,KAAK,UAAU,IAAI,IAAI;AAClC,OAAI,CAAC,MAAM;AACT,2BAAO,IAAI,KAAa;AACxB,SAAK,UAAU,IAAI,KAAK,KAAK;;AAE/B,QAAK,IAAI,IAAI;;;CAIjB,UAAkB,KAAmB;EACnC,MAAM,QAAQ,KAAK,QAAQ,IAAI,IAAI;AACnC,OAAK,QAAQ,OAAO,IAAI;AACxB,MAAI,CAAC,MAAO;AAEZ,OAAK,MAAM,OAAO,MAAM,MAAM;GAC5B,MAAM,OAAO,KAAK,UAAU,IAAI,IAAI;AACpC,OAAI,CAAC,KAAM;AACX,QAAK,OAAO,IAAI;AAChB,OAAI,KAAK,SAAS,EAChB,MAAK,UAAU,OAAO,IAAI"}

package/dist/esm/import-protection-plugin/matchers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"matchers.js","names":[],"sources":["../../../src/import-protection-plugin/matchers.ts"],"sourcesContent":["import picomatch from 'picomatch'\n\nimport type { Pattern } from './utils'\n\nexport interface CompiledMatcher {\n  pattern: Pattern\n  test: (value: string) => boolean\n}\n\n/**\n * Compile a Pattern (string glob or RegExp) into a fast test function.\n * String patterns use picomatch for full glob support (**, *, ?, braces, etc.).\n * RegExp patterns are used as-is.\n */\nexport function compileMatcher(pattern: Pattern): CompiledMatcher {\n  if (pattern instanceof RegExp) {\n    // RegExp with `g` or `y` flags are stateful because `.test()` mutates\n    // `lastIndex`. Reset it to keep matcher evaluation deterministic.\n    return {\n      pattern,\n      test: (value: string) => {\n        pattern.lastIndex = 0\n        return pattern.test(value)\n      },\n    }\n  }\n\n  const isMatch = picomatch(pattern, { dot: true })\n  return { pattern, test: isMatch }\n}\n\nexport function compileMatchers(\n  patterns: Array<Pattern>,\n): Array<CompiledMatcher> {\n  return patterns.map(compileMatcher)\n}\n\nexport function matchesAny(\n  value: string,\n  matchers: Array<CompiledMatcher>,\n): CompiledMatcher | undefined {\n  for (const matcher of matchers) {\n    if (matcher.test(value)) {\n      return matcher\n    }\n  }\n  return undefined\n}\n"],"mappings":";;;;;;;AAcA,SAAgB,eAAe,SAAmC;AAChE,KAAI,mBAAmB,OAGrB,QAAO;EACL;EACA,OAAO,UAAkB;AACvB,WAAQ,YAAY;AACpB,UAAO,QAAQ,KAAK,MAAM;;EAE7B;AAIH,QAAO;EAAE;EAAS,MADF,UAAU,SAAS,EAAE,KAAK,MAAM,CAAC;EAChB;;AAGnC,SAAgB,gBACd,UACwB;AACxB,QAAO,SAAS,IAAI,eAAe;;AAGrC,SAAgB,WACd,OACA,UAC6B;AAC7B,MAAK,MAAM,WAAW,SACpB,KAAI,QAAQ,KAAK,MAAM,CACrB,QAAO"}