@x-viewer/core 0.9.0

package/dist/types/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;
+}) => DxfMTextContentElement[];

package/dist/types/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/types/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/types/core/dxf/round10.d.ts

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

package/dist/types/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 _default: number[];
+export default _default;

package/dist/types/core/dxf-parser/DxfBaseReader.d.ts

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

package/dist/types/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/types/core/dxf-parser/DxfParser.d.ts

@@ -0,0 +1,324 @@
+import IGeometry, { IEntity, IPoint } from "./entities/geomtry";
+import { IClass, 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;
+    handle?: 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: number;
+    ucsOrigin: IPoint;
+    ucsXAxis: IPoint;
+    ucsYAxis: IPoint;
+    renderMode: string;
+    defaultLightingType: number;
+    defaultLightingOn: boolean;
+    ownerHandle: string;
+    ambientColor: number;
+}
+/**
+ * Viewport table definition.
+ * @internal
+ */
+export interface IViewportTableDefinition {
+    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 {
+    dxfSymbolName: "LTYPE";
+    parseTableRecords(): Record<string, ILineType>;
+}
+/**
+ * Definition of a layer.
+ */
+export interface ILayer {
+    /**
+     * Unique layer name with the dxf/dwg file.
+     */
+    name: string;
+    /**
+     * AutoCAD entity handle as hex 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 {
+    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 {
+    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 {
+    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 {
+    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 {
+    entries: IViewport[];
+}
+/**
+ * @internal
+ */
+export interface ILayerTypesTable extends IBaseTable {
+    entries: Record<string, ILineType>;
+}
+/**
+ * @internal
+ */
+export interface ILayersTable extends IBaseTable {
+    entries: Record<string, ILayer>;
+}
+/**
+ * @internal
+ */
+export interface IStylesTable extends IBaseTable {
+    entries: Record<string, IStyle>;
+}
+/**
+ * @internal
+ */
+export interface IDimStyleTable extends IBaseTable {
+    entries: Record<string, IDimStyle>;
+}
+/**
+ * @internal
+ */
+export interface IBlockRecordsTable extends IBaseTable {
+    entries: Record<string, IBlockRecord>;
+}
+/**
+ * @internal
+ */
+export interface ITables {
+    VPORT: IViewportTable;
+    LTYPE: ILayerTypesTable;
+    LAYER: ILayersTable;
+    BLOCK_RECORD: IBlockRecordsTable;
+    STYLE: IStylesTable;
+    DIMSTYLE: IDimStyleTable;
+}
+/**
+ * @internal
+ */
+export type ITable = IViewportTable | ILayerTypesTable | ILayersTable | IBlockRecordsTable | IStylesTable | IDimStyleTable;
+/**
+ * @internal
+ */
+export interface IDxf {
+    header: Record<string, IPoint | number | string>;
+    entities: IEntity[];
+    blocks: Record<string, IBlock>;
+    tables: ITables;
+    objects: Record<string, IObject[]>;
+    classes: IClass[];
+}
+export default class DxfParser {
+    private encoding?;
+    private _entityHandlers;
+    private _objectHandlers;
+    private _layoutBlocks;
+    private unhandledSections;
+    private unhandledObjects;
+    private unhandledEntities;
+    private unsupportedLineTypes;
+    constructor(encoding?: string);
+    parse(source: string | ArrayBuffer): IDxf;
+    registerEntityHandler(handlerType: new () => IGeometry): void;
+    registerObjectHandler(handlerType: new () => IObjectParser): void;
+    private _parse;
+    /**
+     * Converts DwgEntity to IEntity
+     */
+    private _parseDwgEntity;
+    private _parseDwgEntities;
+    /**
+     * Simply call libredwg.convertEx(). For test usage.
+     */
+    private libredwgConvertEx;
+    private parseDwg;
+    /**
+     * Splits a string to string array by line separator, "\r\n", "\r", "\n", etc.
+     * We do this instead of using "String.prototype.split(/\r\n|\r|\n/g)", because it is extreamly slow!
+     */
+    private splitByLineSeparator;
+}

package/dist/types/core/dxf-parser/DxfTextReader.d.ts

@@ -0,0 +1,31 @@
+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/types/core/dxf-parser/ParseHelpers.d.ts

@@ -0,0 +1,45 @@
+import { DwgEntity } from "@mlightcad/libredwg-web";
+import { DxfBaseReader, IGroup } from "./DxfBaseReader";
+import { IEntity, IPoint } from "./entities/geomtry";
+import { IObject } from "./objects/common";
+/**
+ * This sdk cannot support some entity types, like "PROXY" and "REGION",
+ * and it cannot support all "HATCH". An unsupported entity may be exploded
+ * and be replaced by an insert (in dwg2dxf tool), in this case, we need to
+ * know its original type.
+ */
+export declare const OriginalTypes: string[];
+/**
+ * Returns the truecolor value of the given AutoCad color index value
+ * @return {Number} truecolor value as a number
+ */
+export declare function getAcadColor(index: number): number;
+/**
+ * Parses the 2D or 3D coordinate, vector, or point. When complete,
+ * the scanner remains on the last group of the coordinate.
+ * @param {*} scanner
+ */
+export declare function parsePoint(scanner: DxfBaseReader): IPoint;
+/**
+ * Parses 16 numbers as an array. When complete,
+ * the scanner remains on the last group of the value.
+ * @param {*} scanner
+ * @param {*} groupCode
+ */
+export declare function parseMatrix(scanner: DxfBaseReader, groupCode: number): number[];
+/**
+ * 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 declare function checkCommonEntityProperties(entity: IEntity, curr: IGroup): boolean;
+/**
+ * Attempts to parse codes common to all objects. Returns true if the group
+ * was handled by this function.
+ * @param {*} object - the object currently being parsed
+ * @param {*} curr - the current group being parsed
+ */
+export declare function checkCommonObjectProperties(object: IObject, curr: IGroup): boolean;
+export declare function convertDwgCommonEntityProperties(entity: DwgEntity, newEntity: IEntity): void;
+export declare function bigInt2HexString(val: bigint | number): string;

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

@@ -0,0 +1,13 @@
+import { Dwg3dFaceEntity } from "@mlightcad/libredwg-web";
+import IGeometry, { IEntity, IPoint } from "./geomtry";
+import { DxfBaseReader, IGroup } from "../DxfBaseReader";
+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;
+    parseDwgEntity(entity: Dwg3dFaceEntity): IEntity;
+}

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

@@ -0,0 +1,18 @@
+import { DxfBaseReader, IGroup } from "../DxfBaseReader";
+import IGeometry, { IEntity, IPoint } from "./geomtry";
+import { DwgArcEntity } from "@mlightcad/libredwg-web";
+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;
+    parseDwgEntity(entity: DwgArcEntity): IEntity;
+}

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

@@ -0,0 +1,33 @@
+import { DwgAttdefEntity } from "@mlightcad/libredwg-web";
+import IGeometry, { IEntity, IPoint } from "./geomtry";
+import { DxfBaseReader, IGroup } from "../DxfBaseReader";
+export interface IAttdefEntity extends IEntity {
+    xScale: number;
+    textStyle: "STANDARD" | string;
+    text: string;
+    tag: string;
+    prompt: string;
+    startPoint: IPoint;
+    endPoint: IPoint;
+    thickness: number;
+    textHeight: 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;
+    parseDwgEntity(entity: DwgAttdefEntity): IEntity;
+}

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

@@ -0,0 +1,33 @@
+import { DwgAttribEntity } from "@mlightcad/libredwg-web";
+import IGeometry, { IEntity, IPoint } from "./geomtry";
+import { DxfBaseReader, IGroup } from "../DxfBaseReader";
+export interface IAttribEntity extends IEntity {
+    xScale: number;
+    textStyle: "STANDARD" | string;
+    text: string;
+    tag: string;
+    prompt: string;
+    startPoint: IPoint;
+    endPoint: IPoint;
+    thickness: number;
+    textHeight: 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;
+    parseDwgEntity(entity: DwgAttribEntity): IEntity;
+}

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

@@ -0,0 +1,15 @@
+import { DwgCircleEntity } from "@mlightcad/libredwg-web";
+import IGeometry, { IEntity, IPoint } from "./geomtry";
+import { DxfBaseReader, IGroup } from "../DxfBaseReader";
+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;
+    parseDwgEntity(entity: DwgCircleEntity): IEntity;
+}

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

@@ -0,0 +1,24 @@
+import { DwgDimensionEntity } from "@mlightcad/libredwg-web";
+import IGeometry, { IEntity, IPoint } from "./geomtry";
+import { DxfBaseReader, IGroup } from "../DxfBaseReader";
+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;
+    parseDwgEntity(entity: DwgDimensionEntity): IEntity;
+}

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

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