@liasse/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,473 @@
+import { z } from 'zod';
+
+/**
+ * zod is the source of truth: every model type is inferred from a schema here,
+ * and the same schemas validate API payloads later. Nothing in this file may
+ * import an office library — the model is format-agnostic by construction.
+ */
+/** How a scalar value should be presented by an adapter. */
+declare const ValueFormatSchema: z.ZodEnum<["text", "number", "currency", "percent", "date"]>;
+type ValueFormat = z.infer<typeof ValueFormatSchema>;
+declare const AlignSchema: z.ZodEnum<["left", "center", "right"]>;
+type Align = z.infer<typeof AlignSchema>;
+/** A buffer (Node/browser binary) or a string source (url / data-uri / path). */
+declare const BinaryOrUrlSchema: z.ZodType<Uint8Array | string>;
+declare const HeadingBlockSchema: z.ZodObject<{
+    type: z.ZodLiteral<"heading">;
+    text: z.ZodString;
+    level: z.ZodUnion<[z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    type: "heading";
+    level: 1 | 2 | 3;
+}, {
+    text: string;
+    type: "heading";
+    level: 1 | 2 | 3;
+}>;
+type HeadingBlock = z.infer<typeof HeadingBlockSchema>;
+declare const ParagraphBlockSchema: z.ZodObject<{
+    type: z.ZodLiteral<"paragraph">;
+    text: z.ZodString;
+    emphasis: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    type: "paragraph";
+    emphasis?: boolean | undefined;
+}, {
+    text: string;
+    type: "paragraph";
+    emphasis?: boolean | undefined;
+}>;
+type ParagraphBlock = z.infer<typeof ParagraphBlockSchema>;
+declare const TableColumnSchema: z.ZodObject<{
+    key: z.ZodString;
+    header: z.ZodString;
+    format: z.ZodOptional<z.ZodEnum<["text", "number", "currency", "percent", "date"]>>;
+    align: z.ZodOptional<z.ZodEnum<["left", "center", "right"]>>;
+    /** Optional explicit column width (character units). */
+    width: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    header: string;
+    format?: "number" | "text" | "currency" | "percent" | "date" | undefined;
+    align?: "left" | "center" | "right" | undefined;
+    width?: number | undefined;
+}, {
+    key: string;
+    header: string;
+    format?: "number" | "text" | "currency" | "percent" | "date" | undefined;
+    align?: "left" | "center" | "right" | undefined;
+    width?: number | undefined;
+}>;
+type TableColumn = z.infer<typeof TableColumnSchema>;
+declare const SummarySchema: z.ZodRecord<z.ZodString, z.ZodEnum<["sum", "avg", "count"]>>;
+type Summary = z.infer<typeof SummarySchema>;
+declare const ConditionalSchema: z.ZodObject<{
+    column: z.ZodString;
+    rule: z.ZodLiteral<"positiveNegative">;
+}, "strip", z.ZodTypeAny, {
+    column: string;
+    rule: "positiveNegative";
+}, {
+    column: string;
+    rule: "positiveNegative";
+}>;
+type Conditional = z.infer<typeof ConditionalSchema>;
+declare const TableBlockSchema: z.ZodObject<{
+    type: z.ZodLiteral<"table">;
+    columns: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        header: z.ZodString;
+        format: z.ZodOptional<z.ZodEnum<["text", "number", "currency", "percent", "date"]>>;
+        align: z.ZodOptional<z.ZodEnum<["left", "center", "right"]>>;
+        /** Optional explicit column width (character units). */
+        width: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        header: string;
+        format?: "number" | "text" | "currency" | "percent" | "date" | undefined;
+        align?: "left" | "center" | "right" | undefined;
+        width?: number | undefined;
+    }, {
+        key: string;
+        header: string;
+        format?: "number" | "text" | "currency" | "percent" | "date" | undefined;
+        align?: "left" | "center" | "right" | undefined;
+        width?: number | undefined;
+    }>, "many">;
+    rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+    /** Per-column aggregate → emits a summary row with real formulas. */
+    summary: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<["sum", "avg", "count"]>>>;
+    /** Colour cues, e.g. positive in green / negative in red. */
+    conditional: z.ZodOptional<z.ZodObject<{
+        column: z.ZodString;
+        rule: z.ZodLiteral<"positiveNegative">;
+    }, "strip", z.ZodTypeAny, {
+        column: string;
+        rule: "positiveNegative";
+    }, {
+        column: string;
+        rule: "positiveNegative";
+    }>>;
+    /** Format-specific escape hatch, read only by the xlsx adapter. */
+    xlsx: z.ZodOptional<z.ZodObject<{
+        freezeHeader: z.ZodOptional<z.ZodBoolean>;
+        sheetName: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        freezeHeader?: boolean | undefined;
+        sheetName?: string | undefined;
+    }, {
+        freezeHeader?: boolean | undefined;
+        sheetName?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: "table";
+    columns: {
+        key: string;
+        header: string;
+        format?: "number" | "text" | "currency" | "percent" | "date" | undefined;
+        align?: "left" | "center" | "right" | undefined;
+        width?: number | undefined;
+    }[];
+    rows: Record<string, unknown>[];
+    summary?: Record<string, "sum" | "avg" | "count"> | undefined;
+    conditional?: {
+        column: string;
+        rule: "positiveNegative";
+    } | undefined;
+    xlsx?: {
+        freezeHeader?: boolean | undefined;
+        sheetName?: string | undefined;
+    } | undefined;
+}, {
+    type: "table";
+    columns: {
+        key: string;
+        header: string;
+        format?: "number" | "text" | "currency" | "percent" | "date" | undefined;
+        align?: "left" | "center" | "right" | undefined;
+        width?: number | undefined;
+    }[];
+    rows: Record<string, unknown>[];
+    summary?: Record<string, "sum" | "avg" | "count"> | undefined;
+    conditional?: {
+        column: string;
+        rule: "positiveNegative";
+    } | undefined;
+    xlsx?: {
+        freezeHeader?: boolean | undefined;
+        sheetName?: string | undefined;
+    } | undefined;
+}>;
+type TableBlock = z.infer<typeof TableBlockSchema>;
+declare const KeyValueBlockSchema: z.ZodObject<{
+    type: z.ZodLiteral<"keyValue">;
+    items: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+        format: z.ZodOptional<z.ZodEnum<["text", "number", "currency", "percent", "date"]>>;
+    }, "strip", z.ZodTypeAny, {
+        value: string | number | boolean | null;
+        label: string;
+        format?: "number" | "text" | "currency" | "percent" | "date" | undefined;
+    }, {
+        value: string | number | boolean | null;
+        label: string;
+        format?: "number" | "text" | "currency" | "percent" | "date" | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "keyValue";
+    items: {
+        value: string | number | boolean | null;
+        label: string;
+        format?: "number" | "text" | "currency" | "percent" | "date" | undefined;
+    }[];
+}, {
+    type: "keyValue";
+    items: {
+        value: string | number | boolean | null;
+        label: string;
+        format?: "number" | "text" | "currency" | "percent" | "date" | undefined;
+    }[];
+}>;
+type KeyValueBlock = z.infer<typeof KeyValueBlockSchema>;
+declare const ChartBlockSchema: z.ZodObject<{
+    type: z.ZodLiteral<"chart">;
+    chartType: z.ZodEnum<["bar", "line", "pie"]>;
+    data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+    /** Key used for the category axis. */
+    x: z.ZodString;
+    /** One or more series keys for the value axis. */
+    y: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    title: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "chart";
+    chartType: "bar" | "line" | "pie";
+    data: Record<string, unknown>[];
+    x: string;
+    y: string | string[];
+    title?: string | undefined;
+}, {
+    type: "chart";
+    chartType: "bar" | "line" | "pie";
+    data: Record<string, unknown>[];
+    x: string;
+    y: string | string[];
+    title?: string | undefined;
+}>;
+type ChartBlock = z.infer<typeof ChartBlockSchema>;
+declare const ImageBlockSchema: z.ZodObject<{
+    type: z.ZodLiteral<"image">;
+    src: z.ZodType<string | Uint8Array<ArrayBufferLike>, z.ZodTypeDef, string | Uint8Array<ArrayBufferLike>>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    alt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "image";
+    src: string | Uint8Array<ArrayBufferLike>;
+    width?: number | undefined;
+    height?: number | undefined;
+    alt?: string | undefined;
+}, {
+    type: "image";
+    src: string | Uint8Array<ArrayBufferLike>;
+    width?: number | undefined;
+    height?: number | undefined;
+    alt?: string | undefined;
+}>;
+type ImageBlock = z.infer<typeof ImageBlockSchema>;
+declare const SpacerBlockSchema: z.ZodObject<{
+    type: z.ZodLiteral<"spacer">;
+    /** Number of blank rows / units to advance. The `spacer()` helper defaults to 1. */
+    size: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "spacer";
+    size: number;
+}, {
+    type: "spacer";
+    size: number;
+}>;
+type SpacerBlock = z.infer<typeof SpacerBlockSchema>;
+declare const PageBreakBlockSchema: z.ZodObject<{
+    type: z.ZodLiteral<"pageBreak">;
+}, "strip", z.ZodTypeAny, {
+    type: "pageBreak";
+}, {
+    type: "pageBreak";
+}>;
+type PageBreakBlock = z.infer<typeof PageBreakBlockSchema>;
+/**
+ * `Block` and `SectionBlock` are mutually recursive (a section contains blocks).
+ * zod cannot infer recursive types, so we declare the TS types by hand and
+ * annotate the lazy schemas with `z.ZodType<...>`.
+ */
+interface SectionBlock {
+    type: "section";
+    title?: string;
+    blocks: Block[];
+    /** When true, the adapter renders this section onto its own sheet/page. */
+    sheet?: boolean;
+}
+type Block = HeadingBlock | ParagraphBlock | TableBlock | KeyValueBlock | SectionBlock | ChartBlock | ImageBlock | SpacerBlock | PageBreakBlock;
+declare const SectionBlockSchema: z.ZodType<SectionBlock>;
+declare const BlockSchema: z.ZodType<Block>;
+declare const DocumentMetaSchema: z.ZodObject<{
+    title: z.ZodString;
+    author: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    author?: string | undefined;
+    subject?: string | undefined;
+}, {
+    title: string;
+    author?: string | undefined;
+    subject?: string | undefined;
+}>;
+type DocumentMeta = z.infer<typeof DocumentMetaSchema>;
+declare const DocumentSchema: z.ZodObject<{
+    meta: z.ZodObject<{
+        title: z.ZodString;
+        author: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        author?: string | undefined;
+        subject?: string | undefined;
+    }, {
+        title: string;
+        author?: string | undefined;
+        subject?: string | undefined;
+    }>;
+    blocks: z.ZodArray<z.ZodType<Block, z.ZodTypeDef, Block>, "many">;
+}, "strip", z.ZodTypeAny, {
+    blocks: Block[];
+    meta: {
+        title: string;
+        author?: string | undefined;
+        subject?: string | undefined;
+    };
+}, {
+    blocks: Block[];
+    meta: {
+        title: string;
+        author?: string | undefined;
+        subject?: string | undefined;
+    };
+}>;
+type Document = z.infer<typeof DocumentSchema>;
+
+/**
+ * The theme is a plain, JSON-serialisable typed object. Components and adapters
+ * must only ever read tokens from here — never hard-code a colour, font or size.
+ * The xlsx adapter translates each token into an exceljs style primitive.
+ */
+interface Theme {
+    palette: {
+        primary: string;
+        accent: string;
+        neutral: {
+            fg: string;
+            muted: string;
+            border: string;
+            bg: string;
+        };
+        semantic: {
+            positive: string;
+            negative: string;
+        };
+    };
+    typography: {
+        fontFamily: string;
+        baseSize: number;
+        /** Sizes for heading levels 1, 2 and 3. */
+        headingSizes: [number, number, number];
+    };
+    table: {
+        headerFill: string;
+        headerFg: string;
+        banding: boolean;
+        borderColor: string;
+    };
+    /** Base spacing unit. */
+    spacing: number;
+    brand?: {
+        logo?: Uint8Array;
+        headerText?: string;
+        footerText?: string;
+    };
+    /** Mostly for flow formats later (PDF/DOCX). */
+    page?: {
+        orientation?: "portrait" | "landscape";
+    };
+}
+/**
+ * The one shipped theme: an "ink on paper" editorial look that matches the
+ * Liasse brand (deep ink blue, warm paper neutrals, sober finance semantics).
+ */
+declare const defaultTheme: Theme;
+/**
+ * Shallow-ish merge to derive a theme from {@link defaultTheme}. Nested token
+ * groups are merged one level deep so callers can override just a few tokens.
+ */
+declare function defineTheme(overrides?: DeepPartial<Theme>): Theme;
+type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends string | number | boolean | Uint8Array | readonly unknown[] ? T[K] : T[K] extends object ? DeepPartial<T[K]> : T[K];
+};
+
+/**
+ * The builder DSL. Each helper returns a plain block object so components read
+ * declaratively. `defineDocument` is the only function that validates — build
+ * the tree freely, then validate once at the boundary.
+ */
+/** Validate raw input against the document schema; throws on bad input. */
+declare function defineDocument(input: {
+    meta: Document["meta"];
+    blocks: Block[];
+}): Document;
+declare function heading(text: string, opts?: {
+    level?: HeadingBlock["level"];
+}): HeadingBlock;
+declare function paragraph(text: string, opts?: {
+    emphasis?: boolean;
+}): ParagraphBlock;
+declare function table(input: {
+    columns: TableColumn[];
+    rows: Record<string, unknown>[];
+    summary?: TableBlock["summary"];
+    conditional?: TableBlock["conditional"];
+    xlsx?: TableBlock["xlsx"];
+}): TableBlock;
+declare function keyValue(items: KeyValueBlock["items"]): KeyValueBlock;
+declare function kv(label: string, value: KeyValueBlock["items"][number]["value"], format?: ValueFormat): KeyValueBlock["items"][number];
+declare function section(input: {
+    title?: string;
+    blocks: Block[];
+    sheet?: boolean;
+}): SectionBlock;
+declare function chart(input: {
+    chartType: ChartBlock["chartType"];
+    data: Record<string, unknown>[];
+    x: string;
+    y: string | string[];
+    title?: string;
+}): ChartBlock;
+declare function image(input: {
+    src: Uint8Array | string;
+    width?: number;
+    height?: number;
+    alt?: string;
+}): ImageBlock;
+declare function spacer(size?: number): Block;
+declare function pageBreak(): Block;
+
+type RenderFormat = "xlsx" | "pptx" | "docx" | "pdf";
+/**
+ * A renderer turns a {@link Document} + {@link Theme} into output bytes.
+ * Adapters live in their own packages (e.g. `@liasse/xlsx`) and must not leak
+ * format-specific types back into core.
+ *
+ * Renderers return a `Uint8Array` (Node `Buffer` is a `Uint8Array`); the caller
+ * decides what to do with the bytes — packages never touch `fs`.
+ */
+interface Renderer {
+    readonly format: RenderFormat;
+    render(doc: Document, theme: Theme): Promise<Uint8Array>;
+}
+/** Register (or replace) the renderer for a format. Called by adapter packages. */
+declare function registerRenderer(renderer: Renderer): void;
+/** Look up a previously registered renderer, if any. */
+declare function getRenderer(format: RenderFormat): Renderer | undefined;
+interface RenderOptions {
+    format: RenderFormat;
+    theme?: Theme;
+}
+/**
+ * Thin dispatcher: pick the registered renderer for `format` and run it.
+ * For the MVP only the `xlsx` renderer is registered (import `@liasse/xlsx`).
+ */
+declare function render(doc: Document, options: RenderOptions): Promise<Uint8Array>;
+
+/**
+ * Typed error classes for Liasse. Catch these to distinguish a malformed
+ * document (validation) from a failure while producing the output bytes (render).
+ */
+/** Thrown by {@link defineDocument} (and other validators) on invalid input. */
+declare class LiasseValidationError extends Error {
+    /** Flat list of `path: message` issues, derived from the zod error. */
+    readonly issues: {
+        path: string;
+        message: string;
+    }[];
+    constructor(message: string, issues?: {
+        path: string;
+        message: string;
+    }[]);
+}
+/** Thrown by a {@link Renderer} (or the `render` dispatcher) when output fails. */
+declare class LiasseRenderError extends Error {
+    constructor(message: string);
+}
+
+export { type Align, AlignSchema, BinaryOrUrlSchema, type Block, BlockSchema, type ChartBlock, ChartBlockSchema, type Conditional, ConditionalSchema, type Document, type DocumentMeta, DocumentMetaSchema, DocumentSchema, type HeadingBlock, HeadingBlockSchema, type ImageBlock, ImageBlockSchema, type KeyValueBlock, KeyValueBlockSchema, LiasseRenderError, LiasseValidationError, type PageBreakBlock, PageBreakBlockSchema, type ParagraphBlock, ParagraphBlockSchema, type RenderFormat, type RenderOptions, type Renderer, type SectionBlock, SectionBlockSchema, type SpacerBlock, SpacerBlockSchema, type Summary, SummarySchema, type TableBlock, TableBlockSchema, type TableColumn, TableColumnSchema, type Theme, type ValueFormat, ValueFormatSchema, chart, defaultTheme, defineDocument, defineTheme, getRenderer, heading, image, keyValue, kv, pageBreak, paragraph, registerRenderer, render, section, spacer, table };

package/dist/index.js

@@ -0,0 +1,286 @@
+// src/schema.ts
+import { z } from "zod";
+var ValueFormatSchema = z.enum(["text", "number", "currency", "percent", "date"]);
+var AlignSchema = z.enum(["left", "center", "right"]);
+var BinaryOrUrlSchema = z.union([
+  z.instanceof(Uint8Array),
+  z.string().min(1)
+]);
+var HeadingBlockSchema = z.object({
+  type: z.literal("heading"),
+  text: z.string(),
+  // Required in the schema (input === output) so the recursive `Block` union
+  // type-checks; the builder `heading()` helper supplies the default level.
+  level: z.union([z.literal(1), z.literal(2), z.literal(3)])
+});
+var ParagraphBlockSchema = z.object({
+  type: z.literal("paragraph"),
+  text: z.string(),
+  emphasis: z.boolean().optional()
+});
+var TableColumnSchema = z.object({
+  key: z.string().min(1),
+  header: z.string(),
+  format: ValueFormatSchema.optional(),
+  align: AlignSchema.optional(),
+  /** Optional explicit column width (character units). */
+  width: z.number().positive().optional()
+});
+var SummarySchema = z.record(z.string(), z.enum(["sum", "avg", "count"]));
+var ConditionalSchema = z.object({
+  column: z.string().min(1),
+  rule: z.literal("positiveNegative")
+});
+var TableBlockSchema = z.object({
+  type: z.literal("table"),
+  columns: z.array(TableColumnSchema).min(1),
+  rows: z.array(z.record(z.string(), z.unknown())),
+  /** Per-column aggregate → emits a summary row with real formulas. */
+  summary: SummarySchema.optional(),
+  /** Colour cues, e.g. positive in green / negative in red. */
+  conditional: ConditionalSchema.optional(),
+  /** Format-specific escape hatch, read only by the xlsx adapter. */
+  xlsx: z.object({
+    freezeHeader: z.boolean().optional(),
+    sheetName: z.string().optional()
+  }).optional()
+});
+var KeyValueBlockSchema = z.object({
+  type: z.literal("keyValue"),
+  items: z.array(
+    z.object({
+      label: z.string(),
+      value: z.union([z.string(), z.number(), z.boolean(), z.null()]),
+      format: ValueFormatSchema.optional()
+    })
+  )
+});
+var ChartBlockSchema = z.object({
+  type: z.literal("chart"),
+  chartType: z.enum(["bar", "line", "pie"]),
+  data: z.array(z.record(z.string(), z.unknown())),
+  /** Key used for the category axis. */
+  x: z.string().min(1),
+  /** One or more series keys for the value axis. */
+  y: z.union([z.string().min(1), z.array(z.string().min(1)).min(1)]),
+  title: z.string().optional()
+});
+var ImageBlockSchema = z.object({
+  type: z.literal("image"),
+  src: BinaryOrUrlSchema,
+  width: z.number().positive().optional(),
+  height: z.number().positive().optional(),
+  alt: z.string().optional()
+});
+var SpacerBlockSchema = z.object({
+  type: z.literal("spacer"),
+  /** Number of blank rows / units to advance. The `spacer()` helper defaults to 1. */
+  size: z.number().int().positive()
+});
+var PageBreakBlockSchema = z.object({
+  type: z.literal("pageBreak")
+});
+var SectionBlockSchema = z.lazy(
+  () => z.object({
+    type: z.literal("section"),
+    title: z.string().optional(),
+    blocks: z.array(BlockSchema),
+    sheet: z.boolean().optional()
+  })
+);
+var BlockSchema = z.lazy(
+  () => z.union([
+    HeadingBlockSchema,
+    ParagraphBlockSchema,
+    TableBlockSchema,
+    KeyValueBlockSchema,
+    SectionBlockSchema,
+    ChartBlockSchema,
+    ImageBlockSchema,
+    SpacerBlockSchema,
+    PageBreakBlockSchema
+  ])
+);
+var DocumentMetaSchema = z.object({
+  title: z.string().min(1),
+  author: z.string().optional(),
+  subject: z.string().optional()
+});
+var DocumentSchema = z.object({
+  meta: DocumentMetaSchema,
+  blocks: z.array(BlockSchema)
+});
+
+// src/theme.ts
+var defaultTheme = {
+  palette: {
+    primary: "#25336E",
+    accent: "#34489C",
+    neutral: {
+      fg: "#1B1A16",
+      muted: "#837E72",
+      border: "#D9D3C5",
+      bg: "#F6F2E9"
+    },
+    semantic: {
+      positive: "#1F7A4D",
+      negative: "#B23A2E"
+    }
+  },
+  typography: {
+    fontFamily: "IBM Plex Sans",
+    baseSize: 11,
+    headingSizes: [20, 15, 13]
+  },
+  table: {
+    headerFill: "#E7E8F0",
+    headerFg: "#1A2550",
+    banding: true,
+    borderColor: "#E5E0D3"
+  },
+  spacing: 1
+};
+function defineTheme(overrides = {}) {
+  const base = defaultTheme;
+  return {
+    palette: {
+      primary: overrides.palette?.primary ?? base.palette.primary,
+      accent: overrides.palette?.accent ?? base.palette.accent,
+      neutral: { ...base.palette.neutral, ...overrides.palette?.neutral },
+      semantic: { ...base.palette.semantic, ...overrides.palette?.semantic }
+    },
+    typography: {
+      fontFamily: overrides.typography?.fontFamily ?? base.typography.fontFamily,
+      baseSize: overrides.typography?.baseSize ?? base.typography.baseSize,
+      headingSizes: overrides.typography?.headingSizes ?? base.typography.headingSizes
+    },
+    table: { ...base.table, ...overrides.table },
+    spacing: overrides.spacing ?? base.spacing,
+    brand: overrides.brand ? { ...base.brand, ...overrides.brand } : base.brand,
+    page: overrides.page ? { ...base.page, ...overrides.page } : base.page
+  };
+}
+
+// src/errors.ts
+var LiasseValidationError = class _LiasseValidationError extends Error {
+  /** Flat list of `path: message` issues, derived from the zod error. */
+  issues;
+  constructor(message, issues = []) {
+    super(message);
+    this.name = "LiasseValidationError";
+    this.issues = issues;
+    Object.setPrototypeOf(this, _LiasseValidationError.prototype);
+  }
+};
+var LiasseRenderError = class _LiasseRenderError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LiasseRenderError";
+    Object.setPrototypeOf(this, _LiasseRenderError.prototype);
+  }
+};
+
+// src/builder.ts
+function defineDocument(input) {
+  const result = DocumentSchema.safeParse(input);
+  if (!result.success) {
+    throw toValidationError(result.error);
+  }
+  return result.data;
+}
+function heading(text, opts = {}) {
+  return { type: "heading", text, level: opts.level ?? 1 };
+}
+function paragraph(text, opts = {}) {
+  return { type: "paragraph", text, ...opts.emphasis ? { emphasis: true } : {} };
+}
+function table(input) {
+  return { type: "table", ...input };
+}
+function keyValue(items) {
+  return { type: "keyValue", items };
+}
+function kv(label, value, format) {
+  return { label, value, ...format ? { format } : {} };
+}
+function section(input) {
+  return { type: "section", ...input };
+}
+function chart(input) {
+  return { type: "chart", ...input };
+}
+function image(input) {
+  return { type: "image", ...input };
+}
+function spacer(size = 1) {
+  return { type: "spacer", size };
+}
+function pageBreak() {
+  return { type: "pageBreak" };
+}
+function toValidationError(error) {
+  const issues = error.issues.map((i) => ({
+    path: i.path.join("."),
+    message: i.message
+  }));
+  const summary = issues.slice(0, 3).map((i) => i.path ? `${i.path}: ${i.message}` : i.message).join("; ");
+  const more = issues.length > 3 ? ` (+${issues.length - 3} more)` : "";
+  return new LiasseValidationError(`Invalid document: ${summary}${more}`, issues);
+}
+
+// src/renderer.ts
+var renderers = /* @__PURE__ */ new Map();
+function registerRenderer(renderer) {
+  renderers.set(renderer.format, renderer);
+}
+function getRenderer(format) {
+  return renderers.get(format);
+}
+async function render(doc, options) {
+  const renderer = renderers.get(options.format);
+  if (!renderer) {
+    throw new LiasseRenderError(
+      `No renderer registered for format "${options.format}". Import the matching adapter (e.g. "@liasse/xlsx") to register it.`
+    );
+  }
+  return renderer.render(doc, options.theme ?? defaultTheme);
+}
+export {
+  AlignSchema,
+  BinaryOrUrlSchema,
+  BlockSchema,
+  ChartBlockSchema,
+  ConditionalSchema,
+  DocumentMetaSchema,
+  DocumentSchema,
+  HeadingBlockSchema,
+  ImageBlockSchema,
+  KeyValueBlockSchema,
+  LiasseRenderError,
+  LiasseValidationError,
+  PageBreakBlockSchema,
+  ParagraphBlockSchema,
+  SectionBlockSchema,
+  SpacerBlockSchema,
+  SummarySchema,
+  TableBlockSchema,
+  TableColumnSchema,
+  ValueFormatSchema,
+  chart,
+  defaultTheme,
+  defineDocument,
+  defineTheme,
+  getRenderer,
+  heading,
+  image,
+  keyValue,
+  kv,
+  pageBreak,
+  paragraph,
+  registerRenderer,
+  render,
+  section,
+  spacer,
+  table
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schema.ts","../src/theme.ts","../src/errors.ts","../src/builder.ts","../src/renderer.ts"],"sourcesContent":["import { z } from \"zod\";\n\n/**\n * zod is the source of truth: every model type is inferred from a schema here,\n * and the same schemas validate API payloads later. Nothing in this file may\n * import an office library — the model is format-agnostic by construction.\n */\n\n/** How a scalar value should be presented by an adapter. */\nexport const ValueFormatSchema = z.enum([\"text\", \"number\", \"currency\", \"percent\", \"date\"]);\nexport type ValueFormat = z.infer<typeof ValueFormatSchema>;\n\nexport const AlignSchema = z.enum([\"left\", \"center\", \"right\"]);\nexport type Align = z.infer<typeof AlignSchema>;\n\n/** A buffer (Node/browser binary) or a string source (url / data-uri / path). */\n// Explicit `z.ZodType` annotation normalises the inferred binary type to a\n// plain `Uint8Array`, avoiding `ArrayBuffer`/`ArrayBufferLike` generic churn.\nexport const BinaryOrUrlSchema: z.ZodType<Uint8Array | string> = z.union([\n  z.instanceof(Uint8Array),\n  z.string().min(1),\n]);\n\n/* ------------------------------------------------------------------ blocks */\n\nexport const HeadingBlockSchema = z.object({\n  type: z.literal(\"heading\"),\n  text: z.string(),\n  // Required in the schema (input === output) so the recursive `Block` union\n  // type-checks; the builder `heading()` helper supplies the default level.\n  level: z.union([z.literal(1), z.literal(2), z.literal(3)]),\n});\nexport type HeadingBlock = z.infer<typeof HeadingBlockSchema>;\n\nexport const ParagraphBlockSchema = z.object({\n  type: z.literal(\"paragraph\"),\n  text: z.string(),\n  emphasis: z.boolean().optional(),\n});\nexport type ParagraphBlock = z.infer<typeof ParagraphBlockSchema>;\n\nexport const TableColumnSchema = z.object({\n  key: z.string().min(1),\n  header: z.string(),\n  format: ValueFormatSchema.optional(),\n  align: AlignSchema.optional(),\n  /** Optional explicit column width (character units). */\n  width: z.number().positive().optional(),\n});\nexport type TableColumn = z.infer<typeof TableColumnSchema>;\n\nexport const SummarySchema = z.record(z.string(), z.enum([\"sum\", \"avg\", \"count\"]));\nexport type Summary = z.infer<typeof SummarySchema>;\n\nexport const ConditionalSchema = z.object({\n  column: z.string().min(1),\n  rule: z.literal(\"positiveNegative\"),\n});\nexport type Conditional = z.infer<typeof ConditionalSchema>;\n\nexport const TableBlockSchema = z.object({\n  type: z.literal(\"table\"),\n  columns: z.array(TableColumnSchema).min(1),\n  rows: z.array(z.record(z.string(), z.unknown())),\n  /** Per-column aggregate → emits a summary row with real formulas. */\n  summary: SummarySchema.optional(),\n  /** Colour cues, e.g. positive in green / negative in red. */\n  conditional: ConditionalSchema.optional(),\n  /** Format-specific escape hatch, read only by the xlsx adapter. */\n  xlsx: z\n    .object({\n      freezeHeader: z.boolean().optional(),\n      sheetName: z.string().optional(),\n    })\n    .optional(),\n});\nexport type TableBlock = z.infer<typeof TableBlockSchema>;\n\nexport const KeyValueBlockSchema = z.object({\n  type: z.literal(\"keyValue\"),\n  items: z.array(\n    z.object({\n      label: z.string(),\n      value: z.union([z.string(), z.number(), z.boolean(), z.null()]),\n      format: ValueFormatSchema.optional(),\n    }),\n  ),\n});\nexport type KeyValueBlock = z.infer<typeof KeyValueBlockSchema>;\n\nexport const ChartBlockSchema = z.object({\n  type: z.literal(\"chart\"),\n  chartType: z.enum([\"bar\", \"line\", \"pie\"]),\n  data: z.array(z.record(z.string(), z.unknown())),\n  /** Key used for the category axis. */\n  x: z.string().min(1),\n  /** One or more series keys for the value axis. */\n  y: z.union([z.string().min(1), z.array(z.string().min(1)).min(1)]),\n  title: z.string().optional(),\n});\nexport type ChartBlock = z.infer<typeof ChartBlockSchema>;\n\nexport const ImageBlockSchema = z.object({\n  type: z.literal(\"image\"),\n  src: BinaryOrUrlSchema,\n  width: z.number().positive().optional(),\n  height: z.number().positive().optional(),\n  alt: z.string().optional(),\n});\nexport type ImageBlock = z.infer<typeof ImageBlockSchema>;\n\nexport const SpacerBlockSchema = z.object({\n  type: z.literal(\"spacer\"),\n  /** Number of blank rows / units to advance. The `spacer()` helper defaults to 1. */\n  size: z.number().int().positive(),\n});\nexport type SpacerBlock = z.infer<typeof SpacerBlockSchema>;\n\nexport const PageBreakBlockSchema = z.object({\n  type: z.literal(\"pageBreak\"),\n});\nexport type PageBreakBlock = z.infer<typeof PageBreakBlockSchema>;\n\n/* ----------------------------------------------- recursive section + union */\n\n/**\n * `Block` and `SectionBlock` are mutually recursive (a section contains blocks).\n * zod cannot infer recursive types, so we declare the TS types by hand and\n * annotate the lazy schemas with `z.ZodType<...>`.\n */\nexport interface SectionBlock {\n  type: \"section\";\n  title?: string;\n  blocks: Block[];\n  /** When true, the adapter renders this section onto its own sheet/page. */\n  sheet?: boolean;\n}\n\nexport type Block =\n  | HeadingBlock\n  | ParagraphBlock\n  | TableBlock\n  | KeyValueBlock\n  | SectionBlock\n  | ChartBlock\n  | ImageBlock\n  | SpacerBlock\n  | PageBreakBlock;\n\nexport const SectionBlockSchema: z.ZodType<SectionBlock> = z.lazy(() =>\n  z.object({\n    type: z.literal(\"section\"),\n    title: z.string().optional(),\n    blocks: z.array(BlockSchema),\n    sheet: z.boolean().optional(),\n  }),\n);\n\n// A plain (not discriminated) union is required because `SectionBlock` is\n// recursive: discriminatedUnion cannot take a `z.lazy` member, a plain union can.\nexport const BlockSchema: z.ZodType<Block> = z.lazy(() =>\n  z.union([\n    HeadingBlockSchema,\n    ParagraphBlockSchema,\n    TableBlockSchema,\n    KeyValueBlockSchema,\n    SectionBlockSchema,\n    ChartBlockSchema,\n    ImageBlockSchema,\n    SpacerBlockSchema,\n    PageBreakBlockSchema,\n  ]),\n);\n\n/* ----------------------------------------------------------------- document */\n\nexport const DocumentMetaSchema = z.object({\n  title: z.string().min(1),\n  author: z.string().optional(),\n  subject: z.string().optional(),\n});\nexport type DocumentMeta = z.infer<typeof DocumentMetaSchema>;\n\nexport const DocumentSchema = z.object({\n  meta: DocumentMetaSchema,\n  blocks: z.array(BlockSchema),\n});\nexport type Document = z.infer<typeof DocumentSchema>;\n","/**\n * The theme is a plain, JSON-serialisable typed object. Components and adapters\n * must only ever read tokens from here — never hard-code a colour, font or size.\n * The xlsx adapter translates each token into an exceljs style primitive.\n */\nexport interface Theme {\n  palette: {\n    primary: string;\n    accent: string;\n    neutral: { fg: string; muted: string; border: string; bg: string };\n    semantic: { positive: string; negative: string };\n  };\n  typography: {\n    fontFamily: string;\n    baseSize: number;\n    /** Sizes for heading levels 1, 2 and 3. */\n    headingSizes: [number, number, number];\n  };\n  table: {\n    headerFill: string;\n    headerFg: string;\n    banding: boolean;\n    borderColor: string;\n  };\n  /** Base spacing unit. */\n  spacing: number;\n  brand?: {\n    logo?: Uint8Array;\n    headerText?: string;\n    footerText?: string;\n  };\n  /** Mostly for flow formats later (PDF/DOCX). */\n  page?: { orientation?: \"portrait\" | \"landscape\" };\n}\n\n/**\n * The one shipped theme: an \"ink on paper\" editorial look that matches the\n * Liasse brand (deep ink blue, warm paper neutrals, sober finance semantics).\n */\nexport const defaultTheme: Theme = {\n  palette: {\n    primary: \"#25336E\",\n    accent: \"#34489C\",\n    neutral: {\n      fg: \"#1B1A16\",\n      muted: \"#837E72\",\n      border: \"#D9D3C5\",\n      bg: \"#F6F2E9\",\n    },\n    semantic: {\n      positive: \"#1F7A4D\",\n      negative: \"#B23A2E\",\n    },\n  },\n  typography: {\n    fontFamily: \"IBM Plex Sans\",\n    baseSize: 11,\n    headingSizes: [20, 15, 13],\n  },\n  table: {\n    headerFill: \"#E7E8F0\",\n    headerFg: \"#1A2550\",\n    banding: true,\n    borderColor: \"#E5E0D3\",\n  },\n  spacing: 1,\n};\n\n/**\n * Shallow-ish merge to derive a theme from {@link defaultTheme}. Nested token\n * groups are merged one level deep so callers can override just a few tokens.\n */\nexport function defineTheme(overrides: DeepPartial<Theme> = {}): Theme {\n  const base = defaultTheme;\n  return {\n    palette: {\n      primary: overrides.palette?.primary ?? base.palette.primary,\n      accent: overrides.palette?.accent ?? base.palette.accent,\n      neutral: { ...base.palette.neutral, ...overrides.palette?.neutral },\n      semantic: { ...base.palette.semantic, ...overrides.palette?.semantic },\n    },\n    typography: {\n      fontFamily: overrides.typography?.fontFamily ?? base.typography.fontFamily,\n      baseSize: overrides.typography?.baseSize ?? base.typography.baseSize,\n      headingSizes: overrides.typography?.headingSizes ?? base.typography.headingSizes,\n    },\n    table: { ...base.table, ...overrides.table },\n    spacing: overrides.spacing ?? base.spacing,\n    brand: overrides.brand ? { ...base.brand, ...overrides.brand } : base.brand,\n    page: overrides.page ? { ...base.page, ...overrides.page } : base.page,\n  };\n}\n\ntype DeepPartial<T> = {\n  [K in keyof T]?: T[K] extends string | number | boolean | Uint8Array | readonly unknown[]\n    ? T[K]\n    : T[K] extends object\n      ? DeepPartial<T[K]>\n      : T[K];\n};\n","/**\n * Typed error classes for Liasse. Catch these to distinguish a malformed\n * document (validation) from a failure while producing the output bytes (render).\n */\n\n/** Thrown by {@link defineDocument} (and other validators) on invalid input. */\nexport class LiasseValidationError extends Error {\n  /** Flat list of `path: message` issues, derived from the zod error. */\n  readonly issues: { path: string; message: string }[];\n\n  constructor(message: string, issues: { path: string; message: string }[] = []) {\n    super(message);\n    this.name = \"LiasseValidationError\";\n    this.issues = issues;\n    Object.setPrototypeOf(this, LiasseValidationError.prototype);\n  }\n}\n\n/** Thrown by a {@link Renderer} (or the `render` dispatcher) when output fails. */\nexport class LiasseRenderError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"LiasseRenderError\";\n    Object.setPrototypeOf(this, LiasseRenderError.prototype);\n  }\n}\n","import { z } from \"zod\";\nimport { LiasseValidationError } from \"./errors.js\";\nimport {\n  DocumentSchema,\n  type Block,\n  type ChartBlock,\n  type Document,\n  type HeadingBlock,\n  type ImageBlock,\n  type KeyValueBlock,\n  type ParagraphBlock,\n  type SectionBlock,\n  type TableBlock,\n  type TableColumn,\n  type ValueFormat,\n} from \"./schema.js\";\n\n/**\n * The builder DSL. Each helper returns a plain block object so components read\n * declaratively. `defineDocument` is the only function that validates — build\n * the tree freely, then validate once at the boundary.\n */\n\n/** Validate raw input against the document schema; throws on bad input. */\nexport function defineDocument(input: {\n  meta: Document[\"meta\"];\n  blocks: Block[];\n}): Document {\n  const result = DocumentSchema.safeParse(input);\n  if (!result.success) {\n    throw toValidationError(result.error);\n  }\n  return result.data;\n}\n\nexport function heading(text: string, opts: { level?: HeadingBlock[\"level\"] } = {}): HeadingBlock {\n  return { type: \"heading\", text, level: opts.level ?? 1 };\n}\n\nexport function paragraph(text: string, opts: { emphasis?: boolean } = {}): ParagraphBlock {\n  return { type: \"paragraph\", text, ...(opts.emphasis ? { emphasis: true } : {}) };\n}\n\nexport function table(input: {\n  columns: TableColumn[];\n  rows: Record<string, unknown>[];\n  summary?: TableBlock[\"summary\"];\n  conditional?: TableBlock[\"conditional\"];\n  xlsx?: TableBlock[\"xlsx\"];\n}): TableBlock {\n  return { type: \"table\", ...input };\n}\n\nexport function keyValue(items: KeyValueBlock[\"items\"]): KeyValueBlock {\n  return { type: \"keyValue\", items };\n}\n\nexport function kv(\n  label: string,\n  value: KeyValueBlock[\"items\"][number][\"value\"],\n  format?: ValueFormat,\n): KeyValueBlock[\"items\"][number] {\n  return { label, value, ...(format ? { format } : {}) };\n}\n\nexport function section(input: {\n  title?: string;\n  blocks: Block[];\n  sheet?: boolean;\n}): SectionBlock {\n  return { type: \"section\", ...input };\n}\n\nexport function chart(input: {\n  chartType: ChartBlock[\"chartType\"];\n  data: Record<string, unknown>[];\n  x: string;\n  y: string | string[];\n  title?: string;\n}): ChartBlock {\n  return { type: \"chart\", ...input };\n}\n\nexport function image(input: {\n  src: Uint8Array | string;\n  width?: number;\n  height?: number;\n  alt?: string;\n}): ImageBlock {\n  return { type: \"image\", ...input };\n}\n\nexport function spacer(size = 1): Block {\n  return { type: \"spacer\", size };\n}\n\nexport function pageBreak(): Block {\n  return { type: \"pageBreak\" };\n}\n\nfunction toValidationError(error: z.ZodError): LiasseValidationError {\n  const issues = error.issues.map((i) => ({\n    path: i.path.join(\".\"),\n    message: i.message,\n  }));\n  const summary = issues\n    .slice(0, 3)\n    .map((i) => (i.path ? `${i.path}: ${i.message}` : i.message))\n    .join(\"; \");\n  const more = issues.length > 3 ? ` (+${issues.length - 3} more)` : \"\";\n  return new LiasseValidationError(`Invalid document: ${summary}${more}`, issues);\n}\n","import { LiasseRenderError } from \"./errors.js\";\nimport type { Document } from \"./schema.js\";\nimport { defaultTheme, type Theme } from \"./theme.js\";\n\nexport type RenderFormat = \"xlsx\" | \"pptx\" | \"docx\" | \"pdf\";\n\n/**\n * A renderer turns a {@link Document} + {@link Theme} into output bytes.\n * Adapters live in their own packages (e.g. `@liasse/xlsx`) and must not leak\n * format-specific types back into core.\n *\n * Renderers return a `Uint8Array` (Node `Buffer` is a `Uint8Array`); the caller\n * decides what to do with the bytes — packages never touch `fs`.\n */\nexport interface Renderer {\n  readonly format: RenderFormat;\n  render(doc: Document, theme: Theme): Promise<Uint8Array>;\n}\n\nconst renderers = new Map<RenderFormat, Renderer>();\n\n/** Register (or replace) the renderer for a format. Called by adapter packages. */\nexport function registerRenderer(renderer: Renderer): void {\n  renderers.set(renderer.format, renderer);\n}\n\n/** Look up a previously registered renderer, if any. */\nexport function getRenderer(format: RenderFormat): Renderer | undefined {\n  return renderers.get(format);\n}\n\nexport interface RenderOptions {\n  format: RenderFormat;\n  theme?: Theme;\n}\n\n/**\n * Thin dispatcher: pick the registered renderer for `format` and run it.\n * For the MVP only the `xlsx` renderer is registered (import `@liasse/xlsx`).\n */\nexport async function render(doc: Document, options: RenderOptions): Promise<Uint8Array> {\n  const renderer = renderers.get(options.format);\n  if (!renderer) {\n    throw new LiasseRenderError(\n      `No renderer registered for format \"${options.format}\". ` +\n        `Import the matching adapter (e.g. \"@liasse/xlsx\") to register it.`,\n    );\n  }\n  return renderer.render(doc, options.theme ?? defaultTheme);\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@liasse/core",
+  "version": "0.1.0",
+  "description": "Liasse core — format-agnostic document model, theme, builder DSL, zod schemas and the Renderer interface. Zero office dependencies.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  }
+}