@nice2dev/ui-3d 1.2.1 → 1.2.2

package/dist/cjs/model/useModelEditor.js

@@ -24,6 +24,7 @@ var SVGLoader_js = require('three/examples/jsm/loaders/SVGLoader.js');
 var TDSLoader_js = require('three/examples/jsm/loaders/TDSLoader.js');
 var VTKLoader_js = require('three/examples/jsm/loaders/VTKLoader.js');
 var editorAsk = require('../core/editorAsk.js');
+var i18n = require('../core/i18n.js');
 var threeCompat = require('../core/threeCompat.js');
 var modelEditorTypes = require('./modelEditorTypes.js');
 var modelEditorUtils = require('./modelEditorUtils.js');
@@ -76,6 +77,7 @@ function findNodeById(nodes, id) {
    ═══════════════════════════════════════════ */
 function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
     var _a;
+    const { t } = i18n.useNiceTranslation();
     const { pendingAsk, ask } = editorAsk.useEditorAsk();
     /* ── refs ── */
     const mountRef = React.useRef(null);
@@ -415,14 +417,16 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
         }
         focusOnObjectRef.current(obj);
         rebuildTree();
-        setStatusText(`Loaded: ${filename} (${clips.length} animation(s))`);
-    }, [rebuildTree]);
+        setStatusText(t('useModelEditor.loadedAnimationS', 'Loaded: {filename} ({clips} animation(s))')
+            .replace('{filename}', String(filename))
+            .replace('{clips}', String(clips.length)));
+    }, [rebuildTree, t]);
     const loadFile = React.useCallback(async (file) => {
         var _a, _b, _c, _d, _e, _f;
         const name = file.name.toLowerCase();
         const ext = '.' + name.split('.').pop();
         const url = URL.createObjectURL(file);
-        setStatusText(`Loading ${file.name}...`);
+        setStatusText(t('useModelEditor.loading', 'Loading {name}...').replace('{name}', String(file.name)));
         try {
             if (ext === '.fbx') {
                 const loader = new FBXLoader_js.FBXLoader();
@@ -546,32 +550,34 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
                 addObjectToScene(group, [], file.name);
             }
             else {
-                setStatusText(`Unsupported format: ${ext}`);
+                setStatusText(t('useModelEditor.unsupportedFormat', 'Unsupported format: {ext}').replace('{ext}', String(ext)));
             }
         }
         catch (err) {
             log.error('Load error:', err);
-            setStatusText(`Error loading ${file.name}: ${String(err)}`);
+            setStatusText(t('useModelEditor.errorLoading', 'Error loading {name}: {err}')
+                .replace('{name}', String(file.name))
+                .replace('{err}', String(String(err))));
         }
         finally {
             URL.revokeObjectURL(url);
         }
-    }, [addObjectToScene]);
+    }, [addObjectToScene, t]);
     const mergeAnimationFBX = React.useCallback(async (file) => {
         var _a;
         const url = URL.createObjectURL(file);
-        setStatusText(`Merging animations from ${file.name}...`);
+        setStatusText(t('useModelEditor.mergingAnimationsFrom', 'Merging animations from {name}...').replace('{name}', String(file.name)));
         try {
             const loader = new FBXLoader_js.FBXLoader();
             const obj = await new Promise((res, rej) => loader.load(url, res, undefined, rej));
             const clips = (_a = obj.animations) !== null && _a !== void 0 ? _a : [];
             if (clips.length === 0) {
-                setStatusText(`No animations found in ${file.name}`);
+                setStatusText(t('useModelEditor.noAnimationsFoundIn', 'No animations found in {name}').replace('{name}', String(file.name)));
                 return;
             }
             const root = rootObjectRef.current;
             if (!root) {
-                setStatusText('No model loaded — load a base model first');
+                setStatusText(t('useModelEditor.noModelLoadedLoadA', 'No model loaded — load a base model first'));
                 return;
             }
             if (!mixerRef.current) {
@@ -585,16 +591,20 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
             }));
             allClipsRef.current = [...allClipsRef.current, ...newAnims];
             setAnimations([...allClipsRef.current]);
-            setStatusText(`Merged ${clips.length} animation(s) from ${file.name}`);
+            setStatusText(t('useModelEditor.mergedAnimationSFrom', 'Merged {clips} animation(s) from {name}')
+                .replace('{clips}', String(clips.length))
+                .replace('{name}', String(file.name)));
         }
         catch (err) {
             log.error('Merge error:', err);
-            setStatusText(`Error merging ${file.name}: ${String(err)}`);
+            setStatusText(t('useModelEditor.errorMerging', 'Error merging {name}: {err}')
+                .replace('{name}', String(file.name))
+                .replace('{err}', String(String(err))));
         }
         finally {
             URL.revokeObjectURL(url);
         }
-    }, []);
+    }, [t]);
     /* ─────────────────────────────────────────
        Animation controls
        ───────────────────────────────────────── */
@@ -952,8 +962,8 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
         clone.position.x += 1;
         sceneRef.current.add(clone);
         rebuildTree();
-        setStatusText(`Duplicated ${selectedNode.name}`);
-    }, [selectedNode, rebuildTree]);
+        setStatusText(t('useModelEditor.duplicated', 'Duplicated {name}').replace('{name}', String(selectedNode.name)));
+    }, [selectedNode, rebuildTree, t]);
     /* ─────────────────────────────────────────
        Keyboard shortcuts
        ───────────────────────────────────────── */
@@ -1097,7 +1107,7 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
     const exportGLTF = React.useCallback((binary) => {
         const root = rootObjectRef.current;
         if (!root) {
-            setStatusText('Nothing to export');
+            setStatusText(t('useModelEditor.nothingToExport', 'Nothing to export'));
             return;
         }
         const exporter = new GLTFExporter_js.GLTFExporter();
@@ -1118,16 +1128,16 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
             a.download = `export.${binary ? 'glb' : 'gltf'}`;
             a.click();
             URL.revokeObjectURL(a.href);
-            setStatusText(`Exported ${binary ? 'GLB' : 'GLTF'} successfully`);
+            setStatusText(t('useModelEditor.exportedFormat', 'Exported {format} successfully').replace('{format}', binary ? 'GLB' : 'GLTF'));
         }, (err) => {
             log.error('Export error:', err);
-            setStatusText(`Export error: ${String(err)}`);
+            setStatusText(t('useModelEditor.exportError', 'Export error: {err}').replace('{err}', String(String(err))));
         }, options);
-    }, []);
+    }, [t]);
     const exportOBJ = React.useCallback(() => {
         const root = rootObjectRef.current;
         if (!root) {
-            setStatusText('Nothing to export');
+            setStatusText(t('useModelEditor.nothingToExport', 'Nothing to export'));
             return;
         }
         const exporter = new OBJExporter_js.OBJExporter();
@@ -1138,12 +1148,12 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
         a.download = 'export.obj';
         a.click();
         URL.revokeObjectURL(a.href);
-        setStatusText('Exported OBJ successfully');
-    }, []);
+        setStatusText(t('useModelEditor.exportedFormat', 'Exported {format} successfully').replace('{format}', 'OBJ'));
+    }, [t]);
     const exportSTL = React.useCallback((binary) => {
         const root = rootObjectRef.current;
         if (!root) {
-            setStatusText('Nothing to export');
+            setStatusText(t('useModelEditor.nothingToExport', 'Nothing to export'));
             return;
         }
         const exporter = new STLExporter_js.STLExporter();
@@ -1160,12 +1170,12 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
         a.download = 'export.stl';
         a.click();
         URL.revokeObjectURL(a.href);
-        setStatusText(`Exported STL${binary ? ' (binary)' : ''} successfully`);
-    }, []);
+        setStatusText(t('useModelEditor.exportedFormat', 'Exported {format} successfully').replace('{format}', binary ? t('useModelEditor.stlBinary', 'STL (binary)') : 'STL'));
+    }, [t]);
     const exportPLY = React.useCallback((binary) => {
         const root = rootObjectRef.current;
         if (!root) {
-            setStatusText('Nothing to export');
+            setStatusText(t('useModelEditor.nothingToExport', 'Nothing to export'));
             return;
         }
         const exporter = new PLYExporter_js.PLYExporter();
@@ -1183,13 +1193,13 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
             a.download = 'export.ply';
             a.click();
             URL.revokeObjectURL(a.href);
-            setStatusText(`Exported PLY${binary ? ' (binary)' : ''} successfully`);
+            setStatusText(t('useModelEditor.exportedFormat', 'Exported {format} successfully').replace('{format}', binary ? t('useModelEditor.plyBinary', 'PLY (binary)') : 'PLY'));
         }, { binary });
-    }, []);
+    }, [t]);
     const exportUSDZ = React.useCallback(async () => {
         const root = rootObjectRef.current;
         if (!root) {
-            setStatusText('Nothing to export');
+            setStatusText(t('useModelEditor.nothingToExport', 'Nothing to export'));
             return;
         }
         try {
@@ -1204,13 +1214,13 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
             a.download = 'export.usdz';
             a.click();
             URL.revokeObjectURL(a.href);
-            setStatusText('Exported USDZ successfully');
+            setStatusText(t('useModelEditor.exportedFormat', 'Exported {format} successfully').replace('{format}', 'USDZ'));
         }
         catch (err) {
             log.error('USDZ export error:', err);
-            setStatusText(`USDZ export error: ${String(err)}`);
+            setStatusText(t('useModelEditor.usdzExportError', 'USDZ export error: {err}').replace('{err}', String(String(err))));
         }
-    }, []);
+    }, [t]);
     /* ─────────────────────────────────────────
        Dispose & clear
        ───────────────────────────────────────── */
@@ -1279,8 +1289,8 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
         setAnimDuration(0);
         setSelectedId(null);
         rebuildTree();
-        setStatusText('Scene cleared');
-    }, [rebuildTree, disposeObject]);
+        setStatusText(t('useModelEditor.sceneCleared', 'Scene cleared'));
+    }, [rebuildTree, disposeObject, t]);
     // asks first: clearing cannot be undone
     const clearScene = React.useCallback(() => {
         void ask('confirm', 'Clear the entire scene? This cannot be undone.').then((answer) => {
@@ -1298,7 +1308,7 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
         }
         const root = rootObjectRef.current;
         if (!root) {
-            setStatusText('Nothing to save');
+            setStatusText(t('useModelEditor.nothingToSave', 'Nothing to save'));
             return;
         }
         const exporter = new GLTFExporter_js.GLTFExporter();
@@ -1316,9 +1326,9 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
             reader.readAsDataURL(blob);
         }, (err) => {
             log.error('Save to library error:', err);
-            setStatusText(`Save error: ${String(err)}`);
+            setStatusText(t('useModelEditor.saveError', 'Save error: {err}').replace('{err}', String(String(err))));
         }, { binary: true, animations: allClipsRef.current.map((a) => a.clip) });
-    }, [onSaveToLibrary, ask]);
+    }, [onSaveToLibrary, ask, t]);
     /* ─────────────────────────────────────────
        Add Mesh / Light / Camera / Empty
        ───────────────────────────────────────── */
@@ -1385,9 +1395,9 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
         }
         sceneRef.current.add(mesh);
         rebuildTree();
-        setStatusText(`Added ${mesh.name}`);
+        setStatusText(t('useModelEditor.added', 'Added {name}').replace('{name}', String(mesh.name)));
         setAddMenuOpen(null);
-    }, [rebuildTree]);
+    }, [rebuildTree, t]);
     const addSceneLight = React.useCallback((type) => {
         let light;
         switch (type) {
@@ -1439,9 +1449,9 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
             sceneRef.current.add(helper);
         }
         rebuildTree();
-        setStatusText(`Added ${light.name}`);
+        setStatusText(t('useModelEditor.added', 'Added {name}').replace('{name}', String(light.name)));
         setAddMenuOpen(null);
-    }, [rebuildTree]);
+    }, [rebuildTree, t]);
     const addCameraObject = React.useCallback(() => {
         const cam = new THREE__namespace.PerspectiveCamera(50, 16 / 9, 0.1, 1000);
         cam.name = 'Camera';
@@ -1452,9 +1462,9 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
         helper.name = '__helper_Camera';
         sceneRef.current.add(helper);
         rebuildTree();
-        setStatusText('Added Camera');
+        setStatusText(t('useModelEditor.addedCamera', 'Added Camera'));
         setAddMenuOpen(null);
-    }, [rebuildTree]);
+    }, [rebuildTree, t]);
     const addEmpty = React.useCallback((type) => {
         const obj = new THREE__namespace.Object3D();
         obj.name =
@@ -1466,9 +1476,9 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
             obj.add(h);
         }
         rebuildTree();
-        setStatusText(`Added ${obj.name}`);
+        setStatusText(t('useModelEditor.added', 'Added {name}').replace('{name}', String(obj.name)));
         setAddMenuOpen(null);
-    }, [rebuildTree]);
+    }, [rebuildTree, t]);
     /* ─────────────────────────────────────────
        Raycaster click-to-select
        ───────────────────────────────────────── */
@@ -1536,14 +1546,16 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
         }
         e.target.value = '';
         if (!onAIPoseVideo) {
-            setAiStatus('AI pose callback not configured.');
+            setAiStatus(t('useModelEditor.aiPoseCallbackNotConfigured', 'AI pose callback not configured.'));
             return;
         }
         setAiBusy(true);
-        setAiStatus('Uploading video for AI pose estimation...');
+        setAiStatus(t('useModelEditor.uploadingVideoForAiPose', 'Uploading video for AI pose estimation...'));
         try {
             const result = await onAIPoseVideo(file);
-            setAiStatus(`Got ${result.frame_count} frames at ${result.fps} fps. Creating animation clip...`);
+            setAiStatus(t('useModelEditor.gotFramesAtFpsCreating', 'Got {frame_count} frames at {fps} fps. Creating animation clip...')
+                .replace('{frame_count}', String(result.frame_count))
+                .replace('{fps}', String(result.fps)));
             const clip = modelEditorTypes.pose3dToClip(result);
             if (clip && rootObjectRef.current) {
                 if (!mixerRef.current) {
@@ -1558,20 +1570,20 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
                 allClipsRef.current = [...allClipsRef.current, newAnim];
                 setAnimations([...allClipsRef.current]);
                 playClip(allClipsRef.current.length - 1);
-                setAiStatus('Animation created successfully!');
+                setAiStatus(t('useModelEditor.animationCreatedSuccessfully', 'Animation created successfully!'));
             }
             else {
-                setAiStatus('Could not create animation — load a rigged model first.');
+                setAiStatus(t('useModelEditor.couldNotCreateAnimationLoad', 'Could not create animation — load a rigged model first.'));
             }
         }
         catch (err) {
             log.error('AI pose error:', err);
-            setAiStatus(`Error: ${String(err)}`);
+            setAiStatus(t('useModelEditor.error', 'Error: {err}').replace('{err}', String(String(err))));
         }
         finally {
             setAiBusy(false);
         }
-    }, [playClip, onAIPoseVideo]);
+    }, [playClip, onAIPoseVideo, t]);
     /* ─────────────────────────────────────────
        Node helpers
        ───────────────────────────────────────── */
@@ -1595,19 +1607,19 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
     const undo = React.useCallback(() => {
         const label = undoRedoRef.current.undo();
         if (label) {
-            setStatusText(`Undo: ${label}`);
+            setStatusText(t('useModelEditor.undo', 'Undo: {label}').replace('{label}', String(label)));
             rebuildTree();
         }
         setUndoRedoVer((v) => v + 1);
-    }, [rebuildTree]);
+    }, [rebuildTree, t]);
     const redo = React.useCallback(() => {
         const label = undoRedoRef.current.redo();
         if (label) {
-            setStatusText(`Redo: ${label}`);
+            setStatusText(t('useModelEditor.redo', 'Redo: {label}').replace('{label}', String(label)));
             rebuildTree();
         }
         setUndoRedoVer((v) => v + 1);
-    }, [rebuildTree]);
+    }, [rebuildTree, t]);
     const canUndo = undoRedoRef.current.canUndo();
     const canRedo = undoRedoRef.current.canRedo();
     const undoLabel = undoRedoRef.current.undoLabel;
@@ -1636,30 +1648,35 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
             return modelEditorTypes.SUPPORTED_EXTENSIONS.includes(ext);
         });
         if (fileArray.length === 0) {
-            setStatusText('No supported files found');
+            setStatusText(t('useModelEditor.noSupportedFilesFound', 'No supported files found'));
             return;
         }
-        setStatusText(`Importing ${fileArray.length} file(s)...`);
+        setStatusText(t('useModelEditor.importingFileS', 'Importing {fileArray} file(s)...').replace('{fileArray}', String(fileArray.length)));
         let loaded = 0;
         for (const file of fileArray) {
             try {
                 await loadFile(file);
                 loaded++;
-                setStatusText(`Imported ${loaded}/${fileArray.length}: ${file.name}`);
+                setStatusText(t('useModelEditor.imported', 'Imported {loaded}/{fileArray}: {name}')
+                    .replace('{loaded}', String(loaded))
+                    .replace('{fileArray}', String(fileArray.length))
+                    .replace('{name}', String(file.name)));
             }
             catch (err) {
                 log.error(`Failed to import ${file.name}:`, err);
             }
         }
-        setStatusText(`Batch import complete: ${loaded}/${fileArray.length} files loaded`);
-    }, [loadFile]);
+        setStatusText(t('useModelEditor.batchImportCompleteFilesLoaded', 'Batch import complete: {loaded}/{fileArray} files loaded')
+            .replace('{loaded}', String(loaded))
+            .replace('{fileArray}', String(fileArray.length)));
+    }, [loadFile, t]);
     /* ─────────────────────────────────────────
        PBR Presets
        ───────────────────────────────────────── */
     const applyPreset = React.useCallback((preset) => {
         const node = selectedNode;
         if (!node || !(node.object instanceof THREE__namespace.Mesh)) {
-            setStatusText('Select a mesh to apply material preset');
+            setStatusText(t('useModelEditor.selectAMeshToApply', 'Select a mesh to apply material preset'));
             return;
         }
         const mesh = node.object;
@@ -1692,7 +1709,7 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
             mesh.material = newMaterial;
         }
         pushUndo({
-            label: `Apply ${preset.name} preset`,
+            label: t('useModelEditor.applyPreset', 'Apply {name} preset').replace('{name}', String(preset.name)),
             undo: () => {
                 if (Array.isArray(mesh.material)) {
                     mesh.material[materialIdx] = oldClone;
@@ -1711,15 +1728,15 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
             },
         });
         setMatRefresh((v) => v + 1);
-        setStatusText(`Applied ${preset.name} preset`);
-    }, [selectedNode, selMaterialIdx, pushUndo]);
+        setStatusText(t('useModelEditor.appliedPreset', 'Applied {name} preset').replace('{name}', String(preset.name)));
+    }, [selectedNode, selMaterialIdx, pushUndo, t]);
     /* ─────────────────────────────────────────
        LOD Generation
        ───────────────────────────────────────── */
     const generateSelectedLOD = React.useCallback(() => {
         const node = selectedNode;
         if (!node || !(node.object instanceof THREE__namespace.Mesh)) {
-            setStatusText('Select a mesh to generate LOD');
+            setStatusText(t('useModelEditor.selectAMeshToGenerate', 'Select a mesh to generate LOD'));
             return;
         }
         const mesh = node.object;
@@ -1728,7 +1745,7 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
         parent.remove(mesh);
         parent.add(lod);
         pushUndo({
-            label: `Generate LOD for ${mesh.name}`,
+            label: t('useModelEditor.generateLodFor', 'Generate LOD for {name}').replace('{name}', String(mesh.name)),
             undo: () => {
                 parent.remove(lod);
                 parent.add(mesh);
@@ -1739,8 +1756,8 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
             },
         });
         rebuildTree();
-        setStatusText(`Generated LOD for ${mesh.name} (4 levels)`);
-    }, [selectedNode, pushUndo, rebuildTree]);
+        setStatusText(t('useModelEditor.generatedLodFor4Levels', 'Generated LOD for {name} (4 levels)').replace('{name}', String(mesh.name)));
+    }, [selectedNode, pushUndo, rebuildTree, t]);
     /* ─────────────────────────────────────────
        Instancing
        ───────────────────────────────────────── */
@@ -1748,12 +1765,14 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
         const root = rootObjectRef.current || sceneRef.current;
         const result = modelEditorUtils.convertToInstanced(root);
         if (result.created === 0) {
-            setStatusText('No duplicate meshes found to instance');
+            setStatusText(t('useModelEditor.noDuplicateMeshesFoundTo', 'No duplicate meshes found to instance'));
             return;
         }
         rebuildTree();
-        setStatusText(`Created ${result.created} instanced meshes, removed ${result.removed} duplicates`);
-    }, [rebuildTree]);
+        setStatusText(t('useModelEditor.createdInstancedMeshesRemovedDuplicates', 'Created {created} instanced meshes, removed {removed} duplicates')
+            .replace('{created}', String(result.created))
+            .replace('{removed}', String(result.removed)));
+    }, [rebuildTree, t]);
     /* ── HDRI Environment ── */
     const applyHDRI = React.useCallback((preset) => {
         const renderer = rendererRef.current;
@@ -1771,8 +1790,8 @@ function useModelEditor({ onSaveToLibrary, onAIPoseVideo, }) {
         else {
             setFogEnabled(false);
         }
-        setStatusText(`Environment: ${preset.name}`);
-    }, []);
+        setStatusText(t('useModelEditor.environment', 'Environment: {name}').replace('{name}', String(preset.name)));
+    }, [t]);
     /* ── Snap ── */
     const snapPoint = React.useCallback((point) => {
         const root = rootObjectRef.current || sceneRef.current;

package/dist/cjs/model/useModelViewer.js

@@ -10,6 +10,7 @@ var GLTFLoader_js = require('three/examples/jsm/loaders/GLTFLoader.js');
 var OBJLoader_js = require('three/examples/jsm/loaders/OBJLoader.js');
 var PLYLoader_js = require('three/examples/jsm/loaders/PLYLoader.js');
 var STLLoader_js = require('three/examples/jsm/loaders/STLLoader.js');
+var i18n = require('../core/i18n.js');
 var threeCompat = require('../core/threeCompat.js');
 
 function _interopNamespaceDefault(e) {
@@ -62,6 +63,7 @@ const TONE_MAP = {
    ═══════════════════════════════════════════ */
 function useModelViewer(props = {}) {
     var _a;
+    const { t } = i18n.useNiceTranslation();
     const { src, format, navigationMode: initNavMode = 'orbit', quality = 'high', autoRotateSpeed: initAutoRotate = 0, backgroundColor = 'var(--nice-bg, #1a1a2e)', showGrid: initShowGrid = true, shadows = true, gamepad = false, cameraPresets: _cameraPresets = [], annotations: _annotations = [], hotspots: _hotspots = [], floorPlans: _floorPlans = [], onHotspotClick: _onHotspotClick, onAnnotationClick: _onAnnotationClick, onLoadProgress, onLoad, onError, clippingPlanes = [], measureMode: initMeasureMode = false, measurements: _measurements = [], onMeasure: _onMeasure, minDistance = 0.1, maxDistance = 1000, fov = 50, vr: _vr = false, walkSpeed = 5, ambientIntensity = 0.5, directionalIntensity = 0.8, antiAlias = true, toneMapping = 'aces', exposure = 1, } = props;
     /* ── refs ── */
     const mountRef = React.useRef(null);
@@ -349,7 +351,7 @@ function useModelViewer(props = {}) {
         setLoading(true);
         setLoadProgress(0);
         setError(null);
-        setStatusText('Loading…');
+        setStatusText(t('useModelViewer.loading', 'Loading…'));
         const detectedFmt = detectFormat(url, fmt);
         const onProgress = (e) => {
             if (e.lengthComputable) {
@@ -457,21 +459,23 @@ function useModelViewer(props = {}) {
                     mixerRef.current = mixer;
                 }
                 countScene();
-                setStatusText(`Loaded – ${polyCount} tris, ${meshCount} meshes`);
+                setStatusText(t('useModelViewer.loadedTrisMeshes', 'Loaded – {polyCount} tris, {meshCount} meshes')
+                    .replace('{polyCount}', String(polyCount))
+                    .replace('{meshCount}', String(meshCount)));
                 onLoad === null || onLoad === void 0 ? void 0 : onLoad();
             }
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             setError(msg);
-            setStatusText(`Error: ${msg}`);
+            setStatusText(t('useModelViewer.error', 'Error: {msg}').replace('{msg}', String(msg)));
             onError === null || onError === void 0 ? void 0 : onError(err instanceof Error ? err : new Error(msg));
         }
         finally {
             setLoading(false);
             setLoadProgress(1);
         }
-    }, [countScene, detectFormat, onLoad, onError, onLoadProgress, polyCount, meshCount]);
+    }, [countScene, detectFormat, onLoad, onError, onLoadProgress, polyCount, meshCount, t]);
     /* ── auto-load from src ── */
     React.useEffect(() => {
         if (src) {
@@ -612,9 +616,12 @@ function useModelViewer(props = {}) {
     /* ── finalise status text ── */
     React.useEffect(() => {
         if (!loading && !error && polyCount > 0) {
-            setStatusText(`${polyCount.toLocaleString()} triangles · ${meshCount} meshes · ${animNames.length} animation(s)`);
+            setStatusText(t('useModelViewer.trianglesMeshesAnimationS', '{polyCount} triangles · {meshCount} meshes · {animNames} animation(s)')
+                .replace('{polyCount}', String(polyCount.toLocaleString()))
+                .replace('{meshCount}', String(meshCount))
+                .replace('{animNames}', String(animNames.length)));
         }
-    }, [loading, error, polyCount, meshCount, animNames.length]);
+    }, [loading, error, polyCount, meshCount, animNames.length, t]);
     return {
         mountRef,
         loading,

package/dist/cjs/particle/NiceParticleEditor.js

@@ -297,7 +297,7 @@ function SystemListPanel({ systems, selectedId, onSelect, onAdd, onRemove, onDup
         }
         setEditingId(null);
     };
-    return (jsxRuntime.jsxs("div", { className: ParticleEditor_module.systemList, children: [jsxRuntime.jsxs("div", { className: ParticleEditor_module.systemListHeader, children: [jsxRuntime.jsxs("span", { children: ["Systems (", systems.length, ")"] }), jsxRuntime.jsxs("div", { className: ParticleEditor_module.systemListActions, children: [jsxRuntime.jsx("button", { onClick: onAdd, title: t('particleEditor.newSystem', 'New System'), "aria-label": t('particleEditor.newSystem', 'New System'), children: jsxRuntime.jsx(ui.NiceIcon, { name: "plus", size: 14 }) }), jsxRuntime.jsx("button", { onClick: () => setShowPresets(!showPresets), title: t('particleEditor.addPreset', 'Add Preset'), "aria-label": t('particleEditor.addPreset', 'Add Preset'), children: jsxRuntime.jsx(ui.NiceIcon, { name: "clipboard", size: 14 }) })] })] }), showPresets && (jsxRuntime.jsx("div", { className: ParticleEditor_module.presetMenu, children: Object.keys(particleEditorUtils.PARTICLE_PRESETS).map((preset) => (jsxRuntime.jsx("button", { className: ParticleEditor_module.presetItem, onClick: () => {
+    return (jsxRuntime.jsxs("div", { className: ParticleEditor_module.systemList, children: [jsxRuntime.jsxs("div", { className: ParticleEditor_module.systemListHeader, children: [jsxRuntime.jsx("span", { children: t('particleEditor.systems', 'Systems ({systems})').replace('{systems}', String(systems.length)) }), jsxRuntime.jsxs("div", { className: ParticleEditor_module.systemListActions, children: [jsxRuntime.jsx("button", { onClick: onAdd, title: t('particleEditor.newSystem', 'New System'), "aria-label": t('particleEditor.newSystem', 'New System'), children: jsxRuntime.jsx(ui.NiceIcon, { name: "plus", size: 14 }) }), jsxRuntime.jsx("button", { onClick: () => setShowPresets(!showPresets), title: t('particleEditor.addPreset', 'Add Preset'), "aria-label": t('particleEditor.addPreset', 'Add Preset'), children: jsxRuntime.jsx(ui.NiceIcon, { name: "clipboard", size: 14 }) })] })] }), showPresets && (jsxRuntime.jsx("div", { className: ParticleEditor_module.presetMenu, children: Object.keys(particleEditorUtils.PARTICLE_PRESETS).map((preset) => (jsxRuntime.jsx("button", { className: ParticleEditor_module.presetItem, onClick: () => {
                         onAddPreset(preset);
                         setShowPresets(false);
                     }, children: preset.charAt(0).toUpperCase() + preset.slice(1) }, preset))) })), jsxRuntime.jsx("div", { className: ParticleEditor_module.systemItems, children: systems.map((system) => (jsxRuntime.jsx("div", { className: `${ParticleEditor_module.systemItem} ${selectedId === system.id ? ParticleEditor_module.selected : ''}`, onClick: () => onSelect(system.id), children: editingId === system.id ? (jsxRuntime.jsx("input", { type: "text", value: editName, onChange: (e) => setEditName(e.target.value), onBlur: handleFinishRename, onKeyDown: (e) => e.key === 'Enter' && handleFinishRename(), autoFocus: true, className: ParticleEditor_module.renameInput })) : (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [jsxRuntime.jsx("span", { className: ParticleEditor_module.systemName, onDoubleClick: () => handleStartRename(system), children: system.name }), jsxRuntime.jsxs("div", { className: ParticleEditor_module.systemItemActions, children: [jsxRuntime.jsx("button", { onClick: (e) => {
@@ -385,7 +385,7 @@ function ModuleEditor({ system, moduleKey, onUpdate }) {
                         step: 0.1,
                     }), renderToggle('Looping', system.looping, (v) => onUpdate({ looping: v })), renderToggle('Prewarm', system.prewarm, (v) => onUpdate({ prewarm: v })), renderDistributionInput('Start Delay', system.startDelay, (v) => onUpdate({ startDelay: v })), renderDistributionInput('Start Lifetime', system.startLifetime, (v) => onUpdate({ startLifetime: v })), renderDistributionInput('Start Speed', system.startSpeed, (v) => onUpdate({ startSpeed: v })), renderDistributionInput('Start Size', system.startSize, (v) => onUpdate({ startSize: v })), renderDistributionInput('Start Rotation', system.startRotation, (v) => onUpdate({ startRotation: v })), renderDistributionInput('Gravity Modifier', system.gravityModifier, (v) => onUpdate({ gravityModifier: v })), renderSelect('Simulation Space', system.simulationSpace, { local: 'Local', world: 'World', custom: 'Custom' }, (v) => onUpdate({ simulationSpace: v })), renderNumberInput('Simulation Speed', system.simulationSpeed, (v) => onUpdate({ simulationSpeed: v }), { min: 0, step: 0.1 }), renderNumberInput('Max Particles', system.maxParticles, (v) => onUpdate({ maxParticles: v }), { min: 1, step: 1 })] }));
         case 'emission':
-            return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [renderDistributionInput('Rate over Time', system.emission.rateOverTime, (v) => onUpdate({ emission: { ...system.emission, rateOverTime: v } })), renderDistributionInput('Rate over Distance', system.emission.rateOverDistance, (v) => onUpdate({ emission: { ...system.emission, rateOverDistance: v } })), jsxRuntime.jsxs("div", { className: ParticleEditor_module.propertyRow, children: [jsxRuntime.jsxs("label", { children: ["Bursts (", system.emission.bursts.length, ")"] }), jsxRuntime.jsx("button", { className: ParticleEditor_module.addButton, onClick: () => onUpdate({
+            return (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [renderDistributionInput('Rate over Time', system.emission.rateOverTime, (v) => onUpdate({ emission: { ...system.emission, rateOverTime: v } })), renderDistributionInput('Rate over Distance', system.emission.rateOverDistance, (v) => onUpdate({ emission: { ...system.emission, rateOverDistance: v } })), jsxRuntime.jsxs("div", { className: ParticleEditor_module.propertyRow, children: [jsxRuntime.jsx("label", { children: t('particleEditor.bursts', 'Bursts ({bursts})').replace('{bursts}', String(system.emission.bursts.length)) }), jsxRuntime.jsx("button", { className: ParticleEditor_module.addButton, onClick: () => onUpdate({
                                     emission: {
                                         ...system.emission,
                                         bursts: [
@@ -546,7 +546,14 @@ function NiceParticleEditor({ systems: initialSystems, onSystemsChange, onPlay,
                 cancelAnimationFrame(animationFrameRef.current);
             }
         };
-    }, [state.isPlaying, state.isPaused, state.playbackSpeed, state.currentTime, selectedSystem]);
+    }, [
+        state.isPlaying,
+        state.isPaused,
+        state.playbackSpeed,
+        state.currentTime,
+        selectedSystem,
+        dispatch,
+    ]);
     // Export/Import handlers
     const handleExport = () => {
         const json = particleEditorUtils.exportSystemsToJSON(state.systems);

package/dist/cjs/rendering/NiceCascadedShadows.js

@@ -274,7 +274,7 @@ const NiceCascadedShadows = ({ scene, camera, config: configProp, showDebug: ini
             setShowDebug(initialDebug);
         }
     }, [initialDebug, setShowDebug]);
-    return (jsxRuntime.jsxs("div", { className: `nice-cascaded-shadows ${className}`, style: { display: 'grid', gap: 8, fontSize: 13 }, children: [jsxRuntime.jsxs("strong", { children: [jsxRuntime.jsx(ui.NiceIcon, { name: "lightbulb", size: 14 }), ' ', t('cascadedShadows.cascadedShadowMaps', 'Cascaded Shadow Maps')] }), jsxRuntime.jsxs("label", { children: ["Cascades: ", config.cascadeCount, jsxRuntime.jsx("input", { type: "range", min: 1, max: 5, value: config.cascadeCount, onChange: (e) => setConfig({ cascadeCount: parseInt(e.target.value, 10) }), style: { width: '100%' } })] }), jsxRuntime.jsxs("label", { children: ["Max Distance: ", config.maxFar, jsxRuntime.jsx("input", { type: "range", min: 50, max: 1000, step: 10, value: config.maxFar, onChange: (e) => setConfig({ maxFar: parseInt(e.target.value, 10) }), style: { width: '100%' } })] }), jsxRuntime.jsxs("label", { children: ["Split Mode:", jsxRuntime.jsxs("select", { value: config.splitMode, onChange: (e) => setConfig({ splitMode: e.target.value }), style: { width: '100%', marginTop: 2 }, children: [jsxRuntime.jsx("option", { value: "practical", children: t('cascadedShadows.practical', 'Practical') }), jsxRuntime.jsx("option", { value: "logarithmic", children: t('cascadedShadows.logarithmic', 'Logarithmic') }), jsxRuntime.jsx("option", { value: "linear", children: t('cascadedShadows.linear', 'Linear') })] })] }), config.splitMode === 'practical' && (jsxRuntime.jsxs("label", { children: ["Lambda: ", config.practicalSplitLambda.toFixed(2), jsxRuntime.jsx("input", { type: "range", min: 0, max: 1, step: 0.05, value: config.practicalSplitLambda, onChange: (e) => setConfig({ practicalSplitLambda: parseFloat(e.target.value) }), style: { width: '100%' } })] })), jsxRuntime.jsxs("label", { children: ["Shadow Map Size: ", config.shadowMapSize, jsxRuntime.jsxs("select", { value: config.shadowMapSize, onChange: (e) => setConfig({ shadowMapSize: parseInt(e.target.value, 10) }), style: { width: '100%', marginTop: 2 }, children: [jsxRuntime.jsx("option", { value: 512, children: "512" }), jsxRuntime.jsx("option", { value: 1024, children: "1024" }), jsxRuntime.jsx("option", { value: 2048, children: "2048" }), jsxRuntime.jsx("option", { value: 4096, children: "4096" })] })] }), jsxRuntime.jsxs("div", { style: { fontSize: 10, opacity: 0.7 }, children: ["Cascade splits: ", cascadeSplits.map((s) => s.toFixed(1)).join(' | ')] }), jsxRuntime.jsxs("label", { style: { display: 'flex', alignItems: 'center', gap: 6 }, children: [jsxRuntime.jsx("input", { type: "checkbox", checked: showDebug, onChange: (e) => setShowDebug(e.target.checked) }), t('cascadedShadows.showCascadeFrustums', 'Show cascade frustums')] })] }));
+    return (jsxRuntime.jsxs("div", { className: `nice-cascaded-shadows ${className}`, style: { display: 'grid', gap: 8, fontSize: 13 }, children: [jsxRuntime.jsxs("strong", { children: [jsxRuntime.jsx(ui.NiceIcon, { name: "lightbulb", size: 14 }), ' ', t('cascadedShadows.cascadedShadowMaps', 'Cascaded Shadow Maps')] }), jsxRuntime.jsxs("label", { children: [t('cascadedShadows.cascades', 'Cascades: {cascadeCount}').replace('{cascadeCount}', String(config.cascadeCount)), jsxRuntime.jsx("input", { type: "range", min: 1, max: 5, value: config.cascadeCount, onChange: (e) => setConfig({ cascadeCount: parseInt(e.target.value, 10) }), style: { width: '100%' } })] }), jsxRuntime.jsxs("label", { children: [t('cascadedShadows.maxDistance', 'Max Distance: {maxFar}').replace('{maxFar}', String(config.maxFar)), jsxRuntime.jsx("input", { type: "range", min: 50, max: 1000, step: 10, value: config.maxFar, onChange: (e) => setConfig({ maxFar: parseInt(e.target.value, 10) }), style: { width: '100%' } })] }), jsxRuntime.jsxs("label", { children: [t('cascadedShadows.splitMode', 'Split Mode:'), jsxRuntime.jsxs("select", { value: config.splitMode, onChange: (e) => setConfig({ splitMode: e.target.value }), style: { width: '100%', marginTop: 2 }, children: [jsxRuntime.jsx("option", { value: "practical", children: t('cascadedShadows.practical', 'Practical') }), jsxRuntime.jsx("option", { value: "logarithmic", children: t('cascadedShadows.logarithmic', 'Logarithmic') }), jsxRuntime.jsx("option", { value: "linear", children: t('cascadedShadows.linear', 'Linear') })] })] }), config.splitMode === 'practical' && (jsxRuntime.jsxs("label", { children: [t('cascadedShadows.lambda', 'Lambda: {practicalSplitLambda}').replace('{practicalSplitLambda}', String(config.practicalSplitLambda.toFixed(2))), jsxRuntime.jsx("input", { type: "range", min: 0, max: 1, step: 0.05, value: config.practicalSplitLambda, onChange: (e) => setConfig({ practicalSplitLambda: parseFloat(e.target.value) }), style: { width: '100%' } })] })), jsxRuntime.jsxs("label", { children: [t('cascadedShadows.shadowMapSize', 'Shadow Map Size: {shadowMapSize}').replace('{shadowMapSize}', String(config.shadowMapSize)), jsxRuntime.jsxs("select", { value: config.shadowMapSize, onChange: (e) => setConfig({ shadowMapSize: parseInt(e.target.value, 10) }), style: { width: '100%', marginTop: 2 }, children: [jsxRuntime.jsx("option", { value: 512, children: "512" }), jsxRuntime.jsx("option", { value: 1024, children: "1024" }), jsxRuntime.jsx("option", { value: 2048, children: "2048" }), jsxRuntime.jsx("option", { value: 4096, children: "4096" })] })] }), jsxRuntime.jsx("div", { style: { fontSize: 10, opacity: 0.7 }, children: t('cascadedShadows.cascadeSplits', 'Cascade splits: {cascadeSplits}').replace('{cascadeSplits}', String(cascadeSplits.map((s) => s.toFixed(1)).join(' | '))) }), jsxRuntime.jsxs("label", { style: { display: 'flex', alignItems: 'center', gap: 6 }, children: [jsxRuntime.jsx("input", { type: "checkbox", checked: showDebug, onChange: (e) => setShowDebug(e.target.checked) }), t('cascadedShadows.showCascadeFrustums', 'Show cascade frustums')] })] }));
 };
 
 exports.NiceCascadedShadows = NiceCascadedShadows;