@treasuryspatial/rhino-bridge 0.1.4

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+import * as THREE from "three";
+export type RhinoBridgeOptions = {
+    wasmPath?: string;
+    wasmUrl?: string;
+    rotateToYUp?: boolean;
+    transform?: (object: THREE.Object3D) => void;
+    roleKey?: string;
+    roleKeys?: string[];
+    excludeRoles?: string[];
+    geometryRole?: string;
+    idKey?: string;
+    packetKey?: string;
+    layerKey?: string;
+    materialKey?: string;
+};
+export type LayeredGeometryOptions = {
+    mapLayerToId?: (layerName: string, attributes: any) => string | null;
+    transform?: (object: THREE.Object3D) => void;
+    roleKey?: string;
+    roleKeys?: string[];
+    excludeRoles?: string[];
+    packetKey?: string;
+    layerKey?: string;
+    materialKey?: string;
+};
+export declare function threeGroupFrom3dm(base64: string, options?: RhinoBridgeOptions): Promise<THREE.Group>;
+export type Rhino3dmInspection = {
+    ok: boolean;
+    meshCount: number;
+    brepCount: number;
+    extrusionCount: number;
+    otherCount: number;
+};
+export declare function inspect3dmArrayBuffer(buffer: ArrayBuffer | Uint8Array): Promise<Rhino3dmInspection>;
+export declare function inspect3dmBase64(base64: string): Promise<Rhino3dmInspection>;
+export declare function loadLayeredGeometry(geometry3dm: string, options?: LayeredGeometryOptions): Promise<Record<string, THREE.Group>>;
+export declare function extractBrepsByRole(base64: string, options?: RhinoBridgeOptions): Promise<Record<string, string>>;
+declare function convertGeometryToThree(geometry: any): THREE.Object3D | null;
+export { convertGeometryToThree };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AA0B/B,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,KAAK,IAAI,CAAC;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AA2FF,MAAM,MAAM,sBAAsB,GAAG;IACnC,YAAY,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,KAAK,MAAM,GAAG,IAAI,CAAC;IACrE,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,KAAK,IAAI,CAAC;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAUF,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAqD1G;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,EAAE,EAAE,OAAO,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAsCF,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,WAAW,GAAG,UAAU,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAQzG;AAED,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAGlF;AAED,wBAAsB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAsB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAyErI;AAED,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAgDtH;AAED,iBAAS,sBAAsB,CAAC,QAAQ,EAAE,GAAG,GAAG,KAAK,CAAC,QAAQ,GAAG,IAAI,CAkBpE;AAyGD,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/index.js

@@ -0,0 +1,418 @@
+import * as THREE from "three";
+import rhino3dm from "rhino3dm";
+const DEFAULT_BROWSER_WASM_PATH = "/rhino3dm.wasm";
+const DEFAULT_ROLE_KEY = "b2:role";
+const DEFAULT_GEOMETRY_ROLE = "geometry";
+const DEFAULT_ID_KEY = "b2:id";
+const trimTrailingSlashes = (value) => value.replace(/\/+$/, "");
+const trimLeadingSlashes = (value) => value.replace(/^\/+/, "");
+const resolveBrowserWasmUrl = (path, override) => {
+    const envBase = override?.trim() || process.env.NEXT_PUBLIC_RHINO3DM_WASM_URL?.trim() || process.env.RHINO3DM_WASM_URL?.trim();
+    const normalizedPath = trimLeadingSlashes(path);
+    if (envBase && envBase.length > 0) {
+        if (envBase.endsWith(".wasm"))
+            return envBase;
+        const base = trimTrailingSlashes(envBase);
+        return `${base}/${normalizedPath}`;
+    }
+    return `${DEFAULT_BROWSER_WASM_PATH.replace(/[^/]+$/, "")}${normalizedPath}`;
+};
+let rhinoModulePromise = null;
+async function getRhinoModule(options) {
+    if (!rhinoModulePromise) {
+        if (typeof window === "undefined") {
+            const pathModule = await import("path");
+            const fs = await import("fs");
+            const wasmPath = options?.wasmPath
+                ? pathModule.resolve(process.cwd(), options.wasmPath)
+                : process.env.RHINO3DM_WASM_PATH
+                    ? pathModule.resolve(process.cwd(), process.env.RHINO3DM_WASM_PATH)
+                    : pathModule.resolve(process.cwd(), "public", "rhino3dm.wasm");
+            let wasmBinary = null;
+            try {
+                const buffer = fs.readFileSync(wasmPath);
+                wasmBinary = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+            }
+            catch (error) {
+                console.error("[rhino3dm] Failed to read WASM binary from", wasmPath, error);
+            }
+            rhinoModulePromise = rhino3dm({
+                wasmBinary: wasmBinary ?? undefined,
+                locateFile: (path) => (wasmBinary ? wasmPath : resolveBrowserWasmUrl(path, options?.wasmUrl)),
+            });
+        }
+        else {
+            rhinoModulePromise = rhino3dm({
+                locateFile: (path) => resolveBrowserWasmUrl(path, options?.wasmUrl),
+            });
+        }
+    }
+    return rhinoModulePromise;
+}
+const base64ToUint8Array = (base64) => {
+    const normalized = base64.replace(/\s/g, "");
+    let binary;
+    if (typeof window !== "undefined" && typeof window.atob === "function") {
+        binary = window.atob(normalized);
+    }
+    else if (typeof atob === "function") {
+        binary = atob(normalized);
+    }
+    else {
+        binary = Buffer.from(normalized, "base64").toString("binary");
+    }
+    const length = binary.length;
+    const bytes = new Uint8Array(length);
+    for (let i = 0; i < length; i += 1) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+};
+const uint8ArrayToBase64 = (bytes) => {
+    if (typeof Buffer !== "undefined") {
+        return Buffer.from(bytes).toString("base64");
+    }
+    let binary = "";
+    const chunkSize = 0x8000;
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+        const chunk = bytes.subarray(i, i + chunkSize);
+        binary += String.fromCharCode.apply(null, chunk);
+    }
+    if (typeof window !== "undefined" && typeof window.btoa === "function") {
+        return window.btoa(binary);
+    }
+    if (typeof btoa === "function") {
+        return btoa(binary);
+    }
+    throw new Error("No base64 encoder available in this environment.");
+};
+const getUserString = (attributes, key) => {
+    try {
+        if (attributes && typeof attributes.getUserString === "function") {
+            const value = attributes.getUserString(key);
+            if (value !== null && value !== undefined && `${value}`.length > 0) {
+                return String(value);
+            }
+        }
+    }
+    catch (error) {
+        console.warn("[rhino3dm] Unable to read user string", key, error);
+    }
+    return null;
+};
+const resolveUserString = (attributes, keys) => {
+    for (const key of keys) {
+        const value = getUserString(attributes, key);
+        if (value)
+            return value;
+    }
+    return null;
+};
+export async function threeGroupFrom3dm(base64, options) {
+    const rhino = await getRhinoModule(options);
+    const bytes = base64ToUint8Array(base64);
+    const doc = rhino.File3dm.fromByteArray(bytes);
+    const group = new THREE.Group();
+    if (!doc) {
+        console.error("[rhino3dm] Failed to parse 3DM file from bytes");
+        return group;
+    }
+    const rotation = options?.rotateToYUp === false ? null : new THREE.Matrix4().makeRotationX(-Math.PI / 2);
+    const roleKeys = options?.roleKeys ?? [];
+    const roleKey = options?.roleKey ?? DEFAULT_ROLE_KEY;
+    const roleKeyList = roleKeys.length > 0 ? [roleKey, ...roleKeys] : [roleKey];
+    const excludeRoles = options?.excludeRoles ?? [];
+    const packetKey = options?.packetKey ?? DEFAULT_ID_KEY;
+    const layerKey = options?.layerKey ?? "b2:layer";
+    const materialKey = options?.materialKey ?? "b2:material";
+    const objects = doc.objects();
+    const objectCount = objects.count ?? 0;
+    for (let i = 0; i < objectCount; i += 1) {
+        const obj = objects.get(i);
+        const attributes = typeof obj?.attributes === "function" ? obj.attributes() : null;
+        const role = attributes ? resolveUserString(attributes, roleKeyList) : null;
+        if (role && excludeRoles.includes(role)) {
+            continue;
+        }
+        const geom = obj?.geometry?.();
+        const threeObject = convertGeometryToThree(geom);
+        if (threeObject) {
+            if (rotation) {
+                threeObject.applyMatrix4(rotation);
+            }
+            const packetId = attributes ? getUserString(attributes, packetKey) : null;
+            const layer = attributes ? getUserString(attributes, layerKey) : null;
+            const material = attributes ? getUserString(attributes, materialKey) : null;
+            threeObject.userData = {
+                role: role ?? undefined,
+                packet: packetId ?? undefined,
+                id: packetId ?? undefined,
+                layer: layer ?? undefined,
+                material: material ?? undefined,
+            };
+            options?.transform?.(threeObject);
+            group.add(threeObject);
+        }
+    }
+    return group;
+}
+const countRhinoObjects = (doc) => {
+    const objects = doc?.objects?.();
+    const total = objects?.count ?? 0;
+    let meshCount = 0;
+    let brepCount = 0;
+    let extrusionCount = 0;
+    let otherCount = 0;
+    for (let i = 0; i < total; i += 1) {
+        const obj = objects.get(i);
+        const geom = obj?.geometry?.();
+        const typeName = geom?.constructor?.name ?? "";
+        if (typeName === "Mesh") {
+            meshCount += 1;
+            continue;
+        }
+        if (typeName === "Brep") {
+            brepCount += 1;
+            continue;
+        }
+        if (typeName === "Extrusion") {
+            extrusionCount += 1;
+            continue;
+        }
+        otherCount += 1;
+    }
+    return {
+        ok: true,
+        meshCount,
+        brepCount,
+        extrusionCount,
+        otherCount,
+    };
+};
+export async function inspect3dmArrayBuffer(buffer) {
+    const rhino = await getRhinoModule();
+    const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+    const doc = rhino.File3dm.fromByteArray(bytes);
+    if (!doc) {
+        return { ok: false, meshCount: 0, brepCount: 0, extrusionCount: 0, otherCount: 0 };
+    }
+    return countRhinoObjects(doc);
+}
+export async function inspect3dmBase64(base64) {
+    const bytes = base64ToUint8Array(base64);
+    return inspect3dmArrayBuffer(bytes);
+}
+export async function loadLayeredGeometry(geometry3dm, options) {
+    const rhino = await getRhinoModule();
+    const bytes = base64ToUint8Array(geometry3dm);
+    const doc = rhino.File3dm.fromByteArray(bytes);
+    const groups = {};
+    if (!doc) {
+        console.error("[rhino3dm] Failed to parse 3DM file");
+        return groups;
+    }
+    const layerTable = doc.layers?.();
+    const layerNames = new Map();
+    if (layerTable && typeof layerTable.count === "number") {
+        for (let i = 0; i < layerTable.count; i += 1) {
+            const layer = layerTable.get(i);
+            if (!layer)
+                continue;
+            const index = typeof layer.index === "number" ? layer.index : i;
+            layerNames.set(index, layer.name ?? "");
+        }
+    }
+    const roleKeys = options?.roleKeys ?? [];
+    const roleKey = options?.roleKey ?? DEFAULT_ROLE_KEY;
+    const roleKeyList = roleKeys.length > 0 ? [roleKey, ...roleKeys] : [roleKey];
+    const excludeRoles = options?.excludeRoles ?? [DEFAULT_GEOMETRY_ROLE];
+    const packetKey = options?.packetKey ?? DEFAULT_ID_KEY;
+    const layerKey = options?.layerKey ?? "b2:layer";
+    const materialKey = options?.materialKey ?? "b2:material";
+    const objects = doc.objects();
+    const objectCount = objects.count ?? 0;
+    for (let i = 0; i < objectCount; i += 1) {
+        const obj = objects.get(i);
+        if (!obj)
+            continue;
+        const attributes = typeof obj.attributes === "function" ? obj.attributes() : null;
+        const role = attributes ? resolveUserString(attributes, roleKeyList) : null;
+        if (role && excludeRoles.includes(role)) {
+            continue;
+        }
+        const geom = obj.geometry?.();
+        const threeObject = convertGeometryToThree(geom);
+        if (!threeObject)
+            continue;
+        const packetId = attributes ? getUserString(attributes, packetKey) : null;
+        const layer = attributes ? getUserString(attributes, layerKey) : null;
+        const material = attributes ? getUserString(attributes, materialKey) : null;
+        threeObject.userData = {
+            role: role ?? undefined,
+            packet: packetId ?? undefined,
+            id: packetId ?? undefined,
+            layer: layer ?? undefined,
+            material: material ?? undefined,
+        };
+        options?.transform?.(threeObject);
+        const layerIndex = attributes?.layerIndex ?? attributes?.LayerIndex ?? -1;
+        const layerName = layerNames.get(layerIndex) ?? "";
+        const groupId = options?.mapLayerToId?.(layerName, attributes) ?? layerName;
+        if (!groupId)
+            continue;
+        if (!groups[groupId]) {
+            groups[groupId] = new THREE.Group();
+        }
+        groups[groupId].add(threeObject);
+    }
+    return groups;
+}
+export async function extractBrepsByRole(base64, options) {
+    const rhino = await getRhinoModule(options);
+    const bytes = base64ToUint8Array(base64);
+    const doc = rhino.File3dm.fromByteArray(bytes);
+    const breps = {};
+    if (!doc) {
+        console.error("[rhino3dm] Failed to parse 3DM file for Brep extraction");
+        return breps;
+    }
+    const roleKeys = options?.roleKeys ?? [];
+    const roleKey = options?.roleKey ?? DEFAULT_ROLE_KEY;
+    const roleKeyList = roleKeys.length > 0 ? [roleKey, ...roleKeys] : [roleKey];
+    const geometryRole = options?.geometryRole ?? DEFAULT_GEOMETRY_ROLE;
+    const idKey = options?.idKey ?? DEFAULT_ID_KEY;
+    const objects = doc.objects();
+    const objectCount = objects.count ?? 0;
+    for (let i = 0; i < objectCount; i += 1) {
+        const obj = objects.get(i);
+        if (!obj)
+            continue;
+        const attributes = typeof obj.attributes === "function" ? obj.attributes() : null;
+        const role = attributes ? resolveUserString(attributes, roleKeyList) : null;
+        if (role !== geometryRole)
+            continue;
+        const itemId = attributes ? getUserString(attributes, idKey) : null;
+        if (!itemId)
+            continue;
+        const geom = obj.geometry?.();
+        if (!geom)
+            continue;
+        const typeName = geom.constructor?.name;
+        if (typeName !== "Brep") {
+            continue;
+        }
+        const brepDoc = new rhino.File3dm();
+        const attr = new rhino.ObjectAttributes();
+        brepDoc.objects().add(geom, attr);
+        const brepBytes = brepDoc.toByteArray();
+        if (!brepBytes)
+            continue;
+        breps[itemId] = uint8ArrayToBase64(new Uint8Array(brepBytes));
+    }
+    return breps;
+}
+function convertGeometryToThree(geometry) {
+    if (!geometry) {
+        return null;
+    }
+    const typeName = geometry.constructor?.name;
+    if (typeName === "Mesh") {
+        return meshToThree(geometry);
+    }
+    if (typeName === "Brep" || typeName === "Extrusion") {
+        console.warn("[rhino3dm] Non-meshed geometry received. Ensure server-side meshing before serialization.");
+        return null;
+    }
+    console.warn(`[rhino3dm] Unsupported geometry type: ${typeName}`);
+    return null;
+}
+function meshToThree(mesh) {
+    const vertices = mesh.vertices?.();
+    const faces = mesh.faces?.();
+    if (!vertices || !faces) {
+        console.warn("[rhino3dm] Mesh missing vertices or faces");
+        return null;
+    }
+    const vertexCount = vertices.count ?? 0;
+    const faceCount = faces.count ?? 0;
+    if (vertexCount === 0 || faceCount === 0) {
+        console.warn("[rhino3dm] Mesh received with no vertices or faces; skipping");
+        return null;
+    }
+    const geometry = new THREE.BufferGeometry();
+    const positionArray = new Float32Array(vertexCount * 3);
+    let wroteAllVertices = true;
+    if (typeof vertices.toFloatArray === "function") {
+        const flat = vertices.toFloatArray();
+        if (flat?.length === vertexCount * 3) {
+            positionArray.set(flat);
+        }
+        else {
+            wroteAllVertices = false;
+        }
+    }
+    else {
+        wroteAllVertices = false;
+    }
+    if (!wroteAllVertices) {
+        const writeVertex = (targetIndex, vertex) => {
+            if (!vertex) {
+                return false;
+            }
+            const x = typeof vertex.x === "number" ? vertex.x : typeof vertex[0] === "number" ? vertex[0] : Number.NaN;
+            const y = typeof vertex.y === "number" ? vertex.y : typeof vertex[1] === "number" ? vertex[1] : Number.NaN;
+            const z = typeof vertex.z === "number" ? vertex.z : typeof vertex[2] === "number" ? vertex[2] : Number.NaN;
+            if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) {
+                return false;
+            }
+            positionArray[targetIndex * 3 + 0] = x;
+            positionArray[targetIndex * 3 + 1] = y;
+            positionArray[targetIndex * 3 + 2] = z;
+            return true;
+        };
+        for (let i = 0; i < vertexCount; i += 1) {
+            if (!writeVertex(i, vertices.get(i))) {
+                console.warn("[rhino3dm] Invalid vertex encountered; skipping mesh");
+                return null;
+            }
+        }
+    }
+    else {
+        for (let i = 0; i < positionArray.length; i += 1) {
+            if (!Number.isFinite(positionArray[i])) {
+                console.warn("[rhino3dm] Mesh float array contained non-finite values; skipping mesh");
+                return null;
+            }
+        }
+    }
+    geometry.setAttribute("position", new THREE.BufferAttribute(positionArray, 3));
+    const indexArray = [];
+    for (let i = 0; i < faceCount; i += 1) {
+        const face = faces.get(i);
+        if (!face)
+            continue;
+        const a = face[0];
+        const b = face[1];
+        const c = face[2];
+        const d = face.length > 3 ? face[3] : undefined;
+        if (![a, b, c].every((idx) => Number.isInteger(idx) && idx >= 0 && idx < vertexCount)) {
+            console.warn("[rhino3dm] Face reference out of bounds; skipping mesh");
+            return null;
+        }
+        indexArray.push(a, b, c);
+        if (typeof d === "number" && d >= 0 && d < vertexCount) {
+            indexArray.push(a, c, d);
+        }
+    }
+    if (indexArray.length === 0) {
+        console.warn("[rhino3dm] Mesh produced no triangle indices; skipping");
+        return null;
+    }
+    geometry.setIndex(indexArray);
+    geometry.computeVertexNormals();
+    const meshObject = new THREE.Mesh(geometry, new THREE.MeshStandardMaterial({ color: 0xffffff }));
+    meshObject.castShadow = true;
+    meshObject.receiveShadow = true;
+    return meshObject;
+}
+export { convertGeometryToThree };

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@treasuryspatial/rhino-bridge",
+  "version": "0.1.4",
+  "type": "module",
+  "license": "UNLICENSED",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "rhino3dm": "^8.17.0"
+  },
+  "peerDependencies": {
+    "three": "^0.180.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "three": "^0.180.0"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "typecheck": "tsc -b --pretty false --noEmit"
+  }
+}