nuxt-studio 1.4.0 → 1.5.1

package/dist/module/runtime/server/routes/ipx/[...path].js

@@ -0,0 +1,40 @@
+import { eventHandler, getRequestURL, setResponseHeader } from "h3";
+import { requireStudioAuth } from "../../utils/auth.js";
+import { DAY_IN_SECONDS, IPX_PREFIX, getContentTypeFromPath, getIpx, getOriginalImage, parseIpxPath, requireAllowedDomain } from "../../utils/media/ipx.js";
+export default eventHandler(async (event) => {
+  await requireStudioAuth(event);
+  const url = getRequestURL(event);
+  if (!url.pathname.startsWith(`${IPX_PREFIX}/`)) {
+    return;
+  }
+  const parsed = parseIpxPath(url.pathname);
+  if (!parsed) {
+    return;
+  }
+  const domain = requireAllowedDomain(parsed.id);
+  const ipx = getIpx(domain);
+  const image = ipx(parsed.id, parsed.modifiers);
+  let data;
+  let format;
+  try {
+    const result = await image.process();
+    data = result.data;
+    format = result.format;
+  } catch (error) {
+    const fallbackData = await getOriginalImage(parsed.id);
+    if (!fallbackData) {
+      throw error;
+    }
+    data = fallbackData;
+  }
+  if (format) {
+    setResponseHeader(event, "content-type", `image/${format}`);
+  } else {
+    const contentType = getContentTypeFromPath(parsed.id);
+    if (contentType) {
+      setResponseHeader(event, "content-type", contentType);
+    }
+  }
+  setResponseHeader(event, "cache-control", `public, max-age=${DAY_IN_SECONDS}, s-maxage=${DAY_IN_SECONDS}`);
+  return data;
+});

package/dist/module/runtime/server/routes/meta.d.ts

@@ -7,8 +7,15 @@ export interface NuxtComponentMeta {
     global: boolean;
 }
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
-    markdownConfig: any;
-    highlightTheme: any;
-    components: ComponentMeta[];
+    markdownConfig: object;
+    highlightTheme: object;
+    components: {
+        list: ComponentMeta[];
+        groups?: Array<{
+            label: string;
+            include: string[];
+        }>;
+        ungrouped?: "include" | "omit";
+    };
 }>>;
 export default _default;

package/dist/module/runtime/server/routes/meta.js

@@ -22,9 +22,19 @@ export default eventHandler(async (event) => {
     mappedComponents,
     config.studio?.meta?.components
   );
-  return {
+  const componentGroups = config.studio?.meta?.components?.groups;
+  const hasGroups = Array.isArray(componentGroups) && componentGroups.length > 0;
+  const response = {
     markdownConfig: config.studio.markdown || {},
     highlightTheme: highlight?.theme || { default: "github-light", dark: "github-dark", light: "github-light" },
-    components: filteredComponents
+    components: {
+      list: filteredComponents
+    }
   };
+  if (hasGroups) {
+    response.components.groups = componentGroups.map((g) => ({ label: g.label, include: g.include }));
+    const ungrouped = config.studio?.meta?.components?.ungrouped;
+    response.components.ungrouped = ungrouped === "omit" ? "omit" : "include";
+  }
+  return response;
 });

package/dist/module/runtime/server/utils/media/ipx.d.ts

@@ -0,0 +1,14 @@
+import type { IPX } from 'ipx';
+export declare const IPX_PREFIX = "/__nuxt_studio/ipx";
+export declare const DAY_IN_SECONDS: number;
+export declare const publicDir: string;
+export declare function requireAllowedDomain(id: string): string | undefined;
+export declare function getIpx(domain?: string): IPX;
+export declare function getContentTypeFromPath(path: string): "image/svg+xml" | "image/jpeg" | "image/png" | "image/gif" | "image/webp" | "image/avif" | "image/x-icon" | null;
+export declare function getOriginalImage(id: string): Promise<Buffer | null>;
+export declare function getOriginalExternalImage(id: string): Promise<Buffer | null>;
+export declare function getOriginalFsImage(id: string): Promise<NonSharedBuffer | null>;
+export declare function parseIpxPath(pathname: string): {
+    id: string;
+    modifiers: Record<string, string>;
+} | null;

package/dist/module/runtime/server/utils/media/ipx.js

@@ -0,0 +1,111 @@
+import { createError } from "h3";
+import { createIPX, ipxFSStorage, ipxHttpStorage } from "ipx";
+import { readFile } from "node:fs/promises";
+import { extname, resolve } from "node:path";
+import { hasProtocol, parseURL } from "ufo";
+import { useRuntimeConfig } from "#imports";
+export const IPX_PREFIX = "/__nuxt_studio/ipx";
+export const DAY_IN_SECONDS = 60 * 60 * 24;
+const mediaConfig = useRuntimeConfig().public.studio.media;
+export const publicDir = mediaConfig.publicUrl;
+let cachedIpx = null;
+export function requireAllowedDomain(id) {
+  if (!mediaConfig.external) return void 0;
+  const configuredDomain = parseURL(mediaConfig.publicUrl).host;
+  const requestDomain = parseURL(id).host;
+  if (configuredDomain && requestDomain !== configuredDomain) {
+    throw createError({ statusCode: 403, statusMessage: "IPX_FORBIDDEN_DOMAIN" });
+  }
+  return requestDomain || configuredDomain || void 0;
+}
+export function getIpx(domain) {
+  if (!cachedIpx) {
+    if (mediaConfig.external) {
+      cachedIpx = createIPX({
+        storage: {},
+        httpStorage: ipxHttpStorage({ domains: domain ? [domain] : [] }),
+        maxAge: DAY_IN_SECONDS
+      });
+    } else {
+      cachedIpx = createIPX({
+        storage: ipxFSStorage({ dir: publicDir }),
+        maxAge: DAY_IN_SECONDS
+      });
+    }
+  }
+  return cachedIpx;
+}
+export function getContentTypeFromPath(path) {
+  const extension = extname(path).toLowerCase();
+  if (extension === ".ico") return "image/x-icon";
+  if (extension === ".svg") return "image/svg+xml";
+  if (extension === ".png") return "image/png";
+  if (extension === ".jpg" || extension === ".jpeg") return "image/jpeg";
+  if (extension === ".webp") return "image/webp";
+  if (extension === ".gif") return "image/gif";
+  if (extension === ".avif") return "image/avif";
+  return null;
+}
+export async function getOriginalImage(id) {
+  return hasProtocol(id) ? getOriginalExternalImage(id) : getOriginalFsImage(id);
+}
+export async function getOriginalExternalImage(id) {
+  try {
+    const response = await fetch(id);
+    if (!response.ok) return null;
+    return Buffer.from(await response.arrayBuffer());
+  } catch {
+    return null;
+  }
+}
+export async function getOriginalFsImage(id) {
+  if (hasProtocol(id)) {
+    return null;
+  }
+  const normalizedId = id.replace(/^\/+/, "");
+  if (!normalizedId) {
+    return null;
+  }
+  const absolutePath = resolve(publicDir, normalizedId);
+  if (!absolutePath.startsWith(`${publicDir}/`) && absolutePath !== publicDir) {
+    return null;
+  }
+  try {
+    return await readFile(absolutePath);
+  } catch {
+    return null;
+  }
+}
+export function parseIpxPath(pathname) {
+  const relativePath = pathname.slice(IPX_PREFIX.length).replace(/^\/+/, "");
+  if (!relativePath) {
+    return null;
+  }
+  const [modifiersString, ...idSegments] = relativePath.split("/");
+  if (!modifiersString) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "IPX_MISSING_MODIFIERS",
+      message: "IPX modifiers are required."
+    });
+  }
+  const id = decodeURIComponent(idSegments.join("/")).replace(/^(https?:\/)([^/])/, "$1/$2");
+  if (!id) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "IPX_MISSING_ID",
+      message: "IPX resource id is required."
+    });
+  }
+  const modifiers = {};
+  if (modifiersString !== "_") {
+    for (const rawModifier of modifiersString.split(/[&,]/g)) {
+      const [key, ...values] = rawModifier.split(/[:=_]/);
+      if (!key) {
+        continue;
+      }
+      modifiers[key] = values.map((value) => decodeURIComponent(value)).join("_");
+    }
+  }
+  return { id, modifiers };
+}

package/dist/module/runtime/utils/componentGroups.d.ts

@@ -0,0 +1,20 @@
+import type { ComponentMeta } from 'nuxt-studio/app';
+export interface ComponentGroupConfig {
+    label: string;
+    include: string[];
+}
+export interface ComponentGroup {
+    label: string;
+    components: ComponentMeta[];
+}
+/**
+ * Assigns components to groups based on include patterns.
+ * First-match wins when a component matches multiple groups.
+ *
+ * @param components - Flat list of components to group
+ * @param groups - Group configs with label and include patterns
+ * @param ungrouped - Whether unmatched components go in a fallback group
+ * @param fallbackLabel - Label for the fallback group when ungrouped is 'include'
+ * @returns Array of groups with their components (empty groups omitted)
+ */
+export declare function assignComponentsToGroups(components: ComponentMeta[], groups: ComponentGroupConfig[], ungrouped: 'include' | 'omit', fallbackLabel: string): ComponentGroup[];

package/dist/module/runtime/utils/componentGroups.js

@@ -0,0 +1,30 @@
+import { minimatch } from "minimatch";
+function matchAnyPattern(component, patterns) {
+  return patterns.some((pattern) => {
+    const value = pattern.includes("/") ? component.path : component.name;
+    return minimatch(value, pattern);
+  });
+}
+export function assignComponentsToGroups(components, groups, ungrouped, fallbackLabel) {
+  const result = groups.map((g) => ({ label: g.label, components: [] }));
+  const unmatched = [];
+  for (const component of components) {
+    let matched = false;
+    for (let i = 0; i < groups.length; i++) {
+      const group = groups[i];
+      if (group && matchAnyPattern(component, group.include)) {
+        result[i].components.push(component);
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      unmatched.push(component);
+    }
+  }
+  const filtered = result.filter((g) => g.components.length > 0);
+  if (ungrouped === "include" && unmatched.length > 0) {
+    filtered.push({ label: fallbackLabel, components: unmatched });
+  }
+  return filtered;
+}

package/dist/module/runtime/utils/document/generate.js

@@ -54,14 +54,17 @@ export async function generateDocumentFromJSONContent(id, content) {
       body: parsed
     };
   }
-  return {
+  const document = {
     id,
     extension: ContentFileExtension.JSON,
     stem: generateStemFromId(id),
     meta: {},
-    ...parsed,
-    body: parsed.body || parsed
+    ...parsed
   };
+  if (parsed.body) {
+    document.body = parsed.body;
+  }
+  return document;
 }
 export async function generateDocumentFromMarkdownContent(id, content, options = { compress: true }) {
   const markdownConfig = useHostMeta().markdownConfig.value;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-studio",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "description": "Nuxt Studio for Nuxt Content",
   "private": false,
   "repository": {
@@ -49,6 +49,7 @@
   },
   "dependencies": {
     "@ai-sdk/gateway": "^3.0.55",
+    "ipx": "^3.1.1",
     "@ai-sdk/vue": "^3.0.101",
     "@iconify-json/lucide": "^1.2.94",
     "@nuxtjs/mdc": "^0.20.1",