dxf-json 0.0.1

package/src/parser/tables/ltype/consts.ts

@@ -0,0 +1,6 @@
+export enum LineTypeElementType {
+    'NONE' = 0,
+    'AbsoluteRotation' = 1,
+    'TextEmbedded' = 2,
+    'ShapeEmbedded' = 4,
+}

package/src/parser/tables/ltype/index.ts

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

package/src/parser/tables/ltype/parser.ts

@@ -0,0 +1,110 @@
+import {
+    createParser,
+    DXFParserSnippet,
+    Identity,
+} from '../../shared/parserGenerator';
+import { CommonTableEntryParserSnippets } from '../shared';
+import type { LineTypeElement } from './types';
+
+const LTypeElementParserSnippets: DXFParserSnippet[] = [
+    {
+        code: 9,
+        name: 'text',
+        parser: Identity,
+    },
+    {
+        code: 45,
+        name: 'offsetY',
+        parser: Identity,
+    },
+    {
+        code: 44,
+        name: 'offsetX',
+        parser: Identity,
+    },
+    {
+        code: 50,
+        name: 'rotation',
+        parser: Identity,
+    },
+    {
+        code: 46,
+        name: 'scale',
+        parser: Identity,
+    },
+    {
+        code: 340,
+        name: 'styleObjectId',
+        parser: Identity,
+    },
+    {
+        code: 75,
+        name: 'shapeNumber',
+        parser: Identity,
+    },
+    {
+        code: 74,
+        name: 'elementTypeFlag',
+        parser: Identity,
+    },
+    {
+        code: 49,
+        name: 'elementLength',
+        parser: Identity,
+    },
+];
+
+const parseLTypeElement = createParser(LTypeElementParserSnippets, {
+    elementTypeFlag: 0,
+    elementLength: 0,
+});
+
+const LTypeTableParserSnippets: DXFParserSnippet[] = [
+    {
+        code: 49,
+        name: 'pattern',
+        parser(curr, scanner) {
+            const entity = {} as LineTypeElement;
+            parseLTypeElement(curr, scanner, entity);
+            return entity;
+        },
+        isMultiple: true,
+    },
+    {
+        code: 40,
+        name: 'totalPatternLength',
+        parser: Identity,
+    },
+    {
+        code: 73,
+        name: 'numberOfLineTypes',
+        parser: Identity,
+    },
+    {
+        code: 72,
+        parser: Identity, // 항상 의미없는 값(A)이라 버림
+    },
+    {
+        code: 3,
+        name: 'description',
+        parser: Identity,
+    },
+    {
+        code: 70,
+        name: 'standardFlag',
+        parser: Identity,
+    },
+    {
+        code: 2,
+        name: 'name',
+        parser: Identity,
+    },
+    {
+        code: 100,
+        name: 'subclassMarker',
+        parser: Identity,
+    },
+    ...CommonTableEntryParserSnippets,
+];
+
+export const parseLTypeTable = createParser(LTypeTableParserSnippets);

package/src/parser/tables/ltype/types.ts

@@ -0,0 +1,23 @@
+import type { CommonDxfTableEntry } from '../types';
+
+export interface LTypeTableEntry extends CommonDxfTableEntry {
+    subclassMarker: 'AcDbLinetypeTableRecord';
+    name: string;
+    standardFlag: number;
+    description: string;
+    numberOfLineTypes: number;
+    totalPatternLength: number;
+    pattern?: LineTypeElement[];
+}
+
+export interface LineTypeElement {
+    elementLength: number;
+    elementTypeFlag: number;
+    shapeNumber?: number;
+    styleObjectId?: string;
+    scale?: number;
+    rotation?: number;
+    offsetX?: number;
+    offsetY?: number;
+    text?: string;
+}

package/src/parser/tables/parser.ts

@@ -0,0 +1,100 @@
+import {
+    createParser,
+    DXFParserSnippet,
+    Identity,
+} from '../shared/parserGenerator';
+import DxfArrayScanner, { ScannerGroup } from '../DxfArrayScanner';
+import { isMatched } from '../shared';
+import type { DxfTable } from './types';
+import { parseBlockRecordTable } from './blockRecord';
+import { parseDimStyle } from './dimStyle';
+import { parseLayerTable } from './layer';
+import { parseLTypeTable } from './ltype/parser';
+import { parseStyleTable } from './style';
+import { parseVPortTable } from './vport';
+
+const TableParsers = {
+    BLOCK_RECORD: parseBlockRecordTable,
+    DIMSTYLE: parseDimStyle,
+    LAYER: parseLayerTable,
+    LTYPE: parseLTypeTable,
+    STYLE: parseStyleTable,
+    VPORT: parseVPortTable,
+};
+
+const CommonTableParserSnippets: DXFParserSnippet[] = [
+    {
+        code: 70,
+        name: 'maxNumberOfEntries',
+        parser: Identity,
+    },
+    {
+        code: 100,
+        name: 'subclassMarker',
+        parser: Identity,
+    },
+    {
+        code: 330,
+        name: 'ownerObjectId',
+        parser: Identity,
+    },
+    {
+        // ACAD_XDICTIONARY, ignore
+        code: 102,
+    },
+    {
+        code: 360,
+        isMultiple: true,
+    },
+    {
+        code: 102,
+    },
+    {
+        code: 5,
+        name: 'handle',
+        parser: Identity,
+    },
+    {
+        code: 2,
+        name: 'name',
+        parser: Identity,
+    },
+];
+
+const parseCommonTable = createParser(CommonTableParserSnippets);
+
+export function parseTables(curr: ScannerGroup, scanner: DxfArrayScanner) {
+    const tables = {} as any;
+
+    while (!isMatched(curr, 0, 'EOF')) {
+        if (isMatched(curr, 0, 'ENDSEC')) break;
+
+        if (isMatched(curr, 0, 'TABLE')) {
+            curr = scanner.next();
+
+            const table = { entries: [] as any[] } as DxfTable<any>;
+            parseCommonTable(curr, scanner, table);
+            tables[table.name] = table;
+        }
+
+        if (isMatched(curr, 0) && !isMatched(curr, 0, 'ENDTAB')) {
+            const name = curr.value;
+            curr = scanner.next();
+
+            // @ts-ignore
+            const parseTable = TableParsers[name];
+            if (!parseTable) {
+                console.warn(`parseTable: Invalid table name '${name}'`);
+                curr = scanner.next();
+                continue;
+            }
+
+            const record = {} as any;
+            parseTable(curr, scanner, record);
+            tables[name]?.entries.push(record);
+        }
+        curr = scanner.next();
+    }
+
+    return tables;
+}

package/src/parser/tables/shared.ts

@@ -0,0 +1,32 @@
+import {
+    DXFParserSnippet,
+    Identity,
+} from '../shared/parserGenerator';
+import { isMatched } from '../shared';
+
+export const CommonTableEntryParserSnippets: DXFParserSnippet[] = [
+    {
+        code: 100,
+        name: 'subclassMarker',
+        parser: Identity,
+    },
+    {
+        code: 330,
+        name: 'ownerObjectId',
+        parser: Identity,
+    },
+    {
+        code: 102,
+        parser(curr, scanner) {
+            while (!isMatched(curr, 0, 'EOF') && !isMatched(curr, 102, '}')) {
+                curr = scanner.next();
+            }
+        },
+    },
+    {
+        // DIMSTYLE만 예외적으로 미적용
+        code: 5,
+        name: 'handle',
+        parser: Identity,
+    },
+];

package/src/parser/tables/style/index.ts

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

package/src/parser/tables/style/parser.ts

@@ -0,0 +1,70 @@
+import {
+    createParser,
+    DXFParserSnippet,
+    Identity,
+} from '../../shared/parserGenerator';
+import { CommonTableEntryParserSnippets } from '../shared';
+
+const StyleTableParserSnippets: DXFParserSnippet[] = [
+    {
+        code: 1000,
+        name: 'extendedFont',
+        parser: Identity,
+    },
+    {
+        code: 1001, // ACAD signature, skip
+    },
+    {
+        code: 4,
+        name: 'bigFont',
+        parser: Identity,
+    },
+    {
+        code: 3,
+        name: 'font',
+        parser: Identity,
+    },
+    {
+        code: 42,
+        name: 'lastHeight',
+        parser: Identity,
+    },
+    {
+        code: 71,
+        name: 'textGenerationFlag',
+        parser: Identity,
+    },
+    {
+        code: 50,
+        name: 'obliqueAngle',
+        parser: Identity,
+    },
+    {
+        code: 41,
+        name: 'widthFactor',
+        parser: Identity,
+    },
+    {
+        code: 40,
+        name: 'fixedTextHeight',
+        parser: Identity,
+    },
+    {
+        code: 70,
+        name: 'standardFlag',
+        parser: Identity,
+    },
+    {
+        code: 2,
+        name: 'name',
+        parser: Identity,
+    },
+    {
+        code: 100,
+        name: 'subclassMarker',
+        parser: Identity,
+    },
+    ...CommonTableEntryParserSnippets,
+];
+
+export const parseStyleTable = createParser(StyleTableParserSnippets);

package/src/parser/tables/style/types.ts

@@ -0,0 +1,15 @@
+import type { CommonDxfTableEntry } from '../types';
+
+export interface StyleTableEntry extends CommonDxfTableEntry {
+    subclassMarker: 'AcDbTextStyleTableRecord';
+    name: string;
+    standardFlag: number;
+    fixedTextHeight: number;
+    widthFactor: number;
+    obliqueAngle: number;
+    textGenerationFlag: number;
+    lastHeight: number;
+    font: string;
+    bigFont: string;
+    extendedFont?: string;
+}

package/src/parser/tables/types.ts

@@ -0,0 +1,15 @@
+export interface DxfTable<T extends CommonDxfTableEntry> {
+    subclassMarker: 'AcDbSymbolTable';
+    name: string;
+    handle: string;
+    ownerDictionaryIds?: string[];
+    ownerObjectId: string;
+    maxNumberOfEntries: number;
+    entries: T[];
+}
+
+export interface CommonDxfTableEntry {
+    name: string;
+    handle: string;
+    ownerObjectId: string;
+}

package/src/parser/tables/vport/index.ts

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

package/src/parser/tables/vport/parser.ts

@@ -0,0 +1,205 @@
+import {
+    createParser,
+    DXFParserSnippet,
+    Identity,
+    PointParser,
+    ToBoolean,
+} from '../../shared/parserGenerator';
+import { CommonTableEntryParserSnippets } from '../shared';
+
+const VPortTableParserSnippets: DXFParserSnippet[] = [
+    {
+        code: [63, 421, 431],
+        name: 'ambientColor',
+        parser: Identity,
+    },
+    {
+        code: 142,
+        name: 'contrast',
+        parser: Identity,
+    },
+    {
+        code: 141,
+        name: 'brightness',
+        parser: Identity,
+    },
+    {
+        code: 282,
+        name: 'defaultLightingType',
+        parser: Identity,
+    },
+    {
+        code: 292,
+        name: 'isDefaultLightingOn',
+        parser: ToBoolean,
+    },
+    {
+        code: 348,
+        name: 'visualStyleObjectId',
+        parser: Identity,
+    },
+    {
+        code: 333,
+        name: 'shadePlotObjectId',
+        parser: Identity,
+    },
+    {
+        code: 332,
+        name: 'backgroundObjectId',
+        parser: Identity,
+    },
+    {
+        code: 61,
+        name: 'majorGridLines',
+        parser: Identity,
+    },
+    {
+        code: 170,
+        name: 'shadePlotSetting',
+        parser: Identity,
+    },
+    {
+        code: 146,
+        name: 'elevation',
+        parser: Identity,
+    },
+    {
+        code: 79,
+        name: 'orthographicType',
+        parser: Identity,
+    },
+    {
+        code: 112,
+        name: 'ucsYAxis',
+        parser: PointParser,
+    },
+    {
+        code: 111,
+        name: 'ucsXAxis',
+        parser: PointParser,
+    },
+    {
+        code: 110,
+        name: 'ucsOrigin',
+        parser: PointParser,
+    },
+    {
+        code: 74,
+        name: 'ucsIconSetting',
+        parser: Identity,
+    },
+    {
+        code: 71,
+        name: 'viewMode',
+        parser: Identity,
+    },
+    {
+        code: 281,
+        name: 'renderMode',
+        parser: Identity,
+    },
+    {
+        code: 1,
+        name: 'styleSheet',
+        parser: Identity,
+    },
+    {
+        code: [331, 441],
+        name: 'frozenLayers',
+        parser: Identity,
+        isMultiple: true,
+    },
+    {
+        code: 72,
+        name: 'circleSides',
+        parser: Identity,
+    },
+    {
+        code: 51,
+        name: 'viewTwistAngle',
+        parser: Identity,
+    },
+    {
+        code: 50,
+        name: 'snapRotationAngle',
+        parser: Identity,
+    },
+    {
+        code: 45,
+        name: 'viewHeight',
+        parser: Identity,
+    },
+    {
+        code: 44,
+        name: 'backClippingPlane',
+        parser: Identity,
+    },
+    {
+        code: 43,
+        name: 'frontClippingPlane',
+        parser: Identity,
+    },
+    {
+        code: 42,
+        name: 'lensLength',
+        parser: Identity,
+    },
+    {
+        code: 17,
+        name: 'viewTarget',
+        parser: PointParser,
+    },
+    {
+        code: 16,
+        name: 'viewDirectionFromTarget',
+        parser: PointParser,
+    },
+    {
+        code: 15,
+        name: 'gridSpacing',
+        parser: PointParser,
+    },
+    {
+        code: 14,
+        name: 'snapSpacing',
+        parser: PointParser,
+    },
+    {
+        code: 13,
+        name: 'snapBasePoint',
+        parser: PointParser,
+    },
+    {
+        code: 12,
+        name: 'center',
+        parser: PointParser,
+    },
+    {
+        code: 11,
+        name: 'upperRightCorner',
+        parser: PointParser,
+    },
+    {
+        code: 10,
+        name: 'lowerLeftCorner',
+        parser: PointParser,
+    },
+    {
+        code: 70,
+        name: 'standardFlag',
+        parser: Identity,
+    },
+    {
+        code: 2,
+        name: 'name',
+        parser: Identity,
+    },
+    {
+        code: 100,
+        name: 'subclassMarker',
+        parser: Identity,
+    },
+    ...CommonTableEntryParserSnippets,
+];
+
+export const parseVPortTable = createParser(VPortTableParserSnippets);

package/src/parser/tables/vport/types.ts

@@ -0,0 +1,48 @@
+import type {
+    RenderMode,
+    OrthographicType,
+    DefaultLightingType,
+} from '../../../consts';
+import type { Point2D, Point3D } from '../../../types';
+import type { CommonDxfTableEntry } from '../types';
+
+export interface VPortTableEntry extends CommonDxfTableEntry {
+    subclassMarker: 'AcDbViewportTableRecord';
+    name: string;
+    standardFlag: number;
+    lowerLeftCorner: Point2D;
+    upperRightCorner: Point2D;
+    center: Point2D;
+    snapBasePoint: Point2D;
+    snapSpacing: Point2D;
+    gridSpacing: Point2D;
+    viewDirectionFromTarget: Point3D;
+    viewTarget: Point3D;
+    lensLength: number;
+    frontClippingPlane: number;
+    backClippingPlane: number;
+    viewHeight: number;
+    snapRotationAngle: number;
+    viewTwistAngle: number;
+    circleSides: number;
+    frozenLayers: string[];
+    styleSheet: string;
+    renderMode: RenderMode;
+    viewMode: number;
+    ucsIconSetting: number;
+    ucsOrigin: Point3D;
+    ucsXAxis: Point3D;
+    ucsYAxis: Point3D;
+    orthographicType: OrthographicType;
+    elevation: number;
+    shadePlotSetting: number;
+    majorGridLines: number;
+    backgroundObjectId?: string;
+    shadePlotObjectId?: string;
+    visualStyleObjectId?: string;
+    isDefaultLightingOn: boolean;
+    defaultLightingType: DefaultLightingType;
+    brightness: number;
+    contrast: number;
+    ambientColor?: number;
+}

package/src/parser/types.ts

@@ -0,0 +1,30 @@
+import type { DxfHeader } from '../types/dxfHeader';
+import type { DxfBlock } from './blocks/types';
+import type { CommonDxfEntity } from './entities/shared';
+import type { CommonDXFObject } from './objects/common';
+import type { DxfObject } from './objects/types';
+import { BlockRecordTableEntry } from './tables/blockRecord';
+import { DimStylesTableEntry } from './tables/dimStyle';
+import { LayerTableEntry } from './tables/layer';
+import { LTypeTableEntry } from './tables/ltype';
+import { StyleTableEntry } from './tables/style';
+import { DxfTable } from './tables/types';
+import { VPortTableEntry } from './tables/vport';
+
+export interface ParsedDxf {
+    header: DxfHeader;
+    blocks: Record<string, DxfBlock>;
+    entities: CommonDxfEntity[];
+    tables: {
+        BLOCK_RECORD?: DxfTable<BlockRecordTableEntry>;
+        DIMSTYLE?: DxfTable<DimStylesTableEntry>;
+        STYLE?: DxfTable<StyleTableEntry>;
+        LAYER?: DxfTable<LayerTableEntry>;
+        LTYPE?: DxfTable<LTypeTableEntry>;
+        VPORT?: DxfTable<VPortTableEntry>;
+    };
+    objects: {
+        byName: Record<string, CommonDXFObject[]>;
+        byTree?: DxfObject;
+    };
+}

package/src/types/color.ts

@@ -0,0 +1,5 @@
+import type { ColorCode, UndeterminedBlockColor } from '../consts';
+
+export type ColorIndex = ColorCode | number;
+
+export type ColorInstance = typeof UndeterminedBlockColor | number;

package/src/types/dxfHeader.ts

@@ -0,0 +1,21 @@
+import type { Measurement } from '../consts';
+import type { DefaultDxfHeaderVariables } from '../consts/header';
+
+// 필요하면 추가
+export type DxfHeaderVariable =
+    /** Hard-pointer ID to visual style while creating 3D solid primitives */
+    | 'DRAGVS'
+    /** Represents the ACI color index of the "interference objects" created during the INTERFERE command */
+    | 'INTERFERECOLOR'
+    /** Hard-pointer ID to the visual style for interference objects */
+    | 'INTERFEREOBJVS'
+    /** Hard-pointer ID to the visual style for the viewport during interference checking */
+    | 'INTERFEREVPVS'
+    | 'OBSLTYPE'
+    /** Percent ambient/diffuse light; range 1-100 */
+    | 'SHADEDIF'
+    | 'MEASUREMENT';
+
+export type DxfHeader = typeof DefaultDxfHeaderVariables & {
+    MEASUREMENT: Measurement;
+} & Record<string, any>;