devflare 1.0.0-next.14 → 1.0.0-next.16

package/dist/{index-001mw014.js → index-9fbtk7gv.js}

@@ -9,9 +9,13 @@ import {
   __require
 } from "./index-37x76zdn.js";
 
-// src/bundler/worker-bundler.ts
-import { fileURLToPath } from "node:url";
-import { dirname, resolve } from "pathe";
+// src/bundler/do-bundler.ts
+import { resolve as resolve2, dirname, relative } from "pathe";
+import picomatch from "picomatch";
+
+// src/bundler/rolldown-shared.ts
+import { existsSync } from "node:fs";
+import { resolve } from "pathe";
 
 // src/bundler/worker-compat.ts
 import MagicString from "magic-string";
@@ -315,7 +319,31 @@ function createWorkerDynamicImportPlugin() {
   };
 }
 
-// src/bundler/worker-bundler.ts
+// src/bundler/rolldown-shared.ts
+var DEFAULT_EXTERNAL_MODULES = [
+  /^cloudflare:/,
+  /^node:/,
+  "buffer",
+  "crypto",
+  "events",
+  "http",
+  "https",
+  "net",
+  "os",
+  "path",
+  "stream",
+  "tls",
+  "url",
+  "util",
+  "zlib",
+  "fs",
+  "child_process",
+  "async_hooks",
+  "querystring",
+  "string_decoder",
+  "assert",
+  "dns"
+];
 function toArray(value) {
   return Array.isArray(value) ? value : [value];
 }
@@ -374,6 +402,16 @@ function mergeResolveOptions(base, user) {
     }
   };
 }
+function resolveTsconfigOption(options) {
+  if (options.userTsconfig) {
+    return { tsconfig: options.userTsconfig };
+  }
+  const defaultTsconfigPath = resolve(options.cwd, "tsconfig.json");
+  if (options.defaultMode === "always" || existsSync(defaultTsconfigPath)) {
+    return { tsconfig: defaultTsconfigPath };
+  }
+  return {};
+}
 async function ensureDebugShim(outDir) {
   const fs = await import("node:fs/promises");
   const debugShimCode = `
@@ -395,43 +433,13 @@ export default createDebug
   await fs.writeFile(debugShimPath, debugShimCode, "utf-8");
   return debugShimPath;
 }
-async function resolveInternalModuleEntry(relativeCandidates) {
-  const fs = await import("node:fs/promises");
-  const currentFileDir = dirname(fileURLToPath(import.meta.url));
-  for (const candidate of relativeCandidates) {
-    const absolutePath = resolve(currentFileDir, candidate);
-    try {
-      await fs.access(absolutePath);
-      return absolutePath;
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-async function resolveInternalAliasMap(outDir) {
-  const debugShimPath = await ensureDebugShim(outDir);
-  const runtimeEntry = await resolveInternalModuleEntry([
-    "../runtime/index.ts",
-    "../runtime/index.js"
-  ]);
-  const packageEntry = await resolveInternalModuleEntry([
-    "../browser.ts",
-    "../browser.js"
-  ]);
-  return {
-    debug: debugShimPath,
-    ...runtimeEntry ? { "devflare/runtime": runtimeEntry } : {},
-    ...packageEntry ? { devflare: packageEntry } : {}
-  };
-}
-function resolveWorkerRolldownConfig(options) {
+function resolveWorkerCompatibleRolldownConfig(options) {
   const {
     output: userOutputOptions,
     input: _ignoredInput,
     cwd: _ignoredCwd,
     platform: _ignoredPlatform,
-    target: userTarget,
+    target: _ignoredTarget,
     watch: _ignoredWatch,
     external: userExternal,
     plugins: userPlugins,
@@ -447,43 +455,22 @@ function resolveWorkerRolldownConfig(options) {
     inlineDynamicImports: _ignoredInlineDynamicImports,
     ...safeUserOutputOptions
   } = userOutputOptions ?? {};
-  const defaultExternalModules = [
-    /^cloudflare:/,
-    /^node:/,
-    "buffer",
-    "crypto",
-    "events",
-    "http",
-    "https",
-    "net",
-    "os",
-    "path",
-    "stream",
-    "tls",
-    "url",
-    "util",
-    "zlib",
-    "fs",
-    "child_process",
-    "async_hooks",
-    "querystring",
-    "string_decoder",
-    "assert",
-    "dns"
-  ];
   return {
     inputOptions: {
       ...userInputOptions,
       input: options.inputFile,
       cwd: options.cwd,
-      platform: "browser",
-      target: userTarget ?? options.target,
-      tsconfig: userTsconfig ?? resolve(options.cwd, "tsconfig.json"),
-      external: mergeExternalOptions(defaultExternalModules, userExternal),
+      platform: options.platform,
+      ...resolveTsconfigOption({
+        cwd: options.cwd,
+        userTsconfig,
+        defaultMode: options.defaultTsconfigMode
+      }),
+      external: mergeExternalOptions(DEFAULT_EXTERNAL_MODULES, userExternal),
       plugins: mergePluginOptions(createWorkerDynamicImportPlugin(), userPlugins),
-      resolve: mergeResolveOptions({
+      resolve: mergeResolveOptions(options.alias ? {
         alias: options.alias
-      }, userResolve)
+      } : undefined, userResolve)
     },
     outputOptions: {
       ...safeUserOutputOptions,
@@ -492,42 +479,22 @@ function resolveWorkerRolldownConfig(options) {
       sourcemap: safeUserOutputOptions.sourcemap ?? options.sourcemap ?? false,
       minify: safeUserOutputOptions.minify ?? options.minify,
       codeSplitting: false,
-      inlineDynamicImports: true
+      ...options.inlineDynamicImports !== undefined ? { inlineDynamicImports: options.inlineDynamicImports } : {}
     }
   };
 }
-async function bundleWorkerEntry(options) {
+async function writeWorkerCompatibleBundle(options) {
   const { rolldown } = await import("rolldown");
-  const fs = await import("node:fs/promises");
-  const outDir = dirname(options.outFile);
-  await fs.mkdir(outDir, { recursive: true });
-  await fs.rm(options.outFile, { force: true });
-  await fs.rm(`${options.outFile}.map`, { force: true });
-  const alias = await resolveInternalAliasMap(outDir);
-  const { inputOptions, outputOptions } = resolveWorkerRolldownConfig({
-    cwd: options.cwd,
-    inputFile: options.inputFile,
-    outFile: options.outFile,
-    alias,
-    rolldownOptions: options.rolldownOptions,
-    sourcemap: options.sourcemap,
-    minify: options.minify,
-    target: options.target
-  });
-  options.logger?.debug(`Bundling main worker → ${options.outFile}`);
-  const bundle = await rolldown(inputOptions);
+  const bundle = await rolldown(options.inputOptions);
   try {
-    await bundle.write(outputOptions);
+    await bundle.write(options.outputOptions);
     await assertWorkerBundleHasNoDynamicImports(options.outFile);
   } finally {
     await bundle.close();
   }
-  return options.outFile;
 }
 
 // src/bundler/do-bundler.ts
-import { resolve as resolve2, dirname as dirname2, relative } from "pathe";
-import picomatch from "picomatch";
 function classToBindingName(className) {
   return className.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toUpperCase();
 }
@@ -562,137 +529,7 @@ function stripDecoratorSyntax(code) {
   });
   return result;
 }
-function toArray2(value) {
-  return Array.isArray(value) ? value : [value];
-}
-function matchesExternalPattern2(pattern, id) {
-  if (pattern instanceof RegExp) {
-    pattern.lastIndex = 0;
-    return pattern.test(id);
-  }
-  return pattern === id;
-}
-function matchesExternalOption2(option, id, parentId, isResolved) {
-  if (!option) {
-    return false;
-  }
-  if (typeof option === "function") {
-    return option(id, parentId, isResolved) ?? false;
-  }
-  return toArray2(option).some((pattern) => matchesExternalPattern2(pattern, id));
-}
-function mergeExternalOptions2(base, user) {
-  if (!base) {
-    return user;
-  }
-  if (!user) {
-    return base;
-  }
-  if (typeof base !== "function" && typeof user !== "function") {
-    return [...toArray2(base), ...toArray2(user)];
-  }
-  return (id, parentId, isResolved) => {
-    return matchesExternalOption2(base, id, parentId, isResolved) || matchesExternalOption2(user, id, parentId, isResolved) || false;
-  };
-}
-function mergePluginOptions2(base, user) {
-  if (!base) {
-    return user;
-  }
-  if (!user) {
-    return base;
-  }
-  return [base, user];
-}
-function mergeResolveOptions2(base, user) {
-  if (!base) {
-    return user;
-  }
-  if (!user) {
-    return base;
-  }
-  return {
-    ...user,
-    ...base,
-    alias: {
-      ...user.alias ?? {},
-      ...base.alias ?? {}
-    }
-  };
-}
-function resolveDOBundleRolldownConfig(options) {
-  const {
-    output: userOutputOptions,
-    input: _ignoredInput,
-    cwd: _ignoredCwd,
-    platform: _ignoredPlatform,
-    watch: _ignoredWatch,
-    external: userExternal,
-    plugins: userPlugins,
-    resolve: userResolve,
-    tsconfig: userTsconfig,
-    ...userInputOptions
-  } = options.rolldownOptions ?? {};
-  const {
-    codeSplitting: _ignoredCodeSplitting,
-    dir: _ignoredDir,
-    file: _ignoredFile,
-    format: _ignoredFormat,
-    inlineDynamicImports: _ignoredInlineDynamicImports,
-    ...safeUserOutputOptions
-  } = userOutputOptions ?? {};
-  const defaultExternalModules = [
-    /^cloudflare:/,
-    /^node:/,
-    "buffer",
-    "crypto",
-    "events",
-    "http",
-    "https",
-    "net",
-    "os",
-    "path",
-    "stream",
-    "tls",
-    "url",
-    "util",
-    "zlib",
-    "fs",
-    "child_process",
-    "async_hooks",
-    "querystring",
-    "string_decoder",
-    "assert",
-    "dns"
-  ];
-  return {
-    inputOptions: {
-      ...userInputOptions,
-      input: options.inputFile,
-      cwd: options.cwd,
-      platform: "neutral",
-      tsconfig: userTsconfig ?? resolve2(options.cwd, "tsconfig.json"),
-      external: mergeExternalOptions2(defaultExternalModules, userExternal),
-      plugins: mergePluginOptions2(createWorkerDynamicImportPlugin(), userPlugins),
-      resolve: mergeResolveOptions2({
-        alias: {
-          debug: options.debugShimPath
-        }
-      }, userResolve)
-    },
-    outputOptions: {
-      ...safeUserOutputOptions,
-      file: options.outFile,
-      format: "esm",
-      sourcemap: safeUserOutputOptions.sourcemap ?? options.sourcemap ?? false,
-      minify: safeUserOutputOptions.minify ?? options.minify,
-      codeSplitting: false,
-      inlineDynamicImports: true
-    }
-  };
-}
 async function bundleDOFile(sourcePath, className, outDir, cwd, bundleOptions) {
-  const { rolldown } = await import("rolldown");
   const fs = await import("node:fs/promises");
   await fs.mkdir(outDir, { recursive: true });
   const sourceCode = await fs.readFile(sourcePath, "utf-8");
@@ -706,44 +543,34 @@ export default {
 	}
 };
 `;
-  const tempFilePath = resolve2(dirname2(sourcePath), `.devflare-temp-${className}.ts`);
+  const tempFilePath = resolve2(dirname(sourcePath), `.devflare-temp-${className}.ts`);
   await fs.writeFile(tempFilePath, entryCode, "utf-8");
   const classOutDir = resolve2(outDir, className);
   try {
     await fs.rm(classOutDir, { recursive: true, force: true });
   } catch {}
   await fs.mkdir(classOutDir, { recursive: true });
-  const debugShimCode = `
-// Debug module shim for local development
-const createDebug = (namespace) => {
-	const logger = (...args) => {
-		if (createDebug.enabled) console.debug(\`[\${namespace}]\`, ...args)
-	}
-	logger.enabled = false
-	logger.namespace = namespace
-	logger.extend = (sub) => createDebug(\`\${namespace}:\${sub}\`)
-	return logger
-}
-createDebug.enabled = false
-createDebug.formatters = {}
-export default createDebug
-`;
-  const debugShimPath = resolve2(outDir, "_debug_shim.js");
-  await fs.writeFile(debugShimPath, debugShimCode, "utf-8");
+  const debugShimPath = await ensureDebugShim(outDir);
   const outFile = resolve2(classOutDir, "index.js");
-  const { inputOptions, outputOptions } = resolveDOBundleRolldownConfig({
+  const { inputOptions, outputOptions } = resolveWorkerCompatibleRolldownConfig({
     cwd,
     inputFile: tempFilePath,
     outFile,
-    debugShimPath,
+    platform: "neutral",
+    alias: {
+      debug: debugShimPath
+    },
     rolldownOptions: bundleOptions?.rolldownOptions,
     sourcemap: bundleOptions?.sourcemap,
-    minify: bundleOptions?.minify
+    minify: bundleOptions?.minify,
+    inlineDynamicImports: true,
+    defaultTsconfigMode: "always"
+  });
+  await writeWorkerCompatibleBundle({
+    inputOptions,
+    outputOptions,
+    outFile
   });
-  const bundle = await rolldown(inputOptions);
-  await bundle.write(outputOptions);
-  await assertWorkerBundleHasNoDynamicImports(outFile);
-  await bundle.close();
   try {
     await fs.unlink(tempFilePath);
   } catch {}
@@ -810,9 +637,9 @@ function createDOBundler(options) {
     const files = await findFiles(pattern, { cwd });
     let dirsToWatch;
     if (files.length > 0) {
-      dirsToWatch = [...new Set(files.map((f) => dirname2(f)))];
+      dirsToWatch = [...new Set(files.map((f) => dirname(f)))];
     } else {
-      const patternDir = dirname2(pattern);
+      const patternDir = dirname(pattern);
       const absolutePatternDir = resolve2(cwd, patternDir === "." ? "" : patternDir) || cwd;
       dirsToWatch = [absolutePatternDir];
       logger?.debug(`No DO files yet, watching pattern directory: ${absolutePatternDir}`);
@@ -837,7 +664,6 @@ function createDOBundler(options) {
       return normalized;
     };
     const isMatch = picomatch(pattern, {
-      cwd,
       dot: true,
       matchBase: false
     });
@@ -928,4 +754,64 @@ function createDOBundler(options) {
     getResult
   };
 }
+
+// src/bundler/worker-bundler.ts
+import { fileURLToPath } from "node:url";
+import { dirname as dirname2, resolve as resolve3 } from "pathe";
+async function resolveInternalModuleEntry(relativeCandidates) {
+  const fs = await import("node:fs/promises");
+  const currentFileDir = dirname2(fileURLToPath(import.meta.url));
+  for (const candidate of relativeCandidates) {
+    const absolutePath = resolve3(currentFileDir, candidate);
+    try {
+      await fs.access(absolutePath);
+      return absolutePath;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+async function resolveInternalAliasMap(outDir) {
+  const debugShimPath = await ensureDebugShim(outDir);
+  const runtimeEntry = await resolveInternalModuleEntry([
+    "../runtime/index.ts",
+    "../runtime/index.js"
+  ]);
+  const packageEntry = await resolveInternalModuleEntry([
+    "../browser.ts",
+    "../browser.js"
+  ]);
+  return {
+    debug: debugShimPath,
+    ...runtimeEntry ? { "devflare/runtime": runtimeEntry } : {},
+    ...packageEntry ? { devflare: packageEntry } : {}
+  };
+}
+async function bundleWorkerEntry(options) {
+  const fs = await import("node:fs/promises");
+  const outDir = dirname2(options.outFile);
+  await fs.mkdir(outDir, { recursive: true });
+  await fs.rm(options.outFile, { force: true });
+  await fs.rm(`${options.outFile}.map`, { force: true });
+  const alias = await resolveInternalAliasMap(outDir);
+  const { inputOptions, outputOptions } = resolveWorkerCompatibleRolldownConfig({
+    cwd: options.cwd,
+    inputFile: options.inputFile,
+    outFile: options.outFile,
+    alias,
+    platform: "browser",
+    rolldownOptions: options.rolldownOptions,
+    sourcemap: options.sourcemap,
+    minify: options.minify,
+    defaultTsconfigMode: "if-present"
+  });
+  options.logger?.debug(`Bundling main worker → ${options.outFile}`);
+  await writeWorkerCompatibleBundle({
+    inputOptions,
+    outputOptions,
+    outFile: options.outFile
+  });
+  return options.outFile;
+}
 export { createDOBundler, bundleWorkerEntry };