chart-preview 1.1.0 → 1.3.0

package/dist/index.mjs

@@ -38,13 +38,17 @@ var NOTE_SPAN_WIDTH = 0.95;
 function isImageDecoderSupported() {
   return typeof ImageDecoder !== "undefined";
 }
+function areAnimationsSupported() {
+  return isImageDecoderSupported();
+}
 var AnimatedTexture = class {
   constructor(width, height) {
-    this.decoder = null;
     this.frameIndex = 0;
     this.frameCount = 0;
     this.lastFrameTime = 0;
     this.frameDurations = [];
+    /** Pre-decoded frames stored as ImageBitmap for fast synchronous access */
+    this.frameCache = [];
     this.isAnimated = false;
     this.disposed = false;
     this.canvas = document.createElement("canvas");
@@ -57,11 +61,11 @@ var AnimatedTexture = class {
   /**
    * Creates an AnimatedTexture from a URL.
    * Uses ImageDecoder for animation if available, otherwise loads as static texture.
+   * Pre-decodes all frames during initialization for optimal render performance.
    */
   static async create(url) {
     if (!isImageDecoderSupported()) {
-      const textureLoader = new THREE.TextureLoader();
-      return textureLoader.loadAsync(url);
+      return loadStaticTexture(url);
     }
     try {
       const response = await fetch(url);
@@ -71,8 +75,7 @@ var AnimatedTexture = class {
       const contentType = response.headers.get("content-type") || "image/webp";
       const isSupported = await ImageDecoder.isTypeSupported(contentType);
       if (!isSupported) {
-        const textureLoader = new THREE.TextureLoader();
-        return textureLoader.loadAsync(url);
+        return loadStaticTexture(url);
       }
       const decoder = new ImageDecoder({
         data: response.body,
@@ -103,40 +106,51 @@ var AnimatedTexture = class {
         firstFrame.displayWidth,
         firstFrame.displayHeight
       );
-      animTexture.ctx.drawImage(firstFrame, 0, 0);
-      animTexture.texture.needsUpdate = true;
-      animTexture.decoder = decoder;
-      animTexture.frameCount = frameCount;
-      animTexture.isAnimated = true;
       animTexture.frameDurations = [];
+      animTexture.frameCache = [];
       for (let i = 0; i < frameCount; i++) {
         try {
           const frameResult = await decoder.decode({ frameIndex: i });
-          const durationMs = (frameResult.image.duration ?? 1e5) / 1e3;
+          const videoFrame = frameResult.image;
+          const bitmap = await createImageBitmap(videoFrame);
+          animTexture.frameCache.push(bitmap);
+          const durationMs = (videoFrame.duration ?? 1e5) / 1e3;
           animTexture.frameDurations.push(durationMs);
-          frameResult.image.close();
+          videoFrame.close();
         } catch {
           animTexture.frameDurations.push(100);
+          if (animTexture.frameCache.length > 0) {
+            animTexture.frameCache.push(
+              animTexture.frameCache[animTexture.frameCache.length - 1]
+            );
+          }
         }
       }
-      firstFrame.close();
+      if (animTexture.frameCache.length > 0) {
+        animTexture.ctx.drawImage(animTexture.frameCache[0], 0, 0);
+        animTexture.texture.needsUpdate = true;
+      }
+      animTexture.frameCount = animTexture.frameCache.length;
+      animTexture.isAnimated = animTexture.frameCount > 1;
       animTexture.lastFrameTime = performance.now();
+      firstFrame.close();
+      decoder.close();
       return animTexture;
     } catch (error) {
       console.warn(
         "Failed to load animated texture, falling back to static:",
         error
       );
-      const textureLoader = new THREE.TextureLoader();
-      return textureLoader.loadAsync(url);
+      return loadStaticTexture(url);
     }
   }
   /**
    * Updates the texture to the current animation frame based on elapsed time.
-   * Call this each frame in the render loop.
+   * This method is SYNCHRONOUS for optimal render performance - all frames
+   * are pre-decoded during initialization.
    */
-  async tick() {
-    if (!this.isAnimated || !this.decoder || this.disposed) {
+  tick() {
+    if (!this.isAnimated || this.disposed || this.frameCache.length === 0) {
       return;
     }
     const now = performance.now();
@@ -145,15 +159,11 @@ var AnimatedTexture = class {
     if (elapsed >= currentFrameDuration) {
       this.frameIndex = (this.frameIndex + 1) % this.frameCount;
       this.lastFrameTime = now;
-      try {
-        const result = await this.decoder.decode({
-          frameIndex: this.frameIndex
-        });
+      const frame = this.frameCache[this.frameIndex];
+      if (frame) {
         this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
-        this.ctx.drawImage(result.image, 0, 0);
+        this.ctx.drawImage(frame, 0, 0);
         this.texture.needsUpdate = true;
-        result.image.close();
-      } catch {
       }
     }
   }
@@ -162,13 +172,35 @@ var AnimatedTexture = class {
    */
   dispose() {
     this.disposed = true;
-    if (this.decoder) {
-      this.decoder.close();
-      this.decoder = null;
+    for (const bitmap of this.frameCache) {
+      bitmap.close();
     }
+    this.frameCache = [];
     this.texture.dispose();
   }
 };
+async function loadStaticTexture(url) {
+  const textureLoader = new THREE.TextureLoader();
+  try {
+    const texture = await textureLoader.loadAsync(url);
+    texture.colorSpace = THREE.SRGBColorSpace;
+    return texture;
+  } catch (error) {
+    console.warn(`Failed to load static texture from ${url}:`, error);
+    return createPlaceholderTexture();
+  }
+}
+function createPlaceholderTexture() {
+  const canvas = document.createElement("canvas");
+  canvas.width = 32;
+  canvas.height = 32;
+  const ctx = canvas.getContext("2d");
+  ctx.fillStyle = "#FF00FF";
+  ctx.fillRect(0, 0, 32, 32);
+  const texture = new THREE.CanvasTexture(canvas);
+  texture.colorSpace = THREE.SRGBColorSpace;
+  return texture;
+}
 var AnimatedTextureManager = class {
   constructor() {
     this.animatedTextures = [];
@@ -178,8 +210,13 @@ var AnimatedTextureManager = class {
       this.animatedTextures.push(texture);
     }
   }
-  async tick() {
-    await Promise.all(this.animatedTextures.map((t) => t.tick()));
+  /**
+   * Updates all animated textures. This is now SYNCHRONOUS for optimal performance.
+   */
+  tick() {
+    for (const texture of this.animatedTextures) {
+      texture.tick();
+    }
   }
   dispose() {
     for (const texture of this.animatedTextures) {
@@ -332,6 +369,17 @@ var _ChartPreview = class {
   get chartEndTimeMs() {
     return this.audioManager.chartEndTimeMs;
   }
+  /**
+   * Manually triggers a resize of the camera and renderer.
+   * Call this when the container size changes (e.g., entering/exiting fullscreen).
+   */
+  resize() {
+    this.camera.triggerResize();
+    this.renderer.triggerResize();
+    if (this.paused) {
+      this.animateFrame(false);
+    }
+  }
   /**
    * Cleans up all resources. Call this when discarding the preview.
    * The preview should not be used after calling dispose().
@@ -419,6 +467,10 @@ var ChartCamera = class extends THREE.PerspectiveCamera {
     this.aspect = width / height;
     this.updateProjectionMatrix();
   }
+  /** Manually trigger a resize update */
+  triggerResize() {
+    this.onResize();
+  }
   dispose() {
     window.removeEventListener("resize", this.resizeListener);
     this.clear();
@@ -441,6 +493,10 @@ var ChartRenderer = class extends THREE.WebGLRenderer {
     const height = this.divContainer.offsetHeight ?? window.innerHeight;
     this.setSize(width, height);
   }
+  /** Manually trigger a resize update */
+  triggerResize() {
+    this.onResize();
+  }
   dispose() {
     window.removeEventListener("resize", this.resizeListener);
     super.dispose();
@@ -782,11 +838,16 @@ var NotesManager = class {
     }
     for (let i = maxNoteEventIndex + 1; this.noteEvents[i] && this.noteEvents[i].msTime < renderEndTimeMs; i++) {
       const note = this.noteEvents[i];
+      const material = this.noteMaterials.get(note.type)?.get(note.flags);
+      if (!material) {
+        console.warn(
+          `Missing texture for note type ${note.type} with flags ${note.flags}`
+        );
+        continue;
+      }
       const noteGroup = new THREE.Group();
       const scale = note.type === noteTypes.kick ? 0.045 : note.type === noteTypes.open && this.instrumentType === instrumentTypes.sixFret ? 0.04 : SCALE;
-      const sprite = new THREE.Sprite(
-        this.noteMaterials.get(note.type).get(note.flags)
-      );
+      const sprite = new THREE.Sprite(material);
       noteGroup.add(sprite);
       sprite.center = new THREE.Vector2(
         note.type === noteTypes.kick ? 0.62 : 0.5,
@@ -863,12 +924,16 @@ var EventSequence = class {
     return earliestActiveEventIndex === null ? this.lastPrecedingEventIndex + 1 : earliestActiveEventIndex;
   }
 };
-async function loadTextures(instrumentType) {
+async function loadTextures(instrumentType, options = {}) {
+  const { animationsEnabled = true } = options;
   const textureLoader = new THREE.TextureLoader();
   const animatedTextureManager = new AnimatedTextureManager();
   const load = (path) => textureLoader.loadAsync("https://static.enchor.us/" + path);
   const loadAnimated = async (path) => {
     const url = `https://static.enchor.us/preview-${path}.webp`;
+    if (!animationsEnabled) {
+      return loadStaticTexture(url);
+    }
     const result = await AnimatedTexture.create(url);
     if (result instanceof AnimatedTexture) {
       animatedTextureManager.register(result);
@@ -1314,7 +1379,7 @@ function isVideoFile(fileName) {
   const ext = fileName.toLowerCase().slice(fileName.lastIndexOf("."));
   return videoExtensions.includes(ext);
 }
-async function prepareChartData(files, instrument, difficulty, initialSeekPercent = 0) {
+async function prepareChartData(files, instrument, difficulty, initialSeekPercent = 0, textureOptions = {}) {
   const filteredFiles = files.filter((f) => !isVideoFile(f.fileName));
   const scannedChart = scanChartFolder(filteredFiles);
   if (!scannedChart.playable || !scannedChart.notesData) {
@@ -1349,7 +1414,10 @@ async function prepareChartData(files, instrument, difficulty, initialSeekPercen
   }
   const audioFiles = findAudioFiles(filteredFiles);
   const instrumentType = getInstrumentType2(instrument);
-  const textures = await ChartPreview.loadTextures(instrumentType);
+  const textures = await ChartPreview.loadTextures(
+    instrumentType,
+    textureOptions
+  );
   const lastNote = parsedChart.trackData.flatMap((t) => t.noteEventGroups.flat()).reduce((max, note) => Math.max(max, note.msTime + note.msLength), 0);
   const audioLengthMs = scannedChart.song_length || lastNote + 5e3;
   const startDelayMs = (scannedChart.delay || 0) + (scannedChart.chart_offset || 0) * 1e3;
@@ -1670,10 +1738,18 @@ var ChartPreviewPlayer = class extends HTMLElement {
       }
     };
     this.handleFullscreenChange = () => {
-      this._isFullscreen = document.fullscreenElement === this.container;
+      const fullscreenElement = document.fullscreenElement || document.webkitFullscreenElement;
+      this._isFullscreen = fullscreenElement !== null && fullscreenElement !== void 0;
       this.container.classList.toggle("fullscreen", this._isFullscreen);
       this.fullscreenBtn.innerHTML = this._isFullscreen ? ICONS.fullscreenExit : ICONS.fullscreen;
-      this.fullscreenBtn.title = this._isFullscreen ? "Exit fullscreen" : "Toggle fullscreen";
+      this.fullscreenBtn.title = this._isFullscreen ? "Exit fullscreen" : "Enter fullscreen";
+      if (this.chartPreview) {
+        requestAnimationFrame(() => {
+          requestAnimationFrame(() => {
+            this.chartPreview?.resize();
+          });
+        });
+      }
     };
     this.shadow = this.attachShadow({ mode: "open" });
     this.render();
@@ -1698,6 +1774,10 @@ var ChartPreviewPlayer = class extends HTMLElement {
   connectedCallback() {
     this.setAttribute("tabindex", "0");
     document.addEventListener("fullscreenchange", this.handleFullscreenChange);
+    document.addEventListener(
+      "webkitfullscreenchange",
+      this.handleFullscreenChange
+    );
   }
   disconnectedCallback() {
     this.dispose();
@@ -1705,6 +1785,10 @@ var ChartPreviewPlayer = class extends HTMLElement {
       "fullscreenchange",
       this.handleFullscreenChange
     );
+    document.removeEventListener(
+      "webkitfullscreenchange",
+      this.handleFullscreenChange
+    );
     this.removeEventListener("keydown", this.handleKeydown);
   }
   render() {
@@ -1785,7 +1869,8 @@ var ChartPreviewPlayer = class extends HTMLElement {
         this.onSeekEnd();
       }
     });
-    this.fullscreenBtn.addEventListener("click", () => {
+    this.fullscreenBtn.addEventListener("click", (e) => {
+      e.stopPropagation();
       this.toggleFullscreen();
     });
     this.addEventListener("keydown", this.handleKeydown);
@@ -2098,7 +2183,8 @@ var ChartPreviewPlayer = class extends HTMLElement {
         files,
         config.instrument,
         config.difficulty,
-        config.initialSeekPercent
+        config.initialSeekPercent,
+        { animationsEnabled: config.animationsEnabled }
       );
       await this.loadChart({
         parsedChart: preparedData.parsedChart,
@@ -2140,7 +2226,8 @@ var ChartPreviewPlayer = class extends HTMLElement {
         files,
         config.instrument,
         config.difficulty,
-        config.initialSeekPercent
+        config.initialSeekPercent,
+        { animationsEnabled: config.animationsEnabled }
       );
       await this.loadChart({
         parsedChart: preparedData.parsedChart,
@@ -2179,7 +2266,8 @@ var ChartPreviewPlayer = class extends HTMLElement {
         config.files,
         config.instrument,
         config.difficulty,
-        config.initialSeekPercent
+        config.initialSeekPercent,
+        { animationsEnabled: config.animationsEnabled }
       );
       await this.loadChart({
         parsedChart: preparedData.parsedChart,
@@ -2279,12 +2367,28 @@ var ChartPreviewPlayer = class extends HTMLElement {
    * Toggle fullscreen mode
    */
   async toggleFullscreen() {
-    if (!document.fullscreenEnabled)
+    const doc = document;
+    const container = this.container;
+    const isFullscreenEnabled = doc.fullscreenEnabled || doc.webkitFullscreenEnabled;
+    if (!isFullscreenEnabled)
       return;
-    if (this._isFullscreen) {
-      await document.exitFullscreen();
-    } else {
-      await this.container.requestFullscreen();
+    const fullscreenElement = doc.fullscreenElement || doc.webkitFullscreenElement;
+    try {
+      if (fullscreenElement) {
+        if (doc.exitFullscreen) {
+          await doc.exitFullscreen();
+        } else if (doc.webkitExitFullscreen) {
+          doc.webkitExitFullscreen();
+        }
+      } else {
+        if (container.requestFullscreen) {
+          await container.requestFullscreen();
+        } else if (container.webkitRequestFullscreen) {
+          container.webkitRequestFullscreen();
+        }
+      }
+    } catch (error) {
+      console.warn("Fullscreen toggle failed:", error);
     }
   }
   /**
@@ -2319,6 +2423,7 @@ import {
 export {
   ChartPreview,
   ChartPreviewPlayer,
+  areAnimationsSupported,
   extractSngFile,
   fetchSngFile,
   findAudioFiles,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "chart-preview",
-	"version": "1.1.0",
+	"version": "1.3.0",
 	"author": "Geo",
 	"license": "MIT",
 	"main": "dist/index.js",