@waveform-playlist/core 12.6.0 → 12.6.1

package/dist/index.mjs

@@ -456,6 +456,37 @@ function computeMusicalTicks(params) {
   };
   return result;
 }
+function ticksToBarBeat(tick, meterEntries, ppqn) {
+  if (ppqn <= 0) return { bar: 1, beat: 1 };
+  const entries = meterEntries.length > 0 ? meterEntries : [{ tick: 0, numerator: 4, denominator: 4 }];
+  let barOffset = 0;
+  for (let i = 0; i < entries.length; i++) {
+    const meter = entries[i];
+    const segmentStart = meter.tick;
+    const segmentEnd = i + 1 < entries.length ? entries[i + 1].tick : Number.MAX_SAFE_INTEGER;
+    const ts2 = [meter.numerator, meter.denominator];
+    const tpBar2 = ticksPerBar(ts2, ppqn);
+    const tpBeat2 = ticksPerBeat(ts2, ppqn);
+    if (tick >= segmentStart && tick < segmentEnd) {
+      const offset2 = tick - segmentStart;
+      const barIndexInSegment2 = Math.floor(offset2 / tpBar2);
+      const beatInBar2 = Math.floor(offset2 % tpBar2 / tpBeat2);
+      return { bar: barOffset + barIndexInSegment2 + 1, beat: beatInBar2 + 1 };
+    }
+    if (segmentEnd !== Number.MAX_SAFE_INTEGER) {
+      const segmentLen = segmentEnd - segmentStart;
+      barOffset += Math.floor(segmentLen / tpBar2);
+    }
+  }
+  const first = entries[0];
+  const ts = [first.numerator, first.denominator];
+  const tpBar = ticksPerBar(ts, ppqn);
+  const tpBeat = ticksPerBeat(ts, ppqn);
+  const offset = tick - first.tick;
+  const barIndexInSegment = Math.floor(offset / tpBar);
+  const beatInBar = Math.floor(offset % tpBar / tpBeat);
+  return { bar: barIndexInSegment + 1, beat: beatInBar + 1 };
+}
 function snapTickToGrid(tick, snapTo, meterEntries, ppqn = 960) {
   if (snapTo === "off") return tick;
   let meter = meterEntries[0] ?? { tick: 0, numerator: 4, denominator: 4 };
@@ -800,6 +831,14 @@ function applyFadeOut(param, startTime, duration, type = "linear", startValue =
 }
 
 // src/keyboard.ts
+function matchesKeyBinding(event, binding) {
+  const keyMatch = event.key.toLowerCase() === binding.key.toLowerCase() || event.key === binding.key;
+  const ctrlMatch = binding.ctrlKey === void 0 || event.ctrlKey === binding.ctrlKey;
+  const shiftMatch = binding.shiftKey === void 0 || event.shiftKey === binding.shiftKey;
+  const metaMatch = binding.metaKey === void 0 || event.metaKey === binding.metaKey;
+  const altMatch = binding.altKey === void 0 || event.altKey === binding.altKey;
+  return keyMatch && ctrlMatch && shiftMatch && metaMatch && altMatch;
+}
 function handleKeyboardEvent(event, shortcuts, enabled) {
   if (!enabled) return;
   if (event.repeat) return;
@@ -807,14 +846,7 @@ function handleKeyboardEvent(event, shortcuts, enabled) {
   if (target.tagName === "INPUT" || target.tagName === "TEXTAREA" || target.isContentEditable) {
     return;
   }
-  const matchingShortcut = shortcuts.find((shortcut) => {
-    const keyMatch = event.key.toLowerCase() === shortcut.key.toLowerCase() || event.key === shortcut.key;
-    const ctrlMatch = shortcut.ctrlKey === void 0 || event.ctrlKey === shortcut.ctrlKey;
-    const shiftMatch = shortcut.shiftKey === void 0 || event.shiftKey === shortcut.shiftKey;
-    const metaMatch = shortcut.metaKey === void 0 || event.metaKey === shortcut.metaKey;
-    const altMatch = shortcut.altKey === void 0 || event.altKey === shortcut.altKey;
-    return keyMatch && ctrlMatch && shiftMatch && metaMatch && altMatch;
-  });
+  const matchingShortcut = shortcuts.find((shortcut) => matchesKeyBinding(event, shortcut));
   if (matchingShortcut) {
     if (matchingShortcut.preventDefault !== false) {
       event.preventDefault();
@@ -915,13 +947,137 @@ function watchMicrophoneDevices(listener, mediaDevices) {
     md.removeEventListener("devicechange", deliver);
   };
 }
+
+// src/annotations/boundaries.ts
+var LINK_THRESHOLD = 0.01;
+var MIN_ANNOTATION_DURATION = 0.1;
+var ANNOTATION_LINK_THRESHOLD_TICKS = 0.5;
+function annotationMinDurationTicks(ppqn) {
+  return Math.max(1, Math.round(ppqn / 32));
+}
+function updateAnnotationBoundaries(params, options = {}) {
+  const { annotationIndex, newTime, isDraggingStart, annotations, duration, linkEndpoints } = params;
+  const linkThreshold = options.linkThreshold ?? LINK_THRESHOLD;
+  const minDuration = options.minDuration ?? MIN_ANNOTATION_DURATION;
+  const updatedAnnotations = [...annotations];
+  const annotation = annotations[annotationIndex];
+  if (isDraggingStart) {
+    const constrainedStart = Math.min(annotation.end - minDuration, Math.max(0, newTime));
+    const delta = constrainedStart - annotation.start;
+    updatedAnnotations[annotationIndex] = { ...annotation, start: constrainedStart };
+    if (linkEndpoints && annotationIndex > 0) {
+      const prevAnnotation = updatedAnnotations[annotationIndex - 1];
+      if (Math.abs(prevAnnotation.end - annotation.start) < linkThreshold) {
+        updatedAnnotations[annotationIndex - 1] = {
+          ...prevAnnotation,
+          end: Math.max(prevAnnotation.start + minDuration, prevAnnotation.end + delta)
+        };
+      } else if (constrainedStart <= prevAnnotation.end) {
+        updatedAnnotations[annotationIndex] = {
+          ...updatedAnnotations[annotationIndex],
+          start: prevAnnotation.end
+        };
+      }
+    } else if (!linkEndpoints && annotationIndex > 0 && constrainedStart < updatedAnnotations[annotationIndex - 1].end) {
+      updatedAnnotations[annotationIndex - 1] = {
+        ...updatedAnnotations[annotationIndex - 1],
+        end: constrainedStart
+      };
+    }
+  } else {
+    const constrainedEnd = Math.max(annotation.start + minDuration, Math.min(newTime, duration));
+    const delta = constrainedEnd - annotation.end;
+    updatedAnnotations[annotationIndex] = { ...annotation, end: constrainedEnd };
+    if (linkEndpoints && annotationIndex < updatedAnnotations.length - 1) {
+      const nextAnnotation = updatedAnnotations[annotationIndex + 1];
+      if (Math.abs(nextAnnotation.start - annotation.end) < linkThreshold) {
+        const newStart = nextAnnotation.start + delta;
+        updatedAnnotations[annotationIndex + 1] = {
+          ...nextAnnotation,
+          start: Math.min(nextAnnotation.end - minDuration, newStart)
+        };
+        let currentIndex = annotationIndex + 1;
+        while (currentIndex < updatedAnnotations.length - 1) {
+          const current = updatedAnnotations[currentIndex];
+          const next = updatedAnnotations[currentIndex + 1];
+          if (Math.abs(next.start - current.end) < linkThreshold) {
+            const nextDelta = current.end - annotations[currentIndex].end;
+            updatedAnnotations[currentIndex + 1] = {
+              ...next,
+              start: Math.min(next.end - minDuration, next.start + nextDelta)
+            };
+            currentIndex++;
+          } else {
+            break;
+          }
+        }
+      } else if (constrainedEnd >= nextAnnotation.start) {
+        updatedAnnotations[annotationIndex] = {
+          ...updatedAnnotations[annotationIndex],
+          end: nextAnnotation.start
+        };
+      }
+    } else if (!linkEndpoints && annotationIndex < updatedAnnotations.length - 1 && constrainedEnd > updatedAnnotations[annotationIndex + 1].start) {
+      const nextAnnotation = updatedAnnotations[annotationIndex + 1];
+      updatedAnnotations[annotationIndex + 1] = { ...nextAnnotation, start: constrainedEnd };
+      let currentIndex = annotationIndex + 1;
+      while (currentIndex < updatedAnnotations.length - 1) {
+        const current = updatedAnnotations[currentIndex];
+        const next = updatedAnnotations[currentIndex + 1];
+        if (current.end > next.start) {
+          updatedAnnotations[currentIndex + 1] = { ...next, start: current.end };
+          currentIndex++;
+        } else {
+          break;
+        }
+      }
+    }
+  }
+  return updatedAnnotations;
+}
+
+// src/annotations/shortcuts.ts
+var noMods = { ctrlKey: false, metaKey: false };
+var DEFAULT_ANNOTATION_SHORTCUTS = {
+  selectPrevious: [
+    { key: "ArrowUp", ...noMods },
+    { key: "ArrowLeft", ...noMods }
+  ],
+  selectNext: [
+    { key: "ArrowDown", ...noMods },
+    { key: "ArrowRight", ...noMods }
+  ],
+  selectFirst: [{ key: "Home", ...noMods }],
+  selectLast: [{ key: "End", ...noMods }],
+  clearSelection: [{ key: "Escape", ...noMods }],
+  moveStartEarlier: [{ key: "[", ...noMods }],
+  moveStartLater: [{ key: "]", ...noMods }],
+  // '{' / '}' are what event.key reports for Shift+[ / Shift+] — no explicit
+  // shiftKey needed; the key value itself encodes it.
+  moveEndEarlier: [{ key: "{", ...noMods }],
+  moveEndLater: [{ key: "}", ...noMods }],
+  playActive: [{ key: "Enter", ...noMods }]
+};
+var ALL_ACTIONS = Object.keys(DEFAULT_ANNOTATION_SHORTCUTS);
+function resolveAnnotationShortcuts(remap) {
+  return ALL_ACTIONS.flatMap((action) => {
+    const override = remap?.[action];
+    const bindings = override ? [override] : DEFAULT_ANNOTATION_SHORTCUTS[action];
+    return bindings.map((binding) => ({ action, binding }));
+  });
+}
 export {
+  ANNOTATION_LINK_THRESHOLD_TICKS,
+  DEFAULT_ANNOTATION_SHORTCUTS,
   DEFAULT_SPECTROGRAM_COLOR_MAP,
   InteractionState,
+  LINK_THRESHOLD,
   MAX_CANVAS_WIDTH,
+  MIN_ANNOTATION_DURATION,
   MIN_PIXELS_PER_UNIT,
   PPQN,
   SPECTROGRAM_DEFAULTS,
+  annotationMinDurationTicks,
   appendPeaks,
   appendToAudioBuffer,
   applyFadeIn,
@@ -959,11 +1115,13 @@ export {
   handleKeyboardEvent,
   linearCurve,
   logarithmicCurve,
+  matchesKeyBinding,
   normalizedToDb,
   parseSpectrogramCanvasId,
   pixelsToSamples,
   pixelsToSeconds,
   probeRangeSupport,
+  resolveAnnotationShortcuts,
   resolveRecordingOffsetSamples,
   sCurveCurve,
   samplesToPixels,
@@ -977,8 +1135,10 @@ export {
   sortClipsByTime,
   ticksPerBar,
   ticksPerBeat,
+  ticksToBarBeat,
   ticksToSamples,
   trackChannelCount,
+  updateAnnotationBoundaries,
   watchMicrophoneDevices
 };
 //# sourceMappingURL=index.mjs.map