three-slicer-viewer 0.2.5

package/src/settings/toggle_eval.js

@@ -0,0 +1,90 @@
+// Stage 25 S5.1: partial translation of toggle-rules — upstream C++ toggle_options conditions (enable_if) -> JS.
+//  Scope: among the rules touching keys the viewer handles, only those "fully" translatable with the hardcoded locals below.
+//  Untranslatable ones (unknown locals, enum comparisons, …) fail open (stay enabled) — avoids wrongly disabling (honest partial implementation).
+//  Translating all 907 keys / 231 rules is out of scope (noted in the README). Reference: toggle_print_fff_options.locals in toggle-rules.json.
+import { leanSchema } from './data.js'
+
+/**
+ * The evaluator bound to a rule set and a schema. This package ships NO rules: toggle-rules.json is extracted from
+ * upstream's toggle_options logic and stays with the AGPL package, which binds it and re-exports the result as
+ * `three-slicer/toggle`. Bound to nothing, disabledKeys() disables nothing — every field stays enabled.
+ */
+export function makeToggle(toggles = {}, schema = leanSchema) {
+// Settings value accessor (settings map first, schema default otherwise). Percentages ("15%") become numbers.
+function makeCfg(settings) {
+  const val = k => {
+    let v = settings ? settings[k] : undefined
+    if (v === undefined || v === '') { const d = schema[k]?.default; v = Array.isArray(d) ? d[0] : d }
+    return v
+  }
+  const num = k => { const v = val(k); const n = parseFloat(v); return Number.isFinite(n) ? n : 0 }
+  return {
+    bool: k => { const v = val(k); return v === true || v === 1 || v === '1' || v === 'true' },
+    int: k => Math.trunc(num(k)),
+    float: k => num(k),
+    has: k => k in schema,
+  }
+}
+
+// Upstream locals translated inline (viewer-related conditions only). Each value is a boolean.
+function makeLocals(cfg) {
+  const have_raft = cfg.int('raft_layers') > 0
+  const has_spiral_vase = cfg.bool('spiral_mode')
+  const has_top_shell = cfg.int('top_shell_layers') > 0 || (has_spiral_vase && cfg.int('bottom_shell_layers') > 1)
+  const has_bottom_shell = cfg.int('bottom_shell_layers') > 0
+  return {
+    have_raft,
+    have_perimeters: cfg.int('wall_loops') > 0,
+    have_infill: cfg.float('sparse_infill_density') > 0,
+    has_spiral_vase,
+    has_top_shell,
+    has_bottom_shell,
+    has_solid_infill: has_top_shell || has_bottom_shell,
+    have_skirt: cfg.int('skirt_loops') > 0,
+    have_support_material: cfg.bool('enable_support') || have_raft,
+    have_support_interface: cfg.int('support_interface_top_layers') > 0 || cfg.int('support_interface_bottom_layers') > 0,
+    have_prime_tower: cfg.bool('enable_prime_tower'),
+  }
+}
+
+// Map of keys disabled under the current settings { key: condition }. Only rules that are unambiguously false.
+function disabledKeys(cfg) {
+  const locals = makeLocals(cfg)
+  const groups = ['toggle_print_fff_options', 'toggle_filament_options', 'toggle_printer_options',
+    'TabFilament::toggle_options', 'TabPrinter::toggle_options']
+  const out = {}
+  for (const gname of groups) {
+    const g = toggles[gname]
+    if (!g || !Array.isArray(g.rules)) continue
+    for (const rule of g.rules) {
+      if (!rule.enable_if || !Array.isArray(rule.fields)) continue
+      const en = evalEnableIf(rule.enable_if, locals, cfg)
+      if (en === false) for (const k of rule.fields) if (!(k in out)) out[k] = rule.enable_if
+    }
+  }
+  return out
+}
+return { makeCfg, disabledKeys, evalEnableIf }
+}
+
+// Evaluates enable_if (up to the first comma) to a boolean. Returns null (= stays enabled) when not fully translatable.
+export function evalEnableIf(expr, locals, cfg) {
+  let s = String(expr).split(',')[0].trim()
+  if (!s) return null
+  // Direct config access pattern -> value substitution
+  s = s.replace(/config->opt_bool\(\s*"([^"]+)"\s*\)/g, (_, k) => cfg.bool(k) ? 'true' : 'false')
+  s = s.replace(/config->opt_int\(\s*"([^"]+)"\s*\)/g, (_, k) => String(cfg.int(k)))
+  s = s.replace(/config->opt_float\(\s*"([^"]+)"\s*\)/g, (_, k) => String(cfg.float(k)))
+  // Substitute known locals (longest name first — prevents partial matches)
+  for (const name of Object.keys(locals).sort((a, b) => b.length - a.length))
+    s = s.replace(new RegExp('\\b' + name + '\\b', 'g'), locals[name] ? 'true' : 'false')
+  // Check the remaining string is a safe boolean expression (only true/false/numbers/operators/parens) — otherwise unknown -> null
+  const stripped = s.replace(/\btrue\b|\bfalse\b/g, '1')
+  if (!/^[\s()!<>=&|0-9.]*$/.test(stripped)) return null
+  try { return !!Function('"use strict";return (' + s + ')')() } catch { return null }
+}
+
+// The unbound default: nothing disables. `three-slicer/toggle` is the bound one.
+const unbound = makeToggle({}, leanSchema)
+export const makeCfg = unbound.makeCfg
+export const disabledKeys = unbound.disabledKeys

package/types/components.d.ts

@@ -0,0 +1,39 @@
+// three-slicer/components
+import type * as React from 'react'
+import type { SlicerSettings } from './settings-keys.d.ts'
+
+export interface SettingsPanelProps {
+  /**
+   * The config schema to render from. Defaults to this package's reduced schema — types, defaults, enum values,
+   * layout flags and units, but no label or tooltip, so a field is labelled by its key. `three-slicer/components`
+   * passes the full schema; a host may pass its own (a translation, its own vocabulary).
+   */
+  schema?: Record<string, Record<string, unknown>>
+  /** The tab/page/group tree. Defaults to one flat page per builder over this package's ui-tree keys. */
+  uiTree?: Record<string, Array<{ page: string; groups: Array<{ group: string; options: string[] }> }>>
+  /** The enable/disable evaluator. Defaults to the unbound one, which disables nothing. */
+  toggle?: { makeCfg(settings: unknown): unknown; disabledKeys(cfg: unknown): Record<string, string> }
+  /** Sparse map — only edited keys. Missing keys fall back to the config-schema default. */
+  settings: SlicerSettings
+  /** React setState shape. The only channel through which state leaves the component. */
+  setSettings: React.Dispatch<React.SetStateAction<SlicerSettings>>
+  /** Label click — for deep links / detail views. Omit for a plain label (zero router coupling). */
+  onOptionOpen?: (optKey: string) => void
+  /** When embedding inside another panel */
+  embedded?: boolean
+  /** Replace schema-driven widgets per key (e.g. `{ printable_area: MyBedEditor }`) */
+  customWidgets?: Record<string, React.ComponentType<any>>
+  /**
+   * Pins the panel to one builder (optionally one page) and drops the search/group/page/mode chrome, so the form
+   * can be folded into another card. This is how `<Viewport/>`'s `motionPanel` slot is meant to be filled:
+   *
+   * ```jsx
+   * <SettingsPanel settings={settings} setSettings={setSettings} embedded
+   *                only={{ builder: 'TabPrinter::build_kinematics_page' }} />
+   * ```
+   */
+  only?: { builder: string; page?: string }
+}
+
+declare const SettingsPanel: React.FC<SettingsPanelProps>
+export default SettingsPanel

package/types/data.d.ts

@@ -0,0 +1,3 @@
+export const leanSchema: Record<string, { type: string; default?: unknown; enum_values?: string[]; min?: number; max?: number; default_type?: string; defined_in?: string; line?: number }>
+export const uiTreeKeys: Record<string, string[]>
+export const presetKeys: Record<string, string[]>

package/types/gcode.d.ts

@@ -0,0 +1,29 @@
+// three-slicer/viewer/gcode — G-code text -> kernel-shaped layer stream (renderable without slicing).
+// Feed the returned layers straight into buildSegmentData (three-slicer/viewer/toolpath).
+
+export interface GcodeLayer {
+  z: number
+  /** Stride 8: [x0,y0,z0,enc, x1,y1,z1,enc] per segment, enc = role + tool*16 (role 0 = travel). */
+  paths: Float32Array
+  /** One entry per segment; 0 means "use the default line width". */
+  widths: Float32Array
+}
+
+export interface ParseGcodeResult {
+  layers: GcodeLayer[]
+  stats: { layers: number; path_segments: number; travel_segments: number; tools: number[] }
+}
+
+export interface ParseGcodeOptions {
+  /** Used to derive bead width from E when the file has no ;WIDTH: comments. Default 1.75. */
+  filamentDiameter?: number
+  /** Bead-height fallback when a layer's height cannot be inferred from z steps. Default 0.2. */
+  defaultLayerHeight?: number
+}
+
+/**
+ * Parses G0/G1/G2/G3 (I/J arcs), G90/G91, M82/M83, G92, T<n>, and the layer/role comment conventions of
+ * OrcaSlicer/PrusaSlicer (;TYPE: ;WIDTH: ;LAYER_CHANGE ;Z:), Cura (;TYPE: ;LAYER:) and this kernel's own output.
+ * Recovery is lossy where G-code carries no data: unknown roles become wall(1), widths are derived from E.
+ */
+export function parseGcode(text: string, opts?: ParseGcodeOptions): ParseGcodeResult

package/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from './viewer'
+export { default } from './viewer'
+export * from './toolpath'
+export const log: { info(...a: unknown[]): void; warn(...a: unknown[]): void; error(...a: unknown[]): void }
+export function effectiveSettings(settings: Record<string, unknown>, plateSettings: Record<string, unknown>, plate: number): Record<string, unknown>
+export function plateTechnology(settings: Record<string, unknown>, plateSettings: Record<string, unknown>, plate: number): 'FFF' | 'SLA'
+export function statsFromKernel(stats: Record<string, unknown>, throughput?: unknown): Record<string, unknown>

package/types/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