dxf-json 0.0.1

package/src/parser/DxfParser.ts

@@ -0,0 +1,108 @@
+import DxfArrayScanner from './DxfArrayScanner';
+import { parseHeader } from './header';
+import { parseTables } from './tables';
+import { parseBlocks } from './blocks';
+import { parseEntities } from './entities';
+import { parseObjects } from './objects';
+import { isMatched } from './shared';
+import { filterDummyBlocks } from './filterDummyBlocks';
+import type { ParsedDxf } from './types';
+import { Readable } from 'readable-stream';
+export default class DxfParser {
+    parseSync(dxfString: string) {
+        const dxfLinesArray = dxfString.split(/\r\n|\r|\n/g);
+        const scanner = new DxfArrayScanner(dxfLinesArray);
+        if (!scanner.hasNext()) {
+            throw Error('Empty file');
+        }
+
+        return this.parseAll(scanner);
+    }
+    parseStream(stream: Readable) {
+        let dxfString = "";
+        const self = this;
+        return new Promise<ParsedDxf>((res, rej) => {
+            stream.on('data', (chunk) => {
+                dxfString += chunk;
+            });
+            stream.on('end', () => {
+                try {
+                    const dxfLinesArray = dxfString.split(/\r\n|\r|\n/g);
+                    const scanner = new DxfArrayScanner(dxfLinesArray);
+                    if (!scanner.hasNext()) {
+                        throw Error('Empty file');
+                    }
+                    res(self.parseAll(scanner));
+                } catch (err) {
+                    rej(err);
+                }
+            });
+            stream.on('error', (err) => {
+                rej(err);
+            });
+        });
+    }
+
+    async parseFromUrl(url: string, encoding = "utf-8", init?: RequestInit | undefined) {
+        const response = await fetch(url, init)
+
+        if (!response.body) return null;
+
+        const reader = response.body.getReader()
+        let buffer = ""
+        let decoder = new TextDecoder(encoding)
+
+        while (true) {
+            const { done, value } = await reader.read()
+            if (done) {
+                buffer += decoder.decode(new ArrayBuffer(0), { stream: false })
+                break
+            }
+            buffer += decoder.decode(value, { stream: true })
+        }
+        return this.parseSync(buffer)
+    }
+
+
+    parseAll(scanner: DxfArrayScanner) {
+        const dxf: ParsedDxf = {
+            // @ts-ignore
+            header: {},
+            blocks: {},
+            entities: [],
+            tables: {},
+            objects: {
+                byName: {},
+                byTree: undefined,
+            },
+        };
+        let curr = scanner.next();
+
+        while (!isMatched(curr, 0, 'EOF')) {
+            if (isMatched(curr, 0, 'SECTION')) {
+                curr = scanner.next();
+
+                if (isMatched(curr, 2, 'HEADER')) {
+                    curr = scanner.next();
+                    dxf.header = parseHeader(curr, scanner);
+                } else if (isMatched(curr, 2, 'BLOCKS')) {
+                    curr = scanner.next();
+                    dxf.blocks = parseBlocks(curr, scanner);
+                }
+                else if (isMatched(curr, 2, 'ENTITIES')) {
+                    curr = scanner.next();
+                    dxf.entities = parseEntities(curr, scanner);
+                }
+                else if (isMatched(curr, 2, 'TABLES')) {
+                    curr = scanner.next();
+                    dxf.tables = parseTables(curr, scanner);
+                } else if (isMatched(curr, 2, 'OBJECTS')) {
+                    curr = scanner.next();
+                    dxf.objects = parseObjects(curr, scanner);
+                }
+            }
+            curr = scanner.next();
+        }
+        return filterDummyBlocks(dxf);
+    }
+}

package/src/parser/ParseHelpers.ts

@@ -0,0 +1,124 @@
+import AUTO_CAD_COLOR_INDEX from './AutoCadColorIndex';
+import DxfArrayScanner, { ScannerGroup } from './DxfArrayScanner';
+import { CommonDxfEntity, skipApplicationGroups } from './entities/shared';
+import { ViewportEntity } from './entities/viewport/types';
+import { isMatched } from './shared';
+import { parseXData } from './shared/xdata';
+
+/**
+ * Returns the truecolor value of the given AutoCad color index value
+ * @param {import('../types').ColorIndex} index
+ * @return {import('../types').ColorInstance} truecolor value as a number
+ */
+export function getAcadColor(index: number) {
+    return AUTO_CAD_COLOR_INDEX[index];
+}
+
+/** Some entities may contain embedded object which is started by group 101. All the rest data until
+ * end of entity should not be interpreted as entity attributes. There is no documentation for this
+ * feature.
+ * @param scanner
+ */
+export function skipEmbeddedObject(scanner: DxfArrayScanner) {
+    /* Ensure proper start group. */
+    scanner.rewind();
+    let curr = scanner.next();
+    if (curr.code !== 101) {
+        throw new Error('Bad call for skipEmbeddedObject()');
+    }
+    do {
+        curr = scanner.next();
+    } while (curr.code !== 0);
+    scanner.rewind();
+}
+
+/**
+ * Attempts to parse codes common to all entities. Returns true if the group
+ * was handled by this function.
+ * @param {*} entity - the entity currently being parsed
+ * @param {*} curr - the current group being parsed
+ */
+export function checkCommonEntityProperties(entity: CommonDxfEntity, curr: ScannerGroup, scanner: DxfArrayScanner) {
+    if (isMatched(curr, 102)) {
+        skipApplicationGroups(curr, scanner);
+        return true;
+    }
+
+    switch (curr.code) {
+        case 0:
+            entity.type = curr.value as string;
+            break;
+        case 5:
+            entity.handle = curr.value as string;
+            break;
+        case 330:
+            if (!entity.ownerDictionarySoftId) {
+                entity.ownerDictionarySoftId = curr.value;
+            } else {
+                entity.ownerBlockRecordSoftId = curr.value;
+            }
+            break;
+        case 360:
+            entity.ownerdictionaryHardId = curr.value;
+            break;
+        case 67:
+            entity.isInPaperSpace = !!curr.value;
+            break;
+        case 8:
+            entity.layer = curr.value;
+            break;
+        // Code 6 of an entity indicates inheritance of properties (eg. color).
+        //   BYBLOCK means inherits from block
+        //   BYLAYER (default) mean inherits from layer
+        case 6:
+            entity.lineType = curr.value;
+            break;
+        case 347:
+            entity.materialObjectHardId = curr.value;
+            break;
+        case 62: // Acad Index Color. 0 inherits ByBlock. 256 inherits ByLayer. Default is bylayer
+            entity.colorIndex = curr.value;
+            entity.color = getAcadColor(Math.abs(curr.value));
+            break;
+        case 370:
+            //From https://www.woutware.com/Forum/Topic/955/lineweight?returnUrl=%2FForum%2FUserPosts%3FuserId%3D478262319
+            // An integer representing 100th of mm, must be one of the following values:
+            // 0, 5, 9, 13, 15, 18, 20, 25, 30, 35, 40, 50, 53, 60, 70, 80, 90, 100, 106, 120, 140, 158, 200, 211.
+            // -3 = STANDARD, -2 = BYLAYER, -1 = BYBLOCK
+            entity.lineweight = curr.value;
+            break;
+        case 48:
+            entity.lineTypeScale = curr.value;
+            break;
+        case 60:
+            entity.isVisible = !!curr.value;
+            break;
+        case 92:
+            entity.proxyByte = curr.value;
+            break;
+        case 310:
+            entity.proxyEntity = curr.value;
+            break;
+        case 100:
+            // general한 목적으로는 현 구조로 여기서 처리 불가
+            break;
+        case 420:
+            entity.color = curr.value;
+            break;
+        case 430:
+            entity.transparency = curr.value;
+            break;
+        case 390:
+            entity.plotStyleHardId = curr.value;
+            break;
+        case 284:
+            entity.shadowMode = curr.value;
+            break;
+        case 1001:
+            entity.xdata = parseXData(curr, scanner);
+            break;
+        default:
+            return false;
+    }
+    return true;
+}

package/src/parser/blocks/blocks.test.ts

@@ -0,0 +1,97 @@
+import DxfArrayScanner from '../DxfArrayScanner';
+import { parseBlock, parseBlocks } from '.';
+import { isMatched } from '../shared';
+
+const content = ` 0
+BLOCK
+ 2
+block-0
+ 100
+AcDbEntity
+ 0
+ENDBLK
+ 5
+endblk-0
+ 100
+AcDbEntity
+ 100
+AcDbBlockEnd
+ 0
+BLOCK
+ 2
+block-1
+ 100
+AcDbEntity
+ 0
+ENDBLK
+ 5
+endblk-1
+ 100
+AcDbEntity
+ 100
+AcDbBlockEnd
+ 0
+ENDSEC
+ 0
+SECTION
+ 0
+EOF
+`.split('\n');
+
+describe('BLOCK section', () => {
+    describe('parseBlock', () => {
+        it('parseBlock 한 번 실행하고 나면 scanner.next()가 다음 BLOCK의 <0, BLOCK>를 반환한다.', () => {
+            const scanner = new DxfArrayScanner(content);
+            let curr = scanner.next();
+
+            curr = scanner.next(); // 집어넣을 때 이미 <0, BLOCK>을 소모한 상태여야 함
+            parseBlock(curr, scanner);
+
+            curr = scanner.next();
+
+            expect(curr.code).toBe(0);
+            expect(curr.value).toBe('BLOCK');
+        });
+
+        it('parseBlock은 모든 BLOCK을 소모하여야 한다.', () => {
+            const scanner = new DxfArrayScanner(content);
+            let curr = scanner.next();
+
+            curr = scanner.next();
+            const block0 = parseBlock(curr, scanner);
+
+            curr = scanner.next();
+            expect(isMatched(curr, 0, 'BLOCK')).toBeTruthy();
+
+            curr = scanner.next();
+            const block1 = parseBlock(curr, scanner);
+
+            expect(block0.name).toBe('block-0');
+            expect(block1.name).toBe('block-1');
+        });
+    });
+
+    describe('parseBlocks', () => {
+        it('parseBlocks 한 번 실행하고 나면 scanner.next()가 다음 SECTION의 <0, SECTION>을 반환한다.', () => {
+            const scanner = new DxfArrayScanner(content);
+            let curr = scanner.next();
+
+            parseBlocks(curr, scanner);
+
+            curr = scanner.next();
+
+            expect(curr.code).toBe(0);
+            expect(curr.value).toBe('SECTION');
+        });
+
+        it('parseBlocks는 모든 BLOCK을 반환해야 한다.', () => {
+            const scanner = new DxfArrayScanner(content);
+            let curr = scanner.next();
+
+            const blocks = parseBlocks(curr, scanner);
+
+            expect(blocks['block-0']).toMatchObject({ name: 'block-0' });
+            expect(blocks['block-1']).toMatchObject({ name: 'block-1' });
+        });
+    });
+});

package/src/parser/blocks/index.ts

@@ -0,0 +1,88 @@
+import type DxfArrayScanner from '../DxfArrayScanner';
+import type { ScannerGroup } from '../DxfArrayScanner';
+import { parseEntities } from '../entities';
+import { parsePoint } from '../shared/parsePoint';
+import { ensureHandle, isMatched } from '../shared';
+
+export function parseBlocks(curr: ScannerGroup, scanner: DxfArrayScanner) {
+    let blocks: any = {};
+
+    while (!isMatched(curr, 0, 'EOF')) {
+        if (isMatched(curr, 0, 'ENDSEC')) {
+            break;
+        }
+
+        if (isMatched(curr, 0, 'BLOCK')) {
+            curr = scanner.next();
+            const block = parseBlock(curr, scanner);
+
+            ensureHandle(block);
+            if (block.name) {
+                blocks[block.name] = block;
+            }
+        }
+
+        curr = scanner.next();
+    }
+    return blocks;
+}
+
+export function parseBlock(curr: ScannerGroup, scanner: DxfArrayScanner) {
+    let block: any = {};
+
+    while (!isMatched(curr, 0, 'EOF')) {
+        if (isMatched(curr, 0, 'ENDBLK')) {
+            // 당장 ENDBLK 파싱이 없어서 임시로 대충 소비함
+            // 소비 안하면 ENTITY에 딸려들어가서 문제 생김
+            curr = scanner.next();
+            while (!isMatched(curr, 0, 'EOF')) {
+                if (isMatched(curr, 100, 'AcDbBlockEnd')) {
+                    return block;
+                }
+                curr = scanner.next();
+            }
+            break;
+        }
+
+        switch (curr.code) {
+            case 1:
+                block.xrefPath = curr.value;
+                break;
+            case 2:
+                block.name = curr.value;
+                break;
+            case 3:
+                block.name2 = curr.value;
+                break;
+            case 5:
+                block.handle = curr.value;
+                break;
+            case 8:
+                block.layer = curr.value;
+                break;
+            case 10:
+                block.position = parsePoint(scanner);
+                break;
+            case 67:
+                block.paperSpace = curr.value && curr.value == 1 ? true : false;
+                break;
+            case 70:
+                if (curr.value !== 0) {
+                    block.type = curr.value;
+                }
+                break;
+            case 100:
+                // ignore class markers
+                break;
+            case 330:
+                block.ownerHandle = curr.value;
+                break;
+            case 0:
+                block.entities = parseEntities(curr, scanner);
+                break;
+        }
+
+        curr = scanner.next();
+    }
+    return block;
+}

package/src/parser/blocks/types.ts

@@ -0,0 +1,15 @@
+import type { Point3D } from '../../types';
+import type { CommonDxfEntity } from '../entities/shared';
+
+export interface DxfBlock {
+    type: number; // bit flag of BlockTypeFlag
+    name: string;
+    name2: string;
+    handle: string;
+    ownerHandle: string;
+    layer: string;
+    position: Point3D;
+    paperSpace: boolean;
+    xrefPath: string;
+    entities?: CommonDxfEntity[];
+}

package/src/parser/entities/arc/index.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './parser';

package/src/parser/entities/arc/parser.ts

@@ -0,0 +1,67 @@
+import type DxfArrayScanner from '../../DxfArrayScanner';
+import type { ScannerGroup } from '../../DxfArrayScanner';
+import {
+    createParser,
+    DXFParserSnippet,
+    Identity,
+    PointParser,
+} from '../../shared/parserGenerator';
+import { CommonEntitySnippets } from '../shared';
+
+const DefaultArcEntity = {
+    extrusionDirection: { x: 0, y: 0, z: 1 },
+};
+
+const ArcEntityParserSnippets: DXFParserSnippet[] = [
+    {
+        code: 210,
+        name: 'extrusionDirection',
+        parser: PointParser,
+    },
+    {
+        code: 51,
+        name: 'endAngle',
+        parser: Identity,
+    },
+    {
+        code: 50,
+        name: 'startAngle',
+        parser: Identity,
+    },
+    {
+        code: 100,
+        name: 'subclassMarker',
+        parser: Identity,
+    },
+    {
+        code: 40,
+        name: 'radius',
+        parser: Identity,
+    },
+    {
+        code: 10,
+        name: 'center',
+        parser: PointParser,
+    },
+    {
+        code: 39,
+        name: 'thickness',
+        parser: Identity,
+    },
+    {
+        // skip for AcDbCircle
+        code: 100,
+    },
+    ...CommonEntitySnippets,
+];
+
+export class ArcEntityParser {
+    static ForEntityName = 'ARC';
+    private parser = createParser(ArcEntityParserSnippets, DefaultArcEntity);
+
+    parseEntity(scanner: DxfArrayScanner, curr: ScannerGroup) {
+        const entity = {} as any;
+        this.parser(curr, scanner, entity);
+        return entity;
+    }
+}

package/src/parser/entities/arc/types.ts

@@ -0,0 +1,13 @@
+import type { Point3D } from '../../../types';
+import type { CommonDxfEntity } from '../shared';
+
+export interface ArcEntity extends CommonDxfEntity {
+    type: 'ARC';
+    subclassMarker: 'AcDbArc';
+    thickness: number;
+    center: Point3D;
+    radius: number;
+    startAngle: number;
+    endAngle: number;
+    extrusionDirection: Point3D;
+}

package/src/parser/entities/attdef/consts.ts

@@ -0,0 +1,12 @@
+export enum AttributeFlag {
+    NONE = 0,
+    INVISIBLE = 1,
+    CONSTANT = 2,
+    VERIFICATION_REQUIRED = 4,
+    PRESET = 8,
+}
+
+export enum AttDefMTextFlag {
+    MULTILINE = 2,
+    CONSTANT_MULTILINE = 4,
+}

package/src/parser/entities/attdef/index.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './consts';
+export * from './parser';

package/src/parser/entities/attdef/parser.ts

@@ -0,0 +1,119 @@
+import type DxfArrayScanner from '../../DxfArrayScanner';
+import type { ScannerGroup } from '../../DxfArrayScanner';
+import {
+    createParser,
+    DXFParserSnippet,
+    Identity,
+    PointParser,
+    ToBoolean,
+} from '../../shared/parserGenerator';
+import { DefaultTextEntity, TextEntityParserSnippets } from '../text';
+import type { AttdefEntity } from './types';
+
+const DefaultAttDefEntity = {
+    ...DefaultTextEntity,
+};
+
+const AttDefEntityParserSnippets: DXFParserSnippet[] = [
+    {
+        code: 2, // tag. 왜 다시 나오는지 모르겠음
+    },
+    {
+        code: 40,
+        name: 'annotationScale',
+        parser: Identity,
+    },
+    {
+        code: 10,
+        name: 'alignmentPoint',
+        parser: PointParser,
+    },
+    {
+        code: 340,
+        name: 'secondaryAttributesHardIds',
+        isMultiple: true,
+        parser: Identity,
+    },
+    {
+        code: 70,
+        name: 'numberOfSecondaryAttributes',
+        parser: Identity,
+    },
+    {
+        code: 70,
+        name: 'isReallyLocked',
+        parser: ToBoolean,
+    },
+    {
+        code: 70,
+        name: 'mtextFlag',
+        parser: Identity,
+    },
+    {
+        code: 280,
+        name: 'isDuplicatedRecord',
+        parser: ToBoolean,
+    },
+    {
+        code: 100, // AcDbXrecord, skip
+    },
+    {
+        code: 280,
+        name: 'isLocked',
+        parser: ToBoolean,
+    },
+    {
+        code: 74,
+        name: 'valign',
+        parser: Identity,
+    },
+    {
+        code: 73, // field length, useless
+    },
+    {
+        code: 70,
+        name: 'attributeFlag',
+        parser: Identity,
+    },
+    {
+        code: 2,
+        name: 'tag',
+        parser: Identity,
+    },
+    {
+        code: 3,
+        name: 'prompt',
+        parser: Identity,
+    },
+    {
+        code: 280, // version number, always 0, useless
+    },
+    {
+        code: 100,
+        name: 'subclassMarker',
+        parser: Identity,
+    },
+    ...TextEntityParserSnippets.slice(2),
+];
+
+export class AttDefEntityParser {
+    static ForEntityName = 'ATTDEF';
+    private parser = createParser(
+        AttDefEntityParserSnippets,
+        DefaultAttDefEntity,
+    );
+
+    parseEntity(scanner: DxfArrayScanner, curr: ScannerGroup) {
+        const entity = {} as any;
+        this.parser(curr, scanner, entity);
+        return entity as AttdefEntity;
+    }
+}
+
+// entity.invisible = !!(curr.value & 0x01);
+// entity.constant = !!(curr.value & 0x02);
+// entity.verificationRequired = !!(curr.value & 0x04);
+// entity.preset = !!(curr.value & 0x08);
+
+// entity.backwards = !!(curr.value & 0x02);
+// entity.mirrored = !!(curr.value & 0x04);

package/src/parser/entities/attdef/types.ts

@@ -0,0 +1,19 @@
+import type { Point3D } from '../../../types';
+import type { TextEntity } from '../text';
+
+export interface AttdefEntity
+    extends Omit<TextEntity, 'type' | 'subclassMarker'> {
+    type: 'ATTDEF';
+    subclassMarker: 'AcDbAttributeDefinition';
+    prompt: string;
+    tag: string;
+    attributeFlag: number;
+    isLocked: boolean;
+    isDuplicatedRecord: boolean;
+    mtextFlag: number;
+    isReallyLocked: boolean;
+    numberOfSecondaryAttributes: number;
+    secondaryAttributesHardIds: string[];
+    alignmentPoint: Point3D;
+    annotationScale: number;
+}

package/src/parser/entities/attribute/consts.ts

@@ -0,0 +1,6 @@
+export enum AttributeFlag {
+    INVISIBLE = 1,
+    CONSTANT = 2,
+    REQUIRE_VERIFICATION = 4,
+    PRESET = 8,
+}

package/src/parser/entities/attribute/index.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './consts';
+export * from './parser';