three-cad-viewer 4.3.4 → 4.3.6

package/src/utils/sizeof.ts

@@ -1,116 +0,0 @@
-/**
- * Options for memory size calculation.
- */
-interface MemorySizeOptions {
-  excludeAttributes?: string[];
-  visited?: WeakSet<object>;
-}
-
-function calculateObjectSize(obj: unknown, options: MemorySizeOptions = {}): number {
-  const {
-    excludeAttributes = ["parent", "context", "_parent", "__parent"],
-    visited = new WeakSet(),
-  } = options;
-
-  // Prevent circular reference
-  if (obj === null || obj === undefined) return 0;
-
-  // Check for primitive types
-  if (
-    ["number", "string", "boolean", "symbol", "bigint"].includes(typeof obj)
-  ) {
-    return estimatePrimitiveSize(obj as string | number | boolean | symbol | bigint);
-  }
-
-  // Prevent circular references
-  if (typeof obj === "object" && visited.has(obj)) return 0;
-  if (typeof obj === "object") visited.add(obj);
-
-  // Handle Arrays
-  if (Array.isArray(obj)) {
-    return obj.reduce(
-      (total, item) =>
-        total +
-        calculateObjectSize(item, {
-          excludeAttributes,
-          visited,
-        }),
-      estimateArrayOverhead(obj),
-    );
-  }
-
-  // Handle TypedArrays
-  if (ArrayBuffer.isView(obj)) {
-    return obj.byteLength + estimateTypedArrayOverhead();
-  }
-
-  // Handle Maps
-  if (obj instanceof Map) {
-    let mapSize = estimateMapOverhead(obj);
-    for (const [key, value] of obj) {
-      mapSize += calculateObjectSize(key, { excludeAttributes, visited });
-      mapSize += calculateObjectSize(value, { excludeAttributes, visited });
-    }
-    return mapSize;
-  }
-
-  // Handle regular objects
-  if (typeof obj === "object") {
-    let objectSize = estimateObjectOverhead();
-    for (const key in obj) {
-      // Skip excluded attributes
-      if (
-        Object.prototype.hasOwnProperty.call(obj, key) &&
-        !excludeAttributes.includes(key)
-      ) {
-        objectSize += calculateObjectSize(key, { excludeAttributes, visited });
-        objectSize += calculateObjectSize((obj as Record<string, unknown>)[key], {
-          excludeAttributes,
-          visited,
-        });
-      }
-    }
-    return objectSize;
-  }
-
-  // For functions or unknown types
-  return 0;
-}
-
-function estimatePrimitiveSize(primitive: string | number | boolean | symbol | bigint | null | undefined): number {
-  if (primitive === null || primitive === undefined) return 0;
-  switch (typeof primitive) {
-    case "number":
-      return 8; // 64-bit float
-    case "string":
-      return primitive.length * 2; // Assume UTF-16 encoding
-    case "boolean":
-      return 4;
-    case "symbol":
-      return 8;
-    case "bigint":
-      return 8;
-    default:
-      return 0;
-  }
-}
-
-function estimateArrayOverhead(arr: unknown[]): number {
-  return 24 + arr.length * 8; // Array header + pointer overhead
-}
-
-function estimateTypedArrayOverhead(): number {
-  return 24; // Typical overhead for TypedArrays
-}
-
-function estimateMapOverhead(map: Map<unknown, unknown>): number {
-  return 40 + map.size * 16; // Map header + entry overhead
-}
-
-function estimateObjectOverhead(): number {
-  return 32; // Basic object overhead
-}
-
-export function sizeof(obj: unknown): number {
-  return calculateObjectSize(obj);
-}

package/src/utils/timer.ts

@@ -1,69 +0,0 @@
-/**
- * Performance timing utility for measuring execution time.
- *
- * @example
- * ```typescript
- * const timer = new Timer("render", true);
- * // ... do some work ...
- * timer.split("tessellation complete");
- * // ... do more work ...
- * timer.stop();
- * ```
- *
- * @public
- */
-class Timer {
-  private prefix: string;
-  private timeit: boolean;
-  private start: number;
-  private last: number;
-
-  /**
-   * Create a new Timer instance.
-   *
-   * @param prefix - Label prefix for log messages
-   * @param timeit - If false, all timing operations are no-ops
-   */
-  constructor(prefix: string, timeit: boolean) {
-    this.prefix = prefix;
-    this.timeit = timeit;
-    this.start = performance.now();
-    this.last = this.start;
-    if (timeit) {
-      console.info(`three-cad-viewer: ${prefix}:timer start`);
-    }
-  }
-
-  /**
-   * Log a split time (time since last split or start).
-   *
-   * @param msg - Message to include in the log output
-   */
-  split(msg: string): void {
-    if (this.timeit) {
-      const t = performance.now();
-      console.info(
-        `three-cad-viewer: ${this.prefix}:${msg}:timer split ${(
-          t - this.last
-        ).toFixed(1)} ms`,
-      );
-      this.last = t;
-    }
-  }
-
-  /**
-   * Log total elapsed time and stop the timer.
-   */
-  stop(): void {
-    if (this.timeit) {
-      const t = performance.now();
-      console.info(
-        `three-cad-viewer: ${this.prefix}:timer stop ${(t - this.start).toFixed(
-          1,
-        )} ms:`,
-      );
-    }
-  }
-}
-
-export { Timer };

package/src/utils/utils.ts

@@ -1,446 +0,0 @@
-import * as THREE from "three";
-import type { Vector3Tuple, QuaternionTuple } from "three";
-import type { LineSegments2 } from "three/examples/jsm/lines/LineSegments2.js";
-import type { Axis } from "../core/types.js";
-import { gpuTracker } from "./gpu-tracker.js";
-
-// =============================================================================
-// Constants
-// =============================================================================
-
-/** Unit vectors for each axis */
-export const AXIS_VECTORS: Readonly<Record<Axis, THREE.Vector3>> = {
-  x: new THREE.Vector3(1, 0, 0),
-  y: new THREE.Vector3(0, 1, 0),
-  z: new THREE.Vector3(0, 0, 1),
-};
-
-// =============================================================================
-// Utility Functions
-// =============================================================================
-
-/**
- * Flatten a nested array of numbers to a 1D array.
- * The cast is necessary because TypeScript's flat() return type
- * is a complex union that doesn't simplify to number[].
- */
-function flatten(arr: number[][] | number[][][] | number[][][][], depth: number = 1): number[] {
-  return arr.flat(depth) as number[];
-}
-
-/**
- * Convert an array to Vector3Tuple with validation.
- * Throws if the input is not a 3-element array.
- */
-function toVector3Tuple(arr: number[]): Vector3Tuple {
-  if (!Array.isArray(arr) || arr.length !== 3) {
-    throw new Error(`Expected array of length 3, got ${Array.isArray(arr) ? arr.length : typeof arr}`);
-  }
-  return arr as Vector3Tuple;
-}
-
-/**
- * Convert an array to QuaternionTuple with validation.
- * Throws if the input is not a 4-element array.
- */
-function toQuaternionTuple(arr: number[]): QuaternionTuple {
-  if (!Array.isArray(arr) || arr.length !== 4) {
-    throw new Error(`Expected array of length 4, got ${Array.isArray(arr) ? arr.length : typeof arr}`);
-  }
-  return arr as QuaternionTuple;
-}
-
-function isEqual(obj1: unknown, obj2: unknown, tol: number = 1e-9): boolean {
-  if (Array.isArray(obj1) && Array.isArray(obj2)) {
-    return (
-      obj1.length === obj2.length && obj1.every((v, i) => isEqual(v, obj2[i], tol))
-    );
-  } else if (obj1 !== null && obj2 !== null && typeof obj1 === "object" && typeof obj2 === "object") {
-    const rec1 = obj1 as Record<string, unknown>;
-    const rec2 = obj2 as Record<string, unknown>;
-    const keys1 = Object.keys(rec1);
-    const keys2 = Object.keys(rec2);
-
-    if (
-      keys1.length === keys2.length &&
-      keys1.every((key) => Object.prototype.hasOwnProperty.call(rec2, key))
-    ) {
-      return keys1.every((key) => isEqual(rec1[key], rec2[key], tol));
-    } else {
-      return false;
-    }
-  } else {
-    if (typeof obj1 === "number" && typeof obj2 === "number") {
-      return Math.abs(obj1 - obj2) < tol;
-    }
-    return obj1 === obj2;
-  }
-}
-
-function sceneTraverse(obj: THREE.Object3D | null | undefined, fn: (obj: THREE.Object3D) => void): void {
-  if (!obj) return;
-
-  fn(obj);
-
-  if (obj.children && obj.children.length > 0) {
-    obj.children.forEach((o) => {
-      sceneTraverse(o, fn);
-    });
-  }
-}
-
-interface GeometryLike {
-  dispose: () => void;
-  attributes: Record<string, unknown>;
-}
-
-function disposeGeometry(geometry: GeometryLike | null | undefined): void {
-  if (geometry) {
-    gpuTracker.untrack("geometry", geometry);
-    geometry.dispose();
-    for (const attr of Object.values(geometry.attributes)) {
-      if (attr && typeof attr === "object" && "dispose" in attr && typeof attr.dispose === "function") {
-        attr.dispose();
-      }
-    }
-  }
-}
-
-interface Disposable {
-  dispose: () => void;
-}
-
-interface MaterialLike {
-  dispose: () => void;
-  // MeshStandardMaterial texture maps
-  map?: Disposable | null;
-  normalMap?: Disposable | null;
-  roughnessMap?: Disposable | null;
-  metalnessMap?: Disposable | null;
-  aoMap?: Disposable | null;
-  emissiveMap?: Disposable | null;
-  alphaMap?: Disposable | null;
-  bumpMap?: Disposable | null;
-  // MeshPhysicalMaterial additional texture maps
-  transmissionMap?: Disposable | null;
-  clearcoatMap?: Disposable | null;
-  clearcoatRoughnessMap?: Disposable | null;
-  clearcoatNormalMap?: Disposable | null;
-  thicknessMap?: Disposable | null;
-  specularIntensityMap?: Disposable | null;
-  specularColorMap?: Disposable | null;
-  sheenColorMap?: Disposable | null;
-  sheenRoughnessMap?: Disposable | null;
-  anisotropyMap?: Disposable | null;
-}
-
-/** All texture map property names on MaterialLike (for iteration) */
-const MATERIAL_TEXTURE_KEYS: readonly (keyof Omit<MaterialLike, "dispose">)[] = [
-  // MeshStandardMaterial
-  "map", "normalMap", "roughnessMap", "metalnessMap",
-  "aoMap", "emissiveMap", "alphaMap", "bumpMap",
-  // MeshPhysicalMaterial
-  "transmissionMap", "clearcoatMap", "clearcoatRoughnessMap", "clearcoatNormalMap",
-  "thicknessMap", "specularIntensityMap", "specularColorMap",
-  "sheenColorMap", "sheenRoughnessMap", "anisotropyMap",
-];
-
-/**
- * Dispose a material and detach its texture references.
- *
- * Texture GPU resources are NOT freed here -- TextureCache is the sole owner
- * of loaded textures and is responsible for calling texture.dispose().
- * This function only nulls out the material's texture map references to
- * break the association, then disposes the material itself.
- */
-function disposeMaterial(material: MaterialLike | null | undefined): void {
-  if (!material) return;
-
-  // Detach all texture references (do NOT dispose -- TextureCache owns them)
-  for (const key of MATERIAL_TEXTURE_KEYS) {
-    if (material[key]) {
-      (material as unknown as Record<string, unknown>)[key] = null;
-    }
-  }
-
-  gpuTracker.untrack("material", material);
-  material.dispose();
-}
-
-interface MeshLike {
-  geometry?: GeometryLike | null;
-  material?: MaterialLike | MaterialLike[] | null;
-  isMesh?: boolean;
-  isLine?: boolean;
-  isPoints?: boolean;
-}
-
-function disposeMesh(mesh: MeshLike): void {
-  if (mesh.geometry) {
-    disposeGeometry(mesh.geometry);
-  }
-
-  if (mesh.material) {
-    if (Array.isArray(mesh.material)) {
-      mesh.material.forEach(disposeMaterial);
-    } else {
-      disposeMaterial(mesh.material);
-    }
-  }
-}
-
-interface DisposableTree extends MeshLike {
-  children?: DisposableTree[];
-  dispose?: () => void;
-}
-
-function deepDispose(tree: DisposableTree | DisposableTree[] | null | undefined): void {
-  if (!tree) {
-    return;
-  }
-  if (Array.isArray(tree)) {
-    tree.forEach(deepDispose);
-    return;
-  }
-  if (Array.isArray(tree.children)) {
-    tree.children.forEach(deepDispose);
-  }
-  if (tree.dispose) {
-    tree.dispose();
-  } else if (tree.isMesh || tree.isLine || tree.isPoints) {
-    disposeMesh(tree);
-  }
-}
-
-function format(v: number, b: number = 2, a: number = 2): string {
-  const s = Math.abs(v).toFixed(a);
-  let padding = "";
-  const int = s.split(".")[0];
-  for (let i = int.length; i < b; i++) padding += " ";
-  padding += v < 0 ? "-" : " ";
-  return padding + s;
-}
-
-function prettyPrintVector(v: number[], a: number, b: number): string {
-  return `${format(v[0], a, b)}, ${format(v[1], a, b)}, ${format(v[2], a, b)}`;
-}
-
-// KeyEventLike matches MouseEvent, PointerEvent, KeyboardEvent etc.
-type KeyEventLike = {
-  ctrlKey: boolean;
-  shiftKey: boolean;
-  altKey: boolean;
-  metaKey: boolean;
-};
-
-type KeyEventKey = keyof KeyEventLike;
-type MappedKey = "shift" | "ctrl" | "meta" | "alt";
-
-interface KeyMappingConfig {
-  shift: KeyEventKey;
-  ctrl: KeyEventKey;
-  meta: KeyEventKey;
-  alt: KeyEventKey;
-}
-
-class _KeyMapper {
-  private keyMapping: Record<MappedKey, KeyEventKey>;
-  private actionShortcuts: Record<string, string>;
-  private reverseActionShortcuts: Record<string, string>;
-
-  constructor() {
-    this.keyMapping = {
-      shift: "ctrlKey",
-      ctrl: "shiftKey",
-      meta: "altKey",
-      alt: "metaKey",
-    };
-    this.actionShortcuts = {};
-    this.reverseActionShortcuts = {};
-  }
-
-  getshortcuts = (key: MappedKey): string => {
-    return this.keyMapping[key].replace("Key", "");
-  };
-
-  get_config(): Record<MappedKey, KeyEventKey> {
-    return Object.assign({}, this.keyMapping);
-  }
-
-  get = (event: KeyEventLike, key: MappedKey): boolean => {
-    const prop = this.keyMapping[key];
-    return event[prop];
-  };
-
-  set = (config: Partial<KeyMappingConfig>): void => {
-    for (const key of Object.keys(config) as MappedKey[]) {
-      const value = config[key];
-      if (value !== undefined) {
-        this.keyMapping[key] = value;
-      }
-    }
-  };
-
-  setActionShortcuts = (shortcuts: Record<string, string>): void => {
-    this.actionShortcuts = { ...shortcuts };
-    this.reverseActionShortcuts = {};
-    for (const [action, key] of Object.entries(shortcuts)) {
-      this.reverseActionShortcuts[key] = action;
-    }
-  };
-
-  getActionForKey = (key: string): string | undefined => {
-    return this.reverseActionShortcuts[key];
-  };
-
-  getShortcutForAction = (action: string): string | undefined => {
-    return this.actionShortcuts[action];
-  };
-
-  getActionShortcuts = (): Record<string, string> => {
-    return { ...this.actionShortcuts };
-  };
-}
-
-// see https://discourse.threejs.org/t/updates-to-lighting-in-three-js-r155/53733
-function scaleLight(intensity: number): number {
-  return Math.round(Math.PI * intensity);
-}
-
-// =============================================================================
-// THREE.js Type Guards
-// =============================================================================
-
-/**
- * Type guard to check if an Object3D is a Mesh.
- */
-function isMesh(obj: THREE.Object3D): obj is THREE.Mesh {
-  return "isMesh" in obj && obj.isMesh === true;
-}
-
-/**
- * Type guard to check if an Object3D is a Line.
- */
-function isLine(obj: THREE.Object3D): obj is THREE.Line {
-  return "isLine" in obj && obj.isLine === true;
-}
-
-/**
- * Type guard to check if an Object3D is a Points.
- */
-function isPoints(obj: THREE.Object3D): obj is THREE.Points {
-  return "isPoints" in obj && obj.isPoints === true;
-}
-
-/**
- * Type guard to check if an object is an OrthographicCamera.
- * Accepts Object3D to allow use in controls where camera type is broader.
- */
-function isOrthographicCamera(obj: THREE.Object3D): obj is THREE.OrthographicCamera {
-  return "isOrthographicCamera" in obj && (obj as THREE.OrthographicCamera).isOrthographicCamera === true;
-}
-
-/**
- * Type guard to check if an object is a PerspectiveCamera.
- * Accepts Object3D to allow use in controls where camera type is broader.
- */
-function isPerspectiveCamera(obj: THREE.Object3D): obj is THREE.PerspectiveCamera {
-  return "isPerspectiveCamera" in obj && (obj as THREE.PerspectiveCamera).isPerspectiveCamera === true;
-}
-
-/**
- * Type guard to check if an Object3D is a LineSegments2 (fat line).
- */
-function isLineSegments2(obj: THREE.Object3D): obj is LineSegments2 {
-  return obj.type === "LineSegments2";
-}
-
-/**
- * Type guard to check if a material has a color property.
- */
-function hasColor(material: THREE.Material): material is THREE.Material & { color: THREE.Color } {
-  return "color" in material;
-}
-
-/**
- * Type guard to check if a material has emissive property.
- */
-function hasEmissive(material: THREE.Material): material is THREE.Material & { emissive: THREE.Color } {
-  return "emissive" in material;
-}
-
-/**
- * Type guard to check if a material is a MeshStandardMaterial.
- */
-function isMeshStandardMaterial(material: THREE.Material): material is THREE.MeshStandardMaterial {
-  return "isMeshStandardMaterial" in material && material.isMeshStandardMaterial === true;
-}
-
-const KeyMapper = new _KeyMapper();
-
-interface EventListenerEntry {
-  target: EventTarget;
-  event: string;
-  handler: EventListenerOrEventListenerObject;
-  options: boolean | AddEventListenerOptions;
-}
-
-class EventListenerManager {
-  private listeners: EventListenerEntry[];
-
-  constructor() {
-    this.listeners = [];
-  }
-
-  add = (
-    target: EventTarget,
-    event: string,
-    handler: EventListenerOrEventListenerObject,
-    options: boolean | AddEventListenerOptions = false
-  ): void => {
-    target.addEventListener(event, handler, options);
-    this.listeners.push({
-      target: target,
-      event: event,
-      handler: handler,
-      options: options,
-    });
-  };
-
-  dispose(): void {
-    this.listeners.forEach(({ target, event, handler, options }) => {
-      target.removeEventListener(event, handler, options);
-    });
-    this.listeners = [];
-  }
-}
-
-export {
-  flatten,
-  isEqual,
-  sceneTraverse,
-  prettyPrintVector,
-  KeyMapper,
-  scaleLight,
-  deepDispose,
-  disposeGeometry,
-  EventListenerManager,
-  // Type guards
-  isMesh,
-  isLine,
-  isPoints,
-  isOrthographicCamera,
-  isPerspectiveCamera,
-  isLineSegments2,
-  hasColor,
-  hasEmissive,
-  isMeshStandardMaterial,
-  toVector3Tuple,
-  toQuaternionTuple,
-};
-
-export type {
-  KeyEventKey,
-  KeyMappingConfig,
-  DisposableTree,
-};