origam 2.2.1 → 2.5.0

package/dist/src/composables/Media/use-media-player.composable.js

@@ -0,0 +1,289 @@
+import {
+  onBeforeUnmount,
+  onMounted,
+  ref
+} from "vue";
+import { MEDIA_DEFAULT_VOLUME } from "../../consts/Media/media.const.js";
+function prefersReducedMotion() {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") {
+    return false;
+  }
+  return window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+function readBufferedEnd(media) {
+  if (!media.buffered || media.buffered.length === 0) return 0;
+  try {
+    return media.buffered.end(media.buffered.length - 1);
+  } catch {
+    return 0;
+  }
+}
+export function useMediaPlayer(options = {}) {
+  const mediaRef = options.mediaRef ?? ref(null);
+  const playing = ref(false);
+  const paused = ref(true);
+  const currentTime = ref(0);
+  const duration = ref(NaN);
+  const buffered = ref(0);
+  const volume = ref(MEDIA_DEFAULT_VOLUME);
+  const muted = ref(Boolean(options.muted));
+  const ready = ref(false);
+  const loading = ref(false);
+  const error = ref(null);
+  const playbackRate = ref(1);
+  const remoteAvailable = ref(false);
+  const remoteState = ref("disconnected");
+  const play = async () => {
+    const el = mediaRef.value;
+    if (!el) return;
+    try {
+      await el.play();
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+    }
+  };
+  const pause = () => {
+    mediaRef.value?.pause();
+  };
+  const toggle = async () => {
+    if (playing.value) pause();
+    else await play();
+  };
+  const seek = (seconds) => {
+    const el = mediaRef.value;
+    if (!el) return;
+    const max = Number.isFinite(el.duration) ? el.duration : seconds;
+    el.currentTime = Math.max(0, Math.min(seconds, max));
+  };
+  const setVolume = (value) => {
+    const el = mediaRef.value;
+    if (!el) return;
+    const clamped = Math.max(0, Math.min(1, value));
+    el.volume = clamped;
+    if (clamped > 0 && el.muted) {
+      el.muted = false;
+    }
+  };
+  const toggleMute = () => {
+    const el = mediaRef.value;
+    if (!el) return;
+    el.muted = !el.muted;
+  };
+  const load = () => {
+    mediaRef.value?.load();
+  };
+  const skipBackward = (seconds) => {
+    const el = mediaRef.value;
+    if (!el) return;
+    seek(el.currentTime - seconds);
+  };
+  const skipForward = (seconds) => {
+    const el = mediaRef.value;
+    if (!el) return;
+    seek(el.currentTime + seconds);
+  };
+  const setPlaybackRate = (rate) => {
+    const el = mediaRef.value;
+    if (!el) return;
+    const clamped = Math.max(0.25, Math.min(4, rate));
+    el.playbackRate = clamped;
+    playbackRate.value = clamped;
+  };
+  const requestRemotePlayback = async () => {
+    const el = mediaRef.value;
+    if (!el?.remote?.prompt) return;
+    try {
+      await el.remote.prompt();
+    } catch (err) {
+      if (err instanceof Error && err.name !== "NotAllowedError" && err.name !== "NotFoundError") {
+        error.value = err;
+      }
+    }
+  };
+  const stopRemotePlayback = async () => {
+    const el = mediaRef.value;
+    if (!el) return;
+    try {
+      el.pause();
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+    }
+  };
+  const onPlay = () => {
+    playing.value = true;
+    paused.value = false;
+  };
+  const onPause = () => {
+    playing.value = false;
+    paused.value = true;
+  };
+  const onEnded = () => {
+    playing.value = false;
+    paused.value = true;
+  };
+  const onTimeUpdate = () => {
+    const el = mediaRef.value;
+    if (!el) return;
+    currentTime.value = el.currentTime;
+    buffered.value = readBufferedEnd(el);
+  };
+  const onProgress = () => {
+    const el = mediaRef.value;
+    if (!el) return;
+    buffered.value = readBufferedEnd(el);
+  };
+  const onVolumeChange = () => {
+    const el = mediaRef.value;
+    if (!el) return;
+    volume.value = el.volume;
+    muted.value = el.muted;
+  };
+  const onLoadedMetadata = () => {
+    const el = mediaRef.value;
+    if (!el) return;
+    duration.value = el.duration;
+    ready.value = true;
+    loading.value = false;
+  };
+  const onLoadStart = () => {
+    loading.value = true;
+    error.value = null;
+  };
+  const onCanPlay = () => {
+    loading.value = false;
+  };
+  const onWaiting = () => {
+    loading.value = true;
+  };
+  const onError = () => {
+    loading.value = false;
+    const el = mediaRef.value;
+    if (el?.error) error.value = el.error;
+    else error.value = new Error("Unknown media error");
+  };
+  const onRateChange = () => {
+    const el = mediaRef.value;
+    if (!el) return;
+    playbackRate.value = el.playbackRate;
+  };
+  let _remoteAvailabilityCallbackId = null;
+  const onRemoteConnecting = () => {
+    remoteState.value = "connecting";
+  };
+  const onRemoteConnect = () => {
+    remoteState.value = "connected";
+  };
+  const onRemoteDisconnect = () => {
+    remoteState.value = "disconnected";
+  };
+  const bind = (el) => {
+    el.addEventListener("play", onPlay);
+    el.addEventListener("pause", onPause);
+    el.addEventListener("ended", onEnded);
+    el.addEventListener("timeupdate", onTimeUpdate);
+    el.addEventListener("progress", onProgress);
+    el.addEventListener("volumechange", onVolumeChange);
+    el.addEventListener("loadedmetadata", onLoadedMetadata);
+    el.addEventListener("loadstart", onLoadStart);
+    el.addEventListener("canplay", onCanPlay);
+    el.addEventListener("waiting", onWaiting);
+    el.addEventListener("error", onError);
+    el.addEventListener("ratechange", onRateChange);
+    const remote = el.remote;
+    if (remote) {
+      if (remote.state) remoteState.value = remote.state;
+      remote.addEventListener?.("connecting", onRemoteConnecting);
+      remote.addEventListener?.("connect", onRemoteConnect);
+      remote.addEventListener?.("disconnect", onRemoteDisconnect);
+      if (typeof remote.watchAvailability === "function") {
+        remote.watchAvailability((available) => {
+          remoteAvailable.value = available;
+        }).then((id) => {
+          _remoteAvailabilityCallbackId = id;
+        }).catch(() => {
+        });
+      }
+    }
+    volume.value = el.volume;
+    muted.value = el.muted || Boolean(options.muted);
+    paused.value = el.paused;
+    playing.value = !el.paused;
+    if (Number.isFinite(el.duration)) {
+      duration.value = el.duration;
+      ready.value = true;
+    }
+    if (options.autoplay && prefersReducedMotion()) {
+      console.warn(
+        "[origam:media] `autoplay` requested but the user prefers reduced motion; autoplay was suppressed."
+      );
+    }
+  };
+  const unbind = (el) => {
+    el.removeEventListener("play", onPlay);
+    el.removeEventListener("pause", onPause);
+    el.removeEventListener("ended", onEnded);
+    el.removeEventListener("timeupdate", onTimeUpdate);
+    el.removeEventListener("progress", onProgress);
+    el.removeEventListener("volumechange", onVolumeChange);
+    el.removeEventListener("loadedmetadata", onLoadedMetadata);
+    el.removeEventListener("loadstart", onLoadStart);
+    el.removeEventListener("canplay", onCanPlay);
+    el.removeEventListener("waiting", onWaiting);
+    el.removeEventListener("error", onError);
+    el.removeEventListener("ratechange", onRateChange);
+    const remote = el.remote;
+    if (remote) {
+      remote.removeEventListener?.("connecting", onRemoteConnecting);
+      remote.removeEventListener?.("connect", onRemoteConnect);
+      remote.removeEventListener?.("disconnect", onRemoteDisconnect);
+      if (_remoteAvailabilityCallbackId != null && typeof remote.cancelWatchAvailability === "function") {
+        remote.cancelWatchAvailability(_remoteAvailabilityCallbackId).catch(() => {
+        });
+        _remoteAvailabilityCallbackId = null;
+      }
+    }
+  };
+  onMounted(() => {
+    const el = mediaRef.value;
+    if (el) bind(el);
+  });
+  onBeforeUnmount(() => {
+    const el = mediaRef.value;
+    if (el) unbind(el);
+  });
+  return {
+    mediaRef,
+    state: {
+      playing,
+      paused,
+      currentTime,
+      duration,
+      buffered,
+      volume,
+      muted,
+      ready,
+      loading,
+      error,
+      playbackRate,
+      remoteAvailable,
+      remoteState
+    },
+    methods: {
+      play,
+      pause,
+      toggle,
+      seek,
+      setVolume,
+      toggleMute,
+      load,
+      skipBackward,
+      skipForward,
+      setPlaybackRate,
+      requestRemotePlayback,
+      stopRemotePlayback
+    }
+  };
+}
+export function shouldSuppressAutoplay() {
+  return prefersReducedMotion();
+}

package/dist/src/composables/NumberFormat/number-format.composable.cjs

@@ -0,0 +1,165 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.__clearNumberFormatCache = __clearNumberFormatCache;
+exports.useNumberFormat = useNumberFormat;
+var _vue = require("vue");
+var _numberFormat = require("../../consts/NumberFormat/number-format.const.cjs");
+const intlCache = /* @__PURE__ */new Map();
+function resolveLocale(locale) {
+  if (Array.isArray(locale) && locale.length > 0) return locale;
+  if (typeof locale === "string" && locale.length > 0 && locale !== "auto") return locale;
+  if (typeof document !== "undefined") {
+    const htmlLang = document.documentElement?.lang;
+    if (htmlLang) return htmlLang;
+  }
+  if (typeof navigator !== "undefined" && typeof navigator.language === "string" && navigator.language.length > 0) {
+    return navigator.language;
+  }
+  return _numberFormat.NUMBER_FORMAT_FALLBACK_LOCALE;
+}
+function resolveUseGrouping(value) {
+  if (value === void 0) return void 0;
+  if (typeof value === "boolean") return value;
+  return value;
+}
+function resolveStyleAndNotation(format) {
+  switch (format) {
+    case "currency":
+      return {
+        style: "currency"
+      };
+    case "percent":
+      return {
+        style: "percent"
+      };
+    case "unit":
+      return {
+        style: "unit"
+      };
+    case "compact":
+      return {
+        style: "decimal",
+        notation: "compact"
+      };
+    case "scientific":
+      return {
+        style: "decimal",
+        notation: "scientific"
+      };
+    case "engineering":
+      return {
+        style: "decimal",
+        notation: "engineering"
+      };
+    case "decimal":
+    case void 0:
+    default:
+      return {
+        style: "decimal"
+      };
+  }
+}
+function buildIntlOptions(options) {
+  const intl = {};
+  const base = resolveStyleAndNotation(options.format);
+  Object.assign(intl, base);
+  if (options.notation !== void 0) {
+    intl.notation = options.notation;
+  }
+  if (intl.style === "currency") {
+    intl.currency = options.currency || _numberFormat.NUMBER_FORMAT_DEFAULT_CURRENCY;
+    if (options.currencyDisplay !== void 0) {
+      intl.currencyDisplay = options.currencyDisplay;
+    }
+  }
+  if (intl.style === "unit") {
+    if (options.unit) {
+      intl.unit = options.unit;
+      if (options.unitDisplay !== void 0) {
+        intl.unitDisplay = options.unitDisplay;
+      }
+    } else {
+      if (typeof console !== "undefined") {
+        console.warn('[origam] useNumberFormat: format="unit" requires a `unit` option (e.g. "kilometer-per-hour"). Falling back to decimal.');
+      }
+      intl.style = "decimal";
+    }
+  }
+  if (intl.notation === "compact" && options.compactDisplay !== void 0) {
+    intl.compactDisplay = options.compactDisplay;
+  }
+  if (options.minimumFractionDigits !== void 0) intl.minimumFractionDigits = options.minimumFractionDigits;
+  if (options.maximumFractionDigits !== void 0) intl.maximumFractionDigits = options.maximumFractionDigits;
+  if (options.minimumSignificantDigits !== void 0) intl.minimumSignificantDigits = options.minimumSignificantDigits;
+  if (options.maximumSignificantDigits !== void 0) intl.maximumSignificantDigits = options.maximumSignificantDigits;
+  const grouping = resolveUseGrouping(options.useGrouping);
+  if (grouping !== void 0) {
+    intl.useGrouping = grouping;
+  }
+  if (options.signDisplay !== void 0) {
+    intl.signDisplay = options.signDisplay;
+  }
+  return intl;
+}
+function getIntl(locale, options) {
+  const cacheKey = JSON.stringify({
+    l: locale,
+    o: options
+  });
+  const hit = intlCache.get(cacheKey);
+  if (hit !== void 0) {
+    intlCache.delete(cacheKey);
+    intlCache.set(cacheKey, hit);
+    return hit;
+  }
+  const fresh = new Intl.NumberFormat(locale, options);
+  intlCache.set(cacheKey, fresh);
+  if (intlCache.size > _numberFormat.NUMBER_FORMAT_LRU_CAPACITY) {
+    const oldest = intlCache.keys().next().value;
+    if (oldest !== void 0) {
+      intlCache.delete(oldest);
+    }
+  }
+  return fresh;
+}
+function coerceValue(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string" && value.length > 0) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  return 0;
+}
+function __clearNumberFormatCache() {
+  intlCache.clear();
+}
+function useNumberFormat(options = {}) {
+  const normalisedOptions = (0, _vue.computed)(() => {
+    if ((0, _vue.isRef)(options) || typeof options === "function") {
+      return (0, _vue.toValue)(options) ?? {};
+    }
+    return options;
+  });
+  const intl = (0, _vue.computed)(() => {
+    const opts = normalisedOptions.value;
+    const locale = resolveLocale(opts.locale);
+    const intlOptions = buildIntlOptions(opts);
+    return getIntl(locale, intlOptions);
+  });
+  const format = value => {
+    const numeric = coerceValue(value);
+    return intl.value.format(numeric);
+  };
+  const formatToParts = value => {
+    const numeric = coerceValue(value);
+    return intl.value.formatToParts(numeric);
+  };
+  return {
+    intl,
+    format,
+    formatToParts
+  };
+}

package/dist/src/composables/NumberFormat/number-format.composable.d.ts

@@ -0,0 +1,33 @@
+import { type ComputedRef, type MaybeRefOrGetter } from 'vue';
+import type { IUseNumberFormatOptions } from '../../interfaces';
+/**
+ * Test helper — clears the module-level LRU. Exposed for the unit-test
+ * suite (cache-hit assertion) and not advertised in the public docs.
+ */
+export declare function __clearNumberFormatCache(): void;
+/**
+ * Headless number-formatting composable. Wraps `Intl.NumberFormat` with
+ * an LRU cache, reactive locale resolution, and convenience format
+ * dialects (`currency` / `percent` / `unit` / `compact` / `scientific`
+ * / `engineering`).
+ *
+ * The composable accepts options as a plain object OR as ref-like
+ * sources (refs / getters), so the same primitive backs both the
+ * `<OrigamNumberFormat>` SFC and ad-hoc callers (e.g. a Pinia store
+ * that formats numbers for a non-Vue consumer).
+ *
+ * @example
+ * ```ts
+ * const { format, formatToParts } = useNumberFormat({
+ *     locale: 'fr-FR',
+ *     format: 'currency',
+ *     currency: 'EUR'
+ * })
+ * format(1234.5) // → "1 234,50 €"
+ * ```
+ */
+export declare function useNumberFormat(options?: MaybeRefOrGetter<IUseNumberFormatOptions>): {
+    intl: ComputedRef<Intl.NumberFormat>;
+    format: (value: number | string) => string;
+    formatToParts: (value: number | string) => Intl.NumberFormatPart[];
+};

package/dist/src/composables/NumberFormat/number-format.composable.js

@@ -0,0 +1,146 @@
+import {
+  computed,
+  isRef,
+  toValue
+} from "vue";
+import {
+  NUMBER_FORMAT_DEFAULT_CURRENCY,
+  NUMBER_FORMAT_FALLBACK_LOCALE,
+  NUMBER_FORMAT_LRU_CAPACITY
+} from "../../consts/NumberFormat/number-format.const.js";
+const intlCache = /* @__PURE__ */ new Map();
+function resolveLocale(locale) {
+  if (Array.isArray(locale) && locale.length > 0) return locale;
+  if (typeof locale === "string" && locale.length > 0 && locale !== "auto") return locale;
+  if (typeof document !== "undefined") {
+    const htmlLang = document.documentElement?.lang;
+    if (htmlLang) return htmlLang;
+  }
+  if (typeof navigator !== "undefined" && typeof navigator.language === "string" && navigator.language.length > 0) {
+    return navigator.language;
+  }
+  return NUMBER_FORMAT_FALLBACK_LOCALE;
+}
+function resolveUseGrouping(value) {
+  if (value === void 0) return void 0;
+  if (typeof value === "boolean") return value;
+  return value;
+}
+function resolveStyleAndNotation(format) {
+  switch (format) {
+    case "currency":
+      return { style: "currency" };
+    case "percent":
+      return { style: "percent" };
+    case "unit":
+      return { style: "unit" };
+    case "compact":
+      return { style: "decimal", notation: "compact" };
+    case "scientific":
+      return { style: "decimal", notation: "scientific" };
+    case "engineering":
+      return { style: "decimal", notation: "engineering" };
+    case "decimal":
+    case void 0:
+    default:
+      return { style: "decimal" };
+  }
+}
+function buildIntlOptions(options) {
+  const intl = {};
+  const base = resolveStyleAndNotation(options.format);
+  Object.assign(intl, base);
+  if (options.notation !== void 0) {
+    intl.notation = options.notation;
+  }
+  if (intl.style === "currency") {
+    intl.currency = options.currency || NUMBER_FORMAT_DEFAULT_CURRENCY;
+    if (options.currencyDisplay !== void 0) {
+      intl.currencyDisplay = options.currencyDisplay;
+    }
+  }
+  if (intl.style === "unit") {
+    if (options.unit) {
+      intl.unit = options.unit;
+      if (options.unitDisplay !== void 0) {
+        intl.unitDisplay = options.unitDisplay;
+      }
+    } else {
+      if (typeof console !== "undefined") {
+        console.warn('[origam] useNumberFormat: format="unit" requires a `unit` option (e.g. "kilometer-per-hour"). Falling back to decimal.');
+      }
+      intl.style = "decimal";
+    }
+  }
+  if (intl.notation === "compact" && options.compactDisplay !== void 0) {
+    intl.compactDisplay = options.compactDisplay;
+  }
+  if (options.minimumFractionDigits !== void 0) intl.minimumFractionDigits = options.minimumFractionDigits;
+  if (options.maximumFractionDigits !== void 0) intl.maximumFractionDigits = options.maximumFractionDigits;
+  if (options.minimumSignificantDigits !== void 0) intl.minimumSignificantDigits = options.minimumSignificantDigits;
+  if (options.maximumSignificantDigits !== void 0) intl.maximumSignificantDigits = options.maximumSignificantDigits;
+  const grouping = resolveUseGrouping(options.useGrouping);
+  if (grouping !== void 0) {
+    intl.useGrouping = grouping;
+  }
+  if (options.signDisplay !== void 0) {
+    intl.signDisplay = options.signDisplay;
+  }
+  return intl;
+}
+function getIntl(locale, options) {
+  const cacheKey = JSON.stringify({ l: locale, o: options });
+  const hit = intlCache.get(cacheKey);
+  if (hit !== void 0) {
+    intlCache.delete(cacheKey);
+    intlCache.set(cacheKey, hit);
+    return hit;
+  }
+  const fresh = new Intl.NumberFormat(locale, options);
+  intlCache.set(cacheKey, fresh);
+  if (intlCache.size > NUMBER_FORMAT_LRU_CAPACITY) {
+    const oldest = intlCache.keys().next().value;
+    if (oldest !== void 0) {
+      intlCache.delete(oldest);
+    }
+  }
+  return fresh;
+}
+function coerceValue(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string" && value.length > 0) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  return 0;
+}
+export function __clearNumberFormatCache() {
+  intlCache.clear();
+}
+export function useNumberFormat(options = {}) {
+  const normalisedOptions = computed(() => {
+    if (isRef(options) || typeof options === "function") {
+      return toValue(options) ?? {};
+    }
+    return options;
+  });
+  const intl = computed(() => {
+    const opts = normalisedOptions.value;
+    const locale = resolveLocale(opts.locale);
+    const intlOptions = buildIntlOptions(opts);
+    return getIntl(locale, intlOptions);
+  });
+  const format = (value) => {
+    const numeric = coerceValue(value);
+    return intl.value.format(numeric);
+  };
+  const formatToParts = (value) => {
+    const numeric = coerceValue(value);
+    return intl.value.formatToParts(numeric);
+  };
+  return {
+    intl,
+    format,
+    formatToParts
+  };
+}