Demo<
// List of files to load
-const manifest = {
- loop1: 'resources/loops/loop1.mp3',
- loop2: 'resources/loops/loop2.mp3',
- loop3: 'resources/loops/loop3.mp3',
- loop4: 'resources/loops/loop4.mp3',
- bird: 'resources/bird.mp3',
- boing: 'resources/boing.mp3',
- buzzer: 'resources/buzzer.mp3',
- car: 'resources/car.mp3',
- chime: 'resources/chime.mp3',
- success: 'resources/success.mp3',
- sword: 'resources/sword.mp3',
- whistle: 'resources/whistle.mp3'
-};
+const manifest = [
+ { alias: 'loop1', src: 'resources/loops/loop1.mp3' },
+ { alias: 'loop2', src: 'resources/loops/loop2.mp3' },
+ { alias: 'loop3', src: 'resources/loops/loop3.mp3' },
+ { alias: 'loop4', src: 'resources/loops/loop4.mp3' },
+ { alias: 'bird', src: 'resources/bird.mp3' },
+ { alias: 'boing', src: 'resources/boing.mp3' },
+ { alias: 'buzzer', src: 'resources/buzzer.mp3' },
+ { alias: 'car', src: 'resources/car.mp3' },
+ { alias: 'chime', src: 'resources/chime.mp3' },
+ { alias: 'success', src: 'resources/success.mp3' },
+ { alias: 'sword', src: 'resources/sword.mp3' },
+ { alias: 'whistle', src: 'resources/whistle.mp3' },
+];
// Add to the PIXI loader
PIXI.Assets.addBundle('demo', manifest);
diff --git a/examples/filters.html b/examples/filters.html
index 70e4ed3..ea0175e 100644
--- a/examples/filters.html
+++ b/examples/filters.html
@@ -12,7 +12,7 @@
Filetypes
- PIXI.Assets.add('applause', 'resources/applause.{ogg,mp3}');
+ PIXI.Assets.add({ alias: 'applause', src: 'resources/applause.{ogg,mp3}' });
PIXI.Assets.load('applause').then(sound => sound.play());Alternatively, if you don't plan to use Assets (typically because you're using a bundler like Parcel or Webpack), but you still would like to resolve multiple files, you can choose from multiple URLs.
@@ -160,7 +160,7 @@ Preloading
- PIXI.Assets.add('bird', 'resources/bird.mp3');
+ PIXI.Assets.add({ alias: 'bird', src: 'resources/bird.mp3' });
PIXI.Assets.load('bird').then(sound => sound.play());
@@ -242,34 +242,35 @@
Utilities
First setup an Application to render the waveform.
waveform.stage.removeChildren();
-
window.waveform = new PIXI.Application({
+ window.waveform = new PIXI.Application();
+window.waveform.init({
width: 1024,
height: 128,
- view: document.getElementById('waveform'),
+ canvas: document.getElementById('waveform'),
backgroundColor: 0xffffff
});
- PIXI.Assets.add('applause', 'resources/applause.mp3');
-PIXI.Assets.load('applause').then(sound => {
- const baseTexture = PIXI.sound.utils.render(sound, {
- width: waveform.renderer.width,
- height: waveform.renderer.height,
- fill: '#999'
- });
- const playhead = new PIXI.Graphics()
- .beginFill(0xff0000)
- .drawRect(0, 0, 1, waveform.renderer.height);
- const sprite = new PIXI.Sprite(
- new PIXI.Texture(baseTexture)
- );
- waveform.stage.addChild(sprite, playhead);
- sound.play().on('progress', function(value) {
- playhead.x = baseTexture.width * value;
- });
-});PIXI.Assets.add({ alias: 'applause', src: 'resources/applause.mp3' });
+const sound = await PIXI.Assets.load('applause');
+const baseTexture = PIXI.sound.utils.render(sound, {
+ width: waveform.renderer.width,
+ height: waveform.renderer.height,
+ fill: '#999'
+});
+const playhead = new PIXI.Graphics()
+ .rect(0, 0, 1, waveform.renderer.height)
+ .fill(0xff0000);
+const sprite = new PIXI.Sprite(
+ new PIXI.Texture(baseTexture)
+);
+waveform.stage.addChild(sprite, playhead);
+sound.play().on('progress', function(value) {
+ playhead.x = baseTexture.width * value;
+});
+Create a simple sine-wave tone.
diff --git a/examples/sprites.html b/examples/sprites.html
index c77e760..4ba60e5 100644
--- a/examples/sprites.html
+++ b/examples/sprites.html
@@ -10,7 +10,7 @@
;
@@ -553,4 +553,4 @@ class SoundLibrary
}
export { SoundLibrary };
-export type { SoundSourceMap, SoundMap };
+export type { SoundMap, SoundSourceMap };
diff --git a/src/SoundSprite.ts b/src/SoundSprite.ts
index 6739d50..c975a1c 100644
--- a/src/SoundSprite.ts
+++ b/src/SoundSprite.ts
@@ -96,7 +96,8 @@ class SoundSprite
speed: this.speed || this.parent.speed,
end: this.end,
start: this.start,
- loop: this.loop });
+ loop: this.loop
+ });
}
/** Destroy and don't use after this */
@@ -106,5 +107,5 @@ class SoundSprite
}
}
-export type { SoundSprites, SoundSpriteData };
+export type { SoundSpriteData, SoundSprites };
export { SoundSprite };
diff --git a/src/browser.ts b/src/browser.ts
index 8233a4f..354179b 100644
--- a/src/browser.ts
+++ b/src/browser.ts
@@ -1,14 +1,15 @@
import {
- sound,
Filterable,
+ filters,
+ htmlaudio,
Sound,
+ sound,
+ soundAsset,
SoundLibrary,
SoundSprite,
- filters,
- htmlaudio,
utils,
- soundAsset,
- webaudio } from './index';
+ webaudio
+} from './index';
Object.defineProperties(sound,
{
diff --git a/src/filters/index.ts b/src/filters/index.ts
index d9ac623..bf3e096 100644
--- a/src/filters/index.ts
+++ b/src/filters/index.ts
@@ -9,11 +9,11 @@
* ];
* @namespace filters
*/
-export * from './Filter';
-export * from './EqualizerFilter';
export * from './DistortionFilter';
-export * from './StereoFilter';
-export * from './ReverbFilter';
+export * from './EqualizerFilter';
+export * from './Filter';
export * from './MonoFilter';
+export * from './ReverbFilter';
+export * from './StereoFilter';
export * from './StreamFilter';
export * from './TelephoneFilter';
diff --git a/src/htmlaudio/HTMLAudioContext.ts b/src/htmlaudio/HTMLAudioContext.ts
index 783e05c..454acb3 100644
--- a/src/htmlaudio/HTMLAudioContext.ts
+++ b/src/htmlaudio/HTMLAudioContext.ts
@@ -1,13 +1,13 @@
-import { utils } from '@pixi/core';
+import { EventEmitter } from 'pixi.js';
import { Filter } from '../filters/Filter';
import { IMediaContext } from '../interfaces/IMediaContext';
/**
* The fallback version of WebAudioContext which uses `` instead of WebAudio API.
* @memberof htmlaudio
- * @extends PIXI.util.EventEmitter
+ * @extends PIXI.EventEmitter
*/
-class HTMLAudioContext extends utils.EventEmitter implements IMediaContext
+class HTMLAudioContext extends EventEmitter implements IMediaContext
{
/** Current global speed from 0 to 1 */
public speed = 1;
diff --git a/src/htmlaudio/HTMLAudioInstance.ts b/src/htmlaudio/HTMLAudioInstance.ts
index 856bb14..0eade48 100644
--- a/src/htmlaudio/HTMLAudioInstance.ts
+++ b/src/htmlaudio/HTMLAudioInstance.ts
@@ -1,17 +1,17 @@
-import { utils, Ticker } from '@pixi/core';
+import { EventEmitter, Ticker } from 'pixi.js';
+import { Filter } from '../filters/Filter';
import { IMediaInstance } from '../interfaces/IMediaInstance';
import { PlayOptions } from '../Sound';
import { HTMLAudioMedia } from './HTMLAudioMedia';
-import { Filter } from '../filters/Filter';
let id = 0;
/**
* Instance which wraps the `` element playback.
* @memberof htmlaudio
- * @extends PIXI.util.EventEmitter
+ * @extends PIXI.EventEmitter
*/
-class HTMLAudioInstance extends utils.EventEmitter implements IMediaInstance
+class HTMLAudioInstance extends EventEmitter implements IMediaInstance
{
/** Extra padding, in seconds, to deal with low-latecy of HTMLAudio. */
public static readonly PADDING: number = 0.1;
diff --git a/src/htmlaudio/HTMLAudioMedia.ts b/src/htmlaudio/HTMLAudioMedia.ts
index 03cf701..a70269e 100644
--- a/src/htmlaudio/HTMLAudioMedia.ts
+++ b/src/htmlaudio/HTMLAudioMedia.ts
@@ -1,4 +1,4 @@
-import { utils } from '@pixi/core';
+import { EventEmitter } from 'pixi.js';
import { Filter } from '../filters/Filter';
import { IMedia } from '../interfaces/IMedia';
import { LoadedCallback, Sound } from '../Sound';
@@ -8,9 +8,9 @@ import { HTMLAudioInstance } from './HTMLAudioInstance';
/**
* The fallback version of Sound which uses `` instead of WebAudio API.
* @memberof htmlaudio
- * @extends PIXI.util.EventEmitter
+ * @extends PIXI.EventEmitter
*/
-class HTMLAudioMedia extends utils.EventEmitter implements IMedia
+class HTMLAudioMedia extends EventEmitter implements IMedia
{
public parent: Sound;
private _source: HTMLAudioElement;
diff --git a/src/htmlaudio/index.ts b/src/htmlaudio/index.ts
index da61690..e776e86 100644
--- a/src/htmlaudio/index.ts
+++ b/src/htmlaudio/index.ts
@@ -2,6 +2,6 @@
* Classes supporting non-WebAudio based browsers.
* @namespace htmlaudio
*/
-export * from './HTMLAudioMedia';
-export * from './HTMLAudioInstance';
export * from './HTMLAudioContext';
+export * from './HTMLAudioInstance';
+export * from './HTMLAudioMedia';
diff --git a/src/index.ts b/src/index.ts
index 41bcb66..c5e4e77 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,23 +1,23 @@
+import * as filters from './filters';
+import * as htmlaudio from './htmlaudio';
import { setInstance } from './instance';
import { SoundLibrary } from './SoundLibrary';
-import * as htmlaudio from './htmlaudio';
-import * as filters from './filters';
-import * as webaudio from './webaudio';
import * as utils from './utils';
+import * as webaudio from './webaudio';
const sound = setInstance(new SoundLibrary());
+export * from './Filterable';
+export * from './filters/Filter';
+export * from './interfaces';
export * from './Sound';
export * from './soundAsset';
export * from './SoundLibrary';
-export * from './Filterable';
-export * from './interfaces';
-export * from './filters/Filter';
export * from './SoundSprite';
export {
- sound,
- htmlaudio,
filters,
- webaudio,
+ htmlaudio,
+ sound,
utils,
+ webaudio,
};
diff --git a/src/instance.ts b/src/instance.ts
index 9173187..92b5aa6 100644
--- a/src/instance.ts
+++ b/src/instance.ts
@@ -26,4 +26,4 @@ function getInstance(): SoundLibrary
return instance;
}
-export { instance, setInstance, getInstance };
+export { getInstance, instance, setInstance };
diff --git a/src/soundAsset.ts b/src/soundAsset.ts
index ee320e0..3e70c18 100644
--- a/src/soundAsset.ts
+++ b/src/soundAsset.ts
@@ -1,15 +1,20 @@
-import { utils, extensions, ExtensionType } from '@pixi/core';
-import { AssetExtension, LoadAsset, LoaderParser, LoaderParserPriority } from '@pixi/assets';
-import { supported, extensions as exts, mimes } from './utils/supported';
-import { Options, Sound } from './Sound';
+import { AssetExtension, extensions, ExtensionType, LoaderParser, LoaderParserPriority, path, ResolvedAsset } from 'pixi.js';
import { getInstance } from './instance';
+import { Options, Sound } from './Sound';
+import { extensions as exts, mimes, supported } from './utils/supported';
/** Get the alias for the sound */
-const getAlias = (asset: LoadAsset) =>
+const getAlias = (asset: ResolvedAsset) =>
{
- const url = asset.src;
+ const src = asset.src;
+ let alias = asset?.alias?.[0];
+
+ if (!alias || asset.src === alias)
+ {
+ alias = path.basename(src, path.extname(src));
+ }
- return (asset as any)?.alias?.[0] ?? utils.path.basename(url, utils.path.extname(url));
+ return alias;
};
/**
@@ -23,6 +28,7 @@ const soundAsset = {
remove: async (formats) => formats.filter((ext) => formats.includes(ext)),
},
loader: {
+ name: 'sound',
extension: {
type: [ExtensionType.LoadParser],
priority: LoaderParserPriority.High,
@@ -31,13 +37,13 @@ const soundAsset = {
/** Should we attempt to load this file? */
test(url: string): boolean
{
- const ext = utils.path.extname(url).slice(1);
+ const ext = path.extname(url).slice(1);
return !!supported[ext] || mimes.some((mime) => url.startsWith(`data:${mime}`));
},
/** Load the sound file, this is mostly handled by Sound.from() */
- async load(url: string, asset: LoadAsset>): Promise
+ async load(url: string, asset: ResolvedAsset>): Promise
{
// We'll use the internal Sound.from to load the asset
const sound = await new Promise((resolve, reject) => Sound.from({
@@ -64,7 +70,7 @@ const soundAsset = {
},
/** Remove the sound from the library */
- async unload(_sound: Sound, asset: LoadAsset): Promise
+ async unload(_sound: Sound, asset: ResolvedAsset): Promise
{
getInstance().remove(getAlias(asset));
},
diff --git a/src/utils/playOnce.ts b/src/utils/playOnce.ts
index cf79aed..032d9fd 100644
--- a/src/utils/playOnce.ts
+++ b/src/utils/playOnce.ts
@@ -47,4 +47,4 @@ function playOnce(url: string, callback?: (err?: Error) => void): string
return alias;
}
-export { playOnce, PLAY_ID };
+export { PLAY_ID, playOnce };
diff --git a/src/utils/render.ts b/src/utils/render.ts
index 76b98da..288de82 100644
--- a/src/utils/render.ts
+++ b/src/utils/render.ts
@@ -1,4 +1,4 @@
-import { BaseTexture } from '@pixi/core';
+import { CanvasSource, ICanvas, TextureSource } from 'pixi.js';
import { Sound } from '../Sound';
import { WebAudioMedia } from '../webaudio/WebAudioMedia';
@@ -28,23 +28,26 @@ interface RenderOptions
* @param options - Custom rendering options
* @return Result texture
*/
-function render(sound: Sound, options?: RenderOptions): BaseTexture
+function render(sound: Sound, options?: RenderOptions): TextureSource
{
const canvas: HTMLCanvasElement = document.createElement('canvas');
options = {
width: 512,
height: 128,
- fill: 'black', ...(options || {}) };
+ fill: 'black', ...(options || {})
+ };
canvas.width = options.width;
canvas.height = options.height;
- const baseTexture = BaseTexture.from(canvas);
+ const textureSource = new CanvasSource({
+ resource: canvas as ICanvas,
+ });
if (!(sound.media instanceof WebAudioMedia))
{
- return baseTexture;
+ return textureSource;
}
const media: WebAudioMedia = sound.media as WebAudioMedia;
@@ -80,8 +83,9 @@ function render(sound: Sound, options?: RenderOptions): BaseTexture
context.fillRect(i, (1 + min) * amp, 1, Math.max(1, (max - min) * amp));
}
- return baseTexture;
+ return textureSource;
}
-export type { RenderOptions };
export { render };
+export type { RenderOptions };
+
diff --git a/src/utils/sineTone.ts b/src/utils/sineTone.ts
index efeaf37..dc1681f 100644
--- a/src/utils/sineTone.ts
+++ b/src/utils/sineTone.ts
@@ -1,6 +1,6 @@
import { Sound } from '../Sound';
-import { WebAudioMedia } from '../webaudio/WebAudioMedia';
import { WebAudioContext } from '../webaudio/WebAudioContext';
+import { WebAudioMedia } from '../webaudio/WebAudioMedia';
/**
* Create a new sound for a sine wave-based tone. **Only supported with WebAudio**
@@ -39,7 +39,7 @@ function sineTone(hertz = 200, seconds = 1): Sound
// fill the buffer
for (let i = 0; i < fArray.length; i++)
{
- const time = i / buffer.sampleRate;
+ const time = i / buffer.sampleRate;
const angle = hertz * time * 2 * Math.PI;
fArray[i] = Math.sin(angle) * amplitude;
diff --git a/src/utils/supported.ts b/src/utils/supported.ts
index 2e5cdcf..79c3ab6 100644
--- a/src/utils/supported.ts
+++ b/src/utils/supported.ts
@@ -58,7 +58,8 @@ function validateFormats(typeOverrides?: Record): void
m4a: 'audio/mp4',
oga: 'audio/ogg',
opus: 'audio/ogg; codecs="opus"',
- caf: 'audio/x-caf; codecs="opus"', ...(typeOverrides || {}) };
+ caf: 'audio/x-caf; codecs="opus"', ...(typeOverrides || {})
+ };
const audio = document.createElement('audio');
const formats: ExtensionMap = {};
const no = /^no$/;
@@ -77,8 +78,8 @@ function validateFormats(typeOverrides?: Record): void
validateFormats();
export {
- validateFormats,
- supported,
extensions,
mimes,
+ supported,
+ validateFormats,
};
diff --git a/src/webaudio/WebAudioContext.ts b/src/webaudio/WebAudioContext.ts
index 79e8966..3406dd6 100644
--- a/src/webaudio/WebAudioContext.ts
+++ b/src/webaudio/WebAudioContext.ts
@@ -1,4 +1,4 @@
-import { utils } from '@pixi/core';
+import { EventEmitter } from 'pixi.js';
import { Filterable } from '../Filterable';
import { IMediaContext } from '../interfaces';
@@ -42,9 +42,9 @@ class WebAudioContext extends Filterable implements IMediaContext
/**
* Handle global events
- * @type {PIXI.utils.EventEmitter}
+ * @type {PIXI.EventEmitter}
*/
- public events: utils.EventEmitter;
+ public events: EventEmitter;
/** The instance of the AudioContext for WebAudio API. */
private _ctx: AudioContext;
@@ -92,7 +92,7 @@ class WebAudioContext extends Filterable implements IMediaContext
this.compressor = compressor;
this.analyser = analyser;
- this.events = new utils.EventEmitter();
+ this.events = new EventEmitter();
// Set the defaults
this.volume = 1;
diff --git a/src/webaudio/WebAudioInstance.ts b/src/webaudio/WebAudioInstance.ts
index 2fc0cd8..b8f1fbb 100644
--- a/src/webaudio/WebAudioInstance.ts
+++ b/src/webaudio/WebAudioInstance.ts
@@ -1,18 +1,18 @@
-import { utils, Ticker } from '@pixi/core';
+import { EventEmitter, Ticker } from 'pixi.js';
+import { Filter } from '../filters/Filter';
import { IMediaInstance } from '../interfaces';
import { PlayOptions } from '../Sound';
import { WebAudioMedia } from './WebAudioMedia';
import { WebAudioUtils } from './WebAudioUtils';
-import { Filter } from '../filters/Filter';
let id = 0;
/**
* A single play instance that handles the AudioBufferSourceNode.
* @memberof webaudio
- * @extends PIXI.utils.EventEmitter
+ * @extends PIXI.EventEmitter
*/
-class WebAudioInstance extends utils.EventEmitter implements IMediaInstance
+class WebAudioInstance extends EventEmitter implements IMediaInstance
{
/**
* The current unique ID for this instance.
diff --git a/src/webaudio/WebAudioMedia.ts b/src/webaudio/WebAudioMedia.ts
index b239ad3..e848c45 100644
--- a/src/webaudio/WebAudioMedia.ts
+++ b/src/webaudio/WebAudioMedia.ts
@@ -1,4 +1,4 @@
-import { settings } from '@pixi/core';
+import { DOMAdapter } from 'pixi.js';
import { Filter } from '../filters/Filter';
import { IMedia } from '../interfaces/IMedia';
import { LoadedCallback, Sound } from '../Sound';
@@ -141,7 +141,7 @@ class WebAudioMedia implements IMedia
private async _loadUrl(callback?: LoadedCallback): Promise
{
const url: string = this.parent.url;
- const response = await settings.ADAPTER.fetch(url);
+ const response = await DOMAdapter.get().fetch(url);
this._decode(await response.arrayBuffer(), callback);
}
diff --git a/src/webaudio/index.ts b/src/webaudio/index.ts
index c7a4d37..cbda5af 100644
--- a/src/webaudio/index.ts
+++ b/src/webaudio/index.ts
@@ -2,8 +2,8 @@
* Classes supporting non-WebAudio based browsers.
* @namespace webaudio
*/
-export * from './WebAudioMedia';
+export * from './WebAudioContext';
export * from './WebAudioInstance';
+export * from './WebAudioMedia';
export * from './WebAudioNodes';
-export * from './WebAudioContext';
export * from './WebAudioUtils';
diff --git a/test/htmlaudio.test.ts b/test/htmlaudio.test.ts
new file mode 100644
index 0000000..4180f51
--- /dev/null
+++ b/test/htmlaudio.test.ts
@@ -0,0 +1,3 @@
+import { suite } from './suite';
+
+suite(true);
diff --git a/test/index.test.ts b/test/index.test.ts
index 4c43a7c..153f956 100644
--- a/test/index.test.ts
+++ b/test/index.test.ts
@@ -1,494 +1,21 @@
-import { Assets } from 'pixi.js';
-import { sound, Sound, utils, webaudio, htmlaudio, filters, SoundLibrary, IMediaInstance } from '../src';
-import { dataUrlMp3, dataUrlOgg } from './resources/dataUrlResources';
-import path from 'path';
+import { filters, htmlaudio, Sound, sound, SoundLibrary, utils, webaudio } from '../src';
-declare global
+describe('SoundLibrary', () =>
{
- var __resources: string;
-}
-
-// Global reference to the resources
-window.__resources = path.join(__dirname, 'resources');
-
-const manifest: Record = {
- 'alert-4': path.join(__resources, 'alert-4.mp3'),
- 'alert-7': path.join(__resources, 'alert-7.mp3'),
- 'alert-12': path.join(__resources, 'alert-12.mp3'),
- 'musical-11': path.join(__resources, 'musical-11.mp3'),
- 'alert-4-ogg': path.join(__resources, 'alert-4.ogg'),
- silence: path.join(__resources, 'silence.mp3'),
- dataUrlMp3,
- dataUrlOgg
-};
-
-// Import the library
-export function suite(useLegacy = false): void
-{
- const suffix = useLegacy ? ' (legacy)' : '';
-
- describe(`SoundLibrary${suffix}`, () =>
+ it('should have the correct classes', () =>
{
- beforeAll(async () =>
- {
- // Set the legacy
- sound.useLegacy = !!useLegacy;
- });
-
- afterAll(() =>
- {
- sound.removeAll();
- });
-
- afterEach(() =>
- {
- (Sound as any)._pool.length = 0;
- });
-
- it('should have the correct classes', () =>
- {
- expect(typeof sound).toBe('object');
- expect(typeof Sound).toBe('function');
- expect(typeof utils).toBe('object');
- expect(typeof webaudio).toBe('object');
- expect(typeof htmlaudio).toBe('object');
- expect(typeof SoundLibrary).toBe('function');
- expect(typeof filters).toBe('object');
- expect(typeof filters.DistortionFilter).toBe('function');
- expect(typeof filters.EqualizerFilter).toBe('function');
- expect(typeof filters.ReverbFilter).toBe('function');
- expect(typeof filters.StereoFilter).toBe('function');
- expect(typeof filters.StreamFilter).toBe('function');
- expect(sound).toBeInstanceOf(SoundLibrary);
- });
-
- it('should recreate the library', () =>
- {
- sound.close().init();
- sound.useLegacy = !!useLegacy;
- });
-
- it('should load a manifest', function (done)
- {
- let counter = 0;
- const results = sound.add(manifest, {
- preload: true,
- loaded: (_err, s) =>
- {
- expect(s?.isLoaded).toBe(true);
- expect(s?.isPlayable).toBe(true);
- expect(s?.autoPlay).toBe(false);
- expect(s?.loop).toBe(false);
- expect(s?.preload).toBe(true);
- expect(s).toBeInstanceOf(Sound);
- counter++;
- if (counter === Object.keys(manifest).length)
- {
- done();
- }
- },
- });
-
- expect(typeof results).toBe('object');
- expect(results['alert-4']).toBeInstanceOf(Sound);
- expect(results['alert-7']).toBeInstanceOf(Sound);
- expect(results['alert-12']).toBeInstanceOf(Sound);
- expect(results['musical-11']).toBeInstanceOf(Sound);
- expect(results['alert-4-ogg']).toBeInstanceOf(Sound);
- expect(results.silence).toBeInstanceOf(Sound);
- expect(results.dataUrlMp3).toBeInstanceOf(Sound);
- expect(results.dataUrlOgg).toBeInstanceOf(Sound);
- });
-
- it('should get a reference by alias', () =>
- {
- const s = sound.find('alert-7');
-
- expect(s).toBeDefined();
- expect(s).toBeInstanceOf(Sound);
- });
-
- it('should play multiple at once', () =>
- {
- const s = sound.find('alert-12');
-
- s.play();
- s.play();
- s.play();
- s.play();
- expect(s.instances.length).toBe(4);
- s.stop();
- expect(s.instances.length).toBe(0);
- });
-
- it('should play with blocking', () =>
- {
- const s = sound.find('alert-4');
-
- s.singleInstance = true;
- s.play();
- s.play();
- s.play();
- s.play();
- expect(s.instances.length).toBe(1);
- s.stop();
- expect(s.instances.length).toBe(0);
- s.singleInstance = false;
- });
-
- it('should play with stopping single instance', () =>
- {
- const s = sound.find('alert-4');
-
- s.play();
- s.play();
- s.play();
- const instance = s.play() as IMediaInstance;
-
- instance.stop();
- expect(s.instances.length).toBe(3);
- s.stop();
- expect(s.instances.length).toBe(0);
- });
-
- it('should play with single instance param', () =>
- {
- const s = sound.find('alert-4');
-
- s.play();
- s.play();
- s.play();
- expect(s.instances.length).toBe(3);
- s.play({ singleInstance: true });
- expect(s.instances.length).toBe(1);
- s.stop();
- expect(s.instances.length).toBe(0);
- });
-
- it('should support volume change when instance is paused', function (done)
- {
- const s = sound.find('alert-4');
- const i = s.play({ volume: 0 }) as IMediaInstance;
-
- setTimeout(() =>
- {
- i.paused = true;
- i.volume = 0.2;
- done();
- }, 100);
- });
-
- it('should play a sound by alias', function (done)
- {
- sound.play('silence', {
- complete()
- {
- done();
- },
- });
- });
-
- it('should check to see if a file is playing', function (done)
- {
- sound.stopAll();
- expect(sound.isPlaying()).toBe(false);
- sound.play('silence', {
- complete()
- {
- sound.stopAll();
- expect(sound.isPlaying()).toBe(false);
- done();
- }
- });
- expect(sound.isPlaying()).toBe(true);
- });
-
- it('should remove all sounds', () =>
- {
- sound.removeAll();
- expect(Object.keys((sound as any)._sounds).length).toBe(0);
- });
-
- it('should load a sound file', function (done)
- {
- const alias = 'silence';
- const s = sound.add(alias, {
- url: manifest[alias],
- volume: 0,
- preload: true,
- loaded: (err, instance) =>
- {
- expect(err).toBe(null);
- expect(instance).toBe(s);
- expect(instance?.isPlayable).toBe(true);
- expect(sound.exists(alias)).toBe(true);
- sound.remove(alias);
- expect(sound.exists(alias)).toBe(false);
- done();
- },
- });
-
- expect(s.isLoaded).toBe(false);
- expect(s.isPlayable).toBe(false);
- });
-
- it('should play a file', function (done)
- {
- const alias = 'silence';
- const s = sound.add(alias, {
- url: manifest[alias],
- preload: true,
- loaded: () =>
- {
- expect(sound.volume(alias)).toBe(1);
- sound.volume(alias, 0);
- expect(sound.volume(alias)).toBe(0);
- expect(s.volume).toBe(0);
-
- const instance = sound.play(alias, () =>
- {
- expect(instance.progress).toBe(1);
- sound.remove(alias);
- done();
- }) as IMediaInstance;
-
- expect(instance.progress).toBe(0);
-
- // Pause
- sound.pause(alias);
- expect(s.isPlaying).toBe(false);
-
- // Resume
- sound.resume(alias);
- expect(s.isPlaying).toBe(true);
- },
- });
- });
-
- it('sound play once a file', (done) =>
- {
- const alias = utils.playOnce(manifest.silence, (err) =>
- {
- expect(alias).toBeDefined();
- expect(sound.exists(alias)).toBe(false);
- expect(err).toBe(null);
- done();
- });
- });
-
- if (!useLegacy)
- {
- it('should play a sine tone', (done) =>
- {
- const s = utils.sineTone(200, 0.1);
-
- s.volume = 0;
- s.play(() =>
- {
- done?.();
- });
- expect(s.isPlaying);
- });
- }
-
- it('should setup sprites', () =>
- {
- const alias = 'musical-11';
- const s = sound.add(alias, {
- url: manifest[alias],
- sprites: {
- foo: {
- start: 0,
- end: 2,
- },
- bar: {
- start: 3,
- end: 5,
- },
- },
- });
-
- expect(Object.keys(s.sprites).length).toBe(2);
- expect(s.sprites.foo.start).toBe(0);
- expect(s.sprites.foo.end).toBe(2);
- expect(s.sprites.foo.duration).toBe(2);
- expect(s.sprites.bar.start).toBe(3);
- expect(s.sprites.bar.end).toBe(5);
- expect(s.sprites.bar.duration).toBe(2);
- expect(s.sprites.foo.parent).toBe(s);
- expect(s.sprites.bar.parent).toBe(s);
- });
-
- if (!useLegacy)
- {
- it('should take AudioBuffer as source', (done) =>
- {
- const s = utils.sineTone(200, 0.1);
- const buffer = (s.media as any).buffer as AudioBuffer;
-
- expect(buffer).toBeInstanceOf(AudioBuffer);
-
- const snd = Sound.from(buffer);
-
- snd.volume = 0;
- snd.play(() =>
- {
- done?.();
- });
- expect(snd.duration).toBe(0.1);
- expect(snd.isPlaying).toBe(true);
-
- expect(sound.add('sine', buffer)).toBeInstanceOf(Sound);
- });
- }
+ expect(typeof sound).toBe('object');
+ expect(typeof Sound).toBe('function');
+ expect(typeof utils).toBe('object');
+ expect(typeof webaudio).toBe('object');
+ expect(typeof htmlaudio).toBe('object');
+ expect(typeof SoundLibrary).toBe('function');
+ expect(typeof filters).toBe('object');
+ expect(typeof filters.DistortionFilter).toBe('function');
+ expect(typeof filters.EqualizerFilter).toBe('function');
+ expect(typeof filters.ReverbFilter).toBe('function');
+ expect(typeof filters.StereoFilter).toBe('function');
+ expect(typeof filters.StreamFilter).toBe('function');
+ expect(sound).toBeInstanceOf(SoundLibrary);
});
-
- if (!useLegacy)
- {
- describe(`filters.DistortionFilter${suffix}`, () =>
- {
- it('should create a DistortionFilter', () =>
- {
- const filter = new filters.DistortionFilter(0.5);
-
- expect(filter.amount).toBe(0.5);
- });
- });
- }
-
- describe(`SoundInstance${suffix}`, () =>
- {
- afterEach(() =>
- {
- sound.removeAll();
- });
-
- it('should return Promise for playing unloaded sound', function (done)
- {
- const SoundInstance = useLegacy
- ? htmlaudio.HTMLAudioInstance
- : webaudio.WebAudioInstance;
- const s = Sound.from(manifest.silence);
-
- expect(s).toBeInstanceOf(Sound);
- const promise = s.play() as Promise;
-
- promise.then((instance) =>
- {
- expect(instance).toBeInstanceOf(SoundInstance);
- done();
- });
- expect(promise).toBeInstanceOf(Promise);
- });
-
- it('should return instance for playing loaded sound', function (done)
- {
- const SoundInstance = useLegacy
- ? htmlaudio.HTMLAudioInstance
- : webaudio.WebAudioInstance;
- const s = Sound.from({
- url: manifest.silence,
- preload: true,
- loaded: (err) =>
- {
- expect(err).toBe(null);
- expect(s.isLoaded).toBe(true);
- expect(s.isPlayable).toBe(true);
- const instance = s.play();
-
- expect(instance).toBeInstanceOf(SoundInstance);
- done();
- },
- });
- });
-
- it('should apply filters for sound instance', function (done)
- {
- Sound.from({
- url: manifest.silence,
- preload: true,
- loaded: (err, snd) =>
- {
- expect(err).toBe(null);
-
- const filter = new filters.TelephoneFilter();
- const instance = snd?.play({
- filters: [filter],
- });
- const instance2 = snd?.play();
-
- if (useLegacy)
- {
- expect((instance as any).filters).toBe(null);
- expect((instance2 as any).filters).toBe(null);
- }
- else
- {
- expect(instance).toBeInstanceOf(webaudio.WebAudioInstance);
- expect(instance2).toBeInstanceOf(webaudio.WebAudioInstance);
- expect((instance as webaudio.WebAudioInstance).filters).toBeInstanceOf(Array);
- expect((instance as webaudio.WebAudioInstance).filters.length).toBe(1);
- expect((instance as webaudio.WebAudioInstance).filters[0]).toBe(filter);
- expect((instance as webaudio.WebAudioInstance).progress).toBeLessThan(1);
- (instance as webaudio.WebAudioInstance).filters = null as any;
- expect((instance as webaudio.WebAudioInstance).filters).toBe(null);
- expect((instance as webaudio.WebAudioInstance).progress).toBeLessThan(1);
- expect((instance2 as webaudio.WebAudioInstance).filters).toBeUndefined();
- (instance2 as webaudio.WebAudioInstance).destroy();
- expect((instance2 as webaudio.WebAudioInstance).filters).toBe(null);
- }
- done();
- }
- });
- });
- });
-
- describe(`soundAsset${suffix}`, () =>
- {
- beforeAll(async () =>
- {
- await Assets.init({ basePath: window.__resources });
- });
-
- afterEach(() =>
- {
- sound.removeAll();
- });
-
- it('should load files with Assets', async () =>
- {
- for (const name in manifest)
- {
- Assets.add(name, manifest[name]);
- const s = await Assets.load(name);
- const ClassRef = useLegacy
- ? htmlaudio.HTMLAudioMedia
- : webaudio.WebAudioMedia;
-
- expect(s.media).toBeInstanceOf(ClassRef);
- expect(s).toBeInstanceOf(Sound);
- expect(s.isLoaded).toBe(true);
- expect(s.isPlayable).toBe(true);
- await Assets.unload(name);
- }
- });
-
- it('should load an asset without alias', async () =>
- {
- const s = await Assets.load(manifest.silence);
- const ClassRef = useLegacy
- ? htmlaudio.HTMLAudioMedia
- : webaudio.WebAudioMedia;
-
- expect(sound.find('silence')).toBe(s);
- expect(s.media).toBeInstanceOf(ClassRef);
- expect(s).toBeInstanceOf(Sound);
- expect(s.isLoaded).toBe(true);
- expect(s.isPlayable).toBe(true);
- await Assets.unload(manifest.silence);
- });
- });
-}
-
-suite(false);
-suite(true);
+});
diff --git a/test/suite.ts b/test/suite.ts
new file mode 100644
index 0000000..309c1ba
--- /dev/null
+++ b/test/suite.ts
@@ -0,0 +1,475 @@
+import path from 'path';
+import { Assets } from 'pixi.js';
+import { filters, htmlaudio, IMediaInstance, Sound, sound, utils, webaudio } from '../src';
+import { dataUrlMp3, dataUrlOgg } from './resources/dataUrlResources';
+
+declare global
+{
+ var __resources: string;
+}
+
+// Global reference to the resources
+window.__resources = path.join(__dirname, 'resources');
+
+const manifest: Record = {
+ 'alert-4': path.join(__resources, 'alert-4.mp3'),
+ 'alert-7': path.join(__resources, 'alert-7.mp3'),
+ 'alert-12': path.join(__resources, 'alert-12.mp3'),
+ 'musical-11': path.join(__resources, 'musical-11.mp3'),
+ 'alert-4-ogg': path.join(__resources, 'alert-4.ogg'),
+ silence: path.join(__resources, 'silence.mp3'),
+ dataUrlMp3,
+ dataUrlOgg
+};
+
+// Import the library
+function suite(useLegacy = false): void
+{
+ const suffix = useLegacy ? ' (htmlaudio)' : ' (webaudio)';
+
+ describe(`SoundLibrary${suffix}`, () =>
+ {
+ beforeAll(async () =>
+ {
+ // Set the legacy
+ sound.useLegacy = !!useLegacy;
+ });
+
+ afterAll(() =>
+ {
+ sound.removeAll();
+ });
+
+ afterEach(() =>
+ {
+ (Sound as any)._pool.length = 0;
+ });
+
+ it('should recreate the library', () =>
+ {
+ sound.close().init();
+ sound.useLegacy = !!useLegacy;
+ });
+
+ it('should load a manifest', function (done)
+ {
+ let counter = 0;
+ const results = sound.add(manifest, {
+ preload: true,
+ loaded: (_err, s) =>
+ {
+ expect(s?.isLoaded).toBe(true);
+ expect(s?.isPlayable).toBe(true);
+ expect(s?.autoPlay).toBe(false);
+ expect(s?.loop).toBe(false);
+ expect(s?.preload).toBe(true);
+ expect(s).toBeInstanceOf(Sound);
+ counter++;
+ if (counter === Object.keys(manifest).length)
+ {
+ done();
+ }
+ },
+ });
+
+ expect(typeof results).toBe('object');
+ expect(results['alert-4']).toBeInstanceOf(Sound);
+ expect(results['alert-7']).toBeInstanceOf(Sound);
+ expect(results['alert-12']).toBeInstanceOf(Sound);
+ expect(results['musical-11']).toBeInstanceOf(Sound);
+ expect(results['alert-4-ogg']).toBeInstanceOf(Sound);
+ expect(results.silence).toBeInstanceOf(Sound);
+ expect(results.dataUrlMp3).toBeInstanceOf(Sound);
+ expect(results.dataUrlOgg).toBeInstanceOf(Sound);
+ });
+
+ it('should get a reference by alias', () =>
+ {
+ const s = sound.find('alert-7');
+
+ expect(s).toBeDefined();
+ expect(s).toBeInstanceOf(Sound);
+ });
+
+ it('should play multiple at once', () =>
+ {
+ const s = sound.find('alert-12');
+
+ s.play();
+ s.play();
+ s.play();
+ s.play();
+ expect(s.instances.length).toBe(4);
+ s.stop();
+ expect(s.instances.length).toBe(0);
+ });
+
+ it('should play with blocking', () =>
+ {
+ const s = sound.find('alert-4');
+
+ s.singleInstance = true;
+ s.play();
+ s.play();
+ s.play();
+ s.play();
+ expect(s.instances.length).toBe(1);
+ s.stop();
+ expect(s.instances.length).toBe(0);
+ s.singleInstance = false;
+ });
+
+ it('should play with stopping single instance', () =>
+ {
+ const s = sound.find('alert-4');
+
+ s.play();
+ s.play();
+ s.play();
+ const instance = s.play() as IMediaInstance;
+
+ instance.stop();
+ expect(s.instances.length).toBe(3);
+ s.stop();
+ expect(s.instances.length).toBe(0);
+ });
+
+ it('should play with single instance param', () =>
+ {
+ const s = sound.find('alert-4');
+
+ s.play();
+ s.play();
+ s.play();
+ expect(s.instances.length).toBe(3);
+ s.play({ singleInstance: true });
+ expect(s.instances.length).toBe(1);
+ s.stop();
+ expect(s.instances.length).toBe(0);
+ });
+
+ it('should support volume change when instance is paused', function (done)
+ {
+ const s = sound.find('alert-4');
+ const i = s.play({ volume: 0 }) as IMediaInstance;
+
+ setTimeout(() =>
+ {
+ i.paused = true;
+ i.volume = 0.2;
+ done();
+ }, 100);
+ });
+
+ it('should play a sound by alias', function (done)
+ {
+ sound.play('silence', {
+ complete()
+ {
+ done();
+ },
+ });
+ });
+
+ it('should check to see if a file is playing', function (done)
+ {
+ sound.stopAll();
+ expect(sound.isPlaying()).toBe(false);
+ sound.play('silence', {
+ complete()
+ {
+ sound.stopAll();
+ expect(sound.isPlaying()).toBe(false);
+ done();
+ }
+ });
+ expect(sound.isPlaying()).toBe(true);
+ });
+
+ it('should remove all sounds', () =>
+ {
+ sound.removeAll();
+ expect(Object.keys((sound as any)._sounds).length).toBe(0);
+ });
+
+ it('should load a sound file', function (done)
+ {
+ const alias = 'silence';
+ const s = sound.add(alias, {
+ url: manifest[alias],
+ volume: 0,
+ preload: true,
+ loaded: (err, instance) =>
+ {
+ expect(err).toBe(null);
+ expect(instance).toBe(s);
+ expect(instance?.isPlayable).toBe(true);
+ expect(sound.exists(alias)).toBe(true);
+ sound.remove(alias);
+ expect(sound.exists(alias)).toBe(false);
+ done();
+ },
+ });
+
+ expect(s.isLoaded).toBe(false);
+ expect(s.isPlayable).toBe(false);
+ });
+
+ it('should play a file', function (done)
+ {
+ const alias = 'silence';
+ const s = sound.add(alias, {
+ url: manifest[alias],
+ preload: true,
+ loaded: () =>
+ {
+ expect(sound.volume(alias)).toBe(1);
+ sound.volume(alias, 0);
+ expect(sound.volume(alias)).toBe(0);
+ expect(s.volume).toBe(0);
+
+ const instance = sound.play(alias, () =>
+ {
+ expect(instance.progress).toBe(1);
+ sound.remove(alias);
+ done();
+ }) as IMediaInstance;
+
+ expect(instance.progress).toBe(0);
+
+ // Pause
+ sound.pause(alias);
+ expect(s.isPlaying).toBe(false);
+
+ // Resume
+ sound.resume(alias);
+ expect(s.isPlaying).toBe(true);
+ },
+ });
+ });
+
+ it('sound play once a file', (done) =>
+ {
+ const alias = utils.playOnce(manifest.silence, (err) =>
+ {
+ expect(alias).toBeDefined();
+ expect(sound.exists(alias)).toBe(false);
+ expect(err).toBe(null);
+ done();
+ });
+ });
+
+ if (!useLegacy)
+ {
+ it('should play a sine tone', (done) =>
+ {
+ const s = utils.sineTone(200, 0.1);
+
+ s.volume = 0;
+ s.play(() =>
+ {
+ done?.();
+ });
+ expect(s.isPlaying);
+ });
+ }
+
+ it('should setup sprites', () =>
+ {
+ const alias = 'musical-11';
+ const s = sound.add(alias, {
+ url: manifest[alias],
+ sprites: {
+ foo: {
+ start: 0,
+ end: 2,
+ },
+ bar: {
+ start: 3,
+ end: 5,
+ },
+ },
+ });
+
+ expect(Object.keys(s.sprites).length).toBe(2);
+ expect(s.sprites.foo.start).toBe(0);
+ expect(s.sprites.foo.end).toBe(2);
+ expect(s.sprites.foo.duration).toBe(2);
+ expect(s.sprites.bar.start).toBe(3);
+ expect(s.sprites.bar.end).toBe(5);
+ expect(s.sprites.bar.duration).toBe(2);
+ expect(s.sprites.foo.parent).toBe(s);
+ expect(s.sprites.bar.parent).toBe(s);
+ });
+
+ if (!useLegacy)
+ {
+ it('should take AudioBuffer as source', (done) =>
+ {
+ const s = utils.sineTone(200, 0.1);
+ const buffer = (s.media as any).buffer as AudioBuffer;
+
+ expect(buffer).toBeInstanceOf(AudioBuffer);
+
+ const snd = Sound.from(buffer);
+
+ snd.volume = 0;
+ snd.play(() =>
+ {
+ done?.();
+ });
+ expect(snd.duration).toBe(0.1);
+ expect(snd.isPlaying).toBe(true);
+
+ expect(sound.add('sine', buffer)).toBeInstanceOf(Sound);
+ });
+ }
+ });
+
+ describe(`SoundInstance${suffix}`, () =>
+ {
+ afterEach(() =>
+ {
+ sound.removeAll();
+ });
+
+ it('should return Promise for playing unloaded sound', function (done)
+ {
+ const SoundInstance = useLegacy
+ ? htmlaudio.HTMLAudioInstance
+ : webaudio.WebAudioInstance;
+ const s = Sound.from(manifest.silence);
+
+ expect(s).toBeInstanceOf(Sound);
+ const promise = s.play() as Promise;
+
+ promise.then((instance) =>
+ {
+ expect(instance).toBeInstanceOf(SoundInstance);
+ done();
+ });
+ expect(promise).toBeInstanceOf(Promise);
+ });
+
+ it('should return instance for playing loaded sound', function (done)
+ {
+ const SoundInstance = useLegacy
+ ? htmlaudio.HTMLAudioInstance
+ : webaudio.WebAudioInstance;
+ const s = Sound.from({
+ url: manifest.silence,
+ preload: true,
+ loaded: (err) =>
+ {
+ expect(err).toBe(null);
+ expect(s.isLoaded).toBe(true);
+ expect(s.isPlayable).toBe(true);
+ const instance = s.play();
+
+ expect(instance).toBeInstanceOf(SoundInstance);
+ done();
+ },
+ });
+ });
+
+ it('should apply filters for sound instance', function (done)
+ {
+ Sound.from({
+ url: manifest.silence,
+ preload: true,
+ loaded: (err, snd) =>
+ {
+ expect(err).toBe(null);
+
+ const filter = new filters.TelephoneFilter();
+ const instance = snd?.play({
+ filters: [filter],
+ });
+ const instance2 = snd?.play();
+
+ if (useLegacy)
+ {
+ const spy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+ expect((instance as any).filters).toBe(null);
+ expect((instance2 as any).filters).toBe(null);
+ spy.mockRestore();
+ }
+ else
+ {
+ expect(instance).toBeInstanceOf(webaudio.WebAudioInstance);
+ expect(instance2).toBeInstanceOf(webaudio.WebAudioInstance);
+ expect((instance as webaudio.WebAudioInstance).filters).toBeInstanceOf(Array);
+ expect((instance as webaudio.WebAudioInstance).filters.length).toBe(1);
+ expect((instance as webaudio.WebAudioInstance).filters[0]).toBe(filter);
+ expect((instance as webaudio.WebAudioInstance).progress).toBeLessThan(1);
+ (instance as webaudio.WebAudioInstance).filters = null as any;
+ expect((instance as webaudio.WebAudioInstance).filters).toBe(null);
+ expect((instance as webaudio.WebAudioInstance).progress).toBeLessThan(1);
+ expect((instance2 as webaudio.WebAudioInstance).filters).toBeUndefined();
+ (instance2 as webaudio.WebAudioInstance).destroy();
+ expect((instance2 as webaudio.WebAudioInstance).filters).toBe(null);
+ }
+ done();
+ }
+ });
+ });
+ });
+
+ // Currently this isn't working, probably because of Workers
+ describe(`soundAsset${suffix}`, () =>
+ {
+ beforeAll(async () =>
+ {
+ await Assets.init({ basePath: window.__resources });
+ });
+
+ afterEach(() =>
+ {
+ sound.removeAll();
+ });
+
+ it('should load files with Assets', async () =>
+ {
+ for (const name in manifest)
+ {
+ expect(sound.exists(name)).toBe(false);
+
+ Assets.add({ alias: name, src: manifest[name] });
+ const s = await Assets.load(name);
+ const ClassRef = useLegacy
+ ? htmlaudio.HTMLAudioMedia
+ : webaudio.WebAudioMedia;
+
+ expect(sound.exists(name)).toBe(true);
+ expect(sound.find(name)).toBe(s);
+ expect(s.media).toBeInstanceOf(ClassRef);
+ expect(s).toBeInstanceOf(Sound);
+ expect(s.isLoaded).toBe(true);
+ expect(s.isPlayable).toBe(true);
+ await Assets.unload(name);
+ expect(sound.exists(name)).toBe(false);
+ }
+ });
+
+ it('should load an asset without alias', async () =>
+ {
+ expect(sound.exists('silence')).toBe(false);
+
+ const s = await Assets.load(manifest.silence);
+ const ClassRef = useLegacy
+ ? htmlaudio.HTMLAudioMedia
+ : webaudio.WebAudioMedia;
+
+ expect(sound.exists('silence')).toBe(true);
+ expect(sound.find('silence')).toBe(s);
+ expect(s.media).toBeInstanceOf(ClassRef);
+ expect(s).toBeInstanceOf(Sound);
+ expect(s.isLoaded).toBe(true);
+ expect(s.isPlayable).toBe(true);
+ await Assets.unload(manifest.silence);
+ expect(sound.exists('silence')).toBe(false);
+ });
+ });
+}
+
+export { suite };
diff --git a/test/webaudio.test.ts b/test/webaudio.test.ts
new file mode 100644
index 0000000..e8d54bf
--- /dev/null
+++ b/test/webaudio.test.ts
@@ -0,0 +1,14 @@
+import { suite } from './suite';
+import { filters } from '../src';
+
+suite(false);
+
+describe(`filters.DistortionFilter`, () =>
+{
+ it('should create a DistortionFilter', () =>
+ {
+ const filter = new filters.DistortionFilter(0.5);
+
+ expect(filter.amount).toBe(0.5);
+ });
+});
\ No newline at end of file
diff --git a/tsconfig.json b/tsconfig.json
index 0dfecb1..cf96acf 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,5 +1,5 @@
{
- "extends": "@pixi/extension-scripts/lib/configs/tsconfig.json",
+ "extends": "@pixi/extension-scripts/tsconfig",
"compilerOptions": {
"strict": false,
"noImplicitThis": true,
@@ -10,7 +10,8 @@
"preserveConstEnums": true,
"noFallthroughCasesInSwitch": true,
"noImplicitReturns": true,
- "noUncheckedIndexedAccess": true
+ "noUncheckedIndexedAccess": true,
+ "skipLibCheck": true
},
"include": [
"src/**/*"
Sound Demo<