ofs-dxf-ts 1.0.0

package/dist/template/template-injector.js

@@ -0,0 +1,487 @@
+/**
+ * Template injector — emit a DXF by injecting new content into the verbatim
+ * sections of a base document: a user template, or the built-in blank R2018
+ * document for drawings created from scratch.
+ *
+ * Every section of the base is preserved (CLASSES, ACDSDATA, … included); we:
+ *  - allocate new handles above $HANDSEED and write the new $HANDSEED,
+ *  - set or replace HEADER variables,
+ *  - add LTYPE / LAYER / STYLE / BLOCK_RECORD records (existing names are kept),
+ *  - add block definitions and paper space layout blocks to BLOCKS,
+ *  - append model space and active-layout entities to ENTITIES,
+ *  - add LAYOUT / IMAGEDEF / reactor objects and their dictionary entries.
+ *
+ * Only the TABLES, OBJECTS and CLASSES sections are tag-scanned; BLOCKS and
+ * ENTITIES (usually the bulk of a template) are edited by string position.
+ */
+import { blockDefinition, blockRecord, fmt, layerRecord, linetypeRecord, nextHandle, peekHandle, resetHandleCounter, serializeEntity, textStyleRecord, } from '../core/dxf-serializer.js';
+/** Split a section into records, each starting at a group code 0 tag. */
+function scanRecords(section) {
+    const records = [];
+    let cur = null;
+    let pos = 0;
+    while (pos < section.length) {
+        const codeEnd = section.indexOf('\n', pos);
+        if (codeEnd === -1)
+            break;
+        let valueEnd = section.indexOf('\n', codeEnd + 1);
+        if (valueEnd === -1)
+            valueEnd = section.length;
+        const code = section.substring(pos, codeEnd);
+        const value = section.substring(codeEnd + 1, valueEnd);
+        if (code === '0') {
+            if (cur) {
+                cur.end = pos;
+                records.push(cur);
+            }
+            cur = { type: value, handle: '', tags: [], start: pos, end: section.length };
+        }
+        else if (cur) {
+            if (!cur.handle && (code === '5' || code === '105'))
+                cur.handle = value;
+            cur.tags.push([code, value]);
+        }
+        pos = valueEnd + 1;
+    }
+    if (cur)
+        records.push(cur);
+    return records;
+}
+function tag(r, code) {
+    return r.tags.find(t => t[0] === code)?.[1];
+}
+function dictEntries(r) {
+    const out = new Map();
+    for (let i = 0; i < r.tags.length - 1; i++) {
+        const next = r.tags[i + 1][0];
+        if (r.tags[i][0] === '3' && (next === '350' || next === '360'))
+            out.set(r.tags[i][1], r.tags[i + 1][1]);
+    }
+    return out;
+}
+function scanTables(tables) {
+    const out = new Map();
+    let cur = null;
+    for (const r of scanRecords(tables)) {
+        if (r.type === 'TABLE') {
+            cur = { handle: r.handle, endtab: -1, names: new Map() };
+            out.set((tag(r, '2') ?? '').toUpperCase(), cur);
+        }
+        else if (r.type === 'ENDTAB') {
+            if (cur)
+                cur.endtab = r.start;
+            cur = null;
+        }
+        else if (cur) {
+            const name = tag(r, '2');
+            if (name !== undefined)
+                cur.names.set(name.toUpperCase(), { name, handle: r.handle });
+        }
+    }
+    return out;
+}
+function scanLayouts(objects) {
+    const out = [];
+    for (const r of objects) {
+        if (r.type !== 'LAYOUT')
+            continue;
+        const i = r.tags.findIndex(t => t[0] === '100' && t[1] === 'AcDbLayout');
+        if (i === -1)
+            continue;
+        const rest = r.tags.slice(i + 1);
+        out.push({
+            name: rest.find(t => t[0] === '1')?.[1] ?? '',
+            handle: r.handle,
+            blockRecord: rest.find(t => t[0] === '330')?.[1] ?? '',
+            tabOrder: Number(rest.find(t => t[0] === '71')?.[1] ?? 0),
+        });
+    }
+    return out;
+}
+/** Names of the layouts (tabs) defined in a base document, including "Model". */
+export function listLayoutNames(rawSections) {
+    const objects = rawSections.get('OBJECTS');
+    return objects ? scanLayouts(scanRecords(objects)).map(l => l.name) : [];
+}
+function maxHandle(raw) {
+    let max = 0;
+    for (const section of raw.values()) {
+        const lines = section.split('\n');
+        for (let i = 0; i + 1 < lines.length; i += 2) {
+            if (lines[i] === '5' || lines[i] === '105')
+                max = Math.max(max, parseInt(lines[i + 1], 16) || 0);
+        }
+    }
+    return max;
+}
+// ─── Section editing ───
+/** Batched string insertions, applied in one pass. Inserted text must end with "\n". */
+class Edits {
+    items = [];
+    insert(at, text) {
+        this.items.push({ at, text, seq: this.items.length });
+    }
+    apply(s) {
+        if (!this.items.length)
+            return s;
+        const sorted = [...this.items].sort((a, b) => a.at - b.at || a.seq - b.seq);
+        const out = [];
+        let pos = 0;
+        for (const it of sorted) {
+            out.push(s.slice(pos, it.at), it.text);
+            pos = it.at;
+        }
+        out.push(s.slice(pos));
+        return out.join('');
+    }
+}
+function insertBeforeEndsec(section, text) {
+    if (!text)
+        return section;
+    const i = section.lastIndexOf('\n0\nENDSEC');
+    return i === -1 ? section : section.slice(0, i + 1) + text + '\n' + section.slice(i + 1);
+}
+function emptySection(name) {
+    return `0\nSECTION\n2\n${name}\n0\nENDSEC`;
+}
+/** Offset of the ENDBLK record closing block `name`, or -1. */
+function findBlockEnd(blocks, name) {
+    const begin = blocks.indexOf(`\nAcDbBlockBegin\n2\n${name}\n`);
+    if (begin === -1)
+        return -1;
+    const end = blocks.indexOf('\n0\nENDBLK\n', begin);
+    return end === -1 ? -1 : end + 1;
+}
+function readHeaderVar(header, name) {
+    const lines = header.split('\n');
+    for (let i = 4; i + 3 < lines.length; i += 2) {
+        if (lines[i] === '9' && lines[i + 1] === name)
+            return lines[i + 3];
+    }
+    return undefined;
+}
+/** Set (replace or append) a HEADER variable, pair-aware. */
+function setHeaderVar(header, name, values) {
+    const lines = header.split('\n');
+    const block = ['9', name, ...values.flatMap(v => [String(v.code), v.value])];
+    let start = -1;
+    // lines: 0 SECTION 2 HEADER (9 $NAME code value …)* 0 ENDSEC
+    for (let i = 4; i + 1 < lines.length; i += 2) {
+        if (lines[i] !== '9' && lines[i] !== '0')
+            continue;
+        if (start !== -1) {
+            lines.splice(start, i - start, ...block);
+            return lines.join('\n');
+        }
+        if (lines[i] === '9' && lines[i + 1] === name)
+            start = i;
+    }
+    lines.splice(lines.length - 2, 0, ...block);
+    return lines.join('\n');
+}
+// ─── Object writers ───
+const CLASS_DEFS = {
+    IMAGE: ['AcDbRasterImage', 'ISM', 2175, 0, 1],
+    IMAGEDEF: ['AcDbRasterImageDef', 'ISM', 0, 0, 0],
+    IMAGEDEF_REACTOR: ['AcDbRasterImageDefReactor', 'ISM', 1, 0, 0],
+    RASTERVARIABLES: ['AcDbRasterVariables', 'ISM', 0, 0, 0],
+};
+function classRecord(name) {
+    const [cpp, app, flags, wasProxy, isEntity] = CLASS_DEFS[name];
+    return ['0', 'CLASS', '1', name, '2', cpp, '3', app, '90', String(flags), '91', '0',
+        '280', String(wasProxy), '281', String(isEntity)].join('\n');
+}
+function dictionaryObject(handle, owner, entries) {
+    return ['0', 'DICTIONARY', '5', handle, '102', '{ACAD_REACTORS', '330', owner, '102', '}',
+        '330', owner, '100', 'AcDbDictionary', '281', '1', ...entries].join('\n');
+}
+function imageDefObject(handle, owner, path, image, reactors) {
+    return ['0', 'IMAGEDEF', '5', handle,
+        '102', '{ACAD_REACTORS', '330', owner, ...reactors.flatMap(r => ['330', r]), '102', '}',
+        '330', owner, '100', 'AcDbRasterImageDef', '90', '0', '1', path,
+        '10', String(image.imageSize[0]), '20', String(image.imageSize[1]),
+        '11', fmt(Math.hypot(...image.uVector)), '21', fmt(Math.hypot(...image.vVector)),
+        '280', '1', '281', '0'].join('\n');
+}
+function imageDefReactorObject(handle, imageHandle) {
+    return ['0', 'IMAGEDEF_REACTOR', '5', handle, '330', imageHandle,
+        '100', 'AcDbRasterImageDefReactor', '90', '2', '330', imageHandle].join('\n');
+}
+/** $INSUNITS → RASTERVARIABLES units (0 none, 1 mm, 2 cm, 3 m, 4 km, 5 in, 6 ft, 7 yd, 8 mi). */
+const RASTER_UNITS = { '4': 1, '5': 2, '6': 3, '7': 4, '1': 5, '2': 6, '10': 7, '3': 8 };
+function rasterVariablesObject(handle, owner, insUnits) {
+    return ['0', 'RASTERVARIABLES', '5', handle, '102', '{ACAD_REACTORS', '330', owner, '102', '}',
+        '330', owner, '100', 'AcDbRasterVariables', '90', '0',
+        '70', '0', '71', '1', '72', String(RASTER_UNITS[insUnits ?? ''] ?? 0)].join('\n');
+}
+function layoutObject(def, handle, owner, blockRecordHandle, viewportHandle, tabOrder) {
+    const [ml, mb, mr, mt] = def.margins;
+    const w = def.paperWidth, h = def.paperHeight;
+    return ['0', 'LAYOUT', '5', handle, '102', '{ACAD_REACTORS', '330', owner, '102', '}', '330', owner,
+        '100', 'AcDbPlotSettings',
+        '1', '', '2', 'DWG To PDF.pc3', '4', `onfarm_(${w.toFixed(2)}_x_${h.toFixed(2)}_MM)`, '6', '',
+        '40', fmt(ml), '41', fmt(mb), '42', fmt(mr), '43', fmt(mt), '44', fmt(w), '45', fmt(h),
+        '46', '0', '47', '0', '48', '0', '49', '0', '140', '0', '141', '0', '142', '1', '143', '1',
+        '70', '672', '72', '1', '73', '0', '74', '5', '7', '', '75', '16', '147', '1',
+        '76', '0', '77', '2', '78', '300', '148', '0', '149', '0',
+        '100', 'AcDbLayout', '1', def.name, '70', '1', '71', String(tabOrder),
+        '10', fmt(-ml), '20', fmt(-mb), '11', fmt(w - ml), '21', fmt(h - mb),
+        '12', '0', '22', '0', '32', '0',
+        '14', '1.0E+20', '24', '1.0E+20', '34', '1.0E+20',
+        '15', '-1.0E+20', '25', '-1.0E+20', '35', '-1.0E+20',
+        '146', '0', '13', '0', '23', '0', '33', '0',
+        '16', '1', '26', '0', '36', '0', '17', '0', '27', '1', '37', '0',
+        '76', '0', '330', blockRecordHandle, '331', viewportHandle].join('\n');
+}
+/** The overall paper space viewport AutoCAD keeps as viewport #1 of a layout. */
+function mainViewport(def, layer) {
+    const [ml, mb, mr, mt] = def.margins;
+    const center = [(def.paperWidth - ml - mr) / 2, (def.paperHeight - mb - mt) / 2];
+    return {
+        type: 'VIEWPORT', layer, handle: nextHandle(), center,
+        width: def.paperWidth * 1.1, height: def.paperHeight * 1.1,
+        viewCenter: center, viewHeight: def.paperHeight * 1.1, status: 1, id: 1,
+    };
+}
+function viewportFromDef(v, id, layer) {
+    const viewHeight = v.viewHeight ?? (v.scale !== undefined ? v.height * v.scale * (v.unitFactor ?? 0.001) : undefined);
+    if (viewHeight === undefined)
+        throw new Error('A layout viewport needs `viewHeight` or `scale`.');
+    return {
+        type: 'VIEWPORT', layer, center: v.center, width: v.width, height: v.height,
+        viewCenter: v.viewCenter, viewHeight, status: id, id,
+        frozenLayers: v.frozenLayers, locked: v.locked,
+    };
+}
+// ─── Main entry ───
+export function serializeDocument(doc) {
+    const raw = doc.rawSections;
+    let header = raw.get('HEADER') ?? emptySection('HEADER');
+    const seed = parseInt(readHeaderVar(header, '$HANDSEED') ?? '', 16);
+    resetHandleCounter(Number.isFinite(seed) && seed > 0 ? seed : maxHandle(raw) + 1);
+    const tablesRaw = raw.get('TABLES') ?? '';
+    const objectsRaw = raw.get('OBJECTS') ?? '';
+    const blocksRaw = raw.get('BLOCKS') ?? emptySection('BLOCKS');
+    const tableEdits = new Edits();
+    const objectEdits = new Edits();
+    const blockEdits = new Edits();
+    const newObjects = [];
+    const newBlocks = [];
+    let classes = raw.get('CLASSES');
+    const tables = scanTables(tablesRaw);
+    const objects = scanRecords(objectsRaw);
+    const objectsByHandle = new Map(objects.filter(r => r.handle).map(r => [r.handle, r]));
+    const root = objects.find(r => r.type === 'DICTIONARY');
+    const rootEntries = root ? dictEntries(root) : new Map();
+    /** Object named `name` in the root dictionary, if present. */
+    const rootObject = (name) => {
+        const handle = rootEntries.get(name);
+        return handle ? objectsByHandle.get(handle) : undefined;
+    };
+    const dictEntry = (dictName, entry) => {
+        const d = rootObject(dictName);
+        return d ? dictEntries(d).get(entry) : undefined;
+    };
+    const blockRecords = tables.get('BLOCK_RECORD');
+    const requireStructure = (feature) => {
+        if (!blockRecords || !root) {
+            throw new Error(`${feature} need a DXF R2000+ base document (BLOCK_RECORD table and OBJECTS section).`);
+        }
+    };
+    /** Add a table record unless the name exists; returns the record handle. */
+    const addRecord = (tableName, name, write) => {
+        const table = tables.get(tableName);
+        if (!table)
+            return undefined;
+        const existing = table.names.get(name.toUpperCase());
+        if (existing)
+            return existing.handle;
+        const handle = nextHandle();
+        table.names.set(name.toUpperCase(), { name, handle });
+        tableEdits.insert(table.endtab, write(handle, table.handle) + '\n');
+        return handle;
+    };
+    // ── Linetypes, layers, text styles ──
+    for (const lt of doc.linetypes ?? [])
+        addRecord('LTYPE', lt.name, (h, o) => linetypeRecord(lt, h, o));
+    const linetypes = tables.get('LTYPE');
+    const layerRefs = { plotStyle: dictEntry('ACAD_PLOTSTYLENAME', 'Normal'), material: dictEntry('ACAD_MATERIAL', 'Global') };
+    for (const l of doc.layers ?? []) {
+        const known = !linetypes || linetypes.names.has((l.linetype || '').toUpperCase());
+        const layer = known ? l : { ...l, linetype: 'Continuous' };
+        addRecord('LAYER', l.name, (h, o) => layerRecord(layer, h, o, layerRefs));
+    }
+    for (const s of doc.styles ?? [])
+        addRecord('STYLE', s.name, (h, o) => textStyleRecord(s, h, o));
+    const layerHandles = new Map([...(tables.get('LAYER')?.names ?? new Map())].map(([k, v]) => [k, v.handle]));
+    // ── Block definitions ──
+    const blocks = doc.blocks ?? [];
+    if (blocks.length)
+        requireStructure('Block definitions');
+    const blockHandles = blocks.map(b => {
+        if (blockRecords.names.has(b.name.toUpperCase())) {
+            throw new Error(`Block "${b.name}" already exists in the base document.`);
+        }
+        return addRecord('BLOCK_RECORD', b.name, (h, o) => blockRecord(b.name, h, o));
+    });
+    const layouts = new Map();
+    const existingLayouts = scanLayouts(objects);
+    for (const l of existingLayouts) {
+        const br = [...(blockRecords?.names.values() ?? [])].find(v => v.handle === l.blockRecord);
+        layouts.set(l.name.toUpperCase(), {
+            name: l.name, blockRecord: l.blockRecord, blockName: br?.name ?? '',
+            isNew: false, entities: [], nextViewportId: 50,
+        });
+    }
+    const viewportLayer = layerHandles.has('DEFPOINTS') ? 'Defpoints' : '0';
+    let tabOrder = Math.max(0, ...existingLayouts.map(l => l.tabOrder));
+    for (const def of doc.layouts ?? []) {
+        requireStructure('Layouts');
+        const layoutDict = rootObject('ACAD_LAYOUT');
+        if (!layoutDict)
+            throw new Error('The base document has no ACAD_LAYOUT dictionary.');
+        if (layouts.has(def.name.toUpperCase()))
+            throw new Error(`Layout "${def.name}" already exists.`);
+        let n = 0;
+        while (blockRecords.names.has(`*PAPER_SPACE${n}`))
+            n++;
+        const blockName = `*Paper_Space${n}`;
+        const handle = nextHandle();
+        const br = addRecord('BLOCK_RECORD', blockName, (h, o) => blockRecord(blockName, h, o, handle));
+        const main = mainViewport(def, viewportLayer);
+        const viewports = def.viewports.map((v, i) => viewportFromDef(v, i + 2, viewportLayer));
+        layouts.set(def.name.toUpperCase(), {
+            name: def.name, blockRecord: br, blockName, isNew: true,
+            entities: [main, ...viewports], nextViewportId: viewports.length + 2,
+        });
+        objectEdits.insert(layoutDict.end, `3\n${def.name}\n350\n${handle}\n`);
+        newObjects.push(layoutObject(def, handle, layoutDict.handle, br, main.handle, ++tabOrder));
+    }
+    for (const [name, entities] of doc.paperspace ?? []) {
+        const layout = layouts.get(name.toUpperCase());
+        if (!layout)
+            throw new Error(`Unknown layout "${name}".`);
+        for (const e of entities) {
+            layout.entities.push(e.type === 'VIEWPORT' && e.id === undefined ? { ...e, id: layout.nextViewportId++ } : e);
+        }
+    }
+    // ── Images: IMAGEDEF per file, reactor per IMAGE ──
+    const images = new Map();
+    const imageDefs = new Map();
+    const entityLists = [doc.modelspace, ...blocks.map(b => b.entities), ...[...layouts.values()].map(l => l.entities)];
+    for (const list of entityLists) {
+        for (const e of list) {
+            if (e.type !== 'IMAGE' || images.has(e))
+                continue;
+            let def = imageDefs.get(e.imagePath);
+            if (!def) {
+                def = { handle: nextHandle(), image: e, reactors: [] };
+                imageDefs.set(e.imagePath, def);
+            }
+            const refs = { handle: nextHandle(), defHandle: def.handle, reactorHandle: nextHandle() };
+            def.reactors.push(refs.reactorHandle);
+            images.set(e, refs);
+            newObjects.push(imageDefReactorObject(refs.reactorHandle, refs.handle));
+        }
+    }
+    if (imageDefs.size) {
+        requireStructure('Images');
+        const existingDict = rootObject('ACAD_IMAGE_DICT');
+        const dictHandle = existingDict?.handle ?? nextHandle();
+        const used = new Set([...(existingDict ? dictEntries(existingDict).keys() : [])].map(n => n.toUpperCase()));
+        const entries = [];
+        for (const [path, def] of imageDefs) {
+            const base = path.split(/[\\/]/).pop().replace(/\.[^.]*$/, '') || 'image';
+            let name = base;
+            for (let i = 1; used.has(name.toUpperCase()); i++)
+                name = `${base}_${i}`;
+            used.add(name.toUpperCase());
+            entries.push('3', name, '350', def.handle);
+            newObjects.push(imageDefObject(def.handle, dictHandle, path, def.image, def.reactors));
+        }
+        if (existingDict) {
+            objectEdits.insert(existingDict.end, entries.join('\n') + '\n');
+        }
+        else {
+            newObjects.push(dictionaryObject(dictHandle, root.handle, entries));
+            objectEdits.insert(root.end, `3\nACAD_IMAGE_DICT\n350\n${dictHandle}\n`);
+        }
+        if (!rootEntries.has('ACAD_IMAGE_VARS')) {
+            const h = nextHandle();
+            newObjects.push(rasterVariablesObject(h, root.handle, readHeaderVar(header, '$INSUNITS')));
+            objectEdits.insert(root.end, `3\nACAD_IMAGE_VARS\n350\n${h}\n`);
+        }
+        const present = new Set(scanRecords(classes ?? '').filter(r => r.type === 'CLASS').map(r => tag(r, '1')));
+        const missing = Object.keys(CLASS_DEFS).filter(n => !present.has(n)).map(classRecord).join('\n');
+        if (missing)
+            classes = insertBeforeEndsec(classes ?? emptySection('CLASSES'), missing);
+    }
+    // ── Serialize content ──
+    const base = { images, layerHandles };
+    const modelOwner = blockRecords?.names.get('*MODEL_SPACE')?.handle;
+    const entityText = doc.modelspace.map(e => serializeEntity(e, { ...base, owner: modelOwner }));
+    blocks.forEach((b, i) => newBlocks.push(blockDefinition(b.name, blockHandles[i], b.basePoint, b.entities, base)));
+    for (const layout of layouts.values()) {
+        if (!layout.entities.length)
+            continue;
+        const blockUpper = layout.blockName.toUpperCase();
+        if (blockUpper === '*MODEL_SPACE') {
+            entityText.push(...layout.entities.map(e => serializeEntity(e, { ...base, owner: modelOwner })));
+            continue;
+        }
+        const ctx = { ...base, owner: layout.blockRecord, paperSpace: true };
+        if (layout.isNew) {
+            newBlocks.push(blockDefinition(layout.blockName, layout.blockRecord, [0, 0], layout.entities, ctx));
+        }
+        else if (blockUpper === '*PAPER_SPACE') {
+            entityText.push(...layout.entities.map(e => serializeEntity(e, ctx)));
+        }
+        else {
+            const at = findBlockEnd(blocksRaw, layout.blockName);
+            if (at === -1)
+                throw new Error(`Paper space block for layout "${layout.name}" not found.`);
+            blockEdits.insert(at, layout.entities.map(e => serializeEntity(e, ctx)).join('\n') + '\n');
+        }
+    }
+    // ── Header (last: $HANDSEED must cover every handle allocated above) ──
+    for (const [name, values] of doc.headerVars ?? [])
+        header = setHeaderVar(header, name, values);
+    header = setHeaderVar(header, '$HANDSEED', [{ code: 5, value: peekHandle() }]);
+    // ── Assemble in base-document section order ──
+    if (newObjects.length && objectsRaw) {
+        objectEdits.insert(objectsRaw.lastIndexOf('\n0\nENDSEC') + 1, newObjects.join('\n') + '\n');
+    }
+    const order = [...raw.keys()];
+    const ensureSection = (name, after) => {
+        if (order.includes(name))
+            return;
+        const i = order.indexOf(after);
+        order.splice(i === -1 ? order.length : i + 1, 0, name);
+    };
+    if (!order.includes('HEADER'))
+        order.unshift('HEADER');
+    if (classes)
+        ensureSection('CLASSES', 'HEADER');
+    if (newBlocks.length)
+        ensureSection('BLOCKS', order.includes('TABLES') ? 'TABLES' : 'HEADER');
+    ensureSection('ENTITIES', order.includes('BLOCKS') ? 'BLOCKS' : 'HEADER');
+    const body = (name) => {
+        switch (name) {
+            case 'HEADER': return header;
+            case 'CLASSES': return classes;
+            case 'TABLES': return tableEdits.apply(tablesRaw);
+            case 'BLOCKS': return insertBeforeEndsec(blockEdits.apply(blocksRaw), newBlocks.join('\n'));
+            case 'ENTITIES': return insertBeforeEndsec(raw.get('ENTITIES') ?? emptySection('ENTITIES'), entityText.join('\n'));
+            case 'OBJECTS': return objectEdits.apply(objectsRaw);
+            default: return raw.get(name);
+        }
+    };
+    return order.map(body).join('\n') + '\n0\nEOF\n';
+}
+/**
+ * Inject entities and layers into a template.
+ * @deprecated Use `serializeDocument`, which also handles blocks, images and layouts.
+ */
+export function serializeWithTemplate(rawSections, newEntities, newLayers, headerVars) {
+    return serializeDocument({ rawSections, modelspace: newEntities, layers: newLayers, headerVars });
+}

package/dist/template/template-reader.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Template reader — parse a DXF template string into structured data.
+ *
+ * Two parallel views of the template are produced:
+ *  1. `parsed`       — the internal parser's structured object (for indexing).
+ *  2. `rawSections`  — the verbatim text of each SECTION, so the template can be
+ *                      re-emitted byte-for-byte and new entities injected into it
+ *                      (see template-injector). This is what preserves the
+ *                      original AutoCAD/Civil3D layers, blocks and styles exactly.
+ */
+import { ParsedDxf } from '../parser/index.js';
+import { LayerDef, TextStyleDef } from '../core/dxf-entities.js';
+export interface TemplateData {
+    /** Structured parse result (may be partial if parsing warned). */
+    parsed: ParsedDxf | null;
+    /** Verbatim text of each SECTION, keyed by section name (HEADER, TABLES, …). */
+    rawSections: Map<string, string>;
+    /** Block names defined in the template. */
+    blockNames: Set<string>;
+    /** Layer names defined in the template. */
+    layerNames: Set<string>;
+    /** Indexed layer definitions. */
+    layers: Map<string, LayerDef>;
+    /** Indexed text style definitions. */
+    styles: Map<string, TextStyleDef>;
+}
+/** Parse a DXF template string. */
+export declare function readTemplate(content: string): TemplateData;

package/dist/template/template-reader.js

@@ -0,0 +1,80 @@
+/**
+ * Template reader — parse a DXF template string into structured data.
+ *
+ * Two parallel views of the template are produced:
+ *  1. `parsed`       — the internal parser's structured object (for indexing).
+ *  2. `rawSections`  — the verbatim text of each SECTION, so the template can be
+ *                      re-emitted byte-for-byte and new entities injected into it
+ *                      (see template-injector). This is what preserves the
+ *                      original AutoCAD/Civil3D layers, blocks and styles exactly.
+ */
+import { DxfParser } from '../parser/index.js';
+/** Parse a DXF template string. */
+export function readTemplate(content) {
+    const data = {
+        parsed: null,
+        rawSections: new Map(),
+        blockNames: new Set(),
+        layerNames: new Set(),
+        layers: new Map(),
+        styles: new Map(),
+    };
+    // 1. Structured parse (best-effort).
+    const parser = new DxfParser();
+    try {
+        data.parsed = parser.parseSync(content);
+    }
+    catch (e) {
+        console.warn('DXF parser warning: partial parse.', e.message);
+    }
+    // 2. Extract raw sections for pass-through serialization.
+    extractRawSections(content, data.rawSections);
+    // 3. Index blocks / layers / styles from the parsed template.
+    indexTemplate(data);
+    return data;
+}
+function extractRawSections(content, into) {
+    const normalized = content
+        .replace(/\r\n/g, '\n')
+        .replace(/\r/g, '\n')
+        .split('\n')
+        .map(line => line.trim())
+        .join('\n');
+    const sectionRegex = /0\nSECTION\n2\n(\w+)\n([\s\S]*?)0\nENDSEC/g;
+    let match;
+    while ((match = sectionRegex.exec(normalized)) !== null) {
+        into.set(match[1], match[0]);
+    }
+}
+function indexTemplate(data) {
+    const parsed = data.parsed;
+    if (!parsed)
+        return;
+    if (parsed.blocks) {
+        for (const blockName in parsed.blocks) {
+            data.blockNames.add(blockName);
+        }
+    }
+    if (parsed.tables?.layer?.layers) {
+        for (const layerName in parsed.tables.layer.layers) {
+            data.layerNames.add(layerName);
+            const ld = parsed.tables.layer.layers[layerName];
+            data.layers.set(layerName, {
+                name: layerName,
+                color: ld.color || 7,
+                linetype: ld.lineType || 'CONTINUOUS',
+            });
+        }
+    }
+    if (parsed.tables?.style?.styles) {
+        // The parser keys STYLE records by name (not an array).
+        for (const style of Object.values(parsed.tables.style.styles)) {
+            if (style.styleName) {
+                data.styles.set(style.styleName, {
+                    name: style.styleName,
+                    font: style.font || style.styleName,
+                });
+            }
+        }
+    }
+}

package/dist/types/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Generic, API-agnostic types for the DXF library.
+ *
+ * These describe pure geometry/styling primitives only. They deliberately
+ * carry no knowledge of any backend API or project-specific JSON shape —
+ * the consuming application maps its own data into these types.
+ */
+/** A 2D coordinate: [x, y]. */
+export type Coordinate = [number, number];
+/** A 3D coordinate: [x, y, z]. */
+export type Coordinate3D = [number, number, number];
+/**
+ * A styled polyline produced by symbol/geometry helpers.
+ * Generic building block — a list of points plus drawing style.
+ */
+export interface OnfarmLine {
+    coordinate: Coordinate3D[];
+    /** Linetype name, e.g. 'CONTINUOUS', 'DASHED'. */
+    type: string;
+    /** Line width. */
+    width: number;
+    /** ACI color index. */
+    color: number;
+}

package/dist/types/index.js

@@ -0,0 +1,8 @@
+/**
+ * Generic, API-agnostic types for the DXF library.
+ *
+ * These describe pure geometry/styling primitives only. They deliberately
+ * carry no knowledge of any backend API or project-specific JSON shape —
+ * the consuming application maps its own data into these types.
+ */
+export {};