simple-content-site 1.0.2

package/modules/routing.ts

@@ -0,0 +1,41 @@
+import { defineNuxtModule, extendPages, createResolver } from '@nuxt/kit'
+
+export default defineNuxtModule({
+  meta: {
+    name: 'routing',
+  },
+  async setup(_options, nuxt) {
+    const { resolve } = createResolver(import.meta.url)
+
+    const isI18nEnabled = !!(nuxt.options.i18n && nuxt.options.i18n.locales)
+
+    // Ensure useDocusI18n is available in the app
+    nuxt.hook('imports:extend', (imports) => {
+      if (imports.some(i => i.name === 'useDocusI18n')) return
+
+      imports.push({
+        name: 'useDocusI18n',
+        from: resolve('../app/composables/useDocusI18n'),
+      })
+    })
+
+    extendPages((pages) => {
+      const landingTemplate = resolve('../app/templates/landing.vue')
+
+      if (isI18nEnabled) {
+        pages.push({
+          name: 'lang-index',
+          path: '/:lang([a-zA-Z]{2})?',
+          file: landingTemplate,
+        })
+      }
+      else {
+        pages.push({
+          name: 'index',
+          path: '/',
+          file: landingTemplate,
+        })
+      }
+    })
+  },
+})

package/nuxt.config.ts

@@ -0,0 +1,75 @@
+import { extendViteConfig, createResolver, useNuxt } from '@nuxt/kit'
+
+const { resolve } = createResolver(import.meta.url)
+
+export default defineNuxtConfig({
+  modules: [
+    resolve('./modules/config'),
+    resolve('./modules/routing'),
+    resolve('./modules/css'),
+    '@nuxt/ui',
+    '@nuxt/content',
+    '@nuxt/image',
+    '@nuxtjs/robots',
+    'nuxt-og-image',
+    () => {
+      // Update @nuxt/content optimizeDeps options
+      extendViteConfig((config) => {
+        config.optimizeDeps ||= {}
+        config.optimizeDeps.include ||= []
+        config.optimizeDeps.include.push('@nuxt/content > slugify')
+        config.optimizeDeps.include = config.optimizeDeps.include
+          .map(id => id.replace(/^@nuxt\/content > /, 'docus > @nuxt/content > '))
+      })
+    },
+  ],
+  devtools: {
+    enabled: true,
+  },
+  content: {
+    build: {
+      markdown: {
+        highlight: {
+          langs: ['bash', 'diff', 'json', 'js', 'ts', 'html', 'css', 'vue', 'shell', 'mdc', 'md', 'yaml'],
+        },
+        remarkPlugins: {
+          'remark-mdc': {
+            options: {
+              autoUnwrap: true,
+            },
+          },
+        },
+      },
+    },
+  },
+  compatibilityDate: '2025-07-22',
+  nitro: {
+    prerender: {
+      crawlLinks: true,
+      failOnError: false,
+      autoSubfolderIndex: false,
+    },
+  },
+  hooks: {
+    'nitro:config'(nitroConfig) {
+      const nuxt = useNuxt()
+
+      const i18nOptions = nuxt.options.i18n
+
+      const routes: string[] = []
+      if (!i18nOptions) {
+        routes.push('/')
+      }
+      else {
+        routes.push(...(i18nOptions.locales?.map(locale => typeof locale === 'string' ? `/${locale}` : `/${locale.code}`) || []))
+      }
+
+      nitroConfig.prerender = nitroConfig.prerender || {}
+      nitroConfig.prerender.routes = nitroConfig.prerender.routes || []
+      nitroConfig.prerender.routes.push(...(routes || []))
+    },
+  },
+  icon: {
+    provider: 'iconify',
+  },
+})

package/nuxt.schema.ts

@@ -0,0 +1,218 @@
+import { field, group } from '@nuxt/content/preview'
+
+export default defineNuxtSchema({
+  appConfig: {
+    ui: group({
+      title: 'UI',
+      description: 'UI Customization.',
+      icon: 'i-lucide-palette',
+      fields: {
+        colors: group({
+          title: 'Colors',
+          description: 'Manage main colors of your application',
+          icon: 'i-lucide-palette',
+          fields: {
+            primary: field({
+              type: 'string',
+              title: 'Primary',
+              description: 'Primary color of your UI.',
+              icon: 'i-lucide-palette',
+              default: 'green',
+              required: ['red', 'orange', 'amber', 'yellow', 'lime', 'green', 'emerald', 'teal', 'cyan', 'sky', 'blue', 'indigo', 'violet', 'purple', 'fuchsia', 'pink', 'rose'],
+            }),
+            neutral: field({
+              type: 'string',
+              title: 'Neutral',
+              description: 'Neutral color of your UI.',
+              icon: 'i-lucide-palette',
+              default: 'slate',
+              required: ['slate', 'gray', 'zinc', 'neutral', 'stone'],
+            }),
+          },
+        }),
+        icons: group({
+          title: 'Icons',
+          description: 'Manage icons used in the application.',
+          icon: 'i-lucide-settings',
+          fields: {
+            search: field({
+              type: 'icon',
+              title: 'Search Bar',
+              description: 'Icon to display in the search bar.',
+              icon: 'i-lucide-search',
+              default: 'i-lucide-search',
+            }),
+            dark: field({
+              type: 'icon',
+              title: 'Dark mode',
+              description: 'Icon of color mode button for dark mode.',
+              icon: 'i-lucide-moon',
+              default: 'i-lucide-moon',
+            }),
+            light: field({
+              type: 'icon',
+              title: 'Light mode',
+              description: 'Icon of color mode button for light mode.',
+              icon: 'i-lucide-sun',
+              default: 'i-lucide-sun',
+            }),
+            external: field({
+              type: 'icon',
+              title: 'External Link',
+              description: 'Icon for external link.',
+              icon: 'i-lucide-external-link',
+              default: 'i-lucide-external-link',
+            }),
+            chevron: field({
+              type: 'icon',
+              title: 'Chevron',
+              description: 'Icon for chevron.',
+              icon: 'i-lucide-chevron-down',
+              default: 'i-lucide-chevron-down',
+            }),
+            hash: field({
+              type: 'icon',
+              title: 'Hash',
+              description: 'Icon for hash anchors.',
+              icon: 'i-lucide-hash',
+              default: 'i-lucide-hash',
+            }),
+          },
+        }),
+      },
+    }),
+    seo: group({
+      title: 'SEO',
+      description: 'SEO configuration.',
+      icon: 'i-lucide-search',
+      fields: {
+        title: field({
+          type: 'string',
+          title: 'Title',
+          description: 'Title to display in the header.',
+          icon: 'i-lucide-type',
+          default: '',
+        }),
+        description: field({
+          type: 'string',
+          title: 'Description',
+          description: 'Description to display in the header.',
+          icon: 'i-lucide-type',
+          default: '',
+        }),
+      },
+    }),
+    header: group({
+      title: 'Header',
+      description: 'Header configuration.',
+      icon: 'i-lucide-layout',
+      fields: {
+        title: field({
+          type: 'string',
+          title: 'Title',
+          description: 'Title to display in the header.',
+          icon: 'i-lucide-type',
+          default: '',
+        }),
+        logo: group({
+          title: 'Logo',
+          description: 'Header logo configuration.',
+          icon: 'i-lucide-image',
+          fields: {
+            light: field({
+              type: 'media',
+              title: 'Light Mode Logo',
+              description: 'Pick an image from your gallery.',
+              icon: 'i-lucide-sun',
+              default: '',
+            }),
+            dark: field({
+              type: 'media',
+              title: 'Dark Mode Logo',
+              description: 'Pick an image from your gallery.',
+              icon: 'i-lucide-moon',
+              default: '',
+            }),
+            alt: field({
+              type: 'string',
+              title: 'Alt',
+              description: 'Alt to display for accessibility.',
+              icon: 'i-lucide-text',
+              default: '',
+            }),
+          },
+        }),
+      },
+    }),
+    socials: field({
+      type: 'object',
+      title: 'Social Networks',
+      description: 'Social links configuration.',
+      icon: 'i-lucide-network',
+      default: {},
+    }),
+    toc: group({
+      title: 'Table of contents',
+      description: 'TOC configuration.',
+      icon: 'i-lucide-list',
+      fields: {
+        title: field({
+          type: 'string',
+          title: 'Title',
+          description: 'Title of the table of contents.',
+          icon: 'i-lucide-heading',
+          default: 'On this page',
+        }),
+        bottom: group({
+          title: 'Bottom',
+          description: 'Bottom section of the table of contents.',
+          icon: 'i-lucide-list',
+          fields: {
+            title: field({
+              type: 'string',
+              title: 'Title',
+              description: 'Title of the bottom section.',
+              icon: 'i-lucide-heading',
+              default: 'Community',
+            }),
+            links: field({
+              type: 'array',
+              title: 'Links',
+              description: 'Links to display in the bottom section.',
+              icon: 'i-lucide-link',
+              default: [],
+            }),
+          },
+        }),
+      },
+    }),
+    github: group({
+      title: 'GitHub',
+      description: 'GitHub configuration.',
+      icon: 'i-simple-icons-github',
+      fields: {
+        url: field({
+          type: 'string',
+          title: 'URL',
+          description: 'GitHub URL.',
+          icon: 'i-simple-icons-github',
+          default: '',
+        }),
+        branch: field({
+          type: 'string',
+          title: 'Branch',
+          description: 'GitHub branch.',
+          icon: 'i-lucide-git-branch',
+          default: 'main',
+        }),
+        rootDir: field({
+          type: 'string',
+          title: 'Root Directory',
+          description: 'Root directory of the GitHub repository.',
+          icon: 'i-lucide-folder',
+          default: '',
+        }),
+      },
+    }),
+  },
+})

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "simple-content-site",
+  "description": "Nuxt layer for simple website with basic functions.",
+  "version": "1.0.2",
+  "type": "module",
+  "main": "./nuxt.config.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hareland/nuxt-content-site-layer.git"
+  },
+  "private": false,
+  "license": "MIT",
+  "files": [
+    "app",
+    "i18n",
+    "content.config.ts",
+    "modules",
+    "nuxt.config.ts",
+    "nuxt.schema.ts",
+    "server",
+    "utils",
+    "README.md"
+  ],
+  "dependencies": {
+    "@iconify-json/lucide": "^1.2.69",
+    "@iconify-json/simple-icons": "^1.2.54",
+    "@iconify-json/vscode-icons": "^1.2.32",
+    "@nuxt/content": "https://pkg.pr.new/@nuxt/content@dd854d5",
+    "@nuxt/image": "^1.11.0",
+    "@nuxt/kit": "^4.1.3",
+    "@nuxt/ui": "^4.0.1",
+    "@nuxtjs/i18n": "^10.1.1",
+    "@nuxtjs/mdc": "^0.18.0",
+    "@nuxtjs/robots": "^5.5.5",
+    "@vueuse/core": "^13.9.0",
+    "nuxt-studio": "^1.0.0-alpha.1",
+    "defu": "^6.1.4",
+    "exsolve": "^1.0.7",
+    "git-url-parse": "^16.1.0",
+    "minimark": "^0.2.0",
+    "motion-v": "^1.7.2",
+    "nuxt-og-image": "^5.1.12",
+    "pkg-types": "^2.3.0",
+    "scule": "^1.3.0",
+    "tailwindcss": "^4.1.14",
+    "ufo": "^1.6.1"
+  },
+  "peerDependencies": {
+    "better-sqlite3": "12.x",
+    "nuxt": "4.x"
+  }
+}

package/server/routes/raw/[...slug].md.get.ts

@@ -0,0 +1,45 @@
+import { withLeadingSlash } from 'ufo'
+import { stringify } from 'minimark/stringify'
+import { queryCollection } from '@nuxt/content/server'
+import type { Collections } from '@nuxt/content'
+
+export default eventHandler(async (event) => {
+  const slug = getRouterParams(event)['slug.md']
+  if (!slug?.endsWith('.md')) {
+    throw createError({ statusCode: 404, statusMessage: 'Page not found', fatal: true })
+  }
+
+  const path = withLeadingSlash(slug.replace('.md', ''))
+  const config = useRuntimeConfig(event).public
+
+  let collectionName = 'pages'
+  if (config.i18n?.locales) {
+    const pathSegments = path.split('/').filter(Boolean)
+    const firstSegment = pathSegments[0]
+
+    const availableLocales = config.i18n.locales.map((locale: string | { code: string }) =>
+      typeof locale === 'string' ? locale : locale.code,
+    )
+
+    if (firstSegment && availableLocales.includes(firstSegment)) {
+      collectionName = `pages_${firstSegment}`
+    }
+    else if (config.i18n.defaultLocale) {
+      collectionName = `pages_${config.i18n.defaultLocale}`
+    }
+  }
+
+  const page = await queryCollection(event, collectionName as keyof Collections).path(path).first()
+  if (!page) {
+    throw createError({ statusCode: 404, statusMessage: 'Page not found', fatal: true })
+  }
+
+  // Add title and description to the top of the page if missing
+  if (page.body.value[0]?.[0] !== 'h1') {
+    page.body.value.unshift(['blockquote', {}, page.description])
+    page.body.value.unshift(['h1', {}, page.title])
+  }
+
+  setHeader(event, 'Content-Type', 'text/markdown; charset=utf-8')
+  return stringify({ ...page.body, type: 'minimark' }, { format: 'markdown/html' })
+})

package/utils/git.ts

@@ -0,0 +1,110 @@
+import { execSync } from 'node:child_process'
+import { readGitConfig } from 'pkg-types'
+import gitUrlParse from 'git-url-parse'
+
+export interface GitInfo {
+  // Repository name
+  name: string
+  // Repository owner/organization
+  owner: string
+  // Repository URL
+  url: string
+}
+
+export function getGitBranch() {
+  const envName
+    = process.env.CF_PAGES_BRANCH
+      || process.env.CI_COMMIT_BRANCH
+      || process.env.VERCEL_GIT_COMMIT_REF
+      || process.env.BRANCH
+      || process.env.GITHUB_REF_NAME
+
+  if (envName && envName !== 'HEAD') {
+    return envName
+  }
+  try {
+    const branch = execSync('git rev-parse --abbrev-ref HEAD', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim()
+    if (branch && branch !== 'HEAD') {
+      return branch
+    }
+  }
+  catch {
+    // Ignore error
+  }
+
+  return 'main'
+}
+
+export async function getLocalGitInfo(rootDir: string): Promise<GitInfo | undefined> {
+  const remote = await getLocalGitRemote(rootDir)
+  if (!remote) {
+    return
+  }
+
+  // https://www.npmjs.com/package/git-url-parse#clipboard-example
+  const { name, owner, source } = gitUrlParse(remote)
+  const url = `https://${source}/${owner}/${name}`
+
+  return {
+    name,
+    owner,
+    url,
+  }
+}
+
+async function getLocalGitRemote(dir: string): Promise<string | undefined> {
+  try {
+    const parsed = await readGitConfig(dir)
+    if (!parsed) {
+      return
+    }
+    return parsed.remote?.['origin']?.url
+  }
+  catch {
+    // Ignore error
+  }
+}
+
+export function getGitEnv(): GitInfo {
+  // https://github.com/unjs/std-env/issues/59
+  const envInfo = {
+    // Provider
+    provider: process.env.VERCEL_GIT_PROVIDER // vercel
+      || (process.env.GITHUB_SERVER_URL ? 'github' : undefined) // github
+      || '',
+    // Owner
+    owner: process.env.VERCEL_GIT_REPO_OWNER // vercel
+      || process.env.GITHUB_REPOSITORY_OWNER // github
+      || process.env.CI_PROJECT_PATH?.split('/').shift() // gitlab
+      || '',
+    // Name
+    name: process.env.VERCEL_GIT_REPO_SLUG
+      || process.env.GITHUB_REPOSITORY?.split('/').pop() // github
+      || process.env.CI_PROJECT_PATH?.split('/').splice(1).join('/') // gitlab
+      || '',
+    // Url
+    url: process.env.REPOSITORY_URL || '', // netlify
+  }
+
+  if (!envInfo.url && envInfo.provider && envInfo.owner && envInfo.name) {
+    envInfo.url = `https://${envInfo.provider}.com/${envInfo.owner}/${envInfo.name}`
+  }
+
+  // If only url available (ex: Netlify)
+  if (!envInfo.name && !envInfo.owner && envInfo.url) {
+    try {
+      const { name, owner } = gitUrlParse(envInfo.url)
+      envInfo.name = name
+      envInfo.owner = owner
+    }
+    catch {
+      // Ignore error
+    }
+  }
+
+  return {
+    name: envInfo.name,
+    owner: envInfo.owner,
+    url: envInfo.url,
+  }
+}

package/utils/meta.ts

@@ -0,0 +1,29 @@
+import { readFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+
+export function inferSiteURL() {
+  // https://github.com/unjs/std-env/issues/59
+  return (
+    process.env.NUXT_SITE_URL
+    || (process.env.NEXT_PUBLIC_VERCEL_URL && `https://${process.env.NEXT_PUBLIC_VERCEL_URL}`) // Vercel
+    || process.env.URL // Netlify
+    || process.env.CI_PAGES_URL // Gitlab Pages
+    || process.env.CF_PAGES_URL // Cloudflare Pages
+  )
+}
+
+export async function getPackageJsonMetadata(dir: string) {
+  try {
+    const packageJson = await readFile(resolve(dir, 'package.json'), 'utf-8')
+    const parsed = JSON.parse(packageJson)
+    return {
+      name: parsed.name,
+      description: parsed.description,
+    }
+  }
+  catch {
+    return {
+      name: 'docs',
+    }
+  }
+}