three-slicer 0.1.0 → 0.1.2

package/types/settings.d.ts

@@ -0,0 +1,19 @@
+// three-slicer/settings
+import type { SlicerSettings, SettingKey, Point } from './settings-keys.d.ts'
+export type { SlicerSettings, SettingKey, Point }
+
+/** The config-schema default value (undefined for unknown keys) */
+export function schemaDefault(key: string): unknown
+
+/** Settings map first, schema default otherwise. Vector types are returned as-is. */
+export function settingRaw(settings: SlicerSettings | null | undefined, key: string): unknown
+
+/** Normalizes settingRaw to a scalar — [0] for vectors. */
+export function settingScalar(settings: SlicerSettings | null | undefined, key: string): unknown
+
+/**
+ * Settings map -> kernel slice params. Derived from schema keys; missing keys are filled with internal defaults.
+ * ponytail: 53 returned keys, so Record instead of listing each — kernel params are passed straight to slice(),
+ * not an API consumers read field by field. Expand it when field access is actually needed.
+ */
+export function deriveKernelParams(settings: SlicerSettings | null | undefined): Record<string, unknown>

package/types/toggle.d.ts

@@ -0,0 +1,22 @@
+// three-slicer/toggle — partial evaluation of the enable_if expressions in toggle-rules.json.
+import type { SlicerSettings } from './settings-keys.d.ts'
+
+/** Settings accessor — schema default when a value is missing, [0] for vector types. */
+export interface ToggleCfg {
+  bool(key: string): boolean
+  int(key: string): number
+  float(key: string): number
+  /** Whether the key exists in config-schema */
+  has(key: string): boolean
+}
+
+export function makeCfg(settings: SlicerSettings | null | undefined): ToggleCfg
+
+/**
+ * Evaluates a single enable_if expression. Untranslatable expressions return `null` (= fail-open, stays enabled) —
+ * make sure to treat that as distinct from `false`.
+ */
+export function evalEnableIf(expr: string, locals: Record<string, unknown>, cfg: ToggleCfg): boolean | null
+
+/** Keys that must be disabled under the current settings -> the enable_if expression that disabled them. Only rules that are unambiguously false. */
+export function disabledKeys(cfg: ToggleCfg): Record<string, string>

package/types/viewer-loaders.d.ts

@@ -0,0 +1,33 @@
+// three-slicer/viewer/loaders — pure loaders, independent of the kernel.
+
+/** The 5 built-ins plus any extension registered via `registerLoader()`, which pushes onto this array. */
+export const SUPPORTED_EXT: string[]
+
+/** Lowercased extension. Empty string when there is no dot. */
+export function fileExt(name: string): string
+
+export interface LoadedObject {
+  name: string
+  /** Triangle vertex coordinates (N*9, model z-up) */
+  modelPos: Float32Array
+}
+
+/** A single file may contain several objects (3mf/amf/step) -> always an array. */
+export function loadModel(name: string, buffer: ArrayBuffer): Promise<LoadedObject[]>
+
+/**
+ * Registers an extra format. Formats needing heavy dependencies (STEP=OCCT WASM, etc.) are not bundled here,
+ * so the app wires them up itself. The `<Viewport/>` file dialog and drag-and-drop filters pick them up automatically.
+ *
+ * ```js
+ * import { registerLoader } from 'three-slicer/viewer/loaders'
+ * registerLoader('step,stp', async (buffer, name) => [{ name, modelPos }])
+ * ```
+ */
+export function registerLoader(
+  exts: string | string[],
+  fn: (buffer: ArrayBuffer, name: string) => LoadedObject[] | Promise<LoadedObject[]>,
+): void
+
+/** Connected-component split. Returns `null` when there is only one component (cannot split) — not an empty array. */
+export function splitConnectedComponents(localPos: Float32Array): Float32Array[] | null

package/types/viewer-toolpath.d.ts

@@ -0,0 +1,105 @@
+// three-slicer/viewer/toolpath — kernel layers -> GPU-instanced toolpath.
+// Does not import three: makeToolpath takes the THREE namespace as an argument (guaranteeing a single instance).
+
+/** The 24 triangle indices of the 8-vertex diamond cross-section (from SegmentTemplate.cpp:18) */
+export const VERTEX_DATA: number[]
+
+/** Toolpath type -> color. 0=travel, 1=wall … 11=prime */
+export const TYPE_COLOR: Record<number, number[]>
+export const TYPE_LABEL: Record<number, string>
+
+/** Blue-to-red 11-color heatmap (libvgcode ColorRange.hpp:14) */
+export const DEFAULT_RANGES_COLORS: number[][]
+
+export interface ViewTypeDef {
+  key: 'feature' | 'speed' | 'height' | 'width' | 'fan' | 'temp'
+  label: string
+  /** Whether values are continuous (heatmap). False means a fixed color. */
+  cont: boolean
+  unit: string
+}
+export const VIEW_TYPES: ViewTypeDef[]
+
+/** Per-vertex extra data */
+export interface SegmentMeta {
+  vType: Uint8Array
+  vWidth: Float32Array
+  vHeight: Float32Array
+  vLayer: Int32Array
+}
+
+export interface SegmentData {
+  position: Float32Array
+  hwa: Float32Array
+  segIndex: Uint32Array
+  nV: number
+  nSeg: number
+  layerSegPrefix: Uint32Array
+  travelPos: Float32Array
+  travelPrefix: Uint32Array
+  nTrav: number
+  layerCount: number
+  maxAbs: number
+  hasNaN: boolean
+  meta: SegmentMeta
+  /** Total extruded length per type (index = toolpath type, length 16) */
+  typeLengths: Float64Array
+  /** Null when there is not a single vertex */
+  bbox: { min: [number, number, number]; max: [number, number, number] } | null
+}
+
+/** Kernel layers[{z, paths(stride8), widths[]}] -> GPU stream. */
+export function buildSegmentData(layers: unknown[], defaultLineWidth: number): SegmentData
+
+/** Length share per type (%), descending by pct. The kernel does not expose time per role, so length is used as an approximation. */
+export function roleRatios(typeLengths: Float64Array | number[]): Array<{
+  type: number
+  label: string
+  pct: number
+  color: number[]
+}>
+
+/**
+ * speed/fan/temp are absent from the kernel toolpath and derived from settings — these are the values used for that.
+ */
+export interface ColorContext {
+  speedByType?: Record<number, number>
+  firstLayerSpeed?: number
+  fanByType?: Record<number, number>
+  fanFirstLayers?: number
+  tempNormal?: number
+  tempFirst?: number
+  closeFanLayers?: number
+}
+
+export interface ColorResult {
+  /** Per-vertex RGBA (nV*4). The color is packed into `.r`. */
+  color: Float32Array
+  min: number
+  max: number
+  viewType: ViewTypeDef['key']
+  label: string
+  unit: string
+  /** False means fixed colors — min/max are 0 and no legend should be drawn. */
+  cont: boolean
+}
+
+export function computeColors(data: SegmentData, viewType: ViewTypeDef['key'], ctx: ColorContext): ColorResult
+
+export interface ToolpathHandle {
+  /** THREE.Mesh — typed by the THREE namespace passed in */
+  mesh: any
+  /** THREE.LineSegments (travel) */
+  travLines: any
+  setLayerRange(lo: number, hi: number): void
+  /** Backwards compatible — same as setLayerRange(0, n-1). */
+  setVisibleLayers(n: number): void
+  setTravelVisible(visible: boolean): void
+  setColors(color: Float32Array): void
+  dispose(): void
+  nSeg: number
+  layerCount: number
+}
+
+/** @param THREE - the `import * as THREE from 'three'` namespace. The consumer's instance is used as-is. */
+export function makeToolpath(THREE: any, data: SegmentData): ToolpathHandle

package/types/viewer.d.ts

@@ -0,0 +1,15 @@
+// three-slicer/viewer
+import type * as React from 'react'
+import type { SlicerSettings } from './settings-keys.d.ts'
+
+export interface ViewportProps {
+  /** Sparse settings map. Defaults to `{}`. */
+  settings?: SlicerSettings
+  /** React setState shape. Defaults to a no-op. */
+  setSettings?: React.Dispatch<React.SetStateAction<SlicerSettings>>
+  /** Left process-panel slot — usually `<SettingsPanel embedded/>`. Defaults to null. */
+  processPanel?: React.ReactNode
+}
+
+declare const Viewport: React.FC<ViewportProps>
+export default Viewport

package/types/wasm.d.ts

@@ -0,0 +1,5 @@
+// three-slicer/wasm, three-slicer/wasm-mt — emscripten glue (generated, 3.5MB+).
+// ponytail: no precise types here. The glue changes on every rebuild, and the public API is
+//   createSlicer() from three-slicer. Anyone using this directly already knows the kernel internals.
+declare const factory: (opts?: Record<string, unknown>) => Promise<any>
+export default factory

package/types/worker.d.ts

@@ -0,0 +1,3 @@
+// three-slicer/worker — the slice worker script. Not a module you import, but the target of
+// `new Worker(new URL('three-slicer/worker', import.meta.url), { type: 'module' })`.
+export {}

package/viewer/README.md

@@ -1,6 +1,6 @@
 # three-slicer/viewer
 
-3D slicer viewer as a React component: three.js viewport (orbit/transform gizmos), model import (STL/OBJ/3MF/AMF/PLY, multi-object, drag & drop), Web Worker slicing via `three-slicer`, support painting, multi-plate, and a GPU-instanced volumetric toolpath preview ported from OrcaSlicer's libvgcode (millions of segments in a single draw path, per-feature colors, layer range slider, G-code export).
+3D slicer viewer as a React component: three.js viewport (orbit/transform gizmos), model import (STL/OBJ/3MF/AMF/PLY + pluggable formats such as STEP, multi-object, drag & drop), Web Worker slicing via `three-slicer`, support painting, multi-plate, and a GPU-instanced volumetric toolpath preview ported from OrcaSlicer's libvgcode (millions of segments in a single draw path, per-feature colors, layer range slider, G-code export).
 
 ```bash
 npm i three-slicer/viewer react react-dom three@^0.160.0