devflare 1.0.0-next.3 → 1.0.0-next.30

package/dist/{index-18hvb6gb.js → index-gn5wy09x.js}

@@ -9,7 +9,9 @@ var VITE_CONFIG_FILES = [
   "vite.config.ts",
   "vite.config.js",
   "vite.config.mts",
-  "vite.config.mjs"
+  "vite.config.mjs",
+  "vite.config.cts",
+  "vite.config.cjs"
 ];
 var ANSI_REGEX = /\x1b\[[0-9;]*m/g;
 var LOCAL_VITE_URL_REGEX = /https?:\/\/(?:localhost|127\.0\.0\.1|\[::1\])(?::\d+)?\/?/i;
@@ -59,6 +61,15 @@ async function detectViteProject(cwd, fs) {
     wantsViteIntegration
   };
 }
+async function resolveViteMode(cwd, options = {}) {
+  const detection = await detectViteProject(cwd, options.fs);
+  const requested = options.requested ?? true;
+  return {
+    enableVite: requested && detection.shouldStartVite,
+    viteConfigPath: detection.viteConfigPath,
+    detection
+  };
+}
 function stripAnsi(value) {
   return value.replace(ANSI_REGEX, "");
 }
@@ -191,4 +202,4 @@ async function stopSpawnedProcessTree(process, options = {}) {
   await waitForProcessExit(process, timeoutMs);
 }
 
-export { detectViteProject, waitForViteReady, stopSpawnedProcessTree };
+export { detectViteProject, resolveViteMode, waitForViteReady, stopSpawnedProcessTree };

package/dist/index-hpwa6vsw.js

@@ -0,0 +1,239 @@
+// src/utils/send-email.ts
+var RAW_EMAIL = "EmailMessage::raw";
+var wrappedSendEmailBindings = new WeakMap;
+var wrappedEnvBindings = new WeakMap;
+var localSendEmailBindings = new Map;
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isSendEmailBinding(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  try {
+    return typeof value.send === "function" && typeof value.sendBatch !== "function";
+  } catch {
+    return false;
+  }
+}
+function isComposableSendEmailMessage(message) {
+  return isRecord(message) && typeof message.from === "string" && (typeof message.to === "string" || Array.isArray(message.to));
+}
+function formatEmailAddress(value) {
+  if (!value) {
+    return;
+  }
+  return typeof value === "string" ? value : String(value);
+}
+function formatEmailList(value) {
+  if (!value) {
+    return;
+  }
+  return Array.isArray(value) ? value.join(", ") : value;
+}
+function normalizeBodyText(value) {
+  return value.replace(/\r?\n/g, `\r
+`);
+}
+function buildMultipartAlternativeBody(message, boundary) {
+  const parts = [];
+  if (message.text) {
+    parts.push(`--${boundary}`, "Content-Type: text/plain; charset=UTF-8", "", normalizeBodyText(message.text));
+  }
+  if (message.html) {
+    parts.push(`--${boundary}`, "Content-Type: text/html; charset=UTF-8", "", normalizeBodyText(message.html));
+  }
+  parts.push(`--${boundary}--`);
+  return parts.join(`\r
+`);
+}
+function buildRawEmail(message) {
+  const lines = [];
+  const messageId = `<${Date.now()}-${Math.random().toString(36).slice(2)}@devflare.dev>`;
+  lines.push(`From: ${message.from}`);
+  lines.push(`To: ${formatEmailList(message.to)}`);
+  lines.push(`Date: ${new Date().toUTCString()}`);
+  lines.push(`Message-ID: ${messageId}`);
+  if (message.subject) {
+    lines.push(`Subject: ${message.subject}`);
+  }
+  const replyTo = formatEmailAddress(message.replyTo);
+  if (replyTo) {
+    lines.push(`Reply-To: ${replyTo}`);
+  }
+  const cc = formatEmailList(message.cc);
+  if (cc) {
+    lines.push(`Cc: ${cc}`);
+  }
+  const bcc = formatEmailList(message.bcc);
+  if (bcc) {
+    lines.push(`Bcc: ${bcc}`);
+  }
+  if (message.headers) {
+    for (const [key, value] of Object.entries(message.headers)) {
+      lines.push(`${key}: ${value}`);
+    }
+  }
+  lines.push("MIME-Version: 1.0");
+  if (message.text && message.html) {
+    const boundary = `devflare-alt-${crypto.randomUUID()}`;
+    lines.push(`Content-Type: multipart/alternative; boundary="${boundary}"`);
+    lines.push("");
+    lines.push(buildMultipartAlternativeBody(message, boundary));
+    return lines.join(`\r
+`);
+  }
+  lines.push(`Content-Type: ${message.html ? "text/html" : "text/plain"}; charset=UTF-8`);
+  lines.push("");
+  lines.push(normalizeBodyText(message.html ?? message.text ?? ""));
+  return lines.join(`\r
+`);
+}
+function createEmailMessageRaw(raw) {
+  if (typeof raw === "string" || raw instanceof ReadableStream) {
+    return raw;
+  }
+  if (raw instanceof Uint8Array) {
+    const copy = new Uint8Array(raw.byteLength);
+    copy.set(raw);
+    return new Blob([copy]).stream();
+  }
+  if (raw instanceof ArrayBuffer) {
+    return new Blob([new Uint8Array(raw.slice(0))]).stream();
+  }
+  throw new Error("Unsupported EmailMessage raw payload");
+}
+function normalizeSendEmailMessage(message) {
+  if (!isComposableSendEmailMessage(message)) {
+    return message;
+  }
+  if (hasOwn(message, RAW_EMAIL)) {
+    return message;
+  }
+  if (hasOwn(message, "raw") && message.raw !== undefined) {
+    return {
+      from: message.from,
+      to: message.to,
+      [RAW_EMAIL]: createEmailMessageRaw(message.raw)
+    };
+  }
+  return {
+    from: message.from,
+    to: message.to,
+    [RAW_EMAIL]: createEmailMessageRaw(buildRawEmail(message))
+  };
+}
+function wrapSendEmailBinding(binding) {
+  const cached = wrappedSendEmailBindings.get(binding);
+  if (cached) {
+    return cached;
+  }
+  const wrapped = new Proxy(binding, {
+    get(target, prop, receiver) {
+      if (prop === "send") {
+        return async (message) => target.send(normalizeSendEmailMessage(message));
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+  wrappedSendEmailBindings.set(binding, wrapped);
+  return wrapped;
+}
+function createLocalSendEmailBinding(config = {}, options = {}) {
+  return {
+    async send(message) {
+      const normalized = normalizeSendEmailMessage(message);
+      if (isRecord(normalized)) {
+        const from = typeof normalized.from === "string" ? normalized.from : undefined;
+        const recipients = Array.isArray(normalized.to) ? normalized.to.filter((value) => typeof value === "string") : typeof normalized.to === "string" ? [normalized.to] : [];
+        if (from && config.allowedSenderAddresses && !config.allowedSenderAddresses.includes(from)) {
+          throw new Error(`email from ${from} not allowed`);
+        }
+        for (const recipient of recipients) {
+          if (config.destinationAddress !== undefined && recipient !== config.destinationAddress) {
+            throw new Error(`email to ${recipient} not allowed`);
+          }
+          if (config.allowedDestinationAddresses !== undefined && !config.allowedDestinationAddresses.includes(recipient)) {
+            throw new Error(`email to ${recipient} not allowed`);
+          }
+        }
+      }
+      await options.onSend?.(normalized);
+      return;
+    }
+  };
+}
+function setLocalSendEmailBindings(bindings) {
+  localSendEmailBindings.clear();
+  for (const [name, config] of Object.entries(bindings)) {
+    localSendEmailBindings.set(name, createLocalSendEmailBinding(config));
+  }
+}
+function clearLocalSendEmailBindings() {
+  localSendEmailBindings.clear();
+}
+function needsEnvSendEmailWrapping(env) {
+  if (localSendEmailBindings.size > 0) {
+    return true;
+  }
+  for (const key of Reflect.ownKeys(env)) {
+    const value = Reflect.get(env, key);
+    if (isSendEmailBinding(value)) {
+      return true;
+    }
+  }
+  return false;
+}
+function wrapEnvSendEmailBindings(env) {
+  if (!isRecord(env)) {
+    return env;
+  }
+  if (!needsEnvSendEmailWrapping(env)) {
+    return env;
+  }
+  const cached = wrappedEnvBindings.get(env);
+  if (cached) {
+    return cached;
+  }
+  const wrapped = new Proxy(env, {
+    get(target, prop, receiver) {
+      if (typeof prop === "string" && localSendEmailBindings.has(prop)) {
+        return localSendEmailBindings.get(prop);
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return isSendEmailBinding(value) ? wrapSendEmailBinding(value) : value;
+    },
+    has(target, prop) {
+      return Reflect.has(target, prop) || typeof prop === "string" && localSendEmailBindings.has(prop);
+    },
+    ownKeys(target) {
+      return Array.from(new Set([
+        ...Reflect.ownKeys(target),
+        ...localSendEmailBindings.keys()
+      ]));
+    },
+    getOwnPropertyDescriptor(target, prop) {
+      if (typeof prop === "string" && localSendEmailBindings.has(prop)) {
+        return {
+          configurable: true,
+          enumerable: true,
+          writable: false,
+          value: localSendEmailBindings.get(prop)
+        };
+      }
+      const descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+      if (descriptor) {
+        return descriptor;
+      }
+      return;
+    }
+  });
+  wrappedEnvBindings.set(env, wrapped);
+  return wrapped;
+}
+
+export { createEmailMessageRaw, normalizeSendEmailMessage, wrapSendEmailBinding, createLocalSendEmailBinding, setLocalSendEmailBindings, clearLocalSendEmailBindings, wrapEnvSendEmailBindings };