@chanmeng666/archlang 0.6.0 → 0.7.0

package/dist/index.d.ts

@@ -243,6 +243,163 @@ interface PlanNode {
     body: Statement[];
 }
 
+/** Pure geometry helpers. All coordinates in millimetres. Deterministic. */
+
+interface Bounds {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+interface WallSegment {
+    a: Point;
+    b: Point;
+    thickness: number;
+    category: string;
+}
+
+/**
+ * Backend-neutral **Scene IR** — the keystone drawing intermediate.
+ *
+ * `resolve()` produces semantic geometry (rooms, walls, openings); this module
+ * defines a flat list of *positioned drawing primitives* tagged with a layer and
+ * paint. Geometry is computed exactly **once** here (by the elements, lowered via
+ * `scene-build.ts`); every backend (SVG, DXF, PDF, …) is then a thin, pure
+ * serializer of the same `Scene`. This kills the geometry duplication the
+ * string-based `RenderOp` forced (DXF re-deriving door arcs, PDF rasterizing SVG).
+ *
+ * Prior art: Typst's `Frame`/`FrameItem` (crates/typst-library/src/layout/frame.rs)
+ * — a positioned list of drawable items — and D2's `d2target` (a flat, pointer-free
+ * render target consumed by independent backends). ArchLang has no nested
+ * transforms, so unlike Typst's `Frame` the node list is flat (no sub-frames).
+ *
+ * Phase v0.7 keeps this deliberately small: line-weight/line-type/named-layer
+ * metadata, hatch primitives, and circles are intentionally deferred to Phase v0.9
+ * (roadmap §6). Poché stays an SVG `<pattern>` fill string; page chrome (north
+ * arrow, scale bar, title block) stays in the backends for now.
+ */
+
+/**
+ * Ordered draw layers. Nodes are bucketed by `layer` and emitted in this order,
+ * preserving collection order within a layer — this exactly reproduces the v0.1
+ * global draw order (all wall fills, then all wall faces, doors before windows,
+ * labels above fills, …). Doubles as the discriminant of {@link SceneNode.layer}.
+ */
+declare const RENDER_PASSES: readonly ["floor", "furniture", "wallFill", "wallFace", "doors", "windows", "labels", "dims", "annotations"];
+type RenderPass = (typeof RENDER_PASSES)[number];
+/** Render-derived sizes (in mm), scaled from the drawing's reference dimension. */
+interface RenderSizes {
+    refDim: number;
+    wallStroke: number;
+    thin: number;
+    roomFont: number;
+    areaFont: number;
+    dimFont: number;
+    furnFont: number;
+    margin: number;
+    hatchGap: number;
+}
+/**
+ * How a primitive is painted. Strokes/fills carry colours (already theme-resolved
+ * and escaped at the serialization boundary); `width`/`dash` carry *raw* numbers
+ * that each backend formats. The optional `linecap`/`linejoin`/`fillRule` cover
+ * the exact SVG attributes the original element emitters used, so the SVG
+ * serializer reproduces today's output byte-for-byte.
+ */
+interface Paint {
+    /** A colour, `"none"`, or an SVG pattern ref like `"url(#poche)"`. */
+    fill?: string;
+    stroke?: string;
+    /** Raw stroke width in mm (backend applies its own number formatting). */
+    width?: number;
+    /** `stroke-dasharray` pair in mm (e.g. door swing arc). */
+    dash?: [number, number];
+    linecap?: "square";
+    linejoin?: "miter";
+    fillRule?: "nonzero";
+}
+/**
+ * A positioned drawing primitive. Coordinates are absolute millimetres in the
+ * plan's space (origin top-left, +x right, +y down — SVG convention); backends
+ * apply their own transforms (e.g. DXF's Y-flip).
+ */
+type ScenePrim = 
+/** A filled/stroked closed polygon (room, furniture, column, opening cover, per-segment wall fill). */
+{
+    t: "polygon";
+    pts: Point[];
+}
+/** A single straight segment (wall face, door leaf, window pane, dimension lines/ticks). */
+ | {
+    t: "line";
+    a: Point;
+    b: Point;
+}
+/**
+ * A multi-loop closed region drawn as one path (`fill-rule` nonzero), used for
+ * unioned orthogonal walls so the poché fills with proper holes and the outline
+ * has no internal seams.
+ */
+ | {
+    t: "region";
+    loops: Point[][];
+}
+/**
+ * A circular arc (door swing). Carries the `center`/`r` a CAD backend needs to
+ * emit a native arc, plus the explicit `start`/`end` points + `sweep` flag an
+ * SVG `A` command needs — so neither backend re-derives endpoints from trig.
+ */
+ | {
+    t: "arc";
+    center: Point;
+    r: number;
+    start: Point;
+    end: Point;
+    sweep: 0 | 1;
+}
+/** A text label. `value` is the raw (unescaped) string; backends escape on emit. */
+ | {
+    t: "text";
+    at: Point;
+    value: string;
+    size: number;
+    anchor: "start" | "middle" | "end";
+    baseline: "central";
+    /** SVG `font-weight` (e.g. 600 for a room name). */
+    weight?: number;
+    /** Rotation in degrees about `at` (e.g. dimension text along its line). */
+    rotate?: number;
+};
+/** One drawable: a primitive on a layer, with paint and an optional source span. */
+interface SceneNode {
+    layer: RenderPass;
+    prim: ScenePrim;
+    paint: Paint;
+    span?: Span;
+}
+/**
+ * A complete, backend-neutral drawing. `nodes` is the geometry; the remaining
+ * fields are the page-level context backends need (viewBox sizing, theme colours
+ * for chrome, north/scale/title block, hatch materials in use). Theme is baked
+ * into node paint already — it is carried here only for the page chrome.
+ */
+interface Scene {
+    /** Padded page width/height in mm (drawing extent + annotation margin). */
+    width: number;
+    height: number;
+    /** Tight drawing bounds (before margin), for chrome placement. */
+    bounds: Bounds;
+    nodes: SceneNode[];
+    theme: Theme;
+    sizes: RenderSizes;
+    north: NorthDir;
+    scale?: string;
+    title?: TitleNode;
+    name: string;
+    /** Distinct wall materials in use (stable order), so the SVG backend can emit hatch `<pattern>`s. */
+    materials: string[];
+}
+
 interface CompileError {
     /** Human-readable message. */
     message: string;
@@ -280,15 +437,12 @@ interface CompileResult {
     diagnostics: Diagnostic[];
     /** The validated AST, present whenever parsing succeeded. */
     ast?: PlanNode;
-}
-
-/** Pure geometry helpers. All coordinates in millimetres. Deterministic. */
-
-interface WallSegment {
-    a: Point;
-    b: Point;
-    thickness: number;
-    category: string;
+    /**
+     * The backend-neutral Scene IR (positioned drawing primitives), present
+     * whenever rendering succeeded (i.e. no fatal errors). Feed it to alternate
+     * backends: `toDxf(scene)`, `toPdf(scene)`.
+     */
+    scene?: Scene;
 }
 
 /**
@@ -381,29 +535,61 @@ declare function resolve(ast: PlanNode): {
 };
 
 /**
- * DXF export backend — consumes the resolved IR and emits ASCII DXF (R12 /
- * AC1009, the most broadly importable flavor). Pure, synchronous, zero-dep:
- * DXF is plain text, so this needs no external library and is safe to ship in
- * the core. It is NOT part of `compile()` — call it on the IR from `resolve()`.
+ * Lowers a resolved plan (IR) to the backend-neutral {@link Scene}.
  *
- * DXF's Y axis points up, while ArchLang's Y points down (SVG convention), so
- * every coordinate's Y is negated here to keep plans right-side-up in CAD.
+ * This is the single place geometry is assembled: each element contributes
+ * positioned primitives via its registry `render`, walls are unioned/offset here
+ * (the only element needing cross-segment treatment), and the page-level sizing
+ * (reference dimension, derived font/stroke sizes, bounds) is computed once and
+ * carried on the Scene for the backends. Pure & deterministic — no I/O, no time.
  */
 
-/** Render a resolved plan as an ASCII DXF document string. */
-declare function toDxf(ir: ResolvedPlan): string;
+/**
+ * Build the {@link Scene} for a resolved plan. The theme is merged + sanitized
+ * once here and baked into node paint; it is also carried on the Scene for the
+ * page chrome (north/scale/title). `opts.width` does not affect the Scene (it is
+ * an SVG-only attribute) — only `opts.theme` participates.
+ */
+declare function toScene(ir: ResolvedPlan, opts?: CompileOptions): Scene;
 
 /**
- * PDF export backend — consumes the produced SVG and renders it into a PDF via
- * pdfkit + svg-to-pdfkit. These are OPTIONAL dependencies, lazy-`import()`ed so
- * the zero-dep core never hard-requires them; a clear error is thrown if they
- * are absent. This is async and Node-oriented — NOT part of `compile()`.
+ * DXF export backend — a pure serializer of the {@link Scene}. Emits ASCII DXF
+ * (R12 / AC1009, the most broadly importable flavor). Pure, synchronous,
+ * zero-dep: DXF is plain text, so this needs no external library and ships in the
+ * core. Build a Scene with `toScene(resolve(ast).ir)` (or `compile().scene`).
+ *
+ * As of v0.7 the geometry is NOT re-derived here: door arcs, window panes, and
+ * dimension ticks are the very `ScenePrim`s the elements produced. Each primitive
+ * maps generically to a DXF entity; the only element-aware step is mapping a draw
+ * layer to a DXF layer name. DXF's Y axis points up while ArchLang's points down,
+ * so every Y is negated to keep plans right-side-up in CAD.
  */
+
+/** Render a {@link Scene} as an ASCII DXF document string. */
+declare function toDxf(scene: Scene): string;
+
 /**
- * Convert an ArchLang SVG string to a PDF (returned as a Uint8Array).
- * Requires the optional `pdfkit` and `svg-to-pdfkit` packages.
+ * PDF export backend — a **true vector** serializer of the {@link Scene}.
+ *
+ * Walks the Scene's positioned primitives into pdfkit drawing ops, so strokes
+ * are real vector paths and text is selectable (no SVG rasterization round-trip).
+ * `pdfkit` is an OPTIONAL dependency, lazy-`import()`ed so the zero-dep core never
+ * hard-requires it; a clear error is thrown if it is absent. Async + Node-oriented
+ * — NOT part of `compile()`. Build a Scene with `toScene(ir)` or `compile().scene`.
+ *
+ * Coordinates: ArchLang is mm, top-left origin, +y down — pdfkit's user space is
+ * the same orientation, so we map the viewBox by translating by its top-left and
+ * treat 1mm as 1pt (as the previous SVG-based exporter did with `assumePt`).
+ *
+ * Page chrome (north arrow, scale bar, title block) is drawn with PDF-native
+ * helpers to keep parity with the SVG output. This duplicates the chrome geometry
+ * (also in `backends/svg.ts`) — a deliberate, bounded cost until chrome itself
+ * moves into the Scene in a later phase. Hatch patterns are SVG-specific, so
+ * poché regions fill with the solid poché base colour in PDF.
  */
-declare function toPdf(svg: string): Promise<Uint8Array>;
+
+/** Convert a {@link Scene} to a vector PDF (Uint8Array). Requires optional `pdfkit`. */
+declare function toPdf(scene: Scene): Promise<Uint8Array>;
 
 /**
  * ArchLang — compile declarative floor-plan source to a professional SVG.
@@ -417,4 +603,4 @@ declare function compile(source: string, opts?: CompileOptions): CompileResult;
 /** Clear the internal compile cache (useful in long-lived processes/tests). */
 declare function clearCache(): void;
 
-export { type AstElement, type ColumnNode, type CompileError, type CompileOptions, type CompileResult, type CompileWarning, type ComponentDef, type Diagnostic, type DimNode, type DoorNode, type ElementKind, type ExprPoint, type FurnitureNode, type InstanceNode, type LetNode, type NodeBase, type NorthDir, type PlanNode, type Point, type RColumn, type RDim, type RDoor, type RFurniture, type RRoom, type RWall, type RWindow, type ResolvedElement, type ResolvedPlan, type RoomNode, type Severity, type Span, type Statement, type TitleNode, type WallNode, type WindowNode, clearCache, compile, formatDiagnostic, offsetToLineCol, resolve, toDxf, toPdf };
+export { type AstElement, type ColumnNode, type CompileError, type CompileOptions, type CompileResult, type CompileWarning, type ComponentDef, type Diagnostic, type DimNode, type DoorNode, type ElementKind, type ExprPoint, type FurnitureNode, type InstanceNode, type LetNode, type NodeBase, type NorthDir, type Paint, type PlanNode, type Point, type RColumn, type RDim, type RDoor, type RFurniture, type RRoom, type RWall, type RWindow, type RenderPass, type RenderSizes, type ResolvedElement, type ResolvedPlan, type RoomNode, type Scene, type SceneNode, type ScenePrim, type Severity, type Span, type Statement, type TitleNode, type WallNode, type WindowNode, clearCache, compile, formatDiagnostic, offsetToLineCol, resolve, toDxf, toPdf, toScene };

package/dist/index.js

@@ -5,8 +5,9 @@ import {
   offsetToLineCol,
   resolve,
   toDxf,
-  toPdf
-} from "./chunk-PABYLU6Z.js";
+  toPdf,
+  toScene
+} from "./chunk-CPK5CI5Y.js";
 export {
   clearCache,
   compile,
@@ -14,6 +15,7 @@ export {
   offsetToLineCol,
   resolve,
   toDxf,
-  toPdf
+  toPdf,
+  toScene
 };
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chanmeng666/archlang",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "A small declarative language that compiles to professional SVG floor plans — like Typst/LaTeX, but for architecture.",
   "keywords": [
     "architecture",
@@ -66,7 +66,6 @@
     "vscode-textmate": "^9.3.2"
   },
   "optionalDependencies": {
-    "pdfkit": "^0.15.2",
-    "svg-to-pdfkit": "^0.1.8"
+    "pdfkit": "^0.15.2"
   }
 }