@frigear-nu/base 0.0.0-stage → 0.0.2

package/modules/routing.ts

@@ -0,0 +1,112 @@
+import { defineNuxtModule, extendPages, createResolver } from '@nuxt/kit'
+import { landingPageExists } from '../utils/pages'
+import { getAvailableLocales } from '../shared/utils/content'
+
+// `@nuxtjs/i18n` is optional, so we avoid a hard dependency on its types and
+// instead duck-type the subset of its config we need here.
+type LayerI18nOptions = {
+  locales?: Array<string | { code: string }>
+  defaultLocale?: string
+  routesNameSeparator?: string
+}
+
+// `@nuxtjs/i18n` detects the active locale of a route primarily from its
+// route *name* (falling back to a locale prefix in the path otherwise), by
+// splitting the name on this separator (`@nuxtjs/i18n` defaults to `___`,
+// see `routesNameSeparator`). Since our own `i18n: false` routes below skip
+// its automatic per-locale route generation (which normally produces names
+// like `page___en`), we must replicate that naming convention ourselves so
+// `@nuxtjs/i18n` can still resolve the correct active locale for them -
+// notably including the *default* locale, whose paths have no locale
+// prefix to fall back on (e.g. `/` or `/contact`).
+const DEFAULT_ROUTE_NAME_SEPARATOR = '___'
+
+// Locale-root paths (e.g. `/en`) must render the same landing page as `/`
+// instead of falling through to the catch-all content page. Modelled on
+// https://github.com/nuxt-content/docus/blob/main/layer/modules/routing.ts
+export default defineNuxtModule({
+  meta: {
+    name: 'routing',
+  },
+  setup(_options, nuxt) {
+    const { resolve } = createResolver(import.meta.url)
+
+    const i18nOptions = (nuxt.options as typeof nuxt.options & { i18n?: LayerI18nOptions }).i18n
+    const isI18nEnabled = !!i18nOptions?.locales
+    const routeNameSeparator = i18nOptions?.routesNameSeparator || DEFAULT_ROUTE_NAME_SEPARATOR
+
+    // Only add the landing route if the consuming app doesn't already
+    // define its own `index.vue` (which takes precedence over the layer's).
+
+    if (landingPageExists(nuxt.options.rootDir)) {
+      console.warn(`Landing page already exists in the consuming app. Skipping layer landing page. -> make sure to handle locale routes properly.`)
+      return
+    }
+
+    extendPages((pages) => {
+      const pageExist = (path: string) => pages.find(page => page.path === path)
+
+      const landingTemplate = resolve('../app/templates/LandingPage.vue')
+      const localeCodes = getAvailableLocales(nuxt.options as typeof nuxt.options & { i18n?: LayerI18nOptions })
+      if (isI18nEnabled) {
+        const defaultLocale = i18nOptions?.defaultLocale
+
+        // Generate a static route per locale index
+        const localizedIndexPages = localeCodes.map(code => ({
+          name: `lang-index${routeNameSeparator}${code}`,
+          path: defaultLocale === code ? `/` : `/${code}`,
+          file: landingTemplate,
+          meta: {
+            layout: 'default',
+            // These paths are already locale-specific (e.g. `/en`), so
+            // opt them out of `@nuxtjs/i18n`'s own automatic route
+            // localization. Otherwise it prefixes each already-prefixed
+            // path with its locale again (e.g. `/en` -> `/en/en`), which
+            // registers a broken route that Nuxt then tries to prerender.
+            i18n: false,
+          },
+        }))
+
+        //
+        if (localizedIndexPages.length > 0) {
+          pages.push(...localizedIndexPages.filter(p => !pageExist(p.path)))
+        }
+
+        // ensures we set the layout here as well?
+        for (const { path } of localizedIndexPages) {
+          nuxt.options.nitro.routeRules ??= {}
+          nuxt.options.nitro.routeRules[path] = {
+            appLayout: 'default',
+            ...nuxt.options.nitro.routeRules[path] || {},
+          }
+        }
+
+        // The catch-all content route (`app/pages/[[lang]]/[...path].vue`)
+        // uses a single, optional `[[lang]]` param to serve every locale
+        // from one route. Replace it with an explicit route per locale
+        // (default locale unprefixed, others prefixed) so its name can
+        // carry the locale, same as the landing routes above.
+        const catchAllPageIndex = pages.findIndex(page => page.path?.includes(':path(.*)*'))
+        const [catchAllPage] = catchAllPageIndex !== -1 ? pages.splice(catchAllPageIndex, 1) : []
+        if (catchAllPage) {
+          const localizedCatchAllPages = localeCodes.map(code => ({
+            ...catchAllPage,
+            name: `${catchAllPage.name}${routeNameSeparator}${code}`,
+            path: defaultLocale === code ? '/:path(.*)*' : `/${code}/:path(.*)*`,
+            meta: { ...catchAllPage.meta, i18n: false },
+          }))
+          pages.push(...localizedCatchAllPages)
+        }
+      } else {
+        pages.push({
+          name: 'index',
+          path: '/',
+          file: landingTemplate,
+          meta: {
+            layout: 'default',
+          },
+        })
+      }
+    })
+  },
+})

package/nuxt.config.ts

@@ -0,0 +1,132 @@
+// https://nuxt.com/docs/api/configuration/nuxt-config
+import { createResolver } from '@nuxt/kit'
+
+const resolver = createResolver(import.meta.url)
+export default defineNuxtConfig({
+  modules: [
+    resolver.resolve('./modules/config'),
+    resolver.resolve('./modules/routing'),
+    '@nuxt/eslint',
+    '@nuxt/icon',
+    '@nuxt/image',
+    '@comark/nuxt',
+    '@nuxtjs/device',
+    '@nuxt/hints',
+    '@nuxt/fonts',
+    '@nuxt/ui',
+    '@nuxtjs/sitemap',
+    '@nuxtjs/robots',
+    'nuxt-og-image',
+    'nuxt-seo-utils',
+    '@nuxt/content',
+    '@nuxtjs/i18n',
+    '@frigear-nu/menu',
+    (_, nuxt) => {
+      if (!nuxt.options.css.find(css => css.includes('main.css'))) {
+        nuxt.options.css.push(resolver.resolve('./app/assets/css/main.css'))
+      }
+    },
+  ],
+  $meta: {
+    name: 'base',
+  },
+
+  content: {
+    experimental: { sqliteConnector: 'native' },
+    build: {
+      markdown: {
+        remarkPlugins: {},
+        highlight: false,
+      },
+    },
+  },
+
+  // Server source-maps removed to half the required build time for production builds.
+  // Source-maps are still generated for the client-side code.
+  sourcemap: {
+    server: false,
+  },
+
+  features: {
+    inlineStyles: true,
+  },
+  experimental: {
+    defaults: {
+      nuxtLink: {
+        prefetchOn: {
+          interaction: true,
+          visibility: false,
+        },
+      },
+    },
+  },
+
+  compatibilityDate: '2026-07-30',
+
+  vite: {
+    build: {
+      rolldownOptions: {
+        checks: {
+          // Building already spends the vast majority of its time inside
+          // bundler plugin hooks (module resolution/transform work), so this
+          // check just adds noisy, non-actionable warnings to every build.
+          // See https://rolldown.rs/reference/InputOptions.checks#plugintimings
+          pluginTimings: false,
+        },
+      },
+    },
+    plugins: [
+      {
+        // Nuxt 4.6's `installedScanEntries` (in `@nuxt/vite-builder`) feeds every
+        // node_modules-installed component/plugin/layout/middleware file to Vite's
+        // dependency scanner as a scan entry, so it can pre-bundle their deps. Nuxt's
+        // own virtual-module resolvers (`#components`, `#imports`, `#app`, `#build/*`,
+        // ...) skip resolution during that scan, so the request falls through to
+        // Vite/rolldown's default resolver, which tries to resolve the `#`-prefixed
+        // specifier as a Node.js subpath import relative to the *importing package*
+        // (e.g. `@nuxtjs/i18n`) instead of the Nuxt app root - and fails, since that
+        // package never declares the specifier in its own `imports` field. This aborts
+        // the whole scan with "Missing '#x' specifier in '<package>' package" and Vite
+        // falls back to skipping dependency pre-bundling entirely.
+        // Fix pending upstream: https://github.com/nuxt/nuxt/issues/36473
+        name: 'frigear-nu:scan-external-virtual-specifiers',
+        enforce: 'pre',
+        resolveId: {
+          filter: { id: /^#/ },
+          handler(id, _importer, options) {
+            // `scan` is passed at runtime by Vite/rolldown's dependency scanner
+            // but isn't part of the public `resolveId` hook option types.
+            if ((options as { scan?: boolean } | undefined)?.scan) {
+              return { id, external: true }
+            }
+          },
+        },
+      },
+    ],
+  },
+
+  eslint: {
+    config: {
+      stylistic: {
+        commaDangle: 'always-multiline',
+        braceStyle: '1tbs',
+      },
+    },
+  },
+
+  i18n: {
+    strategy: 'prefix_except_default',
+    detectBrowserLanguage: false,
+  },
+  menus: {
+    content: {
+      main: true,
+    },
+  },
+
+  // Keep app/API/auth routes out of search results; `site.indexable` (set by the host app) decides whether
+  // the site as a whole may be indexed at all.
+  robots: {
+    disallow: ['/admin', '/api', '/auth', '/account'],
+  },
+})

package/package.json

@@ -1,6 +1,70 @@
 {
   "name": "@frigear-nu/base",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.2",
+  "description": "Shared Nuxt layer for Frigear websites - bundled modules, UI defaults, content collections, layouts and routing.",
+  "homepage": "https://docs.frigear.dev/layers/base",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/frigear-nu/frigear-nu.git",
+    "directory": "packages/base-layer"
+  },
+  "license": "MIT",
+  "type": "module",
+  "main": "./nuxt.config.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "app",
+    "content.config.ts",
+    "modules",
+    "nuxt.config.ts",
+    "shared",
+    "utils"
+  ],
+  "dependencies": {
+    "@comark/nuxt": "0.6.2",
+    "@frigear-nu/menu": "0.0.8",
+    "@iconify-json/lucide": "^1.2.127",
+    "@iconify-json/simple-icons": "^1.2.94",
+    "@nuxt/content": "3.16.0",
+    "@nuxt/fonts": "^0.14.0",
+    "@nuxt/hints": "^1.1.4",
+    "@nuxt/icon": "^2.5.1",
+    "@nuxt/image": "^2.1.0",
+    "@nuxt/kit": "^4.6.0",
+    "@nuxt/schema": "^4.6.0",
+    "@nuxt/ui": "^4.11.0",
+    "@nuxtjs/device": "4.0.0",
+    "@nuxtjs/i18n": "^10.6.0",
+    "@nuxtjs/robots": "^7.0.2",
+    "@nuxtjs/sitemap": "^9.0.1",
+    "@vueuse/core": "^15.0.0",
+    "defu": "^6.1.7",
+    "motion-v": "^2.4.0",
+    "nuxt-og-image": "^7.0.2",
+    "nuxt-seo-utils": "^9.0.1",
+    "scule": "^1.3.0",
+    "tailwindcss": "^4.3.3",
+    "ufo": "^1.6.4",
+    "zod": "^4.5.4"
+  },
+  "peerDependencies": {
+    "nuxt": "^4.6.0"
+  },
+  "devDependencies": {
+    "@nuxt/eslint": "^1.17.0",
+    "eslint": "^10.9.1",
+    "nuxt": "^4.6.1",
+    "typescript": "^6.0.3",
+    "vue-tsc": "^3.3.11"
+  },
+  "scripts": {
+    "build": "nuxt build",
+    "dev": "nuxt dev",
+    "preview": "nuxt preview",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "typecheck": "nuxt typecheck"
+  }
 }

package/shared/schema/config.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod/v4'
+
+export const WebsiteConfigSchema = z.object({
+  name: z.union([
+    z.string(),
+    z.object({
+      long: z.string(),
+      short: z.string().optional(),
+    }),
+  ]).optional(),
+  /**
+   * Site-wide SEO defaults. The layer ships none: every value comes from here.
+   * `titleTemplate` supports `%s` (page title) and `%siteName`, e.g. `%s | %siteName`.
+   */
+  seo: z.object({
+    titleTemplate: z.string().optional(),
+    description: z.string().optional(),
+    image: z.string().optional(),
+  }).optional(),
+  logo: z.union([
+    z.string(),
+    z.object({
+      light: z.string(),
+      dark: z.string(),
+      class: z.string().optional(),
+      alt: z.string().optional(),
+    }),
+  ]).optional(),
+  navigation: z.array(
+    z.object({
+      label: z.string(),
+      description: z.string().optional(),
+      to: z.string(),
+      icon: z.string().optional(),
+      tags: z.array(z.string()).optional(),
+    }),
+  ).optional(),
+  footer: z.object({
+    sections: z.array(z.object({
+      label: z.string(),
+      icon: z.string().optional(),
+      links: z.array(z.object({
+        label: z.string(),
+        to: z.string(),
+        icon: z.string().optional(),
+      })),
+    })).optional(),
+    copyright: z.string().optional(),
+    right: z.array(z.object({
+      label: z.string(),
+      to: z.string(),
+      icon: z.string().optional(),
+      variant: z.enum(['link', 'solid', 'outline', 'soft', 'subtle', 'ghost']).optional(),
+      size: z.enum(['xs', 'sm', 'md', 'lg', 'xl']).optional(),
+    })).optional(),
+  }).optional(),
+})

package/shared/schema/forms.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod/v4'
+
+export const contactFormSubjectOptions = {
+  apps: 'Apps',
+  websites: 'Nettsider',
+  development: 'Utvikling',
+  support: 'Support',
+  consulting: 'Rådgivning',
+  courses: 'Kurs',
+  other: 'Annet',
+} as const
+
+export const contactFormSubjectSelectItems = Object.entries(contactFormSubjectOptions).map(([key, value]) => ({ value: key, label: value }))
+
+export const contactFormSubjectKeys = Object.keys(contactFormSubjectOptions) as [
+  keyof typeof contactFormSubjectOptions,
+  ...Array<keyof typeof contactFormSubjectOptions>,
+]
+
+export const contactFormSchema = z
+  .object({
+    name: z.string({ message: 'Navn er påkrevd.' }),
+    email: z
+      .string({ message: 'E-post er påkrevd.' })
+      .email('Dette må være en gyldig e-postadresse.'),
+    phone: z.string().optional(),
+    subject: z.enum(contactFormSubjectKeys, { message: 'Emne er påkrevd.' }),
+    // optional in base schema, we enforce the condition below
+    subjectOther: z.string().optional(),
+    message: z
+      .string({ message: 'Beskjed feltet er påkrevd.' })
+      .nonempty('Beskjed feltet er påkrevd.'),
+    _token: z.string().optional(),
+  })
+  .superRefine((data, ctx) => {
+    if (data.subject === 'other' && data.subjectOther?.trim().length === 0) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['subjectOther'],
+        message: 'Du må fylle ut feltet fordi du har valgt "annet".',
+      })
+    }
+  })
+
+export type ContactSchema = z.output<typeof contactFormSchema>

package/shared/schema/page.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod/v4'
+
+export const WebsiteSeoSchema = z.object({
+  /** Overrides `title` in `<title>` and social cards (the page header keeps using `title`). */
+  title: z.string().optional(),
+  description: z.string().optional(),
+  /** Social/OG image, absolute or site-relative. */
+  image: z.string().optional(),
+  /** Ask search engines not to index this page. */
+  noindex: z.boolean().optional(),
+})
+
+export const WebsitePageSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  seo: WebsiteSeoSchema.optional(),
+  /** Wrap the rendered body in a `UContainer` (for plain prose pages such as legal). */
+  container: z.boolean().optional(),
+  pageHeader: z.object({
+    title: z.string().optional(),
+    description: z.string().optional(),
+  }).optional(),
+})

package/shared/utils/content.ts

@@ -0,0 +1,61 @@
+type ConfigWithLocales = {
+  i18n?: { locales?: Array<string | { code: string }> }
+}
+
+// Matches the locale-suffixed collection naming defined in `content.config.ts`
+
+// (e.g. `config` -> `config_no` when the app opts into `@nuxtjs/i18n`).
+export function localizedCollectionName<Name extends string>(
+  name: Name,
+  locale?: string,
+) {
+  return (locale ? `${name}_${locale.replace(/-/g, '_')}` : name) as Name
+}
+
+export function stringOrPropValue<Prop extends Record<string, unknown>>(
+  prop: string | undefined | Prop,
+  key: Prop extends string ? string : keyof Prop,
+) {
+  if (typeof prop === 'undefined') {
+    return undefined
+  }
+  if (typeof prop === 'string') {
+    return prop
+  }
+  return prop?.[key]
+}
+
+export function getAvailableLocales(
+  config: ConfigWithLocales,
+): string[] {
+  return config.i18n?.locales
+    ? config.i18n.locales.map(locale => typeof locale === 'string' ? locale : locale.code)
+    : []
+}
+
+export function getCollectionsToQuery(
+  locale: string | undefined,
+  availableLocales: string[],
+): string[] {
+  if (locale && availableLocales.includes(locale)) {
+    return [`pages_${locale}`]
+  }
+
+  return availableLocales.length > 0
+    ? availableLocales.map(l => `pages_${l}`)
+    : ['pages']
+}
+
+export function getCollectionFromPath(
+  path: string,
+  availableLocales: string[],
+): string {
+  const pathSegments = path.split('/').filter(Boolean)
+  const firstSegment = pathSegments[0]
+
+  if (firstSegment && availableLocales.includes(firstSegment)) {
+    return `pages_${firstSegment}`
+  }
+
+  return 'pages'
+}

package/utils/pages.ts

@@ -0,0 +1,12 @@
+import { existsSync } from 'node:fs'
+import { joinURL } from 'ufo'
+
+/**
+ * Checks if the consuming app defines its own `index.vue` page.
+ * When true, the app is expected to own landing/locale-root routing itself,
+ * so the layer should not rewrite the index page's route.
+ */
+export function landingPageExists(rootDir: string): boolean {
+  const indexPagePath = joinURL(rootDir, 'app', 'pages', 'index.vue')
+  return existsSync(indexPagePath)
+}