@viamrobotics/test-widgets 0.3.1 → 0.5.0

package/dist/components/widgets/camera/decode-viam-depth.js

@@ -0,0 +1,114 @@
+/** MIME type used by Viam's custom 16-bit depth format. */
+export const VIAM_DEPTH_MIME_TYPE = 'image/vnd.viam.dep';
+const HEADER_BYTES = 24;
+// Hue sweep used by RDK's ToPrettyPicture: near = warm (~30°), far = cool (~230°).
+const HUE_NEAR = 30;
+const HUE_FAR = 230;
+const hueToRgb = (hue) => {
+    const sector = hue / 60;
+    const x = Math.round((1 - Math.abs((sector % 2) - 1)) * 255);
+    if (sector < 1)
+        return [255, x, 0];
+    if (sector < 2)
+        return [x, 255, 0];
+    if (sector < 3)
+        return [0, 255, x];
+    if (sector < 4)
+        return [0, x, 255];
+    if (sector < 5)
+        return [x, 0, 255];
+    return [255, 0, x];
+};
+/**
+ * Decode the Viam depth format (`image/vnd.viam.dep`) and return a colorized
+ * visualization (warm = near, cool = far), matching the hue sweep that RDK's
+ * `DepthMap.ToPrettyPicture` produces. Pixels with depth 0 are rendered as
+ * opaque black to match RDK. The wire format is:
+ *
+ * - bytes 0–8: magic `DEPTHMAP` (big-endian)
+ * - bytes 8–16: width (big-endian uint64)
+ * - bytes 16–24: height (big-endian uint64)
+ * - bytes 24–end: depth values as big-endian uint16, row-major
+ *
+ * The browser cannot decode this MIME type natively, so depth frames must be
+ * rendered to a canvas ourselves. References:
+ *
+ * - Reader: https://github.com/viamrobotics/rdk/blob/main/rimage/depth_map_raw.go (readDepthMapViam)
+ * - Format registration: https://github.com/viamrobotics/rdk/blob/main/rimage/image_file.go
+ * - Visualization (`DepthMap.ToPrettyPicture`):
+ *   https://github.com/viamrobotics/rdk/blob/main/rimage/depth_map.go
+ * - Python equivalent (`ViamImage.bytes_to_depth_array`):
+ *   https://github.com/viamrobotics/viam-python-sdk/blob/main/src/viam/media/video.py
+ *
+ * Returns undefined if the buffer is too short to be a valid depth image.
+ */
+export const decodeViamDepth = (bytes) => {
+    if (bytes.length < HEADER_BYTES) {
+        return undefined;
+    }
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    // Verify the 8-byte "DEPTHMAP" magic (0x4445505448_4d4150).
+    const magic = view.getBigUint64(0, false);
+    if (magic !== 0x44455054484d4150n) {
+        return undefined;
+    }
+    const width = Number(view.getBigUint64(8, false));
+    const height = Number(view.getBigUint64(16, false));
+    const pixelCount = width * height;
+    if (bytes.length < HEADER_BYTES + pixelCount * 2) {
+        return undefined;
+    }
+    let min = Number.POSITIVE_INFINITY;
+    let max = 0;
+    for (let i = 0; i < pixelCount; i++) {
+        const depth = view.getUint16(HEADER_BYTES + i * 2, false);
+        if (depth === 0)
+            continue;
+        if (depth < min)
+            min = depth;
+        if (depth > max)
+            max = depth;
+    }
+    const span = Number.isFinite(min) ? Math.max(1, max - min) : 1;
+    const base = Number.isFinite(min) ? min : 0;
+    const hueSpan = HUE_FAR - HUE_NEAR;
+    const pixels = new Uint8ClampedArray(pixelCount * 4);
+    for (let i = 0; i < pixelCount; i++) {
+        const depth = view.getUint16(HEADER_BYTES + i * 2, false);
+        const idx = i * 4;
+        pixels[idx + 3] = 255;
+        if (depth === 0) {
+            // Unmeasured pixel — leave RGB at 0 (black) to match RDK.
+            continue;
+        }
+        const ratio = (depth - base) / span;
+        const [r, g, b] = hueToRgb(HUE_NEAR + ratio * hueSpan);
+        pixels[idx] = r;
+        pixels[idx + 1] = g;
+        pixels[idx + 2] = b;
+    }
+    return { width, height, pixels };
+};
+/**
+ * Decode the Viam depth format and return a PNG `Blob` suitable for display or export,
+ * using the same colorization as `decodeViamDepth`.
+ *
+ * Returns `undefined` if the buffer is too short or a canvas context is unavailable.
+ */
+export const getBlobForViamDepth = (bytes) => {
+    const decoded = decodeViamDepth(bytes);
+    if (!decoded)
+        return Promise.resolve(undefined);
+    const offscreen = document.createElement('canvas');
+    offscreen.width = decoded.width;
+    offscreen.height = decoded.height;
+    const ctx = offscreen.getContext('2d');
+    if (!ctx)
+        return Promise.resolve(undefined);
+    const imageData = ctx.createImageData(decoded.width, decoded.height);
+    imageData.data.set(decoded.pixels);
+    ctx.putImageData(imageData, 0, 0);
+    return new Promise((resolve) => {
+        offscreen.toBlob((blob) => resolve(blob ?? undefined), 'image/png');
+    });
+};

package/dist/components/widgets/camera/export-screenshot.svelte

@@ -6,12 +6,16 @@
 
 	import ErrorDisplay from '../../error.svelte'
 
+	import { getBlobForViamDepth, VIAM_DEPTH_MIME_TYPE } from './decode-viam-depth'
+	import { pickImageForSource } from './pick-image-for-source'
+
 	interface Props {
 		name: string
+		sourceName?: string
 		getImage: () => Promise<QueryObserverResult<Awaited<ReturnType<CameraClient['getImages']>>>>
 	}
 
-	const { name, getImage }: Props = $props()
+	const { name, sourceName = '', getImage }: Props = $props()
 
 	let lastError = $state<Error>()
 
@@ -35,7 +39,6 @@
 	}
 
 	const handleExport = async () => {
-		const exportFilename = `${name}-${getDateString()}.jpeg`
 		const image = await getImage()
 		if (image.error) {
 			lastError = image.error
@@ -43,18 +46,36 @@
 		}
 
 		lastError = undefined
-		if (image.data?.images?.[0]?.image) {
-			const imageBlob = new Blob([new Uint8Array(image.data.images[0].image)], {
-				type: image.data.images[0].mimeType || 'image/jpeg',
-			})
+		const matchingImage = pickImageForSource(image.data?.images, sourceName)
+		if (!matchingImage?.image) {
+			return
+		}
 
-			const link = document.createElement('a')
-			const dataUrl = URL.createObjectURL(imageBlob)
-			link.href = dataUrl
-			link.download = exportFilename
-			link.click()
-			URL.revokeObjectURL(dataUrl)
+		const bytes = new Uint8Array(matchingImage.image)
+		let blob: Blob
+		let ext: string
+
+		if (matchingImage.mimeType === VIAM_DEPTH_MIME_TYPE) {
+			// Decode depth frames to a viewable PNG so the exported file matches the live feed.
+			const depthBlob = await getBlobForViamDepth(bytes)
+			if (!depthBlob) {
+				lastError = new Error('Failed to decode depth image')
+				return
+			}
+			blob = depthBlob
+			ext = 'png'
+		} else {
+			blob = new Blob([bytes], { type: matchingImage.mimeType || 'image/jpeg' })
+			ext = 'jpeg'
 		}
+
+		const exportFilename = `${name}-${getDateString()}.${ext}`
+		const link = document.createElement('a')
+		const dataUrl = URL.createObjectURL(blob)
+		link.href = dataUrl
+		link.download = exportFilename
+		link.click()
+		URL.revokeObjectURL(dataUrl)
 	}
 </script>
 

package/dist/components/widgets/camera/export-screenshot.svelte.d.ts

@@ -2,6 +2,7 @@ import type { QueryObserverResult } from '@tanstack/svelte-query';
 import type { CameraClient } from '@viamrobotics/sdk';
 interface Props {
     name: string;
+    sourceName?: string;
     getImage: () => Promise<QueryObserverResult<Awaited<ReturnType<CameraClient['getImages']>>>>;
 }
 declare const ExportScreenshot: import("svelte").Component<Props, {}, "">;

package/dist/components/widgets/camera/get-xmp-json-from-image.d.ts

@@ -0,0 +1,3 @@
+export type XmpJson = Record<string, unknown>;
+/** Extract XMP metadata from image bytes and return it as a plain object. */
+export declare const getXmpJsonFromImageBytes: (image: Uint8Array, mimeType?: string) => XmpJson | null;

package/dist/components/widgets/camera/get-xmp-json-from-image.js

@@ -0,0 +1,134 @@
+const JPEG_SOI = 0xffd8;
+const JPEG_MARKER_PREFIX = 0xff;
+const JPEG_APP1_MARKER = 0xe1;
+const JPEG_EOI_MARKER = 0xd9;
+const XMP_IDENTIFIER = 'http://ns.adobe.com/xap/1.0/\0';
+/** Extract XMP metadata from image bytes and return it as a plain object. */
+export const getXmpJsonFromImageBytes = (image, mimeType) => {
+    if (mimeType?.includes('png')) {
+        return getXmpJsonFromPng(image);
+    }
+    return getXmpJsonFromJpeg(image);
+};
+const getXmpJsonFromJpeg = (image) => {
+    if (image.length < 4 || readUint16(image, 0) !== JPEG_SOI) {
+        return null;
+    }
+    const xmpXml = readXmpXmlFromJpeg(image);
+    if (!xmpXml) {
+        return null;
+    }
+    return xmpXmlToJson(xmpXml);
+};
+const readXmpXmlFromJpeg = (image) => {
+    const identifier = new TextEncoder().encode(XMP_IDENTIFIER);
+    let offset = 2;
+    while (offset + 4 < image.length) {
+        if (image[offset] !== JPEG_MARKER_PREFIX) {
+            break;
+        }
+        const marker = image[offset + 1];
+        if (marker === undefined) {
+            break;
+        }
+        if (marker === JPEG_EOI_MARKER) {
+            break;
+        }
+        const segmentLength = readUint16(image, offset + 2);
+        if (segmentLength < 2 || offset + 2 + segmentLength > image.length) {
+            break;
+        }
+        if (marker === JPEG_APP1_MARKER) {
+            const segmentData = image.subarray(offset + 4, offset + 2 + segmentLength);
+            if (startsWith(segmentData, identifier)) {
+                const xmpBytes = segmentData.subarray(identifier.length);
+                return new TextDecoder('utf-8').decode(xmpBytes);
+            }
+        }
+        offset += 2 + segmentLength;
+    }
+    return null;
+};
+const getXmpJsonFromPng = (image) => {
+    const signature = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+    if (image.length < signature.length || !startsWith(image, new Uint8Array(signature))) {
+        return null;
+    }
+    let offset = signature.length;
+    while (offset + 12 <= image.length) {
+        const chunkLength = readUint32(image, offset);
+        const chunkType = new TextDecoder('ascii').decode(image.subarray(offset + 4, offset + 8));
+        if (chunkType === 'iTXt') {
+            const chunkData = image.subarray(offset + 8, offset + 8 + chunkLength);
+            const xmpXml = readXmpXmlFromPngITXtChunk(chunkData);
+            if (xmpXml) {
+                return xmpXmlToJson(xmpXml);
+            }
+        }
+        offset += 12 + chunkLength;
+    }
+    return null;
+};
+const readXmpXmlFromPngITXtChunk = (chunkData) => {
+    let index = 0;
+    const readNullTerminated = () => {
+        const start = index;
+        while (index < chunkData.length && chunkData[index] !== 0) {
+            index += 1;
+        }
+        if (index >= chunkData.length) {
+            return null;
+        }
+        const value = new TextDecoder('utf-8').decode(chunkData.subarray(start, index));
+        index += 1;
+        return value;
+    };
+    const keyword = readNullTerminated();
+    if (keyword !== 'XML:com.adobe.xmp') {
+        return null;
+    }
+    readNullTerminated(); // compression flag
+    readNullTerminated(); // compression method
+    readNullTerminated(); // language tag
+    readNullTerminated(); // translated keyword
+    if (index >= chunkData.length) {
+        return null;
+    }
+    return new TextDecoder('utf-8').decode(chunkData.subarray(index));
+};
+const xmpXmlToJson = (xmpXml) => {
+    const doc = new DOMParser().parseFromString(xmpXml, 'application/xml');
+    if (doc.querySelector('parsererror')) {
+        return null;
+    }
+    const json = {};
+    for (const element of doc.querySelectorAll('*')) {
+        for (const attribute of element.attributes) {
+            if (attribute.localName === 'about' || attribute.name === 'rdf:about') {
+                continue;
+            }
+            json[attribute.name] = attribute.value;
+        }
+        if (element.childElementCount === 0 && element.textContent?.trim()) {
+            const key = element.prefix ? `${element.prefix}:${element.localName}` : element.localName;
+            json[key] = element.textContent.trim();
+        }
+    }
+    return Object.keys(json).length > 0 ? json : null;
+};
+const readUint16 = (bytes, offset) => (bytes[offset] << 8) | bytes[offset + 1];
+const readUint32 = (bytes, offset) => (bytes[offset] << 24) |
+    (bytes[offset + 1] << 16) |
+    (bytes[offset + 2] << 8) |
+    bytes[offset + 3];
+const startsWith = (bytes, prefix) => {
+    if (bytes.length < prefix.length) {
+        return false;
+    }
+    for (let index = 0; index < prefix.length; index += 1) {
+        if (bytes[index] !== prefix[index]) {
+            return false;
+        }
+    }
+    return true;
+};

package/dist/components/widgets/camera/live-or-polling-video.svelte

@@ -15,6 +15,9 @@
 	import { formatNumeric } from '../../../format'
 	import { useMeasureFps } from '../../../fps.svelte'
 
+	import { getBlobForViamDepth, VIAM_DEPTH_MIME_TYPE } from './decode-viam-depth'
+	import { pickImageForSource } from './pick-image-for-source'
+
 	interface Props {
 		resourceName: string
 		partID: string
@@ -25,6 +28,7 @@
 		isLoading: boolean
 		videoClass?: string
 		showMousePositionTooltip?: boolean
+		sourceName?: string
 		refetch: () => Promise<unknown>
 	}
 
@@ -38,6 +42,7 @@
 		isLoading,
 		videoClass = '',
 		showMousePositionTooltip = false,
+		sourceName = '',
 		refetch,
 	}: Props = $props()
 
@@ -211,16 +216,38 @@
 	})
 
 	$effect(() => {
-		if (!data?.images?.[0]?.image) {
+		const matchingImage = pickImageForSource(data?.images, sourceName)
+		if (!matchingImage?.image) {
 			return
 		}
 
-		const imageBlob = new Blob([new Uint8Array(data.images[0].image)], {
-			type: data.images[0].mimeType || 'image/jpeg',
-		})
+		const bytes = new Uint8Array(matchingImage.image)
+		let cancelled = false
+		let objectUrl: string | undefined
+
+		const render = async () => {
+			let blob: Blob | undefined
+			if (matchingImage.mimeType === VIAM_DEPTH_MIME_TYPE) {
+				blob = await getBlobForViamDepth(bytes)
+				if (!blob) {
+					lastError = new Error('Failed to decode depth frame: truncated or corrupt buffer')
+					return
+				}
+			} else {
+				blob = new Blob([bytes], { type: matchingImage.mimeType || 'image/jpeg' })
+			}
+			if (cancelled) return
+			lastError = undefined
+			objectUrl = URL.createObjectURL(blob)
+			img.src = objectUrl
+		}
+
+		void render()
 
-		img.src = URL.createObjectURL(imageBlob)
-		return () => URL.revokeObjectURL(img.src)
+		return () => {
+			cancelled = true
+			if (objectUrl) URL.revokeObjectURL(objectUrl)
+		}
 	})
 
 	let contentRect = $state.raw<DOMRect>()

package/dist/components/widgets/camera/live-or-polling-video.svelte.d.ts

@@ -10,6 +10,7 @@ interface Props {
     isLoading: boolean;
     videoClass?: string;
     showMousePositionTooltip?: boolean;
+    sourceName?: string;
     refetch: () => Promise<unknown>;
 }
 declare const LiveOrPollingVideo: import("svelte").Component<Props, {}, "">;

package/dist/components/widgets/camera/pick-image-for-source.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Pick the image whose `sourceName` matches the given source, falling back to
+ * the first image.
+ */
+export declare const pickImageForSource: <T extends {
+    sourceName: string;
+}>(images: T[] | undefined, sourceName: string) => T | undefined;

package/dist/components/widgets/camera/pick-image-for-source.js

@@ -0,0 +1,13 @@
+/**
+ * Pick the image whose `sourceName` matches the given source, falling back to
+ * the first image.
+ */
+export const pickImageForSource = (images, sourceName) => {
+    if (!images || images.length === 0) {
+        return undefined;
+    }
+    if (!sourceName) {
+        return images[0];
+    }
+    return images.find((img) => img.sourceName === sourceName) ?? images[0];
+};

package/dist/components/widgets/camera/three-sixty-camera-view.svelte

@@ -0,0 +1,69 @@
+<script lang="ts">
+	import type { QueryObserverResult } from '@tanstack/svelte-query'
+	import type { OrbitControls as OrbitControlsType } from 'three/examples/jsm/controls/OrbitControls.js'
+
+	import { T } from '@threlte/core'
+	import { OrbitControls, useTexture } from '@threlte/extras'
+	import { CameraClient } from '@viamrobotics/sdk'
+	import { BackSide } from 'three'
+
+	const {
+		data,
+	}: { data: QueryObserverResult<Awaited<ReturnType<CameraClient['getImages']>>>['data'] } =
+		$props()
+
+	let imageUrl = $state.raw('')
+	let controlsRef = $state<OrbitControlsType>()
+
+	$effect(() => {
+		const imageRecord = data?.images?.[0]
+		const image = imageRecord?.image
+		if (!image) {
+			imageUrl = ''
+			return
+		}
+
+		const imageBytes = new Uint8Array(image)
+		const imageBlob = new Blob([imageBytes], {
+			type: imageRecord.mimeType || 'image/jpeg',
+		})
+		const url = URL.createObjectURL(imageBlob)
+		imageUrl = url
+
+		return () => {
+			URL.revokeObjectURL(url)
+		}
+	})
+
+	const texture = $derived.by(() => (imageUrl ? useTexture(imageUrl) : null))
+</script>
+
+<T.PerspectiveCamera
+	makeDefault
+	position={[0, 0, 0.1]}
+	fov={75}
+>
+	<OrbitControls
+		bind:ref={controlsRef}
+		enableZoom={true}
+		enablePan={false}
+	/>
+</T.PerspectiveCamera>
+
+{#if $texture}
+	{#await texture then map}
+		<T.Mesh scale={[-1, 1, 1]}>
+			<T.SphereGeometry args={[500, 60, 40]} />
+			<T.MeshBasicMaterial
+				{map}
+				side={BackSide}
+			/>
+		</T.Mesh>
+	{/await}
+{/if}
+
+<T.AmbientLight intensity={0.5} />
+<T.DirectionalLight
+	position={[5, 5, 5]}
+	intensity={1}
+/>

package/dist/components/widgets/camera/three-sixty-camera-view.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { QueryObserverResult } from '@tanstack/svelte-query';
+import { CameraClient } from '@viamrobotics/sdk';
+type $$ComponentProps = {
+    data: QueryObserverResult<Awaited<ReturnType<CameraClient['getImages']>>>['data'];
+};
+declare const ThreeSixtyCameraView: import("svelte").Component<$$ComponentProps, {}, "">;
+type ThreeSixtyCameraView = ReturnType<typeof ThreeSixtyCameraView>;
+export default ThreeSixtyCameraView;

package/dist/components/widgets/do-command/do-command.svelte

@@ -6,7 +6,8 @@
 	import { PersistedState } from 'runed'
 
 	import { supportsDoCommand } from '../../../client-map'
-	import { getResourceAPI, getResourceKey } from '../../../resource'
+	import { getResourceAPI } from '../../../get-resource-api'
+	import { getResourceKey } from '../../../get-resource-key'
 
 	import ErrorDisplay from '../../error.svelte'
 	import { createDoCommandClient } from './create-do-command-client.svelte'

package/dist/components/widgets/gripper/gripper.svelte

@@ -8,6 +8,7 @@
 	import StopButton from '../../stop-button.svelte'
 
 	import Grab from './grab.svelte'
+	import IsHoldingSomething from './is-holding-something.svelte'
 	import Open from './open.svelte'
 
 	interface Props {
@@ -63,6 +64,10 @@
 					{partID}
 					{resourceName}
 				/>
+				<IsHoldingSomething
+					{partID}
+					{resourceName}
+				/>
 			</div>
 		</div>
 	{/snippet}

package/dist/components/widgets/gripper/is-holding-something.svelte

@@ -0,0 +1,57 @@
+<script lang="ts">
+	import { Pill } from '@viamrobotics/prime-core'
+	import { GripperClient } from '@viamrobotics/sdk'
+	import { createResourceClient, createResourceQuery } from '@viamrobotics/svelte-sdk'
+
+	import ApiSection from '../../api-section.svelte'
+	import Query from '../../query.svelte'
+	import StatusPill from '../../status-pill.svelte'
+
+	import ClosedGripperSvg from './closed-gripper-svg.svelte'
+	import OpenGripperSvg from './open-gripper-svg.svelte'
+
+	interface Props {
+		partID: string
+		resourceName: string
+	}
+
+	const { partID, resourceName }: Props = $props()
+
+	const client = createResourceClient(
+		GripperClient,
+		() => partID,
+		() => resourceName
+	)
+
+	const query = createResourceQuery(client, 'isHoldingSomething', {
+		refetchInterval: 500,
+	})
+</script>
+
+<ApiSection
+	title="IsHoldingSomething"
+	bottomText="Updates automatically"
+	class="grow"
+>
+	<Query
+		{query}
+		contentCx="h-5"
+	>
+		<div class="flex items-center gap-2">
+			{#if query.data !== undefined}
+				{#if query.data}
+					<ClosedGripperSvg />
+				{:else}
+					<OpenGripperSvg />
+				{/if}
+				<StatusPill
+					isActive={query.data}
+					activeText="Holding"
+					inactiveText="Empty"
+				/>
+			{:else}
+				<Pill value="Loading" />
+			{/if}
+		</div>
+	</Query>
+</ApiSection>

package/dist/components/widgets/gripper/is-holding-something.svelte.d.ts

@@ -0,0 +1,7 @@
+interface Props {
+    partID: string;
+    resourceName: string;
+}
+declare const IsHoldingSomething: import("svelte").Component<Props, {}, "">;
+type IsHoldingSomething = ReturnType<typeof IsHoldingSomething>;
+export default IsHoldingSomething;

package/dist/get-resource-api.d.ts

@@ -0,0 +1,2 @@
+import type { ResourceName } from '@viamrobotics/sdk';
+export declare const getResourceAPI: ({ namespace, type, subtype }: ResourceName) => string;

package/dist/get-resource-api.js

@@ -0,0 +1 @@
+export const getResourceAPI = ({ namespace, type, subtype }) => `${namespace}:${type}:${subtype}`;

package/dist/get-resource-key.d.ts

@@ -0,0 +1,2 @@
+import type { ResourceName } from '@viamrobotics/sdk';
+export declare const getResourceKey: (name: ResourceName) => string;

package/dist/get-resource-key.js

@@ -0,0 +1,2 @@
+import { getResourceAPI } from "./get-resource-api.js";
+export const getResourceKey = (name) => `${getResourceAPI(name)}/${name.name}`;

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { createAddImageToDatasetContext, type ImageData, useAddImageToDataset, } from './add-image-to-dataset';
 export { clientForResource } from './client-map';
 export * from './components';
+export { getResourceAPI } from './get-resource-api';
 export { providePip, usePip } from './pip/context.svelte';
-export { getResourceAPI, hasWidget, showResourceWidget, widgetForResource } from './resource';
+export { hasWidget, showResourceWidget, widgetForResource } from './resource';

package/dist/index.js

@@ -1,5 +1,6 @@
 export { createAddImageToDatasetContext, useAddImageToDataset, } from './add-image-to-dataset';
 export { clientForResource } from './client-map';
 export * from './components';
+export { getResourceAPI } from './get-resource-api';
 export { providePip, usePip } from './pip/context.svelte';
-export { getResourceAPI, hasWidget, showResourceWidget, widgetForResource } from './resource';
+export { hasWidget, showResourceWidget, widgetForResource } from './resource';

package/dist/resource.d.ts

@@ -16,8 +16,6 @@ export declare const ResourceStatusText: {
     1: string;
     4: string;
 };
-export declare const getResourceAPI: ({ namespace, type, subtype }: ResourceName) => string;
-export declare const getResourceKey: (name: ResourceName) => string;
 export declare const sortResourceNames: (names: ResourceName[]) => ResourceName[];
 export declare const hasWidget: (resource: ResourceName) => boolean;
 export declare const widgetForResource: (resource: ResourceName) => Component<ResourceWidget> | undefined;

package/dist/resource.js

@@ -1,6 +1,7 @@
 import { robotApi } from '@viamrobotics/sdk';
 import { clientMap } from "./client-map.js";
 import { ArmWidget, AudioInputWidget, AudioOutputWidget, BaseWidget, BoardWidget, ButtonWidget, CameraWidget, DiscoveryWidget, EncoderWidget, GantryWidget, GripperWidget, InputControllerWidget, MLModelServiceWidget, MotorWidget, MovementSensorWidget, NavigationServiceWidget, PowerSensorWidget, SensorWidget, ServoWidget, SlamWidget, SwitchWidget, VisionServiceWidget, } from './components';
+import { getResourceAPI } from "./get-resource-api.js";
 export const ResourceStatusText = {
     [robotApi.ResourceStatus_State.UNSPECIFIED]: 'unspecified',
     [robotApi.ResourceStatus_State.READY]: 'ready',
@@ -63,8 +64,6 @@ const resourceMap =
     'rdk:service:world_state_store': [clientMap['rdk:service:world_state_store'], undefined, true],
     'rdk:service:video': [clientMap['rdk:service:video'], undefined, true],
 };
-export const getResourceAPI = ({ namespace, type, subtype }) => `${namespace}:${type}:${subtype}`;
-export const getResourceKey = (name) => `${getResourceAPI(name)}/${name.name}`;
 // sorts resource names by local/remote -> type -> name (alphabetical) to produce a list like
 // component a
 // component z