aw-highstock_rails 7.0.3

data/vendor/assets/javascripts/highstock/es-modules/modules/sonification/instrumentDefinitions.js

@@ -0,0 +1,37 @@
+/* *
+ *
+ *  (c) 2009-2019 Øystein Moseng
+ *
+ *  Instrument definitions for sonification module.
+ *
+ *  License: www.highcharts.com/license
+ *
+ * */
+
+'use strict';
+
+import Instrument from './Instrument';
+import utilities from './utilities';
+
+var instruments = {};
+
+['sine', 'square', 'triangle', 'sawtooth'].forEach(function (waveform) {
+    // Add basic instruments
+    instruments[waveform] = new Instrument({
+        oscillator: { waveformShape: waveform }
+    });
+
+    // Add musical instruments
+    instruments[waveform + 'Musical'] = new Instrument({
+        allowedFrequencies: utilities.musicalFrequencies,
+        oscillator: { waveformShape: waveform }
+    });
+
+    // Add scaled instruments
+    instruments[waveform + 'Major'] = new Instrument({
+        allowedFrequencies: utilities.getMusicalScale([1, 3, 5, 6, 8, 10, 12]),
+        oscillator: { waveformShape: waveform }
+    });
+});
+
+export default instruments;

data/vendor/assets/javascripts/highstock/es-modules/modules/sonification/musicalFrequencies.js

@@ -0,0 +1,113 @@
+/* *
+ *
+ *  (c) 2009-2019 Øystein Moseng
+ *
+ *  List of musical frequencies from C0 to C8.
+ *
+ *  License: www.highcharts.com/license
+ *
+ * */
+
+'use strict';
+
+var frequencies = [
+    16.351597831287414, // C0
+    17.323914436054505,
+    18.354047994837977,
+    19.445436482630058,
+    20.601722307054366,
+    21.826764464562746,
+    23.12465141947715,
+    24.499714748859326,
+    25.956543598746574,
+    27.5, // A0
+    29.13523509488062,
+    30.86770632850775,
+    32.70319566257483, // C1
+    34.64782887210901,
+    36.70809598967594,
+    38.890872965260115,
+    41.20344461410875,
+    43.653528929125486,
+    46.2493028389543,
+    48.999429497718666,
+    51.91308719749314,
+    55, // A1
+    58.27047018976124,
+    61.7354126570155,
+    65.40639132514966, // C2
+    69.29565774421802,
+    73.41619197935188,
+    77.78174593052023,
+    82.4068892282175,
+    87.30705785825097,
+    92.4986056779086,
+    97.99885899543733,
+    103.82617439498628,
+    110, // A2
+    116.54094037952248,
+    123.47082531403103,
+    130.8127826502993, // C3
+    138.59131548843604,
+    146.8323839587038,
+    155.56349186104046,
+    164.81377845643496,
+    174.61411571650194,
+    184.9972113558172,
+    195.99771799087463,
+    207.65234878997256,
+    220, // A3
+    233.08188075904496,
+    246.94165062806206,
+    261.6255653005986, // C4
+    277.1826309768721,
+    293.6647679174076,
+    311.1269837220809,
+    329.6275569128699,
+    349.2282314330039,
+    369.9944227116344,
+    391.99543598174927,
+    415.3046975799451,
+    440, // A4
+    466.1637615180899,
+    493.8833012561241,
+    523.2511306011972, // C5
+    554.3652619537442,
+    587.3295358348151,
+    622.2539674441618,
+    659.2551138257398,
+    698.4564628660078,
+    739.9888454232688,
+    783.9908719634985,
+    830.6093951598903,
+    880, // A5
+    932.3275230361799,
+    987.7666025122483,
+    1046.5022612023945, // C6
+    1108.7305239074883,
+    1174.6590716696303,
+    1244.5079348883237,
+    1318.5102276514797,
+    1396.9129257320155,
+    1479.9776908465376,
+    1567.981743926997,
+    1661.2187903197805,
+    1760, // A6
+    1864.6550460723597,
+    1975.533205024496,
+    2093.004522404789, // C7
+    2217.4610478149766,
+    2349.31814333926,
+    2489.0158697766474,
+    2637.02045530296,
+    2793.825851464031,
+    2959.955381693075,
+    3135.9634878539946,
+    3322.437580639561,
+    3520, // A7
+    3729.3100921447194,
+    3951.066410048992,
+    4186.009044809578 // C8
+];
+
+export default frequencies;

data/vendor/assets/javascripts/highstock/es-modules/modules/sonification/pointSonify.js

@@ -0,0 +1,385 @@
+/* *
+ *
+ *  (c) 2009-2019 Øystein Moseng
+ *
+ *  Code for sonifying single points.
+ *
+ *  License: www.highcharts.com/license
+ *
+ * */
+
+
+/**
+ * Define the parameter mapping for an instrument.
+ *
+ * @requires module:modules/sonification
+ *
+ * @interface Highcharts.PointInstrumentMappingObject
+ *//**
+ * Define the volume of the instrument. This can be a string with a data
+ * property name, e.g. `'y'`, in which case this data property is used to define
+ * the volume relative to the `y`-values of the other points. A higher `y` value
+ * would then result in a higher volume. This option can also be a fixed number
+ * or a function. If it is a function, this function is called in regular
+ * intervals while the note is playing. It receives three arguments: The point,
+ * the dataExtremes, and the current relative time - where 0 is the beginning of
+ * the note and 1 is the end. The function should return the volume of the note
+ * as a number between 0 and 1.
+ * @name Highcharts.PointInstrumentMappingObject#volume
+ * @type {string|number|Function}
+ *//**
+ * Define the duration of the notes for this instrument. This can be a string
+ * with a data property name, e.g. `'y'`, in which case this data property is
+ * used to define the duration relative to the `y`-values of the other points. A
+ * higher `y` value would then result in a longer duration. This option can also
+ * be a fixed number or a function. If it is a function, this function is called
+ * once before the note starts playing, and should return the duration in
+ * milliseconds. It receives two arguments: The point, and the dataExtremes.
+ * @name Highcharts.PointInstrumentMappingObject#duration
+ * @type {string|number|Function}
+ *//**
+ * Define the panning of the instrument. This can be a string with a data
+ * property name, e.g. `'x'`, in which case this data property is used to define
+ * the panning relative to the `x`-values of the other points. A higher `x`
+ * value would then result in a higher panning value (panned further to the
+ * right). This option can also be a fixed number or a function. If it is a
+ * function, this function is called in regular intervals while the note is
+ * playing. It receives three arguments: The point, the dataExtremes, and the
+ * current relative time - where 0 is the beginning of the note and 1 is the
+ * end. The function should return the panning of the note as a number between
+ * -1 and 1.
+ * @name Highcharts.PointInstrumentMappingObject#pan
+ * @type {string|number|Function|undefined}
+ *//**
+ * Define the frequency of the instrument. This can be a string with a data
+ * property name, e.g. `'y'`, in which case this data property is used to define
+ * the frequency relative to the `y`-values of the other points. A higher `y`
+ * value would then result in a higher frequency. This option can also be a
+ * fixed number or a function. If it is a function, this function is called in
+ * regular intervals while the note is playing. It receives three arguments:
+ * The point, the dataExtremes, and the current relative time - where 0 is the
+ * beginning of the note and 1 is the end. The function should return the
+ * frequency of the note as a number (in Hz).
+ * @name Highcharts.PointInstrumentMappingObject#frequency
+ * @type {string|number|Function}
+ */
+
+
+/**
+ * @requires module:modules/sonification
+ *
+ * @interface Highcharts.PointInstrumentOptionsObject
+ *//**
+ * The minimum duration for a note when using a data property for duration. Can
+ * be overridden by using either a fixed number or a function for
+ * instrumentMapping.duration. Defaults to 20.
+ * @name Highcharts.PointInstrumentOptionsObject#minDuration
+ * @type {number|undefined}
+ *//**
+ * The maximum duration for a note when using a data property for duration. Can
+ * be overridden by using either a fixed number or a function for
+ * instrumentMapping.duration. Defaults to 2000.
+ * @name Highcharts.PointInstrumentOptionsObject#maxDuration
+ * @type {number|undefined}
+ *//**
+ * The minimum pan value for a note when using a data property for panning. Can
+ * be overridden by using either a fixed number or a function for
+ * instrumentMapping.pan. Defaults to -1 (fully left).
+ * @name Highcharts.PointInstrumentOptionsObject#minPan
+ * @type {number|undefined}
+ *//**
+ * The maximum pan value for a note when using a data property for panning. Can
+ * be overridden by using either a fixed number or a function for
+ * instrumentMapping.pan. Defaults to 1 (fully right).
+ * @name Highcharts.PointInstrumentOptionsObject#maxPan
+ * @type {number|undefined}
+ *//**
+ * The minimum volume for a note when using a data property for volume. Can be
+ * overridden by using either a fixed number or a function for
+ * instrumentMapping.volume. Defaults to 0.1.
+ * @name Highcharts.PointInstrumentOptionsObject#minVolume
+ * @type {number|undefined}
+ *//**
+ * The maximum volume for a note when using a data property for volume. Can be
+ * overridden by using either a fixed number or a function for
+ * instrumentMapping.volume. Defaults to 1.
+ * @name Highcharts.PointInstrumentOptionsObject#maxVolume
+ * @type {number|undefined}
+ *//**
+ * The minimum frequency for a note when using a data property for frequency.
+ * Can be overridden by using either a fixed number or a function for
+ * instrumentMapping.frequency. Defaults to 220.
+ * @name Highcharts.PointInstrumentOptionsObject#minFrequency
+ * @type {number|undefined}
+ *//**
+ * The maximum frequency for a note when using a data property for frequency.
+ * Can be overridden by using either a fixed number or a function for
+ * instrumentMapping.frequency. Defaults to 2200.
+ * @name Highcharts.PointInstrumentOptionsObject#maxFrequency
+ * @type {number|undefined}
+ */
+
+
+/**
+ * An instrument definition for a point, specifying the instrument to play and
+ * how to play it.
+ *
+ * @interface Highcharts.PointInstrumentObject
+ *//**
+ * An Instrument instance or the name of the instrument in the
+ * Highcharts.sonification.instruments map.
+ * @name Highcharts.PointInstrumentObject#instrument
+ * @type {Highcharts.Instrument|string}
+ *//**
+ * Mapping of instrument parameters for this instrument.
+ * @name Highcharts.PointInstrumentObject#instrumentMapping
+ * @type {Highcharts.PointInstrumentMappingObject}
+ *//**
+ * Options for this instrument.
+ * @name Highcharts.PointInstrumentObject#instrumentOptions
+ * @type {Highcharts.PointInstrumentOptionsObject|undefined}
+ *//**
+ * Callback to call when the instrument has stopped playing.
+ * @name Highcharts.PointInstrumentObject#onEnd
+ * @type {Function|undefined}
+ */
+
+
+/**
+ * Options for sonifying a point.
+ * @interface Highcharts.PointSonifyOptionsObject
+ *//**
+ * The instrument definitions for this point.
+ * @name Highcharts.PointSonifyOptionsObject#instruments
+ * @type {Array<Highcharts.PointInstrumentObject>}
+ *//**
+ * Optionally provide the minimum/maximum values for the points. If this is not
+ * supplied, it is calculated from the points in the chart on demand. This
+ * option is supplied in the following format, as a map of point data properties
+ * to objects with min/max values:
+ *  ```js
+ *      dataExtremes: {
+ *          y: {
+ *              min: 0,
+ *              max: 100
+ *          },
+ *          z: {
+ *              min: -10,
+ *              max: 10
+ *          }
+ *          // Properties used and not provided are calculated on demand
+ *      }
+ *  ```
+ * @name Highcharts.PointSonifyOptionsObject#dataExtremes
+ * @type {object|undefined}
+ *//**
+ * Callback called when the sonification has finished.
+ * @name Highcharts.PointSonifyOptionsObject#onEnd
+ * @type {Function|undefined}
+ */
+
+
+'use strict';
+
+import H from '../../parts/Globals.js';
+import utilities from './utilities';
+
+// Defaults for the instrument options
+// NOTE: Also change defaults in Highcharts.PointInstrumentOptionsObject if
+//       making changes here.
+var defaultInstrumentOptions = {
+    minDuration: 20,
+    maxDuration: 2000,
+    minVolume: 0.1,
+    maxVolume: 1,
+    minPan: -1,
+    maxPan: 1,
+    minFrequency: 220,
+    maxFrequency: 2200
+};
+
+
+/**
+ * Sonify a single point.
+ *
+ * @sample highcharts/sonification/point-basic/
+ *         Click on points to sonify
+ * @sample highcharts/sonification/point-advanced/
+ *         Sonify bubbles
+ *
+ * @requires module:modules/sonification
+ *
+ * @function Highcharts.Point#sonify
+ *
+ * @param {Highcharts.PointSonifyOptionsObject} options
+ *        Options for the sonification of the point.
+ */
+function pointSonify(options) {
+    var point = this,
+        chart = point.series.chart,
+        dataExtremes = options.dataExtremes || {},
+        // Get the value to pass to instrument.play from the mapping value
+        // passed in.
+        getMappingValue = function (
+            value, makeFunction, allowedExtremes, allowedValues
+        ) {
+            // Fixed number, just use that
+            if (typeof value === 'number' || value === undefined) {
+                return value;
+            }
+            // Function. Return new function if we try to use callback,
+            // otherwise call it now and return result.
+            if (typeof value === 'function') {
+                return makeFunction ?
+                    function (time) {
+                        return value(point, dataExtremes, time);
+                    } :
+                    value(point, dataExtremes);
+            }
+            // String, this is a data prop.
+            if (typeof value === 'string') {
+                // Find data extremes if we don't have them
+                dataExtremes[value] = dataExtremes[value] ||
+                    utilities.calculateDataExtremes(
+                        point.series.chart, value
+                    );
+                // Find the value
+                return utilities.virtualAxisTranslate(
+                    H.pick(point[value], point.options[value]),
+                    dataExtremes[value],
+                    allowedExtremes,
+                    allowedValues
+                );
+            }
+        };
+
+    // Register playing point on chart
+    chart.sonification.currentlyPlayingPoint = point;
+
+    // Keep track of instruments playing
+    point.sonification = point.sonification || {};
+    point.sonification.instrumentsPlaying =
+        point.sonification.instrumentsPlaying || {};
+
+    // Register signal handler for the point
+    var signalHandler = point.sonification.signalHandler =
+        point.sonification.signalHandler ||
+        new utilities.SignalHandler(['onEnd']);
+
+    signalHandler.clearSignalCallbacks();
+    signalHandler.registerSignalCallbacks({ onEnd: options.onEnd });
+
+    // If we have a null point or invisible point, just return
+    if (point.isNull || !point.visible || !point.series.visible) {
+        signalHandler.emitSignal('onEnd');
+        return;
+    }
+
+    // Go through instruments and play them
+    options.instruments.forEach(function (instrumentDefinition) {
+        var instrument = typeof instrumentDefinition.instrument === 'string' ?
+                H.sonification.instruments[instrumentDefinition.instrument] :
+                instrumentDefinition.instrument,
+            mapping = instrumentDefinition.instrumentMapping || {},
+            extremes = H.merge(
+                defaultInstrumentOptions,
+                instrumentDefinition.instrumentOptions
+            ),
+            id = instrument.id,
+            onEnd = function (cancelled) {
+                // Instrument on end
+                if (instrumentDefinition.onEnd) {
+                    instrumentDefinition.onEnd.apply(this, arguments);
+                }
+
+                // Remove currently playing point reference on chart
+                if (
+                    chart.sonification &&
+                    chart.sonification.currentlyPlayingPoint
+                ) {
+                    delete chart.sonification.currentlyPlayingPoint;
+                }
+
+                // Remove reference from instruments playing
+                if (
+                    point.sonification && point.sonification.instrumentsPlaying
+                ) {
+                    delete point.sonification.instrumentsPlaying[id];
+
+                    // This was the last instrument?
+                    if (
+                        !Object.keys(
+                            point.sonification.instrumentsPlaying
+                        ).length
+                    ) {
+                        signalHandler.emitSignal('onEnd', cancelled);
+                    }
+                }
+            };
+
+        // Play the note on the instrument
+        if (instrument && instrument.play) {
+            point.sonification.instrumentsPlaying[instrument.id] = instrument;
+            instrument.play({
+                frequency: getMappingValue(
+                    mapping.frequency,
+                    true,
+                    { min: extremes.minFrequency, max: extremes.maxFrequency }
+                ),
+                duration: getMappingValue(
+                    mapping.duration,
+                    false,
+                    { min: extremes.minDuration, max: extremes.maxDuration }
+                ),
+                pan: getMappingValue(
+                    mapping.pan,
+                    true,
+                    { min: extremes.minPan, max: extremes.maxPan }
+                ),
+                volume: getMappingValue(
+                    mapping.volume,
+                    true,
+                    { min: extremes.minVolume, max: extremes.maxVolume }
+                ),
+                onEnd: onEnd,
+                minFrequency: extremes.minFrequency,
+                maxFrequency: extremes.maxFrequency
+            });
+        } else {
+            H.error(30);
+        }
+    });
+}
+
+
+/**
+ * Cancel sonification of a point. Calls onEnd functions.
+ *
+ * @requires module:modules/sonification
+ *
+ * @function Highcharts.Point#cancelSonify
+ *
+ * @param {boolean} [fadeOut=false]
+ *        Whether or not to fade out as we stop. If false, the points are
+ *        cancelled synchronously.
+ */
+function pointCancelSonify(fadeOut) {
+    var playing = this.sonification && this.sonification.instrumentsPlaying,
+        instrIds = playing && Object.keys(playing);
+
+    if (instrIds && instrIds.length) {
+        instrIds.forEach(function (instr) {
+            playing[instr].stop(!fadeOut, null, 'cancelled');
+        });
+        this.sonification.instrumentsPlaying = {};
+        this.sonification.signalHandler.emitSignal('onEnd', 'cancelled');
+    }
+}
+
+
+var pointSonifyFunctions = {
+    pointSonify: pointSonify,
+    pointCancelSonify: pointCancelSonify
+};
+
+export default pointSonifyFunctions;