@jswork/howler-audio-manager 0.0.0-stage → 1.0.2

package/dist/index.cjs.js

@@ -0,0 +1,747 @@
+"use strict";
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+        return Array.from(iter);
+    }
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _nullishCoalesce(lhs, rhsFn) {
+    if (lhs != null) {
+        return lhs;
+    } else {
+        return rhsFn();
+    }
+}
+function _optionalChain(ops) {
+    var lastAccessLHS = undefined;
+    var value = ops[0];
+    var i = 1;
+    while(i < ops.length){
+        var op = ops[i];
+        var fn = ops[i + 1];
+        i += 2;
+        if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {
+            return undefined;
+        }
+        if (op === 'access' || op === 'optionalAccess') {
+            lastAccessLHS = value;
+            value = fn(value);
+        } else if (op === 'call' || op === 'optionalCall') {
+            var _value;
+            value = fn(function() {
+                for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                    args[_key] = arguments[_key];
+                }
+                return (_value = value).call.apply(_value, [
+                    lastAccessLHS
+                ].concat(_to_consumable_array(args)));
+            });
+            lastAccessLHS = undefined;
+        }
+    }
+    return value;
+} /*!
+ * name: @jswork/howler-audio-manager
+ * description: Howler.js audio manager, enum-driven sounds for H5.
+ * homepage: https://js.work
+ * version: 1.0.2
+ * date: 2026-10-20 20:03:06
+ * license: MIT
+ */ 
+// src/manager.ts
+var _howler = require('howler');
+var AudioManager = /*#__PURE__*/ function() {
+    function AudioManager(options, inject) {
+        _class_call_check(this, AudioManager);
+        this.effectCache = /* @__PURE__ */ new Map();
+        this.urlAudioCache = /* @__PURE__ */ new Map();
+        this.preloadPromises = /* @__PURE__ */ new Map();
+        this.activeUrlHowl = null;
+        this.globalVolume = 1;
+        this.listeners = /* @__PURE__ */ new Map();
+        this.HowlConstructor = _nullishCoalesce(_optionalChain([
+            inject,
+            'optionalAccess',
+            function(_) {
+                return _.HowlClass;
+            }
+        ]), function() {
+            return _howler.Howl;
+        });
+        this.HowlerInstance = _nullishCoalesce(_optionalChain([
+            inject,
+            'optionalAccess',
+            function(_2) {
+                return _2.HowlerObj;
+            }
+        ]), function() {
+            return _howler.Howler;
+        });
+        if (typeof _optionalChain([
+            options,
+            'optionalAccess',
+            function(_3) {
+                return _3.defaultVolume;
+            }
+        ]) === "number") {
+            this.setGlobalVolume(options.defaultVolume);
+        }
+    }
+    _create_class(AudioManager, [
+        {
+            key: "hasEffect",
+            value: function hasEffect(key) {
+                return this.effectCache.has(key);
+            }
+        },
+        {
+            key: "loadEffect",
+            value: function loadEffect(key, url) {
+                var _this = this;
+                if (this.effectCache.has(key)) {
+                    this.effectCache.get(key).unload();
+                }
+                var howl = new this.HowlConstructor({
+                    src: [
+                        url
+                    ],
+                    preload: true
+                });
+                howl.on("load", function() {
+                    _this.emit("load", {
+                        type: "effect",
+                        key: key,
+                        url: url
+                    });
+                });
+                howl.on("loaderror", function(_id, error) {
+                    _this.emit("error", {
+                        type: "effect",
+                        key: key,
+                        url: url,
+                        error: error
+                    });
+                });
+                this.effectCache.set(key, howl);
+            }
+        },
+        {
+            key: "loadEffects",
+            value: function loadEffects(map) {
+                var _this = this;
+                Object.keys(map).forEach(function(key) {
+                    var typedKey = isNaN(Number(key)) ? key : Number(key);
+                    _this.loadEffect(typedKey, map[key]);
+                });
+            }
+        },
+        {
+            key: "playEffect",
+            value: function playEffect(key, options) {
+                var _this = this;
+                var howl = this.effectCache.get(key);
+                if (!howl) {
+                    console.warn("[AudioManager] Effect not found for key: ".concat(String(key), "."));
+                    return void 0;
+                }
+                if (howl.playing()) {
+                    howl.stop();
+                }
+                if (typeof _optionalChain([
+                    options,
+                    'optionalAccess',
+                    function(_4) {
+                        return _4.volume;
+                    }
+                ]) === "number") {
+                    howl.volume(options.volume);
+                }
+                howl.off("play");
+                howl.off("end");
+                howl.off("stop");
+                howl.off("playerror");
+                howl.once("play", function(soundId) {
+                    _optionalChain([
+                        options,
+                        'optionalAccess',
+                        function(_5) {
+                            return _5.onStart;
+                        },
+                        'optionalCall',
+                        function(_6) {
+                            return _6(soundId);
+                        }
+                    ]);
+                    _this.emit("play", {
+                        type: "effect",
+                        key: key,
+                        soundId: soundId
+                    });
+                });
+                howl.once("end", function(soundId) {
+                    if (typeof _optionalChain([
+                        options,
+                        'optionalAccess',
+                        function(_7) {
+                            return _7.volume;
+                        }
+                    ]) === "number") {
+                        howl.volume(1);
+                    }
+                    _optionalChain([
+                        options,
+                        'optionalAccess',
+                        function(_8) {
+                            return _8.onEnd;
+                        },
+                        'optionalCall',
+                        function(_9) {
+                            return _9(soundId);
+                        }
+                    ]);
+                    _this.emit("end", {
+                        type: "effect",
+                        key: key,
+                        soundId: soundId
+                    });
+                });
+                howl.once("stop", function(soundId) {
+                    if (typeof _optionalChain([
+                        options,
+                        'optionalAccess',
+                        function(_10) {
+                            return _10.volume;
+                        }
+                    ]) === "number") {
+                        howl.volume(1);
+                    }
+                    _optionalChain([
+                        options,
+                        'optionalAccess',
+                        function(_11) {
+                            return _11.onStop;
+                        },
+                        'optionalCall',
+                        function(_12) {
+                            return _12(soundId);
+                        }
+                    ]);
+                    _this.emit("stop", {
+                        type: "effect",
+                        key: key,
+                        soundId: soundId
+                    });
+                });
+                howl.once("playerror", function(soundId, error) {
+                    _optionalChain([
+                        options,
+                        'optionalAccess',
+                        function(_13) {
+                            return _13.onError;
+                        },
+                        'optionalCall',
+                        function(_14) {
+                            return _14(soundId, error);
+                        }
+                    ]);
+                    _this.emit("error", {
+                        type: "effect",
+                        key: key,
+                        soundId: soundId,
+                        error: error
+                    });
+                });
+                return howl.play();
+            }
+        },
+        {
+            key: "stopEffect",
+            value: function stopEffect(key) {
+                var howl = this.effectCache.get(key);
+                if (howl) {
+                    howl.stop();
+                }
+            }
+        },
+        {
+            key: "removeEffect",
+            value: function removeEffect(key) {
+                var howl = this.effectCache.get(key);
+                if (howl) {
+                    howl.unload();
+                    this.effectCache.delete(key);
+                }
+            }
+        },
+        {
+            key: "preloadUrl",
+            value: function preloadUrl(url) {
+                var _this = this;
+                var existing = this.urlAudioCache.get(url);
+                if (existing && existing.state() === "loaded") {
+                    return Promise.resolve();
+                }
+                var pending = this.preloadPromises.get(url);
+                if (pending) {
+                    return pending;
+                }
+                var howl = existing && existing.state() !== "unloaded" ? existing : this.createUrlHowl(url);
+                var promise = new Promise(function(resolve, reject) {
+                    howl.once("load", function() {
+                        resolve();
+                    });
+                    howl.once("loaderror", function(_id, error) {
+                        _this.urlAudioCache.delete(url);
+                        reject(error);
+                    });
+                });
+                this.preloadPromises.set(url, promise);
+                var settle = function settle() {
+                    if (_this.preloadPromises.get(url) === promise) {
+                        _this.preloadPromises.delete(url);
+                    }
+                };
+                promise.then(settle, settle);
+                return promise;
+            }
+        },
+        {
+            key: "preloadUrls",
+            value: function preloadUrls(urls) {
+                var _this = this;
+                return Promise.all(urls.map(function(url) {
+                    return _this.preloadUrl(url);
+                }));
+            }
+        },
+        {
+            key: "createUrlHowl",
+            value: function createUrlHowl(url) {
+                var _this = this;
+                var howl = new this.HowlConstructor({
+                    src: [
+                        url
+                    ],
+                    preload: true
+                });
+                howl.on("load", function() {
+                    _this.emit("load", {
+                        type: "url",
+                        url: url
+                    });
+                });
+                howl.on("loaderror", function(_id, error) {
+                    _this.urlAudioCache.delete(url);
+                    _this.emit("error", {
+                        type: "url",
+                        url: url,
+                        error: error
+                    });
+                });
+                this.urlAudioCache.set(url, howl);
+                return howl;
+            }
+        },
+        {
+            key: "playUrl",
+            value: function playUrl(url, options) {
+                var _this = this;
+                var howl = this.urlAudioCache.get(url) || this.createUrlHowl(url);
+                var isSingleton = _optionalChain([
+                    options,
+                    'optionalAccess',
+                    function(_15) {
+                        return _15.singleton;
+                    }
+                ]) !== false;
+                if (isSingleton && this.activeUrlHowl && this.activeUrlHowl !== howl && this.activeUrlHowl.playing()) {
+                    this.activeUrlHowl.stop();
+                }
+                if (howl.playing()) {
+                    howl.stop();
+                }
+                if (_optionalChain([
+                    options,
+                    'optionalAccess',
+                    function(_16) {
+                        return _16.loop;
+                    }
+                ]) !== void 0) {
+                    howl.loop(options.loop);
+                }
+                if (typeof _optionalChain([
+                    options,
+                    'optionalAccess',
+                    function(_17) {
+                        return _17.volume;
+                    }
+                ]) === "number") {
+                    howl.volume(options.volume);
+                }
+                if (isSingleton) {
+                    this.activeUrlHowl = howl;
+                }
+                howl.off("play");
+                howl.off("end");
+                howl.off("stop");
+                howl.off("playerror");
+                howl.once("play", function(soundId) {
+                    _optionalChain([
+                        options,
+                        'optionalAccess',
+                        function(_18) {
+                            return _18.onStart;
+                        },
+                        'optionalCall',
+                        function(_19) {
+                            return _19(soundId);
+                        }
+                    ]);
+                    _this.emit("play", {
+                        type: "url",
+                        url: url,
+                        soundId: soundId
+                    });
+                });
+                howl.once("end", function(soundId) {
+                    if (typeof _optionalChain([
+                        options,
+                        'optionalAccess',
+                        function(_20) {
+                            return _20.volume;
+                        }
+                    ]) === "number") {
+                        howl.volume(1);
+                    }
+                    _optionalChain([
+                        options,
+                        'optionalAccess',
+                        function(_21) {
+                            return _21.onEnd;
+                        },
+                        'optionalCall',
+                        function(_22) {
+                            return _22(soundId);
+                        }
+                    ]);
+                    _this.emit("end", {
+                        type: "url",
+                        url: url,
+                        soundId: soundId
+                    });
+                    if (_this.activeUrlHowl === howl && !howl.loop()) {
+                        _this.activeUrlHowl = null;
+                    }
+                });
+                howl.once("stop", function(soundId) {
+                    if (typeof _optionalChain([
+                        options,
+                        'optionalAccess',
+                        function(_23) {
+                            return _23.volume;
+                        }
+                    ]) === "number") {
+                        howl.volume(1);
+                    }
+                    _optionalChain([
+                        options,
+                        'optionalAccess',
+                        function(_24) {
+                            return _24.onStop;
+                        },
+                        'optionalCall',
+                        function(_25) {
+                            return _25(soundId);
+                        }
+                    ]);
+                    _this.emit("stop", {
+                        type: "url",
+                        url: url,
+                        soundId: soundId
+                    });
+                    if (_this.activeUrlHowl === howl) {
+                        _this.activeUrlHowl = null;
+                    }
+                });
+                howl.once("playerror", function(soundId, error) {
+                    _optionalChain([
+                        options,
+                        'optionalAccess',
+                        function(_26) {
+                            return _26.onError;
+                        },
+                        'optionalCall',
+                        function(_27) {
+                            return _27(soundId, error);
+                        }
+                    ]);
+                    _this.emit("error", {
+                        type: "url",
+                        url: url,
+                        soundId: soundId,
+                        error: error
+                    });
+                    if (_this.activeUrlHowl === howl) {
+                        _this.activeUrlHowl = null;
+                    }
+                });
+                return howl.play();
+            }
+        },
+        {
+            key: "stopUrl",
+            value: function stopUrl(url) {
+                var howl = this.urlAudioCache.get(url);
+                if (howl) {
+                    howl.stop();
+                }
+            }
+        },
+        {
+            key: "on",
+            value: function on(event, handler) {
+                var set = _nullishCoalesce(this.listeners.get(event), function() {
+                    return /* @__PURE__ */ new Set();
+                });
+                this.listeners.set(event, set);
+                set.add(handler);
+                return {
+                    destroy: function destroy() {
+                        set.delete(handler);
+                    }
+                };
+            }
+        },
+        {
+            key: "emit",
+            value: function emit(event, payload) {
+                var set = this.listeners.get(event);
+                if (set) {
+                    set.forEach(function(handler) {
+                        try {
+                            handler(payload);
+                        } catch (err) {
+                            console.error("[AudioManager] Error in event listener for ".concat(event, ":"), err);
+                        }
+                    });
+                }
+            }
+        },
+        {
+            key: "getGlobalVolume",
+            value: function getGlobalVolume() {
+                return this.globalVolume;
+            }
+        },
+        {
+            key: "setGlobalVolume",
+            value: function setGlobalVolume(volume) {
+                this.globalVolume = volume;
+                this.HowlerInstance.volume(volume);
+            }
+        },
+        {
+            key: "mute",
+            value: function mute(muted) {
+                this.HowlerInstance.mute(muted);
+            }
+        },
+        {
+            key: "stopAll",
+            value: function stopAll() {
+                this.HowlerInstance.stop();
+                this.activeUrlHowl = null;
+            }
+        },
+        {
+            key: "destroy",
+            value: function destroy() {
+                this.effectCache.forEach(function(howl) {
+                    return howl.unload();
+                });
+                this.urlAudioCache.forEach(function(howl) {
+                    return howl.unload();
+                });
+                this.effectCache.clear();
+                this.urlAudioCache.clear();
+                this.preloadPromises.clear();
+                this.listeners.clear();
+                this.activeUrlHowl = null;
+            }
+        }
+    ]);
+    return AudioManager;
+}();
+// src/react.tsx
+var _react = require('react');
+var _jsxruntime = require('react/jsx-runtime');
+var AudioManagerContext = _react.createContext.call(void 0, null);
+function AudioManagerProvider(param) {
+    var manager = param.manager, children = param.children;
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, AudioManagerContext.Provider, {
+        value: manager,
+        children: children
+    });
+}
+function useAudio() {
+    var manager = _react.useContext.call(void 0, AudioManagerContext);
+    if (!manager) {
+        throw new Error("useAudio must be used within an <AudioManagerProvider>.");
+    }
+    return manager;
+}
+function useAudioEvent(event, handler) {
+    var manager = useAudio();
+    var handlerRef = _react.useRef.call(void 0, handler);
+    handlerRef.current = handler;
+    _react.useEffect.call(void 0, function() {
+        var subscription = manager.on(event, function(payload) {
+            return handlerRef.current(payload);
+        });
+        return function() {
+            return subscription.destroy();
+        };
+    }, [
+        manager,
+        event
+    ]);
+}
+function useGlobalVolume() {
+    var manager = useAudio();
+    var _react_useState_call = _sliced_to_array(_react.useState.call(void 0, function() {
+        return manager.getGlobalVolume();
+    }), 2), volume = _react_useState_call[0], setVolumeState = _react_useState_call[1];
+    var setVolume = _react.useCallback.call(void 0, function(next) {
+        manager.setGlobalVolume(next);
+        setVolumeState(next);
+    }, [
+        manager
+    ]);
+    return [
+        volume,
+        setVolume
+    ];
+}
+function usePreload(urls) {
+    var manager = useAudio();
+    var urlsKey = JSON.stringify(urls);
+    var _react_useState_call = _sliced_to_array(_react.useState.call(void 0, {
+        status: "idle",
+        error: null
+    }), 2), state = _react_useState_call[0], setState = _react_useState_call[1];
+    _react.useEffect.call(void 0, function() {
+        var list = JSON.parse(urlsKey);
+        if (list.length === 0) {
+            setState({
+                status: "idle",
+                error: null
+            });
+            return;
+        }
+        var cancelled = false;
+        setState({
+            status: "loading",
+            error: null
+        });
+        manager.preloadUrls(list).then(function() {
+            if (!cancelled) setState({
+                status: "loaded",
+                error: null
+            });
+        }, function(error) {
+            if (!cancelled) setState({
+                status: "error",
+                error: error
+            });
+        });
+        return function() {
+            cancelled = true;
+        };
+    }, [
+        manager,
+        urlsKey
+    ]);
+    return state;
+}
+exports.AudioManager = AudioManager;
+exports.AudioManagerProvider = AudioManagerProvider;
+exports.default = AudioManager;
+exports.useAudio = useAudio;
+exports.useAudioEvent = useAudioEvent;
+exports.useGlobalVolume = useGlobalVolume;
+exports.usePreload = usePreload;
+//# sourceMappingURL=index.cjs.js.map