@nuxt/scripts 0.13.2 → 1.0.0-beta.2

package/dist/runtime/registry/tiktok-pixel.d.ts

@@ -0,0 +1,44 @@
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+type StandardEvents = 'ViewContent' | 'ClickButton' | 'Search' | 'AddToWishlist' | 'AddToCart' | 'InitiateCheckout' | 'AddPaymentInfo' | 'CompletePayment' | 'PlaceAnOrder' | 'Contact' | 'Download' | 'SubmitForm' | 'CompleteRegistration' | 'Subscribe';
+interface EventProperties {
+    content_id?: string;
+    content_type?: string;
+    content_name?: string;
+    contents?: Array<{
+        content_id: string;
+        content_type?: string;
+        content_name?: string;
+        price?: number;
+        quantity?: number;
+    }>;
+    currency?: string;
+    value?: number;
+    description?: string;
+    query?: string;
+    [key: string]: any;
+}
+interface IdentifyProperties {
+    email?: string;
+    phone_number?: string;
+    external_id?: string;
+}
+type TtqFns = ((cmd: 'track', event: StandardEvents | string, properties?: EventProperties) => void) & ((cmd: 'page') => void) & ((cmd: 'identify', properties: IdentifyProperties) => void) & ((cmd: string, ...args: any[]) => void);
+export interface TikTokPixelApi {
+    ttq: TtqFns & {
+        push: TtqFns;
+        loaded: boolean;
+        queue: any[];
+    };
+}
+declare global {
+    interface Window extends TikTokPixelApi {
+        TiktokAnalyticsObject: string;
+    }
+}
+export declare const TikTokPixelOptions: import("valibot").ObjectSchema<{
+    readonly id: import("valibot").StringSchema<undefined>;
+    readonly trackPageView: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+}, undefined>;
+export type TikTokPixelInput = RegistryScriptInput<typeof TikTokPixelOptions, true, false, false>;
+export declare function useScriptTikTokPixel<T extends TikTokPixelApi>(_options?: TikTokPixelInput): import("#nuxt-scripts/types").UseScriptContext<T>;
+export {};

package/dist/runtime/registry/tiktok-pixel.js

@@ -0,0 +1,44 @@
+import { withQuery } from "ufo";
+import { useRegistryScript } from "../utils.js";
+import { object, string, optional, boolean } from "#nuxt-scripts-validator";
+export const TikTokPixelOptions = object({
+  id: string(),
+  trackPageView: optional(boolean())
+  // default true
+});
+export function useScriptTikTokPixel(_options) {
+  return useRegistryScript("tiktokPixel", (options) => ({
+    scriptInput: {
+      src: withQuery("https://analytics.tiktok.com/i18n/pixel/events.js", {
+        sdkid: options?.id,
+        lib: "ttq"
+      }),
+      crossorigin: false
+    },
+    schema: import.meta.dev ? TikTokPixelOptions : void 0,
+    scriptOptions: {
+      use() {
+        return { ttq: window.ttq };
+      }
+    },
+    clientInit: import.meta.server ? void 0 : () => {
+      window.TiktokAnalyticsObject = "ttq";
+      const ttq = window.ttq = function(...params) {
+        if (ttq.callMethod) {
+          ttq.callMethod(...params);
+        } else {
+          ttq.queue.push(params);
+        }
+      };
+      ttq.push = ttq;
+      ttq.loaded = true;
+      ttq.queue = [];
+      if (options?.id) {
+        ttq("init", options.id);
+        if (options?.trackPageView !== false) {
+          ttq("page");
+        }
+      }
+    }
+  }), _options);
+}

package/dist/runtime/registry/x-embed.d.ts

@@ -0,0 +1,77 @@
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+export interface XEmbedTweetData {
+    id_str: string;
+    text: string;
+    created_at: string;
+    favorite_count: number;
+    conversation_count: number;
+    user: {
+        name: string;
+        screen_name: string;
+        profile_image_url_https: string;
+        verified?: boolean;
+        is_blue_verified?: boolean;
+    };
+    entities?: {
+        media?: Array<{
+            media_url_https: string;
+            type: string;
+            sizes: Record<string, {
+                w: number;
+                h: number;
+            }>;
+        }>;
+        urls?: Array<{
+            url: string;
+            expanded_url: string;
+            display_url: string;
+        }>;
+    };
+    photos?: Array<{
+        url: string;
+        width: number;
+        height: number;
+    }>;
+    video?: {
+        poster: string;
+        variants: Array<{
+            type: string;
+            src: string;
+        }>;
+    };
+    quoted_tweet?: XEmbedTweetData;
+    parent?: {
+        user: {
+            screen_name: string;
+        };
+    };
+}
+export declare const XEmbedOptions: import("valibot").ObjectSchema<{
+    /**
+     * The tweet ID to embed
+     */
+    readonly tweetId: import("valibot").StringSchema<undefined>;
+    /**
+     * Optional: Custom API endpoint for fetching tweet data
+     * @default '/api/_scripts/x-embed'
+     */
+    readonly apiEndpoint: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    /**
+     * Optional: Custom image proxy endpoint
+     * @default '/api/_scripts/x-embed-image'
+     */
+    readonly imageProxyEndpoint: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+}, undefined>;
+export type XEmbedInput = RegistryScriptInput<typeof XEmbedOptions, false, false, false>;
+/**
+ * Proxy an X/Twitter image URL through the server
+ */
+export declare function proxyXImageUrl(url: string, proxyEndpoint?: string): string;
+/**
+ * Format a tweet date for display
+ */
+export declare function formatTweetDate(dateString: string): string;
+/**
+ * Format a number for display (e.g., 1234 -> 1.2K)
+ */
+export declare function formatCount(count: number): string;

package/dist/runtime/registry/x-embed.js

@@ -0,0 +1,41 @@
+import { object, optional, string } from "#nuxt-scripts-validator";
+export const XEmbedOptions = object({
+  /**
+   * The tweet ID to embed
+   */
+  tweetId: string(),
+  /**
+   * Optional: Custom API endpoint for fetching tweet data
+   * @default '/api/_scripts/x-embed'
+   */
+  apiEndpoint: optional(string()),
+  /**
+   * Optional: Custom image proxy endpoint
+   * @default '/api/_scripts/x-embed-image'
+   */
+  imageProxyEndpoint: optional(string())
+});
+export function proxyXImageUrl(url, proxyEndpoint = "/api/_scripts/x-embed-image") {
+  const separator = proxyEndpoint.includes("?") ? "&" : "?";
+  return `${proxyEndpoint}${separator}url=${encodeURIComponent(url)}`;
+}
+export function formatTweetDate(dateString) {
+  const date = new Date(dateString);
+  const time = date.toLocaleString("en-US", {
+    hour: "numeric",
+    minute: "numeric",
+    hour12: true,
+    timeZone: "UTC"
+  });
+  const day = date.toLocaleString("en-US", { month: "short", timeZone: "UTC" });
+  return `${time} \xB7 ${day} ${date.getUTCDate()}, ${date.getUTCFullYear()}`;
+}
+export function formatCount(count) {
+  if (count >= 1e6) {
+    return `${(count / 1e6).toFixed(1)}M`;
+  }
+  if (count >= 1e3) {
+    return `${(count / 1e3).toFixed(1)}K`;
+  }
+  return count.toString();
+}

package/dist/runtime/server/google-static-maps-proxy.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/google-static-maps-proxy.js

@@ -0,0 +1,54 @@
+import { createError, defineEventHandler, getHeader, getQuery, setHeader } from "h3";
+import { $fetch } from "ofetch";
+import { withQuery } from "ufo";
+import { useRuntimeConfig } from "#imports";
+export default defineEventHandler(async (event) => {
+  const runtimeConfig = useRuntimeConfig();
+  const publicConfig = runtimeConfig.public["nuxt-scripts"]?.googleStaticMapsProxy;
+  const privateConfig = runtimeConfig["nuxt-scripts"]?.googleStaticMapsProxy;
+  if (!publicConfig?.enabled) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Google Static Maps proxy is not enabled"
+    });
+  }
+  const apiKey = privateConfig?.apiKey;
+  if (!apiKey) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Google Maps API key not configured for proxy"
+    });
+  }
+  const referer = getHeader(event, "referer");
+  const host = getHeader(event, "host");
+  if (referer && host) {
+    const refererUrl = new URL(referer).host;
+    if (refererUrl !== host) {
+      throw createError({
+        statusCode: 403,
+        statusMessage: "Invalid referer"
+      });
+    }
+  }
+  const query = getQuery(event);
+  const { key: _clientKey, ...safeQuery } = query;
+  const googleMapsUrl = withQuery("https://maps.googleapis.com/maps/api/staticmap", {
+    ...safeQuery,
+    key: apiKey
+  });
+  const response = await $fetch.raw(googleMapsUrl, {
+    headers: {
+      "User-Agent": "Nuxt Scripts Google Static Maps Proxy"
+    }
+  }).catch((error) => {
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.statusMessage || "Failed to fetch static map"
+    });
+  });
+  const cacheMaxAge = publicConfig.cacheMaxAge || 3600;
+  setHeader(event, "Content-Type", response.headers.get("content-type") || "image/png");
+  setHeader(event, "Cache-Control", `public, max-age=${cacheMaxAge}, s-maxage=${cacheMaxAge}`);
+  setHeader(event, "Vary", "Accept-Encoding");
+  return response._data;
+});

package/dist/runtime/server/instagram-embed-asset.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/instagram-embed-asset.js

@@ -0,0 +1,42 @@
+import { createError, defineEventHandler, getQuery, setHeader } from "h3";
+import { $fetch } from "ofetch";
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event);
+  const url = query.url?.replace(/&/g, "&");
+  if (!url) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Asset URL is required"
+    });
+  }
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(url);
+  } catch {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid asset URL"
+    });
+  }
+  if (parsedUrl.hostname !== "static.cdninstagram.com") {
+    throw createError({
+      statusCode: 403,
+      statusMessage: "Domain not allowed"
+    });
+  }
+  const response = await $fetch.raw(url, {
+    headers: {
+      "Accept": "*/*",
+      "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36"
+    }
+  }).catch((error) => {
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.statusMessage || "Failed to fetch asset"
+    });
+  });
+  const contentType = response.headers.get("content-type") || "application/octet-stream";
+  setHeader(event, "Content-Type", contentType);
+  setHeader(event, "Cache-Control", "public, max-age=86400, s-maxage=86400");
+  return response._data;
+});

package/dist/runtime/server/instagram-embed-image.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/instagram-embed-image.js

@@ -0,0 +1,54 @@
+import { createError, defineEventHandler, getQuery, setHeader } from "h3";
+import { $fetch } from "ofetch";
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event);
+  const url = query.url?.replace(/&/g, "&");
+  if (!url) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Image URL is required"
+    });
+  }
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(url);
+  } catch {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid image URL"
+    });
+  }
+  if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid URL scheme"
+    });
+  }
+  if (!parsedUrl.hostname.endsWith(".cdninstagram.com") && parsedUrl.hostname !== "scontent.cdninstagram.com") {
+    throw createError({
+      statusCode: 403,
+      statusMessage: "Domain not allowed"
+    });
+  }
+  const response = await $fetch.raw(url, {
+    redirect: "manual",
+    headers: {
+      "Accept": "image/webp,image/jpeg,image/png,image/*,*/*;q=0.8",
+      "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36"
+    }
+  }).catch((error) => {
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.statusMessage || "Failed to fetch image"
+    });
+  });
+  if (response.status >= 300 && response.status < 400) {
+    throw createError({
+      statusCode: 403,
+      statusMessage: "Redirects not allowed"
+    });
+  }
+  setHeader(event, "Content-Type", response.headers.get("content-type") || "image/jpeg");
+  setHeader(event, "Cache-Control", "public, max-age=3600, s-maxage=3600");
+  return response._data;
+});

package/dist/runtime/server/instagram-embed.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string>>;
+export default _default;

package/dist/runtime/server/instagram-embed.js

@@ -0,0 +1,91 @@
+import { createError, defineEventHandler, getQuery, setHeader } from "h3";
+import { $fetch } from "ofetch";
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event);
+  const postUrl = query.url;
+  const captions = query.captions === "true";
+  if (!postUrl) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Post URL is required"
+    });
+  }
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(postUrl);
+  } catch {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid postUrl"
+    });
+  }
+  if (!["instagram.com", "www.instagram.com"].includes(parsedUrl.hostname)) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid Instagram URL"
+    });
+  }
+  const pathname = parsedUrl.pathname.endsWith("/") ? parsedUrl.pathname : `${parsedUrl.pathname}/`;
+  const cleanUrl = parsedUrl.origin + pathname;
+  const embedUrl = cleanUrl + "embed/" + (captions ? "captioned/" : "");
+  const html = await $fetch(embedUrl, {
+    headers: {
+      "Accept": "text/html",
+      // Use simple UA - full Chrome UA triggers JS-heavy version without static content
+      "User-Agent": "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"
+    }
+  }).catch((error) => {
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.statusMessage || "Failed to fetch Instagram embed"
+    });
+  });
+  const cssUrls = [];
+  const linkRegex = /<link[^>]+rel=["']stylesheet["'][^>]+href=["']([^"']+)["'][^>]*>/gi;
+  let match;
+  while ((match = linkRegex.exec(html)) !== null) {
+    if (match[1])
+      cssUrls.push(match[1]);
+  }
+  const linkRegex2 = /<link[^>]+href=["']([^"']+)["'][^>]+rel=["']stylesheet["'][^>]*>/gi;
+  while ((match = linkRegex2.exec(html)) !== null) {
+    if (match[1])
+      cssUrls.push(match[1]);
+  }
+  const cssContents = await Promise.all(
+    cssUrls.map(
+      (url) => $fetch(url, {
+        headers: { Accept: "text/css" }
+      }).catch(() => "")
+    )
+  );
+  let combinedCss = cssContents.join("\n");
+  combinedCss = combinedCss.replace(
+    /url\(\/rsrc\.php([^)]+)\)/g,
+    (_m, path) => `url(/api/_scripts/instagram-embed-asset?url=${encodeURIComponent(`https://static.cdninstagram.com/rsrc.php${path}`)})`
+  );
+  const baseStyles = `
+    html { background: white; max-width: 540px; width: calc(100% - 2px); border-radius: 3px; border: 1px solid rgb(219, 219, 219); display: block; margin: 0px 0px 12px; min-width: 326px; padding: 0px; }
+    #splash-screen { display: none !important; }
+    .Embed { opacity: 1 !important; visibility: visible !important; }
+    .EmbeddedMedia, .EmbeddedMediaImage { display: block !important; visibility: visible !important; }
+  `;
+  let rewrittenHtml = html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<link[^>]+rel=["']stylesheet["'][^>]*>/gi, "").replace(/<link[^>]+href=["'][^"']+\.css[^"']*["'][^>]*>/gi, "").replace(/<noscript>[\s\S]*?<\/noscript>/gi, "").replace(
+    /https:\/\/scontent[^"'\s),]+\.cdninstagram\.com[^"'\s),]+/g,
+    (m) => `/api/_scripts/instagram-embed-image?url=${encodeURIComponent(m.replace(/&amp;/g, "&"))}`
+  ).replace(
+    /https:\/\/static\.cdninstagram\.com[^"'\s),]+/g,
+    (m) => `/api/_scripts/instagram-embed-asset?url=${encodeURIComponent(m.replace(/&amp;/g, "&"))}`
+  ).replace(
+    /https:\/\/lookaside\.instagram\.com[^"'\s),]+/g,
+    (m) => `/api/_scripts/instagram-embed-image?url=${encodeURIComponent(m.replace(/&amp;/g, "&"))}`
+  );
+  rewrittenHtml = rewrittenHtml.replace(
+    "</head>",
+    `<style>${baseStyles}
+${combinedCss}</style></head>`
+  );
+  setHeader(event, "Content-Type", "text/html");
+  setHeader(event, "Cache-Control", "public, max-age=600, s-maxage=600");
+  return rewrittenHtml;
+});

package/dist/runtime/server/proxy-handler.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Privacy-aware proxy handler for first-party script collection endpoints.
+ * Routes requests to third-party analytics while protecting user privacy.
+ */
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string | Buffer<ArrayBuffer>>>;
+export default _default;