@viamrobotics/motion-tools 0.19.1 → 1.0.2

package/dist/hooks/usePose.svelte.js

@@ -1,6 +1,6 @@
 import { createResourceClient, createResourceQuery } from '@viamrobotics/svelte-sdk';
 import { usePartID } from './usePartID.svelte';
-import { MotionClient, Transform } from '@viamrobotics/sdk';
+import { MotionClient, Pose, Transform } from '@viamrobotics/sdk';
 import { RefreshRates, useMachineSettings } from './useMachineSettings.svelte';
 import { useMotionClient } from './useMotionClient.svelte';
 import { useEnvironment } from './useEnvironment.svelte';
@@ -12,6 +12,7 @@ import { useLogs } from './useLogs.svelte';
 import { useResourceByName } from './useResourceByName.svelte';
 import { useRefetchPoses } from './useRefetchPoses';
 export const usePose = (name, parent) => {
+    const environment = useEnvironment();
     const logs = useLogs();
     const { refreshRates } = useMachineSettings();
     const partID = usePartID();
@@ -22,15 +23,22 @@ export const usePose = (name, parent) => {
     const { addQueryToRefetch } = useRefetchPoses();
     const resource = $derived(currentName ? resourceByName.current[currentName] : undefined);
     const parentResource = $derived(currentParent ? resourceByName.current[currentParent] : undefined);
-    const environment = useEnvironment();
     const frames = useFrames();
+    let pose = $state(undefined);
     const client = createResourceClient(MotionClient, () => partID.current, () => motionClient.current ?? '');
     const interval = $derived(refreshRates.get(RefreshRates.poses));
-    const resolvedParent = $derived(parentResource?.subtype === 'arm' ? `${parent()}_origin` : parent());
+    const resolvedParent = $derived(parentResource?.subtype === 'arm' || parentResource?.subtype === 'gantry'
+        ? `${parent()}_origin`
+        : parent());
     const query = createResourceQuery(client, 'getPose', () => [currentName, resolvedParent ?? 'world', []], () => ({
-        enabled: interval !== RefetchRates.OFF,
+        enabled: interval !== RefetchRates.OFF && environment.current.viewerMode === 'monitor',
         refetchInterval: interval === RefetchRates.MANUAL ? false : interval,
     }));
+    $effect(() => {
+        if (environment.current.viewerMode === 'monitor') {
+            pose = query.data?.pose;
+        }
+    });
     $effect(() => addQueryToRefetch(query));
     $effect(() => {
         if (query.isFetching) {
@@ -48,13 +56,13 @@ export const usePose = (name, parent) => {
     return {
         get current() {
             /**
-             * Do not return the pose of an arm because in this case the pose represents
+             * Do not return the pose of an arm or gantry because in this case the pose represents
              * the end effector frame and not the origin frame
              */
-            if (resource?.subtype === 'arm') {
+            if (resource?.subtype === 'arm' || resource?.subtype === 'gantry') {
                 return;
             }
-            return query.data?.pose;
+            return pose;
         },
     };
 };

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

@@ -0,0 +1,12 @@
+interface Dimensions {
+    width: number;
+    height: number;
+}
+interface Context {
+    readonly current: Dimensions;
+    readonly isLoaded: boolean;
+    observe: (target: HTMLElement) => void;
+}
+export declare const MIN_DIMENSIONS: Dimensions;
+export declare const useResizable: (name: () => string) => Context;
+export {};

package/dist/hooks/useResizable.svelte.js

@@ -0,0 +1,45 @@
+import { get, set } from 'idb-keyval';
+export const MIN_DIMENSIONS = { width: 240, height: 320 };
+export const useResizable = (name) => {
+    const key = $derived(`${name()}-resizable`);
+    let dimensions = $state.raw(MIN_DIMENSIONS);
+    let loaded = $state(false);
+    let observer;
+    $effect(() => {
+        get(key).then((saved) => {
+            if (saved) {
+                dimensions = saved;
+            }
+            loaded = true;
+        });
+    });
+    const observe = (target) => {
+        // Disconnect previous observer if any
+        observer?.disconnect();
+        observer = new ResizeObserver((entries) => {
+            const entry = entries[0];
+            if (!entry)
+                return;
+            const next = {
+                width: Math.max(entry.contentRect.width, MIN_DIMENSIONS.width),
+                height: Math.max(entry.contentRect.height, MIN_DIMENSIONS.height),
+            };
+            set(key, next);
+        });
+        observer.observe(target);
+    };
+    $effect(() => {
+        return () => {
+            observer?.disconnect();
+        };
+    });
+    return {
+        get current() {
+            return dimensions;
+        },
+        get isLoaded() {
+            return loaded;
+        },
+        observe,
+    };
+};

package/dist/hooks/useResourceByName.svelte.js

@@ -1,7 +1,7 @@
 import { useResourceNames } from '@viamrobotics/svelte-sdk';
 import { getContext, setContext } from 'svelte';
-const key = Symbol('resource-by-name-context');
-export const provideResourceByName = (partID) => {
+export const RESOURCE_BY_NAME_CONTEXT_KEY = Symbol('resource-by-name-context');
+export const createResourceByName = (partID) => {
     const resourceNames = useResourceNames(partID);
     const resourceByName = $derived.by(() => {
         const results = {};
@@ -10,12 +10,15 @@ export const provideResourceByName = (partID) => {
         }
         return results;
     });
-    setContext(key, {
+    return {
         get current() {
             return resourceByName;
         },
-    });
+    };
+};
+export const provideResourceByName = (partID) => {
+    setContext(RESOURCE_BY_NAME_CONTEXT_KEY, createResourceByName(partID));
 };
 export const useResourceByName = () => {
-    return getContext(key);
+    return getContext(RESOURCE_BY_NAME_CONTEXT_KEY);
 };

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

@@ -1,35 +1,25 @@
 import { Object3D } from 'three';
-import type { WorldObject } from '../WorldObject.svelte';
-interface SelectionContext {
-    readonly current: string | undefined;
-    set(value?: string): void;
+import type { Entity } from 'koota';
+interface SelectedEntityContext {
+    readonly current: Entity | undefined;
+    set(entity?: Entity): void;
 }
-interface FocusContext {
-    readonly current: string | undefined;
-    set(value?: string): void;
+interface FocusedEntityContext {
+    readonly current: Entity | undefined;
+    set(entity?: Entity): void;
 }
 export declare const provideSelection: () => {
     selection: {
-        readonly current: string | undefined;
-        set(value?: string): void;
+        readonly current: Entity | undefined;
+        set(entity: Entity): void;
     };
     focus: {
-        readonly current: string | undefined;
-        set(value?: string): void;
+        readonly current: Entity | undefined;
+        set(entity: Entity): void;
     };
-    hover: {
-        readonly current: string | undefined;
-        set(value?: string): void;
-    };
-};
-export declare const useSelected: () => SelectionContext;
-export declare const useFocused: () => FocusContext;
-export declare const useFocusedObject: () => {
-    current: WorldObject | undefined;
-};
-export declare const useSelectedObject: () => {
-    current: WorldObject | undefined;
 };
+export declare const useFocusedEntity: () => FocusedEntityContext;
+export declare const useSelectedEntity: () => SelectedEntityContext;
 export declare const useFocusedObject3d: () => {
     current: Object3D | undefined;
 };

package/dist/hooks/useSelection.svelte.js

@@ -1,65 +1,47 @@
 import { isInstanceOf, useThrelte } from '@threlte/core';
 import { getContext, setContext } from 'svelte';
-import { Matrix4, Object3D } from 'three';
-import { useObjects } from './useObjects.svelte';
-const hoverKey = Symbol('hover-context');
-const selectionKey = Symbol('selection-context');
-const focusKey = Symbol('focus-context');
-const selectedObjectKey = Symbol('selected-frame-context');
-const focusedObjectKey = Symbol('focused-frame-context');
+import { BatchedMesh, Matrix4, Object3D } from 'three';
+import { traits, useTrait, useWorld } from '../ecs';
+const selectedKey = Symbol('selected-frame-context');
+const focusedKey = Symbol('focused-frame-context');
 const focusedObject3dKey = Symbol('focused-object-3d-context');
 export const provideSelection = () => {
-    let selected = $state();
-    let focused = $state();
-    let hovered = $state();
-    const selectionContext = {
+    const world = useWorld();
+    const { scene } = useThrelte();
+    let selected = $state.raw();
+    let focused = $state.raw();
+    $effect(() => {
+        return world.onRemove(traits.Name, (entity) => {
+            if (entity === selected)
+                selected = undefined;
+            if (entity === focused)
+                focused = undefined;
+        });
+    });
+    const selectedEntityContext = {
         get current() {
             return selected;
         },
-        set(value) {
-            selected = value;
+        set(entity) {
+            selected = entity;
         },
     };
-    setContext(selectionKey, selectionContext);
-    const focusContext = {
+    setContext(selectedKey, selectedEntityContext);
+    const focusedEntityContext = {
         get current() {
             return focused;
         },
-        set(value) {
-            focused = value;
-        },
-    };
-    setContext(focusKey, focusContext);
-    const hoverContext = {
-        get current() {
-            return hovered;
-        },
-        set(value) {
-            hovered = value;
-        },
-    };
-    setContext(hoverKey, hoverContext);
-    const objects = useObjects();
-    const selectedObject = $derived(objects.current.find((object) => object.uuid === selected));
-    const selectedObjectContext = {
-        get current() {
-            return selectedObject;
+        set(entity) {
+            focused = entity;
         },
     };
-    setContext(selectedObjectKey, selectedObjectContext);
-    const focusedObject = $derived(objects.current.find((object) => object.uuid === focused));
-    const focusedObjectContext = {
-        get current() {
-            return focusedObject;
-        },
-    };
-    setContext(focusedObjectKey, focusedObjectContext);
-    const { scene } = useThrelte();
-    const uuid = $derived(focusedObject?.uuid);
+    setContext(focusedKey, focusedEntityContext);
     const focusedObject3d = $derived.by(() => {
-        if (!uuid)
+        const name = focused?.get(traits.Name);
+        if (!name) {
             return;
-        const object = scene.getObjectByProperty('uuid', uuid)?.clone();
+        }
+        const object = scene.getObjectByName(name)?.clone();
         object?.traverse((child) => {
             if (isInstanceOf(child, 'LineSegments')) {
                 child.raycast = () => null;
@@ -73,42 +55,40 @@ export const provideSelection = () => {
         },
     });
     return {
-        selection: selectionContext,
-        focus: focusContext,
-        hover: hoverContext,
+        selection: selectedEntityContext,
+        focus: focusedEntityContext,
     };
 };
-export const useSelected = () => {
-    return getContext(selectionKey);
+export const useFocusedEntity = () => {
+    return getContext(focusedKey);
 };
-export const useFocused = () => {
-    return getContext(focusKey);
-};
-export const useFocusedObject = () => {
-    return getContext(focusedObjectKey);
-};
-export const useSelectedObject = () => {
-    return getContext(selectedObjectKey);
+export const useSelectedEntity = () => {
+    return getContext(selectedKey);
 };
 export const useFocusedObject3d = () => {
     return getContext(focusedObject3dKey);
 };
 const matrix = new Matrix4();
 export const useSelectedObject3d = () => {
-    const selectedObject = useSelectedObject();
+    const selectedEntity = useSelectedEntity();
     const { scene } = useThrelte();
+    const name = useTrait(() => selectedEntity.current, traits.Name);
+    const instance = useTrait(() => selectedEntity.current, traits.Instance);
     const object = $derived.by(() => {
-        if (!selectedObject.current) {
+        if (!selectedEntity.current) {
             return;
         }
-        if (selectedObject.current.metadata.batched) {
+        if (instance.current) {
             const proxy = new Object3D();
-            const { id, object } = selectedObject.current.metadata.batched;
-            object.getMatrixAt(id, matrix);
+            const mesh = scene.getObjectById(instance.current.meshID);
+            mesh?.getMatrixAt(instance.current.instanceID, matrix);
             proxy.applyMatrix4(matrix);
             return proxy;
         }
-        return scene.getObjectByProperty('uuid', selectedObject.current.uuid);
+        if (!name.current) {
+            return;
+        }
+        return scene.getObjectByName(name.current);
     });
     return {
         get current() {

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

@@ -1,5 +1,6 @@
+import type { Entity } from 'koota';
 import { SvelteMap } from 'svelte/reactivity';
-type Context = SvelteMap<string, boolean>;
+type Context = SvelteMap<Entity, boolean>;
 export declare const provideVisibility: () => void;
 export declare const useVisibility: () => Context;
 export {};

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

@@ -1,5 +1,4 @@
 export declare const WEBLABS_EXPERIMENTS: {
-    readonly MOTION_TOOLS_EDIT_FRAME: "MOTION_TOOLS_EDIT_FRAME";
     readonly MOTION_TOOLS_RENDER_ARM_MODELS: "MOTION_TOOLS_RENDER_ARM_MODELS";
 };
 export declare const WEBLABS_CONTEXT_KEY: unique symbol;

package/dist/hooks/useWeblabs.svelte.js

@@ -1,7 +1,6 @@
 import { getContext, setContext } from 'svelte';
 import { SvelteSet } from 'svelte/reactivity';
 export const WEBLABS_EXPERIMENTS = {
-    MOTION_TOOLS_EDIT_FRAME: 'MOTION_TOOLS_EDIT_FRAME',
     MOTION_TOOLS_RENDER_ARM_MODELS: 'MOTION_TOOLS_RENDER_ARM_MODELS',
 };
 export const WEBLABS_CONTEXT_KEY = Symbol('weblabs-context');

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

@@ -0,0 +1,9 @@
+import { type TransformChangeEvent, type TransformWithUUID } from '@viamrobotics/sdk';
+export type ChangeMessage = {
+    type: 'change';
+    events: TransformChangeEvent[];
+};
+export type TransformEvent = TransformChangeEvent & {
+    transform: TransformWithUUID;
+};
+export declare const provideWorldStates: () => void;