@buerli.io/core 0.0.35-beta.0 → 0.0.35-beta.4

package/build/esm/store/states/selection.js

@@ -1,269 +0,0 @@
-import { subscribeItems, unsubscribeItems } from '../subscribtion/selection';
-////////////////////////////////////////////////////
-// CONSTANTS
-////////////////////////////////////////////////////
-export const BuerliScope = 'ClassCAD';
-export const selectionData = () => ({
-    refs: {},
-    active: null,
-});
-export const selectionApi = (set, get) => ({
-    unselectAll() {
-        const drawingId = get().id;
-        const activeSelector = get().selection.active;
-        if (activeSelector) {
-            const unselItems = get().selection.refs[activeSelector].items;
-            unsubscribeItems(drawingId, activeSelector, unselItems);
-            set(state => {
-                const selector = state.selection.refs[activeSelector];
-                return {
-                    selection: {
-                        ...state.selection,
-                        refs: { ...state.selection.refs, [activeSelector]: { ...selector, items: [] } },
-                    },
-                };
-            });
-        }
-    },
-    unselect(...unselItems) {
-        const { selection, id: drawingId } = get();
-        const activeSelectorId = selection.active;
-        if (activeSelectorId) {
-            // 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);
-            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);
-            }
-            else {
-                set(state => {
-                    return {
-                        selection: {
-                            ...state.selection,
-                            refs: {
-                                ...state.selection.refs,
-                                [activeSelectorId]: {
-                                    ...state.selection.refs[activeSelectorId],
-                                    items: newItems,
-                                },
-                            },
-                        },
-                    };
-                });
-            }
-            this.setHovered(null, activeSelectorId);
-        }
-    },
-    select(...newItems) {
-        const { selection, api, id: drawingId } = get();
-        const activeSelectorId = selection.active;
-        const { isItemSelected } = api.selection;
-        if (activeSelectorId) {
-            const selector = selection.refs[activeSelectorId];
-            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));
-            let unsubItems = [];
-            let result = [...curItems, ...filteredItems];
-            if (selector.maxLen > 0) {
-                if (filteredItems.length === selector.maxLen) {
-                    result = [...filteredItems];
-                    unsubItems = [...curItems];
-                }
-                else if (filteredItems.length > selector.maxLen) {
-                    const extraItems = filteredItems.length - selector.maxLen;
-                    // If filteredItems has bigger length then selector.maxLen, remove last few items from filteredItems.
-                    result = filteredItems.slice(0, -extraItems);
-                    unsubItems = [...curItems];
-                }
-                else if (filteredItems.length + curItems.length >= selector.maxLen) {
-                    const extraItems = filteredItems.length + curItems.length - selector.maxLen;
-                    const allItems = [...curItems, ...filteredItems];
-                    // If filteredItems.len + curItems.len > selector.maxLen, remove first few items from union of curItems and filteredItems.
-                    result = allItems.slice(extraItems);
-                    unsubItems = allItems.slice(0, extraItems);
-                }
-            }
-            if (selector.customSelect !== undefined) {
-                // Find items which weren't selected before.
-                const diff = result.filter(item1 => {
-                    return selector.items.find(item2 => item2.id === item1.id) === undefined;
-                });
-                selector.customSelect(activeSelectorId, result, diff);
-            }
-            else {
-                // subscribe items which will be selected
-                subscribeItems(drawingId, activeSelectorId, result);
-                // unsubscribe items which will be unselected
-                unsubscribeItems(drawingId, activeSelectorId, unsubItems);
-                set(state => {
-                    return {
-                        selection: {
-                            ...state.selection,
-                            refs: { ...state.selection.refs, [activeSelectorId]: { ...selector, items: result } },
-                        },
-                    };
-                });
-            }
-            this.setHovered(null, activeSelectorId);
-        }
-    },
-    setHovered(item, selectorId) {
-        const { selection } = get();
-        if (selection.active === null && selectorId === undefined)
-            return;
-        const selId = selection.active || selectorId;
-        set(state => ({
-            selection: {
-                ...state.selection,
-                refs: {
-                    ...state.selection.refs,
-                    [selId]: {
-                        ...state.selection.refs[selId],
-                        hoveredItem: item,
-                    },
-                },
-            },
-        }));
-    },
-    activateSelector(selectorId) {
-        set(state => {
-            const refs = state.selection.refs;
-            const curSelectorId = state.selection.active;
-            if (curSelectorId) {
-                // Reset hoveredItem
-                refs[curSelectorId] = {
-                    ...refs[curSelectorId],
-                    hoveredItem: null,
-                };
-            }
-            return {
-                selection: {
-                    ...state.selection,
-                    active: state.selection.active === selectorId ? null : selectorId,
-                    refs: {
-                        ...refs,
-                    },
-                },
-            };
-        });
-    },
-    createSelector(selectorId, filter, activate = false, initialItems = [], maxLen = -1, customSelect, customUnSelect) {
-        if (maxLen > 0 && initialItems.length > maxLen)
-            console.error('Number initialItems should be less or equal to selector.maxLen');
-        set(state => ({
-            selection: {
-                ...state.selection,
-                active: activate ? selectorId : state.selection.active,
-                refs: {
-                    ...state.selection.refs,
-                    [selectorId]: {
-                        items: maxLen > 0 && initialItems.length > maxLen ? [] : initialItems,
-                        hoveredItem: null,
-                        isSelectable: filter,
-                        maxLen,
-                        customSelect,
-                        customUnSelect,
-                    },
-                },
-            },
-        }));
-        return () => {
-            if (get && get()) {
-                const drawingId = get().id;
-                unsubscribeItems(drawingId, selectorId);
-                set(state => {
-                    const refs = state.selection.refs;
-                    delete refs[selectorId];
-                    return {
-                        selection: {
-                            ...state.selection,
-                            active: state.selection.active === selectorId ? null : state.selection.active,
-                            refs,
-                        },
-                    };
-                });
-            }
-        };
-    },
-    areItemsSelected: (items, selectorId) => {
-        const { selection } = get();
-        if (selection.active === null && selectorId === undefined)
-            return false;
-        const selId = selection.active || selectorId;
-        const selector = selection.refs[selId];
-        let res = true;
-        items.forEach(item => {
-            const itemSelected = Boolean(selector.items.find(i => areItemsEqual(i, item)));
-            if (!itemSelected) {
-                res = false;
-            }
-        });
-        return res;
-    },
-    isItemSelected: (item, selectorId) => {
-        const { selection } = get();
-        if (selection.active === null && selectorId === undefined)
-            return false;
-        const selId = selection.active || selectorId;
-        const selector = selection.refs[selId];
-        return Boolean(selector.items.find(i => areItemsEqual(i, item)));
-    },
-    setItems(id, items) {
-        const { selection, id: drawingId } = get();
-        const curItems = selection.refs[id]?.items || [];
-        unsubscribeItems(drawingId, id, curItems);
-        subscribeItems(drawingId, id, items);
-        set(state => {
-            const selector = state.selection.refs[id];
-            return {
-                selection: { ...state.selection, refs: { ...state.selection.refs, [id]: { ...selector, items } } },
-            };
-        });
-    },
-    getGraphicItem: (productId, containerId, graphicId) => {
-        const { cache } = get().geometry;
-        const container = cache[containerId];
-        if (container) {
-            if (graphicId === undefined) {
-                const ids = Object.getOwnPropertyNames(container.map);
-                graphicId = ids.length > 0 ? Number(ids[0]) : undefined;
-            }
-            if (graphicId !== undefined) {
-                const geomElem = container.map[graphicId];
-                if (geomElem) {
-                    return createGraphicItem(productId, geomElem);
-                }
-            }
-        }
-        return null;
-    },
-});
-////////////////////////////////////////////////////
-//#region GLOBAL FUNCTIONS
-const areItemsEqual = (a, b) => a.id === b.id && a.scope === b.scope;
-const createGraphicIdent = (productId, graphicId, type) => {
-    return {
-        id: `${productId}|${graphicId}|${type}`,
-        scope: BuerliScope,
-        label: (type[0] + type[1]).toUpperCase(),
-    };
-};
-export const createGraphicItem = (productId, el) => {
-    return {
-        ...createGraphicIdent(productId, el.graphicId, el.type),
-        data: {
-            ...el,
-            productId,
-        },
-    };
-};
-//#endregion GLOBAL FUNCTIONS
-////////////////////////////////////////////////////

package/build/types/types/index.d.ts

@@ -1,4 +0,0 @@
-export * from './ErrorTypes';
-export * from './IGraphicPackage';
-export * from './IStructurePatch';
-export * from './IStructureTree';