@flightdev/seo 0.2.0

package/dist/vue/index.js

@@ -0,0 +1,1293 @@
+import { reactive, provide, inject, computed, watch, onMounted, onUnmounted } from 'vue';
+
+// src/vue/index.ts
+
+// src/head.ts
+var VOID_TAGS = /* @__PURE__ */ new Set(["meta", "link", "base"]);
+var BOOLEAN_ATTRS = /* @__PURE__ */ new Set(["async", "defer", "nomodule", "crossorigin"]);
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function escapeAttr(str) {
+  return str.replace(/"/g, "&quot;");
+}
+function renderTag(tag) {
+  const parts = [`<${tag.tag}`];
+  if (tag.attrs) {
+    for (const [key, value] of Object.entries(tag.attrs)) {
+      if (value === void 0 || value === false) {
+        continue;
+      }
+      if (value === true) {
+        parts.push(` ${key}`);
+      } else if (BOOLEAN_ATTRS.has(key) && value === "") {
+        parts.push(` ${key}`);
+      } else {
+        parts.push(` ${key}="${escapeAttr(String(value))}"`);
+      }
+    }
+  }
+  if (VOID_TAGS.has(tag.tag)) {
+    parts.push(" />");
+  } else if (tag.content !== void 0) {
+    const isJsonLd = tag.tag === "script" && tag.attrs?.type === "application/ld+json";
+    const content = isJsonLd ? tag.content : escapeHtml(tag.content);
+    parts.push(`>${content}</${tag.tag}>`);
+  } else {
+    parts.push(`></${tag.tag}>`);
+  }
+  return parts.join("");
+}
+function renderTags(tags) {
+  return tags.map((tag) => renderTag(tag)).join("\n");
+}
+
+// src/meta.ts
+function generateTitleTag(title, template, defaultTitle) {
+  let resolvedTitle = title || defaultTitle;
+  if (!resolvedTitle) {
+    return null;
+  }
+  if (template && title) {
+    resolvedTitle = template.replace("%s", title);
+  }
+  return {
+    tag: "title",
+    content: resolvedTitle,
+    key: "title"
+  };
+}
+function generateCharsetTag(charset = "utf-8") {
+  return {
+    tag: "meta",
+    attrs: { charset },
+    key: "meta:charset"
+  };
+}
+function generateViewportTag(viewport) {
+  if (!viewport) {
+    return null;
+  }
+  let content;
+  if (typeof viewport === "string") {
+    content = viewport;
+  } else {
+    const parts = [];
+    if (viewport.width !== void 0) {
+      parts.push(`width=${viewport.width}`);
+    }
+    if (viewport.height !== void 0) {
+      parts.push(`height=${viewport.height}`);
+    }
+    if (viewport.initialScale !== void 0) {
+      parts.push(`initial-scale=${viewport.initialScale}`);
+    }
+    if (viewport.minimumScale !== void 0) {
+      parts.push(`minimum-scale=${viewport.minimumScale}`);
+    }
+    if (viewport.maximumScale !== void 0) {
+      parts.push(`maximum-scale=${viewport.maximumScale}`);
+    }
+    if (viewport.userScalable !== void 0) {
+      parts.push(`user-scalable=${viewport.userScalable ? "yes" : "no"}`);
+    }
+    if (viewport.viewportFit !== void 0) {
+      parts.push(`viewport-fit=${viewport.viewportFit}`);
+    }
+    content = parts.join(", ");
+  }
+  if (!content) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { name: "viewport", content },
+    key: "meta:name:viewport"
+  };
+}
+function generateDescriptionTag(description) {
+  if (!description) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { name: "description", content: description },
+    key: "meta:name:description"
+  };
+}
+function generateKeywordsTag(keywords) {
+  if (!keywords) {
+    return null;
+  }
+  const content = Array.isArray(keywords) ? keywords.join(", ") : keywords;
+  return {
+    tag: "meta",
+    attrs: { name: "keywords", content },
+    key: "meta:name:keywords"
+  };
+}
+function generateAuthorTag(author) {
+  if (!author) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { name: "author", content: author },
+    key: "meta:name:author"
+  };
+}
+function generateGeneratorTag(generator) {
+  if (!generator) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { name: "generator", content: generator },
+    key: "meta:name:generator"
+  };
+}
+function generateApplicationNameTag(name) {
+  if (!name) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { name: "application-name", content: name },
+    key: "meta:name:application-name"
+  };
+}
+function generateReferrerTag(referrer) {
+  if (!referrer) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { name: "referrer", content: referrer },
+    key: "meta:name:referrer"
+  };
+}
+function generateThemeColorTags(themeColor) {
+  if (!themeColor) {
+    return [];
+  }
+  if (typeof themeColor === "string") {
+    return [
+      {
+        tag: "meta",
+        attrs: { name: "theme-color", content: themeColor },
+        key: "meta:name:theme-color"
+      }
+    ];
+  }
+  return themeColor.map((tc, index) => ({
+    tag: "meta",
+    attrs: {
+      name: "theme-color",
+      content: tc.color,
+      media: tc.media
+    },
+    key: `meta:name:theme-color:${index}`
+  }));
+}
+function generateColorSchemeTag(colorScheme) {
+  if (!colorScheme) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { name: "color-scheme", content: colorScheme },
+    key: "meta:name:color-scheme"
+  };
+}
+function robotsMetaToString(robots) {
+  const directives = [];
+  if (robots.index === false) {
+    directives.push("noindex");
+  } else if (robots.index === true) {
+    directives.push("index");
+  }
+  if (robots.follow === false) {
+    directives.push("nofollow");
+  } else if (robots.follow === true) {
+    directives.push("follow");
+  }
+  if (robots.noarchive) {
+    directives.push("noarchive");
+  }
+  if (robots.nosnippet) {
+    directives.push("nosnippet");
+  }
+  if (robots.notranslate) {
+    directives.push("notranslate");
+  }
+  if (robots.maxSnippet !== void 0) {
+    directives.push(`max-snippet:${robots.maxSnippet}`);
+  }
+  if (robots.maxImagePreview !== void 0) {
+    directives.push(`max-image-preview:${robots.maxImagePreview}`);
+  }
+  if (robots.maxVideoPreview !== void 0) {
+    directives.push(`max-video-preview:${robots.maxVideoPreview}`);
+  }
+  if (robots.unavailableAfter) {
+    directives.push(`unavailable_after:${robots.unavailableAfter}`);
+  }
+  return directives.join(", ");
+}
+function generateRobotsTag(robots) {
+  if (!robots) {
+    return null;
+  }
+  const content = typeof robots === "string" ? robots : robotsMetaToString(robots);
+  if (!content) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { name: "robots", content },
+    key: "meta:name:robots"
+  };
+}
+function generateGooglebotTag(googleBot) {
+  if (!googleBot) {
+    return null;
+  }
+  const content = typeof googleBot === "string" ? googleBot : robotsMetaToString(googleBot);
+  if (!content) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { name: "googlebot", content },
+    key: "meta:name:googlebot"
+  };
+}
+function generateVerificationTags(verification) {
+  if (!verification) {
+    return [];
+  }
+  const tags = [];
+  if (verification.google) {
+    tags.push({
+      tag: "meta",
+      attrs: { name: "google-site-verification", content: verification.google },
+      key: "meta:name:google-site-verification"
+    });
+  }
+  if (verification.bing) {
+    tags.push({
+      tag: "meta",
+      attrs: { name: "msvalidate.01", content: verification.bing },
+      key: "meta:name:msvalidate.01"
+    });
+  }
+  if (verification.yandex) {
+    tags.push({
+      tag: "meta",
+      attrs: { name: "yandex-verification", content: verification.yandex },
+      key: "meta:name:yandex-verification"
+    });
+  }
+  if (verification.pinterest) {
+    tags.push({
+      tag: "meta",
+      attrs: { name: "p:domain_verify", content: verification.pinterest },
+      key: "meta:name:p:domain_verify"
+    });
+  }
+  if (verification.norton) {
+    tags.push({
+      tag: "meta",
+      attrs: { name: "norton-safeweb-site-verification", content: verification.norton },
+      key: "meta:name:norton-safeweb-site-verification"
+    });
+  }
+  return tags;
+}
+function generateCanonicalTag(canonical) {
+  if (!canonical) {
+    return null;
+  }
+  return {
+    tag: "link",
+    attrs: { rel: "canonical", href: canonical },
+    key: "link:canonical"
+  };
+}
+function generateBaseTag(base) {
+  if (!base) {
+    return null;
+  }
+  return {
+    tag: "base",
+    attrs: { href: base },
+    key: "base"
+  };
+}
+function generateAlternateTags(alternates) {
+  if (!alternates || alternates.length === 0) {
+    return [];
+  }
+  return alternates.map((alt, index) => {
+    const attrs = {
+      rel: "alternate",
+      href: alt.href
+    };
+    if (alt.hreflang) {
+      attrs.hreflang = alt.hreflang;
+    }
+    if (alt.media) {
+      attrs.media = alt.media;
+    }
+    if (alt.type) {
+      attrs.type = alt.type;
+    }
+    if (alt.title) {
+      attrs.title = alt.title;
+    }
+    return {
+      tag: "link",
+      attrs,
+      key: `link:alternate:${alt.hreflang || index}`
+    };
+  });
+}
+function generateManifestTag(manifest) {
+  if (!manifest) {
+    return null;
+  }
+  return {
+    tag: "link",
+    attrs: { rel: "manifest", href: manifest },
+    key: "link:manifest"
+  };
+}
+function generateMetaTags(metadata, options) {
+  const tags = [];
+  tags.push(generateCharsetTag(metadata.charset));
+  const base = generateBaseTag(metadata.base);
+  if (base) tags.push(base);
+  const viewport = generateViewportTag(metadata.viewport);
+  if (viewport) tags.push(viewport);
+  const title = generateTitleTag(
+    metadata.title,
+    metadata.titleTemplate || options?.titleTemplate,
+    metadata.defaultTitle || options?.defaultTitle
+  );
+  if (title) tags.push(title);
+  const description = generateDescriptionTag(metadata.description);
+  if (description) tags.push(description);
+  const keywords = generateKeywordsTag(metadata.keywords);
+  if (keywords) tags.push(keywords);
+  const author = generateAuthorTag(metadata.author);
+  if (author) tags.push(author);
+  const generator = generateGeneratorTag(metadata.generator);
+  if (generator) tags.push(generator);
+  const appName = generateApplicationNameTag(metadata.applicationName);
+  if (appName) tags.push(appName);
+  const referrer = generateReferrerTag(metadata.referrer);
+  if (referrer) tags.push(referrer);
+  tags.push(...generateThemeColorTags(metadata.themeColor));
+  const colorScheme = generateColorSchemeTag(metadata.colorScheme);
+  if (colorScheme) tags.push(colorScheme);
+  const robots = generateRobotsTag(metadata.robots);
+  if (robots) tags.push(robots);
+  const googleBot = generateGooglebotTag(metadata.googleBot);
+  if (googleBot) tags.push(googleBot);
+  tags.push(...generateVerificationTags(metadata.verification));
+  const canonical = generateCanonicalTag(metadata.canonical);
+  if (canonical) tags.push(canonical);
+  tags.push(...generateAlternateTags(metadata.alternates));
+  const manifest = generateManifestTag(metadata.manifest);
+  if (manifest) tags.push(manifest);
+  if (metadata.other) {
+    for (const [name, content] of Object.entries(metadata.other)) {
+      tags.push({
+        tag: "meta",
+        attrs: { name, content },
+        key: `meta:name:${name}`
+      });
+    }
+  }
+  return tags;
+}
+
+// src/opengraph.ts
+function ogTag(property, content) {
+  if (content === void 0 || content === null || content === "") {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { property: `og:${property}`, content: String(content) },
+    key: `meta:property:og:${property}`
+  };
+}
+function articleTag(property, content) {
+  if (!content) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { property: `article:${property}`, content },
+    key: `meta:property:article:${property}`
+  };
+}
+function profileTag(property, content) {
+  if (!content) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { property: `profile:${property}`, content },
+    key: `meta:property:profile:${property}`
+  };
+}
+function bookTag(property, content) {
+  if (!content) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { property: `book:${property}`, content },
+    key: `meta:property:book:${property}`
+  };
+}
+function productTag(property, content) {
+  if (content === void 0 || content === null || content === "") {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { property: `product:${property}`, content: String(content) },
+    key: `meta:property:product:${property}`
+  };
+}
+function generateImageTags(images) {
+  if (!images || images.length === 0) {
+    return [];
+  }
+  const tags = [];
+  images.forEach((image, index) => {
+    const suffix = index > 0 ? `:${index}` : "";
+    tags.push({
+      tag: "meta",
+      attrs: { property: "og:image", content: image.url },
+      key: `meta:property:og:image${suffix}`
+    });
+    if (image.secureUrl) {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:image:secure_url", content: image.secureUrl },
+        key: `meta:property:og:image:secure_url${suffix}`
+      });
+    }
+    if (image.type) {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:image:type", content: image.type },
+        key: `meta:property:og:image:type${suffix}`
+      });
+    }
+    if (image.width) {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:image:width", content: String(image.width) },
+        key: `meta:property:og:image:width${suffix}`
+      });
+    }
+    if (image.height) {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:image:height", content: String(image.height) },
+        key: `meta:property:og:image:height${suffix}`
+      });
+    }
+    if (image.alt) {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:image:alt", content: image.alt },
+        key: `meta:property:og:image:alt${suffix}`
+      });
+    }
+  });
+  return tags;
+}
+function generateVideoTags(videos) {
+  if (!videos || videos.length === 0) {
+    return [];
+  }
+  const tags = [];
+  videos.forEach((video, index) => {
+    const suffix = index > 0 ? `:${index}` : "";
+    tags.push({
+      tag: "meta",
+      attrs: { property: "og:video", content: video.url },
+      key: `meta:property:og:video${suffix}`
+    });
+    if (video.secureUrl) {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:video:secure_url", content: video.secureUrl },
+        key: `meta:property:og:video:secure_url${suffix}`
+      });
+    }
+    if (video.type) {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:video:type", content: video.type },
+        key: `meta:property:og:video:type${suffix}`
+      });
+    }
+    if (video.width) {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:video:width", content: String(video.width) },
+        key: `meta:property:og:video:width${suffix}`
+      });
+    }
+    if (video.height) {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:video:height", content: String(video.height) },
+        key: `meta:property:og:video:height${suffix}`
+      });
+    }
+  });
+  return tags;
+}
+function generateAudioTags(audio) {
+  if (!audio || audio.length === 0) {
+    return [];
+  }
+  const tags = [];
+  audio.forEach((a, index) => {
+    const suffix = index > 0 ? `:${index}` : "";
+    tags.push({
+      tag: "meta",
+      attrs: { property: "og:audio", content: a.url },
+      key: `meta:property:og:audio${suffix}`
+    });
+    if (a.secureUrl) {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:audio:secure_url", content: a.secureUrl },
+        key: `meta:property:og:audio:secure_url${suffix}`
+      });
+    }
+    if (a.type) {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:audio:type", content: a.type },
+        key: `meta:property:og:audio:type${suffix}`
+      });
+    }
+  });
+  return tags;
+}
+function generateArticleTags(article) {
+  if (!article) {
+    return [];
+  }
+  const tags = [];
+  const publishedTime = articleTag("published_time", article.publishedTime);
+  if (publishedTime) tags.push(publishedTime);
+  const modifiedTime = articleTag("modified_time", article.modifiedTime);
+  if (modifiedTime) tags.push(modifiedTime);
+  const expirationTime = articleTag("expiration_time", article.expirationTime);
+  if (expirationTime) tags.push(expirationTime);
+  const section = articleTag("section", article.section);
+  if (section) tags.push(section);
+  if (article.authors) {
+    article.authors.forEach((author, index) => {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "article:author", content: author },
+        key: `meta:property:article:author:${index}`
+      });
+    });
+  }
+  if (article.tags) {
+    article.tags.forEach((tag, index) => {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "article:tag", content: tag },
+        key: `meta:property:article:tag:${index}`
+      });
+    });
+  }
+  return tags;
+}
+function generateProfileTags(profile) {
+  if (!profile) {
+    return [];
+  }
+  const tags = [];
+  const firstName = profileTag("first_name", profile.firstName);
+  if (firstName) tags.push(firstName);
+  const lastName = profileTag("last_name", profile.lastName);
+  if (lastName) tags.push(lastName);
+  const username = profileTag("username", profile.username);
+  if (username) tags.push(username);
+  const gender = profileTag("gender", profile.gender);
+  if (gender) tags.push(gender);
+  return tags;
+}
+function generateBookTags(book) {
+  if (!book) {
+    return [];
+  }
+  const tags = [];
+  if (book.authors) {
+    book.authors.forEach((author, index) => {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "book:author", content: author },
+        key: `meta:property:book:author:${index}`
+      });
+    });
+  }
+  const isbn = bookTag("isbn", book.isbn);
+  if (isbn) tags.push(isbn);
+  const releaseDate = bookTag("release_date", book.releaseDate);
+  if (releaseDate) tags.push(releaseDate);
+  if (book.tags) {
+    book.tags.forEach((tag, index) => {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "book:tag", content: tag },
+        key: `meta:property:book:tag:${index}`
+      });
+    });
+  }
+  return tags;
+}
+function generateProductTags(product) {
+  if (!product) {
+    return [];
+  }
+  const tags = [];
+  const price = productTag("price:amount", product.priceAmount);
+  if (price) tags.push(price);
+  const currency = productTag("price:currency", product.priceCurrency);
+  if (currency) tags.push(currency);
+  const availability = productTag("availability", product.availability);
+  if (availability) tags.push(availability);
+  const condition = productTag("condition", product.condition);
+  if (condition) tags.push(condition);
+  const retailerId = productTag("retailer_item_id", product.retailerItemId);
+  if (retailerId) tags.push(retailerId);
+  return tags;
+}
+function generateOpenGraphTags(og) {
+  if (!og) {
+    return [];
+  }
+  const tags = [];
+  const type = ogTag("type", og.type || "website");
+  if (type) tags.push(type);
+  const title = ogTag("title", og.title);
+  if (title) tags.push(title);
+  const description = ogTag("description", og.description);
+  if (description) tags.push(description);
+  const url = ogTag("url", og.url);
+  if (url) tags.push(url);
+  const siteName = ogTag("site_name", og.siteName);
+  if (siteName) tags.push(siteName);
+  const locale = ogTag("locale", og.locale);
+  if (locale) tags.push(locale);
+  if (og.alternateLocales) {
+    og.alternateLocales.forEach((alternateLocale, index) => {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:locale:alternate", content: alternateLocale },
+        key: `meta:property:og:locale:alternate:${index}`
+      });
+    });
+  }
+  const determiner = ogTag("determiner", og.determiner);
+  if (determiner) tags.push(determiner);
+  tags.push(...generateImageTags(og.images));
+  tags.push(...generateVideoTags(og.videos));
+  tags.push(...generateAudioTags(og.audio));
+  tags.push(...generateArticleTags(og.article));
+  tags.push(...generateProfileTags(og.profile));
+  tags.push(...generateBookTags(og.book));
+  tags.push(...generateProductTags(og.product));
+  return tags;
+}
+function generateOpenGraphFallback(title, description, url) {
+  const tags = [];
+  const typeTag = ogTag("type", "website");
+  if (typeTag) tags.push(typeTag);
+  const titleTag = ogTag("title", title);
+  if (titleTag) tags.push(titleTag);
+  const descTag = ogTag("description", description);
+  if (descTag) tags.push(descTag);
+  const urlTag = ogTag("url", url);
+  if (urlTag) tags.push(urlTag);
+  return tags;
+}
+
+// src/twitter.ts
+function twitterTag(name, content) {
+  if (!content) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { name: `twitter:${name}`, content },
+    key: `meta:name:twitter:${name}`
+  };
+}
+function normalizeImage(image) {
+  if (!image) {
+    return void 0;
+  }
+  if (typeof image === "string") {
+    return { url: image };
+  }
+  return image;
+}
+function generateTwitterTags(twitter) {
+  if (!twitter) {
+    return [];
+  }
+  const tags = [];
+  const card = twitterTag("card", twitter.card || "summary");
+  if (card) tags.push(card);
+  const title = twitterTag("title", twitter.title);
+  if (title) tags.push(title);
+  const description = twitterTag("description", twitter.description);
+  if (description) tags.push(description);
+  const site = twitterTag("site", twitter.site);
+  if (site) tags.push(site);
+  const siteId = twitterTag("site:id", twitter.siteId);
+  if (siteId) tags.push(siteId);
+  const creator = twitterTag("creator", twitter.creator);
+  if (creator) tags.push(creator);
+  const creatorId = twitterTag("creator:id", twitter.creatorId);
+  if (creatorId) tags.push(creatorId);
+  const image = normalizeImage(twitter.image);
+  if (image) {
+    const imageTag = twitterTag("image", image.url);
+    if (imageTag) tags.push(imageTag);
+    if (image.alt) {
+      const imageAlt = twitterTag("image:alt", image.alt);
+      if (imageAlt) tags.push(imageAlt);
+    }
+  }
+  if (twitter.images && twitter.images.length > 0) {
+    twitter.images.forEach((img, index) => {
+      if (index >= 4) return;
+      const normalizedImg = typeof img === "string" ? { url: img } : img;
+      tags.push({
+        tag: "meta",
+        attrs: { name: `twitter:image${index}`, content: normalizedImg.url },
+        key: `meta:name:twitter:image${index}`
+      });
+      if (normalizedImg.alt) {
+        tags.push({
+          tag: "meta",
+          attrs: { name: `twitter:image${index}:alt`, content: normalizedImg.alt },
+          key: `meta:name:twitter:image${index}:alt`
+        });
+      }
+    });
+  }
+  if (twitter.player) {
+    const playerUrl = twitterTag("player", twitter.player.url);
+    if (playerUrl) tags.push(playerUrl);
+    const playerWidth = twitterTag("player:width", String(twitter.player.width));
+    if (playerWidth) tags.push(playerWidth);
+    const playerHeight = twitterTag("player:height", String(twitter.player.height));
+    if (playerHeight) tags.push(playerHeight);
+    if (twitter.player.stream) {
+      const stream = twitterTag("player:stream", twitter.player.stream);
+      if (stream) tags.push(stream);
+    }
+  }
+  if (twitter.app) {
+    const appName = twitterTag("app:name:iphone", twitter.app.name);
+    if (appName) tags.push(appName);
+    tags.push({
+      tag: "meta",
+      attrs: { name: "twitter:app:name:ipad", content: twitter.app.name },
+      key: "meta:name:twitter:app:name:ipad"
+    });
+    tags.push({
+      tag: "meta",
+      attrs: { name: "twitter:app:name:googleplay", content: twitter.app.name },
+      key: "meta:name:twitter:app:name:googleplay"
+    });
+    if (twitter.app.id.iphone) {
+      const iphoneId = twitterTag("app:id:iphone", twitter.app.id.iphone);
+      if (iphoneId) tags.push(iphoneId);
+    }
+    if (twitter.app.id.ipad) {
+      const ipadId = twitterTag("app:id:ipad", twitter.app.id.ipad);
+      if (ipadId) tags.push(ipadId);
+    }
+    if (twitter.app.id.googleplay) {
+      const googleId = twitterTag("app:id:googleplay", twitter.app.id.googleplay);
+      if (googleId) tags.push(googleId);
+    }
+    if (twitter.app.url) {
+      if (twitter.app.url.iphone) {
+        const iphoneUrl = twitterTag("app:url:iphone", twitter.app.url.iphone);
+        if (iphoneUrl) tags.push(iphoneUrl);
+      }
+      if (twitter.app.url.ipad) {
+        const ipadUrl = twitterTag("app:url:ipad", twitter.app.url.ipad);
+        if (ipadUrl) tags.push(ipadUrl);
+      }
+      if (twitter.app.url.googleplay) {
+        const googleUrl = twitterTag("app:url:googleplay", twitter.app.url.googleplay);
+        if (googleUrl) tags.push(googleUrl);
+      }
+    }
+  }
+  if (twitter.label1) {
+    const label1 = twitterTag("label1", twitter.label1);
+    if (label1) tags.push(label1);
+  }
+  if (twitter.data1) {
+    const data1 = twitterTag("data1", twitter.data1);
+    if (data1) tags.push(data1);
+  }
+  if (twitter.label2) {
+    const label2 = twitterTag("label2", twitter.label2);
+    if (label2) tags.push(label2);
+  }
+  if (twitter.data2) {
+    const data2 = twitterTag("data2", twitter.data2);
+    if (data2) tags.push(data2);
+  }
+  return tags;
+}
+function generateTwitterFallback(title, description, image, cardType = "summary") {
+  const tags = [];
+  const card = twitterTag("card", cardType);
+  if (card) tags.push(card);
+  const titleTag = twitterTag("title", title);
+  if (titleTag) tags.push(titleTag);
+  const descTag = twitterTag("description", description);
+  if (descTag) tags.push(descTag);
+  const imageTag = twitterTag("image", image);
+  if (imageTag) tags.push(imageTag);
+  return tags;
+}
+
+// src/index.ts
+function createSEO(config = {}) {
+  const fullConfig = {
+    baseUrl: config.baseUrl || "",
+    titleTemplate: config.titleTemplate,
+    defaultTitle: config.defaultTitle,
+    defaultOpenGraph: config.defaultOpenGraph,
+    defaultTwitter: config.defaultTwitter,
+    features: {
+      openGraph: config.features?.openGraph ?? true,
+      twitter: config.features?.twitter ?? true,
+      robots: config.features?.robots ?? true
+    }
+  };
+  return {
+    config: fullConfig,
+    render(metadata) {
+      const tags = generateAllTags(metadata, fullConfig);
+      const html = renderTags(tags);
+      return { tags, html };
+    },
+    merge(parent, child) {
+      return mergeMetadata(parent, child);
+    },
+    resolveTitle(metadata) {
+      return resolveTitleWithTemplate(
+        metadata.title,
+        metadata.titleTemplate || fullConfig.titleTemplate,
+        metadata.defaultTitle || fullConfig.defaultTitle
+      );
+    },
+    canonical(path) {
+      if (!fullConfig.baseUrl) {
+        return path;
+      }
+      const base = fullConfig.baseUrl.endsWith("/") ? fullConfig.baseUrl.slice(0, -1) : fullConfig.baseUrl;
+      const normalizedPath = path.startsWith("/") ? path : "/" + path;
+      return base + normalizedPath;
+    }
+  };
+}
+function mergeMetadata(parent, child) {
+  return {
+    ...parent,
+    ...child,
+    // Merge Open Graph
+    openGraph: child.openGraph ? { ...parent.openGraph, ...child.openGraph } : parent.openGraph,
+    // Merge Twitter
+    twitter: child.twitter ? { ...parent.twitter, ...child.twitter } : parent.twitter,
+    // Merge Apple
+    apple: child.apple ? { ...parent.apple, ...child.apple } : parent.apple,
+    // Merge Icons
+    icons: child.icons ? { ...parent.icons, ...child.icons } : parent.icons,
+    // Merge verification
+    verification: child.verification ? { ...parent.verification, ...child.verification } : parent.verification,
+    // Merge other
+    other: child.other ? { ...parent.other, ...child.other } : parent.other
+  };
+}
+function resolveTitleWithTemplate(title, template, defaultTitle) {
+  const resolvedTitle = title || defaultTitle || "";
+  if (!resolvedTitle) {
+    return "";
+  }
+  if (template && title) {
+    return template.replace("%s", title);
+  }
+  return resolvedTitle;
+}
+function generateAllTags(metadata, config) {
+  const tags = [];
+  tags.push(...generateMetaTags(metadata, {
+    titleTemplate: config.titleTemplate,
+    defaultTitle: config.defaultTitle
+  }));
+  if (config.features?.openGraph !== false) {
+    if (metadata.openGraph) {
+      const og = { ...config.defaultOpenGraph, ...metadata.openGraph };
+      tags.push(...generateOpenGraphTags(og));
+    } else if (metadata.title || metadata.description) {
+      tags.push(...generateOpenGraphFallback(
+        metadata.title,
+        metadata.description,
+        metadata.canonical
+      ));
+    }
+  }
+  if (config.features?.twitter !== false) {
+    if (metadata.twitter) {
+      const twitter = { ...config.defaultTwitter, ...metadata.twitter };
+      tags.push(...generateTwitterTags(twitter));
+    } else if (metadata.title || metadata.description) {
+      const ogImage = metadata.openGraph?.images?.[0];
+      const imageUrl = typeof ogImage === "string" ? ogImage : ogImage?.url;
+      tags.push(...generateTwitterFallback(
+        metadata.title,
+        metadata.description,
+        imageUrl
+      ));
+    }
+  }
+  if (metadata.icons) {
+    tags.push(...generateIconTags(metadata.icons));
+  }
+  if (metadata.apple) {
+    tags.push(...generateAppleTags(metadata.apple));
+  }
+  return tags;
+}
+function generateIconTags(icons) {
+  if (!icons) return [];
+  const tags = [];
+  if (icons.icon) {
+    const iconList = Array.isArray(icons.icon) ? icons.icon : [icons.icon];
+    iconList.forEach((icon, index) => {
+      const iconData = typeof icon === "string" ? { url: icon } : icon;
+      tags.push({
+        tag: "link",
+        attrs: {
+          rel: "icon",
+          href: iconData.url,
+          type: iconData.type,
+          sizes: iconData.sizes
+        },
+        key: `link:icon:${index}`
+      });
+    });
+  }
+  if (icons.shortcut) {
+    const shortcut = typeof icons.shortcut === "string" ? { url: icons.shortcut } : icons.shortcut;
+    tags.push({
+      tag: "link",
+      attrs: {
+        rel: "shortcut icon",
+        href: shortcut.url,
+        type: shortcut.type
+      },
+      key: "link:shortcut-icon"
+    });
+  }
+  if (icons.apple) {
+    const appleList = Array.isArray(icons.apple) ? icons.apple : [icons.apple];
+    appleList.forEach((icon, index) => {
+      const iconData = typeof icon === "string" ? { url: icon } : icon;
+      tags.push({
+        tag: "link",
+        attrs: {
+          rel: "apple-touch-icon",
+          href: iconData.url,
+          sizes: iconData.sizes
+        },
+        key: `link:apple-touch-icon:${index}`
+      });
+    });
+  }
+  return tags;
+}
+function generateAppleTags(apple) {
+  if (!apple) return [];
+  const tags = [];
+  if (apple.mobileWebAppCapable) {
+    tags.push({
+      tag: "meta",
+      attrs: { name: "apple-mobile-web-app-capable", content: "yes" },
+      key: "meta:name:apple-mobile-web-app-capable"
+    });
+  }
+  if (apple.statusBarStyle) {
+    tags.push({
+      tag: "meta",
+      attrs: { name: "apple-mobile-web-app-status-bar-style", content: apple.statusBarStyle },
+      key: "meta:name:apple-mobile-web-app-status-bar-style"
+    });
+  }
+  if (apple.title) {
+    tags.push({
+      tag: "meta",
+      attrs: { name: "apple-mobile-web-app-title", content: apple.title },
+      key: "meta:name:apple-mobile-web-app-title"
+    });
+  }
+  if (apple.touchIcon) {
+    const touchIcon = typeof apple.touchIcon === "string" ? { url: apple.touchIcon } : apple.touchIcon;
+    tags.push({
+      tag: "link",
+      attrs: {
+        rel: "apple-touch-icon",
+        href: touchIcon.url,
+        sizes: touchIcon.sizes
+      },
+      key: "link:apple-touch-icon-from-apple"
+    });
+  }
+  return tags;
+}
+
+// src/json-ld/index.ts
+function createJsonLd(schema, options) {
+  const data = {
+    "@context": "https://schema.org",
+    ...schema
+  };
+  return JSON.stringify(data);
+}
+
+// src/vue/index.ts
+var SEO_KEY = /* @__PURE__ */ Symbol("flight-seo");
+function provideSEO(defaultMetadata = {}) {
+  const metadata = reactive({ ...defaultMetadata });
+  const state = {
+    metadata,
+    setMetadata: (newMetadata) => {
+      Object.assign(metadata, newMetadata);
+    },
+    addMetadata: (additionalMetadata) => {
+      Object.assign(metadata, mergeMetadata(metadata, additionalMetadata));
+    }
+  };
+  provide(SEO_KEY, state);
+  return state;
+}
+function injectSEO() {
+  return inject(SEO_KEY);
+}
+function useSEO(metadata, options = {}) {
+  const { immediate = true } = options;
+  const seoContext = injectSEO();
+  const metadataRef = computed(() => {
+    if ("value" in metadata) {
+      return metadata.value;
+    }
+    return metadata;
+  });
+  const updateHead = () => {
+    if (typeof document === "undefined") return;
+    const meta = metadataRef.value;
+    if (meta.title) {
+      const title = meta.titleTemplate ? meta.titleTemplate.replace("%s", meta.title) : meta.title;
+      document.title = title;
+    }
+    if (meta.description) {
+      updateMetaTag("description", meta.description);
+    }
+    if (meta.canonical) {
+      updateLinkTag("canonical", meta.canonical);
+    }
+    if (meta.openGraph) {
+      updateOpenGraphTags(meta.openGraph);
+    }
+    if (meta.twitter) {
+      updateTwitterTags(meta.twitter);
+    }
+    if (seoContext) {
+      seoContext.addMetadata(meta);
+    }
+  };
+  watch(metadataRef, updateHead, { deep: true, immediate });
+  onMounted(() => {
+    if (immediate) {
+      updateHead();
+    }
+  });
+}
+function useSeoMeta(input) {
+  const inputRef = computed(() => {
+    if ("value" in input) {
+      return input.value;
+    }
+    return input;
+  });
+  const metadata = computed(() => {
+    const i = inputRef.value;
+    return {
+      title: i.title,
+      titleTemplate: i.titleTemplate,
+      description: i.description,
+      keywords: i.keywords,
+      author: i.author,
+      robots: i.robots ? { index: !i.robots.includes("noindex"), follow: !i.robots.includes("nofollow") } : void 0,
+      canonical: i.canonical,
+      openGraph: i.ogTitle || i.ogDescription || i.ogImage ? {
+        title: i.ogTitle,
+        description: i.ogDescription,
+        url: i.ogUrl,
+        type: i.ogType,
+        siteName: i.ogSiteName,
+        locale: i.ogLocale,
+        images: i.ogImage ? [{ url: i.ogImage }] : void 0
+      } : void 0,
+      twitter: i.twitterCard || i.twitterTitle || i.twitterImage ? {
+        card: i.twitterCard,
+        title: i.twitterTitle,
+        description: i.twitterDescription,
+        site: i.twitterSite,
+        creator: i.twitterCreator,
+        image: i.twitterImage ? { url: i.twitterImage } : void 0
+      } : void 0
+    };
+  });
+  useSEO(metadata);
+}
+function useJsonLd(schema, options) {
+  const schemaRef = computed(() => {
+    if ("value" in schema) {
+      return schema.value;
+    }
+    return schema;
+  });
+  const scriptId = options?.id ? `json-ld-${options.id}` : "json-ld-data";
+  let scriptElement = null;
+  const updateScript = () => {
+    if (typeof document === "undefined") return;
+    const jsonLd = createJsonLd(schemaRef.value);
+    if (!scriptElement) {
+      scriptElement = document.getElementById(scriptId);
+      if (!scriptElement) {
+        scriptElement = document.createElement("script");
+        scriptElement.type = "application/ld+json";
+        scriptElement.id = scriptId;
+        document.head.appendChild(scriptElement);
+      }
+    }
+    scriptElement.textContent = jsonLd;
+  };
+  watch(schemaRef, updateScript, { deep: true, immediate: true });
+  onMounted(updateScript);
+  onUnmounted(() => {
+    if (scriptElement && scriptElement.parentNode) {
+      scriptElement.parentNode.removeChild(scriptElement);
+    }
+  });
+}
+function renderMetadataToString(metadata) {
+  const seo = createSEO();
+  const { html } = seo.render(metadata);
+  return html;
+}
+function updateMetaTag(name, content) {
+  let meta = document.querySelector(`meta[name="${name}"]`);
+  if (!meta) {
+    meta = document.createElement("meta");
+    meta.setAttribute("name", name);
+    document.head.appendChild(meta);
+  }
+  meta.setAttribute("content", content);
+}
+function updateLinkTag(rel, href) {
+  let link = document.querySelector(`link[rel="${rel}"]`);
+  if (!link) {
+    link = document.createElement("link");
+    link.setAttribute("rel", rel);
+    document.head.appendChild(link);
+  }
+  link.setAttribute("href", href);
+}
+function updateOpenGraphTags(og) {
+  const properties = {
+    "og:title": og.title,
+    "og:description": og.description,
+    "og:type": og.type,
+    "og:url": og.url,
+    "og:site_name": og.siteName,
+    "og:locale": og.locale
+  };
+  for (const [property, content] of Object.entries(properties)) {
+    if (content) {
+      updatePropertyMetaTag(property, content);
+    }
+  }
+  if (og.images && og.images.length > 0) {
+    updatePropertyMetaTag("og:image", og.images[0].url);
+  }
+}
+function updateTwitterTags(twitter) {
+  const names = {
+    "twitter:card": twitter.card,
+    "twitter:title": twitter.title,
+    "twitter:description": twitter.description,
+    "twitter:site": twitter.site,
+    "twitter:creator": twitter.creator
+  };
+  for (const [name, content] of Object.entries(names)) {
+    if (content) {
+      updateNameMetaTag(name, content);
+    }
+  }
+  if (twitter.image) {
+    const imageUrl = typeof twitter.image === "string" ? twitter.image : twitter.image.url;
+    updateNameMetaTag("twitter:image", imageUrl);
+  }
+}
+function updatePropertyMetaTag(property, content) {
+  let meta = document.querySelector(`meta[property="${property}"]`);
+  if (!meta) {
+    meta = document.createElement("meta");
+    meta.setAttribute("property", property);
+    document.head.appendChild(meta);
+  }
+  meta.setAttribute("content", content);
+}
+function updateNameMetaTag(name, content) {
+  let meta = document.querySelector(`meta[name="${name}"]`);
+  if (!meta) {
+    meta = document.createElement("meta");
+    meta.setAttribute("name", name);
+    document.head.appendChild(meta);
+  }
+  meta.setAttribute("content", content);
+}
+
+export { injectSEO, provideSEO, renderMetadataToString, useJsonLd, useSEO, useSeoMeta };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map