kmcom-nuxt-layers 6.4.0 → 6.5.0

package/layers/structure/grid/app/composables/useGridTracks.test.ts

@@ -1,94 +0,0 @@
-import { describe, expect, it } from 'vite-plus/test'
-
-import type { GridPreset, TrackConfig } from '../types/tracks'
-import { resolve, toColumnsCss } from './useGridTracks'
-
-describe('toColumnsCss', () => {
-  it('renders equal segments with no line names', () => {
-    const config: TrackConfig = { columns: [{ size: 1 }, { size: 1 }, { size: 1 }] }
-    expect(toColumnsCss(config)).toBe(
-      'minmax(var(--measure-min), 1fr) minmax(var(--measure-min), 1fr) ' +
-        'minmax(var(--measure-min), 1fr)'
-    )
-  })
-
-  it('renders mixed sizes (8 equal + double + triple)', () => {
-    const config: TrackConfig = {
-      columns: [
-        { size: 1 },
-        { size: 1 },
-        { size: 1 },
-        { size: 1 },
-        { size: 1 },
-        { size: 1 },
-        { size: 1 },
-        { size: 2 },
-        { size: 3 },
-      ],
-    }
-    const css = toColumnsCss(config)
-    expect(css.split(' ').filter((s) => s.startsWith('minmax'))).toHaveLength(9)
-    expect(css).toContain('minmax(var(--measure-min), 2fr)')
-    expect(css).toContain('minmax(var(--measure-min), 3fr)')
-  })
-
-  it('brackets a leading lineStart and trailing lineEnd', () => {
-    const config: TrackConfig = {
-      columns: [{ size: 1, lineStart: 'a-start', lineEnd: 'a-end' }],
-    }
-    expect(toColumnsCss(config)).toBe('[a-start] minmax(var(--measure-min), 1fr) [a-end]')
-  })
-
-  it('merges an adjacent lineEnd and lineStart into one bracket', () => {
-    const config: TrackConfig = {
-      columns: [
-        { size: 2, lineStart: 'feature-start', lineEnd: 'feature-end' },
-        { size: 1, lineStart: 'aside-start', lineEnd: 'aside-end' },
-      ],
-    }
-    expect(toColumnsCss(config)).toBe(
-      '[feature-start] minmax(var(--measure-min), 2fr) ' +
-        '[feature-end aside-start] minmax(var(--measure-min), 1fr) [aside-end]'
-    )
-  })
-
-  it('supports a segment with only lineStart set', () => {
-    const config: TrackConfig = {
-      columns: [{ size: 1, lineStart: 'only-start' }, { size: 1 }],
-    }
-    expect(toColumnsCss(config)).toBe(
-      '[only-start] minmax(var(--measure-min), 1fr) minmax(var(--measure-min), 1fr)'
-    )
-  })
-
-  it('accepts an array of line names', () => {
-    const config: TrackConfig = {
-      columns: [{ size: 1, lineStart: ['a', 'b'] }],
-    }
-    expect(toColumnsCss(config)).toBe('[a b] minmax(var(--measure-min), 1fr)')
-  })
-
-  it('uses minTrackWidth override instead of the --measure-min default', () => {
-    const config: TrackConfig = { columns: [{ size: 1 }], minTrackWidth: '20rem' }
-    expect(toColumnsCss(config)).toBe('minmax(20rem, 1fr)')
-  })
-})
-
-describe('resolve', () => {
-  const presets: Record<string, GridPreset> = {
-    swiss: { name: 'swiss', columns: [{ size: 1 }] },
-  }
-
-  it('looks up a named preset from the registry', () => {
-    expect(resolve('swiss', presets)).toBe(presets.swiss)
-  })
-
-  it('throws for an unknown preset name', () => {
-    expect(() => resolve('nope', presets)).toThrow('Unknown grid preset: "nope"')
-  })
-
-  it('passes a TrackConfig object through unchanged', () => {
-    const custom: TrackConfig = { columns: [{ size: 1 }, { size: 2 }] }
-    expect(resolve(custom, presets)).toBe(custom)
-  })
-})

package/layers/structure/grid/app/types/tracks.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from 'vite-plus/test'
-
-import type { GridPreset, TrackConfig, TrackSegment } from './tracks'
-
-describe('track types', () => {
-  it('accepts a minimal equal-width segment', () => {
-    const segment: TrackSegment = { size: 1 }
-    expect(segment.size).toBe(1)
-  })
-
-  it('accepts a segment with named lines', () => {
-    const segment: TrackSegment = {
-      size: 2,
-      lineStart: 'feature-start',
-      lineEnd: ['feature-end', 'aside-start'],
-    }
-    expect(segment.lineEnd).toEqual(['feature-end', 'aside-start'])
-  })
-
-  it('accepts a TrackConfig with optional minTrackWidth', () => {
-    const config: TrackConfig = {
-      columns: [{ size: 1 }, { size: 2 }],
-      minTrackWidth: '20rem',
-    }
-    expect(config.columns).toHaveLength(2)
-  })
-
-  it('a GridPreset is a named TrackConfig', () => {
-    const preset: GridPreset = { name: 'swiss', columns: [{ size: 1 }] }
-    expect(preset.name).toBe('swiss')
-  })
-})

package/layers/structure/grid/app/utils/placement.test.ts

@@ -1,19 +0,0 @@
-import { describe, expect, it } from 'vite-plus/test'
-
-import { placementFromIndex, placementFromLines } from './placement'
-
-describe('placementFromLines', () => {
-  it('joins two named lines with a slash', () => {
-    expect(placementFromLines('feature-start', 'aside-end')).toBe('feature-start / aside-end')
-  })
-})
-
-describe('placementFromIndex', () => {
-  it('builds a numeric span from colStart and colSpan', () => {
-    expect(placementFromIndex(2, 3)).toBe('2 / span 3')
-  })
-
-  it('spans to the last line when colSpan is "full"', () => {
-    expect(placementFromIndex(4, 'full')).toBe('4 / -1')
-  })
-})

package/layers/structure/layout/app/utils/gridPlacementStyle.test.ts

@@ -1,269 +0,0 @@
-import { describe, expect, it } from 'vite-plus/test'
-
-import {
-  buildGridPlacementClasses,
-  buildGridPlacementStyle,
-  layerZIndex,
-  resolveAlignmentStyles,
-  resolveBleedStyles,
-  resolveDefaultPlacement,
-  resolveLayerStyles,
-  resolveResponsivePlacementVars,
-  resolveRhythmStyles,
-} from './gridPlacementStyle'
-
-describe('layerZIndex map', () => {
-  it('assigns ascending z-index values', () => {
-    expect(layerZIndex).toEqual({ back: 0, mid: 10, front: 20, top: 30 })
-  })
-})
-
-describe('resolveDefaultPlacement', () => {
-  it('returns the fallback when value is undefined', () => {
-    expect(resolveDefaultPlacement(undefined, 'full')).toBe('full')
-    expect(resolveDefaultPlacement<number>(undefined, undefined)).toBeUndefined()
-  })
-
-  it('returns the plain value unchanged', () => {
-    expect(resolveDefaultPlacement(3, undefined)).toBe(3)
-    expect(resolveDefaultPlacement<string>('full', 'other')).toBe('full')
-  })
-
-  it('unwraps a responsive value default', () => {
-    expect(resolveDefaultPlacement({ default: 2, md: 4 }, undefined)).toBe(2)
-  })
-})
-
-describe('resolveResponsivePlacementVars', () => {
-  it('returns no vars for a plain value', () => {
-    expect(resolveResponsivePlacementVars(3, 'cs')).toEqual({})
-  })
-
-  it('returns no vars when value is undefined', () => {
-    expect(resolveResponsivePlacementVars(undefined, 'cs')).toEqual({})
-  })
-
-  it('sets only the md var when only md is provided', () => {
-    expect(resolveResponsivePlacementVars({ default: 1, md: 2 }, 'cs')).toEqual({
-      '--_md-cs': '2',
-    })
-  })
-
-  it('sets only the lg var when only lg is provided', () => {
-    expect(resolveResponsivePlacementVars({ default: 1, lg: 5 }, 're')).toEqual({
-      '--_lg-re': '5',
-    })
-  })
-
-  it('sets both md and lg vars when both are provided', () => {
-    expect(resolveResponsivePlacementVars({ default: 1, md: 2, lg: 5 }, 'ce')).toEqual({
-      '--_md-ce': '2',
-      '--_lg-ce': '5',
-    })
-  })
-})
-
-describe('resolveBleedStyles', () => {
-  it('returns no styles when bleed is not set', () => {
-    expect(resolveBleedStyles({})).toEqual({})
-  })
-
-  it('handles "both" bleed direction', () => {
-    expect(resolveBleedStyles({ bleed: 'both', rowStart: 1, rowSpan: 3 })).toEqual({
-      gridColumn: '1 / -1',
-      marginInline: 'calc(-1 * var(--grid-padding))',
-      gridRow: '1 / span 3',
-    })
-  })
-
-  it('handles "left" bleed direction with a numeric colSpan', () => {
-    expect(resolveBleedStyles({ bleed: 'left', colSpan: 4, rowStart: 2, rowSpan: 1 })).toEqual({
-      gridColumn: '1 / span 4',
-      marginInlineStart: 'calc(-1 * var(--grid-padding))',
-      gridRow: '2 / span 1',
-    })
-  })
-
-  it('handles "left" bleed direction without a numeric colSpan', () => {
-    expect(resolveBleedStyles({ bleed: 'left', colSpan: 'full', rowSpan: 1 })).toEqual({
-      gridColumn: '1 / -1',
-      marginInlineStart: 'calc(-1 * var(--grid-padding))',
-      gridRow: 'auto / span 1',
-    })
-  })
-
-  it('handles "right" bleed direction', () => {
-    expect(resolveBleedStyles({ bleed: 'right', colStart: 3, rowSpan: 2 })).toEqual({
-      gridColumn: '3 / -1',
-      marginInlineEnd: 'calc(-1 * var(--grid-padding))',
-      gridRow: 'auto / span 2',
-    })
-  })
-
-  it('defaults gridRow parts to "auto" when start/span are missing', () => {
-    expect(resolveBleedStyles({ bleed: 'right' })).toEqual({
-      gridColumn: 'auto / -1',
-      marginInlineEnd: 'calc(-1 * var(--grid-padding))',
-      gridRow: 'auto / span undefined',
-    })
-  })
-})
-
-describe('resolveAlignmentStyles', () => {
-  it('returns no styles when neither align nor justify is set', () => {
-    expect(resolveAlignmentStyles()).toEqual({})
-  })
-
-  it('defaults the missing axis to stretch', () => {
-    expect(resolveAlignmentStyles('center')).toEqual({
-      display: 'grid',
-      width: '100%',
-      height: '100%',
-      placeItems: 'center stretch',
-    })
-    expect(resolveAlignmentStyles(undefined, 'end')).toEqual({
-      display: 'grid',
-      width: '100%',
-      height: '100%',
-      placeItems: 'stretch end',
-    })
-  })
-
-  it('combines align and justify', () => {
-    expect(resolveAlignmentStyles('start', 'end')).toEqual({
-      display: 'grid',
-      width: '100%',
-      height: '100%',
-      placeItems: 'start end',
-    })
-  })
-})
-
-describe('resolveRhythmStyles', () => {
-  it('returns no styles when density is undefined', () => {
-    expect(resolveRhythmStyles()).toEqual({})
-  })
-
-  it.each([
-    ['compact', '0.125rem'],
-    ['normal', '0.25rem'],
-    ['relaxed', '0.5rem'],
-  ] as const)('maps %s density to the expected rhythm value', (density, value) => {
-    expect(resolveRhythmStyles(density)).toEqual({ '--rhythm': value })
-  })
-})
-
-describe('resolveLayerStyles', () => {
-  it('returns no styles when layer is not set', () => {
-    expect(resolveLayerStyles()).toEqual({})
-  })
-
-  it('looks up the z-index for the given layer', () => {
-    expect(resolveLayerStyles('front')).toEqual({ zIndex: '20' })
-  })
-})
-
-describe('buildGridPlacementStyle', () => {
-  it('applies defaults for an empty input', () => {
-    expect(buildGridPlacementStyle({})).toEqual({
-      gridColumn: '1 / -1',
-      '--_rs': 'auto',
-      '--_re': '1',
-    })
-  })
-
-  it('returns early for a full colSpan and skips alignment/rhythm/layer/gap', () => {
-    const style = buildGridPlacementStyle({
-      colSpan: 'full',
-      align: 'center',
-      density: 'compact',
-      layer: 'front',
-      gap: '1rem',
-    })
-
-    expect(style).toEqual({
-      gridColumn: '1 / -1',
-      '--_rs': 'auto',
-      '--_re': '1',
-    })
-    expect(style).not.toHaveProperty('zIndex')
-    expect(style).not.toHaveProperty('--rhythm')
-    expect(style).not.toHaveProperty('--grid-gap')
-  })
-
-  it('builds explicit column/row vars for a non-full colSpan and applies alignment/rhythm/layer/gap', () => {
-    const style = buildGridPlacementStyle({
-      colStart: 2,
-      colSpan: 3,
-      rowStart: 1,
-      rowSpan: 2,
-      align: 'center',
-      justify: 'end',
-      density: 'relaxed',
-      layer: 'front',
-      gap: '2rem',
-    })
-
-    expect(style).toEqual({
-      '--_cs': '2',
-      '--_ce': '3',
-      '--_rs': '1',
-      '--_re': '2',
-      display: 'grid',
-      width: '100%',
-      height: '100%',
-      placeItems: 'center end',
-      '--rhythm': '0.5rem',
-      zIndex: '20',
-      '--grid-gap': '2rem',
-    })
-  })
-
-  it('includes responsive vars for responsive-value inputs on a non-full colSpan', () => {
-    const style = buildGridPlacementStyle({
-      colStart: { default: 1, md: 2 },
-      colSpan: { default: 3, lg: 6 },
-    })
-
-    expect(style['--_md-cs']).toBe('2')
-    expect(style['--_lg-ce']).toBe('6')
-  })
-
-  it('applies bleed styles and skips the column/row var block entirely', () => {
-    const style = buildGridPlacementStyle({
-      bleed: 'both',
-      rowStart: 1,
-      rowSpan: 3,
-      align: 'start',
-    })
-
-    expect(style).toEqual({
-      gridColumn: '1 / -1',
-      marginInline: 'calc(-1 * var(--grid-padding))',
-      gridRow: '1 / span 3',
-      display: 'grid',
-      width: '100%',
-      height: '100%',
-      placeItems: 'start stretch',
-    })
-    expect(style).not.toHaveProperty('--_cs')
-    expect(style).not.toHaveProperty('--_rs')
-  })
-
-  it('omits --grid-gap when gap is not provided', () => {
-    const style = buildGridPlacementStyle({ colStart: 1, colSpan: 2 })
-    expect(style).not.toHaveProperty('--grid-gap')
-  })
-})
-
-describe('buildGridPlacementClasses', () => {
-  it('returns the base classes when no container is set', () => {
-    expect(buildGridPlacementClasses({})).toBe('gi-placed @container @container/item')
-  })
-
-  it('appends the container class when container is set', () => {
-    expect(buildGridPlacementClasses({ container: 'wide' })).toBe(
-      'gi-placed @container @container/item layout-container-wide'
-    )
-  })
-})

package/layers/structure/navigation/app/utils/site.test.ts

@@ -1,39 +0,0 @@
-import { describe, expect, it } from 'vite-plus/test'
-
-import { resolveSiteConfig } from './site'
-
-describe('resolveSiteConfig', () => {
-  it('defaults title, subtitle, and description to empty values when omitted', () => {
-    expect(resolveSiteConfig({})).toEqual({
-      title: '',
-      titleWords: [''],
-      subtitle: '',
-      subtitleWords: [''],
-      description: '',
-    })
-  })
-
-  it('splits the title and subtitle into words', () => {
-    expect(resolveSiteConfig({ title: 'Nuxt Layers', subtitle: 'Composable Vue apps' })).toEqual({
-      title: 'Nuxt Layers',
-      titleWords: ['Nuxt', 'Layers'],
-      subtitle: 'Composable Vue apps',
-      subtitleWords: ['Composable', 'Vue', 'apps'],
-      description: '',
-    })
-  })
-
-  it('passes description through unchanged when provided', () => {
-    expect(resolveSiteConfig({ description: 'A monorepo of Nuxt layers' })).toEqual({
-      title: '',
-      titleWords: [''],
-      subtitle: '',
-      subtitleWords: [''],
-      description: 'A monorepo of Nuxt layers',
-    })
-  })
-
-  it('handles a single-word title with no spaces', () => {
-    expect(resolveSiteConfig({ title: 'Solo' }).titleWords).toEqual(['Solo'])
-  })
-})

package/layers/structure/routing/app/utils/resolveRoute.test.ts

@@ -1,47 +0,0 @@
-import { describe, expect, it } from 'vite-plus/test'
-
-import type { FeatureValue, RouteResolution, RoutingLayerConfig } from '../types/routing'
-import { resolveRoute } from './resolveRoute'
-
-function createConfig(overrides: Partial<RoutingLayerConfig> = {}): RoutingLayerConfig {
-  return {
-    preset: 'marketing',
-    strictDefaultDeny: false,
-    layerDefaultDeny: false,
-    betaRedirect: '/coming-soon',
-    runtimeFlags: false,
-    debug: false,
-    maintenance: { enabled: false, allowRoutes: ['/maintenance'] },
-    scrollRouting: { enabled: false, mode: 'replace' },
-    features: {},
-    ...overrides,
-  }
-}
-
-describe('resolveRoute', () => {
-  it('allows routes without a feature by default', () => {
-    expect(resolveRoute({}, createConfig(), () => 'enabled')).toEqual({ outcome: 'allow' })
-  })
-
-  it('denies routes when strict default deny is enabled', () => {
-    expect(resolveRoute({}, createConfig({ strictDefaultDeny: true }), () => 'enabled')).toEqual({
-      outcome: 'deny',
-    })
-  })
-
-  it('denies layer-owned routes without a feature when layer default deny is enabled', () => {
-    expect(
-      resolveRoute({ __fromLayer: true }, createConfig({ layerDefaultDeny: true }), () => 'enabled')
-    ).toEqual({ outcome: 'deny' })
-  })
-
-  const featureCases: Array<[FeatureValue, RouteResolution]> = [
-    ['disabled', { outcome: 'deny' }],
-    ['beta', { outcome: 'redirect', to: '/coming-soon' }],
-    ['coming-soon', { outcome: 'redirect', to: '/coming-soon' }],
-  ]
-
-  it.each(featureCases)('handles %s feature variants', (variant, expected) => {
-    expect(resolveRoute({ feature: 'feature-x' }, createConfig(), () => variant)).toEqual(expected)
-  })
-})