@omrips/viewstl 2.0.0-rc.1 → 2.0.0-rc.3

package/build/v2/node/index.cjs

@@ -0,0 +1,382 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/v2/node/commonjs.js
+var commonjs_exports = {};
+__export(commonjs_exports, {
+  analyzeBuffer: () => analyzeBuffer,
+  analyzeFile: () => analyzeFile,
+  createAnalyzer: () => createAnalyzer
+});
+module.exports = __toCommonJS(commonjs_exports);
+var import_node_path2 = require("node:path");
+var import_node_url2 = require("node:url");
+
+// src/v2/node/api.js
+var import_node_worker_threads = require("node:worker_threads");
+var import_node_path = require("node:path");
+var import_node_url = require("node:url");
+
+// src/v2/memory.js
+var MEMORY_OVERHEAD = 64 * 1024 * 1024;
+
+// src/v2/geometry.js
+var DEFAULT_LIMITS = Object.freeze({
+  max_file_bytes: 256 * 1024 * 1024,
+  max_triangles: 5e6,
+  max_uncompressed_bytes: 256 * 1024 * 1024,
+  max_archive_entries: 1024,
+  max_memory_bytes: Number.MAX_SAFE_INTEGER
+});
+function limitsWith(options = {}) {
+  const limits = { ...DEFAULT_LIMITS };
+  for (const key of Object.keys(limits))
+    if (options[key] !== void 0) {
+      if (!Number.isSafeInteger(options[key]) || options[key] < 1)
+        throw new Error(`Invalid ${key}`);
+      limits[key] = options[key];
+    }
+  return limits;
+}
+
+// src/v2/print-options.js
+function printOptions(input = {}) {
+  const level = input.level ?? "basic";
+  if (!["basic", "detailed"].includes(level))
+    throw new Error("Choose basic or detailed print checks");
+  const number = (v, name, max = 1e9) => {
+    if (!Number.isFinite(v) || v <= 0 || v > max)
+      throw new Error(`Invalid ${name}`);
+    return v;
+  };
+  let profile = null;
+  if (input.profile != null) {
+    if (input.profile.technology !== "fdm")
+      throw new Error("Only FDM profiles are supported");
+    profile = { technology: "fdm" };
+    for (const key of ["min_wall_mm", "line_width_mm"])
+      if (input.profile[key] != null)
+        profile[key] = number(input.profile[key], key);
+    if (input.profile.overhang_degrees != null)
+      profile.overhang_degrees = number(
+        input.profile.overhang_degrees,
+        "overhang angle",
+        89.9
+      );
+    if (input.profile.build_volume_mm != null) {
+      if (!Array.isArray(input.profile.build_volume_mm) || input.profile.build_volume_mm.length !== 3)
+        throw new Error("Build volume requires X, Y and Z");
+      profile.build_volume_mm = input.profile.build_volume_mm.map(
+        (v) => number(v, "build volume")
+      );
+    }
+  }
+  const time = number(input.max_time_ms ?? 3e4, "check time limit", 12e4);
+  return {
+    level,
+    profile,
+    apply_transforms: input.apply_transforms !== false,
+    units_confirmed: input.units_confirmed === true,
+    max_time_ms: time
+  };
+}
+
+// src/v2/node/api.js
+var MB = 1024 ** 2;
+var defaults = {
+  max_file_bytes: 64 * MB,
+  max_triangles: 1e6,
+  max_uncompressed_bytes: 128 * MB,
+  max_archive_entries: 1024,
+  max_memory_bytes: 1024 * MB
+};
+var formats = /* @__PURE__ */ new Map([
+  ["stl", "stl"],
+  ["obj", "obj"],
+  ["3mf", "3mf"],
+  ["step", "step"],
+  ["stp", "step"],
+  ["iges", "iges"],
+  ["igs", "iges"]
+]);
+var units = /* @__PURE__ */ new Set(["mm", "cm", "m", "in", "ft", "um"]);
+function failure(message, code, name = "Error") {
+  return Object.assign(new Error(message), { code, name });
+}
+function integer(value, name, min, max) {
+  if (!Number.isSafeInteger(value) || value < min || value > max)
+    throw new TypeError(`Invalid ${name}`);
+  return value;
+}
+function localPath(input) {
+  if (input instanceof URL) {
+    if (input.protocol !== "file:" || input.hostname && input.hostname !== "localhost")
+      throw new TypeError("Only local file paths and file: URLs are supported");
+    input = (0, import_node_url.fileURLToPath)(input);
+  }
+  if (typeof input !== "string" || !input || input.includes("\0") || /^[\\/]{2}/.test(input) || /^[a-z][a-z\d+.-]*:/i.test(input) && !/^[a-z]:[\\/]/i.test(input))
+    throw new TypeError("Only local file paths and file: URLs are supported");
+  return (0, import_node_path.resolve)(input);
+}
+function settings(input, filename) {
+  if (!input || typeof input !== "object" || Array.isArray(input))
+    throw new TypeError("Analysis options must be an object");
+  const format = formats.get(
+    String(input.format ?? filename.split(".").pop()).toLowerCase()
+  );
+  if (!format)
+    throw failure(
+      "Choose STL, OBJ, 3MF, STEP/STP or IGES/IGS",
+      "ERR_UNSUPPORTED_FORMAT"
+    );
+  if (input.units !== void 0 && !units.has(input.units))
+    throw new TypeError("Units must be mm, cm, m, in, ft or um");
+  if (input.units !== void 0 && input.units !== "mm" && !["stl", "obj"].includes(format))
+    throw new TypeError(
+      "3MF and CAD file units are honored and converted to mm; units cannot override them"
+    );
+  if (input.limits !== void 0 && (!input.limits || typeof input.limits !== "object" || Array.isArray(input.limits)))
+    throw new TypeError("limits must be an object");
+  for (const key of Object.keys(input.limits ?? {}))
+    if (!Object.hasOwn(defaults, key))
+      throw new TypeError(`Unknown analysis limit: ${key}`);
+  const overrides = Object.fromEntries(
+    Object.entries(input.limits ?? {}).filter(
+      ([, value]) => value !== void 0
+    )
+  );
+  const limits = limitsWith({ ...defaults, ...overrides });
+  const timeout_ms = integer(
+    input.timeout_ms ?? 12e4,
+    "timeout_ms",
+    1,
+    2147483647
+  );
+  const checks = printOptions({
+    level: input.level ?? "detailed",
+    profile: input.profile,
+    max_time_ms: input.max_time_ms ?? 3e4
+  });
+  if (input.on_progress !== void 0 && typeof input.on_progress !== "function")
+    throw new TypeError("on_progress must be a function");
+  if (input.signal !== void 0 && !(input.signal instanceof AbortSignal))
+    throw new TypeError("signal must be an AbortSignal");
+  return { filename, format, units: input.units, limits, timeout_ms, checks };
+}
+function createAPI(workerURL) {
+  function createAnalyzer2(options = {}) {
+    const concurrency = integer(options.concurrency ?? 2, "concurrency", 1, 8);
+    const maxQueue = integer(options.max_queue ?? 16, "max_queue", 0, 1024);
+    const maxQueuedBytes = integer(
+      options.max_queued_bytes ?? 128 * MB,
+      "max_queued_bytes",
+      1,
+      Number.MAX_SAFE_INTEGER
+    );
+    const queue = [], active = /* @__PURE__ */ new Set();
+    let closed = false, queuedBytes = 0;
+    const abortError = () => failure("Analysis cancelled", "ABORT_ERR", "AbortError");
+    function finish(job, error, result) {
+      if (job.done) return job.finished;
+      job.done = true;
+      clearTimeout(job.timer);
+      job.signal?.removeEventListener("abort", job.abort);
+      const index = queue.indexOf(job);
+      if (index >= 0) {
+        queue.splice(index, 1);
+        queuedBytes -= job.bytes;
+      }
+      job.task = null;
+      job.finished = (async () => {
+        if (job.worker) await job.worker.terminate().catch(() => {
+        });
+        active.delete(job);
+        error ? job.reject(error) : job.resolve(result);
+        pump();
+      })();
+      return job.finished;
+    }
+    function pump() {
+      while (!closed && active.size < concurrency && queue.length) {
+        const job = queue.shift();
+        queuedBytes -= job.bytes;
+        active.add(job);
+        try {
+          const task = job.task;
+          job.worker = new import_node_worker_threads.Worker(workerURL, {
+            workerData: task,
+            transferList: task.buffer ? [task.buffer] : [],
+            // CLI eval/test flags are not valid entry flags for a file worker.
+            execArgv: [],
+            resourceLimits: {
+              maxOldGenerationSizeMb: Math.max(
+                16,
+                Math.min(
+                  4096,
+                  Math.floor(task.limits.max_memory_bytes / MB / 2)
+                )
+              )
+            }
+          });
+          job.task = null;
+          job.worker.on("message", (message) => {
+            if (job.done) return;
+            if (message.progress) {
+              try {
+                Promise.resolve(job.progress?.(message.progress)).catch(
+                  (error) => void finish(job, error)
+                );
+              } catch (error) {
+                void finish(job, error);
+              }
+            } else if (message.error) {
+              void finish(
+                job,
+                failure(
+                  message.error.message,
+                  message.error.code,
+                  message.error.name
+                )
+              );
+            } else if (message.result) void finish(job, null, message.result);
+            else
+              void finish(
+                job,
+                failure(
+                  "Invalid analysis worker response",
+                  "ERR_ANALYSIS_WORKER"
+                )
+              );
+          });
+          job.worker.on("error", (error) => void finish(job, error));
+          job.worker.on("exit", (code) => {
+            if (!job.done)
+              void finish(
+                job,
+                failure(
+                  `Analysis worker stopped (exit ${code})`,
+                  "ERR_ANALYSIS_WORKER"
+                )
+              );
+          });
+        } catch (error) {
+          void finish(job, error);
+        }
+      }
+    }
+    function submit(task, input, source) {
+      if (closed)
+        return Promise.reject(
+          failure("Analyzer is closed", "ERR_ANALYZER_CLOSED")
+        );
+      if (input.signal?.aborted) return Promise.reject(abortError());
+      if (active.size >= concurrency && queue.length >= maxQueue)
+        return Promise.reject(
+          failure("Analysis queue is full", "ERR_ANALYZER_BUSY")
+        );
+      const bytes = source?.byteLength ?? 0;
+      if (bytes > task.limits.max_file_bytes)
+        return Promise.reject(
+          failure("File size limit exceeded", "ERR_FILE_TOO_LARGE")
+        );
+      if (bytes * 2 + 64 * MB > task.limits.max_memory_bytes)
+        return Promise.reject(
+          failure(
+            "Input exceeds the analysis memory budget",
+            "ERR_ANALYSIS_LIMIT"
+          )
+        );
+      if (active.size >= concurrency && queuedBytes + bytes > maxQueuedBytes)
+        return Promise.reject(
+          failure("Queued input memory limit exceeded", "ERR_ANALYZER_BUSY")
+        );
+      if (source) task.buffer = new Uint8Array(source).buffer;
+      return new Promise((resolveJob, reject) => {
+        const job = {
+          task,
+          bytes,
+          signal: input.signal,
+          progress: input.on_progress,
+          resolve: resolveJob,
+          reject
+        };
+        job.abort = () => void finish(job, abortError());
+        job.signal?.addEventListener("abort", job.abort, { once: true });
+        job.timer = setTimeout(
+          () => void finish(
+            job,
+            failure("Analysis timed out", "ERR_ANALYSIS_TIMEOUT")
+          ),
+          task.timeout_ms
+        );
+        queue.push(job);
+        queuedBytes += bytes;
+        pump();
+      });
+    }
+    return {
+      async analyzeFile(path, options2 = {}) {
+        path = localPath(path);
+        return submit({ ...settings(options2, (0, import_node_path.basename)(path)), path }, options2);
+      },
+      async analyzeBuffer(data, options2 = {}) {
+        let bytes;
+        if (data instanceof ArrayBuffer) bytes = new Uint8Array(data);
+        else if (data instanceof Uint8Array && data.buffer instanceof ArrayBuffer)
+          bytes = data;
+        else
+          throw new TypeError(
+            "Expected an ArrayBuffer, Uint8Array or Node Buffer"
+          );
+        const filename = options2.filename ?? (options2.format ? `model.${options2.format}` : "");
+        if (typeof filename !== "string" || !filename || filename.includes("\0"))
+          throw new TypeError("Provide a filename or format for buffer input");
+        return submit(
+          settings(options2, filename.split(/[\\/]/).pop()),
+          options2,
+          bytes
+        );
+      },
+      async dispose() {
+        closed = true;
+        await Promise.all(
+          [...queue, ...active].map(
+            (job) => finish(job, failure("Analyzer is closed", "ERR_ANALYZER_CLOSED"))
+          )
+        );
+      }
+    };
+  }
+  const shared = createAnalyzer2();
+  return {
+    analyzeFile: shared.analyzeFile,
+    analyzeBuffer: shared.analyzeBuffer,
+    createAnalyzer: createAnalyzer2
+  };
+}
+
+// src/v2/node/commonjs.js
+var { analyzeFile, analyzeBuffer, createAnalyzer } = createAPI(
+  (0, import_node_url2.pathToFileURL)((0, import_node_path2.join)(__dirname, "analysis-worker.js"))
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  analyzeBuffer,
+  analyzeFile,
+  createAnalyzer
+});

package/build/v2/node/index.d.cts

@@ -0,0 +1,122 @@
+/** Physical scale for unitless STL/OBJ files. 3MF/STEP/IGES honor file units. */
+export type AnalysisUnits = "mm" | "cm" | "m" | "in" | "ft" | "um";
+export type AnalysisFormat =
+  "stl" | "obj" | "3mf" | "step" | "stp" | "iges" | "igs";
+export interface AnalysisLimits {
+  max_file_bytes?: number;
+  max_triangles?: number;
+  max_uncompressed_bytes?: number;
+  max_archive_entries?: number;
+  /** Estimated working-set admission budget, not a process RSS cap. */
+  max_memory_bytes?: number;
+}
+export interface AnalysisProfile {
+  technology: "fdm";
+  min_wall_mm?: number;
+  line_width_mm?: number;
+  overhang_degrees?: number;
+  build_volume_mm?: [number, number, number];
+}
+export interface AnalysisProgress {
+  phase: string;
+  elapsed_ms: number;
+  loaded?: number;
+  total?: number;
+}
+export interface AnalysisOptions {
+  format?: AnalysisFormat;
+  units?: AnalysisUnits;
+  /** Defaults to detailed. Basic reports omit intersection/validated-volume checks. */
+  level?: "basic" | "detailed";
+  profile?: AnalysisProfile | null;
+  /** Whole job deadline, including queueing and file parsing; default 120000. */
+  timeout_ms?: number;
+  /** Mesh-check deadline, at most 120000; default 30000. May return a partial report. */
+  max_time_ms?: number;
+  limits?: AnalysisLimits;
+  signal?: AbortSignal;
+  on_progress?: (progress: AnalysisProgress) => void;
+}
+export interface BufferAnalysisOptions extends AnalysisOptions {
+  /** Supply filename or format for Buffer/Uint8Array/ArrayBuffer input. */
+  filename?: string;
+}
+export interface AnalysisCheck {
+  code: string;
+  label: string;
+  severity: "error" | "warning" | "info";
+  status: "pass" | "issue" | "not_run" | "inconclusive";
+  count: number;
+  triangle_ids: number[];
+  edge_vertices: number[];
+  message: string;
+  estimated?: boolean;
+  area_mm2?: number;
+  samples?: number;
+  minimum_sampled_mm?: number | null;
+  unresolved_samples?: number;
+}
+export interface AnalysisReport {
+  schema_version: 1;
+  model_id: number;
+  name: string;
+  filename: string;
+  format: "stl" | "obj" | "3mf" | "step" | "iges";
+  file_bytes: number;
+  triangles: number;
+  /** Known physical measurements are normalized to mm; null means unitless. */
+  units: "mm" | null;
+  units_source: "file" | "option" | null;
+  /** Measurements in mm when units are known, otherwise in input coordinate units. */
+  dimensions: [number, number, number] | null;
+  surface_area: number;
+  volume: number | null;
+  dimensions_mm: [number, number, number] | null;
+  surface_area_mm2: number | null;
+  volume_mm3: number | null;
+  /** Validated mesh volume; does not by itself confirm physical units or printability. */
+  volume_valid: boolean;
+  checks: AnalysisCheck[];
+  summary: "no_issues_found" | "issues_found" | "incomplete";
+  elapsed_ms: number;
+  tolerance_mm?: number;
+  limit_reason?: "time";
+  settings: {
+    level: "basic" | "detailed";
+    profile: AnalysisProfile | null;
+    apply_transforms: boolean;
+    units_confirmed: boolean;
+    max_time_ms: number;
+  };
+}
+export interface AnalyzerOptions {
+  /** Number of simultaneous disposable workers; default 2, range 1–8. */
+  concurrency?: number;
+  /** Number of waiting jobs; default 16. */
+  max_queue?: number;
+  /** Maximum copied buffer bytes waiting in the queue; default 128 MiB. */
+  max_queued_bytes?: number;
+}
+export interface Analyzer {
+  analyzeFile(
+    path: string | URL,
+    options?: AnalysisOptions,
+  ): Promise<AnalysisReport>;
+  analyzeBuffer(
+    data: Uint8Array | ArrayBuffer,
+    options: BufferAnalysisOptions,
+  ): Promise<AnalysisReport>;
+  /** Cancel queued/running jobs and wait for worker termination. */
+  dispose(): Promise<void>;
+}
+/** Analyze a local regular file. HTTP(S) URLs and network-share paths are rejected. */
+export function analyzeFile(
+  path: string | URL,
+  options?: AnalysisOptions,
+): Promise<AnalysisReport>;
+/** The caller's data is copied and is never detached or modified. */
+export function analyzeBuffer(
+  data: Uint8Array | ArrayBuffer,
+  options: BufferAnalysisOptions,
+): Promise<AnalysisReport>;
+export function createAnalyzer(options?: AnalyzerOptions): Analyzer;

package/build/v2/node/index.d.ts

@@ -0,0 +1,122 @@
+/** Physical scale for unitless STL/OBJ files. 3MF/STEP/IGES honor file units. */
+export type AnalysisUnits = "mm" | "cm" | "m" | "in" | "ft" | "um";
+export type AnalysisFormat =
+  "stl" | "obj" | "3mf" | "step" | "stp" | "iges" | "igs";
+export interface AnalysisLimits {
+  max_file_bytes?: number;
+  max_triangles?: number;
+  max_uncompressed_bytes?: number;
+  max_archive_entries?: number;
+  /** Estimated working-set admission budget, not a process RSS cap. */
+  max_memory_bytes?: number;
+}
+export interface AnalysisProfile {
+  technology: "fdm";
+  min_wall_mm?: number;
+  line_width_mm?: number;
+  overhang_degrees?: number;
+  build_volume_mm?: [number, number, number];
+}
+export interface AnalysisProgress {
+  phase: string;
+  elapsed_ms: number;
+  loaded?: number;
+  total?: number;
+}
+export interface AnalysisOptions {
+  format?: AnalysisFormat;
+  units?: AnalysisUnits;
+  /** Defaults to detailed. Basic reports omit intersection/validated-volume checks. */
+  level?: "basic" | "detailed";
+  profile?: AnalysisProfile | null;
+  /** Whole job deadline, including queueing and file parsing; default 120000. */
+  timeout_ms?: number;
+  /** Mesh-check deadline, at most 120000; default 30000. May return a partial report. */
+  max_time_ms?: number;
+  limits?: AnalysisLimits;
+  signal?: AbortSignal;
+  on_progress?: (progress: AnalysisProgress) => void;
+}
+export interface BufferAnalysisOptions extends AnalysisOptions {
+  /** Supply filename or format for Buffer/Uint8Array/ArrayBuffer input. */
+  filename?: string;
+}
+export interface AnalysisCheck {
+  code: string;
+  label: string;
+  severity: "error" | "warning" | "info";
+  status: "pass" | "issue" | "not_run" | "inconclusive";
+  count: number;
+  triangle_ids: number[];
+  edge_vertices: number[];
+  message: string;
+  estimated?: boolean;
+  area_mm2?: number;
+  samples?: number;
+  minimum_sampled_mm?: number | null;
+  unresolved_samples?: number;
+}
+export interface AnalysisReport {
+  schema_version: 1;
+  model_id: number;
+  name: string;
+  filename: string;
+  format: "stl" | "obj" | "3mf" | "step" | "iges";
+  file_bytes: number;
+  triangles: number;
+  /** Known physical measurements are normalized to mm; null means unitless. */
+  units: "mm" | null;
+  units_source: "file" | "option" | null;
+  /** Measurements in mm when units are known, otherwise in input coordinate units. */
+  dimensions: [number, number, number] | null;
+  surface_area: number;
+  volume: number | null;
+  dimensions_mm: [number, number, number] | null;
+  surface_area_mm2: number | null;
+  volume_mm3: number | null;
+  /** Validated mesh volume; does not by itself confirm physical units or printability. */
+  volume_valid: boolean;
+  checks: AnalysisCheck[];
+  summary: "no_issues_found" | "issues_found" | "incomplete";
+  elapsed_ms: number;
+  tolerance_mm?: number;
+  limit_reason?: "time";
+  settings: {
+    level: "basic" | "detailed";
+    profile: AnalysisProfile | null;
+    apply_transforms: boolean;
+    units_confirmed: boolean;
+    max_time_ms: number;
+  };
+}
+export interface AnalyzerOptions {
+  /** Number of simultaneous disposable workers; default 2, range 1–8. */
+  concurrency?: number;
+  /** Number of waiting jobs; default 16. */
+  max_queue?: number;
+  /** Maximum copied buffer bytes waiting in the queue; default 128 MiB. */
+  max_queued_bytes?: number;
+}
+export interface Analyzer {
+  analyzeFile(
+    path: string | URL,
+    options?: AnalysisOptions,
+  ): Promise<AnalysisReport>;
+  analyzeBuffer(
+    data: Uint8Array | ArrayBuffer,
+    options: BufferAnalysisOptions,
+  ): Promise<AnalysisReport>;
+  /** Cancel queued/running jobs and wait for worker termination. */
+  dispose(): Promise<void>;
+}
+/** Analyze a local regular file. HTTP(S) URLs and network-share paths are rejected. */
+export function analyzeFile(
+  path: string | URL,
+  options?: AnalysisOptions,
+): Promise<AnalysisReport>;
+/** The caller's data is copied and is never detached or modified. */
+export function analyzeBuffer(
+  data: Uint8Array | ArrayBuffer,
+  options: BufferAnalysisOptions,
+): Promise<AnalysisReport>;
+export function createAnalyzer(options?: AnalyzerOptions): Analyzer;