@symbiote-native/audio 0.1.2 → 0.1.4

package/src/svelte/use-audio-player.svelte.ts

@@ -0,0 +1,20 @@
+// Svelte twin of `expo-audio`'s `useAudioPlayer`, boxed getter shape matching
+// `use-image-manipulator.svelte.ts` (`components_split_logic_view_lifecycle`)
+
+import { createResourceHook } from '@symbiote-native/svelte/runes/create-resource-hook';
+import { createAudioPlayerController } from '../core/audio-player-controller';
+import type { AudioPlayer } from '../core';
+import type { IAudioPlayerOptions, IAudioSource } from '../core';
+
+export type IUseAudioPlayerResult = {
+  readonly current: AudioPlayer;
+};
+
+const usePlayerResource = createResourceHook(createAudioPlayerController);
+
+export function useAudioPlayer(
+  getSource: () => IAudioSource = () => null,
+  getOptions: () => IAudioPlayerOptions = () => ({}),
+): IUseAudioPlayerResult {
+  return usePlayerResource(() => [getSource(), getOptions()]);
+}

package/src/svelte/use-audio-playlist-status.svelte.ts

@@ -0,0 +1,11 @@
+import { createEventValueHook } from '@symbiote-native/svelte/runes/create-event-value-hook';
+import { PLAYLIST_STATUS_UPDATE } from '../core/types';
+import type { AudioPlaylist } from '../core';
+import type { IAudioPlaylistStatus } from '../core';
+
+/** Svelte twin of `expo-audio`'s `useAudioPlaylistStatus` */
+export const useAudioPlaylistStatus = createEventValueHook<
+  AudioPlaylist,
+  IAudioPlaylistStatus,
+  typeof PLAYLIST_STATUS_UPDATE
+>(PLAYLIST_STATUS_UPDATE, playlist => playlist.currentStatus);

package/src/svelte/use-audio-playlist.svelte.ts

@@ -0,0 +1,19 @@
+// Svelte twin of `expo-audio`'s `useAudioPlaylist`, boxed getter shape matching
+// `use-audio-player.svelte.ts` (`components_split_logic_view_lifecycle`)
+
+import { createResourceHook } from '@symbiote-native/svelte/runes/create-resource-hook';
+import { createAudioPlaylistController } from '../core/audio-playlist-controller';
+import type { AudioPlaylist } from '../core';
+import type { IAudioPlaylistOptions } from '../core';
+
+export type IUseAudioPlaylistResult = {
+  readonly current: AudioPlaylist;
+};
+
+const usePlaylistResource = createResourceHook(createAudioPlaylistController);
+
+export function useAudioPlaylist(
+  getOptions: () => IAudioPlaylistOptions = () => ({}),
+): IUseAudioPlaylistResult {
+  return usePlaylistResource(() => [getOptions()]);
+}

package/src/svelte/use-audio-recorder-state.svelte.ts

@@ -0,0 +1,29 @@
+import { pollRecorderState } from '../core/audio-recorder-polling';
+import type { AudioRecorder } from '../core';
+import type { IRecorderState } from '../core';
+
+const DEFAULT_POLL_INTERVAL_MS = 500;
+
+export type IUseAudioRecorderStateResult = {
+  readonly current: IRecorderState;
+};
+
+/** Svelte twin of `expo-audio`'s `useAudioRecorderState` */
+export function useAudioRecorderState(
+  recorder: AudioRecorder,
+  interval: number = DEFAULT_POLL_INTERVAL_MS,
+): IUseAudioRecorderStateResult {
+  let state = $state(recorder.getStatus());
+
+  $effect(() =>
+    pollRecorderState(recorder, interval, updater => {
+      state = updater(state);
+    }),
+  );
+
+  return {
+    get current(): IRecorderState {
+      return state;
+    },
+  };
+}

package/src/svelte/use-audio-recorder.svelte.ts

@@ -0,0 +1,25 @@
+// Svelte twin of `expo-audio`'s `useAudioRecorder`, boxed getter shape matching
+// `use-audio-player.svelte.ts` (`components_split_logic_view_lifecycle`)
+
+import { createResourceHook } from '@symbiote-native/svelte/runes/create-resource-hook';
+import { createAudioRecorderController } from '../core/audio-recorder-controller';
+import { subscribeRecordingStatus } from '../core/audio-recorder-status';
+import type { AudioRecorder } from '../core';
+import type { IRecordingOptions, IRecordingStatus } from '../core';
+
+export type IUseAudioRecorderResult = {
+  readonly current: AudioRecorder;
+};
+
+const useRecorderResource = createResourceHook(createAudioRecorderController);
+
+export function useAudioRecorder(
+  getOptions: () => IRecordingOptions,
+  statusListener?: (status: IRecordingStatus) => void,
+): IUseAudioRecorderResult {
+  const recorder = useRecorderResource(() => [getOptions()]);
+
+  $effect(() => subscribeRecordingStatus(recorder.current, statusListener));
+
+  return recorder;
+}

package/src/svelte/use-audio-sample-listener.svelte.ts

@@ -0,0 +1,11 @@
+import { subscribeAudioSampleListener } from '../core/audio-sample-listener';
+import type { IAudioSamplePlayer } from '../core/audio-sample-listener';
+import type { IAudioSample } from '../core/types';
+
+/** Svelte twin of `expo-audio`'s `useAudioSampleListener` */
+export function useAudioSampleListener(
+  player: IAudioSamplePlayer,
+  listener: (data: IAudioSample) => void,
+): void {
+  $effect(() => subscribeAudioSampleListener(player, listener));
+}

package/src/svelte/use-audio-stream.svelte.ts

@@ -0,0 +1,44 @@
+// `$effect` is a compiler macro, can't be passed by reference like `watchEffect`/`createEffect`,
+// so it's wrapped instead of handed to `runAudioStreamBufferEffect` directly.
+// Approved cross-framework duplicate vs Solid's use-audio-stream.ts (.claude/reuse.json)
+
+import { createResourceHook } from '@symbiote-native/svelte/runes/create-resource-hook';
+import { createEventValueHook } from '@symbiote-native/svelte/runes/create-event-value-hook';
+import { createAudioStreamHooks } from '../core/audio-stream-hooks';
+import { toAudioStreamKey } from '../core/audio-stream-subscription';
+import { runAudioStreamBufferEffect } from '../core/audio-stream-lifecycle';
+import type { IAudioStreamResult, IUseAudioStreamOptions } from '../core';
+
+const { useStreamResource, useStreamStatus } = createAudioStreamHooks(
+  createResourceHook,
+  createEventValueHook,
+);
+
+export function useAudioStream(getOptions: () => IUseAudioStreamOptions): {
+  readonly current: IAudioStreamResult;
+} {
+  const stream = useStreamResource(() => [toAudioStreamKey(getOptions())]);
+  const status = useStreamStatus(() => stream.current);
+
+  const cleanups: Array<() => void> = [];
+  runAudioStreamBufferEffect(
+    () => stream.current,
+    () => getOptions().onBuffer,
+    effect => {
+      $effect(effect);
+    },
+    cleanup => cleanups.push(cleanup),
+  );
+  $effect(() => () => {
+    for (const cleanup of cleanups) cleanup();
+  });
+
+  return {
+    get current(): IAudioStreamResult {
+      return {
+        stream: stream.current,
+        isStreaming: status.current.isStreaming,
+      };
+    },
+  };
+}

package/src/vue/index.ts

@@ -0,0 +1,9 @@
+export * from '../core';
+export { useAudioPlayer } from './use-audio-player';
+export { useAudioPlayerStatus } from './use-audio-player-status';
+export { useAudioSampleListener } from './use-audio-sample-listener';
+export { useAudioPlaylist } from './use-audio-playlist';
+export { useAudioPlaylistStatus } from './use-audio-playlist-status';
+export { useAudioRecorder } from './use-audio-recorder';
+export { useAudioRecorderState } from './use-audio-recorder-state';
+export { useAudioStream } from './use-audio-stream';

package/src/vue/use-audio-player-status.ts

@@ -0,0 +1,11 @@
+import { createEventValueHook } from '@symbiote-native/vue';
+import { PLAYBACK_STATUS_UPDATE } from '../core/types';
+import type { AudioPlayer } from '../core';
+import type { IAudioStatus } from '../core';
+
+/** Vue twin of `expo-audio`'s `useAudioPlayerStatus` */
+export const useAudioPlayerStatus = createEventValueHook<
+  AudioPlayer,
+  IAudioStatus,
+  typeof PLAYBACK_STATUS_UPDATE
+>(PLAYBACK_STATUS_UPDATE, player => player.currentStatus);

package/src/vue/use-audio-player.ts

@@ -0,0 +1,19 @@
+import {
+  toValue,
+  type ComputedRef,
+  type MaybeRefOrGetter,
+} from '@vue/runtime-core';
+import { createResourceHook } from '@symbiote-native/vue';
+import { createAudioPlayerController } from '../core/audio-player-controller';
+import type { AudioPlayer } from '../core';
+import type { IAudioPlayerOptions, IAudioSource } from '../core';
+
+const usePlayerResource = createResourceHook(createAudioPlayerController);
+
+/** Vue twin of `expo-audio`'s `useAudioPlayer` */
+export function useAudioPlayer(
+  source: MaybeRefOrGetter<IAudioSource> = null,
+  options: MaybeRefOrGetter<IAudioPlayerOptions> = {},
+): ComputedRef<AudioPlayer> {
+  return usePlayerResource(() => [toValue(source), toValue(options)]);
+}

package/src/vue/use-audio-playlist-status.ts

@@ -0,0 +1,11 @@
+import { createEventValueHook } from '@symbiote-native/vue';
+import { PLAYLIST_STATUS_UPDATE } from '../core/types';
+import type { AudioPlaylist } from '../core';
+import type { IAudioPlaylistStatus } from '../core';
+
+/** Vue twin of `expo-audio`'s `useAudioPlaylistStatus` */
+export const useAudioPlaylistStatus = createEventValueHook<
+  AudioPlaylist,
+  IAudioPlaylistStatus,
+  typeof PLAYLIST_STATUS_UPDATE
+>(PLAYLIST_STATUS_UPDATE, playlist => playlist.currentStatus);

package/src/vue/use-audio-playlist.ts

@@ -0,0 +1,15 @@
+import type { ComputedRef, MaybeRefOrGetter } from '@vue/runtime-core';
+import { toValue } from '@vue/runtime-core';
+import { createResourceHook } from '@symbiote-native/vue';
+import { createAudioPlaylistController } from '../core/audio-playlist-controller';
+import type { AudioPlaylist } from '../core';
+import type { IAudioPlaylistOptions } from '../core';
+
+const usePlaylistResource = createResourceHook(createAudioPlaylistController);
+
+/** Vue twin of `expo-audio`'s `useAudioPlaylist` */
+export function useAudioPlaylist(
+  getOptions: MaybeRefOrGetter<IAudioPlaylistOptions> = {},
+): ComputedRef<AudioPlaylist> {
+  return usePlaylistResource(() => [toValue(getOptions)]);
+}

package/src/vue/use-audio-recorder-state.ts

@@ -0,0 +1,21 @@
+import { onUnmounted, shallowRef, type ShallowRef } from '@vue/runtime-core';
+import { pollRecorderState } from '../core/audio-recorder-polling';
+import type { AudioRecorder } from '../core';
+import type { IRecorderState } from '../core';
+
+const DEFAULT_POLL_INTERVAL_MS = 500;
+
+/** Vue twin of `expo-audio`'s `useAudioRecorderState` */
+export function useAudioRecorderState(
+  recorder: AudioRecorder,
+  interval: number = DEFAULT_POLL_INTERVAL_MS,
+): ShallowRef<IRecorderState> {
+  const state = shallowRef(recorder.getStatus());
+
+  const stop = pollRecorderState(recorder, interval, updater => {
+    state.value = updater(state.value);
+  });
+  onUnmounted(stop);
+
+  return state;
+}

package/src/vue/use-audio-recorder.ts

@@ -0,0 +1,30 @@
+import {
+  toValue,
+  watch,
+  type ComputedRef,
+  type MaybeRefOrGetter,
+} from '@vue/runtime-core';
+import { createResourceHook } from '@symbiote-native/vue';
+import { createAudioRecorderController } from '../core/audio-recorder-controller';
+import { subscribeRecordingStatus } from '../core/audio-recorder-status';
+import type { AudioRecorder } from '../core';
+import type { IRecordingOptions, IRecordingStatus } from '../core';
+
+const useRecorderResource = createResourceHook(createAudioRecorderController);
+
+/** Vue twin of `expo-audio`'s `useAudioRecorder` */
+export function useAudioRecorder(
+  getOptions: MaybeRefOrGetter<IRecordingOptions>,
+  statusListener?: (status: IRecordingStatus) => void,
+): ComputedRef<AudioRecorder> {
+  const recorder = useRecorderResource(() => [toValue(getOptions)]);
+
+  watch(
+    recorder,
+    (current, _previous, onCleanup) =>
+      onCleanup(subscribeRecordingStatus(current, statusListener)),
+    { immediate: true },
+  );
+
+  return recorder;
+}

package/src/vue/use-audio-sample-listener.ts

@@ -0,0 +1,22 @@
+import { onUnmounted, watch } from '@vue/runtime-core';
+import { subscribeAudioSampleListener } from '../core/audio-sample-listener';
+import type { IAudioSamplePlayer } from '../core/audio-sample-listener';
+import type { IAudioSample } from '../core/types';
+
+/** Vue twin of `expo-audio`'s `useAudioSampleListener` */
+export function useAudioSampleListener(
+  player: IAudioSamplePlayer,
+  listener: (data: IAudioSample) => void,
+): void {
+  let unsubscribe = subscribeAudioSampleListener(player, listener);
+
+  watch(
+    () => player,
+    next => {
+      unsubscribe();
+      unsubscribe = subscribeAudioSampleListener(next, listener);
+    },
+  );
+
+  onUnmounted(() => unsubscribe());
+}

package/src/vue/use-audio-stream.ts

@@ -0,0 +1,40 @@
+import {
+  computed,
+  onUnmounted,
+  toValue,
+  watchEffect,
+  type ComputedRef,
+  type MaybeRefOrGetter,
+} from '@vue/runtime-core';
+import { createResourceHook, createEventValueHook } from '@symbiote-native/vue';
+import { createAudioStreamHooks } from '../core/audio-stream-hooks';
+import { toAudioStreamKey } from '../core/audio-stream-subscription';
+import { runAudioStreamBufferEffect } from '../core/audio-stream-lifecycle';
+import type { IAudioStreamResult, IUseAudioStreamOptions } from '../core';
+
+const { useStreamResource, useStreamStatus } = createAudioStreamHooks(
+  createResourceHook,
+  createEventValueHook,
+);
+
+/** Vue twin of `expo-audio`'s `useAudioStream` */
+export function useAudioStream(
+  getOptions: MaybeRefOrGetter<IUseAudioStreamOptions>,
+): ComputedRef<IAudioStreamResult> {
+  const stream = useStreamResource(() => [
+    toAudioStreamKey(toValue(getOptions)),
+  ]);
+  const status = useStreamStatus(() => stream.value);
+
+  runAudioStreamBufferEffect(
+    () => stream.value,
+    () => toValue(getOptions).onBuffer,
+    watchEffect,
+    onUnmounted,
+  );
+
+  return computed(() => ({
+    stream: stream.value,
+    isStreaming: status.value.isStreaming,
+  }));
+}