@farm.js/core 0.1.16 → 0.1.18

package/dist/chunk-GDSHDTJ4.cjs

@@ -0,0 +1,152 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkMKB2EGIRcjs = require('./chunk-MKB2EGIR.cjs');
+
+
+var _chunkDVM4FKZLcjs = require('./chunk-DVM4FKZL.cjs');
+
+
+var _chunkOX6O6WVAcjs = require('./chunk-OX6O6WVA.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/route-rules.ts
+function normalizeRouteRules(routeRules) {
+  if (!routeRules) return {};
+  const normalized = {};
+  const normalizedSources = /* @__PURE__ */ new Map();
+  for (const [source, rule] of Object.entries(routeRules)) {
+    if (!rule) continue;
+    const normalizedSource = normalizeRuleSource(source);
+    _chunkDVM4FKZLcjs.validateConfigRouteSource.call(void 0, normalizedSource, `Route rule "${source}" source`);
+    const existingSource = normalizedSources.get(normalizedSource);
+    if (existingSource !== void 0) {
+      throw new Error(
+        `Route rules "${existingSource}" and "${source}" both normalize to "${normalizedSource}".`
+      );
+    }
+    normalizedSources.set(normalizedSource, source);
+    if (typeof rule.redirect === "object" && rule.redirect.statusCode !== void 0 && !_chunkOX6O6WVAcjs.isFarmRedirectStatus.call(void 0, rule.redirect.statusCode)) {
+      throw new RangeError(
+        `Route rule "${normalizedSource}" redirect.statusCode must be one of 301, 302, 303, 307, or 308.`
+      );
+    }
+    normalized[normalizedSource] = {
+      ...rule,
+      ..._chunkMKB2EGIRcjs.normalizeFarmRouteRuntimeConfig.call(void 0, rule, `Route rule "${normalizedSource}"`)
+    };
+  }
+  return normalized;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeRouteRules, "normalizeRouteRules");
+function routeRulesToRedirects(routeRules) {
+  return Object.entries(routeRules).filter(
+    (entry) => Boolean(entry[1].redirect)
+  ).map(([source, rule]) => {
+    const redirect = typeof rule.redirect === "string" ? { to: rule.redirect } : rule.redirect;
+    return {
+      source,
+      destination: redirect.to,
+      permanent: redirect.permanent,
+      statusCode: _nullishCoalesce(redirect.statusCode, () => ( (redirect.permanent === true ? 308 : void 0)))
+    };
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, routeRulesToRedirects, "routeRulesToRedirects");
+function routeRulesToHeaders(routeRules) {
+  const configs = [];
+  for (const [source, rule] of Object.entries(routeRules)) {
+    const headers = {
+      ...normalizeCorsHeaders(rule.cors),
+      ...rule.headers
+    };
+    const entries = Object.entries(headers);
+    if (entries.length === 0) continue;
+    configs.push({
+      source,
+      headers: entries.map(([key, value]) => ({ key, value }))
+    });
+  }
+  return configs;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, routeRulesToHeaders, "routeRulesToHeaders");
+function routeRulesToNitroRouteRules(routeRules) {
+  const nitroRules = {};
+  for (const [source, rule] of Object.entries(routeRules)) {
+    const nitroRule = { ...rule };
+    if (rule.render === "static") {
+      nitroRule.prerender = true;
+    } else if (rule.render === "dynamic") {
+      nitroRule.prerender = false;
+    }
+    if (rule.redirect) {
+      const redirect = typeof rule.redirect === "string" ? { to: rule.redirect } : rule.redirect;
+      if (hasExplicitQuery(redirect.to)) {
+        delete nitroRule.redirect;
+      } else {
+        nitroRule.redirect = {
+          to: redirect.to,
+          status: _nullishCoalesce(redirect.statusCode, () => ( (redirect.permanent === true ? 308 : 307)))
+        };
+      }
+    }
+    if (rule.cors) {
+      nitroRule.cors = true;
+      nitroRule.headers = {
+        ...normalizeCorsHeaders(rule.cors),
+        ...rule.headers
+      };
+    }
+    delete nitroRule.render;
+    delete nitroRule.runtime;
+    delete nitroRule.regions;
+    delete nitroRule.maxDuration;
+    nitroRules[source] = nitroRule;
+  }
+  return nitroRules;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, routeRulesToNitroRouteRules, "routeRulesToNitroRouteRules");
+function normalizeCorsHeaders(cors) {
+  if (!cors) return {};
+  if (cors === true) {
+    return {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "*",
+      "Access-Control-Allow-Headers": "*"
+    };
+  }
+  return {
+    "Access-Control-Allow-Origin": _nullishCoalesce(cors.origin, () => ( "*")),
+    "Access-Control-Allow-Methods": _nullishCoalesce(normalizeList(cors.methods), () => ( "*")),
+    "Access-Control-Allow-Headers": _nullishCoalesce(normalizeList(cors.headers), () => ( "*"))
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeCorsHeaders, "normalizeCorsHeaders");
+function normalizeList(value) {
+  if (!value || typeof value === "string") return value;
+  return value.join(", ");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeList, "normalizeList");
+function normalizeRuleSource(source) {
+  const trimmed = source.trim();
+  if (!trimmed) {
+    throw new TypeError("Route rule source must be a non-empty pathname pattern.");
+  }
+  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeRuleSource, "normalizeRuleSource");
+function hasExplicitQuery(destination) {
+  const queryIndex = destination.indexOf("?");
+  if (queryIndex === -1) return false;
+  const hashIndex = destination.indexOf("#");
+  return hashIndex === -1 || queryIndex < hashIndex;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, hasExplicitQuery, "hasExplicitQuery");
+
+
+
+
+
+
+exports.normalizeRouteRules = normalizeRouteRules; exports.routeRulesToRedirects = routeRulesToRedirects; exports.routeRulesToHeaders = routeRulesToHeaders; exports.routeRulesToNitroRouteRules = routeRulesToNitroRouteRules;