ps-toolkit-ui 0.0.211 → 0.0.215

package/src/assets/plugins/highcharts/code/es-modules/Extensions/Sonification/SonificationUtilities.js

@@ -1,150 +0,0 @@
-/* *
- *
- *  (c) 2009-2021 Øystein Moseng
- *
- *  Utility functions for sonification.
- *
- *  License: www.highcharts.com/license
- *
- *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
- *
- * */
-'use strict';
-import MusicalFrequencies from './MusicalFrequencies.js';
-import SignalHandler from './SignalHandler.js';
-import U from '../../Core/Utilities.js';
-var clamp = U.clamp, merge = U.merge;
-/* eslint-disable no-invalid-this, valid-jsdoc */
-/* *
- *
- *  Constants
- *
- * */
-var SonificationUtilities = {
-    // List of musical frequencies from C0 to C8
-    musicalFrequencies: MusicalFrequencies,
-    // SignalHandler class
-    SignalHandler: SignalHandler,
-    getExtremesForInstrumentProps: getExtremesForInstrumentProps,
-    /**
-     * Get a musical scale by specifying the semitones from 1-12 to include.
-     *  1: C, 2: C#, 3: D, 4: D#, 5: E, 6: F,
-     *  7: F#, 8: G, 9: G#, 10: A, 11: Bb, 12: B
-     * @private
-     * @param {Array<number>} semitones
-     * Array of semitones from 1-12 to include in the scale. Duplicate entries
-     * are ignored.
-     * @return {Array<number>}
-     * Array of frequencies from C0 to C8 that are included in this scale.
-     */
-    getMusicalScale: function (semitones) {
-        return MusicalFrequencies.filter(function (freq, i) {
-            var interval = i % 12 + 1;
-            return semitones.some(function (allowedInterval) {
-                return allowedInterval === interval;
-            });
-        });
-    },
-    /**
-     * Calculate the extreme values in a chart for a data prop.
-     * @private
-     * @param {Highcharts.Chart} chart
-     * The chart
-     * @param {string} prop
-     * The data prop to find extremes for
-     * @return {Highcharts.RangeObject}
-     * Object with min and max properties
-     */
-    calculateDataExtremes: function (chart, prop) {
-        return chart.series.reduce(function (extremes, series) {
-            // We use cropped points rather than series.data here, to allow
-            // users to zoom in for better fidelity.
-            series.points.forEach(function (point) {
-                var val = typeof point[prop] !== 'undefined' ?
-                    point[prop] : point.options[prop];
-                extremes.min = Math.min(extremes.min, val);
-                extremes.max = Math.max(extremes.max, val);
-            });
-            return extremes;
-        }, {
-            min: Infinity,
-            max: -Infinity
-        });
-    },
-    /**
-     * Translate a value on a virtual axis. Creates a new, virtual, axis with a
-     * min and max, and maps the relative value onto this axis.
-     * @private
-     * @param {number} value
-     * The relative data value to translate.
-     * @param {Highcharts.RangeObject} DataExtremesObject
-     * The possible extremes for this value.
-     * @param {Object} limits
-     * Limits for the virtual axis.
-     * @param {boolean} [invert]
-     * Invert the virtual axis.
-     * @return {number}
-     * The value mapped to the virtual axis.
-     */
-    virtualAxisTranslate: function (value, dataExtremes, limits, invert) {
-        var lenValueAxis = dataExtremes.max - dataExtremes.min, lenVirtualAxis = Math.abs(limits.max - limits.min), valueDelta = invert ?
-            dataExtremes.max - value :
-            value - dataExtremes.min, virtualValueDelta = lenVirtualAxis * valueDelta / lenValueAxis, virtualAxisValue = limits.min + virtualValueDelta;
-        return lenValueAxis > 0 ?
-            clamp(virtualAxisValue, limits.min, limits.max) :
-            limits.min;
-    }
-};
-/* *
- *
- *  Functions
- *
- * */
-/**
- * Calculate value extremes for used instrument data properties on a chart.
- * @private
- * @param {Highcharts.Chart} chart
- * The chart to calculate extremes from.
- * @param {Array<Highcharts.PointInstrumentObject>} [instruments]
- * Additional instrument definitions to inspect for data props used, in
- * addition to the instruments defined in the chart options.
- * @param {Highcharts.Dictionary<Highcharts.RangeObject>} [dataExtremes]
- * Predefined extremes for each data prop.
- * @return {Highcharts.Dictionary<Highcharts.RangeObject>}
- * New extremes with data properties mapped to min/max objects.
- */
-function getExtremesForInstrumentProps(chart, instruments, dataExtremes) {
-    var defaultInstrumentDef = (chart.options.sonification &&
-        chart.options.sonification.defaultInstrumentOptions), optionDefToInstrDef = function (optionDef) { return ({
-        instrumentMapping: optionDef.mapping
-    }); };
-    var allInstrumentDefinitions = (instruments || []).slice(0);
-    if (defaultInstrumentDef) {
-        allInstrumentDefinitions.push(optionDefToInstrDef(defaultInstrumentDef));
-    }
-    chart.series.forEach(function (series) {
-        var instrOptions = (series.options.sonification &&
-            series.options.sonification.instruments);
-        if (instrOptions) {
-            allInstrumentDefinitions = allInstrumentDefinitions.concat(instrOptions.map(optionDefToInstrDef));
-        }
-    });
-    return (allInstrumentDefinitions).reduce(function (newExtremes, instrumentDefinition) {
-        Object.keys(instrumentDefinition.instrumentMapping || {}).forEach(function (instrumentParameter) {
-            var value = instrumentDefinition.instrumentMapping[instrumentParameter];
-            if (typeof value === 'string' && !newExtremes[value]) {
-                // This instrument parameter is mapped to a data prop. If we
-                // don't have predefined data extremes, find them.
-                newExtremes[value] = SonificationUtilities
-                    .calculateDataExtremes(chart, value);
-            }
-        });
-        return newExtremes;
-    }, merge(dataExtremes));
-}
-/* *
- *
- *  Default export
- *
- * */
-export default SonificationUtilities;

package/src/assets/plugins/highcharts/code/es-modules/Extensions/Sonification/Timeline.js

@@ -1,308 +0,0 @@
-/* *
- *
- *  (c) 2009-2021 Øystein Moseng
- *
- *  TimelineEvent class definition.
- *
- *  License: www.highcharts.com/license
- *
- *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
- *
- * */
-'use strict';
-import Sonification from './Sonification.js';
-import U from '../../Core/Utilities.js';
-var merge = U.merge, splat = U.splat;
-/**
- * Internal types.
- * @private
- */
-import SU from './SonificationUtilities.js';
-/* eslint-disable no-invalid-this, valid-jsdoc */
-/* *
- *
- *  Class
- *
- * */
-/**
- * The Timeline class. Represents a sonification timeline with a list of
- * timeline paths with events to play at certain times relative to each other.
- *
- * @requires module:modules/sonification
- *
- * @private
- * @class
- * @name Highcharts.Timeline
- *
- * @param {Highcharts.TimelineOptionsObject} options
- *        Options for the Timeline.
- */
-var Timeline = /** @class */ (function () {
-    /* *
-     *
-     *  Constructor
-     *
-     * */
-    function Timeline(options) {
-        /* *
-         *
-         *  Properties
-         *
-         * */
-        this.cursor = void 0;
-        this.options = void 0;
-        this.paths = void 0;
-        this.pathsPlaying = void 0;
-        this.signalHandler = void 0;
-        this.init(options || {});
-    }
-    /* *
-     *
-     *  Functions
-     *
-     * */
-    Timeline.prototype.init = function (options) {
-        this.options = options;
-        this.cursor = 0;
-        this.paths = options.paths || [];
-        this.pathsPlaying = {};
-        this.signalHandler = new SU.SignalHandler(['playOnEnd', 'masterOnEnd', 'onPathStart', 'onPathEnd']);
-        this.signalHandler.registerSignalCallbacks(merge(options, { masterOnEnd: options.onEnd }));
-    };
-    /**
-     * Play the timeline forwards from cursor.
-     * @private
-     * @param {Function} [onEnd]
-     * Callback to call when play finished. Does not override other onEnd
-     * callbacks.
-     */
-    Timeline.prototype.play = function (onEnd) {
-        this.pause();
-        this.signalHandler.clearSignalCallbacks(['playOnEnd']);
-        this.signalHandler.registerSignalCallbacks({ playOnEnd: onEnd });
-        this.playPaths(1);
-    };
-    /**
-     * Play the timeline backwards from cursor.
-     * @private
-     * @param {Function} onEnd
-     * Callback to call when play finished. Does not override other onEnd
-     * callbacks.
-     */
-    Timeline.prototype.rewind = function (onEnd) {
-        this.pause();
-        this.signalHandler.clearSignalCallbacks(['playOnEnd']);
-        this.signalHandler.registerSignalCallbacks({ playOnEnd: onEnd });
-        this.playPaths(-1);
-    };
-    /**
-     * Play the timeline in the specified direction.
-     * @private
-     * @param {number} direction
-     * Direction to play in. 1 for forwards, -1 for backwards.
-     */
-    Timeline.prototype.playPaths = function (direction) {
-        var timeline = this, signalHandler = timeline.signalHandler;
-        if (!timeline.paths.length) {
-            var emptySignal = {
-                cancelled: false
-            };
-            signalHandler.emitSignal('playOnEnd', emptySignal);
-            signalHandler.emitSignal('masterOnEnd', emptySignal);
-            return;
-        }
-        var curPaths = splat(this.paths[this.cursor]), nextPaths = this.paths[this.cursor + direction], 
-        // Play a path
-        playPath = function (path) {
-            // Emit signal and set playing state
-            signalHandler.emitSignal('onPathStart', path);
-            timeline.pathsPlaying[path.id] = path;
-            // Do the play
-            path[direction > 0 ? 'play' : 'rewind'](function (callbackData) {
-                // Play ended callback
-                // Data to pass to signal callbacks
-                var cancelled = callbackData && callbackData.cancelled, signalData = {
-                    path: path,
-                    cancelled: cancelled
-                };
-                // Clear state and send signal
-                delete timeline.pathsPlaying[path.id];
-                signalHandler.emitSignal('onPathEnd', signalData);
-                // Handle next paths
-                var pathsEnded = 0;
-                pathsEnded++;
-                if (pathsEnded >= curPaths.length) {
-                    // We finished all of the current paths for cursor.
-                    if (nextPaths && !cancelled) {
-                        // We have more paths, move cursor along
-                        timeline.cursor += direction;
-                        // Reset upcoming path cursors before playing
-                        splat(nextPaths).forEach(function (nextPath) {
-                            nextPath[direction > 0 ?
-                                'resetCursor' : 'resetCursorEnd']();
-                        });
-                        // Play next
-                        timeline.playPaths(direction);
-                    }
-                    else {
-                        // If it is the last path in this direction,
-                        // call onEnd
-                        signalHandler.emitSignal('playOnEnd', signalData);
-                        signalHandler.emitSignal('masterOnEnd', signalData);
-                    }
-                }
-            });
-        };
-        // Go through the paths under cursor and play them
-        curPaths.forEach(function (path) {
-            if (path) {
-                // Store reference to timeline
-                path.timeline = timeline;
-                // Leave a timeout to let notes fade out before next play
-                setTimeout(function () {
-                    playPath(path);
-                }, Sonification.fadeOutDuration);
-            }
-        });
-    };
-    /**
-     * Stop the playing of the timeline. Cancels all current sounds, but does
-     * not affect the cursor.
-     * @private
-     * @param {boolean} [fadeOut=false]
-     * Whether or not to fade out as we stop. If false, the timeline is
-     * cancelled synchronously.
-     */
-    Timeline.prototype.pause = function (fadeOut) {
-        var timeline = this;
-        // Cancel currently playing events
-        Object.keys(timeline.pathsPlaying).forEach(function (id) {
-            if (timeline.pathsPlaying[id]) {
-                timeline.pathsPlaying[id].pause(fadeOut);
-            }
-        });
-        timeline.pathsPlaying = {};
-    };
-    /**
-     * Reset the cursor to the beginning of the timeline.
-     * @private
-     */
-    Timeline.prototype.resetCursor = function () {
-        this.paths.forEach(function (paths) {
-            splat(paths).forEach(function (path) {
-                path.resetCursor();
-            });
-        });
-        this.cursor = 0;
-    };
-    /**
-     * Reset the cursor to the end of the timeline.
-     * @private
-     */
-    Timeline.prototype.resetCursorEnd = function () {
-        this.paths.forEach(function (paths) {
-            splat(paths).forEach(function (path) {
-                path.resetCursorEnd();
-            });
-        });
-        this.cursor = this.paths.length - 1;
-    };
-    /**
-     * Set the current TimelineEvent under the cursor. If multiple paths are
-     * being played at the same time, this function only affects a single path
-     * (the one that contains the eventId that is passed in).
-     * @private
-     * @param {string} eventId
-     * The ID of the timeline event to set as current.
-     * @return {boolean}
-     * True if the cursor was set, false if no TimelineEvent was found for
-     * this ID.
-     */
-    Timeline.prototype.setCursor = function (eventId) {
-        return this.paths.some(function (paths) {
-            return splat(paths).some(function (path) {
-                return path.setCursor(eventId);
-            });
-        });
-    };
-    /**
-     * Get the current TimelineEvents under the cursors. This function will
-     * return the event under the cursor for each currently playing path, as an
-     * object where the path ID is mapped to the TimelineEvent under that
-     * path's cursor.
-     * @private
-     * @return {Highcharts.Dictionary<Highcharts.TimelineEvent>}
-     * The TimelineEvents under each path's cursors.
-     */
-    Timeline.prototype.getCursor = function () {
-        return this.getCurrentPlayingPaths().reduce(function (acc, cur) {
-            acc[cur.id] = cur.getCursor();
-            return acc;
-        }, {});
-    };
-    /**
-     * Check if timeline is reset or at start.
-     * @private
-     * @return {boolean}
-     * True if timeline is at the beginning.
-     */
-    Timeline.prototype.atStart = function () {
-        if (this.cursor) {
-            return false;
-        }
-        return !splat(this.paths[0]).some(function (path) {
-            return path.cursor;
-        });
-    };
-    /**
-     * Get the current TimelinePaths being played.
-     * @private
-     * @return {Array<Highcharts.TimelinePath>}
-     * The TimelinePaths currently being played.
-     */
-    Timeline.prototype.getCurrentPlayingPaths = function () {
-        if (!this.paths.length) {
-            return [];
-        }
-        return splat(this.paths[this.cursor]);
-    };
-    return Timeline;
-}());
-/* *
- *
- *  Default Export
- *
- * */
-export default Timeline;
-/* *
- *
- *  API Declarations
- *
- * */
-/**
- * A set of options for the Timeline class.
- *
- * @requires module:modules/sonification
- *
- * @private
- * @interface Highcharts.TimelineOptionsObject
- */ /**
-* List of TimelinePaths to play. Multiple paths can be grouped together and
-* played simultaneously by supplying an array of paths in place of a single
-* path.
-* @name Highcharts.TimelineOptionsObject#paths
-* @type {Array<(Highcharts.TimelinePath|Array<Highcharts.TimelinePath>)>}
-*/ /**
-* Callback function to call before a path plays.
-* @name Highcharts.TimelineOptionsObject#onPathStart
-* @type {Function|undefined}
-*/ /**
-* Callback function to call after a path has stopped playing.
-* @name Highcharts.TimelineOptionsObject#onPathEnd
-* @type {Function|undefined}
-*/ /**
-* Callback called when the whole path is finished.
-* @name Highcharts.TimelineOptionsObject#onEnd
-* @type {Function|undefined}
-*/
-(''); // detach doclets above

package/src/assets/plugins/highcharts/code/es-modules/Extensions/Sonification/TimelineEvent.js

@@ -1,157 +0,0 @@
-/* *
- *
- *  (c) 2009-2021 Øystein Moseng
- *
- *  TimelineEvent class definition.
- *
- *  License: www.highcharts.com/license
- *
- *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
- *
- * */
-'use strict';
-import U from '../../Core/Utilities.js';
-var merge = U.merge, uniqueKey = U.uniqueKey;
-/* eslint-disable no-invalid-this, valid-jsdoc */
-/* *
- *
- *  Class
- *
- * */
-/**
- * The TimelineEvent class. Represents a sound event on a timeline.
- *
- * @requires module:modules/sonification
- *
- * @private
- * @class
- * @name Highcharts.TimelineEvent
- *
- * @param {Highcharts.TimelineEventOptionsObject} options
- * Options for the TimelineEvent.
- */
-var TimelineEvent = /** @class */ (function () {
-    /* *
-     *
-     *  Constructor
-     *
-     * */
-    function TimelineEvent(options) {
-        /* *
-         *
-         *  Properties
-         *
-         * */
-        this.id = void 0;
-        this.options = void 0;
-        this.time = void 0;
-        this.init(options);
-    }
-    /* *
-     *
-     *  Functions
-     *
-     * */
-    TimelineEvent.prototype.init = function (options) {
-        this.options = options;
-        this.time = options.time || 0;
-        this.id = this.options.id = options.id || uniqueKey();
-    };
-    /**
-     * Play the event. Does not take the TimelineEvent.time option into account,
-     * and plays the event immediately.
-     *
-     * @function Highcharts.TimelineEvent#play
-     *
-     * @param {Highcharts.TimelineEventOptionsObject} [options]
-     *        Options to pass in to the eventObject when playing it.
-     *
-     */
-    TimelineEvent.prototype.play = function (options) {
-        var eventObject = this.options.eventObject, masterOnEnd = this.options.onEnd, playOnEnd = options && options.onEnd, playOptionsOnEnd = this.options.playOptions &&
-            this.options.playOptions.onEnd, playOptions = merge(this.options.playOptions, options);
-        if (eventObject && eventObject.sonify) {
-            // If we have multiple onEnds defined, use all
-            playOptions.onEnd = masterOnEnd || playOnEnd || playOptionsOnEnd ?
-                function () {
-                    var args = arguments;
-                    [masterOnEnd, playOnEnd, playOptionsOnEnd].forEach(function (onEnd) {
-                        if (onEnd) {
-                            onEnd.apply(this, args);
-                        }
-                    });
-                } : void 0;
-            eventObject.sonify(playOptions);
-        }
-        else {
-            if (playOnEnd) {
-                playOnEnd();
-            }
-            if (masterOnEnd) {
-                masterOnEnd();
-            }
-        }
-    };
-    /**
-     * Cancel the sonification of this event. Does nothing if the event is not
-     * currently sonifying.
-     *
-     * @function Highcharts.TimelineEvent#cancel
-     *
-     * @param {boolean} [fadeOut=false]
-     *        Whether or not to fade out as we stop. If false, the event is
-     *        cancelled synchronously.
-     */
-    TimelineEvent.prototype.cancel = function (fadeOut) {
-        var eventObject = this.options.eventObject;
-        if (eventObject) {
-            eventObject.cancelSonify(fadeOut);
-        }
-    };
-    return TimelineEvent;
-}());
-/* *
- *
- *  Default export
- *
- * */
-export default TimelineEvent;
-/* *
- *
- *  API Declarations
- *
- * */
-/**
- * A set of options for the TimelineEvent class.
- *
- * @requires module:modules/sonification
- *
- * @private
- * @interface Highcharts.TimelineEventOptionsObject
- */ /**
-* The object we want to sonify when playing the TimelineEvent. Can be any
-* object that implements the `sonify` and `cancelSonify` functions. If this is
-* not supplied, the TimelineEvent is considered a silent event, and the onEnd
-* event is immediately called.
-* @name Highcharts.TimelineEventOptionsObject#eventObject
-* @type {*}
-*/ /**
-* Options to pass on to the eventObject when playing it.
-* @name Highcharts.TimelineEventOptionsObject#playOptions
-* @type {object|undefined}
-*/ /**
-* The time at which we want this event to play (in milliseconds offset). This
-* is not used for the TimelineEvent.play function, but rather intended as a
-* property to decide when to call TimelineEvent.play. Defaults to 0.
-* @name Highcharts.TimelineEventOptionsObject#time
-* @type {number|undefined}
-*/ /**
-* Unique ID for the event. Generated automatically if not supplied.
-* @name Highcharts.TimelineEventOptionsObject#id
-* @type {string|undefined}
-*/ /**
-* Callback called when the play has finished.
-* @name Highcharts.TimelineEventOptionsObject#onEnd
-* @type {Function|undefined}
-*/
-(''); // detach doclets above