@autoblogwriter/sdk 1.0.2

package/dist/index.d.cts

@@ -0,0 +1,69 @@
+import { B as BlogAutoClientConfig, F as FetchRequestOptions, P as PostsResponse, a as BlogPost, b as BuildSitemapOptions, M as MetadataRouteSitemap, c as BuildRobotsOptions, d as MetadataRouteRobots, A as AuthMode, I as InternalClientConfig } from './revalidate-445OJMx_.cjs';
+export { g as BlogAutoRevalidatePayload, i as FetchNextConfig, f as PaginatedList, R as RevalidatePathFn, h as RevalidateTagFn, S as SitemapEntry, e as createRevalidateRouteHandler, v as verifyWebhookSignature } from './revalidate-445OJMx_.cjs';
+
+interface BlogAutoClient {
+    getPosts(params?: {
+        limit?: number;
+        cursor?: string;
+    } & FetchRequestOptions): Promise<PostsResponse>;
+    getPostBySlug(slug: string, options?: FetchRequestOptions): Promise<BlogPost | null>;
+    getSitemapEntries(): Promise<Array<{
+        slug: string;
+        updatedAt: string;
+    }>>;
+}
+declare function createBlogAutoClient(config: BlogAutoClientConfig): BlogAutoClient;
+
+declare function buildSitemap(opts: BuildSitemapOptions): MetadataRouteSitemap;
+
+declare function buildRobots(opts: BuildRobotsOptions): MetadataRouteRobots;
+
+declare function renderMarkdownToHtml(markdown: string): string;
+
+interface NextMetadata {
+    title?: string;
+    description?: string;
+    alternates?: {
+        canonical?: string;
+    };
+    openGraph?: {
+        title?: string;
+        description?: string;
+        images?: Array<{
+            url: string;
+        }>;
+    };
+}
+declare function buildNextMetadata(post: BlogPost): NextMetadata;
+
+declare function buildAuthHeaders(apiKey: string, authMode?: AuthMode): Record<string, string>;
+
+declare const DEFAULT_TIMEOUT_MS = 10000;
+declare function resolveClientConfig(config: BlogAutoClientConfig): InternalClientConfig;
+
+declare class BlogAutoError extends Error {
+    readonly causeError?: unknown;
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+declare class ConfigError extends BlogAutoError {
+}
+interface ApiErrorDetails {
+    status: number;
+    code?: string;
+    details?: unknown;
+}
+declare class ApiError extends BlogAutoError {
+    readonly status: number;
+    readonly code?: string;
+    readonly details?: unknown;
+    constructor(message: string, info: ApiErrorDetails, options?: {
+        cause?: unknown;
+    });
+}
+declare class NotFoundError extends ApiError {
+    constructor(message: string, info?: Partial<ApiErrorDetails>);
+}
+
+export { ApiError, type BlogAutoClient, BlogAutoClientConfig, BlogAutoError, BlogPost, BuildRobotsOptions, BuildSitemapOptions, ConfigError, DEFAULT_TIMEOUT_MS, FetchRequestOptions, MetadataRouteRobots, MetadataRouteSitemap, type NextMetadata, NotFoundError, PostsResponse, buildAuthHeaders, buildNextMetadata, buildRobots, buildSitemap, createBlogAutoClient, renderMarkdownToHtml, resolveClientConfig };

package/dist/index.d.ts

@@ -0,0 +1,69 @@
+import { B as BlogAutoClientConfig, F as FetchRequestOptions, P as PostsResponse, a as BlogPost, b as BuildSitemapOptions, M as MetadataRouteSitemap, c as BuildRobotsOptions, d as MetadataRouteRobots, A as AuthMode, I as InternalClientConfig } from './revalidate-445OJMx_.js';
+export { g as BlogAutoRevalidatePayload, i as FetchNextConfig, f as PaginatedList, R as RevalidatePathFn, h as RevalidateTagFn, S as SitemapEntry, e as createRevalidateRouteHandler, v as verifyWebhookSignature } from './revalidate-445OJMx_.js';
+
+interface BlogAutoClient {
+    getPosts(params?: {
+        limit?: number;
+        cursor?: string;
+    } & FetchRequestOptions): Promise<PostsResponse>;
+    getPostBySlug(slug: string, options?: FetchRequestOptions): Promise<BlogPost | null>;
+    getSitemapEntries(): Promise<Array<{
+        slug: string;
+        updatedAt: string;
+    }>>;
+}
+declare function createBlogAutoClient(config: BlogAutoClientConfig): BlogAutoClient;
+
+declare function buildSitemap(opts: BuildSitemapOptions): MetadataRouteSitemap;
+
+declare function buildRobots(opts: BuildRobotsOptions): MetadataRouteRobots;
+
+declare function renderMarkdownToHtml(markdown: string): string;
+
+interface NextMetadata {
+    title?: string;
+    description?: string;
+    alternates?: {
+        canonical?: string;
+    };
+    openGraph?: {
+        title?: string;
+        description?: string;
+        images?: Array<{
+            url: string;
+        }>;
+    };
+}
+declare function buildNextMetadata(post: BlogPost): NextMetadata;
+
+declare function buildAuthHeaders(apiKey: string, authMode?: AuthMode): Record<string, string>;
+
+declare const DEFAULT_TIMEOUT_MS = 10000;
+declare function resolveClientConfig(config: BlogAutoClientConfig): InternalClientConfig;
+
+declare class BlogAutoError extends Error {
+    readonly causeError?: unknown;
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+declare class ConfigError extends BlogAutoError {
+}
+interface ApiErrorDetails {
+    status: number;
+    code?: string;
+    details?: unknown;
+}
+declare class ApiError extends BlogAutoError {
+    readonly status: number;
+    readonly code?: string;
+    readonly details?: unknown;
+    constructor(message: string, info: ApiErrorDetails, options?: {
+        cause?: unknown;
+    });
+}
+declare class NotFoundError extends ApiError {
+    constructor(message: string, info?: Partial<ApiErrorDetails>);
+}
+
+export { ApiError, type BlogAutoClient, BlogAutoClientConfig, BlogAutoError, BlogPost, BuildRobotsOptions, BuildSitemapOptions, ConfigError, DEFAULT_TIMEOUT_MS, FetchRequestOptions, MetadataRouteRobots, MetadataRouteSitemap, type NextMetadata, NotFoundError, PostsResponse, buildAuthHeaders, buildNextMetadata, buildRobots, buildSitemap, createBlogAutoClient, renderMarkdownToHtml, resolveClientConfig };

package/dist/index.js

@@ -0,0 +1,542 @@
+// src/auth.ts
+function buildAuthHeaders(apiKey, authMode = "bearer") {
+  if (authMode === "x-api-key") {
+    return { "x-api-key": apiKey };
+  }
+  return { Authorization: `Bearer ${apiKey}` };
+}
+
+// src/errors.ts
+var BlogAutoError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = new.target.name;
+    this.causeError = options?.cause;
+  }
+};
+var ConfigError = class extends BlogAutoError {
+};
+var ApiError = class extends BlogAutoError {
+  constructor(message, info, options) {
+    super(message, options);
+    this.status = info.status;
+    this.code = info.code;
+    this.details = info.details;
+  }
+};
+var NotFoundError = class extends ApiError {
+  constructor(message, info) {
+    super(message, { status: info?.status ?? 404, code: info?.code, details: info?.details });
+  }
+};
+
+// src/utils.ts
+var DEFAULT_TIMEOUT_MS = 1e4;
+function normalizeApiUrl(apiUrl) {
+  if (!apiUrl) {
+    throw new ConfigError("apiUrl is required");
+  }
+  return apiUrl.replace(/\/$/, "");
+}
+function resolveClientConfig(config) {
+  if (!config) {
+    throw new ConfigError("Client configuration is required");
+  }
+  const apiKey = config.apiKey?.trim();
+  if (!apiKey) {
+    throw new ConfigError("apiKey is required to authenticate with BlogAuto");
+  }
+  if (!config.workspaceId && !config.workspaceSlug) {
+    throw new ConfigError("Provide either workspaceId or workspaceSlug");
+  }
+  const authMode = config.authMode ?? "bearer";
+  return {
+    apiKey,
+    apiUrl: normalizeApiUrl(config.apiUrl),
+    workspaceId: config.workspaceId,
+    workspaceSlug: config.workspaceSlug,
+    authMode,
+    fetch: config.fetch ?? globalThis.fetch.bind(globalThis),
+    headers: { ...config.headers ?? {} },
+    timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS
+  };
+}
+function buildQuery(params) {
+  const query = new URLSearchParams();
+  Object.entries(params).forEach(([key, value]) => {
+    if (value === void 0 || value === null || value === "") {
+      return;
+    }
+    query.set(key, String(value));
+  });
+  const qs = query.toString();
+  return qs ? `?${qs}` : "";
+}
+async function withTimeout(promise, timeoutMs) {
+  if (!timeoutMs) {
+    return promise;
+  }
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(
+        new ApiError(`Request timed out after ${timeoutMs}ms`, {
+          status: 408
+        })
+      );
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+function mergeHeaders(...headerObjects) {
+  return headerObjects.reduce((acc, headers) => {
+    if (!headers) {
+      return acc;
+    }
+    Object.entries(headers).forEach(([key, value]) => {
+      if (value === void 0 || value === null) {
+        return;
+      }
+      acc[key.toLowerCase()] = value;
+    });
+    return acc;
+  }, {});
+}
+
+// src/client.ts
+function createBlogAutoClient(config) {
+  const resolved = resolveClientConfig(config);
+  const fetchImpl = resolved.fetch;
+  function ensureWorkspaceSlug() {
+    if (!resolved.workspaceSlug) {
+      throw new ConfigError("workspaceSlug is required to call the BlogAuto public API");
+    }
+    return resolved.workspaceSlug;
+  }
+  function buildUrl(path, query) {
+    const qs = buildQuery(query ?? {});
+    return `${resolved.apiUrl}${path}${qs}`;
+  }
+  function unwrapSuccessPayload(payload) {
+    if (payload && typeof payload === "object") {
+      const maybePayload = payload;
+      if ("success" in maybePayload) {
+        if (maybePayload.success === false) {
+          throw new ApiError(
+            maybePayload.error?.message ?? "BlogAuto request failed",
+            { status: 500, details: maybePayload }
+          );
+        }
+        if (maybePayload.success && "data" in maybePayload) {
+          return maybePayload.data;
+        }
+      }
+    }
+    return payload;
+  }
+  async function request(opts) {
+    const method = opts.method ?? "GET";
+    const url = buildUrl(opts.path, opts.query);
+    const authHeaders = buildAuthHeaders(resolved.apiKey, resolved.authMode);
+    const baseHeaders = mergeHeaders(resolved.headers, authHeaders, opts.headers);
+    const init = {
+      method,
+      headers: baseHeaders
+    };
+    if (opts.body) {
+      init.body = typeof opts.body === "string" ? opts.body : JSON.stringify(opts.body);
+      init.headers = {
+        ...baseHeaders,
+        "content-type": baseHeaders["content-type"] ?? "application/json"
+      };
+    }
+    if (opts.cache !== void 0) {
+      init.cache = opts.cache;
+    }
+    if (opts.next) {
+      init.next = opts.next;
+    }
+    try {
+      const response = await withTimeout(fetchImpl(url, init), resolved.timeoutMs);
+      if (opts.allowNotFound && response.status === 404) {
+        return null;
+      }
+      const contentType = response.headers.get("content-type") ?? "";
+      const isJson = contentType.includes("application/json");
+      const payload = isJson ? await response.json().catch(() => void 0) : await response.text();
+      if (!response.ok) {
+        if (response.status === 404 && opts.allowNotFound) {
+          return null;
+        }
+        const errorBody = payload;
+        const message = errorBody?.error?.message ?? errorBody?.message ?? `Request failed with status ${response.status}`;
+        throw new ApiError(message, {
+          status: response.status,
+          code: errorBody?.error?.code ?? errorBody?.code,
+          details: errorBody?.error?.details ?? errorBody
+        });
+      }
+      if (isJson) {
+        return unwrapSuccessPayload(payload);
+      }
+      return payload ?? void 0;
+    } catch (error) {
+      if (error instanceof BlogAutoError) {
+        throw error;
+      }
+      throw new ApiError("Network request to BlogAuto failed", { status: 0 }, { cause: error });
+    }
+  }
+  async function fetchBlogPage(limit, page, cacheOptions) {
+    const workspaceSlug = ensureWorkspaceSlug();
+    return request({
+      path: `/v1/public/${encodeURIComponent(workspaceSlug)}/blogs`,
+      query: { limit, page },
+      cache: cacheOptions?.cache,
+      next: cacheOptions?.next
+    });
+  }
+  return {
+    async getPosts(params) {
+      const limit = params?.limit ?? 20;
+      const cursorPage = params?.cursor ? Number(params.cursor) : void 0;
+      const page = Number.isFinite(cursorPage) && cursorPage >= 1 ? cursorPage : 1;
+      const data = await fetchBlogPage(limit, page, params);
+      return {
+        posts: data.items,
+        nextCursor: data.pagination.hasMore ? String(data.pagination.page + 1) : void 0
+      };
+    },
+    async getPostBySlug(slug, options) {
+      if (!slug) {
+        throw new ApiError("slug is required", { status: 400 });
+      }
+      const workspaceSlug = ensureWorkspaceSlug();
+      const post = await request({
+        path: `/v1/public/${encodeURIComponent(workspaceSlug)}/blogs/${encodeURIComponent(slug)}`,
+        allowNotFound: true,
+        cache: options?.cache,
+        next: options?.next
+      });
+      if (post === null) {
+        return null;
+      }
+      return post.post;
+    },
+    async getSitemapEntries() {
+      const entries = [];
+      const limit = 100;
+      let page = 1;
+      while (true) {
+        const pageData = await fetchBlogPage(limit, page);
+        pageData.items.forEach((post) => {
+          entries.push({ slug: post.slug, updatedAt: post.updatedAt });
+        });
+        if (!pageData.pagination.hasMore) {
+          break;
+        }
+        page = pageData.pagination.page + 1;
+      }
+      return entries;
+    }
+  };
+}
+
+// src/sitemap.ts
+function normalizeSiteUrl(url) {
+  return url.replace(/\/$/, "");
+}
+function normalizeRoutePrefix(routePrefix) {
+  if (!routePrefix || routePrefix === "/") {
+    return "";
+  }
+  const withSlash = routePrefix.startsWith("/") ? routePrefix : `/${routePrefix}`;
+  return withSlash.endsWith("/") ? withSlash.slice(0, -1) : withSlash;
+}
+function normalizeSlug(slug) {
+  return slug.replace(/^\/+/, "").replace(/\/+$/, "");
+}
+function buildSitemap(opts) {
+  const siteUrl = normalizeSiteUrl(opts.siteUrl);
+  const prefix = normalizeRoutePrefix(opts.routePrefix ?? "/blog");
+  const entries = opts.entries.map((entry) => {
+    const slug = normalizeSlug(entry.slug);
+    const hasSlug = slug.length > 0;
+    const slugFragment = hasSlug ? `/${slug}` : "";
+    const path = prefix ? `${prefix}${slugFragment}` : hasSlug ? `/${slug}` : "/";
+    return {
+      url: `${siteUrl}${path}`,
+      lastModified: entry.updatedAt
+    };
+  });
+  return entries;
+}
+
+// src/robots.ts
+function normalizeSiteUrl2(url) {
+  return url.replace(/\/$/, "");
+}
+function normalizePath(path) {
+  if (!path) {
+    return "/sitemap.xml";
+  }
+  if (!path.startsWith("/")) {
+    return `/${path}`;
+  }
+  return path;
+}
+function buildRobots(opts) {
+  const siteUrl = normalizeSiteUrl2(opts.siteUrl);
+  const sitemapPath = normalizePath(opts.sitemapPath ?? "/sitemap.xml");
+  const sitemapUrl = `${siteUrl}${sitemapPath}`;
+  return {
+    rules: [{ userAgent: "*", allow: "/" }],
+    sitemap: sitemapUrl
+  };
+}
+
+// src/render.ts
+var CODE_BLOCK_TOKEN = "__BLOGAUTO_CODE_BLOCK_";
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function renderInline(input) {
+  let output = escapeHtml(input);
+  output = output.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>");
+  output = output.replace(/\*(.+?)\*/g, "<em>$1</em>");
+  output = output.replace(/`([^`]+)`/g, (_, code) => `<code>${code}</code>`);
+  output = output.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, (_, alt, src) => {
+    const safeSrc = escapeHtml(src);
+    const safeAlt = escapeHtml(alt);
+    return `<img src="${safeSrc}" alt="${safeAlt}" />`;
+  });
+  output = output.replace(/\[(.+?)\]\((.+?)\)/g, (_, label, href) => {
+    const safeHref = escapeHtml(href);
+    return `<a href="${safeHref}" target="_blank" rel="noreferrer">${label}</a>`;
+  });
+  output = output.replace(/\n/g, "<br />");
+  return output;
+}
+function replaceCodeBlocks(markdown, blocks) {
+  return markdown.replace(/```([\s\S]*?)```/g, (_, code) => {
+    const index = blocks.push(`<pre><code>${escapeHtml(code.trim())}</code></pre>`) - 1;
+    return `${CODE_BLOCK_TOKEN}${index}__`;
+  });
+}
+function restoreCodeBlocks(html, blocks) {
+  return html.replace(/__BLOGAUTO_CODE_BLOCK_(\d+)__/g, (_, rawIndex) => blocks[Number(rawIndex)] ?? "");
+}
+function renderMarkdownToHtml(markdown) {
+  if (!markdown) {
+    return "";
+  }
+  const codeBlocks = [];
+  const withoutCode = replaceCodeBlocks(markdown, codeBlocks);
+  const blocks = withoutCode.replace(/\r\n/g, "\n").split(/\n{2,}/).map((block) => block.trim()).filter(Boolean);
+  const htmlBlocks = blocks.map((block) => {
+    const headingMatch = block.match(/^(#{1,6})\s+(.*)$/);
+    if (headingMatch) {
+      const level = headingMatch[1].length;
+      const content = renderInline(headingMatch[2]);
+      return `<h${level}>${content}</h${level}>`;
+    }
+    const imageMatch = block.match(/^!\[([^\]]*)\]\(([^)]+)\)$/);
+    if (imageMatch) {
+      const safeSrc = escapeHtml(imageMatch[2]);
+      const safeAlt = escapeHtml(imageMatch[1]);
+      return `<img src="${safeSrc}" alt="${safeAlt}" />`;
+    }
+    return `<p>${renderInline(block)}</p>`;
+  });
+  const html = htmlBlocks.join("\n");
+  return restoreCodeBlocks(html, codeBlocks);
+}
+
+// src/revalidate.ts
+import crypto from "crypto";
+function jsonResponse(body, init) {
+  const headers = new Headers(init?.headers);
+  headers.set("content-type", "application/json");
+  return new Response(JSON.stringify(body), {
+    ...init,
+    headers
+  });
+}
+function normalizeSignature(signature) {
+  if (!signature) {
+    return null;
+  }
+  const trimmed = signature.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const withoutPrefix = trimmed.startsWith("sha256=") ? trimmed.slice(7) : trimmed;
+  if (!withoutPrefix) {
+    return null;
+  }
+  try {
+    return Buffer.from(withoutPrefix, "hex");
+  } catch {
+    return null;
+  }
+}
+function verifyWebhookSignature(opts) {
+  const { rawBody, signature, secret } = opts;
+  if (!secret) {
+    throw new Error("Secret is required to verify webhook signatures");
+  }
+  const providedSignature = normalizeSignature(signature);
+  if (!providedSignature) {
+    return false;
+  }
+  const bodyBuffer = typeof rawBody === "string" ? Buffer.from(rawBody) : rawBody;
+  const expected = crypto.createHmac("sha256", secret).update(bodyBuffer).digest();
+  if (providedSignature.length !== expected.length) {
+    return false;
+  }
+  return crypto.timingSafeEqual(providedSignature, expected);
+}
+function defaultPaths(payload) {
+  const paths = /* @__PURE__ */ new Set(["/sitemap.xml", "/robots.txt", "/blog"]);
+  if (payload.postSlug) {
+    paths.add(`/blog/${payload.postSlug}`);
+  }
+  return Array.from(paths);
+}
+function defaultTags(payload) {
+  const tags = /* @__PURE__ */ new Set();
+  if (payload.workspaceSlug) {
+    tags.add(`blogauto:${payload.workspaceSlug}:sitemap`);
+    tags.add(`blogauto:${payload.workspaceSlug}:posts`);
+    if (payload.postSlug) {
+      tags.add(`blogauto:${payload.workspaceSlug}:post:${payload.postSlug}`);
+    }
+  }
+  return Array.from(tags);
+}
+function dedupe(values) {
+  if (!values || values.length === 0) {
+    return [];
+  }
+  return Array.from(
+    new Set(
+      values.filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => value.trim())
+    )
+  );
+}
+function determineRouteType(path) {
+  const lower = path.toLowerCase();
+  if (lower.endsWith(".xml") || lower.endsWith(".txt")) {
+    return "route";
+  }
+  return "page";
+}
+function createRevalidateRouteHandler(options) {
+  if (!options.secret) {
+    throw new Error("secret is required for createRevalidateRouteHandler");
+  }
+  const allowedSkewMs = Math.max(1, options.allowedSkewSeconds ?? 300) * 1e3;
+  const pathBuilder = options.revalidatePaths ?? defaultPaths;
+  const tagBuilder = options.revalidateTags ?? defaultTags;
+  return async function blogAutoRevalidateHandler(request) {
+    const signature = request.headers.get("x-blogauto-signature");
+    const receivedAt = Date.now();
+    const rawBody = await request.text();
+    const isValid = verifyWebhookSignature({
+      rawBody,
+      signature,
+      secret: options.secret
+    });
+    if (!isValid) {
+      return jsonResponse({ error: "Invalid webhook signature" }, { status: 401 });
+    }
+    let payload;
+    try {
+      payload = JSON.parse(rawBody);
+    } catch {
+      return jsonResponse({ error: "Invalid JSON payload" }, { status: 400 });
+    }
+    if (!payload.workspaceSlug || typeof payload.workspaceSlug !== "string") {
+      return jsonResponse({ error: "workspaceSlug is required" }, { status: 400 });
+    }
+    if (!payload.ts || typeof payload.ts !== "string") {
+      return jsonResponse({ error: "Timestamp is required" }, { status: 400 });
+    }
+    const payloadTs = Date.parse(payload.ts);
+    if (Number.isNaN(payloadTs)) {
+      return jsonResponse({ error: "Invalid timestamp" }, { status: 400 });
+    }
+    if (Math.abs(receivedAt - payloadTs) > allowedSkewMs) {
+      return jsonResponse({ error: "Webhook timestamp is outside allowed skew" }, { status: 409 });
+    }
+    const paths = dedupe(pathBuilder(payload));
+    const tags = dedupe(tagBuilder(payload));
+    try {
+      if (options.revalidatePath && paths.length > 0) {
+        await Promise.all(
+          paths.map((path) => options.revalidatePath(path, determineRouteType(path)))
+        );
+      }
+      if (options.revalidateTag && tags.length > 0) {
+        await Promise.all(tags.map((tag) => options.revalidateTag(tag)));
+      }
+    } catch (error) {
+      return jsonResponse(
+        { error: "Failed to revalidate cache", details: error.message },
+        { status: 500 }
+      );
+    }
+    return jsonResponse({
+      ok: true,
+      event: payload.event ?? "post.published",
+      revalidated: {
+        paths,
+        tags
+      }
+    });
+  };
+}
+
+// src/metadata.ts
+function buildNextMetadata(post) {
+  const title = post.seo?.title ?? post.title;
+  const description = post.seo?.description ?? post.excerpt;
+  const canonical = post.metadata?.canonicalUrl;
+  const ogImageUrl = post.metadata?.ogImageUrl;
+  const metadata = {
+    title,
+    description
+  };
+  if (canonical) {
+    metadata.alternates = { canonical };
+  }
+  if (ogImageUrl) {
+    metadata.openGraph = {
+      title,
+      description,
+      images: [{ url: ogImageUrl }]
+    };
+  }
+  return metadata;
+}
+export {
+  ApiError,
+  BlogAutoError,
+  ConfigError,
+  DEFAULT_TIMEOUT_MS,
+  NotFoundError,
+  buildAuthHeaders,
+  buildNextMetadata,
+  buildRobots,
+  buildSitemap,
+  createBlogAutoClient,
+  createRevalidateRouteHandler,
+  renderMarkdownToHtml,
+  resolveClientConfig,
+  verifyWebhookSignature
+};
+//# sourceMappingURL=index.js.map