brepjs 12.8.2 → 12.9.1

package/dist/shapeFns-FDuKkrDR.js

@@ -1,469 +0,0 @@
-import { B as getKernel, c as castShape, g as getShapeKind } from "./shapeTypes-CpSaBLDv.js";
-import { H as HASH_CODE_MAX, D as DEG2RAD } from "./vecOps-ZDdZWbwT.js";
-import { i as iterTopo, d as downcast } from "./faceFns-B8GnxjdY.js";
-import { v as unwrap } from "./result-BaSD1fqR.js";
-function clone(shape) {
-  return castShape(unwrap(downcast(shape.wrapped)));
-}
-function toBREP(shape) {
-  return getKernel().toBREP(shape.wrapped);
-}
-function getHashCode(shape) {
-  return getKernel().hashCode(shape.wrapped, HASH_CODE_MAX);
-}
-function isEmpty(shape) {
-  return getKernel().isNull(shape.wrapped);
-}
-function isSameShape(a, b) {
-  return getKernel().isSame(a.wrapped, b.wrapped);
-}
-function isEqualShape(a, b) {
-  return getKernel().isEqual(a.wrapped, b.wrapped);
-}
-function simplify(shape) {
-  return castShape(getKernel().simplify(shape.wrapped));
-}
-function collectInputFaceHashes(inputs) {
-  const hashes = [];
-  for (const input of inputs) {
-    const origins = getFaceOrigins(input);
-    if (!origins) continue;
-    for (const hash of origins.keys()) {
-      hashes.push(hash);
-    }
-  }
-  return hashes;
-}
-function translate(shape, v) {
-  const inputFaceHashes = collectInputFaceHashes([shape]);
-  const { shape: resultShape, evolution } = getKernel().translateWithHistory(
-    shape.wrapped,
-    v[0],
-    v[1],
-    v[2],
-    inputFaceHashes,
-    HASH_CODE_MAX
-  );
-  const result = castShape(resultShape);
-  propagateOriginsFromEvolution(evolution, [shape], result);
-  return result;
-}
-function rotate(shape, angle, position = [0, 0, 0], direction = [0, 0, 1]) {
-  const inputFaceHashes = collectInputFaceHashes([shape]);
-  const { shape: resultShape, evolution } = getKernel().rotateWithHistory(
-    shape.wrapped,
-    angle * DEG2RAD,
-    inputFaceHashes,
-    HASH_CODE_MAX,
-    direction,
-    position
-  );
-  const result = castShape(resultShape);
-  propagateOriginsFromEvolution(evolution, [shape], result);
-  return result;
-}
-function mirror(shape, planeNormal = [0, 1, 0], planeOrigin = [0, 0, 0]) {
-  const inputFaceHashes = collectInputFaceHashes([shape]);
-  const { shape: resultShape, evolution } = getKernel().mirrorWithHistory(
-    shape.wrapped,
-    planeOrigin,
-    planeNormal,
-    inputFaceHashes,
-    HASH_CODE_MAX
-  );
-  const result = castShape(resultShape);
-  propagateOriginsFromEvolution(evolution, [shape], result);
-  return result;
-}
-function scale(shape, factor, center = [0, 0, 0]) {
-  const inputFaceHashes = collectInputFaceHashes([shape]);
-  const { shape: resultShape, evolution } = getKernel().scaleWithHistory(
-    shape.wrapped,
-    center,
-    factor,
-    inputFaceHashes,
-    HASH_CODE_MAX
-  );
-  const result = castShape(resultShape);
-  propagateOriginsFromEvolution(evolution, [shape], result);
-  return result;
-}
-function resize(shape, dimensions, options) {
-  const bbox = getKernel().boundingBox(shape.wrapped);
-  const size = [
-    bbox.max[0] - bbox.min[0],
-    bbox.max[1] - bbox.min[1],
-    bbox.max[2] - bbox.min[2]
-  ];
-  const auto = options?.auto === true;
-  function factor(dim, sz, baseFactor) {
-    if (dim !== void 0 && sz > 1e-12) return dim / sz;
-    if (dim === void 0 && auto) return baseFactor;
-    return 1;
-  }
-  let autoFactor = 1;
-  if (auto) {
-    if (dimensions[0] !== void 0 && size[0] > 1e-12) autoFactor = dimensions[0] / size[0];
-    else if (dimensions[1] !== void 0 && size[1] > 1e-12) autoFactor = dimensions[1] / size[1];
-    else if (dimensions[2] !== void 0 && size[2] > 1e-12) autoFactor = dimensions[2] / size[2];
-  }
-  const factors = [
-    factor(dimensions[0], size[0], autoFactor),
-    factor(dimensions[1], size[1], autoFactor),
-    factor(dimensions[2], size[2], autoFactor)
-  ];
-  const isUniform = Math.abs(factors[0] - factors[1]) < 1e-6 && Math.abs(factors[1] - factors[2]) < 1e-6;
-  if (!isUniform) {
-    throw new Error(
-      "resize: non-uniform scaling is not supported (WASM build lacks BRepBuilderAPI_GTransform). Use auto: true to scale proportionally, or set all three dimensions to achieve uniform scaling."
-    );
-  }
-  return scale(shape, factors[0]);
-}
-function parseMatrixInput(input) {
-  if ("linear" in input) {
-    return { linear: input.linear, translation: input.translation };
-  }
-  const [r0, r1, r2, r3] = input;
-  const TOL = 1e-10;
-  if (Math.abs(r3[0]) > TOL || Math.abs(r3[1]) > TOL || Math.abs(r3[2]) > TOL || Math.abs(r3[3] - 1) > TOL) {
-    throw new Error(
-      `applyMatrix: invalid bottom row [${String(r3[0])}, ${String(r3[1])}, ${String(r3[2])}, ${String(r3[3])}]. Must be [0, 0, 0, 1] for an affine transform.`
-    );
-  }
-  return {
-    linear: [r0[0], r0[1], r0[2], r1[0], r1[1], r1[2], r2[0], r2[1], r2[2]],
-    translation: [r0[3], r1[3], r2[3]]
-  };
-}
-function det3x3(m) {
-  return m[0] * (m[4] * m[8] - m[5] * m[7]) - m[1] * (m[3] * m[8] - m[5] * m[6]) + m[2] * (m[3] * m[7] - m[4] * m[6]);
-}
-function isOrthogonalMatrix(m) {
-  const TOL = 1e-8;
-  const d00 = m[0] * m[0] + m[3] * m[3] + m[6] * m[6];
-  const d11 = m[1] * m[1] + m[4] * m[4] + m[7] * m[7];
-  const d22 = m[2] * m[2] + m[5] * m[5] + m[8] * m[8];
-  const d01 = m[0] * m[1] + m[3] * m[4] + m[6] * m[7];
-  const d02 = m[0] * m[2] + m[3] * m[5] + m[6] * m[8];
-  const d12 = m[1] * m[2] + m[4] * m[5] + m[7] * m[8];
-  if (Math.abs(d01) > TOL) return false;
-  if (Math.abs(d02) > TOL) return false;
-  if (Math.abs(d12) > TOL) return false;
-  if (Math.abs(d00 - d11) > TOL) return false;
-  if (Math.abs(d00 - d22) > TOL) return false;
-  return true;
-}
-function applyMatrix(shape, matrix) {
-  const { linear, translation } = parseMatrixInput(matrix);
-  const d = det3x3(linear);
-  if (Math.abs(d) < 1e-12) {
-    throw new Error(
-      "applyMatrix: singular matrix (determinant ≈ 0). Cannot apply a non-invertible transform."
-    );
-  }
-  const orthogonal = isOrthogonalMatrix(linear);
-  if (orthogonal) {
-    const inputFaceHashes = collectInputFaceHashes([shape]);
-    const { shape: resultShape2, evolution } = getKernel().generalTransformWithHistory(
-      shape.wrapped,
-      linear,
-      translation,
-      true,
-      inputFaceHashes,
-      HASH_CODE_MAX
-    );
-    const result2 = castShape(resultShape2);
-    propagateOriginsFromEvolution(evolution, [shape], result2);
-    return result2;
-  }
-  const resultShape = getKernel().generalTransformNonOrthogonal(shape.wrapped, linear, translation);
-  const result = castShape(resultShape);
-  propagateOriginsByHash([shape], result);
-  return result;
-}
-function composeTransforms(ops) {
-  const kernelOps = ops.map((op) => {
-    if (op.type === "translate") {
-      return { type: "translate", x: op.v[0], y: op.v[1], z: op.v[2] };
-    }
-    return {
-      type: "rotate",
-      angle: op.angle,
-      axis: op.axis,
-      center: op.center
-    };
-  });
-  const { handle, dispose } = getKernel().composeTransform(kernelOps);
-  return { trsf: handle, cleanup: dispose };
-}
-function transformCopy(shape, composed) {
-  const inputFaceHashes = collectInputFaceHashes([shape]);
-  const { shape: resultShape, evolution } = getKernel().applyComposedTransformWithHistory(
-    shape.wrapped,
-    composed.trsf,
-    inputFaceHashes,
-    HASH_CODE_MAX
-  );
-  const result = castShape(resultShape);
-  propagateOriginsFromEvolution(evolution, [shape], result);
-  return result;
-}
-const topoCache = /* @__PURE__ */ new WeakMap();
-function getOrCreateCache(shape) {
-  let entry = topoCache.get(shape.wrapped);
-  if (!entry) {
-    entry = {};
-    topoCache.set(shape.wrapped, entry);
-  }
-  return entry;
-}
-function invalidateShapeCache(shape) {
-  topoCache.delete(shape.wrapped);
-}
-function getEdges(shape) {
-  const cache = getOrCreateCache(shape);
-  if (cache.edges) return cache.edges;
-  const edges = Array.from(iterTopo(shape.wrapped, "edge")).map(
-    (e) => castShape(unwrap(downcast(e)))
-  );
-  cache.edges = edges;
-  return edges;
-}
-function getFaces(shape) {
-  const cache = getOrCreateCache(shape);
-  if (cache.faces) return cache.faces;
-  const faces = Array.from(iterTopo(shape.wrapped, "face")).map(
-    (e) => castShape(unwrap(downcast(e)))
-  );
-  cache.faces = faces;
-  return faces;
-}
-function getWires(shape) {
-  const cache = getOrCreateCache(shape);
-  if (cache.wires) return cache.wires;
-  const wires = Array.from(iterTopo(shape.wrapped, "wire")).map(
-    (e) => castShape(unwrap(downcast(e)))
-  );
-  cache.wires = wires;
-  return wires;
-}
-function setShapeOrigin(shape, origin) {
-  const cache = getOrCreateCache(shape);
-  const map = /* @__PURE__ */ new Map();
-  for (const f of getFaces(shape)) {
-    map.set(getKernel().hashCode(f.wrapped, HASH_CODE_MAX), origin);
-  }
-  cache.faceOrigins = map;
-}
-function getFaceOrigins(shape) {
-  return topoCache.get(shape.wrapped)?.faceOrigins;
-}
-function propagateOriginsFromEvolution(evolution, inputs, result) {
-  const inputOrigins = /* @__PURE__ */ new Map();
-  for (const input of inputs) {
-    const origins = getFaceOrigins(input);
-    if (!origins) continue;
-    for (const [hash, origin] of origins) {
-      inputOrigins.set(hash, origin);
-    }
-  }
-  if (inputOrigins.size === 0) return;
-  const resultMap = /* @__PURE__ */ new Map();
-  for (const [hash, origin] of inputOrigins) {
-    if (evolution.deleted.has(hash)) continue;
-    const modifiedHashes = evolution.modified.get(hash);
-    if (modifiedHashes && modifiedHashes.length > 0) {
-      for (const modHash of modifiedHashes) {
-        resultMap.set(modHash, origin);
-      }
-    } else {
-      resultMap.set(hash, origin);
-    }
-    const generatedHashes = evolution.generated.get(hash);
-    if (generatedHashes) {
-      for (const genHash of generatedHashes) {
-        if (!resultMap.has(genHash)) {
-          resultMap.set(genHash, 0);
-        }
-      }
-    }
-  }
-  if (resultMap.size > 0) {
-    const cache = getOrCreateCache(result);
-    cache.faceOrigins = resultMap;
-  }
-}
-function propagateOriginsByHash(inputs, result) {
-  const lookup = /* @__PURE__ */ new Map();
-  for (const input of inputs) {
-    const origins = getFaceOrigins(input);
-    if (!origins) continue;
-    for (const [hash, origin] of origins) {
-      lookup.set(hash, origin);
-    }
-  }
-  if (lookup.size === 0) return;
-  const kernel = getKernel();
-  const resultMap = /* @__PURE__ */ new Map();
-  const resultFaces = getFaces(result);
-  for (const f of resultFaces) {
-    const hash = kernel.hashCode(f.wrapped, HASH_CODE_MAX);
-    const origin = lookup.get(hash);
-    if (origin !== void 0) {
-      resultMap.set(hash, origin);
-    }
-  }
-  if (resultMap.size === 0) {
-    const inputSigs = [];
-    for (const input of inputs) {
-      const origins = getFaceOrigins(input);
-      if (!origins) continue;
-      for (const f of getFaces(input)) {
-        const hash = kernel.hashCode(f.wrapped, HASH_CODE_MAX);
-        const origin = origins.get(hash);
-        if (origin === void 0) continue;
-        try {
-          const bounds = kernel.uvBounds(f.wrapped);
-          const normal = kernel.surfaceNormal(
-            f.wrapped,
-            0.5 * (bounds.uMin + bounds.uMax),
-            0.5 * (bounds.vMin + bounds.vMax)
-          );
-          const centroid = kernel.surfaceCenterOfMass(f.wrapped);
-          inputSigs.push({ origin, normal, centroid });
-        } catch {
-        }
-      }
-    }
-    if (inputSigs.length > 0) {
-      for (const f of resultFaces) {
-        const hash = kernel.hashCode(f.wrapped, HASH_CODE_MAX);
-        try {
-          const outBounds = kernel.uvBounds(f.wrapped);
-          const outNormal = kernel.surfaceNormal(
-            f.wrapped,
-            0.5 * (outBounds.uMin + outBounds.uMax),
-            0.5 * (outBounds.vMin + outBounds.vMax)
-          );
-          const outCentroid = kernel.surfaceCenterOfMass(f.wrapped);
-          let bestScore = -Infinity;
-          let bestOrigin;
-          for (const inp of inputSigs) {
-            const dot = outNormal[0] * inp.normal[0] + outNormal[1] * inp.normal[1] + outNormal[2] * inp.normal[2];
-            if (dot < 0.707) continue;
-            const dx = outCentroid[0] - inp.centroid[0];
-            const dy = outCentroid[1] - inp.centroid[1];
-            const dz = outCentroid[2] - inp.centroid[2];
-            const distSq = dx * dx + dy * dy + dz * dz;
-            if (distSq > 100) continue;
-            const score = dot - distSq / 100;
-            if (score > bestScore) {
-              bestScore = score;
-              bestOrigin = inp.origin;
-            }
-          }
-          if (bestOrigin !== void 0) {
-            resultMap.set(hash, bestOrigin);
-          }
-        } catch {
-        }
-      }
-    }
-  }
-  if (resultMap.size > 0) {
-    const cache = getOrCreateCache(result);
-    cache.faceOrigins = resultMap;
-  }
-}
-function getVertices(shape) {
-  const cache = getOrCreateCache(shape);
-  if (cache.vertices) return cache.vertices;
-  const vertices = Array.from(iterTopo(shape.wrapped, "vertex")).map(
-    (e) => castShape(unwrap(downcast(e)))
-  );
-  cache.vertices = vertices;
-  return vertices;
-}
-function* iterEdges(shape) {
-  for (const e of iterTopo(shape.wrapped, "edge")) {
-    yield castShape(unwrap(downcast(e)));
-  }
-}
-function* iterFaces(shape) {
-  for (const f of iterTopo(shape.wrapped, "face")) {
-    yield castShape(unwrap(downcast(f)));
-  }
-}
-function* iterWires(shape) {
-  for (const w of iterTopo(shape.wrapped, "wire")) {
-    yield castShape(unwrap(downcast(w)));
-  }
-}
-function* iterVertices(shape) {
-  for (const v of iterTopo(shape.wrapped, "vertex")) {
-    yield castShape(unwrap(downcast(v)));
-  }
-}
-function getBounds(shape) {
-  const cache = getOrCreateCache(shape);
-  if (cache.bounds) return cache.bounds;
-  const { min, max } = getKernel().boundingBox(shape.wrapped);
-  const bounds = {
-    xMin: min[0],
-    xMax: max[0],
-    yMin: min[1],
-    yMax: max[1],
-    zMin: min[2],
-    zMax: max[2]
-  };
-  cache.bounds = bounds;
-  return bounds;
-}
-function describe(shape) {
-  return {
-    kind: getShapeKind(shape),
-    faceCount: getFaces(shape).length,
-    edgeCount: getEdges(shape).length,
-    wireCount: getWires(shape).length,
-    vertexCount: getVertices(shape).length,
-    valid: getKernel().isValid(shape.wrapped),
-    bounds: getBounds(shape)
-  };
-}
-function vertexPosition(vertex) {
-  return getKernel().vertexPosition(vertex.wrapped);
-}
-export {
-  iterFaces as A,
-  iterVertices as B,
-  iterWires as C,
-  resize as D,
-  setShapeOrigin as E,
-  getFaces as a,
-  propagateOriginsFromEvolution as b,
-  getWires as c,
-  getEdges as d,
-  getVertices as e,
-  getHashCode as f,
-  getFaceOrigins as g,
-  getBounds as h,
-  isSameShape as i,
-  applyMatrix as j,
-  clone as k,
-  describe as l,
-  isEmpty as m,
-  mirror as n,
-  simplify as o,
-  propagateOriginsByHash as p,
-  transformCopy as q,
-  rotate as r,
-  scale as s,
-  toBREP as t,
-  translate as u,
-  vertexPosition as v,
-  composeTransforms as w,
-  invalidateShapeCache as x,
-  isEqualShape as y,
-  iterEdges as z
-};

package/dist/utils/round2.d.ts

@@ -1,3 +0,0 @@
-/** Round a number to 2 decimal places. */
-export default function round2(v: number): number;
-//# sourceMappingURL=round2.d.ts.map

package/dist/utils/round2.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"round2.d.ts","sourceRoot":"","sources":["../../src/utils/round2.ts"],"names":[],"mappings":"AAAA,0CAA0C;AAC1C,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEhD"}

package/dist/utils/round5.d.ts

@@ -1,3 +0,0 @@
-/** Round a number to 5 decimal places. */
-export default function round5(v: number): number;
-//# sourceMappingURL=round5.d.ts.map

package/dist/utils/round5.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"round5.d.ts","sourceRoot":"","sources":["../../src/utils/round5.ts"],"names":[],"mappings":"AAAA,0CAA0C;AAC1C,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEhD"}