@setzkasten-cms/core 0.4.2

package/dist/index.js

@@ -0,0 +1,314 @@
+import {
+  defineCollection,
+  defineConfig,
+  defineSection,
+  f
+} from "./chunk-IL2PWN4R.js";
+
+// src/validation/schema-to-zod.ts
+import { z } from "zod";
+function fieldToZod(field) {
+  switch (field.type) {
+    case "text":
+      return textToZod(field);
+    case "number":
+      return numberToZod(field);
+    case "boolean":
+      return z.boolean();
+    case "select":
+      return selectToZod(field);
+    case "icon":
+      return field.required ? z.string().min(1, `${field.label} ist erforderlich`) : z.string();
+    case "image":
+      return imageToZod(field);
+    case "array":
+      return arrayToZod(field);
+    case "object":
+      return objectToZod(field);
+    case "color":
+      return z.string().regex(/^#[0-9a-fA-F]{6}$/, "Invalid hex color");
+    case "override":
+      return overrideToZod(field);
+    default:
+      return z.unknown();
+  }
+}
+function textToZod(field) {
+  let schema = z.string();
+  if (field.required) {
+    schema = schema.min(1, `${field.label} ist erforderlich`);
+  }
+  if (field.maxLength) {
+    schema = schema.max(field.maxLength, `${field.label} darf max. ${field.maxLength} Zeichen haben`);
+  }
+  if (field.pattern) {
+    schema = schema.regex(field.pattern, `${field.label} hat ein ung\xFCltiges Format`);
+  }
+  return schema;
+}
+function numberToZod(field) {
+  let schema = z.number();
+  if (field.min !== void 0) {
+    schema = schema.min(field.min);
+  }
+  if (field.max !== void 0) {
+    schema = schema.max(field.max);
+  }
+  return schema;
+}
+function selectToZod(field) {
+  const values = field.options.map((o) => o.value);
+  if (values.length === 0) return z.string();
+  const [first, ...rest] = values;
+  return z.enum([first, ...rest]);
+}
+function imageToZod(field) {
+  const schema = z.object({
+    path: z.string(),
+    alt: z.string().optional()
+  });
+  return field.required ? schema.refine((v) => v.path.length > 0, `${field.label} ist erforderlich`) : schema;
+}
+function arrayToZod(field) {
+  const itemSchema = fieldToZod(field.itemField);
+  let schema = z.array(itemSchema);
+  if (field.minItems !== void 0) {
+    schema = schema.min(field.minItems);
+  }
+  if (field.maxItems !== void 0) {
+    schema = schema.max(field.maxItems);
+  }
+  return schema;
+}
+function objectToZod(field) {
+  return schemaToZod(field.fields);
+}
+function overrideToZod(field) {
+  const innerSchema = schemaToZod(field.fields);
+  return z.object({
+    active: z.boolean()
+  }).and(innerSchema.partial());
+}
+function schemaToZod(fields) {
+  const shape = {};
+  for (const [key, field] of Object.entries(fields)) {
+    const zodField = fieldToZod(field);
+    shape[key] = field.required ? zodField : zodField.optional();
+  }
+  return z.object(shape);
+}
+
+// src/serialization/serializer.ts
+function serializeEntry(fields, values, registry) {
+  const result = {};
+  for (const [key, field] of Object.entries(fields)) {
+    const serializer = registry[field.type];
+    const value = values[key];
+    if (serializer && value !== void 0) {
+      result[key] = serializer.serialize(value);
+    } else if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function deserializeEntry(fields, raw, registry) {
+  const result = {};
+  for (const [key, field] of Object.entries(fields)) {
+    const serializer = registry[field.type];
+    const rawValue = raw[key];
+    if (serializer && rawValue !== void 0) {
+      result[key] = serializer.deserialize(rawValue);
+    } else if (rawValue !== void 0) {
+      result[key] = rawValue;
+    } else if (field.defaultValue !== void 0) {
+      result[key] = field.defaultValue;
+    }
+  }
+  return result;
+}
+
+// src/serialization/json-serializer.ts
+var textSerializer = {
+  serialize: (value) => value,
+  deserialize: (raw) => typeof raw === "string" ? raw : String(raw ?? "")
+};
+var numberSerializer = {
+  serialize: (value) => value,
+  deserialize: (raw) => typeof raw === "number" ? raw : Number(raw ?? 0)
+};
+var booleanSerializer = {
+  serialize: (value) => value,
+  deserialize: (raw) => Boolean(raw)
+};
+var selectSerializer = {
+  serialize: (value) => value,
+  deserialize: (raw) => String(raw ?? "")
+};
+var imageSerializer = {
+  serialize: (value) => {
+    if (typeof value === "string") return value;
+    if (value && typeof value === "object" && "path" in value) {
+      return value.path;
+    }
+    return "";
+  },
+  deserialize: (raw) => {
+    if (typeof raw === "string") return { path: raw, alt: "" };
+    if (raw && typeof raw === "object" && "path" in raw) return raw;
+    return { path: "", alt: "" };
+  }
+};
+var colorSerializer = {
+  serialize: (value) => value,
+  deserialize: (raw) => String(raw ?? "#000000")
+};
+var jsonSerializerRegistry = {
+  text: textSerializer,
+  number: numberSerializer,
+  boolean: booleanSerializer,
+  select: selectSerializer,
+  image: imageSerializer,
+  color: colorSerializer,
+  // array, object, override are handled recursively by serializeEntry/deserializeEntry
+  array: {
+    serialize: (value) => Array.isArray(value) ? value : [],
+    deserialize: (raw) => Array.isArray(raw) ? raw : []
+  },
+  object: {
+    serialize: (value) => value && typeof value === "object" ? value : {},
+    deserialize: (raw) => raw && typeof raw === "object" ? raw : {}
+  },
+  override: {
+    serialize: (value) => {
+      if (value && typeof value === "object") return value;
+      return { active: false };
+    },
+    deserialize: (raw) => {
+      if (raw && typeof raw === "object") return raw;
+      return { active: false };
+    }
+  }
+};
+
+// src/commands/command.ts
+function createCommandHistory() {
+  const undoStack = [];
+  const redoStack = [];
+  return {
+    execute(command) {
+      command.execute();
+      undoStack.push(command);
+      redoStack.length = 0;
+    },
+    undo() {
+      const command = undoStack.pop();
+      if (command) {
+        command.undo();
+        redoStack.push(command);
+      }
+    },
+    redo() {
+      const command = redoStack.pop();
+      if (command) {
+        command.execute();
+        undoStack.push(command);
+      }
+    },
+    canUndo() {
+      return undoStack.length > 0;
+    },
+    canRedo() {
+      return redoStack.length > 0;
+    },
+    clear() {
+      undoStack.length = 0;
+      redoStack.length = 0;
+    }
+  };
+}
+
+// src/events/content-event-bus.ts
+function createEventBus() {
+  const listeners = /* @__PURE__ */ new Map();
+  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, /* @__PURE__ */ new Set());
+      }
+      const handlers = listeners.get(type);
+      handlers.add(handler);
+      return () => {
+        handlers.delete(handler);
+        if (handlers.size === 0) {
+          listeners.delete(type);
+        }
+      };
+    }
+  };
+}
+
+// src/errors/errors.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+function validationError(fieldPath, rule, message) {
+  return { type: "validation", fieldPath, rule, message, timestamp: Date.now() };
+}
+function conflictError(message) {
+  return { type: "conflict", message, timestamp: Date.now() };
+}
+function rateLimitError(retryAfter, remaining) {
+  return {
+    type: "rate-limit",
+    retryAfter,
+    remaining,
+    message: `Rate limit exceeded. Retry after ${retryAfter}s`,
+    timestamp: Date.now()
+  };
+}
+function authError(message) {
+  return { type: "auth", message, timestamp: Date.now() };
+}
+function networkError(message, cause) {
+  return { type: "network", message, cause, timestamp: Date.now() };
+}
+function notFoundError(path) {
+  return { type: "not-found", path, message: `Not found: ${path}`, timestamp: Date.now() };
+}
+function serializationError(message, path) {
+  return { type: "serialization", message, path, timestamp: Date.now() };
+}
+export {
+  authError,
+  conflictError,
+  createCommandHistory,
+  createEventBus,
+  defineCollection,
+  defineConfig,
+  defineSection,
+  deserializeEntry,
+  err,
+  f,
+  fieldToZod,
+  jsonSerializerRegistry,
+  networkError,
+  notFoundError,
+  ok,
+  rateLimitError,
+  schemaToZod,
+  serializationError,
+  serializeEntry,
+  validationError
+};

package/dist/testing.d.ts

@@ -0,0 +1,28 @@
+import { y as SetzKastenConfig } from './define-config-bJ65Zaui.js';
+
+/**
+ * @setzkasten-cms/core/testing – Test utilities for other packages
+ */
+/**
+ * Creates a minimal test config for use in tests.
+ */
+declare function createTestConfig(): SetzKastenConfig;
+/**
+ * Creates sample content data matching the test config schema.
+ */
+declare function createTestContent(): {
+    hero: {
+        heading: string;
+        subtitle: string;
+        badge: string;
+    };
+    benefits: {
+        items: {
+            title: string;
+            description: string;
+            icon: string;
+        }[];
+    };
+};
+
+export { createTestConfig, createTestContent };

package/dist/testing.js

@@ -0,0 +1,69 @@
+import {
+  defineConfig,
+  defineSection,
+  f
+} from "./chunk-IL2PWN4R.js";
+
+// src/testing/index.ts
+function createTestConfig() {
+  return defineConfig({
+    storage: { kind: "local" },
+    auth: { providers: ["email"] },
+    products: {
+      test: {
+        label: "Test Product",
+        sections: {
+          hero: defineSection({
+            label: "Hero",
+            fields: {
+              heading: f.text({ label: "Heading", required: true }),
+              subtitle: f.text({ label: "Subtitle", multiline: true }),
+              badge: f.text({ label: "Badge" })
+            }
+          }),
+          benefits: defineSection({
+            label: "Benefits",
+            fields: {
+              items: f.array(
+                f.object(
+                  {
+                    title: f.text({ label: "Title" }),
+                    description: f.text({ label: "Description", multiline: true }),
+                    icon: f.select({
+                      label: "Icon",
+                      options: [
+                        { label: "Check", value: "check" },
+                        { label: "Star", value: "star" }
+                      ]
+                    })
+                  },
+                  { label: "Benefit" }
+                ),
+                { label: "Benefits", minItems: 1 }
+              )
+            }
+          })
+        }
+      }
+    }
+  });
+}
+function createTestContent() {
+  return {
+    hero: {
+      heading: "Test Heading",
+      subtitle: "Test Subtitle",
+      badge: "New"
+    },
+    benefits: {
+      items: [
+        { title: "Benefit 1", description: "Description 1", icon: "check" },
+        { title: "Benefit 2", description: "Description 2", icon: "star" }
+      ]
+    }
+  };
+}
+export {
+  createTestConfig,
+  createTestContent
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@setzkasten-cms/core",
+  "version": "0.4.2",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "types": "./src/index.ts"
+    },
+    "./testing": {
+      "import": "./src/testing.ts",
+      "types": "./src/testing.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "immer": "^10.2.0",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/commands/command.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, it } from 'vitest'
+import type { Command } from './command'
+import { createCommandHistory } from './command'
+
+function createTestCommand(state: { value: string }, newValue: string): Command {
+  const previousValue = state.value
+  return {
+    execute() {
+      state.value = newValue
+    },
+    undo() {
+      state.value = previousValue
+    },
+    describe() {
+      return `Set value to "${newValue}"`
+    },
+  }
+}
+
+describe('CommandHistory', () => {
+  it('executes commands', () => {
+    const history = createCommandHistory()
+    const state = { value: 'initial' }
+
+    history.execute(createTestCommand(state, 'updated'))
+    expect(state.value).toBe('updated')
+  })
+
+  it('undoes commands', () => {
+    const history = createCommandHistory()
+    const state = { value: 'initial' }
+
+    history.execute(createTestCommand(state, 'updated'))
+    history.undo()
+    expect(state.value).toBe('initial')
+  })
+
+  it('redoes commands', () => {
+    const history = createCommandHistory()
+    const state = { value: 'initial' }
+
+    history.execute(createTestCommand(state, 'updated'))
+    history.undo()
+    history.redo()
+    expect(state.value).toBe('updated')
+  })
+
+  it('clears redo stack on new command', () => {
+    const history = createCommandHistory()
+    const state = { value: 'initial' }
+
+    history.execute(createTestCommand(state, 'first'))
+    history.undo()
+    expect(history.canRedo()).toBe(true)
+
+    history.execute(createTestCommand(state, 'second'))
+    expect(history.canRedo()).toBe(false)
+  })
+
+  it('reports canUndo/canRedo correctly', () => {
+    const history = createCommandHistory()
+    const state = { value: 'initial' }
+
+    expect(history.canUndo()).toBe(false)
+    expect(history.canRedo()).toBe(false)
+
+    history.execute(createTestCommand(state, 'updated'))
+    expect(history.canUndo()).toBe(true)
+    expect(history.canRedo()).toBe(false)
+
+    history.undo()
+    expect(history.canUndo()).toBe(false)
+    expect(history.canRedo()).toBe(true)
+  })
+
+  it('clears history', () => {
+    const history = createCommandHistory()
+    const state = { value: 'initial' }
+
+    history.execute(createTestCommand(state, 'updated'))
+    history.clear()
+    expect(history.canUndo()).toBe(false)
+    expect(history.canRedo()).toBe(false)
+  })
+})

package/src/commands/command.ts

@@ -0,0 +1,65 @@
+import type { FieldPath } from '../fields/field-definition'
+
+/**
+ * Command pattern – all mutations go through commands.
+ * This gives undo/redo for free.
+ */
+export interface Command {
+  execute(): void
+  undo(): void
+  describe(): string
+}
+
+/**
+ * Command history – manages undo/redo stacks.
+ */
+export interface CommandHistory {
+  execute(command: Command): void
+  undo(): void
+  redo(): void
+  canUndo(): boolean
+  canRedo(): boolean
+  clear(): void
+}
+
+export function createCommandHistory(): CommandHistory {
+  const undoStack: Command[] = []
+  const redoStack: Command[] = []
+
+  return {
+    execute(command) {
+      command.execute()
+      undoStack.push(command)
+      redoStack.length = 0 // clear redo stack on new action
+    },
+
+    undo() {
+      const command = undoStack.pop()
+      if (command) {
+        command.undo()
+        redoStack.push(command)
+      }
+    },
+
+    redo() {
+      const command = redoStack.pop()
+      if (command) {
+        command.execute()
+        undoStack.push(command)
+      }
+    },
+
+    canUndo() {
+      return undoStack.length > 0
+    },
+
+    canRedo() {
+      return redoStack.length > 0
+    },
+
+    clear() {
+      undoStack.length = 0
+      redoStack.length = 0
+    },
+  }
+}

package/src/errors/errors.ts

@@ -0,0 +1,112 @@
+import type { FieldPath } from '../fields/field-definition'
+
+// ---------------------------------------------------------------------------
+// Discriminated error union
+// ---------------------------------------------------------------------------
+
+export type SetzKastenError =
+  | ValidationError
+  | ConflictError
+  | RateLimitError
+  | AuthError
+  | NetworkError
+  | NotFoundError
+  | SerializationError
+
+interface BaseError {
+  readonly message: string
+  readonly cause?: unknown
+  readonly timestamp: number
+}
+
+export interface ValidationError extends BaseError {
+  readonly type: 'validation'
+  readonly fieldPath: FieldPath
+  readonly rule: string
+}
+
+export interface ConflictError extends BaseError {
+  readonly type: 'conflict'
+}
+
+export interface RateLimitError extends BaseError {
+  readonly type: 'rate-limit'
+  readonly retryAfter: number
+  readonly remaining: number
+}
+
+export interface AuthError extends BaseError {
+  readonly type: 'auth'
+}
+
+export interface NetworkError extends BaseError {
+  readonly type: 'network'
+}
+
+export interface NotFoundError extends BaseError {
+  readonly type: 'not-found'
+  readonly path: string
+}
+
+export interface SerializationError extends BaseError {
+  readonly type: 'serialization'
+  readonly path?: string
+}
+
+// ---------------------------------------------------------------------------
+// Result type for predictable errors
+// ---------------------------------------------------------------------------
+
+export type Result<T, E = SetzKastenError> =
+  | { readonly ok: true; readonly value: T }
+  | { readonly ok: false; readonly error: E }
+
+export function ok<T>(value: T): Result<T, never> {
+  return { ok: true, value }
+}
+
+export function err<E>(error: E): Result<never, E> {
+  return { ok: false, error }
+}
+
+// ---------------------------------------------------------------------------
+// Error factories
+// ---------------------------------------------------------------------------
+
+export function validationError(
+  fieldPath: FieldPath,
+  rule: string,
+  message: string,
+): ValidationError {
+  return { type: 'validation', fieldPath, rule, message, timestamp: Date.now() }
+}
+
+export function conflictError(message: string): ConflictError {
+  return { type: 'conflict', message, timestamp: Date.now() }
+}
+
+export function rateLimitError(retryAfter: number, remaining: number): RateLimitError {
+  return {
+    type: 'rate-limit',
+    retryAfter,
+    remaining,
+    message: `Rate limit exceeded. Retry after ${retryAfter}s`,
+    timestamp: Date.now(),
+  }
+}
+
+export function authError(message: string): AuthError {
+  return { type: 'auth', message, timestamp: Date.now() }
+}
+
+export function networkError(message: string, cause?: unknown): NetworkError {
+  return { type: 'network', message, cause, timestamp: Date.now() }
+}
+
+export function notFoundError(path: string): NotFoundError {
+  return { type: 'not-found', path, message: `Not found: ${path}`, timestamp: Date.now() }
+}
+
+export function serializationError(message: string, path?: string): SerializationError {
+  return { type: 'serialization', message, path, timestamp: Date.now() }
+}