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

package/dist/index.umd.js

@@ -0,0 +1,648 @@
+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 _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_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 _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 _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+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);
+}
+/*!
+ * 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
+ */ (function(g, f) {
+    if ((typeof exports === "undefined" ? "undefined" : _type_of(exports)) == "object" && (typeof module === "undefined" ? "undefined" : _type_of(module)) < "u") {
+        module.exports = f();
+    } else if ("function" == typeof define && define.amd) {
+        define("urlLiteral", f);
+    } else {
+        g["urlLiteral"] = f();
+    }
+})((typeof globalThis === "undefined" ? "undefined" : _type_of(globalThis)) < "u" ? globalThis : (typeof self === "undefined" ? "undefined" : _type_of(self)) < "u" ? self : this, function() {
+    var exports1 = {};
+    var __exports = exports1;
+    var module1 = {
+        exports: exports1
+    };
+    "use strict";
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export = function __export(target, all) {
+        for(var name in all)__defProp(target, name, {
+            get: all[name],
+            enumerable: true
+        });
+    };
+    var __copyProps = function __copyProps(to, from, except, desc) {
+        if (from && (typeof from === "undefined" ? "undefined" : _type_of(from)) === "object" || typeof from === "function") {
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                var _loop = function() {
+                    var key = _step.value;
+                    if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                        get: function get() {
+                            return from[key];
+                        },
+                        enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                    });
+                };
+                for(var _iterator = __getOwnPropNames(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+        }
+        return to;
+    };
+    var __toCommonJS = function __toCommonJS(mod) {
+        return __copyProps(__defProp({}, "__esModule", {
+            value: true
+        }), mod);
+    };
+    // src/index.ts
+    var index_exports = {};
+    __export(index_exports, {
+        AudioManager: function AudioManager1() {
+            return AudioManager;
+        },
+        AudioManagerProvider: function AudioManagerProvider1() {
+            return AudioManagerProvider;
+        },
+        default: function _default() {
+            return AudioManager;
+        },
+        useAudio: function useAudio1() {
+            return useAudio;
+        },
+        useAudioEvent: function useAudioEvent1() {
+            return useAudioEvent;
+        },
+        useGlobalVolume: function useGlobalVolume1() {
+            return useGlobalVolume;
+        },
+        usePreload: function usePreload1() {
+            return usePreload;
+        }
+    });
+    module1.exports = __toCommonJS(index_exports);
+    // src/manager.ts
+    var import_howler = require("howler");
+    var AudioManager = /*#__PURE__*/ function() {
+        "use strict";
+        function AudioManager(options, inject) {
+            _class_call_check(this, AudioManager);
+            var _ref, _ref1;
+            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 = (_ref = inject === null || inject === void 0 ? void 0 : inject.HowlClass) !== null && _ref !== void 0 ? _ref : import_howler.Howl;
+            this.HowlerInstance = (_ref1 = inject === null || inject === void 0 ? void 0 : inject.HowlerObj) !== null && _ref1 !== void 0 ? _ref1 : import_howler.Howler;
+            if (typeof (options === null || options === void 0 ? void 0 : options.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 (options === null || options === void 0 ? void 0 : options.volume) === "number") {
+                        howl.volume(options.volume);
+                    }
+                    howl.off("play");
+                    howl.off("end");
+                    howl.off("stop");
+                    howl.off("playerror");
+                    howl.once("play", function(soundId) {
+                        var _options_onStart;
+                        options === null || options === void 0 ? void 0 : (_options_onStart = options.onStart) === null || _options_onStart === void 0 ? void 0 : _options_onStart.call(options, soundId);
+                        _this.emit("play", {
+                            type: "effect",
+                            key: key,
+                            soundId: soundId
+                        });
+                    });
+                    howl.once("end", function(soundId) {
+                        var _options_onEnd;
+                        if (typeof (options === null || options === void 0 ? void 0 : options.volume) === "number") {
+                            howl.volume(1);
+                        }
+                        options === null || options === void 0 ? void 0 : (_options_onEnd = options.onEnd) === null || _options_onEnd === void 0 ? void 0 : _options_onEnd.call(options, soundId);
+                        _this.emit("end", {
+                            type: "effect",
+                            key: key,
+                            soundId: soundId
+                        });
+                    });
+                    howl.once("stop", function(soundId) {
+                        var _options_onStop;
+                        if (typeof (options === null || options === void 0 ? void 0 : options.volume) === "number") {
+                            howl.volume(1);
+                        }
+                        options === null || options === void 0 ? void 0 : (_options_onStop = options.onStop) === null || _options_onStop === void 0 ? void 0 : _options_onStop.call(options, soundId);
+                        _this.emit("stop", {
+                            type: "effect",
+                            key: key,
+                            soundId: soundId
+                        });
+                    });
+                    howl.once("playerror", function(soundId, error) {
+                        var _options_onError;
+                        options === null || options === void 0 ? void 0 : (_options_onError = options.onError) === null || _options_onError === void 0 ? void 0 : _options_onError.call(options, 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 = (options === null || options === void 0 ? void 0 : options.singleton) !== false;
+                    if (isSingleton && this.activeUrlHowl && this.activeUrlHowl !== howl && this.activeUrlHowl.playing()) {
+                        this.activeUrlHowl.stop();
+                    }
+                    if (howl.playing()) {
+                        howl.stop();
+                    }
+                    if ((options === null || options === void 0 ? void 0 : options.loop) !== void 0) {
+                        howl.loop(options.loop);
+                    }
+                    if (typeof (options === null || options === void 0 ? void 0 : options.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) {
+                        var _options_onStart;
+                        options === null || options === void 0 ? void 0 : (_options_onStart = options.onStart) === null || _options_onStart === void 0 ? void 0 : _options_onStart.call(options, soundId);
+                        _this.emit("play", {
+                            type: "url",
+                            url: url,
+                            soundId: soundId
+                        });
+                    });
+                    howl.once("end", function(soundId) {
+                        var _options_onEnd;
+                        if (typeof (options === null || options === void 0 ? void 0 : options.volume) === "number") {
+                            howl.volume(1);
+                        }
+                        options === null || options === void 0 ? void 0 : (_options_onEnd = options.onEnd) === null || _options_onEnd === void 0 ? void 0 : _options_onEnd.call(options, soundId);
+                        _this.emit("end", {
+                            type: "url",
+                            url: url,
+                            soundId: soundId
+                        });
+                        if (_this.activeUrlHowl === howl && !howl.loop()) {
+                            _this.activeUrlHowl = null;
+                        }
+                    });
+                    howl.once("stop", function(soundId) {
+                        var _options_onStop;
+                        if (typeof (options === null || options === void 0 ? void 0 : options.volume) === "number") {
+                            howl.volume(1);
+                        }
+                        options === null || options === void 0 ? void 0 : (_options_onStop = options.onStop) === null || _options_onStop === void 0 ? void 0 : _options_onStop.call(options, soundId);
+                        _this.emit("stop", {
+                            type: "url",
+                            url: url,
+                            soundId: soundId
+                        });
+                        if (_this.activeUrlHowl === howl) {
+                            _this.activeUrlHowl = null;
+                        }
+                    });
+                    howl.once("playerror", function(soundId, error) {
+                        var _options_onError;
+                        options === null || options === void 0 ? void 0 : (_options_onError = options.onError) === null || _options_onError === void 0 ? void 0 : _options_onError.call(options, 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 _this_listeners_get;
+                    var set = (_this_listeners_get = this.listeners.get(event)) !== null && _this_listeners_get !== void 0 ? _this_listeners_get : /* @__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 import_react = require("react");
+    var import_jsx_runtime = require("react/jsx-runtime");
+    var AudioManagerContext = (0, import_react.createContext)(null);
+    function AudioManagerProvider(param) {
+        var manager = param.manager, children = param.children;
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AudioManagerContext.Provider, {
+            value: manager,
+            children: children
+        });
+    }
+    function useAudio() {
+        var manager = (0, import_react.useContext)(AudioManagerContext);
+        if (!manager) {
+            throw new Error("useAudio must be used within an <AudioManagerProvider>.");
+        }
+        return manager;
+    }
+    function useAudioEvent(event, handler) {
+        var manager = useAudio();
+        var handlerRef = (0, import_react.useRef)(handler);
+        handlerRef.current = handler;
+        (0, import_react.useEffect)(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 _ref = _sliced_to_array((0, import_react.useState)(function() {
+            return manager.getGlobalVolume();
+        }), 2), volume = _ref[0], setVolumeState = _ref[1];
+        var setVolume = (0, import_react.useCallback)(function(next) {
+            manager.setGlobalVolume(next);
+            setVolumeState(next);
+        }, [
+            manager
+        ]);
+        return [
+            volume,
+            setVolume
+        ];
+    }
+    function usePreload(urls) {
+        var manager = useAudio();
+        var urlsKey = JSON.stringify(urls);
+        var _ref = _sliced_to_array((0, import_react.useState)({
+            status: "idle",
+            error: null
+        }), 2), state = _ref[0], setState = _ref[1];
+        (0, import_react.useEffect)(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;
+    }
+    // Annotate the CommonJS export names for ESM import in node:
+    0 && (module1.exports = {
+        AudioManager: AudioManager,
+        AudioManagerProvider: AudioManagerProvider,
+        useAudio: useAudio,
+        useAudioEvent: useAudioEvent,
+        useGlobalVolume: useGlobalVolume,
+        usePreload: usePreload
+    });
+    if (__exports != exports1) module1.exports = exports1;
+    return module1.exports;
+});
+//# sourceMappingURL=index.umd.js.map