@cadview/core 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,510 @@
+interface Point2D {
+    x: number;
+    y: number;
+}
+interface Point3D {
+    x: number;
+    y: number;
+    z: number;
+}
+interface DxfDocument {
+    header: DxfHeader;
+    layers: Map<string, DxfLayer>;
+    lineTypes: Map<string, DxfLineType>;
+    styles: Map<string, DxfStyle>;
+    blocks: Map<string, DxfBlock>;
+    entities: DxfEntity[];
+}
+interface DxfHeader {
+    acadVersion: string;
+    extMin?: Point3D;
+    extMax?: Point3D;
+    insUnits: number;
+    measurement: number;
+    ltScale: number;
+    dwgCodePage?: string;
+    handleSeed?: string;
+    [key: string]: unknown;
+}
+interface DxfLayer {
+    name: string;
+    color: number;
+    lineType: string;
+    flags: number;
+    lineWeight: number;
+    trueColor?: number;
+    isOff: boolean;
+    isFrozen: boolean;
+    isLocked: boolean;
+}
+interface DxfLineType {
+    name: string;
+    description: string;
+    pattern: number[];
+    totalLength: number;
+}
+interface DxfStyle {
+    name: string;
+    fontName: string;
+    bigFontName: string;
+    height: number;
+    widthFactor: number;
+    obliqueAngle: number;
+}
+interface DxfBlock {
+    name: string;
+    basePoint: Point3D;
+    entities: DxfEntity[];
+    flags: number;
+}
+interface DxfEntityBase {
+    type: string;
+    handle?: string;
+    layer: string;
+    color: number;
+    trueColor?: number;
+    lineType: string;
+    lineTypeScale: number;
+    lineWeight: number;
+    visible: boolean;
+    extrusion: Point3D;
+}
+interface DxfLineEntity extends DxfEntityBase {
+    type: 'LINE';
+    start: Point3D;
+    end: Point3D;
+}
+interface DxfCircleEntity extends DxfEntityBase {
+    type: 'CIRCLE';
+    center: Point3D;
+    radius: number;
+}
+interface DxfArcEntity extends DxfEntityBase {
+    type: 'ARC';
+    center: Point3D;
+    radius: number;
+    startAngle: number;
+    endAngle: number;
+}
+interface DxfLwPolylineVertex {
+    x: number;
+    y: number;
+    bulge: number;
+    startWidth: number;
+    endWidth: number;
+}
+interface DxfLwPolylineEntity extends DxfEntityBase {
+    type: 'LWPOLYLINE';
+    vertices: DxfLwPolylineVertex[];
+    closed: boolean;
+    constantWidth: number;
+    elevation: number;
+}
+interface DxfPolylineEntity extends DxfEntityBase {
+    type: 'POLYLINE';
+    vertices: DxfLwPolylineVertex[];
+    closed: boolean;
+    is3d: boolean;
+}
+interface DxfEllipseEntity extends DxfEntityBase {
+    type: 'ELLIPSE';
+    center: Point3D;
+    majorAxis: Point3D;
+    minorRatio: number;
+    startParam: number;
+    endParam: number;
+}
+interface DxfSplineEntity extends DxfEntityBase {
+    type: 'SPLINE';
+    degree: number;
+    flags: number;
+    knots: number[];
+    controlPoints: Point3D[];
+    fitPoints: Point3D[];
+    weights: number[];
+    startTangent?: Point3D;
+    endTangent?: Point3D;
+}
+interface DxfTextEntity extends DxfEntityBase {
+    type: 'TEXT';
+    text: string;
+    insertionPoint: Point3D;
+    alignmentPoint?: Point3D;
+    height: number;
+    rotation: number;
+    widthFactor: number;
+    obliqueAngle: number;
+    style: string;
+    hAlign: number;
+    vAlign: number;
+    generationFlags: number;
+}
+interface DxfMTextEntity extends DxfEntityBase {
+    type: 'MTEXT';
+    text: string;
+    insertionPoint: Point3D;
+    height: number;
+    width: number;
+    attachmentPoint: number;
+    drawingDirection: number;
+    rotation: number;
+    lineSpacingStyle: number;
+    lineSpacingFactor: number;
+    style: string;
+    textDirection?: Point3D;
+    bgFill: number;
+    bgFillColor?: number;
+    bgFillTrueColor?: number;
+    bgFillScale: number;
+}
+interface DxfInsertEntity extends DxfEntityBase {
+    type: 'INSERT';
+    blockName: string;
+    insertionPoint: Point3D;
+    scaleX: number;
+    scaleY: number;
+    scaleZ: number;
+    rotation: number;
+    columnCount: number;
+    rowCount: number;
+    columnSpacing: number;
+    rowSpacing: number;
+    attribs: DxfAttrib[];
+}
+interface DxfAttrib {
+    tag: string;
+    text: string;
+    insertionPoint: Point3D;
+    height: number;
+    rotation: number;
+    style: string;
+    layer: string;
+    color: number;
+}
+interface DxfDimensionEntity extends DxfEntityBase {
+    type: 'DIMENSION';
+    blockName: string;
+    dimStyle: string;
+    dimType: number;
+    defPoint: Point3D;
+    textMidpoint: Point3D;
+    defPoint2?: Point3D;
+    defPoint3?: Point3D;
+    defPoint4?: Point3D;
+    defPoint5?: Point3D;
+    textOverride: string;
+    rotation: number;
+    textRotation: number;
+    leaderLength: number;
+}
+interface DxfHatchBoundaryPath {
+    type: 'polyline' | 'edges';
+    vertices?: Point2D[];
+    bulges?: number[];
+    isClosed?: boolean;
+    edges?: DxfHatchEdge[];
+    flags: number;
+}
+type DxfHatchEdge = {
+    type: 'line';
+    start: Point2D;
+    end: Point2D;
+} | {
+    type: 'arc';
+    center: Point2D;
+    radius: number;
+    startAngle: number;
+    endAngle: number;
+    ccw: boolean;
+} | {
+    type: 'ellipse';
+    center: Point2D;
+    majorAxis: Point2D;
+    minorRatio: number;
+    startAngle: number;
+    endAngle: number;
+    ccw: boolean;
+} | {
+    type: 'spline';
+    degree: number;
+    knots: number[];
+    controlPoints: Point2D[];
+    weights?: number[];
+};
+interface DxfHatchEntity extends DxfEntityBase {
+    type: 'HATCH';
+    patternName: string;
+    solidFill: boolean;
+    associative: boolean;
+    hatchStyle: number;
+    patternType: number;
+    patternAngle: number;
+    patternScale: number;
+    boundaryPaths: DxfHatchBoundaryPath[];
+}
+interface DxfPointEntity extends DxfEntityBase {
+    type: 'POINT';
+    position: Point3D;
+}
+type DxfEntity = DxfLineEntity | DxfCircleEntity | DxfArcEntity | DxfLwPolylineEntity | DxfPolylineEntity | DxfEllipseEntity | DxfSplineEntity | DxfTextEntity | DxfMTextEntity | DxfInsertEntity | DxfDimensionEntity | DxfHatchEntity | DxfPointEntity;
+
+/**
+ * Error thrown when DXF parsing fails.
+ */
+declare class DxfParseError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+/**
+ * Parse a DXF file from string or ArrayBuffer.
+ *
+ * @throws {DxfParseError} If the input is empty, malformed, or cannot be parsed.
+ */
+declare function parseDxf(input: string | ArrayBuffer): DxfDocument;
+
+declare function aciToHex(aci: number): string | undefined;
+declare function aciToDisplayColor(aci: number, isDarkTheme: boolean): string;
+declare function trueColorToHex(trueColor: number): string;
+
+interface ViewTransform {
+    scale: number;
+    offsetX: number;
+    offsetY: number;
+}
+declare function worldToScreen(vt: ViewTransform, wx: number, wy: number): [number, number];
+declare function screenToWorld(vt: ViewTransform, sx: number, sy: number): [number, number];
+declare function applyTransform(ctx: CanvasRenderingContext2D, vt: ViewTransform): void;
+declare function fitToView(canvasWidth: number, canvasHeight: number, minX: number, minY: number, maxX: number, maxY: number, padding?: number): ViewTransform;
+declare function zoomAtPoint(vt: ViewTransform, screenX: number, screenY: number, zoomFactor: number, minScale?: number, maxScale?: number): ViewTransform;
+declare class Camera {
+    private transform;
+    private minScale;
+    private maxScale;
+    constructor(options: {
+        minZoom: number;
+        maxZoom: number;
+    });
+    getTransform(): ViewTransform;
+    setTransform(vt: ViewTransform): void;
+    pan(dx: number, dy: number): void;
+    zoom(screenX: number, screenY: number, factor: number): void;
+}
+
+type Theme = 'dark' | 'light';
+interface ThemeConfig {
+    backgroundColor: string;
+    defaultEntityColor: string;
+    selectionColor: string;
+    measureColor: string;
+    gridColor: string;
+    crosshairColor: string;
+}
+declare const THEMES: Record<Theme, ThemeConfig>;
+
+/**
+ * Resolve the display color for an entity.
+ *
+ * Resolution order:
+ * 1. Entity true color (code 420) - highest priority
+ * 2. Entity ACI color (code 62):
+ *    - 1-255: use ACI color table
+ *    - 0 (BYBLOCK): use parent INSERT color, or default if no parent
+ *    - 256 (BYLAYER): use layer color
+ * 3. Layer color (from LAYER table)
+ * 4. Default theme color (fallback)
+ */
+declare function resolveEntityColor(entity: DxfEntityBase, layers: Map<string, DxfLayer>, theme: Theme, parentColor?: string): string;
+
+declare class CanvasRenderer {
+    private canvas;
+    private ctx;
+    private width;
+    private height;
+    constructor(canvas: HTMLCanvasElement);
+    getContext(): CanvasRenderingContext2D;
+    getWidth(): number;
+    getHeight(): number;
+    updateSize(): void;
+    render(doc: DxfDocument, vt: ViewTransform, theme: Theme, visibleLayers: Set<string>, selectedEntityIndex: number): void;
+    renderEmpty(theme: Theme): void;
+    destroy(): void;
+}
+
+declare function drawEntity(ctx: CanvasRenderingContext2D, entity: DxfEntity, doc: DxfDocument, vt: ViewTransform, theme: Theme, pixelSize: number): void;
+
+interface SelectEvent {
+    entity: DxfEntity;
+    entityIndex: number;
+    worldPoint: Point2D;
+    screenPoint: Point2D;
+}
+interface MeasureEvent {
+    distance: number;
+    angle: number;
+    deltaX: number;
+    deltaY: number;
+    points: [Point2D, Point2D];
+}
+interface CadViewerEventMap {
+    select: SelectEvent;
+    measure: MeasureEvent;
+    viewchange: ViewTransform;
+}
+declare class EventEmitter<T extends Record<string, any> = Record<string, any>> {
+    private listeners;
+    on<K extends keyof T>(event: K, callback: (data: T[K]) => void): void;
+    off<K extends keyof T>(event: K, callback: (data: T[K]) => void): void;
+    emit<K extends keyof T>(event: K, data: T[K]): void;
+    removeAllListeners(): void;
+}
+
+type Tool = 'pan' | 'select' | 'measure';
+interface CadViewerOptions {
+    theme?: Theme;
+    backgroundColor?: string;
+    antialias?: boolean;
+    minZoom?: number;
+    maxZoom?: number;
+    zoomSpeed?: number;
+    initialTool?: Tool;
+}
+declare class CadViewer {
+    private canvas;
+    private renderer;
+    private camera;
+    private layerManager;
+    private emitter;
+    private spatialIndex;
+    private measureTool;
+    private doc;
+    private options;
+    private currentTool;
+    private inputHandler;
+    private resizeObserver;
+    private selectedEntityIndex;
+    private renderPending;
+    private destroyed;
+    private mouseScreenX;
+    private mouseScreenY;
+    constructor(canvas: HTMLCanvasElement, options?: CadViewerOptions);
+    loadFile(file: File): Promise<void>;
+    loadString(dxf: string): void;
+    loadArrayBuffer(buffer: ArrayBuffer): void;
+    /**
+     * Clear the current document and reset all state without destroying the viewer.
+     */
+    clearDocument(): void;
+    private onDocumentLoaded;
+    fitToView(): void;
+    zoomTo(scale: number): void;
+    panTo(worldX: number, worldY: number): void;
+    getViewTransform(): ViewTransform;
+    /** @internal */
+    getZoomSpeed(): number;
+    getLayers(): DxfLayer[];
+    setLayerVisible(name: string, visible: boolean): void;
+    setLayerColor(name: string, color: string): void;
+    setTheme(theme: Theme): void;
+    getTheme(): Theme;
+    setBackgroundColor(color: string): void;
+    setTool(tool: Tool): void;
+    getTool(): Tool;
+    private getCursorForTool;
+    on<K extends keyof CadViewerEventMap>(event: K, callback: (data: CadViewerEventMap[K]) => void): void;
+    off<K extends keyof CadViewerEventMap>(event: K, callback: (data: CadViewerEventMap[K]) => void): void;
+    getDocument(): DxfDocument | null;
+    getEntities(): DxfEntity[];
+    resize(): void;
+    destroy(): void;
+    /** @internal */
+    requestRender(): void;
+    private doRender;
+    /** @internal */
+    handlePan(dx: number, dy: number): void;
+    /** @internal */
+    handleZoom(screenX: number, screenY: number, factor: number): void;
+    /** @internal */
+    handleClick(screenX: number, screenY: number): void;
+    /** @internal — called by InputHandler for mouse move */
+    handleMouseMove(screenX: number, screenY: number): void;
+    private handleSelect;
+    private computeDocumentBounds;
+}
+
+declare class LayerManager {
+    private layers;
+    private visibility;
+    private colorOverrides;
+    private visibleCache;
+    setLayers(layers: Map<string, DxfLayer>): void;
+    getAllLayers(): DxfLayer[];
+    setVisible(name: string, visible: boolean): void;
+    isVisible(name: string): boolean;
+    setColorOverride(name: string, color: string): void;
+    getColorOverride(name: string): string | undefined;
+    getVisibleLayerNames(): Set<string>;
+    clear(): void;
+}
+
+interface SpatialItem {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    entityIndex: number;
+}
+declare class SpatialIndex {
+    private tree;
+    private items;
+    build(entities: DxfEntity[]): void;
+    search(minX: number, minY: number, maxX: number, maxY: number): SpatialItem[];
+    clear(): void;
+}
+/**
+ * Find the nearest entity to a world point.
+ * Returns entity index, or -1 if nothing is within tolerance.
+ */
+declare function hitTest(wx: number, wy: number, entities: DxfEntity[], spatialIndex: SpatialIndex, visibleLayers: Set<string>, scale: number): number;
+
+type SnapType = 'endpoint' | 'midpoint' | 'center' | 'nearest';
+interface SnapResult {
+    point: Point2D;
+    type: SnapType;
+    entityIndex: number;
+}
+type MeasureState = {
+    phase: 'idle';
+} | {
+    phase: 'first-point';
+} | {
+    phase: 'second-point';
+    firstPoint: Point2D;
+    firstSnap?: SnapResult;
+} | {
+    phase: 'done';
+    firstPoint: Point2D;
+    secondPoint: Point2D;
+    distance: number;
+    angle: number;
+};
+declare class MeasureTool {
+    state: MeasureState;
+    currentSnap: SnapResult | null;
+    activate(): void;
+    deactivate(): void;
+    handleClick(wx: number, wy: number, snap: SnapResult | null): MeasureEvent | null;
+    handleMove(snap: SnapResult | null): void;
+}
+declare function findSnaps(wx: number, wy: number, entities: DxfEntity[], spatialIndex: SpatialIndex, scale: number, snapTypes?: Set<SnapType>): SnapResult[];
+declare function renderMeasureOverlay(ctx: CanvasRenderingContext2D, vt: ViewTransform, measureTool: MeasureTool, mouseScreenX: number, mouseScreenY: number, theme: Theme): void;
+
+interface BBox {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+declare function computeEntitiesBounds(entities: DxfEntity[]): BBox | null;
+declare function computeEntityBBox(entity: DxfEntity): BBox | null;
+
+export { type BBox, CadViewer, type CadViewerEventMap, type CadViewerOptions, Camera, CanvasRenderer, type DxfArcEntity, type DxfAttrib, type DxfBlock, type DxfCircleEntity, type DxfDimensionEntity, type DxfDocument, type DxfEllipseEntity, type DxfEntity, type DxfEntityBase, type DxfHatchBoundaryPath, type DxfHatchEdge, type DxfHatchEntity, type DxfHeader, type DxfInsertEntity, type DxfLayer, type DxfLineEntity, type DxfLineType, type DxfLwPolylineEntity, type DxfLwPolylineVertex, type DxfMTextEntity, DxfParseError, type DxfPointEntity, type DxfPolylineEntity, type DxfSplineEntity, type DxfStyle, type DxfTextEntity, EventEmitter, LayerManager, type MeasureEvent, type MeasureState, MeasureTool, type Point2D, type Point3D, type SelectEvent, type SnapResult, type SnapType, SpatialIndex, THEMES, type Theme, type ThemeConfig, type Tool, type ViewTransform, aciToDisplayColor, aciToHex, applyTransform, computeEntitiesBounds, computeEntityBBox, drawEntity, findSnaps, fitToView, hitTest, parseDxf, renderMeasureOverlay, resolveEntityColor, screenToWorld, trueColorToHex, worldToScreen, zoomAtPoint };