@waveform-playlist/core 12.5.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 };
@@ -635,6 +666,44 @@ var SPECTROGRAM_DEFAULTS = {
 };
 var DEFAULT_SPECTROGRAM_COLOR_MAP = "viridis";
 
+// src/utils/carveClipRange.ts
+function carveClipRange(clips, rangeStart, rangeEnd) {
+  if (!(rangeEnd > rangeStart)) {
+    return [...clips];
+  }
+  const result = [];
+  for (const clip of clips) {
+    const clipStart = clip.startSample;
+    const clipEnd = clip.startSample + clip.durationSamples;
+    if (clipEnd <= rangeStart || clipStart >= rangeEnd) {
+      result.push(clip);
+      continue;
+    }
+    const keepHead = clipStart < rangeStart;
+    const keepTail = clipEnd > rangeEnd;
+    if (keepHead) {
+      result.push({
+        ...clip,
+        durationSamples: rangeStart - clipStart
+      });
+    }
+    if (keepTail) {
+      const carvedFromClipStart = rangeEnd - clipStart;
+      const tail = {
+        ...clip,
+        // Head + tail from one clip must not share an id
+        id: keepHead ? `${clip.id}-carve-${rangeEnd}` : clip.id,
+        startSample: rangeEnd,
+        durationSamples: clipEnd - rangeEnd,
+        offsetSamples: clip.offsetSamples + carvedFromClipStart
+      };
+      delete tail.startTick;
+      result.push(tail);
+    }
+  }
+  return result;
+}
+
 // src/clipTimeHelpers.ts
 function clipStartTime(clip) {
   return clip.startSample / clip.sampleRate;
@@ -762,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;
@@ -769,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();
@@ -824,13 +894,190 @@ async function probeRangeSupport(url, fetchImpl = fetch) {
     controller.abort();
   }
 }
+
+// src/enumerateMicrophones.ts
+var UNSUPPORTED = Object.freeze({
+  supported: false,
+  hasLabels: false,
+  devices: []
+});
+function resolveMediaDevices(mediaDevices) {
+  if (mediaDevices) return mediaDevices;
+  return typeof navigator !== "undefined" ? navigator.mediaDevices : void 0;
+}
+async function enumerateMicrophones(mediaDevices) {
+  const md = resolveMediaDevices(mediaDevices);
+  if (!md || typeof md.enumerateDevices !== "function") {
+    return UNSUPPORTED;
+  }
+  const all = await md.enumerateDevices();
+  const inputs = all.filter((device) => device.kind === "audioinput");
+  const hasLabels = inputs.some((device) => device.label.length > 0);
+  return {
+    supported: true,
+    hasLabels,
+    devices: inputs.map((device, index) => ({
+      deviceId: device.deviceId,
+      label: device.label || // Pre-permission fallbacks: Chrome redacts deviceId to '' as well,
+      // so fall through to a positional name when there's nothing to slice.
+      (device.deviceId ? `Microphone ${device.deviceId.slice(0, 8)}` : `Microphone ${index + 1}`),
+      groupId: device.groupId
+    }))
+  };
+}
+function watchMicrophoneDevices(listener, mediaDevices) {
+  const md = resolveMediaDevices(mediaDevices);
+  if (!md || typeof md.enumerateDevices !== "function") {
+    queueMicrotask(() => listener(UNSUPPORTED));
+    return () => {
+    };
+  }
+  let active = true;
+  const deliver = () => {
+    enumerateMicrophones(md).then((result) => {
+      if (active) listener(result);
+    }).catch((err) => {
+      console.warn("[waveform-playlist] Microphone enumeration failed:", String(err));
+    });
+  };
+  md.addEventListener("devicechange", deliver);
+  deliver();
+  return () => {
+    active = false;
+    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,
@@ -838,6 +1085,7 @@ export {
   audibleLatencySamples,
   buildSpectrogramCanvasId,
   calculateDuration,
+  carveClipRange,
   clipDurationTime,
   clipEndTime,
   clipOffsetTime,
@@ -854,6 +1102,7 @@ export {
   createTrack,
   dBToNormalized,
   detectMeterChanges,
+  enumerateMicrophones,
   exponentialCurve,
   findGaps,
   gainToDb,
@@ -866,11 +1115,13 @@ export {
   handleKeyboardEvent,
   linearCurve,
   logarithmicCurve,
+  matchesKeyBinding,
   normalizedToDb,
   parseSpectrogramCanvasId,
   pixelsToSamples,
   pixelsToSeconds,
   probeRangeSupport,
+  resolveAnnotationShortcuts,
   resolveRecordingOffsetSamples,
   sCurveCurve,
   samplesToPixels,
@@ -884,7 +1135,10 @@ export {
   sortClipsByTime,
   ticksPerBar,
   ticksPerBeat,
+  ticksToBarBeat,
   ticksToSamples,
-  trackChannelCount
+  trackChannelCount,
+  updateAnnotationBoundaries,
+  watchMicrophoneDevices
 };
 //# sourceMappingURL=index.mjs.map