@selvajs/visualization 1.0.0-beta.0 → 1.0.0-beta.2

package/dist/parse.d.cts

@@ -1,16 +1,13 @@
-import * as THREE from 'three';
-import { RhinoModule } from 'rhino3dm';
-import { M as MaterialAppearanceOptions } from './types-CdF9R3qA.cjs';
-
-/**
- * Structural, not nominal: satisfies `@selvajs/solve/client`'s `MeshPolicy<THREE.Object3D>`
- * without this package depending on solve.
- */
+import { i as MaterialAppearanceOptions } from "./types-Di80Y609.cjs";
+import * as THREE from "three";
+//#region src/parse/mesh-policy.d.ts
+/** Structurally, not nominally, typed as `@selvajs/solve/client`'s `MeshPolicy<THREE.Object3D>` — avoids a dependency on solve. */
 declare const meshPolicy: {
-    clone(meshes: THREE.Object3D[]): THREE.Object3D[];
-    release(meshes: THREE.Object3D[]): void;
+  clone(meshes: THREE.Object3D[]): THREE.Object3D[];
+  release(meshes: THREE.Object3D[]): void;
 };
-
+//#endregion
+//#region src/parse/webdisplay/response-envelope.d.ts
 /**
  * Declared structurally rather than imported from `@selvajs/compute` — this package converts
  * meshes, it doesn't need a Rhino.Compute client dependency to describe the shape a caller hands
@@ -18,68 +15,75 @@ declare const meshPolicy: {
  * this, so {@link getThreeMeshesFromComputeResponse} keeps accepting one unchanged.
  */
 interface DisplayDataItem {
-    /** Namespaced wire type token, e.g. `Selva.GH.Features.Display.Services.DisplayBatch`. */
-    type: string;
-    data: string;
+  /** Namespaced wire type token, e.g. `Selva.GH.Features.Display.Services.DisplayBatch`. */
+  type: string;
+  data: string;
 }
 interface DisplayResponseValue {
-    InnerTree: {
-        [branchPath: string]: DisplayDataItem[];
-    };
+  InnerTree: {
+    [branchPath: string]: DisplayDataItem[];
+  };
 }
 interface DisplayComputeResponse {
-    values: DisplayResponseValue[];
-    /** Rhino `UnitSystem` name driving unit scaling (see `SCALE_FACTORS`); unrecognized/absent scales 1. */
-    modelunits: string;
+  values: DisplayResponseValue[];
+  /** Rhino `UnitSystem` name driving unit scaling (see `SCALE_FACTORS`); unrecognized/absent scales 1. */
+  modelunits: string;
 }
-
-/** Shared by meshes and items so pick/filter/label code treats them uniformly. No color/material — that's per-kind. */
+//#endregion
+//#region src/parse/display-items/types.d.ts
 interface DisplayIdentity {
-    /** Stable pick key: `${sourceComponentId}:${originalIndex}`. */
-    id: string;
-    /** Distinct from {@link id} — renaming must not change identity. */
-    name: string;
-    layer: string;
-    /** Arbitrary key-value pairs from the GH Metadata input. */
-    metadata?: Record<string, string>;
+  /** Stable pick key: `${sourceComponentId}:${originalIndex}`. Distinct from `name` so renaming doesn't change identity. */
+  id: string;
+  name: string;
+  layer: string;
+  /** Arbitrary key-value pairs from the GH Metadata input. */
+  metadata?: Record<string, string>;
 }
 interface DisplayItemBase extends DisplayIdentity {
-    /** Hex/rgb/named color string, parsed by `parseColor`. Falls back to a viewer default. */
-    color?: string;
-    /** 0–1. Omitted means fully opaque. */
-    opacity?: number;
+  /** Hex/rgb/named color string, parsed by `parseColor`. Falls back to a viewer default. */
+  color?: string;
+  /** 0-1; omitted means fully opaque. */
+  opacity?: number;
 }
 /** Rhino's Z-up frame and `{X,Y,Z}` casing. */
 interface DisplayPosition {
-    X: number;
-    Y: number;
-    Z: number;
+  X: number;
+  Y: number;
+  Z: number;
 }
-/** Rhino-native JSON (`curve.ToNurbsCurve().ToJSON()`), tessellated to a fat `Line2` on decode. */
+/** Rendered as a fat `Line2` straight from `points` — nothing decodes geometry in the browser. */
 interface DisplayCurve extends DisplayItemBase {
-    kind: 'curve';
-    json: string;
-    /** Screen-space CSS px, constant regardless of zoom. Omitted → viewer default. */
-    width?: number;
+  kind: 'curve';
+  /**
+   * Backend-tessellated polyline, flat `[x,y,z, …]` in Rhino's Z-up frame.
+   *
+   * Typed as required even though the plugin still sends a legacy `json` field alongside it: a
+   * payload without `points` came from a Display component too old to render, and parsing throws
+   * rather than treating it as a shape this package supports.
+   */
+  points: number[];
+  /** Screen-space CSS px, constant regardless of zoom. Omitted uses the viewer default. */
+  width?: number;
 }
 interface DisplayPoint extends DisplayItemBase {
-    kind: 'point';
-    position: DisplayPosition;
+  kind: 'point';
+  position: DisplayPosition;
 }
 type DisplayItem = DisplayCurve | DisplayPoint;
-
+//#endregion
+//#region src/parse/webdisplay/types.d.ts
 interface SerializableMaterial {
-    color: string;
-    metalness: number;
-    roughness: number;
-    opacity: number;
-    transparent: boolean;
-    /**
-     * Optional color-map texture reference: http(s) URL, data URI, or plugin asset URL
-     * (`http://localhost:{port}/assets/{hash}`). Omitted entirely (not just empty) when untextured.
-     * When set, the mesh blob also carries per-vertex UVs (FLAG_HAS_UVS) for meshes using it.
-     */
-    map?: string;
+  color: string;
+  metalness: number;
+  roughness: number;
+  opacity: number;
+  transparent: boolean;
+  /**
+   * Optional color-map texture reference: http(s) URL, data URI, or plugin asset URL
+   * (`http://localhost:{port}/assets/{hash}`). Omitted entirely (not just empty) when untextured.
+   * When set, the mesh blob also carries per-vertex UVs (FLAG_HAS_UVS) for meshes using it.
+   */
+  map?: string;
 }
 /**
  * `vertexStart`/`vertexCount` and `indexStart`/`indexCount` are in **element units** of the
@@ -89,24 +93,23 @@ interface SerializableMaterial {
  * vertex components are 2 bytes (int16 quantized) or 4 bytes (`FLAG_FLOAT32`).
  */
 interface MeshMetadata {
-    name: string;
-    /** Layer path for grouping in the scene manager, e.g. 'Structure/Walls'. */
-    layer: string;
-    /** Index in the GH input tree before material grouping; combined with sourceComponentId
-     *  uniquely identifies the GH source geometry. */
-    originalIndex: number;
-    vertexCount: number;
-    /** 3 per triangle. */
-    indexCount: number;
-    vertexStart: number;
-    indexStart: number;
-    /** Arbitrary key-value pairs from the GH Metadata input. */
-    metadata?: Record<string, string>;
+  name: string;
+  /** Layer path for grouping in the scene manager, e.g. 'Structure/Walls'. */
+  layer: string;
+  /** Index in the GH input tree before material grouping; combined with sourceComponentId
+   *  uniquely identifies the GH source geometry. */
+  originalIndex: number;
+  vertexCount: number;
+  /** 3 per triangle. */
+  indexCount: number;
+  vertexStart: number;
+  indexStart: number;
+  /** Arbitrary key-value pairs from the GH Metadata input. */
+  metadata?: Record<string, string>;
 }
 interface MaterialGroup {
-    /** Index into the batch's materials array. */
-    materialId: number;
-    meshes: MeshMetadata[];
+  materialId: number;
+  meshes: MeshMetadata[];
 }
 /**
  * One Display component's payload, ready for Three.js rendering.
@@ -120,59 +123,54 @@ interface MaterialGroup {
  * blob (`items`), not inside it.
  */
 interface DisplayBatch {
-    materials: SerializableMaterial[];
-    groups: MaterialGroup[];
-    compressedData: string;
-    /** InstanceGuid of the WebDisplay GH component that produced this batch; combined with
-     *  MeshMetadata.originalIndex to backtrack any mesh to its GH source. */
-    sourceComponentId?: string;
-    /** Non-mesh display items — see {@link DisplayItem}. Parsed by the separate `display-items`
-     *  path, not the SLVA mesh parser. Omitted when there are none. */
-    items?: DisplayItem[];
+  materials: SerializableMaterial[];
+  groups: MaterialGroup[];
+  compressedData: string;
+  /** InstanceGuid of the WebDisplay GH component that produced this batch; combined with
+   *  MeshMetadata.originalIndex to backtrack any mesh to its GH source. */
+  sourceComponentId?: string;
+  /** Non-mesh display items — see {@link DisplayItem}. Parsed by the separate `display-items`
+   *  path, not the SLVA mesh parser. Omitted when there are none. */
+  items?: DisplayItem[];
 }
 interface MeshBatchParsingOptions {
-    /** Merge meshes with same material into single geometry. Defaults to true. */
-    mergeByMaterial?: boolean;
-    debug?: boolean;
-    /**
-     * Appearance dials applied to every material built from this batch — set once at parse time
-     * (materials are rebuilt per solve). Runtime restyling of an already-built scene lives in the
-     * viewer's `setLook`.
-     */
-    material?: MaterialAppearanceOptions;
+  /** Merge meshes sharing a material into a single geometry. Defaults to true. */
+  mergeByMaterial?: boolean;
+  debug?: boolean;
+  /**
+   * Appearance dials applied to every material built from this batch — set once at parse time
+   * (materials are rebuilt per solve). Runtime restyling of an already-built scene lives in the
+   * viewer's `setLook`.
+   */
+  material?: MaterialAppearanceOptions;
 }
-
 interface MeshExtractionOptions {
-    parsing?: MeshBatchParsingOptions;
-    /** Apply scaling based on model units. Defaults to true. */
-    allowScaling?: boolean;
-    /**
-     * Drop geometry so its lowest point sits on the ground plane. **Defaults to `false`** — content
-     * renders at its true Rhino coordinates, matching the Grasshopper definition. Setting `true`
-     * shifts objects, so anything read back out of the scene (bounds, measured/picked positions) no
-     * longer corresponds to Rhino coordinates.
-     */
-    allowAutoPosition?: boolean;
-    /** Up axis for `allowAutoPosition` grounding. Defaults to `'z'` (Rhino's frame) — only set this
-     *  if the viewer is configured with a non-default `sceneUp`. */
-    groundAxis?: 'x' | 'y' | 'z';
-    /** rhino3dm instance for decoding curve display items — selva-compute doesn't own the WASM
-     *  instance, the host threads it in. Omit to skip curves (points still render). */
-    rhino?: RhinoModule;
-    debug?: boolean;
-}
-
+  parsing?: MeshBatchParsingOptions;
+  /** Scale geometry to model units. Defaults to true. */
+  allowScaling?: boolean;
+  /**
+   * Drop geometry so its lowest point sits on the ground plane. **Defaults to `false`** — content
+   * renders at its true Rhino coordinates, matching the Grasshopper definition. Setting `true`
+   * shifts objects, so anything read back out of the scene (bounds, measured/picked positions) no
+   * longer corresponds to Rhino coordinates.
+   */
+  allowAutoPosition?: boolean;
+  /** Up axis for `allowAutoPosition` grounding. Defaults to `'z'` (Rhino's frame) — only set this
+   *  if the viewer is configured with a non-default `sceneUp`. */
+  groundAxis?: 'x' | 'y' | 'z';
+  debug?: boolean;
+}
+//#endregion
+//#region src/parse/webdisplay/webdisplay-parser.d.ts
 /**
  * Metres per model unit, keyed by Rhino `UnitSystem` name (the `modelunits` string on the compute
- * response). Imperial factors are the exact international definitions (1 in = 0.0254 m,
- * 1 ft = 0.3048 m, 1 mi = 1609.344 m). Units not in this table scale 1 and log a one-time warning
- * — see {@link getScaleFactor}.
+ * response). Imperial factors are the exact international definitions. Units missing from this
+ * table scale by 1 and log a one-time warning — see {@link getScaleFactor}.
  */
 declare const SCALE_FACTORS: Record<string, number>;
 /**
  * Extracts display meshes and items from a Grasshopper WebDisplay compute response: decompresses,
- * scales to meters, and optionally grounds them. Requires the VektorNode Rhino.Compute fork (see
- * root CLAUDE.md).
+ * scales to meters, and optionally grounds them. Requires the VektorNode Rhino.Compute fork.
  *
  * Synchronous internally (large batches block the UI for their duration); `async` only so the
  * shape can stay stable if parsing moves off-thread later.
@@ -180,56 +178,51 @@ declare const SCALE_FACTORS: Record<string, number>;
  * @throws Rethrows unexpected errors after attempting to dispose any created meshes.
  */
 declare function getThreeMeshesFromComputeResponse(data: DisplayComputeResponse, options?: MeshExtractionOptions): Promise<THREE.Object3D[]>;
-
-/** Internal telemetry only (not exposed in public options). */
+//#endregion
+//#region src/parse/webdisplay/batch-parser.d.ts
 interface ParseTelemetry {
-    parseTime?: number;
-    perfStart?: number;
+  parseTime?: number;
+  perfStart?: number;
 }
 /**
  * Parses a DisplayBatch object and creates Three.js meshes from its mesh blob.
  *
  * Synchronous internally — `parseBinaryMeshBatch` does no IO, just typed-array views over the
- * blob. Stays `async` so callers don't have to change shape if parsing moves into a worker later.
+ * blob. Stays `async` so callers don't need to change shape if parsing moves into a worker later.
  *
  * @throws {VisualizationError} On a corrupt/truncated/unsupported mesh blob or malformed group metadata.
  */
-declare function parseMeshBatchObject(batch: DisplayBatch, options?: MeshBatchParsingOptions, 
-/** @internal Timings threaded from an outer entry point; not a caller option. */
+declare function parseMeshBatchObject(batch: DisplayBatch, options?: MeshBatchParsingOptions,
+/** @internal Timings threaded from an outer entry point — not a caller option. */
 telemetry?: ParseTelemetry): Promise<THREE.Mesh[]>;
 /**
  * Parses a raw binary mesh batch blob (SLVA wire format) and creates Three.js meshes.
  *
  * Use this entry point when the blob arrives as a binary WebSocket frame rather than inside a JSON
- * envelope. The blob is self-describing — materials, groups, and `sourceComponentId` come from its
- * embedded metadata header.
+ * envelope — the blob is self-describing, with materials, groups, and `sourceComponentId` coming
+ * from its embedded metadata header.
  *
  * @throws {VisualizationError} On a corrupt/truncated/unsupported mesh blob or malformed group metadata.
  */
 declare function parseMeshBatchBlob(blob: ArrayBuffer | Uint8Array, options?: MeshBatchParsingOptions): Promise<THREE.Mesh[]>;
-
+//#endregion
+//#region src/parse/webdisplay/apply-texture.d.ts
 /**
  * Subscribed to the renderer's own report below, so no host wiring is needed; still exported for a
- * host embedding a foreign renderer that wants to set it directly.
+ * host embedding a foreign renderer that wants to set it directly. Applies to textures loaded from
+ * here on — textures already decoded keep the value they were given.
  */
 declare function setTextureAnisotropy(value: number): void;
-
+//#endregion
+//#region src/parse/display-items/display-items-parser.d.ts
 /**
- * Free every cross-solve GPU cache — cached geometries, textures and edge segments.
+ * Builds THREE objects for the batch's non-mesh items.
  *
- * **You do not normally need this.** These caches register themselves for teardown, so the viewer's
- * `dispose()` already frees them once the last live viewer goes away. It is exported for the cases
- * that sit outside a viewer lifecycle: reclaiming memory under pressure, or a test isolating
- * module-level state.
- *
- * Safe to call repeatedly and with a viewer running — the caches simply repopulate on the next solve.
+ * @throws VisualizationError when a curve predates backend tessellation, so a stale definition
+ * surfaces as an actionable error instead of a scene quietly missing its curves. Every other
+ * unrenderable item is logged and skipped.
  */
-declare function releaseParseCaches(): void;
-
-interface DisplayItemParseOptions {
-    /** Omit to skip curves; points still render. */
-    rhino?: RhinoModule;
-}
-declare function parseDisplayItems(items: DisplayItem[] | undefined, options?: DisplayItemParseOptions): THREE.Object3D[];
-
-export { type DisplayBatch, type DisplayComputeResponse, type DisplayCurve, type DisplayDataItem, type DisplayIdentity, type DisplayItem, type DisplayItemBase, type DisplayItemParseOptions, type DisplayPoint, type DisplayPosition, type DisplayResponseValue, type MaterialGroup, type MeshBatchParsingOptions, type MeshExtractionOptions, type MeshMetadata, SCALE_FACTORS, type SerializableMaterial, getThreeMeshesFromComputeResponse, meshPolicy, parseDisplayItems, parseMeshBatchBlob, parseMeshBatchObject, releaseParseCaches, setTextureAnisotropy };
+declare function parseDisplayItems(items: DisplayItem[] | undefined): THREE.Object3D[];
+//#endregion
+export { type DisplayBatch, type DisplayComputeResponse, type DisplayCurve, type DisplayDataItem, type DisplayIdentity, type DisplayItem, type DisplayItemBase, type DisplayPoint, type DisplayPosition, type DisplayResponseValue, type MaterialGroup, type MeshBatchParsingOptions, type MeshExtractionOptions, type MeshMetadata, SCALE_FACTORS, type SerializableMaterial, getThreeMeshesFromComputeResponse, meshPolicy, parseDisplayItems, parseMeshBatchBlob, parseMeshBatchObject, setTextureAnisotropy };
+//# sourceMappingURL=parse.d.cts.map