@sienci/gviewer 0.1.0

package/dist/react.js

@@ -0,0 +1,141 @@
+import * as o from "react";
+import { a as w, G as V } from "./GCodeSVGRenderer-DnFLLJmH.js";
+const C = o.forwardRef(
+  function(u, c) {
+    const { id: l, options: n, callbacks: a, className: f, style: d } = u, i = o.useRef(null), t = o.useRef(null);
+    return o.useEffect(() => {
+      const e = i.current;
+      if (!e)
+        return;
+      const m = new w({ id: l, container: e, options: n, callbacks: a });
+      return t.current = m, () => {
+        t.current = null, m.dispose();
+      };
+    }, [l]), o.useEffect(() => {
+      var e;
+      (e = t.current) == null || e.setOptions(n ?? {});
+    }, [n]), o.useEffect(() => {
+      var e;
+      (e = t.current) == null || e.setCallbacks(a ?? {});
+    }, [a]), o.useImperativeHandle(
+      c,
+      () => {
+        const e = () => {
+          const r = t.current;
+          if (!r)
+            throw new Error("GCodeViewer is not ready.");
+          return r;
+        };
+        return {
+          get id() {
+            return l;
+          },
+          setCallbacks(r) {
+            e().setCallbacks(r);
+          },
+          snapCameraToView(r, s) {
+            e().snapCameraToView(r, s);
+          },
+          setBitPosition(r, s) {
+            e().setBitPosition(r, s);
+          },
+          setBitVisible(r) {
+            e().setBitVisible(r);
+          },
+          setToolpathRotationA(r) {
+            e().setToolpathRotationA(r);
+          },
+          hideUntilLine(r, s) {
+            e().hideUntilLine(r, s);
+          },
+          seekToLine(r, s) {
+            e().seekToLine(r, s);
+          },
+          showAll() {
+            e().showAll();
+          },
+          resetColors() {
+            e().resetColors();
+          },
+          loadFromUrl(r, s) {
+            return e().loadFromUrl(r, s);
+          },
+          loadFromFile(r) {
+            return e().loadFromFile(r);
+          },
+          loadFromText(r) {
+            return e().loadFromText(r);
+          },
+          loadFromLines(r) {
+            return e().loadFromLines(r);
+          },
+          unload() {
+            e().unload();
+          },
+          setOptions(r) {
+            e().setOptions(r);
+          },
+          getOptions() {
+            return e().getOptions();
+          },
+          resize() {
+            e().resize();
+          },
+          focusToModel() {
+            e().focusToModel();
+          },
+          resetCamera() {
+            e().resetCamera();
+          },
+          getBounds() {
+            return e().getBounds();
+          },
+          dispose() {
+            e().dispose();
+          }
+        };
+      },
+      [l]
+    ), o.createElement("div", { ref: i, className: f, style: d });
+  }
+), G = o.forwardRef(
+  function(u, c) {
+    const { id: l, options: n, className: a, style: f } = u, d = o.useRef(null), i = o.useRef(null);
+    return o.useEffect(() => {
+      const t = d.current;
+      if (!t) return;
+      const e = new V(t, n);
+      return i.current = e, () => {
+        i.current = null, e.dispose();
+      };
+    }, []), o.useEffect(() => {
+      var t;
+      n && ((t = i.current) == null || t.setOptions(n));
+    }, [n]), o.useImperativeHandle(c, () => {
+      const t = () => {
+        const e = i.current;
+        if (!e) throw new Error("GCodeSVGRenderer is not ready.");
+        return e;
+      };
+      return {
+        loadFromLines: (e) => t().loadFromLines(e),
+        loadFromFile: (e) => t().loadFromFile(e),
+        loadFromText: (e) => t().loadFromText(e),
+        clear: () => t().clear(),
+        resetView: () => t().resetView(),
+        setOptions: (e) => t().setOptions(e),
+        setProjectionMode: (e) => t().setProjectionMode(e),
+        getSVGElement: () => t().getSVGElement(),
+        dispose: () => t().dispose()
+      };
+    }, []), o.createElement("div", {
+      ref: d,
+      className: a,
+      style: { width: "100%", height: "100%", ...f }
+    });
+  }
+);
+export {
+  G as GCodeSVGVisualizer,
+  C as GCodeVisualizer
+};

package/dist/types/geometry.d.ts

@@ -0,0 +1,92 @@
+import { ArcMoveCallback, LinearMoveCallback, Position } from "./types";
+export type VertexCollector = {
+    onLinearMove?: (args: Parameters<LinearMoveCallback>[0], vertices: number[]) => void;
+    onArcMove?: (args: Parameters<ArcMoveCallback>[0], vertices: number[]) => void;
+};
+export type VertexBuildOptions = {
+    arcSegments?: number;
+    collector?: VertexCollector;
+};
+export type BatchBuildOptions = {
+    onProgress?: (processed: number, total: number) => void;
+    everyLines?: number;
+    yieldEveryLines?: number;
+    shouldAbort?: () => boolean;
+};
+export type MovementVertices = {
+    rapid: Float32Array;
+    cutting: Float32Array;
+};
+export type LaserBucket = {
+    opacity: number;
+    vertices: Float32Array;
+};
+export type LaserVertices = {
+    rapid: Float32Array;
+    buckets: LaserBucket[];
+    minPower: number;
+    maxPower: number;
+};
+export declare function buildVerticesFromLines(lines: Iterable<string>, options?: VertexBuildOptions): Float32Array;
+export declare function buildMovementVerticesFromLines(lines: Iterable<string>, options?: Omit<VertexBuildOptions, "collector">): MovementVertices;
+export declare function buildMovementVerticesFromLinesBatched(lines: readonly string[], options?: Omit<VertexBuildOptions, "collector"> & {
+    batch?: BatchBuildOptions;
+}): Promise<MovementVertices>;
+export type MovementGeometryLineKind = 0 | 1 | 2 | 3;
+export type MovementGeometry = {
+    positions: Float32Array;
+    lineStartVertex: Int32Array;
+    lineEndVertex: Int32Array;
+    lineKind: Uint8Array;
+    prefixEndVertex: Int32Array;
+};
+export declare function buildMovementGeometryFromLinesBatched(lines: readonly string[], options?: Omit<VertexBuildOptions, "collector"> & {
+    batch?: BatchBuildOptions;
+}): Promise<MovementGeometry>;
+export declare function buildLaserVerticesFromLines(lines: Iterable<string>, options?: {
+    arcSegments?: number;
+    bucketCount?: number;
+    baseOpacity?: number;
+}): LaserVertices;
+export declare function buildLaserVerticesFromLinesBatched(lines: readonly string[], options?: {
+    arcSegments?: number;
+    bucketCount?: number;
+    baseOpacity?: number;
+    batch?: BatchBuildOptions;
+}): Promise<LaserVertices>;
+export type LaserGeometryBucket = {
+    opacity: number;
+    positions: Float32Array;
+    prefixEndVertex: Int32Array;
+};
+export type LaserGeometry = {
+    rapidPositions: Float32Array;
+    rapidPrefixEndVertex: Int32Array;
+    buckets: LaserGeometryBucket[];
+    minPower: number;
+    maxPower: number;
+};
+export type ToolpathGeometryStream = {
+    positions: Float32Array;
+    prefixEndVertex: Int32Array;
+};
+export type ToolpathGeometry = {
+    rapid: ToolpathGeometryStream;
+    cuts: ToolpathGeometryStream[];
+    cutBucketCount: number;
+    minPower: number;
+    maxPower: number;
+};
+export declare function buildToolpathGeometryFromLinesBatched(lines: readonly string[], options?: {
+    arcSegments?: number;
+    bucketCount?: number;
+    laserMode?: boolean;
+    batch?: BatchBuildOptions;
+}): Promise<ToolpathGeometry>;
+export declare function buildLaserGeometryFromLinesBatched(lines: readonly string[], options?: {
+    arcSegments?: number;
+    bucketCount?: number;
+    baseOpacity?: number;
+    batch?: BatchBuildOptions;
+}): Promise<LaserGeometry>;
+export declare function pushXYZ(vertices: number[], position: Position): void;

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./parser";
+export * from "./virtualizer";
+export * from "./geometry";
+export * from "./types";

package/dist/types/parser.d.ts

@@ -0,0 +1,6 @@
+import { ParsedLine } from "./types";
+export declare class GCodeParser {
+    parseLine(line: string): ParsedLine;
+    private stripComments;
+    private parseWords;
+}

package/dist/types/react/GCodeSVGVisualizer.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+import type { GCodeSVGOptions } from "../viewer/svg/types";
+export type GCodeSVGRendererHandle = {
+    loadFromLines(lines: string[]): void;
+    loadFromFile(file: File): Promise<void>;
+    loadFromText(gcode: string): void;
+    clear(): void;
+    resetView(): void;
+    setOptions(opts: Partial<GCodeSVGOptions>): void;
+    setProjectionMode(mode: 'perspective' | 'isometric'): void;
+    getSVGElement(): SVGSVGElement;
+    dispose(): void;
+};
+export type GCodeSVGVisualizerProps = {
+    id: string;
+    options?: Partial<GCodeSVGOptions>;
+    className?: string;
+    style?: React.CSSProperties;
+};
+export declare const GCodeSVGVisualizer: React.ForwardRefExoticComponent<GCodeSVGVisualizerProps & React.RefAttributes<GCodeSVGRendererHandle>>;

package/dist/types/react/GCodeVisualizer.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+import type { GCodeViewerCallbacks, GCodeViewerHandle, GCodeViewerOptions } from "../viewer/types";
+export type GCodeVisualizerProps = {
+    id: string;
+    options?: Partial<GCodeViewerOptions>;
+    callbacks?: GCodeViewerCallbacks;
+    className?: string;
+    style?: React.CSSProperties;
+};
+export declare const GCodeVisualizer: React.ForwardRefExoticComponent<GCodeVisualizerProps & React.RefAttributes<GCodeViewerHandle>>;

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

@@ -0,0 +1,4 @@
+export { GCodeVisualizer } from "./GCodeVisualizer";
+export type { GCodeVisualizerProps } from "./GCodeVisualizer";
+export { GCodeSVGVisualizer } from "./GCodeSVGVisualizer";
+export type { GCodeSVGVisualizerProps, GCodeSVGRendererHandle } from "./GCodeSVGVisualizer";

package/dist/types/types.d.ts

@@ -0,0 +1,71 @@
+export type Axis = "X" | "Y" | "Z" | "A" | "B" | "C";
+export type Position = Record<Axis, number>;
+export type Comment = {
+    type: "paren" | "semicolon";
+    text: string;
+    start: number;
+    end: number;
+};
+export type GCodeWord = {
+    letter: string;
+    value: number;
+    raw: string;
+    start: number;
+    end: number;
+};
+export type ParsedLine = {
+    raw: string;
+    words: GCodeWord[];
+    gcodes: GCodeWord[];
+    params: GCodeWord[];
+    comments: Comment[];
+};
+export type MotionMode = "G0" | "G1" | "G2" | "G3";
+export type DistanceMode = "G90" | "G91";
+export type PlaneMode = "G17" | "G18" | "G19";
+export type UnitsMode = "G20" | "G21";
+export type ModalState = {
+    motion: MotionMode;
+    distance: DistanceMode;
+    plane: PlaneMode;
+    units: UnitsMode;
+    feedMode: "G93" | "G94";
+    feedRate: number | null;
+    spindleSpeed: number | null;
+    tool: number | null;
+    coolant: "M7" | "M8" | "M9" | null;
+    spindle: "M3" | "M4" | "M5" | null;
+    coordinateSystem: "G54" | "G55" | "G56" | "G57" | "G58" | "G59";
+};
+export type LinearMoveCallback = (args: {
+    modals: ModalState;
+    start: Position;
+    end: Position;
+    transformedStart: Position;
+    transformedEnd: Position;
+}) => void;
+export type ArcMoveCallback = (args: {
+    modals: ModalState;
+    start: Position;
+    end: Position;
+    max: Position;
+    center: Position;
+    plane: PlaneMode;
+    motion: MotionMode;
+    transformedStart: Position;
+    transformedEnd: Position;
+    transformedMax: Position;
+    transformedCenter: Position;
+}) => void;
+export type MovementCallbacks = {
+    onLinearMove?: LinearMoveCallback;
+    onArcMove?: ArcMoveCallback;
+};
+export type VirtualizeResult = {
+    parsed: ParsedLine;
+    modals: ModalState;
+    start: Position;
+    end: Position;
+    movement: "none" | "linear" | "arc";
+    arcMax?: Position;
+};

package/dist/types/viewer/GCodeViewer.d.ts

@@ -0,0 +1,89 @@
+import { GCodeViewerCameraView, GCodeViewerBounds, GCodeViewerCallbacks, GCodeViewerCreateArgs, GCodeViewerHandle, GCodeViewerBitPosition, GCodeViewerOptions } from "./types";
+export declare class GCodeViewer implements GCodeViewerHandle {
+    readonly id: string;
+    private readonly container;
+    private readonly canvas;
+    private readonly renderer;
+    private readonly scene;
+    private readonly toolpathRoot;
+    private readonly camera;
+    private readonly controls;
+    private viewCube;
+    private readonly viewCubeCorrection;
+    private callbacks;
+    private options;
+    private resizeObserver;
+    private onWindowResize;
+    private animationFrameId;
+    private gridGroup;
+    private axesGroup;
+    private gridLabelsGroup;
+    private boundingBoxGroup;
+    private bitMarker;
+    private preLaserBitType;
+    private toolpathStreams;
+    private toolpathCutBucketCount;
+    private toolpathRotationA;
+    private sim3dHandle;
+    private currentLines;
+    private linePositions;
+    private renderSequence;
+    private currentBounds;
+    private cameraFocusTransition;
+    constructor(args: GCodeViewerCreateArgs);
+    setBitPosition(position: GCodeViewerBitPosition, options?: {
+        immediate?: boolean;
+    }): void;
+    setBitVisible(visible: boolean): void;
+    setToolpathRotationA(aDegrees: number): void;
+    setCallbacks(callbacks: GCodeViewerCallbacks): void;
+    hideUntilLine(lineIndex: number, mode?: "hide" | "grey"): void;
+    seekToLine(lineIndex: number, mode?: "hide" | "grey"): void;
+    showAll(): void;
+    resetColors(): void;
+    snapCameraToView(view: GCodeViewerCameraView, options?: {
+        durationMs?: number;
+        distance?: number;
+    }): void;
+    private startSnapToView;
+    loadFromUrl(url: string, args?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    loadFromFile(file: File): Promise<void>;
+    loadFromText(gcode: string): Promise<void>;
+    loadFromLines(lines: readonly string[]): Promise<void>;
+    unload(): void;
+    setOptions(next: Partial<GCodeViewerOptions>): void;
+    getOptions(): Readonly<GCodeViewerOptions>;
+    resize(): void;
+    focusToModel(): void;
+    resetCamera(): void;
+    getBounds(): GCodeViewerBounds | null;
+    dispose(): void;
+    private emitProgress;
+    private emitBoundsChanged;
+    private startAnimationLoop;
+    private ensureBitMarker;
+    private worldSizes;
+    private renderGridAndAxes;
+    private refreshGridLabels;
+    private refreshBoundingBox;
+    private setBitMarker;
+    private setGridGroup;
+    private setAxesGroup;
+    private setGridLabelsGroup;
+    private setBoundingBoxGroup;
+    private setGeometryEmpty;
+    private setToolpathGeometry;
+    private refreshToolpathColors;
+    private refreshToolpathOpacities;
+    private cutBucketOpacity;
+    private buildLinePositions;
+    private renderScene;
+    private setSim3dHandle;
+    private setToolpathStreamsVisible;
+    private buildAndApplySim3d;
+    private startCameraFocus;
+    private updateCameraFocusTransition;
+    private updateViewCubeRotation;
+}

package/dist/types/viewer/ViewCube.d.ts

@@ -0,0 +1,16 @@
+import type { GCodeViewerCameraView } from "./types";
+type ViewCubeArgs = {
+    container: HTMLElement;
+    onSelectView: (view: GCodeViewerCameraView) => void;
+};
+export declare class ViewCube {
+    private readonly root;
+    private readonly cube;
+    private readonly onSelectView;
+    private readonly faceButtons;
+    constructor(args: ViewCubeArgs);
+    setActiveFace(view: "front" | "back" | "left" | "right" | "top" | "bottom"): void;
+    setRotationMatrix3d(elements: readonly number[]): void;
+    dispose(): void;
+}
+export {};

package/dist/types/viewer/bbox/boundingBox.d.ts

@@ -0,0 +1,4 @@
+import * as THREE from "three";
+import type { GCodeViewerOptions } from "../types";
+export declare function createBoundingBoxGroup(bounds: THREE.Box3, options: GCodeViewerOptions): THREE.Group;
+export declare function disposeBoundingBoxGroup(group: THREE.Object3D): void;

package/dist/types/viewer/bit/bit.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from "three";
+import type { GCodeViewerBitPosition, GCodeViewerOptions } from "../types";
+export type BitMarker = {
+    object: THREE.Object3D;
+    update(nowMs: number): void;
+    dispose(): void;
+    setVisible(visible: boolean): void;
+    setOptions(options: GCodeViewerOptions): void;
+    setTarget(position: GCodeViewerBitPosition, options?: {
+        immediate?: boolean;
+    }): void;
+};
+export declare function createBitMarker(initialOptions: GCodeViewerOptions): BitMarker;