@djangocfg/nextjs 2.1.225 → 2.1.226

package/dist/og-image/utils/index.d.mts

@@ -1,308 +0,0 @@
-import { Metadata } from 'next';
-
-/**
- * Font Utilities for OG Image Generation
- *
- * Provides dynamic font loading from Google Fonts without requiring files in public/
- * Based on Vercel's official @vercel/og documentation
- */
-interface FontConfig {
-    name: string;
-    weight?: 400 | 500 | 600 | 700 | 800 | 900;
-    style?: 'normal' | 'italic';
-    data: ArrayBuffer;
-}
-/**
- * Load a Google Font dynamically
- *
- * @param font - Font family name (e.g., "Inter", "Roboto", "Manrope")
- * @param text - Text to optimize font for (optional, reduces file size)
- * @param weight - Font weight (default: 700)
- * @returns ArrayBuffer of font data
- *
- * @example
- * const fontData = await loadGoogleFont('Manrope', 'Hello World', 700);
- */
-declare function loadGoogleFont(font: string, text?: string, weight?: number): Promise<ArrayBuffer>;
-/**
- * Load multiple Google Fonts
- *
- * @param fonts - Array of font configurations to load
- * @returns Array of FontConfig objects ready for ImageResponse
- *
- * @example
- * const fonts = await loadGoogleFonts([
- *   { family: 'Manrope', weight: 700 },
- *   { family: 'Inter', weight: 400 }
- * ]);
- */
-declare function loadGoogleFonts(fonts: Array<{
-    family: string;
-    weight?: 400 | 500 | 600 | 700 | 800 | 900;
-    style?: 'normal' | 'italic';
-    text?: string;
-}>): Promise<FontConfig[]>;
-/**
- * Create a font loader with caching
- *
- * Useful for reusing font data across multiple OG image requests
- *
- * @example
- * const fontLoader = createFontLoader();
- * const font = await fontLoader.load('Manrope', 700);
- */
-declare function createFontLoader(): {
-    /**
-     * Load a font with caching
-     */
-    load(family: string, weight?: number, text?: string): Promise<ArrayBuffer>;
-    /**
-     * Clear the cache
-     */
-    clear(): void;
-    /**
-     * Get cache size
-     */
-    size(): number;
-};
-
-/**
- * URL Generation Helpers for OG Images
- *
- * Utilities to generate OG image URLs with proper query parameters
- */
-/**
- * Encode string to base64 with Unicode support
- * Works in both browser and Node.js environments
- */
-declare function encodeBase64(str: string): string;
-/**
- * Decode base64 string with Unicode support
- * Works in both browser, Node.js, and Edge Runtime environments
- */
-declare function decodeBase64(str: string): string;
-/**
- * OG Image URL parameters
- * All parameters can be encoded in URL via base64
- */
-interface OgImageUrlParams {
-    /** Page title */
-    title: string;
-    /** Page description (optional) */
-    description?: string;
-    /** Site name (optional) */
-    siteName?: string;
-    /** Logo URL (optional) */
-    logo?: string;
-    /** Background type: 'gradient' or 'solid' */
-    backgroundType?: 'gradient' | 'solid';
-    /** Gradient start color (hex) */
-    gradientStart?: string;
-    /** Gradient end color (hex) */
-    gradientEnd?: string;
-    /** Background color (for solid type) */
-    backgroundColor?: string;
-    /** Title font size (px) */
-    titleSize?: number;
-    /** Title font weight */
-    titleWeight?: number;
-    /** Title text color */
-    titleColor?: string;
-    /** Description font size (px) */
-    descriptionSize?: number;
-    /** Description text color */
-    descriptionColor?: string;
-    /** Site name font size (px) */
-    siteNameSize?: number;
-    /** Site name text color */
-    siteNameColor?: string;
-    /** Padding (px) */
-    padding?: number;
-    /** Logo size (px) */
-    logoSize?: number;
-    /** Show logo flag */
-    showLogo?: boolean;
-    /** Show site name flag */
-    showSiteName?: boolean;
-    /** Additional custom parameters */
-    [key: string]: string | number | boolean | undefined;
-}
-/**
- * Options for generating OG image URL
- */
-interface GenerateOgImageUrlOptions {
-    /**
-     * Base URL of the OG image API route
-     * @default 'https://djangocfg.com/api/og'
-     */
-    baseUrl?: string;
-    /**
-     * If true, encode params as base64 for safer URLs
-     * @default true
-     */
-    useBase64?: boolean;
-}
-/**
- * Generate OG image URL with query parameters or base64 encoding
- *
- * @param params - URL parameters for the OG image
- * @param options - Generation options (baseUrl, useBase64)
- * @returns Complete OG image URL with encoded parameters
- *
- * @example
- * ```typescript
- * // Using default baseUrl (https://djangocfg.com/api/og)
- * const url = generateOgImageUrl({
- *   title: 'My Page Title',
- *   description: 'Page description here',
- * });
- *
- * // With custom baseUrl
- * const url = generateOgImageUrl(
- *   { title: 'My Page' },
- *   { baseUrl: '/api/og' }
- * );
- * ```
- */
-declare function generateOgImageUrl(params: OgImageUrlParams, options?: GenerateOgImageUrlOptions): string;
-/**
- * Get absolute OG image URL from relative path
- *
- * Useful for generating absolute URLs required by Open Graph meta tags
- *
- * @param relativePath - Relative OG image path (e.g., '/api/og?title=Hello')
- * @param siteUrl - Base site URL (e.g., 'https://example.com')
- * @returns Absolute URL
- *
- * @example
- * ```typescript
- * const absolute = getAbsoluteOgImageUrl(
- *   '/api/og?title=Hello',
- *   'https://example.com'
- * );
- * // Result: https://example.com/api/og?title=Hello
- * ```
- */
-declare function getAbsoluteOgImageUrl(relativePath: string, siteUrl: string): string;
-/**
- * Create OG image URL builder with preset configuration
- *
- * Useful when you want to reuse the same base URL and default parameters
- *
- * @param defaults - Default parameters to merge with each URL generation
- * @param options - Default options (baseUrl, useBase64)
- * @returns URL builder function
- *
- * @example
- * ```typescript
- * const buildOgUrl = createOgImageUrlBuilder(
- *   { siteName: 'My Site', logo: '/logo.png' },
- *   { baseUrl: '/api/og' }
- * );
- *
- * const url1 = buildOgUrl({ title: 'Page 1' });
- * const url2 = buildOgUrl({ title: 'Page 2', description: 'Custom desc' });
- * ```
- */
-declare function createOgImageUrlBuilder(defaults?: Partial<OgImageUrlParams>, options?: GenerateOgImageUrlOptions): (params: OgImageUrlParams) => string;
-/**
- * Parse OG image URL parameters from a URL string (legacy query params)
- *
- * @param url - Full or relative URL with query parameters
- * @returns Parsed parameters object
- *
- * @example
- * ```typescript
- * const params = parseOgImageUrl('/api/og?title=Hello&description=World');
- * // Result: { title: 'Hello', description: 'World' }
- * ```
- */
-declare function parseOgImageUrl(url: string): Record<string, string>;
-/**
- * Parse OG image data from base64-encoded query parameter
- *
- * Use this in your API route to decode the `data` parameter
- * Supports both base64 (new) and legacy query params format
- *
- * @param searchParams - URL search params or request object
- * @returns Parsed OG image parameters
- *
- * @example
- * ```typescript
- * // In Next.js API route (pages/api/og.ts)
- * export default function handler(req) {
- *   const params = parseOgImageData(req.query);
- *   // { title: 'Hello', description: 'World' }
- * }
- *
- * // In Next.js App Router (app/api/og/route.ts)
- * export async function GET(request: Request) {
- *   const { searchParams } = new URL(request.url);
- *   const params = parseOgImageData(Object.fromEntries(searchParams));
- *   // { title: 'Hello', description: 'World' }
- * }
- * ```
- */
-declare function parseOgImageData(searchParams: Record<string, string | string[] | undefined> | URLSearchParams): Record<string, string>;
-
-/**
- * Metadata Utilities for OG Images
- *
- * Helpers to automatically add og:image to Next.js metadata
- */
-
-/**
- * Options for generating OG image metadata
- */
-interface AppMetadataOptions {
-    /** Base URL of the OG image API route (e.g., '/api/og') */
-    ogImageBaseUrl?: string;
-    /** Site URL for absolute URLs (e.g., 'https://example.com') */
-    siteUrl?: string;
-    /** Default parameters to merge with page-specific params */
-    defaultParams?: Partial<OgImageUrlParams>;
-    /** Whether to use base64 encoding (default: true) */
-    useBase64?: boolean;
-    /** Favicon URL (e.g., '/favicon.png') - automatically added to metadata.icons */
-    favicon?: string;
-    /** Apple touch icon URL (e.g., '/apple-icon.png') - automatically added to metadata.icons */
-    appleIcon?: string;
-}
-declare function generateAppMetadata(metadata: Metadata, ogImageParams?: Partial<OgImageUrlParams>, options?: AppMetadataOptions): Metadata;
-/**
- * Create OG image metadata generator with preset configuration
- *
- * Useful when you want to reuse the same configuration across multiple pages
- *
- * @param options - Configuration options
- * @returns Metadata generator function
- *
- * @example
- * ```typescript
- * // In a shared file (e.g., lib/metadata.ts)
- * import { createAppMetadataGenerator } from '@djangocfg/nextjs/og-image';
- * import { settings } from '@/core/settings';
- *
- * export const generateMetadata = createAppMetadataGenerator({
- *   ogImageBaseUrl: '/api/og',
- *   siteUrl: settings.app.siteUrl,
- *   favicon: settings.app.icons.favicon,
- *   appleIcon: settings.app.icons.logo192,
- *   defaultParams: {
- *     siteName: settings.app.name,
- *     logo: settings.app.icons.logoVector,
- *   },
- * });
- *
- * // In page.tsx
- * import { generateMetadata } from '@/lib/metadata';
- *
- * export const metadata = generateMetadata({
- *   title: 'My Page',
- *   description: 'Description',
- * });
- * ```
- */
-declare function createAppMetadataGenerator(options: AppMetadataOptions): (metadata: Metadata, ogImageParams?: Partial<OgImageUrlParams>) => Metadata;
-
-export { type AppMetadataOptions, type FontConfig, type OgImageUrlParams, createAppMetadataGenerator, createFontLoader, createOgImageUrlBuilder, decodeBase64, encodeBase64, generateAppMetadata, generateOgImageUrl, getAbsoluteOgImageUrl, loadGoogleFont, loadGoogleFonts, parseOgImageData, parseOgImageUrl };

package/dist/og-image/utils/index.mjs

@@ -1,327 +0,0 @@
-// src/og-image/utils/fonts.ts
-async function loadGoogleFont(font, text, weight = 700) {
-  let url = `https://fonts.googleapis.com/css2?family=${font}:wght@${weight}`;
-  if (text) {
-    url += `&text=${encodeURIComponent(text)}`;
-  }
-  try {
-    const css = await fetch(url, {
-      headers: {
-        // Required to get TTF format instead of WOFF2
-        "User-Agent": "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_8; de-at) AppleWebKit/533.21.1 (KHTML, like Gecko) Version/5.0.5 Safari/533.21.1"
-      }
-    }).then((res) => res.text());
-    const resource = css.match(/src: url\((.+)\) format\('(opentype|truetype)'\)/);
-    if (!resource || !resource[1]) {
-      throw new Error(`Failed to parse font URL from CSS for font: ${font}`);
-    }
-    const response = await fetch(resource[1]);
-    if (response.status !== 200) {
-      throw new Error(`Failed to fetch font data: HTTP ${response.status}`);
-    }
-    return await response.arrayBuffer();
-  } catch (error) {
-    console.error(`Error loading Google Font "${font}":`, error);
-    throw new Error(`Failed to load font "${font}": ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
-}
-async function loadGoogleFonts(fonts) {
-  const fontConfigs = await Promise.all(
-    fonts.map(async ({ family, weight = 700, style = "normal", text }) => {
-      const data = await loadGoogleFont(family, text, weight);
-      return {
-        name: family,
-        weight,
-        style,
-        data
-      };
-    })
-  );
-  return fontConfigs;
-}
-function createFontLoader() {
-  const cache = /* @__PURE__ */ new Map();
-  return {
-    /**
-     * Load a font with caching
-     */
-    async load(family, weight = 700, text) {
-      const cacheKey = `${family}-${weight}-${text || "all"}`;
-      if (!cache.has(cacheKey)) {
-        cache.set(cacheKey, loadGoogleFont(family, text, weight));
-      }
-      return cache.get(cacheKey);
-    },
-    /**
-     * Clear the cache
-     */
-    clear() {
-      cache.clear();
-    },
-    /**
-     * Get cache size
-     */
-    size() {
-      return cache.size;
-    }
-  };
-}
-
-// src/og-image/utils/url.ts
-var DEFAULT_OG_IMAGE_BASE_URL = "https://djangocfg.com/api/og";
-function encodeBase64(str) {
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(str, "utf-8").toString("base64");
-  }
-  return btoa(unescape(encodeURIComponent(str)));
-}
-function decodeBase64(str) {
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(str, "base64").toString("utf-8");
-  }
-  try {
-    const binaryString = atob(str);
-    return decodeURIComponent(
-      binaryString.split("").map((c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2)).join("")
-    );
-  } catch (error) {
-    return decodeURIComponent(escape(atob(str)));
-  }
-}
-function generateOgImageUrl(params, options = {}) {
-  const {
-    baseUrl = DEFAULT_OG_IMAGE_BASE_URL,
-    useBase64 = true
-  } = options;
-  if (useBase64) {
-    const cleanParams = {};
-    Object.entries(params).forEach(([key, value]) => {
-      if (value !== void 0 && value !== null && value !== "") {
-        cleanParams[key] = value;
-      }
-    });
-    const jsonString = JSON.stringify(cleanParams);
-    const base64Data = encodeBase64(jsonString);
-    return `${baseUrl}/${base64Data}/`;
-  } else {
-    const searchParams = new URLSearchParams();
-    Object.entries(params).forEach(([key, value]) => {
-      if (value !== void 0 && value !== null && value !== "") {
-        searchParams.append(key, String(value));
-      }
-    });
-    const query = searchParams.toString();
-    return query ? `${baseUrl}?${query}` : baseUrl;
-  }
-}
-function getAbsoluteOgImageUrl(relativePath, siteUrl) {
-  if (relativePath.startsWith("http://") || relativePath.startsWith("https://")) {
-    return relativePath;
-  }
-  const cleanSiteUrl = siteUrl.replace(/\/$/, "");
-  const cleanPath = relativePath.startsWith("/") ? relativePath : `/${relativePath}`;
-  return `${cleanSiteUrl}${cleanPath}`;
-}
-function createOgImageUrlBuilder(defaults = {}, options = {}) {
-  return (params) => {
-    return generateOgImageUrl(
-      { ...defaults, ...params },
-      options
-    );
-  };
-}
-function parseOgImageUrl(url) {
-  try {
-    const urlObj = new URL(url, "http://dummy.com");
-    const params = {};
-    urlObj.searchParams.forEach((value, key) => {
-      params[key] = value;
-    });
-    return params;
-  } catch {
-    return {};
-  }
-}
-function parseOgImageData(searchParams) {
-  try {
-    let params;
-    if (searchParams instanceof URLSearchParams) {
-      params = {};
-      for (const [key, value] of searchParams.entries()) {
-        params[key] = value;
-      }
-    } else {
-      params = searchParams;
-    }
-    if (process.env.NODE_ENV === "development") {
-      console.log("[parseOgImageData] Input params keys:", Object.keys(params));
-      console.log("[parseOgImageData] Input params:", params);
-    }
-    const dataParam = params.data;
-    if (dataParam && typeof dataParam === "string" && dataParam.trim() !== "") {
-      if (process.env.NODE_ENV === "development") {
-        console.log("[parseOgImageData] Found data param, length:", dataParam.length);
-      }
-      try {
-        const decoded = decodeBase64(dataParam);
-        if (process.env.NODE_ENV === "development") {
-          console.log("[parseOgImageData] Decoded string:", decoded.substring(0, 100));
-        }
-        const parsed = JSON.parse(decoded);
-        if (process.env.NODE_ENV === "development") {
-          console.log("[parseOgImageData] Parsed JSON:", parsed);
-        }
-        const result2 = {};
-        for (const [key, value] of Object.entries(parsed)) {
-          if (value !== void 0 && value !== null) {
-            result2[key] = String(value);
-          }
-        }
-        if (process.env.NODE_ENV === "development") {
-          console.log("[parseOgImageData] Result:", result2);
-        }
-        return result2;
-      } catch (decodeError) {
-        console.error("[parseOgImageData] Error decoding/parsing data param:", decodeError);
-        if (decodeError instanceof Error) {
-          console.error("[parseOgImageData] Error message:", decodeError.message);
-        }
-      }
-    } else {
-      if (process.env.NODE_ENV === "development") {
-        console.log("[parseOgImageData] No data param found or empty");
-      }
-    }
-    const result = {};
-    for (const [key, value] of Object.entries(params)) {
-      if (key !== "data" && value !== void 0 && value !== null) {
-        result[key] = Array.isArray(value) ? value[0] : String(value);
-      }
-    }
-    if (process.env.NODE_ENV === "development") {
-      console.log("[parseOgImageData] Fallback result:", result);
-    }
-    return result;
-  } catch (error) {
-    console.error("[parseOgImageData] Unexpected error:", error);
-    return {};
-  }
-}
-
-// src/og-image/utils/metadata.ts
-function extractTitle(metadata) {
-  if (typeof metadata.title === "string") {
-    return metadata.title;
-  }
-  if (metadata.title) {
-    if ("default" in metadata.title) {
-      return metadata.title.default;
-    }
-    if ("absolute" in metadata.title) {
-      return metadata.title.absolute;
-    }
-  }
-  return "";
-}
-function extractDescription(metadata) {
-  if (typeof metadata.description === "string") {
-    return metadata.description;
-  }
-  return "";
-}
-function getSiteUrl() {
-  if (typeof process !== "undefined" && process.env.NEXT_PUBLIC_SITE_URL) {
-    return process.env.NEXT_PUBLIC_SITE_URL;
-  }
-  return "";
-}
-function generateAppMetadata(metadata, ogImageParams, options = {}) {
-  const {
-    ogImageBaseUrl = "https://djangocfg.com/api/og",
-    siteUrl: providedSiteUrl,
-    defaultParams = {},
-    useBase64 = true,
-    favicon,
-    appleIcon
-  } = options;
-  const siteUrl = providedSiteUrl && providedSiteUrl !== "undefined" ? providedSiteUrl : getSiteUrl();
-  const extractedTitle = extractTitle(metadata);
-  const extractedDescription = extractDescription(metadata);
-  const finalOgImageParams = {
-    ...defaultParams,
-    title: ogImageParams?.title || extractedTitle || defaultParams.title || "",
-    description: ogImageParams?.description || extractedDescription || defaultParams.description || "",
-    ...ogImageParams
-  };
-  const imageAlt = finalOgImageParams.title || finalOgImageParams.siteName;
-  const relativeOgImageUrl = generateOgImageUrl(
-    finalOgImageParams,
-    { baseUrl: ogImageBaseUrl, useBase64 }
-  );
-  const ogImageUrl = siteUrl ? getAbsoluteOgImageUrl(relativeOgImageUrl, siteUrl) : relativeOgImageUrl;
-  const existingOgImages = metadata.openGraph?.images ? Array.isArray(metadata.openGraph.images) ? metadata.openGraph.images : [metadata.openGraph.images] : [];
-  const existingTwitterImages = metadata.twitter?.images ? Array.isArray(metadata.twitter.images) ? metadata.twitter.images : [metadata.twitter.images] : [];
-  const finalMetadata = {
-    ...metadata,
-    openGraph: {
-      ...metadata.openGraph,
-      images: [
-        ...existingOgImages,
-        {
-          url: ogImageUrl,
-          width: 1200,
-          height: 630,
-          alt: imageAlt
-        }
-      ]
-    },
-    twitter: {
-      ...metadata.twitter,
-      card: "summary_large_image",
-      images: [
-        ...existingTwitterImages,
-        {
-          url: ogImageUrl,
-          alt: imageAlt
-        }
-      ]
-    }
-  };
-  if (!finalMetadata.metadataBase && siteUrl) {
-    if (siteUrl.startsWith("http://") || siteUrl.startsWith("https://")) {
-      try {
-        finalMetadata.metadataBase = new URL(siteUrl);
-      } catch (e) {
-      }
-    }
-  }
-  if (favicon || appleIcon) {
-    const existingIcons = metadata.icons && typeof metadata.icons === "object" && !Array.isArray(metadata.icons) ? metadata.icons : {};
-    finalMetadata.icons = {
-      ...existingIcons,
-      ...favicon && { icon: favicon },
-      ...appleIcon && { apple: appleIcon }
-    };
-  }
-  return finalMetadata;
-}
-function createAppMetadataGenerator(options) {
-  return (metadata, ogImageParams) => {
-    return generateAppMetadata(metadata, ogImageParams, options);
-  };
-}
-export {
-  createAppMetadataGenerator,
-  createFontLoader,
-  createOgImageUrlBuilder,
-  decodeBase64,
-  encodeBase64,
-  generateAppMetadata,
-  generateOgImageUrl,
-  getAbsoluteOgImageUrl,
-  loadGoogleFont,
-  loadGoogleFonts,
-  parseOgImageData,
-  parseOgImageUrl
-};
-//# sourceMappingURL=index.mjs.map