nuxt-schema-org 0.7.0-beta.3 → 1.0.0-beta.11

package/dist/module.d.ts

@@ -1,23 +1,24 @@
-import { SchemaOrgOptions } from '@vueuse/schema-org';
+import { MetaInput } from 'schema-org-graph-js';
 import { NuxtModule } from '@nuxt/schema';
 
-interface ModuleOptions extends SchemaOrgOptions {
+interface ModuleOptions {
     /**
      * Should schema.org only be rendered by the server.
      *
      * Useful for optimising performance as it may not be needed by search engines. Changes runtime package size to 0kb.
+     *
+     * @default false
      */
-    disableRuntimeScriptsWhenSSR: boolean;
+    client?: boolean;
     /**
-     * Whether composables will be automatically imported for you.
-     * @default true
+     * Should full schema types from `schema-dts` be used over a simplified version.
+     * @default false
      */
-    autoImportComposables: boolean;
+    full?: boolean;
     /**
-     * Whether components will be automatically imported for you.
-     * @default true
+     * Metadata for the schema.org generation
      */
-    autoImportComponents: boolean;
+    meta?: MetaInput;
 }
 interface ModuleHooks {
 }

package/dist/module.json

@@ -4,5 +4,5 @@
     "bridge": false
   },
   "name": "nuxt-schema-org",
-  "version": "0.7.0-beta.3"
+  "version": "1.0.0-beta.11"
 }

package/dist/module.mjs

@@ -1,23 +1,9 @@
 import { defineNuxtModule, createResolver, addPlugin, addTemplate, addComponent } from '@nuxt/kit';
-import { schemaOrgAutoImports, schemaOrgComponents } from '@vueuse/schema-org';
-import { createUnplugin } from 'unplugin';
-import MagicString from 'magic-string';
+import { AliasRuntime, AliasProvider, schemaOrgComponents, schemaOrgAutoImports } from '@vueuse/schema-org';
+import { dirname } from 'pathe';
+import { SchemaOrg } from '@vueuse/schema-org-vite';
 
-function normalizeWindowsPath(input = "") {
-  if (!input.includes("\\")) {
-    return input;
-  }
-  return input.replace(/\\/g, "/");
-}
-const _IS_ABSOLUTE_RE = /^\/|^\\|^[a-zA-Z]:[/\\]/;
-const isAbsolute = function(p) {
-  return _IS_ABSOLUTE_RE.test(p);
-};
-const dirname = function(p) {
-  return normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1).join("/") || (isAbsolute(p) ? "/" : ".");
-};
-
-const SchemaOrgPkg = "@vueuse/schema-org";
+const Pkg = "@vueuse/schema-org";
 const module = defineNuxtModule({
   meta: {
     configKey: "schemaOrg",
@@ -25,88 +11,52 @@ const module = defineNuxtModule({
       bridge: false
     }
   },
-  defaults: {
-    disableRuntimeScriptsWhenSSR: false,
-    autoImportComposables: true,
-    autoImportComponents: true
-  },
-  async setup(config, nuxt) {
+  async setup(moduleOptions, nuxt) {
     const { resolve, resolvePath } = createResolver(import.meta.url);
-    const runtimeDir = resolve("./runtime");
-    nuxt.options.build.transpile.push(runtimeDir);
-    const registerClientScripts = !config.disableRuntimeScriptsWhenSSR || nuxt.options.dev;
-    if (registerClientScripts)
-      addPlugin(resolve(runtimeDir, "plugin.client"));
-    addPlugin(resolve(runtimeDir, "plugin.server"));
-    const schemaOrgPath = dirname(await resolvePath(SchemaOrgPkg));
-    nuxt.options.alias[SchemaOrgPkg] = schemaOrgPath;
-    nuxt.options.build.transpile.push(...[schemaOrgPath, SchemaOrgPkg]);
-    nuxt.hook("vite:extendConfig", (config2) => {
-      config2.optimizeDeps = config2.optimizeDeps || {};
-      config2.optimizeDeps.exclude = config2.optimizeDeps.exclude || [];
-      config2.optimizeDeps.exclude.push(...[schemaOrgPath, SchemaOrgPkg]);
+    const schemaOrgPath = dirname(await resolvePath(Pkg));
+    const moduleRuntimeDir = resolve("./runtime");
+    nuxt.options.build.transpile.push(...[moduleRuntimeDir, AliasRuntime]);
+    if (typeof moduleOptions.client === "undefined")
+      moduleOptions.client = !!nuxt.options.dev;
+    const providerPath = await resolvePath(`${schemaOrgPath}/providers/${moduleOptions.full ? "full" : "simple"}`);
+    nuxt.options.alias[AliasProvider] = providerPath;
+    nuxt.options.alias[AliasRuntime] = "@vueuse/schema-org/runtime";
+    nuxt.options.alias[Pkg] = schemaOrgPath;
+    if (!moduleOptions.client)
+      addPlugin(resolve(moduleRuntimeDir, "plugin-fallback.client"));
+    addPlugin({
+      src: resolve(moduleRuntimeDir, "plugin"),
+      mode: moduleOptions.client ? "all" : "server"
     });
     addTemplate({
-      filename: "schemaOrg.config.mjs",
-      getContents: () => `export default ${JSON.stringify({ config })}`
+      filename: "nuxt-schema-org-config.mjs",
+      getContents: () => `export default ${JSON.stringify(moduleOptions)}`
     });
-    if (config.autoImportComposables) {
-      nuxt.hooks.hookOnce("autoImports:sources", (autoImports) => {
-        autoImports.unshift({
-          from: resolve("./runtime/composables"),
-          imports: schemaOrgAutoImports[SchemaOrgPkg]
-        });
+    for (const component of schemaOrgComponents) {
+      await addComponent({
+        name: component,
+        export: component,
+        chunkName: "nuxt-schema-org/components",
+        filePath: AliasRuntime
       });
     }
-    if (config.autoImportComponents) {
-      schemaOrgComponents.forEach((component) => {
-        addComponent({
-          name: component,
-          export: component,
-          filePath: schemaOrgPath
-        });
-      });
-    }
-    if (!registerClientScripts) {
-      const mockTemplate = addTemplate({
-        filename: "schema-org-mock.mjs",
-        getContents() {
-          return schemaOrgAutoImports[SchemaOrgPkg].map((s) => `export function ${s}() {}`).join("\n");
-        }
-      });
-      addComponent({
-        name: "SchemaOrgMock",
-        export: "SchemaOrgMock",
-        filePath: schemaOrgPath
-      });
-      nuxt.options.alias["#schema-org/mock"] = mockTemplate.dst;
-      const mockerPlugin = createUnplugin(() => {
-        return {
-          name: "nuxt-schema-org:mocker",
-          enforce: "post",
-          transformInclude(id) {
-            return id.endsWith(".vue") && id.includes(nuxt.options.srcDir);
-          },
-          transform(code, id) {
-            const s = new MagicString(code);
-            s.replace(resolve(runtimeDir, "composables"), "#schema-org/mock");
-            s.replace(/_resolveComponent\("SchemaOrg(.*?)"\)/gm, '_resolveComponent("SchemaOrgMock")');
-            if (s.hasChanged()) {
-              return {
-                code: s.toString(),
-                map: s.generateMap({ includeContent: true, source: id })
-              };
-            }
-          }
-        };
-      });
-      nuxt.hook("vite:extendConfig", (config2, { isClient }) => {
-        if (isClient) {
-          config2.plugins = config2.plugins || [];
-          config2.plugins.push(mockerPlugin.vite());
+    nuxt.hooks.hook("autoImports:sources", (autoImports) => {
+      autoImports.unshift(...schemaOrgAutoImports);
+    });
+    nuxt.hooks.hook("vite:extendConfig", (config, { isClient }) => {
+      config.optimizeDeps = config.optimizeDeps || {};
+      config.optimizeDeps.exclude = config.optimizeDeps.exclude || [];
+      config.optimizeDeps.exclude.push(...[`${schemaOrgPath}/runtime`, Pkg]);
+      config.plugins = config.plugins || [];
+      config.plugins.push(SchemaOrg({
+        mock: !moduleOptions.client && isClient,
+        full: moduleOptions.full,
+        aliasPaths: {
+          provider: providerPath,
+          pkgDir: schemaOrgPath
         }
-      });
-    }
+      }));
+    });
   }
 });
 

package/dist/runtime/plugin-fallback.client.mjs

@@ -0,0 +1,7 @@
+import { defineNuxtPlugin } from "#app";
+import { watch } from "#imports";
+export default defineNuxtPlugin((nuxtApp) => {
+  watch(() => nuxtApp._route.path, () => {
+    document.querySelector('script[data-id="schema-org-graph"]')?.remove();
+  });
+});

package/dist/runtime/plugin.mjs

@@ -0,0 +1,35 @@
+import { createSchemaOrg } from "@vueuse/schema-org";
+import { defineNuxtPlugin } from "#app";
+import { unref, watch } from "#imports";
+import config from "#build/nuxt-schema-org-config.mjs";
+export default defineNuxtPlugin((nuxtApp) => {
+  const ssr = !!nuxtApp.ssrContext?.url;
+  const client = createSchemaOrg({
+    updateHead(fn) {
+      nuxtApp._useHead(unref(fn));
+    },
+    meta() {
+      const head = nuxtApp.vueApp._context.provides.usehead;
+      const inferredMeta = {};
+      const headTag = head.headTags.reverse().filter((t) => t.tag === "title" && !!t.props.children);
+      if (headTag.length)
+        inferredMeta.title = headTag[0].props.children;
+      return {
+        path: nuxtApp._route.path,
+        ...inferredMeta,
+        ...nuxtApp._route.meta,
+        ...config.meta || {}
+      };
+    }
+  });
+  nuxtApp.vueApp.use(client);
+  if (ssr) {
+    client.generateSchema();
+    client.setupDOM();
+    return;
+  }
+  watch(() => nuxtApp._route.path, () => {
+    client.generateSchema();
+    client.setupDOM();
+  });
+});

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "nuxt-schema-org",
-  "version": "0.7.0-beta.3",
+  "type": "module",
+  "version": "1.0.0-beta.11",
   "description": "Nuxt module for @vueuse/schema-org",
   "author": "Harlan Wilton <harlan@harlanzw.com>",
   "license": "MIT",
@@ -21,10 +22,8 @@
     "nuxt-module",
     "nuxt3"
   ],
-  "sideEffects": false,
   "exports": {
     ".": {
-      "types": "./dist/types.d.ts",
       "require": "./dist/module.cjs",
       "import": "./dist/module.mjs"
     }
@@ -35,14 +34,16 @@
     "dist"
   ],
   "dependencies": {
-    "@nuxt/kit": "3.0.0-rc.6",
-    "@vueuse/schema-org": "0.7.0-beta.3",
-    "magic-string": "^0.26.2",
-    "unplugin": "^0.7.2"
+    "@nuxt/kit": "3.0.0-rc.8",
+    "@vueuse/schema-org": "1.0.0-beta.11",
+    "@vueuse/schema-org-vite": "1.0.0-beta.11",
+    "pathe": "^0.3.4",
+    "schema-org-graph-js": "0.3.3"
   },
   "devDependencies": {
     "@nuxt/module-builder": "latest",
-    "@nuxt/schema": "3.0.0-rc.6"
+    "@nuxt/schema": "3.0.0-rc.8",
+    "nuxt": "3.0.0-rc.8"
   },
   "scripts": {
     "build": "npm run -C ../../playgrounds/nuxt3 prepare && nuxt-module-build",

package/dist/runtime/composables.d.ts

@@ -1,2 +0,0 @@
-export * from '@vueuse/schema-org';
-export declare function useSchemaOrg(input: any): void;

package/dist/runtime/composables.mjs

@@ -1,8 +0,0 @@
-import { isFunction } from "@vue/shared";
-import { computed } from "#imports";
-import { useNuxtApp } from "#app";
-export * from "@vueuse/schema-org";
-export function useSchemaOrg(input) {
-  const resolveInput = isFunction(input) ? computed(input) : input;
-  useNuxtApp()._useSchemaOrg(resolveInput);
-}

package/dist/runtime/plugin.client.mjs

@@ -1,19 +0,0 @@
-import { createSchemaOrg, handleNodesCSR, useVueUseHead } from "@vueuse/schema-org";
-import { defineNuxtPlugin } from "#app";
-import { useRoute } from "#imports";
-import meta from "#build/schemaOrg.config.mjs";
-export default defineNuxtPlugin((nuxtApp) => {
-  const head = nuxtApp.vueApp._context.provides.usehead;
-  const client = createSchemaOrg({
-    provider: {
-      useRoute,
-      setupDOM: useVueUseHead(head),
-      name: "nuxt"
-    },
-    ...meta.config
-  });
-  nuxtApp._useSchemaOrg = (input) => {
-    return handleNodesCSR(client, input);
-  };
-  nuxtApp.vueApp.use(client);
-});

package/dist/runtime/plugin.server.mjs

@@ -1,37 +0,0 @@
-import { createSchemaOrg, handleNodesSSR } from "@vueuse/schema-org";
-import { defineNuxtPlugin } from "#app";
-import { computed, useRoute } from "#imports";
-import meta from "#build/schemaOrg.config.mjs";
-export default defineNuxtPlugin((nuxtApp) => {
-  const head = nuxtApp.vueApp._context.provides.usehead;
-  let _domSetup = false;
-  const client = createSchemaOrg({
-    provider: {
-      useRoute,
-      setupDOM({ schemaRef }) {
-        if (_domSetup)
-          return;
-        head.addHeadObjs(computed(() => {
-          return {
-            script: [
-              {
-                "type": "application/ld+json",
-                "data-id": "schema-org-graph",
-                "key": "schema-org-graph",
-                "children": schemaRef.value
-              }
-            ]
-          };
-        }));
-        _domSetup = true;
-      },
-      name: "nuxt"
-    },
-    ...meta.config
-  });
-  nuxtApp._useSchemaOrg = (input) => {
-    return handleNodesSSR(client, input);
-  };
-  client.setupDOM();
-  nuxtApp.vueApp.use(client);
-});