@goldenratio/wolf 0.0.2 → 0.0.4

package/README.md

@@ -6,6 +6,8 @@
 - Written in TypeScript (better type safety)
 - Compatible with [Google Closure Compiler](https://github.com/google/closure-compiler)
 - ESM only
+- WebAudio only, removed HTML5 audio
+- Minor bug fixes
 
 ## Install
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@goldenratio/wolf",
-  "version": "0.0.2",
-  "description": "Port of howler.js in TypeScript (ESM)",
+  "version": "0.0.4",
+  "description": "Audio library for the modern web. Port of howler.js in TypeScript (ESM)",
   "type": "module",
   "module": "./target/wolf.js",
   "types": "./target/types/main.d.ts",

package/target/types/howl.d.ts

@@ -1,29 +1,24 @@
-import type { HowlEventHandler, HowlEventName, HowlListener, HowlOptions, HowlState, HowlXHR, HowlSpriteMap, WebAudioNodeWithSource } from "./types.js";
+import type { HowlCallback, HowlEventName, HowlListener, HowlOptions, HowlState, HowlXHR, SoundSpriteDefinitions, WebAudioNodeWithSource } from "./types.js";
 import { Sound } from "./sound.js";
-export declare class Howl {
+export declare class Howl<TAudioSpriteKey extends string = string> {
     private readonly howler;
-    _autoplay: boolean;
-    _format: readonly string[] | undefined;
-    _html5: boolean;
+    readonly _preload: boolean | "metadata" | "none";
     _muted: boolean;
     _loop: boolean;
-    _pool: number;
-    _preload: boolean | "metadata" | "none";
     _rate: number;
-    _sprite: HowlSpriteMap;
+    _sprite: SoundSpriteDefinitions;
     _src: readonly string[];
     _volume: number;
     _xhr: HowlXHR;
     _duration: number;
     _state: HowlState;
     _sounds: Sound[];
-    _endTimers: Record<number, ReturnType<typeof setTimeout> | (() => void)>;
-    _queue: Array<{
-        event: string;
-        action: () => void;
-    }>;
-    _playLock: boolean;
-    _webAudio: boolean;
+    private _format;
+    private _autoplay;
+    private _pool;
+    private _endTimers;
+    private _queue;
+    private _playLock;
     _onend: HowlListener[];
     _onfade: HowlListener[];
     _onload: HowlListener[];
@@ -40,7 +35,7 @@ export declare class Howl {
     _onresume: HowlListener[];
     constructor(options: HowlOptions);
     load(): void;
-    play(spriteOrId?: string | number, internal?: boolean): number | undefined;
+    play(spriteOrId?: TAudioSpriteKey | "__default" | number, internal?: boolean): number | undefined;
     state(): HowlState;
     /**
      * Check if a sound (or any sound) is playing.
@@ -100,16 +95,16 @@ export declare class Howl {
      */
     fade(from: number, to: number, len: number, id?: number): this;
     /**
-     * loop() from your snippet.
+     * loop()
      */
     loop(): boolean;
     loop(id: number): boolean;
     loop(loop: boolean): this;
     loop(loop: boolean, id: number): this;
     unload(): void;
-    on(event: HowlEventName, fn: HowlEventHandler, id?: number, once?: boolean): this;
-    off(event?: HowlEventName, fn?: HowlEventHandler | number, id?: number): this;
-    once(event: HowlEventName, fn: HowlEventHandler, id?: number): this;
+    on(event: HowlEventName, fn: HowlCallback, id?: number, once?: boolean): this;
+    off(event?: HowlEventName, fn?: HowlCallback | number, id?: number): this;
+    once(event: HowlEventName, fn: HowlCallback, id?: number): this;
     /**
      * Starts the internal interval to fade a sound.
      */
@@ -128,5 +123,4 @@ export declare class Howl {
     _getSoundIds(id?: number): number[];
     _refreshBuffer(sound: Sound): void;
     _cleanBuffer(node: WebAudioNodeWithSource): void;
-    _clearSound(node: HTMLAudioElement): void;
 }

package/target/types/howler.d.ts

@@ -1,28 +1,24 @@
 import type { Howl } from "./howl.js";
-import type { HowlerState, Html5AudioUnlocked } from "./types.js";
+import type { HowlerState } from "./types.js";
 declare class HowlerGlobal {
+    private _codecs;
+    private _audioUnlocked?;
+    private _mobileUnloaded?;
+    private _suspendTimer?;
+    private _resumeAfterSuspend?;
+    readonly _navigator?: Navigator;
     _counter: number;
-    _html5AudioPool: Html5AudioUnlocked[];
-    html5PoolSize: number;
-    _codecs: Record<string, boolean>;
     _howls: Howl[];
     _muted: boolean;
     _volume: number;
-    _canPlayEvent: "canplaythrough" | "canplay";
-    readonly _navigator?: Navigator;
-    _audioUnlocked?: boolean;
-    _mobileUnloaded?: boolean;
     _scratchBuffer?: AudioBuffer;
-    _suspendTimer?: ReturnType<typeof setTimeout>;
-    _resumeAfterSuspend?: boolean;
     cache: Record<string, AudioBuffer>;
-    masterGain?: GainNode;
     noAudio: boolean;
-    usingWebAudio: boolean;
     autoSuspend: boolean;
-    ctx?: AudioContext;
     autoUnlock: boolean;
     state: HowlerState;
+    masterGain?: GainNode;
+    ctx?: AudioContext;
     constructor();
     volume(): number;
     volume(volume: number): this;
@@ -31,10 +27,8 @@ declare class HowlerGlobal {
     unload(): this;
     codecs(ext: string): boolean;
     _setup(): void;
-    _setupCodecs(): void;
+    private _setupCodecs;
     _unlockAudio(): void;
-    _obtainHtml5Audio(): Html5AudioUnlocked;
-    _releaseHtml5Audio(audio: Html5AudioUnlocked): this;
     _autoSuspend(): void;
     _autoResume(): void;
 }

package/target/types/sound.d.ts

@@ -1,5 +1,5 @@
 import type { Howl } from "./howl.js";
-import type { SoundNode } from "./types.js";
+import type { WebAudioNodeWithSource } from "./types.js";
 import type { Howler } from "./howler.js";
 export declare class Sound {
     private readonly howler;
@@ -14,19 +14,13 @@ export declare class Sound {
     _ended: boolean;
     _sprite: string;
     _id: number;
-    _node?: SoundNode;
-    _panner?: AudioNode;
+    _node?: WebAudioNodeWithSource;
+    _panner?: WebAudioNodeWithSource;
     _start: number;
     _stop: number;
     _playStart: number;
     _interval?: ReturnType<typeof setTimeout>;
     _fadeTo?: number;
-    _errorFn?: (ev: Event) => void;
-    _loadFn?: (ev: Event) => void;
-    _endFn?: (ev: Event) => void;
     constructor(parent: Howl, howler: typeof Howler);
     reset(): this;
-    private errorListener;
-    private loadListener;
-    private endListener;
 }

package/target/types/types.d.ts

@@ -1,10 +1,10 @@
 export type HowlState = "unloaded" | "loading" | "loaded";
 export type HowlerState = "suspended" | "suspending" | "running";
 export type HowlEventName = "end" | "fade" | "load" | "loaderror" | "playerror" | "pause" | "play" | "stop" | "mute" | "volume" | "rate" | "seek" | "unlock" | "resume";
-export type HowlEventHandler = (soundId?: number, errorMsg?: string) => void;
+export type HowlCallback = (soundId?: number, errorMsg?: string) => void;
 export interface HowlListener {
     readonly id?: number;
-    readonly fn: HowlEventHandler;
+    readonly fn: HowlCallback;
     readonly once?: boolean;
 }
 export interface HowlXHR {
@@ -13,40 +13,35 @@ export interface HowlXHR {
     readonly headers?: Record<string, string>;
 }
 export type HowlSpriteDef = [startMs: number, durationMs: number, loop?: boolean];
-export type HowlSpriteMap = Record<string, HowlSpriteDef>;
+export type SoundSpriteDefinitions = Record<string, HowlSpriteDef>;
 export interface HowlOptions {
     readonly src: string | readonly string[];
     readonly autoplay?: boolean;
     readonly format?: string | readonly string[];
-    readonly html5?: boolean;
     readonly mute?: boolean;
     readonly loop?: boolean;
     readonly pool?: number;
     readonly preload?: boolean | "metadata" | "none";
     readonly rate?: number;
-    readonly sprite?: HowlSpriteMap;
+    readonly sprite?: SoundSpriteDefinitions;
     readonly volume?: number;
     readonly xhr?: Partial<HowlXHR>;
-    readonly onend?: HowlEventHandler;
-    readonly onfade?: HowlEventHandler;
-    readonly onload?: HowlEventHandler;
-    readonly onloaderror?: HowlEventHandler;
-    readonly onplayerror?: HowlEventHandler;
-    readonly onpause?: HowlEventHandler;
-    readonly onplay?: HowlEventHandler;
-    readonly onstop?: HowlEventHandler;
-    readonly onmute?: HowlEventHandler;
-    readonly onvolume?: HowlEventHandler;
-    readonly onrate?: HowlEventHandler;
-    readonly onseek?: HowlEventHandler;
-    readonly onunlock?: HowlEventHandler;
-    readonly onresume?: HowlEventHandler;
+    readonly onend?: HowlCallback;
+    readonly onfade?: HowlCallback;
+    readonly onload?: HowlCallback;
+    readonly onloaderror?: HowlCallback;
+    readonly onplayerror?: HowlCallback;
+    readonly onpause?: HowlCallback;
+    readonly onplay?: HowlCallback;
+    readonly onstop?: HowlCallback;
+    readonly onmute?: HowlCallback;
+    readonly onvolume?: HowlCallback;
+    readonly onrate?: HowlCallback;
+    readonly onseek?: HowlCallback;
+    readonly onunlock?: HowlCallback;
+    readonly onresume?: HowlCallback;
 }
 export interface WebAudioNodeWithSource extends GainNode {
     bufferSource?: AudioBufferSourceNode;
     paused?: boolean;
 }
-export interface Html5AudioUnlocked extends HTMLAudioElement {
-    _unlocked?: boolean;
-}
-export type SoundNode = WebAudioNodeWithSource | Html5AudioUnlocked;

package/target/types/utils.d.ts

@@ -1,7 +1,5 @@
 import type { Howl } from "./howl.js";
-import type { Html5AudioUnlocked, SoundNode } from "./types.js";
 import type { Howler } from "./howler.js";
-export declare function isHtml5Audio(node: SoundNode): node is Html5AudioUnlocked;
 export declare function loadBuffer(howl: Howl, howler: typeof Howler): void;
 export declare function safeXhrSend(xhr: XMLHttpRequest): void;
 export declare function loadSound(self: Howl, buffer?: AudioBuffer): void;