dxf-json 0.0.1

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

@@ -0,0 +1,198 @@
+import type DxfArrayScanner from '../../DxfArrayScanner';
+import type { ScannerGroup } from '../../DxfArrayScanner';
+import {
+    Abort,
+    createParser,
+    DXFParserSnippet,
+    Identity,
+    PointParser,
+    ToBoolean,
+} from '../../shared/parserGenerator';
+import { isMatched } from '../../shared';
+import { CommonEntitySnippets } from '../shared';
+import { MTextEntityParserSnippets } from '../mtext';
+import { AttributeEntity } from './types';
+
+const DefaultAttributeEntity = {
+    thickness: 0,
+    rotation: 0,
+    scale: 1,
+    obliqueAngle: 0,
+    textStyle: 'STANDARD',
+    textGenerationFlag: 0,
+    horizontalJustification: 0,
+    verticalJustification: 0,
+    extrusionDirection: { x: 0, y: 0, z: 1 },
+};
+
+const AttributeSnippets: DXFParserSnippet[] = [
+    ...MTextEntityParserSnippets.slice(
+        MTextEntityParserSnippets.findIndex(
+            ({ name }) => name === 'columnType',
+        ),
+        MTextEntityParserSnippets.findIndex(
+            ({ name }) => name === 'subclassMarker',
+        ) + 1,
+    ),
+    // 67, 8은 common에 있음
+    {
+        code: 100, // AcDbEntity
+    },
+    {
+        // MTEXT가 필수로 따라오지 않는 경우도 있기 때문에 이 경우 탈출 필요
+        code: 0,
+        parser(curr) {
+            if (!isMatched(curr, 0, 'MTEXT')) return Abort;
+            return undefined;
+        },
+    },
+    {
+        code: 2,
+        name: 'definitionTag',
+        parser: Identity,
+    },
+    {
+        code: 40,
+        name: 'annotationScale',
+        parser: Identity,
+    },
+    {
+        code: 10,
+        name: 'alignmentPoint',
+        parser: PointParser,
+    },
+    {
+        code: 340,
+        name: 'secondaryAttributesHardId',
+        parser: Identity,
+    },
+    {
+        code: 70,
+        name: 'numberOfSecondaryAttributes',
+        parser: Identity,
+    },
+    {
+        code: 70,
+        name: 'isReallyLocked',
+        parser: ToBoolean,
+    },
+    {
+        code: 70,
+        name: 'mtextFlag',
+        parser: Identity,
+    },
+    {
+        code: 280,
+        name: 'isDuplicatedEntriesKeep',
+        parser: ToBoolean,
+    },
+    {
+        code: 100, // AcDbXRecord
+    },
+    {
+        code: 280,
+        name: 'lockPositionFlag',
+        parser: ToBoolean,
+    },
+    {
+        code: 210,
+        name: 'extrusionDirection',
+        parser: PointParser,
+    },
+    {
+        code: 11,
+        name: 'alignmentPoint',
+        parser: PointParser,
+    },
+    {
+        code: 74,
+        name: 'verticalJustification',
+        parser: Identity,
+    },
+    {
+        code: 72,
+        name: 'horizontalJustification',
+        parser: Identity,
+    },
+    {
+        code: 71,
+        name: 'textGenerationFlag', // attachmentPoint
+        parser: Identity,
+    },
+    {
+        code: 7,
+        name: 'textStyle',
+        parser: Identity,
+    },
+    {
+        code: 51,
+        name: 'obliqueAngle',
+        parser: Identity,
+    },
+    {
+        code: 41,
+        name: 'scale',
+        parser: Identity,
+    },
+    {
+        code: 50,
+        name: 'rotation',
+        parser: Identity,
+    },
+    {
+        code: 73, // 미사용
+    },
+    {
+        code: 70,
+        name: 'attributeFlag',
+        parser: Identity,
+    },
+    {
+        code: 2,
+        name: 'tag',
+        parser: Identity,
+    },
+    {
+        code: 280, // version number, 미사용
+    },
+    {
+        code: 100, // AcDbAttribute
+        name: 'subclassMarker',
+        parser: Identity,
+    },
+    {
+        code: 1,
+        name: 'text',
+        parser: Identity,
+    },
+    {
+        code: 40,
+        name: 'textHeight',
+        parser: Identity,
+    },
+    {
+        code: 10,
+        name: 'startPoint',
+        parser: PointParser,
+    },
+    {
+        code: 39,
+        name: 'thickness',
+        parser: Identity,
+    },
+    {
+        code: 100, // AcDbText
+    },
+    ...CommonEntitySnippets,
+];
+
+export class AttributeEntityParser {
+    static ForEntityName = 'ATTRIB';
+    private parser = createParser(AttributeSnippets, DefaultAttributeEntity);
+
+    parseEntity(scanner: DxfArrayScanner, curr: ScannerGroup) {
+        const entity = {} as any;
+        this.parser(curr, scanner, entity);
+        return entity as AttributeEntity;
+    }
+}

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

@@ -0,0 +1,31 @@
+import type { Point3D } from '../../../types';
+import type { CommonDxfEntity } from '../shared';
+
+export interface AttributeEntity extends CommonDxfEntity {
+    type: 'ATTRIB';
+    subclassMarker: 'AcDbAttribute';
+    thickness: number;
+    startPoint: Point3D;
+    textHeight: number;
+    text: string;
+    tag: string; // cannot contain spaces
+    attributeFlag: number;
+    lineSpacing?: number;
+    rotation: number;
+    scale: number;
+    obliqueAngle: number;
+    textStyle: string;
+    textGenerationFlag: number;
+    horizontalJustification: number;
+    verticalJustification: number;
+    extrusionDirection: Point3D;
+    lockPositionFlag: boolean;
+    isDuplicatedEntriesKeep?: boolean;
+    mtextFlag: 2 | 4;
+    isReallyLocked?: boolean;
+    numberOfSecondaryAttributes?: number;
+    secondaryAttributesHardId?: string;
+    alignmentPoint: Point3D;
+    annotationScale?: number;
+    definitionTag?: string;
+}

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

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

package/src/parser/entities/circle/parser.ts

@@ -0,0 +1,58 @@
+import type DxfArrayScanner from '../../DxfArrayScanner';
+import type { ScannerGroup } from '../../DxfArrayScanner';
+import {
+    createParser,
+    DXFParserSnippet,
+    Identity,
+    PointParser,
+} from '../../shared/parserGenerator';
+import { CommonEntitySnippets } from '../shared';
+import type { CircleEntity } from './types';
+
+const DefaultCircleEntity = {
+    thickness: 0,
+    extrusionDirection: { x: 0, y: 0, z: 1 },
+};
+
+const CircleEntityParserSnippets: DXFParserSnippet[] = [
+    {
+        code: 210,
+        name: 'extrusionDirection',
+        parser: PointParser,
+    },
+    {
+        code: 40,
+        name: 'radius',
+        parser: Identity,
+    },
+    {
+        code: 10,
+        name: 'center',
+        parser: PointParser,
+    },
+    {
+        code: 39,
+        name: 'thickness',
+        parser: Identity,
+    },
+    {
+        code: 100,
+        name: 'subclassMarker',
+        parser: Identity,
+    },
+    ...CommonEntitySnippets,
+];
+
+export class CircleEntityParser {
+    static ForEntityName = 'CIRCLE';
+    private parser = createParser(
+        CircleEntityParserSnippets,
+        DefaultCircleEntity,
+    );
+
+    parseEntity(scanner: DxfArrayScanner, curr: ScannerGroup) {
+        const entity = {} as any;
+        this.parser(curr, scanner, entity);
+        return entity as CircleEntity;
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { Point3D } from '../../../types';
+import type { CommonDxfEntity } from '../shared';
+
+export interface CircleEntity extends CommonDxfEntity {
+    type: 'CIRCLE';
+    subclassMarker: 'AcDbCircle';
+    thickness: number;
+    center: Point3D;
+    radius: number;
+    extrusionDirection: Point3D;
+}

package/src/parser/entities/dimension/common.ts

@@ -0,0 +1,98 @@
+import DxfArrayScanner, { ScannerGroup } from 'parser/DxfArrayScanner';
+import { Point3D } from 'types';
+import * as helpers from '../../ParseHelpers';
+import { parsePoint } from '../../shared/parsePoint';
+import { AlignedDimensionEntity, AngularDimensionEntity, DimensionEntity, DimensionEntityCommon, OrdinateDimensionEntity, RadialDiameterDimensionEntity } from './types';
+
+/**
+ * @returns Return `false` if curr is not related to common dimension group
+ */
+export function parseDimension(entity: DimensionEntity, curr: ScannerGroup, scanner: DxfArrayScanner) {
+    switch (curr.code) {
+        case 100:
+            entity.subclassMarker = curr.value;
+            break;
+        case 280:
+            entity.version = curr.value;
+            break;
+        case 2:
+            entity.name = curr.value;
+            break;
+        case 10:
+            entity.definitionPoint = parsePoint(scanner) as Point3D;
+            break;
+        case 11:
+            entity.textPoint = parsePoint(scanner) as Point3D;
+            break;
+        case 12:
+            // for aligned
+            (entity as AlignedDimensionEntity).insertionPoint = parsePoint(scanner) as Point3D;
+            break;
+        case 13:
+            // group 13 and 14 are subclass specific definition point
+            // for further information, look dxf dimension specification
+            (entity as AlignedDimensionEntity | AngularDimensionEntity | OrdinateDimensionEntity).subDefinitionPoint1 = parsePoint(scanner) as Point3D;
+            break;
+        case 14:
+            (entity as AlignedDimensionEntity | AngularDimensionEntity | OrdinateDimensionEntity).subDefinitionPoint2 = parsePoint(scanner) as Point3D;
+            break;
+        case 15:
+            // for angular, radial, diameter
+            (entity as AngularDimensionEntity | RadialDiameterDimensionEntity).centerPoint = parsePoint(scanner) as Point3D;
+            break;
+        case 16:
+            // for angular
+            (entity as AngularDimensionEntity).arcPoint = parsePoint(scanner) as Point3D;
+            break;
+        case 70:
+            entity.dimensionType = curr.value;
+            break;
+        case 71:
+            entity.attachmentPoint = curr.value;
+            break;
+        case 72:
+            entity.textLineSpacingStyle = curr.value;
+            break;
+        case 40:
+            // for radial, diameter
+            (entity as RadialDiameterDimensionEntity).leaderLength = curr.value;
+            break;
+        case 41:
+            entity.textLineSpacingFactor = curr.value;
+            break;
+        case 42:
+            entity.measurement = curr.value;
+            break;
+        case 1:
+            // if value === null or "<>", measurement should be drawn as text instead
+            // if value === "", text is suppressed.
+            // otherwise text should be drawn as is.
+            entity.text = curr.value;
+            break;
+        case 50:
+            // for aligned
+            (entity as AlignedDimensionEntity).rotationAngle = curr.value;
+            break;
+        case 52:
+            // for aligned
+            (entity as AlignedDimensionEntity).obliqueAngle = curr.value;
+            break;
+        case 53:
+            entity.textRotation = curr.value;
+            break;
+        case 51:
+            // This group value is the negative of the angle between the OCS X axis
+            // and the UCS X axis. It is always in the XY plane of the OCS
+            entity.ocsRotation = curr.value;
+            break;
+        case 210:
+            entity.extrusionDirection = parsePoint(scanner) as Point3D;
+            break;
+        case 3:
+            entity.styleName = curr.value;
+            break;
+        default:
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+    }
+}

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

@@ -0,0 +1,24 @@
+import DxfArrayScanner, { ScannerGroup } from 'parser/DxfArrayScanner';
+import { isMatched } from '../../shared';
+import { parseDimension } from './common';
+import { DimensionEntity } from './types';
+
+export default class DimensionParser {
+    static ForEntityName = 'DIMENSION';
+
+    parseEntity(scanner: DxfArrayScanner, curr: ScannerGroup) {
+        const entity = {} as DimensionEntity;
+
+        while (!isMatched(curr, 0, 'EOF')) {
+            if (curr.code === 0) {
+                scanner.rewind();
+                return entity;
+            }
+
+            parseDimension(entity, curr, scanner);
+            curr = scanner.next();
+        }
+
+        return entity;
+    }
+}

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

@@ -0,0 +1,65 @@
+import {
+    AttachmentPoint,
+    DimensionTextLineSpacing,
+    DimensionType,
+} from '../../../consts';
+import type { Point3D } from '../../../types';
+import type { CommonDxfEntity } from '../shared';
+
+export interface DimensionEntityCommon extends CommonDxfEntity {
+    type: 'DIMENSION';
+    subclassMarker: string;
+    handle: string;
+    version: string;
+    // Name of the block that contains the entities that make up the dimension picture
+    name: string;
+    definitionPoint: Point3D;
+    textPoint: Point3D;
+    dimensionType: DimensionType;
+    attachmentPoint: AttachmentPoint;
+    textLineSpacingStyle?: DimensionTextLineSpacing;
+    textLineSpacingFactor?: number;
+    measurement?: number;
+    text?: string;
+    textRotation?: number;
+    ocsRotation?: number;
+    extrusionDirection?: Point3D;
+    styleName: string;
+}
+
+export interface AlignedDimensionEntity extends DimensionEntityCommon {
+    subclassMarker: 'AcDbAlignedDimension' | 'AcDbRotatedDimension';
+    insertionPoint?: Point3D;
+    subDefinitionPoint1: Point3D;
+    subDefinitionPoint2: Point3D;
+    rotationAngle: number;
+    obliqueAngle: number;
+}
+
+export interface AngularDimensionEntity extends DimensionEntityCommon {
+    subclassMarker: 'AcDb3PointAngularDimension';
+    subDefinitionPoint1: Point3D;
+    subDefinitionPoint2: Point3D;
+    centerPoint: Point3D;
+    arcPoint: Point3D;
+}
+
+export interface OrdinateDimensionEntity extends DimensionEntityCommon {
+    subclassMarker: 'AcDbOrdinateDimension';
+    subDefinitionPoint1: Point3D;
+    subDefinitionPoint2: Point3D;
+}
+
+export interface RadialDiameterDimensionEntity extends DimensionEntityCommon {
+    subclassMarker: 'AcDbRadialDimension' | 'AcDbDiametricDimension';
+    centerPoint: Point3D;
+    leaderLength: number;
+}
+
+export type DimensionEntity = DimensionEntityCommon &
+    (
+        | Partial<AlignedDimensionEntity>
+        | Partial<AngularDimensionEntity>
+        | Partial<OrdinateDimensionEntity>
+        | Partial<RadialDiameterDimensionEntity>
+    );

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

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

package/src/parser/entities/ellipse/parser.ts

@@ -0,0 +1,66 @@
+import DxfArrayScanner, { ScannerGroup } from '../../DxfArrayScanner';
+import {
+    createParser,
+    DXFParserSnippet,
+    Identity,
+    PointParser,
+} from '../../shared/parserGenerator';
+import { CommonEntitySnippets } from '../shared';
+import { EllipseEntity } from './types';
+
+const DefaultEllipseEnitty = {
+    extrusionDirection: { x: 0, y: 0, z: 1 },
+};
+
+const EllipseEntityParserSnippets: DXFParserSnippet[] = [
+    {
+        code: 42,
+        name: 'endAngle',
+        parser: Identity,
+    },
+    {
+        code: 41,
+        name: 'startAngle',
+        parser: Identity,
+    },
+    {
+        code: 40,
+        name: 'axisRatio',
+        parser: Identity,
+    },
+    {
+        code: 210,
+        name: 'extrusionDirection',
+        parser: PointParser,
+    },
+    {
+        code: 11,
+        name: 'majorAxisEndPoint',
+        parser: PointParser,
+    },
+    {
+        code: 10,
+        name: 'center',
+        parser: PointParser,
+    },
+    {
+        code: 100,
+        name: 'subclassMarker',
+        parser: Identity,
+    },
+    ...CommonEntitySnippets,
+];
+
+export class EllipseEntityParser {
+    static ForEntityName = 'ELLIPSE';
+    private parser = createParser(
+        EllipseEntityParserSnippets,
+        DefaultEllipseEnitty,
+    );
+
+    parseEntity(scanner: DxfArrayScanner, curr: ScannerGroup) {
+        const entity = {} as any;
+        this.parser(curr, scanner, entity);
+        return entity as EllipseEntity;
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { Point3D } from '../../../types';
+import type { CommonDxfEntity } from '../shared';
+
+export interface EllipseEntity extends CommonDxfEntity {
+    type: 'ELLIPSE';
+    subclassMarker: 'AcDbEllipse';
+    center: Point3D;
+    majorAxisEndPoint: Point3D;
+    extrusionDirection: Point3D;
+    axisRatio: number;
+    startAngle: number; // radian
+    endAngle: number; // radian
+}

package/src/parser/entities/entities.test.ts

@@ -0,0 +1,86 @@
+import { parseEntities } from '.';
+import DxfArrayScanner from '../DxfArrayScanner';
+
+describe('ENTITIES section', () => {
+    describe('parseEntities', () => {
+        it('BLOCKS 섹션 안에서 parseEntities를 실행하면 scanner.next()가 <0, ENDBLK>이어야 한다.', () => {
+            const content = ` 0
+LINE
+ 5
+entity-0
+ 100
+AcDbLine
+ 100
+AcDbEntity
+ 0
+ENDBLK
+ 0
+EOF
+`.split('\n');
+            const scanner = new DxfArrayScanner(content);
+            let curr = scanner.next();
+
+            parseEntities(curr, scanner);
+
+            curr = scanner.next();
+
+            expect(curr.code).toBe(0);
+            expect(curr.value).toBe('ENDBLK');
+        });
+
+        it('ENTITIES 섹션 안에서 parseEntities를 실행하면 scanner.next()가 <0, ENDSEC>이어야 한다.', () => {
+            const content = ` 0
+LINE
+  5
+entity-0
+  100
+AcDbLine
+  100
+AcDbEntity
+  0
+ENDSEC
+  0
+EOF
+`.split('\n');
+            const scanner = new DxfArrayScanner(content);
+            let curr = scanner.next();
+
+            parseEntities(curr, scanner);
+
+            curr = scanner.next();
+
+            expect(curr.code).toBe(0);
+            expect(curr.value).toBe('ENDSEC');
+        });
+
+        it('parseEntities는 모든 ENTITY를 소모하여야 한다.', () => {
+            const content = ` 0
+LINE
+ 5
+entity-0
+ 100
+AcDbLine
+ 0
+LINE
+ 5
+entity-1
+ 100
+AcDbLine
+ 100
+AcDbEntity
+ 0
+ENDBLK
+ 0
+EOF
+`.split('\n');
+            const scanner = new DxfArrayScanner(content);
+            let curr = scanner.next();
+
+            const entities = parseEntities(curr, scanner);
+
+            expect(entities.length).toBe(2);
+            expect(entities[0].handle).toBe('entity-0');
+            expect(entities[1].handle).toBe('entity-1');
+        });
+    });
+});