nuxt-site-config 0.0.3 → 0.1.1

package/dist/build.d.ts

@@ -0,0 +1,7 @@
+import { S as SiteConfigInput, a as SiteConfig } from './type-8a5f4ec7.js';
+export { b as MaybeComputedRef, c as MaybeComputedRefEntries, M as MaybeReadonlyRef } from './type-8a5f4ec7.js';
+import 'vue';
+
+declare function useSiteConfig(overrides?: SiteConfigInput): Promise<SiteConfig>;
+
+export { SiteConfig, SiteConfigInput, useSiteConfig };

package/dist/build.mjs

@@ -0,0 +1,102 @@
+import { tryUseNuxt } from '@nuxt/kit';
+import { readPackageJSON } from 'pkg-types';
+import { withHttp, withHttps } from 'ufo';
+import defu from 'defu';
+
+let _siteConfigOverrides = [];
+const processShim = typeof process !== "undefined" ? process : {};
+const envShim = processShim.env || {};
+const SITE_CONFIG_ENV = {
+  name: envShim.NUXT_PUBLIC_SITE_NAME,
+  url: envShim.NUXT_PUBLIC_SITE_URL,
+  description: envShim.NUXT_PUBLIC_SITE_DESCRIPTION,
+  image: envShim.NUXT_PUBLIC_SITE_IMAGE,
+  index: envShim.NUXT_PUBLIC_SITE_INDEX,
+  titleSeparator: envShim.NUXT_PUBLIC_SITE_TITLE_SEPARATOR,
+  trailingSlash: envShim.NUXT_PUBLIC_SITE_TRAILING_SLASH,
+  language: envShim.NUXT_PUBLIC_SITE_LANGUAGE
+};
+const NITRO_ENV_URL = [
+  envShim.NUXT_PUBLIC_VERCEL_URL,
+  // vercel
+  envShim.NUXT_PUBLIC_URL,
+  // netlify
+  envShim.NUXT_PUBLIC_CF_PAGES_URL
+  // cloudflare pages
+];
+let overrideCount = 0;
+function stackSiteConfigOverrides(overrides = {}) {
+  const id = overrideCount++;
+  _siteConfigOverrides.push({
+    id,
+    ...overrides
+  });
+  return () => {
+    _siteConfigOverrides = _siteConfigOverrides.filter((o) => o.id !== id);
+  };
+}
+function createSiteConfigContainer() {
+  const cleanUps = [];
+  function setOverrides(overrides) {
+    if (Object.keys(overrides || {}).length > 0)
+      cleanUps.push(stackSiteConfigOverrides(overrides));
+  }
+  function compute(input) {
+    const nitroEnvConfig = {};
+    const nitroUrl = NITRO_ENV_URL.find((k) => Boolean(k));
+    if (nitroUrl)
+      nitroEnvConfig.url = nitroUrl;
+    for (const k of Object.keys(SITE_CONFIG_ENV)) {
+      if (SITE_CONFIG_ENV[k])
+        nitroEnvConfig[k] = SITE_CONFIG_ENV[k];
+    }
+    const finalOverrides = {};
+    for (const o of _siteConfigOverrides)
+      Object.assign(finalOverrides, o);
+    const config = defu(finalOverrides, nitroEnvConfig, input.runtimeConfig || {}, input.contextConfig || {});
+    if (typeof config.index !== "undefined")
+      config.index = String(config.index) !== "false";
+    else
+      config.index = envShim.PROD;
+    if (typeof config.trailingSlash !== "undefined")
+      config.trailingSlash = String(config.trailingSlash) !== "false";
+    if (config.url && !config.url.startsWith("http"))
+      config.url = config.url.includes("localhost") ? withHttp(config.url) : withHttps(config.url);
+    return config;
+  }
+  return {
+    setOverrides,
+    cleanUp() {
+      cleanUps.forEach((c) => c());
+    },
+    compute
+  };
+}
+
+async function useSiteConfig(overrides = {}) {
+  const container = createSiteConfigContainer();
+  const runtimeConfig = {};
+  const nuxt = tryUseNuxt();
+  if (nuxt) {
+    for (const k of Object.keys(SITE_CONFIG_ENV)) {
+      const env = runtimeConfig[k] = nuxt?.options.runtimeConfig.public.site[k];
+      if (env)
+        runtimeConfig[k] = env;
+    }
+  }
+  const contextConfig = {};
+  const pkgJson = await readPackageJSON(void 0, { startingFrom: nuxt?.options.rootDir });
+  if (pkgJson) {
+    if (pkgJson.name)
+      contextConfig.name = pkgJson.name;
+    if (pkgJson.description)
+      contextConfig.description = pkgJson.description;
+  }
+  if (!contextConfig.name) {
+    contextConfig.name = nuxt?.options.rootDir.split("/").pop();
+  }
+  container.setOverrides(overrides);
+  return container.compute({ runtimeConfig, contextConfig });
+}
+
+export { useSiteConfig };

package/dist/module.cjs

@@ -0,0 +1,5 @@
+module.exports = function(...args) {
+  return import('./module.mjs').then(m => m.default.call(this, ...args))
+}
+const _meta = module.exports.meta = require('./module.json')
+module.exports.getMeta = () => Promise.resolve(_meta)

package/dist/module.d.ts

@@ -0,0 +1,20 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { a as SiteConfig } from './type-8a5f4ec7.js';
+import 'vue';
+
+interface ModuleOptions extends SiteConfig {
+}
+interface ModulePublicRuntimeConfig {
+    site: Partial<SiteConfig>;
+}
+declare module '@nuxt/schema' {
+    interface RuntimeNuxtHooks {
+        'site-config:resolve': (siteConfig: SiteConfig) => void;
+    }
+}
+interface ModuleHooks {
+    'site-config:resolve': (siteConfig: SiteConfig) => void;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
+
+export { ModuleHooks, ModuleOptions, ModulePublicRuntimeConfig, _default as default };

package/dist/module.json

@@ -0,0 +1,9 @@
+{
+  "name": "nuxt-site-config",
+  "compatibility": {
+    "nuxt": "^3.5.0",
+    "bridge": false
+  },
+  "configKey": "site",
+  "version": "0.1.1"
+}

package/dist/module.mjs

@@ -0,0 +1,38 @@
+import { defineNuxtModule, createResolver, addImports, addComponent } from '@nuxt/kit';
+import defu from 'defu';
+import { useSiteConfig } from './build.mjs';
+import 'pkg-types';
+import 'ufo';
+
+const module = defineNuxtModule({
+  meta: {
+    name: "nuxt-site-config",
+    compatibility: {
+      nuxt: "^3.5.0",
+      bridge: false
+    },
+    configKey: "site"
+  },
+  async setup(config, nuxt) {
+    nuxt.options.runtimeConfig.public.site = defu(config, nuxt.options.runtimeConfig.public.site || {});
+    const { resolve } = createResolver(import.meta.url);
+    const composables = ["useSiteConfig", "createInternalLinkResolver", "resolveAbsoluteInternalLink", "resolveTrailingSlash"];
+    composables.forEach((c) => {
+      addImports({
+        from: resolve("./runtime/composables"),
+        name: c
+      });
+    });
+    await addComponent({
+      filePath: resolve("./runtime/component/SiteLink.vue"),
+      name: "SiteLink"
+    });
+    const shared = resolve("./runtime/shared");
+    nuxt.options.build.transpile.push(shared);
+    nuxt.hook("modules:done", async () => {
+      nuxt.options.runtimeConfig.public.site = await useSiteConfig(nuxt.options.runtimeConfig.public.site);
+    });
+  }
+});
+
+export { module as default };

package/dist/runtime/component/SiteLink.vue

@@ -0,0 +1,33 @@
+<script lang="ts" setup>
+// we need to intercept the `to` property and make sure that we have the right trailing slash
+import { computed, createInternalLinkResolver, defineProps } from '#imports'
+
+const props = defineProps({
+  to: {
+    type: String,
+    required: true,
+  },
+})
+
+const linkResolver = createInternalLinkResolver()
+
+const to = computed(() => {
+  // only for relative links
+  if (props.to !== '/' && props.to.startsWith('/'))
+    return linkResolver(props.to)
+  return props.to
+})
+
+const attrs = computed(() => {
+  return {
+    ...props,
+    to: to.value,
+  }
+})
+</script>
+
+<template>
+  <NuxtLink v-bind="{ ...$attrs, ...attrs }">
+    <slot />
+  </NuxtLink>
+</template>

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

@@ -0,0 +1,2 @@
+export * from './useSiteConfig';
+export * from './utils';

package/dist/runtime/composables/index.mjs

@@ -0,0 +1,2 @@
+export * from "./useSiteConfig.mjs";
+export * from "./utils.mjs";

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

@@ -0,0 +1,2 @@
+import type { MaybeComputedRefEntries, SiteConfigInput } from '../../type';
+export declare function useSiteConfig(overrides?: MaybeComputedRefEntries<SiteConfigInput>): any;

package/dist/runtime/composables/useSiteConfig.mjs

@@ -0,0 +1,60 @@
+import { joinURL } from "ufo";
+import { getRequestURL } from "h3";
+import { SITE_CONFIG_ENV, createSiteConfigContainer } from "../shared.mjs";
+import {
+  onBeforeUnmount,
+  onMounted,
+  ref,
+  unref,
+  useAppConfig,
+  useRequestEvent,
+  useRuntimeConfig,
+  watch,
+  watchEffect
+} from "#imports";
+function useRequestURL() {
+  if (process.server) {
+    const { baseURL } = useRuntimeConfig().app;
+    const url = getRequestURL(useRequestEvent());
+    url.pathname = joinURL(baseURL, url.pathname);
+    return url;
+  }
+  return new URL(window.location.href);
+}
+export function useSiteConfig(overrides = {}) {
+  const siteConfig = ref({});
+  const siteConfigInput = ref({});
+  const container = createSiteConfigContainer();
+  watch(() => overrides, () => {
+    const tmpOverridesInput = {};
+    const unrefdOverrides = unref(overrides);
+    for (const k of Object.keys(unrefdOverrides)) {
+      tmpOverridesInput[k] = unref(unrefdOverrides[k]);
+    }
+    container.setOverrides(tmpOverridesInput);
+    siteConfig.value = container.compute(siteConfigInput.value);
+  }, {
+    deep: true,
+    immediate: true
+  });
+  function computeConfig() {
+    const { baseURL } = useRuntimeConfig().app;
+    const contextConfig = {
+      url: joinURL(useRequestURL().origin, baseURL)
+    };
+    const { public: publicRuntimeConfig } = useRuntimeConfig();
+    const appConfig = useAppConfig();
+    const runtimeConfig = {};
+    for (const k of Object.keys(SITE_CONFIG_ENV)) {
+      runtimeConfig[k] = appConfig.site?.[k] || publicRuntimeConfig.site?.[k];
+    }
+    siteConfigInput.value = { runtimeConfig, contextConfig };
+    siteConfig.value = container.compute(siteConfigInput.value);
+  }
+  watchEffect(computeConfig);
+  onMounted(computeConfig);
+  onBeforeUnmount(() => {
+    container.cleanUp && container.cleanUp();
+  });
+  return siteConfig;
+}

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

@@ -0,0 +1,3 @@
+export declare function resolveTrailingSlash(path: string): any;
+export declare function resolveAbsoluteInternalLink(relativeInternalLink: string): any;
+export declare function createInternalLinkResolver(): (path: string) => string;

package/dist/runtime/composables/utils.mjs

@@ -0,0 +1,21 @@
+import { withBase, withTrailingSlash, withoutTrailingSlash } from "ufo";
+import { computed, useSiteConfig } from "#imports";
+export function resolveTrailingSlash(path) {
+  const siteConfig = useSiteConfig();
+  return computed(() => {
+    return siteConfig.value.trailingSlash ? withTrailingSlash(path) : withoutTrailingSlash(path);
+  });
+}
+export function resolveAbsoluteInternalLink(relativeInternalLink) {
+  const siteConfig = useSiteConfig();
+  const slashes = resolveTrailingSlash(relativeInternalLink);
+  return computed(() => {
+    return withBase(slashes.value, siteConfig.value.url || "/");
+  });
+}
+export function createInternalLinkResolver() {
+  const siteConfig = useSiteConfig();
+  return (path) => {
+    return withBase(siteConfig.value.trailingSlash ? withTrailingSlash(path) : withoutTrailingSlash(path), siteConfig.value.url || "/");
+  };
+}

package/dist/runtime/shared.d.ts

@@ -0,0 +1,11 @@
+import type { SiteConfig, SiteConfigInput } from '../type';
+export declare const SITE_CONFIG_ENV: SiteConfigInput;
+export declare function stackSiteConfigOverrides(overrides?: SiteConfigInput): () => void;
+export declare function createSiteConfigContainer(): {
+    setOverrides: (overrides?: SiteConfigInput) => void;
+    cleanUp(): void;
+    compute: (input: {
+        runtimeConfig?: SiteConfigInput;
+        contextConfig?: SiteConfigInput;
+    }) => SiteConfig;
+};

package/dist/runtime/shared.mjs

@@ -0,0 +1,71 @@
+import { withHttp, withHttps } from "ufo";
+import defu from "defu";
+let _siteConfigOverrides = [];
+const processShim = typeof process !== "undefined" ? process : {};
+const envShim = processShim.env || {};
+export const SITE_CONFIG_ENV = {
+  name: envShim.NUXT_PUBLIC_SITE_NAME,
+  url: envShim.NUXT_PUBLIC_SITE_URL,
+  description: envShim.NUXT_PUBLIC_SITE_DESCRIPTION,
+  image: envShim.NUXT_PUBLIC_SITE_IMAGE,
+  index: envShim.NUXT_PUBLIC_SITE_INDEX,
+  titleSeparator: envShim.NUXT_PUBLIC_SITE_TITLE_SEPARATOR,
+  trailingSlash: envShim.NUXT_PUBLIC_SITE_TRAILING_SLASH,
+  language: envShim.NUXT_PUBLIC_SITE_LANGUAGE
+};
+const NITRO_ENV_URL = [
+  envShim.NUXT_PUBLIC_VERCEL_URL,
+  // vercel
+  envShim.NUXT_PUBLIC_URL,
+  // netlify
+  envShim.NUXT_PUBLIC_CF_PAGES_URL
+  // cloudflare pages
+];
+let overrideCount = 0;
+export function stackSiteConfigOverrides(overrides = {}) {
+  const id = overrideCount++;
+  _siteConfigOverrides.push({
+    id,
+    ...overrides
+  });
+  return () => {
+    _siteConfigOverrides = _siteConfigOverrides.filter((o) => o.id !== id);
+  };
+}
+export function createSiteConfigContainer() {
+  const cleanUps = [];
+  function setOverrides(overrides) {
+    if (Object.keys(overrides || {}).length > 0)
+      cleanUps.push(stackSiteConfigOverrides(overrides));
+  }
+  function compute(input) {
+    const nitroEnvConfig = {};
+    const nitroUrl = NITRO_ENV_URL.find((k) => Boolean(k));
+    if (nitroUrl)
+      nitroEnvConfig.url = nitroUrl;
+    for (const k of Object.keys(SITE_CONFIG_ENV)) {
+      if (SITE_CONFIG_ENV[k])
+        nitroEnvConfig[k] = SITE_CONFIG_ENV[k];
+    }
+    const finalOverrides = {};
+    for (const o of _siteConfigOverrides)
+      Object.assign(finalOverrides, o);
+    const config = defu(finalOverrides, nitroEnvConfig, input.runtimeConfig || {}, input.contextConfig || {});
+    if (typeof config.index !== "undefined")
+      config.index = String(config.index) !== "false";
+    else
+      config.index = envShim.PROD;
+    if (typeof config.trailingSlash !== "undefined")
+      config.trailingSlash = String(config.trailingSlash) !== "false";
+    if (config.url && !config.url.startsWith("http"))
+      config.url = config.url.includes("localhost") ? withHttp(config.url) : withHttps(config.url);
+    return config;
+  }
+  return {
+    setOverrides,
+    cleanUp() {
+      cleanUps.forEach((c) => c());
+    },
+    compute
+  };
+}

package/dist/type-8a5f4ec7.d.ts

@@ -0,0 +1,43 @@
+import { ComputedRef, Ref } from 'vue';
+
+interface SiteConfig {
+    /**
+     * The canonical Site URL.
+     * @default `process.env.NUXT_PUBLIC_SITE_URL`
+     * Fallback options are:
+     * - SSR: Inferred from request headers
+     * - SPA: Inferred from `window.location`
+     * - Prerendered: Inferred from CI environment
+     */
+    url: string;
+    name: string;
+    description: string;
+    image: string;
+    titleSeparator: string;
+    language: string;
+    index: boolean;
+    trailingSlash: boolean;
+}
+interface SiteConfigInput {
+    url?: string;
+    name?: string;
+    description?: string;
+    image?: string;
+    titleSeparator?: string;
+    language?: string;
+    index?: boolean | string;
+    trailingSlash?: boolean | string;
+}
+declare module 'nuxt/schema' {
+    interface AppConfigInput {
+        /** Theme configuration */
+        site?: SiteConfigInput;
+    }
+}
+type MaybeReadonlyRef<T> = (() => T) | ComputedRef<T>;
+type MaybeComputedRef<T> = T | MaybeReadonlyRef<T> | Ref<T>;
+type MaybeComputedRefEntries<T> = MaybeComputedRef<T> | {
+    [key in keyof T]?: MaybeComputedRef<T[key]>;
+};
+
+export { MaybeReadonlyRef as M, SiteConfigInput as S, SiteConfig as a, MaybeComputedRef as b, MaybeComputedRefEntries as c };

package/dist/types.d.ts

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-site-config",
   "type": "module",
-  "version": "0.0.3",
+  "version": "0.1.1",
   "packageManager": "pnpm@8.5.0",
   "description": "Shared site configuration for Nuxt 3 modules.",
   "license": "MIT",