kmcom-nuxt-layers 2.5.1 → 2.6.0

package/layers/core/app/utils/browserInfo.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, it } from 'vitest'
+
+import { getBrowserVersionParts, isBrowserAtLeast, parseBrowserInfo } from './browserInfo'
+
+describe('parseBrowserInfo', () => {
+  // In a node vitest environment `import.meta.client` is not defined by Nuxt's
+  // build macros, so it is falsy and the function always takes its SSR/default
+  // branch regardless of the user agent passed in.
+  it('returns the unknown/default shape when import.meta.client is falsy', () => {
+    expect(parseBrowserInfo('Mozilla/5.0 Chrome/120.0.0.0')).toEqual({
+      name: 'unknown',
+      version: '0',
+      engine: 'unknown',
+      os: 'unknown',
+    })
+  })
+
+  it('returns the same default shape with no user agent argument', () => {
+    expect(parseBrowserInfo()).toEqual({
+      name: 'unknown',
+      version: '0',
+      engine: 'unknown',
+      os: 'unknown',
+    })
+  })
+
+  it('returns the same default shape with a null user agent', () => {
+    expect(parseBrowserInfo(null)).toEqual({
+      name: 'unknown',
+      version: '0',
+      engine: 'unknown',
+      os: 'unknown',
+    })
+  })
+})
+
+describe('getBrowserVersionParts', () => {
+  it('parses a major.minor version string', () => {
+    expect(getBrowserVersionParts('120.5')).toEqual({ major: 120, minor: 5 })
+  })
+
+  it('defaults minor to 0 when only a major version is given', () => {
+    expect(getBrowserVersionParts('120')).toEqual({ major: 120, minor: 0 })
+  })
+
+  it('defaults both parts to 0 for a non-numeric version', () => {
+    expect(getBrowserVersionParts('abc')).toEqual({ major: 0, minor: 0 })
+  })
+
+  it('defaults both parts to 0 for an empty string', () => {
+    expect(getBrowserVersionParts('')).toEqual({ major: 0, minor: 0 })
+  })
+
+  it('parses extra version segments, ignoring anything past minor', () => {
+    expect(getBrowserVersionParts('120.5.9.1')).toEqual({ major: 120, minor: 5 })
+  })
+})
+
+describe('isBrowserAtLeast', () => {
+  it('returns false when the minimum version has no major segment', () => {
+    expect(isBrowserAtLeast('120.0', '')).toBe(false)
+  })
+
+  it('returns true when the current major exceeds the required major', () => {
+    expect(isBrowserAtLeast('121.0', '120.5')).toBe(true)
+  })
+
+  it('returns false when the current major is behind the required major', () => {
+    expect(isBrowserAtLeast('119.9', '120.0')).toBe(false)
+  })
+
+  it('compares minor versions when majors are equal', () => {
+    expect(isBrowserAtLeast('120.5', '120.5')).toBe(true)
+    expect(isBrowserAtLeast('120.6', '120.5')).toBe(true)
+    expect(isBrowserAtLeast('120.4', '120.5')).toBe(false)
+  })
+
+  it('treats a missing minimum minor as 0', () => {
+    expect(isBrowserAtLeast('120.0', '120')).toBe(true)
+  })
+})

package/layers/core/app/utils/featureClasses.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, it } from 'vitest'
+
+import type { FeatureDetection } from '../types/detection'
+import { getFeatureClassNames } from './featureClasses'
+
+function createFeatures(overrides: Partial<FeatureDetection> = {}): FeatureDetection {
+  return {
+    grid: false,
+    subgrid: false,
+    containerQueries: false,
+    has: false,
+    aspectRatio: false,
+    logicalProperties: false,
+    backdropFilter: false,
+    intersectionObserver: false,
+    resizeObserver: false,
+    serviceWorker: false,
+    webGL: false,
+    darkMode: false,
+    reducedMotion: false,
+    highContrast: false,
+    webp: false,
+    avif: false,
+    ...overrides,
+  }
+}
+
+describe('getFeatureClassNames', () => {
+  it('emits the "no-" variant for every unsupported CSS feature and no extras', () => {
+    expect(getFeatureClassNames(createFeatures())).toEqual([
+      'no-grid',
+      'no-subgrid',
+      'no-container-queries',
+      'no-has',
+      'no-aspect-ratio',
+      'no-backdrop-filter',
+    ])
+  })
+
+  it('emits the "supports-" variant for every supported CSS feature plus all extras', () => {
+    expect(
+      getFeatureClassNames(
+        createFeatures({
+          grid: true,
+          subgrid: true,
+          containerQueries: true,
+          has: true,
+          aspectRatio: true,
+          backdropFilter: true,
+          intersectionObserver: true,
+          resizeObserver: true,
+          serviceWorker: true,
+          webGL: true,
+          webp: true,
+          avif: true,
+        })
+      )
+    ).toEqual([
+      'supports-grid',
+      'supports-subgrid',
+      'supports-container-queries',
+      'supports-has',
+      'supports-aspect-ratio',
+      'supports-backdrop-filter',
+      'has-intersection-observer',
+      'has-resize-observer',
+      'has-service-worker',
+      'has-webgl',
+      'supports-webp',
+      'supports-avif',
+    ])
+  })
+
+  it('only includes extra classes for the features that are truthy', () => {
+    const classes = getFeatureClassNames(
+      createFeatures({ intersectionObserver: true, avif: true })
+    )
+
+    expect(classes).toContain('has-intersection-observer')
+    expect(classes).toContain('supports-avif')
+    expect(classes).not.toContain('has-resize-observer')
+    expect(classes).not.toContain('supports-webp')
+  })
+
+  it('mixes supported and unsupported CSS features independently', () => {
+    const classes = getFeatureClassNames(createFeatures({ grid: true, has: true }))
+
+    expect(classes).toEqual([
+      'supports-grid',
+      'no-subgrid',
+      'no-container-queries',
+      'supports-has',
+      'no-aspect-ratio',
+      'no-backdrop-filter',
+    ])
+  })
+
+  it('ignores keys that are not part of either class map (e.g. darkMode)', () => {
+    const classes = getFeatureClassNames(createFeatures({ darkMode: true, highContrast: true }))
+    expect(classes.join(' ')).not.toContain('dark')
+    expect(classes.join(' ')).not.toContain('contrast')
+  })
+})

package/layers/core/app/utils/regex.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest'
+
+import { splitSpaces } from './regex'
+
+describe('splitSpaces', () => {
+  it('splits a sentence on single whitespace characters', () => {
+    expect(splitSpaces('Nuxt Layers rocks')).toEqual(['Nuxt', 'Layers', 'rocks'])
+  })
+
+  it('splits on the first whitespace match only per gap (non-global regex)', () => {
+    // The source regex has no /g flag, so String#split still splits on every
+    // occurrence (split applies the pattern repeatedly regardless of /g).
+    expect(splitSpaces('a  b')).toEqual(['a', '', 'b'])
+  })
+
+  it('returns a single-element array for text with no spaces', () => {
+    expect(splitSpaces('single')).toEqual(['single'])
+  })
+
+  it('returns two empty strings for a single space', () => {
+    expect(splitSpaces(' ')).toEqual(['', ''])
+  })
+
+  it('returns an array with one empty string for an empty string', () => {
+    expect(splitSpaces('')).toEqual([''])
+  })
+
+  it('splits on tabs and newlines as whitespace', () => {
+    expect(splitSpaces('a\tb\nc')).toEqual(['a', 'b', 'c'])
+  })
+})

package/layers/feeds/nuxt.config.ts

@@ -18,16 +18,13 @@ export default defineNuxtConfig({
       // These are owned by the feeds layer so we prerender them here.
       // Collection-specific routes (/feed/blog/rss etc.) must be added to
       // nitro.prerender.routes in the consuming app's nuxt.config.ts.
-      routes: [
-        '/feed/demo',
-        '/feed/rss',
-        '/feed/atom',
-        '/feed/json',
-        '/feed/rss/all',
-        '/feed/atom/all',
-        '/feed/json/all',
-        '/feed/style.xsl',
-      ],
+      //
+      // The /all variants (/feed/rss/all etc.) are intentionally NOT prerendered:
+      // prerendering /feed/rss to a static file `feed/rss` and /feed/rss/all to
+      // `feed/rss/all` collides on disk (a file and a directory can't share the
+      // same path → EISDIR/EEXIST). The /all routes are served dynamically by the
+      // Nitro server function instead.
+      routes: ['/feed/demo', '/feed/rss', '/feed/atom', '/feed/json', '/feed/style.xsl'],
     },
   },
 

package/layers/feeds/server/utils/feed-author.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from 'vitest'
+
+import { resolveFeedAuthor, resolveFeedDate } from './feed-author'
+
+describe('resolveFeedAuthor', () => {
+  it('prefers the first entry of the authors array', () => {
+    expect(
+      resolveFeedAuthor({
+        authors: [{ name: 'Kieran Mansfield' }, { name: 'Someone Else' }],
+        author: 'Fallback Author',
+      })
+    ).toBe('Kieran Mansfield')
+  })
+
+  it('falls back to a string author when authors array is missing', () => {
+    expect(resolveFeedAuthor({ author: 'Kieran Mansfield' })).toBe('Kieran Mansfield')
+  })
+
+  it('falls back to an object author.name when author is not a string', () => {
+    expect(resolveFeedAuthor({ author: { name: 'Kieran Mansfield' } })).toBe('Kieran Mansfield')
+  })
+
+  it('returns undefined when no author information is present', () => {
+    expect(resolveFeedAuthor({})).toBeUndefined()
+  })
+
+  it('ignores an authors array entry with an empty name and falls through', () => {
+    expect(
+      resolveFeedAuthor({ authors: [{ name: '' }], author: 'Kieran Mansfield' })
+    ).toBe('Kieran Mansfield')
+  })
+
+  it('ignores an empty string author and falls through to object author', () => {
+    expect(resolveFeedAuthor({ author: '' })).toBeUndefined()
+  })
+
+  it('returns undefined when authors array is empty and no author is set', () => {
+    expect(resolveFeedAuthor({ authors: [] })).toBeUndefined()
+  })
+})
+
+describe('resolveFeedDate', () => {
+  it('prefers item.date when present', () => {
+    const result = resolveFeedDate({ date: '2024-01-01T00:00:00.000Z' })
+    expect(result).toEqual(new Date('2024-01-01T00:00:00.000Z'))
+  })
+
+  it('falls back to item.createdAt when date is missing', () => {
+    const result = resolveFeedDate({ createdAt: '2023-06-15T00:00:00.000Z' })
+    expect(result).toEqual(new Date('2023-06-15T00:00:00.000Z'))
+  })
+
+  it('falls back to now when neither date nor createdAt is present', () => {
+    const before = Date.now()
+    const result = resolveFeedDate({})
+    const after = Date.now()
+
+    expect(result.getTime()).toBeGreaterThanOrEqual(before)
+    expect(result.getTime()).toBeLessThanOrEqual(after)
+  })
+
+  it('accepts a numeric timestamp', () => {
+    const timestamp = 1700000000000
+    expect(resolveFeedDate({ date: timestamp })).toEqual(new Date(timestamp))
+  })
+
+  it('accepts a Date instance', () => {
+    const date = new Date('2022-03-03T00:00:00.000Z')
+    expect(resolveFeedDate({ date })).toEqual(date)
+  })
+})

package/layers/feeds/server/utils/feed-config.test.ts

@@ -0,0 +1,162 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  createFeedConfig,
+  resolveFeedCollection,
+  resolveFeedLimit,
+  resolveFeedSiteConfig,
+} from './feed-config'
+
+describe('resolveFeedSiteConfig', () => {
+  it('defaults site to an empty object when appConfig.site is missing', () => {
+    const result = resolveFeedSiteConfig({}, new URL('https://example.com/feed'))
+    expect(result.site).toEqual({})
+  })
+
+  it('strips a trailing slash from a configured site url', () => {
+    const result = resolveFeedSiteConfig(
+      { site: { url: 'https://example.com/' } },
+      new URL('https://request-origin.com/feed')
+    )
+    expect(result.siteUrl).toBe('https://example.com')
+  })
+
+  it('keeps a site url without a trailing slash unchanged', () => {
+    const result = resolveFeedSiteConfig(
+      { site: { url: 'https://example.com' } },
+      new URL('https://request-origin.com/feed')
+    )
+    expect(result.siteUrl).toBe('https://example.com')
+  })
+
+  it('falls back to the request origin when no site url is configured', () => {
+    const result = resolveFeedSiteConfig({}, new URL('https://request-origin.com/feed?x=1'))
+    expect(result.siteUrl).toBe('https://request-origin.com')
+  })
+})
+
+describe('resolveFeedCollection', () => {
+  it('uses the explicit collection argument when provided', () => {
+    expect(resolveFeedCollection({ defaultCollection: 'docs' }, 'blog')).toBe('blog')
+  })
+
+  it('falls back to the configured default collection', () => {
+    expect(resolveFeedCollection({ defaultCollection: 'docs' }, undefined)).toBe('docs')
+  })
+
+  it('falls back to "blog" when neither is provided', () => {
+    expect(resolveFeedCollection(undefined, undefined)).toBe('blog')
+  })
+})
+
+describe('createFeedConfig', () => {
+  it('uses "My Site" as the title fallback with no collection label', () => {
+    const config = createFeedConfig({ site: {}, siteUrl: 'https://example.com', collection: undefined })
+    expect(config.title).toBe('My Site')
+  })
+
+  it('appends a capitalized collection label to the title', () => {
+    const config = createFeedConfig({
+      site: { title: 'Nuxt Layers' },
+      siteUrl: 'https://example.com',
+      collection: 'blog',
+    })
+    expect(config.title).toBe('Nuxt Layers — Blog')
+  })
+
+  it('defaults description to an empty string', () => {
+    const config = createFeedConfig({ site: {}, siteUrl: 'https://example.com', collection: undefined })
+    expect(config.description).toBe('')
+  })
+
+  it('passes description through when set', () => {
+    const config = createFeedConfig({
+      site: { description: 'A monorepo of Nuxt layers' },
+      siteUrl: 'https://example.com',
+      collection: undefined,
+    })
+    expect(config.description).toBe('A monorepo of Nuxt layers')
+  })
+
+  it('builds an author object when the site has a named author', () => {
+    const config = createFeedConfig({
+      site: { author: { name: 'Kieran Mansfield', email: 'hi@example.com', link: 'https://example.com' } },
+      siteUrl: 'https://example.com',
+      collection: undefined,
+    })
+    expect(config.author).toEqual({
+      name: 'Kieran Mansfield',
+      email: 'hi@example.com',
+      link: 'https://example.com',
+    })
+  })
+
+  it('omits author when the site author has no name', () => {
+    const config = createFeedConfig({ site: {}, siteUrl: 'https://example.com', collection: undefined })
+    expect(config.author).toBeUndefined()
+  })
+
+  it('maps a falsy site.image to undefined', () => {
+    const config = createFeedConfig({
+      site: { image: '' },
+      siteUrl: 'https://example.com',
+      collection: undefined,
+    })
+    expect(config.image).toBeUndefined()
+  })
+
+  it('passes through a truthy site.image', () => {
+    const config = createFeedConfig({
+      site: { image: 'https://example.com/og.png' },
+      siteUrl: 'https://example.com',
+      collection: undefined,
+    })
+    expect(config.image).toBe('https://example.com/og.png')
+  })
+
+  it('defaults favicon to /favicon.ico', () => {
+    const config = createFeedConfig({ site: {}, siteUrl: 'https://example.com', collection: undefined })
+    expect(config.favicon).toBe('/favicon.ico')
+  })
+
+  it('prefers an explicit copyright over a generated one', () => {
+    const config = createFeedConfig({
+      site: { copyright: 'All rights reserved', author: { name: 'Kieran Mansfield' } },
+      siteUrl: 'https://example.com',
+      collection: undefined,
+    })
+    expect(config.copyright).toBe('All rights reserved')
+  })
+
+  it('generates a copyright string from the author name and current year', () => {
+    const config = createFeedConfig({
+      site: { author: { name: 'Kieran Mansfield' } },
+      siteUrl: 'https://example.com',
+      collection: undefined,
+    })
+    expect(config.copyright).toBe(`Copyright ${new Date().getFullYear()} Kieran Mansfield`)
+  })
+
+  it('omits copyright when there is no explicit copyright and no author name', () => {
+    const config = createFeedConfig({ site: {}, siteUrl: 'https://example.com', collection: undefined })
+    expect(config.copyright).toBeUndefined()
+  })
+})
+
+describe('resolveFeedLimit', () => {
+  it('defaults to 30 when no limit is configured', () => {
+    expect(resolveFeedLimit(undefined)).toBe(30)
+  })
+
+  it('uses the configured limit', () => {
+    expect(resolveFeedLimit({ limit: 10 })).toBe(10)
+  })
+
+  it('returns Infinity when unlimited is requested, ignoring the configured limit', () => {
+    expect(resolveFeedLimit({ limit: 10 }, { unlimited: true })).toBe(Infinity)
+  })
+
+  it('returns the default limit when unlimited is explicitly false', () => {
+    expect(resolveFeedLimit(undefined, { unlimited: false })).toBe(30)
+  })
+})

package/layers/forms/app/utils/contact-schema.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from 'vitest'
+
+import { contactSchema } from './contact-schema'
+
+describe('contactSchema', () => {
+  it('fails when name is too short', () => {
+    const result = contactSchema.safeParse({
+      name: 'ab',
+      email: 'valid@example.com',
+      message: 'a long enough message',
+    })
+
+    expect(result.success).toBe(false)
+    if (!result.success) {
+      expect(result.error.issues[0]?.message).toBe('Name must be at least 3 characters')
+    }
+  })
+
+  it('fails when email is invalid', () => {
+    const result = contactSchema.safeParse({
+      name: 'Kieran',
+      email: 'not-an-email',
+      message: 'a long enough message',
+    })
+
+    expect(result.success).toBe(false)
+    if (!result.success) {
+      expect(result.error.issues[0]?.message).toBe('Please enter a valid email')
+    }
+  })
+
+  it('fails when message is too short', () => {
+    const result = contactSchema.safeParse({
+      name: 'Kieran',
+      email: 'valid@example.com',
+      message: 'short',
+    })
+
+    expect(result.success).toBe(false)
+    if (!result.success) {
+      expect(result.error.issues[0]?.message).toBe('Message must be at least 8 characters')
+    }
+  })
+
+  it('passes with valid input', () => {
+    const result = contactSchema.safeParse({
+      name: 'Kieran',
+      email: 'valid@example.com',
+      message: 'a long enough message',
+    })
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data).toEqual({
+        name: 'Kieran',
+        email: 'valid@example.com',
+        message: 'a long enough message',
+      })
+    }
+  })
+
+  it('returns a safeParse shape with success/data or success/error', () => {
+    const passResult = contactSchema.safeParse({
+      name: 'Kieran',
+      email: 'valid@example.com',
+      message: 'a long enough message',
+    })
+    expect(passResult).toHaveProperty('success')
+    expect(passResult).toHaveProperty('data')
+
+    const failResult = contactSchema.safeParse({ name: '', email: '', message: '' })
+    expect(failResult).toHaveProperty('success')
+    expect(failResult).toHaveProperty('error')
+  })
+})

package/layers/forms/app/utils/fieldProps.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, it } from 'vitest'
+
+import type { FieldConfig } from '../types/fields'
+import {
+  buildBaseInputProps,
+  buildFormFieldProps,
+  buildNumberInputProps,
+  buildTextInputProps,
+} from './fieldProps'
+
+describe('buildFormFieldProps', () => {
+  it('includes only required keys when optional args are undefined', () => {
+    const props = buildFormFieldProps({ name: 'email', required: true, size: 'md' })
+
+    expect(props).toEqual({ name: 'email', required: true, size: 'md' })
+    expect(props).not.toHaveProperty('label')
+    expect(props).not.toHaveProperty('class')
+  })
+
+  it('renames className to class when provided', () => {
+    const props = buildFormFieldProps({
+      name: 'email',
+      required: true,
+      size: 'md',
+      className: 'my-class',
+    })
+
+    expect(props).toHaveProperty('class', 'my-class')
+    expect(props).not.toHaveProperty('className')
+  })
+
+  it('includes label when provided', () => {
+    const props = buildFormFieldProps({
+      name: 'email',
+      required: false,
+      size: 'sm',
+      label: 'Email address',
+    })
+
+    expect(props).toEqual({ name: 'email', required: false, size: 'sm', label: 'Email address' })
+  })
+})
+
+describe('buildBaseInputProps', () => {
+  it('omits placeholder and leadingIcon when undefined', () => {
+    const props = buildBaseInputProps({ size: 'md' })
+
+    expect(props).toEqual({ size: 'md' })
+    expect(props).not.toHaveProperty('placeholder')
+    expect(props).not.toHaveProperty('leadingIcon')
+  })
+
+  it('renames icon to leadingIcon when provided', () => {
+    const props = buildBaseInputProps({ size: 'md', icon: 'i-lucide-mail' })
+
+    expect(props).toHaveProperty('leadingIcon', 'i-lucide-mail')
+    expect(props).not.toHaveProperty('icon')
+  })
+
+  it('includes placeholder when provided', () => {
+    const props = buildBaseInputProps({ size: 'md', placeholder: 'you@example.com' })
+
+    expect(props).toEqual({ size: 'md', placeholder: 'you@example.com' })
+  })
+})
+
+describe('buildTextInputProps', () => {
+  const baseConfig: FieldConfig = {
+    inputType: 'text',
+    validation: {} as FieldConfig['validation'],
+  }
+
+  it('omits inputmode, autocomplete, placeholder, leadingIcon when undefined', () => {
+    const props = buildTextInputProps({ config: baseConfig, size: 'md' })
+
+    expect(props).toEqual({ type: 'text', size: 'md' })
+    expect(props).not.toHaveProperty('inputmode')
+    expect(props).not.toHaveProperty('autocomplete')
+    expect(props).not.toHaveProperty('placeholder')
+    expect(props).not.toHaveProperty('leadingIcon')
+  })
+
+  it('includes inputmode and autocomplete from config when set', () => {
+    const config: FieldConfig = {
+      inputType: 'email',
+      inputMode: 'email',
+      autocomplete: 'email',
+      validation: {} as FieldConfig['validation'],
+    }
+
+    const props = buildTextInputProps({ config, size: 'lg' })
+
+    expect(props).toEqual({
+      type: 'email',
+      size: 'lg',
+      inputmode: 'email',
+      autocomplete: 'email',
+    })
+  })
+
+  it('renames icon to leadingIcon and includes placeholder when provided', () => {
+    const props = buildTextInputProps({
+      config: baseConfig,
+      size: 'md',
+      placeholder: 'Name',
+      icon: 'i-lucide-user',
+    })
+
+    expect(props).toEqual({
+      type: 'text',
+      size: 'md',
+      placeholder: 'Name',
+      leadingIcon: 'i-lucide-user',
+    })
+  })
+})
+
+describe('buildNumberInputProps', () => {
+  it('omits placeholder, leadingIcon, formatOptions when undefined', () => {
+    const props = buildNumberInputProps({ size: 'md' })
+
+    expect(props).toEqual({ size: 'md' })
+    expect(props).not.toHaveProperty('placeholder')
+    expect(props).not.toHaveProperty('leadingIcon')
+    expect(props).not.toHaveProperty('formatOptions')
+  })
+
+  it('includes formatOptions when provided', () => {
+    const formatOptions: Intl.NumberFormatOptions = { style: 'currency', currency: 'USD' }
+    const props = buildNumberInputProps({ size: 'md', formatOptions })
+
+    expect(props).toEqual({ size: 'md', formatOptions })
+  })
+
+  it('renames icon to leadingIcon when provided', () => {
+    const props = buildNumberInputProps({ size: 'md', icon: 'i-lucide-hash' })
+
+    expect(props).toHaveProperty('leadingIcon', 'i-lucide-hash')
+    expect(props).not.toHaveProperty('icon')
+  })
+})