@maqiuyao/dxf-viewer 0.1.0

package/dist/src/dxfViewer/core/dxf/LinePatternShaders.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from "three";
+export declare class LinePatternShaders {
+    /**
+     * Creates line shader by given pattern.
+     * Note: remember to call line.computeLineDistances() in order to make it work!
+     */
+    static createLineShaderMaterial(pattern: number[], color: number, scale: number, viewportScaleUniform: {
+        value: number;
+    }, cameraZoomUniform: {
+        value: number;
+    }): THREE.Material;
+}

package/dist/src/dxfViewer/core/dxf/bspline.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copied and ported to code standard as the b-spline library is not maintained any longer.
+ * Source:
+ * https://github.com/thibauts/b-spline
+ * Copyright (c) 2015 Thibaut Séguy <thibaut.seguy@gmail.com>
+ */
+export declare const bspline: (t: number, degree: number, points: number[][], knots: number[], weights?: number[]) => number[];

package/dist/src/dxfViewer/core/dxf/dxfom-mtext.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @internal
+ */
+export type DxfMTextContentElement = DxfMTextContentElement[] | string | {
+    /** font family */
+    f?: string;
+    /** bold */
+    b?: 0 | 1;
+    /** italic */
+    i?: 0 | 1;
+    /** code page */
+    c?: number;
+    /** pitch */
+    p?: number;
+    /** angle in degrees */
+    Q?: number;
+    /** character height (with unit) */
+    H?: [number, string];
+    /** character width (with unit) */
+    W?: [number, string];
+    /** stacking */
+    S?: [string, "^" | "/" | "#", string];
+    /** alignment (0: bottom, 1: center, 2: top) */
+    A?: 0 | 1 | 2;
+    /** color index */
+    C?: number;
+    /** character spacing */
+    T?: number;
+    /** underscore */
+    L?: 0 | 1;
+    /** overscore */
+    O?: 0 | 1;
+    /** strike through */
+    K?: 0 | 1;
+};
+/**
+ * @internal
+ * [{f:""},
+ *  {W:[,]},
+ *  {C:number},
+ *  ...
+ *  ""] // The last one must be the test string
+ */
+export declare const parseDxfMTextContent: (s: string, options?: {
+    readonly encoding?: string | TextDecoder | undefined;
+}) => DxfMTextContentElement[];

package/dist/src/dxfViewer/core/dxf/dxfom-text.d.ts

@@ -0,0 +1,16 @@
+export interface DxfTextContentElement {
+    /** text content */
+    text: string;
+    /** strike-through */
+    k?: 1;
+    /** overscore */
+    o?: 1;
+    /** underscore */
+    u?: 1;
+}
+export declare const decodeDxfTextCharacterCodes: (text: string, mbcsEncoding?: string | TextDecoder) => string;
+export declare const decodeDxfTextUnicodeCodePoints: (text: string) => string;
+export declare const decodeDxfTextMbcsCharacterCodes: (text: string, encoding: string | TextDecoder) => string;
+export declare const parseDxfTextContent: (text: string, options?: {
+    readonly encoding?: string | TextDecoder;
+}) => DxfTextContentElement[];

package/dist/src/dxfViewer/core/dxf/index.d.ts

@@ -0,0 +1,10 @@
+export * from './DxfCompare';
+export * from './DxfLoader';
+export * from './bspline';
+export * from './dxfom-mtext';
+export * from './round10';
+export * from './DxfConstants';
+export * from './DxfUtils';
+export * from './HatchPatternShaders';
+export * from './LinePatternShaders';
+export * from './dxfom-text';

package/dist/src/dxfViewer/core/dxf/round10.d.ts

@@ -0,0 +1 @@
+export declare const round10: (value: number, exp: number) => number;

package/dist/src/dxfViewer/core/dxf-parser/AutoCadColorIndex.d.ts

@@ -0,0 +1,8 @@
+/**
+ * AutoCad files sometimes use an indexed color value between 1 and 255 inclusive.
+ * Each value corresponds to a color. index 1 is red, that is 16711680 or 0xFF0000.
+ * index 0 and 256, while included in this array, are actually reserved for inheritance
+ * values in AutoCad so they should not be used for index color lookups.
+ */
+declare const AutoCadColorIndex: number[];
+export default AutoCadColorIndex;

package/dist/src/dxfViewer/core/dxf-parser/DxfBaseReader.d.ts

@@ -0,0 +1,13 @@
+export interface IGroup {
+    code: number;
+    value: number | string | boolean;
+}
+export declare abstract class DxfBaseReader {
+    protected pointer: number;
+    protected eof: boolean;
+    lastReadGroup: IGroup | undefined;
+    constructor();
+    abstract next(): IGroup;
+    abstract hasNext(): boolean;
+    abstract isEOF(): boolean;
+}

package/dist/src/dxfViewer/core/dxf-parser/DxfBinaryReader.d.ts

@@ -0,0 +1,14 @@
+import { DxfBaseReader, IGroup } from './DxfBaseReader';
+export default class DxfBinaryReader extends DxfBaseReader {
+    private reader;
+    private decoder;
+    private int8Array;
+    private caches;
+    constructor(data: ArrayBuffer);
+    next(): IGroup;
+    hasNext(): boolean;
+    isEOF(): boolean;
+    private parseGroupValue;
+    private readNullTerminatedString;
+    private ReadBinaryData;
+}

package/dist/src/dxfViewer/core/dxf-parser/DxfParser.d.ts

@@ -0,0 +1,321 @@
+import { default as IGeometry, IEntity, IPoint } from './entities/geomtry';
+import { IObject, IObjectParser } from './objects/common';
+/**
+ * @internal
+ */
+export declare enum BlockTypeFlags {
+    None = 0,
+    AnonymousBlock = 1,
+    NonConstantAttributeDefinitions = 2,
+    XRef = 4,
+    XRefOverlay = 8,
+    ExternallyDependent = 16,
+    ResolvedExternalReference = 32,
+    DefinitionExternalReference = 64
+}
+/**
+ * Definition of a block. Which contains entities, name, handle, etc.
+ * @internal
+ */
+export interface IBlock {
+    entities: IEntity[];
+    ownerHandle: string;
+    xrefPath: string;
+    name: string;
+    name2: string;
+    handle: string;
+    layer: string;
+    position: IPoint;
+    paperSpace: boolean;
+    blockType: BlockTypeFlags;
+    description?: string;
+}
+/**
+ * Definition of a viewport.
+ * @internal
+ */
+export interface IViewport {
+    name: string;
+    lowerLeftCorner: IPoint;
+    upperRightCorner: IPoint;
+    center: IPoint;
+    snapBasePoint: IPoint;
+    snapSpacing: IPoint;
+    gridSpacing: IPoint;
+    viewDirectionFromTarget: IPoint;
+    viewTarget: IPoint;
+    aspectRatio: number;
+    lensLength: number;
+    frontClippingPlane: string | number | boolean;
+    backClippingPlane: string | number | boolean;
+    viewHeight: number;
+    snapRotationAngle: number;
+    viewTwistAngle: number;
+    orthographicType: string;
+    ucsOrigin: IPoint;
+    ucsXAxis: IPoint;
+    ucsYAxis: IPoint;
+    renderMode: string;
+    defaultLightingType: string;
+    defaultLightingOn: string;
+    ownerHandle: string;
+    ambientColor: number;
+}
+/**
+ * Viewport table definition.
+ * @internal
+ */
+export interface IViewportTableDefinition {
+    tableRecordsProperty: "viewports";
+    tableName: "viewport";
+    dxfSymbolName: "VPORT";
+    parseTableRecords(): IViewport[];
+}
+/**
+ * Line type.
+ * @internal
+ */
+export interface ILineType {
+    name: string;
+    description: string;
+    pattern: number[];
+    patternLength: number;
+}
+/**
+ * Line type table definition.
+ * @internal
+ */
+export interface ILineTypeTableDefinition {
+    tableRecordsProperty: "lineTypes";
+    tableName: "lineType";
+    dxfSymbolName: "LTYPE";
+    parseTableRecords(): Record<string, ILineType>;
+}
+/**
+ * Definition of a layer.
+ */
+export interface ILayer {
+    /**
+     * Unique layer name with the dxf/dwg file.
+     */
+    name: string;
+    /**
+     * @internal
+     */
+    handle: string;
+    visible: boolean;
+    /**
+     * @internal
+     */
+    colorIndex: number;
+    /**
+     * color in decimal
+     */
+    color: number;
+    /**
+     * @internal
+     */
+    frozen: boolean;
+    /**
+     * @internal
+     */
+    flag: number;
+    /**
+     * @internal
+     */
+    lineType: string;
+    /**
+     * @internal
+     */
+    lineweight: 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 | -2 | -1;
+}
+/**
+ * Layer table definition.
+ * @internal
+ */
+export interface ILayerTableDefinition {
+    tableRecordsProperty: "layers";
+    tableName: "layer";
+    dxfSymbolName: "LAYER";
+    parseTableRecords(): Record<string, ILayer>;
+}
+/**
+ * BlockRecord
+ * @internal
+ */
+export interface IBlockRecord {
+    handle: string;
+    ownerHandle: string;
+    blockName: string;
+    layoutHandle: string;
+    blockInsertUnits: number;
+    blockExplodability: number;
+    blockScalability: number;
+    bitmap?: string;
+}
+/**
+ * @internal
+ */
+export interface IBlockRecordTableDefinition {
+    tableRecordsProperty: "blockRecords";
+    tableName: "blockRecord";
+    dxfSymbolName: "BLOCK_RECORD";
+    parseTableRecords(): Record<string, IBlockRecord>;
+}
+/**
+ * Definition of a style.
+ * @internal
+ */
+export interface IStyle {
+    handle: string;
+    ownerHandle: string;
+    styleName: string;
+    priorTextHeight: number;
+    textHeight: number;
+    xScale: number;
+    rotation: number;
+    mirrorType: number;
+    fontFile: string;
+    bigFontFile: string;
+}
+/**
+ * Style table definition.
+ * @internal
+ */
+export interface IStyleTableDefinition {
+    tableRecordsProperty: "styles";
+    tableName: "style";
+    dxfSymbolName: "STYLE";
+    parseTableRecords(): Record<string, IStyle>;
+}
+/**
+ * Dim style.
+ * @internal
+ */
+export interface IDimStyle {
+    styleName: string;
+    DIMSCALE: number;
+    DIMASZ: number;
+    DIMEXO: string;
+    DIMEXE: string;
+    DIMSE1: string;
+    DIMSE2: string;
+    DIMTAD: string;
+    DIMTXT: string;
+    DIMGAP: number;
+    DIMCLRD: number;
+    DIMCLRT: number;
+    DIMLFAC: number;
+    DIMDEC: string;
+    DIMLDRBLK: string;
+}
+/**
+ * Dim style table definition
+ * @internal
+ */
+export interface IDimStyleTableDefinition {
+    tableRecordsProperty: "dimStyles";
+    tableName: "dimStyle";
+    dxfSymbolName: "DIMSTYLE";
+    parseTableRecords(): Record<string, IDimStyle>;
+}
+/**
+ * Table definitions.
+ * @internal
+ */
+export interface ITableDefinitions {
+    VPORT: IViewportTableDefinition;
+    LTYPE: ILineTypeTableDefinition;
+    LAYER: ILayerTableDefinition;
+    BLOCK_RECORD: IBlockRecordTableDefinition;
+    STYLE: IStyleTableDefinition;
+    DIMSTYLE: IDimStyleTableDefinition;
+}
+/**
+ * Base table
+ * @internal
+ */
+export interface IBaseTable {
+    handle: string;
+    ownerHandle: string;
+}
+/**
+ * Viewport table
+ * @internal
+ */
+export interface IViewportTable extends IBaseTable {
+    viewports: IViewport[];
+}
+/**
+ * @internal
+ */
+export interface ILayerTypesTable extends IBaseTable {
+    lineTypes: Record<string, ILineType>;
+}
+/**
+ * @internal
+ */
+export interface ILayersTable extends IBaseTable {
+    layers: Record<string, ILayer>;
+}
+/**
+ * @internal
+ */
+export interface IStylesTable extends IBaseTable {
+    styles: Record<string, IStyle>;
+}
+/**
+ * @internal
+ */
+export interface IDimStyleTable extends IBaseTable {
+    dimStyles: Record<string, IDimStyle>;
+}
+/**
+ * @internal
+ */
+export interface IBlockRecordsTable extends IBaseTable {
+    blockRecords: Record<string, IBlockRecord>;
+}
+/**
+ * @internal
+ */
+export interface ITables {
+    viewport: IViewportTable;
+    lineType: ILayerTypesTable;
+    layer: ILayersTable;
+    blockRecord: IBlockRecordsTable;
+    style: IStylesTable;
+    dimStyle: IDimStyleTable;
+}
+/**
+ * @internal
+ */
+export type ITable = IViewportTable | ILayerTypesTable | ILayersTable | IBlockRecordsTable | IStylesTable | IDimStyleTable;
+/**
+ * @internal
+ */
+export interface IDxf {
+    header: Record<string, IPoint | number>;
+    entities: IEntity[];
+    blocks: Record<string, IBlock>;
+    tables: ITables;
+    objects: Record<string, IObject[]>;
+}
+export default class DxfParser {
+    private _entityHandlers;
+    private _objectHandlers;
+    private _layoutBlocks;
+    unhandledSections: Record<string, number>;
+    unhandledObjects: Record<string, number>;
+    unhandledEntities: Record<string, number>;
+    unsupportedLineTypes: Record<string, number>;
+    encoding: string;
+    constructor(encoding: string);
+    parse(data: string | ArrayBuffer): any;
+    registerEntityHandler(HandlerClass: new () => IGeometry): void;
+    registerObjectHandler(HandlerClass: new () => IObjectParser): void;
+    parseSync(data: string | ArrayBuffer): any;
+    parseStream(stream: any): Promise<any>;
+    private _parse;
+    private splitByLineSeparator;
+}

package/dist/src/dxfViewer/core/dxf-parser/DxfTextReader.d.ts

@@ -0,0 +1,30 @@
+import { IGroup, DxfBaseReader } from './DxfBaseReader';
+/**
+ * Based off the AutoCad 2012 DXF Reference
+ * http://images.autodesk.com/adsk/files/autocad_2012_pdf_dxf-reference_enu.pdf
+ *
+ * Reads through an array representing lines of a dxf file. Takes an array and
+ * provides an easy interface to extract group code and value pairs.
+ * @param data - an array where each element represents a line in the dxf file
+ * @constructor
+ */
+export default class DxfTextRender extends DxfBaseReader {
+    private data;
+    constructor(data: string[]);
+    /**
+     * Gets the next group (code, value) from the array. A group is two consecutive elements
+     * in the array. The first is the code, the second is the value.
+     * @returns {{code: Number}|*}
+     */
+    next(): IGroup;
+    /**
+     * Returns true if there is another code/value pair (2 elements in the array).
+     * @returns {boolean}
+     */
+    hasNext(): boolean;
+    /**
+     * Returns true if the scanner is at the end of the array
+     * @returns {boolean}
+     */
+    isEOF(): boolean;
+}

package/dist/src/dxfViewer/core/dxf-parser/ParseHelpers.d.ts

@@ -0,0 +1,18 @@
+import { DxfBaseReader, IGroup } from './DxfBaseReader';
+import { IPoint } from './entities/geomtry';
+/**
+ * Some entities may have their type hidden, and be replaced by an insert (in dwg2dxf tool),
+ * in this case, we need to know its original type.
+ */
+export declare const OriginalTypes: string[];
+export declare function getAcadColor(colorIndex: number): number;
+export declare function parsePoint(scanner: DxfBaseReader): IPoint;
+export declare function parseMatrix(scanner: DxfBaseReader, expectedCode: number): number[];
+/**
+ * 解析 DXF 实体的通用属性（适用于所有实体类型）
+ * @param entity - 当前实体对象
+ * @param group - 当前组码 { code: number, value: any }
+ * @returns 是否处理了该组码
+ */
+export declare function checkCommonEntityProperties(entity: any, group: IGroup): boolean;
+export declare function checkCommonObjectProperties(object: any, group: IGroup): boolean;

package/dist/src/dxfViewer/core/dxf-parser/entities/3dface.d.ts

@@ -0,0 +1,11 @@
+import { DxfBaseReader, IGroup } from '../DxfBaseReader';
+import { default as IGeometry, IEntity, IPoint } from './geomtry';
+export interface I3DfaceEntity extends IEntity {
+    shape: boolean;
+    hasContinuousLinetypePattern: boolean;
+    vertices: IPoint[];
+}
+export default class ThreeDface implements IGeometry {
+    ForEntityName: "3DFACE";
+    parseEntity(scanner: DxfBaseReader, curr: IGroup): I3DfaceEntity;
+}

package/dist/src/dxfViewer/core/dxf-parser/entities/arc.d.ts

@@ -0,0 +1,16 @@
+import { DxfBaseReader, IGroup } from '../DxfBaseReader';
+import { default as IGeometry, IEntity, IPoint } from './geomtry';
+export interface IArcEntity extends IEntity {
+    center: IPoint;
+    radius: number;
+    startAngle: number;
+    endAngle: number;
+    angleLength: number;
+    extrusionDirectionX: number;
+    extrusionDirectionY: number;
+    extrusionDirectionZ: number;
+}
+export default class Arc implements IGeometry {
+    ForEntityName: "ARC";
+    parseEntity(scanner: DxfBaseReader, curr: IGroup): IArcEntity;
+}

package/dist/src/dxfViewer/core/dxf-parser/entities/attdef.d.ts

@@ -0,0 +1,31 @@
+import { DxfBaseReader, IGroup } from '../DxfBaseReader';
+import { default as IGeometry, IEntity, IPoint } from './geomtry';
+export interface IAttdefEntity extends IEntity {
+    text: string;
+    tag: string;
+    prompt: string;
+    textStyle: string;
+    startPoint: IPoint;
+    endPoint: IPoint;
+    thickness: number;
+    textHeight: number;
+    xScale: number;
+    rotation: number;
+    obliqueAngle: number;
+    invisible: boolean;
+    constant: boolean;
+    verificationRequired: boolean;
+    preset: boolean;
+    backwards: boolean;
+    mirrored: boolean;
+    horizontalJustification: number;
+    fieldLength: number;
+    verticalJustification: number;
+    extrusionDirectionX: number;
+    extrusionDirectionY: number;
+    extrusionDirectionZ: number;
+}
+export default class Attdef implements IGeometry {
+    ForEntityName: "ATTDEF";
+    parseEntity(scanner: DxfBaseReader, curr: IGroup): IAttdefEntity;
+}

package/dist/src/dxfViewer/core/dxf-parser/entities/attrib.d.ts

@@ -0,0 +1,31 @@
+import { DxfBaseReader, IGroup } from '../DxfBaseReader';
+import { default as IGeometry, IEntity, IPoint } from './geomtry';
+export interface IAttribEntity extends IEntity {
+    text: string;
+    tag: string;
+    prompt: string;
+    textStyle: string;
+    startPoint: IPoint;
+    endPoint: IPoint;
+    thickness: number;
+    textHeight: number;
+    xScale: number;
+    rotation: number;
+    obliqueAngle: number;
+    invisible: boolean;
+    constant: boolean;
+    verificationRequired: boolean;
+    preset: boolean;
+    backwards: boolean;
+    mirrored: boolean;
+    horizontalJustification: number;
+    fieldLength: number;
+    verticalJustification: number;
+    extrusionDirectionX: number;
+    extrusionDirectionY: number;
+    extrusionDirectionZ: number;
+}
+export default class Attrib implements IGeometry {
+    ForEntityName: "ATTRIB";
+    parseEntity(scanner: DxfBaseReader, curr: IGroup): IAttribEntity;
+}

package/dist/src/dxfViewer/core/dxf-parser/entities/circle.d.ts

@@ -0,0 +1,13 @@
+import { DxfBaseReader, IGroup } from '../DxfBaseReader';
+import { default as IGeometry, IEntity, IPoint } from './geomtry';
+export interface ICircleEntity extends IEntity {
+    center: IPoint;
+    radius: number;
+    startAngle: number;
+    endAngle: number;
+    angleLength: number;
+}
+export default class Circle implements IGeometry {
+    ForEntityName: "CIRCLE";
+    parseEntity(scanner: DxfBaseReader, curr: IGroup): ICircleEntity;
+}

package/dist/src/dxfViewer/core/dxf-parser/entities/dimension.d.ts

@@ -0,0 +1,22 @@
+import { DxfBaseReader, IGroup } from '../DxfBaseReader';
+import { default as IGeometry, IEntity, IPoint } from './geomtry';
+export interface IDimensionEntity extends IEntity {
+    block: string;
+    dimStyleName: string;
+    anchorPoint: IPoint;
+    middleOfText: IPoint;
+    insertionPoint: IPoint;
+    linearOrAngularPoint1: IPoint;
+    linearOrAngularPoint2: IPoint;
+    diameterOrRadiusPoint: IPoint;
+    arcPoint: IPoint;
+    dimensionType: number;
+    attachmentPoint: number;
+    actualMeasurement: number;
+    text: string;
+    angle: number;
+}
+export default class Dimension implements IGeometry {
+    ForEntityName: "DIMENSION";
+    parseEntity(scanner: DxfBaseReader, curr: IGroup): IDimensionEntity;
+}

package/dist/src/dxfViewer/core/dxf-parser/entities/ellipse.d.ts

@@ -0,0 +1,15 @@
+import { DxfBaseReader, IGroup } from '../DxfBaseReader';
+import { default as IGeometry, IEntity, IPoint } from './geomtry';
+export interface IEllipseEntity extends IEntity {
+    center: IPoint;
+    majorAxisEndPoint: IPoint;
+    axisRatio: number;
+    startAngle: number;
+    endAngle: number;
+    extrusionDirection: IPoint;
+    name: string;
+}
+export default class Ellipse implements IGeometry {
+    ForEntityName: "ELLIPSE";
+    parseEntity(scanner: DxfBaseReader, curr: IGroup): IEllipseEntity;
+}