@nuxt/scripts 0.0.0 → 0.1.0

package/dist/module.mjs

@@ -0,0 +1,77 @@
+import { useNuxt, defineNuxtModule, createResolver, useLogger, addImportsDir } from '@nuxt/kit';
+import { readPackageJSON } from 'pkg-types';
+import { existsSync } from 'node:fs';
+
+const DEVTOOLS_UI_ROUTE = "/__nuxt-scripts";
+const DEVTOOLS_UI_LOCAL_PORT = 3030;
+function setupDevToolsUI(options, resolve, nuxt = useNuxt()) {
+  const clientPath = resolve("./client");
+  const isProductionBuild = 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-scripts",
+      // title to display in the tab
+      title: "Scripts",
+      // any icon from Iconify, or a URL to an image
+      icon: "carbon:script",
+      // iframe view
+      view: {
+        type: "iframe",
+        src: DEVTOOLS_UI_ROUTE
+      }
+    });
+  });
+}
+
+const module = defineNuxtModule({
+  meta: {
+    name: "@nuxt/scripts",
+    configKey: "scripts",
+    compatibility: {
+      nuxt: "^3.9.0",
+      bridge: false
+    }
+  },
+  defaults: {
+    enabled: true,
+    debug: false
+  },
+  async setup(config, nuxt) {
+    const { resolve } = createResolver(import.meta.url);
+    const { name, version } = await readPackageJSON(resolve("../package.json"));
+    const logger = useLogger(name);
+    if (config.enabled === false) {
+      logger.debug("The module is disabled, skipping setup.");
+      return;
+    }
+    nuxt.options.alias["#nuxt-scripts"] = resolve("./runtime/types");
+    nuxt.options.runtimeConfig["nuxt-scripts"] = { version };
+    nuxt.options.runtimeConfig.public["nuxt-scripts"] = { defaults: config.defaults };
+    addImportsDir(resolve("./runtime/composables"));
+    if (nuxt.options.dev)
+      setupDevToolsUI(config, resolve);
+  }
+});
+
+export { module as default };

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

@@ -0,0 +1 @@
+export declare function isDoNotTrackEnabled(): boolean;

package/dist/runtime/composables/isDoNotTrackEnabled.mjs

@@ -0,0 +1,15 @@
+import { useRequestHeader } from "#imports";
+const doNotTrackEnabledValues = [
+  // account for all browsers and their different values
+  "1",
+  // W3C standard
+  "yes",
+  // old standard
+  "true"
+  // old standard
+];
+export function isDoNotTrackEnabled() {
+  if (import.meta.server)
+    return doNotTrackEnabledValues.includes(useRequestHeader("DNT") || "");
+  return doNotTrackEnabledValues.includes(window.navigator.doNotTrack || "");
+}

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

@@ -0,0 +1,4 @@
+import type { NuxtUseScriptInput, NuxtUseScriptOptions } from '#nuxt-scripts';
+export declare function useScript<T>(input: NuxtUseScriptInput, options?: NuxtUseScriptOptions<T>): T & {
+    $script: import("@unhead/vue").VueScriptInstance<T>;
+};

package/dist/runtime/composables/useScript.mjs

@@ -0,0 +1,60 @@
+import { useScript as _useScript } from "@unhead/vue";
+import { injectHead, useNuxtApp } from "#imports";
+export function useScript(input, options) {
+  input = typeof input === "string" ? { src: input } : input;
+  options = options || {};
+  const nuxtApp = useNuxtApp();
+  const script = _useScript(input, {
+    async transform(script2) {
+      await nuxtApp.hooks.callHook("scripts:transform", { script: script2, options });
+      return script2;
+    },
+    ...options
+  });
+  if (import.meta.dev) {
+    let syncScripts = function() {
+      nuxtApp._scripts[script.$script.id] = payload;
+      nuxtApp.hooks.callHook("scripts:updated", { scripts: nuxtApp._scripts });
+    };
+    const payload = {
+      key: input.key || input.src,
+      src: input.src,
+      $script: null,
+      events: []
+    };
+    nuxtApp._scripts = nuxtApp._scripts || {};
+    if (!nuxtApp._scripts[script.$script.id]) {
+      const head = injectHead();
+      head.hooks.hook("script:updated", (ctx) => {
+        if (ctx.script.id !== script.$script.id)
+          return;
+        payload.events.push({
+          type: "status",
+          status: ctx.script.status,
+          at: Date.now()
+        });
+        payload.$script = script.$script;
+        syncScripts();
+      });
+      head.hooks.hook("script:instance-fn", (ctx) => {
+        if (ctx.script.id !== script.$script.id)
+          return;
+        payload.events.push({
+          type: "fn-call",
+          fn: ctx.fn,
+          args: ctx.args,
+          at: Date.now()
+        });
+        syncScripts();
+      });
+      payload.$script = script.$script;
+      payload.events.push({
+        type: "status",
+        status: "awaitingLoad",
+        at: Date.now()
+      });
+      syncScripts();
+    }
+  }
+  return script;
+}

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

@@ -0,0 +1,5 @@
+import type { UseScriptInput } from '@unhead/vue';
+import type { NuxtUseTrackingScriptOptions } from '#nuxt-scripts';
+export declare function useTrackingScript<T>(input: UseScriptInput, options?: NuxtUseTrackingScriptOptions<T>): {
+    $script: import("@unhead/vue").VueScriptInstance<unknown>;
+} | undefined;

package/dist/runtime/composables/useTrackingScript.mjs

@@ -0,0 +1,32 @@
+import { useScript } from "./useScript.mjs";
+import { isDoNotTrackEnabled, isRef, onNuxtReady, ref, toValue, watch } from "#imports";
+export function useTrackingScript(input, options) {
+  if (!options.ignoreDoNotTrack && isDoNotTrackEnabled())
+    return;
+  const instance = useScript(input, {
+    ...options,
+    trigger: "manual"
+  });
+  onNuxtReady(() => {
+    const consented = ref(false);
+    if (options?.consent) {
+      if (typeof options?.consent === "boolean") {
+        consented.value = true;
+      } else if (options?.consent instanceof Promise) {
+        options?.consent.then((res) => {
+          consented.value = typeof res === "boolean" ? res : true;
+        });
+      } else if (isRef(options?.consent)) {
+        watch(options.consent, (_val) => {
+          const val = toValue(_val);
+          if (typeof val === "boolean")
+            consented.value = val;
+        }, { immediate: true });
+      }
+    }
+    watch(consented, (ready) => {
+      ready && instance.$script.load();
+    });
+  });
+  return instance;
+}

package/dist/runtime/types.d.ts

@@ -0,0 +1,9 @@
+import type { UseScriptOptions } from '@unhead/schema';
+import type { UseScriptInput } from '@unhead/vue';
+import type { Ref } from 'vue';
+export type NuxtUseScriptOptions<T = any> = UseScriptOptions<T>;
+export type NuxtUseScriptInput = UseScriptInput;
+export type NuxtUseTrackingScriptOptions<T = any> = Omit<NuxtUseScriptOptions<T>, 'trigger'> & {
+    consent: Promise<boolean | void> | Ref<boolean> | boolean;
+    ignoreDoNotTrack?: boolean;
+};

package/dist/types.d.mts

@@ -0,0 +1,18 @@
+
+import type { ModuleOptions, ModuleHooks } from './module.js'
+
+
+declare module '@nuxt/schema' {
+  interface NuxtConfig { ['scripts']?: Partial<ModuleOptions> }
+  interface NuxtOptions { ['scripts']?: ModuleOptions }
+  interface NuxtHooks extends ModuleHooks {}
+}
+
+declare module 'nuxt/schema' {
+  interface NuxtConfig { ['scripts']?: Partial<ModuleOptions> }
+  interface NuxtOptions { ['scripts']?: ModuleOptions }
+  interface NuxtHooks extends ModuleHooks {}
+}
+
+
+export type { ModuleHooks, ModuleOptions, default } from './module.js'

package/dist/types.d.ts

@@ -0,0 +1,18 @@
+
+import type { ModuleOptions, ModuleHooks } from './module'
+
+
+declare module '@nuxt/schema' {
+  interface NuxtConfig { ['scripts']?: Partial<ModuleOptions> }
+  interface NuxtOptions { ['scripts']?: ModuleOptions }
+  interface NuxtHooks extends ModuleHooks {}
+}
+
+declare module 'nuxt/schema' {
+  interface NuxtConfig { ['scripts']?: Partial<ModuleOptions> }
+  interface NuxtOptions { ['scripts']?: ModuleOptions }
+  interface NuxtHooks extends ModuleHooks {}
+}
+
+
+export type { ModuleHooks, ModuleOptions, default } from './module'

package/package.json

@@ -1,8 +1,74 @@
 {
   "name": "@nuxt/scripts",
-  "version": "0.0.0",
+  "type": "module",
+  "version": "0.1.0",
+  "packageManager": "pnpm@8.15.4",
+  "description": "Next-gen Scripts for Nuxt",
+  "author": {
+    "website": "https://harlanzw.com",
+    "name": "Harlan Wilton",
+    "url": "harlan@harlanzw.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nuxt/scripts.git"
+  },
+  "bugs": {
+    "url": "https://github.com/nuxt/scripts/issues"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/module.mjs",
+      "require": "./dist/module.cjs"
+    }
+  },
+  "main": "./dist/module.cjs",
+  "types": "./dist/types.d.ts",
   "files": [
     "dist"
   ],
-  "author": "Daniel Roe <daniel@roe.dev>"
-}
+  "build": {
+    "externals": [
+      "@unhead/vue",
+      "@unhead/schema"
+    ]
+  },
+  "dependencies": {
+    "@nuxt/devtools-kit": "^1.0.8",
+    "@nuxt/devtools-ui-kit": "^1.0.8",
+    "@nuxt/kit": "^3.10.3",
+    "pkg-types": "^1.0.3",
+    "shiki": "^1.1.7",
+    "sirv": "^2.0.4",
+    "defu": "^6.1.4"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "2.8.1",
+    "@nuxt/devtools-ui-kit": "^1.0.8",
+    "@nuxt/module-builder": "^0.5.5",
+    "@nuxt/test-utils": "3.11.0",
+    "@nuxt/ui": "2.14.2",
+    "bumpp": "^9.4.0",
+    "eslint": "8.57.0",
+    "nuxt": "^3.10.3",
+    "nuxt-icon": "^0.6.9",
+    "playwright": "^1.42.1",
+    "typescript": "^5.4.2",
+    "vitest": "^1.3.1"
+  },
+  "scripts": {
+    "build": "pnpm prepack",
+    "client:build": "nuxi generate client",
+    "client:dev": "nuxi dev client --port 3300",
+    "dev": "nuxi dev playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
+    "typecheck": "pnpm dlx vue-tsc --noEmit",
+    "release": "pnpm build && bumpp && pnpm -r publish --no-git-checks",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "true",
+    "test:types": "true"
+  }
+}