brepjs 8.0.0 → 8.0.2

package/dist/query-hMSmOWJP.cjs

@@ -1,395 +0,0 @@
-"use strict";
-const occtBoundary = require("./occtBoundary-du8_ex-p.cjs");
-const shapeTypes = require("./shapeTypes-DKhwEnUM.cjs");
-const vecOps = require("./vecOps-CjRL1jau.cjs");
-const result = require("./result.cjs");
-const cast = require("./cast-DkB0GKmQ.cjs");
-const shapeFns = require("./shapeFns-BvOndshS.cjs");
-const faceFns = require("./faceFns-BwK7FP7N.cjs");
-const measurement = require("./measurement-fxm_pW7x.cjs");
-const curveFns = require("./curveFns-BilyYL_s.cjs");
-const errors = require("./errors-DK1VAdP4.cjs");
-const PRECISION_INTERSECTION = 1e-9;
-const PRECISION_OFFSET = 1e-8;
-const PRECISION_POINT = 1e-6;
-const samePoint = ([x0, y0], [x1, y1], precision = PRECISION_POINT) => {
-  return Math.abs(x0 - x1) <= precision && Math.abs(y0 - y1) <= precision;
-};
-const add2d = ([x0, y0], [x1, y1]) => {
-  return [x0 + x1, y0 + y1];
-};
-const subtract2d = ([x0, y0], [x1, y1]) => {
-  return [x0 - x1, y0 - y1];
-};
-const scalarMultiply2d = ([x0, y0], scalar) => {
-  return [x0 * scalar, y0 * scalar];
-};
-const distance2d = ([x0, y0], [x1, y1] = [0, 0]) => {
-  return Math.sqrt((x0 - x1) ** 2 + (y0 - y1) ** 2);
-};
-const squareDistance2d = ([x0, y0], [x1, y1] = [0, 0]) => {
-  return (x0 - x1) ** 2 + (y0 - y1) ** 2;
-};
-function crossProduct2d([x0, y0], [x1, y1]) {
-  return x0 * y1 - y0 * x1;
-}
-const angle2d = ([x0, y0], [x1, y1] = [0, 0]) => {
-  return Math.atan2(y1 * x0 - y0 * x1, x0 * x1 + y0 * y1);
-};
-const polarAngle2d = ([x0, y0], [x1, y1] = [0, 0]) => {
-  return Math.atan2(y1 - y0, x1 - x0);
-};
-const normalize2d = ([x0, y0]) => {
-  const l = distance2d([x0, y0]);
-  if (l < 1e-12) {
-    result.bug("normalize2d", "Cannot normalize zero-length vector");
-  }
-  return [x0 / l, y0 / l];
-};
-const rotate2d = (point, angle, center = [0, 0]) => {
-  const [px0, py0] = point;
-  const [cx, cy] = center;
-  const px = px0 - cx;
-  const py = py0 - cy;
-  const sinA = Math.sin(angle);
-  const cosA = Math.cos(angle);
-  const xnew = px * cosA - py * sinA;
-  const ynew = px * sinA + py * cosA;
-  return [xnew + cx, ynew + cy];
-};
-const polarToCartesian = (r, theta) => {
-  const x = Math.cos(theta) * r;
-  const y = Math.sin(theta) * r;
-  return [x, y];
-};
-const cartesianToPolar = ([x, y]) => {
-  const r = distance2d([x, y]);
-  const theta = Math.atan2(y, x);
-  return [r, theta];
-};
-function createFinder(topoKind, filters, getNormal) {
-  const withFilter = (pred) => createFinder(topoKind, [...filters, pred]);
-  const shouldKeep = (element) => filters.every((f) => f(element));
-  const extractElements = (shape) => {
-    const result2 = [];
-    for (const raw of cast.iterTopo(shape.wrapped, topoKind)) {
-      const element = shapeTypes.castShape(errors.unwrap(cast.downcast(raw)));
-      if (shouldKeep(element)) {
-        result2.push(element);
-      }
-    }
-    return result2;
-  };
-  const finder = {
-    _filters: filters,
-    _topoKind: topoKind,
-    when: (pred) => withFilter(pred),
-    inList: (elements) => {
-      const hashSet = /* @__PURE__ */ new Map();
-      for (const e of elements) {
-        const h = shapeFns.getHashCode(e);
-        const bucket = hashSet.get(h);
-        if (bucket) bucket.push(e);
-        else hashSet.set(h, [e]);
-      }
-      return withFilter((el) => {
-        const bucket = hashSet.get(shapeFns.getHashCode(el));
-        return !!bucket && bucket.some((e) => shapeFns.isSameShape(e, el));
-      });
-    },
-    not: (builderFn) => {
-      const inner = builderFn(createFinder(topoKind, []));
-      return withFilter((el) => !inner.shouldKeep(el));
-    },
-    either: (fns) => {
-      const builtFinders = fns.map((fn) => fn(createFinder(topoKind, [])));
-      return withFilter((el) => builtFinders.some((f) => f.shouldKeep(el)));
-    },
-    findAll: (shape) => extractElements(shape),
-    findUnique: (shape) => {
-      const elements = extractElements(shape);
-      if (elements.length !== 1) {
-        return errors.err(
-          errors.queryError(
-            "FINDER_NOT_UNIQUE",
-            `Finder expected a unique match but found ${elements.length} element(s)`
-          )
-        );
-      }
-      return errors.ok(elements[0]);
-    },
-    shouldKeep
-  };
-  return finder;
-}
-const DIRECTIONS = {
-  X: [1, 0, 0],
-  Y: [0, 1, 0],
-  Z: [0, 0, 1]
-};
-function resolveDir(dir) {
-  if (typeof dir === "string") return DIRECTIONS[dir] ?? [0, 0, 1];
-  return dir;
-}
-function edgeFinder() {
-  return createEdgeFinder([]);
-}
-function createEdgeFinder(filters) {
-  const base = createFinder("edge", filters);
-  const withFilter = (pred) => createEdgeFinder([...filters, pred]);
-  return {
-    ...base,
-    when: (pred) => createEdgeFinder([...filters, pred]),
-    inList: (elements) => createEdgeFinder([...base.inList(elements)._filters]),
-    not: (fn) => createEdgeFinder([...base.not(fn)._filters]),
-    either: (fns) => createEdgeFinder([
-      ...base.either(fns)._filters
-    ]),
-    inDirection: (dir = "Z", angle = 0) => {
-      const d = vecOps.vecNormalize(resolveDir(dir));
-      return withFilter((edge) => {
-        const oc = occtBoundary.getKernel().oc;
-        const r = shapeTypes.gcWithScope();
-        const adaptor = r(new oc.BRepAdaptor_Curve_2(edge.wrapped));
-        const tmpPnt = r(new oc.gp_Pnt_1());
-        const tmpVec = r(new oc.gp_Vec_1());
-        const mid = (Number(adaptor.FirstParameter()) + Number(adaptor.LastParameter())) / 2;
-        adaptor.D1(mid, tmpPnt, tmpVec);
-        const tangent = vecOps.vecNormalize([tmpVec.X(), tmpVec.Y(), tmpVec.Z()]);
-        const ang = Math.acos(Math.min(1, Math.abs(vecOps.vecDot(tangent, d))));
-        return Math.abs(ang - vecOps.DEG2RAD * angle) < 1e-6;
-      });
-    },
-    ofLength: (length, tolerance = 1e-3) => withFilter((edge) => Math.abs(curveFns.curveLength(edge) - length) < tolerance),
-    ofCurveType: (curveType) => withFilter((edge) => curveFns.getCurveType(edge) === curveType),
-    parallelTo: (dir = "Z") => createEdgeFinder([...filters]).inDirection(dir, 0),
-    atDistance: (distance, point = [0, 0, 0]) => withFilter((edge) => {
-      const oc = occtBoundary.getKernel().oc;
-      const r = shapeTypes.gcWithScope();
-      const pnt = r(occtBoundary.toOcPnt(point));
-      const vtxMaker = r(new oc.BRepBuilderAPI_MakeVertex(pnt));
-      const vtx = vtxMaker.Vertex();
-      const distTool = r(new oc.BRepExtrema_DistShapeShape_1());
-      distTool.LoadS1(vtx);
-      distTool.LoadS2(edge.wrapped);
-      const progress = r(new oc.Message_ProgressRange_1());
-      distTool.Perform(progress);
-      const d = distTool.Value();
-      return Math.abs(d - distance) < 1e-6;
-    })
-  };
-}
-function faceFinder() {
-  return createFaceFinder([]);
-}
-function createFaceFinder(filters) {
-  const base = createFinder("face", filters);
-  const withFilter = (pred) => createFaceFinder([...filters, pred]);
-  return {
-    ...base,
-    when: (pred) => createFaceFinder([...filters, pred]),
-    inList: (elements) => createFaceFinder([...base.inList(elements)._filters]),
-    not: (fn) => createFaceFinder([...base.not(fn)._filters]),
-    either: (fns) => createFaceFinder([
-      ...base.either(fns)._filters
-    ]),
-    inDirection: (dir = "Z", angle = 0) => {
-      const d = vecOps.vecNormalize(resolveDir(dir));
-      return withFilter((face) => {
-        const n = faceFns.normalAt(face);
-        const ang = Math.acos(Math.min(1, Math.abs(vecOps.vecDot(vecOps.vecNormalize(n), d))));
-        return Math.abs(ang - vecOps.DEG2RAD * angle) < 1e-6;
-      });
-    },
-    parallelTo: (dir = "Z") => createFaceFinder([...filters]).inDirection(dir, 0),
-    ofSurfaceType: (surfaceType) => withFilter((face) => errors.unwrap(faceFns.getSurfaceType(face)) === surfaceType),
-    ofArea: (area, tolerance = 1e-3) => withFilter((face) => Math.abs(measurement.measureArea(face) - area) < tolerance),
-    atDistance: (distance, point = [0, 0, 0]) => withFilter((face) => {
-      const oc = occtBoundary.getKernel().oc;
-      const r = shapeTypes.gcWithScope();
-      const pnt = r(occtBoundary.toOcPnt(point));
-      const vtxMaker = r(new oc.BRepBuilderAPI_MakeVertex(pnt));
-      const vtx = vtxMaker.Vertex();
-      const distTool = r(new oc.BRepExtrema_DistShapeShape_1());
-      distTool.LoadS1(vtx);
-      distTool.LoadS2(face.wrapped);
-      const progress = r(new oc.Message_ProgressRange_1());
-      distTool.Perform(progress);
-      const d = distTool.Value();
-      return Math.abs(d - distance) < 1e-6;
-    })
-  };
-}
-function wireFinder() {
-  return createWireFinder([]);
-}
-function createWireFinder(filters) {
-  const base = createFinder("wire", filters);
-  const withFilter = (pred) => createWireFinder([...filters, pred]);
-  return {
-    ...base,
-    when: (pred) => createWireFinder([...filters, pred]),
-    inList: (elements) => createWireFinder([...base.inList(elements)._filters]),
-    not: (fn) => createWireFinder([...base.not(fn)._filters]),
-    either: (fns) => createWireFinder([
-      ...base.either(fns)._filters
-    ]),
-    isClosed: () => withFilter((wire) => curveFns.curveIsClosed(wire)),
-    isOpen: () => withFilter((wire) => !curveFns.curveIsClosed(wire)),
-    ofEdgeCount: (count) => withFilter((wire) => {
-      let edgeCount = 0;
-      for (const _raw of cast.iterTopo(wire.wrapped, "edge")) {
-        edgeCount++;
-      }
-      return edgeCount === count;
-    })
-  };
-}
-function vertexFinder() {
-  return createVertexFinder([]);
-}
-function createVertexFinder(filters) {
-  const base = createFinder("vertex", filters);
-  const withFilter = (pred) => createVertexFinder([...filters, pred]);
-  return {
-    ...base,
-    when: (pred) => createVertexFinder([...filters, pred]),
-    inList: (elements) => createVertexFinder([...base.inList(elements)._filters]),
-    not: (fn) => createVertexFinder([
-      ...base.not(fn)._filters
-    ]),
-    either: (fns) => createVertexFinder([
-      ...base.either(fns)._filters
-    ]),
-    nearestTo: (point) => {
-      const newFilters = [...filters];
-      const finderWithNearestTo = createVertexFinderWithNearest(newFilters, point);
-      return finderWithNearestTo;
-    },
-    atPosition: (point, tolerance = 1e-4) => withFilter((vertex) => {
-      const pos = shapeFns.vertexPosition(vertex);
-      return vecOps.vecDistance(pos, point) < tolerance;
-    }),
-    withinBox: (min, max) => withFilter((vertex) => {
-      const pos = shapeFns.vertexPosition(vertex);
-      return pos[0] >= min[0] - 1e-6 && pos[0] <= max[0] + 1e-6 && pos[1] >= min[1] - 1e-6 && pos[1] <= max[1] + 1e-6 && pos[2] >= min[2] - 1e-6 && pos[2] <= max[2] + 1e-6;
-    }),
-    atDistance: (distance, point = [0, 0, 0], tolerance = 1e-4) => withFilter((vertex) => {
-      const pos = shapeFns.vertexPosition(vertex);
-      return Math.abs(vecOps.vecDistance(pos, point) - distance) < tolerance;
-    })
-  };
-}
-function createVertexFinderWithNearest(filters, nearestPoint) {
-  const baseFinder = createVertexFinder(filters);
-  const findAllNearest = (shape) => {
-    const candidates = baseFinder.findAll(shape);
-    if (candidates.length === 0) return [];
-    let bestIdx = 0;
-    let bestDist = vecOps.vecDistance(shapeFns.vertexPosition(candidates[0]), nearestPoint);
-    for (let i = 1; i < candidates.length; i++) {
-      const d = vecOps.vecDistance(shapeFns.vertexPosition(candidates[i]), nearestPoint);
-      if (d < bestDist) {
-        bestDist = d;
-        bestIdx = i;
-      }
-    }
-    return [candidates[bestIdx]];
-  };
-  const findUniqueNearest = (shape) => {
-    const nearest = findAllNearest(shape);
-    if (nearest.length === 0) {
-      return errors.err(
-        errors.queryError("FINDER_NOT_UNIQUE", "Finder expected a unique match but found 0 element(s)")
-      );
-    }
-    return errors.ok(nearest[0]);
-  };
-  return {
-    ...baseFinder,
-    findAll: findAllNearest,
-    findUnique: findUniqueNearest
-  };
-}
-const PI_2 = 2 * Math.PI;
-const positiveHalfAngle = (angle) => {
-  const limitedAngle = angle % PI_2;
-  const coterminalAngle = limitedAngle < 0 ? limitedAngle + PI_2 : limitedAngle;
-  if (coterminalAngle < Math.PI) return coterminalAngle;
-  if (coterminalAngle === Math.PI) return 0;
-  return Math.abs(coterminalAngle - PI_2);
-};
-function blueprintCorners(blueprint) {
-  return blueprint.curves.map((curve, index) => ({
-    firstCurve: curve,
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    secondCurve: blueprint.curves[(index + 1) % blueprint.curves.length],
-    point: curve.lastPoint
-  }));
-}
-function cornerFinder() {
-  return createCornerFinder([]);
-}
-function createCornerFinder(filters) {
-  const withFilter = (pred) => createCornerFinder([...filters, pred]);
-  const shouldKeep = (corner) => filters.every((f) => f(corner));
-  return {
-    shouldKeep,
-    when: (pred) => withFilter(pred),
-    inList: (points) => withFilter((corner) => points.some((p) => samePoint(p, corner.point))),
-    atDistance: (distance, point = [0, 0]) => withFilter((corner) => Math.abs(distance2d(point, corner.point) - distance) < 1e-9),
-    atPoint: (point) => withFilter((corner) => samePoint(point, corner.point)),
-    inBox: (corner1, corner2) => {
-      const minX = Math.min(corner1[0], corner2[0]);
-      const maxX = Math.max(corner1[0], corner2[0]);
-      const minY = Math.min(corner1[1], corner2[1]);
-      const maxY = Math.max(corner1[1], corner2[1]);
-      return withFilter((corner) => {
-        const [x, y] = corner.point;
-        return x >= minX && x <= maxX && y >= minY && y <= maxY;
-      });
-    },
-    ofAngle: (angle) => withFilter((corner) => {
-      const tgt1 = corner.firstCurve.tangentAt(1);
-      const tgt2 = corner.secondCurve.tangentAt(0);
-      return Math.abs(positiveHalfAngle(angle2d(tgt1, tgt2)) - positiveHalfAngle(vecOps.DEG2RAD * angle)) < 1e-9;
-    }),
-    not: (fn) => {
-      const inner = fn(createCornerFinder([]));
-      return withFilter((corner) => !inner.shouldKeep(corner));
-    },
-    either: (fns) => {
-      const builtFinders = fns.map((fn) => fn(createCornerFinder([])));
-      return withFilter((corner) => builtFinders.some((f) => f.shouldKeep(corner)));
-    },
-    find: (blueprint) => blueprintCorners(blueprint).filter(shouldKeep)
-  };
-}
-function getSingleFace(f, shape) {
-  if (typeof f === "object" && "_topoKind" in f) {
-    return f.findUnique(shape);
-  }
-  if (typeof f !== "function" && shapeTypes.isFace(f)) return errors.ok(f);
-  const fnResult = f(faceFinder());
-  return fnResult.findUnique(shape);
-}
-exports.PRECISION_INTERSECTION = PRECISION_INTERSECTION;
-exports.PRECISION_OFFSET = PRECISION_OFFSET;
-exports.add2d = add2d;
-exports.cartesianToPolar = cartesianToPolar;
-exports.cornerFinder = cornerFinder;
-exports.crossProduct2d = crossProduct2d;
-exports.distance2d = distance2d;
-exports.edgeFinder = edgeFinder;
-exports.faceFinder = faceFinder;
-exports.getSingleFace = getSingleFace;
-exports.normalize2d = normalize2d;
-exports.polarAngle2d = polarAngle2d;
-exports.polarToCartesian = polarToCartesian;
-exports.rotate2d = rotate2d;
-exports.samePoint = samePoint;
-exports.scalarMultiply2d = scalarMultiply2d;
-exports.squareDistance2d = squareDistance2d;
-exports.subtract2d = subtract2d;
-exports.vertexFinder = vertexFinder;
-exports.wireFinder = wireFinder;