@setzkasten-cms/core 0.4.2

package/src/events/content-event-bus.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it, vi } from 'vitest'
+import { createEventBus } from './content-event-bus'
+
+describe('ContentEventBus', () => {
+  it('emits events to subscribers', () => {
+    const bus = createEventBus()
+    const handler = vi.fn()
+
+    bus.on('field-changed', handler)
+    bus.emit({ type: 'field-changed', path: ['title'], value: 'Hello' })
+
+    expect(handler).toHaveBeenCalledWith({
+      type: 'field-changed',
+      path: ['title'],
+      value: 'Hello',
+    })
+  })
+
+  it('only notifies matching event types', () => {
+    const bus = createEventBus()
+    const fieldHandler = vi.fn()
+    const saveHandler = vi.fn()
+
+    bus.on('field-changed', fieldHandler)
+    bus.on('entry-saved', saveHandler)
+
+    bus.emit({ type: 'field-changed', path: ['title'], value: 'Hello' })
+
+    expect(fieldHandler).toHaveBeenCalledOnce()
+    expect(saveHandler).not.toHaveBeenCalled()
+  })
+
+  it('supports unsubscribing', () => {
+    const bus = createEventBus()
+    const handler = vi.fn()
+
+    const unsubscribe = bus.on('field-changed', handler)
+    bus.emit({ type: 'field-changed', path: ['title'], value: 'Hello' })
+    expect(handler).toHaveBeenCalledOnce()
+
+    unsubscribe()
+    bus.emit({ type: 'field-changed', path: ['title'], value: 'World' })
+    expect(handler).toHaveBeenCalledOnce() // still just once
+  })
+
+  it('supports multiple subscribers', () => {
+    const bus = createEventBus()
+    const handler1 = vi.fn()
+    const handler2 = vi.fn()
+
+    bus.on('entry-saved', handler1)
+    bus.on('entry-saved', handler2)
+
+    bus.emit({ type: 'entry-saved', collection: 'posts', slug: 'hello' })
+
+    expect(handler1).toHaveBeenCalledOnce()
+    expect(handler2).toHaveBeenCalledOnce()
+  })
+})

package/src/events/content-event-bus.ts

@@ -0,0 +1,55 @@
+import type { FieldPath } from '../fields/field-definition'
+
+// ---------------------------------------------------------------------------
+// Content event types
+// ---------------------------------------------------------------------------
+
+export type ContentEvent =
+  | { readonly type: 'field-changed'; readonly path: FieldPath; readonly value: unknown }
+  | { readonly type: 'entry-saved'; readonly collection: string; readonly slug: string }
+  | { readonly type: 'entry-deleted'; readonly collection: string; readonly slug: string }
+  | { readonly type: 'entry-loaded'; readonly collection: string; readonly slug: string }
+
+export type ContentEventType = ContentEvent['type']
+export type Unsubscribe = () => void
+
+/**
+ * Observer pattern – decoupled communication between form state and preview engine.
+ */
+export interface ContentEventBus {
+  emit(event: ContentEvent): void
+  on<T extends ContentEventType>(
+    type: T,
+    handler: (event: Extract<ContentEvent, { type: T }>) => void,
+  ): Unsubscribe
+}
+
+export function createEventBus(): ContentEventBus {
+  const listeners = new Map<string, Set<(event: ContentEvent) => void>>()
+
+  return {
+    emit(event) {
+      const handlers = listeners.get(event.type)
+      if (handlers) {
+        for (const handler of handlers) {
+          handler(event)
+        }
+      }
+    },
+
+    on(type, handler) {
+      if (!listeners.has(type)) {
+        listeners.set(type, new Set())
+      }
+      const handlers = listeners.get(type)!
+      handlers.add(handler as (event: ContentEvent) => void)
+
+      return () => {
+        handlers.delete(handler as (event: ContentEvent) => void)
+        if (handlers.size === 0) {
+          listeners.delete(type)
+        }
+      }
+    },
+  }
+}

package/src/fields/factories.test.ts

@@ -0,0 +1,168 @@
+import { describe, expect, it } from 'vitest'
+import { f } from './factories'
+
+describe('Field Factories', () => {
+  describe('f.text()', () => {
+    it('creates a text field with defaults', () => {
+      const field = f.text({ label: 'Title' })
+      expect(field.type).toBe('text')
+      expect(field.label).toBe('Title')
+      expect(field.multiline).toBe(false)
+      expect(field.defaultValue).toBe('')
+      expect(field.required).toBe(false)
+    })
+
+    it('creates a multiline text field', () => {
+      const field = f.text({ label: 'Description', multiline: true, maxLength: 500 })
+      expect(field.multiline).toBe(true)
+      expect(field.maxLength).toBe(500)
+    })
+
+    it('returns a frozen object', () => {
+      const field = f.text({ label: 'Test' })
+      expect(Object.isFrozen(field)).toBe(true)
+    })
+  })
+
+  describe('f.number()', () => {
+    it('creates a number field with defaults', () => {
+      const field = f.number({ label: 'Count' })
+      expect(field.type).toBe('number')
+      expect(field.defaultValue).toBe(0)
+      expect(field.slider).toBe(false)
+    })
+
+    it('creates a number field with min/max/step', () => {
+      const field = f.number({ label: 'Latitude', min: -90, max: 90, step: 0.0001 })
+      expect(field.min).toBe(-90)
+      expect(field.max).toBe(90)
+      expect(field.step).toBe(0.0001)
+    })
+  })
+
+  describe('f.boolean()', () => {
+    it('creates a boolean field', () => {
+      const field = f.boolean({ label: 'Enabled' })
+      expect(field.type).toBe('boolean')
+      expect(field.defaultValue).toBe(false)
+    })
+
+    it('accepts custom default', () => {
+      const field = f.boolean({ label: 'Active', defaultValue: true })
+      expect(field.defaultValue).toBe(true)
+    })
+  })
+
+  describe('f.select()', () => {
+    it('creates a select field', () => {
+      const field = f.select({
+        label: 'Style',
+        options: [
+          { label: 'Primary', value: 'primary' },
+          { label: 'Secondary', value: 'secondary' },
+        ],
+      })
+      expect(field.type).toBe('select')
+      expect(field.options).toHaveLength(2)
+      expect(field.defaultValue).toBe('primary')
+      expect(field.multi).toBe(false)
+    })
+  })
+
+  describe('f.image()', () => {
+    it('creates an image field with defaults', () => {
+      const field = f.image({
+        label: 'Hero Image',
+        directory: 'public/images/hero/',
+      })
+      expect(field.type).toBe('image')
+      expect(field.directory).toBe('public/images/hero/')
+      expect(field.accept).toEqual(['webp', 'jpg', 'png'])
+      expect(field.filenameStrategy).toBe('original')
+    })
+
+    it('accepts custom accept types', () => {
+      const field = f.image({
+        label: 'Logo',
+        directory: 'public/images/logo/',
+        accept: ['svg', 'png'],
+        maxSize: '1MB',
+      })
+      expect(field.accept).toEqual(['svg', 'png'])
+      expect(field.maxSize).toBe('1MB')
+    })
+  })
+
+  describe('f.array()', () => {
+    it('creates an array field', () => {
+      const field = f.array(f.text({ label: 'Tag' }), {
+        label: 'Tags',
+        minItems: 1,
+        maxItems: 10,
+      })
+      expect(field.type).toBe('array')
+      expect(field.itemField.type).toBe('text')
+      expect(field.minItems).toBe(1)
+      expect(field.maxItems).toBe(10)
+    })
+
+    it('supports complex item types', () => {
+      const field = f.array(
+        f.object(
+          {
+            name: f.text({ label: 'Name' }),
+            url: f.text({ label: 'URL' }),
+          },
+          { label: 'Link' },
+        ),
+        { label: 'Links' },
+      )
+      expect(field.type).toBe('array')
+      expect(field.itemField.type).toBe('object')
+    })
+  })
+
+  describe('f.object()', () => {
+    it('creates an object field', () => {
+      const field = f.object(
+        {
+          street: f.text({ label: 'Street' }),
+          city: f.text({ label: 'City' }),
+          zip: f.text({ label: 'ZIP' }),
+        },
+        { label: 'Address', collapsible: true },
+      )
+      expect(field.type).toBe('object')
+      expect(field.collapsible).toBe(true)
+      expect(Object.keys(field.fields)).toEqual(['street', 'city', 'zip'])
+    })
+  })
+
+  describe('f.override()', () => {
+    it('creates an override field with active flag', () => {
+      const field = f.override(
+        {
+          heading: f.text({ label: 'Heading' }),
+          subtitle: f.text({ label: 'Subtitle', multiline: true }),
+        },
+        { label: 'Hero anpassen' },
+      )
+      expect(field.type).toBe('override')
+      expect(field.defaultValue).toEqual({ active: false })
+      expect(Object.keys(field.fields)).toEqual(['heading', 'subtitle'])
+    })
+  })
+
+  describe('f.color()', () => {
+    it('creates a color field', () => {
+      const field = f.color({
+        label: 'Brand Color',
+        defaultValue: '#a2c617',
+        presets: ['#a2c617', '#333333', '#ffffff'],
+      })
+      expect(field.type).toBe('color')
+      expect(field.defaultValue).toBe('#a2c617')
+      expect(field.presets).toHaveLength(3)
+    })
+  })
+})

package/src/fields/factories.ts

@@ -0,0 +1,166 @@
+import type {
+  ArrayFieldDef,
+  ArrayFieldOptions,
+  BooleanFieldDef,
+  BooleanFieldOptions,
+  ColorFieldDef,
+  ColorFieldOptions,
+  FieldDefinition,
+  FieldRecord,
+  IconFieldDef,
+  IconFieldOptions,
+  ImageFieldDef,
+  ImageFieldOptions,
+  NumberFieldDef,
+  NumberFieldOptions,
+  ObjectFieldDef,
+  ObjectFieldOptions,
+  OverrideFieldDef,
+  OverrideFieldOptions,
+  SelectFieldDef,
+  SelectFieldOptions,
+  TextFieldDef,
+  TextFieldOptions,
+} from './field-definition'
+
+/**
+ * Field factories – the public API for defining content schemas.
+ *
+ * Each factory returns a frozen FieldDefinition object with a discriminated
+ * `type` property. The phantom type parameter carries the runtime value type
+ * through the type system for end-to-end inference.
+ */
+export const f = {
+  text(options: TextFieldOptions): TextFieldDef {
+    return Object.freeze({
+      type: 'text' as const,
+      label: options.label,
+      description: options.description,
+      defaultValue: options.defaultValue ?? '',
+      required: options.required ?? false,
+      multiline: options.multiline ?? false,
+      placeholder: options.placeholder,
+      maxLength: options.maxLength,
+      pattern: options.pattern,
+      formatting: options.formatting ?? false,
+    })
+  },
+
+  number(options: NumberFieldOptions): NumberFieldDef {
+    return Object.freeze({
+      type: 'number' as const,
+      label: options.label,
+      description: options.description,
+      defaultValue: options.defaultValue ?? 0,
+      required: options.required ?? false,
+      min: options.min,
+      max: options.max,
+      step: options.step,
+      slider: options.slider ?? false,
+    })
+  },
+
+  boolean(options: BooleanFieldOptions): BooleanFieldDef {
+    return Object.freeze({
+      type: 'boolean' as const,
+      label: options.label,
+      description: options.description,
+      defaultValue: options.defaultValue ?? false,
+    })
+  },
+
+  select(options: SelectFieldOptions): SelectFieldDef {
+    return Object.freeze({
+      type: 'select' as const,
+      label: options.label,
+      description: options.description,
+      defaultValue: options.defaultValue ?? options.options[0]?.value ?? '',
+      required: options.required ?? false,
+      options: Object.freeze(options.options),
+      multi: options.multi ?? false,
+    })
+  },
+
+  icon(options: IconFieldOptions): IconFieldDef {
+    return Object.freeze({
+      type: 'icon' as const,
+      label: options.label,
+      description: options.description,
+      defaultValue: options.defaultValue ?? '',
+      required: options.required ?? false,
+    })
+  },
+
+  image(options: ImageFieldOptions): ImageFieldDef {
+    return Object.freeze({
+      type: 'image' as const,
+      label: options.label,
+      description: options.description,
+      required: options.required ?? false,
+      directory: options.directory,
+      accept: Object.freeze(options.accept ?? ['webp', 'jpg', 'png']),
+      maxSize: options.maxSize,
+      filenameStrategy: options.filenameStrategy ?? 'original',
+    })
+  },
+
+  array<TItem extends FieldDefinition>(
+    itemField: TItem,
+    options: ArrayFieldOptions,
+  ): ArrayFieldDef<TItem> {
+    return Object.freeze({
+      type: 'array' as const,
+      label: options.label,
+      description: options.description,
+      required: options.required ?? false,
+      itemField,
+      minItems: options.minItems,
+      maxItems: options.maxItems,
+      itemLabel: options.itemLabel,
+    }) as ArrayFieldDef<TItem>
+  },
+
+  object<TFields extends FieldRecord>(
+    fields: TFields,
+    options: ObjectFieldOptions,
+  ): ObjectFieldDef<TFields> {
+    return Object.freeze({
+      type: 'object' as const,
+      label: options.label,
+      description: options.description,
+      required: options.required ?? false,
+      fields,
+      collapsible: options.collapsible ?? false,
+    }) as ObjectFieldDef<TFields>
+  },
+
+  color(options: ColorFieldOptions): ColorFieldDef {
+    return Object.freeze({
+      type: 'color' as const,
+      label: options.label,
+      description: options.description,
+      defaultValue: options.defaultValue ?? '#000000',
+      presets: Object.freeze(options.presets ?? []),
+    })
+  },
+
+  /**
+   * Override field – wraps a set of fields with an "active" checkbox.
+   * When inactive, the override fields are hidden and don't affect output.
+   * This replaces Keystatic's DOM-hack approach with a native schema concept.
+   */
+  override<TFields extends FieldRecord>(
+    fields: TFields,
+    options: OverrideFieldOptions,
+  ): OverrideFieldDef<TFields> {
+    return Object.freeze({
+      type: 'override' as const,
+      label: options.label,
+      description: options.description,
+      defaultValue: { active: false } as { active: boolean } & Partial<
+        Record<keyof TFields, unknown>
+      >,
+      fields,
+    }) as OverrideFieldDef<TFields>
+  },
+} as const

package/src/fields/field-definition.ts

@@ -0,0 +1,215 @@
+import type { z } from 'zod'
+
+// ---------------------------------------------------------------------------
+// Core field definition types
+// ---------------------------------------------------------------------------
+
+/** Discriminator for all field types */
+export type FieldType =
+  | 'text'
+  | 'number'
+  | 'boolean'
+  | 'select'
+  | 'icon'
+  | 'image'
+  | 'array'
+  | 'object'
+  | 'conditional'
+  | 'color'
+  | 'override'
+
+/** Path to a field in a nested schema (e.g. ['items', 0, 'title']) */
+export type FieldPath = ReadonlyArray<string | number>
+
+/**
+ * Base field definition. The phantom type TValue carries the runtime value type
+ * through the type system without ever being assigned at runtime.
+ */
+export interface FieldDefinition<TType extends FieldType = FieldType, TValue = unknown> {
+  readonly type: TType
+  readonly label: string
+  readonly description?: string
+  readonly defaultValue?: TValue
+  readonly required?: boolean
+  readonly _phantom?: TValue // phantom type – never assigned, only for inference
+}
+
+// ---------------------------------------------------------------------------
+// Concrete field option types
+// ---------------------------------------------------------------------------
+
+export interface TextFieldOptions {
+  label: string
+  description?: string
+  defaultValue?: string
+  required?: boolean
+  multiline?: boolean
+  placeholder?: string
+  maxLength?: number
+  pattern?: RegExp
+  /** Enable inline formatting (bold, italic, strike, links). Output is HTML. */
+  formatting?: boolean
+}
+
+export interface TextFieldDef extends FieldDefinition<'text', string> {
+  readonly multiline: boolean
+  readonly placeholder?: string
+  readonly maxLength?: number
+  readonly pattern?: RegExp
+  readonly formatting: boolean
+}
+
+export interface NumberFieldOptions {
+  label: string
+  description?: string
+  defaultValue?: number
+  required?: boolean
+  min?: number
+  max?: number
+  step?: number
+  slider?: boolean
+}
+
+export interface NumberFieldDef extends FieldDefinition<'number', number> {
+  readonly min?: number
+  readonly max?: number
+  readonly step?: number
+  readonly slider: boolean
+}
+
+export interface BooleanFieldOptions {
+  label: string
+  description?: string
+  defaultValue?: boolean
+}
+
+export interface BooleanFieldDef extends FieldDefinition<'boolean', boolean> {}
+
+export interface SelectOption {
+  readonly label: string
+  readonly value: string
+  readonly icon?: string
+}
+
+export interface SelectFieldOptions {
+  label: string
+  description?: string
+  defaultValue?: string
+  required?: boolean
+  options: readonly SelectOption[]
+  multi?: boolean
+}
+
+export interface SelectFieldDef extends FieldDefinition<'select', string> {
+  readonly options: readonly SelectOption[]
+  readonly multi: boolean
+}
+
+export interface IconFieldOptions {
+  label: string
+  description?: string
+  defaultValue?: string
+  required?: boolean
+}
+
+export interface IconFieldDef extends FieldDefinition<'icon', string> {}
+
+export interface ImageFieldOptions {
+  label: string
+  description?: string
+  required?: boolean
+  directory: string
+  accept?: readonly string[]
+  maxSize?: string
+  filenameStrategy?: 'original' | 'slugified' | 'custom'
+}
+
+export interface ImageValue {
+  readonly path: string
+  readonly alt?: string
+}
+
+export interface ImageFieldDef extends FieldDefinition<'image', ImageValue> {
+  readonly directory: string
+  readonly accept: readonly string[]
+  readonly maxSize?: string
+  readonly filenameStrategy: 'original' | 'slugified' | 'custom'
+}
+
+export interface ArrayFieldOptions {
+  label: string
+  description?: string
+  required?: boolean
+  minItems?: number
+  maxItems?: number
+  itemLabel?: (item: unknown, index: number) => string
+}
+
+export interface ArrayFieldDef<TItem extends FieldDefinition = FieldDefinition>
+  extends FieldDefinition<'array', InferFieldValue<TItem>[]> {
+  readonly itemField: TItem
+  readonly minItems?: number
+  readonly maxItems?: number
+  readonly itemLabel?: (item: unknown, index: number) => string
+}
+
+export interface ObjectFieldOptions {
+  label: string
+  description?: string
+  required?: boolean
+  collapsible?: boolean
+}
+
+export type FieldRecord = Record<string, FieldDefinition>
+
+export interface ObjectFieldDef<TFields extends FieldRecord = FieldRecord>
+  extends FieldDefinition<'object', InferSchemaValues<TFields>> {
+  readonly fields: TFields
+  readonly collapsible: boolean
+}
+
+export interface ColorFieldOptions {
+  label: string
+  description?: string
+  defaultValue?: string
+  presets?: readonly string[]
+}
+
+export interface ColorFieldDef extends FieldDefinition<'color', string> {
+  readonly presets: readonly string[]
+}
+
+export interface OverrideFieldOptions {
+  label: string
+  description?: string
+}
+
+export interface OverrideFieldDef<TFields extends FieldRecord = FieldRecord>
+  extends FieldDefinition<'override', { active: boolean } & Partial<InferSchemaValues<TFields>>> {
+  readonly fields: TFields
+}
+
+// ---------------------------------------------------------------------------
+// Type inference utilities
+// ---------------------------------------------------------------------------
+
+/** Extract the runtime value type from a FieldDefinition */
+export type InferFieldValue<F> = F extends FieldDefinition<infer _T, infer V> ? V : never
+
+/** Infer all values from a schema record */
+export type InferSchemaValues<S extends FieldRecord> = {
+  [K in keyof S]: InferFieldValue<S[K]>
+}
+
+/** Union of all concrete field definitions */
+export type AnyFieldDef =
+  | TextFieldDef
+  | NumberFieldDef
+  | BooleanFieldDef
+  | SelectFieldDef
+  | IconFieldDef
+  | ImageFieldDef
+  | ArrayFieldDef
+  | ObjectFieldDef
+  | ColorFieldDef
+  | OverrideFieldDef