@fcannizzaro/streamdeck-react 0.1.11 → 0.1.12

package/dist/action.js

@@ -5,7 +5,6 @@ function defineAction(config) {
 		key: config.key,
 		dial: config.dial,
 		touchStrip: config.touchStrip,
-		touchStripFPS: config.touchStripFPS,
 		dialLayout: config.dialLayout,
 		wrapper: config.wrapper,
 		defaultSettings: config.defaultSettings ?? {}

package/dist/adapter/index.d.ts

@@ -0,0 +1,2 @@
+export type { StreamDeckAdapter, AdapterActionHandle, AdapterActionCallbacks, AdapterWillAppearEvent, AdapterActionDevice, AdapterController, AdapterCoordinates, AdapterSize, AdapterTriggerDescription, AdapterKeyDownPayload, AdapterKeyUpPayload, AdapterDialRotatePayload, AdapterDialPressPayload, AdapterTouchTapPayload, } from './types';
+export { physicalDevice } from './physical-device';

package/dist/adapter/physical-device.d.ts

@@ -0,0 +1,2 @@
+import { StreamDeckAdapter } from './types';
+export declare function physicalDevice(): StreamDeckAdapter;

package/dist/adapter/physical-device.js

@@ -0,0 +1,153 @@
+import streamDeck, { SingletonAction } from "@elgato/streamdeck";
+//#region src/adapter/physical-device.ts
+function wrapSdkAction(action) {
+	return {
+		id: action.id,
+		device: {
+			id: action.device.id,
+			type: action.device.type,
+			size: action.device.size,
+			name: action.device.name
+		},
+		controllerType: action.controllerType,
+		coordinates: "coordinates" in action ? action.coordinates : void 0,
+		async setImage(dataUri) {
+			if ("setImage" in action) await action.setImage(dataUri);
+		},
+		async setTitle(title) {
+			if ("setTitle" in action) await action.setTitle(title);
+		},
+		async showOk() {
+			if ("showOk" in action) await action.showOk();
+		},
+		async showAlert() {
+			await action.showAlert();
+		},
+		async setSettings(settings) {
+			await action.setSettings(settings);
+		},
+		async setFeedback(payload) {
+			if ("setFeedback" in action) await action.setFeedback(payload);
+		},
+		async setFeedbackLayout(layout) {
+			if ("setFeedbackLayout" in action) await action.setFeedbackLayout(layout);
+		},
+		async setTriggerDescription(hints) {
+			if ("setTriggerDescription" in action) await action.setTriggerDescription({
+				rotate: hints.rotate,
+				push: hints.push,
+				touch: hints.touch,
+				longTouch: hints.longTouch
+			});
+		}
+	};
+}
+function physicalDevice() {
+	return {
+		pluginUUID: streamDeck.info.plugin.uuid,
+		async connect() {
+			await streamDeck.connect();
+		},
+		async getGlobalSettings() {
+			return streamDeck.settings.getGlobalSettings();
+		},
+		async setGlobalSettings(settings) {
+			await streamDeck.settings.setGlobalSettings(settings);
+		},
+		onGlobalSettingsChanged(callback) {
+			streamDeck.settings.onDidReceiveGlobalSettings((ev) => {
+				callback(ev.settings);
+			});
+		},
+		registerAction(uuid, callbacks) {
+			const singletonAction = new class extends SingletonAction {
+				manifestId = uuid;
+				onWillAppear(ev) {
+					callbacks.onWillAppear({
+						action: wrapSdkAction(ev.action),
+						payload: {
+							settings: ev.payload.settings,
+							controller: ev.payload.controller,
+							isInMultiAction: ev.payload.isInMultiAction
+						}
+					});
+				}
+				onWillDisappear(ev) {
+					callbacks.onWillDisappear(ev.action.id);
+				}
+				onKeyDown(ev) {
+					callbacks.onKeyDown(ev.action.id, {
+						settings: ev.payload.settings,
+						isInMultiAction: ev.payload.isInMultiAction,
+						state: ev.payload.state,
+						userDesiredState: "userDesiredState" in ev.payload ? ev.payload.userDesiredState : void 0
+					});
+				}
+				onKeyUp(ev) {
+					callbacks.onKeyUp(ev.action.id, {
+						settings: ev.payload.settings,
+						isInMultiAction: ev.payload.isInMultiAction,
+						state: ev.payload.state,
+						userDesiredState: "userDesiredState" in ev.payload ? ev.payload.userDesiredState : void 0
+					});
+				}
+				onDialRotate(ev) {
+					callbacks.onDialRotate(ev.action.id, {
+						ticks: ev.payload.ticks,
+						pressed: ev.payload.pressed,
+						settings: ev.payload.settings
+					});
+				}
+				onDialDown(ev) {
+					callbacks.onDialDown(ev.action.id, {
+						settings: ev.payload.settings,
+						controller: "Encoder"
+					});
+				}
+				onDialUp(ev) {
+					callbacks.onDialUp(ev.action.id, {
+						settings: ev.payload.settings,
+						controller: "Encoder"
+					});
+				}
+				onTouchTap(ev) {
+					callbacks.onTouchTap(ev.action.id, {
+						tapPos: ev.payload.tapPos,
+						hold: ev.payload.hold,
+						settings: ev.payload.settings
+					});
+				}
+				onDidReceiveSettings(ev) {
+					callbacks.onDidReceiveSettings(ev.action.id, ev.payload.settings);
+				}
+				onSendToPlugin(ev) {
+					callbacks.onSendToPlugin(ev.action.id, ev.payload);
+				}
+				onPropertyInspectorDidAppear(ev) {
+					callbacks.onPropertyInspectorDidAppear(ev.action.id);
+				}
+				onPropertyInspectorDidDisappear(ev) {
+					callbacks.onPropertyInspectorDidDisappear(ev.action.id);
+				}
+				onTitleParametersDidChange(ev) {
+					callbacks.onTitleParametersDidChange(ev.action.id, {
+						title: ev.payload.title,
+						settings: ev.payload.settings
+					});
+				}
+			}();
+			streamDeck.actions.registerAction(singletonAction);
+		},
+		async openUrl(url) {
+			await streamDeck.system.openUrl(url);
+		},
+		async switchToProfile(deviceId, profile) {
+			await streamDeck.profiles.switchToProfile(deviceId, profile);
+		},
+		async sendToPropertyInspector(payload) {
+			await streamDeck.ui.sendToPropertyInspector(payload);
+		}
+	};
+}
+//#endregion
+export { physicalDevice };

package/dist/adapter/types.d.ts

@@ -0,0 +1,127 @@
+import { JsonObject, JsonValue } from '@elgato/utils';
+/** Controller surface type. Matches SDK Controller values exactly. */
+export type AdapterController = "Keypad" | "Encoder";
+/** Grid coordinates for a key or encoder on a device. */
+export interface AdapterCoordinates {
+    readonly column: number;
+    readonly row: number;
+}
+/** Device grid size (number of key columns and rows). */
+export interface AdapterSize {
+    readonly columns: number;
+    readonly rows: number;
+}
+/** Hint labels for dial/encoder trigger zones shown on the Stream Deck LCD. */
+export interface AdapterTriggerDescription {
+    rotate?: string;
+    push?: string;
+    touch?: string;
+    longTouch?: string;
+}
+export interface AdapterActionHandle {
+    readonly id: string;
+    readonly device: AdapterActionDevice;
+    readonly controllerType: AdapterController;
+    readonly coordinates?: AdapterCoordinates;
+    /** Push a rendered data URI to the key display. No-op on encoder surfaces. */
+    setImage(dataUri: string): Promise<void>;
+    /** Set the key title overlay. No-op on encoder surfaces. */
+    setTitle(title: string): Promise<void>;
+    /** Flash the OK checkmark on the key. No-op on encoder surfaces. */
+    showOk(): Promise<void>;
+    /** Flash the alert triangle on the action. */
+    showAlert(): Promise<void>;
+    /** Persist action settings to the Stream Deck. */
+    setSettings(settings: JsonObject): Promise<void>;
+    /** Push dial/touchstrip feedback payload. No-op on key surfaces. */
+    setFeedback(payload: Record<string, unknown>): Promise<void>;
+    /** Set the encoder feedback layout (JSON or layout ID). No-op on key surfaces. */
+    setFeedbackLayout(layout: string | Record<string, unknown>): Promise<void>;
+    /** Set dial hint text (rotate, push, touch labels). No-op on key surfaces. */
+    setTriggerDescription(hints: AdapterTriggerDescription): Promise<void>;
+}
+/** Device info as seen from an action event. */
+export interface AdapterActionDevice {
+    readonly id: string;
+    /**
+     * Numeric device type matching Elgato DeviceType enum values.
+     * Using `number` instead of the SDK's enum avoids coupling to specific
+     * device models while remaining compatible with the KEY_SIZES lookup
+     * table in registry.ts.
+     */
+    readonly type: number;
+    readonly size: AdapterSize;
+    readonly name: string;
+}
+/** Event payload provided to onWillAppear callbacks. */
+export interface AdapterWillAppearEvent {
+    action: AdapterActionHandle;
+    payload: {
+        settings: JsonObject;
+        controller: AdapterController;
+        isInMultiAction: boolean;
+    };
+}
+export interface AdapterKeyDownPayload {
+    settings: JsonObject;
+    isInMultiAction: boolean;
+    state?: number;
+    userDesiredState?: number;
+}
+export interface AdapterKeyUpPayload {
+    settings: JsonObject;
+    isInMultiAction: boolean;
+    state?: number;
+    userDesiredState?: number;
+}
+export interface AdapterDialRotatePayload {
+    ticks: number;
+    pressed: boolean;
+    settings: JsonObject;
+}
+export interface AdapterDialPressPayload {
+    settings: JsonObject;
+    controller: "Encoder";
+}
+export interface AdapterTouchTapPayload {
+    tapPos: [x: number, y: number];
+    hold: boolean;
+    settings: JsonObject;
+}
+export interface AdapterActionCallbacks {
+    onWillAppear(ev: AdapterWillAppearEvent): void;
+    onWillDisappear(actionId: string): void;
+    onKeyDown(actionId: string, payload: AdapterKeyDownPayload): void;
+    onKeyUp(actionId: string, payload: AdapterKeyUpPayload): void;
+    onDialRotate(actionId: string, payload: AdapterDialRotatePayload): void;
+    onDialDown(actionId: string, payload: AdapterDialPressPayload): void;
+    onDialUp(actionId: string, payload: AdapterDialPressPayload): void;
+    onTouchTap(actionId: string, payload: AdapterTouchTapPayload): void;
+    onDidReceiveSettings(actionId: string, settings: JsonObject): void;
+    onSendToPlugin(actionId: string, payload: JsonValue): void;
+    onPropertyInspectorDidAppear(actionId: string): void;
+    onPropertyInspectorDidDisappear(actionId: string): void;
+    onTitleParametersDidChange(actionId: string, payload: {
+        title: string;
+        settings: JsonObject;
+    }): void;
+}
+export interface StreamDeckAdapter {
+    /** Plugin UUID, used for devtools identification. */
+    readonly pluginUUID: string;
+    /** Initialize the adapter and connect to the backend. */
+    connect(): Promise<void>;
+    /** Retrieve plugin-wide global settings. */
+    getGlobalSettings<T extends JsonObject = JsonObject>(): Promise<T>;
+    /** Persist plugin-wide global settings. */
+    setGlobalSettings<T extends JsonObject = JsonObject>(settings: T): Promise<void>;
+    /** Subscribe to external global settings changes (e.g. from Property Inspector). */
+    onGlobalSettingsChanged(callback: (settings: JsonObject) => void): void;
+    registerAction(uuid: string, callbacks: AdapterActionCallbacks): void;
+    /** Open a URL in the user's default browser. */
+    openUrl(url: string): Promise<void>;
+    /** Switch the active Stream Deck profile. */
+    switchToProfile(deviceId: string, profile: string): Promise<void>;
+    /** Send a payload to the Property Inspector. */
+    sendToPropertyInspector(payload: JsonValue): Promise<void>;
+}

package/dist/devtools/bridge.d.ts

@@ -63,7 +63,7 @@ export declare class DevtoolsBridge implements RegistryObserver {
     private static readonly TB_PREFIX;
     private handleHighlight;
     /**
-     * Restore a highlighted action or touchstrip to its normal state.
+     * Restore a highlighted action or TouchStrip to its normal state.
      * Un-suppresses hardware pushes and restores the original image(s).
      */
     private restoreHighlight;
@@ -73,7 +73,7 @@ export declare class DevtoolsBridge implements RegistryObserver {
     private broadcastHighlightRender;
     /**
      * Clear highlight URIs for the given actionId.
-     * For touchstrip IDs, clears all per-segment keys (touchstrip:*:seg:N).
+     * For TouchStrip IDs, clears all per-segment keys (touchStrip:*:seg:N).
      * For regular actions, clears the single actionId key.
      */
     private broadcastHighlightClear;

package/dist/devtools/bridge.js

@@ -141,7 +141,7 @@ var DevtoolsBridge = class DevtoolsBridge {
 			columns: /* @__PURE__ */ new Map()
 		});
 		this.eventBusOwners.set(root.eventBus, {
-			actionId: `touchstrip:${deviceId}`,
+			actionId: `touchStrip:${deviceId}`,
 			uuid: ""
 		});
 	}
@@ -339,8 +339,7 @@ var DevtoolsBridge = class DevtoolsBridge {
 	/** Convert internal RenderProfile to wire-protocol ProfileData. */
 	toProfileData(profile) {
 		return {
-			vnodeToElementMs: profile.vnodeToElementMs,
-			fromJsxMs: profile.fromJsxMs,
+			vnodeConversionMs: profile.vnodeConversionMs,
 			takumiRenderMs: profile.takumiRenderMs,
 			hashMs: profile.hashMs,
 			base64Ms: profile.base64Ms,
@@ -363,7 +362,7 @@ var DevtoolsBridge = class DevtoolsBridge {
 			});
 		}
 		const msg = {
-			type: "render:touchstrip",
+			type: "render:touchStrip",
 			ts: Date.now(),
 			deviceId,
 			canvas: {
@@ -377,7 +376,7 @@ var DevtoolsBridge = class DevtoolsBridge {
 		};
 		this.server.broadcast(msg);
 	}
-	static TB_PREFIX = "touchstrip:";
+	static TB_PREFIX = "touchStrip:";
 	async handleHighlight(actionId, nodeId) {
 		try {
 			const prevId = this.highlightedActionId;
@@ -419,7 +418,7 @@ var DevtoolsBridge = class DevtoolsBridge {
 		} catch {}
 	}
 	/**
-	* Restore a highlighted action or touchstrip to its normal state.
+	* Restore a highlighted action or TouchStrip to its normal state.
 	* Un-suppresses hardware pushes and restores the original image(s).
 	*/
 	async restoreHighlight(id) {
@@ -454,7 +453,7 @@ var DevtoolsBridge = class DevtoolsBridge {
 			const segmentWidth = 200;
 			const segmentHeight = 100;
 			const fullWidth = (Math.max(...columns) + 1) * segmentWidth;
-			const result = await renderTouchStripWithHighlight(tb.root.vcontainer, fullWidth, segmentHeight, columns, segmentWidth, this.renderConfig.touchstripImageFormat, this.renderConfig, nodeId);
+			const result = await renderTouchStripWithHighlight(tb.root.vcontainer, fullWidth, segmentHeight, columns, segmentWidth, this.renderConfig, nodeId);
 			if (result && this.highlightedActionId === actionId && this.highlightedNodeId === nodeId) {
 				await tb.root.pushSegmentImages(result.segmentUris);
 				for (const [col, uri] of result.segmentUris) this.broadcastHighlightRender(`${actionId}:seg:${col}`, uri);
@@ -473,7 +472,7 @@ var DevtoolsBridge = class DevtoolsBridge {
 	}
 	/**
 	* Clear highlight URIs for the given actionId.
-	* For touchstrip IDs, clears all per-segment keys (touchstrip:*:seg:N).
+	* For TouchStrip IDs, clears all per-segment keys (touchStrip:*:seg:N).
 	* For regular actions, clears the single actionId key.
 	*/
 	broadcastHighlightClear(id) {

package/dist/devtools/highlight.d.ts

@@ -1,4 +1,3 @@
-import { OutputFormat } from '@takumi-rs/core';
 import { VContainer } from '../reconciler/vnode';
 import { RenderConfig } from '../render/pipeline';
 export declare function renderWithHighlight(container: VContainer, width: number, height: number, config: RenderConfig, targetNid: number): Promise<string | null>;
@@ -6,4 +5,4 @@ export interface TouchStripHighlightResult {
     /** Per-column data URIs for ALL segments. */
     segmentUris: Map<number, string>;
 }
-export declare function renderTouchStripWithHighlight(container: VContainer, fullWidth: number, segmentHeight: number, columns: number[], segmentWidth: number, format: OutputFormat, config: RenderConfig, targetNid: number): Promise<TouchStripHighlightResult | null>;
+export declare function renderTouchStripWithHighlight(container: VContainer, fullWidth: number, segmentHeight: number, columns: number[], segmentWidth: number, config: RenderConfig, targetNid: number): Promise<TouchStripHighlightResult | null>;

package/dist/devtools/highlight.js

@@ -18,7 +18,8 @@ async function renderWithHighlight(container, width, height, config, targetNid)
 		devicePixelRatio: config.devicePixelRatio
 	}), config.imageFormat);
 }
-async function renderTouchStripWithHighlight(container, fullWidth, segmentHeight, columns, segmentWidth, format, config, targetNid) {
+var TOUCHSTRIP_HIGHLIGHT_FORMAT = "png";
+async function renderTouchStripWithHighlight(container, fullWidth, segmentHeight, columns, segmentWidth, config, targetNid) {
 	if (container.children.length === 0) return null;
 	const effectiveNid = resolveTargetNid(container, targetNid);
 	const rootNode = buildTakumiRoot(container);
@@ -50,10 +51,10 @@ async function renderTouchStripWithHighlight(container, fullWidth, segmentHeight
 		const segBuffer = await config.renderer.render(clipNode, {
 			width: segmentWidth,
 			height: segmentHeight,
-			format,
+			format: TOUCHSTRIP_HIGHLIGHT_FORMAT,
 			devicePixelRatio: config.devicePixelRatio
 		});
-		segmentUris.set(column, bufferToDataUri(segBuffer, format));
+		segmentUris.set(column, bufferToDataUri(segBuffer, TOUCHSTRIP_HIGHLIGHT_FORMAT));
 	});
 	await Promise.all(segmentPromises);
 	return { segmentUris };

package/dist/devtools/types.d.ts

@@ -150,7 +150,7 @@ export interface RenderMessage extends BaseMessage {
     profile?: ProfileData;
 }
 export interface TouchStripRenderMessage extends BaseMessage {
-    type: "render:touchstrip";
+    type: "render:touchStrip";
     deviceId: string;
     canvas: {
         width: number;
@@ -179,7 +179,7 @@ export interface LifecycleMessage extends BaseMessage {
     event: "appear" | "disappear";
     actionId: string;
     actionUuid: string;
-    surface: "key" | "dial" | "touch" | "touchstrip";
+    surface: "key" | "dial" | "touch" | "touchStrip";
     device: {
         id: string;
         type: number;
@@ -203,8 +203,8 @@ export interface HighlightRenderMessage extends BaseMessage {
 }
 /** Per-render pipeline timing data, embedded in RenderMessage. */
 export interface ProfileData {
-    vnodeToElementMs: number;
-    fromJsxMs: number;
+    /** Time to convert VNode tree to Takumi node tree (ms). */
+    vnodeConversionMs: number;
     takumiRenderMs: number;
     hashMs: number;
     base64Ms: number;
@@ -234,7 +234,7 @@ export interface MetricsData {
     /** Image cache memory usage in bytes. */
     imageCacheBytes: number;
     /** TouchStrip cache memory usage in bytes. */
-    touchstripCacheBytes: number;
+    touchStripCacheBytes: number;
 }
 export interface MetricsMessage extends BaseMessage {
     type: "metrics";

package/dist/hooks/animation.d.ts

@@ -35,7 +35,7 @@ export interface TweenConfig {
     duration: number;
     /** Easing function name or custom (t: number) => number. @default "easeOut" */
     easing: EasingName | EasingFn;
-    /** Target FPS for the animation tick loop. @default 60 */
+    /** Target FPS for the animation tick loop. @default 30 */
     fps: number;
 }
 export interface TweenResult<T extends AnimationTarget> {

package/dist/hooks/animation.js

@@ -12,7 +12,7 @@ var SPRING_DEFAULTS = {
 var TWEEN_DEFAULTS = {
 	duration: 300,
 	easing: "easeOut",
-	fps: 60
+	fps: 30
 };
 /** Max dt cap to prevent spring explosion after long pauses.
 *  If the process is suspended (debugger, GC pause), dt could be
@@ -196,7 +196,7 @@ function useSpring(target, config) {
 		config?.displacementThreshold,
 		config?.clamp
 	]);
-	const fps = config?.fps ?? 60;
+	const fps = config?.fps ?? 30;
 	const isObject = typeof target === "object" && target !== null;
 	const stateRef = useRef(null);
 	if (stateRef.current === null) stateRef.current = initializeSpringState(target);

package/dist/hooks/events.js

@@ -38,7 +38,7 @@ function useTouchTap(callback) {
 function useDialHint(hints) {
 	const { action } = useContext(StreamDeckContext);
 	useEffect(() => {
-		if ("setTriggerDescription" in action) action.setTriggerDescription({
+		action.setTriggerDescription({
 			rotate: hints.rotate,
 			push: hints.press,
 			touch: hints.touch,

package/dist/hooks/sdk.js

@@ -3,23 +3,23 @@ import { useCallbackRef } from "./internal/useCallbackRef.js";
 import { useCallback, useContext, useEffect } from "react";
 //#region src/hooks/sdk.ts
 function useOpenUrl() {
-	const { sdk } = useContext(StreamDeckContext);
+	const { adapter } = useContext(StreamDeckContext);
 	return useCallback(async (url) => {
-		await sdk.system.openUrl(url);
-	}, [sdk]);
+		await adapter.openUrl(url);
+	}, [adapter]);
 }
 function useSwitchProfile() {
-	const { sdk, action } = useContext(StreamDeckContext);
+	const { adapter, action } = useContext(StreamDeckContext);
 	return useCallback(async (profile, deviceId) => {
 		const devId = deviceId ?? action.device.id;
-		await sdk.profiles.switchToProfile(devId, profile);
-	}, [sdk, action]);
+		await adapter.switchToProfile(devId, profile);
+	}, [adapter, action]);
 }
 function useSendToPI() {
-	const { sdk } = useContext(StreamDeckContext);
+	const { adapter } = useContext(StreamDeckContext);
 	return useCallback(async (payload) => {
-		await sdk.ui.sendToPropertyInspector(payload);
-	}, [sdk]);
+		await adapter.sendToPropertyInspector(payload);
+	}, [adapter]);
 }
 function usePropertyInspector(callback) {
 	const bus = useContext(EventBusContext);
@@ -41,13 +41,13 @@ function useShowAlert() {
 function useShowOk() {
 	const { action } = useContext(StreamDeckContext);
 	return useCallback(async () => {
-		if ("showOk" in action) await action.showOk();
+		await action.showOk();
 	}, [action]);
 }
 function useTitle() {
 	const { action } = useContext(StreamDeckContext);
 	return useCallback(async (title) => {
-		if ("setTitle" in action) await action.setTitle(title);
+		await action.setTitle(title);
 	}, [action]);
 }
 //#endregion

package/dist/hooks/utility.js

@@ -1,10 +1,11 @@
 import { useCallbackRef } from "./internal/useCallbackRef.js";
 import { useCallback, useEffect, useMemo, useRef } from "react";
 //#region src/hooks/utility.ts
-var DEFAULT_TICK_FPS = 60;
+var DEFAULT_TICK_FPS = 30;
+var MAX_TICK_FPS = 30;
 function toTickIntervalMs(fps) {
 	if (!Number.isFinite(fps) || fps <= 0) return Math.round(1e3 / DEFAULT_TICK_FPS);
-	return Math.max(1, Math.round(1e3 / fps));
+	return Math.max(1, Math.round(1e3 / Math.min(fps, MAX_TICK_FPS)));
 }
 function useInterval(callback, delayMs) {
 	const callbackRef = useCallbackRef(callback);

package/dist/index.d.ts

@@ -3,6 +3,8 @@ export { defineAction } from './action';
 export type { RenderProfile } from './render/pipeline';
 export type { CacheStats } from './render/image-cache';
 export type { RenderMetrics } from './render/metrics';
+export { physicalDevice } from './adapter/physical-device';
+export type { StreamDeckAdapter, AdapterActionHandle, AdapterActionCallbacks, AdapterWillAppearEvent, AdapterActionDevice, AdapterController, AdapterCoordinates, AdapterSize, AdapterTriggerDescription, } from './adapter/types';
 export { useKeyDown, useKeyUp, useDialRotate, useDialDown, useDialUp, useTouchTap, useDialHint, } from './hooks/events';
 export { useTap, useLongPress, useDoubleTap } from './hooks/gestures';
 export { useSettings, useGlobalSettings } from './hooks/settings';
@@ -21,7 +23,7 @@ export { ProgressBar } from './components/ProgressBar';
 export { CircularGauge } from './components/CircularGauge';
 export { ErrorBoundary } from './components/ErrorBoundary';
 export { tw } from './tw/index';
-export type { PluginConfig, FontConfig, ActionConfig, ActionConfigInput, ActionDefinition, ActionUUID, ManifestActions, EncoderLayout, WrapperComponent, DeviceInfo, ActionInfo, CanvasInfo, TouchStripLayout, TouchStripLayoutItem, KeyDownPayload, KeyUpPayload, DialRotatePayload, DialPressPayload, TouchTapPayload, DialHints, StreamDeckAccess, TouchStripInfo, TouchStripTapPayload, TouchStripDialRotatePayload, TouchStripDialPressPayload, } from './types';
+export type { PluginConfig, FontConfig, ActionConfig, ActionConfigInput, ActionDefinition, ActionUUID, ManifestActions, EncoderLayout, WrapperComponent, Controller, Coordinates, Size, DeviceInfo, ActionInfo, CanvasInfo, TouchStripLayout, TouchStripLayoutItem, KeyDownPayload, KeyUpPayload, DialRotatePayload, DialPressPayload, TouchTapPayload, DialHints, StreamDeckAccess, TouchStripInfo, TouchStripTapPayload, TouchStripDialRotatePayload, TouchStripDialPressPayload, } from './types';
 export type { TapOptions, LongPressOptions, DoubleTapOptions } from './hooks/gestures';
 export type { BoxProps } from './components/Box';
 export type { TextProps } from './components/Text';

package/dist/index.js

@@ -1,3 +1,4 @@
+import { physicalDevice } from "./adapter/physical-device.js";
 import { createPlugin } from "./plugin.js";
 import { defineAction } from "./action.js";
 import { useDialDown, useDialHint, useDialRotate, useDialUp, useKeyDown, useKeyUp, useTouchTap } from "./hooks/events.js";
@@ -17,4 +18,4 @@ import { ProgressBar } from "./components/ProgressBar.js";
 import { CircularGauge } from "./components/CircularGauge.js";
 import { ErrorBoundary } from "./components/ErrorBoundary.js";
 import { tw } from "./tw/index.js";
-export { Box, CircularGauge, Easings, ErrorBoundary, Icon, Image, ProgressBar, SpringPresets, Text, createPlugin, defineAction, tw, useAction, useCanvas, useDevice, useDialDown, useDialHint, useDialRotate, useDialUp, useDoubleTap, useGlobalSettings, useInterval, useKeyDown, useKeyUp, useLongPress, useOpenUrl, usePrevious, usePropertyInspector, useSendToPI, useSettings, useShowAlert, useShowOk, useSpring, useStreamDeck, useSwitchProfile, useTap, useTick, useTimeout, useTitle, useTouchStrip, useTouchStripDialDown, useTouchStripDialRotate, useTouchStripDialUp, useTouchStripTap, useTouchTap, useTween, useWillAppear, useWillDisappear };
+export { Box, CircularGauge, Easings, ErrorBoundary, Icon, Image, ProgressBar, SpringPresets, Text, createPlugin, defineAction, physicalDevice, tw, useAction, useCanvas, useDevice, useDialDown, useDialHint, useDialRotate, useDialUp, useDoubleTap, useGlobalSettings, useInterval, useKeyDown, useKeyUp, useLongPress, useOpenUrl, usePrevious, usePropertyInspector, useSendToPI, useSettings, useShowAlert, useShowOk, useSpring, useStreamDeck, useSwitchProfile, useTap, useTick, useTimeout, useTitle, useTouchStrip, useTouchStripDialDown, useTouchStripDialRotate, useTouchStripDialUp, useTouchStripTap, useTouchTap, useTween, useWillAppear, useWillDisappear };