@buerli.io/core 0.1.0 → 0.2.0-beta.1

package/build/geometry/ThreeGeometryCreator.d.ts

@@ -12,7 +12,10 @@ export declare class ThreeGeometryCreator {
         container: {
             id: number;
             ownerId: number;
+            type: GraphicType.NONE | GraphicType.BREP | GraphicType.POLYBREP | GraphicType.CURVEARRAY;
         };
+        operationId: any;
+        rawGraphic: IGraphicElement | null;
     };
     createGeometry(container: IGraphicContainer, color?: number[]): ContainerGeometryT;
     createSurface(mesh: IGraphicMesh, container: IGraphicContainer, color?: number[]): {
@@ -22,7 +25,10 @@ export declare class ThreeGeometryCreator {
         container: {
             id: number;
             ownerId: number;
+            type: GraphicType.NONE | GraphicType.BREP | GraphicType.POLYBREP | GraphicType.CURVEARRAY;
         };
+        operationId: any;
+        rawGraphic: IGraphicElement | null;
         isValid: boolean;
         geometry: THREE.BufferGeometry;
         graphicId: number;
@@ -36,7 +42,10 @@ export declare class ThreeGeometryCreator {
         container: {
             id: number;
             ownerId: number;
+            type: GraphicType.NONE | GraphicType.BREP | GraphicType.POLYBREP | GraphicType.CURVEARRAY;
         };
+        operationId: any;
+        rawGraphic: IGraphicElement | null;
         isValid: boolean;
         geometry: THREE.BufferGeometry;
         graphicId: number;
@@ -53,7 +62,10 @@ export declare class ThreeGeometryCreator {
         container: {
             id: number;
             ownerId: number;
+            type: GraphicType.NONE | GraphicType.BREP | GraphicType.POLYBREP | GraphicType.CURVEARRAY;
         };
+        operationId: any;
+        rawGraphic: IGraphicElement | null;
         isValid: boolean;
         geometry: THREE.BufferGeometry;
         graphicId: number;
@@ -71,7 +83,10 @@ export declare class ThreeGeometryCreator {
         container: {
             id: number;
             ownerId: number;
+            type: GraphicType.NONE | GraphicType.BREP | GraphicType.POLYBREP | GraphicType.CURVEARRAY;
         };
+        operationId: any;
+        rawGraphic: IGraphicElement | null;
         isValid: boolean;
         geometry: THREE.BufferGeometry;
         graphicId: number;
@@ -90,7 +105,10 @@ export declare class ThreeGeometryCreator {
         container: {
             id: number;
             ownerId: number;
+            type: GraphicType.NONE | GraphicType.BREP | GraphicType.POLYBREP | GraphicType.CURVEARRAY;
         };
+        operationId: any;
+        rawGraphic: IGraphicElement | null;
         isValid: boolean;
         geometry: THREE.BufferGeometry;
         graphicId: number;
@@ -105,7 +123,10 @@ export declare class ThreeGeometryCreator {
         container: {
             id: number;
             ownerId: number;
+            type: GraphicType.NONE | GraphicType.BREP | GraphicType.POLYBREP | GraphicType.CURVEARRAY;
         };
+        operationId: any;
+        rawGraphic: IGraphicElement | null;
         isValid: boolean;
         geometry: THREE.BufferGeometry;
         graphicId: number;
@@ -120,7 +141,10 @@ export declare class ThreeGeometryCreator {
         container: {
             id: number;
             ownerId: number;
+            type: GraphicType.NONE | GraphicType.BREP | GraphicType.POLYBREP | GraphicType.CURVEARRAY;
         };
+        operationId: any;
+        rawGraphic: IGraphicElement | null;
         geometry: THREE.BufferGeometry;
         graphicId: number;
         type: GraphicType;
@@ -134,7 +158,10 @@ export declare class ThreeGeometryCreator {
         container: {
             id: number;
             ownerId: number;
+            type: GraphicType.NONE | GraphicType.BREP | GraphicType.POLYBREP | GraphicType.CURVEARRAY;
         };
+        operationId: any;
+        rawGraphic: IGraphicElement | null;
         geometry: THREE.BufferGeometry;
         graphicId: number;
         type: GraphicType;
@@ -150,7 +177,10 @@ export declare class ThreeGeometryCreator {
         container: {
             id: number;
             ownerId: number;
+            type: GraphicType.NONE | GraphicType.BREP | GraphicType.POLYBREP | GraphicType.CURVEARRAY;
         };
+        operationId: any;
+        rawGraphic: IGraphicElement | null;
         geometry: THREE.BufferGeometry;
         graphicId: number;
         type: GraphicType;
@@ -168,7 +198,10 @@ export declare class ThreeGeometryCreator {
         container: {
             id: number;
             ownerId: number;
+            type: GraphicType.NONE | GraphicType.BREP | GraphicType.POLYBREP | GraphicType.CURVEARRAY;
         };
+        operationId: any;
+        rawGraphic: IGraphicElement | null;
         key: string;
         graphicId: number;
         type: GraphicType;
@@ -196,6 +229,7 @@ declare type PointKey = string;
 declare type PointType = 'start' | 'end' | 'center';
 export declare type ContainerGeometryT = {
     graphicId: GraphicID;
+    type: GraphicType;
     map: Record<GraphicID, GeometryElement>;
     meshes: MeshGeometry[];
     lines: LineGeometry[];

package/build/geometry/ThreeGeometryCreator.js

@@ -1,5 +1,20 @@
 import * as THREE from 'three';
-import { GraphicType, } from './../types';
+import { ContainerType, GraphicType, } from './../types';
+const convertType = (contType) => {
+    let type = GraphicType.NONE;
+    switch (contType) {
+        case ContainerType.BREP:
+            type = GraphicType.BREP;
+            break;
+        case ContainerType.CURVEARRAY:
+            type = GraphicType.CURVEARRAY;
+            break;
+        case ContainerType.POLYBREP:
+            type = GraphicType.POLYBREP;
+            break;
+    }
+    return type;
+};
 /**
  * Creates THREE geometry based on the data within a @see IGraphicContainer.
  */
@@ -8,6 +23,7 @@ export class ThreeGeometryCreator {
         this.coordHeightTolerance = 0.01;
     }
     getMetadata(geometry, container, color = [0, 0, 0], opacity = 0) {
+        var _a;
         const contProps = container.properties; // container has always properties
         const geomProps = geometry ? geometry.properties : {};
         let col = container.properties.material.color || color;
@@ -18,11 +34,18 @@ export class ThreeGeometryCreator {
         }
         const rgbColor = new THREE.Color(col[0] / 255, col[1] / 255, col[2] / 255);
         const layer = geomProps && geomProps.layer ? geomProps.layer : contProps.layer;
-        return { color: rgbColor, opacity: opa, layer, container: { id: container.id, ownerId: container.owner } };
+        return {
+            color: rgbColor,
+            opacity: opa,
+            layer,
+            container: { id: container.id, ownerId: container.owner, type: convertType(container.type) },
+            operationId: (_a = geometry === null || geometry === void 0 ? void 0 : geometry.properties) === null || _a === void 0 ? void 0 : _a.operationId,
+            rawGraphic: geometry,
+        };
     }
     createGeometry(container, color = [0, 0, 0]) {
-        const graphicId = container.id;
-        const { properties } = container;
+        const { id: graphicId, properties, type: contType } = container;
+        const type = convertType(contType);
         const box = { min: new THREE.Vector3(...properties.min), max: new THREE.Vector3(...properties.max) };
         const meshes = [];
         const lines = [];
@@ -66,6 +89,7 @@ export class ThreeGeometryCreator {
         }
         const points = Object.values(pointMap);
         return Object.assign({ graphicId,
+            type,
             map,
             meshes,
             lines,
@@ -135,7 +159,10 @@ export class ThreeGeometryCreator {
     }
     createLine(line, container, points, color = [0, 0, 0]) {
         const graphicId = line.id;
-        const type = GraphicType.LINE;
+        let type = GraphicType.LINE;
+        if (container.type === ContainerType.CURVEARRAY) {
+            type = GraphicType.CURVELINE;
+        }
         const pts = line.points;
         const [startId, endId] = line.pointIds;
         const start = new THREE.Vector3(pts[0], pts[1], pts[2]);
@@ -144,13 +171,15 @@ export class ThreeGeometryCreator {
         this.insertPoint(container, `${endId}|point`, endId, end.clone(), line.id, 'end', points);
         const geometry = new THREE.BufferGeometry().setFromPoints([start.clone(), end.clone()]);
         return Object.assign(Object.assign({ geometry,
-            graphicId,
-            type }, this.getMetadata(line, container, color)), { start: start.clone(), end: end.clone() });
+            graphicId, type: type }, this.getMetadata(line, container, color)), { start: start.clone(), end: end.clone() });
     }
     createEdge(edge, container, points, color = [0, 0, 0]) {
         const threePts = [];
         const graphicId = edge.id;
-        const type = GraphicType.EDGE;
+        let type = GraphicType.EDGE;
+        if (container.type === ContainerType.CURVEARRAY) {
+            type = GraphicType.CURVESPLINE;
+        }
         const pts = edge.points;
         for (let i = 0, length = pts.length / 3; i < length; i++) {
             threePts.push(new THREE.Vector3(pts[i * 3], pts[i * 3 + 1], pts[i * 3 + 2]));
@@ -172,12 +201,14 @@ export class ThreeGeometryCreator {
         this.insertPoint(container, `${endId}|point`, endId, end, edge.id, 'end', points);
         const geometry = new THREE.BufferGeometry().setFromPoints(threePts);
         return Object.assign(Object.assign({ geometry,
-            graphicId,
-            type }, this.getMetadata(edge, container, color)), { start: start.clone(), end: end.clone() });
+            graphicId, type: type }, this.getMetadata(edge, container, color)), { start: start.clone(), end: end.clone() });
     }
     createArc(arc, container, points, color = [0, 0, 0]) {
         const graphicId = arc.id;
-        const type = arc.isCircle ? GraphicType.CIRCLE : GraphicType.ARC;
+        let type = arc.isCircle ? GraphicType.CIRCLE : GraphicType.ARC;
+        if (container.type === ContainerType.CURVEARRAY) {
+            type = arc.isCircle ? GraphicType.CURVECIRCLE : GraphicType.CURVEARC;
+        }
         // take half of coordHeightTolerance used for faces, as classcad does it in the tessellation process
         const coordHeight = this.coordHeightTolerance / 2;
         const radius = arc.radius;
@@ -218,12 +249,11 @@ export class ThreeGeometryCreator {
         this.insertPoint(container, `${endId}|point`, endId, end, arc.id, 'end', points);
         const geometry = new THREE.BufferGeometry().setFromPoints(threePts);
         return Object.assign(Object.assign({ geometry,
-            graphicId,
-            type }, this.getMetadata(arc, container, color)), { normal: normal.clone(), center: center.clone(), radius: arc.radius, angle: arc.angle });
+            graphicId, type: type }, this.getMetadata(arc, container, color)), { normal: normal.clone(), center: center.clone(), radius: arc.radius, angle: arc.angle });
     }
     createPoint(container, key, graphicId, position, ownerId, type) {
         return Object.assign(Object.assign({ key,
-            graphicId, type: GraphicType.POINT }, this.getMetadata(null, container)), { position: position.clone(), geometry: position.clone(), owners: [{ ownerId, type }] });
+            graphicId, type: (container.type === ContainerType.CURVEARRAY ? GraphicType.CURVEPOINT : GraphicType.POINT) }, this.getMetadata(null, container)), { position: position.clone(), geometry: position.clone(), owners: [{ ownerId, type }] });
     }
     insertPoint(container, key, graphicId, position, ownerId, type, points) {
         const existingPoint = points[key];
@@ -241,6 +271,7 @@ export class ThreeGeometryCreator {
 export const EMPTY_CONTAINER_GEOMETRY = () => {
     return {
         graphicId: Number.NaN,
+        type: GraphicType.NONE,
         map: {},
         meshes: [],
         lines: [],
@@ -248,10 +279,12 @@ export const EMPTY_CONTAINER_GEOMETRY = () => {
         arcs: [],
         points: [],
         box: { min: new THREE.Vector3(), max: new THREE.Vector3() },
-        container: { id: NaN, ownerId: NaN },
+        container: { id: Number.NaN, ownerId: Number.NaN, type: GraphicType.NONE },
         color: new THREE.Color(),
         opacity: 1.0,
         layer: null,
+        operationId: Number.NaN,
+        rawGraphic: null,
     };
 };
 export const isEqualGeometry = (a, b) => {

package/build/store/states/cad.d.ts

@@ -1,7 +1,7 @@
 import { GetState, SetState } from 'zustand';
 import { BuerliStoreApi } from '../../store/store';
 import { DrawingState } from './drawing';
-export declare type States = {
+declare type States = {
     current: number;
     stack: string[];
     captionMap: Record<string, {
@@ -9,8 +9,16 @@ export declare type States = {
         caption: string;
     }>;
 };
+declare type Pending = {
+    id: string;
+    name: string;
+    stamp: number;
+    args?: any;
+};
 export declare type CadData = {
+    connected: boolean;
     states: States;
+    pending: Pending[];
 };
 export declare type CadApi = ReturnType<typeof cadApi>;
 export declare const cadData: () => CadData;
@@ -23,4 +31,10 @@ export declare const cadApi: (set: SetState<DrawingState>, get: GetState<Drawing
         stateName: string;
         caption: string;
     }>) => void;
+    addPending: (name: string, options?: {
+        args?: any;
+    } | undefined) => string;
+    removePending: (id: string) => void;
+    setConnected: (connected: boolean) => void;
 };
+export {};

package/build/store/states/cad.js

@@ -1,8 +1,11 @@
+import { v4 } from 'uuid';
 ////////////////////////////////////////////////////
 // DATA
 ////////////////////////////////////////////////////
 export const cadData = () => ({
+    connected: false,
     states: { current: 0, stack: [], captionMap: {} },
+    pending: [],
 });
 ////////////////////////////////////////////////////
 // API
@@ -10,4 +13,18 @@ export const cadData = () => ({
 export const cadApi = (set, get, buerliApi) => ({
     setStates: (current, stack, captionMap) => set(state => ({ cad: Object.assign(Object.assign({}, state.cad), { states: Object.assign(Object.assign({}, state.cad.states), { current, stack, captionMap }) }) })),
     setCaptionMap: (captionMap) => set(state => ({ cad: Object.assign(Object.assign({}, state.cad), { states: Object.assign(Object.assign({}, state.cad.states), { captionMap }) }) })),
+    addPending: (name, options) => {
+        const id = v4();
+        set(state => ({
+            cad: Object.assign(Object.assign({}, state.cad), { pending: [...state.cad.pending, Object.assign(Object.assign({}, options), { id, name, stamp: Date.now() })] }),
+        }));
+        return id;
+    },
+    removePending: (id) => {
+        const newPending = get().cad.pending.filter(p => p.id !== id);
+        set(state => ({ cad: Object.assign(Object.assign({}, state.cad), { pending: newPending }) }));
+    },
+    setConnected: (connected) => {
+        return set(state => ({ cad: Object.assign(Object.assign({}, state.cad), { connected }) }));
+    },
 });

package/build/store/states/drawing.d.ts

@@ -25,7 +25,6 @@ export declare type DrawingAPI = {
     graphic: GraphicApi;
     canvas: CanvasApi;
     cad: CadApi;
-    setCustom: (key: string, value: Record<string, any>) => void;
 };
 declare type StateData = {
     id: DrawingID;
@@ -37,7 +36,6 @@ declare type StateData = {
     selection: SelectionData;
     plugin: PluginData;
     cad: CadData;
-    custom: any;
 };
 export declare type DrawingState = Readonly<StateData> & Readonly<{
     api: DrawingAPI;

package/build/store/states/drawing.js

@@ -28,7 +28,6 @@ export const createDrawingState = (set, get, buerliApi, drawingNumber, name) =>
         graphic: graphicData(),
         canvas: canvasData(),
         cad: cadData(),
-        custom: {},
         api: {
             structure: structureApi(set, get, buerliApi),
             selection: selectionApi(set, get, buerliApi),
@@ -37,9 +36,6 @@ export const createDrawingState = (set, get, buerliApi, drawingNumber, name) =>
             graphic: graphicApi(set, get, buerliApi),
             canvas: canvasApi(set, get, buerliApi),
             cad: cadApi(set, get, buerliApi),
-            setCustom: (key, value) => {
-                set(state => (Object.assign(Object.assign({}, state), { custom: Object.assign(Object.assign({}, state.custom), { [key]: Object.assign(Object.assign({}, state.custom[key]), value) }) })));
-            },
         },
         id: drawingId,
         name: name || `Drawing #${drawingNumber}`,

package/build/store/states/geometry.d.ts

@@ -1,6 +1,6 @@
 import * as THREE from 'three';
 import { GetState, SetState } from 'zustand';
-import { ContainerGeometryT } from '../../geometry/ThreeGeometryCreator';
+import { ContainerGeometryT, GeometryElement } from '../../geometry/ThreeGeometryCreator';
 import { BuerliStoreApi } from '../../store/store';
 import { GraphicID } from '../../types/IGraphicPackage';
 import { ObjectID } from '../../types/IStructureTree';
@@ -45,5 +45,10 @@ export declare const geometryApi: (set: SetState<DrawingState>, get: GetState<Dr
     setColor: (containerId: GraphicID, r: number, g: number, b: number) => void;
     setOpacity: (containerId: GraphicID, opacity: number) => void;
     setConfig: (objId: ObjectID | GraphicID, config: Partial<GeometryConfig> | null) => void;
+    findDecorated: () => GeometryElement[];
+    filter: (cb: (elem: GeometryElement) => boolean, options?: {
+        onlyOne?: boolean | undefined;
+        containerId?: number | undefined;
+    } | undefined) => GeometryElement[];
 };
 export {};

package/build/store/states/geometry.js

@@ -83,4 +83,29 @@ export const geometryApi = (set, get, buerliApi) => ({
             return { geometry: Object.assign(Object.assign({}, state.geometry), { config: Object.assign(Object.assign({}, state.geometry.config), { product: productConfigs }) }) };
         });
     },
+    findDecorated: () => {
+        const { geometry: api } = get().api;
+        return api.filter(elem => { var _a, _b, _c, _d, _e; return Boolean((_b = (_a = elem.rawGraphic) === null || _a === void 0 ? void 0 : _a.properties) === null || _b === void 0 ? void 0 : _b.label) || Boolean((_e = (_d = (_c = elem.rawGraphic) === null || _c === void 0 ? void 0 : _c.properties) === null || _d === void 0 ? void 0 : _d.material) === null || _e === void 0 ? void 0 : _e.color); });
+    },
+    filter: (cb, options) => {
+        const result = [];
+        const { cache } = get().geometry;
+        const contIds = Object.getOwnPropertyNames(cache).map(n => Number(n));
+        for (const contId of contIds) {
+            if ((options === null || options === void 0 ? void 0 : options.containerId) && contId !== options.containerId) {
+                continue;
+            }
+            const ids = Object.getOwnPropertyNames(cache[contId].map).map(id => Number(id));
+            for (const id of ids) {
+                const elem = cache[contId].map[id];
+                if (cb(elem)) {
+                    result.push(elem);
+                    if (options === null || options === void 0 ? void 0 : options.onlyOne) {
+                        return result;
+                    }
+                }
+            }
+        }
+        return result;
+    },
 });

package/build/store/states/graphic.d.ts

@@ -11,11 +11,6 @@ export declare const graphicData: () => GraphicData;
 export declare const graphicApi: (set: SetState<DrawingState>, get: GetState<DrawingState>, buerliApi: BuerliStoreApi) => {
     addPackages: (packages: IGraphicPackage[]) => void;
     cleanupGraphicRecords: () => void;
-    findDecorated: () => {
-        elem: IGraphicElement;
-        containerId: ObjectID;
-        solidId: ObjectID;
-    }[];
     filter: (cb: (elem: IGraphicElement) => boolean, options?: {
         onlyOne?: boolean | undefined;
         containerId?: number | undefined;

package/build/store/states/graphic.js

@@ -79,10 +79,6 @@ export const graphicApi = (set, get, buerliApi) => ({
             set({ geometry: Object.assign(Object.assign({}, geometry), { cache: usedGeometry, stamp: Date.now() }) });
         }
     },
-    findDecorated: () => {
-        const { graphic: api } = get().api;
-        return api.filter(elem => { var _a, _b, _c; return Boolean((_a = elem.properties) === null || _a === void 0 ? void 0 : _a.label) || Boolean((_c = (_b = elem.properties) === null || _b === void 0 ? void 0 : _b.material) === null || _c === void 0 ? void 0 : _c.color); });
-    },
     filter: (cb, options) => {
         const result = [];
         const { containers } = get().graphic;

package/build/store/states/selection.d.ts

@@ -41,15 +41,22 @@ export declare type SelectionData = {
 export declare type SelectionApi = ReturnType<typeof selectionApi>;
 export declare const selectionData: () => SelectionData;
 export declare const selectionApi: (set: SetState<DrawingState>, get: GetState<DrawingState>, buerliApi: BuerliStoreApi) => {
-    unselectAll(): void;
-    unselect(...unselItems: SelectedItem[]): void;
-    select(...newItems: SelectedItem[]): void;
+    unselectAll(selectorId?: SelectorID | undefined): void;
+    unselect(items: SelectedItem | SelectedItem[], selectorId?: SelectorID | undefined): void;
+    select(items: SelectedItem | SelectedItem[], selectorId?: SelectorID | undefined): void;
     setHovered(item: SelectedItem | null, selectorId?: SelectorID | undefined): void;
     activateSelector(selectorId: SelectorID | null): void;
     createSelector(selectorId: SelectorID, filter: SelectionFilter, activate?: boolean, initialItems?: SelectedItem[], maxLen?: number, customSelect?: CustomSelect | undefined, customUnSelect?: CustomSelect | undefined): () => void;
     areItemsSelected: (items: SelectedItem[], selectorId?: SelectorID | undefined) => boolean;
     isItemSelected: (item: SelectedItem, selectorId?: SelectorID | undefined) => boolean;
     setItems(id: SelectorID, items: SelectedItem[]): void;
-    getGraphicItem: (productId: ObjectID, containerId: GraphicID, graphicId?: number | undefined) => SelectedItem | null;
+    selectGraphic: (selectorId: SelectorID, items: {
+        productId: ObjectID;
+        containerId: GraphicID;
+        graphicId?: GraphicID;
+    }[], options?: {
+        unselectExisting?: boolean | undefined;
+    } | undefined) => void;
+    getGraphicItem: (productId: ObjectID, containerId: GraphicID, graphicId?: number | undefined) => SelectedItem<ProductElement> | null;
 };
 export declare const createGraphicItem: (productId: ObjectID, el: GeometryElement) => SelectedItem<ProductElement>;

package/build/store/states/selection.js

@@ -8,56 +8,58 @@ export const selectionData = () => ({
     active: null,
 });
 export const selectionApi = (set, get, buerliApi) => ({
-    unselectAll() {
-        const drawingId = get().id;
-        const activeSelector = get().selection.active;
-        if (activeSelector) {
-            const unselItems = get().selection.refs[activeSelector].items;
-            unsubscribeItems(buerliApi, drawingId, activeSelector, unselItems);
+    unselectAll(selectorId) {
+        const { selection, id: drawingId } = get();
+        const selId = (selectorId || selection.active);
+        if (selId) {
+            const unselItems = selection.refs[selId].items;
+            unsubscribeItems(buerliApi, drawingId, selId, unselItems);
             set(state => {
-                const selector = state.selection.refs[activeSelector];
+                const selector = state.selection.refs[selId];
                 return {
-                    selection: Object.assign(Object.assign({}, state.selection), { refs: Object.assign(Object.assign({}, state.selection.refs), { [activeSelector]: Object.assign(Object.assign({}, selector), { items: [] }) }) }),
+                    selection: Object.assign(Object.assign({}, state.selection), { refs: Object.assign(Object.assign({}, state.selection.refs), { [selId]: Object.assign(Object.assign({}, selector), { items: [] }) }) }),
                 };
             });
         }
     },
-    unselect(...unselItems) {
+    unselect(items, selectorId) {
         const { selection, id: drawingId } = get();
-        const activeSelectorId = selection.active;
-        if (activeSelectorId) {
+        const selId = (selectorId || selection.active);
+        if (selId) {
+            const unselItems = Array.isArray(items) ? items : [items];
             // Remove unselItems from selector's items
-            const selector = selection.refs[activeSelectorId];
+            const selector = selection.refs[selId];
             const newItems = selector.items.filter(item => unselItems.find(uItem => uItem.id === item.id) === undefined);
-            unsubscribeItems(buerliApi, drawingId, activeSelectorId, unselItems);
+            unsubscribeItems(buerliApi, drawingId, selId, unselItems);
             if (selector.customUnSelect) {
                 // Find recently unselected items
                 const diff = selector.items.filter(item1 => {
                     return newItems.find(item2 => item2.id === item1.id) === undefined;
                 });
-                selector.customUnSelect(activeSelectorId, newItems, diff);
+                selector.customUnSelect(selId, newItems, diff);
             }
             else {
                 set(state => {
                     return {
-                        selection: Object.assign(Object.assign({}, state.selection), { refs: Object.assign(Object.assign({}, state.selection.refs), { [activeSelectorId]: Object.assign(Object.assign({}, state.selection.refs[activeSelectorId]), { items: newItems }) }) }),
+                        selection: Object.assign(Object.assign({}, state.selection), { refs: Object.assign(Object.assign({}, state.selection.refs), { [selId]: Object.assign(Object.assign({}, state.selection.refs[selId]), { items: newItems }) }) }),
                     };
                 });
             }
-            this.setHovered(null, activeSelectorId);
+            this.setHovered(null, selId);
         }
     },
-    select(...newItems) {
+    select(items, selectorId) {
         const { selection, api, id: drawingId } = get();
-        const activeSelectorId = selection.active;
-        const { isItemSelected } = api.selection;
-        if (activeSelectorId) {
-            const selector = selection.refs[activeSelectorId];
+        const selId = (selectorId || selection.active);
+        if (selId) {
+            const { isItemSelected } = api.selection;
+            const newItems = Array.isArray(items) ? items : [items];
+            const selector = selection.refs[selId];
             const curItems = selector.items;
             // Remove duplicates
             let filteredItems = newItems.filter((item1, idx) => newItems.findIndex(item2 => item2.id === item1.id) === idx);
             // Remove already selected items and duplicates
-            filteredItems = filteredItems.filter(item => !isItemSelected(item, activeSelectorId));
+            filteredItems = filteredItems.filter(item => !isItemSelected(item, selId));
             let unsubItems = [];
             let result = [...curItems, ...filteredItems];
             if (selector.maxLen > 0) {
@@ -84,27 +86,27 @@ export const selectionApi = (set, get, buerliApi) => ({
                 const diff = result.filter(item1 => {
                     return selector.items.find(item2 => item2.id === item1.id) === undefined;
                 });
-                selector.customSelect(activeSelectorId, result, diff);
+                selector.customSelect(selId, result, diff);
             }
             else {
                 // subscribe items which will be selected
-                subscribeItems(buerliApi, drawingId, activeSelectorId, result);
+                subscribeItems(buerliApi, drawingId, selId, result);
                 // unsubscribe items which will be unselected
-                unsubscribeItems(buerliApi, drawingId, activeSelectorId, unsubItems);
+                unsubscribeItems(buerliApi, drawingId, selId, unsubItems);
                 set(state => {
                     return {
-                        selection: Object.assign(Object.assign({}, state.selection), { refs: Object.assign(Object.assign({}, state.selection.refs), { [activeSelectorId]: Object.assign(Object.assign({}, selector), { items: result }) }) }),
+                        selection: Object.assign(Object.assign({}, state.selection), { refs: Object.assign(Object.assign({}, state.selection.refs), { [selId]: Object.assign(Object.assign({}, selector), { items: result }) }) }),
                     };
                 });
             }
-            this.setHovered(null, activeSelectorId);
+            this.setHovered(null, selId);
         }
     },
     setHovered(item, selectorId) {
         const { selection } = get();
         if (selection.active === null && selectorId === undefined)
             return;
-        const selId = selection.active || selectorId;
+        const selId = (selectorId || selection.active);
         set(state => ({
             selection: Object.assign(Object.assign({}, state.selection), { refs: Object.assign(Object.assign({}, state.selection.refs), { [selId]: Object.assign(Object.assign({}, state.selection.refs[selId]), { hoveredItem: item }) }) }),
         }));
@@ -153,7 +155,7 @@ export const selectionApi = (set, get, buerliApi) => ({
         const { selection } = get();
         if (selection.active === null && selectorId === undefined)
             return false;
-        const selId = selection.active || selectorId;
+        const selId = (selectorId || selection.active);
         const selector = selection.refs[selId];
         let res = true;
         items.forEach(item => {
@@ -168,7 +170,7 @@ export const selectionApi = (set, get, buerliApi) => ({
         const { selection } = get();
         if (selection.active === null && selectorId === undefined)
             return false;
-        const selId = selection.active || selectorId;
+        const selId = (selectorId || selection.active);
         const selector = selection.refs[selId];
         return Boolean(selector.items.find(i => areItemsEqual(i, item)));
     },
@@ -185,17 +187,36 @@ export const selectionApi = (set, get, buerliApi) => ({
             };
         });
     },
+    selectGraphic: (selectorId, items, options) => {
+        const { api } = get();
+        const selItems = items
+            .map(i => api.selection.getGraphicItem(i.productId, i.containerId, i.graphicId))
+            .filter(i => Boolean(i));
+        if (options === null || options === void 0 ? void 0 : options.unselectExisting) {
+            api.selection.setItems(selectorId, selItems);
+        }
+        else {
+            api.selection.select(selItems, selectorId);
+        }
+    },
     getGraphicItem: (productId, containerId, graphicId) => {
         const { cache } = get().geometry;
         const container = cache[containerId];
+        let useContainer = false;
         if (container) {
             if (graphicId === undefined) {
                 const ids = Object.getOwnPropertyNames(container.map);
                 graphicId = ids.length > 0 ? Number(ids[0]) : undefined;
+                useContainer = true;
             }
             if (graphicId !== undefined) {
-                const geomElem = container.map[graphicId];
+                let geomElem = container.map[graphicId];
+                if (!geomElem) {
+                    geomElem = container.points.find(p => p.graphicId === graphicId);
+                }
                 if (geomElem) {
+                    geomElem.graphicId = useContainer ? containerId : geomElem.graphicId;
+                    geomElem.type = useContainer ? container.type : geomElem.type;
                     return createGraphicItem(productId, geomElem);
                 }
             }
@@ -206,11 +227,23 @@ export const selectionApi = (set, get, buerliApi) => ({
 ////////////////////////////////////////////////////
 //#region GLOBAL FUNCTIONS
 const areItemsEqual = (a, b) => a.id === b.id && a.scope === b.scope;
+const getLabel = (type) => {
+    const uppLetters = type.replace(/[a-z]/g, '');
+    if (uppLetters.length >= 2) {
+        return uppLetters[0] + uppLetters[1];
+    }
+    else if (uppLetters.length === 1) {
+        return (type[0] + uppLetters[0]).toUpperCase();
+    }
+    else {
+        return (type[0] + type[1]).toUpperCase();
+    }
+};
 const createGraphicIdent = (productId, graphicId, type) => {
     return {
         id: `${productId}|${graphicId}|${type}`,
         scope: BuerliScope,
-        label: (type[0] + type[1]).toUpperCase(),
+        label: getLabel(type),
     };
 };
 export const createGraphicItem = (productId, el) => {

package/build/store/states/structure.js

@@ -1,3 +1,4 @@
+import fastpatch from 'fast-json-patch';
 import jsonpatch from 'jsonpatch';
 import * as THREE from 'three';
 import { DEFAULT_STRUCTURE_TREE, } from '../../types';
@@ -29,19 +30,50 @@ export const structureApi = (set, get, buerliApi) => ({
     },
     applyPatches: (patches) => {
         const before = get().structure.products.concat(get().structure.visibleContainers);
-        // Timing.dump('load', 'received tree patches')
-        set(state => {
-            let structure = state.structure;
-            try {
-                structure = jsonpatch.apply_patch(state.structure, patches);
+        const applyBlock = (block) => {
+            if (block.length === 0)
+                return;
+            set(state => {
+                let structure = state.structure;
+                try {
+                    // TODO: keep an eye on the patch behaviour in general.
+                    // For large changes 'fast-json-patch' is much more performant than 'jsonpatch'.
+                    // However, for smaller changes 'jsonpatch' is more performant than 'fast-json-patch'.
+                    if (block.length > 100) {
+                        structure = fastpatch.applyPatch(state.structure, block, false, false).newDocument;
+                    }
+                    else {
+                        structure = jsonpatch.apply_patch(state.structure, block);
+                    }
+                }
+                catch (e) {
+                    console.error(e);
+                }
+                // console.info('currentProduct in new patched structure: ', structure.currentProduct)
+                return { structure: Object.assign(Object.assign({}, state.structure), structure) };
+            });
+        };
+        const treePatches = [];
+        const otherPatches = [];
+        for (const patch of patches) {
+            if (patch.path.startsWith('/tree/')) {
+                treePatches.push(patch);
             }
-            catch (e) {
-                console.error(e);
+            else {
+                otherPatches.push(patch);
             }
-            return {
-                structure: Object.assign(Object.assign({}, get().structure), structure),
-            };
-        });
+        }
+        // console.info(JSON.stringify(otherPatches))
+        //////////////////////////////////////////////////////////////////////////////
+        // The following split of the state update helps very much in some cases to
+        // prevent not existing object access in many React hooks.
+        // 1. Perform meta information update as the first step (root, currentProduct, ...)
+        applyBlock(otherPatches);
+        // 2. Perform tree update as a second, separate step
+        applyBlock(treePatches);
+        // TODO: The update behaviour for structure updates in buerli/zustand/react-hooks
+        //       has to be analyzed in more detail based on a very simple example.
+        //////////////////////////////////////////////////////////////////////////////
         const { api } = get();
         api.structure.postProcessStructureUpdate();
         // Update the bounds, but only if products or visible containers changed.

package/build/types/IGraphicPackage.d.ts

@@ -10,6 +10,7 @@ export interface IGraphicPackageProperties {
 export interface IGraphicContainer {
     id: GraphicID;
     owner: ObjectID;
+    type: ContainerType;
     properties: IGraphicContainerProps;
     meshes: IGraphicMesh[];
     lines: IGraphicLine[];
@@ -120,14 +121,31 @@ export declare enum GraphicType {
     SPHERE = "sphere",
     NURBS = "nurbs",
     NURBSSURFACE = "nurbsSurface",
-    LOOP = "loop",
-    SOLID = "solid"
+    NONE = "none",
+    BREP = "brep",
+    POLYBREP = "polyBrep",
+    CURVEARRAY = "curveArray",
+    CURVELINE = "curveLine",
+    CURVESPLINE = "curveSpline",
+    CURVEARC = "curveArc",
+    CURVECIRCLE = "curveCircle",
+    CURVEPOINT = "curvePoint",
+    LOOP = "loop"
+}
+export declare enum ContainerType {
+    NONE = 0,
+    BREP = 1,
+    CURVEARRAY = 2,
+    POLYBREP = 3
 }
 declare type RoA = ReadonlyArray<GraphicType>;
 export declare const AllTypes: RoA;
 export declare const Surfaces: RoA;
 export declare const LineSegments: RoA;
 export declare const Primitives: RoA;
+export declare const CurveSegments: RoA;
+export declare const EntityTypes: RoA;
+export declare const PointTypes: RoA;
 export interface IGraphicMaterial {
     color: number[];
     opacity: number;

package/build/types/IGraphicPackage.js

@@ -1,5 +1,6 @@
 export var GraphicType;
 (function (GraphicType) {
+    // Primitives
     GraphicType["POINT"] = "point";
     GraphicType["LINE"] = "line";
     GraphicType["EDGE"] = "edge";
@@ -11,11 +12,35 @@ export var GraphicType;
     GraphicType["SPHERE"] = "sphere";
     GraphicType["NURBS"] = "nurbs";
     GraphicType["NURBSSURFACE"] = "nurbsSurface";
+    // Entities
+    GraphicType["NONE"] = "none";
+    GraphicType["BREP"] = "brep";
+    GraphicType["POLYBREP"] = "polyBrep";
+    GraphicType["CURVEARRAY"] = "curveArray";
+    // Curve array elements
+    GraphicType["CURVELINE"] = "curveLine";
+    GraphicType["CURVESPLINE"] = "curveSpline";
+    GraphicType["CURVEARC"] = "curveArc";
+    GraphicType["CURVECIRCLE"] = "curveCircle";
+    GraphicType["CURVEPOINT"] = "curvePoint";
+    // Custom type(s) (not defined by server protocol)
     GraphicType["LOOP"] = "loop";
-    GraphicType["SOLID"] = "solid";
 })(GraphicType || (GraphicType = {}));
+export var ContainerType;
+(function (ContainerType) {
+    ContainerType[ContainerType["NONE"] = 0] = "NONE";
+    ContainerType[ContainerType["BREP"] = 1] = "BREP";
+    ContainerType[ContainerType["CURVEARRAY"] = 2] = "CURVEARRAY";
+    ContainerType[ContainerType["POLYBREP"] = 3] = "POLYBREP";
+    // POINTARRAY = 4, // Not used at the moment
+    // GRAPHIC = 5, // Not used at the moment
+    // LIGHTWEIGHTBREP = 6, // Not used at the moment
+})(ContainerType || (ContainerType = {}));
 const G = GraphicType;
 export const AllTypes = Object.keys(G).map(key => G[key]);
 export const Surfaces = [G.PLANE, G.CYLINDER, G.CONE, G.SPHERE, G.NURBS, G.NURBSSURFACE];
 export const LineSegments = [G.LINE, G.EDGE, G.ARC, G.CIRCLE];
 export const Primitives = Surfaces.concat(LineSegments).concat([G.POINT]);
+export const CurveSegments = [G.CURVELINE, G.CURVESPLINE, G.CURVEARC, G.CURVECIRCLE];
+export const EntityTypes = [G.BREP, G.POLYBREP, G.CURVEARRAY];
+export const PointTypes = [G.POINT, G.CURVEPOINT];

package/build/utils/Measure.js

@@ -21,10 +21,12 @@ export const Measure = {
             const newItem = Object.assign({}, item);
             switch (newItem.type) {
                 case GraphicType.POINT:
+                case GraphicType.CURVEPOINT:
                     const point = newItem;
                     point.position = point.position.clone().applyMatrix4(matrix);
                     break;
                 case GraphicType.LINE:
+                case GraphicType.CURVELINE:
                     const line = newItem;
                     line.start = line.start.clone().applyMatrix4(matrix);
                     line.end = line.end.clone().applyMatrix4(matrix);
@@ -48,12 +50,14 @@ export const Measure = {
                     cone.origin = cone.origin.clone().applyMatrix4(matrix);
                     break;
                 case GraphicType.ARC:
+                case GraphicType.CURVEARC:
                     const arc = newItem;
                     arc.normal = arc.normal.clone().applyMatrix3(matrix3);
                     arc.normal.normalize();
                     arc.center = arc.center.clone().applyMatrix4(matrix);
                     break;
                 case GraphicType.CIRCLE:
+                case GraphicType.CURVECIRCLE:
                     const circle = newItem;
                     circle.normal = circle.normal.clone().applyMatrix3(matrix3);
                     circle.normal.normalize();
@@ -83,6 +87,7 @@ export const Measure = {
         for (const element of transformed) {
             switch (element.type) {
                 case GraphicType.POINT:
+                case GraphicType.CURVEPOINT:
                     const point = element;
                     results.push({
                         value: vecToStr(point.position),
@@ -91,6 +96,7 @@ export const Measure = {
                     });
                     break;
                 case GraphicType.LINE:
+                case GraphicType.CURVELINE:
                     const line = element;
                     let absoluteDistance = line.start.distanceTo(line.end);
                     absoluteDistance = Measure.round(absoluteDistance, 3);
@@ -102,6 +108,7 @@ export const Measure = {
                     });
                     break;
                 case GraphicType.EDGE:
+                case GraphicType.CURVESPLINE:
                     const edge = element;
                     results.push({
                         value: vecToStr(edge.start),
@@ -111,6 +118,7 @@ export const Measure = {
                     results.push({ value: vecToStr(edge.end), description: 'Edge end', type: MeasureResultType.POSITION });
                     break;
                 case GraphicType.ARC:
+                case GraphicType.CURVEARC:
                     const arc = element;
                     const arcNEnd = arc.center.clone().addScaledVector(arc.normal.clone().normalize(), 40);
                     const pointOnArc = getPointOnCircumference(arc.center, arc.normal, arc.radius);
@@ -134,6 +142,7 @@ export const Measure = {
                     });
                     break;
                 case GraphicType.CIRCLE:
+                case GraphicType.CURVECIRCLE:
                     const circle = element;
                     const circleNEnd = circle.center.clone().addScaledVector(circle.normal.clone().normalize(), 40);
                     const pointOnCircle = getPointOnCircumference(circle.center, circle.normal, circle.radius);
@@ -273,11 +282,14 @@ export const Measure = {
         let results = [];
         switch (first.type) {
             case GraphicType.POINT:
+            case GraphicType.CURVEPOINT:
                 switch (second.type) {
                     case GraphicType.POINT:
+                    case GraphicType.CURVEPOINT:
                         results = Measure.calculatePointPoint(first, second);
                         break;
                     case GraphicType.LINE:
+                    case GraphicType.CURVELINE:
                         results = Measure.calculatePointLine(first, second);
                         break;
                     case GraphicType.PLANE:
@@ -289,11 +301,14 @@ export const Measure = {
                 }
                 break;
             case GraphicType.LINE:
+            case GraphicType.CURVELINE:
                 switch (second.type) {
                     case GraphicType.POINT:
+                    case GraphicType.CURVEPOINT:
                         results = Measure.calculatePointLine(second, first);
                         break;
                     case GraphicType.LINE:
+                    case GraphicType.CURVELINE:
                         results = Measure.calculateLineLine(first, second);
                         break;
                     case GraphicType.PLANE:
@@ -307,12 +322,15 @@ export const Measure = {
             case GraphicType.PLANE:
                 switch (second.type) {
                     case GraphicType.POINT:
+                    case GraphicType.CURVEPOINT:
                         results = Measure.calculatePointPlane(second, first);
                         break;
                     case GraphicType.LINE:
+                    case GraphicType.CURVELINE:
                         results = Measure.calculateLinePlane(second, first);
                         break;
                     case GraphicType.ARC:
+                    case GraphicType.CURVEARC:
                         results = Measure.calculateArcPlane(second, first);
                         break;
                     case GraphicType.PLANE:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buerli.io/core",
-  "version": "0.1.0",
+  "version": "0.2.0-beta.1",
   "description": "buerli state management",
   "author": "AWV Informatik AG <info@awv-informatik.ch>",
   "license": "ISC",
@@ -32,7 +32,8 @@
     "three": "^0.138"
   },
   "dependencies": {
-    "jsonpatch": "^3.0.1",
+    "fast-json-patch": "^3.1.1",
+    "jsonpatch": "^3.1.0",
     "uuid": "^3.3.2",
     "zustand": "^3.5.7"
   },