@viamrobotics/motion-tools 1.12.3 → 1.13.1

package/dist/hooks/useFrames.svelte.d.ts

@@ -1,11 +1,6 @@
 import { Transform } from '@viamrobotics/sdk';
-interface FrameTransform {
-    type: 'machine' | 'config' | 'fragment';
-    transform: Transform;
-}
 interface FramesContext {
-    current: FrameTransform[];
-    getParentFrameOptions: (componentName: string) => string[];
+    current: Transform[];
 }
 export declare const provideFrames: (partID: () => string) => void;
 export declare const useFrames: () => FramesContext;

package/dist/hooks/useFrames.svelte.js

@@ -1,27 +1,29 @@
 import { getContext, setContext, untrack } from 'svelte';
-import { Transform } from '@viamrobotics/sdk';
-import { useRobotClient, createRobotQuery, useMachineStatus } from '@viamrobotics/svelte-sdk';
+import { MachineConnectionEvent, Transform } from '@viamrobotics/sdk';
+import { useRobotClient, createRobotQuery, useMachineStatus, useConnectionStatus, } from '@viamrobotics/svelte-sdk';
+import {} from 'koota';
 import { useLogs } from './useLogs.svelte';
 import { resourceNameToColor } from '../color';
-import { createTransformFromFrame } from '../frame';
-import { usePartConfig } from './usePartConfig.svelte';
 import { useEnvironment } from './useEnvironment.svelte';
 import { createPose } from '../transform';
 import { useResourceByName } from './useResourceByName.svelte';
 import { traits, useWorld } from '../ecs';
+import { useConfigFrames } from './useConfigFrames.svelte';
 const key = Symbol('frames-context');
 export const provideFrames = (partID) => {
+    const configFrames = useConfigFrames();
     const environment = useEnvironment();
     const world = useWorld();
     const resourceByName = useResourceByName();
     const client = useRobotClient(partID);
+    const connectionStatus = useConnectionStatus(partID);
     const machineStatus = useMachineStatus(partID);
     const logs = useLogs();
+    const isEditMode = $derived(environment.current.viewerMode === 'edit');
     const query = createRobotQuery(client, 'frameSystemConfig', () => ({
-        enabled: partID() !== '' && environment.current.viewerMode === 'monitor',
+        enabled: partID() !== '' && !isEditMode,
     }));
     const revision = $derived(machineStatus.current?.config?.revision);
-    const partConfig = usePartConfig();
     $effect(() => {
         if (query.isFetching) {
             logs.add('Fetching frames...');
@@ -30,218 +32,117 @@ export const provideFrames = (partID) => {
             logs.add(`Frames: ${query.error.message}`, 'error');
         }
     });
-    $effect(() => {
-        if (partConfig.isDirty) {
-            environment.current.viewerMode = 'edit';
-        }
-        else {
-            environment.current.viewerMode = 'monitor';
-        }
-    });
-    const machineFrames = $derived.by(() => {
+    const frames = $derived.by(() => {
         const frames = {};
         for (const { frame } of query.data ?? []) {
             if (frame === undefined) {
                 continue;
             }
-            frames[frame.referenceFrame] = {
-                type: 'machine',
-                transform: frame,
-            };
+            frames[frame.referenceFrame] = frame;
         }
-        return frames;
-    });
-    const [configFrames, configUnsetFrameNames] = $derived.by(() => {
-        const { components } = partConfig.current;
-        const results = {};
-        const unsetResults = [];
-        for (const { name, frame } of components ?? []) {
-            if (!frame) {
-                unsetResults.push(name);
-                continue;
-            }
-            results[name] = {
-                type: 'config',
-                transform: createTransformFromFrame(name, frame),
+        if (isEditMode || connectionStatus.current === MachineConnectionEvent.DISCONNECTED) {
+            const mergedFrames = {
+                ...frames,
+                ...configFrames.current,
             };
+            /**
+             * Remove frames that have just been deleted locally for optimistic updates,
+             * or frames that have been removed by fragment overrides
+             */
+            for (const name of configFrames.unsetFrames) {
+                delete mergedFrames[name];
+            }
+            return mergedFrames;
         }
-        return [results, unsetResults];
-    });
-    const [fragmentFrames, fragmentUnsetFrameNames] = $derived.by(() => {
-        const { fragment_mods: fragmentMods = [] } = partConfig.current;
-        const fragmentDefinedComponents = Object.keys(partConfig.componentNameToFragmentId);
-        const results = {};
-        const unsetResults = [];
-        // deal with fragment defined components
-        for (const fragmentComponentName of fragmentDefinedComponents || []) {
-            const fragmentId = partConfig.componentNameToFragmentId[fragmentComponentName];
-            const fragmentMod = fragmentMods?.find((mod) => mod.fragment_id === fragmentId);
-            if (!fragmentMod) {
-                continue;
-            }
-            const setComponentModIndex = fragmentMod.mods.findLastIndex((mod) => mod['$set']?.[`components.${fragmentComponentName}.frame`] !== undefined);
-            const unsetComponentModIndex = fragmentMod.mods.findLastIndex((mod) => mod['$unset']?.[`components.${fragmentComponentName}.frame`] !== undefined);
-            if (setComponentModIndex < unsetComponentModIndex) {
-                unsetResults.push(fragmentComponentName);
-            }
-            else if (unsetComponentModIndex < setComponentModIndex) {
-                const frameData = fragmentMod.mods[setComponentModIndex]['$set'][`components.${fragmentComponentName}.frame`];
-                results[fragmentComponentName] = {
-                    type: 'fragment',
-                    transform: createTransformFromFrame(fragmentComponentName, frameData),
-                };
-            }
-        }
-        return [results, unsetResults];
-    });
-    const frames = $derived.by(() => {
-        const result = {
-            ...machineFrames,
-            ...configFrames,
-            ...fragmentFrames,
-        };
-        // Remove frames that have just been deleted locally for optimistic updates
-        for (const name of configUnsetFrameNames) {
-            delete result[name];
-        }
-        // Remove frames that have been removed by fragment overrides
-        for (const name of fragmentUnsetFrameNames) {
-            delete result[name];
-        }
-        return result;
+        /**
+         * If we're not in edit mode and we have a robot connection,
+         * we only use frames reported by the machine
+         *
+         */
+        return frames;
     });
     const current = $derived(Object.values(frames));
     const entities = new Map();
     $effect.pre(() => {
         if (revision) {
-            untrack(async () => {
-                await query.refetch();
-                for (const [name, machineFrame] of Object.entries(machineFrames)) {
-                    if (machineFrame === undefined) {
-                        continue;
-                    }
-                    const existing = entities.get(name);
-                    if (existing) {
-                        const pose = createPose(machineFrame.transform.poseInObserverFrame?.pose);
-                        existing.set(traits.Pose, pose);
-                        if (environment.current.viewerMode === 'monitor') {
-                            // if we are in monitor mode, we want the network pose to overwrite any leftover edited poses
-                            existing.set(traits.EditedPose, pose);
-                        }
-                    }
-                }
-            });
-        }
-    });
-    $effect.pre(() => {
-        for (const [name, configFrame] of Object.entries(configFrames)) {
-            if (configFrame === undefined) {
-                continue;
-            }
-            const existing = entities.get(name);
-            if (existing) {
-                const pose = createPose(configFrame.transform.poseInObserverFrame?.pose);
-                existing.set(traits.EditedPose, pose);
-            }
-        }
-    });
-    $effect.pre(() => {
-        for (const [name, fragmentFrame] of Object.entries(fragmentFrames)) {
-            if (fragmentFrame === undefined) {
-                continue;
-            }
-            const existing = entities.get(name);
-            if (existing) {
-                const pose = createPose(fragmentFrame.transform.poseInObserverFrame?.pose);
-                existing.set(traits.EditedPose, pose);
-            }
+            untrack(() => query.refetch());
         }
     });
     $effect.pre(() => {
-        for (const frame of current) {
-            if (frame === undefined) {
-                continue;
-            }
-            const name = frame.transform.referenceFrame;
-            const parent = frame.transform.poseInObserverFrame?.referenceFrame;
-            const pose = createPose(frame.transform.poseInObserverFrame?.pose);
-            const center = frame.transform.physicalObject?.center
-                ? createPose(frame.transform.physicalObject.center)
-                : undefined;
-            const resourceName = resourceByName.current[frame.transform.referenceFrame];
-            const color = resourceNameToColor(resourceName);
-            const existing = entities.get(name);
-            if (existing) {
-                if (!parent || parent === 'world') {
-                    existing.remove(traits.Parent);
-                }
-                else if (parent && existing.has(traits.Parent)) {
-                    existing.set(traits.Parent, parent);
+        if (current.length === 0)
+            return;
+        const currentResourcesByName = resourceByName.current;
+        // We only want to update whenever "current" or "resourceByName.current" changes
+        untrack(() => {
+            const active = {};
+            for (const frame of current) {
+                const name = frame.referenceFrame;
+                active[name] = true;
+                const parent = frame.poseInObserverFrame?.referenceFrame;
+                const pose = createPose(frame.poseInObserverFrame?.pose);
+                const center = frame.physicalObject?.center
+                    ? createPose(frame.physicalObject.center)
+                    : undefined;
+                const resourceName = currentResourcesByName[frame.referenceFrame];
+                const color = resourceNameToColor(resourceName);
+                const existing = entities.get(name);
+                if (existing) {
+                    if (!parent || parent === 'world') {
+                        existing.remove(traits.Parent);
+                    }
+                    else if (parent && existing.has(traits.Parent)) {
+                        existing.set(traits.Parent, parent);
+                    }
+                    else {
+                        existing.add(traits.Parent(parent));
+                    }
+                    if (color) {
+                        existing.set(traits.Color, color);
+                    }
+                    if (center) {
+                        existing.set(traits.Center, center);
+                    }
+                    existing.remove(traits.Box, traits.Sphere, traits.BufferGeometry, traits.Capsule);
+                    if (frame.physicalObject) {
+                        const geometry = traits.Geometry(frame.physicalObject);
+                        existing.add(geometry);
+                    }
+                    existing.set(traits.EditedPose, pose);
+                    continue;
                 }
-                else {
-                    existing.add(traits.Parent(parent));
+                const entityTraits = [
+                    traits.Name(name),
+                    traits.Pose(pose),
+                    traits.EditedPose(pose),
+                    traits.FramesAPI,
+                    traits.ShowAxesHelper,
+                ];
+                if (parent && parent !== 'world') {
+                    entityTraits.push(traits.Parent(parent));
                 }
                 if (color) {
-                    existing.set(traits.Color, color);
+                    entityTraits.push(traits.Color(color));
                 }
                 if (center) {
-                    existing.set(traits.Center, center);
+                    entityTraits.push(traits.Center(center));
                 }
-                existing.remove(traits.Box, traits.Sphere, traits.BufferGeometry, traits.Capsule);
-                if (frame.transform.physicalObject) {
-                    const geometry = traits.Geometry(frame.transform.physicalObject);
-                    existing.add(geometry);
+                if (frame.physicalObject) {
+                    entityTraits.push(traits.Geometry(frame.physicalObject));
                 }
-                continue;
-            }
-            const entityTraits = [
-                traits.Name(name),
-                traits.Pose(pose),
-                traits.EditedPose(pose),
-                traits.FramesAPI,
-                traits.ShowAxesHelper,
-            ];
-            if (parent && parent !== 'world') {
-                entityTraits.push(traits.Parent(parent));
-            }
-            if (color) {
-                entityTraits.push(traits.Color(color));
-            }
-            if (center) {
-                entityTraits.push(traits.Center(center));
-            }
-            if (frame.transform.physicalObject) {
-                entityTraits.push(traits.Geometry(frame.transform.physicalObject));
-            }
-            const entity = world.spawn(...entityTraits);
-            entities.set(name, entity);
-        }
-        // Clean up non-active entities
-        for (const [name, entity] of entities) {
-            if (!frames[name]) {
-                entity?.destroy();
-                entities.delete(name);
-            }
-        }
-    });
-    const getParentFrameOptions = (componentName) => {
-        const validFrames = new Set(current.map((frame) => frame.transform.referenceFrame));
-        validFrames.add('world');
-        const frameNameQueue = [componentName];
-        while (frameNameQueue.length > 0) {
-            const frameName = frameNameQueue.shift();
-            if (frameName) {
-                validFrames.delete(frameName);
-                const frames = current.filter((frame) => frame.transform.poseInObserverFrame?.referenceFrame === frameName);
-                for (const frame of frames) {
-                    frameNameQueue.push(frame.transform.referenceFrame);
+                const entity = world.spawn(...entityTraits);
+                entities.set(name, entity);
+            }
+            // Clean up non-active entities
+            for (const [name, entity] of entities) {
+                if (!active[name]) {
+                    entity?.destroy();
+                    entities.delete(name);
+                    continue;
                 }
             }
-        }
-        return Array.from(validFrames);
-    };
+        });
+    });
     setContext(key, {
-        getParentFrameOptions,
         get current() {
             return current;
         },

package/dist/hooks/useGeometries.svelte.js

@@ -68,7 +68,7 @@ export const provideGeometries = (partID) => {
                         for (const geometry of query.data) {
                             index += 1;
                             const resourceName = resources.current[name];
-                            const label = geometry.label ? geometry.label : `${name} geometry ${index}`;
+                            const label = geometry.label || `${name} geometry ${index}`;
                             active[`${name}:${label}`] = true;
                             const pose = createPose(geometry.center);
                             const subtype = resourceName?.subtype;

package/dist/hooks/useLinked.svelte.js

@@ -18,11 +18,12 @@ export const provideLinkedEntities = () => {
             linkedEntities = linkedEntities.filter((e) => e !== target);
         }
     });
+    const unsub = () => {
+        unsubAdd();
+        unsubRemove();
+    };
     $effect(() => {
-        return () => {
-            unsubAdd();
-            unsubRemove();
-        };
+        return unsub;
     });
     setContext(linkedKey, {
         get current() {

package/dist/hooks/usePartConfig.svelte.js

@@ -79,16 +79,16 @@ export const providePartConfig = (partID, params) => {
         const existingFrameIndex = fragmentMod.mods.findLastIndex(
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         (mod) => mod?.['$set']?.[modSetPath] !== undefined);
-        if (existingFrameIndex !== -1) {
+        if (existingFrameIndex === -1) {
+            fragmentMod.mods.push(frame);
+        }
+        else {
             const existingGeometry = fragmentMod.mods[existingFrameIndex]['$set']?.[modSetPath].geometry;
             if (existingGeometry && !frameGeometry) {
                 frame['$set'][modSetPath].geometry = existingGeometry;
             }
             fragmentMod.mods[existingFrameIndex] = frame;
         }
-        else {
-            fragmentMod.mods.push(frame);
-        }
         config.set(newConfig);
     };
     const updatePartFrame = (componentName, referenceFrame, pose, geometry) => {
@@ -126,12 +126,11 @@ export const providePartConfig = (partID, params) => {
     };
     const deletePartFrame = (componentName) => {
         const newConfig = getCurrent();
-        const component = newConfig?.components?.find((comp) => comp.name === componentName);
-        if (!component) {
-            return;
+        const component = newConfig?.components?.find(({ name }) => name === componentName);
+        if (component) {
+            delete component.frame;
+            config.set(newConfig);
         }
-        delete component.frame;
-        config.set(newConfig);
     };
     const deleteFragmentFrame = (fragmentId, componentName) => {
         const newConfig = getCurrent();
@@ -168,29 +167,29 @@ export const providePartConfig = (partID, params) => {
         },
         updateFrame: (componentName, referenceFrame, framePosition, frameGeometry) => {
             const fragmentId = config.componentNameToFragmentId[componentName];
-            if (fragmentId !== undefined) {
-                updateFragmentFrame(fragmentId, componentName, referenceFrame, framePosition, frameGeometry);
+            if (fragmentId === undefined) {
+                updatePartFrame(componentName, referenceFrame, framePosition, frameGeometry);
             }
             else {
-                updatePartFrame(componentName, referenceFrame, framePosition, frameGeometry);
+                updateFragmentFrame(fragmentId, componentName, referenceFrame, framePosition, frameGeometry);
             }
         },
         deleteFrame: (componentName) => {
             const fragmentId = config.componentNameToFragmentId[componentName];
-            if (fragmentId !== undefined) {
-                deleteFragmentFrame(fragmentId, componentName);
+            if (fragmentId === undefined) {
+                deletePartFrame(componentName);
             }
             else {
-                deletePartFrame(componentName);
+                deleteFragmentFrame(fragmentId, componentName);
             }
         },
         createFrame: (componentName) => {
             const fragmentId = config.componentNameToFragmentId[componentName];
-            if (fragmentId !== undefined) {
-                createFragmentFrame(fragmentId, componentName);
+            if (fragmentId === undefined) {
+                createPartFrame(componentName);
             }
             else {
-                createPartFrame(componentName);
+                createFragmentFrame(fragmentId, componentName);
             }
         },
         save: () => config.save?.(),

package/dist/hooks/usePointcloudObjects.svelte.js

@@ -47,10 +47,10 @@ export const providePointcloudObjects = (partID) => {
      */
     $effect(() => {
         for (const [name, query] of propQueries) {
-            if (name && query.data?.objectPointCloudsSupported === false) {
-                if (disabledVisionServices.get(name) === undefined) {
-                    disabledVisionServices.set(name, true);
-                }
+            if (name &&
+                query.data?.objectPointCloudsSupported === false &&
+                disabledVisionServices.get(name) === undefined) {
+                disabledVisionServices.set(name, true);
             }
         }
     });

package/dist/hooks/usePointclouds.svelte.js

@@ -50,10 +50,8 @@ export const providePointclouds = (partID) => {
      */
     $effect(() => {
         for (const [name, query] of propQueries) {
-            if (name && query.data?.supportsPcd === false) {
-                if (disabledCameras.get(name) === undefined) {
-                    disabledCameras.set(name, true);
-                }
+            if (name && query.data?.supportsPcd === false && disabledCameras.get(name) === undefined) {
+                disabledCameras.set(name, true);
             }
         }
     });

package/dist/hooks/usePose.svelte.js

@@ -10,7 +10,7 @@ import { RefetchRates } from '../components/overlay/RefreshRate.svelte';
 import { useLogs } from './useLogs.svelte';
 import { useResourceByName } from './useResourceByName.svelte';
 import { useRefetchPoses } from './useRefetchPoses';
-const origingFrameComponentTypes = ['arm', 'gantry', 'gripper', 'base'];
+const originFrameComponentTypes = new Set(['arm', 'gantry', 'gripper', 'base']);
 export const usePose = (name, parent) => {
     const environment = useEnvironment();
     const logs = useLogs();
@@ -26,12 +26,8 @@ export const usePose = (name, parent) => {
     const frames = useFrames();
     let pose = $state();
     const interval = $derived(refreshRates.get(RefreshRates.poses));
-    const resolvedParent = $derived(origingFrameComponentTypes.includes(parentResource?.subtype ?? '')
-        ? `${parent()}_origin`
-        : parent());
-    const resolvedName = $derived(origingFrameComponentTypes.includes(resource?.subtype ?? '')
-        ? `${currentName}_origin`
-        : currentName);
+    const resolvedParent = $derived(originFrameComponentTypes.has(parentResource?.subtype ?? '') ? `${parent()}_origin` : parent());
+    const resolvedName = $derived(originFrameComponentTypes.has(resource?.subtype ?? '') ? `${currentName}_origin` : currentName);
     const query = createRobotQuery(robotClient, 'getPose', () => [resolvedName, resolvedParent ?? 'world', []], () => ({
         enabled: interval !== RefetchRates.OFF && environment.current.viewerMode === 'monitor',
         refetchInterval: interval === RefetchRates.MANUAL ? false : interval,

package/dist/hooks/useResizable.svelte.js

@@ -28,10 +28,11 @@ export const useResizable = (name, defaultDimensions) => {
         });
         observer.observe(target);
     };
+    const disconnect = () => {
+        observer?.disconnect();
+    };
     $effect(() => {
-        return () => {
-            observer?.disconnect();
-        };
+        return disconnect;
     });
     return {
         get current() {

package/dist/hooks/useSettings.svelte.js

@@ -30,11 +30,11 @@ const defaults = () => ({
     renderSubEntityHoverDetail: false,
     xrController: {
         left: {
-            scaleFactor: 1.0,
+            scaleFactor: 1,
             rotationEnabled: true,
         },
         right: {
-            scaleFactor: 1.0,
+            scaleFactor: 1,
             rotationEnabled: true,
         },
     },

package/dist/hooks/useVisibility.svelte.js

@@ -1,20 +1,8 @@
-import { get, set } from 'idb-keyval';
 import { getContext, setContext } from 'svelte';
 import { SvelteMap } from 'svelte/reactivity';
 const key = Symbol('object-visibility-context');
-const idbKey = 'object-visibility';
 export const provideVisibility = () => {
     const map = new SvelteMap();
-    get(idbKey).then((entries) => {
-        if (entries) {
-            for (const [key, value] of entries) {
-                map.set(key, value);
-            }
-        }
-    });
-    $effect(() => {
-        set(idbKey, [...map.entries()]);
-    });
     setContext(key, map);
 };
 export const useVisibility = () => {

package/dist/hooks/useWeblabs.svelte.js

@@ -17,6 +17,7 @@ const addCookie = (name, value, days, path = '/') => {
         date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000); // days in milliseconds
         expires = '; expires=' + date.toUTCString();
     }
+    // eslint-disable-next-line unicorn/no-document-cookie
     document.cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}${expires}; path=${path}`;
 };
 const getCookieExperiments = () => {
@@ -44,10 +45,10 @@ export const createWeblabs = () => {
     };
 };
 export const provideWeblabs = () => {
-    const urlExperiment = new URLSearchParams(window.location.search).get('experiment');
+    const urlExperiment = new URLSearchParams(globalThis.location.search).get('experiment');
     if (urlExperiment) {
         const experimentSet = new Set([...getCookieExperiments(), urlExperiment]);
-        addCookie('weblab_experiments', Array.from(experimentSet).join(','));
+        addCookie('weblab_experiments', [...experimentSet].join(','));
     }
     setContext(WEBLABS_CONTEXT_KEY, createWeblabs());
 };

package/dist/hooks/useWorldState.svelte.js

@@ -189,15 +189,17 @@ const createWorldState = (client) => {
                 continue;
             }
             switch (event.changeType) {
-                case TransformChangeType.REMOVED:
+                case TransformChangeType.REMOVED: {
                     eventsByUUID.set(uuid, event);
                     break;
-                case TransformChangeType.ADDED:
+                }
+                case TransformChangeType.ADDED: {
                     if (existing.changeType !== TransformChangeType.REMOVED) {
                         eventsByUUID.set(uuid, event);
                     }
                     break;
-                case TransformChangeType.UPDATED:
+                }
+                case TransformChangeType.UPDATED: {
                     // merge with existing updated event
                     if (existing.changeType === TransformChangeType.UPDATED) {
                         existing.updatedFields ??= { paths: [] };
@@ -214,6 +216,7 @@ const createWorldState = (client) => {
                         eventsByUUID.set(uuid, event);
                     }
                     break;
+                }
             }
         }
         pendingEvents.push(...eventsByUUID.values());

package/dist/loaders/pcd/index.js

@@ -22,6 +22,7 @@ export const parsePcdInWorker = (data) => {
     return new Promise((resolve, reject) => {
         const id = ++requestId;
         pending.set(id, { resolve, reject });
-        worker.postMessage({ id, data }, [data.buffer]);
+        const copy = new Uint8Array(data);
+        worker.postMessage({ id, data: copy }, [copy.buffer]);
     });
 };