@fcannizzaro/streamdeck-react 0.1.10 → 0.1.12

package/dist/hooks/animation.js

@@ -0,0 +1,381 @@
+import { usePrevious, useTick } from "./utility.js";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+//#region src/hooks/animation.ts
+var SPRING_DEFAULTS = {
+	tension: 170,
+	friction: 26,
+	mass: 1,
+	velocityThreshold: .01,
+	displacementThreshold: .005,
+	clamp: false
+};
+var TWEEN_DEFAULTS = {
+	duration: 300,
+	easing: "easeOut",
+	fps: 30
+};
+/** Max dt cap to prevent spring explosion after long pauses.
+*  If the process is suspended (debugger, GC pause), dt could be
+*  seconds-long, causing the spring to overshoot wildly.  Capping
+*  at ~64ms (roughly one frame at 15fps) keeps the simulation stable. */
+var MAX_DT_SEC = .064;
+/**
+* Semi-implicit Euler step for a damped harmonic oscillator.
+* Updates velocity first, then position — stable at low frame rates.
+*/
+function stepSpring(state, target, config, dtSeconds) {
+	const { tension, friction, mass } = config;
+	const displacement = state.position - target;
+	const acceleration = (-tension * displacement + -friction * state.velocity) / mass;
+	let velocity = state.velocity + acceleration * dtSeconds;
+	let position = state.position + velocity * dtSeconds;
+	if (config.clamp) {
+		if (displacement > 0 && position < target || displacement < 0 && position > target) {
+			position = target;
+			velocity = 0;
+		}
+	}
+	return {
+		position,
+		velocity
+	};
+}
+/** Check if a spring channel has come to rest. */
+function isSettled(state, target, config) {
+	return Math.abs(state.velocity) < config.velocityThreshold && Math.abs(state.position - target) < config.displacementThreshold;
+}
+var SpringPresets = {
+	default: {
+		tension: 170,
+		friction: 26,
+		mass: 1
+	},
+	stiff: {
+		tension: 400,
+		friction: 28,
+		mass: 1
+	},
+	wobbly: {
+		tension: 180,
+		friction: 12,
+		mass: 1
+	},
+	gentle: {
+		tension: 120,
+		friction: 14,
+		mass: 1
+	},
+	molasses: {
+		tension: 80,
+		friction: 30,
+		mass: 1
+	},
+	snap: {
+		tension: 300,
+		friction: 36,
+		mass: 1,
+		clamp: true
+	},
+	heavy: {
+		tension: 200,
+		friction: 20,
+		mass: 3
+	}
+};
+var Easings = {
+	linear: (t) => t,
+	easeIn: (t) => t * t,
+	easeOut: (t) => t * (2 - t),
+	easeInOut: (t) => t < .5 ? 2 * t * t : -1 + (4 - 2 * t) * t,
+	easeInCubic: (t) => t * t * t,
+	easeOutCubic: (t) => 1 - (1 - t) ** 3,
+	easeInOutCubic: (t) => t < .5 ? 4 * t * t * t : 1 - (-2 * t + 2) ** 3 / 2,
+	easeInBack: (t) => {
+		const c = 1.70158;
+		return (c + 1) * t * t * t - c * t * t;
+	},
+	easeOutBack: (t) => {
+		const c = 1.70158;
+		return 1 + (c + 1) * (t - 1) ** 3 + c * (t - 1) ** 2;
+	},
+	easeOutBounce: (t) => {
+		const n1 = 7.5625;
+		const d1 = 2.75;
+		if (t < 1 / d1) return n1 * t * t;
+		if (t < 2 / d1) return n1 * (t -= 1.5 / d1) * t + .75;
+		if (t < 2.5 / d1) return n1 * (t -= 2.25 / d1) * t + .9375;
+		return n1 * (t -= 2.625 / d1) * t + .984375;
+	}
+};
+function resolveEasing(easing) {
+	return typeof easing === "function" ? easing : Easings[easing];
+}
+var SCALAR_KEY = "_";
+function toChannelMap(target) {
+	if (typeof target === "number") return new Map([[SCALAR_KEY, target]]);
+	return new Map(Object.entries(target));
+}
+function snapshotValue(target) {
+	if (typeof target === "number") return target;
+	const result = {};
+	for (const [key, val] of Object.entries(target)) result[key] = val;
+	return result;
+}
+function snapshotFromSpringState(state, isObject) {
+	if (!isObject) return state.get(SCALAR_KEY).position;
+	const result = {};
+	for (const [key, s] of state) result[key] = s.position;
+	return result;
+}
+function snapshotFromMap(map, isObject) {
+	if (!isObject) return map.get(SCALAR_KEY);
+	const result = {};
+	for (const [key, val] of map) result[key] = val;
+	return result;
+}
+function forEachChannel(target, fn) {
+	if (typeof target === "number") fn(SCALAR_KEY, target);
+	else for (const [key, val] of Object.entries(target)) fn(key, val);
+}
+function shallowEqual(a, b) {
+	if (typeof a === "number" && typeof b === "number") return a === b;
+	if (typeof a !== typeof b) return false;
+	const aObj = a;
+	const bObj = b;
+	const aKeys = Object.keys(aObj);
+	const bKeys = Object.keys(bObj);
+	if (aKeys.length !== bKeys.length) return false;
+	return aKeys.every((k) => aObj[k] === bObj[k]);
+}
+function initializeSpringState(target) {
+	const map = /* @__PURE__ */ new Map();
+	forEachChannel(target, (key, value) => {
+		map.set(key, {
+			position: value,
+			velocity: 0
+		});
+	});
+	return map;
+}
+function snapSpringToTarget(state, target) {
+	forEachChannel(target, (key, value) => {
+		state.set(key, {
+			position: value,
+			velocity: 0
+		});
+	});
+}
+/**
+* Spring physics-based animation hook.
+*
+* Returns animated value(s) that follow the target with natural spring dynamics
+* (damped harmonic oscillator). Supports single numbers and objects of numbers.
+*
+* Automatically starts/stops the tick loop when the spring is in motion or settled.
+*
+* @example
+* ```tsx
+* const { value: scale } = useSpring(pressed ? 0.85 : 1, SpringPresets.wobbly);
+* ```
+*
+* @example
+* ```tsx
+* const { value } = useSpring({ x: targetX, opacity: show ? 1 : 0 }, SpringPresets.gentle);
+* // value.x and value.opacity are plain numbers
+* ```
+*/
+function useSpring(target, config) {
+	const resolvedConfig = useMemo(() => ({
+		...SPRING_DEFAULTS,
+		...config
+	}), [
+		config?.tension,
+		config?.friction,
+		config?.mass,
+		config?.velocityThreshold,
+		config?.displacementThreshold,
+		config?.clamp
+	]);
+	const fps = config?.fps ?? 30;
+	const isObject = typeof target === "object" && target !== null;
+	const stateRef = useRef(null);
+	if (stateRef.current === null) stateRef.current = initializeSpringState(target);
+	const targetRef = useRef(target);
+	targetRef.current = target;
+	const configRef = useRef(resolvedConfig);
+	configRef.current = resolvedConfig;
+	const [value, setValue] = useState(() => snapshotValue(target));
+	const [isAnimating, setIsAnimating] = useState(false);
+	const prevTarget = usePrevious(target);
+	useEffect(() => {
+		if (prevTarget !== void 0 && !shallowEqual(prevTarget, target)) {
+			const state = stateRef.current;
+			forEachChannel(target, (key, val) => {
+				if (!state.has(key)) state.set(key, {
+					position: val,
+					velocity: 0
+				});
+			});
+			setIsAnimating(true);
+		}
+	}, [prevTarget, target]);
+	useTick((deltaMs) => {
+		const dt = Math.min(deltaMs / 1e3, MAX_DT_SEC);
+		const state = stateRef.current;
+		const currentTarget = targetRef.current;
+		const cfg = configRef.current;
+		let allSettled = true;
+		forEachChannel(currentTarget, (key, targetVal) => {
+			const channelState = state.get(key);
+			if (!channelState) return;
+			const next = stepSpring(channelState, targetVal, cfg, dt);
+			state.set(key, next);
+			if (!isSettled(next, targetVal, cfg)) allSettled = false;
+		});
+		if (allSettled) {
+			snapSpringToTarget(state, currentTarget);
+			setValue(snapshotValue(currentTarget));
+			setIsAnimating(false);
+		} else setValue(snapshotFromSpringState(state, isObject));
+	}, isAnimating ? fps : false);
+	const set = useCallback((newTarget) => {
+		targetRef.current = newTarget;
+		const state = stateRef.current;
+		forEachChannel(newTarget, (key, val) => {
+			if (!state.has(key)) state.set(key, {
+				position: val,
+				velocity: 0
+			});
+		});
+		setIsAnimating(true);
+	}, []);
+	const jump = useCallback((newTarget) => {
+		targetRef.current = newTarget;
+		snapSpringToTarget(stateRef.current, newTarget);
+		setValue(snapshotValue(newTarget));
+		setIsAnimating(false);
+	}, []);
+	return useMemo(() => ({
+		value,
+		isAnimating,
+		set,
+		jump
+	}), [
+		value,
+		isAnimating,
+		set,
+		jump
+	]);
+}
+function interpolateTween(tween, easingFn) {
+	const easedT = easingFn(tween.duration > 0 ? Math.min(tween.elapsed / tween.duration, 1) : 1);
+	const result = /* @__PURE__ */ new Map();
+	for (const [key, fromVal] of tween.from) {
+		const toVal = tween.to.get(key) ?? fromVal;
+		result.set(key, fromVal + (toVal - fromVal) * easedT);
+	}
+	return result;
+}
+/**
+* Duration + easing-based animation hook.
+*
+* Returns animated value(s) that smoothly transition to the target over the
+* specified duration using an easing curve. Supports single numbers and objects
+* of numbers.
+*
+* When the target changes mid-tween, a new tween starts from the current
+* interpolated position (no discontinuity).
+*
+* @example
+* ```tsx
+* const { value: opacity } = useTween(visible ? 1 : 0, { duration: 500, easing: "easeInOut" });
+* ```
+*
+* @example
+* ```tsx
+* const { value } = useTween({ y: expanded ? 0 : -50, opacity: expanded ? 1 : 0 });
+* // value.y and value.opacity are plain numbers
+* ```
+*/
+function useTween(target, config) {
+	const duration = config?.duration ?? TWEEN_DEFAULTS.duration;
+	const easingFn = resolveEasing(config?.easing ?? TWEEN_DEFAULTS.easing);
+	const fps = config?.fps ?? TWEEN_DEFAULTS.fps;
+	const isObject = typeof target === "object" && target !== null;
+	const tweenRef = useRef(null);
+	if (tweenRef.current === null) {
+		const initial = toChannelMap(target);
+		tweenRef.current = {
+			from: new Map(initial),
+			to: new Map(initial),
+			elapsed: duration,
+			duration
+		};
+	}
+	const targetRef = useRef(target);
+	const easingRef = useRef(easingFn);
+	easingRef.current = easingFn;
+	const [value, setValue] = useState(() => snapshotValue(target));
+	const [progress, setProgress] = useState(1);
+	const [isAnimating, setIsAnimating] = useState(false);
+	const prevTarget = usePrevious(target);
+	useEffect(() => {
+		if (prevTarget !== void 0 && !shallowEqual(prevTarget, target)) {
+			const tween = tweenRef.current;
+			tween.from = interpolateTween(tween, easingRef.current);
+			tween.to = toChannelMap(target);
+			tween.elapsed = 0;
+			tween.duration = duration;
+			targetRef.current = target;
+			setIsAnimating(true);
+		}
+	}, [
+		prevTarget,
+		target,
+		duration
+	]);
+	useTick((deltaMs) => {
+		const tween = tweenRef.current;
+		tween.elapsed = Math.min(tween.elapsed + deltaMs, tween.duration);
+		const t = tween.duration > 0 ? tween.elapsed / tween.duration : 1;
+		const result = interpolateTween(tween, easingRef.current);
+		setProgress(t);
+		setValue(snapshotFromMap(result, isObject));
+		if (t >= 1) setIsAnimating(false);
+	}, isAnimating ? fps : false);
+	const set = useCallback((newTarget) => {
+		const tween = tweenRef.current;
+		tween.from = interpolateTween(tween, easingRef.current);
+		tween.to = toChannelMap(newTarget);
+		tween.elapsed = 0;
+		tween.duration = duration;
+		targetRef.current = newTarget;
+		setIsAnimating(true);
+	}, [duration]);
+	const jump = useCallback((newTarget) => {
+		const tween = tweenRef.current;
+		const map = toChannelMap(newTarget);
+		tween.from = new Map(map);
+		tween.to = new Map(map);
+		tween.elapsed = tween.duration;
+		targetRef.current = newTarget;
+		setValue(snapshotValue(newTarget));
+		setProgress(1);
+		setIsAnimating(false);
+	}, []);
+	return useMemo(() => ({
+		value,
+		progress,
+		isAnimating,
+		set,
+		jump
+	}), [
+		value,
+		progress,
+		isAnimating,
+		set,
+		jump
+	]);
+}
+//#endregion
+export { Easings, SpringPresets, useSpring, useTween };

package/dist/hooks/events.js

@@ -1,6 +1,6 @@
 import { EventBusContext, StreamDeckContext } from "../context/providers.js";
 import { useCallbackRef } from "./internal/useCallbackRef.js";
-import { useContext, useEffect, useRef } from "react";
+import { useContext, useEffect } from "react";
 //#region src/hooks/events.ts
 function useEvent(event, callback) {
 	const bus = useContext(EventBusContext);
@@ -37,12 +37,8 @@ function useTouchTap(callback) {
 }
 function useDialHint(hints) {
 	const { action } = useContext(StreamDeckContext);
-	const prevHints = useRef("");
 	useEffect(() => {
-		const serialized = JSON.stringify(hints);
-		if (serialized === prevHints.current) return;
-		prevHints.current = serialized;
-		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/touchstrip.d.ts

@@ -0,0 +1,6 @@
+import { TouchStripInfo, TouchStripTapPayload, TouchStripDialRotatePayload, TouchStripDialPressPayload } from '../types';
+export declare function useTouchStrip(): TouchStripInfo;
+export declare function useTouchStripTap(callback: (payload: TouchStripTapPayload) => void): void;
+export declare function useTouchStripDialRotate(callback: (payload: TouchStripDialRotatePayload) => void): void;
+export declare function useTouchStripDialDown(callback: (payload: TouchStripDialPressPayload) => void): void;
+export declare function useTouchStripDialUp(callback: (payload: TouchStripDialPressPayload) => void): void;

package/dist/hooks/touchstrip.js

@@ -0,0 +1,37 @@
+import { EventBusContext } from "../context/providers.js";
+import { TouchStripContext } from "../context/touchstrip-context.js";
+import { useCallbackRef } from "./internal/useCallbackRef.js";
+import { useContext, useEffect } from "react";
+//#region src/hooks/touchstrip.ts
+function useTouchStripEvent(event, callback) {
+	const bus = useContext(EventBusContext);
+	const callbackRef = useCallbackRef(callback);
+	useEffect(() => {
+		const handler = (payload) => {
+			callbackRef.current(payload);
+		};
+		bus.on(event, handler);
+		return () => bus.off(event, handler);
+	}, [
+		bus,
+		callbackRef,
+		event
+	]);
+}
+function useTouchStrip() {
+	return useContext(TouchStripContext);
+}
+function useTouchStripTap(callback) {
+	useTouchStripEvent("touchStripTap", callback);
+}
+function useTouchStripDialRotate(callback) {
+	useTouchStripEvent("touchStripDialRotate", callback);
+}
+function useTouchStripDialDown(callback) {
+	useTouchStripEvent("touchStripDialDown", callback);
+}
+function useTouchStripDialUp(callback) {
+	useTouchStripEvent("touchStripDialUp", callback);
+}
+//#endregion
+export { useTouchStrip, useTouchStripDialDown, useTouchStripDialRotate, useTouchStripDialUp, useTouchStripTap };

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

@@ -1,13 +1,20 @@
 export { createPlugin } from './plugin';
 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';
 export { useDevice, useAction, useCanvas, useStreamDeck } from './hooks/context';
 export { useWillAppear, useWillDisappear } from './hooks/lifecycle';
 export { useInterval, useTimeout, usePrevious, useTick } from './hooks/utility';
+export { useSpring, useTween, SpringPresets, Easings } from './hooks/animation';
+export type { SpringConfig, SpringResult, TweenConfig, TweenResult, EasingName, EasingFn, AnimationTarget, AnimatedValue, } from './hooks/animation';
 export { useOpenUrl, useSwitchProfile, useSendToPI, usePropertyInspector, useShowAlert, useShowOk, useTitle, } from './hooks/sdk';
-export { useTouchBar, useTouchBarTap, useTouchBarDialRotate, useTouchBarDialDown, useTouchBarDialUp, } from './hooks/touchbar';
+export { useTouchStrip, useTouchStripTap, useTouchStripDialRotate, useTouchStripDialDown, useTouchStripDialUp, } from './hooks/touchstrip';
 export { Box } from './components/Box';
 export { Text } from './components/Text';
 export { Image } from './components/Image';
@@ -16,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, ActionDefinition, EncoderLayout, WrapperComponent, DeviceInfo, ActionInfo, CanvasInfo, TouchStripLayout, TouchStripLayoutItem, KeyDownPayload, KeyUpPayload, DialRotatePayload, DialPressPayload, TouchTapPayload, DialHints, StreamDeckAccess, TouchBarInfo, TouchBarTapPayload, TouchBarDialRotatePayload, TouchBarDialPressPayload, } 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";
@@ -6,8 +7,9 @@ import { useGlobalSettings, useSettings } from "./hooks/settings.js";
 import { useAction, useCanvas, useDevice, useStreamDeck } from "./hooks/context.js";
 import { useWillAppear, useWillDisappear } from "./hooks/lifecycle.js";
 import { useInterval, usePrevious, useTick, useTimeout } from "./hooks/utility.js";
+import { Easings, SpringPresets, useSpring, useTween } from "./hooks/animation.js";
 import { useOpenUrl, usePropertyInspector, useSendToPI, useShowAlert, useShowOk, useSwitchProfile, useTitle } from "./hooks/sdk.js";
-import { useTouchBar, useTouchBarDialDown, useTouchBarDialRotate, useTouchBarDialUp, useTouchBarTap } from "./hooks/touchbar.js";
+import { useTouchStrip, useTouchStripDialDown, useTouchStripDialRotate, useTouchStripDialUp, useTouchStripTap } from "./hooks/touchstrip.js";
 import { Box } from "./components/Box.js";
 import { Text } from "./components/Text.js";
 import { Image } from "./components/Image.js";
@@ -16,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, ErrorBoundary, Icon, Image, ProgressBar, Text, createPlugin, defineAction, tw, useAction, useCanvas, useDevice, useDialDown, useDialHint, useDialRotate, useDialUp, useDoubleTap, useGlobalSettings, useInterval, useKeyDown, useKeyUp, useLongPress, useOpenUrl, usePrevious, usePropertyInspector, useSendToPI, useSettings, useShowAlert, useShowOk, useStreamDeck, useSwitchProfile, useTap, useTick, useTimeout, useTitle, useTouchBar, useTouchBarDialDown, useTouchBarDialRotate, useTouchBarDialUp, useTouchBarTap, useTouchTap, 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 };

package/dist/manifest-codegen.d.ts

@@ -0,0 +1,38 @@
+export interface ParsedAction {
+    uuid: string;
+    controllers: readonly ("Keypad" | "Encoder")[];
+}
+/**
+ * Find the manifest.json inside a `*.sdPlugin` directory.
+ *
+ * - If `explicit` is a string, it is resolved against `root`.
+ * - If `explicit` is `false`, codegen is disabled (returns `null`).
+ * - Otherwise, auto-detects by scanning `root` for `*.sdPlugin/manifest.json`.
+ */
+export declare function findManifestPath(root: string, explicit?: string | false, warn?: (msg: string) => void): string | null;
+/**
+ * Parse a Stream Deck plugin manifest and extract action metadata.
+ * Returns an empty array on failure (with a warning).
+ */
+export declare function parseManifest(path: string, warn?: (msg: string) => void): ParsedAction[];
+/**
+ * Generate the `declare module` augmentation string from parsed actions.
+ * Returns an empty string when there are no actions.
+ */
+export declare function generateManifestDts(actions: ParsedAction[]): string;
+/**
+ * Write the generated `.d.ts` file only when the content has changed.
+ * Creates the parent directory if it does not exist.
+ *
+ * @returns `true` if the file was written, `false` if content was unchanged.
+ */
+export declare function writeManifestDtsIfChanged(outPath: string, content: string): boolean;
+/**
+ * High-level helper: find, parse, generate, and write manifest types.
+ *
+ * @returns The resolved manifest path (for watch registration), or `null`.
+ */
+export declare function generateManifestTypes(root: string, manifestOption: string | false | undefined, warn?: (msg: string) => void): {
+    manifestPath: string;
+    written: boolean;
+} | null;