@editframe/elements 0.14.0-beta.3 → 0.15.0-beta.1

package/dist/elements/EFWaveform.js

@@ -1,9 +1,11 @@
 import { EFAudio } from "./EFAudio.js";
+import { CSSStyleObserver } from "@bramus/style-observer";
 import { Task } from "@lit/task";
 import { html, css, LitElement } from "lit";
 import { property, customElement } from "lit/decorators.js";
 import { createRef, ref } from "lit/directives/ref.js";
 import { EF_INTERACTIVE } from "../EF_INTERACTIVE.js";
+import { EF_RENDERING } from "../EF_RENDERING.js";
 import { TWMixin } from "../gui/TWMixin.js";
 import { CrossUpdateController } from "./CrossUpdateController.js";
 import { EFTemporal } from "./EFTemporal.js";
@@ -23,69 +25,47 @@ let EFWaveform = class extends EFTemporal(TWMixin(LitElement)) {
     super(...arguments);
     this.canvasRef = createRef();
     this.ctx = null;
+    this.styleObserver = null;
     this.mode = "bars";
     this.color = "currentColor";
     this.targetSelector = "";
+    this.lineWidth = 4;
     this.frameTask = new Task(this, {
       autoRun: EF_INTERACTIVE,
-      args: () => [this.targetElement.audioBufferTask.status],
+      args: () => [this.targetElement?.frequencyDataTask.status],
       task: async () => {
-        await this.targetElement.audioBufferTask.taskComplete;
+        if (!this.targetElement) return;
+        await this.targetElement.frequencyDataTask.taskComplete;
         this.ctx ||= this.initCanvas();
         const ctx = this.ctx;
         if (!ctx) return;
-        if (!this.targetElement.audioBufferTask.value) return;
-        if (this.targetElement.trimAdjustedOwnCurrentTimeMs > 0) {
-          const FRAME_DURATION_MS = 48e3 / 1e3;
-          const FRAME_SMEAR_MS = FRAME_DURATION_MS * 1;
-          const FRAME_SMEAR_S = FRAME_SMEAR_MS / 1e3;
-          const audioContext = new OfflineAudioContext(2, 48e3 / 25, 48e3);
-          const audioBufferSource = audioContext.createBufferSource();
-          audioBufferSource.buffer = this.targetElement.audioBufferTask.value.buffer;
-          const analyser = audioContext.createAnalyser();
-          analyser.fftSize = 128 * 8;
-          audioBufferSource.connect(analyser);
-          const startTime = Math.max(
-            0,
-            (this.targetElement.trimAdjustedOwnCurrentTimeMs - this.targetElement.audioBufferTask.value.startOffsetMs) / 1e3
-          );
-          audioBufferSource.start(0, startTime, FRAME_SMEAR_S);
-          await audioContext.startRendering();
-          const frameData = new Uint8Array(analyser.frequencyBinCount);
-          analyser.getByteFrequencyData(frameData);
-          const smoothedData = frameData.slice(0, frameData.length / 2);
-          if (this.color === "currentColor") {
-            const computedStyle = getComputedStyle(this);
-            const currentColor = computedStyle.color;
-            ctx.strokeStyle = currentColor;
-            ctx.fillStyle = currentColor;
-          }
-          switch (this.mode) {
-            case "bars":
-              this.drawBars(ctx, smoothedData);
-              break;
-            case "bricks":
-              this.drawBricks(ctx, smoothedData);
-              break;
-            case "curve":
-              this.drawCurve(ctx, smoothedData);
-              break;
-            case "line":
-              this.drawLine(ctx, smoothedData);
-              break;
-            case "pixel":
-              this.drawPixel(ctx, smoothedData);
-              break;
-            case "wave":
-              this.drawWave(ctx, smoothedData);
-              break;
-            case "roundBars":
-              this.drawRoundBars(ctx, smoothedData);
-              break;
-            case "equalizer":
-              this.drawEqualizer(ctx, smoothedData);
-              break;
-          }
+        const frequencyData = this.targetElement.frequencyDataTask.value;
+        if (!frequencyData) return;
+        if (this.color === "currentColor") {
+          const computedStyle = getComputedStyle(this);
+          const currentColor = computedStyle.color;
+          ctx.strokeStyle = currentColor;
+          ctx.fillStyle = currentColor;
+        }
+        switch (this.mode) {
+          case "bars":
+            this.drawBars(ctx, frequencyData);
+            break;
+          case "bricks":
+            this.drawBricks(ctx, frequencyData);
+            break;
+          case "line":
+            this.drawLine(ctx, frequencyData);
+            break;
+          case "pixel":
+            this.drawPixel(ctx, frequencyData);
+            break;
+          case "wave":
+            this.drawWave(ctx, frequencyData);
+            break;
+          case "roundBars":
+            this.drawRoundBars(ctx, frequencyData);
+            break;
         }
       }
     });
@@ -98,8 +78,11 @@ let EFWaveform = class extends EFTemporal(TWMixin(LitElement)) {
   }
   connectedCallback() {
     super.connectedCallback();
-    if (this.targetElement) {
-      new CrossUpdateController(this.targetElement, this);
+    try {
+      if (this.targetElement) {
+        new CrossUpdateController(this.targetElement, this);
+      }
+    } catch (e) {
     }
     this.resizeObserver = new ResizeObserver(() => {
       this.resizeCanvas();
@@ -113,11 +96,18 @@ let EFWaveform = class extends EFTemporal(TWMixin(LitElement)) {
       }
     });
     this.mutationObserver.observe(this, { attributes: true });
+    if (!EF_RENDERING()) {
+      this.styleObserver = new CSSStyleObserver(["color"], () => {
+        this.frameTask.run();
+      });
+      this.styleObserver.attach(this);
+    }
   }
   disconnectedCallback() {
     super.disconnectedCallback();
     this.resizeObserver?.disconnect();
     this.mutationObserver?.disconnect();
+    this.styleObserver?.detach();
   }
   resizeCanvas() {
     this.ctx = this.initCanvas();
@@ -128,7 +118,10 @@ let EFWaveform = class extends EFTemporal(TWMixin(LitElement)) {
   initCanvas() {
     const canvas = this.canvasRef.value;
     if (!canvas) return null;
-    const rect = this.getBoundingClientRect();
+    const rect = {
+      width: this.offsetWidth,
+      height: this.offsetHeight
+    };
     const dpr = window.devicePixelRatio;
     canvas.style.width = `${rect.width}px`;
     canvas.style.height = `${rect.height}px`;
@@ -142,149 +135,161 @@ let EFWaveform = class extends EFTemporal(TWMixin(LitElement)) {
   }
   drawBars(ctx, frequencyData) {
     const canvas = ctx.canvas;
-    const waveWidth = canvas.width / devicePixelRatio;
-    const waveHeight = canvas.height / devicePixelRatio;
-    const barWidth = waveWidth / frequencyData.length * 0.8;
-    const baseline = waveHeight / 2;
+    const waveWidth = canvas.width;
+    const waveHeight = canvas.height;
+    const baseline = waveHeight / 4;
+    const totalBars = frequencyData.length;
+    const paddingInner = 0.5;
+    const paddingOuter = 0.01;
+    const availableWidth = waveWidth * (1 - 2 * paddingOuter);
+    const barWidth = availableWidth / (totalBars + (totalBars - 1) * paddingInner);
     ctx.clearRect(0, 0, waveWidth, waveHeight);
+    const path = new Path2D();
     frequencyData.forEach((value, i) => {
-      const height = value / 255 * (waveHeight / 2);
-      const x = i * (waveWidth / frequencyData.length);
+      const normalizedValue = value / 255;
+      const height = normalizedValue * (waveHeight / 2);
+      const x = waveWidth * paddingOuter + i * (barWidth * (1 + paddingInner));
       const y = baseline - height;
-      ctx.fillRect(x, y, barWidth, Math.max(height * 2, 2));
+      path.rect(x, y, barWidth, height * 2);
     });
+    ctx.fill(path);
   }
   drawBricks(ctx, frequencyData) {
     const canvas = ctx.canvas;
-    const waveWidth = canvas.width / devicePixelRatio;
-    const waveHeight = canvas.height / devicePixelRatio;
-    const brickWidth = waveWidth / frequencyData.length;
-    const brickHeightFactor = waveHeight / 255 / 2;
-    const brickPadding = 2;
-    const midHeight = waveHeight / 2;
-    ctx.clearRect(0, 0, waveWidth, waveHeight);
-    ctx.beginPath();
-    ctx.setLineDash([2]);
-    ctx.lineWidth = 4;
-    ctx.moveTo(0, midHeight);
-    ctx.lineTo(waveWidth, midHeight);
-    ctx.stroke();
-    ctx.setLineDash([]);
-    frequencyData.forEach((value, i) => {
-      const x = i * brickWidth;
-      const height = value * brickHeightFactor * 2;
-      const y = midHeight - height / 2;
-      ctx.fillRect(x, y, brickWidth - brickPadding, height);
-    });
-  }
-  drawLine(ctx, frequencyData) {
-    const canvas = ctx.canvas;
-    const waveWidth = canvas.width / devicePixelRatio;
-    const waveHeight = canvas.height / devicePixelRatio;
+    const waveWidth = canvas.width;
+    const waveHeight = canvas.height;
     ctx.clearRect(0, 0, waveWidth, waveHeight);
-    ctx.beginPath();
+    const path = new Path2D();
+    const columnWidth = waveWidth / frequencyData.length;
+    const boxSize = columnWidth * 0.9;
     frequencyData.forEach((value, i) => {
-      const x = i / frequencyData.length * waveWidth;
-      const y = (1 - value / 255) * waveHeight;
-      if (i === 0) {
-        ctx.moveTo(x, y);
-      } else {
-        ctx.lineTo(x, y);
+      const brickHeight = value / 255 * waveHeight;
+      for (let j = 0; j <= brickHeight; j++) {
+        const x = columnWidth * i;
+        const y = waveHeight - (j * columnWidth + boxSize);
+        path.rect(x, y, boxSize, boxSize);
       }
     });
-    ctx.lineWidth = 4;
-    ctx.stroke();
+    ctx.fill(path);
   }
   drawRoundBars(ctx, frequencyData) {
     const canvas = ctx.canvas;
-    const waveWidth = canvas.width / devicePixelRatio;
-    const waveHeight = canvas.height / devicePixelRatio;
-    const barWidth = waveWidth / frequencyData.length * 0.5;
-    const baseline = waveHeight / 2;
-    const maxHeight = waveHeight / 2;
+    const waveWidth = canvas.width;
+    const waveHeight = canvas.height;
+    const baseline = waveHeight / 4;
+    const totalBars = frequencyData.length;
+    const paddingInner = 0.5;
+    const paddingOuter = 0.01;
+    const availableWidth = waveWidth * (1 - 2 * paddingOuter);
+    const barWidth = availableWidth / (totalBars + (totalBars - 1) * paddingInner);
     ctx.clearRect(0, 0, waveWidth, waveHeight);
+    const path = new Path2D();
     frequencyData.forEach((value, i) => {
-      const height = value / 255 * maxHeight;
-      const x = i * (waveWidth / frequencyData.length);
+      const normalizedValue = value / 255;
+      const height = normalizedValue * (waveHeight / 2);
+      const x = waveWidth * paddingOuter + i * (barWidth * (1 + paddingInner));
       const y = baseline - height;
-      const radius = barWidth / 2;
-      ctx.beginPath();
-      ctx.roundRect(x, y, barWidth, Math.max(height * 2, 2), radius);
-      ctx.fill();
+      path.roundRect(x, y, barWidth, height * 2, barWidth / 2);
     });
+    ctx.fill(path);
   }
   drawEqualizer(ctx, frequencyData) {
     const canvas = ctx.canvas;
-    const waveWidth = canvas.width / devicePixelRatio;
-    const waveHeight = canvas.height / devicePixelRatio;
+    const waveWidth = canvas.width;
+    const waveHeight = canvas.height / 2;
     const barWidth = waveWidth / frequencyData.length * 0.8;
     const baseline = waveHeight / 2;
     ctx.clearRect(0, 0, waveWidth, waveHeight);
-    ctx.beginPath();
-    ctx.lineWidth = 2;
-    ctx.moveTo(0, baseline);
-    ctx.lineTo(waveWidth, baseline);
-    ctx.stroke();
+    const baselinePath = new Path2D();
+    const barsPath = new Path2D();
+    baselinePath.moveTo(0, baseline);
+    baselinePath.lineTo(waveWidth, baseline);
     frequencyData.forEach((value, i) => {
       const height = value / 255 * (waveHeight / 2);
       const x = i * (waveWidth / frequencyData.length);
       const y = baseline - height;
-      ctx.fillRect(x, y, barWidth, Math.max(height * 2, 1));
+      barsPath.rect(x, y, barWidth, Math.max(height * 2, 1));
     });
+    ctx.lineWidth = 2;
+    ctx.stroke(baselinePath);
+    ctx.fill(barsPath);
   }
-  drawCurve(ctx, frequencyData) {
+  drawLine(ctx, frequencyData) {
     const canvas = ctx.canvas;
-    const waveWidth = canvas.width / devicePixelRatio;
-    const waveHeight = canvas.height / devicePixelRatio;
+    const waveWidth = canvas.width;
+    const waveHeight = canvas.height / 2;
     ctx.clearRect(0, 0, waveWidth, waveHeight);
-    ctx.beginPath();
+    const path = new Path2D();
     frequencyData.forEach((value, i) => {
       const x = i / frequencyData.length * waveWidth;
       const y = (1 - value / 255) * waveHeight;
       if (i === 0) {
-        ctx.moveTo(x, y);
+        path.moveTo(x, y);
       } else {
-        ctx.lineTo(x, y);
+        path.lineTo(x, y);
       }
     });
-    ctx.lineWidth = 4;
-    ctx.stroke();
+    ctx.lineWidth = this.lineWidth;
+    ctx.stroke(path);
   }
   drawPixel(ctx, frequencyData) {
     const canvas = ctx.canvas;
-    const waveWidth = canvas.width / devicePixelRatio;
-    const waveHeight = canvas.height / devicePixelRatio;
+    const waveWidth = canvas.width;
+    const waveHeight = canvas.height / 2;
     const baseline = waveHeight / 2;
-    const barWidth = waveWidth / frequencyData.length * 0.97;
+    const barWidth = waveWidth / frequencyData.length;
     ctx.clearRect(0, 0, waveWidth, waveHeight);
+    const path = new Path2D();
     frequencyData.forEach((value, i) => {
       const x = i * (waveWidth / frequencyData.length);
       const barHeight = value / 255 * baseline;
       const y = baseline - barHeight;
-      ctx.fillRect(x, y, barWidth, barHeight * 2);
+      path.rect(x, y, barWidth, barHeight * 2);
     });
+    ctx.fill(path);
   }
   drawWave(ctx, frequencyData) {
     const canvas = ctx.canvas;
-    const waveWidth = canvas.width / devicePixelRatio;
-    const waveHeight = canvas.height / devicePixelRatio;
-    const baseline = waveHeight / 2;
-    const barWidth = waveWidth / frequencyData.length * 0.97;
+    const waveWidth = canvas.width;
+    const waveHeight = canvas.height;
+    const baseline = canvas.height / 4;
     ctx.clearRect(0, 0, waveWidth, waveHeight);
-    ctx.beginPath();
-    ctx.moveTo(0, baseline);
-    ctx.lineTo(waveWidth, baseline);
-    ctx.strokeStyle = this.color;
-    ctx.lineWidth = 1;
-    ctx.stroke();
+    const path = new Path2D();
+    path.moveTo(0, baseline);
     frequencyData.forEach((value, i) => {
-      const x = i * (waveWidth / frequencyData.length);
-      const barHeight = value / 255 * (waveHeight / 2);
-      const y = baseline - barHeight;
-      ctx.fillRect(x, y, barWidth, barHeight * 2);
+      const normalizedValue = value / 255;
+      const x = i / (frequencyData.length - 1) * waveWidth;
+      const y = baseline - normalizedValue * (waveHeight / 2);
+      if (i === 0) {
+        path.moveTo(x, y);
+      } else {
+        const prevX = (i - 1) / (frequencyData.length - 1) * waveWidth;
+        const prevValue = (frequencyData[i - 1] ?? 0) / 255;
+        const prevY = baseline - prevValue * (waveHeight / 2);
+        const xc = (prevX + x) / 2;
+        const yc = (prevY + y) / 2;
+        path.quadraticCurveTo(prevX, prevY, xc, yc);
+      }
     });
+    for (let i = frequencyData.length - 1; i >= 0; i--) {
+      const normalizedValue = (frequencyData[i] ?? 0) / 255;
+      const x = i / (frequencyData.length - 1) * waveWidth;
+      const y = baseline + normalizedValue * (waveHeight / 2);
+      if (i === frequencyData.length - 1) {
+        path.lineTo(x, y);
+      } else {
+        const nextX = (i + 1) / (frequencyData.length - 1) * waveWidth;
+        const nextValue = (frequencyData[i + 1] ?? 0) / 255;
+        const nextY = baseline + nextValue * (waveHeight / 2);
+        const xc = (nextX + x) / 2;
+        const yc = (nextY + y) / 2;
+        path.quadraticCurveTo(nextX, nextY, xc, yc);
+      }
+    }
+    ctx.fill(path);
   }
   get durationMs() {
+    if (!this.targetElement) return 0;
     return this.targetElement.durationMs;
   }
   get targetElement() {
@@ -292,7 +297,7 @@ let EFWaveform = class extends EFTemporal(TWMixin(LitElement)) {
     if (target instanceof EFAudio || target instanceof EFVideo) {
       return target;
     }
-    throw new Error("Invalid target, must be an EFAudio or EFVideo element");
+    return null;
   }
   updated(changedProperties) {
     super.updated(changedProperties);
@@ -328,6 +333,9 @@ __decorateClass([
 __decorateClass([
   property({ type: String, attribute: "target", reflect: true })
 ], EFWaveform.prototype, "targetSelector", 2);
+__decorateClass([
+  property({ type: Number, attribute: "line-width" })
+], EFWaveform.prototype, "lineWidth", 2);
 EFWaveform = __decorateClass([
   customElement("ef-waveform")
 ], EFWaveform);

package/dist/gui/EFWorkbench.js

@@ -62,7 +62,7 @@ let EFWorkbench = class extends ContextMixin(TWMixin(LitElement)) {
           focusOverlay.style.display = "block";
           const rect = this.focusedElement.getBoundingClientRect();
           Object.assign(focusOverlay.style, {
-            position: "absolute",
+            position: "fixed",
             top: `${rect.top}px`,
             left: `${rect.left}px`,
             width: `${rect.width}px`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@editframe/elements",
-  "version": "0.14.0-beta.3",
+  "version": "0.15.0-beta.1",
   "description": "",
   "exports": {
     ".": {
@@ -21,7 +21,8 @@
   "author": "",
   "license": "UNLICENSED",
   "dependencies": {
-    "@editframe/assets": "0.14.0-beta.3",
+    "@bramus/style-observer": "^1.3.0",
+    "@editframe/assets": "0.15.0-beta.1",
     "@lit/context": "^1.1.2",
     "@lit/task": "^1.0.1",
     "d3": "^7.9.0",

package/src/elements/EFImage.browsertest.ts

@@ -18,9 +18,9 @@ describe("EFImage", () => {
       const workbench = document.createElement("ef-workbench");
       const element = document.createElement("ef-image");
       workbench.appendChild(element);
-      element.assetId = "550e8400-e29b-41d4-a716-446655440000:example.jpg";
+      element.assetId = "550e8400-e29b-41d4-a716-446655440000";
       expect(element.assetPath()).toBe(
-        "editframe://api/v1/image_files/550e8400-e29b-41d4-a716-446655440000:example.jpg",
+        "editframe://api/v1/image_files/550e8400-e29b-41d4-a716-446655440000",
       );
     });
   });
@@ -46,4 +46,35 @@ describe("EFImage", () => {
       expect(image.assetPath()).toBe(`test:///api/v1/image_files/${id}`);
     });
   });
+
+  describe("hasOwnDuration", () => {
+    test("is false by default", () => {
+      const image = document.createElement("ef-image");
+      expect(image.hasOwnDuration).toBe(false);
+    });
+
+    test("is true when duration is set", () => {
+      const image = document.createElement("ef-image");
+      image.setAttribute("duration", "1s");
+      expect(image.hasOwnDuration).toBe(true);
+    });
+  });
+
+  describe("durationMs", () => {
+    test("Can be set on element directly", () => {
+      const image = document.createElement("ef-image");
+      image.src =
+        "https://editframe.dev/api/v1/image_files/550e8400-e29b-41d4-a716-446655440000";
+      image.duration = "1s";
+      expect(image.durationMs).toBe(1000);
+    });
+
+    test("Can be set through setAttribute", () => {
+      const image = document.createElement("ef-image");
+      image.src =
+        "https://editframe.dev/api/v1/image_files/550e8400-e29b-41d4-a716-446655440000";
+      image.setAttribute("duration", "1s");
+      expect(image.durationMs).toBe(1000);
+    });
+  });
 });

package/src/elements/EFImage.ts

@@ -5,12 +5,15 @@ import { createRef, ref } from "lit/directives/ref.js";
 import { EF_INTERACTIVE } from "../EF_INTERACTIVE.js";
 import { EF_RENDERING } from "../EF_RENDERING.js";
 import { EFSourceMixin } from "./EFSourceMixin.js";
+import { EFTemporal } from "./EFTemporal.js";
 import { FetchMixin } from "./FetchMixin.js";
 
 @customElement("ef-image")
-export class EFImage extends EFSourceMixin(FetchMixin(LitElement), {
-  assetType: "image_files",
-}) {
+export class EFImage extends EFTemporal(
+  EFSourceMixin(FetchMixin(LitElement), {
+    assetType: "image_files",
+  }),
+) {
   static styles = [
     css`
       :host {
@@ -52,6 +55,10 @@ export class EFImage extends EFSourceMixin(FetchMixin(LitElement), {
     return `/@ef-image/${this.src}`;
   }
 
+  get hasOwnDuration() {
+    return this.hasExplicitDuration;
+  }
+
   fetchImage = new Task(this, {
     autoRun: EF_INTERACTIVE,
     args: () => [this.assetPath(), this.fetch] as const,