@duet3d/gcodeviewer 3.7.0-alpha.1

package/dist/lineshader.d.ts

@@ -0,0 +1,30 @@
+import { ShaderMaterial } from '@babylonjs/core/Materials/shaderMaterial';
+import { Scene } from '@babylonjs/core/scene';
+import { UniformBuffer } from '@babylonjs/core/Materials/uniformBuffer';
+export default class LineShaderMaterial {
+    scene: Scene;
+    material: ShaderMaterial;
+    toolBuffer: UniformBuffer;
+    renderMode: number;
+    isLineMesh: boolean;
+    static readonly vertexShader = "\n   #define THIN_INSTANCES\n   precision highp float;\n   \n\n   attribute vec3 position;\n   attribute vec3 normal;\n\n   attribute float filePosition;\n   attribute vec3 pickColor;\n   attribute float tool;\n   attribute float feedRate;\n   attribute float filePositionEnd;\n   attribute float isPerimeter;\n   attribute vec3 baseColor;\n\n   uniform mat4 viewProjection;\n   uniform mat4 worldView;\n   uniform mat4 view;\n\n   uniform float animationLength;\n   uniform float currentPosition;\n   uniform vec4 toolColors[20];\n   uniform vec3 focusedPickColor;\n   uniform float maxFeedRate;\n   uniform float minFeedRate;\n   uniform bool progressMode;\n   uniform vec4 progressColor;\n   uniform bool showSupports;\n   uniform bool showTravels;\n   uniform float utime;\n   uniform int renderMode;\n\n   uniform bool alphaMode;\n   uniform bool lineMesh;\n\n   varying vec3 eye_normal;\n   flat out vec3 vDiffColor;\n   flat out float fIsPerimeter;\n   flat out float bDiscard;\n   flat out float fShow;\n   flat out float focused;\n\n #include<instancesDeclaration>\n\n   void main()\n   {\n      #include<instancesVertex>\n  \n      fIsPerimeter = isPerimeter;\n\n      switch(renderMode){\n            case 0: \n               vDiffColor = baseColor.rgb; \n            break; // use default diffuse color;\n            case 1:\n               if(tool < 255.0)\n               {\n                  vDiffColor = toolColors[int(tool)].rgb;\n               }\n               else\n               {\n                  vDiffColor = vec3(1,0,0); //Travel Color Make Configurable at some point\n               }\n            break;\n            case 2:\n               float m = (feedRate - minFeedRate) / (maxFeedRate - minFeedRate);\n               vDiffColor = mix(vec3(0,0,1), vec3(1,0,0), m); \n               break;\n            case 5:\n               vDiffColor = pickColor.rgb;\n               break;\n         }\n\n         fShow = currentPosition - filePosition;\n         focused = 0.;\n\n         if(focusedPickColor == pickColor && !(currentPosition >= filePosition && currentPosition <= filePositionEnd)) \n         {\n            vDiffColor = vec3(1, 1, 1) - vDiffColor.rgb;\n            focused = 1.;\n         }\n         else if (tool >= 254.0)  //Travel\n         {\n            if(fShow >= 0.0 && fShow < animationLength / 8.0)\n            {\n                  vDiffColor = mix(vec3(1.0, 0.0, 0.0), vec3(0.5,0.0,0.0), fShow / animationLength / 2.0);\n            }\n            else if (showTravels && fShow >= 0.0)\n            {\n               vDiffColor = vec3(0.3, 0.5, 0.8); // persistent travel lines\n            }\n            else\n            {\n               bDiscard = 1.;\n            }\n         }\n         else //Extrusion\n         {\n            if (fShow >= 0.0  && fShow < animationLength) \n            { \n               if(currentPosition < filePositionEnd){\n                  // float animation = smoothstep(0.0, 1.0, fract(utime / 50.0));\n                  float animation = sin(2.0 * 3.1415 * utime / 1000.0) * 0.5 + 0.5;\n                  vDiffColor = mix(vec3(0, 0, 1), vec3(0,1,0), animation);\n               }\n               else \n               {\n                  vDiffColor = mix(vec3(1, 1, 1) - vDiffColor.rgb, vDiffColor.rgb, fShow / animationLength);\n               }\n            }\n            else if (fShow >= 0.0 && progressMode) \n            {\n               vDiffColor = progressColor.rgb;\n            }\n            else if(fShow < 0.0 && !alphaMode && !progressMode)\n            {\n               bDiscard = 1.;\n            }\n         }\n\n         //Final Results\n         gl_Position = viewProjection * finalWorld *  vec4(position, 1.0);\n         mat4 n =transpose(inverse(worldView * finalWorld));\n         eye_normal = (n * (vec4(normal , 1.0) * vec4(position,1.)) ).xyz;\n   }";
+    static readonly fragmentShader = "\n   precision highp float;\n   #include<helperFunctions>\n\n   const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929);\n   const vec3 LIGHT_FRONT_DIR = vec3(0.0, 0.0, 1.0);\n   \n   // x = ambient, y = top diffuse, z = front diffuse, w = global\n   const vec4 light_intensity = vec4(0.45, 0.7, 0.75, 0.75);\n   varying vec3 eye_normal;\n\n   uniform bool lineMesh;\n   uniform bool alphaMode;\n   uniform bool progressMode;\n   uniform float alphaValue;\n\n   flat in vec3 vDiffColor;\n   flat in float fIsPerimeter;\n   flat in float bDiscard;\n   flat in float fShow;\n   flat in float focused;\n   const vec3 lowerBound = vec3(0.3,0.3,0.3);\n\n   void main(){\n\n         if( bDiscard > 0.0) {\n            discard;\n         }\n\n         vec4 diffuseColor = vec4(vDiffColor, 1);\n\n         if(focused > 0.) \n         {\n            diffuseColor.a = 1.0;\n         }\n         else\n         {\n            diffuseColor.a = fShow >= 0.0 || !alphaMode ? 0.99 : alphaValue;\n         }\n         \n        if(lineMesh) {\n            if(fIsPerimeter < 1.0)\n            {\n               if(all(lessThan(diffuseColor.rgb,lowerBound.rgb))) {\n                  diffuseColor = vec4(diffuseColor.rgb + lowerBound, diffuseColor.a);\n               }\n               else {\n                  diffuseColor = vec4(diffuseColor.rgb - lowerBound, diffuseColor.a);\n               }\n            }\n            else\n            {\n            diffuseColor = vec4(diffuseColor.rgb, diffuseColor.a);\n            }\n            gl_FragColor = diffuseColor;\n         }\n         else\n         {\n            vec3 normal = normalize(eye_normal);\n            float NdotL = abs(dot(normal, LIGHT_TOP_DIR));\n            float intensity = light_intensity.x + NdotL * light_intensity.y;\n            NdotL = abs(dot(normal, LIGHT_FRONT_DIR));\n            intensity += NdotL * light_intensity.z;\n            gl_FragColor = vec4(diffuseColor.rgb * light_intensity.w * intensity, diffuseColor.a);\n         }\n   }";
+    constructor(scene: Scene);
+    buildMaterial(): void;
+    updateRenderMode(mode: number): void;
+    updateCurrentFilePosition(position: number): void;
+    getMaterial(): ShaderMaterial;
+    updateToolColors(toolColors: number[]): void;
+    setPickColor(color: number[]): void;
+    setMaxFeedRate(feedRate: number): void;
+    setMinFeedRate(feedRate: number): void;
+    setAlphaMode(mode: boolean): void;
+    setAlphaValue(value: number): void;
+    setProgressMode(mode: boolean): void;
+    setShowTravels(show: boolean): void;
+    setProgressColor(color: number[]): void;
+    setLineMesh(mode: boolean): void;
+    showSupports(show: boolean): void;
+    refreshMaterialState(): void;
+    dispose(): void;
+}

package/dist/modelmaterial.d.ts

@@ -0,0 +1,24 @@
+import { Scene } from '@babylonjs/core/scene';
+import { CustomMaterial } from '@babylonjs/materials/custom/customMaterial';
+import { UniformBuffer } from '@babylonjs/core/Materials/uniformBuffer';
+export default class ModelMaterial {
+    scene: Scene;
+    material: CustomMaterial;
+    toolBuffer: UniformBuffer;
+    renderMode: number;
+    constructor(scene: Scene);
+    buildMaterial(): void;
+    updateRenderMode(mode: number): void;
+    updateCurrentFilePosition(position: number): void;
+    getMaterial(): CustomMaterial;
+    updateToolColors(toolColors: number[]): void;
+    setPickColor(color: number[]): void;
+    setMaxFeedRate(feedRate: number): void;
+    setMinFeedRate(feedRate: number): void;
+    setAlphaMode(mode: boolean): void;
+    setProgressMode(mode: boolean): void;
+    setProgressColor(color: number[]): void;
+    setLineMesh(mode: boolean): void;
+    showSupports(show: boolean): void;
+    dispose(): void;
+}

package/dist/processor.d.ts

@@ -0,0 +1,96 @@
+import { Base } from './GCodeLines';
+import { default as ProcessorProperties } from './processorproperties';
+import { Scene } from '@babylonjs/core/scene';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { default as GPUPicker } from './gpupicker';
+import { default as LineShaderMaterial } from './lineshader';
+import { default as Nozzle } from './Renderables/nozzle';
+export default class Processor {
+    gCodeLines: Base[];
+    processorProperties: ProcessorProperties;
+    scene: Scene;
+    meshes: Mesh[];
+    breakPoint: number;
+    gpuPicker: GPUPicker;
+    worker: Worker;
+    modelMaterial: LineShaderMaterial[];
+    filePosition: number;
+    maxIndex: number;
+    focusedColorId: number;
+    lastMeshMode: number;
+    perimeterOnly: boolean;
+    originalFile: string;
+    nozzle: Nozzle | null;
+    positionTracker: Map<number, {
+        x: number;
+        y: number;
+        z: number;
+        feedRate: number;
+        extruding: boolean;
+    }>;
+    private isPlaying;
+    private playbackTimeout;
+    private sortedPositions;
+    private lastReportedProgress;
+    private lastReportedChunk;
+    private wasmProcessor;
+    private wasmRenderBuffers;
+    private lastProcessingMethod;
+    private processingStats;
+    enableWasmProcessing(): Promise<void>;
+    getProcessingMethod(): string;
+    getProcessingStats(): {
+        method: string;
+        wasmEnabled: boolean;
+        wasmVersion?: string;
+        totalTime?: number;
+        wasmTime?: number;
+        typescriptTime?: number;
+        wasmRenderTime?: number;
+        linesProcessed?: number;
+        movesFound?: number;
+        positionsExtracted?: number;
+        renderSegmentsGenerated?: number;
+    };
+    isWasmEnabled(): boolean;
+    private getWasmVersion;
+    initNozzle(diameter?: number): void;
+    getNozzle(): Nozzle | null;
+    setTools(toolData: {
+        color: string;
+        diameter?: number;
+    }[]): void;
+    cleanup(): void;
+    dispose(): void;
+    loadFile(file: any): Promise<void>;
+    private loadFileStreamed;
+    private loadFileWithWasm;
+    private loadFileStreamedWithPositions;
+    addNewMaterial(): LineShaderMaterial;
+    testRenderScene(): Promise<void>;
+    testRenderSceneProgressive(): Promise<void>;
+    setMeshMode(mode: any): void;
+    testBuildMesh(renderlines: any, segCount: any, alphaIndex: any): Mesh[];
+    getFileSize(): number;
+    getGCodeInRange(filePos: any, count?: number): void;
+    updateFilePosition(position: number, animate?: boolean): void;
+    private updateNozzlePositionInstant;
+    private updateNozzlePositionAnimated;
+    animateNozzleToPosition(targetPosition: number): Promise<void>;
+    updateByLineNumber(lineNumber: number): void;
+    private buildMeshesFromWasmBuffers;
+    private createMeshesFromWasmBuffers;
+    private applyWasmBuffersToMesh;
+    setPerimeterOnly(perimeterOnly: any): Promise<void>;
+    showSupports(show: any): void;
+    startNozzleAnimation(): void;
+    pauseNozzleAnimation(): void;
+    resumeNozzleAnimation(): void;
+    stopNozzleAnimation(): void;
+    private animateToNextPosition;
+    isNozzleAnimationPlaying(): boolean;
+    private getCurrentAnimationIndex;
+    private skipToPosition;
+    private streamLines;
+    private findClosestPositionIndex;
+}

package/dist/processorproperties.d.ts

@@ -0,0 +1,64 @@
+import { Vector3 } from '@babylonjs/core/Maths/math.vector';
+import { default as Tool } from './tools';
+import { Color4 } from '@babylonjs/core/Maths/math.color';
+import { default as SlicerBase } from './GCodeParsers/slicerbase';
+export declare enum ColorMode {
+    Tool = 0,
+    Feature = 1,
+    FeedRate = 2
+}
+export declare enum ArcPlane {
+    XY = "XY",
+    XZ = "XZ",
+    YZ = "YZ"
+}
+export declare enum Units {
+    millimeters = "mm",
+    inches = "in"
+}
+export default class ProcessorProperties {
+    maxHeight: number;
+    minHeight: number;
+    lineCount: number;
+    layerDictionary: [];
+    previousZ: number;
+    filePosition: number;
+    lineNumber: number;
+    tools: Tool[];
+    currentTool: Tool;
+    currentPosition: Vector3;
+    currentFeedRate: number;
+    maxFeedRate: number;
+    minFeedRate: number;
+    progressColor: Color4;
+    progressAnimation: boolean;
+    firstGCodeByte: number;
+    lastGCodeByte: number;
+    hasMixing: boolean;
+    currentWorkplaceIdx: number;
+    workplaceOffsets: Vector3[];
+    absolute: boolean;
+    firmwareRetraction: boolean;
+    units: Units;
+    totalRenderedSegments: number;
+    fixRadius: boolean;
+    arcPlane: ArcPlane;
+    cncMode: boolean;
+    spindleSpeed: number;
+    spindleOn: boolean;
+    bedLevelingActive: boolean;
+    extruderAbsolute: boolean;
+    slicer: SlicerBase;
+    zBelt: boolean;
+    zBeltLength: number;
+    gantryAngle: number;
+    currentZ: number;
+    hyp: number;
+    adj: number;
+    setGantryAngle(angle: number): void;
+    get CurrentFeedRate(): number;
+    set CurrentFeedRate(value: number);
+    get currentWorkplace(): Vector3;
+    buildToolFloat32Array(): any[];
+    constructor();
+}

package/dist/rendershaders.d.ts

@@ -0,0 +1,2 @@
+export declare const vertexShader = "\n// Vertex shader\n#if defined(WEBGL2) || defines(WEBGPU)\nprecision highp sampler2DArray;\n#endif\nprecision highp float;\n\n        // Attributes\n        attribute vec3 position;\n         attribute float filePosition;\n       \n         //Inputs\n         uniform float currentPosition;\n         \n\n        // Uniforms\n        uniform mat4 viewProjection;\n        uniform mat4 finalWorld;\n\n        //outputs\n         varying float vShow;\n\n#include<instancesDeclaration>\n\n\nvoid main(void) {\n   #include<instancesVertex>\n   gl_Position = viewProjection * finalWorld * vec4(position, 1.0);\n   vShow = currentPosition - filePosition;\n}\n";
+export declare const fragmentShader = "\n// Fragment shader\n#if defined(PREPASS)\n#extension GL_EXT_draw_buffers : require\nlayout(location = 0) out highp vec4 glFragData[SCENE_MRT_COUNT];\nhighp vec4 gl_FragColor;\n#endif\n#if defined(WEBGL2) || defines(WEBGPU)\nprecision highp sampler2DArray;\n#endif\nprecision highp float;\n\nuniform mat4 u_World;\nuniform mat4 u_ViewProjection;\nuniform vec4 u_color;\n\nvarying float vShow;\n\n#include<helperFunctions>\n\n\n\nvoid main(void) {\n\ngl_FragColor = u_color;\n#ifdef CONVERTTOLINEAR0\ngl_FragColor = toLinearSpace(gl_FragColor);\n#endif\n#ifdef CONVERTTOGAMMA0\ngl_FragColor = toGammaSpace(gl_FragColor);\n#endif\n#if defined(PREPASS)\ngl_FragData[0] = gl_FragColor;\n#endif\n\n}\n";

package/dist/tools.d.ts

@@ -0,0 +1,9 @@
+import { Color4 } from '@babylonjs/core/Maths/math.color';
+export default class Tool {
+    toolNumber: number;
+    color: Color4;
+    diameter: number;
+    temperature: number;
+    constructor(idx: any, color: any);
+}
+export declare const tools: Tool[];

package/dist/util.d.ts

@@ -0,0 +1,17 @@
+import { Vector3 } from '@babylonjs/core/Maths/math.vector';
+export declare function numToColor(num?: number): number[];
+export declare function colorToNum(color: number[]): number;
+export declare function colorToNumUint8(color: Uint8Array): number;
+export declare function delay(ms: any): Promise<unknown>;
+export declare function doArc(tokens: any, currentPosition: any, relativeMove: any, arcSegLength: any, fixRadius: any, arcPlane: any, offset: any): {
+    position: Vector3;
+    points: any[];
+} | {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    points: any[];
+};
+export declare function binarySearchClosest(arr: any, target: any, field: any): number;

package/dist/viewer-direct.d.ts

@@ -0,0 +1,21 @@
+import { default as Viewer } from './viewer';
+export default class ViewerDirect {
+    viewer: Viewer;
+    mainCanvas: HTMLCanvasElement | null;
+    passThru: any;
+    constructor(canvas: HTMLCanvasElement);
+    init(): void;
+    postMessage(message: any): void;
+    cancel(): void;
+    loadFile(file: any): void;
+    unload(): void;
+    updateFilePosition(filePosition: number): void;
+    getGCodes(position: number, count: number): void;
+    goToLineNumber(lineNumber: number): void;
+    setAlphaMode(mode: boolean): void;
+    setProgressMode(mode: boolean): void;
+    setRenderMode(mode: number): void;
+    setMaxFPS(fps: number): void;
+    setMeshMode(mode: number): void;
+    setPerimeterOnly(perimeterOnly: boolean): void;
+}

package/dist/viewer-proxy.d.ts

@@ -0,0 +1,73 @@
+export default class ViewerProxy {
+    private webWorker;
+    mainCanvas: HTMLCanvasElement | null;
+    constructor(canvas: HTMLCanvasElement);
+    private onmessage;
+    passThru: any;
+    private onerror;
+    init(): void;
+    cancel(): void;
+    loadFile(file: any): void;
+    unload(): void;
+    reset(): void;
+    updateColorTest(): void;
+    updateFilePosition(filePosition: number, animate?: boolean): void;
+    setRenderMode(mode: number): void;
+    getGCodes(position: number, count: number): void;
+    goToLineNumber(lineNumber: number): void;
+    setAlphaMode(mode: boolean): void;
+    setProgressMode(mode: boolean): void;
+    setMeshMode(mode: number): void;
+    setMaxFPS(fps: number): void;
+    setPerimeterOnly(perimeterOnly: boolean): void;
+    toggleNozzle(visible: boolean): void;
+    startNozzleAnimation(): void;
+    pauseNozzleAnimation(): void;
+    resumeNozzleAnimation(): void;
+    stopNozzleAnimation(): void;
+    showViewBox(visible: boolean): void;
+    setCameraDirection(direction: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    resetCamera(): void;
+    frameToPrint(): void;
+    requestPrintBounds(): void;
+    setBackgroundColor(color: string): void;
+    setCameraInertia(enabled: boolean): void;
+    setZClipPlane(top: number, bottom: number): void;
+    setTools(tools: {
+        color: string;
+        diameter?: number;
+    }[]): void;
+    setBuildVolume(volume: {
+        x: {
+            min: number;
+            max: number;
+        };
+        y: {
+            min: number;
+            max: number;
+        };
+        z: {
+            min: number;
+            max: number;
+        };
+    }): void;
+    setBedRenderMode(mode: number): void;
+    setBedColor(color: string): void;
+    setProgressColor(color: string): void;
+    setTransparencyValue(value: number): void;
+    setShowTravels(show: boolean): void;
+    setAnimationSpeed(speed: number): void;
+    setDeltaBed(isDelta: boolean): void;
+    showBed(visible: boolean): void;
+    showAxes(visible: boolean): void;
+    loadObjectBoundaries(objects: any[]): void;
+    showObjectSelection(visible: boolean): void;
+    showObjectLabels(visible: boolean): void;
+    enableWasmProcessing(): Promise<void>;
+    getProcessingStats(): Promise<any>;
+    cloneEvent(event: any): {};
+}

package/dist/viewer.d.ts

@@ -0,0 +1,87 @@
+import { Engine } from '@babylonjs/core/Engines/engine';
+import { Scene } from '@babylonjs/core/scene';
+import { ArcRotateCamera } from '@babylonjs/core/Cameras/arcRotateCamera';
+import { Light } from '@babylonjs/core/Lights/light';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { PointLight } from '@babylonjs/core/Lights/pointLight';
+import { FlyCamera } from '@babylonjs/core/Cameras/flyCamera';
+import { default as Processor } from './processor';
+import { default as ViewBox, ViewBoxDirection } from './Renderables/viewbox';
+import { default as Bed, BuildVolume, RenderBedMode } from './Renderables/bed';
+import { default as Axes } from './Renderables/axes';
+import { default as BuildObjects } from './Renderables/buildobjects';
+export default class Viewer {
+    scene: Scene | undefined;
+    engine: Engine | null;
+    orbitCamera: ArcRotateCamera | null;
+    flyCamera: FlyCamera | null;
+    offscreenCanvas: OffscreenCanvas | HTMLCanvasElement;
+    box: Mesh;
+    boxRotation: number;
+    light: Light;
+    pointLight: PointLight;
+    lastTimeStamp: number;
+    x: number;
+    y: number;
+    z: number;
+    pause: boolean;
+    registeredEventHandlers: Map<string, any>;
+    worker: Worker;
+    processor: Processor;
+    viewBox: ViewBox | null;
+    bed: Bed | null;
+    axes: Axes | null;
+    buildObjects: BuildObjects | null;
+    zTopClipValue: number | null;
+    zBottomClipValue: number | null;
+    offscreen: boolean;
+    lastFrameUpdate: number;
+    renderTimeout: number;
+    maxFrameRate: number;
+    rect: {
+        top: number;
+        left: number;
+        right: number;
+        bottom: number;
+        x: number;
+        y: number;
+        height: number;
+        width: number;
+    };
+    constructor();
+    init_worker(data: any, worker: Worker): void;
+    init_direct(canvas: HTMLCanvasElement, fakeWorker: any): void;
+    setSizes(width: any, height: any): void;
+    initEngine(): Promise<void>;
+    setCameraDirection(direction: ViewBoxDirection): void;
+    resetCamera(): void;
+    private getPrintBoundingBox;
+    frameToPrint(): void;
+    postPrintBounds(): void;
+    registerClipIgnore(mesh: any): void;
+    showViewBox(visible: boolean): void;
+    setBackgroundColor(hexColor: string): void;
+    setCameraInertia(enabled: boolean): void;
+    setZClipPlane(top: number, bottom: number): void;
+    setBuildVolume(volume: BuildVolume): void;
+    setBedRenderMode(mode: RenderBedMode): void;
+    setBedColor(color: string): void;
+    setProgressColor(color: string): void;
+    setTransparencyValue(value: number): void;
+    setShowTravels(show: boolean): void;
+    setAnimationSpeed(speed: number): void;
+    setDeltaBed(isDelta: boolean): void;
+    showBed(visible: boolean): void;
+    showAxes(visible: boolean): void;
+    loadObjectBoundaries(objects: any[]): void;
+    showObjectSelection(visible: boolean): void;
+    showObjectLabels(visible: boolean): void;
+    isArcRotateCameraStopped(camera: any): boolean;
+    loadInstrumentation(): void;
+    loadFile(file: any): Promise<void>;
+    setMaxFPS(fps: any): void;
+    bindHandler(targetName: any, eventName: any, fn: any, opt: any): void;
+    handleEvent(eventType: any, event: any): void;
+    noop(): void;
+    unload(): void;
+}

package/dist/viewer.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/wasmprocessor.d.ts

@@ -0,0 +1,37 @@
+export interface WasmProcessingResult {
+    success: boolean;
+    errorMessage: string;
+    lineCount: number;
+    moveCount: number;
+    processingTimeMs: number;
+}
+export interface WasmPositionData {
+    x: number;
+    y: number;
+    z: number;
+    feedRate: number;
+    extruding: boolean;
+}
+export interface WasmRenderBuffers {
+    segmentCount: number;
+    matrixData: Float32Array;
+    colorData: Float32Array;
+    pickData: Float32Array;
+    filePositionData: Float32Array;
+    fileEndPositionData: Float32Array;
+    toolData: Float32Array;
+    feedRateData: Float32Array;
+    isPerimeterData: Float32Array;
+}
+export declare class WasmProcessor {
+    private processor;
+    private initialized;
+    initialize(): Promise<void>;
+    processFile(content: string, progressCallback?: (progress: number, label: string) => void): Promise<WasmProcessingResult>;
+    getPositionData(filePosition: number): WasmPositionData | undefined;
+    getSortedPositions(): Uint32Array;
+    getPositionCount(): number;
+    findClosestPosition(targetPosition: number): number | undefined;
+    generateRenderBuffers(nozzleSize?: number, padding?: number, progressCallback?: (progress: number, label: string) => void): WasmRenderBuffers;
+    dispose(): void;
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@duet3d/gcodeviewer",
+  "version": "3.7.0-alpha.1",
+  "description": "G-code viewer and processor library with Babylon.js rendering and a Rust/WASM parsing fast path",
+  "main": "./dist/index.cjs.js",
+  "module": "./dist/index.es.js",
+  "types": "./dist/index.d.ts",
+  "files": ["dist"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.es.js",
+      "require": "./dist/index.cjs.js"
+    },
+    "./assets/*": "./dist/assets/*.js"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview",
+    "check": "tsc --noEmit",
+    "build:wasm": "cd WASM_FileProcessor && wasm-pack build --target web --out-dir pkg --release",
+    "build:wasm:node": "cd WASM_FileProcessor && wasm-pack build --target nodejs --out-dir pkg-node --release"
+  },
+  "contributors": ["Juan Rosario", "Christian Hammacher"],
+  "license": "ISC",
+  "devDependencies": {
+    "@babylonjs/core": "^9.15.0",
+    "@babylonjs/materials": "^9.15.0",
+    "@tweenjs/tween.js": "^25.0.0",
+    "typescript": "^6.0.3",
+    "vite": "^8.1.3",
+    "vite-plugin-dts": "^5.0.3"
+  }
+}