Bump JupyterCAD

.pre-commit-config.yaml

@@ -40,6 +40,7 @@ repos:
     rev: v4.0.0-alpha.8
     hooks:
       - id: prettier
+        args: ['--no-error-on-unmatched-pattern']
 
   - repo: https://github.com/pre-commit/mirrors-eslint
     rev: v9.0.0-alpha.0

package.json

@@ -52,8 +52,8 @@
         "watch:labextension": "jupyter labextension watch ."
     },
     "dependencies": {
-        "@jupytercad/base": "^2.0.0-alpha.1",
-        "@jupytercad/schema": "^2.0.0-alpha.1",
+        "@jupytercad/base": "^2.0.0-alpha.5",
+        "@jupytercad/schema": "^2.0.0-alpha.5",
         "@jupyterlab/application": "^4.0.0",
         "@jupyterlab/coreutils": "^6.0.0",
         "@jupyterlab/services": "^7.0.0",

src/command.ts

@@ -3,14 +3,16 @@ import {
   IDict,
   IJCadObject,
   IJupyterCadModel,
-  IJupyterCadTracker
+  IJupyterCadTracker,
+  JCadWorkerSupportedFormat
 } from '@jupytercad/schema';
 import { JupyterFrontEnd } from '@jupyterlab/application';
 import { showErrorMessage } from '@jupyterlab/apputils';
 import { ITranslator } from '@jupyterlab/translation';
 
 import { gridIcon } from './icon';
 import formSchema from './schema.json';
+import { WORKER_ID } from './worker';
 
 export namespace CommandIDs {
   export const mesh = 'jupytercad:salome:mesh';
@@ -33,24 +35,36 @@ export function addCommands(
 namespace Private {
   const meshOperator = {
     title: 'Mesh parameters',
-    shape: 'Post::SalomeMesh',
     default: (model: IJupyterCadModel) => {
       const objects = model.getAllObject();
-      const selected = model.localState?.selected?.value || [];
+      const selected = model.localState?.selected?.value;
+      let objectName = objects[0].name ?? '';
+      if (selected) {
+        for (const key in selected) {
+          if (selected[key].type === 'shape') {
+            objectName = key;
+            break;
+          }
+        }
+      }
       return {
         Name: newName('Mesh', model),
-        Object: selected.length > 0 ? selected[0] : objects[0].name ?? '',
+        Object: objectName,
         NumberOfSegments: 10
       };
     },
     syncData: (model: IJupyterCadModel) => {
       return (props: IDict) => {
         const { Name, ...parameters } = props;
-        const objectModel = {
-          shape: 'Post::SalomeMesh',
+        const objectModel: IJCadObject = {
+          shape: 'Post::SalomeMesh' as any,
           parameters,
           visible: true,
-          name: Name
+          name: Name,
+          shapeMetadata: {
+            shapeFormat: JCadWorkerSupportedFormat.BREP,
+            workerId: WORKER_ID
+          }
         };
         const sharedModel = model.sharedModel;
         if (sharedModel) {
@@ -60,7 +74,7 @@ namespace Private {
             }
 
             if (!sharedModel.objectExists(objectModel.name)) {
-              sharedModel.addObject(objectModel as IJCadObject);
+              sharedModel.addObject(objectModel);
             } else {
               showErrorMessage(
                 'The object already exists',

src/index.ts

@@ -17,10 +17,10 @@ import { ServerConnection } from '@jupyterlab/services';
 import { ITranslator, nullTranslator } from '@jupyterlab/translation';
 
 import { AppClient } from './_client/AppClient';
-import { CommandIDs, addCommands } from './command';
+import { addCommands, CommandIDs } from './command';
 import { API_NAMESPACE, requestAPI } from './handler';
 import formSchema from './schema.json';
-import { SalomeWorker } from './worker';
+import { SalomeWorker, WORKER_ID } from './worker';
 
 /**
  * Initialization data for the jupytercad-salome extension.
@@ -64,7 +64,7 @@ const plugin: JupyterFrontEndPlugin<void> = {
       TOKEN: settings.token
     });
     const worker = new SalomeWorker({ appClient, tracker });
-    workerRegistry.registerWorker('jupytercad-salome:worker', worker);
+    workerRegistry.registerWorker(WORKER_ID, worker);
     schemaRegistry.registerSchema('Post::SalomeMesh', formSchema);
 
     addCommands(app, tracker, translator);

src/worker.ts

@@ -3,17 +3,19 @@ import {
   IJCadObject,
   IJCadWorker,
   IJupyterCadTracker,
+  IPostOperatorInput,
   IPostResult,
-  IWorkerMessageBase,
+  JCadWorkerSupportedFormat,
   MainAction,
   WorkerAction
 } from '@jupytercad/schema';
 import { showErrorMessage } from '@jupyterlab/apputils';
 import { PromiseDelegate } from '@lumino/coreutils';
 import { v4 as uuid } from 'uuid';
 
-import { AppClient, ExecutionRequest, ExecutionResponse } from './_client';
+import { AppClient, ExecutionRequest } from './_client';
 
+export const WORKER_ID = 'jupytercad-salome-worker';
 export class SalomeWorker implements IJCadWorker {
   constructor(options: SalomeWorker.IOptions) {
     this._appClient = options.appClient;
@@ -23,6 +25,7 @@ export class SalomeWorker implements IJCadWorker {
   get ready(): Promise<void> {
     return this._ready.promise;
   }
+  shapeFormat = JCadWorkerSupportedFormat.BREP;
 
   register(options: {
     messageHandler: ((msg: any) => void) | ((msg: any) => Promise<void>);
@@ -41,55 +44,55 @@ export class SalomeWorker implements IJCadWorker {
     this._messageHandlers.delete(id);
   }
 
-  postMessage(msg: IWorkerMessageBase): void {
+  postMessage(msg: {
+    id: string;
+    action: WorkerAction;
+    payload?: IPostOperatorInput;
+  }): void {
     if (msg.action !== WorkerAction.POSTPROCESS) {
       return;
     }
-    if (msg.payload && Object.keys(msg.payload).length > 0) {
-      const promises: Promise<ExecutionResponse>[] = [];
-      const jcObjects: IJCadObject[] = [];
-      for (const key in msg.payload) {
-        const item = msg.payload[key] as {
-          occBrep: string;
-          jcObject: IJCadObject;
-        };
-        const numberOfSegments =
-          item.jcObject?.parameters?.NumberOfSegments ?? 15;
-        const res = this._appClient.execute.generateMesh({
-          requestBody: {
-            sourcePath: this._tracker.currentWidget?.context.path,
-            geometry: item.occBrep,
-            format: ExecutionRequest.format.BREP,
-            numberOfSegments
-          }
-        });
-        promises.push(res);
-        jcObjects.push(item.jcObject);
+
+    if (msg.payload) {
+      const { jcObject, postShape } = msg.payload;
+      if (!postShape) {
+        return;
       }
-      Promise.all(promises).then(allRes => {
+
+      const numberOfSegments = jcObject?.parameters?.NumberOfSegments ?? 15;
+      const p = this._appClient.execute.generateMesh({
+        requestBody: {
+          sourcePath: this._tracker.currentWidget?.context.path,
+          geometry: postShape as string,
+          format: ExecutionRequest.format.BREP,
+          numberOfSegments
+        }
+      });
+
+      p.then(postResponse => {
         const id = msg.id;
         const payload: {
           jcObject: IJCadObject;
           postResult: IPostResult;
         }[] = [];
-        allRes.forEach((postResponse, idx) => {
-          if (postResponse.error) {
-            showErrorMessage('Execution Error', postResponse.error);
-          } else {
-            payload.push({
-              postResult: {
-                format: 'STL',
-                binary: true,
-                value: postResponse.mesh
-              },
-              jcObject: jcObjects[idx]
-            });
+        if (postResponse.error) {
+          showErrorMessage('Execution Error', postResponse.error);
+        } else {
+          payload.push({
+            postResult: {
+              format: 'STL',
+              binary: true,
+              value: postResponse.mesh
+            },
+            jcObject
+          });
+        }
+        if (payload.length > 0) {
+          const handler: (msg: IDisplayPost) => void =
+            this._messageHandlers.get(id);
+          if (handler) {
+            handler({ action: MainAction.DISPLAY_POST, payload });
           }
-        });
-        const handler: (msg: IDisplayPost) => void =
-          this._messageHandlers.get(id);
-        if (handler) {
-          handler({ action: MainAction.DISPLAY_POST, payload });
         }
       });
     }