@buerli.io/core 1.1.0 → 2.0.0-beta.20261016085358

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

@@ -0,0 +1,162 @@
+/**
+ * applyPatchImmutable — RFC 6902 (JSON Patch) applied with structural sharing.
+ *
+ * Never mutates the input document. Copies exactly the containers on the path
+ * of each operation (copy-on-write); untouched siblings keep their identity,
+ * so store subscribers with reference-equality selectors only wake where
+ * something actually changed.
+ *
+ * The speed trick: a per-batch `cloned` set tracks containers that are already
+ * fresh copies owned by this batch — those are mutated in place. A batch of
+ * N ops therefore costs one shallow copy per DISTINCT touched container (plus
+ * the walk), not one copy chain per op. No full deep clone, ever.
+ *
+ * This replaces the previous two-library setup (jsonpatch for small blocks,
+ * fast-json-patch with a full deep clone for blocks > 100 ops): it is faster
+ * than either in its own domain AND keeps identities correct, so the 100-op
+ * threshold and its discontinuous identity behavior are gone.
+ *
+ * Supported ops: add, remove, replace, move, copy, test (the full RFC set;
+ * the engine's json::diff emits only add/remove/replace). Throws on invalid
+ * paths/ops — the caller decides how to recover, exactly like the previous
+ * jsonpatch behavior.
+ */
+/** '/a/b~1c/0' → ['a', 'b/c', '0'] with RFC 6901 unescaping (~1 → '/', ~0 → '~'). */
+const parsePointer = (path) => {
+    if (path === '')
+        return [];
+    if (path[0] !== '/')
+        throw new Error(`invalid JSON pointer: ${path}`);
+    return path
+        .slice(1)
+        .split('/')
+        .map(s => s.replace(/~1/g, '/').replace(/~0/g, '~'));
+};
+const toIndex = (seg, arr, allowEnd) => {
+    const idx = seg === '-' ? arr.length : Number(seg);
+    if (!Number.isInteger(idx) || idx < 0 || idx > arr.length - (allowEnd ? 0 : 1)) {
+        throw new Error(`array index out of bounds: ${seg}`);
+    }
+    return idx;
+};
+const deepEqual = (a, b) => {
+    if (a === b)
+        return true;
+    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
+        return false;
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    const ka = Object.keys(a);
+    if (ka.length !== Object.keys(b).length)
+        return false;
+    return ka.every(k => deepEqual(a[k], b[k]));
+};
+const getAtPath = (doc, segs) => {
+    let cur = doc;
+    for (const seg of segs) {
+        if (cur === null || typeof cur !== 'object')
+            throw new Error('path not found');
+        cur = Array.isArray(cur) ? cur[toIndex(seg, cur, false)] : cur[seg];
+        if (cur === undefined)
+            throw new Error('path not found');
+    }
+    return cur;
+};
+/** Portable deep clone for the rare `copy` op (structuredClone needs node >= 17). */
+const deepClone = (v) => typeof structuredClone === 'function' ? structuredClone(v) : JSON.parse(JSON.stringify(v));
+export function applyPatchImmutable(doc, ops) {
+    // Containers created by THIS batch — safe to mutate in place. Keyed by the
+    // copies themselves, so shared history from the input doc is never touched.
+    const cloned = new Set();
+    /** Return a batch-owned version of `container` (copying it if needed). */
+    const own = (container) => {
+        if (cloned.has(container))
+            return container;
+        const copy = (Array.isArray(container) ? container.slice() : Object.assign({}, container));
+        cloned.add(copy);
+        return copy;
+    };
+    let root = doc;
+    const applyOne = (op) => {
+        var _a, _b, _c;
+        const segs = parsePointer(op.path);
+        // Whole-document operations.
+        if (segs.length === 0) {
+            switch (op.op) {
+                case 'replace':
+                case 'add':
+                    root = op.value;
+                    return;
+                case 'test':
+                    if (!deepEqual(root, op.value))
+                        throw new Error('test failed at root');
+                    return;
+                default:
+                    throw new Error(`op "${op.op}" not allowed on document root`);
+            }
+        }
+        // move/copy decompose into get + remove/add. Reusing the moved reference
+        // is safe (it ends up at exactly one location); copy inserts a detached
+        // clone so a later op on one copy can never alias into the other.
+        if (op.op === 'move') {
+            const value = getAtPath(root, parsePointer((_a = op.from) !== null && _a !== void 0 ? _a : ''));
+            applyOne({ op: 'remove', path: (_b = op.from) !== null && _b !== void 0 ? _b : '' });
+            applyOne({ op: 'add', path: op.path, value });
+            return;
+        }
+        if (op.op === 'copy') {
+            applyOne({ op: 'add', path: op.path, value: deepClone(getAtPath(root, parsePointer((_c = op.from) !== null && _c !== void 0 ? _c : ''))) });
+            return;
+        }
+        // Copy-on-write walk: own every container from the root down to the
+        // operation's parent, re-linking each owned copy into its (owned) parent.
+        root = own(root);
+        let parent = root;
+        for (let i = 0; i < segs.length - 1; i++) {
+            const key = Array.isArray(parent) ? toIndex(segs[i], parent, false) : segs[i];
+            const child = parent[key];
+            if (child === null || typeof child !== 'object')
+                throw new Error(`path not found: ${op.path}`);
+            const owned = own(child);
+            if (owned !== child)
+                parent[key] = owned; // parent is owned → safe
+            parent = owned;
+        }
+        const last = segs[segs.length - 1];
+        switch (op.op) {
+            case 'replace':
+                if (Array.isArray(parent))
+                    parent[toIndex(last, parent, false)] = op.value;
+                else if (last in parent)
+                    parent[last] = op.value;
+                else
+                    throw new Error(`replace target missing: ${op.path}`);
+                return;
+            case 'add':
+                if (Array.isArray(parent))
+                    parent.splice(toIndex(last, parent, true), 0, op.value);
+                else
+                    parent[last] = op.value;
+                return;
+            case 'remove':
+                if (Array.isArray(parent))
+                    parent.splice(toIndex(last, parent, false), 1);
+                else if (last in parent)
+                    delete parent[last];
+                else
+                    throw new Error(`remove target missing: ${op.path}`);
+                return;
+            case 'test': {
+                const actual = Array.isArray(parent) ? parent[toIndex(last, parent, false)] : parent[last];
+                if (!deepEqual(actual, op.value))
+                    throw new Error(`test failed: ${op.path}`);
+                return;
+            }
+            default:
+                throw new Error(`unknown op: ${op.op}`);
+        }
+    };
+    for (const op of ops)
+        applyOne(op);
+    return root;
+}

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

@@ -1,8 +1,7 @@
-import fastpatch from 'fast-json-patch';
-import jsonpatch from 'jsonpatch';
 import * as THREE from 'three';
 import { DEFAULT_STRUCTURE_TREE } from '../../types';
 import { MathUtils } from '../../utils/Math';
+import { applyPatchImmutable } from './immutablePatch';
 ////////////////////////////////////////////////////
 // DATA
 ////////////////////////////////////////////////////
@@ -28,28 +27,33 @@ export const structureApi = (set, get, buerliApi) => ({
         // console.log('cleanup')
         api.structure.postProcessStructureUpdate();
     },
+    /**
+     * Applies structure patches to the tree. Returns `false` when a patch block
+     * failed to apply — the tree is then diverged from the server's baseline and
+     * stays diverged (patches are relative), so the caller should recover by
+     * re-fetching the full tree.
+     */
     applyPatches: (patches) => {
         const before = get().structure.products.concat(get().structure.visibleContainers);
+        let ok = true;
         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);
-                    }
+                    // Structural-sharing patch application: only containers on a patched
+                    // path get new identities, untouched subtrees stay reference-equal —
+                    // so identity-sensitive subscribers/effects only react to genuine
+                    // changes. Replaces the former jsonpatch/fast-json-patch split (the
+                    // > 100 ops fast-json-patch path deep-cloned the WHOLE document and
+                    // gave every node a new identity on every large block).
+                    structure = applyPatchImmutable(state.structure, block);
                 }
                 catch (e) {
+                    ok = false;
                     console.error(e);
                 }
-                // console.info('currentProduct in new patched structure: ', structure.currentProduct)
                 return { structure: Object.assign(Object.assign({}, state.structure), structure) };
             });
         };
@@ -81,6 +85,7 @@ export const structureApi = (set, get, buerliApi) => ({
         if (before.sort().join() !== after.sort().join()) {
             api.geometry.updateBounds();
         }
+        return ok;
     },
     filterTree: (tree, filter) => {
         const objs = [];

package/build/esm/store/store.js

@@ -1,3 +1,3 @@
-import vanillaCreate from 'zustand/vanilla';
+import { createStore } from 'zustand/vanilla';
 import { createState } from './states/buerli';
-export const api = vanillaCreate()(createState);
+export const api = createStore()(createState);

package/build/esm/utils/Measure.js

@@ -1,4 +1,3 @@
-/* eslint-disable max-lines */
 import * as THREE from 'three';
 import { GraphicType } from '../re-export';
 import { getDrawing } from './../store';

package/build/types/geometry/ThreeGeometryCreator.d.ts

@@ -15,7 +15,7 @@ export declare class ThreeGeometryCreator {
             type: GraphicType.NONE | GraphicType.BREP | GraphicType.POLYBREP | GraphicType.CURVEARRAY;
         };
         operationId: any;
-        rawGraphic: import("@classcad/api-js/build/types/scg/Scg").ScgGraphicElement | null;
+        rawGraphic: import("@classcad/api-js").ScgGraphicElement | null;
     };
     createGeometry(container: IGraphicContainer, color?: number[]): ContainerGeometryT;
     createSurface(mesh: IGraphicMesh, container: IGraphicContainer, color?: number[]): {
@@ -28,9 +28,9 @@ export declare class ThreeGeometryCreator {
             type: GraphicType.NONE | GraphicType.BREP | GraphicType.POLYBREP | GraphicType.CURVEARRAY;
         };
         operationId: any;
-        rawGraphic: import("@classcad/api-js/build/types/scg/Scg").ScgGraphicElement | null;
+        rawGraphic: import("@classcad/api-js").ScgGraphicElement | null;
         isValid: boolean;
-        geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>;
+        geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
         graphicId: number;
         type: GraphicType;
         loops: number[][];
@@ -45,9 +45,9 @@ export declare class ThreeGeometryCreator {
             type: GraphicType.NONE | GraphicType.BREP | GraphicType.POLYBREP | GraphicType.CURVEARRAY;
         };
         operationId: any;
-        rawGraphic: import("@classcad/api-js/build/types/scg/Scg").ScgGraphicElement | null;
+        rawGraphic: import("@classcad/api-js").ScgGraphicElement | null;
         isValid: boolean;
-        geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>;
+        geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
         graphicId: number;
         type: GraphicType;
         loops: number[][];
@@ -56,7 +56,7 @@ export declare class ThreeGeometryCreator {
         type: GraphicType;
         pointOnPlane: THREE.Vector3;
         normal: THREE.Vector3;
-        graphicId: number;
+        graphicId: GraphicID;
         color: THREE.Color | undefined;
         opacity: number;
         layer: any;
@@ -66,9 +66,9 @@ export declare class ThreeGeometryCreator {
             type: GraphicType.NONE | GraphicType.BREP | GraphicType.POLYBREP | GraphicType.CURVEARRAY;
         };
         operationId: any;
-        rawGraphic: import("@classcad/api-js/build/types/scg/Scg").ScgGraphicElement | null;
+        rawGraphic: import("@classcad/api-js").ScgGraphicElement | null;
         isValid: boolean;
-        geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>;
+        geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
         loops: number[][];
     };
     createCylinder(mesh: IGraphicMesh, meshGeom: MeshGeometry): {
@@ -77,7 +77,7 @@ export declare class ThreeGeometryCreator {
         axis: THREE.Vector3;
         height: number;
         radius: number;
-        graphicId: number;
+        graphicId: GraphicID;
         color: THREE.Color | undefined;
         opacity: number;
         layer: any;
@@ -87,9 +87,9 @@ export declare class ThreeGeometryCreator {
             type: GraphicType.NONE | GraphicType.BREP | GraphicType.POLYBREP | GraphicType.CURVEARRAY;
         };
         operationId: any;
-        rawGraphic: import("@classcad/api-js/build/types/scg/Scg").ScgGraphicElement | null;
+        rawGraphic: import("@classcad/api-js").ScgGraphicElement | null;
         isValid: boolean;
-        geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>;
+        geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
         loops: number[][];
     };
     createCone(mesh: IGraphicMesh, meshGeom: MeshGeometry): {
@@ -99,7 +99,7 @@ export declare class ThreeGeometryCreator {
         height: number;
         radiusBottom: number;
         radiusTop: number;
-        graphicId: number;
+        graphicId: GraphicID;
         color: THREE.Color | undefined;
         opacity: number;
         layer: any;
@@ -109,15 +109,15 @@ export declare class ThreeGeometryCreator {
             type: GraphicType.NONE | GraphicType.BREP | GraphicType.POLYBREP | GraphicType.CURVEARRAY;
         };
         operationId: any;
-        rawGraphic: import("@classcad/api-js/build/types/scg/Scg").ScgGraphicElement | null;
+        rawGraphic: import("@classcad/api-js").ScgGraphicElement | null;
         isValid: boolean;
-        geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>;
+        geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
         loops: number[][];
     };
     createSphere(mesh: IGraphicMesh, meshGeom: MeshGeometry): {
         type: GraphicType;
         radius: number;
-        graphicId: number;
+        graphicId: GraphicID;
         color: THREE.Color | undefined;
         opacity: number;
         layer: any;
@@ -127,9 +127,9 @@ export declare class ThreeGeometryCreator {
             type: GraphicType.NONE | GraphicType.BREP | GraphicType.POLYBREP | GraphicType.CURVEARRAY;
         };
         operationId: any;
-        rawGraphic: import("@classcad/api-js/build/types/scg/Scg").ScgGraphicElement | null;
+        rawGraphic: import("@classcad/api-js").ScgGraphicElement | null;
         isValid: boolean;
-        geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>;
+        geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
         loops: number[][];
     };
     createLine(line: IGraphicLine, container: IGraphicContainer, points: PointMap, color?: number[]): {
@@ -144,8 +144,8 @@ export declare class ThreeGeometryCreator {
             type: GraphicType.NONE | GraphicType.BREP | GraphicType.POLYBREP | GraphicType.CURVEARRAY;
         };
         operationId: any;
-        rawGraphic: import("@classcad/api-js/build/types/scg/Scg").ScgGraphicElement | null;
-        geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>;
+        rawGraphic: import("@classcad/api-js").ScgGraphicElement | null;
+        geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
         graphicId: number;
         type: GraphicType;
     };
@@ -161,8 +161,8 @@ export declare class ThreeGeometryCreator {
             type: GraphicType.NONE | GraphicType.BREP | GraphicType.POLYBREP | GraphicType.CURVEARRAY;
         };
         operationId: any;
-        rawGraphic: import("@classcad/api-js/build/types/scg/Scg").ScgGraphicElement | null;
-        geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>;
+        rawGraphic: import("@classcad/api-js").ScgGraphicElement | null;
+        geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
         graphicId: number;
         type: GraphicType;
     };
@@ -182,8 +182,8 @@ export declare class ThreeGeometryCreator {
             type: GraphicType.NONE | GraphicType.BREP | GraphicType.POLYBREP | GraphicType.CURVEARRAY;
         };
         operationId: any;
-        rawGraphic: import("@classcad/api-js/build/types/scg/Scg").ScgGraphicElement | null;
-        geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes>;
+        rawGraphic: import("@classcad/api-js").ScgGraphicElement | null;
+        geometry: THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
         graphicId: number;
         type: GraphicType;
     };
@@ -203,7 +203,7 @@ export declare class ThreeGeometryCreator {
             type: GraphicType.NONE | GraphicType.BREP | GraphicType.POLYBREP | GraphicType.CURVEARRAY;
         };
         operationId: any;
-        rawGraphic: import("@classcad/api-js/build/types/scg/Scg").ScgGraphicElement | null;
+        rawGraphic: import("@classcad/api-js").ScgGraphicElement | null;
         key: string;
         graphicId: number;
         type: GraphicType;
@@ -211,30 +211,30 @@ export declare class ThreeGeometryCreator {
     private insertPoint;
 }
 export declare const EMPTY_CONTAINER_GEOMETRY: () => ContainerGeometryT;
-declare type CommonProps = {
+type CommonProps = {
     graphicId: GraphicID;
     type: GraphicType;
 };
-export declare type Metadata = ReturnType<ThreeGeometryCreator['getMetadata']>;
-export declare type MeshGeometry = CommonProps & ReturnType<ThreeGeometryCreator['createMesh']>;
-export declare type PlaneGeometry = CommonProps & ReturnType<ThreeGeometryCreator['createPlane']>;
-export declare type CylinderGeometry = CommonProps & ReturnType<ThreeGeometryCreator['createCylinder']>;
-export declare type ConeGeometry = CommonProps & ReturnType<ThreeGeometryCreator['createCone']>;
-export declare type SphereGeometry = CommonProps & ReturnType<ThreeGeometryCreator['createSphere']>;
-export declare type LineGeometry = CommonProps & ReturnType<ThreeGeometryCreator['createLine']>;
-export declare type EdgeGeometry = CommonProps & ReturnType<ThreeGeometryCreator['createEdge']>;
-export declare type ArcGeometry = CommonProps & ReturnType<ThreeGeometryCreator['createArc']>;
-export declare type CircleGeometry = ArcGeometry;
-export declare type PointGeometry = CommonProps & ReturnType<ThreeGeometryCreator['createPoint']> & {
+export type Metadata = ReturnType<ThreeGeometryCreator['getMetadata']>;
+export type MeshGeometry = CommonProps & ReturnType<ThreeGeometryCreator['createMesh']>;
+export type PlaneGeometry = CommonProps & ReturnType<ThreeGeometryCreator['createPlane']>;
+export type CylinderGeometry = CommonProps & ReturnType<ThreeGeometryCreator['createCylinder']>;
+export type ConeGeometry = CommonProps & ReturnType<ThreeGeometryCreator['createCone']>;
+export type SphereGeometry = CommonProps & ReturnType<ThreeGeometryCreator['createSphere']>;
+export type LineGeometry = CommonProps & ReturnType<ThreeGeometryCreator['createLine']>;
+export type EdgeGeometry = CommonProps & ReturnType<ThreeGeometryCreator['createEdge']>;
+export type ArcGeometry = CommonProps & ReturnType<ThreeGeometryCreator['createArc']>;
+export type CircleGeometry = ArcGeometry;
+export type PointGeometry = CommonProps & ReturnType<ThreeGeometryCreator['createPoint']> & {
     owners: Array<{
         ownerId: GraphicID;
         type: PointType;
     }>;
 };
-declare type PointMap = Record<string, PointGeometry>;
-declare type PointKey = string;
-declare type PointType = 'start' | 'end' | 'center';
-export declare type ContainerGeometryT = {
+type PointMap = Record<string, PointGeometry>;
+type PointKey = string;
+type PointType = 'start' | 'end' | 'center';
+export type ContainerGeometryT = {
     graphicId: GraphicID;
     type: GraphicType;
     map: Record<GraphicID, GeometryElement>;
@@ -248,8 +248,8 @@ export declare type ContainerGeometryT = {
         max: THREE.Vector3;
     };
 } & ReturnType<ThreeGeometryCreator['getMetadata']>;
-export declare type GeometryElement = MeshGeometry | PlaneGeometry | CylinderGeometry | ConeGeometry | SphereGeometry | LineGeometry | EdgeGeometry | ArcGeometry | CircleGeometry | PointGeometry;
-export declare type ProductElement = GeometryElement & {
+export type GeometryElement = MeshGeometry | PlaneGeometry | CylinderGeometry | ConeGeometry | SphereGeometry | LineGeometry | EdgeGeometry | ArcGeometry | CircleGeometry | PointGeometry;
+export type ProductElement = GeometryElement & {
     productId: ObjectID;
 };
 export declare const isEqualGeometry: (a: GeometryElement, b: GeometryElement) => boolean;

package/build/types/index.d.ts

@@ -14,25 +14,25 @@ export * from './re-export';
  * Please have a look at https://github.com/awv-informatik/buerli/pull/129 for more information.
  */
 import { BuerliState as BS } from './store/states/buerli';
-export declare type BuerliState = BS;
+export type BuerliState = BS;
 import { DrawingAPI as DrawingAPI1, DrawingID as DrawingID1, DrawingState as DrawingState1 } from './store/states/drawing';
-export declare type DrawingID = DrawingID1;
-export declare type DrawingState = DrawingState1;
-export declare type DrawingAPI = DrawingAPI1;
+export type DrawingID = DrawingID1;
+export type DrawingState = DrawingState1;
+export type DrawingAPI = DrawingAPI1;
 import { GeometryConfig as GeometryConfig1, GeometryBounds as GeometryBounds1 } from './store/states/geometry';
-export declare type GeometryConfig = GeometryConfig1;
-export declare type GeometryBounds = GeometryBounds1;
+export type GeometryConfig = GeometryConfig1;
+export type GeometryBounds = GeometryBounds1;
 import { Plugin as Plugin1, PluginDescription as PluginDescription1, PluginID as PluginID1, PluginState as PluginState1 } from './store/states/plugin';
-export declare type Plugin = Plugin1;
-export declare type PluginDescription<InternalState = any> = PluginDescription1<InternalState>;
-export declare type PluginID = PluginID1;
-export declare type PluginState<InternalState extends Record<any, any> = any> = PluginState1<InternalState>;
+export type Plugin = Plugin1;
+export type PluginDescription<InternalState = any> = PluginDescription1<InternalState>;
+export type PluginID = PluginID1;
+export type PluginState<InternalState extends Record<any, any> = any> = PluginState1<InternalState>;
 import { SeletedItemData, SelectedItem as SelectedItem1, SelectionFilter as SelectionFilter1, SelectionScope as SelectionScope1, Selector as Selector1, SelectorID as SelectorID1, CustomSelect as CustomSelect1 } from './store/states/selection';
-export declare type SelectedItem<T extends SeletedItemData<any> = any> = SelectedItem1<T>;
-export declare type SelectionFilter = SelectionFilter1;
-export declare type SelectionScope = SelectionScope1;
-export declare type Selector<T extends SeletedItemData<any> = any> = Selector1<T>;
-export declare type SelectorID = SelectorID1;
-export declare type CustomSelect = CustomSelect1;
+export type SelectedItem<T extends SeletedItemData<any> = any> = SelectedItem1<T>;
+export type SelectionFilter = SelectionFilter1;
+export type SelectionScope = SelectionScope1;
+export type Selector<T extends SeletedItemData<any> = any> = Selector1<T>;
+export type SelectorID = SelectorID1;
+export type CustomSelect = CustomSelect1;
 import { Message as Message1 } from './store/states/message';
-export declare type Message = Message1;
+export type Message = Message1;

package/build/types/re-export.d.ts

@@ -23,48 +23,48 @@ ScgMeshTypes as MeshTypes,
 /** @deprecated */
 ScgPointTypes as PointTypes, };
 /** @deprecated */
-export declare type IStructureTree = ScgTree;
+export type IStructureTree = ScgTree;
 /** @deprecated */
-export declare type IStructureProtocol = ScgStructure;
+export type IStructureProtocol = ScgStructure;
 /** @deprecated */
-export declare type IStructureObject = ScgObject;
+export type IStructureObject = ScgObject;
 /** @deprecated */
-export declare type IStructureMember = ScgMember;
+export type IStructureMember = ScgMember;
 /** @deprecated */
-export declare type IStructurePatch = ScgStructurePatchOp;
+export type IStructurePatch = ScgStructurePatchOp;
 /** @deprecated */
-export declare type IGraphicPackage = ScgGraphicPackage;
+export type IGraphicPackage = ScgGraphicPackage;
 /** @deprecated */
-export declare type IGraphicElement = ScgGraphicElement;
+export type IGraphicElement = ScgGraphicElement;
 /** @deprecated */
-export declare type IGraphicContainer = ScgGraphicContainer;
+export type IGraphicContainer = ScgGraphicContainer;
 /** @deprecated */
-export declare type IGraphicArc = ScgGraphicArc;
+export type IGraphicArc = ScgGraphicArc;
 /** @deprecated */
-export declare type IGraphicCone = ScgGraphicCone;
+export type IGraphicCone = ScgGraphicCone;
 /** @deprecated */
-export declare type IGraphicCylinder = ScgGraphicCylinder;
+export type IGraphicCylinder = ScgGraphicCylinder;
 /** @deprecated */
-export declare type IGraphicEdge = ScgGraphicEdge;
+export type IGraphicEdge = ScgGraphicEdge;
 /** @deprecated */
-export declare type IGraphicLine = ScgGraphicLine;
+export type IGraphicLine = ScgGraphicLine;
 /** @deprecated */
-export declare type IGraphicMesh = ScgGraphicMesh;
+export type IGraphicMesh = ScgGraphicMesh;
 /** @deprecated */
-export declare type IGraphicPlane = ScgGraphicPlane;
+export type IGraphicPlane = ScgGraphicPlane;
 /** @deprecated */
-export declare type IGraphicSphere = ScgGraphicSphere;
+export type IGraphicSphere = ScgGraphicSphere;
 /** @deprecated */
-export declare type PointMemValue = ScgPoint;
+export type PointMemValue = ScgPoint;
 /** @deprecated */
-export declare type ArrayMem = ScgArrayMem;
+export type ArrayMem = ScgArrayMem;
 /** @deprecated */
-export declare type IdMem = ScgIdMem;
+export type IdMem = ScgIdMem;
 /** @deprecated */
-export declare type PointMem = ScgPointMem;
+export type PointMem = ScgPointMem;
 /** @deprecated */
-export declare type RealMem = ScgRealMem;
+export type RealMem = ScgRealMem;
 /** @deprecated */
-export declare type StringMem = ScgStringMem;
+export type StringMem = ScgStringMem;
 /** @deprecated */
-export declare type APIOptions = FacadeOptions;
+export type APIOptions = FacadeOptions;

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

@@ -3,15 +3,15 @@ import { DrawingID, DrawingState } from './drawing';
 import { GeometryConfig } from './geometry';
 import { MessageState } from './message';
 import { PluginDef, PluginImpl } from './plugin';
-declare type GeneralApi = {
+type GeneralApi = {
     init(options?: Partial<BuerliState['options']>): void;
 };
-declare type DrawingManagementApi = {
+type DrawingManagementApi = {
     createDrawing(name?: string): Promise<DrawingState>;
     removeDrawing(id: DrawingID): void;
     setActiveDrawing(id: DrawingID | null): void;
 };
-export declare type BuerliState = Readonly<{
+export type BuerliState = Readonly<{
     initDone: boolean;
     options: {
         elements: any;

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

@@ -1,7 +1,7 @@
 import { StoreApi } from 'zustand';
 import { BuerliState } from './buerli';
 import { DrawingState } from './drawing';
-declare type States = {
+type States = {
     current: number;
     stack: string[];
     captionMap: Record<string, {
@@ -10,14 +10,14 @@ declare type States = {
         undoable?: boolean;
     }>;
 };
-declare type Pending = {
+type Pending = {
     id: string;
     name: string;
     stamp: number;
     args?: any;
     promise?: Promise<any>;
 };
-export declare type CadData = {
+export type CadData = {
     connection: {
         active: boolean;
         connected: boolean;
@@ -25,9 +25,9 @@ export declare type CadData = {
     states: States;
     pending: Pending[];
 };
-export declare type CadApi = ReturnType<typeof cadApi>;
+export type CadApi = ReturnType<typeof cadApi>;
 export declare const cadData: () => CadData;
-export declare const cadApi: (set: StoreApi<DrawingState>['setState'], get: StoreApi<DrawingState>['getState'], buerliApi: StoreApi<BuerliState>) => {
+export declare const cadApi: (set: StoreApi<DrawingState>["setState"], get: StoreApi<DrawingState>["getState"], buerliApi: StoreApi<BuerliState>) => {
     setStates: (current: number, stack: string[], captionMap: Record<string, {
         stateName: string;
         caption: string;

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

@@ -16,8 +16,8 @@ import { InteractionApi, InteractionData } from './interaction';
 import { PluginApi, PluginData } from './plugin';
 import { SelectionApi, SelectionData } from './selection';
 import { StructureApi, StructureData } from './structure';
-export declare type DrawingID = string | number;
-export declare type DrawingAPI = {
+export type DrawingID = string | number;
+export type DrawingAPI = {
     structure: StructureApi;
     selection: SelectionApi;
     interaction: InteractionApi;
@@ -27,7 +27,7 @@ export declare type DrawingAPI = {
     cad: CadApi;
     reset: () => void;
 };
-declare type StateData = {
+type StateData = {
     id: DrawingID;
     name: string;
     structure: StructureData;
@@ -38,7 +38,7 @@ declare type StateData = {
     plugin: PluginData;
     cad: CadData;
 };
-export declare type DrawingState = Readonly<StateData> & Readonly<{
+export type DrawingState = Readonly<StateData> & Readonly<{
     api: DrawingAPI;
 }>;
 export declare const createDrawingState: (set: StoreApi<DrawingState>['setState'], get: StoreApi<DrawingState>['getState'], buerliApi: StoreApi<BuerliState>, drawingNumber: number, name?: string) => DrawingState;