ofs-dxf-ts 1.0.0

package/dist/core/dxf-document.js

@@ -0,0 +1,529 @@
+/**
+ * DxfDocument — Core document class with template parsing.
+ *
+ * ✅ Works in both Node.js AND Browser/Angular environments.
+ *
+ * Every document is built on a base DXF: a user template, or the built-in
+ * blank DXF R2018 document when created from scratch. New layers, linetypes,
+ * text styles, blocks, images and layouts are injected into that base on
+ * output, so both modes produce the same, complete R2000+ structure.
+ *
+ * Usage (Node.js):
+ *   const doc = DxfDocument.readFile('./template/template2018.dxf');
+ *   doc.saveas('output.dxf');
+ *
+ * Usage (Browser/Angular):
+ *   const doc = DxfDocument.fromString(templateDxfString);
+ *   const dxfOutput = doc.toDxfString();
+ *   // download via Blob, or send to server
+ *
+ * Usage (from scratch — both environments):
+ *   const doc = DxfDocument.create();
+ *   doc.addLayer('MyLayer', 7, 'CONTINUOUS');
+ *   const msp = doc.modelspace();
+ *   msp.add_circle([50, 50], 25);
+ *   const output = doc.toDxfString();
+ */
+import { Modelspace } from './modelspace.js';
+import { readTemplate } from '../template/template-reader.js';
+import { serializeDocument, listLayoutNames } from '../template/template-injector.js';
+import { BLANK_DXF_R2018 } from '../template/blank-document.js';
+let _fs = null;
+try {
+    const proc = typeof process !== 'undefined' ? process : undefined;
+    if (proc?.versions?.node) {
+        _fs = proc.getBuiltinModule?.('fs') ?? null;
+        if (!_fs) {
+            const req = globalThis.require;
+            if (typeof req === 'function')
+                _fs = req('fs');
+        }
+    }
+}
+catch { /* browser environment — fs not available */ }
+export class DxfDocument {
+    // Internal state
+    _layers = new Map();
+    _linetypes = new Map();
+    _styles = new Map();
+    _blocks = new Map();
+    _msp = new Modelspace();
+    _layouts = [];
+    /** Upper-cased layout name → entity collector for that layout. */
+    _paperspaces = new Map();
+    // Base document (template or blank)
+    _rawSections = new Map();
+    _templateBlockNames = new Set();
+    _templateLayerNames = new Set();
+    _templateStyleNames = new Set();
+    _templateLayoutNames = [];
+    // Parsed template reference (from dxf-parser)
+    _parsedTemplate = null;
+    constructor() { }
+    // ─── Static Constructors ───
+    /**
+     * Read a DXF file from disk (Node.js only).
+     * @throws Error if called in browser environment.
+     */
+    static readFile(filePath) {
+        if (!_fs) {
+            throw new Error('DxfDocument.readFile() requires Node.js. ' +
+                'In browser/Angular, use DxfDocument.fromString(content) instead.');
+        }
+        const content = _fs.readFileSync(filePath, 'utf-8');
+        return DxfDocument.fromString(content);
+    }
+    /**
+     * Parse a DXF template from a string.
+     * ✅ Works in both Node.js and Browser/Angular.
+     */
+    static fromString(content) {
+        const doc = new DxfDocument();
+        doc._loadBase(content);
+        return doc;
+    }
+    /**
+     * Create a blank DXF document (DXF R2018, meters).
+     * ✅ Works in both Node.js and Browser/Angular.
+     */
+    static create() {
+        const doc = new DxfDocument();
+        doc._loadBase(BLANK_DXF_R2018);
+        doc._addDefaultLinetypes();
+        return doc;
+    }
+    // ─── Public API ───
+    /** Get the modelspace for adding entities. */
+    modelspace() {
+        return this._msp;
+    }
+    /** Add or update a layer. */
+    addLayer(name, color = 7, linetype = 'CONTINUOUS') {
+        this._layers.set(name, { name, color, linetype });
+    }
+    /** Check if a layer exists. */
+    hasLayer(name) {
+        return this._layers.has(name) || this._templateLayerNames.has(name);
+    }
+    /** Get layer definition. */
+    getLayer(name) {
+        return this._layers.get(name);
+    }
+    /** Access layers as a record (backward compat). */
+    get layers() {
+        const obj = {};
+        for (const [name, def] of this._layers) {
+            obj[name] = def;
+        }
+        for (const name of this._templateLayerNames) {
+            if (!obj[name]) {
+                obj[name] = { name, color: 7, linetype: 'CONTINUOUS' };
+            }
+        }
+        return obj;
+    }
+    /**
+     * Add a text style. For Thai text use a TrueType font file name,
+     * e.g. `addTextStyle('THAI', 'THSarabunNew.ttf')`.
+     * Styles that already exist in the base document are kept as they are.
+     */
+    addTextStyle(name, font, height) {
+        this._styles.set(name, { name, font, height });
+    }
+    /** ezdxf-compatible styles.new() */
+    get styles() {
+        const self = this;
+        return {
+            new: (name, dxfattribs) => {
+                self.addTextStyle(name, dxfattribs.font);
+            }
+        };
+    }
+    /**
+     * Add a linetype definition. Pattern values are in drawing units:
+     * positive = dash, negative = gap, 0 = dot.
+     * Linetypes that already exist in the base document are kept as they are.
+     */
+    addLineType(name, description, pattern) {
+        this._linetypes.set(name, { name, description, pattern });
+    }
+    // ─── GeoReference ───
+    _geoRef = null;
+    /**
+     * Set geographic coordinate reference for the drawing.
+     * This embeds coordinate system info into the DXF HEADER.
+     *
+     * @example
+     *   // UTM Zone 47N (Thailand)
+     *   doc.setGeoReference({
+     *       crsId: 'EPSG:32647',
+     *       designPoint: [0, 0],
+     *       referencePoint: [600000, 1700000],  // Easting, Northing
+     *       northDirection: 0,
+     *       scaleFactor: 1,
+     *       coordinateType: 2,  // projected
+     *   });
+     */
+    setGeoReference(geoRef) {
+        this._geoRef = geoRef;
+        // Set header variables for coordinate system
+        this._headerVars.set('$INSUNITS', [{ code: 70, value: '6' }]); // Meters
+        // Store design/reference point mapping
+        this._headerVars.set('$UCSORG', [
+            { code: 10, value: String(geoRef.referencePoint[0]) },
+            { code: 20, value: String(geoRef.referencePoint[1]) },
+            { code: 30, value: '0' },
+        ]);
+        // Store north direction
+        this._headerVars.set('$ANGBASE', [{ code: 50, value: String(geoRef.northDirection) }]);
+    }
+    /** Get the geo reference definition (if set). */
+    get geoReference() { return this._geoRef; }
+    // ─── Layout (Paper Space) ───
+    /**
+     * Add a Paper Space layout for plotting.
+     * Paper space units are mm; the origin is the lower-left corner of the
+     * printable area (inside the margins), as in AutoCAD.
+     *
+     * @example
+     *   doc.addLayout({
+     *       name: 'A1',
+     *       paperWidth: 841,   // mm
+     *       paperHeight: 594,  // mm
+     *       margins: [0, 0, 0, 0],
+     *       viewports: [{
+     *           center: [420, 297],
+     *           width: 800, height: 560,
+     *           viewCenter: [519500, 1033500],
+     *           scale: 12500,               // 1:12,500 — model in meters
+     *           frozenLayers: ['GRID'],
+     *       }]
+     *   });
+     */
+    addLayout(layout) {
+        if (this.hasLayout(layout.name))
+            throw new Error(`Layout "${layout.name}" already exists.`);
+        this._layouts.push(layout);
+    }
+    /** Get all layout definitions added with addLayout(). */
+    get layouts() { return this._layouts; }
+    /** Names of all layouts: those of the base document (incl. "Model") and added ones. */
+    get layoutNames() {
+        return [...this._templateLayoutNames, ...this._layouts.map(l => l.name)];
+    }
+    /** Check if a layout exists (case-insensitive). */
+    hasLayout(name) {
+        return this.layoutNames.some(n => n.toUpperCase() === name.toUpperCase());
+    }
+    /**
+     * Entity collector for a layout: an existing layout of the base document
+     * (e.g. "Layout1") or one added with addLayout(). "Model" returns model space.
+     */
+    paperspace(name) {
+        if (name.toUpperCase() === 'MODEL')
+            return this._msp;
+        if (!this.hasLayout(name))
+            throw new Error(`Unknown layout "${name}".`);
+        const key = name.toUpperCase();
+        let entry = this._paperspaces.get(key);
+        if (!entry) {
+            entry = { name, space: new Modelspace() };
+            this._paperspaces.set(key, entry);
+        }
+        return entry.space;
+    }
+    // ─── Blocks ───
+    /**
+     * Define (or redefine) a block. Entity coordinates are block-local,
+     * relative to `basePoint`.
+     */
+    addBlockDefinition(name, entities, basePoint = [0, 0]) {
+        if (this._templateBlockNames.has(name)) {
+            throw new Error(`Block "${name}" already exists in the base document.`);
+        }
+        this._blocks.set(name, { name, basePoint, entities });
+    }
+    /** Check if a block exists (in template or user-defined). */
+    hasBlock(name) {
+        return this._blocks.has(name) || this._templateBlockNames.has(name);
+    }
+    /** Get all block names. */
+    getBlockNames() {
+        const names = new Set();
+        for (const name of this._blocks.keys())
+            names.add(name);
+        for (const name of this._templateBlockNames)
+            names.add(name);
+        return Array.from(names);
+    }
+    // ─── Layer Control (ezdxf-style) ───
+    /** Freeze a layer (entities on this layer are hidden and ignored). */
+    freezeLayer(name) {
+        const layer = this._layers.get(name);
+        if (layer)
+            layer.frozen = true;
+    }
+    /** Thaw a layer (undo freeze). */
+    thawLayer(name) {
+        const layer = this._layers.get(name);
+        if (layer)
+            layer.frozen = false;
+    }
+    /** Lock a layer (entities visible but not editable). */
+    lockLayer(name) {
+        const layer = this._layers.get(name);
+        if (layer)
+            layer.locked = true;
+    }
+    /** Unlock a layer. */
+    unlockLayer(name) {
+        const layer = this._layers.get(name);
+        if (layer)
+            layer.locked = false;
+    }
+    /** Turn a layer off (entities hidden but still selectable). */
+    setLayerOff(name) {
+        const layer = this._layers.get(name);
+        if (layer)
+            layer.off = true;
+    }
+    /** Turn a layer on. */
+    setLayerOn(name) {
+        const layer = this._layers.get(name);
+        if (layer)
+            layer.off = false;
+    }
+    /** Set layer color. */
+    setLayerColor(name, color) {
+        const layer = this._layers.get(name);
+        if (layer)
+            layer.color = color;
+    }
+    /** Set layer linetype. */
+    setLayerLinetype(name, linetype) {
+        const layer = this._layers.get(name);
+        if (layer)
+            layer.linetype = linetype;
+    }
+    // ─── HEADER Variables (View/Zoom/Extent) ───
+    _headerVars = new Map();
+    /**
+     * Set a HEADER variable (replaces the base document's value).
+     * @example doc.setHeaderVar('$INSUNITS', [{ code: 70, value: '6' }]); // Meters
+     */
+    setHeaderVar(name, values) {
+        this._headerVars.set(name, values);
+    }
+    /**
+     * Set the drawing extents (bounding box).
+     * This controls the initial zoom-to-extents view in CAD software.
+     * Equivalent to ezdxf: doc.header['$EXTMIN'] / doc.header['$EXTMAX']
+     */
+    setExtents(minX, minY, maxX, maxY) {
+        this._headerVars.set('$EXTMIN', [
+            { code: 10, value: String(minX) },
+            { code: 20, value: String(minY) },
+            { code: 30, value: '0' },
+        ]);
+        this._headerVars.set('$EXTMAX', [
+            { code: 10, value: String(maxX) },
+            { code: 20, value: String(maxY) },
+            { code: 30, value: '0' },
+        ]);
+    }
+    /**
+     * Auto-calculate extents from all entities in modelspace.
+     * Scans all entity coordinates and sets $EXTMIN/$EXTMAX accordingly.
+     */
+    zoomExtents(padding = 0) {
+        const bounds = this._calculateBounds();
+        if (bounds) {
+            this.setExtents(bounds.minX - padding, bounds.minY - padding, bounds.maxX + padding, bounds.maxY + padding);
+            this.setViewCenter((bounds.minX + bounds.maxX) / 2, (bounds.minY + bounds.maxY) / 2, Math.max(bounds.maxX - bounds.minX, bounds.maxY - bounds.minY) + padding * 2);
+        }
+    }
+    /**
+     * Set the view center and height (zoom level) for the initial view.
+     * Equivalent to ezdxf setting $VIEWCTR and $VIEWSIZE.
+     */
+    setViewCenter(x, y, viewHeight) {
+        this._headerVars.set('$VIEWCTR', [
+            { code: 10, value: String(x) },
+            { code: 20, value: String(y) },
+        ]);
+        if (viewHeight !== undefined) {
+            this._headerVars.set('$VIEWSIZE', [
+                { code: 40, value: String(viewHeight) },
+            ]);
+        }
+    }
+    /**
+     * Zoom to a specific window (rectangle).
+     */
+    zoomWindow(minX, minY, maxX, maxY) {
+        this.setExtents(minX, minY, maxX, maxY);
+        this.setViewCenter((minX + maxX) / 2, (minY + maxY) / 2, maxY - minY);
+    }
+    /** Access the HEADER vars map (used by serializer). */
+    get headerVars() {
+        return this._headerVars;
+    }
+    /**
+     * Calculate bounding box of all entities in modelspace.
+     */
+    _calculateBounds() {
+        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+        let hasPoints = false;
+        const update = (x, y) => {
+            minX = Math.min(minX, x);
+            minY = Math.min(minY, y);
+            maxX = Math.max(maxX, x);
+            maxY = Math.max(maxY, y);
+            hasPoints = true;
+        };
+        for (const e of this._msp.entities) {
+            switch (e.type) {
+                case 'LINE':
+                    update(e.start[0], e.start[1]);
+                    update(e.end[0], e.end[1]);
+                    break;
+                case 'LWPOLYLINE':
+                    for (const p of e.points)
+                        update(p[0], p[1]);
+                    break;
+                case 'POLYLINE':
+                    for (const p of e.points)
+                        update(p[0], p[1]);
+                    break;
+                case 'CIRCLE':
+                    update(e.center[0] - e.radius, e.center[1] - e.radius);
+                    update(e.center[0] + e.radius, e.center[1] + e.radius);
+                    break;
+                case 'ARC':
+                    update(e.center[0] - e.radius, e.center[1] - e.radius);
+                    update(e.center[0] + e.radius, e.center[1] + e.radius);
+                    break;
+                case 'TEXT':
+                    update(e.position[0], e.position[1]);
+                    break;
+                case 'MTEXT':
+                    update(e.position[0], e.position[1]);
+                    break;
+                case 'INSERT':
+                    update(e.position[0], e.position[1]);
+                    break;
+                case 'POINT':
+                    update(e.position[0], e.position[1]);
+                    break;
+                case 'ELLIPSE':
+                    update(e.center[0], e.center[1]);
+                    break;
+                case 'SPLINE':
+                    for (const p of e.controlPoints)
+                        update(p[0], p[1]);
+                    break;
+                case 'LEADER':
+                    for (const v of e.vertices)
+                        update(v[0], v[1]);
+                    break;
+                case 'HATCH':
+                    for (const b of e.boundaries)
+                        for (const p of b.points)
+                            update(p[0], p[1]);
+                    break;
+                case 'IMAGE': {
+                    const [x, y] = e.insertionPoint;
+                    const [w, h] = e.imageSize;
+                    update(x, y);
+                    update(x + e.uVector[0] * w + e.vVector[0] * h, y + e.uVector[1] * w + e.vVector[1] * h);
+                    break;
+                }
+                case 'DIMENSION':
+                    if (e.point1)
+                        update(e.point1[0], e.point1[1]);
+                    if (e.point2)
+                        update(e.point2[0], e.point2[1]);
+                    break;
+            }
+        }
+        return hasPoints ? { minX, minY, maxX, maxY } : null;
+    }
+    // ─── Backward Compatibility (dxf-writer API shim) ───
+    setActiveLayer(_name) { }
+    drawPolyline(points, closed = false) {
+        this._msp.add_lwpolyline(points, {}, closed);
+    }
+    drawCircle(cx, cy, radius) {
+        this._msp.add_circle([cx, cy], radius);
+    }
+    drawText(x, y, height, rotation, text) {
+        this._msp.add_text(text, { height, rotation }).set_placement([x, y]);
+    }
+    // ─── Serialization ───
+    /** Serialize to DXF string. ✅ Works everywhere. */
+    toDxfString() {
+        const paperspace = new Map();
+        for (const { name, space } of this._paperspaces.values())
+            paperspace.set(name, space.entities);
+        return serializeDocument({
+            rawSections: this._rawSections,
+            modelspace: this._msp.entities,
+            layers: Array.from(this._layers.values()).filter(l => !this._templateLayerNames.has(l.name)),
+            linetypes: Array.from(this._linetypes.values()),
+            styles: Array.from(this._styles.values()).filter(s => !this._templateStyleNames.has(s.name)),
+            blocks: Array.from(this._blocks.values()),
+            layouts: this._layouts,
+            paperspace,
+            headerVars: this._headerVars,
+        });
+    }
+    /**
+     * Save to file (Node.js only).
+     * @throws Error if called in browser environment.
+     */
+    saveas(filePath) {
+        if (!_fs) {
+            throw new Error('DxfDocument.saveas() requires Node.js. ' +
+                'In browser/Angular, use doc.toDxfString() and create a Blob download instead.');
+        }
+        _fs.writeFileSync(filePath, this.toDxfString(), 'utf-8');
+    }
+    /**
+     * Download DXF file in browser.
+     * ✅ Works in Browser/Angular.
+     */
+    downloadAs(filename) {
+        if (typeof window === 'undefined' || typeof document === 'undefined') {
+            throw new Error('DxfDocument.downloadAs() requires a browser environment.');
+        }
+        const blob = new Blob([this.toDxfString()], { type: 'application/dxf' });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = filename;
+        a.click();
+        URL.revokeObjectURL(url);
+    }
+    // ─── Private Methods ───
+    _loadBase(content) {
+        const tpl = readTemplate(content);
+        this._parsedTemplate = tpl.parsed;
+        this._rawSections = tpl.rawSections;
+        this._templateBlockNames = tpl.blockNames;
+        this._templateLayerNames = tpl.layerNames;
+        this._templateStyleNames = new Set(tpl.styles.keys());
+        this._templateLayoutNames = listLayoutNames(tpl.rawSections);
+        for (const [name, def] of tpl.layers)
+            this._layers.set(name, def);
+        for (const [name, def] of tpl.styles)
+            this._styles.set(name, def);
+    }
+    _addDefaultLinetypes() {
+        this._linetypes.set('CONTINUOUS', { name: 'CONTINUOUS', description: 'Solid line', pattern: [] });
+        this._linetypes.set('DASHED', { name: 'DASHED', description: '_ _ _ _', pattern: [0.5, -0.5] });
+        this._linetypes.set('CENTER', { name: 'CENTER', description: '____ _ ____', pattern: [2, -1, 0.5, -1] });
+        this._linetypes.set('PHANTOM', { name: 'PHANTOM', description: '__ __ . __ __', pattern: [2.5, -0.5, 0.5, -0.5, 0.5, -0.5] });
+        this._linetypes.set('HIDDEN', { name: 'HIDDEN', description: '_ _ _ _', pattern: [0.25, -0.125] });
+        this._linetypes.set('DOT', { name: 'DOT', description: '. . . . .', pattern: [0, -0.25] });
+    }
+}