@vctrl/hooks 0.7.7 → 0.8.0

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.7.7",
+  "version": "0.8.0",
   "name": "@vctrl/hooks",
   "description": "vctrl/hooks is a React hooks package designed to simplify 3D model loading and management within React applications. It's part of the vectreal-core ecosystem and is primarily used in the vctrl/viewer React component and the official website application.",
   "bugs": {
@@ -46,12 +46,12 @@
     "react": "18.3.1"
   },
   "dependencies": {
-    "jszip": "^3.10.1",
-    "file-saver": "^2.0.5",
-    "three": "^0.168.0",
     "@gltf-transform/core": "^4.0.8",
-    "@gltf-transform/functions": "^4.0.8",
     "@gltf-transform/extensions": "^4.0.10",
-    "meshoptimizer": "^0.21.0"
+    "@gltf-transform/functions": "^4.0.8",
+    "file-saver": "^2.0.5",
+    "jszip": "^3.10.1",
+    "meshoptimizer": "^0.21.0",
+    "three": "^0.168.0"
   }
 }

package/use-load-model/model-context.d.ts

@@ -8,28 +8,30 @@ declare const ModelContext: import('react').Context<{
     load: (filesOrDirectories: import('./types').InputFileOrDirectory) => Promise<void>;
     reset: () => void;
     optimize: {
+        simplifyOptimization: () => void;
+        dedupOptimization: () => void;
+        quantizeOptimization: () => void;
+        normalsOptimization: () => void;
+        texturesCompressOptimization: () => void;
+        getSize: () => void;
+        reset: () => void;
+        report: null;
+        error: null;
+        loading: boolean;
+    } | {
         simplifyOptimization: (options?: {
             ratio?: number;
             error?: number;
         } | undefined) => Promise<void>;
         dedupOptimization: (options?: import('@gltf-transform/functions').DedupOptions | undefined) => Promise<void>;
         quantizeOptimization: (options?: import('@gltf-transform/functions').QuantizeOptions | undefined) => Promise<void>;
+        normalsOptimization: (options?: import('@gltf-transform/functions').NormalsOptions | undefined) => Promise<void>;
         texturesCompressOptimization: (options?: import('@gltf-transform/functions').TextureCompressOptions | undefined) => Promise<void>;
         getSize: () => import('../use-optimize-model/types').ModelSize | null;
         reset: () => void;
         report: import('@gltf-transform/functions').InspectReport | null;
         error: Error | null;
         loading: boolean;
-    } | {
-        simplifyOptimization: () => void;
-        dedupOptimization: () => void;
-        quantizeOptimization: () => void;
-        texturesCompressOptimization: () => void;
-        getSize: () => void;
-        reset: () => void;
-        report: null;
-        error: null;
-        loading: boolean;
     };
     file: import('./types').ModelFile | null;
     isFileLoading: boolean;
@@ -43,28 +45,30 @@ declare const useModelContext: () => {
     load: (filesOrDirectories: import('./types').InputFileOrDirectory) => Promise<void>;
     reset: () => void;
     optimize: {
+        simplifyOptimization: () => void;
+        dedupOptimization: () => void;
+        quantizeOptimization: () => void;
+        normalsOptimization: () => void;
+        texturesCompressOptimization: () => void;
+        getSize: () => void;
+        reset: () => void;
+        report: null;
+        error: null;
+        loading: boolean;
+    } | {
         simplifyOptimization: (options?: {
             ratio?: number;
             error?: number;
         } | undefined) => Promise<void>;
         dedupOptimization: (options?: import('@gltf-transform/functions').DedupOptions | undefined) => Promise<void>;
         quantizeOptimization: (options?: import('@gltf-transform/functions').QuantizeOptions | undefined) => Promise<void>;
+        normalsOptimization: (options?: import('@gltf-transform/functions').NormalsOptions | undefined) => Promise<void>;
         texturesCompressOptimization: (options?: import('@gltf-transform/functions').TextureCompressOptions | undefined) => Promise<void>;
         getSize: () => import('../use-optimize-model/types').ModelSize | null;
         reset: () => void;
         report: import('@gltf-transform/functions').InspectReport | null;
         error: Error | null;
         loading: boolean;
-    } | {
-        simplifyOptimization: () => void;
-        dedupOptimization: () => void;
-        quantizeOptimization: () => void;
-        texturesCompressOptimization: () => void;
-        getSize: () => void;
-        reset: () => void;
-        report: null;
-        error: null;
-        loading: boolean;
     };
     file: import('./types').ModelFile | null;
     isFileLoading: boolean;

package/use-load-model/use-load-model.d.ts

@@ -41,28 +41,30 @@ declare function useLoadModel(optimizer?: ReturnType<typeof useOptimizeModel>):
      * - `loading`: The loading state of the optimizer.
      */
     optimize: {
+        simplifyOptimization: () => void;
+        dedupOptimization: () => void;
+        quantizeOptimization: () => void;
+        normalsOptimization: () => void;
+        texturesCompressOptimization: () => void;
+        getSize: () => void;
+        reset: () => void;
+        report: null;
+        error: null;
+        loading: boolean;
+    } | {
         simplifyOptimization: (options?: {
             ratio?: number;
             error?: number;
         } | undefined) => Promise<void>;
         dedupOptimization: (options?: import('@gltf-transform/functions').DedupOptions | undefined) => Promise<void>;
         quantizeOptimization: (options?: import('@gltf-transform/functions').QuantizeOptions | undefined) => Promise<void>;
+        normalsOptimization: (options?: import('@gltf-transform/functions').NormalsOptions | undefined) => Promise<void>;
         texturesCompressOptimization: (options?: import('@gltf-transform/functions').TextureCompressOptions | undefined) => Promise<void>;
         getSize: () => import('../use-optimize-model/types').ModelSize | null;
         reset: () => void;
         report: import('@gltf-transform/functions').InspectReport | null;
         error: Error | null;
         loading: boolean;
-    } | {
-        simplifyOptimization: () => void;
-        dedupOptimization: () => void;
-        quantizeOptimization: () => void;
-        texturesCompressOptimization: () => void;
-        getSize: () => void;
-        reset: () => void;
-        report: null;
-        error: null;
-        loading: boolean;
     };
     file: ModelFile | null;
     isFileLoading: boolean;

package/use-load-model.cjs.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./model-context-DLPGvQ8f.cjs");exports.ModelContext=e.ModelContext;exports.ModelFileTypes=e.ModelFileTypes;exports.ModelProvider=e.ModelProvider;exports.useLoadModel=e.useLoadModel;exports.useModelContext=e.useModelContext;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./model-context-Du5WQddA.cjs");exports.ModelContext=e.ModelContext;exports.ModelFileTypes=e.ModelFileTypes;exports.ModelProvider=e.ModelProvider;exports.useLoadModel=e.useLoadModel;exports.useModelContext=e.useModelContext;

package/use-load-model.es.js

@@ -1,4 +1,4 @@
-import { a as s, M as a, b as d, u as l, c as M } from "./model-context-hgFMs-nK.js";
+import { a as s, M as a, b as d, u as l, c as M } from "./model-context-fEKN9ymq.js";
 export {
   s as ModelContext,
   a as ModelFileTypes,

package/use-optimize-model/use-optimize-model.d.ts

@@ -1,5 +1,5 @@
 import { Object3D } from 'three';
-import { dedup, quantize, textureCompress } from '@gltf-transform/functions';
+import { dedup, quantize, normals, textureCompress } from '@gltf-transform/functions';
 import { ModelSize } from './types';
 /**
  * Custom React hook for optimizing Three.js models using glTF-Transform.
@@ -20,6 +20,7 @@ declare const useOptimizeModel: () => {
     }) => Promise<void>;
     dedupOptimization: (options?: Parameters<typeof dedup>[0]) => Promise<void>;
     quantizeOptimization: (options?: Parameters<typeof quantize>[0]) => Promise<void>;
+    normalsOptimization: (options?: Parameters<typeof normals>[0]) => Promise<void>;
     texturesOptimization: (options?: Parameters<typeof textureCompress>[0]) => Promise<void>;
     reset: () => void;
     error: Error | null;

package/{use-optimize-model-CgEMWTEN.js → use-optimize-model-BXWR9d6e.js}

@@ -1,15 +1,15 @@
-import { useReducer as L, useRef as d, useCallback as o } from "react";
-import { G as M } from "./GLTFExporter-Q5UJ5eb1.js";
-import { WebIO as _ } from "@gltf-transform/core";
-import { inspect as y, weld as b, simplify as B, dedup as U, quantize as F, textureCompress as H } from "@gltf-transform/functions";
-import { KHRMeshQuantization as K, KHRMaterialsVolume as q, KHRMaterialsTransmission as G } from "@gltf-transform/extensions";
-import { MeshoptSimplifier as k } from "meshoptimizer";
+import { useReducer as M, useRef as d, useCallback as n } from "react";
+import { G as _ } from "./GLTFExporter-Q5UJ5eb1.js";
+import { WebIO as b } from "@gltf-transform/core";
+import { inspect as y, weld as B, simplify as U, dedup as F, quantize as H, normals as K, textureCompress as q } from "@gltf-transform/functions";
+import { KHRMeshQuantization as G, KHRMaterialsVolume as k, KHRMaterialsTransmission as I } from "@gltf-transform/extensions";
+import { MeshoptSimplifier as Q } from "meshoptimizer";
 const f = {
   modelDoc: null,
   modelReport: null,
   error: null,
   loading: !1
-}, I = (i, t) => {
+}, V = (i, t) => {
   switch (t.type) {
     case "LOAD_START":
       return { ...i, loading: !0, error: null };
@@ -27,14 +27,14 @@ const f = {
     default:
       return i;
   }
-}, J = () => {
-  const [i, t] = L(I, f), { modelDoc: n, modelReport: a, error: R, loading: S } = i, O = d(new M()), u = d(
-    new _().registerExtensions([
-      K,
-      q,
-      G
+}, P = () => {
+  const [i, t] = M(V, f), { modelDoc: s, modelReport: a, error: R, loading: S } = i, O = d(new _()), u = d(
+    new b().registerExtensions([
+      G,
+      k,
+      I
     ])
-  ), z = o(async (r) => {
+  ), z = n(async (r) => {
     t({ type: "LOAD_START" });
     try {
       const e = { binary: !0 }, l = await O.current.parseAsync(r, e), c = new Uint8Array(l), p = await u.current.readBinary(c), m = y(p);
@@ -45,77 +45,83 @@ const f = {
     } catch (e) {
       t({ type: "LOAD_ERROR", payload: e }), console.error("Error loading model:", e);
     }
-  }, []), s = o(
+  }, []), o = n(
     async (r) => {
-      if (n)
+      if (s)
         try {
-          await n.transform(...r);
-          const e = y(n);
+          await s.transform(...r);
+          const e = y(s);
           t({
             type: "LOAD_SUCCESS",
-            payload: { modelDoc: n, modelReport: e }
+            payload: { modelDoc: s, modelReport: e }
           });
         } catch (e) {
           console.error("Error applying transforms:", e);
         }
     },
-    [n]
-  ), E = o(
+    [s]
+  ), w = n(
     async (r) => {
       const { ratio: e = 0.5, error: l = 1e-3 } = r || {};
-      await s([
-        b(),
-        B({
-          simplifier: k,
+      await o([
+        B(),
+        U({
+          simplifier: Q,
           ratio: e,
           error: l
         })
       ]);
     },
-    [s]
-  ), w = o(
+    [o]
+  ), E = n(
     async (r) => {
-      await s([U(r)]);
+      await o([F(r)]);
     },
-    [s]
-  ), g = o(
+    [o]
+  ), g = n(
     async (r) => {
-      await s([F(r)]);
+      await o([H(r)]);
     },
-    [s]
-  ), D = o(
+    [o]
+  ), D = n(
     async (r) => {
-      r && await s([H(r)]);
+      await o([K(r)]);
     },
-    [s]
-  ), A = o(async () => {
-    if (!n) return null;
+    [o]
+  ), A = n(
+    async (r) => {
+      r && await o([q(r)]);
+    },
+    [o]
+  ), h = n(async () => {
+    if (!s) return null;
     try {
-      return await u.current.writeBinary(n);
+      return await u.current.writeBinary(s);
     } catch (r) {
       return console.error("Error getting model binary:", r), null;
     }
-  }, [n]), h = o(() => {
+  }, [s]), x = n(() => {
     if (!a) return null;
-    const r = (m) => m.reduce((T, C) => T + C.size, 0), e = r(a.meshes.properties), l = r(a.textures.properties), c = e + l, p = `${(c / (1024 * 1024)).toFixed(2)} MB`;
+    const r = (m) => m.reduce((C, L) => C + L.size, 0), e = r(a.meshes.properties), l = r(a.textures.properties), c = e + l, p = `${(c / (1024 * 1024)).toFixed(2)} MB`;
     return { fileSize: c, displayFileSize: p };
-  }, [a]), x = o(() => {
+  }, [a]), T = n(() => {
     t({ type: "RESET" });
   }, []);
   return {
     load: z,
-    getModel: A,
-    getSize: h,
+    getModel: h,
+    getSize: x,
     report: a,
-    simplifyOptimization: E,
-    dedupOptimization: w,
+    simplifyOptimization: w,
+    dedupOptimization: E,
     quantizeOptimization: g,
-    texturesOptimization: D,
-    reset: x,
+    normalsOptimization: D,
+    texturesOptimization: A,
+    reset: T,
     error: R,
     loading: S
   };
 };
 export {
-  J as u
+  P as u
 };

package/use-optimize-model-EEn8K4nu.cjs

@@ -0,0 +1 @@
+"use strict";const r=require("react"),T=require("./GLTFExporter-ltc8rmzz.cjs"),L=require("@gltf-transform/core"),a=require("@gltf-transform/functions"),m=require("@gltf-transform/extensions"),q=require("meshoptimizer"),R={modelDoc:null,modelReport:null,error:null,loading:!1},M=(i,o)=>{switch(o.type){case"LOAD_START":return{...i,loading:!0,error:null};case"LOAD_SUCCESS":return{...i,loading:!1,modelDoc:o.payload.modelDoc,modelReport:o.payload.modelReport};case"LOAD_ERROR":return{...i,loading:!1,error:o.payload};case"RESET":return{...R};default:return i}},_=()=>{const[i,o]=r.useReducer(M,R),{modelDoc:n,modelReport:l,error:f,loading:S}=i,z=r.useRef(new T.GLTFExporter),y=r.useRef(new L.WebIO().registerExtensions([m.KHRMeshQuantization,m.KHRMaterialsVolume,m.KHRMaterialsTransmission])),O=r.useCallback(async e=>{o({type:"LOAD_START"});try{const t={binary:!0},c=await z.current.parseAsync(e,t),u=new Uint8Array(c),p=await y.current.readBinary(u),d=a.inspect(p);o({type:"LOAD_SUCCESS",payload:{modelDoc:p,modelReport:d}})}catch(t){o({type:"LOAD_ERROR",payload:t}),console.error("Error loading model:",t)}},[]),s=r.useCallback(async e=>{if(n)try{await n.transform(...e);const t=a.inspect(n);o({type:"LOAD_SUCCESS",payload:{modelDoc:n,modelReport:t}})}catch(t){console.error("Error applying transforms:",t)}},[n]),C=r.useCallback(async e=>{const{ratio:t=.5,error:c=.001}=e||{};await s([a.weld(),a.simplify({simplifier:q.MeshoptSimplifier,ratio:t,error:c})])},[s]),E=r.useCallback(async e=>{await s([a.dedup(e)])},[s]),w=r.useCallback(async e=>{await s([a.quantize(e)])},[s]),b=r.useCallback(async e=>{await s([a.normals(e)])},[s]),g=r.useCallback(async e=>{e&&await s([a.textureCompress(e)])},[s]),D=r.useCallback(async()=>{if(!n)return null;try{return await y.current.writeBinary(n)}catch(e){return console.error("Error getting model binary:",e),null}},[n]),A=r.useCallback(()=>{if(!l)return null;const e=d=>d.reduce((k,x)=>k+x.size,0),t=e(l.meshes.properties),c=e(l.textures.properties),u=t+c,p=`${(u/(1024*1024)).toFixed(2)} MB`;return{fileSize:u,displayFileSize:p}},[l]),h=r.useCallback(()=>{o({type:"RESET"})},[]);return{load:O,getModel:D,getSize:A,report:l,simplifyOptimization:C,dedupOptimization:E,quantizeOptimization:w,normalsOptimization:b,texturesOptimization:g,reset:h,error:f,loading:S}};exports.useOptimizeModel=_;

package/use-optimize-model.cjs.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./use-optimize-model-BcDBGz71.cjs");exports.useOptimizeModel=e.useOptimizeModel;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./use-optimize-model-EEn8K4nu.cjs");exports.useOptimizeModel=e.useOptimizeModel;

package/use-optimize-model.es.js

@@ -1,4 +1,4 @@
-import { u as i } from "./use-optimize-model-CgEMWTEN.js";
+import { u as i } from "./use-optimize-model-BXWR9d6e.js";
 export {
   i as useOptimizeModel
 };

package/use-optimize-model-BcDBGz71.cjs

@@ -1 +0,0 @@
-"use strict";const t=require("react"),T=require("./GLTFExporter-ltc8rmzz.cjs"),k=require("@gltf-transform/core"),a=require("@gltf-transform/functions"),m=require("@gltf-transform/extensions"),L=require("meshoptimizer"),R={modelDoc:null,modelReport:null,error:null,loading:!1},q=(i,o)=>{switch(o.type){case"LOAD_START":return{...i,loading:!0,error:null};case"LOAD_SUCCESS":return{...i,loading:!1,modelDoc:o.payload.modelDoc,modelReport:o.payload.modelReport};case"LOAD_ERROR":return{...i,loading:!1,error:o.payload};case"RESET":return{...R};default:return i}},M=()=>{const[i,o]=t.useReducer(q,R),{modelDoc:s,modelReport:l,error:f,loading:S}=i,z=t.useRef(new T.GLTFExporter),y=t.useRef(new k.WebIO().registerExtensions([m.KHRMeshQuantization,m.KHRMaterialsVolume,m.KHRMaterialsTransmission])),O=t.useCallback(async e=>{o({type:"LOAD_START"});try{const r={binary:!0},c=await z.current.parseAsync(e,r),u=new Uint8Array(c),p=await y.current.readBinary(u),d=a.inspect(p);o({type:"LOAD_SUCCESS",payload:{modelDoc:p,modelReport:d}})}catch(r){o({type:"LOAD_ERROR",payload:r}),console.error("Error loading model:",r)}},[]),n=t.useCallback(async e=>{if(s)try{await s.transform(...e);const r=a.inspect(s);o({type:"LOAD_SUCCESS",payload:{modelDoc:s,modelReport:r}})}catch(r){console.error("Error applying transforms:",r)}},[s]),C=t.useCallback(async e=>{const{ratio:r=.5,error:c=.001}=e||{};await n([a.weld(),a.simplify({simplifier:L.MeshoptSimplifier,ratio:r,error:c})])},[n]),E=t.useCallback(async e=>{await n([a.dedup(e)])},[n]),w=t.useCallback(async e=>{await n([a.quantize(e)])},[n]),b=t.useCallback(async e=>{e&&await n([a.textureCompress(e)])},[n]),g=t.useCallback(async()=>{if(!s)return null;try{return await y.current.writeBinary(s)}catch(e){return console.error("Error getting model binary:",e),null}},[s]),D=t.useCallback(()=>{if(!l)return null;const e=d=>d.reduce((h,x)=>h+x.size,0),r=e(l.meshes.properties),c=e(l.textures.properties),u=r+c,p=`${(u/(1024*1024)).toFixed(2)} MB`;return{fileSize:u,displayFileSize:p}},[l]),A=t.useCallback(()=>{o({type:"RESET"})},[]);return{load:O,getModel:g,getSize:D,report:l,simplifyOptimization:C,dedupOptimization:E,quantizeOptimization:w,texturesOptimization:b,reset:A,error:f,loading:S}};exports.useOptimizeModel=M;