kmcom-nuxt-layers 2.5.1 → 2.6.0

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

@@ -0,0 +1,310 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  aspectClasses,
+  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('aspectClasses map', () => {
+  it('maps aspect ratios to tailwind classes', () => {
+    expect(aspectClasses).toEqual({
+      '1/1': 'aspect-square',
+      '4/3': 'aspect-[4/3]',
+      '3/4': 'aspect-[3/4]',
+      '16/9': 'aspect-video',
+      '9/16': 'aspect-[9/16]',
+      '2/1': 'aspect-[2/1]',
+      '1/2': 'aspect-[1/2]',
+    })
+  })
+})
+
+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 neither z nor layer is set', () => {
+    expect(resolveLayerStyles()).toEqual({})
+  })
+
+  it('prefers an explicit z over the layer lookup', () => {
+    expect(resolveLayerStyles(99, 'back')).toEqual({ zIndex: '99' })
+  })
+
+  it('falls back to the layer z-index lookup', () => {
+    expect(resolveLayerStyles(undefined, 'front')).toEqual({ zIndex: '20' })
+  })
+
+  it('treats z=0 as a defined value', () => {
+    expect(resolveLayerStyles(0, 'top')).toEqual({ zIndex: '0' })
+  })
+})
+
+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',
+      z: 5,
+      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',
+      z: 5,
+      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: '5',
+      '--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 aspect/container is set', () => {
+    expect(buildGridPlacementClasses({})).toBe('gi-placed @container @container/item')
+  })
+
+  it('appends the aspect class when aspect is set', () => {
+    expect(buildGridPlacementClasses({ aspect: '16/9' })).toBe(
+      'gi-placed @container @container/item aspect-video'
+    )
+  })
+
+  it('appends the container class when container is set', () => {
+    expect(buildGridPlacementClasses({ container: 'wide' })).toBe(
+      'gi-placed @container @container/item layout-container-wide'
+    )
+  })
+
+  it('appends both aspect and container classes when both are set', () => {
+    expect(buildGridPlacementClasses({ aspect: '1/1', container: 'fluid' })).toBe(
+      'gi-placed @container @container/item aspect-square layout-container-fluid'
+    )
+  })
+})

package/layers/metadata/providers/comicvine/nuxt.config.ts

@@ -26,7 +26,7 @@ export default defineNuxtConfig({
 })
 
 declare module '@nuxt/schema' {
-  interface RuntimeConfig {
+  type RuntimeConfig = {
     metadataComicvine: {
       apiKey: string
       baseUrl: string

package/layers/metadata/providers/comicvine/server/utils/metadata-comicvine/client.ts

@@ -1,14 +1,19 @@
 import type { ComicVineApiResponse } from './types'
 
-const FIELD_LIST_ISSUE = 'id,name,issue_number,description,deck,cover_date,store_date,site_detail_url,image,volume,person_credits,publisher'
-const FIELD_LIST_VOLUME = 'id,name,description,deck,start_year,site_detail_url,image,publisher,people'
+const FIELD_LIST_ISSUE =
+  'id,name,issue_number,description,deck,cover_date,store_date,site_detail_url,image,volume,person_credits,publisher'
+const FIELD_LIST_VOLUME =
+  'id,name,description,deck,start_year,count_of_issues,site_detail_url,image,publisher,people'
 
 function getConfig() {
   const config = useRuntimeConfig()
   return config.metadataComicvine
 }
 
-async function comicVineFetch<T>(path: string, params: Record<string, string>): Promise<ComicVineApiResponse<T>> {
+async function comicVineFetch<T>(
+  path: string,
+  params: Record<string, string>
+): Promise<ComicVineApiResponse<T>> {
   const { apiKey, baseUrl } = getConfig()
 
   const url = new URL(`${baseUrl}${path}`)
@@ -16,13 +21,15 @@ async function comicVineFetch<T>(path: string, params: Record<string, string>):
   url.searchParams.set('format', 'json')
   for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v)
 
-  const res = await $fetch<ComicVineApiResponse<T>>(url.toString())
+  const res = await $fetch<ComicVineApiResponse<T>>(url.toString(), {
+    headers: { 'User-Agent': 'Mozilla/5.0 (compatible; nuxt-metadata/1.0)' },
+  })
   if (res.status_code !== 1) throw new MetadataProviderError('comicvine', `API error: ${res.error}`)
   return res
 }
 
 export async function searchComicVineIssues(query: string, limit = 10) {
-  return comicVineFetch<import('./types').ComicVineIssue[]>('/search/', {
+  return comicVineFetch<Array<import('./types').ComicVineIssue>>('/search/', {
     query,
     resources: 'issue',
     limit: String(limit),
@@ -31,7 +38,7 @@ export async function searchComicVineIssues(query: string, limit = 10) {
 }
 
 export async function searchComicVineVolumes(query: string, limit = 10) {
-  return comicVineFetch<import('./types').ComicVineVolume[]>('/search/', {
+  return comicVineFetch<Array<import('./types').ComicVineVolume>>('/search/', {
     query,
     resources: 'volume',
     limit: String(limit),

package/layers/metadata/providers/comicvine/server/utils/metadata-comicvine/normalise.test.ts

@@ -0,0 +1,201 @@
+import { describe, expect, it } from 'vitest'
+
+import { normaliseComicVineIssue, normaliseComicVineVolume } from './normalise'
+import type { ComicVineIssue, ComicVineVolume } from './types'
+
+function baseIssue(overrides: Partial<ComicVineIssue> = {}): ComicVineIssue {
+  return {
+    id: 1000,
+    name: null,
+    issue_number: '1',
+    description: null,
+    deck: null,
+    cover_date: null,
+    store_date: null,
+    site_detail_url: 'https://comicvine.gamespot.com/issue/1000',
+    image: null,
+    volume: null,
+    person_credits: null,
+    publisher: null,
+    ...overrides,
+  }
+}
+
+function baseVolume(overrides: Partial<ComicVineVolume> = {}): ComicVineVolume {
+  return {
+    id: 2000,
+    name: 'Amazing Spider-Man',
+    description: null,
+    deck: null,
+    start_year: null,
+    count_of_issues: null,
+    site_detail_url: 'https://comicvine.gamespot.com/volume/2000',
+    image: null,
+    publisher: null,
+    people: null,
+    ...overrides,
+  }
+}
+
+describe('normaliseComicVineIssue', () => {
+  it('prefers volume name + issue number for the title', () => {
+    const record = normaliseComicVineIssue(
+      baseIssue({ volume: { id: 1, name: 'Amazing Spider-Man' }, issue_number: '5' })
+    )
+    expect(record.title).toBe('Amazing Spider-Man #5')
+  })
+
+  it('falls back to the issue name when there is no volume', () => {
+    const record = normaliseComicVineIssue(baseIssue({ name: 'The Beginning', issue_number: '1' }))
+    expect(record.title).toBe('The Beginning')
+  })
+
+  it('falls back to "Issue #n" when neither volume nor name are present', () => {
+    const record = normaliseComicVineIssue(baseIssue({ issue_number: '7' }))
+    expect(record.title).toBe('Issue #7')
+  })
+
+  it('sets subtitle to the issue name when present', () => {
+    const record = normaliseComicVineIssue(baseIssue({ name: 'The Beginning' }))
+    expect(record.subtitle).toBe('The Beginning')
+  })
+
+  it('leaves subtitle undefined when the issue has no name', () => {
+    expect(normaliseComicVineIssue(baseIssue()).subtitle).toBeUndefined()
+  })
+
+  it('prefers deck over description', () => {
+    const record = normaliseComicVineIssue(
+      baseIssue({ deck: 'Short deck', description: 'Long description' })
+    )
+    expect(record.description).toBe('Short deck')
+  })
+
+  it('falls back to description when deck is absent', () => {
+    const record = normaliseComicVineIssue(baseIssue({ description: 'Long description' }))
+    expect(record.description).toBe('Long description')
+  })
+
+  it('leaves description undefined when both deck and description are absent', () => {
+    expect(normaliseComicVineIssue(baseIssue()).description).toBeUndefined()
+  })
+
+  it('maps person_credits to creators', () => {
+    const record = normaliseComicVineIssue(
+      baseIssue({ person_credits: [{ id: 10, name: 'Stan Lee', role: 'writer' }] })
+    )
+    expect(record.creators).toEqual([{ name: 'Stan Lee', role: 'writer', providerId: '10' }])
+  })
+
+  it('leaves creators undefined when person_credits is empty or null', () => {
+    expect(normaliseComicVineIssue(baseIssue({ person_credits: [] })).creators).toBeUndefined()
+    expect(normaliseComicVineIssue(baseIssue({ person_credits: null })).creators).toBeUndefined()
+  })
+
+  it('prefers medium_url over original_url for coverUrl', () => {
+    const record = normaliseComicVineIssue(
+      baseIssue({ image: { medium_url: 'medium.jpg', original_url: 'original.jpg' } })
+    )
+    expect(record.coverUrl).toBe('medium.jpg')
+  })
+
+  it('falls back to original_url when medium_url is missing', () => {
+    const record = normaliseComicVineIssue(
+      baseIssue({
+        image: { medium_url: undefined as unknown as string, original_url: 'original.jpg' },
+      })
+    )
+    expect(record.coverUrl).toBe('original.jpg')
+  })
+
+  it('leaves coverUrl undefined when image is null', () => {
+    expect(normaliseComicVineIssue(baseIssue()).coverUrl).toBeUndefined()
+  })
+
+  it('sets identifiers.comicVineId to the stringified id', () => {
+    expect(normaliseComicVineIssue(baseIssue({ id: 42 })).identifiers).toEqual({
+      comicVineId: '42',
+    })
+  })
+
+  it('stamps lastSyncedAt as an ISO-ish string', () => {
+    expect(normaliseComicVineIssue(baseIssue()).lastSyncedAt).toEqual(expect.any(String))
+  })
+})
+
+describe('normaliseComicVineVolume', () => {
+  it('appends the start year to the title when present', () => {
+    expect(normaliseComicVineVolume(baseVolume({ start_year: '1963' })).title).toBe(
+      'Amazing Spider-Man (1963)'
+    )
+  })
+
+  it('omits the year suffix when start_year is absent', () => {
+    expect(normaliseComicVineVolume(baseVolume()).title).toBe('Amazing Spider-Man')
+  })
+
+  it('pluralises the issue count subtitle for more than one issue', () => {
+    expect(normaliseComicVineVolume(baseVolume({ count_of_issues: 5 })).subtitle).toBe('5 issues')
+  })
+
+  it('uses the singular issue count subtitle for exactly one issue', () => {
+    expect(normaliseComicVineVolume(baseVolume({ count_of_issues: 1 })).subtitle).toBe('1 issue')
+  })
+
+  it('joins publisher and issue count with " · "', () => {
+    const record = normaliseComicVineVolume(
+      baseVolume({ publisher: { id: 1, name: 'Marvel' }, count_of_issues: 3 })
+    )
+    expect(record.subtitle).toBe('Marvel · 3 issues')
+  })
+
+  it('drops the null issue count and keeps only the publisher', () => {
+    const record = normaliseComicVineVolume(
+      baseVolume({ publisher: { id: 1, name: 'Marvel' }, count_of_issues: null })
+    )
+    expect(record.subtitle).toBe('Marvel')
+  })
+
+  it('subtitle is undefined when both publisher and issue count are absent', () => {
+    expect(normaliseComicVineVolume(baseVolume()).subtitle).toBeUndefined()
+  })
+
+  it('maps people to creators', () => {
+    const record = normaliseComicVineVolume(
+      baseVolume({ people: [{ id: 5, name: 'Stan Lee', role: 'writer' }] })
+    )
+    expect(record.creators).toEqual([{ name: 'Stan Lee', role: 'writer', providerId: '5' }])
+  })
+
+  it('leaves creators undefined when people is empty or null', () => {
+    expect(normaliseComicVineVolume(baseVolume({ people: [] })).creators).toBeUndefined()
+    expect(normaliseComicVineVolume(baseVolume({ people: null })).creators).toBeUndefined()
+  })
+
+  it('prefers deck over description', () => {
+    const record = normaliseComicVineVolume(
+      baseVolume({ deck: 'deck text', description: 'desc text' })
+    )
+    expect(record.description).toBe('deck text')
+  })
+
+  it('prefers medium_url over original_url, falling back when missing', () => {
+    const withMedium = normaliseComicVineVolume(
+      baseVolume({ image: { medium_url: 'medium.jpg', original_url: 'original.jpg' } })
+    )
+    expect(withMedium.coverUrl).toBe('medium.jpg')
+
+    const withoutMedium = normaliseComicVineVolume(
+      baseVolume({
+        image: { medium_url: undefined as unknown as string, original_url: 'original.jpg' },
+      })
+    )
+    expect(withoutMedium.coverUrl).toBe('original.jpg')
+  })
+
+  it('sets identifiers.comicVineId to the stringified id', () => {
+    expect(normaliseComicVineVolume(baseVolume({ id: 99 })).identifiers).toEqual({
+      comicVineId: '99',
+    })
+  })
+})

package/layers/metadata/providers/comicvine/server/utils/metadata-comicvine/normalise.ts

@@ -1,4 +1,5 @@
-import type { MetadataRecord, MetadataCreator } from '#layers/metadata/shared/types'
+import type { MetadataCreator, MetadataRecord } from '#layers/metadata/shared/types'
+
 import type { ComicVineIssue, ComicVineVolume } from './types'
 
 // fallow-ignore-next-line complexity
@@ -9,18 +10,24 @@ export function normaliseComicVineIssue(issue: ComicVineIssue): MetadataRecord {
     providerId: String(p.id),
   }))
 
+  const description = issue.deck ?? issue.description
+  const publishedAt = issue.cover_date ?? issue.store_date
+  const coverUrl = issue.image?.medium_url ?? issue.image?.original_url
+
   return {
     id: `comicvine:issue:${issue.id}`,
     provider: 'comicvine',
     providerId: String(issue.id),
     mediaType: 'comic',
-    title: issue.volume?.name ? `${issue.volume.name} #${issue.issue_number}` : (issue.name ?? `Issue #${issue.issue_number}`),
-    subtitle: issue.name ?? undefined,
-    description: issue.deck ?? issue.description ?? undefined,
-    creators: creators.length ? creators : undefined,
-    publisher: issue.publisher?.name ?? undefined,
-    publishedAt: issue.cover_date ?? issue.store_date ?? undefined,
-    coverUrl: issue.image?.medium_url ?? issue.image?.original_url ?? undefined,
+    title: issue.volume?.name
+      ? `${issue.volume.name} #${issue.issue_number}`
+      : (issue.name ?? `Issue #${issue.issue_number}`),
+    ...(issue.name && { subtitle: issue.name }),
+    ...(description && { description }),
+    ...(creators.length && { creators }),
+    ...(issue.publisher?.name && { publisher: issue.publisher.name }),
+    ...(publishedAt && { publishedAt }),
+    ...(coverUrl && { coverUrl }),
     identifiers: { comicVineId: String(issue.id) },
     sourceUrl: issue.site_detail_url,
     raw: issue,
@@ -36,17 +43,29 @@ export function normaliseComicVineVolume(volume: ComicVineVolume): MetadataRecor
     providerId: String(p.id),
   }))
 
+  const subtitle = [
+    volume.publisher?.name,
+    volume.count_of_issues
+      ? `${volume.count_of_issues} issue${volume.count_of_issues === 1 ? '' : 's'}`
+      : null,
+  ]
+    .filter(Boolean)
+    .join(' · ')
+  const description = volume.deck ?? volume.description
+  const coverUrl = volume.image?.medium_url ?? volume.image?.original_url
+
   return {
     id: `comicvine:volume:${volume.id}`,
     provider: 'comicvine',
     providerId: String(volume.id),
-    mediaType: 'comic',
-    title: volume.name,
-    description: volume.deck ?? volume.description ?? undefined,
-    creators: creators.length ? creators : undefined,
-    publisher: volume.publisher?.name ?? undefined,
-    publishedAt: volume.start_year ?? undefined,
-    coverUrl: volume.image?.medium_url ?? volume.image?.original_url ?? undefined,
+    mediaType: 'comic-series',
+    title: volume.start_year ? `${volume.name} (${volume.start_year})` : volume.name,
+    ...(subtitle && { subtitle }),
+    ...(description && { description }),
+    ...(creators.length && { creators }),
+    ...(volume.publisher?.name && { publisher: volume.publisher.name }),
+    ...(volume.start_year && { publishedAt: volume.start_year }),
+    ...(coverUrl && { coverUrl }),
     identifiers: { comicVineId: String(volume.id) },
     sourceUrl: volume.site_detail_url,
     raw: volume,