improved node setup for bitbybit

Author: matas-bitbybit-dev

examples/node/express-app/bitbybit.ts

@@ -1,23 +1,71 @@
 import { createRequire } from "module";
-import { OCCTService } from "@bitbybit-dev/occt/lib/occ-service.js";
-import { OccHelper } from "@bitbybit-dev/occt/lib/occ-helper.js";
-import { VectorHelperService } from "@bitbybit-dev/occt/lib/api/vector-helper.service.js";
-import { ShapesHelperService } from "@bitbybit-dev/occt/lib/api/shapes-helper.service.js";
-import initOpenCascade from "@bitbybit-dev/occt/bitbybit-dev-occt/index.js";
+
+// Base utilities
+import {
+    MathBitByBit,
+    Logic,
+    Lists,
+    TextBitByBit,
+    Vector,
+    Point,
+    Transforms,
+    Color,
+    GeometryHelper,
+    Line,
+    Polyline,
+} from "@bitbybit-dev/base";
+
+// Core functionality
+import { JSONBitByBit, CSVBitByBit, Verb, ContextBase } from "@bitbybit-dev/core";
+
+// JSCAD for Node.js
+import { Jscad } from "@bitbybit-dev/jscad";
+
+// Manifold for Node.js
+import { ManifoldService } from "@bitbybit-dev/manifold";
+
+// OCCT for Node.js
+import { OCCTService, OccHelper, VectorHelperService, ShapesHelperService } from "@bitbybit-dev/occt";
+import initOpenCascade, { BitbybitOcctModule } from "@bitbybit-dev/occt/bitbybit-dev-occt/index.js";
+
+// Manifold WASM module
+import Module from "manifold-3d";
+
+// JSON path for advanced JSON queries
+import { JSONPath } from "jsonpath-plus";
+
+// NURBS functionality
+import vrb from "verb-nurbs-web";
 
 const require = createRequire(import.meta.url);
 
 export class BitByBitBase {
-    public occt!: OCCTService;
+    // Base utilities
+    public math!: MathBitByBit;
+    public logic!: Logic;
+    public lists!: Lists;
+    public text!: TextBitByBit;
+    public vector!: Vector;
+    public point!: Point;
+    public transforms!: Transforms;
+    public color!: Color;
+    public line!: Line;
+    public polyline!: Polyline;
 
-    constructor() {
-    }
+    // Core functionality
+    public json!: JSONBitByBit;
+    public csv!: CSVBitByBit;
+    public verb!: Verb;
+
+    // Geometry kernels
+    public jscad!: Jscad;
+    public manifold!: ManifoldService;
+    public occt!: OCCTService;
 
     async init() {
-        // For Node.js, we need to specify the path to the WASM file
+        // Initialize OCCT (OpenCascade) with locateFile for Node.js WASM loading
         const wasmPath = require.resolve("@bitbybit-dev/occt/bitbybit-dev-occt/bitbybit-dev-occt.5e93f201.wasm");
-        
-        const occ = await initOpenCascade({
+        const occ = await (initOpenCascade as (options?: { locateFile?: (path: string) => string }) => Promise<BitbybitOcctModule>)({
             locateFile: (path: string) => {
                 if (path.endsWith(".wasm")) {
                     return wasmPath;
@@ -26,6 +74,42 @@ export class BitByBitBase {
             }
         });
 
+        // Initialize JSCAD
+        const jscadModule = await import("@bitbybit-dev/jscad/jscad-generated.js");
+        const jscad = jscadModule.default();
+        this.jscad = new Jscad(jscad);
+
+        // Initialize Manifold
+        const manifoldWasmPath = require.resolve("manifold-3d/manifold.wasm");
+        const wasm = await Module({
+            locateFile: () => manifoldWasmPath,
+        });
+        wasm.setup();
+        this.manifold = new ManifoldService(wasm);
+
+        // Initialize base utilities
+        const geometryHelper = new GeometryHelper();
+        this.math = new MathBitByBit();
+        this.lists = new Lists();
+        this.logic = new Logic();
+        this.color = new Color(this.math);
+        this.vector = new Vector(this.math, geometryHelper);
+        this.transforms = new Transforms(this.vector, this.math);
+        this.point = new Point(geometryHelper, this.transforms, this.vector, this.lists);
+        this.line = new Line(this.vector, this.point, geometryHelper);
+        this.polyline = new Polyline(this.vector, this.point, this.line, geometryHelper);
+        this.text = new TextBitByBit(this.point);
+
+        // Initialize core functionality with context
+        const context = new ContextBase();
+        context.verb = { geom: vrb.geom, core: vrb.core };
+        context.jsonpath = JSONPath;
+
+        this.verb = new Verb(context, geometryHelper, this.math);
+        this.json = new JSONBitByBit(context);
+        this.csv = new CSVBitByBit();
+
+        // Initialize OCCT service
         const vecHelper = new VectorHelperService();
         const shapesHelper = new ShapesHelperService();
         const occHelper = new OccHelper(vecHelper, shapesHelper, occ);

examples/node/express-app/index.ts

@@ -1,34 +1,86 @@
 import express, { Express, Request, Response } from "express";
 import dotenv from "dotenv";
-import { BitByBitBase } from "./bitbybit.js";
+import { BitByBitBase } from "./bitbybit";
+
+dotenv.config();
 
 const bitbybit = new BitByBitBase();
+let initialized = false;
 
 async function run() {
+    console.log("Initializing BitByBit with OCCT, JSCAD, and Manifold kernels...");
     await bitbybit.init();
+    initialized = true;
+    console.log("BitByBit initialized successfully!");
 }
 
 run();
 
-dotenv.config();
-
 const app: Express = express();
-const port = process.env.PORT;
-
+const port = process.env.PORT || 3000;
 
+// Endpoint demonstrating OCCT capabilities
 app.get("/", (req: Request, res: Response) => {
-    if (bitbybit) {
-        const cube = bitbybit.occt?.shapes.solid.createCube({ size: 3, center: [0, 0, 0] });
-        const stepTXT = bitbybit.occt?.io.saveShapeSTEP({
-            shape: cube,
-            fileName: "cube.step",
-            adjustYtoZ: true,
-            tryDownload: false,
-        });
-        res.send(`${stepTXT}`);
-    } else {
-        res.send("OCC not initialised");
+    if (!initialized) {
+        res.send("BitByBit is still initializing...");
+        return;
+    }
+
+    const cube = bitbybit.occt.shapes.solid.createCube({ size: 3, center: [0, 0, 0] });
+    const stepTXT = bitbybit.occt.io.saveShapeSTEP({
+        shape: cube,
+        fileName: "cube.step",
+        adjustYtoZ: true,
+        tryDownload: false,
+    });
+    res.send(`OCCT STEP output:\n${stepTXT}`);
+});
+
+// Endpoint demonstrating math utilities
+app.get("/math", (req: Request, res: Response) => {
+    if (!initialized) {
+        res.send("BitByBit is still initializing...");
+        return;
     }
+
+    const result = {
+        remapValue: bitbybit.math.remap({ number: 0.5, fromLow: 0, fromHigh: 1, toLow: 0, toHigh: 100 }),
+        randomNumber: bitbybit.math.random(),
+    };
+    res.json(result);
+});
+
+// Endpoint demonstrating vector operations
+app.get("/vector", (req: Request, res: Response) => {
+    if (!initialized) {
+        res.send("BitByBit is still initializing...");
+        return;
+    }
+
+    const vec1: [number, number, number] = [1, 2, 3];
+    const vec2: [number, number, number] = [4, 5, 6];
+    const result = {
+        add: bitbybit.vector.add({ first: vec1, second: vec2 }),
+        cross: bitbybit.vector.cross({ first: vec1, second: vec2 }),
+        dot: bitbybit.vector.dot({ first: vec1, second: vec2 }),
+        length: bitbybit.vector.length({ vector: vec1 }),
+    };
+    res.json(result);
+});
+
+// Endpoint demonstrating VERB NURBS
+app.get("/verb", (req: Request, res: Response) => {
+    if (!initialized) {
+        res.send("BitByBit is still initializing...");
+        return;
+    }
+
+    const curve = bitbybit.verb.curve.createBezierCurve({
+        points: [[0, 0, 0], [1, 2, 0], [3, 1, 0], [4, 0, 0]],
+        weights: [1, 1, 1, 1],
+    });
+    const point = bitbybit.verb.curve.pointAtParam({ curve, parameter: 0.5 });
+    res.json({ curveType: "Bezier", pointAtHalf: point });
 });
 
 app.listen(port, () => {