@threlte/gltf 3.0.1 → 3.0.3

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @threlte/gltf
 
+## 3.0.3
+
+### Patch Changes
+
+- da99fff: Run `knip` and prune unused dependencies and exports
+
+## 3.0.2
+
+### Patch Changes
+
+- b1bc980: Update dependencies
+
 ## 3.0.1
 
 ### Patch Changes

package/README.md

@@ -35,7 +35,7 @@ This helps with performance optimization for asset-heavy Threlte apps. It also a
 
 #### The GLTF workflow on the web is not ideal ...
 
-- GLTF is thrown wholesale into the scene which prevents re-use, in threejs objects can only be mounted once
+- GLTF is thrown wholesale into the scene which prevents re-use, in Three.js objects can only be mounted once
 - Contents can only be found by traversal which is cumbersome and slow
 - Changes to queried nodes are made by mutation, which alters the source data and prevents re-use
 - Re-structuring content, making nodes conditional or adding/removing is cumbersome
@@ -323,10 +323,6 @@ Contributions are what make the open source community such an amazing place to l
 - **Filing Issues** - if you have feature requestions or you think you spotted a bug, [submit an issue](https://github.com/threlte/threlte/issues/new).
 - **Contributing Code** - if you would like to drop us a PR, read the [contribution guide](https://github.com/threlte/threlte/blob/main/CONTRIBUTING.md) first.
 
-## Sponsors
-
-[![Powered by Vercel](./assets/vercel/powered-by-vercel.svg)](https://vercel.com/?utm_source=threlte&utm_campaign=oss)
-
 ---
 
 ### License

package/cli.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 'use strict'
+
+import { dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
 import meow from 'meow'
-import { dirname } from 'path'
 import { readPackageUpSync } from 'read-pkg-up'
-import { fileURLToPath } from 'url'
 import gltf from './src/index.js'
 
 const __filename = fileURLToPath(import.meta.url)
@@ -26,12 +27,14 @@ const cli = meow(
     --draco, -d         Draco binary path
     --preload -P        Add preload method to module script
     --suspense -u       Make the component suspense-ready
-    --isolated, -i      Output as isolated module (No $$restProps usage)
+    --isolated, -i      Output as isolated module
     --root, -r          Sets directory from which .gltf file is served
     --transform, -T     Transform the asset for the web (draco, prune, resize)
       --resolution, -R  Transform resolution for texture resizing (default: 1024)
-      --simplify, -S    Transform simplification (default: false) (experimental!)
-        --weld          Weld tolerance (default: 0.0001)
+      --keepmeshes, -j  Do not join compatible meshes
+      --keepmaterials, -M Do not palette join materials
+      --format, -f      Texture format (default: "webp")
+      --simplify, -S    Transform simplification (default: false)
         --ratio         Simplifier ratio (default: 0.75)
         --error         Simplifier error threshold (default: 0.001)
     --debug, -D         Debug output
@@ -39,26 +42,29 @@ const cli = meow(
   {
     importMeta: import.meta,
     flags: {
-      output: { type: 'string', alias: 'o' },
-      types: { type: 'boolean', alias: 't' },
-      keepnames: { type: 'boolean', alias: 'k' },
-      keepgroups: { type: 'boolean', alias: 'K' },
-      shadows: { type: 'boolean', alias: 's' },
-      printwidth: { type: 'number', alias: 'p', default: 120 },
-      meta: { type: 'boolean', alias: 'm' },
-      precision: { type: 'number', alias: 'p', default: 2 },
-      isolated: { type: 'boolean', alias: 'i', default: false },
-      preload: { type: 'boolean', alias: 'P', default: false },
-      suspense: { type: 'boolean', alias: 'u', default: false },
-      draco: { type: 'string', alias: 'd' },
-      root: { type: 'string', alias: 'r' },
-      transform: { type: 'boolean', alias: 'T' },
-      resolution: { type: 'number', alias: 'R', default: 1024 },
-      simplify: { type: 'boolean', alias: 'S', default: false },
-      weld: { type: 'number', default: 0.0001 },
+      output: { type: 'string', shortFlag: 'o' },
+      types: { type: 'boolean', shortFlag: 't' },
+      keepnames: { type: 'boolean', shortFlag: 'k' },
+      keepgroups: { type: 'boolean', shortFlag: 'K' },
+      shadows: { type: 'boolean', shortFlag: 's' },
+      printwidth: { type: 'number', shortFlag: 'p', default: 120 },
+      meta: { type: 'boolean', shortFlag: 'm' },
+      precision: { type: 'number', shortFlag: 'p', default: 2 },
+      isolated: { type: 'boolean', shortFlag: 'i', default: false },
+      preload: { type: 'boolean', shortFlag: 'P', default: false },
+      suspense: { type: 'boolean', shortFlag: 'u', default: false },
+      draco: { type: 'string', shortFlag: 'd' },
+      root: { type: 'string', shortFlag: 'r' },
+      transform: { type: 'boolean', shortFlag: 'T' },
+      resolution: { type: 'number', shortFlag: 'R', default: 1024 },
+      degrade: { type: 'string', shortFlag: 'q', default: '' },
+      degraderesolution: { type: 'number', shortFlag: 'Q', default: 512 },
+      simplify: { type: 'boolean', shortFlag: 'S', default: false },
+      keepmeshes: { type: 'boolean', shortFlag: 'j', default: false },
+      keepmaterials: { type: 'boolean', shortFlag: 'M', default: false },
       ratio: { type: 'number', default: 0.75 },
       error: { type: 'number', default: 0.001 },
-      debug: { type: 'boolean', alias: 'D' }
+      debug: { type: 'boolean', shortFlag: 'D' }
     }
   }
 )
@@ -68,22 +74,17 @@ const { packageJson } = readPackageUpSync({ cwd: __dirname, normalize: false })
 if (cli.input.length === 0) {
   console.log(cli.help)
 } else {
-  const config = {
-    ...cli.flags,
-    header: `Auto-generated by: https://github.com/threlte/threlte/tree/main/packages/gltf
-Command: npx @threlte/gltf@${packageJson.version} ${process.argv.slice(2).join(' ')}`
-  }
   const file = cli.input[0]
-  let nameExt = file.match(/[-_\w]+[.][\w]+$/i)[0]
-  let name = nameExt.split('.').slice(0, -1).join('.')
-  const output = name + '.svelte'
-  const showLog = (log) => {
-    console.info('log:', log)
-  }
+  const nameExt = file.match(/[-_\w]+[.][\w]+$/i)[0]
+  const name = nameExt.split('.').slice(0, -1).join('.')
+  const output = `${name}.svelte`
+
   try {
     await gltf(file, output, {
-      ...config,
-      showLog,
+      ...cli.flags,
+      header: `Auto-generated by: https://github.com/threlte/threlte/tree/main/packages/gltf
+Command: npx @threlte/gltf@${packageJson.version} ${process.argv.slice(2).join(' ')}`,
+      showLog: (log) => console.info('log:', log),
       timeout: 0,
       delay: 1
     })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@threlte/gltf",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "description": "GLTF to Threlte converter",
   "type": "module",
   "keywords": [
@@ -18,42 +18,36 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/threlte/threlte.git"
+    "url": "https://github.com/threlte/threlte",
+    "directory": "packages/gltf"
   },
   "bugs": {
-    "url": "https://github.com/threlte/threlte.git/issues"
+    "url": "https://github.com/threlte/threlte/issues"
   },
-  "homepage": "https://github.com/threlte/threlte.git#readme",
+  "homepage": "https://threlte.xyz",
   "bin": "./cli.js",
   "main": "./src/utils/exports.js",
-  "engines": {
-    "node": ">=16"
-  },
   "dependencies": {
-    "@gltf-transform/core": "^3.2.1",
-    "@gltf-transform/extensions": "^3.2.1",
-    "@gltf-transform/functions": "^3.2.1",
-    "@node-loader/babel": "^2.0.1",
-    "draco3dgltf": "^1.5.6",
-    "jsdom": "^20.0.3",
+    "@gltf-transform/core": "^4.2.1",
+    "@gltf-transform/extensions": "^4.2.1",
+    "@gltf-transform/functions": "^4.2.1",
+    "draco3dgltf": "^1.5.7",
+    "jsdom": "^27.1.0",
     "jsdom-global": "^3.0.2",
-    "meow": "^11.0.0",
-    "meshoptimizer": "^0.18.1",
-    "prettier": "^3.2.5",
-    "prettier-plugin-svelte": "^3.2.2",
-    "sharp": "^0.32.0",
-    "svelte": "^5.26.2",
-    "three": "0.122.0",
-    "three-stdlib": "^2.21.8"
+    "keyframe-resample": "^0.1.0",
+    "meow": "^14.0.0",
+    "meshoptimizer": "^0.25.0",
+    "prettier": "^3.6.2",
+    "prettier-plugin-svelte": "^3.4.0",
+    "read-pkg-up": "^11.0.0",
+    "sharp": "^0.34.5",
+    "svelte": "5.53.6",
+    "three": "0.159.0"
   },
   "devDependencies": {
-    "chalk": "^4.1.1",
-    "fast-glob": "^3.2.7",
-    "fs-extra": "^9.0.1",
-    "husky": "^4.3.0",
-    "lint-staged": "^10.4.0",
-    "read-pkg-up": "^9.1.0",
-    "rimraf": "^5.0.1"
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.6",
+    "rimraf": "^6.1.0"
   },
   "husky": {
     "hooks": {

package/src/bin/DRACOLoader.js

@@ -1,9 +1,9 @@
-'use strict'
-import THREE from 'three'
+import * as THREE from 'three'
 import draco from 'draco3dgltf'
+
 const decoder = draco.createDecoderModule()
-const DRACOLoader = (THREE.DRACOLoader = function (t) {
-  ;(this.timeLoaded = 0),
+const DRACOLoader = function (t) {
+  ;((this.timeLoaded = 0),
     (this.manager = t || THREE.DefaultLoadingManager),
     (this.materials = null),
     (this.verbosity = 0),
@@ -14,17 +14,18 @@ const DRACOLoader = (THREE.DRACOLoader = function (t) {
       normal: 'NORMAL',
       color: 'COLOR',
       uv: 'TEX_COORD'
-    })
-})
-
-export default DRACOLoader
+    }))
+}
 
-THREE.DRACOLoader.prototype = {
-  constructor: THREE.DRACOLoader,
+DRACOLoader.prototype = {
+  constructor: DRACOLoader,
+  preload: function () {
+    return this
+  },
   load: function (t, e, r, o) {
     var i = this,
       n = new THREE.FileLoader(i.manager)
-    n.setPath(this.path),
+    ;(n.setPath(this.path),
       n.setResponseType('arraybuffer'),
       n.load(
         t,
@@ -33,20 +34,20 @@ THREE.DRACOLoader.prototype = {
         },
         r,
         o
-      )
+      ))
   },
   setPath: function (t) {
-    return (this.path = t), this
+    return ((this.path = t), this)
   },
   setVerbosity: function (t) {
-    return (this.verbosity = t), this
+    return ((this.verbosity = t), this)
   },
   setDrawMode: function (t) {
-    return (this.drawMode = t), this
+    return ((this.drawMode = t), this)
   },
   setSkipDequantization: function (t, e) {
     var r = !0
-    return void 0 !== e && (r = e), (this.getAttributeOptions(t).skipDequantization = r), this
+    return (void 0 !== e && (r = e), (this.getAttributeOptions(t).skipDequantization = r), this)
   },
   decodeDracoFile: function (t, e, r, o) {
     decoder.then((decoder) => this.decodeDracoFileInternal(t, decoder, e, r, o))
@@ -77,53 +78,53 @@ THREE.DRACOLoader.prototype = {
       l = r.num_points() * c
     switch (i) {
       case Float32Array:
-        ;(d = new t.DracoFloat32Array()),
+        ;((d = new t.DracoFloat32Array()),
           e.GetAttributeFloatForAllPoints(r, n, d),
           (s[o] = new Float32Array(l)),
-          (A = THREE.Float32BufferAttribute)
+          (A = THREE.Float32BufferAttribute))
         break
       case Int8Array:
-        ;(d = new t.DracoInt8Array()),
+        ;((d = new t.DracoInt8Array()),
           e.GetAttributeInt8ForAllPoints(r, n, d),
           (s[o] = new Int8Array(l)),
-          (A = THREE.Int8BufferAttribute)
+          (A = THREE.Int8BufferAttribute))
         break
       case Int16Array:
-        ;(d = new t.DracoInt16Array()),
+        ;((d = new t.DracoInt16Array()),
           e.GetAttributeInt16ForAllPoints(r, n, d),
           (s[o] = new Int16Array(l)),
-          (A = THREE.Int16BufferAttribute)
+          (A = THREE.Int16BufferAttribute))
         break
       case Int32Array:
-        ;(d = new t.DracoInt32Array()),
+        ;((d = new t.DracoInt32Array()),
           e.GetAttributeInt32ForAllPoints(r, n, d),
           (s[o] = new Int32Array(l)),
-          (A = THREE.Int32BufferAttribute)
+          (A = THREE.Int32BufferAttribute))
         break
       case Uint8Array:
-        ;(d = new t.DracoUInt8Array()),
+        ;((d = new t.DracoUInt8Array()),
           e.GetAttributeUInt8ForAllPoints(r, n, d),
           (s[o] = new Uint8Array(l)),
-          (A = THREE.Uint8BufferAttribute)
+          (A = THREE.Uint8BufferAttribute))
         break
       case Uint16Array:
-        ;(d = new t.DracoUInt16Array()),
+        ;((d = new t.DracoUInt16Array()),
           e.GetAttributeUInt16ForAllPoints(r, n, d),
           (s[o] = new Uint16Array(l)),
-          (A = THREE.Uint16BufferAttribute)
+          (A = THREE.Uint16BufferAttribute))
         break
       case Uint32Array:
-        ;(d = new t.DracoUInt32Array()),
+        ;((d = new t.DracoUInt32Array()),
           e.GetAttributeUInt32ForAllPoints(r, n, d),
           (s[o] = new Uint32Array(l)),
-          (A = THREE.Uint32BufferAttribute)
+          (A = THREE.Uint32BufferAttribute))
         break
       default:
         u = 'THREE.DRACOLoader: Unexpected attribute type.'
         throw (console.error(u), new Error(u))
     }
     for (var b = 0; b < l; b++) s[o][b] = d.GetValue(b)
-    a.setAttribute(o, new A(s[o], c)), t.destroy(d)
+    ;(a.setAttribute(o, new A(s[o], c)), t.destroy(d))
   },
   convertDracoGeometryTo3JS: function (t, e, r, o, i, n) {
     var a, s, u
@@ -139,11 +140,11 @@ THREE.DRACOLoader.prototype = {
       var d = 'THREE.DRACOLoader: Decoding failed: '
       throw ((d += s.error_msg()), console.error(d), t.destroy(e), t.destroy(a), new Error(d))
     }
-    t.destroy(o),
+    ;(t.destroy(o),
       r == t.TRIANGULAR_MESH
         ? ((u = a.num_faces()),
           this.verbosity > 0 && console.log('Number of faces loaded: ' + u.toString()))
-        : (u = 0)
+        : (u = 0))
     var A = a.num_points(),
       c = a.num_attributes()
     this.verbosity > 0 &&
@@ -187,28 +188,28 @@ THREE.DRACOLoader.prototype = {
         for (I = 0; I < u; ++I) {
           e.GetFaceFromMesh(a, I, D)
           var m = 3 * I
-          ;(f.indices[m] = D.GetValue(0)),
+          ;((f.indices[m] = D.GetValue(0)),
             (f.indices[m + 1] = D.GetValue(1)),
-            (f.indices[m + 2] = D.GetValue(2))
+            (f.indices[m + 2] = D.GetValue(2)))
         }
         t.destroy(D)
       }
-    ;(y.drawMode = this.drawMode),
+    ;((y.drawMode = this.drawMode),
       r == t.TRIANGULAR_MESH &&
         y.setIndex(
           new (f.indices.length > 65535
             ? THREE.Uint32BufferAttribute
             : THREE.Uint16BufferAttribute)(f.indices, 1)
-        )
+        ))
     var G = new t.AttributeQuantizationTransform()
     if (G.InitFromAttribute(b)) {
-      ;(y.attributes.position.isQuantized = !0),
+      ;((y.attributes.position.isQuantized = !0),
         (y.attributes.position.maxRange = G.range()),
         (y.attributes.position.numQuantizationBits = G.quantization_bits()),
-        (y.attributes.position.minValues = new Float32Array(3))
+        (y.attributes.position.minValues = new Float32Array(3)))
       for (I = 0; I < 3; ++I) y.attributes.position.minValues[I] = G.min_value(I)
     }
-    return t.destroy(G), t.destroy(e), t.destroy(a), y
+    return (t.destroy(G), t.destroy(e), t.destroy(a), y)
   },
   isVersionSupported: function (t, e) {
     e(decoder.isVersionSupported(t))
@@ -220,3 +221,5 @@ THREE.DRACOLoader.prototype = {
     )
   }
 }
+
+export { DRACOLoader }