@buerli.io/core 2.0.0-beta.20261017202221 → 2.0.0-beta.20261018104453

package/build/cjs/geometry/ThreeGeometryCreator.js

@@ -52,7 +52,10 @@ const convertType = (contType) => {
     return type;
 };
 /**
- * Creates THREE geometry based on the data within a @see IGraphicContainer.
+ * Makes the three.js geometry of a graphic container (`ScgGraphicContainer`): what `geometry.cache` of a drawing
+ * holds.
+ *
+ * @internal
  */
 class ThreeGeometryCreator {
     constructor() {
@@ -69,11 +72,24 @@ class ThreeGeometryCreator {
         const rgbColor = color ? new THREE.Color(`rgb(${color[0]}, ${color[1]}, ${color[2]})`) : undefined;
         const layer = geomProps && geomProps.layer ? geomProps.layer : container.properties.layer;
         return {
+            /** The color ClassCAD gave it (its material), if any. */
             color: rgbColor,
+            /** The opacity ClassCAD gave it, from 0 to 1; `0` when it has none. */
             opacity,
+            /** The layer ClassCAD put it on. */
             layer,
+            /**
+             * The container (solid) it is in.
+             *
+             * @privateRemarks `@property __type.<name>` documents a field of the object type that is written on one line.
+             * @property __type.id - The container's id, the solid's CAD entity, as in `geometry.cache`.
+             * @property __type.ownerId - The solid object it belongs to, in the structure tree.
+             * @property __type.type - What kind of container: `brep`, `polyBrep` or `curveArray`.
+             */
             container: { id: container.id, ownerId: container.owner, type: convertType(container.type) },
+            /** The operation (feature) that made a face. */
             operationId: (_a = geometry === null || geometry === void 0 ? void 0 : geometry.properties) === null || _a === void 0 ? void 0 : _a.operationId,
+            /** The element as ClassCAD sent it (`ScgGraphicElement`). */
             rawGraphic: geometry,
         };
     }
@@ -161,9 +177,15 @@ class ThreeGeometryCreator {
         mesh.normals && geometry.setAttribute('normal', new THREE.Float32BufferAttribute(mesh.normals, 3));
         return Object.assign({ 
             // TODO: The server should not send invalid meshes.
-            isValid: mesh.vertices && mesh.vertices.length > 0, geometry,
+            /** Whether the face has vertices; faces without are left out. */
+            isValid: mesh.vertices && mesh.vertices.length > 0, 
+            /** The face's triangles, with normals. */
+            geometry,
+            /** The face's id in its container. */
             graphicId,
+            /** The kind of face: `plane`, `cylinder`, `cone`, `sphere` or `nurbsSurface`. */
             type,
+            /** The loops of edges around the face, each a list of edge ids. */
             loops }, this.getMetadata(mesh, container, color));
     }
     createPlane(mesh, meshGeom) {
@@ -205,8 +227,17 @@ class ThreeGeometryCreator {
         this.insertPoint(container, `${startId}|point`, startId, start.clone(), line.id, 'start', points);
         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: type }, this.getMetadata(line, container, color)), { start: start.clone(), end: end.clone() });
+        return Object.assign(Object.assign({ 
+            /** The line, as a line segment. */
+            geometry,
+            /** The edge's id in its container. */
+            graphicId, 
+            /** `line`, or `curveLine` in a sketch's curves. */
+            type: type }, this.getMetadata(line, container, color)), { 
+            /** Where the line starts. */
+            start: start.clone(), 
+            /** Where it ends. */
+            end: end.clone() });
     }
     createEdge(edge, container, points, color) {
         const threePts = [];
@@ -235,8 +266,17 @@ class ThreeGeometryCreator {
         this.insertPoint(container, `${startId}|point`, startId, start, edge.id, 'start', points);
         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: type }, this.getMetadata(edge, container, color)), { start: start.clone(), end: end.clone() });
+        return Object.assign(Object.assign({ 
+            /** The curve, as line segments. */
+            geometry,
+            /** The edge's id in its container. */
+            graphicId, 
+            /** `nurbsCurve`, or `curveSpline` in a sketch's curves. */
+            type: type }, this.getMetadata(edge, container, color)), { 
+            /** Where the curve starts. */
+            start: start.clone(), 
+            /** Where it ends. */
+            end: end.clone() });
     }
     createArc(arc, container, points, color) {
         const graphicId = arc.id;
@@ -283,12 +323,47 @@ class ThreeGeometryCreator {
         this.insertPoint(container, `${startId}|point`, startId, start, arc.id, 'start', points);
         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: type }, this.getMetadata(arc, container, color)), { normal: normal.clone(), center: center.clone(), start: start.clone(), end: end.clone(), radius: arc.radius, angle: arc.angle });
+        return Object.assign(Object.assign({ 
+            /** The arc, as line segments. */
+            geometry,
+            /** The edge's id in its container. */
+            graphicId, 
+            /** `arc` or `circle`, or `curveArc` or `curveCircle` in a sketch's curves. */
+            type: type }, this.getMetadata(arc, container, color)), { 
+            /** The normal of the arc's plane, of length 1. */
+            normal: normal.clone(), 
+            /** The center. */
+            center: center.clone(), 
+            /** Where the arc starts. */
+            start: start.clone(), 
+            /** Where it ends; where it starts for a circle. */
+            end: end.clone(), 
+            /** The radius. */
+            radius: arc.radius, 
+            /** The angle the arc spans, in radians. */
+            angle: arc.angle });
     }
     createPoint(container, key, graphicId, position, ownerId, type) {
-        return Object.assign(Object.assign({ key,
-            graphicId, type: (container.type === re_export_1.ContainerType.CURVEARRAY ? re_export_1.GraphicType.CURVEPOINT : re_export_1.GraphicType.POINT) }, this.getMetadata(null, container)), { position: position.clone(), geometry: position.clone(), owners: [{ ownerId, type }] });
+        return Object.assign(Object.assign({ 
+            /** The point's key in its container, `<graphicId>|point`. */
+            key,
+            /** The point's id in its container. */
+            graphicId, 
+            /** `point`, or `curvePoint` in a sketch's curves. */
+            type: (container.type === re_export_1.ContainerType.CURVEARRAY ? re_export_1.GraphicType.CURVEPOINT : re_export_1.GraphicType.POINT) }, this.getMetadata(null, container)), { 
+            /** Where the point is. */
+            position: position.clone(), 
+            /** Where the point is, as for `position`. */
+            geometry: position.clone(), 
+            /** The edges the point is an end of: each edge's id (`ownerId`) and which end it is (`type`). */
+            owners: [
+                {
+                    /** The edge's id. */
+                    ownerId,
+                    /** Which end of the edge the point is. */
+                    type,
+                },
+            ] });
     }
     insertPoint(container, key, graphicId, position, ownerId, type, points) {
         const existingPoint = points[key];
@@ -304,6 +379,11 @@ class ThreeGeometryCreator {
     }
 }
 exports.ThreeGeometryCreator = ThreeGeometryCreator;
+/**
+ * Returns the geometry of an empty container.
+ *
+ * @internal
+ */
 const EMPTY_CONTAINER_GEOMETRY = () => {
     return {
         graphicId: Number.NaN,
@@ -324,6 +404,12 @@ const EMPTY_CONTAINER_GEOMETRY = () => {
     };
 };
 exports.EMPTY_CONTAINER_GEOMETRY = EMPTY_CONTAINER_GEOMETRY;
+/**
+ * Returns whether two elements of the geometry are the same: the same `graphicId` and `type`.
+ *
+ * @advanced
+ * @category Geometry
+ */
 const isEqualGeometry = (a, b) => {
     return a.graphicId === b.graphicId && a.type === b.type;
 };

package/build/cjs/graphic/filters.js

@@ -3,23 +3,123 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.solidFilter = exports.loopFilter = exports.planeFilter = exports.meshFilter = exports.pointFilter = exports.arcCircleFilter = exports.circleFilter = exports.arcFilter = exports.edgeFilter = exports.lineFilter = void 0;
 const re_export_1 = require("../re-export");
 const selection_1 = require("../store/states/selection");
+/**
+ * Takes straight edges of solids.
+ *
+ * Use it as a selector's filter ({@link SelectionFilter}): {@link Selector} has an example.
+ *
+ * @param scope - The item's scope; only {@link BuerliScope} is taken.
+ * @param data - The element's `GraphicType`.
+ * @advanced
+ * @category Selection
+ */
 const lineFilter = (scope, data) => scope === selection_1.BuerliScope && data === re_export_1.GraphicType.LINE;
 exports.lineFilter = lineFilter;
+/**
+ * Takes edges of solids: lines, arcs, circles and other curves.
+ *
+ * Use it as a selector's filter ({@link SelectionFilter}): {@link Selector} has an example.
+ *
+ * @param scope - The item's scope; only {@link BuerliScope} is taken.
+ * @param data - The element's `GraphicType`.
+ * @advanced
+ * @category Selection
+ */
 const edgeFilter = (scope, data) => scope === selection_1.BuerliScope && re_export_1.EdgeTypes.includes(data);
 exports.edgeFilter = edgeFilter;
+/**
+ * Takes arcs of solids, not full circles.
+ *
+ * Use it as a selector's filter ({@link SelectionFilter}): {@link Selector} has an example.
+ *
+ * @param scope - The item's scope; only {@link BuerliScope} is taken.
+ * @param data - The element's `GraphicType`.
+ * @advanced
+ * @category Selection
+ */
 const arcFilter = (scope, data) => scope === selection_1.BuerliScope && data === re_export_1.GraphicType.ARC;
 exports.arcFilter = arcFilter;
+/**
+ * Takes circles of solids.
+ *
+ * Use it as a selector's filter ({@link SelectionFilter}): {@link Selector} has an example.
+ *
+ * @param scope - The item's scope; only {@link BuerliScope} is taken.
+ * @param data - The element's `GraphicType`.
+ * @advanced
+ * @category Selection
+ */
 const circleFilter = (scope, data) => scope === selection_1.BuerliScope && data === re_export_1.GraphicType.CIRCLE;
 exports.circleFilter = circleFilter;
+/**
+ * Takes arcs and circles, for example for a center or a radius.
+ *
+ * Use it as a selector's filter ({@link SelectionFilter}): {@link Selector} has an example.
+ *
+ * @param scope - The item's scope; only {@link BuerliScope} is taken.
+ * @param data - The element's `GraphicType`.
+ * @advanced
+ * @category Selection
+ */
 const arcCircleFilter = (scope, data) => scope === selection_1.BuerliScope && (data === re_export_1.GraphicType.ARC || data === re_export_1.GraphicType.CIRCLE);
 exports.arcCircleFilter = arcCircleFilter;
+/**
+ * Takes points of solids: the ends of their edges.
+ *
+ * Use it as a selector's filter ({@link SelectionFilter}): {@link Selector} has an example.
+ *
+ * @param scope - The item's scope; only {@link BuerliScope} is taken.
+ * @param data - The element's `GraphicType`.
+ * @advanced
+ * @category Selection
+ */
 const pointFilter = (scope, data) => scope === selection_1.BuerliScope && data === re_export_1.GraphicType.POINT;
 exports.pointFilter = pointFilter;
+/**
+ * Takes faces of solids: planar, cylindrical, conical, spherical and free-form faces.
+ *
+ * Use it as a selector's filter ({@link SelectionFilter}): {@link Selector} has an example.
+ *
+ * @param scope - The item's scope; only {@link BuerliScope} is taken.
+ * @param data - The element's `GraphicType`.
+ * @advanced
+ * @category Selection
+ */
 const meshFilter = (scope, data) => scope === selection_1.BuerliScope && re_export_1.MeshTypes.includes(data);
 exports.meshFilter = meshFilter;
+/**
+ * Takes planar faces.
+ *
+ * Use it as a selector's filter ({@link SelectionFilter}): {@link Selector} has an example.
+ *
+ * @param scope - The item's scope; only {@link BuerliScope} is taken.
+ * @param data - The element's `GraphicType`.
+ * @advanced
+ * @category Selection
+ */
 const planeFilter = (scope, data) => scope === selection_1.BuerliScope && data === re_export_1.GraphicType.PLANE;
 exports.planeFilter = planeFilter;
+/**
+ * Takes loops, the edges around a face: the 3D view takes the loop of the face that is picked.
+ *
+ * Use it as a selector's filter ({@link SelectionFilter}): {@link Selector} has an example.
+ *
+ * @param scope - The item's scope; only {@link BuerliScope} is taken.
+ * @param data - The element's `GraphicType`.
+ * @advanced
+ * @category Selection
+ */
 const loopFilter = (scope, data) => scope === selection_1.BuerliScope && data === re_export_1.GraphicType.LOOP;
 exports.loopFilter = loopFilter;
+/**
+ * Takes whole solids: picking any face or edge selects its solid.
+ *
+ * Use it as a selector's filter ({@link SelectionFilter}): {@link Selector} has an example.
+ *
+ * @param scope - The item's scope; only {@link BuerliScope} is taken.
+ * @param data - The element's `GraphicType`.
+ * @advanced
+ * @category Selection
+ */
 const solidFilter = (scope, data) => scope === selection_1.BuerliScope && data === re_export_1.GraphicType.BREP;
 exports.solidFilter = solidFilter;

package/build/cjs/index.js

@@ -1,4 +1,64 @@
 "use strict";
+/**
+ * The state the buerli packages share: the drawings, each with its structure tree, its geometry, its selection
+ * and its plugins, and the messages for the app. `@buerli.io/classcad` fills a drawing as ClassCAD changes it, and
+ * `@buerli.io/react` renders it; apps mostly reach it through those two, and use a few things from here directly.
+ *
+ * ## What it exposes
+ *
+ * - {@link getDrawing}: a drawing's state, its structure tree, geometry, selection and plugins, and its API.
+ * - {@link DrawingState} and {@link DrawingAPI}: what a drawing holds and what it can do.
+ * - {@link api}: the store itself, with all drawings, to read, change and subscribe to.
+ * - {@link subscribeToDrawing}: calls back when a part of a drawing changes.
+ * - {@link showMessage}: tells the user something, in the message display of react-cad and Buerligons.
+ * - {@link Selector} and {@link SelectedItem}: the lists the user picks faces, edges and other items into.
+ * - {@link GeometryConfig}: how the geometry of solids is shown.
+ *
+ * @example
+ * ```ts
+ * import { BuerliCadFacade, createApi, init, WASMClient } from '@buerli.io/classcad'
+ * import { getDrawing } from '@buerli.io/core'
+ *
+ * init(drawingId => new WASMClient(drawingId, { token: 'ccpk_…' }))
+ *
+ * // Connecting makes a drawing in the store
+ * const drawingId = await new BuerliCadFacade().connect()
+ * if (drawingId) {
+ *   await createApi(drawingId).v1.part.create({ name: 'Part' })
+ *   // The structure tree that ClassCAD sent: its objects by id
+ *   const { tree } = getDrawing(drawingId).structure
+ *   console.log(Object.values(tree).map(object => `${object.class} ${object.name}`))
+ * }
+ * ```
+ *
+ * @categoryDescription Drawings
+ * A drawing is one model in the store: its structure tree, geometry, selections and plugins, which
+ * `@buerli.io/classcad` keeps up to date. Read it when an app needs to know what the model holds.
+ *
+ * @categoryDescription Messages
+ * Messages for the user, which the message displays of react-cad and Buerligons show: to tell what an app is doing.
+ *
+ * @categoryDescription Selection
+ * Selectors, the lists the user picks faces, edges and other items into in the 3D view, and what the user has
+ * selected in the model: for apps that let the user pick.
+ *
+ * @categoryDescription Geometry
+ * How the geometry of solids is shown, and the bounds of a model. The three.js geometry itself, made from the
+ * graphic ClassCAD sends, is for apps that work with faces and edges directly.
+ *
+ * @categoryDescription Measure
+ * Positions, lengths, distances and angles of elements of the geometry, as the Measure plugin of react-cad shows
+ * them.
+ *
+ * @categoryDescription Plugins
+ * Plugins add panels and 3D views to a CAD app, for the features of a model or for a whole drawing: for those who
+ * make plugins.
+ *
+ * @categoryDescription Utilities
+ * Math for the coordinate systems of ClassCAD, and timing.
+ *
+ * @packageDocumentation
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/cjs/store/index.js

@@ -8,27 +8,128 @@ exports.showMessage = showMessage;
 exports.updateMessage = updateMessage;
 exports.closeMessage = closeMessage;
 const store_1 = require("./store");
+/**
+ * Returns a drawing's state: its structure tree, geometry, selection and plugins, and its API.
+ *
+ * It is the state as it is now, read once; to follow it as it changes, use {@link subscribeToDrawing}, or
+ * `useDrawing` of `@buerli.io/react` in a component. Returns `undefined` for a drawing that does not exist (any more),
+ * although the type does not say so.
+ *
+ * @param id - The drawing, as `@buerli.io/classcad` returns it when it connects.
+ * @returns The drawing's state, or `undefined`.
+ * @example
+ * ```ts
+ * import { BuerliCadFacade, init, WASMClient } from '@buerli.io/classcad'
+ * import { getDrawing } from '@buerli.io/core'
+ *
+ * init(drawingId => new WASMClient(drawingId, { token: 'ccpk_…' }))
+ *
+ * const facade = new BuerliCadFacade()
+ * const drawingId = await facade.connect()
+ * const part = drawingId && (await facade.api.v1.part.create({ name: 'Bracket' }))
+ * if (drawingId && part) {
+ *   await facade.api.v1.part.box({ id: part, length: 100, width: 50, height: 20 })
+ *
+ *   const drawing = getDrawing(drawingId)
+ *   // The part in the structure tree, and the three.js geometry of its solids
+ *   const object = drawing.structure.tree[part]
+ *   const solids = (object.solids ?? []).map(id => drawing.geometry.cache[id])
+ *   console.log(object.name, solids.length)
+ * }
+ * ```
+ * @category Drawings
+ */
 function getDrawing(id) {
     const { drawing } = store_1.api.getState();
     return drawing.refs[id];
 }
 /**
- * @returns PluginState or undefined if either drawing or plugin don't exist
+ * Returns a plugin's state: its description, its own `state`, and `set` to change that.
+ *
+ * Plugins of features are created when their feature is opened, global plugins when the drawing is made
+ * (see {@link PluginState}). Read once; `usePlugin` of `@buerli.io/react` follows it in a component.
+ *
+ * @param drawingId - The drawing the plugin belongs to.
+ * @param pluginId - The plugin: for a feature's plugin, the feature's object id.
+ * @returns The plugin's state, or `undefined` when the drawing or the plugin does not exist.
+ * @example
+ * ```ts
+ * import { getDrawing, getPlugin } from '@buerli.io/core'
+ *
+ * // Open the Measure plugin of a drawing, and have it show three digits
+ * const drawing = getDrawing(drawingId)
+ * const measureId = drawing.plugin.global.find(id => drawing.plugin.refs[id]?.name === 'Measure')
+ * if (measureId) {
+ *   drawing.api.plugin.setActiveGlobal(measureId, true)
+ *   getPlugin(drawingId, measureId)?.set({ digits: 3 })
+ * }
+ * ```
+ * @advanced
+ * @category Plugins
  */
 function getPlugin(drawingId, pluginId) {
     var _a;
     const { drawing } = store_1.api.getState();
     return (_a = drawing.refs[drawingId]) === null || _a === void 0 ? void 0 : _a.plugin.refs[pluginId];
 }
+/**
+ * Sets options of the store; `init` of `@buerli.io/classcad` calls it with the options it is given.
+ *
+ * @internal
+ */
 function init(options) {
     store_1.api.getState().api.init(options);
 }
+/**
+ * Tells the user something: shows a message in the message display of react-cad and Buerligons.
+ *
+ * The store holds one message, the latest (`message` of {@link BuerliState}): a new one takes the place of the one
+ * before, and the display, which keeps a list of them, shows it as it comes. Warnings and errors of ClassCAD calls
+ * come this way as well.
+ *
+ * @param message - What to say, and what kind of message it is.
+ * @returns The message's id, for {@link updateMessage} and {@link closeMessage}.
+ * @example
+ * ```ts
+ * import { createApi } from '@buerli.io/classcad'
+ * import { closeMessage, showMessage, updateMessage } from '@buerli.io/core'
+ *
+ * const id = showMessage({ type: 'busy', text: 'Recalculating …', drawingId })
+ * try {
+ *   await createApi(drawingId).v1.common.recalc()
+ *   updateMessage(id, { type: 'success', text: 'Recalculated', drawingId })
+ * } catch {
+ *   // ClassCAD's error comes as a message of its own
+ *   closeMessage(id)
+ * }
+ * ```
+ * @category Messages
+ */
 function showMessage(message) {
     return store_1.api.getState().message.api.show(message);
 }
+/**
+ * Replaces a message that {@link showMessage} showed, for example a busy message with its outcome.
+ *
+ * The replacement becomes the store's latest message, with the same id, also when other messages came since.
+ * {@link showMessage} has an example.
+ *
+ * @param id - The message, as {@link showMessage} returned it.
+ * @param message - What the message says now.
+ * @category Messages
+ */
 function updateMessage(id, message) {
     store_1.api.getState().message.api.update(id, message);
 }
+/**
+ * Takes a message back: clears the store's latest message if it is this one.
+ *
+ * A display of the latest message, like Buerligons' one-line message, clears with it; react-cad's list keeps the
+ * messages it has shown. {@link showMessage} has an example.
+ *
+ * @param id - The message, as {@link showMessage} returned it.
+ * @category Messages
+ */
 function closeMessage(id) {
     store_1.api.getState().message.api.close(id);
 }

package/build/cjs/store/states/buerli.js

@@ -27,8 +27,7 @@ exports.createState = createState;
 const generalApi = set => ({
     // 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,
-     * there is a warning disaplying for these cases.
+     * Merges the given options into `state.options` (the ones it names replace the ones there) and sets `initDone`.
      *
      * @param options - options which will be set into state.options
      */

package/build/cjs/store/states/cad.js

@@ -15,8 +15,23 @@ exports.cadData = cadData;
 // API
 ////////////////////////////////////////////////////
 const cadApi = (set, get, buerliApi) => ({
+    /**
+     * Sets the undo history, as ClassCAD reports it.
+     *
+     * @internal
+     */
     setStates: (current, stack, captionMap) => set(state => ({ cad: Object.assign(Object.assign({}, state.cad), { states: Object.assign(Object.assign({}, state.cad.states), { current, stack, captionMap }) }) })),
+    /**
+     * Sets what the changes of the undo history are called.
+     *
+     * @internal
+     */
     setCaptionMap: (captionMap) => set(state => ({ cad: Object.assign(Object.assign({}, state.cad), { states: Object.assign(Object.assign({}, state.cad.states), { captionMap }) }) })),
+    /**
+     * Adds a call to the calls under way and returns its id.
+     *
+     * @internal
+     */
     addPending: (name, options) => {
         const id = (0, uuid_1.v4)();
         set(state => ({
@@ -24,13 +39,28 @@ const cadApi = (set, get, buerliApi) => ({
         }));
         return id;
     },
+    /**
+     * Removes a call from the calls under way.
+     *
+     * @internal
+     */
     removePending: (id) => {
         const newPending = get().cad.pending.filter(p => p.id !== id);
         set(state => ({ cad: Object.assign(Object.assign({}, state.cad), { pending: newPending }) }));
     },
+    /**
+     * Sets whether the client is connected.
+     *
+     * @internal
+     */
     setConnected: (connected) => {
         return set(state => ({ cad: Object.assign(Object.assign({}, state.cad), { connection: Object.assign(Object.assign({}, state.cad.connection), { connected }) }) }));
     },
+    /**
+     * Sets whether the client is connected or trying to connect.
+     *
+     * @internal
+     */
     setActive: (active) => {
         return set(state => ({ cad: Object.assign(Object.assign({}, state.cad), { connection: Object.assign(Object.assign({}, state.cad.connection), { active }) }) }));
     },
@@ -39,6 +69,8 @@ const cadApi = (set, get, buerliApi) => ({
      *
      * **This method is designed for interal usage only, please do not use it in user code!**
      * **It will be removed in a future release!**
+     *
+     * @internal
      */
     clearPending: () => {
         set(state => ({ cad: Object.assign(Object.assign({}, state.cad), { pending: [] }) }));

package/build/cjs/store/states/geometry.js

@@ -56,8 +56,9 @@ exports.geometryData = geometryData;
 ////////////////////////////////////////////////////
 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.
+     * Updates `geometry.bounds` from all products of the model, if a product has a solid.
+     *
+     * @internal
      */
     updateBounds: () => {
         const { api, structure } = get();
@@ -67,10 +68,12 @@ const geometryApi = (set, get, buerliApi) => ({
         }
     },
     /**
-     * Batch variant of @see createGeometryIfNotCached: creates the missing geometry of all given containers
+     * Batch variant of `createGeometryIfNotCached`: creates the missing geometry of all given containers
      * and stores it with one state update. Adding the graphic of a large assembly calls this once per batch
      * instead of once per container, so subscribers are notified once and the cache is copied once.
      * Returns the number of geometries created.
+     *
+     * @internal
      */
     createGeometriesIfNotCached: (containerIds, color) => {
         const { graphic, geometry } = get();
@@ -93,6 +96,11 @@ const geometryApi = (set, get, buerliApi) => ({
         }
         return count;
     },
+    /**
+     * Returns the geometry of a container, and makes it from the graphic first if it is not in the cache.
+     *
+     * @internal
+     */
     createGeometryIfNotCached: (containerId, color) => {
         const { graphic, geometry } = get();
         let geom = geometry.cache[containerId];
@@ -110,6 +118,15 @@ const geometryApi = (set, get, buerliApi) => ({
         }
         return geom;
     },
+    /**
+     * Colors a face of a solid in the 3D view, until its geometry comes anew from ClassCAD. The model is not changed.
+     *
+     * @param containerId - The solid, as in `geometry.cache`.
+     * @param graphicId - The face.
+     * @param r - Red, from 0 to 1.
+     * @param g - Green, from 0 to 1.
+     * @param b - Blue, from 0 to 1.
+     */
     setGraphicColor: (containerId, graphicId, r, g, b) => {
         // Provide values as a CSS color string, which will be gamma corrected by three.js
         const color = new THREE.Color(`rgb(${Math.round(r * 255)}, ${Math.round(g * 255)}, ${Math.round(b * 255)})`);
@@ -130,6 +147,15 @@ const geometryApi = (set, get, buerliApi) => ({
             };
         });
     },
+    /**
+     * Colors a solid in the 3D view (its faces without a color of their own), until its geometry comes anew from
+     * ClassCAD. The model is not changed.
+     *
+     * @param containerId - The solid, as in `geometry.cache`.
+     * @param r - Red, from 0 to 1.
+     * @param g - Green, from 0 to 1.
+     * @param b - Blue, from 0 to 1.
+     */
     setContainerColor: (containerId, r, g, b) => {
         // Provide values as a CSS color string, which will be gamma corrected by three.js
         const color = new THREE.Color(`rgb(${Math.round(r * 255)}, ${Math.round(g * 255)}, ${Math.round(b * 255)})`);
@@ -138,12 +164,26 @@ const geometryApi = (set, get, buerliApi) => ({
             geometry: Object.assign(Object.assign({}, state.geometry), { cache: Object.assign(Object.assign({}, state.geometry.cache), { [containerId]: Object.assign(Object.assign({}, cachedGeom), { dirtyStamp: Date.now() }) }) }),
         }));
     },
+    /**
+     * Sets the opacity of a solid in the 3D view (its faces without an opacity of their own), until its geometry
+     * comes anew from ClassCAD. The model is not changed.
+     *
+     * @param containerId - The solid, as in `geometry.cache`.
+     * @param opacity - From 0 (invisible) to 1.
+     */
     setOpacity: (containerId, opacity) => {
         const cachedGeom = Object.assign(Object.assign({}, get().geometry.cache[containerId]), { opacity });
         set(state => ({
             geometry: Object.assign(Object.assign({}, state.geometry), { cache: Object.assign(Object.assign({}, state.geometry.cache), { [containerId]: Object.assign(Object.assign({}, cachedGeom), { dirtyStamp: Date.now() }) }) }),
         }));
     },
+    /**
+     * Sets how the geometry of a product or a solid is shown: merges `config` into the one it has, or removes it with
+     * `null`.
+     *
+     * @param objId - The product or the solid.
+     * @param config - What to change, or `null` to show it as all others.
+     */
     setConfig: (objId, config) => {
         set(state => {
             const productConfigs = Object.assign({}, state.geometry.config.product);
@@ -165,10 +205,17 @@ const geometryApi = (set, get, buerliApi) => ({
             return { geometry: Object.assign(Object.assign({}, state.geometry), { config: Object.assign(Object.assign({}, state.geometry.config), { product: productConfigs }) }) };
         });
     },
+    /** Returns the elements of the geometry that ClassCAD gave a label or a color of their own. */
     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); });
     },
+    /**
+     * Returns the elements of the geometry (faces, edges, arcs and lines) that `cb` accepts.
+     *
+     * @param cb - Whether to take an element.
+     * @param options - `onlyOne` stops at the first, `containerId` looks in one solid only.
+     */
     filter: (cb, options) => {
         const result = [];
         const { cache } = get().geometry;