dxf-json 0.0.1

package/src/parser/objects/plotSettings.ts

@@ -0,0 +1,231 @@
+import { DXFParserSnippet, Identity } from '../shared/parserGenerator';
+import type { CommonDXFObject } from './common';
+
+export const PlotSettingsSnippets: DXFParserSnippet[] = [
+    {
+        code: 333,
+        name: 'shadePlotId',
+        parser: Identity,
+    },
+    {
+        code: 149,
+        name: 'imageOriginY',
+        parser: Identity,
+    },
+    {
+        code: 148,
+        name: 'imageOriginX',
+        parser: Identity,
+    },
+    {
+        code: 147,
+        name: 'scaleFactor',
+        parser: Identity,
+    },
+    {
+        code: 78,
+        name: 'shadePlotCustomDPI',
+        parser: Identity,
+    },
+    {
+        code: 77,
+        name: 'shadePlotResolution',
+        parser: Identity,
+    },
+    {
+        code: 76,
+        name: 'shadePlotMode',
+        parser: Identity,
+    },
+    {
+        code: 75,
+        name: 'standardScaleType',
+        parser: Identity,
+    },
+    {
+        code: 7,
+        name: 'currentStyleSheet',
+        parser: Identity,
+    },
+    {
+        code: 74,
+        name: 'plotType',
+        parser: Identity,
+    },
+    {
+        code: 73,
+        name: 'plotRotation',
+        parser: Identity,
+    },
+    {
+        code: 72,
+        name: 'paperUnit',
+        parser: Identity,
+    },
+    {
+        code: 70,
+        name: 'layoutFlag',
+        parser: Identity,
+    },
+    {
+        code: 143,
+        name: 'printScaleDenominator',
+        parser: Identity,
+    },
+    {
+        code: 142,
+        name: 'printScaleNominator',
+        parser: Identity,
+    },
+    {
+        code: 141,
+        name: 'windowAreaYMax',
+        parser: Identity,
+    },
+    {
+        code: 140,
+        name: 'windowAreaYMin',
+        parser: Identity,
+    },
+    {
+        code: 49,
+        name: 'windowAreaXMax',
+        parser: Identity,
+    },
+    {
+        code: 48,
+        name: 'windowAreaXMin',
+        parser: Identity,
+    },
+    {
+        code: 47,
+        name: 'plotOriginY',
+        parser: Identity,
+    },
+    {
+        code: 46,
+        name: 'plotOriginX',
+        parser: Identity,
+    },
+    {
+        code: 45,
+        name: 'paperHeight',
+        parser: Identity,
+    },
+    {
+        code: 44,
+        name: 'paperWidth',
+        parser: Identity,
+    },
+    {
+        code: 43,
+        name: 'marginTop',
+        parser: Identity,
+    },
+    {
+        code: 42,
+        name: 'marginRight',
+        parser: Identity,
+    },
+    {
+        code: 41,
+        name: 'marginBottom',
+        parser: Identity,
+    },
+    {
+        code: 40,
+        name: 'marginLeft',
+        parser: Identity,
+    },
+    {
+        code: 6,
+        name: 'plotViewName',
+        parser: Identity,
+    },
+    {
+        code: 4,
+        name: 'paperSize',
+        parser: Identity,
+    },
+    {
+        code: 2,
+        name: 'configName',
+        parser: Identity,
+    },
+    {
+        code: 1,
+        name: 'pageSetupName',
+        parser: Identity,
+    },
+    {
+        code: 100,
+        name: 'subclassMarker',
+        parser: Identity,
+    },
+];
+
+export enum PlotPaperUnit {
+    INCHES = 0,
+    MILLIMETERS = 1,
+    PIXELS = 2,
+}
+
+export enum PlotType {
+    LAST_SCREEN_DISPLAY = 0,
+    DRAWING_EXTENTS = 1,
+    DRAWING_LIMITS = 2,
+    VIEW_SPECIFIED = 3, // specified in plotViewName
+    WINDOW_SPECIFIED = 4, // specified in plotViewName
+    LAYOUT_INFORMATION = 5,
+}
+
+export enum ShadePlotMode {
+    AS_DISPLAYED = 0,
+    WIREFRAME = 1,
+    HIDDEN = 2,
+    RENDERED = 3,
+}
+
+export enum ShadePlotResolution {
+    DRAFT = 0,
+    PREVIEW = 1,
+    NORMAL = 2,
+    PRESENTATION = 3,
+    MAXIMUM = 4,
+    CUSTOM = 5,
+}
+
+export interface PlotSettingDXFObject extends CommonDXFObject {
+    subclassMarker: 'AcDbPlotSettings7';
+    pageSetupName: string;
+    configName: string;
+    paperSize: string;
+    plotViewName: string;
+    marginLeft: number;
+    marginBottom: number;
+    marginRight: number;
+    marginTop: number;
+    paperWidth: number;
+    paperHeight: number;
+    plotOriginX: number;
+    plotOriginY: number;
+    windowAreaXMin: number;
+    windowAreaYMin: number;
+    windowAreaXMax: number;
+    windowAreaYMax: number;
+    printScaleNominator: number;
+    printScaleDenominator: number;
+    layoutFlag: number;
+    plotPaperUnit: PlotPaperUnit;
+    plotRotation: 0 | 1 | 2 | 3;
+    plotType: PlotType;
+    currentStyleSheet: string;
+    standardScaleType: number; // see https://help.autodesk.com/view/OARX/2023/ENU/?guid=GUID-1113675E-AB07-4567-801A-310CDE0D56E9
+    shadePlotMode: ShadePlotMode;
+    shadePlotResolution: ShadePlotResolution;
+    shadePlotCustomDPI?: number; // 100 ~ 32767
+    scaleFactor: number;
+    imageOriginX: number;
+    imageOriginY: number;
+    shadePlotId: string;
+}

package/src/parser/objects/treefy.ts

@@ -0,0 +1,53 @@
+import type { HydratedDxfObject, DxfDictionary, DxfObject } from './types';
+
+export function createObjectTree(objects: DxfObject[]) {
+    const objectMap = Object.fromEntries(
+        objects.map((object) => [object.handle, object as HydratedDxfObject]),
+    );
+
+    for (const object of objects) {
+        hydrateParent(object, objectMap);
+        hydrateDictionary(object, objectMap);
+    }
+
+    return objects[0];
+}
+
+function hydrateParent(
+    object: HydratedDxfObject,
+    objectMap: Record<string, HydratedDxfObject>,
+) {
+    if (isDictionary(object) && object.ownerDictionaryIdSoft === '0') return;
+
+    if (object.ownerDictionaryIdSoft) {
+        object.ownerDictionarySoft = objectMap[object.ownerDictionaryIdSoft];
+    }
+
+    if (object.ownerDictionaryIdHard) {
+        object.ownerDictionaryHard = objectMap[object.ownerDictionaryIdHard];
+    }
+
+    if (object.ownerObjectId) {
+        object.ownerObject = objectMap[object.ownerObjectId];
+    }
+}
+
+function hydrateDictionary(
+    object: HydratedDxfObject,
+    objectMap: Record<string, HydratedDxfObject>,
+) {
+    if (!isDictionary(object) || !object.entries) return;
+
+    object.entries = Object.fromEntries(
+        (object.entries as any).map(
+            ({ name, objectId }: Record<string, string>) => [
+                name,
+                objectMap[objectId],
+            ],
+        ),
+    );
+}
+
+function isDictionary(object: HydratedDxfObject): object is DxfDictionary {
+    return (object as any).subclassMarker === 'AcDbDictionary';
+}

package/src/parser/objects/types.ts

@@ -0,0 +1,17 @@
+export interface DxfObject {
+    name: string;
+    handle: string;
+    ownerDictionaryIdSoft: string;
+    ownerDictionaryIdHard?: string;
+    ownerObjectId?: string;
+}
+
+export interface HydratedDxfObject extends DxfObject {
+    ownerDictionarySoft?: HydratedDxfObject;
+    ownerDictionaryHard?: HydratedDxfObject;
+    ownerObject?: HydratedDxfObject;
+}
+
+export interface DxfDictionary extends HydratedDxfObject {
+    entries?: Record<string, HydratedDxfObject>;
+}

package/src/parser/shared/index.ts

@@ -0,0 +1,21 @@
+import type { ScannerGroup } from '../DxfArrayScanner';
+
+let lastHandle = 0;
+
+export function ensureHandle(entity: any) {
+    if (!entity) {
+        throw new TypeError('entity cannot be undefined or null');
+    }
+
+    if (!entity.handle) {
+        entity.handle = lastHandle++;
+    }
+}
+
+/**
+ * group이 `code`와 `value`를 갖는지 확인
+ * `value`가 `null`이나 `undefined`인 경우 아무거나 다 매칭한다고 가정한다.
+ */
+export function isMatched(group: ScannerGroup, code: number, value?: any) {
+    return group.code === code && (value == null || group.value === value);
+}

package/src/parser/shared/parsePoint.ts

@@ -0,0 +1,37 @@
+import type { Point2D, Point3D } from '../../types';
+import type DxfArrayScanner from '../DxfArrayScanner';
+
+/**
+ * Parses the 2D or 3D coordinate, vector, or point. When complete,
+ * the scanner remains on the last group of the coordinate.
+ */
+export function parsePoint(scanner: DxfArrayScanner): Point3D | Point2D {
+    const point = {} as Point3D;
+
+    // Reread group for the first coordinate
+    scanner.rewind();
+    let curr = scanner.next();
+    const firstCode = curr.code;
+    point.x = curr.value as number;
+
+    curr = scanner.next();
+    if (curr.code !== firstCode + 10)
+        throw new Error(
+            'Expected code for point value to be ' +
+            20 +
+            ' but got ' +
+            curr.code +
+            '.',
+        );
+    point.y = curr.value as number;
+
+    curr = scanner.next();
+    if (curr.code !== firstCode + 20) {
+        // Only the x and y are specified. Don't read z.
+        scanner.rewind(); // Let the calling code advance off the point
+        return point;
+    }
+    point.z = curr.value as number;
+
+    return point;
+}

package/src/parser/shared/parserGenerator.test.ts

@@ -0,0 +1,164 @@
+import DxfArrayScanner from '../DxfArrayScanner';
+import { createParser, Identity } from './parserGenerator';
+
+describe('createParser', () => {
+    it('snippet을 소모하고 name이 있으면 object에 넣어야 한다.', () => {
+        const parse = createParser([
+            {
+                code: 1,
+                name: 'a',
+                parser: Identity,
+            },
+            {
+                code: 2,
+                name: 'b',
+                parser: Identity,
+            },
+            {
+                code: 3,
+                name: 'c',
+                parser: Identity,
+            },
+        ]);
+
+        const scanner = new DxfArrayScanner([
+            '1',
+            'x',
+            '2',
+            'y',
+            '3',
+            'z',
+            '0',
+            'EOF',
+        ]);
+
+        const obj = {} as any;
+        let curr = scanner.next();
+        parse(curr, scanner, obj);
+
+        expect(obj.a).toBe('x');
+        expect(obj.b).toBe('y');
+        expect(obj.c).toBe('z');
+    });
+
+    it('정해진 snippet을 소모하고 나면 파서가 종료해야한다.', () => {
+        const parse = createParser([
+            {
+                code: 1,
+            },
+            {
+                code: 2,
+            },
+            {
+                code: 3,
+            },
+        ]);
+
+        const scanner = new DxfArrayScanner([
+            '1',
+            '',
+            '2',
+            '',
+            '3',
+            '',
+            '1',
+            '',
+            '2',
+            '',
+            '0',
+            'EOF',
+        ]);
+
+        let curr = scanner.next();
+        parse(curr, scanner, {});
+
+        curr = scanner.next();
+        expect(curr.code).toBe(1);
+    });
+
+    it('isMultiple이 걸린 경우 snippet을 소모해선 안된다', () => {
+        const parse = createParser([
+            {
+                code: 1,
+                name: 'a',
+                isMultiple: true,
+                parser: Identity,
+            },
+            {
+                code: 2,
+                name: 'b',
+                parser: Identity,
+            },
+            {
+                code: 3,
+                name: 'c',
+                parser: Identity,
+            },
+        ]);
+
+        const scanner = new DxfArrayScanner([
+            '1',
+            'x',
+            '2',
+            'y',
+            '3',
+            'z',
+            '1',
+            'u',
+            '2',
+            'v',
+            '0',
+            'EOF',
+        ]);
+
+        const obj = {} as any;
+        let curr = scanner.next();
+        parse(curr, scanner, obj);
+
+        expect(obj.a instanceof Array).toBeTruthy();
+        expect(obj.a[0]).toBe('x');
+        expect(obj.a[1]).toBe('u');
+
+        curr = scanner.next();
+        expect(curr.code).toBe(2);
+    });
+
+    it('pushContext가 걸린 경우, 새로 생긴 맥락부터 뒤져본다.', () => {
+        const parse = createParser([
+            {
+                code: 1,
+                name: 'a',
+                parser: Identity,
+            },
+            {
+                code: 2,
+                name: 'b',
+                parser: Identity,
+                pushContext: true,
+            },
+            {
+                code: 1,
+                name: 'c',
+                parser: Identity,
+            },
+        ]);
+
+        const scanner = new DxfArrayScanner([
+            '1',
+            'x',
+            '2',
+            'y',
+            '1',
+            'z',
+            '0',
+            'EOF',
+        ]);
+
+        const obj = {} as any;
+        let curr = scanner.next();
+        parse(curr, scanner, obj);
+
+        expect(obj.a).toBe('z');
+        expect(obj.c).toBe('x');
+    });
+});

package/src/parser/shared/parserGenerator.ts

@@ -0,0 +1,180 @@
+import { isMatched } from '.';
+import type DxfArrayScanner from '../DxfArrayScanner';
+import { ScannerGroup } from '../DxfArrayScanner';
+import { parsePoint } from './parsePoint';
+
+export const Abort = Symbol();
+
+// Snippet은 스트림에서 code를 읽었을 때 적절한 원자 파서를
+// 대응해 주는 역할을 한다.
+// Snippet은 스택에 쌓이며, 여러 Snippet이 동일한 code를
+// 소비할 수 있을 때, 가장 위에 쌓인 Snippet이 우선순위를 갖는다.
+export interface DXFParserSnippet {
+    code: number | number[]; // 복수의 코드를 다 한 곳으로 몰아넣기
+    name?: string; // 파싱한 값을 넣을 오브젝트 속성 명, 없으면 등록 안하고 패스함
+
+    // 추가로 더 읽어야 할 때만 scanner 사용하고, 새 값은 읽어놓지 말 것
+    // 반환되는 값이 entity[name]에 대입되므로 특별한 경우엔 entity 건들지 말고
+    // 사용할 경우, 최종값이 반환되도록 잘 건드릴 것
+    // 만약 Abort 심볼이 반환될 경우 값에 대입하지 않고 읽은 것을 한 칸 되돌리고
+    // 종료함
+    parser?(curr: ScannerGroup, scanner: DxfArrayScanner, entity: any): any;
+    isMultiple?: boolean; // code가 여러 번 들어올 수 있는 경우, true로 표기
+
+    // https://github.com/connect-for-you/cadview-front/issues/41
+    // 이 스니펫을 기점으로 맥락을 바꿈
+    pushContext?: boolean;
+}
+
+// 만약 파서가 어떤 유의미한 snippet도 찾지 못한 경우 전진하지 말고 false 반환
+// 만약 파서가 유의미한 snippet을 찾아서 사용한 경우 반드시 한 칸 전진시키고 true 반환
+// 즉 새로운 애를 하나는 무조건 읽어놓음
+export type DXFParser = (
+    curr: ScannerGroup,
+    scanner: DxfArrayScanner,
+    target: any,
+) => boolean;
+
+export function createParser(
+    snippets: DXFParserSnippet[],
+    defaultObject?: any,
+): DXFParser {
+    return (curr, scanner, target) => {
+        const snippetMaps = createSnippetMaps(snippets);
+        let isReadOnce = false;
+        let contextIndex = snippetMaps.length - 1;
+
+        while (!isMatched(curr, 0, 'EOF')) {
+            const snippetMap = findSnippetMap(
+                snippetMaps,
+                curr.code,
+                contextIndex,
+            );
+            const snippet = snippetMap?.[curr.code].at(-1);
+
+            if (!snippetMap || !snippet) {
+                scanner.rewind();
+                break;
+            }
+
+            if (!snippet.isMultiple) {
+                snippetMap[curr.code].pop();
+            }
+
+            const { name, parser, isMultiple } = snippet;
+            const parsedValue = parser?.(curr, scanner, target);
+
+            if (parsedValue === Abort) {
+                scanner.rewind();
+                break;
+            }
+
+            if (name) {
+                const [leaf, fieldName] = getObjectByPath(target, name);
+
+                if (isMultiple) {
+                    // prototype으로 디폴트값 넣어준 경우 nullish coalescing으로 해결 안됨 
+                    // @ts-ignore
+                    if (!Object.hasOwn(leaf, fieldName)) {
+                        leaf[fieldName] = [];
+                    }
+                    leaf[fieldName].push(parsedValue);
+                } else {
+                    leaf[fieldName] = parsedValue;
+                }
+            }
+
+            if (snippet.pushContext) {
+                contextIndex -= 1;
+            }
+
+            isReadOnce = true;
+            curr = scanner.next();
+        }
+
+        if (defaultObject) {
+            Object.setPrototypeOf(target, defaultObject);
+        }
+
+        return isReadOnce;
+    };
+}
+
+function createSnippetMaps(snippets: DXFParserSnippet[]) {
+    return snippets.reduce(
+        (acc, snippet) => {
+            if (snippet.pushContext) {
+                acc.push({});
+            }
+
+            const context = acc[acc.length - 1];
+            const codes =
+                typeof snippet.code === 'number'
+                    ? [snippet.code]
+                    : snippet.code;
+
+            for (const code of codes) {
+                const bin = (context[code] ??= []);
+
+                if (snippet.isMultiple && bin.length) {
+                    console.warn(
+                        `Snippet ${bin.at(-1)!.name
+                        } for code(${code}) is shadowed by ${snippet.name}`,
+                    );
+                }
+                bin.push(snippet);
+            }
+
+            return acc;
+        },
+        [{}] as Record<number, DXFParserSnippet[]>[],
+    );
+}
+
+function findSnippetMap(
+    snippetMaps: Record<number, DXFParserSnippet[]>[],
+    code: number,
+    contextIndex: number,
+) {
+    return snippetMaps.find(
+        (map, index) => index >= contextIndex && map[code]?.length,
+    );
+}
+
+/**
+ * path를 .으로 나누고, 그 서브패스의 값을 설정할 수 있게 함.
+ * 값이 없으면 알아서 만듦
+ *
+ * ex) a.b -> target[a]를 반환하여 b를 대입할 수 있게 함
+ *     a.b.c -> target[a][b]를 반환하여 c를 대입할 수 있게 함
+ *
+ * @param target .으로 구분된 경로
+ * @param path
+ * @return [finalTargetObject, name]
+ */
+function getObjectByPath(target: any, path: string) {
+    const fragments = path.split('.');
+
+    let currentTarget = target;
+    for (let depth = 0; depth < fragments.length - 1; ++depth) {
+        const currentName = fragments[depth];
+        // @ts-ignore
+        if (!Object.hasOwn(currentTarget, currentName)) {
+            currentTarget[currentName] = {};
+        }
+        currentTarget = currentTarget[currentName];
+    }
+    return [currentTarget, fragments.at(-1)!];
+}
+
+export function Identity({ value }: ScannerGroup) {
+    return value;
+}
+
+export function PointParser(_: any, scanner: DxfArrayScanner) {
+    return parsePoint(scanner);
+}
+
+export function ToBoolean({ value }: ScannerGroup) {
+    return !!value;
+}

package/src/parser/shared/xdata/index.ts

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