@aicut/core 0.5.0 → 0.6.0

package/dist/lighting/index.d.cts

@@ -1,5 +1,5 @@
-import { L as Locale } from '../i18n-B-DFWgKe.cjs';
-import { b as Theme } from '../types-CHplD9V5.cjs';
+import { L as Locale } from '../i18n-B24k4XVG.cjs';
+import { b as Theme } from '../types-CmS-UIEr.cjs';
 
 /**
  * Lighting-editor-specific string keys. Kept in a SEPARATE interface

package/dist/lighting/index.d.ts

@@ -1,5 +1,5 @@
-import { L as Locale } from '../i18n-B-DFWgKe.js';
-import { b as Theme } from '../types-CHplD9V5.js';
+import { L as Locale } from '../i18n-B24k4XVG.js';
+import { b as Theme } from '../types-CmS-UIEr.js';
 
 /**
  * Lighting-editor-specific string keys. Kept in a SEPARATE interface

package/dist/lighting/index.js

@@ -1,4 +1,4 @@
-import { mergeLocale, applyTheme } from '../chunk-CCDON7CU.js';
+import { mergeLocale, applyTheme } from '../chunk-H6AY6NW4.js';
 
 // src/lighting/presets.ts
 var PRESET_DIRECTIONS = {

package/dist/playback/webcodecs/index.cjs

@@ -1,5 +1,74 @@
 'use strict';
 
+// src/keyframes/types.ts
+var IDENTITY_TRANSFORM = {
+  panX: 0,
+  panY: 0,
+  scale: 1
+};
+
+// src/keyframes/interpolate.ts
+function applyEasing(t, easing) {
+  switch (easing) {
+    case "linear":
+      return t;
+    case "easeIn":
+      return t * t * t;
+    case "easeOut": {
+      const u = 1 - t;
+      return 1 - u * u * u;
+    }
+    case "easeInOut":
+      return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
+  }
+}
+function defaultFor(prop) {
+  return prop === "scale" ? 1 : 0;
+}
+function staticValue(clip, prop) {
+  const v = clip[prop];
+  return v ?? defaultFor(prop);
+}
+function keyframesForProp(kfs, prop) {
+  const out = [];
+  for (const k of kfs) if (k.prop === prop) out.push(k);
+  out.sort((a, b) => a.time - b.time);
+  return out;
+}
+function interpolateProp(clip, prop, localMs) {
+  if (!clip.keyframes || clip.keyframes.length === 0) {
+    return staticValue(clip, prop);
+  }
+  const arr = keyframesForProp(clip.keyframes, prop);
+  if (arr.length === 0) return staticValue(clip, prop);
+  if (arr.length === 1) return arr[0].value;
+  const first = arr[0];
+  const last = arr[arr.length - 1];
+  if (localMs <= first.time) return first.value;
+  if (localMs >= last.time) return last.value;
+  for (let i = 0; i < arr.length - 1; i += 1) {
+    const a = arr[i];
+    const b = arr[i + 1];
+    if (localMs >= a.time && localMs <= b.time) {
+      if (b.time === a.time) return a.value;
+      const rawT = (localMs - a.time) / (b.time - a.time);
+      const eased = applyEasing(rawT, a.easing ?? "linear");
+      return a.value + (b.value - a.value) * eased;
+    }
+  }
+  return last.value;
+}
+function getEffectiveTransform(clip, localMs) {
+  if ((!clip.keyframes || clip.keyframes.length === 0) && clip.panX === void 0 && clip.panY === void 0 && clip.scale === void 0) {
+    return IDENTITY_TRANSFORM;
+  }
+  return {
+    panX: interpolateProp(clip, "panX", localMs),
+    panY: interpolateProp(clip, "panY", localMs),
+    scale: interpolateProp(clip, "scale", localMs)
+  };
+}
+
 // ../../node_modules/.pnpm/mp4box@2.4.1/node_modules/mp4box/dist/rolldown-runtime-w6R9maHv.mjs
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
@@ -10120,6 +10189,10 @@ var WebCodecsEngine = class {
   lastFrameTs = 0;
   decodedFramesTotal = 0;
   destroyed = false;
+  /** Output frame rect (fixed bounds, no transform) in CSS pixels. */
+  lastOutputRect = null;
+  /** Post-transform content rect in CSS pixels. */
+  lastFrameRect = null;
   onTimeUpdate;
   onEnded;
   onError;
@@ -10238,6 +10311,12 @@ var WebCodecsEngine = class {
     this.sources.clear();
     this.mount.remove();
   }
+  getOutputFrameRect() {
+    return this.lastOutputRect;
+  }
+  getFrameRect() {
+    return this.lastFrameRect;
+  }
   // --- internals -------------------------------------------------------
   syncSources() {
     const wantedVideoIds = new Set(
@@ -10539,12 +10618,40 @@ var WebCodecsEngine = class {
       if (chosenFrame) {
         const vw = chosenFrame.displayWidth || chosenFrame.codedWidth;
         const vh = chosenFrame.displayHeight || chosenFrame.codedHeight;
-        const scale = Math.min(cw / vw, ch / vh);
-        const dw = vw * scale;
-        const dh = vh * scale;
-        const dx = (cw - dw) / 2;
-        const dy = (ch - dh) / 2;
-        this.ctx.drawImage(chosenFrame, dx, dy, dw, dh);
+        const baseScale = Math.min(cw / vw, ch / vh);
+        const dw = vw * baseScale;
+        const dh = vh * baseScale;
+        const dpr = window.devicePixelRatio || 1;
+        const t = getEffectiveTransform(clip, localMs);
+        const outX = (cw - dw) / 2;
+        const outY = (ch - dh) / 2;
+        this.ctx.save();
+        this.ctx.beginPath();
+        this.ctx.rect(outX, outY, dw, dh);
+        this.ctx.clip();
+        this.ctx.translate(cw / 2 + t.panX * dpr, ch / 2 + t.panY * dpr);
+        this.ctx.scale(t.scale, t.scale);
+        this.ctx.drawImage(chosenFrame, -dw / 2, -dh / 2, dw, dh);
+        this.ctx.restore();
+        this.lastOutputRect = {
+          x: outX / dpr,
+          y: outY / dpr,
+          w: dw / dpr,
+          h: dh / dpr
+        };
+        const cssCx = cw / (2 * dpr) + t.panX;
+        const cssCy = ch / (2 * dpr) + t.panY;
+        const cssW = dw * t.scale / dpr;
+        const cssH = dh * t.scale / dpr;
+        this.lastFrameRect = {
+          x: cssCx - cssW / 2,
+          y: cssCy - cssH / 2,
+          w: cssW,
+          h: cssH
+        };
+      } else {
+        this.lastFrameRect = null;
+        this.lastOutputRect = null;
       }
       this.feedDecoder(src);
     }