dxfview 0.0.2

package/dist/types/core/font/shx/TextShape.d.ts

@@ -0,0 +1,24 @@
+import * as THREE from "three";
+/**
+ * Text shape, to describe a specific character.
+ */
+export declare class TextShape extends THREE.Shape {
+    width: number;
+    lastPoint: THREE.Vector2;
+    polylines: Array<Array<THREE.Vector2>>;
+    private bounds;
+    constructor(lastPoint: THREE.Vector2, polylines: Array<Array<THREE.Vector2>>);
+    /**
+     * Gets an offsetted new TextShape
+     */
+    offset(vector: THREE.Vector2): TextShape;
+    /**
+     * Gets an transformed new TextShape
+     */
+    transform(matrix: THREE.Matrix3): TextShape;
+    protected calcWidth(polylines: THREE.Vector2[][]): number;
+    /**
+     * Converts a TextShape to THREE.BufferGeometry
+     */
+    toThreeGeometry(): THREE.BufferGeometry<THREE.NormalBufferAttributes>;
+}

package/dist/types/core/font/shx/gbk/index.d.ts

@@ -0,0 +1,4 @@
+export declare function encode(str: string): Uint8Array;
+export declare function traditionalChineseToSimpliled(text: string): string;
+export declare function isChinese(text: string): boolean;
+export declare function isTraditionalChinese(text: string): boolean;

package/dist/types/core/font/shx/index.d.ts

@@ -0,0 +1 @@
+export * from "./Shx.constants";

package/dist/types/core/font/shx/util/BitConverter.d.ts

@@ -0,0 +1,18 @@
+export declare class BitConverter {
+    static GetBytes(value: string | number | boolean | []): Uint8Array;
+    static Get1Bytes(value: number | boolean | []): Uint8Array;
+    static byteTosbyte(byte: number): number;
+    static ToBoolean(value: Uint8Array, startIndex: number): boolean;
+    static ToInt8(value: Uint8Array, startIndex: number): number;
+    static ToUInt8(value: Uint8Array, startIndex: number): number;
+    static ToInt16(value: Uint8Array, startIndex: number): number;
+    static ToInt32(value: Uint8Array, startIndex: number): number;
+    static ToUInt16(value: Uint8Array, startIndex: number): number;
+    static ToUInt32(value: Uint8Array, startIndex: number): number;
+    static ToChar(value: Uint8Array, startIndex: number): string;
+    static ToAscii(value: Uint8Array, startIndex: number): string;
+    static ToAsciiString(value: Uint8Array, startIndex: number, length: number): string;
+    static ToUTF16String(value: Uint8Array, startIndex: number, length: number): string;
+    static ToFloat32(value: Uint8Array, startIndex: number): number;
+    static ToFloat64(value: Uint8Array, startIndex: number): number;
+}

package/dist/types/core/geometry-offset/Edge.d.ts

@@ -0,0 +1,27 @@
+import type { Pair } from "polygon-clipping";
+/**
+ * Offset edge
+ * @internal
+ */
+export declare class Edge {
+    current: Pair;
+    next: Pair;
+    inNormal: Pair;
+    outNormal: Pair;
+    constructor(current: Pair, next: Pair);
+    /**
+     * Creates outwards normal
+     */
+    private outwardsNormal;
+    /**
+     * Creates inwards normal
+     */
+    private inwardsNormal;
+    /**
+     * Offsets the edge by dx, dy
+     */
+    offset(dx: number, dy: number): Edge;
+    inverseOffset(dx: number, dy: number): Edge;
+    inverse(): Edge;
+    static offsetEdge(current: Pair, next: Pair, dx: number, dy: number): Edge;
+}

package/dist/types/core/geometry-offset/Offset.d.ts

@@ -0,0 +1,46 @@
+import type { MultiPolygon, Pair, Polygon, Ring } from "polygon-clipping";
+import { Edge } from "./Edge";
+/**
+ * Offset builder
+ * @internal
+ */
+export declare class Offset {
+    vertices: Pair | Ring | Polygon;
+    edges: Edge[] | Edge[][];
+    private arcSegments;
+    private distance;
+    constructor(vertices: Pair | Ring | Polygon, arcSegments?: number);
+    /**
+     * Recursively process contour to create normals
+     */
+    private processContour;
+    setArcSegments(arcSegments: number): this;
+    /**
+     * Creates arch between two edges
+     *
+     * @param  {Array.<Object>} vertices
+     * @param  {Object}         center
+     * @param  {Number}         radius
+     * @param  {Object}         startVertex
+     * @param  {Object}         endVertex
+     * @param  {Number}         segments
+     * @param  {Boolean}        bOutwards
+     */
+    private createArc;
+    setDistance(dist: number): this;
+    private ensureLastPoint;
+    /**
+     * Decides by the sign if it's a padding or a margin
+     */
+    offset(dist: number): Pair | Ring | Polygon | MultiPolygon;
+    private offsetSegment;
+    private margin;
+    private padding;
+    offsetLine(dist: number): Pair | Ring | Polygon | MultiPolygon;
+    /**
+     * Just offsets lines, no fill
+     */
+    private offsetLines;
+    private offsetContour;
+    offsetPoint(distance: number): MultiPolygon;
+}

package/dist/types/core/geometry-offset/index.d.ts

@@ -0,0 +1 @@
+export * from "./Offset";

package/dist/types/core/helpers/BinaryReader.d.ts

@@ -0,0 +1,24 @@
+import JSBI from "jsbi";
+export declare class BinaryReader {
+    private endian;
+    private position;
+    private data;
+    private decoder;
+    constructor(arraybuffer: ArrayBuffer, endian?: string);
+    readAsciiString(length: number): string;
+    readUtf8String(length: number): string;
+    readBytes(length?: number): Uint8Array;
+    readUint8(): number;
+    readInt8(): number;
+    readUint16(): number;
+    readInt16(): number;
+    readUint32(): number;
+    readInt32(): number;
+    readFloat32(): number;
+    readFloat64(): number;
+    readInt64(): JSBI;
+    readUint64(): JSBI;
+    getPosition(): number;
+    setPosition(position: number): void;
+    isEnd(): boolean;
+}

package/dist/types/core/helpers/BoxSelectHelper.d.ts

@@ -0,0 +1,44 @@
+import * as THREE from "three";
+import { Tooltip } from "../../components/tool-tip";
+import { mouseButtonAction, singleTouchAction } from "../../core/camera-controls/types";
+import type { EventInfo, InputManager } from "../../core/input/InputManager";
+import type { BaseViewer } from "../../core/viewers";
+/**
+ * Box select an area in screen coordinate.
+ * @internal
+ */
+export declare class BoxSelectHelper {
+    protected viewer: BaseViewer;
+    protected input: InputManager;
+    protected mouseDown: boolean;
+    protected mouseMove: boolean;
+    protected mouseDownPositionX: number;
+    protected mouseDownPositionY: number;
+    protected tempKey?: mouseButtonAction;
+    protected tempTouch?: singleTouchAction;
+    protected tempEnableRotate: boolean;
+    protected rectDom?: HTMLDivElement;
+    protected tooltip?: Tooltip;
+    private active;
+    static readonly BORDER_COLOR = "#fff000";
+    static readonly BORDER_WIDTH = "2px";
+    protected resolve?: (value: THREE.Box2 | PromiseLike<THREE.Box2> | undefined) => void;
+    protected reject?: (reason: any) => void;
+    protected isResolvedOrRejected: boolean;
+    constructor(viewer: BaseViewer);
+    private get viewerContainer();
+    isActive(): boolean;
+    activate(): void;
+    deactivate(): void;
+    private mousedown;
+    private mousemove;
+    private mouseup;
+    keydown: (e: EventInfo) => void;
+    private drawRect;
+    private setRectDomVisible;
+    /**
+     * Starts to select a box area
+     */
+    select(): Promise<THREE.Box2 | undefined>;
+    destroy(): void;
+}

package/dist/types/core/helpers/LoadingHelper.d.ts

@@ -0,0 +1,46 @@
+import * as THREE from "three";
+import type { DxfData, DxfLoaderConfig } from "../../core/dxf";
+import type { FontManager } from "../../core/font";
+export declare class LoadingHelper {
+    private static decoderPath;
+    private gltfLoader?;
+    private font?;
+    private manager?;
+    constructor(manager?: THREE.LoadingManager);
+    /**
+     * Loads a model from local
+     * @param url Created by URL.createObjectURL(file)
+     * @param src Source filename, used to find out format
+     * @param onProgress On progress callback
+     * @returns Loaded object
+     */
+    loadLocalModel(url: string, src: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    loadModel(src: string, fileFormat?: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D | void>;
+    loadGltf(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    parseGltf(data: ArrayBuffer | string, path: string, onLoad: (object: THREE.Object3D) => void, onError?: (event: ErrorEvent) => void): void;
+    loadFbx(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    loadObj(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    loadStl(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    loadDae(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    loadDxf(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    loadPly(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    /**
+     * It is kind of tricky to load image into scene, but we'll do this by creating a sprite.
+     */
+    loadImage(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    /**
+     * Loads dxf data, including entities, tables(layers, blocks), etc.
+     */
+    loadDxfData(url: string, dxfDataId?: string, onProgress?: (event: ProgressEvent) => void, onLoad?: () => void, cfg?: DxfLoaderConfig): Promise<DxfData>;
+    /**
+     * Sets font.
+     * Font is required for DxfViewer to view Chinese, etc.
+     */
+    setFont(font: FontManager): void;
+    /**
+     * Sets decoder path for draco loader.
+     * @param decoderPath e.g., "libs/draco/gltf/"
+     */
+    static setDracoDecoderPath(path: string): void;
+    private getGltfLoader;
+}

package/dist/types/core/helpers/MobileTouchHelperDrawable.d.ts

@@ -0,0 +1,26 @@
+import * as THREE from "three";
+import { Drawable } from "../../core/canvas";
+import { EventInfo } from "../../core/input/InputManager";
+/**
+ * Touch helper for mobile
+ */
+export declare class MobileTouchHelperDrawable extends Drawable {
+    private position;
+    needsFrustumCulled: boolean;
+    renderOrder: number;
+    constructor(position: THREE.Vector2);
+    setPosition(position: THREE.Vector2): void;
+    isPointInPath(p: THREE.Vector3, raycaster?: THREE.Raycaster | undefined): boolean;
+    draw(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawInnerCircle(ctx: CanvasRenderingContext2D): void;
+    drawOuterRing(ctx: CanvasRenderingContext2D): void;
+    drawSnapTriangle(ctx: CanvasRenderingContext2D): void;
+    translate(tx: number, ty: number): void;
+    getTouchPoint(): {
+        x: number;
+        y: number;
+    };
+    isIntersect(e: EventInfo): boolean;
+    drawSelect(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    getClassType(): string;
+}

package/dist/types/core/helpers/OSnapHelper.d.ts

@@ -0,0 +1,167 @@
+import * as THREE from "three";
+import { CanvasRender, Drawable, DrawableList } from "../../core/canvas";
+import { ILine, OSnapMarkerType } from "../../core/utils";
+/**
+ * SnapDrawable：用于在 overlay canvas 上绘制对象捕捉（OSnap）标记。
+ * 它继承自 Drawable 并提供多种标记样式（十字、方块、三角等）以及可选的捕捉辅助线。
+ */
+export declare class SnapDrawable extends Drawable {
+    static lineColor: string;
+    static readonly FILL_COLOR_NONE = "rgba(0, 0, 0, 0)";
+    static readonly SNAP_LINE_COLOR = "rgba(255, 240, 0, 0.3)";
+    static lineWidth: number;
+    static iconSize: number;
+    needsFrustumCulled: boolean;
+    renderOrder: number;
+    snapType: OSnapMarkerType;
+    private osnapInfo?;
+    private drawSnapFunctions;
+    private snapLineVisible;
+    constructor(type: OSnapMarkerType);
+    setSnapLineVisible(visible: boolean): void;
+    draw(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawDebug(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawSelect(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    isPointInPath(p: THREE.Vector3): boolean;
+    drawSnapLine(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    /**
+     *      p1
+     *      |
+     *      | point (origin)
+     *     / \
+     *   /     \
+     *  p2      p3
+     */
+    drawTripleCorss(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawSquare(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawTriangle(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    /**
+     * Snap marker for circle center.
+     */
+    drawCircleWithCross(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawCross(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    /**
+     * p4|\
+     *   |  \
+     * p2|____\ p1 (origin)
+     *   |    | \
+     *   |____|___\
+     * P5     p3   P6
+     */
+    drawPerpendicular(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    update(osnapInfo: OSnapInfo): void;
+    getClassType(): string;
+}
+/**
+ * OSnapType：对象捕捉类型枚举，用于表示可捕捉的几何点类型。
+ * 数值设计为位掩码（便于使用按位或来开启/关闭不同类型）。
+ */
+export declare enum OSnapType {
+    None = 0,
+    Vertex = 1,
+    MiddlePoint = 2,
+    Edge = 4,
+    Face = 8,
+    FootOfPerpendicular = 16,
+    Intersection = 32,
+    CircleCenter = 64
+}
+interface OSnapInfo {
+    point: THREE.Vector3;
+    distance: number;
+    type: OSnapType;
+    line?: ILine;
+}
+export declare class OSnapHelper {
+    protected drawableList: DrawableList;
+    protected overlayRender?: CanvasRender;
+    protected markers: Record<number, SnapDrawable>;
+    protected activeOSnapType: OSnapType;
+    protected snapToleranceInWorldCoord: number;
+    protected intersectionLimit: number;
+    /**
+     * OSnapType 的优先级，数值越小优先级越高。
+     * 在多种捕捉结果出现时，依据优先级与距离选择最终的捕捉点。
+     */
+    osnapTypePriorities: Record<OSnapType, number>;
+    protected enabledOSnapTypes: number;
+    constructor(overlayRender: CanvasRender);
+    private initOSnapMarkers;
+    /**
+     * If a specific OSnapType is enabled.
+     */
+    isOSnapTypeEnabled(type: OSnapType): boolean;
+    /**
+     * Enables a specific OSnapType.
+     */
+    setOSnapTypeEnabled(type: OSnapType, enabled: boolean): void;
+    /**
+     * Sets snap tolerance in world coordinate.
+     */
+    setSnapTolerance(toleranceInWorldCoord: number): void;
+    /**
+     * Gets snap tolerance in world coordinate.
+     */
+    getSnapTolerance(): number;
+    setIntersectionLimit(val: number): void;
+    getIntersectionLimit(): number;
+    /**
+     * Gets osnap marker line color.
+     * @returns rgb/rgba number array, each value is between 0 and 1. e.g. [0.92, 0.95, 0.96].
+     */
+    getMarkerLineColor(): number[];
+    /**
+     * Sets osnap marker line color.
+     * @param color rgb/rgba number array, each value is between 0 and 1. e.g. [0.92, 0.95, 0.96].
+     */
+    setMarkerLineColor(color: number[]): void;
+    /**
+     * Gets osnap marker line width.
+     */
+    getMarkerLineWidth(): number;
+    /**
+     * Sets osnap marker line width.
+     */
+    setMarkerLineWidth(width: number): void;
+    /**
+     * Gets osnap marker icon size in pixel.
+     */
+    getMarkerIconSize(): number;
+    /**
+     * Sets osnap marker icon size in pixel.
+     */
+    setMarkerIconSize(size: number): void;
+    getMarker(type: OSnapType): SnapDrawable;
+    setAllSnapLinesVisible(visible: boolean): void;
+    deactivate(): void;
+    destroy(): void;
+    /**
+     * Tries to find a proper snap point and display corresponding marker.
+     * @param intersections The raycaster intersections, must have been sorted by distance.
+     * @param is3d If it is a 3d or 2d viewer.
+     * @param lastMouseDownPosition Used in order to to get foot of perpendicular.
+     * @returns Target snap point if any
+     */
+    handleSnap(rayCasterResult: THREE.Intersection[], is3d: boolean, lastMouseDownPosition?: THREE.Vector3): THREE.Vector3 | undefined;
+    /**
+     * Tries to find a proper snap point and display corresponding marker.
+     * @param mousePosition Mouse position in world coordinate.
+     * @param intersections
+     * @param is3d If it is a 3d or 2d viewer.
+     * @param lastMouseDownPosition Used in order to to get foot of perpendicular.
+     * @returns Target snap point if any
+     */
+    protected getSnapPointAndUpdateMarker(mousePosition: THREE.Vector3, intersections: THREE.Intersection[], is3d: boolean, lastMouseDownPosition?: THREE.Vector3): THREE.Vector3 | undefined;
+    activateMarker(type: OSnapType, osnapInfo?: OSnapInfo): void;
+    private getFootOfPerpendicular;
+    private getSnapInfo;
+    private getOsnapInfoListFromMesh;
+    private getOsnapInfoFromSegment;
+    private getOsnapInfoListFromLine;
+    private getOsnapInfoListFromPoint;
+    /**
+     * Used for 3d scene to get outline info by faces.
+     */
+    private getIntersectsIncludeOutline;
+}
+export {};

package/dist/types/core/helpers/ObjectPixelSizeHelper.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from "three";
+import { CameraControlsEx } from "../../core/controls";
+/**
+ * Helper class to adjust object visual size
+ */
+export declare class ObjectPixelSizeHelper {
+    private object;
+    private camera;
+    targetPixelHeight: number;
+    canvasHeight: number;
+    constructor(camera: THREE.Camera, controls: CameraControlsEx, object: THREE.Object3D, targetPixelHeight: number, canvasHeight: number);
+    adjustSize(): void;
+}

package/dist/types/core/helpers/PickMarkupHelper.d.ts

@@ -0,0 +1,29 @@
+import * as THREE from "three";
+import { Tooltip } from "../../components/tool-tip";
+import { EventInfo } from "../../core/input/InputManager";
+import type { BaseViewer } from "../../core/viewers";
+/**
+ * Box select an area in screen coordinate.
+ * @internal
+ */
+export declare class PickMarkupHelper {
+    protected viewer: BaseViewer;
+    private active;
+    protected tooltip?: Tooltip;
+    protected resolve?: (value: THREE.Box2 | PromiseLike<THREE.Box2> | undefined) => void;
+    protected reject?: (reason: any) => void;
+    protected isResolvedOrRejected: boolean;
+    constructor(viewer: BaseViewer);
+    private get viewerContainer();
+    private get camera();
+    isActive(): boolean;
+    private mouseClicked;
+    activate(): void;
+    deactivate(): void;
+    keydown: (e: EventInfo) => void;
+    /**
+     * Starts to pick a markup area.
+     */
+    pick(): Promise<THREE.Box2 | undefined>;
+    destroy(): void;
+}

package/dist/types/core/helpers/RafHelper.d.ts

@@ -0,0 +1,18 @@
+/**
+ * This class implemented setTimeout and setInterval using RequestAnimationFrame
+ * This code references to
+ * https://github.com/aisriver/myHome3D/blob/master/src/utils/RAF.ts
+ * @internal
+ */
+export declare class RafHelper {
+    readonly TIMEOUT = "timeout";
+    readonly INTERVAL = "interval";
+    private timeoutMap;
+    private intervalMap;
+    private run;
+    private setIdMap;
+    setTimeout(cb: () => void, interval: number): symbol;
+    clearTimeout(timer: symbol): void;
+    setInterval(cb: () => void, interval: number): symbol;
+    clearInterval(timer: symbol): void;
+}

package/dist/types/core/helpers/ZoomToRectHelper.d.ts

@@ -0,0 +1,17 @@
+import * as THREE from "three";
+import type { DxfViewer } from "../../core/viewers";
+export declare class ZoomToRectHelper {
+    protected viewer: DxfViewer;
+    private boxSelectHelper?;
+    private active;
+    constructor(viewer: DxfViewer);
+    private get viewerContainer();
+    get camera(): THREE.OrthographicCamera | THREE.PerspectiveCamera;
+    get raycaster(): THREE.Raycaster;
+    isActive(): boolean;
+    activate(): void;
+    deactivate(): void;
+    protected pickPositionByScreenPoint(p: THREE.Vector2): THREE.Vector3 | undefined;
+    protected handleZoomToRect(leftTop: THREE.Vector2, rightBottom: THREE.Vector2): void;
+    destroy(): void;
+}

package/dist/types/core/helpers/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./RafHelper";
+export * from "./BinaryReader";
+export * from "./LoadingHelper";
+export * from "./ObjectPixelSizeHelper";
+export * from "./OSnapHelper";
+export * from "./PickMarkupHelper";
+export * from "./BoxSelectHelper";
+export * from "./ZoomToRectHelper";
+export * from "./MobileTouchHelperDrawable";

package/dist/types/core/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./canvas";
+export * from "./compare";
+export * from "./controls";
+export * from "./dxf";
+export * from "./dxf-parser";
+export * from "./geometry-offset";
+export * from "./helpers";
+export * from "./input";
+export * from "./markup";
+export * from "./font";
+export * from "./utils";
+export * from "./model";
+export * from "./viewers";
+export * from "./Configs";
+export * from "./Constants";
+export * from "./Units";
+export * from "./VersionManager";
+export * from "./license/index";

package/dist/types/core/indexeddb/AnnotationTable.d.ts

@@ -0,0 +1,14 @@
+import { BaseTable } from "./BaseTable";
+/**
+ * Table is known as ObjectStore in IndexedDb
+ * AnnotationTable in IndexedDb
+ */
+export declare class AnnotationTable extends BaseTable {
+    tableName(): string;
+    /**
+     * Singleton design pattern
+     */
+    private static _instance;
+    static instance(): AnnotationTable;
+    query(projectId: string, successCallback?: any, errorCallback?: any): void;
+}

package/dist/types/core/indexeddb/BaseTable.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Table is known as ObjectStore in IndexedDb
+ */
+export declare class BaseTable {
+    db?: IDBDatabase;
+    isCreatingTable: boolean;
+    constructor();
+    /**
+     * Derived class have to override this method and return a table name!
+     */
+    tableName(): string;
+    /**
+     * Adds a record to a table
+     */
+    add(record: any, successCallback?: any, errorCallback?: any): void;
+    /**
+     * Saves a record
+     */
+    save(record: any, successCallback?: any, errorCallback?: any): void;
+    /**
+     * Deletes a record
+     */
+    delete(key: string, successCallback?: any, errorCallback?: any): void;
+    /**
+     * Updates a record
+     */
+    update(): void;
+    /**
+     * Queries records in a table
+     * @param cursorHandler callback to handle records one by one
+     */
+    query(cursorHandler?: any, errorCallback?: any): void;
+    queryByIndex(indexName: any, indexValue: any, successCallback?: any, errorCallback?: any): void;
+    queryAll(successCallback?: any, errorCallback?: any): void;
+    clearAll(successCallback?: any, errorCallback?: any): void;
+}

package/dist/types/core/indexeddb/DxfDataTable.d.ts

@@ -0,0 +1,22 @@
+import { BaseTable } from "./BaseTable";
+export interface DxfDataTableRecord {
+    dxfDataId: string;
+    dxf: object;
+}
+/**
+ * DxfDataTable in IndexedDb
+ * Table is known as ObjectStore in IndexedDb
+ */
+export declare class DxfDataTable extends BaseTable {
+    tableName(): string;
+    /**
+     * Singleton design pattern
+     */
+    private static _instance;
+    static instance(): DxfDataTable;
+    /**
+     * Queires a dxf data
+     * @param dxfDataId should be a unique id to identify different dxf files
+     */
+    query(dxfDataId: string, successCallback?: any, errorCallback?: any): void;
+}

package/dist/types/core/indexeddb/FontDataTable.d.ts

@@ -0,0 +1,32 @@
+import { BaseTable } from "./BaseTable";
+import type { Orientation, ShxFontType } from "../../core/font/shx";
+export interface FontDataTableRecord {
+    fontType?: ShxFontType;
+    order: number;
+    data: Record<number, Uint8Array>;
+    info: string;
+    orientation: Orientation;
+    baseUp: number;
+    baseDown: number;
+    fileName: string;
+    fileHeader: string;
+    fileVersion: string;
+}
+/**
+ * DxfDataTable in IndexedDb
+ * Table is known as ObjectStore in IndexedDb
+ */
+export declare class FontDataTable extends BaseTable {
+    tableName(): string;
+    /**
+     * Singleton design pattern
+     */
+    private static _instance;
+    static instance(): FontDataTable;
+    /**
+     * Queires a dxf data
+     * @param fileId should be a unique id to identify different dxf files
+     */
+    query(fileName: string): Promise<FontDataTableRecord>;
+    queryAll(): Promise<FontDataTableRecord[]>;
+}