DocumentKit

Block-first document model + fluent builders + HTML renderer for structured technical reports (equations, tables, pictures, paragraphs). Standalone, domain-neutral library.

Source: github.com/PetrFoltyn/DocumentKit

Practical walkthrough: docs/AUTHORING.md — covers prerequisites, defining a ViewModel, creating equations/tables, composing a document, and rendering, from scratch.

What's in the box

• Block model — IDocumentBlock + 10 concrete block kinds (EquationBlock, InequalityBlock, VariableListBlock, ParagraphBlock, ExplanationBlock, TableBlock, ImageBlock, ContentBlock, PageBreakBlock).
• Builders — TableBuilder (fluent table API), EquationBlockBuilder (abstract base for named equations) + three Inline*BlockBuilder concrete wrappers (InlineEquationBlockBuilder, InlineInequalityBlockBuilder, InlineVariableListBlockBuilder), PictureBlockBuilder (SVG wrapper).
• Term API — operator-based equation builder producing LaTeX/KaTeX (+ - * /, Pow, Sqrt, Abs, Min, Max, Sum, …).
• VarValue + [Var] attribute — compile-time variable metadata; a Roslyn source generator emits a strongly-typed .Vars() extension method per ViewModel.
• LocalizedString — value-type for translatable / non-translatable / composite text. Custom JSON converter accepts plain string and {"k": "KEY"} forms.
• IUnit / IUnits — unit-system abstraction. Bring your own implementations (or use the included convenience classes).
• BlockHtmlRenderer — renders any IDocumentBlock to HTML strings. Backwards-compatible with System.Web.UI.HtmlTextWriter (shim included for .NET 8+).

Quick start

using DCEPresentation;
using DCEPresentation.Model;
using DCEPresentation.Model.Blocks;
using DCEPresentation.Render;
using static DCEPresentation.Eq;

// 1. Define a ViewModel with [Var] attributes (source generator emits .Vars()).
public class BeamResultVM
{
    [Var( Symbol = @"M_{Ed}", Unit = "MOMENT" )]
    public double MEd { get; set; }

    [Var( Symbol = @"M_{Rd}", Unit = "MOMENT" )]
    public double MRd { get; set; }

    [Var( Symbol = @"U", Unit = "PERCEN", Auto = 1 )]
    public double U { get; set; }
}

// 2. Build blocks
IUnits units = MyUnitsImpl.Metric;   // your own IUnits implementation
var vm = new BeamResultVM { MEd = 320, MRd = 400, U = 80 };
var v = vm.Vars();

var blocks = new IDocumentBlock[]
{
    new ParagraphBlock( LocalizedString.Translated( "GUI_CapacityCheck" ),
        cssClass: "section-title" ),

    new InlineEquationBlockBuilder( units,
        ( v.MEd / v.MRd == v.U ).WithReference( "EN1992", "6.1 (4)" )
    ).ToBlock(),

    TableBuilder.For( units, LocalizedString.Translated( "GUI_Summary" ) )
        .Row( v.MEd, v.MRd, v.U )
        .ToBlock(),
};

// 3. Render
foreach( var block in blocks )
    Console.WriteLine( BlockHtmlRenderer.Render( block ) );

See docs/AUTHORING.md for a full end-to-end example including the minimum IUnit/IUnits/LocalizerProvider setup.

Architecture

IUnits (interface)          — unit lookup by name
  └─ IUnit (interface)      — symbol, conversion, formatting

VarValue (struct)           — value + symbol + unit metadata
  ├─ .ToDocumentValue()     — for equations (LaTeX)
  ├─ .ToHtmlValue()         — for tables (HTML)
  └─ .ToFormattedText()     — for plain text

LocalizedString (struct)    — translatable/literal/composite text
  ├─ .Translated(key)
  ├─ .Literal(text)
  └─ + operator (composition)

Term (abstract)             — expression tree node
  ├─ VarValueTerm            — variable reference
  ├─ ConstantTerm            — numeric constant
  ├─ ProductTerm             — A * B * C
  ├─ FractionTerm            — A / B (vertical fraction)
  ├─ DivideTerm              — A / B (inline)
  ├─ AddTerm / SubtractTerm  — A + B, A - B
  ├─ SqrtTerm / PowerTerm    — Sqrt(A), A^n
  └─ SumTerm                 — Σ notation

EquationBuilder             — (formula == result) pattern
  ├─ .Build(units)           — DocumentEquationInLine
  ├─ .BuildWithReferences()  — with code references
  ├─ .WithAbbreviatedSymbol()
  └─ >= / <= operators       — InequalityBuilder

TableBuilder                — fluent HTML tables
  ├─ .Row(VarValue...)       — data row from values
  ├─ .Row(Action<RowBuilder>)— custom row
  ├─ .WithHeader()           — explicit header
  ├─ .PropertyRow()          — key-value layout
  └─ .WithSummaryLayout()    — summary format

IDocumentBlock              — structured output (10 kinds)
BlockHtmlRenderer.Render()  — IDocumentBlock → HTML string

Term API conventions

Target frameworks

• .NET Framework 4.8
• .NET 8+ (with bundled HtmlTextWriter shim)

Namespace

All public types live under DCEPresentation (root namespace retained for source compatibility with existing consumers).