@ubean/seo 0.1.1 → 0.1.3

package/dist/index.d.ts

@@ -0,0 +1,110 @@
+import { UseSeoMetaInput } from "@unhead/vue";
+//#region src/index.d.ts
+interface RobotsOptions {
+  userAgent?: string;
+  allow?: string | string[];
+  disallow?: string | string[];
+  sitemap?: string | string[];
+  crawlDelay?: number;
+}
+interface SitemapUrl {
+  loc: string;
+  lastmod?: string | Date;
+  changefreq?: 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
+  priority?: number;
+}
+interface MetaTag {
+  name?: string;
+  property?: string;
+  content: string;
+}
+interface LinkTag {
+  rel: string;
+  href: string;
+  hreflang?: string;
+  type?: string;
+  sizes?: string;
+  media?: string;
+  as?: string;
+  crossorigin?: '' | 'anonymous' | 'use-credentials';
+}
+interface OpenGraphMeta {
+  title?: string;
+  description?: string;
+  type?: 'website' | 'article' | 'book' | 'profile' | 'music.song' | 'music.album' | 'video.movie';
+  url?: string;
+  image?: string | OGImage;
+  siteName?: string;
+  locale?: string;
+  localeAlternate?: string[];
+}
+interface OGImage {
+  url: string;
+  width?: number;
+  height?: number;
+  alt?: string;
+  type?: string;
+}
+interface TwitterMeta {
+  card?: 'summary' | 'summary_large_image' | 'app' | 'player';
+  site?: string;
+  creator?: string;
+  title?: string;
+  description?: string;
+  image?: string;
+}
+interface SeoMetadata {
+  title?: string;
+  titleTemplate?: string | ((title: string) => string);
+  description?: string;
+  keywords?: string | string[];
+  author?: string;
+  canonical?: string;
+  robots?: string | {
+    index?: boolean;
+    follow?: boolean;
+  };
+  openGraph?: OpenGraphMeta;
+  twitter?: TwitterMeta;
+  meta?: MetaTag[];
+  link?: LinkTag[];
+  htmlAttrs?: Record<string, string>;
+  bodyAttrs?: Record<string, string>;
+}
+interface ManifestIcon {
+  src: string;
+  sizes: string;
+  type: string;
+  purpose?: string;
+}
+interface WebAppManifest {
+  name?: string;
+  short_name?: string;
+  description?: string;
+  start_url?: string;
+  display?: 'fullscreen' | 'standalone' | 'minimal-ui' | 'browser';
+  background_color?: string;
+  theme_color?: string;
+  orientation?: 'portrait' | 'landscape' | 'any';
+  icons?: ManifestIcon[];
+  scope?: string;
+  lang?: string;
+  dir?: 'ltr' | 'rtl' | 'auto';
+}
+declare function useSeoMeta<T extends Record<string, any>>(meta: T): T;
+declare function mergeMetadata(...metadatas: (SeoMetadata | undefined | null)[]): SeoMetadata;
+declare function buildMetaTags(meta: SeoMetadata): MetaTag[];
+declare function buildLinkTags(meta: SeoMetadata): LinkTag[];
+declare function buildTitle(meta: SeoMetadata, fallbackTitle?: string): string;
+declare function renderHeadTags(meta: SeoMetadata, fallbackTitle?: string): string;
+declare function createManifestResponse(manifest: WebAppManifest): Response;
+declare function defineManifest(manifest: WebAppManifest): WebAppManifest;
+declare function formatRobotsTxt(options: RobotsOptions[] | RobotsOptions): string;
+declare function escapeXml(str: string): string;
+declare function formatSitemapXml(urls: SitemapUrl[]): string;
+declare function createRobotsResponse(options: RobotsOptions[] | RobotsOptions): Response;
+declare function createSitemapResponse(urls: SitemapUrl[]): Response;
+declare function defineRobotsConfig(config: RobotsOptions[] | RobotsOptions): RobotsOptions[] | RobotsOptions;
+declare function defineSitemapConfig(urls: SitemapUrl[] | (() => SitemapUrl[] | Promise<SitemapUrl[]>)): SitemapUrl[] | (() => SitemapUrl[] | Promise<SitemapUrl[]>);
+//#endregion
+export { LinkTag, ManifestIcon, MetaTag, OGImage, OpenGraphMeta, RobotsOptions, SeoMetadata, SitemapUrl, TwitterMeta, type UseSeoMetaInput, WebAppManifest, buildLinkTags, buildMetaTags, buildTitle, createManifestResponse, createRobotsResponse, createSitemapResponse, defineManifest, defineRobotsConfig, defineSitemapConfig, escapeXml, formatRobotsTxt, formatSitemapXml, mergeMetadata, renderHeadTags, useSeoMeta };

package/dist/index.js

@@ -0,0 +1,272 @@
+import { useSeoMeta as useSeoMeta$1 } from "@unhead/vue";
+//#region src/index.ts
+function useSeoMeta(meta) {
+	try {
+		useSeoMeta$1(meta);
+	} catch {}
+	return meta;
+}
+function mergeMetadata(...metadatas) {
+	const result = {};
+	for (const meta of metadatas) {
+		if (!meta) continue;
+		if (meta.title !== void 0) result.title = meta.title;
+		if (meta.titleTemplate !== void 0) result.titleTemplate = meta.titleTemplate;
+		if (meta.description !== void 0) result.description = meta.description;
+		if (meta.keywords !== void 0) result.keywords = meta.keywords;
+		if (meta.author !== void 0) result.author = meta.author;
+		if (meta.canonical !== void 0) result.canonical = meta.canonical;
+		if (meta.robots !== void 0) result.robots = meta.robots;
+		if (meta.htmlAttrs) result.htmlAttrs = {
+			...result.htmlAttrs,
+			...meta.htmlAttrs
+		};
+		if (meta.bodyAttrs) result.bodyAttrs = {
+			...result.bodyAttrs,
+			...meta.bodyAttrs
+		};
+		if (meta.openGraph) result.openGraph = {
+			...result.openGraph,
+			...meta.openGraph
+		};
+		if (meta.twitter) result.twitter = {
+			...result.twitter,
+			...meta.twitter
+		};
+		if (meta.meta) result.meta = [...result.meta || [], ...meta.meta];
+		if (meta.link) result.link = [...result.link || [], ...meta.link];
+	}
+	return result;
+}
+function buildMetaTags(meta) {
+	const tags = [];
+	if (meta.description) tags.push({
+		name: "description",
+		content: meta.description
+	});
+	if (meta.keywords) {
+		const kws = Array.isArray(meta.keywords) ? meta.keywords.join(", ") : meta.keywords;
+		tags.push({
+			name: "keywords",
+			content: kws
+		});
+	}
+	if (meta.author) tags.push({
+		name: "author",
+		content: meta.author
+	});
+	if (meta.robots) {
+		let robotsValue;
+		if (typeof meta.robots === "string") robotsValue = meta.robots;
+		else {
+			const parts = [];
+			if (meta.robots.index !== void 0) parts.push(meta.robots.index ? "index" : "noindex");
+			if (meta.robots.follow !== void 0) parts.push(meta.robots.follow ? "follow" : "nofollow");
+			robotsValue = parts.join(", ");
+		}
+		if (robotsValue) tags.push({
+			name: "robots",
+			content: robotsValue
+		});
+	}
+	if (meta.openGraph) {
+		const og = meta.openGraph;
+		if (og.title) tags.push({
+			property: "og:title",
+			content: og.title
+		});
+		if (og.description) tags.push({
+			property: "og:description",
+			content: og.description
+		});
+		if (og.type) tags.push({
+			property: "og:type",
+			content: og.type
+		});
+		if (og.url) tags.push({
+			property: "og:url",
+			content: og.url
+		});
+		if (og.siteName) tags.push({
+			property: "og:site_name",
+			content: og.siteName
+		});
+		if (og.locale) tags.push({
+			property: "og:locale",
+			content: og.locale
+		});
+		if (og.localeAlternate) for (const loc of og.localeAlternate) tags.push({
+			property: "og:locale:alternate",
+			content: loc
+		});
+		if (og.image) if (typeof og.image === "string") tags.push({
+			property: "og:image",
+			content: og.image
+		});
+		else {
+			tags.push({
+				property: "og:image",
+				content: og.image.url
+			});
+			if (og.image.width) tags.push({
+				property: "og:image:width",
+				content: String(og.image.width)
+			});
+			if (og.image.height) tags.push({
+				property: "og:image:height",
+				content: String(og.image.height)
+			});
+			if (og.image.alt) tags.push({
+				property: "og:image:alt",
+				content: og.image.alt
+			});
+			if (og.image.type) tags.push({
+				property: "og:image:type",
+				content: og.image.type
+			});
+		}
+	}
+	if (meta.twitter) {
+		const tw = meta.twitter;
+		if (tw.card) tags.push({
+			name: "twitter:card",
+			content: tw.card
+		});
+		if (tw.site) tags.push({
+			name: "twitter:site",
+			content: tw.site
+		});
+		if (tw.creator) tags.push({
+			name: "twitter:creator",
+			content: tw.creator
+		});
+		if (tw.title) tags.push({
+			name: "twitter:title",
+			content: tw.title
+		});
+		if (tw.description) tags.push({
+			name: "twitter:description",
+			content: tw.description
+		});
+		if (tw.image) tags.push({
+			name: "twitter:image",
+			content: tw.image
+		});
+	}
+	if (meta.meta) tags.push(...meta.meta);
+	return tags;
+}
+function buildLinkTags(meta) {
+	const links = [];
+	if (meta.canonical) links.push({
+		rel: "canonical",
+		href: meta.canonical
+	});
+	if (meta.link) links.push(...meta.link);
+	return links;
+}
+function buildTitle(meta, fallbackTitle) {
+	let title = meta.title || fallbackTitle || "";
+	if (meta.titleTemplate && title) if (typeof meta.titleTemplate === "function") title = meta.titleTemplate(title);
+	else title = meta.titleTemplate.replace("%s", title);
+	return title;
+}
+function renderHeadTags(meta, fallbackTitle) {
+	const parts = [];
+	const title = buildTitle(meta, fallbackTitle);
+	if (title) parts.push(`<title>${escapeHtml(title)}</title>`);
+	const metaTags = buildMetaTags(meta);
+	for (const tag of metaTags) if (tag.name) parts.push(`<meta name="${escapeHtml(tag.name)}" content="${escapeHtml(tag.content)}">`);
+	else if (tag.property) parts.push(`<meta property="${escapeHtml(tag.property)}" content="${escapeHtml(tag.content)}">`);
+	const linkTags = buildLinkTags(meta);
+	for (const link of linkTags) {
+		const attrs = [`rel="${escapeHtml(link.rel)}"`, `href="${escapeHtml(link.href)}"`];
+		if (link.hreflang) attrs.push(`hreflang="${escapeHtml(link.hreflang)}"`);
+		if (link.type) attrs.push(`type="${escapeHtml(link.type)}"`);
+		if (link.sizes) attrs.push(`sizes="${escapeHtml(link.sizes)}"`);
+		if (link.media) attrs.push(`media="${escapeHtml(link.media)}"`);
+		if (link.as) attrs.push(`as="${escapeHtml(link.as)}"`);
+		if (link.crossorigin !== void 0) attrs.push(link.crossorigin ? `crossorigin="${escapeHtml(link.crossorigin)}"` : "crossorigin");
+		parts.push(`<link ${attrs.join(" ")}>`);
+	}
+	return parts.join("\n");
+}
+function createManifestResponse(manifest) {
+	return new Response(JSON.stringify(manifest, null, 2), { headers: {
+		"Content-Type": "application/manifest+json; charset=utf-8",
+		"Cache-Control": "public, max-age=86400"
+	} });
+}
+function defineManifest(manifest) {
+	return manifest;
+}
+function escapeHtml(str) {
+	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function formatRobotsTxt(options) {
+	const groups = Array.isArray(options) ? options : [options];
+	const lines = [];
+	for (const group of groups) {
+		lines.push(`User-agent: ${group.userAgent || "*"}`);
+		if (group.allow) {
+			const allows = Array.isArray(group.allow) ? group.allow : [group.allow];
+			for (const path of allows) lines.push(`Allow: ${path}`);
+		}
+		if (group.disallow) {
+			const disallows = Array.isArray(group.disallow) ? group.disallow : [group.disallow];
+			for (const path of disallows) lines.push(`Disallow: ${path}`);
+		}
+		if (group.crawlDelay !== void 0) lines.push(`Crawl-delay: ${group.crawlDelay}`);
+		lines.push("");
+	}
+	const sitemaps = /* @__PURE__ */ new Set();
+	for (const group of groups) if (group.sitemap) {
+		const maps = Array.isArray(group.sitemap) ? group.sitemap : [group.sitemap];
+		for (const url of maps) sitemaps.add(url);
+	}
+	for (const sitemap of sitemaps) lines.push(`Sitemap: ${sitemap}`);
+	return `${lines.join("\n").trim()}\n`;
+}
+function escapeXml(str) {
+	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function formatDate(date) {
+	if (date instanceof Date) return date.toISOString().split("T")[0];
+	return date;
+}
+function formatSitemapXml(urls) {
+	const lines = ["<?xml version=\"1.0\" encoding=\"UTF-8\"?>"];
+	lines.push("<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">");
+	for (const url of urls) {
+		lines.push("  <url>");
+		lines.push(`    <loc>${escapeXml(url.loc)}</loc>`);
+		if (url.lastmod) lines.push(`    <lastmod>${escapeXml(formatDate(url.lastmod))}</lastmod>`);
+		if (url.changefreq) lines.push(`    <changefreq>${url.changefreq}</changefreq>`);
+		if (url.priority !== void 0) lines.push(`    <priority>${url.priority.toFixed(1)}</priority>`);
+		lines.push("  </url>");
+	}
+	lines.push("</urlset>");
+	return lines.join("\n");
+}
+function createRobotsResponse(options) {
+	const body = formatRobotsTxt(options);
+	return new Response(body, { headers: {
+		"Content-Type": "text/plain; charset=utf-8",
+		"Cache-Control": "public, max-age=3600"
+	} });
+}
+function createSitemapResponse(urls) {
+	const body = formatSitemapXml(urls);
+	return new Response(body, { headers: {
+		"Content-Type": "application/xml; charset=utf-8",
+		"Cache-Control": "public, max-age=3600"
+	} });
+}
+function defineRobotsConfig(config) {
+	return config;
+}
+function defineSitemapConfig(urls) {
+	return urls;
+}
+//#endregion
+export { buildLinkTags, buildMetaTags, buildTitle, createManifestResponse, createRobotsResponse, createSitemapResponse, defineManifest, defineRobotsConfig, defineSitemapConfig, escapeXml, formatRobotsTxt, formatSitemapXml, mergeMetadata, renderHeadTags, useSeoMeta };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ubean/seo",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "SEO utilities for ubean (useSeoMeta, robots, sitemap, manifest)",
   "files": [
     "dist"