@farm.js/core 0.1.17 → 0.1.19

package/dist/chunk-OXSIH4D6.cjs

@@ -0,0 +1,476 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkR5JIFR6Bcjs = require('./chunk-R5JIFR6B.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/metadata.ts
+var FARM_METADATA_ATTRIBUTE = "data-farm-metadata";
+var FARM_NOT_FOUND_TITLE = "404 - Page Not Found";
+async function resolveFarmNotFoundMetadata(layoutModules, notFoundModule) {
+  let metadata = {};
+  for (const layout of layoutModules) {
+    if (!layout) continue;
+    metadata = mergeMetadata(metadata, layout.metadata);
+    if (typeof layout.generateMetadata === "function") {
+      metadata = mergeMetadata(metadata, await layout.generateMetadata({ params: {} }));
+    }
+  }
+  let own = {};
+  if (notFoundModule) {
+    own = mergeMetadata(own, notFoundModule.metadata);
+    if (typeof notFoundModule.generateMetadata === "function") {
+      own = mergeMetadata(
+        own,
+        await notFoundModule.generateMetadata({ params: {}, searchParams: {} })
+      );
+    }
+  }
+  return mergeMetadata(metadata, { ...own, title: _nullishCoalesce(own.title, () => ( FARM_NOT_FOUND_TITLE)) });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmNotFoundMetadata, "resolveFarmNotFoundMetadata");
+function mergeMetadata(base, next) {
+  if (!base) return next ? { ...next } : {};
+  if (!next) return { ...base };
+  return {
+    ...base,
+    ...next,
+    jsonLd: mergeMetadataJsonLd(base.jsonLd, next.jsonLd),
+    title: mergeMetadataTitle(base.title, next.title),
+    other: mergeNestedMetadata(base.other, next.other),
+    openGraph: mergeNestedMetadata(base.openGraph, next.openGraph),
+    twitter: mergeNestedMetadata(base.twitter, next.twitter),
+    alternates: mergeNestedMetadata(base.alternates, next.alternates),
+    icons: mergeNestedMetadata(base.icons, next.icons),
+    verification: mergeNestedMetadata(base.verification, next.verification)
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, mergeMetadata, "mergeMetadata");
+function mergeMetadataTitle(base, next) {
+  if (next === void 0) return base;
+  const parentTemplate = isRecord(base) ? normalizeContent(base.template) : void 0;
+  if (typeof next === "string") {
+    return parentTemplate ? applyTitleTemplate(parentTemplate, next) : next;
+  }
+  if (!isRecord(next)) return next;
+  const defaultTitle = _nullishCoalesce(normalizeContent(next.default), () => ( resolveMetadataTitle(base)));
+  return {
+    ...next,
+    default: defaultTitle && parentTemplate ? applyTitleTemplate(parentTemplate, defaultTitle) : defaultTitle
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, mergeMetadataTitle, "mergeMetadataTitle");
+function applyTitleTemplate(template, title) {
+  return template.split("%s").join(title);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, applyTitleTemplate, "applyTitleTemplate");
+function mergeMetadataJsonLd(base, next) {
+  if (base === void 0) return next;
+  if (next === void 0) return base;
+  return [...normalizeArray(base), ...normalizeArray(next)];
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, mergeMetadataJsonLd, "mergeMetadataJsonLd");
+function addMetadataImageReference(metadata, reference) {
+  if (reference.kind === "opengraph") {
+    const openGraph = { ...metadata.openGraph };
+    if (!hasMetadataImages(openGraph.images) && !hasMetadataImages(openGraph.image)) {
+      openGraph.images = [
+        {
+          url: reference.href,
+          width: reference.width,
+          height: reference.height,
+          alt: reference.alt,
+          type: reference.contentType
+        }
+      ];
+    }
+    return {
+      ...metadata,
+      openGraph
+    };
+  }
+  const twitter = { ...metadata.twitter };
+  if (!hasMetadataImages(twitter.images)) {
+    twitter.images = [reference.href];
+    twitter.card = twitter.card || "summary_large_image";
+  }
+  return {
+    ...metadata,
+    twitter
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, addMetadataImageReference, "addMetadataImageReference");
+var MARKDOWN_MIME_TYPE = "text/markdown";
+function addMetadataMarkdownAlternate(metadata, href) {
+  if (!href) return metadata;
+  const alternates = isRecord(metadata.alternates) ? metadata.alternates : {};
+  const types = isRecord(alternates.types) ? alternates.types : {};
+  if (Object.keys(types).some((type) => type.toLowerCase() === MARKDOWN_MIME_TYPE)) {
+    return metadata;
+  }
+  return {
+    ...metadata,
+    alternates: {
+      ...alternates,
+      types: { ...types, [MARKDOWN_MIME_TYPE]: sanitizeSelfCanonicalPathname(href) }
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, addMetadataMarkdownAlternate, "addMetadataMarkdownAlternate");
+function renderMetadataHead(metadata, options = {}) {
+  const resolvedMetadata = metadata || {};
+  const metadataBase = resolveMetadataBase(resolvedMetadata);
+  const explicitTitle = resolveMetadataTitle(resolvedMetadata.title);
+  const title = explicitTitle || "Farm.js App";
+  const tags = [];
+  appendMetaName(tags, "description", resolvedMetadata.description);
+  appendMetaName(tags, "keywords", normalizeKeywords(resolvedMetadata.keywords));
+  appendMetaName(tags, "author", resolvedMetadata.author);
+  if (Array.isArray(resolvedMetadata.authors)) {
+    for (const author of resolvedMetadata.authors) {
+      appendMetaName(tags, "author", _optionalChain([author, 'optionalAccess', _ => _.name]));
+      if (_optionalChain([author, 'optionalAccess', _2 => _2.url])) {
+        appendLink(tags, "author", resolveMetadataUrl(author.url, metadataBase));
+      }
+    }
+  }
+  appendMetaName(tags, "creator", resolvedMetadata.creator);
+  appendMetaName(tags, "publisher", resolvedMetadata.publisher);
+  appendMetaName(tags, "robots", normalizeRobots(resolvedMetadata.robots));
+  if (isRecord(resolvedMetadata.robots)) {
+    appendMetaName(tags, "googlebot", normalizeRobots(resolvedMetadata.robots.googleBot));
+  }
+  const alternates = resolvedMetadata.alternates;
+  const explicitCanonical = isRecord(alternates) ? alternates.canonical : void 0;
+  const canonicalHref = explicitCanonical != null ? resolveMetadataUrl(explicitCanonical, metadataBase) : options.pathname ? resolveMetadataUrl(sanitizeSelfCanonicalPathname(options.pathname), metadataBase) : void 0;
+  if (canonicalHref) {
+    appendLink(tags, "canonical", canonicalHref);
+  }
+  if (isRecord(alternates) && isRecord(alternates.languages)) {
+    for (const [language, href] of Object.entries(alternates.languages)) {
+      appendLink(tags, "alternate", resolveMetadataUrl(href, metadataBase), {
+        hreflang: language
+      });
+    }
+  }
+  if (isRecord(alternates) && isRecord(alternates.types)) {
+    for (const [type, value] of Object.entries(alternates.types)) {
+      for (const entry of normalizeArray(value)) {
+        const link = isRecord(entry) ? entry : { url: entry };
+        appendLink(tags, "alternate", resolveMetadataUrl(link.url, metadataBase), {
+          type,
+          title: link.title
+        });
+      }
+    }
+  }
+  const hasFavicon = appendIcons(tags, resolvedMetadata.icons, metadataBase);
+  if (resolvedMetadata.manifest) {
+    appendLink(
+      tags,
+      "manifest",
+      resolveMetadataUrl(resolvedMetadata.manifest, metadataBase)
+    );
+  }
+  appendNamedMetaRecord(tags, resolvedMetadata.other);
+  appendOpenGraph(tags, resolvedMetadata.openGraph, metadataBase);
+  appendTwitter(tags, resolvedMetadata.twitter, metadataBase);
+  appendVerification(tags, resolvedMetadata.verification);
+  if (options.jsonLd) {
+    const jsonLdConfig = options.jsonLd === true ? {} : options.jsonLd;
+    const jsonLdScript = _chunkR5JIFR6Bcjs.renderFarmAgentJsonLd.call(void 0, jsonLdConfig, {
+      metadataBase,
+      siteName: isRecord(resolvedMetadata.openGraph) ? normalizeContent(resolvedMetadata.openGraph.siteName) : void 0,
+      title: explicitTitle,
+      description: normalizeContent(resolvedMetadata.description)
+    });
+    if (jsonLdScript) tags.push(jsonLdScript);
+  }
+  for (const entry of normalizeArray(resolvedMetadata.jsonLd)) {
+    if (!isRecord(entry)) continue;
+    tags.push(
+      `<script type="application/ld+json" ${FARM_METADATA_ATTRIBUTE}>${_chunkR5JIFR6Bcjs.serializeJsonLd.call(void 0, entry)}</script>`
+    );
+  }
+  return {
+    title: escapeText(title),
+    tags: tags.length > 0 ? `
+  ${tags.join("\n  ")}` : "",
+    hasFavicon,
+    hasExplicitTitle: Boolean(explicitTitle)
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, renderMetadataHead, "renderMetadataHead");
+function mergeNestedMetadata(base, next) {
+  if (isRecord(base) && isRecord(next)) {
+    return {
+      ...base,
+      ...next
+    };
+  }
+  return _nullishCoalesce(next, () => ( base));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, mergeNestedMetadata, "mergeNestedMetadata");
+function appendOpenGraph(tags, openGraph, metadataBase) {
+  if (!isRecord(openGraph)) return;
+  appendMetaProperty(tags, "og:title", openGraph.title);
+  appendMetaProperty(tags, "og:description", openGraph.description);
+  appendMetaProperty(tags, "og:url", resolveMetadataUrl(openGraph.url, metadataBase));
+  appendMetaProperty(tags, "og:site_name", openGraph.siteName);
+  appendMetaProperty(tags, "og:type", _nullishCoalesce(openGraph.type, () => ( "website")));
+  appendMetaProperty(tags, "og:locale", openGraph.locale);
+  const images = normalizeMetadataImages(
+    _nullishCoalesce(openGraph.images, () => ( openGraph.image)),
+    metadataBase
+  );
+  for (const image of images) {
+    appendMetaProperty(tags, "og:image", image.url);
+    appendMetaProperty(tags, "og:image:width", image.width);
+    appendMetaProperty(tags, "og:image:height", image.height);
+    appendMetaProperty(tags, "og:image:alt", image.alt);
+    appendMetaProperty(tags, "og:image:type", image.type);
+  }
+  if (openGraph.type === "article") {
+    appendMetaProperty(tags, "article:published_time", normalizeDate(openGraph.publishedTime));
+    appendMetaProperty(tags, "article:modified_time", normalizeDate(openGraph.modifiedTime));
+    for (const author of normalizeArray(openGraph.authors)) {
+      appendMetaProperty(tags, "article:author", author);
+    }
+    appendMetaProperty(tags, "article:section", openGraph.section);
+    for (const tag of normalizeArray(openGraph.tags)) {
+      appendMetaProperty(tags, "article:tag", tag);
+    }
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, appendOpenGraph, "appendOpenGraph");
+function appendTwitter(tags, twitter, metadataBase) {
+  if (!isRecord(twitter)) return;
+  appendMetaName(tags, "twitter:card", twitter.card);
+  appendMetaName(tags, "twitter:site", twitter.site);
+  appendMetaName(tags, "twitter:creator", twitter.creator);
+  appendMetaName(tags, "twitter:title", twitter.title);
+  appendMetaName(tags, "twitter:description", twitter.description);
+  for (const image of normalizeMetadataImages(twitter.images, metadataBase)) {
+    appendMetaName(tags, "twitter:image", image.url);
+    appendMetaName(tags, "twitter:image:alt", image.alt);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, appendTwitter, "appendTwitter");
+function appendNamedMetaRecord(tags, record) {
+  if (!isRecord(record)) return;
+  for (const [name, value] of Object.entries(record)) {
+    for (const content of normalizeArray(value)) {
+      appendMetaName(tags, name, content, true);
+    }
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, appendNamedMetaRecord, "appendNamedMetaRecord");
+function appendIcons(tags, icons, metadataBase) {
+  if (!icons) return false;
+  if (typeof icons === "string") {
+    const initialTagCount2 = tags.length;
+    appendLink(tags, "icon", resolveMetadataUrl(icons, metadataBase));
+    return tags.length > initialTagCount2;
+  }
+  if (!isRecord(icons)) return false;
+  const initialTagCount = tags.length;
+  appendIconList(tags, "icon", icons.icon, metadataBase);
+  appendIconList(tags, "shortcut icon", icons.shortcut, metadataBase);
+  const hasFavicon = tags.length > initialTagCount;
+  appendIconList(tags, "apple-touch-icon", icons.apple, metadataBase);
+  return hasFavicon;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, appendIcons, "appendIcons");
+function appendIconList(tags, rel, value, metadataBase) {
+  for (const icon of normalizeArray(value)) {
+    if (typeof icon === "string") {
+      appendLink(tags, rel, resolveMetadataUrl(icon, metadataBase));
+      continue;
+    }
+    if (!isRecord(icon)) continue;
+    appendLink(tags, rel, resolveMetadataUrl(icon.url, metadataBase), {
+      sizes: icon.sizes,
+      type: icon.type
+    });
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, appendIconList, "appendIconList");
+function appendMetaName(tags, name, content, marked = false) {
+  const normalized = normalizeContent(content);
+  if (!normalized || !name) return;
+  const marker = marked ? ` ${FARM_METADATA_ATTRIBUTE}` : "";
+  tags.push(
+    `<meta name="${escapeAttribute(name)}" content="${escapeAttribute(normalized)}"${marker}>`
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, appendMetaName, "appendMetaName");
+function appendMetaProperty(tags, property, content) {
+  const normalized = normalizeContent(content);
+  if (!normalized) return;
+  tags.push(
+    `<meta property="${escapeAttribute(property)}" content="${escapeAttribute(normalized)}">`
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, appendMetaProperty, "appendMetaProperty");
+var VERIFICATION_META_NAMES = [
+  ["google", "google-site-verification"],
+  ["bing", "msvalidate.01"],
+  ["yandex", "yandex-verification"]
+];
+function appendVerification(tags, verification) {
+  if (!isRecord(verification)) return;
+  for (const [key, name] of VERIFICATION_META_NAMES) {
+    for (const token of normalizeArray(verification[key])) {
+      appendMetaName(tags, name, token);
+    }
+  }
+  appendNamedMetaRecord(tags, verification.other);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, appendVerification, "appendVerification");
+function appendLink(tags, rel, href, attrs = {}) {
+  const normalizedHref = normalizeContent(href);
+  if (!normalizedHref) return;
+  const attrText = Object.entries(attrs).map(([key, value]) => {
+    const normalized = normalizeContent(value);
+    return normalized ? ` ${key}="${escapeAttribute(normalized)}"` : "";
+  }).join("");
+  tags.push(
+    `<link rel="${escapeAttribute(rel)}" href="${escapeAttribute(normalizedHref)}"${attrText}>`
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, appendLink, "appendLink");
+function normalizeMetadataImages(value, metadataBase) {
+  return normalizeArray(value).map((item) => {
+    if (typeof item === "string") {
+      return { url: resolveMetadataUrl(item, metadataBase) || item };
+    }
+    if (!isRecord(item)) return null;
+    const rawUrl = item.url || item.src;
+    const url = resolveMetadataUrl(rawUrl, metadataBase);
+    if (!url) return null;
+    return {
+      url,
+      width: normalizeNumber(item.width),
+      height: normalizeNumber(item.height),
+      alt: typeof item.alt === "string" ? item.alt : void 0,
+      type: typeof item.type === "string" ? item.type : void 0
+    };
+  }).filter((item) => item !== null);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeMetadataImages, "normalizeMetadataImages");
+function normalizeArray(value) {
+  if (value == null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeArray, "normalizeArray");
+function hasMetadataImages(value) {
+  return normalizeMetadataImages(value).length > 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, hasMetadataImages, "hasMetadataImages");
+function resolveMetadataTitle(title) {
+  if (typeof title === "string") return title;
+  if (isRecord(title)) {
+    return normalizeContent(title.default);
+  }
+  return void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveMetadataTitle, "resolveMetadataTitle");
+function normalizeKeywords(keywords) {
+  if (Array.isArray(keywords)) return keywords.filter(Boolean).join(", ");
+  return keywords;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeKeywords, "normalizeKeywords");
+var ROBOTS_FLAGS = ["noarchive", "nosnippet", "noimageindex"];
+var ROBOTS_VALUES = [
+  "max-snippet",
+  "max-image-preview",
+  "max-video-preview",
+  "unavailable_after"
+];
+function normalizeRobots(robots) {
+  if (typeof robots === "string") return robots;
+  if (!isRecord(robots)) return void 0;
+  const values = [];
+  if (typeof robots.index === "boolean") values.push(robots.index ? "index" : "noindex");
+  if (typeof robots.follow === "boolean") values.push(robots.follow ? "follow" : "nofollow");
+  for (const flag of ROBOTS_FLAGS) {
+    if (robots[flag] === true) values.push(flag);
+  }
+  for (const directive of ROBOTS_VALUES) {
+    const value = normalizeContent(robots[directive]);
+    if (value) values.push(`${directive}:${value}`);
+  }
+  return values.join(", ") || void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeRobots, "normalizeRobots");
+function resolveMetadataBase(metadata) {
+  const base = metadata.metadataBase;
+  if (!base) return void 0;
+  return String(base);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveMetadataBase, "resolveMetadataBase");
+function sanitizeSelfCanonicalPathname(pathname) {
+  if (typeof pathname !== "string" || pathname.length === 0) return "/";
+  const collapsed = pathname.replace(/^[/\\]+/, "/");
+  return collapsed.startsWith("/") ? collapsed : `/${collapsed}`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, sanitizeSelfCanonicalPathname, "sanitizeSelfCanonicalPathname");
+function resolveMetadataUrl(value, metadataBase) {
+  const normalized = normalizeContent(value);
+  if (!normalized) return void 0;
+  if (!metadataBase) return normalized;
+  try {
+    return new URL(normalized, metadataBase).toString();
+  } catch (e) {
+    return normalized;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveMetadataUrl, "resolveMetadataUrl");
+function normalizeNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeNumber, "normalizeNumber");
+function normalizeDate(value) {
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? void 0 : value.toISOString();
+  }
+  return normalizeContent(value);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeDate, "normalizeDate");
+function normalizeContent(value) {
+  if (value == null) return void 0;
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (value instanceof URL) return value.toString();
+  return void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeContent, "normalizeContent");
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isRecord, "isRecord");
+function escapeText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, escapeText, "escapeText");
+function escapeAttribute(value) {
+  return escapeText(value).replace(/"/g, "&quot;");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, escapeAttribute, "escapeAttribute");
+
+
+
+
+
+
+
+
+
+exports.FARM_METADATA_ATTRIBUTE = FARM_METADATA_ATTRIBUTE; exports.resolveFarmNotFoundMetadata = resolveFarmNotFoundMetadata; exports.mergeMetadata = mergeMetadata; exports.addMetadataImageReference = addMetadataImageReference; exports.addMetadataMarkdownAlternate = addMetadataMarkdownAlternate; exports.renderMetadataHead = renderMetadataHead; exports.resolveMetadataTitle = resolveMetadataTitle;