devflare 1.0.0-next.1 → 1.0.0-next.10

package/dist/index-1p814k7s.js

@@ -0,0 +1,227 @@
+import {
+  findFiles
+} from "./index-rbht7m9r.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/worker-entry/routes.ts
+import { relative, resolve } from "pathe";
+var DEFAULT_ROUTE_DIR = "src/routes";
+var DEFAULT_ROUTE_FILE_PATTERNS = [
+  "**/*.ts",
+  "**/*.tsx",
+  "**/*.js",
+  "**/*.jsx",
+  "**/*.mts",
+  "**/*.mjs"
+];
+function normalizeRoutePrefix(prefix) {
+  if (!prefix || prefix === "/") {
+    return "";
+  }
+  const normalized = prefix.startsWith("/") ? prefix : `/${prefix}`;
+  return normalized.replace(/\/+$/g, "");
+}
+function createStaticSegmentsFromPrefix(prefix) {
+  if (!prefix) {
+    return [];
+  }
+  return prefix.split("/").filter(Boolean).map((value) => ({
+    type: "static",
+    value
+  }));
+}
+function shouldIgnoreRouteFile(relativePath) {
+  return relativePath.split("/").some((segment) => segment.startsWith("_"));
+}
+function toRoutePath(segments) {
+  if (segments.length === 0) {
+    return "/";
+  }
+  return `/${segments.map((segment) => {
+    if (segment.type === "static") {
+      return segment.value;
+    }
+    if (segment.type === "param") {
+      return `[${segment.name}]`;
+    }
+    if (segment.type === "rest") {
+      return `[...${segment.name}]`;
+    }
+    return `[[...${segment.name}]]`;
+  }).join("/")}`;
+}
+function getRouteSignature(segments) {
+  if (segments.length === 0) {
+    return "/";
+  }
+  return segments.map((segment) => {
+    if (segment.type === "static") {
+      return `static:${segment.value}`;
+    }
+    if (segment.type === "param") {
+      return "param";
+    }
+    if (segment.type === "rest") {
+      return "rest";
+    }
+    return "optional-rest";
+  }).join("/");
+}
+function getSegmentPriority(segment) {
+  if (segment.type === "static") {
+    return 4;
+  }
+  if (segment.type === "param") {
+    return 3;
+  }
+  if (segment.type === "rest") {
+    return 1;
+  }
+  return 0;
+}
+function compareRoutes(a, b) {
+  const maxLength = Math.max(a.segments.length, b.segments.length);
+  for (let index = 0;index < maxLength; index += 1) {
+    const left = a.segments[index];
+    const right = b.segments[index];
+    if (!left && !right) {
+      break;
+    }
+    if (!left) {
+      return 1;
+    }
+    if (!right) {
+      return -1;
+    }
+    const priorityDifference = getSegmentPriority(right) - getSegmentPriority(left);
+    if (priorityDifference !== 0) {
+      return priorityDifference;
+    }
+    if (left.type === "static" && right.type === "static") {
+      const lexicalDifference = left.value.localeCompare(right.value);
+      if (lexicalDifference !== 0) {
+        return lexicalDifference;
+      }
+    }
+  }
+  return a.filePath.localeCompare(b.filePath);
+}
+function parseRouteSegments(relativePath, prefixSegments) {
+  const withoutExtension = relativePath.replace(/\.[^.]+$/u, "");
+  const rawSegments = withoutExtension.split("/").filter(Boolean);
+  const routeSegments = [...prefixSegments];
+  for (let index = 0;index < rawSegments.length; index += 1) {
+    const segment = rawSegments[index];
+    const isLastSegment = index === rawSegments.length - 1;
+    if (segment === "index" && isLastSegment) {
+      continue;
+    }
+    const optionalRestMatch = segment.match(/^\[\[\.\.\.(.+)\]\]$/u);
+    if (optionalRestMatch) {
+      if (!isLastSegment) {
+        throw new Error(`Optional rest segment must be the final segment: ${relativePath}`);
+      }
+      routeSegments.push({
+        type: "optional-rest",
+        name: optionalRestMatch[1]
+      });
+      continue;
+    }
+    const restMatch = segment.match(/^\[\.\.\.(.+)\]$/u);
+    if (restMatch) {
+      if (!isLastSegment) {
+        throw new Error(`Rest segment must be the final segment: ${relativePath}`);
+      }
+      routeSegments.push({
+        type: "rest",
+        name: restMatch[1]
+      });
+      continue;
+    }
+    const dynamicMatch = segment.match(/^\[(.+)\]$/u);
+    if (dynamicMatch) {
+      routeSegments.push({
+        type: "param",
+        name: dynamicMatch[1]
+      });
+      continue;
+    }
+    routeSegments.push({
+      type: "static",
+      value: segment
+    });
+  }
+  return routeSegments;
+}
+async function directoryExists(dirPath) {
+  const fs = await import("node:fs/promises");
+  try {
+    const stat = await fs.stat(dirPath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function getRouteDirectoryCandidate(cwd, config) {
+  const routesConfig = config.files?.routes;
+  if (routesConfig === false) {
+    return null;
+  }
+  const dir = routesConfig?.dir ?? DEFAULT_ROUTE_DIR;
+  return {
+    dir,
+    absoluteDir: resolve(cwd, dir),
+    prefix: normalizeRoutePrefix(routesConfig?.prefix)
+  };
+}
+async function discoverRoutes(cwd, config) {
+  const routeDirectory = getRouteDirectoryCandidate(cwd, config);
+  if (!routeDirectory) {
+    return null;
+  }
+  if (!await directoryExists(routeDirectory.absoluteDir)) {
+    return null;
+  }
+  const prefixSegments = createStaticSegmentsFromPrefix(routeDirectory.prefix);
+  const files = await findFiles(DEFAULT_ROUTE_FILE_PATTERNS, {
+    cwd: routeDirectory.absoluteDir,
+    absolute: true
+  });
+  const discoveredRoutes = [];
+  const routeSignatures = new Map;
+  for (const absolutePath of files) {
+    const relativeToRouteDir = relative(routeDirectory.absoluteDir, absolutePath).replace(/\\/g, "/");
+    if (shouldIgnoreRouteFile(relativeToRouteDir)) {
+      continue;
+    }
+    const segments = parseRouteSegments(relativeToRouteDir, prefixSegments);
+    const routePath = toRoutePath(segments);
+    const filePath = relative(cwd, absolutePath).replace(/\\/g, "/");
+    const signature = getRouteSignature(segments);
+    const existingFilePath = routeSignatures.get(signature);
+    if (existingFilePath) {
+      throw new Error(`Conflicting file routes detected for "${routePath}". Both "${existingFilePath}" and "${filePath}" resolve to the same route.`);
+    }
+    routeSignatures.set(signature, filePath);
+    discoveredRoutes.push({
+      absolutePath,
+      filePath,
+      routePath,
+      segments
+    });
+  }
+  if (discoveredRoutes.length === 0) {
+    return null;
+  }
+  discoveredRoutes.sort(compareRoutes);
+  return {
+    dir: routeDirectory.dir,
+    absoluteDir: routeDirectory.absoluteDir,
+    prefix: routeDirectory.prefix,
+    routes: discoveredRoutes
+  };
+}
+
+export { getRouteDirectoryCandidate, discoverRoutes };

package/dist/{index-hcex3rgh.js → index-1phx14av.js}

@@ -70,7 +70,14 @@ var analyticsBindingSchema = z.object({
   dataset: z.string()
 });
 var sendEmailBindingSchema = z.object({
-  destinationAddress: z.string().optional()
+  destinationAddress: z.string().optional(),
+  allowedDestinationAddresses: z.array(z.string()).optional(),
+  allowedSenderAddresses: z.array(z.string()).optional()
+}).refine((binding) => {
+  return !(binding.destinationAddress && binding.allowedDestinationAddresses);
+}, {
+  message: "sendEmail bindings must use either destinationAddress or allowedDestinationAddresses, not both",
+  path: ["allowedDestinationAddresses"]
 });
 var bindingsSchema = z.object({
   kv: z.record(z.string(), z.string()).optional(),
@@ -115,12 +122,43 @@ var observabilitySchema = z.object({
 var limitsSchema = z.object({
   cpu_ms: z.number().optional()
 }).optional();
+var rolldownOptionsSchema = z.custom((value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}, {
+  message: "Expected Rolldown options object"
+});
+var rolldownConfigSchema = z.object({
+  target: z.string().optional(),
+  minify: z.boolean().optional(),
+  sourcemap: z.boolean().optional(),
+  options: rolldownOptionsSchema.optional()
+}).optional();
+var viteConfigSchema = z.object({
+  plugins: z.array(z.unknown()).optional()
+}).catchall(z.unknown()).optional();
 var buildConfigSchema = z.object({
   target: z.string().optional(),
   minify: z.boolean().optional(),
   sourcemap: z.boolean().optional(),
-  rolldownOptions: z.record(z.string(), z.unknown()).optional()
+  rolldownOptions: rolldownOptionsSchema.optional()
 }).optional();
+function normalizeViteConfig(vite, plugins) {
+  const normalizedVite = {
+    ...plugins !== undefined ? { plugins } : {},
+    ...vite ?? {}
+  };
+  return Object.keys(normalizedVite).length > 0 ? normalizedVite : undefined;
+}
+function normalizeRolldownConfig(rolldown, build) {
+  const normalizedRolldown = {
+    ...build?.target !== undefined ? { target: build.target } : {},
+    ...build?.minify !== undefined ? { minify: build.minify } : {},
+    ...build?.sourcemap !== undefined ? { sourcemap: build.sourcemap } : {},
+    ...build?.rolldownOptions !== undefined ? { options: build.rolldownOptions } : {},
+    ...rolldown ?? {}
+  };
+  return Object.keys(normalizedRolldown).length > 0 ? normalizedRolldown : undefined;
+}
 var migrationSchema = z.object({
   tag: z.string(),
   new_classes: z.array(z.string()).optional(),
@@ -134,7 +172,7 @@ var migrationSchema = z.object({
 var wranglerConfigSchema = z.object({
   passthrough: z.record(z.string(), z.unknown()).optional()
 }).optional();
-var envConfigSchemaInner = z.object({
+var envConfigSchema = z.object({
   name: z.string().optional(),
   compatibilityDate: compatibilityDateSchema.optional(),
   compatibilityFlags: z.array(z.string()).optional(),
@@ -148,15 +186,35 @@ var envConfigSchemaInner = z.object({
   limits: limitsSchema,
   observability: observabilitySchema,
   migrations: z.array(migrationSchema).optional(),
-  build: buildConfigSchema,
+  rolldown: rolldownConfigSchema,
+  vite: viteConfigSchema,
   wrangler: wranglerConfigSchema
 }).partial();
+var envConfigSchemaInner = envConfigSchema.extend({
+  build: buildConfigSchema,
+  plugins: z.array(z.unknown()).optional()
+}).transform((config) => {
+  const normalizedVite = normalizeViteConfig(config.vite, config.plugins);
+  const normalizedRolldown = normalizeRolldownConfig(config.rolldown, config.build);
+  const {
+    build: _legacyBuild,
+    plugins: _legacyPlugins,
+    vite: _vite,
+    rolldown: _rolldown,
+    ...rest
+  } = config;
+  return {
+    ...rest,
+    ...normalizedVite ? { vite: normalizedVite } : {},
+    ...normalizedRolldown ? { rolldown: normalizedRolldown } : {}
+  };
+});
 function getCurrentDate() {
   const now = new Date;
   return now.toISOString().split("T")[0];
 }
 var FORCED_COMPATIBILITY_FLAGS = ["nodejs_compat", "nodejs_als"];
-var configSchema = z.object({
+var canonicalConfigSchema = z.object({
   name: z.string({
     required_error: "Worker name is required"
   }),
@@ -177,11 +235,30 @@ var configSchema = z.object({
   limits: limitsSchema,
   observability: observabilitySchema,
   migrations: z.array(migrationSchema).optional(),
-  build: buildConfigSchema,
-  plugins: z.array(z.unknown()).optional(),
+  rolldown: rolldownConfigSchema,
+  vite: viteConfigSchema,
   env: z.record(z.string(), envConfigSchemaInner).optional(),
   wrangler: wranglerConfigSchema
 });
+var configSchema = canonicalConfigSchema.extend({
+  build: buildConfigSchema,
+  plugins: z.array(z.unknown()).optional()
+}).transform((config) => {
+  const normalizedVite = normalizeViteConfig(config.vite, config.plugins);
+  const normalizedRolldown = normalizeRolldownConfig(config.rolldown, config.build);
+  const {
+    build: _legacyBuild,
+    plugins: _legacyPlugins,
+    vite: _vite,
+    rolldown: _rolldown,
+    ...rest
+  } = config;
+  return {
+    ...rest,
+    ...normalizedVite ? { vite: normalizedVite } : {},
+    ...normalizedRolldown ? { rolldown: normalizedRolldown } : {}
+  };
+});
 function normalizeDOBinding(config) {
   if (typeof config === "string") {
     return { className: config };

package/dist/{index-tk6ej9dj.js → index-2q3pmzrx.js}

@@ -1,14 +1,14 @@
 import {
   DEFAULT_ENTRYPOINT_PATTERN,
-  findFiles
+  findFiles,
+  findFilesSync
 } from "./index-rbht7m9r.js";
 import {
   __require
 } from "./index-37x76zdn.js";
 
 // src/utils/entrypoint-discovery.ts
-import { readdirSync, readFileSync } from "fs";
-import { join } from "path";
+import { readFileSync } from "fs";
 var ENTRYPOINT_CLASS_PATTERN = /export\s+class\s+(\w+)\s+extends\s+WorkerEntrypoint/g;
 function findEntrypointClasses(code) {
   const classes = [];
@@ -19,22 +19,18 @@ function findEntrypointClasses(code) {
   }
   return classes;
 }
-var EP_FILE_PATTERN = /^ep\.[^.]+\.ts$/;
-function discoverEntrypointsSync(dir) {
+function discoverEntrypointsSync(cwd, pattern = DEFAULT_ENTRYPOINT_PATTERN) {
   const discovered = [];
   try {
-    const files = readdirSync(dir, { withFileTypes: true });
+    const files = findFilesSync(pattern, { cwd });
     for (const file of files) {
-      if (file.isFile() && EP_FILE_PATTERN.test(file.name)) {
-        const filePath = join(dir, file.name);
-        try {
-          const code = readFileSync(filePath, "utf-8");
-          const classNames = findEntrypointClasses(code);
-          for (const className of classNames) {
-            discovered.push({ className, filePath });
-          }
-        } catch {}
-      }
+      try {
+        const code = readFileSync(file, "utf-8");
+        const classNames = findEntrypointClasses(code);
+        for (const className of classNames) {
+          discovered.push({ className, filePath: file });
+        }
+      } catch {}
     }
   } catch {}
   return discovered;