@buerli.io/core 0.0.36-beta.0 → 0.1.0

package/build/index.d.ts

@@ -11,8 +11,9 @@ export * from './store/subscribtion/subscribeToDrawing';
  *
  * Please have a look at https://github.com/awv-informatik/buerli/pull/129 for more information.
  */
-import { BuerliState as BS } from './store/states/buerli';
+import { BuerliState as BS, BuerliOptions as BO } from './store/states/buerli';
 export declare type BuerliState = BS;
+export declare type BuerliOptions = BO;
 import { DrawingAPI as DrawingAPI1, DrawingID as DrawingID1, DrawingState as DrawingState1 } from './store/states/drawing';
 export declare type DrawingID = DrawingID1;
 export declare type DrawingState = DrawingState1;

package/build/store/index.d.ts

@@ -1,4 +1,4 @@
-import { BuerliOptions, BuerliState } from './states/buerli';
+import { BuerliOptions } from './states/buerli';
 import { DrawingID, DrawingState } from './states/drawing';
 import { Message, MessageID } from './states/message';
 import { PluginID, PluginState } from './states/plugin';
@@ -7,10 +7,10 @@ declare function getDrawing(id: DrawingID): DrawingState;
  * @returns PluginState or undefined if either drawing or plugin don't exist
  */
 declare function getPlugin(drawingId: DrawingID, pluginId: PluginID): PluginState;
-declare function init(sel?: Partial<BuerliOptions> | ((state: BuerliState) => Partial<BuerliOptions>)): void;
+declare function init(options?: Partial<BuerliOptions>): void;
 declare function showMessage(message: Message): MessageID;
 declare function updateMessage(id: MessageID, message: Message): void;
 export { BuerliMessageScope } from './states/message';
 export { BuerliScope, createGraphicItem } from './states/selection';
-export * from './store';
+export { api } from './store';
 export { getDrawing, getPlugin, init, showMessage, updateMessage };

package/build/store/index.js

@@ -11,8 +11,8 @@ function getPlugin(drawingId, pluginId) {
     const { drawing } = api.getState();
     return (_a = drawing.refs[drawingId]) === null || _a === void 0 ? void 0 : _a.plugin.refs[pluginId];
 }
-function init(sel) {
-    api.getState().api.init(typeof sel === 'function' ? sel(api.getState()) || {} : sel);
+function init(options) {
+    api.getState().api.init(options);
 }
 function showMessage(message) {
     return api.getState().message.api.show(message);
@@ -22,5 +22,5 @@ function updateMessage(id, message) {
 }
 export { BuerliMessageScope } from './states/message';
 export { BuerliScope, createGraphicItem } from './states/selection';
-export * from './store';
+export { api } from './store';
 export { getDrawing, getPlugin, init, showMessage, updateMessage };

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

@@ -1,4 +1,5 @@
 import { GetState, SetState } from 'zustand';
+import { BuerliStoreApi } from '../../store/store';
 import { DrawingID, DrawingState } from './drawing';
 import { GeometryConfig } from './geometry';
 import { MessageState } from './message';
@@ -13,7 +14,6 @@ declare type StateData = {
     };
 } & MessageState;
 export declare type BuerliOptions = {
-    url: string;
     elements: any;
     plugins: Record<string, PluginImpl>;
     globalPlugins: PluginDef[];
@@ -32,8 +32,8 @@ declare type StateApi = ReturnType<typeof generalApi> & ReturnType<typeof drawin
 export declare type BuerliState = Readonly<StateData> & Readonly<{
     api: StateApi;
 }>;
-export declare const createState: (set: SetState<BuerliState>, get: GetState<BuerliState>, api: any) => BuerliState;
-declare const generalApi: (set: SetState<BuerliState>, get: GetState<BuerliState>) => {
+export declare const createState: (set: SetState<BuerliState>, get: GetState<BuerliState>, buerliApi: BuerliStoreApi) => BuerliState;
+declare const generalApi: (set: SetState<BuerliState>, get: GetState<BuerliState>, buerliApi: BuerliStoreApi) => {
     /**
      * This api method initializes state. Considering user can accidentally ommit some important like elements,
      * there is a warning disaplying for these cases.
@@ -42,7 +42,7 @@ declare const generalApi: (set: SetState<BuerliState>, get: GetState<BuerliState
      */
     init(options?: Partial<BuerliOptions> | undefined): void;
 };
-declare const drawingManagementApi: (set: SetState<BuerliState>, get: GetState<BuerliState>, api: any) => {
+declare const drawingManagementApi: (set: SetState<BuerliState>, get: GetState<BuerliState>, buerliApi: BuerliStoreApi) => {
     createDrawing(name?: string | undefined): Promise<DrawingState>;
     removeDrawing(id: DrawingID): void;
     setActiveDrawing(id: DrawingID | null): void;

package/build/store/states/buerli.js

@@ -1,8 +1,7 @@
 import { createDrawingState } from './drawing';
 import { getInitialMessageState } from './message';
 const initError = 'Please call the init action before you use the buerli store.';
-export const createState = (set, get, api) => (Object.assign({ initDone: false, options: {
-        url: '',
+export const createState = (set, get, buerliApi) => (Object.assign({ initDone: false, options: {
         elements: {},
         plugins: {},
         globalPlugins: [],
@@ -20,8 +19,8 @@ export const createState = (set, get, api) => (Object.assign({ initDone: false,
         ids: [],
         refs: {},
         active: null,
-    }, api: Object.assign(Object.assign({}, generalApi(set, get)), drawingManagementApi(set, get, api)) }, getInitialMessageState(set, get, api)));
-const generalApi = (set, get) => ({
+    }, api: Object.assign(Object.assign({}, generalApi(set, get, buerliApi)), drawingManagementApi(set, get, buerliApi)) }, getInitialMessageState(set, get, buerliApi)));
+const generalApi = (set, get, buerliApi) => ({
     // TODO: rename init to setOptions and remove initDone if everything is ok
     /**
      * This api method initializes state. Considering user can accidentally ommit some important like elements,
@@ -33,7 +32,7 @@ const generalApi = (set, get) => ({
         set(state => ({ options: Object.assign(Object.assign({}, state.options), options), initDone: true }));
     },
 });
-const drawingManagementApi = (set, get, api) => ({
+const drawingManagementApi = (set, get, buerliApi) => ({
     async createDrawing(name) {
         const { initDone, drawing } = get();
         if (!initDone)
@@ -43,7 +42,7 @@ const drawingManagementApi = (set, get, api) => ({
             return {
                 drawing: Object.assign(Object.assign({}, state.drawing), { refs: Object.assign(Object.assign({}, state.drawing.refs), { [drawingState.id]: Object.assign(Object.assign({}, state.drawing.refs[drawingState.id]), newState) }) }),
             };
-        }), () => get().drawing.refs[drawingState.id], api, drawing.ids.length, name);
+        }), () => get().drawing.refs[drawingState.id], buerliApi, drawing.ids.length, name);
         set(state => ({
             drawing: Object.assign(Object.assign({}, state.drawing), { refs: Object.assign(Object.assign({}, state.drawing.refs), { [drawingState.id]: drawingState }), ids: [...state.drawing.ids, drawingState.id], active: drawingState.id }),
         }));

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

@@ -0,0 +1,26 @@
+import { GetState, SetState } from 'zustand';
+import { BuerliStoreApi } from '../../store/store';
+import { DrawingState } from './drawing';
+export declare type States = {
+    current: number;
+    stack: string[];
+    captionMap: Record<string, {
+        stateName: string;
+        caption: string;
+    }>;
+};
+export declare type CadData = {
+    states: States;
+};
+export declare type CadApi = ReturnType<typeof cadApi>;
+export declare const cadData: () => CadData;
+export declare const cadApi: (set: SetState<DrawingState>, get: GetState<DrawingState>, buerliApi: BuerliStoreApi) => {
+    setStates: (current: number, stack: string[], captionMap: Record<string, {
+        stateName: string;
+        caption: string;
+    }>) => void;
+    setCaptionMap: (captionMap: Record<string, {
+        stateName: string;
+        caption: string;
+    }>) => void;
+};

package/build/store/states/cad.js

@@ -0,0 +1,13 @@
+////////////////////////////////////////////////////
+// DATA
+////////////////////////////////////////////////////
+export const cadData = () => ({
+    states: { current: 0, stack: [], captionMap: {} },
+});
+////////////////////////////////////////////////////
+// API
+////////////////////////////////////////////////////
+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 }) }) })),
+});

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

@@ -1,4 +1,5 @@
 import { GetState, SetState } from 'zustand';
+import { BuerliStoreApi } from '../../store/store';
 import { DrawingState } from './drawing';
 declare type Controls = {
     isInteracting: boolean;
@@ -9,7 +10,7 @@ export declare type CanvasData = {
 };
 export declare type CanvasApi = ReturnType<typeof canvasApi>;
 export declare const canvasData: () => CanvasData;
-export declare const canvasApi: (set: SetState<DrawingState>, get: GetState<DrawingState>) => {
+export declare const canvasApi: (set: SetState<DrawingState>, get: GetState<DrawingState>, buerliApi: BuerliStoreApi) => {
     setInteraction: (isInteracting: boolean) => void;
     setControlsEnabled: (enabled: boolean) => void;
 };

package/build/store/states/canvas.js

@@ -7,7 +7,7 @@ export const canvasData = () => ({
 ////////////////////////////////////////////////////
 // API
 ////////////////////////////////////////////////////
-export const canvasApi = (set, get) => ({
+export const canvasApi = (set, get, buerliApi) => ({
     setInteraction: (isInteracting) => set(state => ({ canvas: Object.assign(Object.assign({}, state.canvas), { controls: Object.assign(Object.assign({}, state.canvas.controls), { isInteracting }) }) })),
     setControlsEnabled: (enabled) => set(state => ({ canvas: Object.assign(Object.assign({}, state.canvas), { controls: Object.assign(Object.assign({}, state.canvas.controls), { enabled }) }) })),
 });

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

@@ -8,6 +8,8 @@
  * @image /doc/assets/core/drawing.png
  */
 import { GetState, SetState } from 'zustand';
+import { BuerliStoreApi } from '../../store/store';
+import { CadApi, CadData } from './cad';
 import { CanvasApi, CanvasData } from './canvas';
 import { GeometryApi, GeometryData } from './geometry';
 import { GraphicApi, GraphicData } from './graphic';
@@ -22,6 +24,7 @@ export declare type DrawingAPI = {
     geometry: GeometryApi;
     graphic: GraphicApi;
     canvas: CanvasApi;
+    cad: CadApi;
     setCustom: (key: string, value: Record<string, any>) => void;
 };
 declare type StateData = {
@@ -33,10 +36,11 @@ declare type StateData = {
     canvas: CanvasData;
     selection: SelectionData;
     plugin: PluginData;
+    cad: CadData;
     custom: any;
 };
 export declare type DrawingState = Readonly<StateData> & Readonly<{
     api: DrawingAPI;
 }>;
-export declare const createDrawingState: (set: SetState<DrawingState>, get: GetState<DrawingState>, api: any, drawingNumber: number, name?: string) => DrawingState;
+export declare const createDrawingState: (set: SetState<DrawingState>, get: GetState<DrawingState>, buerliApi: BuerliStoreApi, drawingNumber: number, name?: string) => DrawingState;
 export {};

package/build/store/states/drawing.js

@@ -8,6 +8,7 @@
  * @image /doc/assets/core/drawing.png
  */
 import { v4 as uuidv4 } from 'uuid';
+import { cadApi, cadData } from './cad';
 import { canvasApi, canvasData } from './canvas';
 import { geometryApi, geometryData } from './geometry';
 import { graphicApi, graphicData } from './graphic';
@@ -17,7 +18,7 @@ import { structureApi, structureData } from './structure';
 ////////////////////////////////////////////////////
 // DATA
 ////////////////////////////////////////////////////
-export const createDrawingState = (set, get, api, drawingNumber, name) => {
+export const createDrawingState = (set, get, buerliApi, drawingNumber, name) => {
     const drawingId = uuidv4();
     return {
         structure: structureData(),
@@ -26,14 +27,16 @@ export const createDrawingState = (set, get, api, drawingNumber, name) => {
         geometry: geometryData(),
         graphic: graphicData(),
         canvas: canvasData(),
+        cad: cadData(),
         custom: {},
         api: {
-            structure: structureApi(set, get),
-            selection: selectionApi(set, get),
-            plugin: pluginApi(set, get),
-            geometry: geometryApi(set, get),
-            graphic: graphicApi(set, get),
-            canvas: canvasApi(set, get),
+            structure: structureApi(set, get, buerliApi),
+            selection: selectionApi(set, get, buerliApi),
+            plugin: pluginApi(set, get, buerliApi),
+            geometry: geometryApi(set, get, buerliApi),
+            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) }) })));
             },

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

@@ -1,6 +1,7 @@
 import * as THREE from 'three';
 import { GetState, SetState } from 'zustand';
 import { ContainerGeometryT } from '../../geometry/ThreeGeometryCreator';
+import { BuerliStoreApi } from '../../store/store';
 import { GraphicID } from '../../types/IGraphicPackage';
 import { ObjectID } from '../../types/IStructureTree';
 import { DrawingState } from './drawing';
@@ -34,7 +35,7 @@ export declare type GeometryData = {
 };
 export declare type GeometryApi = ReturnType<typeof geometryApi>;
 export declare const geometryData: () => GeometryData;
-export declare const geometryApi: (set: SetState<DrawingState>, get: GetState<DrawingState>) => {
+export declare const geometryApi: (set: SetState<DrawingState>, get: GetState<DrawingState>, buerliApi: BuerliStoreApi) => {
     /**
      * Updates the @see geometry.bounds depending on all products of the model.
      * The update will only happen, if at least one solid of one product is available.

package/build/store/states/geometry.js

@@ -17,7 +17,7 @@ export const geometryData = () => ({
 ////////////////////////////////////////////////////
 // API
 ////////////////////////////////////////////////////
-export const geometryApi = (set, get) => ({
+export const geometryApi = (set, get, buerliApi) => ({
     /**
      * Updates the @see geometry.bounds depending on all products of the model.
      * The update will only happen, if at least one solid of one product is available.

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

@@ -1,12 +1,27 @@
 import { GetState, SetState } from 'zustand';
-import { IGraphicContainer, IGraphicPackage } from '../../types/IGraphicPackage';
+import { BuerliStoreApi } from '../../store/store';
+import { IGraphicContainer, IGraphicElement, IGraphicPackage } from '../../types/IGraphicPackage';
+import { ObjectID } from '../../types/IStructureTree';
 import { DrawingState } from './drawing';
 export declare type GraphicData = {
     containers: Record<number, IGraphicContainer>;
 };
 export declare type GraphicApi = ReturnType<typeof graphicApi>;
 export declare const graphicData: () => GraphicData;
-export declare const graphicApi: (set: SetState<DrawingState>, get: GetState<DrawingState>) => {
+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;
+    } | undefined) => {
+        elem: IGraphicElement;
+        containerId: ObjectID;
+        solidId: ObjectID;
+    }[];
 };

package/build/store/states/graphic.js

@@ -7,7 +7,7 @@ export const graphicData = () => ({
 ////////////////////////////////////////////////////
 // API
 ////////////////////////////////////////////////////
-export const graphicApi = (set, get) => ({
+export const graphicApi = (set, get, buerliApi) => ({
     addPackages: (packages) => {
         // Timing.dump('load', `add graphic packages ${graphic.length} ${graphic[0].containers.length}`)
         let cacheChanged = false;
@@ -79,4 +79,36 @@ export const graphicApi = (set, get) => ({
             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;
+        const contIds = Object.getOwnPropertyNames(containers).map(n => Number(n));
+        for (const contId of contIds) {
+            if ((options === null || options === void 0 ? void 0 : options.containerId) && contId !== options.containerId) {
+                continue;
+            }
+            const cont = containers[contId];
+            const items = [
+                ...((cont === null || cont === void 0 ? void 0 : cont.arcs) || []),
+                ...((cont === null || cont === void 0 ? void 0 : cont.cones) || []),
+                ...((cont === null || cont === void 0 ? void 0 : cont.edges) || []),
+                ...((cont === null || cont === void 0 ? void 0 : cont.lines) || []),
+                ...((cont === null || cont === void 0 ? void 0 : cont.meshes) || []),
+                ...((cont === null || cont === void 0 ? void 0 : cont.vertices) || []),
+            ];
+            for (const elem of items) {
+                if (cb(elem)) {
+                    result.push({ elem, solidId: cont.owner, containerId: cont.id });
+                    if (options === null || options === void 0 ? void 0 : options.onlyOne) {
+                        return result;
+                    }
+                }
+            }
+        }
+        return result;
+    },
 });

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

@@ -1,6 +1,7 @@
 import { GetState, PartialState, SetState } from 'zustand';
 import { ObjectID } from '../../types';
 import { DrawingID, DrawingState } from './drawing';
+import { BuerliStoreApi } from '../../store/store';
 export declare type PluginDescription<InternalState = any> = {
     name: string;
     version: string;
@@ -42,11 +43,11 @@ export declare type PluginData = {
 };
 export declare type PluginApi = ReturnType<typeof pluginApi>;
 export declare const pluginData: () => PluginData;
-export declare const pluginApi: (set: SetState<DrawingState>, get: GetState<DrawingState>) => {
+export declare const pluginApi: (set: SetState<DrawingState>, get: GetState<DrawingState>, buerliApi: BuerliStoreApi) => {
     setActiveFeature: (id: ObjectID | null) => void;
     setVisiblePlugin: (id: PluginID, visible: boolean) => void;
     setActiveGlobal: (id: PluginID, active: boolean) => void;
-    createPlugin: (def: PluginDef, defaultId?: string | number | undefined, drawingId?: string | number | undefined, objectId?: number | undefined) => (deactivate?: boolean) => void;
+    createPlugin: (def: PluginDef, defaultId?: string | number | undefined, drawingId?: DrawingID | undefined, objectId?: number | undefined) => (deactivate?: boolean) => void;
 };
 export declare function isPromisePlugin(def: PluginDef): def is Promise<Plugin>;
 export {};

package/build/store/states/plugin.js

@@ -9,7 +9,7 @@ export const pluginData = () => ({
     },
     visible: [],
 });
-export const pluginApi = (set, get) => ({
+export const pluginApi = (set, get, buerliApi) => ({
     setActiveFeature: (id) => {
         set(state => {
             let plugins = state.plugin.refs;
@@ -71,7 +71,9 @@ export const pluginApi = (set, get) => ({
                         });
                     } });
                 return {
-                    plugin: Object.assign(Object.assign({}, currentState.plugin), { feature: description.global ? currentState.plugin.feature : [...currentState.plugin.feature, id], global: description.global ? [...currentState.plugin.global, id] : currentState.plugin.global, refs: Object.assign(Object.assign({}, currentState.plugin.refs), { [id]: Object.assign(Object.assign({}, currentState.plugin.refs[id]), newPlugin) }) }),
+                    plugin: Object.assign(Object.assign({}, currentState.plugin), { feature: description.global
+                            ? currentState.plugin.feature
+                            : [...currentState.plugin.feature, id], global: description.global ? [...currentState.plugin.global, id] : currentState.plugin.global, refs: Object.assign(Object.assign({}, currentState.plugin.refs), { [id]: Object.assign(Object.assign({}, currentState.plugin.refs[id]), newPlugin) }) }),
                 };
             });
         }

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

@@ -1,4 +1,5 @@
 import { GetState, SetState } from 'zustand';
+import { BuerliStoreApi } from '../../store/store';
 import { GraphicID } from '../../types/IGraphicPackage';
 import { ObjectID } from '../../types/IStructureTree';
 import { GeometryElement, ProductElement } from './../../geometry/ThreeGeometryCreator';
@@ -39,15 +40,15 @@ 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>) => {
+export declare const selectionApi: (set: SetState<DrawingState>, get: GetState<DrawingState>, buerliApi: BuerliStoreApi) => {
     unselectAll(): void;
     unselect(...unselItems: SelectedItem[]): void;
     select(...newItems: SelectedItem[]): void;
-    setHovered(item: SelectedItem | null, selectorId?: string | number | 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?: string | number | undefined) => boolean;
-    isItemSelected: (item: SelectedItem, selectorId?: string | number | undefined) => boolean;
+    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;
 };

package/build/store/states/selection.js

@@ -7,13 +7,13 @@ export const selectionData = () => ({
     refs: {},
     active: null,
 });
-export const selectionApi = (set, get) => ({
+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(drawingId, activeSelector, unselItems);
+            unsubscribeItems(buerliApi, drawingId, activeSelector, unselItems);
             set(state => {
                 const selector = state.selection.refs[activeSelector];
                 return {
@@ -29,7 +29,7 @@ export const selectionApi = (set, get) => ({
             // Remove unselItems from selector's items
             const selector = selection.refs[activeSelectorId];
             const newItems = selector.items.filter(item => unselItems.find(uItem => uItem.id === item.id) === undefined);
-            unsubscribeItems(drawingId, activeSelectorId, unselItems);
+            unsubscribeItems(buerliApi, drawingId, activeSelectorId, unselItems);
             if (selector.customUnSelect) {
                 // Find recently unselected items
                 const diff = selector.items.filter(item1 => {
@@ -88,9 +88,9 @@ export const selectionApi = (set, get) => ({
             }
             else {
                 // subscribe items which will be selected
-                subscribeItems(drawingId, activeSelectorId, result);
+                subscribeItems(buerliApi, drawingId, activeSelectorId, result);
                 // unsubscribe items which will be unselected
-                unsubscribeItems(drawingId, activeSelectorId, unsubItems);
+                unsubscribeItems(buerliApi, drawingId, activeSelectorId, 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 }) }) }),
@@ -138,7 +138,7 @@ export const selectionApi = (set, get) => ({
         return () => {
             if (get && get()) {
                 const drawingId = get().id;
-                unsubscribeItems(drawingId, selectorId);
+                unsubscribeItems(buerliApi, drawingId, selectorId);
                 set(state => {
                     const refs = state.selection.refs;
                     delete refs[selectorId];
@@ -176,8 +176,8 @@ export const selectionApi = (set, get) => ({
         var _a;
         const { selection, id: drawingId } = get();
         const curItems = ((_a = selection.refs[id]) === null || _a === void 0 ? void 0 : _a.items) || [];
-        unsubscribeItems(drawingId, id, curItems);
-        subscribeItems(drawingId, id, items);
+        unsubscribeItems(buerliApi, drawingId, id, curItems);
+        subscribeItems(buerliApi, drawingId, id, items);
         set(state => {
             const selector = state.selection.refs[id];
             return {

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

@@ -1,5 +1,6 @@
 import * as THREE from 'three';
 import { GetState, SetState } from 'zustand';
+import { BuerliStoreApi } from '../../store/store';
 import { GraphicID, IStructureObject, IStructurePatch, IStructureProtocol, IStructureTree, ObjectID } from '../../types';
 import { DrawingState } from './drawing';
 export declare type StructureData = IStructureProtocol & {
@@ -8,7 +9,7 @@ export declare type StructureData = IStructureProtocol & {
 };
 export declare type StructureApi = ReturnType<typeof structureApi>;
 export declare const structureData: () => StructureData;
-export declare const structureApi: (set: SetState<DrawingState>, get: GetState<DrawingState>) => {
+export declare const structureApi: (set: SetState<DrawingState>, get: GetState<DrawingState>, buerliApi: BuerliStoreApi) => {
     get: () => StructureData;
     set: (structure: IStructureProtocol) => void;
     applyPatches: (patches: IStructurePatch[]) => void;

package/build/store/states/structure.js

@@ -11,7 +11,7 @@ export const structureData = () => {
 ////////////////////////////////////////////////////
 // API
 ////////////////////////////////////////////////////
-export const structureApi = (set, get) => ({
+export const structureApi = (set, get, buerliApi) => ({
     get: () => {
         return get().structure;
     },

package/build/store/store.d.ts

@@ -1,3 +1,5 @@
+import { StoreApi } from 'zustand/vanilla';
 import { BuerliState } from './states/buerli';
-declare const api: import("zustand").StoreApi<BuerliState>;
-export { api };
+declare type BuerliStoreApi = StoreApi<BuerliState>;
+declare const api: StoreApi<BuerliState>;
+export { api, BuerliStoreApi };

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

@@ -1,5 +1,6 @@
-import { SelectorID, DrawingID } from '../..';
-import { SelectedItem } from '../states/selection';
+import { DrawingID } from '../../store/states/drawing';
+import { BuerliStoreApi } from '../../store/store';
+import { SelectedItem, SelectorID } from '../states/selection';
 export declare const unsubs: Record<string, () => void>;
-export declare function subscribeItems(drawingId: DrawingID, selectorId: SelectorID, items?: SelectedItem[]): void;
-export declare function unsubscribeItems(drawingId: DrawingID, selectorId: SelectorID, items?: SelectedItem[]): void;
+export declare function subscribeItems(buerliApi: BuerliStoreApi, drawingId: DrawingID, selectorId: SelectorID, items?: SelectedItem[]): void;
+export declare function unsubscribeItems(buerliApi: BuerliStoreApi, drawingId: DrawingID, selectorId: SelectorID, items?: SelectedItem[]): void;

package/build/store/subscribtion/selection.js

@@ -1,32 +1,31 @@
 // This is the solution for cases when object was deleted from tree and we need to remove corresponding selectedItem.
-import { getDrawing } from '../..';
 import { subscribeToDrawing } from './subscribeToDrawing';
 // This object contains unsubscibe function for all existing selections in all drawings
 export const unsubs = {};
 function getId(selectorId, itemId) {
     return `${selectorId}_${itemId}`;
 }
-export function subscribeItems(drawingId, selectorId, items) {
-    const items_ = items || getDrawing(drawingId).selection.refs[selectorId].items;
+export function subscribeItems(buerliApi, drawingId, selectorId, items) {
+    const items_ = items || buerliApi.getState().drawing.refs[drawingId].selection.refs[selectorId].items;
     items_.forEach(item => {
-        subscribeItem(drawingId, selectorId, item);
+        subscribeItem(buerliApi, drawingId, selectorId, item);
     });
 }
-function subscribeItem(drawingId, selectorId, item) {
+function subscribeItem(buerliApi, drawingId, selectorId, item) {
     if (item.removeCondition && !unsubs[getId(selectorId, item.id)]) {
-        const selApi = getDrawing(drawingId).api.selection;
-        unsubs[getId(selectorId, item.id)] = subscribeToDrawing(drawingId, (d) => item.removeCondition && item.removeCondition(d), (removeCond) => {
+        const selApi = buerliApi.getState().drawing.refs[drawingId].api.selection;
+        unsubs[getId(selectorId, item.id)] = subscribeToDrawing(buerliApi, drawingId, (d) => item.removeCondition && item.removeCondition(d), (removeCond) => {
             var _a;
             // Unselect item whose removeCondition got true
             if (removeCond) {
-                const newItems = ((_a = getDrawing(drawingId).selection.refs[selectorId]) === null || _a === void 0 ? void 0 : _a.items) || [];
+                const newItems = ((_a = buerliApi.getState().drawing.refs[drawingId].selection.refs[selectorId]) === null || _a === void 0 ? void 0 : _a.items) || [];
                 selApi.setItems(selectorId, newItems.filter(item_ => item_.id !== item.id));
             }
         });
     }
 }
-export function unsubscribeItems(drawingId, selectorId, items) {
-    const items_ = items || getDrawing(drawingId).selection.refs[selectorId].items;
+export function unsubscribeItems(buerliApi, drawingId, selectorId, items) {
+    const items_ = items || buerliApi.getState().drawing.refs[drawingId].selection.refs[selectorId].items;
     items_.forEach(item => {
         unsubscribeItem(selectorId, item);
     });

package/build/store/subscribtion/subscribeToDrawing.d.ts

@@ -1,2 +1,3 @@
 import { DrawingID, DrawingState } from '../states/drawing';
-export declare function subscribeToDrawing(drawingId: DrawingID, sel: (d: DrawingState) => any, callback: (arg: any) => void): () => void;
+import { BuerliStoreApi } from '../store';
+export declare function subscribeToDrawing(buerliApi: BuerliStoreApi, drawingId: DrawingID, sel: (d: DrawingState) => any, callback: (arg: any) => void): () => void;

package/build/store/subscribtion/subscribeToDrawing.js

@@ -1,5 +1,4 @@
-import { api } from '../store';
-export function subscribeToDrawing(drawingId, sel, callback) {
-    const unsub = api.subscribe(callback, state => state.drawing.refs[drawingId] && sel(state.drawing.refs[drawingId]));
+export function subscribeToDrawing(buerliApi, drawingId, sel, callback) {
+    const unsub = buerliApi.subscribe(callback, state => state.drawing.refs[drawingId] && sel(state.drawing.refs[drawingId]));
     return unsub;
 }

package/build/utils/Math.d.ts

@@ -2,4 +2,5 @@ import * as THREE from 'three';
 export declare const MathUtils: {
     convertToMatrix4: (coordinateSystem: number[][]) => THREE.Matrix4;
     convertToMatrix3: (coordinateSystem: number[][]) => THREE.Matrix3;
+    convertToCoordinateSystem: (matrix: THREE.Matrix4) => number[][];
 };

package/build/utils/Math.js

@@ -8,4 +8,18 @@ export const MathUtils = {
         const [, vx, vy, vz] = coordinateSystem;
         return new THREE.Matrix3().fromArray([...vx, ...vy, ...vz]);
     },
+    convertToCoordinateSystem: function (matrix) {
+        const position = new THREE.Vector3();
+        const xAxis = new THREE.Vector3();
+        const yAxis = new THREE.Vector3();
+        const zAxis = new THREE.Vector3();
+        position.setFromMatrixPosition(matrix);
+        matrix.extractBasis(xAxis, yAxis, zAxis);
+        const coordSys = [];
+        coordSys[0] = [position.x, position.y, position.z];
+        coordSys[1] = [xAxis.x, xAxis.y, xAxis.z];
+        coordSys[2] = [yAxis.x, yAxis.y, yAxis.z];
+        coordSys[3] = [zAxis.x, zAxis.y, zAxis.z];
+        return coordSys;
+    },
 };

package/build/utils/Measure.js

@@ -73,17 +73,11 @@ export const Measure = {
             .toArray()
             .map(n => Math.round(n * 100) / 100)
             .join(', ')} ]`;
-        const dir = (start, end) => end
-            .clone()
-            .sub(start)
-            .normalize();
+        const dir = (start, end) => end.clone().sub(start).normalize();
         const getPointOnCircumference = (center, axis, radius) => {
             const axisNormalized = axis.clone().normalize();
             const helperVec = axisNormalized.x !== 1 ? new THREE.Vector3(1, 0, 0) : new THREE.Vector3(0, 1, 0);
-            const tangent = axisNormalized
-                .clone()
-                .cross(helperVec)
-                .normalize();
+            const tangent = axisNormalized.clone().cross(helperVec).normalize();
             return center.clone().addScaledVector(tangent, radius);
         };
         for (const element of transformed) {
@@ -464,35 +458,22 @@ export const Measure = {
         return Math.round(value * factor) / factor;
     },
     areParallel(vec1, vec2) {
-        const val = Math.abs(vec1
-            .clone()
-            .cross(vec2)
-            .length());
+        const val = Math.abs(vec1.clone().cross(vec2).length());
         return val < tolerance;
     },
     arePerpendicular(vec1, vec2) {
-        const val = Math.abs(vec1
-            .clone()
-            .normalize()
-            .dot(vec2.clone().normalize()));
+        const val = Math.abs(vec1.clone().normalize().dot(vec2.clone().normalize()));
         return val < tolerance;
     },
     getPointLineMPoints(pointsPos, startPos, endPos) {
         const p1 = pointsPos.clone();
         const lineDir = endPos.clone().sub(startPos);
-        const p2 = pointsPos
-            .clone()
-            .sub(startPos)
-            .projectOnVector(lineDir)
-            .add(startPos);
+        const p2 = pointsPos.clone().sub(startPos).projectOnVector(lineDir).add(startPos);
         return [p1, p2];
     },
     getPointPlaneMPoints(pointPos, pointOnPlane, normal) {
         const p1 = pointPos.clone();
-        const offsetV = pointPos
-            .clone()
-            .sub(pointOnPlane)
-            .projectOnVector(normal);
+        const offsetV = pointPos.clone().sub(pointOnPlane).projectOnVector(normal);
         const p2 = pointPos.clone().sub(offsetV);
         return [p1, p2];
     },
@@ -538,14 +519,8 @@ export const Measure = {
     },
     getPlanePlaneMDirs(normal1, normal2) {
         if (!Measure.areParallel(normal1, normal2)) {
-            const tangent1 = normal1
-                .clone()
-                .projectOnPlane(normal2)
-                .normalize();
-            const tangent2 = normal2
-                .clone()
-                .projectOnPlane(normal1)
-                .normalize();
+            const tangent1 = normal1.clone().projectOnPlane(normal2).normalize();
+            const tangent2 = normal2.clone().projectOnPlane(normal1).normalize();
             const angle = tangent1.angleTo(tangent2);
             return angle <= Math.PI / 2 ? [tangent1, tangent2] : [tangent1, tangent2.negate()];
         }

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@buerli.io/core",
-  "version": "0.0.36-beta.0",
+  "version": "0.1.0",
   "description": "buerli state management",
   "author": "AWV Informatik AG <info@awv-informatik.ch>",
+  "license": "ISC",
   "repository": {},
   "main": "build/index.js",
   "module": "build/index.js",
@@ -10,38 +11,17 @@
   "sideEffects": false,
   "scripts": {
     "ver": "npm version",
-    "prepack": "npm run build:dist",
+    "prepack": "npm run clean && npm run build",
     "clean": "rimraf ./build && rimraf ./coverage",
-    "build": "echo Typescript: && tsc --version && tsc && echo DONE",
-    "build:dist": "npm run clean && echo Typescript: && tsc --version && tsc --sourceMap false && echo DONE",
+    "build": "tsc",
+    "build:dev": "tsc --sourceMap true --declarationMap true",
     "lint": "eslint \"./src/**/*.ts?(x)\"",
     "test": "jest",
     "coverage": "npm run clean && npm run build && npm run jestLite -- --coverage",
-    "prettier": "prettier --write \"./{src,tests}/**/*.{js,jsx,ts,tsx,json}\""
-  },
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged"
-    }
-  },
-  "prettier": {
-    "semi": false,
-    "arrowParens": "avoid",
-    "trailingComma": "all",
-    "singleQuote": true,
-    "jsxBracketSameLine": true,
-    "tabWidth": 2,
-    "printWidth": 120
+    "prettify": "prettier --write \"./{src,tests}/**/*.{js,jsx,ts,tsx,json}\""
   },
-  "lint-staged": {
-    "*.{js,jsx,ts,tsx,json,md}": [
-      "prettier --write",
-      "git add"
-    ]
-  },
-  "license": "ISC",
   "devDependencies": {
-    "@types/three": "^0.130.1",
+    "@types/three": "^0.137",
     "@babel/preset-env": "^7.10.4",
     "@babel/preset-typescript": "^7.10.4",
     "babel-jest": "^26.1.0",
@@ -49,8 +29,7 @@
     "babel-plugin-transform-class-properties": "^6.24.1",
     "jest": "^26.1.0",
     "rimraf": "^2.6.3",
-    "three": "^0.131.3",
-    "typescript": "4.1.2"
+    "three": "^0.138"
   },
   "dependencies": {
     "jsonpatch": "^3.0.1",
@@ -58,6 +37,6 @@
     "zustand": "^3.5.7"
   },
   "peerDependencies": {
-    "three": ">=0.128"
+    "three": ">=0.138"
   }
 }