nuxt-schema-org 4.0.4 → 4.1.1

package/dist/content.d.cts

@@ -0,0 +1,15 @@
+import * as zod from 'zod';
+import { TypeOf, ZodRawShape } from 'zod';
+import { Collection } from '@nuxt/content';
+
+declare const schema: zod.ZodObject<{
+    schemaOrg: zod.ZodOptional<zod.ZodUnion<[zod.ZodRecord<zod.ZodString, zod.ZodAny>, zod.ZodOptional<zod.ZodArray<zod.ZodRecord<zod.ZodString, zod.ZodAny>, "many">>]>>;
+}, "strip", zod.ZodTypeAny, {
+    schemaOrg?: Record<string, any> | Record<string, any>[] | undefined;
+}, {
+    schemaOrg?: Record<string, any> | Record<string, any>[] | undefined;
+}>;
+type SchemaOrgSchema = TypeOf<typeof schema>;
+declare function asSchemaOrgCollection<T extends ZodRawShape>(collection: Collection<T>): Collection<T>;
+
+export { type SchemaOrgSchema, asSchemaOrgCollection, schema };

package/dist/content.d.mts

@@ -0,0 +1,15 @@
+import * as zod from 'zod';
+import { TypeOf, ZodRawShape } from 'zod';
+import { Collection } from '@nuxt/content';
+
+declare const schema: zod.ZodObject<{
+    schemaOrg: zod.ZodOptional<zod.ZodUnion<[zod.ZodRecord<zod.ZodString, zod.ZodAny>, zod.ZodOptional<zod.ZodArray<zod.ZodRecord<zod.ZodString, zod.ZodAny>, "many">>]>>;
+}, "strip", zod.ZodTypeAny, {
+    schemaOrg?: Record<string, any> | Record<string, any>[] | undefined;
+}, {
+    schemaOrg?: Record<string, any> | Record<string, any>[] | undefined;
+}>;
+type SchemaOrgSchema = TypeOf<typeof schema>;
+declare function asSchemaOrgCollection<T extends ZodRawShape>(collection: Collection<T>): Collection<T>;
+
+export { type SchemaOrgSchema, asSchemaOrgCollection, schema };

package/dist/content.d.ts

@@ -0,0 +1,15 @@
+import * as zod from 'zod';
+import { TypeOf, ZodRawShape } from 'zod';
+import { Collection } from '@nuxt/content';
+
+declare const schema: zod.ZodObject<{
+    schemaOrg: zod.ZodOptional<zod.ZodUnion<[zod.ZodRecord<zod.ZodString, zod.ZodAny>, zod.ZodOptional<zod.ZodArray<zod.ZodRecord<zod.ZodString, zod.ZodAny>, "many">>]>>;
+}, "strip", zod.ZodTypeAny, {
+    schemaOrg?: Record<string, any> | Record<string, any>[] | undefined;
+}, {
+    schemaOrg?: Record<string, any> | Record<string, any>[] | undefined;
+}>;
+type SchemaOrgSchema = TypeOf<typeof schema>;
+declare function asSchemaOrgCollection<T extends ZodRawShape>(collection: Collection<T>): Collection<T>;
+
+export { type SchemaOrgSchema, asSchemaOrgCollection, schema };

package/dist/content.mjs

@@ -0,0 +1,23 @@
+import { z } from '@nuxt/content';
+
+const SchemaOrgNode = z.record(z.string(), z.any());
+const schema = z.object({
+  schemaOrg: z.union([SchemaOrgNode, z.array(SchemaOrgNode).optional()]).optional()
+});
+const headSchema = z.object({
+  head: z.object({
+    meta: z.array(z.record(z.string(), z.any()).optional()),
+    script: z.array(z.record(z.string(), z.any()).optional())
+  }).optional()
+});
+function asSchemaOrgCollection(collection) {
+  if (collection.type === "page") {
+    collection.schema = collection.schema ? schema.extend(collection.schema.shape) : schema;
+    if (!("head" in collection.schema.shape)) {
+      collection.schema = headSchema.extend(collection.schema.shape);
+    }
+  }
+  return collection;
+}
+
+export { asSchemaOrgCollection, schema };

package/dist/module.cjs

@@ -1,5 +1,209 @@
-module.exports = function(...args) {
-  return import('./module.mjs').then(m => m.default.call(this, ...args))
+'use strict';
+
+const kit = require('@nuxt/kit');
+const schemaOrg = require('@unhead/schema-org');
+const vue = require('@unhead/schema-org/vue');
+const defu = require('defu');
+const kit$1 = require('nuxt-site-config/kit');
+const pkgTypes = require('pkg-types');
+const node_fs = require('node:fs');
+const pathe = require('pathe');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+const DEVTOOLS_UI_ROUTE = "/__nuxt-schema-org";
+const DEVTOOLS_UI_LOCAL_PORT = 3030;
+function setupDevToolsUI(options, resolve, nuxt = kit.useNuxt()) {
+  const clientPath = resolve("./client");
+  const isProductionBuild = node_fs.existsSync(clientPath);
+  if (isProductionBuild) {
+    nuxt.hook("vite:serverCreated", async (server) => {
+      const sirv = await import('sirv').then((r) => r.default || r);
+      server.middlewares.use(
+        DEVTOOLS_UI_ROUTE,
+        sirv(clientPath, { dev: true, single: true })
+      );
+    });
+  } else {
+    nuxt.hook("vite:extendConfig", (config) => {
+      config.server = config.server || {};
+      config.server.proxy = config.server.proxy || {};
+      config.server.proxy[DEVTOOLS_UI_ROUTE] = {
+        target: `http://localhost:${DEVTOOLS_UI_LOCAL_PORT}${DEVTOOLS_UI_ROUTE}`,
+        changeOrigin: true,
+        followRedirects: true,
+        rewrite: (path) => path.replace(DEVTOOLS_UI_ROUTE, "")
+      };
+    });
+  }
+  nuxt.hook("devtools:customTabs", (tabs) => {
+    tabs.push({
+      // unique identifier
+      name: "nuxt-schema-org",
+      // title to display in the tab
+      title: "Schema.org",
+      // any icon from Iconify, or a URL to an image
+      icon: "carbon:chart-relationship",
+      // iframe view
+      view: {
+        type: "iframe",
+        src: DEVTOOLS_UI_ROUTE
+      }
+    });
+  });
 }
-const _meta = module.exports.meta = require('./module.json')
-module.exports.getMeta = () => Promise.resolve(_meta)
+
+function extendTypes(module, template) {
+  const nuxt = kit.useNuxt();
+  const { resolve } = kit.createResolver((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('module.cjs', document.baseURI).href)));
+  kit.addTemplate({
+    filename: `module/${module}.d.ts`,
+    getContents: async () => {
+      const typesPath = pathe.relative(resolve(nuxt.options.rootDir, nuxt.options.buildDir, "module"), resolve("runtime/types"));
+      const s = await template({ typesPath });
+      return `// Generated by ${module}
+${s}
+export {}
+`;
+    }
+  });
+  nuxt.hooks.hook("prepare:types", ({ references }) => {
+    references.push({ path: resolve(nuxt.options.buildDir, `module/${module}.d.ts`) });
+  });
+}
+
+const module$1 = kit.defineNuxtModule({
+  meta: {
+    name: "nuxt-schema-org",
+    configKey: "schemaOrg",
+    compatibility: {
+      nuxt: ">=3.7.0",
+      bridge: false
+    }
+  },
+  defaults(nuxt) {
+    return {
+      enabled: true,
+      debug: nuxt.options.debug || false,
+      defaults: true,
+      reactive: nuxt.options.dev || !nuxt.options.ssr,
+      minify: !nuxt.options.dev,
+      scriptAttributes: {
+        "data-nuxt-schema-org": true
+      }
+    };
+  },
+  async setup(config, nuxt) {
+    const { resolve } = kit.createResolver((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('module.cjs', document.baseURI).href)));
+    const { name, version } = await pkgTypes.readPackageJSON(resolve("../package.json"));
+    const logger = kit.useLogger(name);
+    logger.level = config.debug ? 4 : 3;
+    if (config.enabled === false) {
+      logger.debug("The module is disabled, skipping setup.");
+      return;
+    }
+    if (!nuxt.options.ssr && nuxt.options.dev)
+      logger.warn("You are using Schema.org with SSR disabled. This is not recommended, Google may not detect your Schema.org, and it adds extra page weight");
+    await kit$1.installNuxtSiteConfig();
+    const runtimeConfig = {
+      reactive: config.reactive,
+      minify: config.minify,
+      scriptAttributes: config.scriptAttributes,
+      identity: config.identity,
+      version
+    };
+    if (config.reactive)
+      nuxt.options.runtimeConfig.public["nuxt-schema-org"] = runtimeConfig;
+    else
+      nuxt.options.runtimeConfig["nuxt-schema-org"] = runtimeConfig;
+    const pluginPath = kit.hasNuxtModule("@nuxtjs/i18n") && nuxt.options.i18n?.locales ? "./runtime/app/plugins/i18n" : "./runtime/app/plugins";
+    kit.addPlugin({
+      src: resolve(pluginPath, "init"),
+      mode: config.reactive ? "all" : "server"
+    });
+    if (config.defaults) {
+      kit.addPlugin({
+        src: resolve(pluginPath, "defaults"),
+        mode: config.reactive ? "all" : "server"
+      });
+    }
+    nuxt.options.alias["#schema-org"] = resolve("./runtime");
+    const usingNuxtContent = kit.hasNuxtModule("@nuxt/content");
+    const isNuxtContentV3 = usingNuxtContent && await kit.hasNuxtModuleCompatibility("@nuxt/content", "^3");
+    const isNuxtContentV2 = usingNuxtContent && await kit.hasNuxtModuleCompatibility("@nuxt/content", "^2");
+    if (isNuxtContentV3) {
+      nuxt.hooks.hook("content:file:afterParse", (ctx) => {
+        if (typeof ctx.content.schemaOrg === "undefined") {
+          return;
+        }
+        const content = ctx.content;
+        const nodes = Array.isArray(content.schemaOrg) ? content.schemaOrg : [schemaOrg.defineWebPage(content.schemaOrg)];
+        const replaceType = (node) => {
+          if (node.type) {
+            node["@type"] = node.type;
+            delete node.type;
+          }
+          Object.entries(node).forEach(([, value]) => {
+            if (typeof value === "object") {
+              replaceType(value);
+            }
+          });
+          return node;
+        };
+        const script = {
+          type: "application/ld+json",
+          key: "schema-org-graph",
+          nodes: nodes.map(replaceType),
+          ...config.scriptAttributes
+        };
+        content.head = defu.defu({
+          script: [script]
+        }, content.head);
+        ctx.content = content;
+      });
+    } else if (isNuxtContentV2) {
+      kit.addServerPlugin(resolve("./runtime/server/plugins/nuxt-content-v2"));
+    }
+    if (!config.reactive)
+      nuxt.options.optimization.treeShake.composables.client["nuxt-schema-org"] = vue.schemaOrgAutoImports[0].imports;
+    for (const component of vue.schemaOrgComponents) {
+      await kit.addComponent({
+        name: component,
+        export: component,
+        chunkName: "nuxt-schema-org/components",
+        filePath: "@unhead/schema-org/vue"
+      });
+    }
+    kit.addImports({
+      from: resolve("./runtime/app/composables/useSchemaOrg"),
+      name: "useSchemaOrg"
+    });
+    nuxt.hooks.hook("imports:sources", (autoImports) => {
+      vue.schemaOrgAutoImports[0].imports = vue.schemaOrgAutoImports[0].imports.filter((i) => i !== "useSchemaOrg");
+      autoImports.unshift(...vue.schemaOrgAutoImports);
+    });
+    extendTypes("nuxt-schema-org", ({ typesPath }) => {
+      return `
+declare module '@nuxt/schema' {
+  export interface RuntimeNuxtHooks {
+    'schema-org:meta': (meta: import('${typesPath}').MetaInput) => void | Promise<void>
+  }
+}
+declare module '#app' {
+  export interface RuntimeNuxtHooks {
+    'schema-org:meta': (meta: import('${typesPath}').MetaInput) => void | Promise<void>
+  }
+}
+`;
+    });
+    if (config.debug || nuxt.options.dev) {
+      kit.addServerHandler({
+        route: "/__schema-org__/debug.json",
+        handler: resolve("./runtime/server/routes/__schema-org__/debug")
+      });
+    }
+    if (nuxt.options.dev)
+      setupDevToolsUI(config, resolve);
+  }
+});
+
+module.exports = module$1;

package/dist/module.d.cts

@@ -0,0 +1,49 @@
+import { NuxtModule } from '@nuxt/schema';
+import { ScriptBase, TagUserProperties, DataKeys } from '@unhead/schema';
+import { OrganizationSimple, PersonSimple, LocalBusinessSimple } from '@unhead/schema-org';
+
+interface ModuleOptions {
+    /**
+     * Whether a default WebPage, WebSite and Identity node be created.
+     */
+    defaults?: boolean;
+    /**
+     * The identity of the site.
+     */
+    identity?: 'Person' | 'Organization' | 'LocalBusiness' | OrganizationSimple | PersonSimple | LocalBusinessSimple;
+    /**
+     * Whether the module should be loaded.
+     *
+     * @default true
+     */
+    enabled: boolean;
+    /**
+     * Whether the output should be minified.
+     *
+     * @default `process.env.NODE_ENV === 'production'`
+     */
+    minify: boolean;
+    /**
+     * Whether the output should be reactive or just use the initial SSR output.
+     *
+     * @default `process.dev || !nuxt.options.ssr`
+     */
+    reactive: boolean;
+    /**
+     * Attributes to apply to the script tag containing the LD+JSON Schema.org snippet.
+     *
+     * By default, will apply an `id` of `schema-org-graph`. Set to `false` to apply no attributes.
+     */
+    scriptAttributes?: (ScriptBase & TagUserProperties & DataKeys) | false;
+    /**
+     * Enables debug logs.
+     *
+     * @default false
+     */
+    debug: boolean;
+}
+interface ModuleHooks {
+}
+declare const _default: NuxtModule<ModuleOptions>;
+
+export { type ModuleHooks, type ModuleOptions, _default as default };

package/dist/module.json

@@ -5,7 +5,7 @@
     "nuxt": ">=3.7.0",
     "bridge": false
   },
-  "version": "4.0.3",
+  "version": "4.1.0",
   "builder": {
     "@nuxt/module-builder": "0.8.4",
     "unbuild": "2.0.0"

package/dist/module.mjs

@@ -1,5 +1,7 @@
 import { useNuxt, createResolver, addTemplate, defineNuxtModule, useLogger, hasNuxtModule, addPlugin, hasNuxtModuleCompatibility, addServerPlugin, addComponent, addImports, addServerHandler } from '@nuxt/kit';
+import { defineWebPage } from '@unhead/schema-org';
 import { schemaOrgAutoImports, schemaOrgComponents } from '@unhead/schema-org/vue';
+import { defu } from 'defu';
 import { installNuxtSiteConfig } from 'nuxt-site-config/kit';
 import { readPackageJSON } from 'pkg-types';
 import { existsSync } from 'node:fs';
@@ -122,8 +124,41 @@ const module = defineNuxtModule({
       });
     }
     nuxt.options.alias["#schema-org"] = resolve("./runtime");
-    if (hasNuxtModule("@nuxt/content") && await hasNuxtModuleCompatibility("@nuxt/content", "^2")) {
-      addServerPlugin(resolve("./runtime/server/plugins/nuxt-content"));
+    const usingNuxtContent = hasNuxtModule("@nuxt/content");
+    const isNuxtContentV3 = usingNuxtContent && await hasNuxtModuleCompatibility("@nuxt/content", "^3");
+    const isNuxtContentV2 = usingNuxtContent && await hasNuxtModuleCompatibility("@nuxt/content", "^2");
+    if (isNuxtContentV3) {
+      nuxt.hooks.hook("content:file:afterParse", (ctx) => {
+        if (typeof ctx.content.schemaOrg === "undefined") {
+          return;
+        }
+        const content = ctx.content;
+        const nodes = Array.isArray(content.schemaOrg) ? content.schemaOrg : [defineWebPage(content.schemaOrg)];
+        const replaceType = (node) => {
+          if (node.type) {
+            node["@type"] = node.type;
+            delete node.type;
+          }
+          Object.entries(node).forEach(([, value]) => {
+            if (typeof value === "object") {
+              replaceType(value);
+            }
+          });
+          return node;
+        };
+        const script = {
+          type: "application/ld+json",
+          key: "schema-org-graph",
+          nodes: nodes.map(replaceType),
+          ...config.scriptAttributes
+        };
+        content.head = defu({
+          script: [script]
+        }, content.head);
+        ctx.content = content;
+      });
+    } else if (isNuxtContentV2) {
+      addServerPlugin(resolve("./runtime/server/plugins/nuxt-content-v2"));
     }
     if (!config.reactive)
       nuxt.options.optimization.treeShake.composables.client["nuxt-schema-org"] = schemaOrgAutoImports[0].imports;

package/dist/runtime/app/plugins/i18n/tsconfig.json

@@ -1,3 +1,3 @@
-{
-  "extends": "../../../../../test/fixtures/i18n/.nuxt/tsconfig.json"
-}
+{
+  "extends": "../../../../../test/fixtures/i18n/.nuxt/tsconfig.json"
+}

package/dist/runtime/server/plugins/nuxt-content-v2.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitropack/types").NitroAppPlugin;
+export default _default;

package/dist/runtime/server/tsconfig.json

@@ -1,3 +1,3 @@
-{
-  "extends": "../../../.nuxt/tsconfig.server.json"
-}
+{
+  "extends": "../../../.nuxt/tsconfig.server.json"
+}

package/dist/schema.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+const schemaOrg = require('@unhead/schema-org');
+
+
+
+Object.keys(schemaOrg).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = schemaOrg[k];
+});

package/dist/schema.d.cts

@@ -0,0 +1 @@
+export * from '@unhead/schema-org';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-schema-org",
   "type": "module",
-  "version": "4.0.4",
+  "version": "4.1.1",
   "description": "The quickest and easiest way to build Schema.org graphs for Nuxt.",
   "author": "Harlan Wilton <harlan@harlanzw.com>",
   "license": "MIT",
@@ -30,48 +30,55 @@
     "./schema": {
       "types": "./dist/schema.d.ts",
       "import": "./dist/schema.mjs"
+    },
+    "./content": {
+      "types": "./dist/content.d.ts",
+      "import": "./dist/content.mjs"
     }
   },
   "main": "./dist/module.cjs",
   "types": "./dist/types.d.ts",
+  "typesVersions": {
+    "*": {
+      "content": [
+        "dist/content"
+      ]
+    }
+  },
   "files": [
+    "content.d.ts",
     "dist",
     "schema.d.ts"
   ],
   "dependencies": {
-    "@nuxt/devtools-kit": "^1.6.3",
-    "@nuxt/kit": "^3.14.1592",
-    "@unhead/schema-org": "^1.11.14",
+    "@nuxt/devtools-kit": "^2.0.0-beta.3",
+    "@nuxt/kit": "^3.15.2",
+    "@unhead/schema-org": "^1.11.18",
+    "defu": "^6.1.4",
     "nuxt-site-config": "^3.0.6",
-    "pathe": "^1.1.2",
-    "pkg-types": "^1.2.1",
+    "pathe": "^2.0.2",
+    "pkg-types": "^1.3.1",
     "sirv": "^3.0.0"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^3.11.2",
-    "@nuxt/content": "^2.13.4",
+    "@antfu/eslint-config": "^3.14.0",
+    "@nuxt/content": "^3.0.0",
     "@nuxt/module-builder": "^0.8.4",
-    "@nuxt/schema": "^3.14.1592",
-    "@nuxt/test-utils": "^3.15.1",
-    "@nuxt/ui": "^2.20.0",
+    "@nuxt/schema": "^3.15.2",
+    "@nuxt/test-utils": "^3.15.4",
+    "@nuxt/ui": "^2.21.0",
     "@nuxtjs/i18n": "^9.1.1",
-    "@nuxtjs/robots": "^5.0.1",
-    "bumpp": "^9.9.0",
+    "@nuxtjs/robots": "^5.2.0",
+    "bumpp": "^9.10.1",
     "cheerio": "^1.0.0",
-    "eslint": "^9.16.0",
-    "nuxt": "^3.14.1592",
+    "eslint": "^9.18.0",
+    "nuxt": "^3.15.2",
     "typescript": "5.6.3",
-    "vitest": "^2.1.8"
+    "vitest": "^3.0.2"
   },
   "resolutions": {
     "typescript": "5.6.3"
   },
-  "build": {
-    "externals": [
-      "@unhead/schema",
-      "@unhead/schema-org/vue"
-    ]
-  },
   "scripts": {
     "lint": "eslint . --fix",
     "client:build": "nuxi generate client",

package/schema.d.ts

@@ -1 +1 @@
-export * from './dist/schema'
+export * from './dist/schema'