@3driseai/3drise-viewer 0.1.1

package/dist/hooks/useInteraction.js

@@ -0,0 +1,273 @@
+/**
+ * useInteraction.ts
+ *
+ * Hook for handling Interactions on scene objects.
+ * Provides executeInteraction function and utility functions for:
+ * - Resolving target objects
+ * - Executing operations
+ * - Triggering animations
+ */
+import { useCallback, useRef } from 'react';
+import { AnimationsManager, texturesManager } from '@3driseai/3drise-core';
+import useCameraAnimation from '../hooks/useCameraAnimation.js';
+import { useFrameAnimations } from '../hooks/useFrameAnimations.js';
+import { useObjectEffects } from '../hooks/useObjectEffects.js';
+import { findById } from '../utils/sceneQuery.js';
+// =============================================================================
+// TYPES
+// =============================================================================
+// =============================================================================
+// HOOK
+// =============================================================================
+export function useInteraction({ 
+// mode = 'default',
+cameraSettings, sequences, }) {
+    // Redux state
+    // Track currently animated object for toggle behavior
+    const currentAnimatedRef = useRef(null);
+    // Hooks
+    const { animateCamera } = useCameraAnimation({
+        autoAnimate: false,
+        defaultDuration: 1,
+        defaultEase: "power2.out"
+    });
+    const { moveToFront, zoomToFrame, restoreOriginalTransform, restoreCamera } = useFrameAnimations(cameraSettings);
+    const { vanishObject, restoreVanishedObject, animateGlowEffect, removeGlow, isVanished, isGlowing, glowingObjects, vanishedObjects, } = useObjectEffects();
+    // ===========================================================================
+    // UTILITY: Resolve Target Objects
+    // ===========================================================================
+    const resolveTargets = useCallback((interaction, currentRef) => {
+        const { targetIds, targetMode } = interaction;
+        // If no targetIds specified, return current object only
+        if (!targetIds || targetIds.length === 0) {
+            return [currentRef];
+        }
+        console.log('[useInteraction] resolveTargets:', { targetIds, targetMode });
+        const targetRefs = [];
+        // Add current object if mode is 'add'
+        if (targetMode === 'add') {
+            targetRefs.push(currentRef);
+        }
+        // Lookup targets from scene
+        targetIds.forEach(id => {
+            const obj = findById(id);
+            if (obj) {
+                targetRefs.push(obj);
+            }
+            else {
+                console.warn(`[useInteraction] Target not found: ${id}`);
+            }
+        });
+        return targetRefs.length > 0 ? targetRefs : [currentRef];
+    }, []);
+    // ===========================================================================
+    // UTILITY: Trigger Animations
+    // ===========================================================================
+    const triggerAnimations = useCallback((animationIds) => {
+        if (!animationIds || animationIds.length === 0)
+            return;
+        console.log('[useInteraction] triggerAnimations:', animationIds);
+        console.log('Available sequences:', sequences.map(s => s.id));
+        animationIds.forEach(animationId => {
+            const sequence = sequences.find(s => s.id === animationId);
+            if (sequence) {
+                AnimationsManager.playSequence(sequence);
+            }
+            else {
+                console.warn(`[useInteraction] Sequence not found: ${animationId}`);
+            }
+        });
+    }, [sequences]);
+    // ===========================================================================
+    // UTILITY: Execute Single Operation
+    // ===========================================================================
+    const executeOperation = useCallback(async (operation, ref, createdObject, textureUrl) => {
+        if (!operation || operation === 'none')
+            return;
+        const defaultDuration = 1.0;
+        const defaultEase = "power2.out";
+        const defaultDistance = 2.0;
+        const isCurrentlySelected = currentAnimatedRef.current !== null;
+        const isSameObject = currentAnimatedRef.current?.uuid === ref.uuid;
+        console.log('[useInteraction] executeOperation:', operation);
+        switch (operation) {
+            case 'vanish': {
+                if (isVanished(ref.uuid)) {
+                    restoreVanishedObject(ref, defaultDuration, defaultEase);
+                }
+                else {
+                    vanishObject(ref, defaultDuration, defaultEase);
+                }
+                break;
+            }
+            case 'glow': {
+                if (isGlowing(ref.uuid)) {
+                    removeGlow(ref);
+                }
+                else {
+                    animateGlowEffect(ref);
+                }
+                break;
+            }
+            case 'focus': {
+                animateCamera({}, defaultDuration, defaultEase, createdObject.meshSettings.position);
+                break;
+            }
+            case 'moveToFront': {
+                // Toggle: if clicking the same object, restore it
+                if (isCurrentlySelected && isSameObject) {
+                    restoreOriginalTransform(currentAnimatedRef.current, {
+                        duration: defaultDuration,
+                        ease: defaultEase
+                    });
+                    currentAnimatedRef.current = null;
+                    return;
+                }
+                // Restore previous object if different
+                if (isCurrentlySelected && !isSameObject) {
+                    restoreOriginalTransform(currentAnimatedRef.current, {
+                        duration: defaultDuration,
+                        ease: defaultEase
+                    });
+                }
+                // Apply new animation
+                moveToFront(ref, {
+                    distance: defaultDistance,
+                    scale: [6, 4],
+                    duration: defaultDuration,
+                    ease: defaultEase
+                });
+                currentAnimatedRef.current = ref;
+                break;
+            }
+            case 'zoom': {
+                // Toggle: if clicking the same object, restore camera
+                if (isCurrentlySelected && isSameObject) {
+                    restoreCamera({ duration: defaultDuration, ease: defaultEase });
+                    currentAnimatedRef.current = null;
+                    return;
+                }
+                // Restore previous camera if different object
+                if (isCurrentlySelected && !isSameObject) {
+                    restoreCamera({ duration: defaultDuration, ease: defaultEase });
+                }
+                // Apply new zoom
+                zoomToFrame(ref, {
+                    distance: defaultDistance,
+                    duration: defaultDuration,
+                    ease: defaultEase
+                });
+                currentAnimatedRef.current = ref;
+                break;
+            }
+            case 'playAnimation':
+                // Handled by triggerAnimations
+                break;
+            case 'displayImage': {
+                if (!textureUrl)
+                    break;
+                let applier;
+                let meshWithMap = null;
+                ref.traverse((child) => {
+                    if (!applier && typeof child.userData?.applyTexture === 'function') {
+                        applier = child.userData.applyTexture;
+                    }
+                    else if (!meshWithMap && child.material) {
+                        meshWithMap = child;
+                    }
+                });
+                if (applier) {
+                    applier(textureUrl);
+                }
+                else if (meshWithMap) {
+                    const name = textureUrl.split('/').pop()?.split('.')[0] || `texture-${Date.now()}`;
+                    try {
+                        const loaded = await texturesManager.loadTexture(name, textureUrl, 'images');
+                        const mat = meshWithMap.material;
+                        mat.map = loaded;
+                        mat.needsUpdate = true;
+                    }
+                    catch (err) {
+                        console.error('[useInteraction] Failed to load texture:', err);
+                    }
+                }
+                break;
+            }
+            case 'create':
+            case 'update':
+            case 'delete':
+            case 'toggle':
+            case 'loadProject':
+                console.log(`[useInteraction] ${operation} - not implemented for scene interactions`);
+                break;
+            default:
+                console.warn(`[useInteraction] Unknown operation: ${operation}`);
+        }
+    }, [
+        isVanished,
+        isGlowing,
+        vanishObject,
+        restoreVanishedObject,
+        animateGlowEffect,
+        removeGlow,
+        animateCamera,
+        moveToFront,
+        zoomToFrame,
+        restoreOriginalTransform,
+        restoreCamera,
+    ]);
+    // ===========================================================================
+    // UTILITY: Execute Multiple Operations
+    // ===========================================================================
+    const executeOperations = useCallback((operations, ref, createdObject, textureUrl) => {
+        if (!operations || operations.length === 0)
+            return;
+        console.log('[useInteraction] executeOperations:', operations);
+        operations.forEach(operation => {
+            executeOperation(operation, ref, createdObject, textureUrl);
+        });
+    }, [executeOperation]);
+    // ===========================================================================
+    // MAIN: Execute Interaction
+    // ===========================================================================
+    const executeInteraction = useCallback((params) => {
+        const { interaction, ref, createdObject } = params;
+        if (!interaction.enabled)
+            return;
+        console.log('[useInteraction] executeInteraction:', {
+            mouseEvent: interaction.mouseEvent,
+            operations: interaction.operations,
+            targetIds: interaction.targetIds,
+            animationIds: interaction.animationIds
+        });
+        let textureUrl = undefined;
+        if (interaction.operations?.includes('displayImage')) {
+            console.log('Display Image interaction triggered:', {
+                ref,
+            });
+            textureUrl = ref.userData?.url;
+            console.log('Texture URL:', textureUrl);
+        }
+        // 1. Resolve target objects
+        const targets = resolveTargets(interaction, ref);
+        // 2. Execute operations on each target
+        targets.forEach(targetRef => {
+            // Find the createdObject for this target (if different from original)
+            // For now, use the original createdObject for position data
+            executeOperations(interaction.operations, targetRef, createdObject, textureUrl);
+        });
+        // 3. Trigger animations
+        triggerAnimations(interaction.animationIds);
+    }, [resolveTargets, executeOperations, triggerAnimations]);
+    // ===========================================================================
+    // RETURN
+    // ===========================================================================
+    return {
+        executeInteraction,
+        // Expose refs for context to share
+        currentAnimatedRef,
+        glowingObjects,
+        vanishedObjects,
+    };
+}
+export default useInteraction;

package/dist/hooks/useInteractionEffects.d.ts

@@ -0,0 +1,11 @@
+import type { CreatedObjectSettings } from '@3driseai/3drise-core';
+import { Object3D } from "three";
+export interface UseInteractionEffectsOptions {
+    enabled?: boolean;
+    animateMaterial?: boolean;
+}
+export interface UseInteractionEffectsResult {
+}
+export declare const useMouseMove: (objectSettings: CreatedObjectSettings | null, options: UseInteractionEffectsOptions, object: Object3D) => UseInteractionEffectsResult;
+export default useMouseMove;
+//# sourceMappingURL=useInteractionEffects.d.ts.map

package/dist/hooks/useInteractionEffects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInteractionEffects.d.ts","sourceRoot":"","sources":["../../src/hooks/useInteractionEffects.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACjC,MAAM,WAAW,4BAA4B;IACzC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,2BAA2B;CAC3C;AAqDD,eAAO,MAAM,YAAY,GAAI,gBAAgB,qBAAqB,GAAG,IAAI,EAAE,SAAS,4BAAiC,EAAE,QAAQ,QAAQ,KAAG,2BAoBzI,CAAC;AACF,eAAe,YAAY,CAAC"}

package/dist/hooks/useInteractionEffects.js

@@ -0,0 +1,74 @@
+import { useFrame } from "@react-three/fiber";
+import { detectAnimatableDomain, handleEdgesMouseMove, handleMaterialMouseMove, handleTransformMouseMove, } from '@3driseai/3drise-core';
+// =============================================================================
+// FLAT-SHAPE BACK COMPAT
+// =============================================================================
+//
+// Older persisted projects store mouseMove as { enabled, properties: [...] }
+// (a single flat array). The new shape is per-domain. This helper detects
+// which shape we got and projects the flat array onto the per-domain shape so
+// the rest of the hook can deal with one model only.
+//
+// Note: 'light' is intentionally not handled here — the light domain is
+// driven by useLightMouseMove inside LightObject, not by this hook.
+function splitFlatProperties(settings, properties) {
+    const out = { transform: [], material: [], edges: [] };
+    for (const p of properties) {
+        const domain = detectAnimatableDomain(settings, p.property);
+        if (domain === 'transform')
+            out.transform.push(p);
+        else if (domain === 'edges')
+            out.edges.push(p);
+        else if (domain === 'material')
+            out.material.push(p);
+    }
+    return out;
+}
+function isPerDomainShape(mm) {
+    if (!mm)
+        return false;
+    return 'transform' in mm || 'material' in mm || 'edges' in mm || 'light' in mm;
+}
+function resolveDomains(settings) {
+    const mm = settings.mouseMove;
+    if (!mm)
+        return { enabled: false };
+    if (isPerDomainShape(mm)) {
+        return { transform: mm.transform, material: mm.material, edges: mm.edges, enabled: mm.enabled };
+    }
+    // Flat shape — project onto per-domain.
+    if (!mm.enabled || !mm.properties?.length)
+        return { enabled: mm.enabled };
+    const split = splitFlatProperties(settings, mm.properties);
+    return {
+        transform: { enabled: true, properties: split.transform },
+        material: { enabled: true, properties: split.material },
+        edges: { enabled: true, properties: split.edges },
+        enabled: true,
+    };
+}
+// =============================================================================
+// useMouseMove
+// =============================================================================
+export const useMouseMove = (objectSettings, options = {}, object) => {
+    const { enabled = true, animateMaterial = true } = options;
+    useFrame((state) => {
+        if (!enabled || !object || !objectSettings)
+            return;
+        const domains = resolveDomains(objectSettings);
+        if (!domains.enabled)
+            return;
+        const pointer = state.pointer;
+        if (domains.transform?.enabled && domains.transform.properties?.length) {
+            handleTransformMouseMove({ object, meshSettings: objectSettings.meshSettings }, domains.transform.properties, pointer);
+        }
+        if (animateMaterial && domains.material?.enabled && domains.material.properties?.length) {
+            handleMaterialMouseMove({ object, materialSettings: objectSettings.materialSettings }, domains.material.properties, pointer);
+        }
+        if (domains.edges?.enabled && domains.edges.properties?.length) {
+            handleEdgesMouseMove({ object, edgesMaterialSettings: objectSettings.edgesSettings?.materialSettings }, domains.edges.properties, pointer);
+        }
+    });
+    return {};
+};
+export default useMouseMove;

package/dist/hooks/useKey.d.ts

@@ -0,0 +1,26 @@
+type KeyHandler = (event: KeyboardEvent) => void;
+interface UseKeyOptions {
+    /** Whether the hook should be active */
+    enabled?: boolean;
+    /** Target element to attach the event listener to (defaults to window) */
+    target?: EventTarget | null;
+    /** Prevent default behavior */
+    preventDefault?: boolean;
+    /** Stop event propagation */
+    stopPropagation?: boolean;
+}
+/**
+ * Custom hook for handling keyboard events
+ * @param keyHandlers - Object mapping key names to handler functions
+ * @param options - Configuration options
+ */
+export declare const useKey: (keyHandlers: Record<string, KeyHandler>, options?: UseKeyOptions) => void;
+/**
+ * Custom hook for handling both keydown and keyup events
+ * @param keyDownHandlers - Object mapping key names to keydown handler functions
+ * @param keyUpHandlers - Object mapping key names to keyup handler functions
+ * @param options - Configuration options
+ */
+export declare const useKeyUpDown: (keyDownHandlers: Record<string, KeyHandler>, keyUpHandlers?: Record<string, KeyHandler>, options?: UseKeyOptions) => void;
+export default useKey;
+//# sourceMappingURL=useKey.d.ts.map

package/dist/hooks/useKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKey.d.ts","sourceRoot":"","sources":["../../src/hooks/useKey.ts"],"names":[],"mappings":"AACA,KAAK,UAAU,GAAG,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;AAEjD,UAAU,aAAa;IACnB,wCAAwC;IACxC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,0EAA0E;IAC1E,MAAM,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAC5B,+BAA+B;IAC/B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,6BAA6B;IAC7B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;;GAIG;AACH,eAAO,MAAM,MAAM,GAAI,aAAa,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,EAAE,UAAS,aAAkB,KAAG,IAsB7F,CAAC;AACF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,iBAAiB,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,EAAE,gBAAe,MAAM,CAAC,MAAM,EAAE,UAAU,CAAM,EAAE,UAAS,aAAkB,KAAG,IAoCvJ,CAAC;AACF,eAAe,MAAM,CAAC"}

package/dist/hooks/useKey.js

@@ -0,0 +1,73 @@
+import { useEffect, useCallback } from 'react';
+/**
+ * Custom hook for handling keyboard events
+ * @param keyHandlers - Object mapping key names to handler functions
+ * @param options - Configuration options
+ */
+export const useKey = (keyHandlers, options = {}) => {
+    const { enabled = true, target = typeof window !== 'undefined' ? window : null, preventDefault = false, stopPropagation = false, } = options;
+    const handleKeyDown = useCallback((event) => {
+        if (!enabled)
+            return;
+        const handler = keyHandlers[event.key];
+        if (handler) {
+            if (preventDefault)
+                event.preventDefault();
+            if (stopPropagation)
+                event.stopPropagation();
+            handler(event);
+        }
+    }, [keyHandlers, enabled, preventDefault, stopPropagation]);
+    useEffect(() => {
+        if (!target || !enabled)
+            return;
+        target.addEventListener('keydown', handleKeyDown);
+        return () => {
+            target.removeEventListener('keydown', handleKeyDown);
+        };
+    }, [target, enabled, handleKeyDown]);
+};
+/**
+ * Custom hook for handling both keydown and keyup events
+ * @param keyDownHandlers - Object mapping key names to keydown handler functions
+ * @param keyUpHandlers - Object mapping key names to keyup handler functions
+ * @param options - Configuration options
+ */
+export const useKeyUpDown = (keyDownHandlers, keyUpHandlers = {}, options = {}) => {
+    const { enabled = true, target = typeof window !== 'undefined' ? window : null, preventDefault = false, stopPropagation = false, } = options;
+    const handleKeyDown = useCallback((event) => {
+        if (!enabled)
+            return;
+        const handler = keyDownHandlers[event.key];
+        if (handler) {
+            if (preventDefault)
+                event.preventDefault();
+            if (stopPropagation)
+                event.stopPropagation();
+            handler(event);
+        }
+    }, [keyDownHandlers, enabled, preventDefault, stopPropagation]);
+    const handleKeyUp = useCallback((event) => {
+        if (!enabled)
+            return;
+        const handler = keyUpHandlers[event.key];
+        if (handler) {
+            if (preventDefault)
+                event.preventDefault();
+            if (stopPropagation)
+                event.stopPropagation();
+            handler(event);
+        }
+    }, [keyUpHandlers, enabled, preventDefault, stopPropagation]);
+    useEffect(() => {
+        if (!target || !enabled)
+            return;
+        target.addEventListener('keydown', handleKeyDown);
+        target.addEventListener('keyup', handleKeyUp);
+        return () => {
+            target.removeEventListener('keydown', handleKeyDown);
+            target.removeEventListener('keyup', handleKeyUp);
+        };
+    }, [target, enabled, handleKeyDown, handleKeyUp]);
+};
+export default useKey;

package/dist/hooks/useLightAnimation.d.ts

@@ -0,0 +1,10 @@
+import type { RefObject } from 'react';
+import type { AnimationOptions } from '@3driseai/3drise-core';
+import type { Light } from "three";
+export interface UseLightAnimationOptions {
+    enabled?: boolean;
+    hovered?: boolean;
+}
+export declare const useLightAnimation: (lightRef: RefObject<Light | null>, animations: AnimationOptions[] | undefined, options?: UseLightAnimationOptions) => void;
+export default useLightAnimation;
+//# sourceMappingURL=useLightAnimation.d.ts.map

package/dist/hooks/useLightAnimation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLightAnimation.d.ts","sourceRoot":"","sources":["../../src/hooks/useLightAnimation.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAGvC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AACnC,MAAM,WAAW,wBAAwB;IACrC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAGD,eAAO,MAAM,iBAAiB,GAAI,UAAU,SAAS,CAAC,KAAK,GAAG,IAAI,CAAC,EAAE,YAAY,gBAAgB,EAAE,GAAG,SAAS,EAAE,UAAS,wBAA6B,KAAG,IAkBzJ,CAAC;AACF,eAAe,iBAAiB,CAAC"}

package/dist/hooks/useLightAnimation.js

@@ -0,0 +1,34 @@
+// =============================================================================
+// useLightAnimation — drives keyframe animations on a THREE.Light
+// =============================================================================
+//
+// Per-frame animator that reads an AnimationOptions[] array and applies
+// interpolated values to a Light ref. Used by both per-object lights
+// (LightObject) and scene-level lights (LightsManager: ambient + sun).
+//
+// No-op when animations is undefined / empty, or when the ref hasn't attached
+// yet.
+//
+import { useEffect, useRef } from 'react';
+import { useFrame } from '@react-three/fiber';
+import { handleLightAnimations } from '@3driseai/3drise-core';
+export const useLightAnimation = (lightRef, animations, options = {}) => {
+    const { enabled = true, hovered = false } = options;
+    const startValuesRef = useRef({});
+    // Reset cached start values whenever the animations array reference changes,
+    // so editing an animation in the UI re-samples the light's current value.
+    useEffect(() => {
+        startValuesRef.current = {};
+    }, [animations]);
+    useFrame(() => {
+        if (!enabled)
+            return;
+        const light = lightRef.current;
+        if (!light)
+            return;
+        if (!animations || animations.length === 0)
+            return;
+        handleLightAnimations({ light, startValuesCache: startValuesRef.current }, animations, Date.now(), hovered);
+    });
+};
+export default useLightAnimation;

package/dist/hooks/useLightHandlers.d.ts

@@ -0,0 +1,14 @@
+import type { MutableRefObject } from 'react';
+import type { DirectionalLight, SpotLight, PointLight } from 'three';
+import type { BaseLightConfig, SpotLightConfig, PointLightConfig } from "@3driseai/3drise-core";
+interface LightRefsInput {
+    directionalLightRefs: MutableRefObject<Map<string, DirectionalLight>>;
+    spotLightRefs: MutableRefObject<Map<string, SpotLight>>;
+    pointLightRefs: MutableRefObject<Map<string, PointLight>>;
+}
+export declare const useLightHandlers: (lightRefs: LightRefsInput, lightConfigs: (BaseLightConfig | SpotLightConfig | PointLightConfig)[]) => {
+    handleLightEnter: (lightName: string) => void;
+    handleLightLeave: (lightName: string) => void;
+};
+export default useLightHandlers;
+//# sourceMappingURL=useLightHandlers.d.ts.map

package/dist/hooks/useLightHandlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLightHandlers.d.ts","sourceRoot":"","sources":["../../src/hooks/useLightHandlers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAE9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AAErE,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAChG,UAAU,cAAc;IACpB,oBAAoB,EAAE,gBAAgB,CAAC,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC;IACtE,aAAa,EAAE,gBAAgB,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;IACxD,cAAc,EAAE,gBAAgB,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;CAC7D;AAMD,eAAO,MAAM,gBAAgB,GAAI,WAAW,cAAc,EAAE,cAAc,CAAC,eAAe,GAAG,eAAe,GAAG,gBAAgB,CAAC,EAAE,KAAG;IAC7H,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9C,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;CA6GrD,CAAC;AACF,eAAe,gBAAgB,CAAC"}

package/dist/hooks/useLightHandlers.js

@@ -0,0 +1,116 @@
+import { useCallback, useRef } from 'react';
+import { Color, MathUtils } from 'three';
+import { useFrame } from '@react-three/fiber';
+const getLightFromRefs = (refs, lightName) => refs.directionalLightRefs.current.get(lightName) ||
+    refs.spotLightRefs.current.get(lightName) ||
+    refs.pointLightRefs.current.get(lightName);
+export const useLightHandlers = (lightRefs, lightConfigs) => {
+    const hoveredLightRef = useRef(null);
+    const getInterpolatedValue = (baseValue, minValue, maxValue, multiplier, sensitivity = 1) => {
+        const normalizedMultiplier = (multiplier + 1) / 2;
+        const finalMultiplier = Math.max(0, Math.min(1, normalizedMultiplier * sensitivity));
+        if ((typeof minValue === 'string' && minValue.startsWith('#')) ||
+            (typeof maxValue === 'string' && maxValue.startsWith('#'))) {
+            const minColor = new Color(minValue);
+            const maxColor = new Color(maxValue);
+            const minArr = minColor.toArray();
+            const maxArr = maxColor.toArray();
+            return new Color().fromArray(minArr.map((min, i) => MathUtils.lerp(min, maxArr[i], finalMultiplier)));
+        }
+        if (Array.isArray(minValue) && Array.isArray(maxValue) && minValue.length === 3) {
+            return [
+                MathUtils.lerp(minValue[0], maxValue[0], finalMultiplier),
+                MathUtils.lerp(minValue[1], maxValue[1], finalMultiplier),
+                MathUtils.lerp(minValue[2], maxValue[2], finalMultiplier),
+            ];
+        }
+        if (typeof minValue === 'number' && typeof maxValue === 'number') {
+            return MathUtils.lerp(minValue, maxValue, finalMultiplier);
+        }
+        return baseValue;
+    };
+    const applyHandlerToLight = (light, config, handlers, pointer, handlerType) => {
+        const handler = handlers[handlerType];
+        if (!handler?.enabled || !handler.properties?.length)
+            return;
+        handler.properties.forEach((props) => {
+            const { property, propertySettings } = props;
+            const { min: minValue, max: maxValue, axis, sensitivity = 1, inverted = false } = propertySettings;
+            let multiplier = 0;
+            if (handlerType === 'onMouseMove') {
+                if (axis === 'x')
+                    multiplier = pointer.x;
+                if (axis === 'y')
+                    multiplier = pointer.y;
+                if (axis === 'both')
+                    multiplier = (pointer.x + pointer.y) / 2;
+                if (inverted)
+                    multiplier *= -1;
+            }
+            else {
+                multiplier = handlerType === 'onMouseEnter' ? 1 : -1;
+            }
+            const baseValue = config[property];
+            if (baseValue === undefined)
+                return;
+            const interpolatedValue = getInterpolatedValue(baseValue, minValue, maxValue, multiplier, sensitivity);
+            switch (property) {
+                case 'intensity':
+                    light.intensity = interpolatedValue;
+                    break;
+                case 'color':
+                    light.color = interpolatedValue instanceof Color ? interpolatedValue : new Color(interpolatedValue);
+                    break;
+                case 'position':
+                    if (Array.isArray(interpolatedValue) && interpolatedValue.length === 3)
+                        light.position.set(interpolatedValue[0], interpolatedValue[1], interpolatedValue[2]);
+                    break;
+                case 'angle':
+                    if ('angle' in light)
+                        light.angle = interpolatedValue;
+                    break;
+                case 'penumbra':
+                    if ('penumbra' in light)
+                        light.penumbra = interpolatedValue;
+                    break;
+                case 'distance':
+                    if ('distance' in light)
+                        light.distance = interpolatedValue;
+                    break;
+                case 'decay':
+                    if ('decay' in light)
+                        light.decay = interpolatedValue;
+                    break;
+            }
+        });
+    };
+    const handleLightEnter = useCallback((lightName) => {
+        hoveredLightRef.current = lightName;
+        const light = getLightFromRefs(lightRefs, lightName);
+        const config = lightConfigs.find((c) => c.name === lightName);
+        if (light && config?.handlers?.onMouseEnter?.enabled) {
+            applyHandlerToLight(light, config, config.handlers, { x: 0, y: 0 }, 'onMouseEnter');
+        }
+    }, [lightConfigs]);
+    const handleLightLeave = useCallback((lightName) => {
+        hoveredLightRef.current = null;
+        const light = getLightFromRefs(lightRefs, lightName);
+        const config = lightConfigs.find((c) => c.name === lightName);
+        if (light && config?.handlers?.onMouseLeave?.enabled) {
+            applyHandlerToLight(light, config, config.handlers, { x: 0, y: 0 }, 'onMouseLeave');
+        }
+    }, [lightConfigs]);
+    useFrame((state) => {
+        const pointer = state.pointer;
+        lightConfigs.forEach((config) => {
+            if (!config.handlers?.onMouseMove?.enabled)
+                return;
+            const light = getLightFromRefs(lightRefs, config.name);
+            if (!light)
+                return;
+            applyHandlerToLight(light, config, config.handlers, pointer, 'onMouseMove');
+        });
+    });
+    return { handleLightEnter, handleLightLeave };
+};
+export default useLightHandlers;

package/dist/hooks/useLightMouseMove.d.ts

@@ -0,0 +1,11 @@
+import type { MouseMoveDomain } from '@3driseai/3drise-core';
+import { type RefObject } from "react";
+import type { Light } from "three";
+export interface UseLightMouseMoveOptions {
+    enabled?: boolean;
+    /** Optional base values (intensity/color/etc.) used for fallback resolution. */
+    lightConfig?: Record<string, any>;
+}
+export declare const useLightMouseMove: (lightRef: RefObject<Light | null>, domain: MouseMoveDomain | undefined, options?: UseLightMouseMoveOptions) => void;
+export default useLightMouseMove;
+//# sourceMappingURL=useLightMouseMove.d.ts.map