@wpnuxt/core 1.0.0-edge.29 → 1.0.0-edge.31

package/README.md

@@ -67,14 +67,14 @@ pnpm run release
 ```
 
 <!-- Badges -->
-[npm-version-src]: https://img.shields.io/npm/v/@vernaillen/wpnuxt/latest.svg?style=flat&colorA=18181B&colorB=28CF8D
-[npm-version-href]: https://www.npmjs.com/package/@vernaillen/wpnuxt
+[npm-version-src]: https://img.shields.io/npm/v/@wpnuxt/core/latest.svg?style=flat&colorA=18181B&colorB=28CF8D
+[npm-version-href]: https://www.npmjs.com/package/@wpnuxt/core
 
-[npm-downloads-src]: https://img.shields.io/npm/dm/@vernaillen/wpnuxt.svg?style=flat&colorA=18181B&colorB=28CF8D
-[npm-downloads-href]: https://www.npmjs.com/package/@vernaillen/wpnuxt
+[npm-downloads-src]: https://img.shields.io/npm/dm/@wpnuxt/core.svg?style=flat&colorA=18181B&colorB=28CF8D
+[npm-downloads-href]: https://www.npmjs.com/package/@wpnuxt/core
 
-[license-src]: https://img.shields.io/npm/l/@vernaillen/wpnuxt?style=flat&colorA=18181B&colorB=28CF8D
-[license-href]: https://www.npmjs.com/package/@vernaillen/wpnuxt
+[license-src]: https://img.shields.io/npm/l/@wpnuxt/core?style=flat&colorA=18181B&colorB=28CF8D
+[license-href]: https://www.npmjs.com/package/@wpnuxt/core
 
 [nuxt-src]: https://img.shields.io/badge/Nuxt-18181B?logo=nuxt.js
 [nuxt-href]: https://nuxt.com

package/dist/module.d.mts

@@ -1,4 +1,5 @@
 import * as _nuxt_schema from '@nuxt/schema';
+import { OperationTypeNode } from 'graphql';
 
 interface WPNuxtConfig {
 
@@ -22,6 +23,13 @@ interface WPNuxtConfig {
 
   enableCache?: boolean
 
+  /**
+   * Cache duration in seconds for WordPress content
+   *
+   * @default 300 (5 minutes)
+   */
+  cacheMaxAge?: number
+
   staging?: boolean
 
   /**

package/dist/module.json

@@ -1,10 +1,12 @@
 {
   "name": "@wpnuxt/core",
-  "version": "1.0.0-edge.29",
+  "version": "1.0.0-edge.31",
   "configKey": "wpNuxt",
-  "nuxt": ">=3.1.0",
+  "compatibility": {
+    "nuxt": ">=3.1.0"
+  },
   "builder": {
-    "@nuxt/module-builder": "1.0.1",
-    "unbuild": "3.5.0"
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
   }
 }

package/dist/module.mjs

@@ -1,31 +1,30 @@
-import { createResolver, hasNuxtModule, addTemplate, resolveFiles, defineNuxtModule, addPlugin, addImports, addComponentsDir, addServerHandler, installModule, addTypeTemplate } from '@nuxt/kit';
+import { createResolver, addTemplate, hasNuxtModule, resolveFiles, defineNuxtModule, addPlugin, addImportsDir, addComponentsDir, addServerHandler, installModule, addTypeTemplate } from '@nuxt/kit';
 import { createConsola, consola } from 'consola';
-import { promises, existsSync, cpSync, statSync } from 'node:fs';
-import { ref } from 'vue';
+import { promises, existsSync, statSync } from 'node:fs';
 import { join } from 'pathe';
 import { upperFirst } from 'scule';
 import { parse } from 'graphql';
 
 const name = "@wpnuxt/core";
-const version = "1.0.0-edge.29";
+const version = "1.0.0-edge.31";
 
-const loggerRef = ref();
+let loggerInstance;
 const initLogger = (logLevel) => {
-  loggerRef.value = createConsola({
-    level: logLevel ? logLevel : 3,
-    formatOptions: {
-      colors: true,
-      compact: true,
-      date: true,
-      fancy: true
-    }
-  }).withTag("wpnuxt");
-  return loggerRef.value;
+  if (!loggerInstance) {
+    loggerInstance = createConsola({
+      level: logLevel ?? 3,
+      formatOptions: {
+        colors: true,
+        compact: true,
+        date: true,
+        fancy: true
+      }
+    }).withTag("wpnuxt");
+  }
+  return loggerInstance;
 };
 const getLogger = () => {
-  if (loggerRef.value) {
-    return loggerRef.value;
-  }
+  return loggerInstance;
 };
 function validateConfig(options) {
   if (!options.wordpressUrl || options.wordpressUrl.length === 0) {
@@ -45,42 +44,98 @@ async function mergeQueries(nuxt) {
   await promises.rm(queryOutputPath, { recursive: true, force: true });
   const userQueryPath = "~/extend/queries/".replace(/^(~~|@@)/, nuxt.options.rootDir).replace(/^(~|@)/, nuxt.options.srcDir);
   const userQueryPathExists = existsSync(userQueryPath);
-  cpSync(resolveRuntimeModule("./queries/"), queryOutputPath, { recursive: true });
-  addQueriesFromAddOnModule("@wpnuxt/blocks", queryOutputPath, nuxt, resolve);
-  addQueriesFromAddOnModule("@wpnuxt/auth", queryOutputPath, nuxt, resolve);
+  const queryFiles = /* @__PURE__ */ new Map();
+  await copyAndTrack(resolveRuntimeModule("./queries/"), queryOutputPath, queryFiles, "runtime");
+  const blocksPath = getAddOnModuleQueriesPath("@wpnuxt/blocks", nuxt);
+  if (blocksPath) {
+    logger?.debug("Loading queries from @wpnuxt/blocks");
+    await copyAndTrack(blocksPath, queryOutputPath, queryFiles, "@wpnuxt/blocks");
+  }
+  const authPath = getAddOnModuleQueriesPath("@wpnuxt/auth", nuxt);
+  if (authPath) {
+    logger?.debug("Loading queries from @wpnuxt/auth");
+    await copyAndTrack(authPath, queryOutputPath, queryFiles, "@wpnuxt/auth");
+  }
   if (userQueryPathExists) {
-    logger.debug("Extending queries:", userQueryPath);
-    cpSync(resolve(userQueryPath), queryOutputPath, { recursive: true });
+    logger?.debug("Extending queries:", userQueryPath);
+    await copyAndTrack(resolve(userQueryPath), queryOutputPath, queryFiles, "user");
+    const conflicts = detectQueryConflicts(queryFiles);
+    if (conflicts.length > 0) {
+      logger?.warn("Query file conflicts detected:");
+      conflicts.forEach((conflict) => {
+        logger?.warn(`  - ${conflict.file} exists in multiple sources: ${conflict.sources.join(", ")}`);
+      });
+    }
+  } else {
+    if (!blocksPath) {
+      const moduleName = "wpnuxt/blocks";
+      addTemplate({
+        write: true,
+        filename: moduleName + ".mjs",
+        getContents: () => `export { }`
+      });
+      nuxt.options.alias["#" + moduleName] = resolve(nuxt.options.buildDir, moduleName);
+    }
+    if (!authPath) {
+      const moduleName = "wpnuxt/auth";
+      addTemplate({
+        write: true,
+        filename: moduleName + ".mjs",
+        getContents: () => `export { }`
+      });
+      nuxt.options.alias["#" + moduleName] = resolve(nuxt.options.buildDir, moduleName);
+    }
   }
-  logger.debug("Copied merged queries in folder:", queryOutputPath);
+  logger?.debug("Copied merged queries in folder:", queryOutputPath);
   return queryOutputPath;
 }
-function addQueriesFromAddOnModule(addOnModuleName, queryOutputPath, nuxt, resolve) {
-  const logger = getLogger();
-  if (hasNuxtModule(addOnModuleName)) {
-    for (const m of nuxt.options._installedModules) {
-      if (m.meta.name === addOnModuleName && m.entryPath) {
-        logger.debug("Loading queries from " + addOnModuleName);
-        let blocksQueriesPath;
-        if (m.entryPath == "../src/module") {
-          blocksQueriesPath = join(nuxt.options.rootDir, "../src/runtime/queries/");
-        } else if (m.entryPath.startsWith("../")) {
-          blocksQueriesPath = join(nuxt.options.rootDir, "../", m.entryPath, "./runtime/queries/");
-        } else {
-          blocksQueriesPath = join("./node_modules", m.entryPath, "dist/runtime/queries/");
+async function copyAndTrack(sourcePath, destPath, fileMap, sourceLabel) {
+  try {
+    const entries = await promises.readdir(sourcePath, { withFileTypes: true });
+    await promises.mkdir(destPath, { recursive: true });
+    await Promise.all(
+      entries.map(async (entry) => {
+        const srcPath = join(sourcePath, entry.name);
+        const destFilePath = join(destPath, entry.name);
+        if (entry.isDirectory()) {
+          await copyAndTrack(srcPath, destFilePath, fileMap, sourceLabel);
+        } else if (entry.isFile() && (entry.name.endsWith(".gql") || entry.name.endsWith(".graphql"))) {
+          await promises.copyFile(srcPath, destFilePath);
+          const existing = fileMap.get(entry.name);
+          fileMap.set(entry.name, existing ? `${existing},${sourceLabel}` : sourceLabel);
         }
-        cpSync(blocksQueriesPath, queryOutputPath, { recursive: true });
+      })
+    );
+  } catch {
+  }
+}
+function detectQueryConflicts(fileMap) {
+  const conflicts = [];
+  fileMap.forEach((sources, file) => {
+    const sourceList = sources.split(",");
+    if (sourceList.length > 1) {
+      conflicts.push({ file, sources: sourceList });
+    }
+  });
+  return conflicts;
+}
+function getAddOnModuleQueriesPath(addOnModuleName, nuxt) {
+  if (!hasNuxtModule(addOnModuleName)) {
+    return null;
+  }
+  const installedModules = nuxt.options._installedModules || [];
+  for (const m of installedModules) {
+    if (m.meta.name === addOnModuleName && m.entryPath) {
+      if (m.entryPath === "../src/module") {
+        return join(nuxt.options.rootDir, "../src/runtime/queries/");
+      } else if (m.entryPath.startsWith("../")) {
+        return join(nuxt.options.rootDir, "../", m.entryPath, "./runtime/queries/");
+      } else {
+        return join("./node_modules", m.entryPath, "dist/runtime/queries/");
       }
     }
-  } else {
-    const moduleName = addOnModuleName.replace("@", "");
-    addTemplate({
-      write: true,
-      filename: moduleName + ".mjs",
-      getContents: () => `export { }`
-    });
-    nuxt.options.alias["#" + moduleName] = resolve(nuxt.options.buildDir, moduleName);
   }
+  return null;
 }
 
 const _parseDoc = async (doc) => {
@@ -132,44 +187,59 @@ async function prepareContext(ctx) {
     const fragments = q.fragments?.length ? q.fragments.map((f) => `${f}Fragment${fragmentSuffix}`).join(" | ") : "any";
     return `  export const ${functionName}: (params?: ${q.name}QueryVariables) => AsyncData<${fragments}, FetchError | null | undefined>`;
   };
-  ctx.generateImports = () => [
-    ...ctx.fns.map((f) => fnExp(f))
-  ].join("\n");
+  ctx.generateImports = () => {
+    const parts = ["import { useWPContent } from '#imports'", ""];
+    for (const fn of ctx.fns) {
+      parts.push(fnExp(fn));
+    }
+    return parts.join("\n");
+  };
   const types = [];
-  ctx.fns.forEach((o) => types.push(...getQueryTypeTemplate(o)));
-  ctx.generateDeclarations = () => [
-    `import type { ${[...new Set(types)].join(", ")} } from '#build/graphql-operations'`,
-    "import { AsyncData } from 'nuxt/app'",
-    "import { FetchError } from 'ofetch'",
-    "declare module '#wpnuxt' {",
-    ...[
-      ...ctx.fns.map((f) => fnExp(f, true))
-    ],
-    "}"
-  ].join("\n");
+  for (const fn of ctx.fns) {
+    types.push(...getQueryTypeTemplate(fn));
+  }
+  ctx.generateDeclarations = () => {
+    const declarations = [
+      `import type { ${[...new Set(types)].join(", ")} } from '#build/graphql-operations'`,
+      "import { AsyncData } from 'nuxt/app'",
+      "import { FetchError } from 'ofetch'",
+      "declare module '#wpnuxt' {"
+    ];
+    for (const fn of ctx.fns) {
+      declarations.push(fnExp(fn, true));
+    }
+    declarations.push("}");
+    return declarations.join("\n");
+  };
   ctx.fnImports = ctx.fns.map((fn) => ({ from: "#wpnuxt", name: fnName(fn.name) }));
-  logger.debug("generated WPNuxt composables: ");
-  ctx.fns.forEach((f) => logger.debug(` ${fnName(f.name)}()`));
+  if (logger) {
+    logger.debug("generated WPNuxt composables: ");
+    for (const fn of ctx.fns) {
+      logger.debug(` ${fnName(fn.name)}()`);
+    }
+  }
 }
 function getQueryTypeTemplate(q) {
-  const types = [];
-  types.push(`${q.name}QueryVariables`);
+  const types = [`${q.name}QueryVariables`];
   if (q.fragments && q.fragments.length > 0) {
-    q.fragments.forEach((f) => types.push(`${f}Fragment`));
+    for (const fragment of q.fragments) {
+      types.push(`${fragment}Fragment`);
+    }
   }
   return types;
 }
 async function prepareFunctions(ctx) {
   if (!ctx.docs) {
-    getLogger().error("no GraphQL query documents were found!");
+    getLogger()?.error("no GraphQL query documents were found!");
     return;
   }
-  for await (const doc of ctx.docs) {
-    const operations = await parseDoc(await promises.readFile(doc, "utf8"));
-    operations.forEach((query) => {
-      ctx.fns.push(query);
-    });
-  }
+  const allOperations = await Promise.all(
+    ctx.docs.map(async (doc) => {
+      const content = await promises.readFile(doc, "utf8");
+      return parseDoc(content);
+    })
+  );
+  ctx.fns.push(...allOperations.flat());
 }
 
 const allowDocument = (f, resolver) => {
@@ -190,6 +260,7 @@ const defaultConfigs = {
   frontendUrl: "",
   defaultMenuName: "main",
   enableCache: true,
+  cacheMaxAge: 300,
   staging: false,
   logLevel: 3,
   composablesPrefix: "useWP",
@@ -201,7 +272,9 @@ const module = defineNuxtModule({
     name,
     version,
     configKey: "wpNuxt",
-    nuxt: ">=3.1.0"
+    compatibility: {
+      nuxt: ">=3.1.0"
+    }
   },
   // Default configuration options of the Nuxt module
   defaults: defaultConfigs,
@@ -213,6 +286,7 @@ const module = defineNuxtModule({
       frontendUrl: process.env.WPNUXT_FRONTEND_URL || options.frontendUrl,
       defaultMenuName: process.env.WPNUXT_DEFAULT_MENU_NAME || options.defaultMenuName,
       enableCache: process.env.WPNUXT_ENABLE_CACHE ? process.env.WPNUXT_ENABLE_CACHE === "true" : options.enableCache,
+      cacheMaxAge: process.env.WPNUXT_CACHE_MAX_AGE ? Number.parseInt(process.env.WPNUXT_CACHE_MAX_AGE) : options.cacheMaxAge,
       staging: process.env.WPNUXT_STAGING === "true" || options.staging,
       downloadSchema: process.env.WPNUXT_DOWNLOAD_SCHEMA === "true" || options.downloadSchema,
       logLevel: process.env.WPNUXT_LOG_LEVEL ? Number.parseInt(process.env.WPNUXT_LOG_LEVEL) : options.logLevel,
@@ -223,9 +297,9 @@ const module = defineNuxtModule({
     nuxt.options.runtimeConfig.public.wpNuxt = publicWPNuxtConfig;
     validateConfig(publicWPNuxtConfig);
     const logger = initLogger(publicWPNuxtConfig.logLevel);
-    logger.info("config:", publicWPNuxtConfig);
-    logger.info("Connecting GraphQL to", publicWPNuxtConfig.wordpressUrl);
-    logger.info("frontendUrl:", publicWPNuxtConfig.frontendUrl);
+    logger.debug("Config:", publicWPNuxtConfig);
+    logger.debug("Connecting GraphQL to", publicWPNuxtConfig.wordpressUrl);
+    logger.info("WPNuxt frontend URL:", publicWPNuxtConfig.frontendUrl);
     if (publicWPNuxtConfig.enableCache) logger.info("Cache enabled");
     logger.debug("Debug mode enabled, log level:", publicWPNuxtConfig.logLevel);
     if (publicWPNuxtConfig.staging) logger.info("Staging enabled");
@@ -242,42 +316,35 @@ const module = defineNuxtModule({
     addPlugin({
       src: resolveRuntimeModule("plugins/vue-sanitize-directive")
     });
-    addImports([
-      { name: "isStaging", as: "isStaging", from: resolveRuntimeModule("./composables/isStaging") },
-      { name: "useWPContent", as: "useWPContent", from: resolveRuntimeModule("./composables/useWPContent") },
-      { name: "parseDoc", as: "parseDoc", from: resolveRuntimeModule("./composables/useParser") },
-      { name: "usePrevNextPost", as: "usePrevNextPost", from: resolveRuntimeModule("./composables/usePrevNextPost") },
-      { name: "loginUser", as: "loginUser", from: resolveRuntimeModule("./composables/user") },
-      { name: "logoutUser", as: "logoutUser", from: resolveRuntimeModule("./composables/user") },
-      { name: "getCurrentUserId", as: "getCurrentUserId", from: resolveRuntimeModule("./composables/user") },
-      { name: "getCurrentUserName", as: "getCurrentUserName", from: resolveRuntimeModule("./composables/user") },
-      { name: "useTokens", as: "useTokens", from: resolveRuntimeModule("./composables/useTokens") },
-      { name: "useWPUri", as: "useWPUri", from: resolveRuntimeModule("./composables/useWPUri") },
-      { name: "useFeaturedImage", as: "useFeaturedImage", from: resolveRuntimeModule("./composables/useFeaturedImage") }
-    ]);
+    addImportsDir(resolveRuntimeModule("./composables"));
     addComponentsDir({
       path: resolveRuntimeModule("./components"),
       pathPrefix: false,
       prefix: "",
-      global: true
+      global: false,
+      // Lazy load components for better performance
+      extensions: [".vue"]
     });
     addServerHandler({
-      route: "/api/wpContent",
-      handler: resolveRuntimeModule("./server/api/wpContent.post")
+      route: "/api/_wpnuxt/content",
+      handler: resolveRuntimeModule("./server/api/_wpnuxt/content.post")
     });
     addServerHandler({
-      route: "/api/config",
-      handler: resolveRuntimeModule("./server/api/config")
+      route: "/api/_wpnuxt/config",
+      handler: resolveRuntimeModule("./server/api/_wpnuxt/config")
     });
-    await installModule("@vueuse/nuxt", {});
-    const mergedQueriesFolder = await mergeQueries(nuxt);
+    const [_, mergedQueriesFolder] = await Promise.all([
+      installModule("@vueuse/nuxt", {}),
+      mergeQueries(nuxt)
+    ]);
     await installModule("nuxt-graphql-middleware", {
       debug: publicWPNuxtConfig.logLevel ? publicWPNuxtConfig.logLevel > 3 : false,
       graphqlEndpoint: `${publicWPNuxtConfig.wordpressUrl}/graphql`,
       downloadSchema: publicWPNuxtConfig.downloadSchema,
       codegenConfig: {
         debugMode: publicWPNuxtConfig.logLevel ? publicWPNuxtConfig.logLevel > 3 : false,
-        useCache: false
+        useCache: !publicWPNuxtConfig.downloadSchema
+        // Cache when schema is committed
       },
       codegenSchemaConfig: {
         urlSchemaOptions: {

package/dist/runtime/components/ContentRenderer.d.vue.ts

@@ -0,0 +1,7 @@
+import type { NodeWithContentEditorFragment } from '#build/graphql-operations';
+type __VLS_Props = {
+    node: NodeWithContentEditorFragment;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/ContentRenderer.vue.d.ts

@@ -2,5 +2,6 @@ import type { NodeWithContentEditorFragment } from '#build/graphql-operations';
 type __VLS_Props = {
     node: NodeWithContentEditorFragment;
 };
-declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/StagingBanner.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/StagingBanner.vue

@@ -1,10 +1,8 @@
 <script setup>
 import { OperationTypeNode } from "graphql";
-import { useWPUri } from "../composables/useWPUri";
-import { useWPContent } from "../composables";
 import WPNuxtLogo from "./WPNuxtLogo.vue";
 import WordPressLogo from "./WordPressLogo.vue";
-import { useRuntimeConfig, useHead, useRoute } from "#imports";
+import { useRuntimeConfig, useHead, useRoute, useWPContent, useWPUri } from "#imports";
 const config = useRuntimeConfig();
 const frontendUrl = config.public.wpNuxt.frontendUrl;
 const wordpressUrl = config.public.wpNuxt.wordpressUrl;
@@ -38,20 +36,24 @@ if (import.meta.client) {
       <div class="bar-left">
         <WPNuxtLogo wp-color="white" />
         <div class="bar-button-wrapper">
-          <NuxtLink
-            :to="wpUri.admin"
+          <a
+            :href="wpUri.admin"
             class="bar-button"
+            target="_blank"
+            rel="noopener noreferrer"
           >
             <WordPressLogo /> Admin
-          </NuxtLink>
+          </a>
         </div>
         <div
           v-if="post"
           class="bar-button-wrapper"
         >
-          <NuxtLink
-            :to="wpUri.postEdit('' + post.databaseId)"
+          <a
+            :href="wpUri.postEdit('' + post.databaseId)"
             class="bar-button primary"
+            target="_blank"
+            rel="noopener noreferrer"
           >
             <svg
               class="icon"
@@ -69,16 +71,17 @@ if (import.meta.client) {
               />
             </svg>
             Edit <span class="hidden sm:inline-flex">{{ post.contentTypeName }}</span>
-          </NuxtLink>
+          </a>
         </div>
       </div>
       <div class="bar-right">
         <div class="bar-button-wrapper">
-          <NuxtLink
+          <a
             v-if="frontendUrl"
-            :to="frontendUrl"
+            :href="frontendUrl"
             class="bar-button"
             target="_blank"
+            rel="noopener noreferrer"
           >
             Live site
             <svg
@@ -93,7 +96,7 @@ if (import.meta.client) {
                 d="M18 10.82a1 1 0 0 0-1 1V19a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V8a1 1 0 0 1 1-1h7.18a1 1 0 0 0 0-2H5a3 3 0 0 0-3 3v11a3 3 0 0 0 3 3h11a3 3 0 0 0 3-3v-7.18a1 1 0 0 0-1-1m3.92-8.2a1 1 0 0 0-.54-.54A1 1 0 0 0 21 2h-6a1 1 0 0 0 0 2h3.59L8.29 14.29a1 1 0 0 0 0 1.42a1 1 0 0 0 1.42 0L20 5.41V9a1 1 0 0 0 2 0V3a1 1 0 0 0-.08-.38"
               />
             </svg>
-          </NuxtLink>
+          </a>
         </div>
       </div>
     </div>

package/dist/runtime/components/StagingBanner.vue.d.ts

@@ -1,2 +1,3 @@
-declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/WPContent.d.vue.ts

@@ -0,0 +1,7 @@
+import type { NodeWithContentEditorFragment, NodeWithEditorBlocksFragment } from '#build/graphql-operations';
+type __VLS_Props = {
+    node: NodeWithContentEditorFragment | NodeWithEditorBlocksFragment;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/WPContent.vue.d.ts

@@ -2,5 +2,6 @@ import type { NodeWithContentEditorFragment, NodeWithEditorBlocksFragment } from
 type __VLS_Props = {
     node: NodeWithContentEditorFragment | NodeWithEditorBlocksFragment;
 };
-declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/WPNuxtLogo.d.vue.ts

@@ -0,0 +1,6 @@
+type __VLS_Props = {
+    wpColor?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/WPNuxtLogo.vue.d.ts

@@ -1,5 +1,6 @@
 type __VLS_Props = {
     wpColor?: string;
 };
-declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/WordPressLogo.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/WordPressLogo.vue.d.ts

@@ -1,2 +1,3 @@
-declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/composables/usePrevNextPost.d.ts

@@ -1,4 +1,4 @@
 export declare const usePrevNextPost: (currentPostPath: string) => Promise<{
-    prev: any;
-    next: any;
+    prev: string | null;
+    next: string | null;
 }>;

package/dist/runtime/composables/usePrevNextPost.js

@@ -1,5 +1,5 @@
 import { OperationTypeNode } from "graphql";
-import { useWPContent } from "./useWPContent.js";
+import { useWPContent } from "#imports";
 const _usePrevNextPost = async (currentPostPath) => {
   const currentPostSlug = currentPostPath.replaceAll("/", "");
   const allPosts = await getAllPosts();
@@ -8,15 +8,15 @@ const _usePrevNextPost = async (currentPostPath) => {
   const nextPost = currentIndex > 0 ? allPosts.slugs[currentIndex - 1] : null;
   const prevPost = allPosts.slugs.length > currentIndex + 1 ? allPosts.slugs[currentIndex + 1] : null;
   return {
-    prev: prevPost ? prevPost : null,
-    next: nextPost ? nextPost : null
+    prev: prevPost ?? null,
+    next: nextPost ?? null
   };
 };
 const getAllPosts = async () => {
   const { data: allPosts } = await useWPContent(OperationTypeNode.QUERY, "Posts", ["posts", "nodes"], false);
-  if (allPosts) {
+  if (allPosts && Array.isArray(allPosts)) {
     return {
-      slugs: allPosts?.map((post) => {
+      slugs: allPosts.map((post) => {
         if (post) return post.slug;
         else return null;
       })

package/dist/runtime/composables/useWPContent.d.ts

@@ -1,6 +1,8 @@
 import type { FetchError } from 'ofetch';
 import type { OperationTypeNode } from 'graphql';
-export declare const useWPContent: <T>(operation: OperationTypeNode, queryName: string, nodes: string[], fixImagePaths: boolean, params?: T) => Promise<{
-    data: unknown;
-    error: import("vue").Ref<FetchError<any> | null, FetchError<any> | null>;
-}>;
+interface WPContentResponse<T> {
+    data?: T;
+    error?: FetchError | null;
+}
+export declare const useWPContent: <T>(operation: OperationTypeNode, queryName: string, nodes: string[], fixImagePaths: boolean, params?: T) => Promise<WPContentResponse<T>>;
+export {};

package/dist/runtime/composables/useWPContent.js

@@ -1,22 +1,57 @@
 import { getRelativeImagePath } from "../util/images.js";
+import { useRuntimeConfig } from "#imports";
 const _useWPContent = async (operation, queryName, nodes, fixImagePaths, params) => {
-  const { data, error } = await $fetch("/api/wpContent", {
-    method: "POST",
-    body: {
-      operation,
-      queryName,
-      params
+  try {
+    const config = useRuntimeConfig();
+    const wordpressUrl = config.public.wpNuxt.wordpressUrl;
+    const response = await $fetch("/api/_wpnuxt/content", {
+      method: "POST",
+      body: {
+        operation,
+        queryName,
+        params
+      }
+    });
+    const { data, error } = response;
+    const actualError = error && typeof error === "object" && "value" in error ? error.value : error;
+    if (actualError) {
+      console.error(`[WPNuxt] Error fetching ${queryName}:`, actualError);
+      return { data: void 0, error: actualError };
     }
-  });
-  return {
-    data: data ? transformData(data, nodes, fixImagePaths) : void 0,
-    error
-  };
+    return {
+      data: data ? transformData(data, nodes, fixImagePaths, wordpressUrl) : void 0,
+      error: null
+    };
+  } catch (err) {
+    const fetchError = err;
+    console.error(`[WPNuxt] Failed to fetch ${queryName}:`, fetchError.message || err);
+    return {
+      data: void 0,
+      error: fetchError
+    };
+  }
+};
+const fixMalformedUrls = (content, wordpressUrl) => {
+  const urlObj = new URL(wordpressUrl);
+  const port = urlObj.port;
+  if (port) {
+    const malformedPattern = new RegExp(`(href|src)=["']:${port}/`, "g");
+    content = content.replace(malformedPattern, `$1="${wordpressUrl}/`);
+  }
+  return content;
 };
-const transformData = (data, nodes, fixImagePaths) => {
+const transformData = (data, nodes, fixImagePaths, wordpressUrl) => {
   const transformedData = findData(data, nodes);
-  if (fixImagePaths && transformedData?.featuredImage?.node?.sourceUrl) {
-    transformedData.featuredImage.node.relativePath = getRelativeImagePath(transformedData.featuredImage.node.sourceUrl);
+  if (transformedData && typeof transformedData === "object") {
+    if ("content" in transformedData && typeof transformedData.content === "string") {
+      transformedData.content = fixMalformedUrls(transformedData.content, wordpressUrl);
+    }
+    if (fixImagePaths && "featuredImage" in transformedData) {
+      const typed = transformedData;
+      if (typed.featuredImage?.node?.sourceUrl) {
+        typed.featuredImage.node.relativePath = getRelativeImagePath(typed.featuredImage.node.sourceUrl);
+      }
+    }
   }
   return transformedData;
 };
@@ -24,8 +59,12 @@ const findData = (data, nodes) => {
   if (nodes.length === 0) return data;
   if (nodes.length > 0) {
     return nodes.reduce((acc, node) => {
-      return acc[node];
+      if (acc && typeof acc === "object" && node in acc) {
+        return acc[node];
+      }
+      return acc;
     }, data);
   }
+  return data;
 };
 export const useWPContent = _useWPContent;

package/dist/runtime/plugins/vue-sanitize-directive.d.ts

@@ -1,2 +1,6 @@
-declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
-export default _default;
+declare module 'vue-sanitize-directive' {
+  import type { Plugin } from 'vue'
+
+  const VueSanitizeDirective: Plugin
+  export default VueSanitizeDirective
+}

package/dist/runtime/server/api/{config.js → _wpnuxt/config.js}

@@ -1,4 +1,5 @@
-import { defineCachedEventHandler, useRuntimeConfig } from "#imports";
+import { defineCachedEventHandler } from "nitro/runtime";
+import { useRuntimeConfig } from "#imports";
 export default defineCachedEventHandler(async (event) => {
   const config = useRuntimeConfig(event);
   return {

package/dist/runtime/server/api/_wpnuxt/content.post.d.ts

@@ -0,0 +1,10 @@
+declare const _default: any;
+export default _default;
+/**
+ * Get the parameters for the GraphQL middleware query.
+ * Converts complex objects to a JSON string to pass as a single query parameter.
+ *
+ * @param variables - The GraphQL query variables
+ * @returns Query parameters suitable for GET requests
+ */
+export declare function buildRequestParams(variables?: Record<string, unknown> | undefined | null): Record<string, string>;

package/dist/runtime/server/api/_wpnuxt/content.post.js

@@ -0,0 +1,105 @@
+import { readBody, createError } from "h3";
+import { LRUCache } from "lru-cache";
+import { defineCachedEventHandler } from "nitro/runtime";
+import { useRuntimeConfig } from "#imports";
+const queryCache = new LRUCache({
+  max: 500,
+  // Maximum 500 cached queries
+  ttl: 1e3 * 60 * 5,
+  // 5 minutes TTL
+  updateAgeOnGet: true,
+  // Refresh TTL on access
+  updateAgeOnHas: false
+});
+function fastHash(str) {
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+  }
+  return (hash >>> 0).toString(36);
+}
+async function getCachedBody(event) {
+  if (!event.context._wpContentBody) {
+    event.context._wpContentBody = await readBody(event);
+  }
+  return event.context._wpContentBody;
+}
+export default defineCachedEventHandler(async (event) => {
+  const config = useRuntimeConfig().public.wpNuxt;
+  const body = await getCachedBody(event);
+  if (!body || !body.queryName) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Bad Request",
+      message: "The request must contain a queryName"
+    });
+  }
+  const memoryCacheKey = `${body.queryName}_${body.params ? fastHash(JSON.stringify(body.params)) : "no-params"}`;
+  const cached = queryCache.get(memoryCacheKey);
+  if (cached && config?.enableCache) {
+    return {
+      data: cached.data,
+      error: cached.error
+    };
+  }
+  try {
+    const operation = body.operation || "query";
+    const response = await $fetch(
+      `/api/graphql_middleware/${operation}/${body.queryName}`,
+      {
+        method: operation === "mutation" ? "POST" : "GET",
+        params: operation === "query" ? buildRequestParams(body.params) : void 0,
+        body: operation === "mutation" ? body.params : void 0,
+        headers: {
+          Authorization: `Bearer ${event.context.accessToken || ""}`
+        }
+      }
+    );
+    if (response.errors && response.errors.length > 0) {
+      console.error(`[WPNuxt] GraphQL errors for ${body.queryName}:`, response.errors);
+    }
+    const result = {
+      data: response.data,
+      error: response.errors || void 0
+    };
+    if (operation === "query" && config?.enableCache) {
+      queryCache.set(memoryCacheKey, {
+        data: result.data,
+        error: result.error,
+        timestamp: Date.now()
+      });
+    }
+    return result;
+  } catch (error) {
+    console.error(`[WPNuxt] Failed to fetch GraphQL query ${body.queryName}:`, error);
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Internal Server Error",
+      message: `Failed to fetch content: ${error instanceof Error ? error.message : "Unknown error"}`
+    });
+  }
+}, {
+  group: "api",
+  name: "wpContent",
+  getKey: async (event) => {
+    const body = await getCachedBody(event);
+    const paramsHash = body.params ? fastHash(JSON.stringify(body.params)) : "";
+    return `${body.queryName}${paramsHash ? `_${paramsHash}` : ""}`;
+  },
+  swr: true,
+  maxAge: useRuntimeConfig().public.wpNuxt?.cacheMaxAge || 300
+});
+export function buildRequestParams(variables) {
+  if (!variables) {
+    return {};
+  }
+  for (const key in variables) {
+    if (typeof variables[key] !== "string") {
+      return {
+        __variables: JSON.stringify(variables)
+      };
+    }
+  }
+  return variables;
+}

package/dist/runtime/server/nitro.d.ts

@@ -0,0 +1,3 @@
+declare module 'nitro/runtime' {
+  export { defineCachedEventHandler } from 'nitropack/runtime'
+}

package/dist/runtime/types.d.ts

@@ -0,0 +1,87 @@
+// Type declarations for auto-generated modules
+declare module '#graphql-operations' {
+  export * from '#build/graphql-operations'
+}
+
+declare module '#build/graphql-operations' {
+  // These types are auto-generated by nuxt-graphql-middleware
+  export interface NodeByUriQueryVariables {
+    uri?: string
+  }
+
+  export interface PostsQueryVariables {
+    first?: number
+    after?: string
+  }
+
+  // Fragment types
+  export interface MenuItemFragment {
+    id?: string
+    label?: string
+    url?: string
+  }
+
+  export interface PostFragment {
+    id?: string
+    title?: string
+    content?: string
+    slug?: string
+    uri?: string
+    date?: string
+    excerpt?: string
+    contentTypeName?: string
+    categories?: {
+      nodes?: Array<{ name?: string }>
+    }
+    featuredImage?: {
+      node?: {
+        sourceUrl?: string
+        altText?: string
+      }
+    }
+  }
+
+  export interface PageFragment {
+    id?: string
+    title?: string
+    content?: string
+    slug?: string
+    uri?: string
+    date?: string
+    contentTypeName?: string
+    featuredImage?: {
+      node?: {
+        sourceUrl?: string
+        altText?: string
+      }
+    }
+  }
+
+  export interface NodeWithContentEditorFragment {
+    id?: string
+    content?: string
+  }
+
+  export interface NodeWithEditorBlocksFragment {
+    id?: string
+    editorBlocks?: unknown[]
+  }
+
+  export interface NodeWithFeaturedImage {
+    id?: string
+    featuredImage?: {
+      node?: {
+        sourceUrl?: string
+      }
+    }
+  }
+
+  // Add more as needed by the actual GraphQL schema
+  export type Maybe<T> = T | null
+}
+
+declare module '#wpnuxt/blocks' {
+  // Placeholder for blocks module types
+  export const CoreButton: unknown
+  export const BlockRenderer: unknown
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wpnuxt/core",
-  "version": "1.0.0-edge.29",
+  "version": "1.0.0-edge.31",
   "description": "WPNuxt",
   "repository": {
     "type": "git",
@@ -51,45 +51,44 @@
     "start": "pnpm run wp-env:create && pnpm run dev"
   },
   "dependencies": {
-    "@nuxt/kit": "3.17.1",
-    "@vueuse/nuxt": "^13.1.0",
+    "@nuxt/kit": "4.2.2",
+    "@vueuse/nuxt": "^14.1.0",
+    "consola": "^3.4.2",
     "defu": "^6.1.4",
-    "graphql": "^16.11.0",
-    "nuxt-graphql-middleware": "5.0.0",
+    "graphql": "^16.12.0",
+    "knitwork": "^1.3.0",
+    "lru-cache": "^11.2.4",
+    "nuxt-graphql-middleware": "5.2.3",
+    "pathe": "^2.0.3",
+    "scule": "^1.3.0",
     "vue-sanitize-directive": "^0.2.1"
   },
   "devDependencies": {
-    "@nuxt/devtools": "^2.4.0",
-    "@nuxt/eslint-config": "^1.3.0",
-    "@nuxt/module-builder": "^1.0.1",
-    "@nuxt/schema": "3.17.1",
-    "@nuxt/test-utils": "^3.18.0",
-    "@rollup/rollup-linux-arm64-gnu": "^4.40.1",
-    "@rollup/rollup-linux-arm64-musl": "^4.40.1",
-    "@types/node": "22.15.3",
-    "@vitest/coverage-v8": "^3.1.2",
+    "@nuxt/devtools": "^3.1.1",
+    "@nuxt/eslint-config": "^1.12.1",
+    "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/schema": "4.2.2",
+    "@nuxt/test-utils": "^3.21.0",
+    "@rollup/rollup-linux-arm64-gnu": "^4.53.5",
+    "@rollup/rollup-linux-arm64-musl": "^4.53.5",
+    "@types/node": "25.0.3",
+    "@vitest/coverage-v8": "^4.0.16",
     "@vue/test-utils": "^2.4.6",
-    "@wordpress/env": "^10.22.0",
-    "changelogen": "^0.6.1",
-    "markdownlint-cli": "^0.44.0",
-    "nuxt": "^3.17.1",
+    "@wordpress/env": "^10.36.0",
+    "changelogen": "^0.6.2",
+    "markdownlint-cli": "^0.47.0",
+    "nuxt": "^4.2.2",
     "nuxt-content-twoslash": "^0.1.2",
-    "release-it": "^19.0.1",
-    "typescript": "^5.8.3",
+    "release-it": "^19.1.0",
+    "typescript": "^5.9.3",
     "untyped": "2.0.0",
-    "vite": "^6.3.4",
-    "vitest": "^3.1.2",
+    "vite": "^7.3.0",
+    "vitest": "^4.0.16",
     "vue-docgen-web-types": "^0.1.8",
-    "vue-tsc": "2.2.10"
-  },
-  "peerDependencies": {
-    "consola": "^3.3.3",
-    "graphql": "^16.10.0",
-    "knitwork": "^1.2.0",
-    "pathe": "^2.0.1",
-    "scule": "^1.3.0"
+    "vue-tsc": "3.1.8"
   },
   "engines": {
     "node": ">=20"
-  }
+  },
+  "packageManager": "pnpm@10.18.0+sha512.e804f889f1cecc40d572db084eec3e4881739f8dec69c0ff10d2d1beff9a4e309383ba27b5b750059d7f4c149535b6cd0d2cb1ed3aeb739239a4284a68f40cfa"
 }

package/dist/runtime/composables/index.d.ts

@@ -1,3 +0,0 @@
-export { isStaging } from './isStaging.js';
-export { useWPContent } from './useWPContent.js';
-export { useWPUri } from './useWPUri.js';

package/dist/runtime/composables/index.js

@@ -1,3 +0,0 @@
-export { isStaging } from "./isStaging.js";
-export { useWPContent } from "./useWPContent.js";
-export { useWPUri } from "./useWPUri.js";

package/dist/runtime/server/api/wpContent.post.d.ts

@@ -1,6 +0,0 @@
-declare const _default: any;
-export default _default;
-/**
- * Get the parameters for the GraphQL middleware query.
- */
-export declare function buildRequestParams(variables?: Record<string, any> | undefined | null): Record<string, any>;

package/dist/runtime/server/api/wpContent.post.js

@@ -1,46 +0,0 @@
-import { readBody } from "h3";
-import { defineCachedEventHandler } from "#imports";
-export default defineCachedEventHandler(async (event) => {
-  const body = await readBody(event);
-  if (!body || !body.queryName) {
-    throw new Error(
-      "The request must contain a queryName"
-    );
-  }
-  return $fetch("/api/graphql_middleware/" + (body.operation || "query") + "/" + body.queryName, {
-    method: body.operation === "mutation" ? "POST" : "GET",
-    params: body.operation === "query" ? buildRequestParams(body.params) : void 0,
-    body: body.operation === "mutation" ? body.params : void 0,
-    headers: {
-      Authorization: `Bearer ${event.context.accessToken}`
-    }
-  }).then((v) => {
-    return {
-      data: v.data,
-      error: v.errors || void 0
-    };
-  });
-}, {
-  group: "api",
-  name: "wpContent",
-  getKey: async (event) => {
-    const body = await readBody(event);
-    return `${body.queryName}${body.params ? "_" + JSON.stringify(body.params).replaceAll('"', "").replaceAll(":", "_") : ""}`;
-  },
-  swr: true,
-  maxAge: 60 * 5
-  // 5 minutes
-});
-export function buildRequestParams(variables) {
-  if (!variables) {
-    return {};
-  }
-  for (const key in variables) {
-    if (typeof variables[key] !== "string") {
-      return {
-        __variables: JSON.stringify(variables)
-      };
-    }
-  }
-  return variables;
-}