@jk2908/cxx 0.2.6 → 0.3.1

package/dist/next/index.d.ts

@@ -1,30 +1,41 @@
 import type { NextConfig } from 'next';
 import type { Logger } from '../logger.js';
-import type { PluginConfig, Tags } from '../types.js';
+import type { PluginConfig } from '../types.js';
 /**
- * Transform one module and, in development, register it with the shared watcher state
+ * Transform one module and, in development, register it with the shared watcher state.
  */
 export declare function processFile(source: string, filePath: string, pluginConfig: PluginConfig, logger: Logger): {
     source: string;
+    config: string;
     template: string;
-    tags: Tags;
-} | {
-    template: string;
-    tags: Tags;
+    tags: import("../types.js").Tags;
+    map: import("magic-string").SourceMap | null;
 };
-export declare function withCxx(nextConfig?: NextConfig, pluginConfig?: PluginConfig): Promise<{
+export declare function withCxx(nextConfig?: NextConfig, pluginConfig?: PluginConfig): {
     turbopack: {
         rules: {
             "*.{tsx,jsx,ts,js}": ({
                 loader: string;
                 options: {
-                    pluginConfig: PluginConfig;
+                    pluginConfig: {
+                        watch: {
+                            root: string;
+                            ignore?: string[];
+                        };
+                        typeSuffix?: string | false;
+                    };
                 };
             } | import("next/dist/server/config-shared.js").TurbopackRuleConfigItem | import("next/dist/server/config-shared.js").TurbopackLoaderItem)[] | {
                 loaders: ({
                     loader: string;
                     options: {
-                        pluginConfig: PluginConfig;
+                        pluginConfig: {
+                            watch: {
+                                root: string;
+                                ignore?: string[];
+                            };
+                            typeSuffix?: string | false;
+                        };
                     };
                 } | import("next/dist/server/config-shared.js").TurbopackLoaderItem)[];
                 as?: string;
@@ -41,6 +52,12 @@ export declare function withCxx(nextConfig?: NextConfig, pluginConfig?: PluginCo
             title?: string | RegExp;
             description?: string | RegExp;
         }>;
+        chunkLoadingGlobal?: string;
+    };
+    webpack(config: unknown, context: unknown): {
+        module?: {
+            rules?: unknown[];
+        };
     };
     allowedDevOrigins?: string[];
     exportPathMap?: (defaultMap: import("next/dist/server/config-shared.js").ExportPathMap, ctx: {
@@ -65,7 +82,6 @@ export declare function withCxx(nextConfig?: NextConfig, pluginConfig?: PluginCo
     };
     redirects?: () => Promise<import("next/dist/lib/load-custom-routes.js").Redirect[]> | import("next/dist/lib/load-custom-routes.js").Redirect[];
     excludeDefaultMomentLocales?: boolean;
-    webpack?: import("next/dist/server/config-shared.js").NextJsWebpackConfig | null;
     trailingSlash?: boolean;
     env?: Record<string, string | undefined>;
     distDir?: string;
@@ -84,6 +100,7 @@ export declare function withCxx(nextConfig?: NextConfig, pluginConfig?: PluginCo
     generateBuildId?: () => string | null | Promise<string | null>;
     generateEtags?: boolean;
     pageExtensions?: string[];
+    instrumentationClientInject?: string[];
     compress?: boolean;
     poweredByHeader?: boolean;
     images?: import("next/dist/shared/lib/image-config.js").ImageConfig;
@@ -95,6 +112,7 @@ export declare function withCxx(nextConfig?: NextConfig, pluginConfig?: PluginCo
         pagesBufferLength?: number;
     };
     deploymentId?: string;
+    supportsImmutableAssets?: boolean;
     basePath?: string;
     sassOptions?: {
         implementation?: string;
@@ -148,6 +166,7 @@ export declare function withCxx(nextConfig?: NextConfig, pluginConfig?: PluginCo
     logging?: import("next/dist/server/config-shared.js").LoggingConfig | false;
     enablePrerenderSourceMaps?: boolean;
     cacheComponents?: boolean;
+    partialPrefetching?: boolean | "unstable_eager";
     cacheLife?: {
         [profile: string]: {
             stale?: number;
@@ -156,15 +175,17 @@ export declare function withCxx(nextConfig?: NextConfig, pluginConfig?: PluginCo
         };
     };
     expireTime?: number;
+    agentRules?: boolean;
     experimental?: import("next/dist/server/config-shared.js").ExperimentalConfig;
     bundlePagesRouterDependencies?: boolean;
     serverExternalPackages?: string[];
     outputFileTracingRoot?: string;
     outputFileTracingExcludes?: Record<string, string[]>;
     outputFileTracingIncludes?: Record<string, string[]>;
+    outputHashSalt?: string;
     watchOptions?: {
         pollIntervalMs?: number;
     };
     htmlLimitedBots?: RegExp;
-}>;
+};
 //# sourceMappingURL=index.d.ts.map

package/dist/next/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/next/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,MAAM,CAAA;AAQtC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AA2DrD;;GAEG;AACH,wBAAgB,WAAW,CAC1B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,MAAM;;;;;;;EA8Cd;AAwBD,wBAAsB,OAAO,CAC5B,UAAU,GAAE,UAAe,EAC3B,YAAY,GAAE,YAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+Bk2E,CAAC;uBAAsC,CAAC;;;;;;;;;;;;;;;;mBAAsn5B,CAAC;kBAA+B,CAAC;gBAA6B,CAAC;;mBAAuD,CAAC;kBAA+B,CAAC;gBAA6B,CAAC;;;;;;;;;;;;;eAA8lF,CAAC;cAAwB,CAAC;cAAwB,CAAC;;;;;;;;;;;;gBAAo9D,CAAC;;;sBAAie,CAAC;yBAA4H,CAAC;;;;;sBAAkiB,CAAC;;;;;;;;;iBAA4+C,CAAC;;;;;6BAA+sB,CAAC;sBAAoC,CAAC;;aAAoC,CAAC;;6BAA0D,CAAC;oBAA8B,CAAC;0BAAkE,CAAC;;qBAA2C,CAAC;mBAAiC,CAAC;;wBAA+C,CAAC;eAAmD,CAAC;iBAA4C,CAAC;2BAAyC,CAAC;;cAA6L,CAAC;oBAAyP,CAAC;iCAA8S,CAAC;;;;;;;;;;;;yBAAm0D,CAAC;6BAAwC,CAAC;;;;;;;iBAAowB,CAAC;sBAAgC,CAAC;kBAA4B,CAAC;;;;;;;;;;;sBAA21C,CAAC;;;GAD514C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/next/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,MAAM,CAAA;AAMtC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAqI/C;;GAEG;AACH,wBAAgB,WAAW,CAC1B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,MAAM;;;;;;EAgBd;AAID,wBAAgB,OAAO,CAAC,UAAU,GAAE,UAAe,EAAE,YAAY,GAAE,YAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsDkpE,CAAC;uBAAsC,CAAC;;;;oBApB5vE,OAAO,WAAW,OAAO;iBAI9B;YAAE,KAAK,CAAC,EAAE,OAAO,EAAE,CAAA;SAAE;;;;;;;;;;;;;;;mBAgBg05C,CAAC;kBAA+B,CAAC;gBAA6B,CAAC;;mBAAuD,CAAC;kBAA+B,CAAC;gBAA6B,CAAC;;;;;;;;;;;;eAA8lF,CAAC;cAAwB,CAAC;cAAwB,CAAC;;;;;;;;;;;;;gBAAkxE,CAAC;;;sBAAie,CAAC;yBAA4H,CAAC;;;;;;sBAAuyB,CAAC;;;;;;;;;iBAA4+C,CAAC;;;;;6BAA+sB,CAAC;sBAAoC,CAAC;;aAAoC,CAAC;;6BAA0D,CAAC;oBAA8B,CAAC;0BAAkE,CAAC;;qBAA2C,CAAC;mBAAiC,CAAC;;wBAA+C,CAAC;eAAmD,CAAC;iBAA4C,CAAC;2BAAyC,CAAC;;cAA6L,CAAC;oBAAyP,CAAC;iCAA8S,CAAC;;;;;;;;;;;;yBAAm0D,CAAC;6BAAwC,CAAC;;;;;;;;iBAAgxD,CAAC;sBAAgC,CAAC;kBAA4B,CAAC;;;;;;;;;;;;;sBAA+vE,CAAC;;;EADjp5D"}

package/dist/next/index.js

@@ -1,8 +1,12 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
 // src/build.ts
 import { createHash } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { transform } from "lightningcss";
+import MagicString from "magic-string";
 
 // src/config.ts
 var NAME = "cxx";
@@ -52,31 +56,73 @@ function capitalise(str) {
 function pascalise(str) {
   return str.split(/[ _-]+/).map(capitalise).join("");
 }
-function debounce(fn, wait) {
-  let timeoutId = null;
-  return (...args) => {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
+function createBatcher(wait, flush) {
+  const pending = new Map;
+  let timer = null;
+  let running = false;
+  async function drain() {
+    if (running)
+      return;
+    running = true;
+    try {
+      while (pending.size > 0) {
+        const batch = new Map(pending);
+        pending.clear();
+        await flush(batch);
+      }
+    } finally {
+      running = false;
     }
-    timeoutId = setTimeout(() => {
-      fn.apply(null, args);
+  }
+  function schedule() {
+    if (timer)
+      clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = null;
+      drain();
     }, wait);
+  }
+  return {
+    add(key, value) {
+      pending.set(key, value);
+      schedule();
+    },
+    flush() {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      return drain();
+    }
   };
 }
 
 // src/build.ts
+var decoder = new TextDecoder;
 var collectCache = new LruCache;
 var fileCache = new LruCache;
+var writeChain = Promise.resolve();
 function isENOENT(err) {
   return err instanceof Error && "code" in err && err.code === "ENOENT";
 }
+async function writeFileAtomic(filePath, content) {
+  const tmp = `${filePath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await fs.writeFile(tmp, content);
+  await fs.rename(tmp, filePath);
+}
+function enqueueWrite(task) {
+  const run = writeChain.then(task, task);
+  writeChain = run.then(() => {
+    return;
+  }, () => {
+    return;
+  });
+  return run;
+}
 async function maybeWrite(filePath, content) {
   const cached = fileCache.get(filePath);
-  if (cached !== content) {
-    await fs.writeFile(filePath, content);
-    fileCache.set(filePath, content);
-    return true;
-  }
+  if (cached === content)
+    return false;
   try {
     if (await fs.readFile(filePath, "utf-8") === content) {
       fileCache.set(filePath, content);
@@ -86,11 +132,12 @@ async function maybeWrite(filePath, content) {
     if (!isENOENT(err))
       throw err;
   }
-  await fs.writeFile(filePath, content);
+  await writeFileAtomic(filePath, content);
   fileCache.set(filePath, content);
   return true;
 }
-var regex = /(?:const|var|let)\s*\[(\w+|)\s*,?\s*(\w+|)\s*,?\s*(\w+|)\s*\]\s*=\s*cxx(?:\s*`([\s\S]*?)`|\s*\.\s*tag(?:\s*<[^>]+>)?\s*\(\s*(['"])(.*?)\5\s*\)\s*`([\s\S]*?)`)/gm;
+var regex = /((?:export\s+)?)(?:const|var|let)\s*\[(\w*)\s*,?\s*(\w*)\s*,?\s*(\w*)\s*\]\s*=\s*cxx(?:\s*`([\s\S]*?)`|\s*\.\s*tag(?:\s*<[^>]+>)?\s*\(\s*(['"])(.*?)\6\s*\)\s*`([\s\S]*?)`)/gm;
+var IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 function hashCss(code) {
   return `cxx-${createHash("sha256").update(code).digest("base64url").slice(0, 12)}`;
 }
@@ -101,12 +148,26 @@ class DuplicateTagError extends Error {
     super(`Tag ${tag} has already been seen. Tags must be unique across your application`);
   }
 }
+
+class InvalidTagError extends Error {
+  name = "InvalidTagError";
+  constructor(tag) {
+    super(`Tag "${tag}" does not map to a valid TypeScript identifier. ` + `Use letters, numbers, spaces, "_" or "-"`);
+  }
+}
 function collect(source, id, config) {
-  const tags = new Map;
+  const configKey = JSON.stringify(config);
   const cached = collectCache.get(id);
-  if (cached?.source === source)
+  if (cached?.source === source && cached.config === configKey)
     return cached;
-  const template = source.replace(regex, (_match, varOne, varTwo, varThree, plainCss, _quote, tag, taggedCss) => {
+  const tags = new Map;
+  const magic = new MagicString(source);
+  let matched = false;
+  regex.lastIndex = 0;
+  let match;
+  while (match = regex.exec(source)) {
+    matched = true;
+    const [, exp, varOne, varTwo, varThree, plainCss, , tag, taggedCss] = match;
     const css = plainCss ?? taggedCss;
     const { code, exports = {} } = transform({
       minify: true,
@@ -119,49 +180,112 @@ function collect(source, id, config) {
     if (tag) {
       const suffix = typeof config.typeSuffix === "string" ? config.typeSuffix : config.typeSuffix === false ? "" : "Classes";
       const tagWithSuffix = pascalise(`${tag}${suffix}`);
+      if (!IDENTIFIER.test(tagWithSuffix))
+        throw new InvalidTagError(tag);
       if (tags.has(tagWithSuffix))
         throw new DuplicateTagError(tagWithSuffix);
       tags.set(tagWithSuffix, Object.keys(styles));
     }
-    return [
-      varOne && `const ${varOne} = \`${code}\``,
-      varTwo && `const ${varTwo} = ${JSON.stringify(styles)}`,
-      varThree && `const ${varThree} = \`${href}\``
-    ].filter(Boolean).join(`
+    const statements = [];
+    if (varOne) {
+      statements.push(`${exp}const ${varOne} = ${JSON.stringify(decoder.decode(code))}`);
+    }
+    if (varTwo) {
+      statements.push(`${exp}const ${varTwo} = ${JSON.stringify(styles)}`);
+    }
+    if (varThree) {
+      statements.push(`${exp}const ${varThree} = ${JSON.stringify(href)}`);
+    }
+    magic.overwrite(match.index, match.index + match[0].length, statements.join(`
+`));
+  }
+  const template = magic.toString();
+  const map = matched ? magic.generateMap({ source: id, includeContent: true, hires: true }) : null;
+  const result = { source, config: configKey, template, tags, map };
+  collectCache.set(id, result);
+  return result;
+}
+function renderTypes(tags) {
+  return [
+    AUTOGEN_MSG,
+    "",
+    `import '${PKG_NAME}'`,
+    "",
+    `declare module '${PKG_NAME}' {`,
+    tagsToType(tags),
+    "}",
+    ""
+  ].join(`
 `);
-  });
-  collectCache.set(id, { source, template, tags });
-  return {
-    template,
-    tags
-  };
 }
-async function writeTypes(tags) {
+async function writeRenderedTypes(tags) {
   const filePath = path.join(GENERATED_DIR, "index.d.ts");
   if (!tags.size) {
-    try {
-      await fs.rm(filePath, { force: true });
-      fileCache.delete(filePath);
-    } catch (err) {
-      if (!isENOENT(err))
-        throw err;
-    }
+    await fs.rm(filePath, { force: true });
+    fileCache.delete(filePath);
     return;
   }
   await fs.mkdir(GENERATED_DIR, { recursive: true });
-  await maybeWrite(filePath, `${AUTOGEN_MSG}
-
-			import '${PKG_NAME}'
-
-			declare module '${PKG_NAME}' {
-				${tagsToType(tags)}
-			}
-		`);
+  await maybeWrite(filePath, renderTypes(tags));
+}
+function writeTypes(tags) {
+  return enqueueWrite(() => writeRenderedTypes(tags));
+}
+var PARTIAL_DIR = path.join(GENERATED_DIR, "tags");
+function partialPath(filePath) {
+  return path.join(PARTIAL_DIR, `${createHash("sha1").update(filePath).digest("hex")}.json`);
+}
+async function readPartials() {
+  let entries;
+  try {
+    entries = await fs.readdir(PARTIAL_DIR);
+  } catch (err) {
+    if (isENOENT(err))
+      return new Map;
+    throw err;
+  }
+  const tags = new Map;
+  for (const entry of entries) {
+    if (!entry.endsWith(".json"))
+      continue;
+    const partial = path.join(PARTIAL_DIR, entry);
+    let parsed;
+    try {
+      parsed = JSON.parse(await fs.readFile(partial, "utf-8"));
+    } catch {
+      continue;
+    }
+    try {
+      await fs.access(parsed.file);
+    } catch {
+      await fs.rm(partial, { force: true });
+      continue;
+    }
+    for (const [name, classes] of Object.entries(parsed.tags)) {
+      if (tags.has(name))
+        throw new DuplicateTagError(name);
+      tags.set(name, classes);
+    }
+  }
+  return tags;
+}
+function writeTypesForFile(filePath, tags) {
+  return enqueueWrite(async () => {
+    await fs.mkdir(PARTIAL_DIR, { recursive: true });
+    const partial = partialPath(filePath);
+    if (!tags.size) {
+      await fs.rm(partial, { force: true });
+    } else {
+      await writeFileAtomic(partial, JSON.stringify({ file: filePath, tags: Object.fromEntries(tags) }));
+    }
+    await writeRenderedTypes(await readPartials());
+  });
 }
 function tagsToType(tags) {
-  return [...tags].map(([tag, classes]) => `
-		export type ${tag} = ${classes.length > 0 ? classes.toSorted((a, b) => a.length - b.length).map((c) => `'${c}'`).join(" | ") : "never"}
-	`).join(`
+  return [...tags].map(([tag, classes]) => {
+    const union = classes.length > 0 ? classes.toSorted((a, b) => a.length - b.length).map((c) => `'${c}'`).join(" | ") : "never";
+    return `	export type ${tag} = ${union}`;
+  }).join(`
 `);
 }
 function flattenTags(tagsByFile) {
@@ -180,106 +304,119 @@ function flattenTags(tagsByFile) {
 import fs2 from "node:fs/promises";
 import path2 from "node:path";
 import { fileURLToPath } from "node:url";
-import watcher from "@parcel/watcher";
 var nextDir = path2.dirname(fileURLToPath(import.meta.url));
 var loader = path2.join(nextDir, "cxx-loader.cjs");
-var tagsByFile = new Map;
 var watchedFiles = new Map;
-var subscriptionsByDir = new Map;
-async function rebuildFile(filePath, event) {
-  const watchedFile = watchedFiles.get(filePath);
-  if (!watchedFile)
+var subscription = null;
+var subscriptionPromise = null;
+var cleanupRegistered = false;
+var watcherLogger = null;
+var DEFAULT_IGNORE = [
+  "**/node_modules/**",
+  "**/.next/**",
+  `**/${GENERATED_DIR}/**`,
+  "**/.git/**"
+];
+async function onEvent(event, filePath) {
+  const watched = watchedFiles.get(filePath);
+  if (!watched)
     return;
-  const { pluginConfig, logger } = watchedFile;
-  const hadTags = tagsByFile.has(filePath);
+  const { pluginConfig, logger } = watched;
   if (event === "delete") {
-    tagsByFile.delete(filePath);
-    if (!hadTags)
-      return;
-    await writeTypes(flattenTags(tagsByFile));
+    await writeTypesForFile(filePath, new Map);
     logger.info(`updated types from ${filePath}`);
     return;
   }
+  let source;
   try {
-    const source = await fs2.readFile(filePath, "utf-8");
-    const { tags } = collect(source, filePath, pluginConfig);
-    const hasTags = tags.size > 0;
-    if (hasTags) {
-      tagsByFile.set(filePath, tags);
-    } else {
-      tagsByFile.delete(filePath);
-    }
-    if (!hadTags && !hasTags)
-      return;
-    await writeTypes(flattenTags(tagsByFile));
-    logger.info(`updated types from ${filePath}`);
+    source = await fs2.readFile(filePath, "utf-8");
   } catch (err) {
     if (!isENOENT(err))
       throw err;
-    if (!hadTags)
-      return;
-    tagsByFile.delete(filePath);
-    await writeTypes(flattenTags(tagsByFile));
+    await writeTypesForFile(filePath, new Map);
     logger.info(`updated types from ${filePath}`);
+    return;
   }
+  const { tags } = collect(source, filePath, pluginConfig);
+  await writeTypesForFile(filePath, tags);
+  logger.info(`updated types from ${filePath}`);
+}
+function ensureWatcher(pluginConfig, logger) {
+  watcherLogger = logger;
+  if (subscriptionPromise)
+    return;
+  const root = pluginConfig.watch?.root ?? process.cwd();
+  const ignore = [...DEFAULT_IGNORE, ...pluginConfig.watch?.ignore ?? []];
+  subscriptionPromise = (async () => {
+    const { subscribe } = await import("@parcel/watcher");
+    subscription = await subscribe(root, (watchErr, events) => {
+      if (watchErr) {
+        watcherLogger?.error(`failed to watch ${root}`, watchErr);
+        return;
+      }
+      for (const event of events) {
+        const filePath = path2.resolve(event.path);
+        if (!watchedFiles.has(filePath))
+          continue;
+        onEvent(event.type, filePath).catch((err) => {
+          watcherLogger?.error(`failed to update types from ${filePath}`, err);
+        });
+      }
+    }, { ignore });
+    registerCleanup();
+  })().catch((err) => {
+    watcherLogger?.error("failed to start cxx watcher", err);
+    subscriptionPromise = null;
+  });
+}
+async function cleanup() {
+  const active = subscription;
+  subscription = null;
+  subscriptionPromise = null;
+  watchedFiles.clear();
+  if (active)
+    await active.unsubscribe();
+}
+async function shutdown(signal) {
+  try {
+    await cleanup();
+  } finally {
+    process.kill(process.pid, signal);
+  }
+}
+function registerCleanup() {
+  if (cleanupRegistered)
+    return;
+  cleanupRegistered = true;
+  process.once("SIGINT", () => void shutdown("SIGINT"));
+  process.once("SIGTERM", () => void shutdown("SIGTERM"));
 }
 function processFile(source, filePath, pluginConfig, logger) {
   const resolvedFilePath = path2.resolve(filePath);
-  const directoryPath = path2.dirname(resolvedFilePath);
-  let subscription = subscriptionsByDir.get(directoryPath);
-  if (true) {
+  if (process.env["NODE_ENV"] !== "production") {
     watchedFiles.set(resolvedFilePath, { pluginConfig, logger });
-    if (!subscription) {
-      subscription = watcher.subscribe(directoryPath, async (err, events) => {
-        if (err) {
-          logger.error(`failed to update types from ${directoryPath}`, err);
-          return;
-        }
-        for (const event of events) {
-          const eventFilePath = path2.resolve(event.path);
-          if (!watchedFiles.has(eventFilePath))
-            continue;
-          try {
-            await rebuildFile(eventFilePath, event.type);
-          } catch (watchErr) {
-            logger.error(`failed to update types from ${eventFilePath}`, watchErr);
-          }
-        }
-      });
-      subscriptionsByDir.set(directoryPath, subscription);
-    }
-  }
-  const result = collect(source, filePath, pluginConfig);
-  if (result.tags.size > 0) {
-    tagsByFile.set(filePath, result.tags);
-  } else {
-    tagsByFile.delete(filePath);
+    ensureWatcher(pluginConfig, logger);
   }
-  writeTypes(flattenTags(tagsByFile));
+  const result = collect(source, resolvedFilePath, pluginConfig);
+  writeTypesForFile(resolvedFilePath, result.tags).catch((err) => {
+    logger.error(`failed to write types for ${resolvedFilePath}`, err);
+  });
   return result;
 }
-async function cleanup() {
-  await Promise.all([...subscriptionsByDir].map(async ([directoryPath, subPromise]) => {
-    subscriptionsByDir.delete(directoryPath);
-    await (await subPromise).unsubscribe();
-  }));
-  subscriptionsByDir.clear();
-}
-process.once("SIGINT", () => {
-  cleanup().finally(() => process.exit(130));
-});
-process.once("SIGTERM", () => {
-  cleanup().finally(() => process.exit(143));
-});
-async function withCxx(nextConfig = {}, pluginConfig = {}) {
-  const TURBOPACK_GLOB = "*.{tsx,jsx,ts,js}";
+var TURBOPACK_GLOB = "*.{tsx,jsx,ts,js}";
+function withCxx(nextConfig = {}, pluginConfig = {}) {
+  const watchRoot = pluginConfig.watch?.root ?? nextConfig.turbopack?.root ?? process.cwd();
   const loaderItem = {
     loader,
     options: {
-      pluginConfig
+      pluginConfig: {
+        ...pluginConfig,
+        watch: { ...pluginConfig.watch, root: watchRoot }
+      }
     }
   };
   const currentRule = nextConfig.turbopack?.rules?.[TURBOPACK_GLOB];
+  const userWebpack = nextConfig.webpack;
   return {
     ...nextConfig,
     turbopack: {
@@ -291,12 +428,24 @@ async function withCxx(nextConfig = {}, pluginConfig = {}) {
           loaders: [...currentRule.loaders ?? [], loaderItem]
         } : { loaders: [loaderItem] }
       }
+    },
+    webpack(config, context) {
+      const next = userWebpack ? userWebpack(config, context) : config;
+      next.module ??= {};
+      next.module.rules ??= [];
+      next.module.rules.push({
+        test: /\.[jt]sx?$/,
+        exclude: /node_modules/,
+        enforce: "pre",
+        use: [loaderItem]
+      });
+      return next;
     }
   };
 }
 export {
-  withCxx,
-  processFile
+  processFile,
+  withCxx
 };
 
-//# debugId=B9F61A8763996E6064756E2164756E21
+//# debugId=A4FD970DD20B088B64756E2164756E21