From 4391c5f81ce379c874ee4c51fcb80f4d8b393966 Mon Sep 17 00:00:00 2001 From: francoismg Date: Thu, 18 Jul 2024 05:54:59 +0000 Subject: [PATCH] =?UTF-8?q?Deploy=20preview=20for=20PR=2012=20=F0=9F=9B=AB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- pr-preview/pr-12/components/FileComponent.js | 1 - .../pr-12/components/SettingsComponent.js | 158 ++- .../file_type/FITSSettingsComponent.js | 189 ++- .../inputs/ArithmeticColumnInput.js | 244 ++++ .../pr-12/containers/RegistryContainer.js | 11 + .../pr-12/data_processors/DataPreProcessor.js | 75 +- pr-preview/pr-12/dist/astrovis/astrovis.js | 1075 +++++++++++++++-- .../pr-12/errors/NoEventSubscriberError.js | 6 + .../events/ArithmeticColumnChangeEvent.js | 49 + .../pr-12/events/FileRegistryChangeEvent.js | 17 +- pr-preview/pr-12/index.html | 82 ++ pr-preview/pr-12/main.js | 6 + .../registries/EventSubscribersRegistry.js | 5 +- pr-preview/pr-12/registries/FileRegistry.js | 29 + pr-preview/pr-12/utils/ColumnUtils.js | 19 + pr-preview/pr-12/utils/ExpressionBlock.js | 47 + pr-preview/pr-12/utils/ExpressionParser.js | 79 ++ pr-preview/pr-12/visualizations/D3Graph.js | 111 +- pr-preview/pr-12/webpack.dev.js | 2 +- pr-preview/pr-12/wrappers/BokehWrapper.js | 80 +- pr-preview/pr-12/wrappers/D3Wrapper.js | 9 +- .../pr-12/wrappers/FITSReaderWrapper.js | 69 +- 22 files changed, 2122 insertions(+), 241 deletions(-) create mode 100644 pr-preview/pr-12/components/inputs/ArithmeticColumnInput.js create mode 100644 pr-preview/pr-12/errors/NoEventSubscriberError.js create mode 100644 pr-preview/pr-12/events/ArithmeticColumnChangeEvent.js create mode 100644 pr-preview/pr-12/utils/ColumnUtils.js create mode 100644 pr-preview/pr-12/utils/ExpressionBlock.js create mode 100644 pr-preview/pr-12/utils/ExpressionParser.js diff --git a/pr-preview/pr-12/components/FileComponent.js b/pr-preview/pr-12/components/FileComponent.js index 9fe6283..432b5b1 100644 --- a/pr-preview/pr-12/components/FileComponent.js +++ b/pr-preview/pr-12/components/FileComponent.js @@ -271,7 +271,6 @@ export class FileComponent extends HTMLElement { handleSelectChangeEvent(event) { event.stopPropagation(); - } _setContainer() { diff --git a/pr-preview/pr-12/components/SettingsComponent.js b/pr-preview/pr-12/components/SettingsComponent.js index 02039db..4c76343 100644 --- a/pr-preview/pr-12/components/SettingsComponent.js +++ b/pr-preview/pr-12/components/SettingsComponent.js @@ -3,6 +3,9 @@ import {SettingsChangedEvent} from "../events/SettingsChangedEvent"; import {VisualizationGenerationEvent} from "../events/VisualizationGenerationEvent"; import {FileRegistry} from "../registries/FileRegistry"; import {WrapperContainer} from "../containers/WrapperContainer"; +import {ColumnUtils} from "../utils/ColumnUtils"; +import {RegistryContainer} from "../containers/RegistryContainer"; +import {FileRegistryChangeEvent} from "../events/FileRegistryChangeEvent"; export class SettingsComponent extends HTMLElement { @@ -50,6 +53,7 @@ export class SettingsComponent extends HTMLElement { this.handleHDUsChangeEvent = this.handleHDUsChangeEvent.bind(this); this.handleGenerateEvent = this.handleGenerateEvent.bind(this); this.handleFileChangeEvent = this.handleFileChangeEvent.bind(this); + this.handleArithmeticColumnChangeEvent = this.handleArithmeticColumnChangeEvent.bind(this); this._setupExternalListeners(); this._setupInnerListeners(); @@ -68,12 +72,14 @@ export class SettingsComponent extends HTMLElement { this.addEventListener('select-data-type-change', this.handleDataTypeChangeEvent); this.addEventListener('select-hdus-change', this.handleHDUsChangeEvent); this.addEventListener('button-generate-click', this.handleGenerateEvent); + this.addEventListener('arithmetic-column-change', this.handleArithmeticColumnChangeEvent); } _setupInnerElementsListeners() { this._setSelectLibraryListener(); this._setSelectDataTypeListener() this._setSelectHDUsListener(); + this._setSelectAxisListener(); this._setGenerateButtonListener(); this._setCalculationRadioListeners(); } @@ -177,7 +183,12 @@ export class SettingsComponent extends HTMLElement { if(file.type === 'fits') { let fits_reader_wrapper = WrapperContainer.getFITSReaderWrapper(); - fits_reader_wrapper.setFile(file.file); + if(file.product_type !== 'spectrum') { + fits_reader_wrapper.setFile(file.file); + } else { + fits_reader_wrapper.setFileFromFileObject(file); + } + let fits_columns = fits_reader_wrapper.getAllColumns(); fits_columns.forEach((fits_column) => { @@ -215,9 +226,15 @@ export class SettingsComponent extends HTMLElement { } this._setSelectGroupAxis(select_options); + + select_options.unshift(this._createGenericColumnOptionsGroup()); this._setSelectGroupErrorBars(select_options); } + handleArithmeticColumnChangeEvent(event) { + //this._setSelectAxis() + } + _setContainer() { this.container = document.getElementById(this.container_id) } @@ -292,6 +309,21 @@ export class SettingsComponent extends HTMLElement { return opt_group } + _createGenericColumnOptionsGroup() { + let opt_group = document.createElement("optgroup"); + opt_group.label = "Genereic columns"; + opt_group.className += "generic"; + + let option = document.createElement("option"); + + option.text = 'None'; + option.value = `none`; + + opt_group.appendChild(option); + + return opt_group; + } + _setSelectAxis(columns) { this._resetSelectAxis(); @@ -448,6 +480,117 @@ export class SettingsComponent extends HTMLElement { }); } + _setSelectAxisListener() { + let select_axis_x = document.getElementById(SettingsComponent.select_axis_x_id); + let select_axis_y = document.getElementById(SettingsComponent.select_axis_y_id); + + let select_error_bar_x = document.getElementById(SettingsComponent.select_error_bar_x_id); + let select_error_bar_y = document.getElementById(SettingsComponent.select_error_bar_y_id); + + select_axis_x.addEventListener('change', (e) => { + let column_id = e.target.value; + + let data_type = document.getElementById(SettingsComponent.select_data_type_id).value; + + if(data_type === 'light-curve') { + + let column_descriptor = ColumnUtils.getColumnSettings(column_id) + + let file_object = FileRegistry.getFileById(column_descriptor.file_id); + + let frw = WrapperContainer.getFITSReaderWrapper(); + frw.setFile(file_object.file); + + let columns_name= frw.getAllColumns(); + + if(column_descriptor.column_name.toUpperCase() === 'RATE' && + columns_name.some(column => { + return column.name.toUpperCase() === 'ERROR' && parseInt(column.hdu_index) === parseInt(column_descriptor.hdu_index) + })) { + + Array.from(select_error_bar_x.options).forEach((option) => { + let option_column_descriptor = ColumnUtils.getColumnSettings(option.value); + + if(option_column_descriptor.file_id === column_descriptor.file_id && + option_column_descriptor.hdu_index === column_descriptor.hdu_index && + option_column_descriptor.column_name.toUpperCase() === 'ERROR') + + select_error_bar_x.value = option.value; + }) + } + + if(column_descriptor.column_name.toUpperCase() === 'TIME' && + columns_name.some(column => { + return column.name.toUpperCase() === 'TIMEDEL' && parseInt(column.hdu_index) === parseInt(column_descriptor.hdu_index) + })) { + + Array.from(select_error_bar_x.options).forEach((option) => { + let option_column_descriptor = ColumnUtils.getColumnSettings(option.value); + + if (option_column_descriptor.file_id === column_descriptor.file_id && + option_column_descriptor.hdu_index === column_descriptor.hdu_index && + option_column_descriptor.column_name.toUpperCase() === 'TIMEDEL') + + select_error_bar_x.value = option.value; + }) + } + } + + }) + + select_axis_y.addEventListener('change', (e) => { + let column_id = e.target.value; + + let data_type = document.getElementById(SettingsComponent.select_data_type_id).value; + + if(data_type === 'light-curve') { + + let column_descriptor= ColumnUtils.getColumnSettings(column_id) + + let file_object = FileRegistry.getFileById(column_descriptor.file_id); + + let frw= WrapperContainer.getFITSReaderWrapper(); + frw.setFile(file_object.file); + + let columns_name= frw.getAllColumns(); + + if(column_descriptor.column_name.toUpperCase() === 'RATE' && + columns_name.some(column => { + return column.name.toUpperCase() === 'ERROR' && parseInt(column.hdu_index) === parseInt(column_descriptor.hdu_index) + })) { + + Array.from(select_error_bar_y.options).forEach((option) => { + let option_column_descriptor = ColumnUtils.getColumnSettings(option.value); + + if(option_column_descriptor.file_id === column_descriptor.file_id && + option_column_descriptor.hdu_index === column_descriptor.hdu_index && + option_column_descriptor.column_name.toUpperCase() === 'ERROR') + + select_error_bar_y.value = option.value; + }) + } + + if(column_descriptor.column_name.toUpperCase() === 'TIME' && + columns_name.some(column => { + return column.name.toUpperCase() === 'TIMEDEL' && parseInt(column.hdu_index) === parseInt(column_descriptor.hdu_index) + })) { + + Array.from(select_error_bar_y.options).forEach((option) => { + let option_column_descriptor = ColumnUtils.getColumnSettings(option.value); + + if (option_column_descriptor.file_id === column_descriptor.file_id && + option_column_descriptor.hdu_index === column_descriptor.hdu_index && + option_column_descriptor.column_name.toUpperCase() === 'TIMEDEL') + + select_error_bar_y.value = option.value; + }) + } + } + + }) + + } + _setCalculationRadioListeners() { let radio_buttons = document.querySelectorAll('.' + SettingsComponent.calculation_radio_class); radio_buttons.forEach(radio_button => { @@ -526,8 +669,17 @@ export class SettingsComponent extends HTMLElement { if(values['has-error-bars-checkbox'].checked === true) { let error_bars = {}; - error_bars.x = values['select-axis-x-error-bar'].value; - error_bars.y = values['select-axis-y-error-bar'].value; + if(values['select-axis-x-error-bar'] !== undefined) { + error_bars.x = values['select-axis-x-error-bar'].value; + } else { + delete error_bars.x + } + + if(values['select-axis-y-error-bar'] !== undefined) { + error_bars.y = values['select-axis-y-error-bar'].value; + } else { + delete error_bars.y + } this.settings_object.setErrorBarsSettings(error_bars); } diff --git a/pr-preview/pr-12/components/file_type/FITSSettingsComponent.js b/pr-preview/pr-12/components/file_type/FITSSettingsComponent.js index 260a3e0..11697f3 100644 --- a/pr-preview/pr-12/components/file_type/FITSSettingsComponent.js +++ b/pr-preview/pr-12/components/file_type/FITSSettingsComponent.js @@ -1,6 +1,7 @@ import {WrapperContainer} from "../../containers/WrapperContainer"; import {FileRegistry} from "../../registries/FileRegistry"; import {FileRegistryChangeEvent} from "../../events/FileRegistryChangeEvent"; +import {RegistryContainer} from "../../containers/RegistryContainer"; export class FITSSettingsComponent extends HTMLElement { @@ -14,6 +15,11 @@ export class FITSSettingsComponent extends HTMLElement { add_to_plot_btn_id = "add-to-plot"; remove_from_plot_btn_id = "remove-from-plot"; + save_btn_id = 'save-file-settings'; + + product_type_select_id = 'product-type-select'; + arf_file_select_id = 'arf-file-select'; + rmf_file_select_id = 'rmf-file-select'; container = '
' + '
' + @@ -76,6 +82,13 @@ export class FITSSettingsComponent extends HTMLElement { '
\n' + '
File settings
\n' + '
\n' + + ' ' + ' \n' + @@ -122,7 +135,7 @@ export class FITSSettingsComponent extends HTMLElement { '
\n' + '
\n' + '\n' + - ' \n' + + ' \n' + ' \n' + ' \n' + '
\n' + @@ -134,6 +147,7 @@ export class FITSSettingsComponent extends HTMLElement { setupComponent() { this.setHDUSelect(); this.setupActionButtons(); + this.setProductSettings(); let select_hdu = document.getElementById(this.select_hdu_id); let hdu_index = select_hdu.value; @@ -172,6 +186,10 @@ export class FITSSettingsComponent extends HTMLElement { setupInnerElementListeners() { this.setHDUSelectListener(); + this.setSaveButtonListener(); + //this.setProductTypeSelectListener(); + //this.setARFFileSelectListener(); + //this.setRMFFileSelectListener(); } setupActionButtons() { @@ -193,7 +211,12 @@ export class FITSSettingsComponent extends HTMLElement { this.is_current = true; let frce = new FileRegistryChangeEvent(); - frce.dispatchToSubscribers(); + + try { + frce.dispatchToSubscribers(); + } catch(e) { + console.log("No subsribers for event : " + FileRegistryChangeEvent.name); + } this.resetContainerForCurrentFile(); @@ -205,12 +228,31 @@ export class FITSSettingsComponent extends HTMLElement { this.is_current = false; let frce = new FileRegistryChangeEvent(); - frce.dispatchToSubscribers(); + + try { + frce.dispatchToSubscribers(); + } catch(e) { + console.log("No subscribers for specified event : " + FileRegistryChangeEvent.name); + } this.resetContainerForCurrentFile(); }); } + setProductSettings() { + let product_type = null; + let rmf_file = null; + let arf_file = null; + + if(this.file.product_type) product_type = this.file.product_type; + if(this.file.rmf_file) rmf_file = this.file.rmf_file; + if(this.file.arf_file) arf_file = this.file.arf_file; + + //this.setProductTypeSelect(product_type); + //this.setRMFFileSelect(rmf_file); + //this.setARFFileSelect(arf_file); + } + setTables(hdu_index) { this.resetTables(); @@ -294,8 +336,149 @@ export class FITSSettingsComponent extends HTMLElement { } + setSaveButtonListener() { + let save_settings_btn = document.getElementById(this.save_btn_id); + + save_settings_btn.addEventListener('click', (event) => { + let product_type_select = document.getElementById(this.product_type_select_id); + + if(product_type_select.value === 'spectrum') { + let rmf_file_select = document.getElementById(this.rmf_file_select_id); + let arf_file_select = document.getElementById(this.arf_file_select_id); + + let rmf_file_id = rmf_file_select.value; + let arf_file_id = arf_file_select.value; + + FileRegistry.setFileMetadata(this.file.id, { + rmf_file: rmf_file_id, + arf_file: arf_file_id + }); + } + + }) + + } + + setProductTypeSelect(value = null) { + let product_type_select = document.getElementById(this.product_type_select_id); + + if(value) { + product_type_select.value = 'none'; + } else { + product_type_select.value = value; + } + } + + setProductTypeSelectListener() { + let product_type_select = document.getElementById(this.product_type_select_id); + + product_type_select.addEventListener('change', (event) => { + if(product_type_select.value === 'spectrum') { + this.setProductSettingsVisibility('spectrum'); + } else if(product_type_select.value === 'lightcurve') { + this.setProductSettingsVisibility('lightcurve'); + } else { + this.setProductSettingsVisibility(); + } + }) + + } + + setRMFFileSelect(value = null) { + let rmf_file_select = document.getElementById(this.rmf_file_select_id); + + let file_options = this.getFilesOptionsList(); + + file_options.forEach((option) => { + rmf_file_select.appendChild(option) + }); + + if(!value) { + rmf_file_select.value = 'none'; + } else { + rmf_file_select.value = value; + } + } + + setRMFFileSelectListener() { + let rmf_file_select = document.getElementById(this.rmf_file_select_id); + + } + + setARFFileSelect(value = null) { + let arf_file_select = document.getElementById(this.arf_file_select_id); + + let file_options = this.getFilesOptionsList(); + + file_options.forEach((option) => { + arf_file_select.appendChild(option) + }); + + if(!value) { + arf_file_select.value = 'none'; + } else { + arf_file_select.value = value; + } + } + + setARFFileSelectListener() { + let arf_file_select = document.getElementById(this.arf_file_select_id); + + } + + setProductSettingsVisibility(settings = null) { + let rmf_file_select = document.getElementById(this.rmf_file_select_id); + let arf_file_select = document.getElementById(this.arf_file_select_id); + + rmf_file_select.style.display = 'none'; + arf_file_select.style.display = 'none'; + + let spectrum_elements = document.getElementsByClassName('spectrum-settings'); + + for (let i = 0; i < spectrum_elements.length; i++) { + spectrum_elements[i].style.display = 'none'; + } + + if(!settings) { + + } else if(settings === 'spectrum') { + rmf_file_select.style.display = 'block'; + arf_file_select.style.display = 'block'; + + for (let i = 0; i < spectrum_elements.length; i++) { + spectrum_elements[i].style.display = 'block'; + } + } else if(settings === 'lightcurve') { + + } + } + resetContainerForCurrentFile() { this.setupComponent(); } + getFilesOptionsList() { + let file_options = []; + let file_list = FileRegistry.getAllFiles(); + + let option = document.createElement("option"); + + option.setAttribute('selected', 'true'); + + option.value = 'none'; + option.text = 'None'; + + file_options.push(option); + + file_list.forEach((file) => { + option = document.createElement("option"); + + option.value = file.id; + option.text = file.file_name; + + file_options.push(option); + }) + + return file_options; + } } \ No newline at end of file diff --git a/pr-preview/pr-12/components/inputs/ArithmeticColumnInput.js b/pr-preview/pr-12/components/inputs/ArithmeticColumnInput.js new file mode 100644 index 0000000..cf21c92 --- /dev/null +++ b/pr-preview/pr-12/components/inputs/ArithmeticColumnInput.js @@ -0,0 +1,244 @@ +import {FileRegistry} from "../../registries/FileRegistry"; +import {WrapperContainer} from "../../containers/WrapperContainer"; + +export class ArithmeticColumnInput extends HTMLElement { + + static column_display_id = 'column-display-list'; + static column_create_button_id = 'column-edit-button'; + static column_main_input_id = 'column-main-input'; + static column_list_id = 'column-input-list'; + static input_expression = 'input-expression'; + + static button_commands = ['C', '<--', '-->', 'V'] + + column_display = ""; + column_create_button = ""; + column_main_input = "
" + + "
" + + "
" + + "
" + + "
" + + "" + + "" + + "" + + "" + + "
" + + "
" + + "" + + "" + + "" + + "" + + "
" + + "
" + + "" + + "" + + "" + + "" + + "
" + + "
" + + "" + + "" + + "" + + "" + + "" + + "
" + + "
" + + "
" + + "
    " + + "
    " + + "
    " + + "
    " + + display_formula = ''; + inner_formula = ''; + + constructor() { + super(); + + this.innerHTML = this.column_display + this.column_main_input + this.column_create_button; + + this.handleFileChangeEvent = this.handleFileChangeEvent.bind(this); + + + this._setupInnerElementsListeners(); + this._setupExternalListeners(); + } + + _setupExternalListeners() { + this.addEventListener('file-registry-change', this.handleFileChangeEvent); + } + + _setupInnerElementsListeners() { + this._setCreateButtonListener(); + this._setKeyboardListener(); + } + + _setCreateButtonListener() { + let create_button = document.getElementById(ArithmeticColumnInput.column_create_button_id); + + create_button.addEventListener('click', (e) => { + let display_main_input = document.getElementById(ArithmeticColumnInput.column_main_input_id); + display_main_input.classList.toggle('visible'); + }) + } + + handleFileChangeEvent(event) { + let current_file_list = FileRegistry.getCurrentFilesList(); + let columns = []; + + this._resetColumnInput(); + + current_file_list.forEach((file) => { + + if(file.type === 'fits') { + let fits_reader_wrapper = WrapperContainer.getFITSReaderWrapper(); + + fits_reader_wrapper.setFile(file.file); + let fits_columns = fits_reader_wrapper.getAllColumns(); + + fits_columns.forEach((fits_column) => { + let column = {...fits_column, file_id: file.id}; + columns.push(column); + }) + + } + }) + + let columns_by_file = columns.reduce((acc, column) => { + if (!acc[column.file_id]) { + acc[column.file_id] = []; + } + acc[column.file_id].push(column); + return acc; + }, {}); + + let li_group_list = []; + + let i = 1; + for (let file_id in columns_by_file) { + if (columns_by_file.hasOwnProperty(file_id)) { + let file = FileRegistry.getFileById(file_id); + let file_name = file.file_name; + + let frw = WrapperContainer.getFITSReaderWrapper(); + frw.setFile(file.file); + + li_group_list.push(this.createColumnsList(columns_by_file[file_id], frw)); + } + i++; + } + + this.setColumnInput(li_group_list); + this._setColumnInputListener(); + } + + executeCommand(command) { + let input_display = document.getElementById(ArithmeticColumnInput.input_expression); + + switch (command) { + + case 'C': + input_display.value = ''; + + break; + + case 'V': + this.addColumnToDisplay(input_display.value); + + break; + + case '<--': + + break; + + case '-->': + + break; + + } + } + + createColumnsList(file_columns, fits_reader_wrapper) { + + let li_group = []; + + file_columns.forEach(column => { + let li = document.createElement("li"); + + let hdu_type = fits_reader_wrapper.getHeaderCardValueByNameFromHDU(column.hdu_index, 'XTENSION'); + let hdu_extname = fits_reader_wrapper.getHeaderCardValueByNameFromHDU(column.hdu_index, 'EXTNAME'); + let name = hdu_type+'-'+hdu_extname+' '+column.name; + + if(column.is_from_header) { + name += '(HEADER)'; + } + + if(column.is_processed) { + li.innerHTML = name; + li.setAttribute('dataset-id',`${column.from_file}.${column.hdu_index}$${column.name}`); + } else { + li.innerHTML = name; + li.setAttribute('data-id',`${column.file_id}.${column.hdu_index}$${column.name}`); + } + + li_group.push(li); + }); + + return li_group; + } + + setColumnInput(li_group_list) { + let ul_columns = document.getElementById(ArithmeticColumnInput.column_list_id); + + li_group_list.forEach((li_group) => { + li_group.forEach((li) => { + ul_columns.appendChild(li); + }) + }) + } + + _setKeyboardListener() { + let buttons = document.querySelectorAll('div.button-grid button'); + let input_display = document.getElementById(ArithmeticColumnInput.input_expression); + + buttons.forEach((button) => { + button.addEventListener('click', (e) => { + let operator = button.textContent; + + if(!ArithmeticColumnInput.button_commands.includes(operator)) { + input_display.value += operator; + } else { + this.executeCommand(operator); + } + }); + }); + } + + _resetColumnInput() { + let column_list = document.getElementById(ArithmeticColumnInput.column_list_id); + column_list.innerHTML = ''; + } + + _setColumnInputListener() { + let lis = document.querySelectorAll('ul#column-input-list li'); + let input_display = document.getElementById(ArithmeticColumnInput.input_expression); + + lis.forEach(function(li) { + li.addEventListener('click', (e) => { + let column_id = li.getAttribute('data-id'); + input_display.value += column_id; + }); + }); + } + + addColumnToDisplay(expression) { + let column_display = document.getElementById(ArithmeticColumnInput.column_display_id); + + let li_expression = document.createElement('li'); + li_expression.innerHTML = expression+' '; + li_expression.setAttribute('data-column', expression); + + column_display.appendChild(li_expression); + } + +} \ No newline at end of file diff --git a/pr-preview/pr-12/containers/RegistryContainer.js b/pr-preview/pr-12/containers/RegistryContainer.js index 0f1f0ba..7c69bff 100644 --- a/pr-preview/pr-12/containers/RegistryContainer.js +++ b/pr-preview/pr-12/containers/RegistryContainer.js @@ -1,7 +1,10 @@ import { EventSubscribersRegistry } from '../registries/EventSubscribersRegistry.js' +import {FileRegistry} from "../registries/FileRegistry"; export class RegistryContainer { + static file_registry = null; + constructor() { } @@ -10,6 +13,14 @@ export class RegistryContainer { return new EventSubscribersRegistry(); } + getFileRegistry() { + return RegistryContainer.file_registry; + } + + static setFileRegistry(file_registry) { + RegistryContainer.file_registry = file_registry; + } + static getRegistryContainer() { return new RegistryContainer(); } diff --git a/pr-preview/pr-12/data_processors/DataPreProcessor.js b/pr-preview/pr-12/data_processors/DataPreProcessor.js index 4281d15..a0e58f9 100644 --- a/pr-preview/pr-12/data_processors/DataPreProcessor.js +++ b/pr-preview/pr-12/data_processors/DataPreProcessor.js @@ -50,7 +50,7 @@ export class DataPreProcessor { if(error_bar.column_name === SpectrumProcessor.E_MID_LOG) { column_data.forEach(col_data => { - console.log(col_data); + }) } @@ -99,6 +99,9 @@ export class DataPreProcessor { processErrorBarDataJSON(dataset, axis, error_bars) { + console.log(error_bars); + console.log(dataset); + let error_bar_x_values = []; let error_bar_y_values = []; @@ -108,34 +111,56 @@ export class DataPreProcessor { let error_bar_x_column = error_bars.x; let error_bar_y_column = error_bars.y; + let error_bars_object = {}; + dataset.forEach(function(datapoint){ - let error_bar_x = [ - { - bound: parseFloat(datapoint[axis_y]) - parseFloat(datapoint[error_bar_y_column]), - [axis_x]: parseFloat(datapoint[axis_x]) - }, - { - bound: parseFloat(datapoint[axis_y]) + parseFloat(datapoint[error_bar_y_column]), - [axis_x]: parseFloat(datapoint[axis_x]) - } - ] - - let error_bar_y = [ - { - bound: parseFloat(datapoint[axis_x]) - parseFloat(datapoint[error_bar_x_column]), - [axis_y]: parseFloat(datapoint[axis_y]) - }, - { - bound: parseFloat(datapoint[axis_x]) + parseFloat(datapoint[error_bar_x_column]), - [axis_y]: parseFloat(datapoint[axis_y]) - } - ] - error_bar_x_values.push(error_bar_x); - error_bar_y_values.push(error_bar_y); + if(error_bars.x) { + + console.log("X"); + console.log(datapoint[axis_x]); + console.log(error_bar_x_column); + + let error_bar_x = [ + { + bound: parseFloat(datapoint[axis_x]) - parseFloat(datapoint[error_bar_x_column]), + [axis_y]: parseFloat(datapoint[axis_y]) + }, + { + bound: parseFloat(datapoint[axis_x]) + parseFloat(datapoint[error_bar_x_column]), + [axis_y]: parseFloat(datapoint[axis_y]) + } + ] + + error_bar_x_values.push(error_bar_x); + } + + if(error_bars.y) { + + console.log("Y"); + console.log(datapoint[axis_x]); + console.log(error_bar_y_column); + + let error_bar_y = [ + { + bound: parseFloat(datapoint[axis_y]) - parseFloat(datapoint[error_bar_y_column]), + [axis_x]: parseFloat(datapoint[axis_x]) + }, + { + bound: parseFloat(datapoint[axis_y]) + parseFloat(datapoint[error_bar_y_column]), + [axis_x]: parseFloat(datapoint[axis_x]) + } + ] + + error_bar_y_values.push(error_bar_y); + } + }) - return { x: error_bar_x_values, y: error_bar_y_values } + if(error_bars.x) error_bars_object.x = error_bar_x_values; + if(error_bars.y) error_bars_object.y = error_bar_y_values; + + return error_bars_object; } getSpectrumProcessedColumn(hdu_index, column_name, fits_reader_wrapper) { diff --git a/pr-preview/pr-12/dist/astrovis/astrovis.js b/pr-preview/pr-12/dist/astrovis/astrovis.js index 25bbbb6..0d83f31 100644 --- a/pr-preview/pr-12/dist/astrovis/astrovis.js +++ b/pr-preview/pr-12/dist/astrovis/astrovis.js @@ -299,7 +299,6 @@ class FileComponent extends HTMLElement { handleSelectChangeEvent(event) { event.stopPropagation(); - } _setContainer() { @@ -329,6 +328,12 @@ __webpack_require__.r(__webpack_exports__); /* harmony import */ var _events_VisualizationGenerationEvent__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../events/VisualizationGenerationEvent */ "./events/VisualizationGenerationEvent.js"); /* harmony import */ var _registries_FileRegistry__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../registries/FileRegistry */ "./registries/FileRegistry.js"); /* harmony import */ var _containers_WrapperContainer__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../containers/WrapperContainer */ "./containers/WrapperContainer.js"); +/* harmony import */ var _utils_ColumnUtils__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../utils/ColumnUtils */ "./utils/ColumnUtils.js"); +/* harmony import */ var _containers_RegistryContainer__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../containers/RegistryContainer */ "./containers/RegistryContainer.js"); +/* harmony import */ var _events_FileRegistryChangeEvent__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../events/FileRegistryChangeEvent */ "./events/FileRegistryChangeEvent.js"); + + + @@ -381,6 +386,7 @@ class SettingsComponent extends HTMLElement { this.handleHDUsChangeEvent = this.handleHDUsChangeEvent.bind(this); this.handleGenerateEvent = this.handleGenerateEvent.bind(this); this.handleFileChangeEvent = this.handleFileChangeEvent.bind(this); + this.handleArithmeticColumnChangeEvent = this.handleArithmeticColumnChangeEvent.bind(this); this._setupExternalListeners(); this._setupInnerListeners(); @@ -399,12 +405,14 @@ class SettingsComponent extends HTMLElement { this.addEventListener('select-data-type-change', this.handleDataTypeChangeEvent); this.addEventListener('select-hdus-change', this.handleHDUsChangeEvent); this.addEventListener('button-generate-click', this.handleGenerateEvent); + this.addEventListener('arithmetic-column-change', this.handleArithmeticColumnChangeEvent); } _setupInnerElementsListeners() { this._setSelectLibraryListener(); this._setSelectDataTypeListener() this._setSelectHDUsListener(); + this._setSelectAxisListener(); this._setGenerateButtonListener(); this._setCalculationRadioListeners(); } @@ -508,7 +516,12 @@ class SettingsComponent extends HTMLElement { if(file.type === 'fits') { let fits_reader_wrapper = _containers_WrapperContainer__WEBPACK_IMPORTED_MODULE_4__.WrapperContainer.getFITSReaderWrapper(); - fits_reader_wrapper.setFile(file.file); + if(file.product_type !== 'spectrum') { + fits_reader_wrapper.setFile(file.file); + } else { + fits_reader_wrapper.setFileFromFileObject(file); + } + let fits_columns = fits_reader_wrapper.getAllColumns(); fits_columns.forEach((fits_column) => { @@ -546,9 +559,15 @@ class SettingsComponent extends HTMLElement { } this._setSelectGroupAxis(select_options); + + select_options.unshift(this._createGenericColumnOptionsGroup()); this._setSelectGroupErrorBars(select_options); } + handleArithmeticColumnChangeEvent(event) { + //this._setSelectAxis() + } + _setContainer() { this.container = document.getElementById(this.container_id) } @@ -623,6 +642,21 @@ class SettingsComponent extends HTMLElement { return opt_group } + _createGenericColumnOptionsGroup() { + let opt_group = document.createElement("optgroup"); + opt_group.label = "Genereic columns"; + opt_group.className += "generic"; + + let option = document.createElement("option"); + + option.text = 'None'; + option.value = `none`; + + opt_group.appendChild(option); + + return opt_group; + } + _setSelectAxis(columns) { this._resetSelectAxis(); @@ -779,6 +813,117 @@ class SettingsComponent extends HTMLElement { }); } + _setSelectAxisListener() { + let select_axis_x = document.getElementById(SettingsComponent.select_axis_x_id); + let select_axis_y = document.getElementById(SettingsComponent.select_axis_y_id); + + let select_error_bar_x = document.getElementById(SettingsComponent.select_error_bar_x_id); + let select_error_bar_y = document.getElementById(SettingsComponent.select_error_bar_y_id); + + select_axis_x.addEventListener('change', (e) => { + let column_id = e.target.value; + + let data_type = document.getElementById(SettingsComponent.select_data_type_id).value; + + if(data_type === 'light-curve') { + + let column_descriptor = _utils_ColumnUtils__WEBPACK_IMPORTED_MODULE_5__.ColumnUtils.getColumnSettings(column_id) + + let file_object = _registries_FileRegistry__WEBPACK_IMPORTED_MODULE_3__.FileRegistry.getFileById(column_descriptor.file_id); + + let frw = _containers_WrapperContainer__WEBPACK_IMPORTED_MODULE_4__.WrapperContainer.getFITSReaderWrapper(); + frw.setFile(file_object.file); + + let columns_name= frw.getAllColumns(); + + if(column_descriptor.column_name.toUpperCase() === 'RATE' && + columns_name.some(column => { + return column.name.toUpperCase() === 'ERROR' && parseInt(column.hdu_index) === parseInt(column_descriptor.hdu_index) + })) { + + Array.from(select_error_bar_x.options).forEach((option) => { + let option_column_descriptor = _utils_ColumnUtils__WEBPACK_IMPORTED_MODULE_5__.ColumnUtils.getColumnSettings(option.value); + + if(option_column_descriptor.file_id === column_descriptor.file_id && + option_column_descriptor.hdu_index === column_descriptor.hdu_index && + option_column_descriptor.column_name.toUpperCase() === 'ERROR') + + select_error_bar_x.value = option.value; + }) + } + + if(column_descriptor.column_name.toUpperCase() === 'TIME' && + columns_name.some(column => { + return column.name.toUpperCase() === 'TIMEDEL' && parseInt(column.hdu_index) === parseInt(column_descriptor.hdu_index) + })) { + + Array.from(select_error_bar_x.options).forEach((option) => { + let option_column_descriptor = _utils_ColumnUtils__WEBPACK_IMPORTED_MODULE_5__.ColumnUtils.getColumnSettings(option.value); + + if (option_column_descriptor.file_id === column_descriptor.file_id && + option_column_descriptor.hdu_index === column_descriptor.hdu_index && + option_column_descriptor.column_name.toUpperCase() === 'TIMEDEL') + + select_error_bar_x.value = option.value; + }) + } + } + + }) + + select_axis_y.addEventListener('change', (e) => { + let column_id = e.target.value; + + let data_type = document.getElementById(SettingsComponent.select_data_type_id).value; + + if(data_type === 'light-curve') { + + let column_descriptor= _utils_ColumnUtils__WEBPACK_IMPORTED_MODULE_5__.ColumnUtils.getColumnSettings(column_id) + + let file_object = _registries_FileRegistry__WEBPACK_IMPORTED_MODULE_3__.FileRegistry.getFileById(column_descriptor.file_id); + + let frw= _containers_WrapperContainer__WEBPACK_IMPORTED_MODULE_4__.WrapperContainer.getFITSReaderWrapper(); + frw.setFile(file_object.file); + + let columns_name= frw.getAllColumns(); + + if(column_descriptor.column_name.toUpperCase() === 'RATE' && + columns_name.some(column => { + return column.name.toUpperCase() === 'ERROR' && parseInt(column.hdu_index) === parseInt(column_descriptor.hdu_index) + })) { + + Array.from(select_error_bar_y.options).forEach((option) => { + let option_column_descriptor = _utils_ColumnUtils__WEBPACK_IMPORTED_MODULE_5__.ColumnUtils.getColumnSettings(option.value); + + if(option_column_descriptor.file_id === column_descriptor.file_id && + option_column_descriptor.hdu_index === column_descriptor.hdu_index && + option_column_descriptor.column_name.toUpperCase() === 'ERROR') + + select_error_bar_y.value = option.value; + }) + } + + if(column_descriptor.column_name.toUpperCase() === 'TIME' && + columns_name.some(column => { + return column.name.toUpperCase() === 'TIMEDEL' && parseInt(column.hdu_index) === parseInt(column_descriptor.hdu_index) + })) { + + Array.from(select_error_bar_y.options).forEach((option) => { + let option_column_descriptor = _utils_ColumnUtils__WEBPACK_IMPORTED_MODULE_5__.ColumnUtils.getColumnSettings(option.value); + + if (option_column_descriptor.file_id === column_descriptor.file_id && + option_column_descriptor.hdu_index === column_descriptor.hdu_index && + option_column_descriptor.column_name.toUpperCase() === 'TIMEDEL') + + select_error_bar_y.value = option.value; + }) + } + } + + }) + + } + _setCalculationRadioListeners() { let radio_buttons = document.querySelectorAll('.' + SettingsComponent.calculation_radio_class); radio_buttons.forEach(radio_button => { @@ -857,8 +1002,17 @@ class SettingsComponent extends HTMLElement { if(values['has-error-bars-checkbox'].checked === true) { let error_bars = {}; - error_bars.x = values['select-axis-x-error-bar'].value; - error_bars.y = values['select-axis-y-error-bar'].value; + if(values['select-axis-x-error-bar'] !== undefined) { + error_bars.x = values['select-axis-x-error-bar'].value; + } else { + delete error_bars.x + } + + if(values['select-axis-y-error-bar'] !== undefined) { + error_bars.y = values['select-axis-y-error-bar'].value; + } else { + delete error_bars.y + } this.settings_object.setErrorBarsSettings(error_bars); } @@ -1003,6 +1157,8 @@ __webpack_require__.r(__webpack_exports__); /* harmony import */ var _containers_WrapperContainer__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../containers/WrapperContainer */ "./containers/WrapperContainer.js"); /* harmony import */ var _registries_FileRegistry__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../registries/FileRegistry */ "./registries/FileRegistry.js"); /* harmony import */ var _events_FileRegistryChangeEvent__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../events/FileRegistryChangeEvent */ "./events/FileRegistryChangeEvent.js"); +/* harmony import */ var _containers_RegistryContainer__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../containers/RegistryContainer */ "./containers/RegistryContainer.js"); + @@ -1019,6 +1175,11 @@ class FITSSettingsComponent extends HTMLElement { add_to_plot_btn_id = "add-to-plot"; remove_from_plot_btn_id = "remove-from-plot"; + save_btn_id = 'save-file-settings'; + + product_type_select_id = 'product-type-select'; + arf_file_select_id = 'arf-file-select'; + rmf_file_select_id = 'rmf-file-select'; container = '
    ' + '
    ' + @@ -1081,6 +1242,13 @@ class FITSSettingsComponent extends HTMLElement { '
    \n' + '
    File settings
    \n' + '
    \n' + + ' ' + ' \n' + @@ -1127,7 +1295,7 @@ class FITSSettingsComponent extends HTMLElement { '
    \n' + '
    \n' + '\n' + - ' \n' + + ' \n' + ' \n' + ' \n' + '
    \n' + @@ -1139,6 +1307,7 @@ class FITSSettingsComponent extends HTMLElement { setupComponent() { this.setHDUSelect(); this.setupActionButtons(); + this.setProductSettings(); let select_hdu = document.getElementById(this.select_hdu_id); let hdu_index = select_hdu.value; @@ -1177,6 +1346,10 @@ class FITSSettingsComponent extends HTMLElement { setupInnerElementListeners() { this.setHDUSelectListener(); + this.setSaveButtonListener(); + //this.setProductTypeSelectListener(); + //this.setARFFileSelectListener(); + //this.setRMFFileSelectListener(); } setupActionButtons() { @@ -1198,7 +1371,12 @@ class FITSSettingsComponent extends HTMLElement { this.is_current = true; let frce = new _events_FileRegistryChangeEvent__WEBPACK_IMPORTED_MODULE_2__.FileRegistryChangeEvent(); - frce.dispatchToSubscribers(); + + try { + frce.dispatchToSubscribers(); + } catch(e) { + console.log("No subsribers for event : " + _events_FileRegistryChangeEvent__WEBPACK_IMPORTED_MODULE_2__.FileRegistryChangeEvent.name); + } this.resetContainerForCurrentFile(); @@ -1210,12 +1388,31 @@ class FITSSettingsComponent extends HTMLElement { this.is_current = false; let frce = new _events_FileRegistryChangeEvent__WEBPACK_IMPORTED_MODULE_2__.FileRegistryChangeEvent(); - frce.dispatchToSubscribers(); + + try { + frce.dispatchToSubscribers(); + } catch(e) { + console.log("No subscribers for specified event : " + _events_FileRegistryChangeEvent__WEBPACK_IMPORTED_MODULE_2__.FileRegistryChangeEvent.name); + } this.resetContainerForCurrentFile(); }); } + setProductSettings() { + let product_type = null; + let rmf_file = null; + let arf_file = null; + + if(this.file.product_type) product_type = this.file.product_type; + if(this.file.rmf_file) rmf_file = this.file.rmf_file; + if(this.file.arf_file) arf_file = this.file.arf_file; + + //this.setProductTypeSelect(product_type); + //this.setRMFFileSelect(rmf_file); + //this.setARFFileSelect(arf_file); + } + setTables(hdu_index) { this.resetTables(); @@ -1299,10 +1496,410 @@ class FITSSettingsComponent extends HTMLElement { } + setSaveButtonListener() { + let save_settings_btn = document.getElementById(this.save_btn_id); + + save_settings_btn.addEventListener('click', (event) => { + let product_type_select = document.getElementById(this.product_type_select_id); + + if(product_type_select.value === 'spectrum') { + let rmf_file_select = document.getElementById(this.rmf_file_select_id); + let arf_file_select = document.getElementById(this.arf_file_select_id); + + let rmf_file_id = rmf_file_select.value; + let arf_file_id = arf_file_select.value; + + _registries_FileRegistry__WEBPACK_IMPORTED_MODULE_1__.FileRegistry.setFileMetadata(this.file.id, { + rmf_file: rmf_file_id, + arf_file: arf_file_id + }); + } + + }) + + } + + setProductTypeSelect(value = null) { + let product_type_select = document.getElementById(this.product_type_select_id); + + if(value) { + product_type_select.value = 'none'; + } else { + product_type_select.value = value; + } + } + + setProductTypeSelectListener() { + let product_type_select = document.getElementById(this.product_type_select_id); + + product_type_select.addEventListener('change', (event) => { + if(product_type_select.value === 'spectrum') { + this.setProductSettingsVisibility('spectrum'); + } else if(product_type_select.value === 'lightcurve') { + this.setProductSettingsVisibility('lightcurve'); + } else { + this.setProductSettingsVisibility(); + } + }) + + } + + setRMFFileSelect(value = null) { + let rmf_file_select = document.getElementById(this.rmf_file_select_id); + + let file_options = this.getFilesOptionsList(); + + file_options.forEach((option) => { + rmf_file_select.appendChild(option) + }); + + if(!value) { + rmf_file_select.value = 'none'; + } else { + rmf_file_select.value = value; + } + } + + setRMFFileSelectListener() { + let rmf_file_select = document.getElementById(this.rmf_file_select_id); + + } + + setARFFileSelect(value = null) { + let arf_file_select = document.getElementById(this.arf_file_select_id); + + let file_options = this.getFilesOptionsList(); + + file_options.forEach((option) => { + arf_file_select.appendChild(option) + }); + + if(!value) { + arf_file_select.value = 'none'; + } else { + arf_file_select.value = value; + } + } + + setARFFileSelectListener() { + let arf_file_select = document.getElementById(this.arf_file_select_id); + + } + + setProductSettingsVisibility(settings = null) { + let rmf_file_select = document.getElementById(this.rmf_file_select_id); + let arf_file_select = document.getElementById(this.arf_file_select_id); + + rmf_file_select.style.display = 'none'; + arf_file_select.style.display = 'none'; + + let spectrum_elements = document.getElementsByClassName('spectrum-settings'); + + for (let i = 0; i < spectrum_elements.length; i++) { + spectrum_elements[i].style.display = 'none'; + } + + if(!settings) { + + } else if(settings === 'spectrum') { + rmf_file_select.style.display = 'block'; + arf_file_select.style.display = 'block'; + + for (let i = 0; i < spectrum_elements.length; i++) { + spectrum_elements[i].style.display = 'block'; + } + } else if(settings === 'lightcurve') { + + } + } + resetContainerForCurrentFile() { this.setupComponent(); } + getFilesOptionsList() { + let file_options = []; + let file_list = _registries_FileRegistry__WEBPACK_IMPORTED_MODULE_1__.FileRegistry.getAllFiles(); + + let option = document.createElement("option"); + + option.setAttribute('selected', 'true'); + + option.value = 'none'; + option.text = 'None'; + + file_options.push(option); + + file_list.forEach((file) => { + option = document.createElement("option"); + + option.value = file.id; + option.text = file.file_name; + + file_options.push(option); + }) + + return file_options; + } +} + +/***/ }), + +/***/ "./components/inputs/ArithmeticColumnInput.js": +/*!****************************************************!*\ + !*** ./components/inputs/ArithmeticColumnInput.js ***! + \****************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ ArithmeticColumnInput: () => (/* binding */ ArithmeticColumnInput) +/* harmony export */ }); +/* harmony import */ var _registries_FileRegistry__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../registries/FileRegistry */ "./registries/FileRegistry.js"); +/* harmony import */ var _containers_WrapperContainer__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../containers/WrapperContainer */ "./containers/WrapperContainer.js"); + + + +class ArithmeticColumnInput extends HTMLElement { + + static column_display_id = 'column-display-list'; + static column_create_button_id = 'column-edit-button'; + static column_main_input_id = 'column-main-input'; + static column_list_id = 'column-input-list'; + static input_expression = 'input-expression'; + + static button_commands = ['C', '<--', '-->', 'V'] + + column_display = "
      "; + column_create_button = ""; + column_main_input = "
      " + + "
      " + + "
      " + + "
      " + + "
      " + + "" + + "" + + "" + + "" + + "
      " + + "
      " + + "" + + "" + + "" + + "" + + "
      " + + "
      " + + "" + + "" + + "" + + "" + + "
      " + + "
      " + + "" + + "" + + "" + + "" + + "" + + "
      " + + "
      " + + "
      " + + "
        " + + "
        " + + "
        " + + "
        " + + display_formula = ''; + inner_formula = ''; + + constructor() { + super(); + + this.innerHTML = this.column_display + this.column_main_input + this.column_create_button; + + this.handleFileChangeEvent = this.handleFileChangeEvent.bind(this); + + + this._setupInnerElementsListeners(); + this._setupExternalListeners(); + } + + _setupExternalListeners() { + this.addEventListener('file-registry-change', this.handleFileChangeEvent); + } + + _setupInnerElementsListeners() { + this._setCreateButtonListener(); + this._setKeyboardListener(); + } + + _setCreateButtonListener() { + let create_button = document.getElementById(ArithmeticColumnInput.column_create_button_id); + + create_button.addEventListener('click', (e) => { + let display_main_input = document.getElementById(ArithmeticColumnInput.column_main_input_id); + display_main_input.classList.toggle('visible'); + }) + } + + handleFileChangeEvent(event) { + let current_file_list = _registries_FileRegistry__WEBPACK_IMPORTED_MODULE_0__.FileRegistry.getCurrentFilesList(); + let columns = []; + + this._resetColumnInput(); + + current_file_list.forEach((file) => { + + if(file.type === 'fits') { + let fits_reader_wrapper = _containers_WrapperContainer__WEBPACK_IMPORTED_MODULE_1__.WrapperContainer.getFITSReaderWrapper(); + + fits_reader_wrapper.setFile(file.file); + let fits_columns = fits_reader_wrapper.getAllColumns(); + + fits_columns.forEach((fits_column) => { + let column = {...fits_column, file_id: file.id}; + columns.push(column); + }) + + } + }) + + let columns_by_file = columns.reduce((acc, column) => { + if (!acc[column.file_id]) { + acc[column.file_id] = []; + } + acc[column.file_id].push(column); + return acc; + }, {}); + + let li_group_list = []; + + let i = 1; + for (let file_id in columns_by_file) { + if (columns_by_file.hasOwnProperty(file_id)) { + let file = _registries_FileRegistry__WEBPACK_IMPORTED_MODULE_0__.FileRegistry.getFileById(file_id); + let file_name = file.file_name; + + let frw = _containers_WrapperContainer__WEBPACK_IMPORTED_MODULE_1__.WrapperContainer.getFITSReaderWrapper(); + frw.setFile(file.file); + + li_group_list.push(this.createColumnsList(columns_by_file[file_id], frw)); + } + i++; + } + + this.setColumnInput(li_group_list); + this._setColumnInputListener(); + } + + executeCommand(command) { + let input_display = document.getElementById(ArithmeticColumnInput.input_expression); + + switch (command) { + + case 'C': + input_display.value = ''; + + break; + + case 'V': + this.addColumnToDisplay(input_display.value); + + break; + + case '<--': + + break; + + case '-->': + + break; + + } + } + + createColumnsList(file_columns, fits_reader_wrapper) { + + let li_group = []; + + file_columns.forEach(column => { + let li = document.createElement("li"); + + let hdu_type = fits_reader_wrapper.getHeaderCardValueByNameFromHDU(column.hdu_index, 'XTENSION'); + let hdu_extname = fits_reader_wrapper.getHeaderCardValueByNameFromHDU(column.hdu_index, 'EXTNAME'); + let name = hdu_type+'-'+hdu_extname+' '+column.name; + + if(column.is_from_header) { + name += '(HEADER)'; + } + + if(column.is_processed) { + li.innerHTML = name; + li.setAttribute('dataset-id',`${column.from_file}.${column.hdu_index}$${column.name}`); + } else { + li.innerHTML = name; + li.setAttribute('data-id',`${column.file_id}.${column.hdu_index}$${column.name}`); + } + + li_group.push(li); + }); + + return li_group; + } + + setColumnInput(li_group_list) { + let ul_columns = document.getElementById(ArithmeticColumnInput.column_list_id); + + li_group_list.forEach((li_group) => { + li_group.forEach((li) => { + ul_columns.appendChild(li); + }) + }) + } + + _setKeyboardListener() { + let buttons = document.querySelectorAll('div.button-grid button'); + let input_display = document.getElementById(ArithmeticColumnInput.input_expression); + + buttons.forEach((button) => { + button.addEventListener('click', (e) => { + let operator = button.textContent; + + if(!ArithmeticColumnInput.button_commands.includes(operator)) { + input_display.value += operator; + } else { + this.executeCommand(operator); + } + }); + }); + } + + _resetColumnInput() { + let column_list = document.getElementById(ArithmeticColumnInput.column_list_id); + column_list.innerHTML = ''; + } + + _setColumnInputListener() { + let lis = document.querySelectorAll('ul#column-input-list li'); + let input_display = document.getElementById(ArithmeticColumnInput.input_expression); + + lis.forEach(function(li) { + li.addEventListener('click', (e) => { + let column_id = li.getAttribute('data-id'); + input_display.value += column_id; + }); + }); + } + + addColumnToDisplay(expression) { + let column_display = document.getElementById(ArithmeticColumnInput.column_display_id); + + let li_expression = document.createElement('li'); + li_expression.innerHTML = expression+' '; + li_expression.setAttribute('data-column', expression); + + column_display.appendChild(li_expression); + } + } /***/ }), @@ -1361,10 +1958,14 @@ __webpack_require__.r(__webpack_exports__); /* harmony export */ RegistryContainer: () => (/* binding */ RegistryContainer) /* harmony export */ }); /* harmony import */ var _registries_EventSubscribersRegistry_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../registries/EventSubscribersRegistry.js */ "./registries/EventSubscribersRegistry.js"); +/* harmony import */ var _registries_FileRegistry__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../registries/FileRegistry */ "./registries/FileRegistry.js"); + class RegistryContainer { + static file_registry = null; + constructor() { } @@ -1373,6 +1974,14 @@ class RegistryContainer { return new _registries_EventSubscribersRegistry_js__WEBPACK_IMPORTED_MODULE_0__.EventSubscribersRegistry(); } + getFileRegistry() { + return RegistryContainer.file_registry; + } + + static setFileRegistry(file_registry) { + RegistryContainer.file_registry = file_registry; + } + static getRegistryContainer() { return new RegistryContainer(); } @@ -1607,7 +2216,7 @@ class DataPreProcessor { if(error_bar.column_name === _SpectrumProcessor__WEBPACK_IMPORTED_MODULE_2__.SpectrumProcessor.E_MID_LOG) { column_data.forEach(col_data => { - console.log(col_data); + }) } @@ -1656,6 +2265,9 @@ class DataPreProcessor { processErrorBarDataJSON(dataset, axis, error_bars) { + console.log(error_bars); + console.log(dataset); + let error_bar_x_values = []; let error_bar_y_values = []; @@ -1665,34 +2277,56 @@ class DataPreProcessor { let error_bar_x_column = error_bars.x; let error_bar_y_column = error_bars.y; + let error_bars_object = {}; + dataset.forEach(function(datapoint){ - let error_bar_x = [ - { - bound: parseFloat(datapoint[axis_y]) - parseFloat(datapoint[error_bar_y_column]), - [axis_x]: parseFloat(datapoint[axis_x]) - }, - { - bound: parseFloat(datapoint[axis_y]) + parseFloat(datapoint[error_bar_y_column]), - [axis_x]: parseFloat(datapoint[axis_x]) - } - ] - let error_bar_y = [ - { - bound: parseFloat(datapoint[axis_x]) - parseFloat(datapoint[error_bar_x_column]), - [axis_y]: parseFloat(datapoint[axis_y]) - }, - { - bound: parseFloat(datapoint[axis_x]) + parseFloat(datapoint[error_bar_x_column]), - [axis_y]: parseFloat(datapoint[axis_y]) - } - ] + if(error_bars.x) { + + console.log("X"); + console.log(datapoint[axis_x]); + console.log(error_bar_x_column); + + let error_bar_x = [ + { + bound: parseFloat(datapoint[axis_x]) - parseFloat(datapoint[error_bar_x_column]), + [axis_y]: parseFloat(datapoint[axis_y]) + }, + { + bound: parseFloat(datapoint[axis_x]) + parseFloat(datapoint[error_bar_x_column]), + [axis_y]: parseFloat(datapoint[axis_y]) + } + ] + + error_bar_x_values.push(error_bar_x); + } + + if(error_bars.y) { + + console.log("Y"); + console.log(datapoint[axis_x]); + console.log(error_bar_y_column); + + let error_bar_y = [ + { + bound: parseFloat(datapoint[axis_y]) - parseFloat(datapoint[error_bar_y_column]), + [axis_x]: parseFloat(datapoint[axis_x]) + }, + { + bound: parseFloat(datapoint[axis_y]) + parseFloat(datapoint[error_bar_y_column]), + [axis_x]: parseFloat(datapoint[axis_x]) + } + ] + + error_bar_y_values.push(error_bar_y); + } - error_bar_x_values.push(error_bar_x); - error_bar_y_values.push(error_bar_y); }) - return { x: error_bar_x_values, y: error_bar_y_values } + if(error_bars.x) error_bars_object.x = error_bar_x_values; + if(error_bars.y) error_bars_object.y = error_bar_y_values; + + return error_bars_object; } getSpectrumProcessedColumn(hdu_index, column_name, fits_reader_wrapper) { @@ -2231,6 +2865,25 @@ class InvalidURLError extends Error { /***/ }), +/***/ "./errors/NoEventSubscriberError.js": +/*!******************************************!*\ + !*** ./errors/NoEventSubscriberError.js ***! + \******************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ NoEventSubscriberError: () => (/* binding */ NoEventSubscriberError) +/* harmony export */ }); +class NoEventSubscriberError extends Error { + constructor(message) { + super(message); + this.name = "NoEventSubscriberError"; + } +} + +/***/ }), + /***/ "./errors/NoEventToDispatchError.js": /*!******************************************!*\ !*** ./errors/NoEventToDispatchError.js ***! @@ -2376,13 +3029,15 @@ __webpack_require__.r(__webpack_exports__); /* harmony export */ FileRegistryChangeEvent: () => (/* binding */ FileRegistryChangeEvent) /* harmony export */ }); /* harmony import */ var _containers_RegistryContainer__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../containers/RegistryContainer */ "./containers/RegistryContainer.js"); +/* harmony import */ var _errors_NoEventSubscriberError__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../errors/NoEventSubscriberError */ "./errors/NoEventSubscriberError.js"); + class FileRegistryChangeEvent { static defaultOptions = { bubbles: true, - composed: false + composed: true }; static name = "file-registry-change"; @@ -2419,10 +3074,16 @@ class FileRegistryChangeEvent { let subscribers_id = esr.getSubscribersForEvent(FileRegistryChangeEvent.name); let subscriber_element = null; - subscribers_id.forEach((subscriber_id) => { - subscriber_element = document.getElementById(subscriber_id); - subscriber_element.dispatchEvent(this.event); - }) + try { + subscribers_id.forEach((subscriber_id) => { + subscriber_element = document.getElementById(subscriber_id); + subscriber_element.dispatchEvent(this.event); + }) + } catch(e) { + if(subscribers_id.length <= 0) { + throw new _errors_NoEventSubscriberError__WEBPACK_IMPORTED_MODULE_1__.NoEventSubscriberError(); + } + } } } @@ -2544,8 +3205,9 @@ class EventSubscribersRegistry { 'fits-loaded': ['settings-component', 'file-component'], 'configuration': ['settings-component'], 'file-loaded': ['file-component'], - 'file-selected': ['settings-component'], - 'file-registry-change': ['settings-component', 'file-component'] + 'file-selected': ['settings-component', 'arithmetic-column-component'], + 'file-registry-change': ['settings-component', 'file-component', 'arithmetic-column-component'], + //'arithmetic-column-change': ['settings-component'] } constructor() { @@ -2612,6 +3274,10 @@ class FileRegistry { FileRegistry.file_counter++; } + static _addToAvailableFiles(file) { + FileRegistry.available_files.push(file); + } + static moveToAvailableFiles(file) { FileRegistry.available_files.push(file); } @@ -2632,6 +3298,15 @@ class FileRegistry { FileRegistry.moveToAvailableFiles(file); } + static getAllFiles() { + let available_files = FileRegistry.getAvailableFilesList(); + let current_files = FileRegistry.getCurrentFilesList(); + + let files = available_files.concat(current_files); + + return files; + } + static getFileById(file_id) { let file_array = [...FileRegistry.available_files, ...FileRegistry.current_files]; @@ -2656,6 +3331,22 @@ class FileRegistry { return is_current; } + static setFileMetadata(file_id, metadata) { + let files = FileRegistry.getAllFiles(); + + let file = files.filter(file => file.id !== parseInt(file_id)); + + file = { ...file, ...metadata }; + + if(FileRegistry.isFileCurrent(file_id)) { + FileRegistry.removeFromCurrentFiles(file_id); + FileRegistry.addToCurrentFiles(file); + } else { + FileRegistry.removeFromAvailableFiles(file_id); + FileRegistry._addToAvailableFiles(file); + } + } + static sendRegistryChangeEvent() { let frce = new _events_FileRegistryChangeEvent__WEBPACK_IMPORTED_MODULE_0__.FileRegistryChangeEvent(); frce.dispatchToSubscribers(); @@ -2903,6 +3594,38 @@ class VisualizationSettings { /***/ }), +/***/ "./utils/ColumnUtils.js": +/*!******************************!*\ + !*** ./utils/ColumnUtils.js ***! + \******************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ ColumnUtils: () => (/* binding */ ColumnUtils) +/* harmony export */ }); +class ColumnUtils { + + static getColumnSettings(column_settings) { + let settings = column_settings.split('$'); + + let column_location = settings[0].split('.'); + let column_name = settings[1] || ''; + + let file_id = column_location[0]; + let hdu_index = column_location.length > 1 ? column_location[1] : ''; + + return { + file_id: file_id, + hdu_index: hdu_index, + column_name: column_name + }; + } + +} + +/***/ }), + /***/ "./utils/ObjectUtils.js": /*!******************************!*\ !*** ./utils/ObjectUtils.js ***! @@ -3298,10 +4021,12 @@ class D3Graph { this.x_scale_type = scales['x']; this.y_scale_type = scales['y']; - if (error_bars) { + if(error_bars) { this.has_error_bars = true; this.error_bars = error_bars; + console.log(error_bars); + this.x_axis_data_col_error_bar = axis['x'].value; this.y_axis_data_col_error_bar = axis['y'].value; @@ -3482,34 +4207,35 @@ class D3Graph { this.error_bars = error_bars; - let error_bar_x = {x: error_bars.x}; - - let line_error_bar_x = d3.line() - .x(d => this.x_scale(d[this.x_axis_data_col])) - .y(d => this.y_scale(d.bound)); + if(error_bars.y) { + let line_error_bar_x = d3.line() + .x(d => this.x_scale(d[this.x_axis_data_col])) + .y(d => this.y_scale(d.bound)); - error_bars.x.forEach((error_bar) => { - d3.select('#data-plot').append("path") - .attr("class", "error-bar-x") - .attr("fill", "none") - .attr("stroke", "steelblue") - .attr("stroke-width", 1.5) - .attr("d", line_error_bar_x(error_bar)); - }) + error_bars.y.forEach((error_bar) => { + d3.select('#data-plot').append("path") + .attr("class", "error-bar-x") + .attr("fill", "none") + .attr("stroke", "steelblue") + .attr("stroke-width", 1.5) + .attr("d", line_error_bar_x(error_bar)); + }) + } - let line_error_bar_y = d3.line() - .x(d => this.x_scale(d.bound)) - .y(d => this.y_scale(d[this.y_axis_data_col])); - - error_bars.y.forEach((error_bar) => { - d3.select('#data-plot').append("path") - .attr("class", "error-bar-x") - .attr("fill", "none") - .attr("stroke", "steelblue") - .attr("stroke-width", 1.5) - .attr("d", line_error_bar_y(error_bar)); - }) + if(error_bars.x) { + let line_error_bar_y = d3.line() + .x(d => this.x_scale(d.bound)) + .y(d => this.y_scale(d[this.y_axis_data_col])); + error_bars.x.forEach((error_bar) => { + d3.select('#data-plot').append("path") + .attr("class", "error-bar-x") + .attr("fill", "none") + .attr("stroke", "steelblue") + .attr("stroke-width", 1.5) + .attr("d", line_error_bar_y(error_bar)); + }) + } } _setAxisLine() { @@ -3588,31 +4314,35 @@ class D3Graph { if(this.has_error_bars) { - let line_error_bar_x = d3.line() - .x(d => rescaled_x(d[this.x_axis_data_col])) - .y(d => rescaled_y(d.bound)); - - this.error_bars.x.forEach((error_bar) => { - d3.select('#data-plot').append("path") - .attr("class", "error-bar-x") - .attr("fill", "none") - .attr("stroke", "steelblue") - .attr("stroke-width", 1.5) - .attr("d", line_error_bar_x(error_bar)); - }) - - let line_error_bar_y = d3.line() - .x(d => rescaled_x(d.bound)) - .y(d => rescaled_y(d[this.y_axis_data_col])); + if(this.error_bars.y) { + let line_error_bar_x = d3.line() + .x(d => rescaled_x(d[this.x_axis_data_col])) + .y(d => rescaled_y(d.bound)); + + this.error_bars.y.forEach((error_bar) => { + d3.select('#data-plot').append("path") + .attr("class", "error-bar-x") + .attr("fill", "none") + .attr("stroke", "steelblue") + .attr("stroke-width", 1.5) + .attr("d", line_error_bar_x(error_bar)); + }) + } - this.error_bars.y.forEach((error_bar) => { - d3.select('#data-plot').append("path") - .attr("class", "error-bar-x") - .attr("fill", "none") - .attr("stroke", "steelblue") - .attr("stroke-width", 1.5) - .attr("d", line_error_bar_y(error_bar)); - }) + if(this.error_bars.x) { + let line_error_bar_y = d3.line() + .x(d => rescaled_x(d.bound)) + .y(d => rescaled_y(d[this.y_axis_data_col])); + + this.error_bars.x.forEach((error_bar) => { + d3.select('#data-plot').append("path") + .attr("class", "error-bar-x") + .attr("fill", "none") + .attr("stroke", "steelblue") + .attr("stroke-width", 1.5) + .attr("d", line_error_bar_y(error_bar)); + }) + } } } @@ -3753,10 +4483,7 @@ class BokehWrapper { let processed_data = dpp.getProcessedDataset(dataset_settings); - let processed_json_data = dpp.datasetToJSONData(processed_data); - let data_type = this.settings_object.getDataTypeSettings(); - let hdu = this.settings_object.getHDUsSettings(); let scales = this.settings_object.getScalesSettings(); @@ -3771,6 +4498,25 @@ class BokehWrapper { let data = {x: processed_data.axis[0].data, y: processed_data.axis[1].data}; if(error_bars) { + + console.log(processed_data.error_bars); + + let error_bars_object = {}; + + processed_data.error_bars.forEach((error_bar) => { + error_bar.data = error_bar.data.map(value => !isFinite(value) ? 0 : value); + error_bar.data = error_bar.data.map(value => isNaN(value) ? 0 : value); + + error_bars_object[error_bar.axis] = error_bar.column_name; + + if(error_bar.axis === 'x') { + data.dx = error_bar.data; + } else if(error_bar.axis === 'y') { + data.dy = error_bar.data; + } + }) + + /* error_bars = {x: processed_data.error_bars[0].column_name, y: processed_data.error_bars[1].column_name}; processed_data.error_bars[0].data = processed_data.error_bars[0].data.map(value => !isFinite(value) ? 0 : value); @@ -3778,6 +4524,7 @@ class BokehWrapper { data.dx = processed_data.error_bars[0].data.map(value => isNaN(value) ? 0 : value); data.dy = processed_data.error_bars[1].data.map(value => isNaN(value) ? 0 : value); + */ let asymmetric_uncertainties = false; @@ -3791,7 +4538,6 @@ class BokehWrapper { } let ranges = this.settings_object.getRangesSettings(); - let has_custom_range = false; let custom_range_data = null; if(ranges != null) { @@ -3813,29 +4559,6 @@ class BokehWrapper { } } - getProcessedData(data_type, hdu_index, axis, error_bars) { - let data = null; - - let dpc = _containers_DataProcessorContainer__WEBPACK_IMPORTED_MODULE_1__.DataProcessorContainer.getDataProcessorContainer(); - let data_processor; - - let frw = _containers_WrapperContainer__WEBPACK_IMPORTED_MODULE_3__.WrapperContainer.getFITSReaderWrapper(); - - if(data_type === 'light-curve') { - data_processor = dpc.getLightCurveProcessor(frw, hdu_index); - } else if(data_type === 'spectrum') { - data_processor = dpc.getSpectrumProcessor(frw, hdu_index); - } - - data = data_processor.processDataRawJSON(axis, error_bars); - - if(error_bars) { - data = this._processErrorBarData(data); - } - - return data; - } - _getColumnSettings(column_settings) { let settings = column_settings.split('$'); @@ -3860,6 +4583,38 @@ class BokehWrapper { div_factor = 1; } + if(data.dx) { + let x_low = []; + let x_up = []; + + for(let i in data.dx) { + x_low[i] = data.x[i] - data.dx[i] / div_factor; + x_up[i] = data.x[i] + data.dx[i] / div_factor; + } + + data.x_low = x_low; + data.x_up = x_up; + + delete data.dx; + } + + if(data.dy) { + let y_low = []; + let y_up = []; + + for(let i in data.dy) { + y_low[i] = data.y[i] - data.dy[i]; + y_up[i] = data.y[i] + data.dy[i]; + } + + data.y_low = y_low; + data.y_up = y_up; + + delete data.dy; + + } + + /* let y_low = [], y_up = [], x_low = [], x_up = []; for (let i in data.dy) { @@ -3876,6 +4631,7 @@ class BokehWrapper { delete data.dy; delete data.dx; + */ return data; } @@ -4009,8 +4765,13 @@ class D3Wrapper { axis = {x: processed_data.axis[0].column_name, y: processed_data.axis[1].column_name}; if(has_error_bars) { - error_bars = {x: processed_data.error_bars[0].column_name, y: processed_data.error_bars[1].column_name}; - error_bars = dpp.processErrorBarDataJSON(processed_json_data, axis, error_bars) + let error_bars_object = {}; + + processed_data.error_bars.forEach((error_bar) => { + error_bars_object[error_bar.axis] = error_bar.column_name; + }) + + error_bars = dpp.processErrorBarDataJSON(processed_json_data, axis, error_bars_object) } if(ranges != null) { @@ -4097,6 +4858,7 @@ class FITSReaderWrapper { constructor(file_path = null) { if(file_path) { + console.log(file_path); if (FITSReaderWrapper.is_path_valid(file_path)) { this.file_path = file_path; this._getFile() @@ -4152,6 +4914,12 @@ class FITSReaderWrapper { this.file = file; } + setFileFromFileObject(file_object) { + this.file = file_object.file; + this.arf_file = file_object.arf_file_id; + this.rmf_file = file_object.rmf_file_id; + } + getHDU(hdu_index) { if(hdu_index >= 0 && hdu_index < this.file.hdus.length) { return this.file.hdus[hdu_index]; @@ -4423,6 +5191,15 @@ class FITSReaderWrapper { frw.setFile(ancrfile.file); } + } else if(this.arf_file) { + + let ancrfile = _registries_FileRegistry__WEBPACK_IMPORTED_MODULE_2__.FileRegistry.getFileById(this.arf_file); + + if(ancrfile !== undefined) { + let frw = new FITSReaderWrapper(); + frw.setFile(ancrfile.file); + } + } if(hdu.header.get('RESPFILE') !== null) { @@ -4478,8 +5255,59 @@ class FITSReaderWrapper { }) } - } + } else if(this.rmf_file) { + let respfile = _registries_FileRegistry__WEBPACK_IMPORTED_MODULE_2__.FileRegistry.getFileById(this.rmf_file); + + if(respfile !== undefined) { + let frw = new FITSReaderWrapper(); + + frw.setFile(respfile.file); + + let hdus_index = frw.getTabularHDUs(); + + let has_e_min_max = false; + hdus_index.forEach((hdu_index) => { + let columns_name = frw.getColumnsNameFromHDU(hdu_index); + if (columns_name.includes("E_MIN") && columns_name.includes("E_MAX")) { + has_e_min_max = true; + let e_min_max_hdus_index = hdu_index; + + let column = { + name: 'E_HALF_WIDTH', + hdu_index: hdu_index, + is_from_header: false, + is_processed: true, + from_file: respfile.id + } + + columns.push(column); + + column = { + name: 'E_MID', + hdu_index: hdu_index, + is_from_header: false, + is_processed: true, + from_file: respfile.id + } + + columns.push(column); + + column = { + name: 'E_MID_LOG', + hdu_index: hdu_index, + is_from_header: false, + is_processed: true, + from_file: respfile.id + } + + columns.push(column); + + } + }) + + } + } } }) @@ -4595,6 +5423,12 @@ __webpack_require__.r(__webpack_exports__); /* harmony import */ var _components_file_type_CSVSettingsComponent_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./components/file_type/CSVSettingsComponent.js */ "./components/file_type/CSVSettingsComponent.js"); /* harmony import */ var _visualizations_D3Graph__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./visualizations/D3Graph */ "./visualizations/D3Graph.js"); /* harmony import */ var _visualizations_BokehGraph__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./visualizations/BokehGraph */ "./visualizations/BokehGraph.js"); +/* harmony import */ var _registries_FileRegistry__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./registries/FileRegistry */ "./registries/FileRegistry.js"); +/* harmony import */ var _containers_RegistryContainer__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./containers/RegistryContainer */ "./containers/RegistryContainer.js"); +/* harmony import */ var _components_inputs_ArithmeticColumnInput__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./components/inputs/ArithmeticColumnInput */ "./components/inputs/ArithmeticColumnInput.js"); + + + @@ -4623,11 +5457,14 @@ _containers_WrapperContainer_js__WEBPACK_IMPORTED_MODULE_3__.WrapperContainer.se _containers_VisualizationContainer_js__WEBPACK_IMPORTED_MODULE_4__.VisualizationContainer.setBokehVisualization(new _visualizations_BokehGraph__WEBPACK_IMPORTED_MODULE_11__.BokehGraph()); _containers_VisualizationContainer_js__WEBPACK_IMPORTED_MODULE_4__.VisualizationContainer.setD3Visualization(new _visualizations_D3Graph__WEBPACK_IMPORTED_MODULE_10__.D3Graph()); +_containers_RegistryContainer__WEBPACK_IMPORTED_MODULE_13__.RegistryContainer.setFileRegistry(new _registries_FileRegistry__WEBPACK_IMPORTED_MODULE_12__.FileRegistry()); + customElements.define('file-component', _components_FileComponent_js__WEBPACK_IMPORTED_MODULE_5__.FileComponent); customElements.define('settings-component', _components_SettingsComponent_js__WEBPACK_IMPORTED_MODULE_6__.SettingsComponent); customElements.define('visualization-component', _components_VisualizationComponent_js__WEBPACK_IMPORTED_MODULE_7__.VisualizationComponent); customElements.define('fits-component', _components_file_type_FITSSettingsComponent_js__WEBPACK_IMPORTED_MODULE_8__.FITSSettingsComponent); customElements.define('csv-component', _components_file_type_CSVSettingsComponent_js__WEBPACK_IMPORTED_MODULE_9__.CSVSettingsComponent); +customElements.define('arithmetic-column-component', _components_inputs_ArithmeticColumnInput__WEBPACK_IMPORTED_MODULE_14__.ArithmeticColumnInput); })(); @@ -4635,4 +5472,4 @@ customElements.define('csv-component', _components_file_type_CSVSettingsComponen /******/ })() ; }); -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"astrovis.js","mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD,O;;;;;;;;;;;;;;;;;;ACVgE;AACR;AACkB;AACF;;AAEjE;;AAEP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA,8CAA8C,0EAAgB;;AAE9D;;AAEA,iBAAiB;AACjB;AACA,iBAAiB;AACjB,cAAc;AACd;AACA;AACA;AACA;AACA;;AAEA,SAAS;;AAET;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;;AAEA,+BAA+B,kEAAY;AAC3C;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA,iBAAiB;;AAEjB,aAAa;AACb,SAAS;AACT;;AAEA;AACA;AACA;;AAEA;;AAEA,SAAS;;AAET;AACA;AACA;;AAEA,uBAAuB,kEAAY;;AAEnC,YAAY,kEAAY;;AAExB;AACA;;AAEA,2BAA2B,oFAAuB;AAClD;AACA,SAAS;AACT;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,QAAQ,kEAAY;;AAEpB;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA,SAAS;AACT;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA,6BAA6B,kEAAY;;AAEzC,8CAA8C,mFAAqB;;AAEnE;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA,oBAAoB,kEAAY;AAChC,UAAU;AACV,oBAAoB,kEAAY;AAChC;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,SAAS;;AAET;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;;;;;;;;;AC5RkE;AACE;AACgB;AAC5B;AACQ;;AAEzD;;AAEP;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA,+BAA+B,4EAAiB;;AAEhD;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA,UAAU;AACV;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA,yCAAyC,8EAAoB;AAC7D;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA,UAAU;AACV;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA,iDAAiD,8FAA4B;AAC7E;;AAEA;;AAEA;AACA,gCAAgC,kEAAY;AAC5C;;AAEA;;AAEA;AACA,0CAA0C,0EAAgB;;AAE1D;AACA;;AAEA;AACA,kCAAkC;AAClC;AACA,iBAAiB;;AAEjB,cAAc;;AAEd;AACA,SAAS;;AAET;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,IAAI;;AAEb;;AAEA;AACA;AACA;AACA,2BAA2B,kEAAY;AACvC;;AAEA,0BAA0B,0EAAgB;AAC1C;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA,SAAS;;AAET;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,kCAAkC,iBAAiB,GAAG,iBAAiB,GAAG,YAAY;AACtF,cAAc;AACd;AACA,kCAAkC,eAAe,GAAG,iBAAiB,GAAG,YAAY;AACpF;AACA;AACA;AACA,SAAS;;AAET;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,aAAa;AACb,SAAS;AACT;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,aAAa;AACb,SAAS;;AAET;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,aAAa;AACb,SAAS;AACT;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,aAAa;AACb,SAAS;AACT;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA,SAAS;;AAET;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;;AAEb;AACA,SAAS;AACT;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;;AAEb;AACA,SAAS;AACT;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;;AAEb;AACA,SAAS;AACT;;AAEA;AACA;AACA;AACA;;AAEA,aAAa;AACb,SAAS;AACT;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,aAAa;;AAEb;AACA,SAAS;AACT;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,kBAAkB;AAClB;AACA;AACA,cAAc;;AAEd;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA,qBAAqB;AACrB;AACA;;AAEA;AACA;AACA;AACA,cAAc;AACd;AACA;;AAEA;AACA;AACA;AACA,cAAc;AACd;AACA;;AAEA;AACA,UAAU;AACV;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,mCAAmC;AACnC;AACA,SAAS;;AAET;;AAEA;;AAEA;AACA;AACA;;AAEA,+BAA+B;AAC/B,SAAS;;AAET;;AAEA;AACA;AACA;AACA;;AAEA,+BAA+B;AAC/B,SAAS;;AAET;AACA;;AAEA;;;;;;;;;;;;;;AC3lBO;;AAEP;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;;;;ACpBO;;AAEP;AACA;AACA;;AAEA;;;;;;;;;;;;;;;;;ACNmE;AACR;AACkB;;AAEtE;;AAEP;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA,4GAA4G;AAC5G;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,6FAA6F;AAC7F;;AAEA;AACA;;AAEA;AACA;;AAEA,wFAAwF;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA,kBAAkB,0EAAgB;AAClC;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,SAAS;;AAET;AACA;AACA,SAAS;;AAET;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA,YAAY,kEAAY;;AAExB;;AAEA,2BAA2B,oFAAuB;AAClD;;AAEA;;AAEA,SAAS;;AAET;AACA,YAAY,kEAAY;;AAExB;;AAEA,2BAA2B,oFAAuB;AAClD;;AAEA;AACA,SAAS;AACT;;AAEA;AACA;;AAEA;AACA;;AAEA,kBAAkB,0EAAgB;AAClC;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;;;AAGT;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,aAAa;;AAEb;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;;AAEb,UAAU;AACV;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA,SAAS;;AAET;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;;;;;;;AC5SyE;AACM;AACJ;;AAEpE;;AAEP;;AAEA;;AAEA;AACA,mBAAmB,kFAAgB;AACnC;;AAEA;AACA,mBAAmB,wFAAmB;AACtC;;AAEA;AACA,mBAAmB,oFAAiB;AACpC;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;;;;;AC1BoF;;AAE7E;;AAEP;;AAEA;;AAEA;AACA,mBAAmB,6FAAwB;AAC3C;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;;;;;;AChB4E;AACA;;AAErE;;AAEP;;AAEA;;AAEA;AACA,mBAAmB,qFAAqB;AACxC;;AAEA;AACA,mBAAmB,qFAAqB;AACxC;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;;;;;;ACrByD;AACN;;AAE5C;;AAEP;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV,uBAAuB,kEAAU;AACjC;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV,uBAAuB,4DAAO;AAC9B;AACA;;AAEA;;;;;;;;;;;;;;;;;ACtCoE;AACV;AACN;;AAE7C;;AAEP;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV,uBAAuB,6EAAiB;AACxC;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV,uBAAuB,mEAAY;AACnC;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV,uBAAuB,6DAAS;AAChC;AACA;;AAEA;;;;;;;;;;;;;;;;;;ACpDgE;AACR;AACF;AACsB;;AAErE;;AAEP;;AAEA;;AAEA;AACA;;AAEA;;AAEA,8BAA8B,kEAAY;;AAE1C,sBAAsB,0EAAgB;AACtC;;AAEA;;AAEA;AACA,gBAAgB,iEAAiB;;AAEjC;AACA,cAAc;AACd;AACA;;AAEA;;AAEA,SAAS;;AAET;AACA;;AAEA,kCAAkC,kEAAY;;AAE9C,0BAA0B,0EAAgB;AAC1C;;AAEA;;AAEA;AACA,oBAAoB,iEAAiB;;AAErC;;AAEA,iDAAiD,iEAAiB;AAClE;AACA;AACA,yBAAyB;AACzB;;AAEA,kBAAkB;AAClB;AACA;;AAEA;AACA,aAAa;AACb;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,aAAa;;AAEb,SAAS;;AAET;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,iBAAiB;;AAEjB,aAAa;AACb;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,SAAS;;AAET,iBAAiB;AACjB;;AAEA;AACA;;AAEA,iBAAiB,sFAAsB;;AAEvC;AACA;;AAEA;AACA,kCAAkC,iEAAiB;AACnD,SAAS;;AAET;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,cAAc;AACd;AACA,cAAc;AACd;AACA;;AAEA;AACA;AACA,cAAc;AACd;AACA,cAAc;AACd;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAAS;;AAET;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA,cAAc;AACd;AACA,cAAc;AACd;AACA;;AAEA;AACA,SAAS;;AAET;;AAEA;AACA;;AAEA;AACA;AACA,cAAc;AACd;AACA,cAAc;AACd;AACA;;AAEA;AACA,SAAS;;AAET;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;;AAEA;;;;;;;;;;;;;;AC9QO;;AAEP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA,wDAAwD,QAAQ;AAChE,wDAAwD,QAAQ;;AAEhE;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA,uEAAuE,SAAS;;AAEhF;AACA;AACA;;AAEA,uEAAuE,mBAAmB;;AAE1F;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,SAAS;;AAET,gBAAgB;AAChB;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA,wDAAwD,cAAc;AACtE,UAAU;AACV;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,2BAA2B,qBAAqB;AAChD;AACA;AACA;AACA,aAAa;;AAEb;AACA;AACA;AACA;;AAEA,SAAS;;AAET;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA,wBAAwB,cAAc;AACtC;AACA;;AAEA;AACA;;AAEA,mCAAmC,aAAa;AAChD;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA,UAAU;;AAEV;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;;;;;;;;;;;;;;ACrRO;;AAEP;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,gBAAgB;AAChB;;AAEA;;;;;;;;;;;;;;ACxCO;AACP;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;ACLO;AACP;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;ACLO;AACP;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;ACLO;AACP;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;ACLkE;;AAE3D;;AAEP;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,iDAAiD,cAAc;;AAE/D,wBAAwB,eAAe;AACvC,yBAAyB;;AAEzB;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA,kBAAkB,4EAAiB;AACnC;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;;;;;;;;;;;;;;;;ACnCkE;;AAE3D;;AAEP;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA,2BAA2B,cAAc;;AAEzC,wBAAwB;AACxB,yBAAyB;;AAEzB;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,kBAAkB,4EAAiB;AACnC;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;;;;;;;;;;;;;;;;AChDkE;;AAE3D;;AAEP;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA,2BAA2B,cAAc;;AAEzC,wBAAwB;AACxB,yBAAyB;;AAEzB;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,kBAAkB,4EAAiB;AACnC;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;;;;;;;;;;;;;;;;AChDwE;;AAEjE;;AAEP;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,4CAA4C,cAAc;;AAE1D,wBAAwB,eAAe;AACvC,yBAAyB;;AAEzB;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;AACA,UAAU;AACV,sBAAsB,kFAAsB;AAC5C;AACA;AACA;;;;;;;;;;;;;;;;AChC0E;;AAEnE;;AAEP;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,4CAA4C,cAAc;;AAE1D,wBAAwB,eAAe;AACvC,yBAAyB;;AAEzB;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;AACA,UAAU;AACV,sBAAsB,kFAAsB;AAC5C;AACA;AACA;;;;;;;;;;;;;;;;AChCoF;;AAE7E;;AAEP;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA,UAAU;AACV,sBAAsB,8FAA4B;AAClD;AACA;;AAEA;;;;;;;;;;;;;;;;ACxB0E;AACzB;;AAE1C;;AAEP;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,qBAAqB;AACrB;AACA,uBAAuB,2DAAW;AAClC;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,uBAAuB,oFAAuB;AAC9C;AACA;;AAEA;;;;;;;;;;;;;;;ACrFiD;;AAE1C;;AAEP;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;;AAEA;AACA,SAAS;AACT;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;;AAEA;AACA,SAAS;AACT;AACA;AACA;;AAEA;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA;;AAEA,wBAAwB,2DAAW;;AAEnC;AACA;;AAEA;AACA;;AAEA,wBAAwB,2DAAW;;AAEnC;AACA;;AAEA;;;;;;;;;;;;;;AClFO;;AAEP;AACA;AACA;AACA,gBAAgB;AAChB,kBAAkB;AAClB;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;AC/HO;;AAEP;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,kBAAkB;AAClB;AACA,kBAAkB;AAClB;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;;;;AC1BO;;AAEP;AACA;AACA;;AAEA;AACA,UAAU;AACV;AACA;AACA;;AAEA;;;;;;;;;;;;;;ACZO;;AAEP;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;;AAEA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;;AAEA;AACA,cAAc;AACd;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,kDAAkD,0BAA0B;AAC5E,UAAU;AACV;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;;AAEA;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA,2CAA2C,YAAY,IAAI,YAAY;AACvE;AACA;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;AACA;AACA,mBAAmB,WAAW;AAC9B,oBAAoB,eAAe;AACnC,oBAAoB,cAAc;AAClC;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,WAAW;AAC9B,oBAAoB,eAAe;AACnC,oBAAoB,cAAc;AAClC;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,0CAA0C,4BAA4B;AACtE,0CAA0C,4BAA4B;AACtE;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;;;;AC5NO;;AAEP;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA,SAAS,MAAM,MAAM;;AAErB;;AAEA,oBAAoB;;AAEpB;AACA;;AAEA,cAAc;AACd;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA,cAAc;AACd;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,iBAAiB;;AAEjB;AACA;;AAEA;;AAEA;;AAEA,UAAU;AACV;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,uCAAuC,2BAA2B;AAClE,uCAAuC,2BAA2B;AAClE;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,uBAAuB,sCAAsC;AAC7D;AACA;AACA;;AAEA;;AAEA;;AAEA,2BAA2B;;AAE3B;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,uCAAuC,oCAAoC;AAC3E,uCAAuC,oCAAoC;;AAE3E;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;;AAEb;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;AC3ZgE;AACY;AACA;AACZ;AACQ;;AAEjE;;AAEP;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA,8CAA8C,0EAAkB;;AAEhE;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA,sCAAsC,2BAA2B;;AAEjE;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,0CAA0C,2BAA2B;;AAErE;AACA;;AAEA;AACA;;AAEA,sBAAsB,sFAAsB;;AAE5C;;AAEA;;AAEA;AACA;;AAEA;;;AAGA,oBAAoB;AACpB;;AAEA;AACA;;;AAGA,wBAAwB;;AAExB;AACA,8BAA8B;;AAE9B;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,kBAAkB;AAClB;AACA;;AAEA;AACA;;AAEA,gCAAgC,sFAAsB;;AAEtD;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA,kBAAkB,sFAAsB;AACxC;;AAEA,kBAAkB,0EAAgB;;AAElC;AACA;AACA,UAAU;AACV;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA,oCAAoC,kFAAqB;AACzD;;AAEA;;;;;;;;;;;;;;;;;;ACjPgE;AACY;AACA;AACJ;;AAEjE;;AAEP;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA,8CAA8C,0EAAkB;AAChE;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA,sCAAsC,2BAA2B;;AAEjE;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,0CAA0C,2BAA2B;;AAErE;AACA;;AAEA;AACA;;AAEA,sBAAsB,sFAAsB;;AAE5C;AACA;;AAEA,oBAAoB;;AAEpB;AACA,8BAA8B;AAC9B;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;;AAEA,gCAAgC,sFAAsB;;AAEtD;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,oCAAoC,kFAAqB;AACzD;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;;;;;;;;AChK0D;AACM;AACR;AACP;AACS;;AAEnD;;AAEP;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd,0BAA0B,oEAAe;AACzC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,UAAU;AACV,sBAAsB,oEAAe;AACrC;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,4DAA4D,gBAAgB;AAC5E;AACA;AACA,aAAa;AACb;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA,UAAU;AACV;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,cAAc;AACd;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,SAAS;;AAET;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA,UAAU;AACV,sBAAsB,0EAAkB;AACxC;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,aAAa;AACb,UAAU;AACV,sBAAsB,0EAAkB;AACxC;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,qBAAqB;AACrB,kBAAkB;;AAElB;;AAEA;AACA,aAAa;;AAEb;;AAEA,4BAA4B,oDAAoD;;AAEhF;;AAEA;AACA;AACA,iBAAiB;;AAEjB;AACA;;AAEA,UAAU;AACV,sBAAsB,0EAAkB;AACxC;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,aAAa;;AAEb,UAAU;AACV,sBAAsB,0EAAkB;AACxC;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;;AAET;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,iBAAiB;;AAEjB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,mCAAmC,kEAAY;AAC/C,wBAAwB,2DAAW;AACnC;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,mCAAmC,kEAAY;AAC/C,wBAAwB,2DAAW;AACnC;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,yBAAyB;;AAEzB;AACA;;AAEA;AACA,SAAS;;AAET;AACA;;AAEA;AACA,yBAAyB,oEAAe;AACxC;AACA;AACA;AACA,SAAS;;AAET;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;;;;;UCnbA;UACA;;UAEA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;;UAEA;UACA;;UAEA;UACA;UACA;;;;;WCtBA;WACA;WACA;WACA;WACA,yCAAyC,wCAAwC;WACjF;WACA;WACA;;;;;WCPA;;;;;WCAA;WACA;WACA;WACA,uDAAuD,iBAAiB;WACxE;WACA,gDAAgD,aAAa;WAC7D;;;;;;;;;;;;;;;;;;;;;;;ACNmE;AACV;AACN;AACgB;AACY;AAClB;AACQ;AACU;AACQ;AACF;AAClC;AACM;;AAEzD;;AAEA,8BAA8B,6EAAiB;;AAE/C,wBAAwB,mEAAY;;AAEpC,qBAAqB,6DAAS;;AAE9B,6EAAgB;AAChB,6EAAgB;AAChB,6EAAgB;;AAEhB,yFAAsB,2BAA2B,mEAAU;AAC3D,yFAAsB,wBAAwB,6DAAO;;AAErD,wCAAwC,uEAAa;AACrD,4CAA4C,+EAAiB;AAC7D,iDAAiD,yFAAsB;AACvE,wCAAwC,iGAAqB;AAC7D,uCAAuC,+FAAoB","sources":["webpack://Astrovis/webpack/universalModuleDefinition","webpack://Astrovis/./components/FileComponent.js","webpack://Astrovis/./components/SettingsComponent.js","webpack://Astrovis/./components/VisualizationComponent.js","webpack://Astrovis/./components/file_type/CSVSettingsComponent.js","webpack://Astrovis/./components/file_type/FITSSettingsComponent.js","webpack://Astrovis/./containers/DataProcessorContainer.js","webpack://Astrovis/./containers/RegistryContainer.js","webpack://Astrovis/./containers/SettingsContainer.js","webpack://Astrovis/./containers/VisualizationContainer.js","webpack://Astrovis/./containers/WrapperContainer.js","webpack://Astrovis/./data_processors/DataPreProcessor.js","webpack://Astrovis/./data_processors/LightCurveProcessor.js","webpack://Astrovis/./data_processors/SpectrumProcessor.js","webpack://Astrovis/./errors/EventNotFoundInRegistryError.js","webpack://Astrovis/./errors/HDUNotTabularError.js","webpack://Astrovis/./errors/InvalidURLError.js","webpack://Astrovis/./errors/NoEventToDispatchError.js","webpack://Astrovis/./events/ConfigurationEvent.js","webpack://Astrovis/./events/FileLoadedEvent.js","webpack://Astrovis/./events/FileRegistryChangeEvent.js","webpack://Astrovis/./events/SettingsChangedEvent.js","webpack://Astrovis/./events/VisualizationGenerationEvent.js","webpack://Astrovis/./registries/EventSubscribersRegistry.js","webpack://Astrovis/./registries/FileRegistry.js","webpack://Astrovis/./settings/SettingsConfiguration.js","webpack://Astrovis/./settings/VisualizationSettings.js","webpack://Astrovis/./utils/ObjectUtils.js","webpack://Astrovis/./utils/StringUtils.js","webpack://Astrovis/./visualizations/BokehGraph.js","webpack://Astrovis/./visualizations/D3Graph.js","webpack://Astrovis/./wrappers/BokehWrapper.js","webpack://Astrovis/./wrappers/D3Wrapper.js","webpack://Astrovis/./wrappers/FITSReaderWrapper.js","webpack://Astrovis/webpack/bootstrap","webpack://Astrovis/webpack/runtime/define property getters","webpack://Astrovis/webpack/runtime/hasOwnProperty shorthand","webpack://Astrovis/webpack/runtime/make namespace object","webpack://Astrovis/./main.js"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Astrovis\"] = factory();\n\telse\n\t\troot[\"Astrovis\"] = factory();\n})(this, () => {\nreturn ","import {WrapperContainer} from \"../containers/WrapperContainer\";\nimport {FileRegistry} from \"../registries/FileRegistry\";\nimport {FileRegistryChangeEvent} from \"../events/FileRegistryChangeEvent\";\nimport {FITSSettingsComponent} from \"./file_type/FITSSettingsComponent\";\n\nexport class FileComponent extends HTMLElement {\n\n    static component_id = \"file_component\";\n    static select_file = \"select-file\";\n    static input_file_url = \"file-input-url\";\n    static input_file_local = \"file-input-local\";\n    static input_file_type = \"select-file-type\";\n    static load_button = \"load-file\";\n\n    static available_files_list_id = 'available-files-list';\n    static current_files_list_id = 'current-files-list';\n\n    static file_settings_container_id = 'file-settings-container';\n\n    static save_button_id = 'save-file-settings';\n    static add_button_id = 'add-to-plot'\n    static remove_button_id = 'remove-from-plot'\n\n    container_id;\n    container;\n\n    fits_reader_wrapper = null;\n\n    constructor(container_id) {\n        super();\n        this.container_id = container_id;\n        this._setContainer();\n\n        this.handleFITSLoadedEvent = this.handleFITSLoadedEvent.bind(this);\n        this.handleSelectChangeEvent = this.handleSelectChangeEvent.bind(this);\n        this.handleLoadFileEvent = this.handleLoadFileEvent.bind(this);\n        this.handleFileLoadedEvent = this.handleFileLoadedEvent.bind(this);\n        this.handleFileRegistryChangeEvent = this.handleFileRegistryChangeEvent.bind(this);\n\n        this._setupExternalListeners();\n        this._setupInnerListeners();\n\n        this._setupInnerElementsListeners();\n    }\n\n    _setupExternalListeners() {\n        this.addEventListener('fits-loaded', this.handleFITSLoadedEvent);\n        this.addEventListener('file-loaded', this.handleFileLoadedEvent)\n        this.addEventListener('file-registry-change', this.handleFileRegistryChangeEvent)\n    }\n\n    _setupInnerListeners() {\n        this.addEventListener('select-change', this.handleSelectChangeEvent);\n        this.addEventListener('load-file', this.handleLoadFileEvent);\n    }\n\n    _setupInnerElementsListeners() {\n        this._setLoadLocalFileButtonListener();\n        this._setFilesListsListeners();\n    }\n\n    _setLoadLocalFileButtonListener() {\n        let file_input = document.getElementById(FileComponent.input_file_local);\n        let type_input = document.getElementById(FileComponent.input_file_type);\n\n        let file_type = type_input.value;\n\n        file_input.addEventListener('change', function(event) {\n            let file = event.target.files[0];\n\n            if(file_type === 'fits') {\n                file.arrayBuffer().then(arrayBuffer => {\n                    let fits_reader_wrapper = WrapperContainer.getFITSReaderWrapper();\n\n                    fits_reader_wrapper.initializeFromBuffer(arrayBuffer, file.name);\n\n                }).catch(error => {\n                    console.error('Error reading file as ArrayBuffer:', error);\n                });\n            } else if(file_type === 'csv') {\n                let reader = new FileReader();\n                reader.onload = function(event) {\n                    let csv_file = event.target.result;\n                };\n            }\n\n        });\n\n    }\n\n    _setFilesListsListeners() {\n        let list_available = document.getElementById(FileComponent.available_files_list_id);\n        let list_current = document.getElementById(FileComponent.current_files_list_id);\n\n        let buttons_available = list_available.querySelectorAll(\"button\");\n        let buttons_current = list_current.querySelectorAll(\"button\");\n\n        let buttons = Array.from(buttons_available).concat(Array.from(buttons_current));\n\n        buttons.forEach(button => {\n            button.addEventListener(\"click\", () => {\n\n                button.classList.toggle(\"active\");\n\n                let aria_current = button.getAttribute(\"aria-current\");\n                if (aria_current && aria_current === \"true\") {\n                    button.removeAttribute(\"aria-current\");\n                    this.clearFileSettingsPanel();\n                } else {\n                    button.setAttribute(\"aria-current\", \"true\");\n\n                    let file = FileRegistry.getFileById(button.getAttribute(\"data-id\"));\n                    this.setFileSettingsPanel(file);\n                }\n\n                let buttons_to_filter = Array.from(buttons);\n\n                let filtered_buttons = buttons_to_filter.filter(list_button => list_button !== button);\n\n                filtered_buttons.forEach(filtered_button => {\n                    filtered_button.classList.remove('active');\n                    filtered_button.removeAttribute('aria-current');\n                })\n\n            });\n        });\n    }\n\n    _setFileSettingsButtonsListeners() {\n        let save_button = document.getElementById(FileComponent.save_button_id);\n        let add_button = document.getElementById(FileComponent.add_button_id);\n\n        save_button.addEventListener('click', (event) => {\n\n        });\n\n        add_button.addEventListener('click', (event) => {\n            let btn = event.target;\n            let file_id = btn.getAttribute('data-id');\n\n            let file = FileRegistry.getFileById(file_id);\n\n            FileRegistry.addToCurrentFiles(file);\n\n            this.updateCurrentFilesList();\n            this.updateAvailableFilesList();\n\n            let frce = new FileRegistryChangeEvent();\n            frce.dispatchToSubscribers();\n        });\n    }\n\n    handleFITSLoadedEvent(event) {\n        this.fits_reader_wrapper = event.detail['fits_reader_wrapper'];\n        let file_path = this.fits_reader_wrapper.getFilePath();\n\n        this._addFileToSelect(file_path);\n    }\n\n    handleFileLoadedEvent(event) {\n        FileRegistry.addToAvailableFiles(event.detail);\n\n        this.updateAvailableFilesList();\n        this._setFilesListsListeners();\n    }\n\n    handleFileRegistryChangeEvent(event) {\n        this.updateAvailableFilesList();\n        this.updateCurrentFilesList();\n\n        this._setFilesListsListeners();\n    }\n\n    handleLoadFileEvent(event) {\n\n    }\n\n    updateFilesLists() {\n        this.updateAvailableFilesList();\n        this.updateCurrentFilesList();\n    }\n\n    updateAvailableFilesList() {\n        let available_files_list_element = document.getElementById(FileComponent.available_files_list_id);\n\n        available_files_list_element.innerHTML = '';\n\n        let file_elements = this._createFileSelection('available');\n\n        file_elements.forEach((file_element) => {\n            available_files_list_element.appendChild(file_element);\n        })\n    }\n\n    updateCurrentFilesList() {\n        let current_files_list_element = document.getElementById(FileComponent.current_files_list_id);\n\n        current_files_list_element.innerHTML = '';\n\n        let file_elements = this._createFileSelection('current');\n\n        file_elements.forEach((file_element) => {\n            current_files_list_element.appendChild(file_element);\n        })\n    }\n\n    clearFileSettingsPanel() {\n        let file_settings_component_container = document.getElementById(FileComponent.file_settings_container_id);\n        file_settings_component_container.innerHTML = '';\n    }\n\n    setFileSettingsPanel(file) {\n        this.clearFileSettingsPanel();\n\n        if(file.type === 'fits') {\n\n            let is_current = FileRegistry.isFileCurrent(file.id);\n\n            let file_settings_component = new FITSSettingsComponent(file, is_current);\n\n            let file_settings_component_container = document.getElementById(FileComponent.file_settings_container_id);\n            file_settings_component_container.appendChild(file_settings_component);\n\n            file_settings_component.setupComponent();\n        }\n\n    }\n\n    _addFileToSelect(file) {\n        let file_option = this._createSelectOption(file);\n        let select = document.getElementById(FileComponent.select_file);\n\n        select.add(file_option);\n    }\n\n    _createFileSelection(list = 'available') {\n        let files;\n\n        if(list === 'available') {\n            files = FileRegistry.getAvailableFilesList();\n        } else {\n            files = FileRegistry.getCurrentFilesList();\n        }\n\n        let selection_elements = [];\n\n        let file_selection;\n        files.forEach((available_file) => {\n            let file_uid = available_file.id+'.'+available_file.file_name;\n\n            file_selection = document.createElement(\"button\");\n            file_selection.setAttribute(\"type\", \"button\");\n            file_selection.setAttribute(\"class\", \"available-file-selection list-group-item list-group-item-action\");\n            file_selection.setAttribute(\"data-id\", available_file.id);\n            file_selection.textContent = file_uid;\n\n            selection_elements.push(file_selection);\n        })\n\n        return selection_elements;\n    }\n\n    _createSelectOption(file_path) {\n        let option = document.createElement(\"option\");\n\n        option.value = file_path;\n        option.text = file_path;\n\n        return option;\n    }\n\n    handleSelectChangeEvent(event) {\n        event.stopPropagation();\n\n    }\n\n    _setContainer() {\n        this.container = document.getElementById(this.container_id)\n    }\n\n    resetContainer() {\n        this.container.innerHTML = \"\";\n    }\n\n}","import {SettingsContainer} from \"../containers/SettingsContainer\";\nimport {SettingsChangedEvent} from \"../events/SettingsChangedEvent\";\nimport {VisualizationGenerationEvent} from \"../events/VisualizationGenerationEvent\";\nimport {FileRegistry} from \"../registries/FileRegistry\";\nimport {WrapperContainer} from \"../containers/WrapperContainer\";\n\nexport class SettingsComponent extends HTMLElement {\n\n    container_id;\n    container\n\n    static component_id = \"settings_component\";\n    static container_id = \"settings-component\";\n\n    static select_library_id = \"select-library\";\n\n    static select_data_type_id = \"select-data-type\";\n\n    static light_curve_settings_id = \"light-curve-settings\"\n    static spectrum_settings_id = \"spectrum-settings\"\n\n    static select_hdus_id = \"select-hdus\";\n\n    static calculation_radio_class = \"calculation-radio\";\n\n    static select_axis_x_id = \"select-axis-x\";\n    static select_axis_y_id = \"select-axis-y\";\n\n    static select_error_bar_x_id = \"select-axis-x-error-bar\";\n    static select_error_bar_y_id = \"select-axis-y-error-bar\";\n\n    static supported_data_types = ['generic', 'light-curve', 'spectrum'];\n\n    fits_reader_wrapper = null;\n    settings_object = null;\n\n    constructor() {\n        super();\n\n        this.container_id = SettingsComponent.container_id;\n        this._setContainer();\n\n        this.settings_object = SettingsContainer.getSettingsContainer().getVisualizationSettingsObject();\n\n        this.handleFITSLoadedEvent = this.handleFITSLoadedEvent.bind(this);\n        this.handleConfigurationEvent = this.handleConfigurationEvent.bind(this);\n\n        this.handleLibraryChangeEvent = this.handleLibraryChangeEvent.bind(this);\n        this.handleDataTypeChangeEvent = this.handleDataTypeChangeEvent.bind(this);\n        this.handleHDUsChangeEvent = this.handleHDUsChangeEvent.bind(this);\n        this.handleGenerateEvent = this.handleGenerateEvent.bind(this);\n        this.handleFileChangeEvent = this.handleFileChangeEvent.bind(this);\n\n        this._setupExternalListeners();\n        this._setupInnerListeners();\n\n        this._setupInnerElementsListeners();\n    }\n\n    _setupExternalListeners() {\n        this.addEventListener('fits-loaded', this.handleFITSLoadedEvent);\n        this.addEventListener('configuration', this.handleConfigurationEvent);\n        this.addEventListener('file-registry-change', this.handleFileChangeEvent);\n    }\n\n    _setupInnerListeners() {\n        this.addEventListener('select-library-change', this.handleLibraryChangeEvent);\n        this.addEventListener('select-data-type-change', this.handleDataTypeChangeEvent);\n        this.addEventListener('select-hdus-change', this.handleHDUsChangeEvent);\n        this.addEventListener('button-generate-click', this.handleGenerateEvent);\n    }\n\n    _setupInnerElementsListeners() {\n        this._setSelectLibraryListener();\n        this._setSelectDataTypeListener()\n        this._setSelectHDUsListener();\n        this._setGenerateButtonListener();\n        this._setCalculationRadioListeners();\n    }\n\n    handleFITSLoadedEvent(event) {\n        this.fits_reader_wrapper = event.detail['fits_reader_wrapper'];\n\n        let hdus = this.fits_reader_wrapper.getHDUs();\n        this._setSelectHDUs(hdus);\n\n        if(this.fits_reader_wrapper.isHDUTabular(hdus[0].index)) {\n            let hdu_columns_name = this.fits_reader_wrapper.getColumnsNameFromHDU(hdus[0].index);\n\n            this._setSelectAxis(hdu_columns_name);\n            this._setSelectErrorBars(hdu_columns_name);\n\n        } else {\n            this._resetSelectAxis();\n            this._resetSelectErrorBars()\n        }\n\n    }\n\n    handleConfigurationEvent(event) {\n        let configuration_object = event.detail.configuration_object;\n\n        this.updateSettings(configuration_object);\n    }\n\n    handleLibraryChangeEvent(event) {\n        event.stopPropagation();\n\n        this.updateSettingsObject();\n\n        let settings_changed_event = new SettingsChangedEvent(this.settings_object);\n        settings_changed_event.dispatch();\n    }\n\n    handleDataTypeChangeEvent(event) {\n        event.stopPropagation();\n        let data_type = event.detail.data_type;\n\n        if(SettingsComponent.supported_data_types.includes(data_type)) {\n            this.updateSettingsObject();\n\n            switch(data_type) {\n\n                case 'light-curve':\n                    document.getElementById(SettingsComponent.light_curve_settings_id).style.display = 'block';\n                    document.getElementById(SettingsComponent.spectrum_settings_id).style.display = 'none';\n                    break;\n\n                case 'spectrum':\n                    document.getElementById(SettingsComponent.spectrum_settings_id).style.display = 'block';\n                    document.getElementById(SettingsComponent.light_curve_settings_id).style.display = 'none';\n                    break;\n\n                default:\n                    document.getElementById(SettingsComponent.spectrum_settings_id).style.display = 'none';\n                    document.getElementById(SettingsComponent.light_curve_settings_id).style.display = 'none';\n            }\n\n        }\n\n    }\n\n    handleHDUsChangeEvent(event) {\n        event.stopPropagation();\n        let hdu_index = event.detail.hdu_index;\n\n        if(this.fits_reader_wrapper.isHDUTabular(hdu_index)) {\n            let hdu_columns_name = this.fits_reader_wrapper.getColumnsNameFromHDU(hdu_index);\n\n            this._setSelectAxis(hdu_columns_name);\n            this._setSelectErrorBars(hdu_columns_name);\n\n        } else {\n            this._resetSelectAxis();\n            this._resetSelectErrorBars()\n        }\n    }\n\n    handleGenerateEvent(event) {\n        event.stopPropagation();\n\n        this.settings_object.reset();\n\n        this.updateSettingsObject();\n\n        let visualization_generation_event = new VisualizationGenerationEvent(this.settings_object);\n        visualization_generation_event.dispatch();\n\n    }\n\n    handleFileChangeEvent(event) {\n        let current_file_list = FileRegistry.getCurrentFilesList();\n        let columns = [];\n\n        current_file_list.forEach((file) => {\n\n            if(file.type === 'fits') {\n                let fits_reader_wrapper = WrapperContainer.getFITSReaderWrapper();\n\n                fits_reader_wrapper.setFile(file.file);\n                let fits_columns = fits_reader_wrapper.getAllColumns();\n\n                fits_columns.forEach((fits_column) => {\n                    let column = {...fits_column, file_id: file.id};\n                    columns.push(column);\n                })\n\n            } else if(file.type === 'csv') {\n\n            }\n        })\n\n        let columns_by_file = columns.reduce((acc, column) => {\n            if (!acc[column.file_id]) {\n                acc[column.file_id] = [];\n            }\n            acc[column.file_id].push(column);\n            return acc;\n        }, {});\n\n        let select_options = [];\n\n        let i = 1;\n        for (let file_id in columns_by_file) {\n            if (columns_by_file.hasOwnProperty(file_id)) {\n                let file = FileRegistry.getFileById(file_id);\n                let file_name = file.file_name;\n\n                let frw = WrapperContainer.getFITSReaderWrapper();\n                frw.setFile(file.file);\n\n                select_options.push(this._createFileColumnsOptionsGroup(columns_by_file[file_id], file_name, 'opt-group', frw));\n            }\n            i++;\n        }\n\n        this._setSelectGroupAxis(select_options);\n        this._setSelectGroupErrorBars(select_options);\n    }\n\n    _setContainer() {\n        this.container = document.getElementById(this.container_id)\n    }\n\n    _resetContainer() {\n        this.container.innerHTML = \"\";\n    }\n\n    _setSelectHDUs(hdus) {\n        this._resetSelectHDUs();\n\n        let select = document.getElementById(SettingsComponent.select_hdus_id);\n\n        let options = this._createHDUsOptions(hdus);\n\n        options.forEach(function(option) {\n            select.add(option);\n        });\n    }\n\n    _resetSelectHDUs() {\n        let select = document.getElementById(SettingsComponent.select_hdus_id);\n        select.innerHTML = '';\n    }\n\n    _createHDUsOptions(HDUs) {\n        let options = [];\n        let option;\n\n        HDUs.forEach(function(hdu, index) {\n            option = document.createElement(\"option\");\n\n            if(index === 0) option.setAttribute('selected', 'true');\n\n            option.value = hdu.index;\n            option.text = hdu.name;\n\n            options.push(option);\n        })\n\n        return options;\n    }\n\n    _createFileColumnsOptionsGroup(file_columns, group_name, group_class, fits_reader_wrapper) {\n\n        let opt_group = document.createElement(\"optgroup\");\n        opt_group.label = group_name;\n        opt_group.className += group_class;\n\n        file_columns.forEach(column => {\n            let option = document.createElement(\"option\");\n\n            let hdu_type = fits_reader_wrapper.getHeaderCardValueByNameFromHDU(column.hdu_index, 'XTENSION');\n            let hdu_extname = fits_reader_wrapper.getHeaderCardValueByNameFromHDU(column.hdu_index, 'EXTNAME');\n            let name = hdu_type+'-'+hdu_extname+' '+column.name;\n\n            if(column.is_from_header) {\n                name += '(HEADER)';\n            }\n\n            if(column.is_processed) {\n                option.text = name;\n                option.value = `${column.from_file}.${column.hdu_index}$${column.name}`;\n            } else {\n                option.text = name;\n                option.value = `${column.file_id}.${column.hdu_index}$${column.name}`;\n            }\n            \n            opt_group.appendChild(option);\n        });\n\n        return opt_group\n    }\n\n    _setSelectAxis(columns) {\n        this._resetSelectAxis();\n\n        let select_axis_x = document.getElementById(SettingsComponent.select_axis_x_id);\n        let select_axis_y = document.getElementById(SettingsComponent.select_axis_y_id);\n\n        let select_axis = [select_axis_x, select_axis_y];\n\n        let options = this._createColumnsOptions(columns);\n\n        options.forEach(function(option) {\n            select_axis.forEach(function(select) {\n                let cloned_option = option.cloneNode(true);\n                select.add(cloned_option);\n            })\n        });\n    }\n\n    _setSelectGroupAxis(columns_optgroup) {\n        this._resetSelectAxis();\n\n        let select_axis_x = document.getElementById(SettingsComponent.select_axis_x_id);\n        let select_axis_y = document.getElementById(SettingsComponent.select_axis_y_id);\n\n        let select_axis = [select_axis_x, select_axis_y];\n\n        columns_optgroup.forEach((column_optgroup) => {\n            select_axis.forEach((select) => {\n                let cloned_optgroup = column_optgroup.cloneNode(true);\n                select.add(cloned_optgroup);\n            })\n        })\n\n    }\n\n    _resetSelectAxis() {\n        let select_axis_x = document.getElementById(SettingsComponent.select_axis_x_id);\n        let select_axis_y = document.getElementById(SettingsComponent.select_axis_y_id);\n\n        select_axis_x.innerHTML = '';\n        select_axis_y.innerHTML = '';\n    }\n\n    _setSelectErrorBars(columns) {\n        this._resetSelectErrorBars();\n\n        let select_error_bar_x = document.getElementById(SettingsComponent.select_error_bar_x_id);\n        let select_error_bar_y = document.getElementById(SettingsComponent.select_error_bar_y_id);\n\n        let select_error_bars = [select_error_bar_x, select_error_bar_y];\n\n        let options = this._createColumnsOptions(columns);\n\n        options.forEach(function(option) {\n            select_error_bars.forEach(function(select) {\n                let cloned_option = option.cloneNode(true);\n                select.add(cloned_option);\n            })\n        });\n    }\n\n    _setSelectGroupErrorBars(columns_optgroup) {\n        this._resetSelectErrorBars();\n\n        let select_error_bar_x = document.getElementById(SettingsComponent.select_error_bar_x_id);\n        let select_error_bar_y = document.getElementById(SettingsComponent.select_error_bar_y_id);\n\n        let select_error_bars = [select_error_bar_x, select_error_bar_y];\n\n        columns_optgroup.forEach((column_optgroup) => {\n            select_error_bars.forEach((select) => {\n                let cloned_optgroup = column_optgroup.cloneNode(true);\n                select.add(cloned_optgroup);\n            })\n        })\n    }\n\n    _resetSelectErrorBars() {\n        let select_error_bar_x = document.getElementById(SettingsComponent.select_error_bar_x_id);\n        let select_error_bar_y = document.getElementById(SettingsComponent.select_error_bar_y_id);\n\n        select_error_bar_x.innerHTML = '';\n        select_error_bar_y.innerHTML = '';\n    }\n\n    _createColumnsOptions(columns) {\n        let options = [];\n        let option;\n\n        columns.forEach(function(column) {\n\n            option = document.createElement(\"option\");\n\n            option.value = column;\n            option.text = column;\n\n            options.push(option);\n        })\n\n        return options;\n    }\n\n    _setSelectLibraryListener() {\n        let select_library = document.getElementById(SettingsComponent.select_library_id);\n\n        select_library.addEventListener('change', (event) => {\n            event.preventDefault();\n            const custom_change_event = new CustomEvent('select-library-change', {\n                bubbles: false,\n                compose: false,\n                cancelable: true,\n                detail: {\n                    library: select_library.value\n                }\n            });\n\n            this.dispatchEvent(custom_change_event);\n        });\n    }\n\n    _setSelectDataTypeListener() {\n        let select_data_type = document.getElementById(SettingsComponent.select_data_type_id);\n\n        select_data_type.addEventListener('change', (event) => {\n            event.preventDefault();\n            const custom_change_event = new CustomEvent('select-data-type-change', {\n                bubbles: false,\n                compose: false,\n                cancelable: true,\n                detail: {\n                    data_type: select_data_type.value\n                }\n            });\n\n            this.dispatchEvent(custom_change_event);\n        });\n    }\n\n    _setSelectHDUsListener() {\n        let select_hdus = document.getElementById(SettingsComponent.select_hdus_id);\n\n        select_hdus.addEventListener('change', (event) => {\n            event.preventDefault();\n            const custom_change_event = new CustomEvent('select-hdus-change', {\n                bubbles: false,\n                compose: false,\n                cancelable: true,\n                detail: {\n                    hdu_index: select_hdus.value\n                }\n            });\n\n            this.dispatchEvent(custom_change_event);\n        });\n    }\n\n    _setCalculationRadioListeners() {\n        let radio_buttons = document.querySelectorAll('.' + SettingsComponent.calculation_radio_class);\n        radio_buttons.forEach(radio_button => {\n            radio_button.addEventListener('change', event => {\n\n            });\n        });\n    }\n\n    _setGenerateButtonListener() {\n        let button_generate = document.getElementById('button-generate');\n\n        button_generate.addEventListener('click', (event) => {\n            event.preventDefault();\n            const custom_change_event = new CustomEvent('button-generate-click', {\n                bubbles: false,\n                compose: false,\n                cancelable: true,\n                detail: {\n\n                }\n            });\n\n            this.dispatchEvent(custom_change_event);\n        });\n    }\n\n    updateSettings(configuration) {\n        for (let [setting, values] of Object.entries(configuration)) {\n\n            let setting_element = document.getElementById(setting);\n            if (setting_element) {\n\n                if (values.display === true) {\n                    setting_element.style.display = 'block';\n                } else {\n                    setting_element.style.display = 'none';\n                }\n            } else {\n\n            }\n        }\n    }\n\n    updateSettingsObject() {\n        let values = this._extractFormValues();\n\n        let library = {};\n        library.library = values['select-library'].value;\n        this.settings_object.setLibrarySettings(library);\n\n        let hdu = {};\n        hdu['hdu_index'] = values['select-hdus'].value;\n        this.settings_object.setHDUsSettings(hdu);\n\n        let data_type = {};\n\n        data_type.type = values['select-data-type'].value;\n        this.settings_object.setDataTypeSettings(data_type);\n\n        if(values['select-axis-x'] && values['select-axis-y']) {\n            let axis = {};\n            let scales = {};\n\n            axis.x = values['select-axis-x'].value;\n            axis.y = values['select-axis-y'].value;\n\n            scales.x = values['select-axis-x-scale'].value;\n            scales.y = values['select-axis-y-scale'].value;\n\n            this.settings_object.setAxisSettings(axis);\n            this.settings_object.setScalesSettings(scales);\n        }\n\n        if(values['has-error-bars-checkbox']) {\n            if(values['has-error-bars-checkbox'].checked === true) {\n                let error_bars = {};\n\n                error_bars.x = values['select-axis-x-error-bar'].value;\n                error_bars.y = values['select-axis-y-error-bar'].value;\n\n                this.settings_object.setErrorBarsSettings(error_bars);\n            }\n        }\n\n        if(values['has-x-range-checkbox'].checked === true || values['has-y-range-checkbox'].checked === true) {\n\n            let ranges = {\n                x: {},\n                y: {}\n            };\n\n            if(values['has-x-range-checkbox'].checked === true) {\n                ranges['x'].lower_bound = values['x-lower-bound'].value;\n                ranges['x'].upper_bound = values['x-higher-bound'].value;\n            } else {\n                ranges['x'] = null;\n            }\n\n            if(values['has-y-range-checkbox'].checked === true) {\n                ranges['y'].lower_bound = values['y-lower-bound'].value;\n                ranges['y'].upper_bound = values['y-higher-bound'].value;\n            } else {\n                ranges['y'] = null;\n            }\n\n            this.settings_object.setRangesSettings(ranges);\n        } else {\n            this.settings_object.setRangesSettings(null);\n        }\n\n    }\n\n    _extractFormValues() {\n\n        let form_values = {};\n\n        let selects = this.container.querySelectorAll('.form-select');\n\n        selects.forEach(select => {\n            let id = select.id;\n            let classes = select.className.split(' ');\n            let value = select.value;\n\n            if(window.getComputedStyle(select, null).getPropertyValue(\"display\") !== 'none' && value !== 'none') {\n                form_values[id] = {classes, value};\n            }\n        });\n\n        let checkboxes = this.container.querySelectorAll('.form-checkbox');\n\n        checkboxes.forEach(checkbox => {\n\n            let id = checkbox.id;\n            let classes = checkbox.className.split(' ');\n            let checked = checkbox.checked;\n\n            form_values[id] = {classes, checked};\n        });\n\n        let inputs = this.container.querySelectorAll('.form-input');\n\n        inputs.forEach(input => {\n            let id = input.id;\n            let classes = input.className.split(' ');\n            let value = input.value;\n\n            form_values[id] = {classes, value};\n        })\n\n        return form_values;\n    }\n\n}","export class VisualizationComponent extends HTMLElement {\n\n    container_id;\n    container\n\n    constructor(container_id) {\n        super();\n\n        this.container_id = container_id;\n        this._setContainer();\n    }\n\n    _setContainer() {\n        this.container = document.getElementById(this.container_id)\n    }\n\n    resetContainer() {\n        this.container.innerHTML = \"\";\n    }\n\n}","export class CSVSettingsComponent extends HTMLElement {\n\n    constructor(file_id) {\n        super();\n    }\n\n}","import {WrapperContainer} from \"../../containers/WrapperContainer\";\nimport {FileRegistry} from \"../../registries/FileRegistry\";\nimport {FileRegistryChangeEvent} from \"../../events/FileRegistryChangeEvent\";\n\nexport class FITSSettingsComponent extends HTMLElement {\n\n    container_id = \"fits-settings-container\";\n    select_hdu_id = \"select-hdu-file\";\n    table_header_id = \"table-header-data\";\n    table_data_id = \"table-data\";\n\n    file = null;\n    is_current = false;\n\n    add_to_plot_btn_id = \"add-to-plot\";\n    remove_from_plot_btn_id = \"remove-from-plot\";\n\n    container = '<div id=\"fits-settings-container\" class=\"full-width-column\" style=\"grid-column: 1 / span 2;\">' +\n        '<div class=\"card\">' +\n        '<div class=\"card-body\">' +\n        '</div>' +\n        '</div>' +\n        '</div>';\n\n    select_hdu_file = '<select id=\"select-hdu-file\" class=\"form-select\"></select>';\n\n    inner_container = '<div class=\"inner-row\"></div>';\n\n    header_column = '<div class=\"left-column\">' +\n        '<div class=\"card-header\">Header</div>' +\n        '<div class=\"card-body\">' +\n        '<div id=\"header-hdu-file\">' +\n        '</div>' +\n        '</div>';\n\n    table_header = '<table id=\"table-header-data\" class=\"table table-striped\">' +\n        '    <thead>' +\n        '    <tr>' +\n        '        <th scope=\"col\">#</th>' +\n        '        <th scope=\"col\">Name</th>' +\n        '        <th scope=\"col\">Value</th>' +\n        '        <th scope=\"col\">Comment</th>' +\n        '    </tr>' +\n        '    </thead>' +\n        '    <tbody class=\"table-group-divider\">' +\n        '    </tbody>' +\n        '</table>'\n\n    data_column = '<div class=\"right-column\">' +\n        '<div class=\"card-header\">Data</div>' +\n        '<div class=\"card-body\">' +\n        '   <div id=\"data-hdu-file\">' +\n        '   </div>' +\n        '</div>';\n\n    table_data = '<table id=\"table-data\" class=\"table table-striped\">' +\n        '    <thead>' +\n        '       <tr>' +\n        '       </tr>' +\n        '    </thead>' +\n        '    <tbody class=\"table-group-divider\">' +\n        '    </tbody>' +\n        '</table>'\n\n    btn_save_settings = '<button class=\"btn btn-success\" id=\"save-file-settings\">Save changes</button>';\n    btn_add_to_plot = '<button class=\"btn btn-primary\" id=\"add-to-plot\">Add to plot</button>;'\n    btn_remove_from_plot = '<button class=\"btn btn-danger\" id=\"remove-from-plot\">Remove from plot</button>';\n\n    constructor(file, is_current) {\n        super();\n\n        this.file = file;\n        this.is_current = is_current;\n\n        this.innerHTML = '<div class=\"full-width-column\" style=\"grid-column: 1 / span 2;\">\\n' +\n            '                            <div class=\"card\">\\n' +\n            '                                <div class=\"card-header\">File settings</div>\\n' +\n            '                                <div class=\"card-body\">\\n' +\n            '                                    <select id=\"select-hdu-file\" class=\"form-select\">\\n' +\n            '\\n' +\n            '                                    </select>\\n' +\n            '\\n' +\n            '                                    <div class=\"inner-row\">\\n' +\n            '                                        <div class=\"left-column\">\\n' +\n            '                                            <div class=\"card\">\\n' +\n            '                                                <div class=\"card-header\">Header</div>\\n' +\n            '                                                <div class=\"card-body\">\\n' +\n            '                                                    <div id=\"header-hdu-file\" class=\"file-data-container\">\\n' +\n            '                                                        <table id=\"table-header-data\" class=\"table table-striped\">\\n' +\n            '                                                            <thead>\\n' +\n            '                                                            <tr>\\n' +\n            '                                                                <th scope=\"col\">#</th>\\n' +\n            '                                                                <th scope=\"col\">Name</th>\\n' +\n            '                                                                <th scope=\"col\">Value</th>\\n' +\n            '                                                                <th scope=\"col\">Comment</th>\\n' +\n            '                                                            </tr>\\n' +\n            '                                                            </thead>\\n' +\n            '                                                            <tbody class=\"table-group-divider\">\\n' +\n            '\\n' +\n            '                                                            </tbody>\\n' +\n            '                                                        </table>\\n' +\n            '                                                    </div>\\n' +\n            '                                                </div>\\n' +\n            '                                            </div>\\n' +\n            '                                        </div>\\n' +\n            '                                        <div class=\"right-column\">\\n' +\n            '                                            <div class=\"card\">\\n' +\n            '                                                <div class=\"card-header\">Data</div>\\n' +\n            '                                                <div class=\"card-body\">\\n' +\n            '                                                    <div id=\"data-hdu-file\" class=\"file-data-container\">\\n' +\n            '<table id=\"table-data\" class=\"table table-striped\">' +\n                '    <thead>' +\n                '       <tr>' +\n                    '       </tr>' +\n                '    </thead>' +\n                '    <tbody class=\"table-group-divider\">' +\n                '    </tbody>' +\n                '</table>'+\n            '                                                    </div>\\n' +\n            '                                                </div>\\n' +\n            '                                            </div>\\n' +\n            '                                        </div>\\n' +\n            '                                    </div>\\n' +\n            '\\n' +\n            '                                    <!-- button class=\"btn btn-success\" id=\"save-file-settings\">Save changes</button -->\\n' +\n            '                                    <button class=\"btn btn-primary\" id=\"add-to-plot\">Add to plot</button>\\n' +\n            '                                    <button class=\"btn btn-danger\" id=\"remove-from-plot\">Remove from plot</button>\\n' +\n            '                                </div>\\n' +\n            '                            </div>\\n' +\n            '                        </div>'\n\n    }\n\n    setupComponent() {\n        this.setHDUSelect();\n        this.setupActionButtons();\n\n        let select_hdu = document.getElementById(this.select_hdu_id);\n        let hdu_index = select_hdu.value;\n\n        this.setTables(hdu_index);\n\n        this.setupInnerElementListeners();\n    }\n\n    setHDUSelect() {\n\n        let select_hdu = document.getElementById(this.select_hdu_id);\n\n        select_hdu.innerHTML = '';\n\n        let frw = WrapperContainer.getFITSReaderWrapper();\n        frw.setFile(this.file.file);\n\n        let hdus = frw.getHDUs();\n\n        let options = [];\n        hdus.forEach((hdu) => {\n            let option = document.createElement(\"option\");\n\n            option.value = hdu.index;\n            option.text = hdu.name + ' ' + hdu.extname;\n\n            options.push(option);\n        })\n\n        options.forEach((option) => {\n            select_hdu.add(option);\n        })\n\n    }\n\n    setupInnerElementListeners() {\n        this.setHDUSelectListener();\n    }\n\n    setupActionButtons() {\n\n        let add_to_plot_btn = document.getElementById(this.add_to_plot_btn_id);\n        let remove_from_plot_btn  = document.getElementById(this.remove_from_plot_btn_id);\n\n        if(this.is_current) {\n            add_to_plot_btn.style.display = 'none';\n            remove_from_plot_btn.style.display = 'initial';\n        } else {\n            add_to_plot_btn.style.display = 'initial';\n            remove_from_plot_btn.style.display = 'none';\n        }\n\n        add_to_plot_btn.addEventListener('click', (event) => {\n            FileRegistry.addToCurrentFiles(this.file);\n\n            this.is_current = true;\n\n            let frce = new FileRegistryChangeEvent();\n            frce.dispatchToSubscribers();\n\n            this.resetContainerForCurrentFile();\n\n        });\n\n        remove_from_plot_btn.addEventListener('click', (event) => {\n            FileRegistry.removeFromCurrentFiles(this.file.id);\n\n            this.is_current = false;\n\n            let frce = new FileRegistryChangeEvent();\n            frce.dispatchToSubscribers();\n\n            this.resetContainerForCurrentFile();\n        });\n    }\n\n    setTables(hdu_index) {\n        this.resetTables();\n\n        let table_header = document.getElementById(this.table_header_id);\n        let table_data = document.getElementById(this.table_data_id);\n\n        let frw = WrapperContainer.getFITSReaderWrapper();\n        frw.setFile(this.file.file);\n\n        let hdu_cards = frw.getHeaderCardsValueFromHDU(hdu_index)\n\n        let tbody = table_header.querySelector('tbody');\n\n        hdu_cards.forEach(card => {\n\n            let row = tbody.insertRow();\n\n            let index_cell = row.insertCell(0);\n            let card_cell = row.insertCell(1);\n            let name_cell = row.insertCell(2);\n            let description_cell = row.insertCell(3);\n\n            index_cell.textContent = card.index;\n            card_cell.textContent = card.card_name;\n            name_cell.textContent = card.value;\n            description_cell.textContent = card.comment;\n        });\n\n\n        try {\n\n            let hdu_columns_name = frw.getColumnsNameFromHDU(hdu_index);\n            let hdu_data = frw.getColumnsJSONDataFromHDU(hdu_index)\n\n            let header_row = table_data.tHead.insertRow();\n            tbody = table_data.querySelector('tbody');\n\n            hdu_columns_name.forEach((column) => {\n                let header_cell = document.createElement('th');\n                header_cell.textContent = column;\n                header_row.appendChild(header_cell);\n            });\n\n            hdu_data.forEach(data_point => {\n\n                const row = tbody.insertRow();\n                for (let key in data_point) {\n                    if (Object.hasOwnProperty.call(data_point, key)) {\n                        let cell = row.insertCell();\n                        cell.textContent = data_point[key];\n                    }\n                }\n            });\n\n        } catch(e) {\n            console.log(\"DATA PARSING ERROR\");\n        }\n    }\n\n    resetTables() {\n        let table_header = document.getElementById(this.table_header_id);\n        let table_data = document.getElementById(this.table_data_id);\n\n        let tbody = table_header.querySelector('tbody');\n        tbody.innerHTML = '';\n\n        tbody = table_data.querySelector('tbody');\n        let thead = table_data.querySelector('thead');\n\n        tbody.innerHTML = '';\n        thead.innerHTML = '<tr></tr>';\n    }\n\n    setHDUSelectListener() {\n\n        let select_element = document.getElementById(this.select_hdu_id);\n\n        select_element.addEventListener('change', (event) => {\n            this.setTables(event.target.value);\n        });\n\n    }\n\n    resetContainerForCurrentFile() {\n        this.setupComponent();\n    }\n\n}","import { DataPreProcessor } from '../data_processors/DataPreProcessor.js'\nimport { LightCurveProcessor } from '../data_processors/LightCurveProcessor.js'\nimport { SpectrumProcessor } from '../data_processors/SpectrumProcessor.js'\n\nexport class DataProcessorContainer {\n\n    constructor() {\n\n    }\n\n    getDataPreProcessor() {\n        return new DataPreProcessor();\n    }\n\n    getLightCurveProcessor(fits_reader_wrapper, hdu_index) {\n        return new LightCurveProcessor(fits_reader_wrapper, hdu_index);\n    }\n\n    getSpectrumProcessor() {\n        return new SpectrumProcessor();\n    }\n\n    static getDataProcessorContainer() {\n        return new DataProcessorContainer();\n    }\n\n}","import { EventSubscribersRegistry } from '../registries/EventSubscribersRegistry.js'\n\nexport class RegistryContainer {\n\n    constructor() {\n\n    }\n\n    getEventSubscribersRegistry() {\n        return new EventSubscribersRegistry();\n    }\n\n    static getRegistryContainer() {\n        return new RegistryContainer();\n    }\n\n}","import { VisualizationSettings } from '../settings/VisualizationSettings.js'\nimport { SettingsConfiguration } from '../settings/SettingsConfiguration.js'\n\nexport class SettingsContainer {\n\n    constructor() {\n\n    }\n\n    getVisualizationSettingsObject() {\n        return new VisualizationSettings();\n    }\n\n    getSettingsConfigurationObject() {\n        return new SettingsConfiguration();\n    }\n\n    static getSettingsContainer() {\n        return new SettingsContainer();\n    }\n\n}","import { BokehGraph } from '../visualizations/BokehGraph'\nimport { D3Graph } from '../visualizations/D3Graph'\n\nexport class VisualizationContainer {\n\n    static bokeh_graph = null;\n    static d3_graph = null;\n\n    static visualization_container = '#visualization-container'\n\n    constructor() {\n\n    }\n\n    static setBokehVisualization(bokeh_visualization) {\n        VisualizationContainer.bokeh_visualization = bokeh_visualization;\n    }\n\n    static setD3Visualization(d3_visualization) {\n        VisualizationContainer.d3_visualization = d3_visualization;\n    }\n\n    static getBokehVisualization() {\n        if(VisualizationContainer.bokeh_visualization !== null) {\n            return VisualizationContainer.bokeh_visualization;\n        } else {\n            return new BokehGraph(VisualizationContainer.visualization_container);\n        }\n    }\n\n    static getD3Visualization() {\n        if(VisualizationContainer.d3_visualization !== null) {\n            return VisualizationContainer.d3_visualization;\n        } else {\n            return new D3Graph(VisualizationContainer.visualization_container);\n        }\n    }\n\n}","import { FITSReaderWrapper } from '../wrappers/FITSReaderWrapper.js'\nimport { BokehWrapper } from '../wrappers/BokehWrapper.js'\nimport { D3Wrapper } from '../wrappers/D3Wrapper.js'\n\nexport class WrapperContainer {\n\n    static fits_reader_wrapper = null;\n    static bokeh_wrapper = null;\n    static d3_wrapper = null;\n\n    static visualization_container = 'visualization-container'\n\n    constructor() {\n\n    }\n\n    static setFITSReaderWrapper(fits_reader_wrapper) {\n        WrapperContainer.fits_reader_wrapper = fits_reader_wrapper;\n    }\n\n    static setBokehWrapper(bokeh_wrapper) {\n        WrapperContainer.bokeh_wrapper = bokeh_wrapper;\n    }\n\n    static setD3Wrapper(d3_wrapper) {\n        WrapperContainer.d3_wrapper = d3_wrapper;\n    }\n\n    static getFITSReaderWrapper() {\n        if(WrapperContainer.fits_reader_wrapper !== null) {\n            return WrapperContainer.fits_reader_wrapper;\n        } else {\n            return new FITSReaderWrapper('');\n        }\n    }\n\n    static getBokehWrapper() {\n        if(WrapperContainer.bokeh_wrapper !== null) {\n            return WrapperContainer.bokeh_wrapper;\n        } else {\n            return new BokehWrapper(WrapperContainer.visualization_container);\n        }\n    }\n\n    static getD3Wrapper() {\n        if(WrapperContainer.d3_wrapper !== null) {\n            return WrapperContainer.d3_wrapper;\n        } else {\n            return new D3Wrapper(WrapperContainer.visualization_container);\n        }\n    }\n\n}","import {WrapperContainer} from \"../containers/WrapperContainer\";\nimport {FileRegistry} from \"../registries/FileRegistry\";\nimport {SpectrumProcessor} from \"./SpectrumProcessor\";\nimport {DataProcessorContainer} from \"../containers/DataProcessorContainer\";\n\nexport class DataPreProcessor {\n\n    constructor() {\n\n    }\n\n    getProcessedDataset(dataset_settings_object) {\n        let dataset = {};\n\n        dataset_settings_object.axis.forEach((axis) => {\n\n            let file_object = FileRegistry.getFileById(axis.file_id);\n\n            let frw = WrapperContainer.getFITSReaderWrapper();\n            frw.setFile(file_object.file);\n\n            let column_data;\n\n            if(dataset_settings_object.data_type.type === 'spectrum' &&\n                SpectrumProcessor.processed_columns_name.includes(axis.column_name)) {\n\n                column_data = this.getSpectrumProcessedColumn(axis.hdu_index, axis.column_name, frw)\n            } else {\n                column_data = frw.getColumnDataFromHDU(axis.hdu_index, axis.column_name);\n            }\n\n            axis.data = column_data;\n\n        })\n\n        if(dataset_settings_object.hasOwnProperty('error_bars')) {\n            dataset_settings_object.error_bars.forEach((error_bar) => {\n\n                let file_object = FileRegistry.getFileById(error_bar.file_id);\n\n                let frw = WrapperContainer.getFITSReaderWrapper();\n                frw.setFile(file_object.file);\n\n                let column_data;\n\n                if(dataset_settings_object.data_type.type === 'spectrum' &&\n                    SpectrumProcessor.processed_columns_name.includes(error_bar.column_name)) {\n\n                    column_data = this.getSpectrumProcessedColumn(error_bar.hdu_index, error_bar.column_name, frw)\n\n                    if(error_bar.column_name === SpectrumProcessor.E_MID_LOG) {\n                        column_data.forEach(col_data => {\n                            console.log(col_data);\n                        })\n                    }\n\n                } else {\n                    column_data = frw.getColumnDataFromHDU(error_bar.hdu_index, error_bar.column_name);\n                }\n\n                error_bar.data = column_data;\n            })\n        }\n\n        dataset = dataset_settings_object;\n\n        return dataset;\n    }\n\n    datasetToJSONData(dataset_settings_object) {\n        let rows = [];\n\n        dataset_settings_object.axis.forEach((axis) => {\n\n            axis.data.forEach((value, index) => {\n                if (!rows[index]) {\n                    rows[index] = {};\n                }\n                rows[index][axis.column_name] = value;\n            });\n\n        })\n\n        if(dataset_settings_object.hasOwnProperty('error_bars')) {\n            dataset_settings_object.error_bars.forEach((error_bar) => {\n\n                error_bar.data.forEach((value, index) => {\n                    if (!rows[index]) {\n                        rows[index] = {};\n                    }\n                    rows[index][error_bar.column_name] = value;\n                });\n\n            })\n        }\n\n        return rows;\n    }\n\n    processErrorBarDataJSON(dataset, axis, error_bars) {\n\n        let error_bar_x_values = [];\n        let error_bar_y_values = [];\n\n        let axis_x = axis.x;\n        let axis_y = axis.y;\n\n        let error_bar_x_column = error_bars.x;\n        let error_bar_y_column = error_bars.y;\n\n        dataset.forEach(function(datapoint){\n            let error_bar_x = [\n                {\n                    bound: parseFloat(datapoint[axis_y]) - parseFloat(datapoint[error_bar_y_column]),\n                    [axis_x]: parseFloat(datapoint[axis_x])\n                },\n                {\n                    bound: parseFloat(datapoint[axis_y]) + parseFloat(datapoint[error_bar_y_column]),\n                    [axis_x]: parseFloat(datapoint[axis_x])\n                }\n            ]\n\n            let error_bar_y = [\n                {\n                    bound: parseFloat(datapoint[axis_x]) - parseFloat(datapoint[error_bar_x_column]),\n                    [axis_y]: parseFloat(datapoint[axis_y])\n                },\n                {\n                    bound: parseFloat(datapoint[axis_x]) + parseFloat(datapoint[error_bar_x_column]),\n                    [axis_y]: parseFloat(datapoint[axis_y])\n                }\n            ]\n\n            error_bar_x_values.push(error_bar_x);\n            error_bar_y_values.push(error_bar_y);\n        })\n\n        return { x: error_bar_x_values, y: error_bar_y_values }\n    }\n\n    getSpectrumProcessedColumn(hdu_index, column_name, fits_reader_wrapper) {\n        let processed_column = [];\n\n        let sp = DataProcessorContainer.getDataProcessorContainer().getSpectrumProcessor();\n\n        let e_min_col = fits_reader_wrapper.getColumnDataFromHDU(hdu_index, \"E_MIN\");\n        let e_max_col = fits_reader_wrapper.getColumnDataFromHDU(hdu_index, \"E_MAX\");\n\n        e_min_col.forEach((e_min, index) => {\n            processed_column.push(SpectrumProcessor.spectrum_col_functions[column_name](e_min, e_max_col[index]));\n        })\n\n        return processed_column;\n    }\n\n    processDataForRange(ranges, data, error_bars = null) {\n        let temp_processed_data = [];\n        let temp_processed_error_bars = {};\n        let temp_error_bar_x = [];\n        let temp_error_bar_y = [];\n        let processed_data = [];\n\n        data.forEach((data_point, i) => {\n            let keys = Object.keys(data_point);\n            let x_column = keys[0];\n            let y_column = keys[1];\n\n            if (ranges.x === null) {\n                data_point.match_range_x = true;\n            } else if (data_point[x_column] >= ranges.x.lower_bound && data_point[x_column] <= ranges.x.upper_bound) {\n                data_point.match_range_x = true;\n            } else {\n                data_point.match_range_x = false;\n            }\n\n            if(ranges.y === null) {\n                data_point.match_range_y = true;\n            } else if(data_point[y_column] >= ranges.y.lower_bound && data_point[y_column] <= ranges.y.upper_bound) {\n                data_point.match_range_y = true;\n            } else {\n                data_point.match_range_y = false;\n            }\n\n            if(data_point.match_range_x + data_point.match_range_y == 2) {\n                temp_processed_data.push(data_point);\n                if(error_bars != null) {\n                    temp_error_bar_x.push(error_bars.x[i]);\n                    temp_error_bar_y.push(error_bars.y[i]);\n                }\n            }\n\n        })\n\n        if(error_bars != null) {\n            temp_processed_error_bars.x = temp_error_bar_x;\n            temp_processed_error_bars.y = temp_error_bar_y;\n            processed_data.error_bars = temp_processed_error_bars;\n        }\n\n        processed_data.data = temp_processed_data;\n\n        return processed_data;\n    }\n\n    processDataForRangeBokeh(ranges, data, has_error_bars = false) {\n        let processed_data = {};\n        processed_data.x = [];\n        processed_data.y = []\n\n        if(has_error_bars) {\n            processed_data.x_low = [];\n            processed_data.x_up = [];\n            processed_data.y_low = [];\n            processed_data.y_up = [];\n        }\n\n        let temp_x = [];\n        let temp_y = [];\n\n        data.x.forEach((data_point) => {\n\n            let temp_data_object = {};\n            temp_data_object.value = data_point;\n\n            if (ranges.x === null) {\n                temp_data_object.match_range_x = true;\n            } else if (data_point >= ranges.x.lower_bound && data_point <= ranges.x.upper_bound) {\n                temp_data_object.match_range_x = true;\n            } else {\n                temp_data_object.match_range_x = false;\n            }\n\n            temp_x.push(temp_data_object);\n        })\n\n        data.y.forEach((data_point) => {\n\n            let temp_data_object = {};\n            temp_data_object.value = data_point;\n\n            if (ranges.y === null) {\n                temp_data_object.match_range_y = true;\n            } else if (data_point >= ranges.y.lower_bound && data_point <= ranges.y.upper_bound) {\n                temp_data_object.match_range_y = true;\n            } else {\n                temp_data_object.match_range_y = false;\n            }\n\n            temp_y.push(temp_data_object)\n        })\n\n        temp_x.forEach((data_point_x, i) => {\n            let data_point_y = temp_y[i];\n\n            if(data_point_x.match_range_x + data_point_y.match_range_y == 2) {\n                processed_data.x.push(data_point_x.value);\n                processed_data.y.push(data_point_y.value);\n\n                if(has_error_bars) {\n                    processed_data.y_low.push(data.y_low[i]);\n                    processed_data.y_up.push(data.y_up[i]);\n                    processed_data.x_low.push(data.x_low[i]);\n                    processed_data.x_up.push(data.x_up[i]);\n                }\n            }\n        })\n\n        return processed_data;\n    }\n\n}","export class LightCurveProcessor {\n\n    static header_cards = [\n        'TIMEREF',\n        'TIMEDEL',\n        'MJDREF',\n        'TSTART',\n        'TSTOP',\n        'TELAPSE',\n        'E_MIN',\n        'E_MAX',\n        'E_UNIT']\n\n    static columns_names = {\n        time: 'TIME',\n        timedel: 'TIMEDEL',\n        rate: 'RATE',\n        error: 'ERROR',\n        fracexp: 'FRACEXP'\n    }\n\n    static binning_types = {\n        'TIME_BASED': 'time_based',\n        'EQUAL_COUNT': 'equal_count'\n    }\n\n    static bin_value_methods = [\n        'mean',\n        'weightedmean',\n        'median',\n        'wmedian',\n        'stddev',\n        'meddev',\n        'kurtosis',\n        'skewness',\n        'max',\n        'min',\n        'sum'\n    ]\n\n    static min_columns_number = 2;\n    static mandatory_columns = ['RATE'];\n    static replacement_columns = ['TIMEDEL'];\n\n    hdu;\n    hdu_index = null;\n\n    binning_type;\n    method;\n\n    fits_reader_wrapper;\n    header_values = {};\n\n    constructor(fits_reader_wrapper, hdu_index) {\n        this.fits_reader_wrapper = fits_reader_wrapper;\n        this.hdu_index = hdu_index;\n\n        this._setHDU();\n    }\n\n    _setHDU() {\n        this.hdu = this.fits_reader_wrapper.getHDU(this.hdu_index);\n    }\n\n    setHDU(hdu, hdu_index) {\n        this.hdu = hdu;\n        this.hdu_index = hdu_index;\n    }\n\n    processDataRawJSON(axis, error_bars = null) {\n        //let raw_fits_data = this.hdu.data;\n        let raw_fits_data = this.fits_reader_wrapper.getDataFromHDU(this.hdu_index);\n        let data = {};\n\n        let x;\n        let y;\n\n        let x_column = axis.x;\n        let y_column = axis.y;\n\n        raw_fits_data.getColumn(x_column, function(col){x = col});\n        raw_fits_data.getColumn(y_column, function(col){y = col});\n\n        data.x = x;\n        data.y = y;\n\n        if(error_bars) {\n\n            let dy;\n\n            let error_bar_x_column = error_bars.x;\n            let error_bar_y_column = error_bars.y;\n\n            raw_fits_data.getColumn(error_bar_y_column, function(col) {dy = col});\n\n            data.dy = dy;\n            //data.timedel = this.getTimedel(error_bar_x_column);\n            //data.timedel = this.fits_reader_wrapper.getHeaderFromHDU(this.hdu_index).get(\"TIMEDEL\");\n\n            raw_fits_data.getColumn(error_bar_x_column, function(col) {data.timedel = col});\n\n        }\n\n        return data;\n    }\n\n    processDataJSON(axis, error_bars = null) {\n        let raw_fits_data = this.hdu.data;\n        let light_curve_data = {};\n\n        if(!this._checkColumns()) {\n            throw new Error(\"\");\n        }\n\n        light_curve_data.main = this.fits_reader_wrapper.getColumnsJSONDataFromHDU(this.hdu_index);\n\n        if(error_bars) {\n            light_curve_data.error_bars = this._processErrorBarsDataJSON(error_bars, axis, light_curve_data.main);\n        }\n\n        return light_curve_data;\n    }\n\n    _processErrorBarsDataJSON(error_bars, axis, data) {\n        let error_bar_x_values = [];\n        let error_bar_y_values = [];\n\n        let axis_x = axis.x;\n        let axis_y = axis.y;\n\n        let error_bar_x_column = error_bars.x;\n        let error_bar_y_column = error_bars.y;\n\n        data.forEach(function(datapoint){\n            let error_bar_x = [\n                {\n                    bound: parseFloat(datapoint[axis_y]) - parseFloat(datapoint[error_bar_y_column]),\n                    [axis_x]: parseFloat(datapoint[axis_x])\n                },\n                {\n                    bound: parseFloat(datapoint[axis_y]) + parseFloat(datapoint[error_bar_y_column]),\n                    [axis_x]: parseFloat(datapoint[axis_x])\n                }\n            ]\n\n            let error_bar_y = [\n                {\n                    bound: parseFloat(datapoint[axis_x]) - parseFloat(datapoint[error_bar_x_column]),\n                    [axis_y]: parseFloat(datapoint[axis_y])\n                },\n                {\n                    bound: parseFloat(datapoint[axis_x]) + parseFloat(datapoint[error_bar_x_column]),\n                    [axis_y]: parseFloat(datapoint[axis_y])\n                }\n            ]\n\n            error_bar_x_values.push(error_bar_x);\n            error_bar_y_values.push(error_bar_y);\n        })\n\n        return {x: error_bar_x_values, y: error_bar_y_values}\n    }\n\n    _checkColumns(required_nb_columns) {\n        let is_checked = true;\n\n        let columns_number = this.fits_reader_wrapper.getNumberOfColumnFromHDU(this.hdu_index)\n        let columns_name = this.fits_reader_wrapper.getColumnsNameFromHDU(this.hdu_index)\n\n        if(columns_number < required_nb_columns || !columns_name.includes(LightCurveProcessor.columns_names.rate)) {\n            is_checked = false;\n        }\n\n        return is_checked;\n    }\n\n    getTimedel(error_bar_x = null) {\n        let timedel;\n\n        if(this.fits_reader_wrapper.getColumnsNameFromHDU(this.hdu_index).includes(\"TIMEDEL\")) {\n            data.getColumn(error_bar_x, function (col) {timedel = col});\n        } else {\n            let header = this.fits_reader_wrapper.getHeaderFromHDU(this.hdu_index);\n            timedel = header.get(\"TIMEDEL\");\n        }\n\n        return timedel;\n    }\n\n    _getValueFromHDUHeader() {\n        let card_value;\n        LightCurveProcessor.header_cards.forEach((card_name) => {\n            card_value = null;\n\n            card_value = this.fits_reader_wrapper.getHeaderCardValueByNameFromHDU(this.hdu_index, card_name)\n            this.header_values[card_name] = card_value;\n        })\n    }\n\n    setBinningType(binning_type) {\n        this.binning_type = binning_type\n    }\n\n    setBinValueMethod(method) {\n        this.method = method;\n    }\n\n    getBinsForMethod(rate_column, fracexp_column, bins, method) {\n        let processed_bins = [];\n\n        bins.forEach((bin) => {\n            let times = [];\n            let rates = [];\n            let fracexps = [];\n\n            bin.forEach(({ time, rate, fracexp }) => {\n                times.push(time);\n                rates.push(rate);\n                fracexps.push(fracexp);\n            });\n\n            let bin_rate_max = Math.max(...rates);\n            let bin_rate_min = Math.min(...rates);\n            let bin_rate_mean = rates.reduce((total, value) => total + value, 0) / rates.length;\n            let bin_rate_sum = rates.reduce((total, value) => total + value, 0);\n\n        })\n\n        return processed_bins;\n    }\n\n    getRateFracexpWeightedMeanBinnedData(rate_column, fracexp_column, bin_size) {\n        let num_data_points = rate_column.length;\n        let num_bins = Math.ceil(num_data_points / bin_size);\n\n        let binned_rates = [];\n\n        for (let i = 0; i < num_bins; i++) {\n            let start_pos = i * bin_size;\n            let end_pos = Math.min(start_pos + bin_size, rate_column.length);\n\n            let weighted_sum = 0;\n            let num_data_points_bin = 0;\n\n            for(let j = start_pos; j < end_pos; j++) {\n                weighted_sum += rate_column[j] * fracexp_column[j];\n                num_data_points_bin++;\n            }\n\n            let bin_rate_value = weighted_sum / num_data_points_bin;\n            binned_rates.push(bin_rate_value);\n        }\n\n        return binned_rates;\n    }\n\n    getMedianDate(dates) {\n        let sorted_dates = dates.sort((a, b) => a - b);\n\n        let median_index = Math.floor(sorted_dates.length / 2);\n\n        if (sorted_dates.length % 2 !== 0) {\n            return sorted_dates[median_index];\n        } else {\n\n        }\n    }\n\n    getDurationInSeconds(time_column) {\n        let lowest_time = Math.min(...time_column);\n        let highest_time = Math.max(...time_column);\n\n        let duration_seconds = (highest_time - lowest_time) * 86400;\n\n        return duration_seconds;\n    }\n\n}","export class SpectrumProcessor {\n\n    static processed_columns_name = ['E_HALF_WIDTH', 'E_MID', 'E_MID_LOG'];\n\n    static D_E = 'E_HALF_WIDTH';\n    static E_MID = 'E_MID';\n    static E_MID_LOG = 'E_MID_LOG';\n\n    static spectrum_col_functions = {\n        E_HALF_WIDTH: SpectrumProcessor.getEnergyHalfWidth,\n        E_MID: SpectrumProcessor.getEnergyMidPoint,\n        E_MID_LOG: SpectrumProcessor.getEnergyMidPointLog,\n    }\n\n    constructor() {\n\n    }\n\n    //D_E\n    static getEnergyHalfWidth(e_min, e_max) {\n        return ((e_max - e_min) / 2);\n    }\n\n    //E_MID\n    static getEnergyMidPoint(e_min, e_max) {\n        return ((e_max + e_min) / 2);\n    }\n\n    //E_MID_LOG\n    static getEnergyMidPointLog(e_min, e_max) {\n        return Math.sqrt(e_max * e_min);\n    }\n\n    static getAsymetricEneryErrorBar(e_min, e_max, e_mid) {\n        let e_error_up = e_max - e_mid;\n        let e_error_down = e_mid - e_min;\n\n        return {'e_error_up': e_error_up, 'e_error_down': e_error_down};\n    }\n\n}","export class EventNotFoundInRegistryError extends Error {\n    constructor(message) {\n        super(message);\n        this.name = \"EventNotFoundInRegistryError\";\n    }\n}","export class HDUNotTabularError extends Error {\n    constructor(message) {\n        super(message);\n        this.name = \"HDUNotTabularError\";\n    }\n}","export class InvalidURLError extends Error {\n    constructor(message) {\n        super(message);\n        this.name = \"InvalidURLError\";\n    }\n}","export class NoEventToDispatchError extends Error {\n    constructor(message) {\n        super(message);\n        this.name = \"NoEventToDispatch\";\n    }\n}","import {RegistryContainer} from \"../containers/RegistryContainer\";\n\nexport class ConfigurationEvent {\n\n    static defaultOptions = {\n        bubbles: true,\n        composed: false,\n        cancelable: true\n    };\n\n    static name = \"configuration\";\n\n    event = null;\n\n    constructor(configuration_object, detail = {}, options = {}) {\n\n        this.detail = { ...detail, ...{'configuration_object': configuration_object}};\n        this.options = { ...ConfigurationEvent.defaultOptions, ...options };\n\n        this.event = new CustomEvent(ConfigurationEvent.name, {\n            detail: this.detail,\n            ...this.options\n        });\n    }\n\n    dispatchToSubscribers() {\n        let esr = RegistryContainer.getRegistryContainer().getEventSubscribersRegistry();\n        let subscribers_id = esr.getSubscribersForEvent(ConfigurationEvent.name)\n\n        let subscriber_element = null;\n        subscribers_id.forEach((subscriber_id) => {\n            subscriber_element = document.getElementById(subscriber_id);\n            subscriber_element.dispatchEvent(this.event);\n        })\n    }\n}\n","import {RegistryContainer} from \"../containers/RegistryContainer\";\n\nexport class FileLoadedEvent {\n\n    static defaultOptions = {\n        bubbles: true,\n        composed: false\n    };\n\n    static name = \"file-loaded\";\n    static main_root_id = 'jsvis-main';\n    static main_root_element = null;\n\n    event = null;\n\n    constructor(detail = {}, options = {}) {\n\n        this.detail = { ...detail };\n        this.options = { ...FileLoadedEvent.defaultOptions, ...options };\n\n        this.event = new CustomEvent(FileLoadedEvent.name, {\n            detail: this.detail,\n            ...this.options\n        });\n    }\n\n    dispatchToTarget(target) {\n        target.dispatchEvent(this.event);\n    }\n\n    dispatchToMainRoot() {\n        if(FileLoadedEvent.main_root_element === null) {\n            FileLoadedEvent.main_root_element = document.getElementById(FileLoadedEvent.main_root_id);\n        }\n\n        document.dispatchEvent(this.event);\n    }\n\n    dispatchToSubscribers() {\n        let esr = RegistryContainer.getRegistryContainer().getEventSubscribersRegistry();\n        let subscribers_id = esr.getSubscribersForEvent(FileLoadedEvent.name)\n\n        let subscriber_element = null;\n        subscribers_id.forEach((subscriber_id) => {\n            subscriber_element = document.getElementById(subscriber_id);\n            subscriber_element.dispatchEvent(this.event);\n        })\n    }\n}\n","import {RegistryContainer} from \"../containers/RegistryContainer\";\n\nexport class FileRegistryChangeEvent {\n\n    static defaultOptions = {\n        bubbles: true,\n        composed: false\n    };\n\n    static name = \"file-registry-change\";\n    static main_root_id = 'jsvis-main';\n    static main_root_element = null;\n\n    event = null;\n\n    constructor(detail = {}, options = {}) {\n\n        this.detail = { ...detail };\n        this.options = { ...FileRegistryChangeEvent.defaultOptions, ...options };\n\n        this.event = new CustomEvent(FileRegistryChangeEvent.name, {\n            detail: this.detail,\n            ...this.options\n        });\n    }\n\n    dispatchToTarget(target) {\n        target.dispatchEvent(this.event);\n    }\n\n    dispatchToMainRoot() {\n        if(FileRegistryChangeEvent.main_root_element === null) {\n            FileRegistryChangeEvent.main_root_element = document.getElementById(FileRegistryChangeEvent.main_root_id);\n        }\n        \n        document.dispatchEvent(this.event);\n    }\n\n    dispatchToSubscribers() {\n        let esr = RegistryContainer.getRegistryContainer().getEventSubscribersRegistry();\n        let subscribers_id = esr.getSubscribersForEvent(FileRegistryChangeEvent.name);\n\n        let subscriber_element = null;\n        subscribers_id.forEach((subscriber_id) => {\n            subscriber_element = document.getElementById(subscriber_id);\n            subscriber_element.dispatchEvent(this.event);\n        })\n    }\n}\n","import {NoEventToDispatchError} from \"../errors/NoEventToDispatchError\";\n\nexport class SettingsChangedEvent {\n\n    static defaultOptions = {\n        bubbles: true,\n        composed: false,\n        cancelable: true\n    };\n\n    static name = \"settings-changed\";\n\n    event = null;\n\n    constructor(settings_object, detail = {}, options = {}) {\n\n        this.detail = { ...detail, ...{'settings_object': settings_object}};\n        this.options = { ...SettingsChangedEvent.defaultOptions, ...options };\n\n        this.event = new CustomEvent(SettingsChangedEvent.name, {\n            detail: this.detail,\n            ...this.options\n        });\n    }\n\n    dispatch() {\n        if(this.event !== null) {\n            document.dispatchEvent(this.event);\n        } else {\n            throw new NoEventToDispatchError(\"No event to dispatch\");\n        }\n    }\n}\n","import { NoEventToDispatchError } from \"../errors/NoEventToDispatchError\";\n\nexport class VisualizationGenerationEvent {\n\n    static defaultOptions = {\n        bubbles: true,\n        composed: false,\n        cancelable: true\n    };\n\n    static name = \"visualization-generation\";\n\n    event = null;\n\n    constructor(settings_object, detail = {}, options = {}) {\n\n        this.detail = { ...detail, ...{'settings_object': settings_object}};\n        this.options = { ...VisualizationGenerationEvent.defaultOptions, ...options };\n\n        this.event = new CustomEvent(VisualizationGenerationEvent.name, {\n            detail: this.detail,\n            ...this.options\n        });\n    }\n\n    dispatch() {\n        if(this.event !== null) {\n            document.dispatchEvent(this.event);\n        } else {\n            throw new NoEventToDispatchError(\"No event to dispatch\");\n        }\n    }\n}\n","import {EventNotFoundInRegistryError} from \"../errors/EventNotFoundInRegistryError\";\n\nexport class EventSubscribersRegistry {\n\n    static events_subscribers = {\n        'fits-loaded': ['settings-component', 'file-component'],\n        'configuration': ['settings-component'],\n        'file-loaded': ['file-component'],\n        'file-selected': ['settings-component'],\n        'file-registry-change': ['settings-component', 'file-component']\n    }\n\n    constructor() {\n\n    }\n\n    getSubscribersForEvent(event_name) {\n        if(EventSubscribersRegistry.events_subscribers.hasOwnProperty(event_name)) {\n            return EventSubscribersRegistry.events_subscribers[event_name];\n        } else {\n            throw new EventNotFoundInRegistryError(\"Event not found : \" + event_name);\n        }\n    }\n\n}","import {FileRegistryChangeEvent} from \"../events/FileRegistryChangeEvent\";\nimport {StringUtils} from \"../utils/StringUtils\";\n\nexport class FileRegistry {\n\n    static available_files = [];\n\n    static current_files = [];\n\n    static file_counter = 0;\n\n    constructor() {\n\n    }\n\n    static getAvailableFilesList() {\n        FileRegistry.available_files = FileRegistry.available_files.filter(obj => obj !== undefined);\n        return FileRegistry.available_files;\n    }\n\n    static getCurrentFilesList() {\n        FileRegistry.current_files = FileRegistry.current_files.filter(obj => obj !== undefined);\n        return FileRegistry.current_files;\n    }\n\n    static addToAvailableFiles(file_to_add) {\n        let file = { ...file_to_add,\n            id: FileRegistry.file_counter,\n            file_name: StringUtils.cleanFileName(file_to_add.file_name)\n        };\n\n        FileRegistry.available_files.push(file);\n\n        FileRegistry.file_counter++;\n    }\n\n    static moveToAvailableFiles(file) {\n        FileRegistry.available_files.push(file);\n    }\n\n    static removeFromAvailableFiles(file_id) {\n        FileRegistry.available_files = FileRegistry.available_files.filter(file => file.id !== parseInt(file_id));\n    }\n\n    static addToCurrentFiles(file) {\n        FileRegistry.current_files.push(file);\n        FileRegistry.removeFromAvailableFiles(file.id);\n    }\n\n    static removeFromCurrentFiles(file_id) {\n        let file = FileRegistry.current_files.find(file => file.id === parseInt(file_id));\n\n        FileRegistry.current_files = FileRegistry.current_files.filter(file => file.id !== parseInt(file_id));\n        FileRegistry.moveToAvailableFiles(file);\n    }\n\n    static getFileById(file_id) {\n        let file_array = [...FileRegistry.available_files, ...FileRegistry.current_files];\n\n        let file = file_array.find(file => file.id === parseInt(file_id));\n        return file;\n    }\n\n    static getFileByName(file_name) {\n        let file_array = [...FileRegistry.available_files, ...FileRegistry.current_files];\n\n        let file = file_array.find(file => file.file_name === file_name);\n        return file;\n    }\n\n    static isFileCurrent(file_id) {\n        let is_current = false;\n\n        if(FileRegistry.current_files.some(file => file.id === parseInt(file_id))) {\n            is_current = true;\n        }\n\n        return is_current;\n    }\n\n    static sendRegistryChangeEvent() {\n        let frce = new FileRegistryChangeEvent();\n        frce.dispatchToSubscribers();\n    }\n\n}","import {ObjectUtils} from \"../utils/ObjectUtils\";\n\nexport class SettingsConfiguration {\n\n    static default_configuration = {\n        'library-settings': {\n            display: true,\n            selected: 'none'\n        },\n        'bokeh-settings': {\n            display: false,\n            'bokeh-options': {\n                tools: {\n                    display : false\n                }\n            }\n        },\n        'd3-settings': {\n            display: false,\n            'd3-options': {\n\n            }\n        },\n        'data-type-settings': {\n            display: true,\n            selected: 'generic'\n        },\n        'light-curve-settings': {\n            display: false,\n            'light-curve-options': {\n\n            }\n        },\n        'spectrum-settings': {\n            display: false,\n            'spectrum-options': {\n\n            }\n        },\n        'hdus-settings': {\n            display: false\n        },\n        'axis-settings': {\n            display: true\n        },\n        'error-bars-settings': {\n            display: true\n        },\n        'binning-settings': {\n            display: true\n        },\n        'additional-dataset-settings': {\n            display: true\n        }\n    }\n\n    configuration = null;\n\n    constructor(configuration_object = null) {\n        if(configuration_object) {\n            this.configuration = JSON.parse(JSON.stringify(SettingsConfiguration.default_configuration));\n        } else {\n            this.configuration = JSON.parse(JSON.stringify(configuration_object));\n        }\n    }\n\n    getConfigurationObject(wrapper_configuration) {\n        let configuration = null;\n\n        configuration = ObjectUtils.deep_merge(SettingsConfiguration.default_configuration, wrapper_configuration);\n\n        return configuration;\n    }\n\n    static getConfigurationObject(wrapper_configuration) {\n        let configuration = null;\n\n        configuration = ObjectUtils.deep_merge(SettingsConfiguration.default_configuration, wrapper_configuration);\n\n        return configuration;\n    }\n\n}","export class VisualizationSettings {\n\n    static default_settings = {\n        library: '',\n        data_type: '',\n        axis: {},\n        scales: {},\n        error_bars: {}\n    }\n\n    settings = {};\n\n    settings_library = null;\n    settings_data_type = null;\n    settings_hdus = null;\n    settings_axis = null;\n    settings_scales = null;\n    settings_error_bars = null;\n\n    constructor(settings_object = null) {\n        if(settings_object) {\n            this.settings = JSON.parse(JSON.stringify(settings_object))\n        } else {\n            this.settings = JSON.parse(JSON.stringify(VisualizationSettings.default_settings))\n        }\n    }\n\n    setLibrarySettings(library) {\n        this.settings_library = library;\n    }\n\n    getLibrarySettings() {\n        if(this.settings_library) {\n            return this.settings_library;\n        } else {\n            return null;\n        }\n    }\n\n    setDataTypeSettings(data_type) {\n        this.settings_data_type = data_type;\n    }\n\n    getDataTypeSettings() {\n        if(this.settings_data_type) {\n            return this.settings_data_type;\n        } else {\n            return null;\n        }\n    }\n\n    getLightCurveSettings() {\n\n    }\n\n    getSpectrumSettings() {\n\n    }\n\n    setHDUsSettings(hdus) {\n        this.settings_hdus = hdus;\n    }\n\n    getHDUsSettings() {\n        if(this.settings_hdus !== null) {\n            return this.settings_hdus;\n        } else {\n            return null;\n        }\n    }\n\n    setAxisSettings(axis) {\n        this.settings_axis = axis;\n    }\n\n    getAxisSettings() {\n        if(this.settings_axis) {\n            return this.settings_axis;\n        } else {\n            return null;\n        }\n    }\n\n    setScalesSettings(scales) {\n        this.settings_scales = scales;\n    }\n\n    getScalesSettings() {\n        if(this.settings_scales) {\n            return this.settings_scales;\n        } else {\n            return null;\n        }\n    }\n\n    setErrorBarsSettings(error_bars) {\n        this.settings_error_bars = error_bars;\n    }\n\n    getErrorBarsSettings() {\n        if(this.settings_error_bars) {\n            return this.settings_error_bars;\n        } else {\n            return null;\n        }\n    }\n\n    setRangesSettings(ranges) {\n        this.settings_ranges = ranges;\n    }\n\n    getRangesSettings() {\n        return this.settings_ranges;\n    }\n\n    getAdditionalDatasetsSettings() {\n\n    }\n\n    reset() {\n        this.settings_library = null;\n        this.settings_data_type = null;\n        this.settings_hdus = null;\n        this.settings_axis = null;\n        this.settings_scales = null;\n        this.settings_error_bars = null;\n    }\n}","export class ObjectUtils {\n\n    static deep_merge(base_object, merging_object) {\n        let merged_object = {};\n\n        for (let key in base_object) {\n            if (base_object.hasOwnProperty(key)) {\n                merged_object[key] = base_object[key];\n            }\n        }\n\n        for (let key in merging_object) {\n            if (merging_object.hasOwnProperty(key)) {\n                if(Array.isArray(merging_object[key])) {\n\n                } else if (merged_object.hasOwnProperty(key) && typeof merging_object[key] === 'object') {\n                    merged_object[key] = ObjectUtils.deep_merge(merged_object[key], merging_object[key]);\n                } else {\n                    merged_object[key] = merging_object[key];\n                }\n            }\n        }\n\n        return merged_object;\n    }\n\n}","export class StringUtils {\n\n    static cleanFileName(str) {\n        if (str.startsWith('.') || str.startsWith('/')) {\n            str = str.substring(1);\n\n            return StringUtils.cleanFileName(str);\n        } else {\n            return str;\n        }\n    }\n\n}","export class BokehGraph {\n\n    container_id = null;\n    container = null;\n\n    static plt = Bokeh.Plotting;\n\n    static scale_functions = {\n        \"linear\": Bokeh.LinearScale,\n        \"log\": Bokeh.LogScale\n    }\n\n    source = null;\n\n    y_error_bar;\n    x_error_bar;\n\n    columns;\n    data_table;\n\n    static supported_tool_array = [\n        \"pan\",\n        \"box_zoom\",\n        \"wheel_zoom\",\n        \"hover\",\n        \"crosshair\",\n        \"reset\",\n        \"save\",\n        \"lasso_select\",\n        \"poly_select\",\n        \"tap\",\n        \"examine,\",\n        \"undo\",\n        \"redo\"];\n\n    static default_tool_array = [\n        \"pan\",\n        \"box_zoom\",\n        \"wheel_zoom\",\n        \"hover\",\n        \"crosshair\",\n        \"reset\",\n        \"save\"];\n\n    static default_tool_string = \"pan,box_zoom,wheel_zoom,hover,crosshair,reset,save\";\n\n    tool_array = [];\n    tool_string = \"\";\n\n    has_data_table = false;\n\n    constructor(container_id = '#visualization-container') {\n        this.container_id = container_id;\n        this._setContainer();\n    }\n\n    _setContainer() {\n        this.container = document.getElementById(this.container_id);\n    }\n\n    initializeSettings(data, labels, scales, title, error_bars = null, custom_range = null) {\n        this.setupSource(data);\n\n        if(error_bars) {\n            this.setupPlot(title, data['y_low'], data['y_up']);\n        } else {\n            if(custom_range) {\n                let x_low = [];\n                let x_up = [];\n\n                let y_low = [];\n                let y_up = [];\n\n                if(custom_range.x !== null) {\n                    custom_range.x.lower_bound !== null ? x_low.push(custom_range.x.lower_bound) : x_low = data['x'];\n                    custom_range.x.upper_bound !== null ? x_up.push(custom_range.x.upper_bound) : x_up = data['x'];\n                } else {\n                    x_low = data['x'];\n                    x_up = data['x'];\n                }\n\n                if(custom_range.y !== null) {\n                    custom_range.y.lower_bound !== null ? y_low.push(custom_range.y.lower_bound) : y_low = data['y'];\n                    custom_range.y.upper_bound !== null ? y_up.push(custom_range.y.upper_bound) : y_up = data['y'];\n                } else {\n                    y_low = data['y'];\n                    y_up = data['y'];\n                }\n\n                this.setupPlot(title, y_low, y_up, x_low, x_up)\n            } else {\n                this.setupPlot(title, data['y'], data['y']);\n            }\n\n        }\n\n        this.setupData();\n        this.setupScales(scales);\n        this.setupLabels(labels);\n\n        if(error_bars) {\n            this.setupErrorBars();\n        }\n    }\n\n    initializeGraph() {\n\n        if(this.has_data_table) {\n            BokehGraph.plt.show(new Bokeh.Column({children: [p, data_table]}), \"#graph-container\");\n        } else {\n            BokehGraph.plt.show(this.plot, this.container_id);\n        }\n    }\n\n    setupPlot(title, y_range_low, y_range_up, x_range_low = null, x_range_up= null) {\n\n        if(x_range_low) {\n            this.plot = BokehGraph.plt.figure({\n                title: title,\n                tools: BokehGraph.default_tool_string,\n                width: 800,\n                height: 600,\n            });\n        } else {\n            this.plot = BokehGraph.plt.figure({\n                title: title,\n                tools: BokehGraph.default_tool_string,\n                width: 800,\n                height: 600,\n            });\n        }\n    }\n\n    setupSource(data_sources) {\n        this.source = new Bokeh.ColumnDataSource({\n            data: data_sources\n        });\n    }\n\n    setupData() {\n        const circles = this.plot.circle({ field: \"x\" }, { field: \"y\" }, {\n            source: this.source,\n            size: 4,\n            fill_color: \"navy\",\n            line_color: null,\n        });\n    }\n\n    setupErrorBars() {\n        this.y_error_bar = new Bokeh.Whisker({\n            dimension: \"height\",\n            source: this.source,\n            base: {field: \"x\"},\n            lower: {field: \"y_low\"},\n            upper: {field: \"y_up\"},\n            line_color: \"navy\",\n            lower_head: null,\n            upper_head: null,\n        });\n\n        this.x_error_bar = new Bokeh.Whisker({\n            dimension: \"width\",\n            source: this.source,\n            base: {field: \"y\"},\n            lower: {field: \"x_low\"},\n            upper: {field: \"x_up\"},\n            line_color: \"navy\",\n            lower_head: null,\n            upper_head: null,\n        });\n\n        this.plot.add_layout(this.y_error_bar);\n        this.plot.add_layout(this.x_error_bar);\n    }\n\n    setupScales (scales) {\n        if(scales) {\n            this.plot.x_scale = new BokehGraph.scale_functions[scales.x]();\n            this.plot.y_scale = new BokehGraph.scale_functions[scales.y]();\n        }\n    }\n\n    setupLabels(labels) {\n        this.plot.xaxis.axis_label = labels.x;\n        this.plot.yaxis.axis_label = labels.y;\n    }\n\n    setupColumns(labels, columns) {\n        this.columns = [\n            new Bokeh.Tables.TableColumn({field: 'x', title: labels.x}),\n            new Bokeh.Tables.TableColumn({field: 'y', title: labels.y})\n        ]\n    }\n\n    setupDataTable() {\n        this.data_table = new Bokeh.Tables.DataTable({\n            source: this.source,\n            columns: this.columns,\n            width: 800,\n        });\n    }\n\n    createToolArray(tool_array) {\n        this.tool_array = tool_array;\n    }\n\n    addToolToToolArray(tool_name) {\n        if (!this.tool_array.includes(tool_name) && BokehGraph.supported_tool_array.includes(tool_name)) {\n            this.tool_array.push(tool_name);\n        }\n    }\n\n    removeToolFromToolArray(tool_name) {\n        this.tool_array = this.tool_array.filter(str => str !== tool_name);\n    }\n\n    setToolStringFromToolArray() {\n        this.tool_string = this.tool_array.join(',');\n    }\n\n}","export class D3Graph {\n\n    x_scale;\n    x_scale_type;\n\n    y_scale;\n    y_scale_type;\n\n    x_axis;\n    x_axis_data_col;\n\n    y_axis;\n    y_axis_data_col;\n\n    dataset;\n    svg; plot; clip; zoom_rect;\n\n    zoom;\n\n    line_container; path;\n\n    container;\n    container_id;\n\n    margin = {top: 10, right: 30, bottom: 30, left: 60};\n    width = 800 - this.margin.left - this.margin.right;\n    height = 400 - this.margin.top - this.margin.bottom;\n\n    has_error_bars = false;\n    x_axis_data_col_error_bar;\n    y_axis_data_col_error_bar;\n\n    has_line = false;\n\n    has_multiple_plots = false;\n    additional_plots = [];\n\n    initialized;\n\n    static scale_functions = {\n        \"linear\": d3.scaleLinear,\n        \"log\": d3.scaleLog\n    };\n\n    static default_scales = {\n        \"x\": 'linear',\n        \"y\": 'linear'\n    }\n\n    static default_axis_tick_format = \".2f\";\n\n    constructor(container_id = 'visualization-container', dataset = null) {\n        this.container_id = container_id;\n        this.dataset = dataset;\n\n        this._setContainer();\n\n        this._updateChart = this._updateChart.bind(this);\n\n        this.initialized = false;\n    }\n\n    _setContainer() {\n        this.container = document.getElementById(this.container_id);\n    }\n\n    initializeSettings(data,\n                       axis,\n                       scales = D3Graph.default_scales,\n                       error_bars = null,\n                       has_line = false,\n                       additional_plots = null) {\n\n        let is_set = false;\n\n        try {\n\n            this.dataset = data;\n\n            this.x_axis_data_col = axis['x'];\n            this.y_axis_data_col = axis['y'];\n\n            this.x_scale_type = scales['x'];\n            this.y_scale_type = scales['y'];\n\n            if (error_bars) {\n                this.has_error_bars = true;\n                this.error_bars = error_bars;\n\n                this.x_axis_data_col_error_bar = axis['x'].value;\n                this.y_axis_data_col_error_bar = axis['y'].value;\n\n            } else {\n                this.has_error_bars = false;\n            }\n\n            if (additional_plots) {\n                this.has_multiple_plots = true;\n                this.additional_plots = [];\n\n                let additional_plots_temp = [];\n                additional_plots.forEach(function (plot) {\n                    additional_plots_temp.push(plot);\n                });\n\n                this.additional_plots = additional_plots_temp;\n            }\n\n            this.has_line = has_line;\n\n            is_set = true;\n\n        } catch(e) {\n            console.log(\"Error during graph settings process\")\n        }\n\n        return is_set;\n    }\n\n    initializeGraph() {\n        try {\n            this._setSVGContainer();\n\n            this._setXScale();\n            this._setYScale();\n\n            this._setXAxis();\n            this._setXAxisLabel();\n\n            this._setYAxis();\n            this._setYAxisLabel()\n\n            this._setDataPlot();\n\n            this._setZoomBehavior();\n\n            if(this.has_error_bars) {\n                this._setErrorBars(this.error_bars);\n            }\n\n            if(this.has_line) {\n                this._setAxisLine();\n            }\n\n            if(this.has_multiple_plots) {\n                this._setAdditionalPlots();\n            }\n\n            this.initialized = true;\n        } catch(e) {\n            console.log(\"Error during graph initialization\");\n            this.initialized = false;\n        }\n\n        return this.initialized;\n    }\n\n    _setSVGContainer() {\n\n        let full_width = this._getFullWidth();\n        let full_height = this._getFullHeight();\n\n        this.svg = d3.select(this.container)\n            .append(\"svg\")\n            .attr(\"width\", full_width)\n            .attr(\"height\", full_height)\n            .append(\"g\")\n            .attr(\"transform\",\n                \"translate(\" + this.margin.left + \",\" + this.margin.top + \")\");\n    }\n\n    _setXScale() {\n        this.x_scale = D3Graph.scale_functions[this.x_scale_type]()\n            .domain(d3.extent(this.dataset, d => d[this.x_axis_data_col]))\n            .range([ 0, this.width ]);\n    }\n\n    _setYScale() {\n        this.y_scale = D3Graph.scale_functions[this.y_scale_type]()\n            .domain(d3.extent(this.dataset, d => d[this.y_axis_data_col]))\n            .range([ this.height, 0]);\n    }\n\n    _setXAxis(tick_format = D3Graph.default_axis_tick_format) {\n         this.x_axis = this.svg.append(\"g\")\n            .attr(\"id\", \"x\")\n            .attr(\"transform\", \"translate(0,\" + this.height + \")\")\n            .call(d3.axisBottom(this.x_scale)\n                .tickFormat(d3.format(tick_format)))\n            .call(g => g.selectAll(\".tick line\").clone()\n                .attr(\"class\", \"tick-line\")\n                .attr(\"y2\", -this.height)\n                .attr(\"stroke-opacity\", 0.2))\n    }\n\n    _setYAxis(tick_format = D3Graph.default_axis_tick_format) {\n        this.y_axis = this.svg.append(\"g\")\n            .attr(\"id\", \"y\")\n            .call(d3.axisLeft(this.y_scale)\n                .tickFormat(d3.format(tick_format)))\n            .call(g => g.selectAll(\".tick line\").clone()\n                .attr(\"x2\", this.width)\n                .attr(\"stroke-opacity\", 0.2));\n    }\n\n    _setXAxisLabel() {\n        this.x_axis.select(\".tick:last-of-type text\").clone()\n            .attr(\"id\", \"x-label\")\n            .attr(\"y\", -11)\n            .attr(\"x\", 2)\n            .attr(\"text-anchor\", \"start\")\n            .attr(\"font-weight\", \"bold\")\n            .text(this.x_axis_data_col);\n    }\n\n    _setYAxisLabel() {\n        this.y_axis.select(\".tick:last-of-type text\").clone()\n            .attr(\"id\", \"y-label\")\n            .attr(\"x\", 3)\n            .attr(\"y\", -5)\n            .attr(\"text-anchor\", \"start\")\n            .attr(\"font-weight\", \"bold\")\n            .text(this.y_axis_data_col);\n    }\n\n    _setDataPlot() {\n\n        let x = this.x_scale;\n        let y = this.y_scale;\n\n        let x_col_data = this.x_axis_data_col;\n        let y_col_data = this.y_axis_data_col;\n\n        this.clip = this.svg.append(\"defs\").append(\"SVG:clipPath\")\n            .attr(\"id\", \"clip\")\n            .append(\"SVG:rect\")\n            .attr(\"width\", this.width )\n            .attr(\"height\", this.height )\n            .attr(\"x\", 0)\n            .attr(\"y\", 0);\n\n        this.plot = this.svg.append('g')\n            .attr(\"clip-path\", \"url(#clip)\")\n            .attr(\"id\", \"data-plot\")\n\n        this.plot\n            .selectAll(\"circle\")\n            .data(this.dataset)\n            .enter()\n            .append(\"circle\")\n            .attr(\"cx\", function (d) { return x(d[x_col_data]); } )\n            .attr(\"cy\", function (d) { return y(d[y_col_data]); } )\n            .attr(\"r\", 4)\n            .style(\"fill\", \"transparent\")\n            .style(\"stroke\", \"black\")\n            .style(\"opacity\", 1)\n    }\n\n    _setAdditionalPlots() {\n        let plot;\n        for(let i = 0; i < this.additional_plots.length, i++;) {\n            plot = this.additional_plots[i];\n        }\n    }\n\n    _setErrorBars(error_bars) {\n\n        this.error_bars = error_bars;\n\n        let error_bar_x = {x: error_bars.x};\n\n        let line_error_bar_x = d3.line()\n            .x(d => this.x_scale(d[this.x_axis_data_col]))\n            .y(d => this.y_scale(d.bound));\n\n        error_bars.x.forEach((error_bar) => {\n            d3.select('#data-plot').append(\"path\")\n                .attr(\"class\", \"error-bar-x\")\n                .attr(\"fill\", \"none\")\n                .attr(\"stroke\", \"steelblue\")\n                .attr(\"stroke-width\", 1.5)\n                .attr(\"d\", line_error_bar_x(error_bar));\n        })\n\n        let line_error_bar_y = d3.line()\n            .x(d => this.x_scale(d.bound))\n            .y(d => this.y_scale(d[this.y_axis_data_col]));\n\n        error_bars.y.forEach((error_bar) => {\n            d3.select('#data-plot').append(\"path\")\n                .attr(\"class\", \"error-bar-x\")\n                .attr(\"fill\", \"none\")\n                .attr(\"stroke\", \"steelblue\")\n                .attr(\"stroke-width\", 1.5)\n                .attr(\"d\", line_error_bar_y(error_bar));\n        })\n\n    }\n\n    _setAxisLine() {\n        let line = d3.line()\n            .curve(d3.curveCatmullRom)\n            .x(d => this.x_axis(d[this.x_axis_data_col]))\n            .y(d => this.y_axis(d[this.y_axis_data_col]));\n\n        this.line_container = this.svg.append(\"g\")\n            .attr(\"id\", \"path-container\")\n            .attr(\"clip-path\", \"url(#clip)\");\n\n        this.path = this.line_container.append(\"path\")\n            .attr(\"id\", \"path\")\n            .attr(\"fill\", \"none\").attr(\"stroke\", \"steelblue\")\n            .attr(\"d\", line(data));\n    }\n\n    _setZoomBehavior() {\n\n        this.zoom = d3.zoom()\n            .scaleExtent([.5, 20])\n            .extent([[0, 0], [this.width, this.height]])\n            .on(\"zoom\", this._updateChart);\n\n        this.zoom_rect = this.svg.append(\"rect\")\n            .attr(\"width\", this.width)\n            .attr(\"height\", this.height)\n            .style(\"fill\", \"none\")\n            .style(\"pointer-events\", \"all\")\n            .attr('transform', 'translate(' + this.margin.left + ',' + this.margin.top + ')')\n            .call(this.zoom);\n\n    }\n\n    _updateChart(e) {\n\n        let rescaled_x = e.transform.rescaleX(this.x_scale);\n        let rescaled_y = e.transform.rescaleY(this.y_scale);\n\n        this.x_axis.call(d3.axisBottom(rescaled_x).tickFormat(d3.format(D3Graph.default_axis_tick_format)))\n        this.y_axis.call(d3.axisLeft(rescaled_y).tickFormat(d3.format(D3Graph.default_axis_tick_format)))\n\n        this.svg.selectAll(\".tick-line\").remove();\n        this.svg.selectAll(\"#y-label\").remove();\n        this.svg.selectAll(\"#x-label\").remove();\n        this.svg.selectAll(\".error-bar-x\").remove();\n\n        this.x_axis.selectAll(\".tick line\").clone()\n            .attr(\"class\", \"tick-line\")\n            .attr(\"y2\", -this.height)\n            .attr(\"stroke-opacity\", 0.2)\n\n        this.y_axis.selectAll(\".tick line\").clone()\n            .attr(\"class\", \"tick-line\")\n            .attr(\"x2\", this.width)\n            .attr(\"stroke-opacity\", 0.2)\n\n        this._setXAxisLabel();\n        this._setYAxisLabel();\n\n        let x_data_col = this.x_axis_data_col;\n        let y_data_col = this.y_axis_data_col;\n\n        this.svg.selectAll(\"circle\")\n            .data(this.dataset)\n            .transition()\n            .duration(150)\n            .attr(\"cx\", function (d) { return rescaled_x(d[x_data_col]); } )\n            .attr(\"cy\", function (d) { return rescaled_y(d[y_data_col]); } )\n\n        if(this.has_line) {\n            this.svg.selectAll(\"path\").remove();\n            this._setAxisLine();\n        }\n\n        if(this.has_error_bars) {\n\n            let line_error_bar_x = d3.line()\n                .x(d => rescaled_x(d[this.x_axis_data_col]))\n                .y(d => rescaled_y(d.bound));\n\n            this.error_bars.x.forEach((error_bar) => {\n                d3.select('#data-plot').append(\"path\")\n                    .attr(\"class\", \"error-bar-x\")\n                    .attr(\"fill\", \"none\")\n                    .attr(\"stroke\", \"steelblue\")\n                    .attr(\"stroke-width\", 1.5)\n                    .attr(\"d\", line_error_bar_x(error_bar));\n            })\n\n            let line_error_bar_y = d3.line()\n                .x(d => rescaled_x(d.bound))\n                .y(d => rescaled_y(d[this.y_axis_data_col]));\n\n            this.error_bars.y.forEach((error_bar) => {\n                d3.select('#data-plot').append(\"path\")\n                    .attr(\"class\", \"error-bar-x\")\n                    .attr(\"fill\", \"none\")\n                    .attr(\"stroke\", \"steelblue\")\n                    .attr(\"stroke-width\", 1.5)\n                    .attr(\"d\", line_error_bar_y(error_bar));\n            })\n        }\n\n    }\n\n    _getFullWidth() {\n        return this.width + this.margin.left + this.margin.right\n    }\n\n    _getFullHeight() {\n        return this.height + this.margin.top + this.margin.bottom\n    }\n}","import {ConfigurationEvent} from \"../events/ConfigurationEvent\";\nimport {DataProcessorContainer} from \"../containers/DataProcessorContainer\";\nimport {VisualizationContainer} from \"../containers/VisualizationContainer\";\nimport {WrapperContainer} from \"../containers/WrapperContainer\";\nimport {SettingsConfiguration} from \"../settings/SettingsConfiguration\";\n\nexport class BokehWrapper {\n\n    static container_id = 'visualization-container';\n\n    static library = 'bokeh';\n\n    static title = {\n        'light-curve': 'Light curve',\n        'spectrum': 'spectrum'\n    }\n\n    static specific_settings = {\n        'bokeh-settings': {\n            display: true,\n            'bokeh-options': {\n                tools: {\n                    display: false\n                }\n            }\n        }\n    };\n\n    container = null;\n\n    configuration_object = null;\n\n    constructor() {\n        this._setContainer();\n        this._setupListeners();\n    }\n\n    _setContainer() {\n        this.container = document.getElementById(BokehWrapper.container_id);\n    }\n\n    _resetContainer() {\n        this.container.innerHTML = \"\";\n    }\n\n    _setupListeners() {\n        document.addEventListener('settings-changed', this.handleSettingsChangedEvent.bind(this));\n        document.addEventListener('visualization-generation', this.handleVisualizationGenerationEvent.bind(this));\n    }\n\n    handleSettingsChangedEvent(event) {\n        let settings_object = event.detail.settings_object;\n\n        let library_settings = settings_object.getLibrarySettings();\n\n        if(library_settings.library === BokehWrapper.library) {\n            this.createConfigurationObject();\n\n            if(this.configuration_object !== null) {\n                let configuration_event = new ConfigurationEvent(this.configuration_object);\n\n                configuration_event.dispatchToSubscribers();\n            }\n        }\n    }\n\n    handleVisualizationGenerationEvent(event) {\n        this.settings_object = event.detail.settings_object;\n\n        let library_settings = this.settings_object.getLibrarySettings();\n\n        if(library_settings.library === BokehWrapper.library) {\n\n            this._resetContainer();\n\n            let dataset_settings = {};\n\n            let axis = this.settings_object.getAxisSettings();\n            let axis_settings = [];\n\n            for(let axis_column in axis) {\n                let axis_column_object = this._getColumnSettings(axis[axis_column]);\n                axis_column_object = {...axis_column_object, ...{axis: axis_column}}\n\n                axis_settings.push(axis_column_object);\n            }\n\n            dataset_settings.axis = axis_settings;\n            dataset_settings.data_type = this.settings_object.getDataTypeSettings();\n\n            let error_bars = this.settings_object.getErrorBarsSettings();\n            let has_error_bars = false;\n\n            if(error_bars !== null) {\n\n                let error_bars_settings = [];\n                for(let axis_column in error_bars) {\n                    let axis_column_object = this._getColumnSettings(error_bars[axis_column]);\n                    axis_column_object = {...axis_column_object, ...{axis: axis_column}}\n\n                    error_bars_settings.push(axis_column_object);\n                }\n\n                dataset_settings.error_bars = error_bars_settings;\n            }\n\n            let dpp = DataProcessorContainer.getDataProcessorContainer().getDataPreProcessor();\n\n            let processed_data = dpp.getProcessedDataset(dataset_settings);\n\n            let processed_json_data = dpp.datasetToJSONData(processed_data);\n\n            let data_type = this.settings_object.getDataTypeSettings();\n            let hdu = this.settings_object.getHDUsSettings();\n\n            let scales = this.settings_object.getScalesSettings();\n\n\n            axis = {x: processed_data.axis[0].column_name, y: processed_data.axis[1].column_name};\n            let labels = axis;\n\n            processed_data.axis[0].data = processed_data.axis[0].data.map(value => isNaN(value) ? 0 : value);\n            processed_data.axis[1].data = processed_data.axis[1].data.map(value => isNaN(value) ? 0 : value);\n\n\n            let data = {x: processed_data.axis[0].data, y: processed_data.axis[1].data};\n\n            if(error_bars) {\n                error_bars = {x: processed_data.error_bars[0].column_name, y: processed_data.error_bars[1].column_name};\n\n                processed_data.error_bars[0].data = processed_data.error_bars[0].data.map(value => !isFinite(value) ? 0 : value);\n                processed_data.error_bars[1].data = processed_data.error_bars[1].data.map(value => !isFinite(value) ? 0 : value);\n\n                data.dx = processed_data.error_bars[0].data.map(value => isNaN(value) ? 0 : value);\n                data.dy = processed_data.error_bars[1].data.map(value => isNaN(value) ? 0 : value);\n\n                let asymmetric_uncertainties = false;\n\n                if(data_type === 'spectrum') {\n                    asymmetric_uncertainties = true;\n                }\n\n                data = this._processErrorBarData(data, asymmetric_uncertainties);\n\n                has_error_bars = true;\n            }\n\n            let ranges = this.settings_object.getRangesSettings();\n            let has_custom_range = false;\n            let custom_range_data = null;\n\n            if(ranges != null) {\n\n                if(has_error_bars) {\n                    custom_range_data = dpp.processDataForRangeBokeh(ranges, data, true);\n                } else {\n                    custom_range_data = dpp.processDataForRangeBokeh(ranges, data);\n                }\n\n                data = custom_range_data;\n            }\n\n            let visualization = VisualizationContainer.getBokehVisualization();\n\n            visualization.initializeSettings(data, labels, scales, BokehWrapper.title['data_type'], error_bars, ranges);\n\n            visualization.initializeGraph();\n        }\n    }\n\n    getProcessedData(data_type, hdu_index, axis, error_bars) {\n        let data = null;\n\n        let dpc = DataProcessorContainer.getDataProcessorContainer();\n        let data_processor;\n\n        let frw = WrapperContainer.getFITSReaderWrapper();\n\n        if(data_type === 'light-curve') {\n            data_processor = dpc.getLightCurveProcessor(frw, hdu_index);\n        } else if(data_type === 'spectrum') {\n            data_processor = dpc.getSpectrumProcessor(frw, hdu_index);\n        }\n\n        data = data_processor.processDataRawJSON(axis, error_bars);\n\n        if(error_bars) {\n            data = this._processErrorBarData(data);\n        }\n\n        return data;\n    }\n\n    _getColumnSettings(column_settings) {\n        let settings = column_settings.split('$');\n\n        let column_location = settings[0].split('.');\n        let column_name = settings[1] || '';\n\n        let file_id = column_location[0];\n        let hdu_index = column_location.length > 1 ? column_location[1] : '';\n\n        return {\n            file_id: file_id,\n            hdu_index: hdu_index,\n            column_name: column_name\n        };\n    }\n\n    _processErrorBarData(data, asymetric_uncertainties = false) {\n\n        let div_factor= 2;\n\n        if(asymetric_uncertainties) {\n            div_factor = 1;\n        }\n\n        let y_low = [], y_up = [], x_low = [], x_up = [];\n\n        for (let i in data.dy) {\n            y_low[i] = data.y[i] - data.dy[i];\n            y_up[i] = data.y[i] + data.dy[i];\n            x_low[i] = data.x[i] - data.dx[i] / div_factor;\n            x_up[i] = data.x[i] + data.dx[i] / div_factor;\n        }\n\n        data.y_low = y_low;\n        data.y_up = y_up;\n        data.x_low = x_low;\n        data.x_up = x_up;\n\n        delete data.dy;\n        delete data.dx;\n\n        return data;\n    }\n\n    createConfigurationObject() {\n        this.configuration_object = SettingsConfiguration.getConfigurationObject(BokehWrapper.specific_settings);\n    }\n\n}","import {ConfigurationEvent} from \"../events/ConfigurationEvent\";\nimport {DataProcessorContainer} from \"../containers/DataProcessorContainer\";\nimport {VisualizationContainer} from \"../containers/VisualizationContainer\";\nimport {SettingsConfiguration} from \"../settings/SettingsConfiguration\";\n\nexport class D3Wrapper {\n\n    static library = \"d3\";\n    static container_id = \"visualization-container\";\n\n    static specific_settings = {\n        'd3-settings': {\n            display: true,\n            'd3-options': {\n                'has_line': true,\n                display: false\n            }\n        }\n    };\n\n    container;\n    container_id;\n\n    settings_object;\n    configuration_object = null;\n\n    constructor(container_id = D3Wrapper.container_id) {\n        this._setupListeners();\n\n        this.container_id = container_id;\n        this._setContainer();\n    }\n\n    _setupListeners() {\n        document.addEventListener('settings-changed', this.handleSettingsChangedEvent.bind(this));\n        document.addEventListener('visualization-generation', this.handleVisualizationGenerationEvent.bind(this));\n    }\n\n    handleSettingsChangedEvent(event) {\n        let settings_object = event.detail.settings_object;\n\n        let library_settings = settings_object.getLibrarySettings();\n\n        if(library_settings.library === D3Wrapper.library) {\n            this.createConfigurationObject();\n\n            if(this.configuration_object !== null) {\n                let configuration_event = new ConfigurationEvent(this.configuration_object);\n                configuration_event.dispatchToSubscribers();\n            }\n        }\n\n    }\n\n    handleVisualizationGenerationEvent(event) {\n        this.settings_object = event.detail.settings_object;\n\n        let library_settings = this.settings_object.getLibrarySettings();\n\n        if(library_settings.library === D3Wrapper.library) {\n\n            this.resetContainer();\n\n            let dataset_settings = {};\n\n            let data_type = this.settings_object.getDataTypeSettings();\n            let axis = this.settings_object.getAxisSettings();\n            let scales = this.settings_object.getScalesSettings();\n            let error_bars = this.settings_object.getErrorBarsSettings();\n            let ranges = this.settings_object.getRangesSettings();\n\n            let has_error_bars = false;\n\n            dataset_settings.data_type = data_type;\n\n            let axis_settings = [];\n            for(let axis_column in axis) {\n                let axis_column_object = this._getColumnSettings(axis[axis_column]);\n                axis_column_object = {...axis_column_object, ...{axis: axis_column}}\n\n                axis_settings.push(axis_column_object);\n            }\n\n            dataset_settings.axis = axis_settings;\n\n            if(error_bars !== null) {\n                has_error_bars = true;\n\n                let error_bars_settings = [];\n                for(let axis_column in error_bars) {\n                    let axis_column_object = this._getColumnSettings(error_bars[axis_column]);\n                    axis_column_object = {...axis_column_object, ...{axis: axis_column}}\n\n                    error_bars_settings.push(axis_column_object);\n                }\n\n                dataset_settings.error_bars = error_bars_settings;\n            }\n\n            let dpp = DataProcessorContainer.getDataProcessorContainer().getDataPreProcessor();\n\n            let processed_data = dpp.getProcessedDataset(dataset_settings);\n            let processed_json_data = dpp.datasetToJSONData(processed_data);\n\n            axis = {x: processed_data.axis[0].column_name, y: processed_data.axis[1].column_name};\n\n            if(has_error_bars) {\n                error_bars = {x: processed_data.error_bars[0].column_name, y: processed_data.error_bars[1].column_name};\n                error_bars = dpp.processErrorBarDataJSON(processed_json_data, axis, error_bars)\n            }\n\n            if(ranges != null) {\n                let custom_range_data = null;\n\n                if(has_error_bars) {\n                    custom_range_data = dpp.processDataForRange(ranges, processed_json_data, error_bars);\n                    processed_json_data = custom_range_data.data;\n                    error_bars = custom_range_data.error_bars;\n                } else {\n                    custom_range_data = dpp.processDataForRange(ranges, processed_json_data);\n                    processed_json_data = custom_range_data.data;\n                }\n            }\n\n            let visualization = VisualizationContainer.getD3Visualization();\n\n            visualization.initializeSettings(processed_json_data, axis, scales, error_bars, false, null);\n            visualization.initializeGraph();\n        }\n\n    }\n\n    _setContainer() {\n        this.container = document.getElementById(this.container_id)\n    }\n\n    resetContainer() {\n        this.container.innerHTML = \"\";\n    }\n\n    createConfigurationObject() {\n        this.configuration_object = SettingsConfiguration.getConfigurationObject(D3Wrapper.specific_settings);\n    }\n\n    _getColumnSettings(column_settings) {\n        let settings = column_settings.split('$');\n\n        let column_location = settings[0].split('.');\n        let column_name = settings[1] || '';\n\n        let file_id = column_location[0];\n        let hdu_index = column_location.length > 1 ? column_location[1] : '';\n\n        return {\n            file_id: file_id,\n            hdu_index: hdu_index,\n            column_name: column_name\n        };\n    }\n\n}","import {InvalidURLError} from \"../errors/InvalidURLError\";\nimport {HDUNotTabularError} from \"../errors/HDUNotTabularError\";\nimport {FileRegistry} from \"../registries/FileRegistry\";\nimport {StringUtils} from \"../utils/StringUtils\";\nimport {FileLoadedEvent} from \"../events/FileLoadedEvent\";\n\nexport class FITSReaderWrapper {\n\n    file_path = null;\n    file = null;\n\n    static BINTABLE = 'BINTABLE';\n    static TABLE = 'TABLE';\n\n    constructor(file_path = null) {\n        if(file_path) {\n            if (FITSReaderWrapper.is_path_valid(file_path)) {\n                this.file_path = file_path;\n                this._getFile()\n            } else {\n                throw new InvalidURLError(\"Invalid file path : \" + file_path);\n            }\n        }\n    }\n\n    initializeFromPath(file_path) {\n        if(FITSReaderWrapper.is_path_valid(file_path)) {\n            this.file_path = file_path;\n            this._getFile()\n        } else {\n            throw new InvalidURLError(\"Invalid file path : \" + file_path);\n        }\n\n    }\n\n    initializeFromBuffer(array_buffer, file_name) {\n        this.file_path = file_name;\n        this._readFile(array_buffer);\n    }\n\n    _getFile() {\n\n        return fetch(this.file_path)\n            .then((response) => {\n                if (!response.ok) {\n                    throw new Error(`HTTP error, status = ${response.status}`);\n                }\n                return response.arrayBuffer();\n            })\n            .then((buffer) => this._readFile(buffer));\n    }\n\n    _readFile(arrayBuffer) {\n        try {\n            this.file = window.FITSReader.parseFITS(arrayBuffer);\n\n            this.sendFITSLoadedEvents();\n\n        } catch(e) {\n            console.log(\"Error initializing interface\")\n        }\n    }\n\n    getFilePath() {\n        return this.file_path;\n    }\n\n    setFile(file) {\n        this.file = file;\n    }\n\n    getHDU(hdu_index) {\n        if(hdu_index >= 0 && hdu_index < this.file.hdus.length) {\n            return this.file.hdus[hdu_index];\n        } else {\n            return null;\n        }\n    }\n\n    getHDUs() {\n\n        let HDUs = [];\n        let hdu_object;\n        let type;\n        let extname = '';\n\n        this.file.hdus.forEach(function(hdu, index) {\n\n            if (hdu.header.primary === true) {\n                type = \"PRIMARY\";\n            } else {\n                type = hdu.header.get('XTENSION');\n                extname = hdu.header.get('EXTNAME');\n            }\n\n            hdu_object = {\n                \"name\": type,\n                \"index\": index,\n                \"extname\": extname\n            };\n\n            HDUs.push(hdu_object);\n        })\n\n        return HDUs;\n    }\n\n    getTabularHDUs() {\n        let tabular_hdus_index = [];\n\n        this.file.hdus.forEach(function(hdu, index) {\n            if (hdu.header.primary !== true) {\n                if(hdu.header.get('XTENSION') === \"TABLE\" || hdu.header.get('XTENSION') === \"BINTABLE\") {\n                    tabular_hdus_index.push(index);\n                }\n            }\n        })\n\n        return tabular_hdus_index;\n    }\n\n    getNumberOfColumnFromHDU(hdu_index) {\n        let hdu = this.file.getHDU(hdu_index);\n\n        let header = hdu.header;\n        let data = hdu.data;\n\n        let type = header.get('XTENSION');\n\n        let column_number = null;\n\n        if(type === FITSReaderWrapper.BINTABLE || type === FITSReaderWrapper.TABLE) {\n            column_number = data.cols;\n        } else {\n            throw new HDUNotTabularError(\"Selected HDU is not tabular\");\n        }\n\n        return column_number;\n    }\n\n    getColumnsNameFromHDU(hdu_index) {\n        let hdu = this.file.getHDU(hdu_index);\n\n        let header = hdu.header;\n        let data = hdu.data;\n\n        let type = hdu.header.get('XTENSION');\n\n        let columns = [];\n        let column_name;\n\n        if(type === FITSReaderWrapper.BINTABLE || type === FITSReaderWrapper.TABLE) {\n            data.columns.forEach(function (column) {\n                column_name = column;\n\n                columns.push(column_name);\n            })\n        } else {\n            throw new HDUNotTabularError(\"Selected HDU is not tabular\");\n        }\n\n        return columns;\n    }\n\n    getColumnsJSONDataFromHDU(hdu_index) {\n\n        let hdu = this.file.getHDU(hdu_index);\n\n        let header = hdu.header;\n        let data = hdu.data;\n\n        let type = hdu.header.get('XTENSION');\n\n        let columns_data_json = [];\n        let raw_columns_data_array = [];\n        let column_data;\n\n        if(type === FITSReaderWrapper.BINTABLE || type === FITSReaderWrapper.TABLE) {\n            data.columns.forEach(function(column) {\n\n                try {\n                    data.getColumn(column, function (col) {\n                        column_data = col;\n                    })\n                } catch(e) {\n\n                }\n\n                raw_columns_data_array[column] = column_data;\n            })\n\n            let column_names = Object.keys(raw_columns_data_array);\n\n            for (let i = 0; i < raw_columns_data_array[column_names[0]].length; i++) {\n\n                let column_json_data_object = {};\n\n                column_names.forEach((column_name) => {\n                    column_json_data_object[column_name] = raw_columns_data_array[column_name][i];\n                });\n\n                columns_data_json.push(column_json_data_object);\n            }\n\n        } else {\n            throw new HDUNotTabularError(\"Selected HDU is not tabular\");\n        }\n\n        return columns_data_json;\n    }\n\n    getColumnDataFromHDU(hdu_index, column_name) {\n        let hdu = this.file.getHDU(hdu_index);\n\n        let header = hdu.header;\n        let data = hdu.data;\n\n        let type = hdu.header.get('XTENSION');\n\n        let col_data = [];\n        if(type === FITSReaderWrapper.BINTABLE || type === FITSReaderWrapper.TABLE) {\n\n            data.getColumn(column_name, function(col){\n                if(col[0] === undefined) {\n                    let header_col_data = hdu.header.get(column_name);\n                    col = col.map(() => header_col_data);\n                }\n\n                col_data = col;\n            })\n\n        } else {\n            throw new HDUNotTabularError(\"Selected HDU is not tabular\");\n        }\n\n        return col_data;\n    }\n\n    getHeaderFromHDU(hdu_index) {\n        let hdu = this.file.getHDU(hdu_index);\n        let header = hdu.header;\n\n        return header;\n    }\n\n    getDataFromHDU(hdu_index) {\n        let hdu = this.file.getHDU(hdu_index);\n        let data = hdu.data;\n\n        return data;\n    }\n\n    getHeaderCardValueByNameFromHDU(hdu_index, card_name) {\n        let hdu = this.file.getHDU(hdu_index);\n        let header = hdu.header;\n\n        let value = header.get(card_name);\n\n        if(value === undefined) {\n            value = '';\n        }\n\n        return value;\n    }\n\n    getHeaderCardsValueFromHDU(hdu_index) {\n        let hdu = this.file.getHDU(hdu_index);\n\n        const cards_array = [];\n\n        Object.entries(hdu.header.cards).forEach(function(item) {\n            let item_value_array = item[1];\n\n            if(typeof item_value_array === 'object' && !Array.isArray(item_value_array)) {\n                item_value_array['card_name'] = item[0];\n                cards_array.push(item_value_array);\n            }\n        })\n\n        let sorted_hdu_cards = cards_array.sort((a, b) => a.index - b.index);\n\n        return sorted_hdu_cards;\n    }\n\n    isHDUTabular(hdu_index) {\n        let hdu = this.file.getHDU(hdu_index);\n        let header = hdu.header;\n\n        let type = header.get('XTENSION');\n\n        let is_tabular = false;\n\n        if(type === FITSReaderWrapper.BINTABLE || type === FITSReaderWrapper.TABLE) {\n            is_tabular = true;\n        }\n\n        return is_tabular;\n    }\n\n    _isHDUTabular(hdu) {\n        let extension = hdu.header.get('XTENSION');\n        return extension === FITSReaderWrapper.BINTABLE || extension === FITSReaderWrapper.TABLE;\n    }\n\n    getAllColumns() {\n        let columns = [];\n\n        this.file.hdus.forEach((hdu, index) => {\n\n            if(this._isHDUTabular(hdu)) {\n                let columns_name = this.getColumnsNameFromHDU(index);\n\n                columns_name.forEach((column_name) => {\n                    let column = {\n                        name: column_name,\n                        hdu_index: index,\n                        is_from_header: false\n                    }\n\n                    columns.push(column);\n                })\n\n                if(hdu.header.get('TIMEDEL') !== null) {\n                    let column = {\n                        name: 'TIMEDEL',\n                        hdu_index: index,\n                        is_from_header: true\n                    }\n\n                    columns.push(column);\n                }\n\n                if(hdu.header.get('ANCRFILE') !== null) {\n                    let ancrfile = FileRegistry.getFileByName(\n                        StringUtils.cleanFileName(hdu.header.get('ANCRFILE'))\n                    );\n\n                    if(ancrfile !== undefined) {\n                        let frw = new FITSReaderWrapper();\n                        frw.setFile(ancrfile.file);\n                    }\n\n                }\n\n                if(hdu.header.get('RESPFILE') !== null) {\n                    let respfile = FileRegistry.getFileByName(\n                        StringUtils.cleanFileName(hdu.header.get('RESPFILE'))\n                    );\n\n                    if(respfile !== undefined) {\n                        let frw = new FITSReaderWrapper();\n\n                        frw.setFile(respfile.file);\n\n                        let hdus_index = frw.getTabularHDUs();\n\n                        let has_e_min_max = false;\n                        hdus_index.forEach((hdu_index) => {\n                            let columns_name = frw.getColumnsNameFromHDU(hdu_index);\n                            if (columns_name.includes(\"E_MIN\") && columns_name.includes(\"E_MAX\")) {\n                                has_e_min_max = true;\n                                let e_min_max_hdus_index = hdu_index;\n\n                                let column = {\n                                    name: 'E_HALF_WIDTH',\n                                    hdu_index: hdu_index,\n                                    is_from_header: false,\n                                    is_processed: true,\n                                    from_file: respfile.id\n                                }\n\n                                columns.push(column);\n\n                                column = {\n                                    name: 'E_MID',\n                                    hdu_index: hdu_index,\n                                    is_from_header: false,\n                                    is_processed: true,\n                                    from_file: respfile.id\n                                }\n\n                                columns.push(column);\n\n                                column = {\n                                    name: 'E_MID_LOG',\n                                    hdu_index: hdu_index,\n                                    is_from_header: false,\n                                    is_processed: true,\n                                    from_file: respfile.id\n                                }\n\n                                columns.push(column);\n\n                            }\n                        })\n\n                    }\n                }\n\n            }\n        })\n\n        return columns;\n    }\n\n    sendFITSLoadedEvents() {\n        let filele = new FileLoadedEvent({\n            file_name: this.file_path,\n            type: 'fits',\n            file: this.file\n        });\n\n        filele.dispatchToSubscribers();\n    }\n\n    static is_path_valid(path) {\n        let is_valid = false;\n\n        if(FITSReaderWrapper._isPathValid(path) || FITSReaderWrapper._isURLValid(path)) {\n            is_valid = true;\n        }\n\n        return is_valid;\n    }\n\n    static _isURLValid(url) {\n        const urlRegex = /^(ftp|http|https):\\/\\/[^ \"]+$/;\n        return urlRegex.test(url);\n    }\n\n    static _isPathValid(path) {\n        const pathRegex = /^(\\/[a-zA-Z0-9._-]+)+\\/?$/;\n        return pathRegex.test(path);\n    }\n\n}","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","import { FITSReaderWrapper } from './wrappers/FITSReaderWrapper.js'\nimport { BokehWrapper } from './wrappers/BokehWrapper.js'\nimport { D3Wrapper } from './wrappers/D3Wrapper.js'\nimport { WrapperContainer } from './containers/WrapperContainer.js'\nimport { VisualizationContainer } from './containers/VisualizationContainer.js'\nimport { FileComponent } from './components/FileComponent.js'\nimport { SettingsComponent } from './components/SettingsComponent.js'\nimport { VisualizationComponent } from './components/VisualizationComponent.js'\nimport { FITSSettingsComponent } from './components/file_type/FITSSettingsComponent.js'\nimport { CSVSettingsComponent } from './components/file_type/CSVSettingsComponent.js'\nimport { D3Graph } from \"./visualizations/D3Graph\";\nimport { BokehGraph } from \"./visualizations/BokehGraph\";\n\nlet file_path = window.location.href + \"_test_files/spiacs_lc_query.fits\";\n\nlet fits_reader_wrapper = new FITSReaderWrapper(file_path);\n\nlet bokeh_wrapper = new BokehWrapper();\n\nlet d3_wrapper = new D3Wrapper();\n\nWrapperContainer.setFITSReaderWrapper(fits_reader_wrapper);\nWrapperContainer.setBokehWrapper(bokeh_wrapper);\nWrapperContainer.setD3Wrapper(d3_wrapper);\n\nVisualizationContainer.setBokehVisualization(new BokehGraph());\nVisualizationContainer.setD3Visualization(new D3Graph());\n\ncustomElements.define('file-component', FileComponent);\ncustomElements.define('settings-component', SettingsComponent);\ncustomElements.define('visualization-component', VisualizationComponent);\ncustomElements.define('fits-component', FITSSettingsComponent);\ncustomElements.define('csv-component', CSVSettingsComponent);\n"],"names":[],"sourceRoot":""} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"astrovis.js","mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD,O;;;;;;;;;;;;;;;;;;ACVgE;AACR;AACkB;AACF;;AAEjE;;AAEP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA,8CAA8C,0EAAgB;;AAE9D;;AAEA,iBAAiB;AACjB;AACA,iBAAiB;AACjB,cAAc;AACd;AACA;AACA;AACA;AACA;;AAEA,SAAS;;AAET;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;;AAEA,+BAA+B,kEAAY;AAC3C;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA,iBAAiB;;AAEjB,aAAa;AACb,SAAS;AACT;;AAEA;AACA;AACA;;AAEA;;AAEA,SAAS;;AAET;AACA;AACA;;AAEA,uBAAuB,kEAAY;;AAEnC,YAAY,kEAAY;;AAExB;AACA;;AAEA,2BAA2B,oFAAuB;AAClD;AACA,SAAS;AACT;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,QAAQ,kEAAY;;AAEpB;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA,SAAS;AACT;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA,6BAA6B,kEAAY;;AAEzC,8CAA8C,mFAAqB;;AAEnE;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA,oBAAoB,kEAAY;AAChC,UAAU;AACV,oBAAoB,kEAAY;AAChC;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,SAAS;;AAET;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;;;;;;;;;;;;AC3RkE;AACE;AACgB;AAC5B;AACQ;AACf;AACiB;AACQ;;AAEnE;;AAEP;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA,+BAA+B,4EAAiB;;AAEhD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA,UAAU;AACV;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA,yCAAyC,8EAAoB;AAC7D;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA,UAAU;AACV;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA,iDAAiD,8FAA4B;AAC7E;;AAEA;;AAEA;AACA,gCAAgC,kEAAY;AAC5C;;AAEA;;AAEA;AACA,0CAA0C,0EAAgB;;AAE1D;AACA;AACA,kBAAkB;AAClB;AACA;;AAEA;;AAEA;AACA,kCAAkC;AAClC;AACA,iBAAiB;;AAEjB,cAAc;;AAEd;AACA,SAAS;;AAET;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,IAAI;;AAEb;;AAEA;AACA;AACA;AACA,2BAA2B,kEAAY;AACvC;;AAEA,0BAA0B,0EAAgB;AAC1C;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA,SAAS;;AAET;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,kCAAkC,iBAAiB,GAAG,iBAAiB,GAAG,YAAY;AACtF,cAAc;AACd;AACA,kCAAkC,eAAe,GAAG,iBAAiB,GAAG,YAAY;AACpF;AACA;AACA;AACA,SAAS;;AAET;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,aAAa;AACb,SAAS;AACT;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,aAAa;AACb,SAAS;;AAET;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,aAAa;AACb,SAAS;AACT;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,aAAa;AACb,SAAS;AACT;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA,SAAS;;AAET;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;;AAEb;AACA,SAAS;AACT;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;;AAEb;AACA,SAAS;AACT;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;;AAEb;AACA,SAAS;AACT;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA,wCAAwC,2DAAW;;AAEnD,kCAAkC,kEAAY;;AAE9C,0BAA0B,0EAAgB;AAC1C;;AAEA;;AAEA;AACA;AACA;AACA,qBAAqB;;AAErB;AACA,uDAAuD,2DAAW;;AAElE;AACA;AACA;;AAEA;AACA,qBAAqB;AACrB;;AAEA;AACA;AACA;AACA,qBAAqB;;AAErB;AACA,uDAAuD,2DAAW;;AAElE;AACA;AACA;;AAEA;AACA,qBAAqB;AACrB;AACA;;AAEA,SAAS;;AAET;AACA;;AAEA;;AAEA;;AAEA,uCAAuC,2DAAW;;AAElD,kCAAkC,kEAAY;;AAE9C,yBAAyB,0EAAgB;AACzC;;AAEA;;AAEA;AACA;AACA;AACA,qBAAqB;;AAErB;AACA,uDAAuD,2DAAW;;AAElE;AACA;AACA;;AAEA;AACA,qBAAqB;AACrB;;AAEA;AACA;AACA;AACA,qBAAqB;;AAErB;AACA,uDAAuD,2DAAW;;AAElE;AACA;AACA;;AAEA;AACA,qBAAqB;AACrB;AACA;;AAEA,SAAS;;AAET;;AAEA;AACA;AACA;AACA;;AAEA,aAAa;AACb,SAAS;AACT;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,aAAa;;AAEb;AACA,SAAS;AACT;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,kBAAkB;AAClB;AACA;AACA,cAAc;;AAEd;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,kBAAkB;AAClB;AACA;;AAEA;AACA;AACA,kBAAkB;AAClB;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA,qBAAqB;AACrB;AACA;;AAEA;AACA;AACA;AACA,cAAc;AACd;AACA;;AAEA;AACA;AACA;AACA,cAAc;AACd;AACA;;AAEA;AACA,UAAU;AACV;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,mCAAmC;AACnC;AACA,SAAS;;AAET;;AAEA;;AAEA;AACA;AACA;;AAEA,+BAA+B;AAC/B,SAAS;;AAET;;AAEA;AACA;AACA;AACA;;AAEA,+BAA+B;AAC/B,SAAS;;AAET;AACA;;AAEA;;;;;;;;;;;;;;ACnvBO;;AAEP;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;;;;ACpBO;;AAEP;AACA;AACA;;AAEA;;;;;;;;;;;;;;;;;;ACNmE;AACR;AACkB;AACR;;AAE9D;;AAEP;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,4GAA4G;AAC5G;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,6FAA6F;AAC7F;;AAEA;AACA;;AAEA;AACA;;AAEA,wFAAwF;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA,kBAAkB,0EAAgB;AAClC;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,SAAS;;AAET;AACA;AACA,SAAS;;AAET;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA,YAAY,kEAAY;;AAExB;;AAEA,2BAA2B,oFAAuB;;AAElD;AACA;AACA,cAAc;AACd,2DAA2D,oFAAuB;AAClF;;AAEA;;AAEA,SAAS;;AAET;AACA,YAAY,kEAAY;;AAExB;;AAEA,2BAA2B,oFAAuB;;AAElD;AACA;AACA,cAAc;AACd,sEAAsE,oFAAuB;AAC7F;;AAEA;AACA,SAAS;AACT;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA,kBAAkB,0EAAgB;AAClC;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;;;AAGT;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,aAAa;;AAEb;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;;AAEb,UAAU;AACV;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA,SAAS;;AAET;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA,gBAAgB,kEAAY;AAC5B;AACA;AACA,iBAAiB;AACjB;;AAEA,SAAS;;AAET;;AAEA;AACA;;AAEA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,cAAc;AACd;AACA,cAAc;AACd;AACA;AACA,SAAS;;AAET;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA,SAAS;;AAET;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA,SAAS;;AAET;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA,wBAAwB,8BAA8B;AACtD;AACA;;AAEA;;AAEA,UAAU;AACV;AACA;;AAEA,4BAA4B,8BAA8B;AAC1D;AACA;AACA,UAAU;;AAEV;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,wBAAwB,kEAAY;;AAEpC;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA,SAAS;;AAET;AACA;AACA;;;;;;;;;;;;;;;;ACne2D;AACQ;;AAE5D;;AAEP;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;;;AAGA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA,gCAAgC,kEAAY;AAC5C;;AAEA;;AAEA;;AAEA;AACA,0CAA0C,0EAAgB;;AAE1D;AACA;;AAEA;AACA,kCAAkC;AAClC;AACA,iBAAiB;;AAEjB;AACA,SAAS;;AAET;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,IAAI;;AAEb;;AAEA;AACA;AACA;AACA,2BAA2B,kEAAY;AACvC;;AAEA,0BAA0B,0EAAgB;AAC1C;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,gDAAgD,iBAAiB,GAAG,iBAAiB,GAAG,YAAY;AACpG,cAAc;AACd;AACA,6CAA6C,eAAe,GAAG,iBAAiB,GAAG,YAAY;AAC/F;;AAEA;AACA,SAAS;;AAET;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,aAAa;AACb,SAAS;AACT;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,kBAAkB;AAClB;AACA;AACA,aAAa;AACb,SAAS;AACT;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,aAAa;AACb,SAAS;AACT;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;;;;;;;ACnPyE;AACM;AACJ;;AAEpE;;AAEP;;AAEA;;AAEA;AACA,mBAAmB,kFAAgB;AACnC;;AAEA;AACA,mBAAmB,wFAAmB;AACtC;;AAEA;AACA,mBAAmB,oFAAiB;AACpC;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;;;;;;AC1BoF;AAC5B;;AAEjD;;AAEP;;AAEA;;AAEA;;AAEA;AACA,mBAAmB,6FAAwB;AAC3C;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;;;;;;AC3B4E;AACA;;AAErE;;AAEP;;AAEA;;AAEA;AACA,mBAAmB,qFAAqB;AACxC;;AAEA;AACA,mBAAmB,qFAAqB;AACxC;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;;;;;;ACrByD;AACN;;AAE5C;;AAEP;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV,uBAAuB,kEAAU;AACjC;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV,uBAAuB,4DAAO;AAC9B;AACA;;AAEA;;;;;;;;;;;;;;;;;ACtCoE;AACV;AACN;;AAE7C;;AAEP;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV,uBAAuB,6EAAiB;AACxC;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV,uBAAuB,mEAAY;AACnC;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV,uBAAuB,6DAAS;AAChC;AACA;;AAEA;;;;;;;;;;;;;;;;;;ACpDgE;AACR;AACF;AACsB;;AAErE;;AAEP;;AAEA;;AAEA;AACA;;AAEA;;AAEA,8BAA8B,kEAAY;;AAE1C,sBAAsB,0EAAgB;AACtC;;AAEA;;AAEA;AACA,gBAAgB,iEAAiB;;AAEjC;AACA,cAAc;AACd;AACA;;AAEA;;AAEA,SAAS;;AAET;AACA;;AAEA,kCAAkC,kEAAY;;AAE9C,0BAA0B,0EAAgB;AAC1C;;AAEA;;AAEA;AACA,oBAAoB,iEAAiB;;AAErC;;AAEA,iDAAiD,iEAAiB;AAClE;;AAEA,yBAAyB;AACzB;;AAEA,kBAAkB;AAClB;AACA;;AAEA;AACA,aAAa;AACb;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,aAAa;;AAEb,SAAS;;AAET;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,iBAAiB;;AAEjB,aAAa;AACb;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,SAAS;;AAET;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA,iBAAiB,sFAAsB;;AAEvC;AACA;;AAEA;AACA,kCAAkC,iEAAiB;AACnD,SAAS;;AAET;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,cAAc;AACd;AACA,cAAc;AACd;AACA;;AAEA;AACA;AACA,cAAc;AACd;AACA,cAAc;AACd;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAAS;;AAET;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA,cAAc;AACd;AACA,cAAc;AACd;AACA;;AAEA;AACA,SAAS;;AAET;;AAEA;AACA;;AAEA;AACA;AACA,cAAc;AACd;AACA,cAAc;AACd;AACA;;AAEA;AACA,SAAS;;AAET;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;;AAEA;;;;;;;;;;;;;;ACvSO;;AAEP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA,wDAAwD,QAAQ;AAChE,wDAAwD,QAAQ;;AAEhE;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA,uEAAuE,SAAS;;AAEhF;AACA;AACA;;AAEA,uEAAuE,mBAAmB;;AAE1F;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,SAAS;;AAET,gBAAgB;AAChB;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA,wDAAwD,cAAc;AACtE,UAAU;AACV;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,2BAA2B,qBAAqB;AAChD;AACA;AACA;AACA,aAAa;;AAEb;AACA;AACA;AACA;;AAEA,SAAS;;AAET;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA,wBAAwB,cAAc;AACtC;AACA;;AAEA;AACA;;AAEA,mCAAmC,aAAa;AAChD;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA,UAAU;;AAEV;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;;;;;;;;;;;;;;ACrRO;;AAEP;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,gBAAgB;AAChB;;AAEA;;;;;;;;;;;;;;ACxCO;AACP;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;ACLO;AACP;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;ACLO;AACP;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;ACLO;AACP;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;ACLO;AACP;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;ACLkE;;AAE3D;;AAEP;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,iDAAiD,cAAc;;AAE/D,wBAAwB,eAAe;AACvC,yBAAyB;;AAEzB;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA,kBAAkB,4EAAiB;AACnC;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;;;;;;;;;;;;;;;;ACnCkE;;AAE3D;;AAEP;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA,2BAA2B,cAAc;;AAEzC,wBAAwB;AACxB,yBAAyB;;AAEzB;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,kBAAkB,4EAAiB;AACnC;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;;;;;;;;;;;;;;;;;AChDkE;AACM;;AAEjE;;AAEP;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA,2BAA2B,cAAc;;AAEzC,wBAAwB;AACxB,yBAAyB;;AAEzB;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,kBAAkB,4EAAiB;AACnC;;AAEA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,UAAU;AACV;AACA,0BAA0B,kFAAsB;AAChD;AACA;AACA;AACA;;;;;;;;;;;;;;;;ACvDwE;;AAEjE;;AAEP;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,4CAA4C,cAAc;;AAE1D,wBAAwB,eAAe;AACvC,yBAAyB;;AAEzB;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;AACA,UAAU;AACV,sBAAsB,kFAAsB;AAC5C;AACA;AACA;;;;;;;;;;;;;;;;AChC0E;;AAEnE;;AAEP;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,4CAA4C,cAAc;;AAE1D,wBAAwB,eAAe;AACvC,yBAAyB;;AAEzB;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;AACA,UAAU;AACV,sBAAsB,kFAAsB;AAC5C;AACA;AACA;;;;;;;;;;;;;;;;AChCoF;;AAE7E;;AAEP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA,UAAU;AACV,sBAAsB,8FAA4B;AAClD;AACA;;AAEA;;;;;;;;;;;;;;;;ACzB0E;AACzB;;AAE1C;;AAEP;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,qBAAqB;AACrB;AACA,uBAAuB,2DAAW;AAClC;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA,iBAAiB;;AAEjB;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;;AAEA;AACA,uBAAuB,oFAAuB;AAC9C;AACA;;AAEA;;;;;;;;;;;;;;;AClHiD;;AAE1C;;AAEP;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;;AAEA;AACA,SAAS;AACT;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;;AAEA;AACA,SAAS;AACT;AACA;AACA;;AAEA;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA;;AAEA,wBAAwB,2DAAW;;AAEnC;AACA;;AAEA;AACA;;AAEA,wBAAwB,2DAAW;;AAEnC;AACA;;AAEA;;;;;;;;;;;;;;AClFO;;AAEP;AACA;AACA;AACA,gBAAgB;AAChB,kBAAkB;AAClB;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;AC/HO;;AAEP;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;;;AClBO;;AAEP;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,kBAAkB;AAClB;AACA,kBAAkB;AAClB;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;;;;AC1BO;;AAEP;AACA;AACA;;AAEA;AACA,UAAU;AACV;AACA;AACA;;AAEA;;;;;;;;;;;;;;ACZO;;AAEP;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;;AAEA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;;AAEA;AACA,cAAc;AACd;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,kDAAkD,0BAA0B;AAC5E,UAAU;AACV;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;;AAEA;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA,2CAA2C,YAAY,IAAI,YAAY;AACvE;AACA;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;AACA;AACA,mBAAmB,WAAW;AAC9B,oBAAoB,eAAe;AACnC,oBAAoB,cAAc;AAClC;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA,mBAAmB,WAAW;AAC9B,oBAAoB,eAAe;AACnC,oBAAoB,cAAc;AAClC;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,0CAA0C,4BAA4B;AACtE,0CAA0C,4BAA4B;AACtE;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;;;;AC5NO;;AAEP;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA,SAAS,MAAM,MAAM;;AAErB;;AAEA,oBAAoB;;AAEpB;AACA;;AAEA,cAAc;AACd;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA,cAAc;AACd;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,iBAAiB;;AAEjB;AACA;;AAEA;;AAEA;;AAEA,UAAU;AACV;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,UAAU;AACV;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,uCAAuC,2BAA2B;AAClE,uCAAuC,2BAA2B;AAClE;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,uBAAuB,sCAAsC;AAC7D;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,uCAAuC,oCAAoC;AAC3E,uCAAuC,oCAAoC;;AAE3E;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;AClagE;AACY;AACA;AACZ;AACQ;;AAEjE;;AAEP;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA,8CAA8C,0EAAkB;;AAEhE;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA,sCAAsC,2BAA2B;;AAEjE;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,0CAA0C,2BAA2B;;AAErE;AACA;;AAEA;AACA;;AAEA,sBAAsB,sFAAsB;;AAE5C;;AAEA;;AAEA;;;AAGA,oBAAoB;AACpB;;AAEA;AACA;;;AAGA,wBAAwB;;AAExB;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,sBAAsB;AACtB;AACA;AACA,iBAAiB;;AAEjB;AACA,8BAA8B;;AAE9B;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA,kBAAkB;AAClB;AACA;;AAEA;AACA;;AAEA,gCAAgC,sFAAsB;;AAEtD;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,oCAAoC,kFAAqB;AACzD;;AAEA;;;;;;;;;;;;;;;;;;AC3QgE;AACY;AACA;AACJ;;AAEjE;;AAEP;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA,8CAA8C,0EAAkB;AAChE;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA,sCAAsC,2BAA2B;;AAEjE;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,0CAA0C,2BAA2B;;AAErE;AACA;;AAEA;AACA;;AAEA,sBAAsB,sFAAsB;;AAE5C;AACA;;AAEA,oBAAoB;;AAEpB;AACA;;AAEA;AACA;AACA,iBAAiB;;AAEjB;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;;AAEA,gCAAgC,sFAAsB;;AAEtD;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,oCAAoC,kFAAqB;AACzD;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;;;;;;;;ACrK0D;AACM;AACR;AACP;AACS;;AAEnD;;AAEP;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd,0BAA0B,oEAAe;AACzC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,UAAU;AACV,sBAAsB,oEAAe;AACrC;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,4DAA4D,gBAAgB;AAC5E;AACA;AACA,aAAa;AACb;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA,UAAU;AACV;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,cAAc;AACd;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,SAAS;;AAET;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA,UAAU;AACV,sBAAsB,0EAAkB;AACxC;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,aAAa;AACb,UAAU;AACV,sBAAsB,0EAAkB;AACxC;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,qBAAqB;AACrB,kBAAkB;;AAElB;;AAEA;AACA,aAAa;;AAEb;;AAEA,4BAA4B,oDAAoD;;AAEhF;;AAEA;AACA;AACA,iBAAiB;;AAEjB;AACA;;AAEA,UAAU;AACV,sBAAsB,0EAAkB;AACxC;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,aAAa;;AAEb,UAAU;AACV,sBAAsB,0EAAkB;AACxC;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;;AAET;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,iBAAiB;;AAEjB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,mCAAmC,kEAAY;AAC/C,wBAAwB,2DAAW;AACnC;;AAEA;AACA;AACA;AACA;;AAEA,kBAAkB;;AAElB,mCAAmC,kEAAY;;AAE/C;AACA;AACA;AACA;;AAEA;;AAEA;AACA,mCAAmC,kEAAY;AAC/C,wBAAwB,2DAAW;AACnC;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,yBAAyB;;AAEzB;;AAEA,kBAAkB;AAClB,mCAAmC,kEAAY;;AAE/C;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,yBAAyB;;AAEzB;AACA;AACA;AACA,SAAS;;AAET;AACA;;AAEA;AACA,yBAAyB,oEAAe;AACxC;AACA;AACA;AACA,SAAS;;AAET;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;;;;;UCtfA;UACA;;UAEA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;;UAEA;UACA;;UAEA;UACA;UACA;;;;;WCtBA;WACA;WACA;WACA;WACA,yCAAyC,wCAAwC;WACjF;WACA;WACA;;;;;WCPA;;;;;WCAA;WACA;WACA;WACA,uDAAuD,iBAAiB;WACxE;WACA,gDAAgD,aAAa;WAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;ACNmE;AACV;AACN;AACgB;AACY;AAClB;AACQ;AACU;AACQ;AACF;AAClC;AACM;AACF;AACU;AACe;;AAEhF;;AAEA,8BAA8B,6EAAiB;;AAE/C,wBAAwB,mEAAY;;AAEpC,qBAAqB,6DAAS;;AAE9B,6EAAgB;AAChB,6EAAgB;AAChB,6EAAgB;;AAEhB,yFAAsB,2BAA2B,mEAAU;AAC3D,yFAAsB,wBAAwB,6DAAO;;AAErD,6EAAiB,qBAAqB,mEAAY;;AAElD,wCAAwC,uEAAa;AACrD,4CAA4C,+EAAiB;AAC7D,iDAAiD,yFAAsB;AACvE,wCAAwC,iGAAqB;AAC7D,uCAAuC,+FAAoB;AAC3D,qDAAqD,4FAAqB","sources":["webpack://Astrovis/webpack/universalModuleDefinition","webpack://Astrovis/./components/FileComponent.js","webpack://Astrovis/./components/SettingsComponent.js","webpack://Astrovis/./components/VisualizationComponent.js","webpack://Astrovis/./components/file_type/CSVSettingsComponent.js","webpack://Astrovis/./components/file_type/FITSSettingsComponent.js","webpack://Astrovis/./components/inputs/ArithmeticColumnInput.js","webpack://Astrovis/./containers/DataProcessorContainer.js","webpack://Astrovis/./containers/RegistryContainer.js","webpack://Astrovis/./containers/SettingsContainer.js","webpack://Astrovis/./containers/VisualizationContainer.js","webpack://Astrovis/./containers/WrapperContainer.js","webpack://Astrovis/./data_processors/DataPreProcessor.js","webpack://Astrovis/./data_processors/LightCurveProcessor.js","webpack://Astrovis/./data_processors/SpectrumProcessor.js","webpack://Astrovis/./errors/EventNotFoundInRegistryError.js","webpack://Astrovis/./errors/HDUNotTabularError.js","webpack://Astrovis/./errors/InvalidURLError.js","webpack://Astrovis/./errors/NoEventSubscriberError.js","webpack://Astrovis/./errors/NoEventToDispatchError.js","webpack://Astrovis/./events/ConfigurationEvent.js","webpack://Astrovis/./events/FileLoadedEvent.js","webpack://Astrovis/./events/FileRegistryChangeEvent.js","webpack://Astrovis/./events/SettingsChangedEvent.js","webpack://Astrovis/./events/VisualizationGenerationEvent.js","webpack://Astrovis/./registries/EventSubscribersRegistry.js","webpack://Astrovis/./registries/FileRegistry.js","webpack://Astrovis/./settings/SettingsConfiguration.js","webpack://Astrovis/./settings/VisualizationSettings.js","webpack://Astrovis/./utils/ColumnUtils.js","webpack://Astrovis/./utils/ObjectUtils.js","webpack://Astrovis/./utils/StringUtils.js","webpack://Astrovis/./visualizations/BokehGraph.js","webpack://Astrovis/./visualizations/D3Graph.js","webpack://Astrovis/./wrappers/BokehWrapper.js","webpack://Astrovis/./wrappers/D3Wrapper.js","webpack://Astrovis/./wrappers/FITSReaderWrapper.js","webpack://Astrovis/webpack/bootstrap","webpack://Astrovis/webpack/runtime/define property getters","webpack://Astrovis/webpack/runtime/hasOwnProperty shorthand","webpack://Astrovis/webpack/runtime/make namespace object","webpack://Astrovis/./main.js"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Astrovis\"] = factory();\n\telse\n\t\troot[\"Astrovis\"] = factory();\n})(this, () => {\nreturn ","import {WrapperContainer} from \"../containers/WrapperContainer\";\nimport {FileRegistry} from \"../registries/FileRegistry\";\nimport {FileRegistryChangeEvent} from \"../events/FileRegistryChangeEvent\";\nimport {FITSSettingsComponent} from \"./file_type/FITSSettingsComponent\";\n\nexport class FileComponent extends HTMLElement {\n\n    static component_id = \"file_component\";\n    static select_file = \"select-file\";\n    static input_file_url = \"file-input-url\";\n    static input_file_local = \"file-input-local\";\n    static input_file_type = \"select-file-type\";\n    static load_button = \"load-file\";\n\n    static available_files_list_id = 'available-files-list';\n    static current_files_list_id = 'current-files-list';\n\n    static file_settings_container_id = 'file-settings-container';\n\n    static save_button_id = 'save-file-settings';\n    static add_button_id = 'add-to-plot'\n    static remove_button_id = 'remove-from-plot'\n\n    container_id;\n    container;\n\n    fits_reader_wrapper = null;\n\n    constructor(container_id) {\n        super();\n        this.container_id = container_id;\n        this._setContainer();\n\n        this.handleFITSLoadedEvent = this.handleFITSLoadedEvent.bind(this);\n        this.handleSelectChangeEvent = this.handleSelectChangeEvent.bind(this);\n        this.handleLoadFileEvent = this.handleLoadFileEvent.bind(this);\n        this.handleFileLoadedEvent = this.handleFileLoadedEvent.bind(this);\n        this.handleFileRegistryChangeEvent = this.handleFileRegistryChangeEvent.bind(this);\n\n        this._setupExternalListeners();\n        this._setupInnerListeners();\n\n        this._setupInnerElementsListeners();\n    }\n\n    _setupExternalListeners() {\n        this.addEventListener('fits-loaded', this.handleFITSLoadedEvent);\n        this.addEventListener('file-loaded', this.handleFileLoadedEvent)\n        this.addEventListener('file-registry-change', this.handleFileRegistryChangeEvent)\n    }\n\n    _setupInnerListeners() {\n        this.addEventListener('select-change', this.handleSelectChangeEvent);\n        this.addEventListener('load-file', this.handleLoadFileEvent);\n    }\n\n    _setupInnerElementsListeners() {\n        this._setLoadLocalFileButtonListener();\n        this._setFilesListsListeners();\n    }\n\n    _setLoadLocalFileButtonListener() {\n        let file_input = document.getElementById(FileComponent.input_file_local);\n        let type_input = document.getElementById(FileComponent.input_file_type);\n\n        let file_type = type_input.value;\n\n        file_input.addEventListener('change', function(event) {\n            let file = event.target.files[0];\n\n            if(file_type === 'fits') {\n                file.arrayBuffer().then(arrayBuffer => {\n                    let fits_reader_wrapper = WrapperContainer.getFITSReaderWrapper();\n\n                    fits_reader_wrapper.initializeFromBuffer(arrayBuffer, file.name);\n\n                }).catch(error => {\n                    console.error('Error reading file as ArrayBuffer:', error);\n                });\n            } else if(file_type === 'csv') {\n                let reader = new FileReader();\n                reader.onload = function(event) {\n                    let csv_file = event.target.result;\n                };\n            }\n\n        });\n\n    }\n\n    _setFilesListsListeners() {\n        let list_available = document.getElementById(FileComponent.available_files_list_id);\n        let list_current = document.getElementById(FileComponent.current_files_list_id);\n\n        let buttons_available = list_available.querySelectorAll(\"button\");\n        let buttons_current = list_current.querySelectorAll(\"button\");\n\n        let buttons = Array.from(buttons_available).concat(Array.from(buttons_current));\n\n        buttons.forEach(button => {\n            button.addEventListener(\"click\", () => {\n\n                button.classList.toggle(\"active\");\n\n                let aria_current = button.getAttribute(\"aria-current\");\n                if (aria_current && aria_current === \"true\") {\n                    button.removeAttribute(\"aria-current\");\n                    this.clearFileSettingsPanel();\n                } else {\n                    button.setAttribute(\"aria-current\", \"true\");\n\n                    let file = FileRegistry.getFileById(button.getAttribute(\"data-id\"));\n                    this.setFileSettingsPanel(file);\n                }\n\n                let buttons_to_filter = Array.from(buttons);\n\n                let filtered_buttons = buttons_to_filter.filter(list_button => list_button !== button);\n\n                filtered_buttons.forEach(filtered_button => {\n                    filtered_button.classList.remove('active');\n                    filtered_button.removeAttribute('aria-current');\n                })\n\n            });\n        });\n    }\n\n    _setFileSettingsButtonsListeners() {\n        let save_button = document.getElementById(FileComponent.save_button_id);\n        let add_button = document.getElementById(FileComponent.add_button_id);\n\n        save_button.addEventListener('click', (event) => {\n\n        });\n\n        add_button.addEventListener('click', (event) => {\n            let btn = event.target;\n            let file_id = btn.getAttribute('data-id');\n\n            let file = FileRegistry.getFileById(file_id);\n\n            FileRegistry.addToCurrentFiles(file);\n\n            this.updateCurrentFilesList();\n            this.updateAvailableFilesList();\n\n            let frce = new FileRegistryChangeEvent();\n            frce.dispatchToSubscribers();\n        });\n    }\n\n    handleFITSLoadedEvent(event) {\n        this.fits_reader_wrapper = event.detail['fits_reader_wrapper'];\n        let file_path = this.fits_reader_wrapper.getFilePath();\n\n        this._addFileToSelect(file_path);\n    }\n\n    handleFileLoadedEvent(event) {\n        FileRegistry.addToAvailableFiles(event.detail);\n\n        this.updateAvailableFilesList();\n        this._setFilesListsListeners();\n    }\n\n    handleFileRegistryChangeEvent(event) {\n        this.updateAvailableFilesList();\n        this.updateCurrentFilesList();\n\n        this._setFilesListsListeners();\n    }\n\n    handleLoadFileEvent(event) {\n\n    }\n\n    updateFilesLists() {\n        this.updateAvailableFilesList();\n        this.updateCurrentFilesList();\n    }\n\n    updateAvailableFilesList() {\n        let available_files_list_element = document.getElementById(FileComponent.available_files_list_id);\n\n        available_files_list_element.innerHTML = '';\n\n        let file_elements = this._createFileSelection('available');\n\n        file_elements.forEach((file_element) => {\n            available_files_list_element.appendChild(file_element);\n        })\n    }\n\n    updateCurrentFilesList() {\n        let current_files_list_element = document.getElementById(FileComponent.current_files_list_id);\n\n        current_files_list_element.innerHTML = '';\n\n        let file_elements = this._createFileSelection('current');\n\n        file_elements.forEach((file_element) => {\n            current_files_list_element.appendChild(file_element);\n        })\n    }\n\n    clearFileSettingsPanel() {\n        let file_settings_component_container = document.getElementById(FileComponent.file_settings_container_id);\n        file_settings_component_container.innerHTML = '';\n    }\n\n    setFileSettingsPanel(file) {\n        this.clearFileSettingsPanel();\n\n        if(file.type === 'fits') {\n\n            let is_current = FileRegistry.isFileCurrent(file.id);\n\n            let file_settings_component = new FITSSettingsComponent(file, is_current);\n\n            let file_settings_component_container = document.getElementById(FileComponent.file_settings_container_id);\n            file_settings_component_container.appendChild(file_settings_component);\n\n            file_settings_component.setupComponent();\n        }\n\n    }\n\n    _addFileToSelect(file) {\n        let file_option = this._createSelectOption(file);\n        let select = document.getElementById(FileComponent.select_file);\n\n        select.add(file_option);\n    }\n\n    _createFileSelection(list = 'available') {\n        let files;\n\n        if(list === 'available') {\n            files = FileRegistry.getAvailableFilesList();\n        } else {\n            files = FileRegistry.getCurrentFilesList();\n        }\n\n        let selection_elements = [];\n\n        let file_selection;\n        files.forEach((available_file) => {\n            let file_uid = available_file.id+'.'+available_file.file_name;\n\n            file_selection = document.createElement(\"button\");\n            file_selection.setAttribute(\"type\", \"button\");\n            file_selection.setAttribute(\"class\", \"available-file-selection list-group-item list-group-item-action\");\n            file_selection.setAttribute(\"data-id\", available_file.id);\n            file_selection.textContent = file_uid;\n\n            selection_elements.push(file_selection);\n        })\n\n        return selection_elements;\n    }\n\n    _createSelectOption(file_path) {\n        let option = document.createElement(\"option\");\n\n        option.value = file_path;\n        option.text = file_path;\n\n        return option;\n    }\n\n    handleSelectChangeEvent(event) {\n        event.stopPropagation();\n    }\n\n    _setContainer() {\n        this.container = document.getElementById(this.container_id)\n    }\n\n    resetContainer() {\n        this.container.innerHTML = \"\";\n    }\n\n}","import {SettingsContainer} from \"../containers/SettingsContainer\";\nimport {SettingsChangedEvent} from \"../events/SettingsChangedEvent\";\nimport {VisualizationGenerationEvent} from \"../events/VisualizationGenerationEvent\";\nimport {FileRegistry} from \"../registries/FileRegistry\";\nimport {WrapperContainer} from \"../containers/WrapperContainer\";\nimport {ColumnUtils} from \"../utils/ColumnUtils\";\nimport {RegistryContainer} from \"../containers/RegistryContainer\";\nimport {FileRegistryChangeEvent} from \"../events/FileRegistryChangeEvent\";\n\nexport class SettingsComponent extends HTMLElement {\n\n    container_id;\n    container\n\n    static component_id = \"settings_component\";\n    static container_id = \"settings-component\";\n\n    static select_library_id = \"select-library\";\n\n    static select_data_type_id = \"select-data-type\";\n\n    static light_curve_settings_id = \"light-curve-settings\"\n    static spectrum_settings_id = \"spectrum-settings\"\n\n    static select_hdus_id = \"select-hdus\";\n\n    static calculation_radio_class = \"calculation-radio\";\n\n    static select_axis_x_id = \"select-axis-x\";\n    static select_axis_y_id = \"select-axis-y\";\n\n    static select_error_bar_x_id = \"select-axis-x-error-bar\";\n    static select_error_bar_y_id = \"select-axis-y-error-bar\";\n\n    static supported_data_types = ['generic', 'light-curve', 'spectrum'];\n\n    fits_reader_wrapper = null;\n    settings_object = null;\n\n    constructor() {\n        super();\n\n        this.container_id = SettingsComponent.container_id;\n        this._setContainer();\n\n        this.settings_object = SettingsContainer.getSettingsContainer().getVisualizationSettingsObject();\n\n        this.handleFITSLoadedEvent = this.handleFITSLoadedEvent.bind(this);\n        this.handleConfigurationEvent = this.handleConfigurationEvent.bind(this);\n\n        this.handleLibraryChangeEvent = this.handleLibraryChangeEvent.bind(this);\n        this.handleDataTypeChangeEvent = this.handleDataTypeChangeEvent.bind(this);\n        this.handleHDUsChangeEvent = this.handleHDUsChangeEvent.bind(this);\n        this.handleGenerateEvent = this.handleGenerateEvent.bind(this);\n        this.handleFileChangeEvent = this.handleFileChangeEvent.bind(this);\n        this.handleArithmeticColumnChangeEvent = this.handleArithmeticColumnChangeEvent.bind(this);\n\n        this._setupExternalListeners();\n        this._setupInnerListeners();\n\n        this._setupInnerElementsListeners();\n    }\n\n    _setupExternalListeners() {\n        this.addEventListener('fits-loaded', this.handleFITSLoadedEvent);\n        this.addEventListener('configuration', this.handleConfigurationEvent);\n        this.addEventListener('file-registry-change', this.handleFileChangeEvent);\n    }\n\n    _setupInnerListeners() {\n        this.addEventListener('select-library-change', this.handleLibraryChangeEvent);\n        this.addEventListener('select-data-type-change', this.handleDataTypeChangeEvent);\n        this.addEventListener('select-hdus-change', this.handleHDUsChangeEvent);\n        this.addEventListener('button-generate-click', this.handleGenerateEvent);\n        this.addEventListener('arithmetic-column-change', this.handleArithmeticColumnChangeEvent);\n    }\n\n    _setupInnerElementsListeners() {\n        this._setSelectLibraryListener();\n        this._setSelectDataTypeListener()\n        this._setSelectHDUsListener();\n        this._setSelectAxisListener();\n        this._setGenerateButtonListener();\n        this._setCalculationRadioListeners();\n    }\n\n    handleFITSLoadedEvent(event) {\n        this.fits_reader_wrapper = event.detail['fits_reader_wrapper'];\n\n        let hdus = this.fits_reader_wrapper.getHDUs();\n        this._setSelectHDUs(hdus);\n\n        if(this.fits_reader_wrapper.isHDUTabular(hdus[0].index)) {\n            let hdu_columns_name = this.fits_reader_wrapper.getColumnsNameFromHDU(hdus[0].index);\n\n            this._setSelectAxis(hdu_columns_name);\n            this._setSelectErrorBars(hdu_columns_name);\n\n        } else {\n            this._resetSelectAxis();\n            this._resetSelectErrorBars()\n        }\n\n    }\n\n    handleConfigurationEvent(event) {\n        let configuration_object = event.detail.configuration_object;\n\n        this.updateSettings(configuration_object);\n    }\n\n    handleLibraryChangeEvent(event) {\n        event.stopPropagation();\n\n        this.updateSettingsObject();\n\n        let settings_changed_event = new SettingsChangedEvent(this.settings_object);\n        settings_changed_event.dispatch();\n    }\n\n    handleDataTypeChangeEvent(event) {\n        event.stopPropagation();\n        let data_type = event.detail.data_type;\n\n        if(SettingsComponent.supported_data_types.includes(data_type)) {\n            this.updateSettingsObject();\n\n            switch(data_type) {\n\n                case 'light-curve':\n                    document.getElementById(SettingsComponent.light_curve_settings_id).style.display = 'block';\n                    document.getElementById(SettingsComponent.spectrum_settings_id).style.display = 'none';\n                    break;\n\n                case 'spectrum':\n                    document.getElementById(SettingsComponent.spectrum_settings_id).style.display = 'block';\n                    document.getElementById(SettingsComponent.light_curve_settings_id).style.display = 'none';\n                    break;\n\n                default:\n                    document.getElementById(SettingsComponent.spectrum_settings_id).style.display = 'none';\n                    document.getElementById(SettingsComponent.light_curve_settings_id).style.display = 'none';\n            }\n\n        }\n\n    }\n\n    handleHDUsChangeEvent(event) {\n        event.stopPropagation();\n        let hdu_index = event.detail.hdu_index;\n\n        if(this.fits_reader_wrapper.isHDUTabular(hdu_index)) {\n            let hdu_columns_name = this.fits_reader_wrapper.getColumnsNameFromHDU(hdu_index);\n\n            this._setSelectAxis(hdu_columns_name);\n            this._setSelectErrorBars(hdu_columns_name);\n\n        } else {\n            this._resetSelectAxis();\n            this._resetSelectErrorBars()\n        }\n    }\n\n    handleGenerateEvent(event) {\n        event.stopPropagation();\n\n        this.settings_object.reset();\n\n        this.updateSettingsObject();\n\n        let visualization_generation_event = new VisualizationGenerationEvent(this.settings_object);\n        visualization_generation_event.dispatch();\n\n    }\n\n    handleFileChangeEvent(event) {\n        let current_file_list = FileRegistry.getCurrentFilesList();\n        let columns = [];\n\n        current_file_list.forEach((file) => {\n\n            if(file.type === 'fits') {\n                let fits_reader_wrapper = WrapperContainer.getFITSReaderWrapper();\n\n                if(file.product_type !== 'spectrum') {\n                    fits_reader_wrapper.setFile(file.file);\n                } else {\n                    fits_reader_wrapper.setFileFromFileObject(file);\n                }\n\n                let fits_columns = fits_reader_wrapper.getAllColumns();\n\n                fits_columns.forEach((fits_column) => {\n                    let column = {...fits_column, file_id: file.id};\n                    columns.push(column);\n                })\n\n            } else if(file.type === 'csv') {\n\n            }\n        })\n\n        let columns_by_file = columns.reduce((acc, column) => {\n            if (!acc[column.file_id]) {\n                acc[column.file_id] = [];\n            }\n            acc[column.file_id].push(column);\n            return acc;\n        }, {});\n\n        let select_options = [];\n\n        let i = 1;\n        for (let file_id in columns_by_file) {\n            if (columns_by_file.hasOwnProperty(file_id)) {\n                let file = FileRegistry.getFileById(file_id);\n                let file_name = file.file_name;\n\n                let frw = WrapperContainer.getFITSReaderWrapper();\n                frw.setFile(file.file);\n\n                select_options.push(this._createFileColumnsOptionsGroup(columns_by_file[file_id], file_name, 'opt-group', frw));\n            }\n            i++;\n        }\n\n        this._setSelectGroupAxis(select_options);\n\n        select_options.unshift(this._createGenericColumnOptionsGroup());\n        this._setSelectGroupErrorBars(select_options);\n    }\n\n    handleArithmeticColumnChangeEvent(event) {\n        //this._setSelectAxis()\n    }\n\n    _setContainer() {\n        this.container = document.getElementById(this.container_id)\n    }\n\n    _resetContainer() {\n        this.container.innerHTML = \"\";\n    }\n\n    _setSelectHDUs(hdus) {\n        this._resetSelectHDUs();\n\n        let select = document.getElementById(SettingsComponent.select_hdus_id);\n\n        let options = this._createHDUsOptions(hdus);\n\n        options.forEach(function(option) {\n            select.add(option);\n        });\n    }\n\n    _resetSelectHDUs() {\n        let select = document.getElementById(SettingsComponent.select_hdus_id);\n        select.innerHTML = '';\n    }\n\n    _createHDUsOptions(HDUs) {\n        let options = [];\n        let option;\n\n        HDUs.forEach(function(hdu, index) {\n            option = document.createElement(\"option\");\n\n            if(index === 0) option.setAttribute('selected', 'true');\n\n            option.value = hdu.index;\n            option.text = hdu.name;\n\n            options.push(option);\n        })\n\n        return options;\n    }\n\n    _createFileColumnsOptionsGroup(file_columns, group_name, group_class, fits_reader_wrapper) {\n\n        let opt_group = document.createElement(\"optgroup\");\n        opt_group.label = group_name;\n        opt_group.className += group_class;\n\n        file_columns.forEach(column => {\n            let option = document.createElement(\"option\");\n\n            let hdu_type = fits_reader_wrapper.getHeaderCardValueByNameFromHDU(column.hdu_index, 'XTENSION');\n            let hdu_extname = fits_reader_wrapper.getHeaderCardValueByNameFromHDU(column.hdu_index, 'EXTNAME');\n            let name = hdu_type+'-'+hdu_extname+' '+column.name;\n\n            if(column.is_from_header) {\n                name += '(HEADER)';\n            }\n\n            if(column.is_processed) {\n                option.text = name;\n                option.value = `${column.from_file}.${column.hdu_index}$${column.name}`;\n            } else {\n                option.text = name;\n                option.value = `${column.file_id}.${column.hdu_index}$${column.name}`;\n            }\n            \n            opt_group.appendChild(option);\n        });\n\n        return opt_group\n    }\n\n    _createGenericColumnOptionsGroup() {\n        let opt_group = document.createElement(\"optgroup\");\n        opt_group.label = \"Genereic columns\";\n        opt_group.className += \"generic\";\n\n        let option = document.createElement(\"option\");\n\n        option.text = 'None';\n        option.value = `none`;\n\n        opt_group.appendChild(option);\n\n        return opt_group;\n    }\n\n    _setSelectAxis(columns) {\n        this._resetSelectAxis();\n\n        let select_axis_x = document.getElementById(SettingsComponent.select_axis_x_id);\n        let select_axis_y = document.getElementById(SettingsComponent.select_axis_y_id);\n\n        let select_axis = [select_axis_x, select_axis_y];\n\n        let options = this._createColumnsOptions(columns);\n\n        options.forEach(function(option) {\n            select_axis.forEach(function(select) {\n                let cloned_option = option.cloneNode(true);\n                select.add(cloned_option);\n            })\n        });\n    }\n\n    _setSelectGroupAxis(columns_optgroup) {\n        this._resetSelectAxis();\n\n        let select_axis_x = document.getElementById(SettingsComponent.select_axis_x_id);\n        let select_axis_y = document.getElementById(SettingsComponent.select_axis_y_id);\n\n        let select_axis = [select_axis_x, select_axis_y];\n\n        columns_optgroup.forEach((column_optgroup) => {\n            select_axis.forEach((select) => {\n                let cloned_optgroup = column_optgroup.cloneNode(true);\n                select.add(cloned_optgroup);\n            })\n        })\n\n    }\n\n    _resetSelectAxis() {\n        let select_axis_x = document.getElementById(SettingsComponent.select_axis_x_id);\n        let select_axis_y = document.getElementById(SettingsComponent.select_axis_y_id);\n\n        select_axis_x.innerHTML = '';\n        select_axis_y.innerHTML = '';\n    }\n\n    _setSelectErrorBars(columns) {\n        this._resetSelectErrorBars();\n\n        let select_error_bar_x = document.getElementById(SettingsComponent.select_error_bar_x_id);\n        let select_error_bar_y = document.getElementById(SettingsComponent.select_error_bar_y_id);\n\n        let select_error_bars = [select_error_bar_x, select_error_bar_y];\n\n        let options = this._createColumnsOptions(columns);\n\n        options.forEach(function(option) {\n            select_error_bars.forEach(function(select) {\n                let cloned_option = option.cloneNode(true);\n                select.add(cloned_option);\n            })\n        });\n    }\n\n    _setSelectGroupErrorBars(columns_optgroup) {\n        this._resetSelectErrorBars();\n\n        let select_error_bar_x = document.getElementById(SettingsComponent.select_error_bar_x_id);\n        let select_error_bar_y = document.getElementById(SettingsComponent.select_error_bar_y_id);\n\n        let select_error_bars = [select_error_bar_x, select_error_bar_y];\n\n        columns_optgroup.forEach((column_optgroup) => {\n            select_error_bars.forEach((select) => {\n                let cloned_optgroup = column_optgroup.cloneNode(true);\n                select.add(cloned_optgroup);\n            })\n        })\n    }\n\n    _resetSelectErrorBars() {\n        let select_error_bar_x = document.getElementById(SettingsComponent.select_error_bar_x_id);\n        let select_error_bar_y = document.getElementById(SettingsComponent.select_error_bar_y_id);\n\n        select_error_bar_x.innerHTML = '';\n        select_error_bar_y.innerHTML = '';\n    }\n\n    _createColumnsOptions(columns) {\n        let options = [];\n        let option;\n\n        columns.forEach(function(column) {\n\n            option = document.createElement(\"option\");\n\n            option.value = column;\n            option.text = column;\n\n            options.push(option);\n        })\n\n        return options;\n    }\n\n    _setSelectLibraryListener() {\n        let select_library = document.getElementById(SettingsComponent.select_library_id);\n\n        select_library.addEventListener('change', (event) => {\n            event.preventDefault();\n            const custom_change_event = new CustomEvent('select-library-change', {\n                bubbles: false,\n                compose: false,\n                cancelable: true,\n                detail: {\n                    library: select_library.value\n                }\n            });\n\n            this.dispatchEvent(custom_change_event);\n        });\n    }\n\n    _setSelectDataTypeListener() {\n        let select_data_type = document.getElementById(SettingsComponent.select_data_type_id);\n\n        select_data_type.addEventListener('change', (event) => {\n            event.preventDefault();\n            const custom_change_event = new CustomEvent('select-data-type-change', {\n                bubbles: false,\n                compose: false,\n                cancelable: true,\n                detail: {\n                    data_type: select_data_type.value\n                }\n            });\n\n            this.dispatchEvent(custom_change_event);\n        });\n    }\n\n    _setSelectHDUsListener() {\n        let select_hdus = document.getElementById(SettingsComponent.select_hdus_id);\n\n        select_hdus.addEventListener('change', (event) => {\n            event.preventDefault();\n            const custom_change_event = new CustomEvent('select-hdus-change', {\n                bubbles: false,\n                compose: false,\n                cancelable: true,\n                detail: {\n                    hdu_index: select_hdus.value\n                }\n            });\n\n            this.dispatchEvent(custom_change_event);\n        });\n    }\n\n    _setSelectAxisListener() {\n        let select_axis_x = document.getElementById(SettingsComponent.select_axis_x_id);\n        let select_axis_y = document.getElementById(SettingsComponent.select_axis_y_id);\n\n        let select_error_bar_x = document.getElementById(SettingsComponent.select_error_bar_x_id);\n        let select_error_bar_y = document.getElementById(SettingsComponent.select_error_bar_y_id);\n\n        select_axis_x.addEventListener('change', (e) => {\n            let column_id = e.target.value;\n\n            let data_type = document.getElementById(SettingsComponent.select_data_type_id).value;\n\n            if(data_type === 'light-curve') {\n\n                let column_descriptor = ColumnUtils.getColumnSettings(column_id)\n\n                let file_object = FileRegistry.getFileById(column_descriptor.file_id);\n\n                let frw = WrapperContainer.getFITSReaderWrapper();\n                frw.setFile(file_object.file);\n\n                let columns_name= frw.getAllColumns();\n\n                if(column_descriptor.column_name.toUpperCase() === 'RATE' &&\n                    columns_name.some(column => {\n                        return column.name.toUpperCase() === 'ERROR' && parseInt(column.hdu_index) === parseInt(column_descriptor.hdu_index)\n                    })) {\n\n                    Array.from(select_error_bar_x.options).forEach((option) => {\n                        let option_column_descriptor = ColumnUtils.getColumnSettings(option.value);\n\n                        if(option_column_descriptor.file_id === column_descriptor.file_id &&\n                            option_column_descriptor.hdu_index === column_descriptor.hdu_index &&\n                            option_column_descriptor.column_name.toUpperCase() === 'ERROR')\n\n                            select_error_bar_x.value = option.value;\n                    })\n                }\n\n                if(column_descriptor.column_name.toUpperCase() === 'TIME' &&\n                    columns_name.some(column => {\n                        return column.name.toUpperCase() === 'TIMEDEL' && parseInt(column.hdu_index) === parseInt(column_descriptor.hdu_index)\n                    })) {\n\n                    Array.from(select_error_bar_x.options).forEach((option) => {\n                        let option_column_descriptor = ColumnUtils.getColumnSettings(option.value);\n\n                        if (option_column_descriptor.file_id === column_descriptor.file_id &&\n                            option_column_descriptor.hdu_index === column_descriptor.hdu_index &&\n                            option_column_descriptor.column_name.toUpperCase() === 'TIMEDEL')\n\n                            select_error_bar_x.value = option.value;\n                    })\n                }\n            }\n\n        })\n\n        select_axis_y.addEventListener('change', (e) => {\n            let column_id = e.target.value;\n\n            let data_type = document.getElementById(SettingsComponent.select_data_type_id).value;\n\n            if(data_type === 'light-curve') {\n\n                let column_descriptor= ColumnUtils.getColumnSettings(column_id)\n\n                let file_object = FileRegistry.getFileById(column_descriptor.file_id);\n\n                let frw= WrapperContainer.getFITSReaderWrapper();\n                frw.setFile(file_object.file);\n\n                let columns_name= frw.getAllColumns();\n\n                if(column_descriptor.column_name.toUpperCase() === 'RATE' &&\n                    columns_name.some(column => {\n                        return column.name.toUpperCase() === 'ERROR' && parseInt(column.hdu_index) === parseInt(column_descriptor.hdu_index)\n                    })) {\n\n                    Array.from(select_error_bar_y.options).forEach((option) => {\n                        let option_column_descriptor = ColumnUtils.getColumnSettings(option.value);\n\n                        if(option_column_descriptor.file_id === column_descriptor.file_id &&\n                            option_column_descriptor.hdu_index === column_descriptor.hdu_index &&\n                            option_column_descriptor.column_name.toUpperCase() === 'ERROR')\n\n                            select_error_bar_y.value = option.value;\n                    })\n                }\n\n                if(column_descriptor.column_name.toUpperCase() === 'TIME' &&\n                    columns_name.some(column => {\n                        return column.name.toUpperCase() === 'TIMEDEL' && parseInt(column.hdu_index) === parseInt(column_descriptor.hdu_index)\n                    })) {\n\n                    Array.from(select_error_bar_y.options).forEach((option) => {\n                        let option_column_descriptor = ColumnUtils.getColumnSettings(option.value);\n\n                        if (option_column_descriptor.file_id === column_descriptor.file_id &&\n                            option_column_descriptor.hdu_index === column_descriptor.hdu_index &&\n                            option_column_descriptor.column_name.toUpperCase() === 'TIMEDEL')\n\n                            select_error_bar_y.value = option.value;\n                    })\n                }\n            }\n\n        })\n\n    }\n\n    _setCalculationRadioListeners() {\n        let radio_buttons = document.querySelectorAll('.' + SettingsComponent.calculation_radio_class);\n        radio_buttons.forEach(radio_button => {\n            radio_button.addEventListener('change', event => {\n\n            });\n        });\n    }\n\n    _setGenerateButtonListener() {\n        let button_generate = document.getElementById('button-generate');\n\n        button_generate.addEventListener('click', (event) => {\n            event.preventDefault();\n            const custom_change_event = new CustomEvent('button-generate-click', {\n                bubbles: false,\n                compose: false,\n                cancelable: true,\n                detail: {\n\n                }\n            });\n\n            this.dispatchEvent(custom_change_event);\n        });\n    }\n\n    updateSettings(configuration) {\n        for (let [setting, values] of Object.entries(configuration)) {\n\n            let setting_element = document.getElementById(setting);\n            if (setting_element) {\n\n                if (values.display === true) {\n                    setting_element.style.display = 'block';\n                } else {\n                    setting_element.style.display = 'none';\n                }\n            } else {\n\n            }\n        }\n    }\n\n    updateSettingsObject() {\n        let values = this._extractFormValues();\n\n        let library = {};\n        library.library = values['select-library'].value;\n        this.settings_object.setLibrarySettings(library);\n\n        let hdu = {};\n        hdu['hdu_index'] = values['select-hdus'].value;\n        this.settings_object.setHDUsSettings(hdu);\n\n        let data_type = {};\n\n        data_type.type = values['select-data-type'].value;\n        this.settings_object.setDataTypeSettings(data_type);\n\n        if(values['select-axis-x'] && values['select-axis-y']) {\n            let axis = {};\n            let scales = {};\n\n            axis.x = values['select-axis-x'].value;\n            axis.y = values['select-axis-y'].value;\n\n            scales.x = values['select-axis-x-scale'].value;\n            scales.y = values['select-axis-y-scale'].value;\n\n            this.settings_object.setAxisSettings(axis);\n            this.settings_object.setScalesSettings(scales);\n        }\n\n        if(values['has-error-bars-checkbox']) {\n            if(values['has-error-bars-checkbox'].checked === true) {\n                let error_bars = {};\n\n                if(values['select-axis-x-error-bar'] !== undefined) {\n                    error_bars.x = values['select-axis-x-error-bar'].value;\n                } else {\n                    delete error_bars.x\n                }\n\n                if(values['select-axis-y-error-bar'] !== undefined) {\n                    error_bars.y = values['select-axis-y-error-bar'].value;\n                } else {\n                    delete error_bars.y\n                }\n\n                this.settings_object.setErrorBarsSettings(error_bars);\n            }\n        }\n\n        if(values['has-x-range-checkbox'].checked === true || values['has-y-range-checkbox'].checked === true) {\n\n            let ranges = {\n                x: {},\n                y: {}\n            };\n\n            if(values['has-x-range-checkbox'].checked === true) {\n                ranges['x'].lower_bound = values['x-lower-bound'].value;\n                ranges['x'].upper_bound = values['x-higher-bound'].value;\n            } else {\n                ranges['x'] = null;\n            }\n\n            if(values['has-y-range-checkbox'].checked === true) {\n                ranges['y'].lower_bound = values['y-lower-bound'].value;\n                ranges['y'].upper_bound = values['y-higher-bound'].value;\n            } else {\n                ranges['y'] = null;\n            }\n\n            this.settings_object.setRangesSettings(ranges);\n        } else {\n            this.settings_object.setRangesSettings(null);\n        }\n\n    }\n\n    _extractFormValues() {\n\n        let form_values = {};\n\n        let selects = this.container.querySelectorAll('.form-select');\n\n        selects.forEach(select => {\n            let id = select.id;\n            let classes = select.className.split(' ');\n            let value = select.value;\n\n            if(window.getComputedStyle(select, null).getPropertyValue(\"display\") !== 'none' && value !== 'none') {\n                form_values[id] = {classes, value};\n            }\n        });\n\n        let checkboxes = this.container.querySelectorAll('.form-checkbox');\n\n        checkboxes.forEach(checkbox => {\n\n            let id = checkbox.id;\n            let classes = checkbox.className.split(' ');\n            let checked = checkbox.checked;\n\n            form_values[id] = {classes, checked};\n        });\n\n        let inputs = this.container.querySelectorAll('.form-input');\n\n        inputs.forEach(input => {\n            let id = input.id;\n            let classes = input.className.split(' ');\n            let value = input.value;\n\n            form_values[id] = {classes, value};\n        })\n\n        return form_values;\n    }\n\n}","export class VisualizationComponent extends HTMLElement {\n\n    container_id;\n    container\n\n    constructor(container_id) {\n        super();\n\n        this.container_id = container_id;\n        this._setContainer();\n    }\n\n    _setContainer() {\n        this.container = document.getElementById(this.container_id)\n    }\n\n    resetContainer() {\n        this.container.innerHTML = \"\";\n    }\n\n}","export class CSVSettingsComponent extends HTMLElement {\n\n    constructor(file_id) {\n        super();\n    }\n\n}","import {WrapperContainer} from \"../../containers/WrapperContainer\";\nimport {FileRegistry} from \"../../registries/FileRegistry\";\nimport {FileRegistryChangeEvent} from \"../../events/FileRegistryChangeEvent\";\nimport {RegistryContainer} from \"../../containers/RegistryContainer\";\n\nexport class FITSSettingsComponent extends HTMLElement {\n\n    container_id = \"fits-settings-container\";\n    select_hdu_id = \"select-hdu-file\";\n    table_header_id = \"table-header-data\";\n    table_data_id = \"table-data\";\n\n    file = null;\n    is_current = false;\n\n    add_to_plot_btn_id = \"add-to-plot\";\n    remove_from_plot_btn_id = \"remove-from-plot\";\n    save_btn_id = 'save-file-settings';\n\n    product_type_select_id = 'product-type-select';\n    arf_file_select_id = 'arf-file-select';\n    rmf_file_select_id = 'rmf-file-select';\n\n    container = '<div id=\"fits-settings-container\" class=\"full-width-column\" style=\"grid-column: 1 / span 2;\">' +\n        '<div class=\"card\">' +\n        '<div class=\"card-body\">' +\n        '</div>' +\n        '</div>' +\n        '</div>';\n\n    select_hdu_file = '<select id=\"select-hdu-file\" class=\"form-select\"></select>';\n\n    inner_container = '<div class=\"inner-row\"></div>';\n\n    header_column = '<div class=\"left-column\">' +\n        '<div class=\"card-header\">Header</div>' +\n        '<div class=\"card-body\">' +\n        '<div id=\"header-hdu-file\">' +\n        '</div>' +\n        '</div>';\n\n    table_header = '<table id=\"table-header-data\" class=\"table table-striped\">' +\n        '    <thead>' +\n        '    <tr>' +\n        '        <th scope=\"col\">#</th>' +\n        '        <th scope=\"col\">Name</th>' +\n        '        <th scope=\"col\">Value</th>' +\n        '        <th scope=\"col\">Comment</th>' +\n        '    </tr>' +\n        '    </thead>' +\n        '    <tbody class=\"table-group-divider\">' +\n        '    </tbody>' +\n        '</table>'\n\n    data_column = '<div class=\"right-column\">' +\n        '<div class=\"card-header\">Data</div>' +\n        '<div class=\"card-body\">' +\n        '   <div id=\"data-hdu-file\">' +\n        '   </div>' +\n        '</div>';\n\n    table_data = '<table id=\"table-data\" class=\"table table-striped\">' +\n        '    <thead>' +\n        '       <tr>' +\n        '       </tr>' +\n        '    </thead>' +\n        '    <tbody class=\"table-group-divider\">' +\n        '    </tbody>' +\n        '</table>'\n\n    btn_save_settings = '<button class=\"btn btn-success\" id=\"save-file-settings\">Save changes</button>';\n    btn_add_to_plot = '<button class=\"btn btn-primary\" id=\"add-to-plot\">Add to plot</button>;'\n    btn_remove_from_plot = '<button class=\"btn btn-danger\" id=\"remove-from-plot\">Remove from plot</button>';\n\n    constructor(file, is_current) {\n        super();\n\n        this.file = file;\n        this.is_current = is_current;\n\n        this.innerHTML = '<div class=\"full-width-column\" style=\"grid-column: 1 / span 2;\">\\n' +\n            '                            <div class=\"card\">\\n' +\n            '                                <div class=\"card-header\">File settings</div>\\n' +\n            '                                <div class=\"card-body\">\\n' +\n            ' <!--label for=\"product-type-select\">Product type :</label>' +\n            ' <select id=\"product-type-select\" class=\"form-select\"><option selected=\"selected\" value=\"none\">None</option><option value=\"lightcurve\">Light Curve</option><option value=\"spectrum\">Spectrum</option></select> ' +\n            ' <label for=\"product-type-select\" class=\"spectrum-settings\">ARF file : </label>' +\n            ' <select id=\"arf-file-select\" class=\"form-select spectrum-settings\"></select>' +\n            ' <label for=\"product-type-select\" class=\"spectrum-settings\">RMF file :</label>' +\n            ' <select id=\"rmf-file-select\" class=\"form-select spectrum-settings\"></select>' +\n            ' <label for=\"select-hdu-file\">HDU :</label-->' +\n            '                                    <select id=\"select-hdu-file\" class=\"form-select\">\\n' +\n            '\\n' +\n            '                                    </select>\\n' +\n            '\\n' +\n            '                                    <div class=\"inner-row\">\\n' +\n            '                                        <div class=\"left-column\">\\n' +\n            '                                            <div class=\"card\">\\n' +\n            '                                                <div class=\"card-header\">Header</div>\\n' +\n            '                                                <div class=\"card-body\">\\n' +\n            '                                                    <div id=\"header-hdu-file\" class=\"file-data-container\">\\n' +\n            '                                                        <table id=\"table-header-data\" class=\"table table-striped\">\\n' +\n            '                                                            <thead>\\n' +\n            '                                                            <tr>\\n' +\n            '                                                                <th scope=\"col\">#</th>\\n' +\n            '                                                                <th scope=\"col\">Name</th>\\n' +\n            '                                                                <th scope=\"col\">Value</th>\\n' +\n            '                                                                <th scope=\"col\">Comment</th>\\n' +\n            '                                                            </tr>\\n' +\n            '                                                            </thead>\\n' +\n            '                                                            <tbody class=\"table-group-divider\">\\n' +\n            '\\n' +\n            '                                                            </tbody>\\n' +\n            '                                                        </table>\\n' +\n            '                                                    </div>\\n' +\n            '                                                </div>\\n' +\n            '                                            </div>\\n' +\n            '                                        </div>\\n' +\n            '                                        <div class=\"right-column\">\\n' +\n            '                                            <div class=\"card\">\\n' +\n            '                                                <div class=\"card-header\">Data</div>\\n' +\n            '                                                <div class=\"card-body\">\\n' +\n            '                                                    <div id=\"data-hdu-file\" class=\"file-data-container\">\\n' +\n            '<table id=\"table-data\" class=\"table table-striped\">' +\n                '    <thead>' +\n                '       <tr>' +\n                    '       </tr>' +\n                '    </thead>' +\n                '    <tbody class=\"table-group-divider\">' +\n                '    </tbody>' +\n                '</table>'+\n            '                                                    </div>\\n' +\n            '                                                </div>\\n' +\n            '                                            </div>\\n' +\n            '                                        </div>\\n' +\n            '                                    </div>\\n' +\n            '\\n' +\n            '                                    <button class=\"btn btn-success\" id=\"save-file-settings\">Save changes</button>\\n' +\n            '                                    <button class=\"btn btn-primary\" id=\"add-to-plot\">Add to plot</button>\\n' +\n            '                                    <button class=\"btn btn-danger\" id=\"remove-from-plot\">Remove from plot</button>\\n' +\n            '                                </div>\\n' +\n            '                            </div>\\n' +\n            '                        </div>'\n\n    }\n\n    setupComponent() {\n        this.setHDUSelect();\n        this.setupActionButtons();\n        this.setProductSettings();\n\n        let select_hdu = document.getElementById(this.select_hdu_id);\n        let hdu_index = select_hdu.value;\n\n        this.setTables(hdu_index);\n\n        this.setupInnerElementListeners();\n    }\n\n    setHDUSelect() {\n\n        let select_hdu = document.getElementById(this.select_hdu_id);\n\n        select_hdu.innerHTML = '';\n\n        let frw = WrapperContainer.getFITSReaderWrapper();\n        frw.setFile(this.file.file);\n\n        let hdus = frw.getHDUs();\n\n        let options = [];\n        hdus.forEach((hdu) => {\n            let option = document.createElement(\"option\");\n\n            option.value = hdu.index;\n            option.text = hdu.name + ' ' + hdu.extname;\n\n            options.push(option);\n        })\n\n        options.forEach((option) => {\n            select_hdu.add(option);\n        })\n\n    }\n\n    setupInnerElementListeners() {\n        this.setHDUSelectListener();\n        this.setSaveButtonListener();\n        //this.setProductTypeSelectListener();\n        //this.setARFFileSelectListener();\n        //this.setRMFFileSelectListener();\n    }\n\n    setupActionButtons() {\n\n        let add_to_plot_btn = document.getElementById(this.add_to_plot_btn_id);\n        let remove_from_plot_btn  = document.getElementById(this.remove_from_plot_btn_id);\n\n        if(this.is_current) {\n            add_to_plot_btn.style.display = 'none';\n            remove_from_plot_btn.style.display = 'initial';\n        } else {\n            add_to_plot_btn.style.display = 'initial';\n            remove_from_plot_btn.style.display = 'none';\n        }\n\n        add_to_plot_btn.addEventListener('click', (event) => {\n            FileRegistry.addToCurrentFiles(this.file);\n\n            this.is_current = true;\n\n            let frce = new FileRegistryChangeEvent();\n\n            try {\n                frce.dispatchToSubscribers();\n            } catch(e) {\n                console.log(\"No subsribers for event : \" + FileRegistryChangeEvent.name);\n            }\n\n            this.resetContainerForCurrentFile();\n\n        });\n\n        remove_from_plot_btn.addEventListener('click', (event) => {\n            FileRegistry.removeFromCurrentFiles(this.file.id);\n\n            this.is_current = false;\n\n            let frce = new FileRegistryChangeEvent();\n\n            try {\n                frce.dispatchToSubscribers();\n            } catch(e) {\n                console.log(\"No subscribers for specified event : \" + FileRegistryChangeEvent.name);\n            }\n\n            this.resetContainerForCurrentFile();\n        });\n    }\n\n    setProductSettings() {\n        let product_type = null;\n        let rmf_file = null;\n        let arf_file = null;\n\n        if(this.file.product_type) product_type = this.file.product_type;\n        if(this.file.rmf_file) rmf_file = this.file.rmf_file;\n        if(this.file.arf_file) arf_file = this.file.arf_file;\n\n        //this.setProductTypeSelect(product_type);\n        //this.setRMFFileSelect(rmf_file);\n        //this.setARFFileSelect(arf_file);\n    }\n\n    setTables(hdu_index) {\n        this.resetTables();\n\n        let table_header = document.getElementById(this.table_header_id);\n        let table_data = document.getElementById(this.table_data_id);\n\n        let frw = WrapperContainer.getFITSReaderWrapper();\n        frw.setFile(this.file.file);\n\n        let hdu_cards = frw.getHeaderCardsValueFromHDU(hdu_index)\n\n        let tbody = table_header.querySelector('tbody');\n\n        hdu_cards.forEach(card => {\n\n            let row = tbody.insertRow();\n\n            let index_cell = row.insertCell(0);\n            let card_cell = row.insertCell(1);\n            let name_cell = row.insertCell(2);\n            let description_cell = row.insertCell(3);\n\n            index_cell.textContent = card.index;\n            card_cell.textContent = card.card_name;\n            name_cell.textContent = card.value;\n            description_cell.textContent = card.comment;\n        });\n\n\n        try {\n\n            let hdu_columns_name = frw.getColumnsNameFromHDU(hdu_index);\n            let hdu_data = frw.getColumnsJSONDataFromHDU(hdu_index)\n\n            let header_row = table_data.tHead.insertRow();\n            tbody = table_data.querySelector('tbody');\n\n            hdu_columns_name.forEach((column) => {\n                let header_cell = document.createElement('th');\n                header_cell.textContent = column;\n                header_row.appendChild(header_cell);\n            });\n\n            hdu_data.forEach(data_point => {\n\n                const row = tbody.insertRow();\n                for (let key in data_point) {\n                    if (Object.hasOwnProperty.call(data_point, key)) {\n                        let cell = row.insertCell();\n                        cell.textContent = data_point[key];\n                    }\n                }\n            });\n\n        } catch(e) {\n            console.log(\"DATA PARSING ERROR\");\n        }\n    }\n\n    resetTables() {\n        let table_header = document.getElementById(this.table_header_id);\n        let table_data = document.getElementById(this.table_data_id);\n\n        let tbody = table_header.querySelector('tbody');\n        tbody.innerHTML = '';\n\n        tbody = table_data.querySelector('tbody');\n        let thead = table_data.querySelector('thead');\n\n        tbody.innerHTML = '';\n        thead.innerHTML = '<tr></tr>';\n    }\n\n    setHDUSelectListener() {\n\n        let select_element = document.getElementById(this.select_hdu_id);\n\n        select_element.addEventListener('change', (event) => {\n            this.setTables(event.target.value);\n        });\n\n    }\n\n    setSaveButtonListener() {\n        let save_settings_btn = document.getElementById(this.save_btn_id);\n\n        save_settings_btn.addEventListener('click', (event) => {\n            let product_type_select = document.getElementById(this.product_type_select_id);\n\n            if(product_type_select.value === 'spectrum') {\n                let rmf_file_select = document.getElementById(this.rmf_file_select_id);\n                let arf_file_select = document.getElementById(this.arf_file_select_id);\n\n                let rmf_file_id = rmf_file_select.value;\n                let arf_file_id = arf_file_select.value;\n\n                FileRegistry.setFileMetadata(this.file.id, {\n                    rmf_file: rmf_file_id,\n                    arf_file: arf_file_id\n                });\n            }\n\n        })\n\n    }\n\n    setProductTypeSelect(value = null) {\n        let product_type_select = document.getElementById(this.product_type_select_id);\n\n        if(value) {\n            product_type_select.value = 'none';\n        } else {\n            product_type_select.value = value;\n        }\n    }\n\n    setProductTypeSelectListener() {\n        let product_type_select = document.getElementById(this.product_type_select_id);\n\n        product_type_select.addEventListener('change', (event) => {\n            if(product_type_select.value === 'spectrum') {\n                this.setProductSettingsVisibility('spectrum');\n            } else if(product_type_select.value === 'lightcurve') {\n                this.setProductSettingsVisibility('lightcurve');\n            } else {\n                this.setProductSettingsVisibility();\n            }\n        })\n\n    }\n\n    setRMFFileSelect(value = null) {\n        let rmf_file_select = document.getElementById(this.rmf_file_select_id);\n\n        let file_options = this.getFilesOptionsList();\n\n        file_options.forEach((option) => {\n            rmf_file_select.appendChild(option)\n        });\n\n        if(!value) {\n            rmf_file_select.value = 'none';\n        } else {\n            rmf_file_select.value = value;\n        }\n    }\n\n    setRMFFileSelectListener() {\n        let rmf_file_select = document.getElementById(this.rmf_file_select_id);\n\n    }\n\n    setARFFileSelect(value = null) {\n        let arf_file_select = document.getElementById(this.arf_file_select_id);\n\n        let file_options = this.getFilesOptionsList();\n\n        file_options.forEach((option) => {\n            arf_file_select.appendChild(option)\n        });\n\n        if(!value) {\n            arf_file_select.value = 'none';\n        } else {\n            arf_file_select.value = value;\n        }\n    }\n\n    setARFFileSelectListener() {\n        let arf_file_select = document.getElementById(this.arf_file_select_id);\n\n    }\n\n    setProductSettingsVisibility(settings = null) {\n        let rmf_file_select = document.getElementById(this.rmf_file_select_id);\n        let arf_file_select = document.getElementById(this.arf_file_select_id);\n\n        rmf_file_select.style.display = 'none';\n        arf_file_select.style.display = 'none';\n\n        let spectrum_elements = document.getElementsByClassName('spectrum-settings');\n\n        for (let i = 0; i < spectrum_elements.length; i++) {\n            spectrum_elements[i].style.display = 'none';\n        }\n\n        if(!settings) {\n\n        } else if(settings === 'spectrum') {\n            rmf_file_select.style.display = 'block';\n            arf_file_select.style.display = 'block';\n\n            for (let i = 0; i < spectrum_elements.length; i++) {\n                spectrum_elements[i].style.display = 'block';\n            }\n        } else if(settings === 'lightcurve') {\n\n        }\n    }\n\n    resetContainerForCurrentFile() {\n        this.setupComponent();\n    }\n\n    getFilesOptionsList() {\n        let file_options = [];\n        let file_list = FileRegistry.getAllFiles();\n\n        let option = document.createElement(\"option\");\n\n        option.setAttribute('selected', 'true');\n\n        option.value = 'none';\n        option.text = 'None';\n\n        file_options.push(option);\n\n        file_list.forEach((file) => {\n            option = document.createElement(\"option\");\n\n            option.value = file.id;\n            option.text = file.file_name;\n\n            file_options.push(option);\n        })\n\n        return file_options;\n    }\n}","import {FileRegistry} from \"../../registries/FileRegistry\";\nimport {WrapperContainer} from \"../../containers/WrapperContainer\";\n\nexport class ArithmeticColumnInput extends HTMLElement {\n\n    static column_display_id = 'column-display-list';\n    static column_create_button_id = 'column-edit-button';\n    static column_main_input_id = 'column-main-input';\n    static column_list_id = 'column-input-list';\n    static input_expression = 'input-expression';\n\n    static button_commands = ['C', '<--', '-->', 'V']\n\n    column_display = \"<ul id='column-display-list'></ul>\";\n    column_create_button = \"<button id='column-edit-button' class='btn btn-primary'>Create column</button>\";\n    column_main_input = \"<div id='column-main-input'>\" +\n        \"<div id='input-display'><input id='input-expression' type='text'></div>\" +\n        \"<div id='input-container' class='column-input-container'>\" +\n        \"<div id='input-keyboard' class='column-input-keyboard'>\" +\n        \"<div class='button-grid'>\" +\n        \"<button class='btn btn-secondary'>+</button>\" +\n        \"<button class='btn btn-secondary'>-</button>\" +\n        \"<button class='btn btn-secondary'>*</button>\" +\n        \"<button class='btn btn-secondary'>/</button>\" +\n        \"</div>\" +\n        \"<div class='button-grid'>\" +\n        \"<button class='btn btn-secondary'>(</button>\" +\n        \"<button class='btn btn-secondary'>)</button>\" +\n        \"<button class='btn btn-secondary'>pow2()</button>\" +\n        \"<button class='btn btn-secondary'>pow3()</button>\" +\n        \"</div>\" +\n        \"<div class='button-grid'>\" +\n        \"<button class='btn btn-secondary'>sqrt()</button>\" +\n        \"<button class='btn btn-secondary'>min()</button>\" +\n        \"<button class='btn btn-secondary'>max()</button>\" +\n        \"<button class='btn btn-secondary'>mean()</button>\" +\n        \"</div>\" +\n        \"<div class='button-grid'>\" +\n        \"<button class='btn btn-secondary'>log()</button>\" +\n        \"<button class='btn btn-secondary'><--</button>\" +\n        \"<button class='btn btn-secondary'>--></button>\" +\n        \"<button class='btn btn-danger'>C</button>\" +\n        \"<button class='btn btn-success'>V</button>\" +\n        \"</div>\" +\n        \"</div>\" +\n        \"<div id='input-columns'>\" +\n        \"<ul id='column-input-list'></ul>\" +\n        \"</div>\" +\n        \"</div>\" +\n        \"</div>\"\n\n    display_formula = '';\n    inner_formula = '';\n\n    constructor() {\n        super();\n\n        this.innerHTML = this.column_display + this.column_main_input + this.column_create_button;\n\n        this.handleFileChangeEvent = this.handleFileChangeEvent.bind(this);\n\n\n        this._setupInnerElementsListeners();\n        this._setupExternalListeners();\n    }\n\n    _setupExternalListeners() {\n        this.addEventListener('file-registry-change', this.handleFileChangeEvent);\n    }\n\n    _setupInnerElementsListeners() {\n        this._setCreateButtonListener();\n        this._setKeyboardListener();\n    }\n\n    _setCreateButtonListener() {\n        let create_button = document.getElementById(ArithmeticColumnInput.column_create_button_id);\n\n        create_button.addEventListener('click', (e) => {\n            let display_main_input = document.getElementById(ArithmeticColumnInput.column_main_input_id);\n            display_main_input.classList.toggle('visible');\n        })\n    }\n\n    handleFileChangeEvent(event) {\n        let current_file_list = FileRegistry.getCurrentFilesList();\n        let columns = [];\n\n        this._resetColumnInput();\n\n        current_file_list.forEach((file) => {\n\n            if(file.type === 'fits') {\n                let fits_reader_wrapper = WrapperContainer.getFITSReaderWrapper();\n\n                fits_reader_wrapper.setFile(file.file);\n                let fits_columns = fits_reader_wrapper.getAllColumns();\n\n                fits_columns.forEach((fits_column) => {\n                    let column = {...fits_column, file_id: file.id};\n                    columns.push(column);\n                })\n\n            }\n        })\n\n        let columns_by_file = columns.reduce((acc, column) => {\n            if (!acc[column.file_id]) {\n                acc[column.file_id] = [];\n            }\n            acc[column.file_id].push(column);\n            return acc;\n        }, {});\n\n        let li_group_list = [];\n\n        let i = 1;\n        for (let file_id in columns_by_file) {\n            if (columns_by_file.hasOwnProperty(file_id)) {\n                let file = FileRegistry.getFileById(file_id);\n                let file_name = file.file_name;\n\n                let frw = WrapperContainer.getFITSReaderWrapper();\n                frw.setFile(file.file);\n\n                li_group_list.push(this.createColumnsList(columns_by_file[file_id], frw));\n            }\n            i++;\n        }\n\n        this.setColumnInput(li_group_list);\n        this._setColumnInputListener();\n    }\n\n    executeCommand(command) {\n        let input_display = document.getElementById(ArithmeticColumnInput.input_expression);\n\n        switch (command) {\n\n            case 'C':\n                input_display.value = '';\n\n                break;\n\n            case 'V':\n                this.addColumnToDisplay(input_display.value);\n\n                break;\n\n            case '<--':\n\n                break;\n\n            case '-->':\n\n                break;\n\n        }\n    }\n\n    createColumnsList(file_columns, fits_reader_wrapper) {\n\n        let li_group = [];\n\n        file_columns.forEach(column => {\n            let li = document.createElement(\"li\");\n\n            let hdu_type = fits_reader_wrapper.getHeaderCardValueByNameFromHDU(column.hdu_index, 'XTENSION');\n            let hdu_extname = fits_reader_wrapper.getHeaderCardValueByNameFromHDU(column.hdu_index, 'EXTNAME');\n            let name = hdu_type+'-'+hdu_extname+' '+column.name;\n\n            if(column.is_from_header) {\n                name += '(HEADER)';\n            }\n\n            if(column.is_processed) {\n                li.innerHTML = name;\n                li.setAttribute('dataset-id',`${column.from_file}.${column.hdu_index}$${column.name}`);\n            } else {\n                li.innerHTML = name;\n                li.setAttribute('data-id',`${column.file_id}.${column.hdu_index}$${column.name}`);\n            }\n\n            li_group.push(li);\n        });\n\n        return li_group;\n    }\n\n    setColumnInput(li_group_list) {\n        let ul_columns = document.getElementById(ArithmeticColumnInput.column_list_id);\n\n        li_group_list.forEach((li_group) => {\n            li_group.forEach((li) => {\n                ul_columns.appendChild(li);\n            })\n        })\n    }\n\n    _setKeyboardListener() {\n        let buttons = document.querySelectorAll('div.button-grid button');\n        let input_display = document.getElementById(ArithmeticColumnInput.input_expression);\n\n        buttons.forEach((button) => {\n            button.addEventListener('click', (e) => {\n                let operator = button.textContent;\n\n                if(!ArithmeticColumnInput.button_commands.includes(operator)) {\n                    input_display.value += operator;\n                } else {\n                    this.executeCommand(operator);\n                }\n            });\n        });\n    }\n\n    _resetColumnInput() {\n        let column_list = document.getElementById(ArithmeticColumnInput.column_list_id);\n        column_list.innerHTML = '';\n    }\n\n    _setColumnInputListener() {\n        let lis = document.querySelectorAll('ul#column-input-list li');\n        let input_display = document.getElementById(ArithmeticColumnInput.input_expression);\n\n        lis.forEach(function(li) {\n            li.addEventListener('click', (e) => {\n                let column_id = li.getAttribute('data-id');\n                 input_display.value += column_id;\n            });\n        });\n    }\n\n    addColumnToDisplay(expression) {\n        let column_display = document.getElementById(ArithmeticColumnInput.column_display_id);\n\n        let li_expression = document.createElement('li');\n        li_expression.innerHTML = expression+' <button class=\"btn btn-danger\">X</button>';\n        li_expression.setAttribute('data-column', expression);\n\n        column_display.appendChild(li_expression);\n    }\n\n}","import { DataPreProcessor } from '../data_processors/DataPreProcessor.js'\nimport { LightCurveProcessor } from '../data_processors/LightCurveProcessor.js'\nimport { SpectrumProcessor } from '../data_processors/SpectrumProcessor.js'\n\nexport class DataProcessorContainer {\n\n    constructor() {\n\n    }\n\n    getDataPreProcessor() {\n        return new DataPreProcessor();\n    }\n\n    getLightCurveProcessor(fits_reader_wrapper, hdu_index) {\n        return new LightCurveProcessor(fits_reader_wrapper, hdu_index);\n    }\n\n    getSpectrumProcessor() {\n        return new SpectrumProcessor();\n    }\n\n    static getDataProcessorContainer() {\n        return new DataProcessorContainer();\n    }\n\n}","import { EventSubscribersRegistry } from '../registries/EventSubscribersRegistry.js'\nimport {FileRegistry} from \"../registries/FileRegistry\";\n\nexport class RegistryContainer {\n\n    static file_registry = null;\n\n    constructor() {\n\n    }\n\n    getEventSubscribersRegistry() {\n        return new EventSubscribersRegistry();\n    }\n\n    getFileRegistry() {\n        return RegistryContainer.file_registry;\n    }\n\n    static setFileRegistry(file_registry) {\n        RegistryContainer.file_registry = file_registry;\n    }\n\n    static getRegistryContainer() {\n        return new RegistryContainer();\n    }\n\n}","import { VisualizationSettings } from '../settings/VisualizationSettings.js'\nimport { SettingsConfiguration } from '../settings/SettingsConfiguration.js'\n\nexport class SettingsContainer {\n\n    constructor() {\n\n    }\n\n    getVisualizationSettingsObject() {\n        return new VisualizationSettings();\n    }\n\n    getSettingsConfigurationObject() {\n        return new SettingsConfiguration();\n    }\n\n    static getSettingsContainer() {\n        return new SettingsContainer();\n    }\n\n}","import { BokehGraph } from '../visualizations/BokehGraph'\nimport { D3Graph } from '../visualizations/D3Graph'\n\nexport class VisualizationContainer {\n\n    static bokeh_graph = null;\n    static d3_graph = null;\n\n    static visualization_container = '#visualization-container'\n\n    constructor() {\n\n    }\n\n    static setBokehVisualization(bokeh_visualization) {\n        VisualizationContainer.bokeh_visualization = bokeh_visualization;\n    }\n\n    static setD3Visualization(d3_visualization) {\n        VisualizationContainer.d3_visualization = d3_visualization;\n    }\n\n    static getBokehVisualization() {\n        if(VisualizationContainer.bokeh_visualization !== null) {\n            return VisualizationContainer.bokeh_visualization;\n        } else {\n            return new BokehGraph(VisualizationContainer.visualization_container);\n        }\n    }\n\n    static getD3Visualization() {\n        if(VisualizationContainer.d3_visualization !== null) {\n            return VisualizationContainer.d3_visualization;\n        } else {\n            return new D3Graph(VisualizationContainer.visualization_container);\n        }\n    }\n\n}","import { FITSReaderWrapper } from '../wrappers/FITSReaderWrapper.js'\nimport { BokehWrapper } from '../wrappers/BokehWrapper.js'\nimport { D3Wrapper } from '../wrappers/D3Wrapper.js'\n\nexport class WrapperContainer {\n\n    static fits_reader_wrapper = null;\n    static bokeh_wrapper = null;\n    static d3_wrapper = null;\n\n    static visualization_container = 'visualization-container'\n\n    constructor() {\n\n    }\n\n    static setFITSReaderWrapper(fits_reader_wrapper) {\n        WrapperContainer.fits_reader_wrapper = fits_reader_wrapper;\n    }\n\n    static setBokehWrapper(bokeh_wrapper) {\n        WrapperContainer.bokeh_wrapper = bokeh_wrapper;\n    }\n\n    static setD3Wrapper(d3_wrapper) {\n        WrapperContainer.d3_wrapper = d3_wrapper;\n    }\n\n    static getFITSReaderWrapper() {\n        if(WrapperContainer.fits_reader_wrapper !== null) {\n            return WrapperContainer.fits_reader_wrapper;\n        } else {\n            return new FITSReaderWrapper('');\n        }\n    }\n\n    static getBokehWrapper() {\n        if(WrapperContainer.bokeh_wrapper !== null) {\n            return WrapperContainer.bokeh_wrapper;\n        } else {\n            return new BokehWrapper(WrapperContainer.visualization_container);\n        }\n    }\n\n    static getD3Wrapper() {\n        if(WrapperContainer.d3_wrapper !== null) {\n            return WrapperContainer.d3_wrapper;\n        } else {\n            return new D3Wrapper(WrapperContainer.visualization_container);\n        }\n    }\n\n}","import {WrapperContainer} from \"../containers/WrapperContainer\";\nimport {FileRegistry} from \"../registries/FileRegistry\";\nimport {SpectrumProcessor} from \"./SpectrumProcessor\";\nimport {DataProcessorContainer} from \"../containers/DataProcessorContainer\";\n\nexport class DataPreProcessor {\n\n    constructor() {\n\n    }\n\n    getProcessedDataset(dataset_settings_object) {\n        let dataset = {};\n\n        dataset_settings_object.axis.forEach((axis) => {\n\n            let file_object = FileRegistry.getFileById(axis.file_id);\n\n            let frw = WrapperContainer.getFITSReaderWrapper();\n            frw.setFile(file_object.file);\n\n            let column_data;\n\n            if(dataset_settings_object.data_type.type === 'spectrum' &&\n                SpectrumProcessor.processed_columns_name.includes(axis.column_name)) {\n\n                column_data = this.getSpectrumProcessedColumn(axis.hdu_index, axis.column_name, frw)\n            } else {\n                column_data = frw.getColumnDataFromHDU(axis.hdu_index, axis.column_name);\n            }\n\n            axis.data = column_data;\n\n        })\n\n        if(dataset_settings_object.hasOwnProperty('error_bars')) {\n            dataset_settings_object.error_bars.forEach((error_bar) => {\n\n                let file_object = FileRegistry.getFileById(error_bar.file_id);\n\n                let frw = WrapperContainer.getFITSReaderWrapper();\n                frw.setFile(file_object.file);\n\n                let column_data;\n\n                if(dataset_settings_object.data_type.type === 'spectrum' &&\n                    SpectrumProcessor.processed_columns_name.includes(error_bar.column_name)) {\n\n                    column_data = this.getSpectrumProcessedColumn(error_bar.hdu_index, error_bar.column_name, frw)\n\n                    if(error_bar.column_name === SpectrumProcessor.E_MID_LOG) {\n                        column_data.forEach(col_data => {\n\n                        })\n                    }\n\n                } else {\n                    column_data = frw.getColumnDataFromHDU(error_bar.hdu_index, error_bar.column_name);\n                }\n\n                error_bar.data = column_data;\n            })\n        }\n\n        dataset = dataset_settings_object;\n\n        return dataset;\n    }\n\n    datasetToJSONData(dataset_settings_object) {\n        let rows = [];\n\n        dataset_settings_object.axis.forEach((axis) => {\n\n            axis.data.forEach((value, index) => {\n                if (!rows[index]) {\n                    rows[index] = {};\n                }\n                rows[index][axis.column_name] = value;\n            });\n\n        })\n\n        if(dataset_settings_object.hasOwnProperty('error_bars')) {\n            dataset_settings_object.error_bars.forEach((error_bar) => {\n\n                error_bar.data.forEach((value, index) => {\n                    if (!rows[index]) {\n                        rows[index] = {};\n                    }\n                    rows[index][error_bar.column_name] = value;\n                });\n\n            })\n        }\n\n        return rows;\n    }\n\n    processErrorBarDataJSON(dataset, axis, error_bars) {\n\n        console.log(error_bars);\n        console.log(dataset);\n\n        let error_bar_x_values = [];\n        let error_bar_y_values = [];\n\n        let axis_x = axis.x;\n        let axis_y = axis.y;\n\n        let error_bar_x_column = error_bars.x;\n        let error_bar_y_column = error_bars.y;\n\n        let error_bars_object = {};\n\n        dataset.forEach(function(datapoint){\n\n            if(error_bars.x) {\n\n                console.log(\"X\");\n                console.log(datapoint[axis_x]);\n                console.log(error_bar_x_column);\n\n                let error_bar_x = [\n                    {\n                        bound: parseFloat(datapoint[axis_x]) - parseFloat(datapoint[error_bar_x_column]),\n                        [axis_y]: parseFloat(datapoint[axis_y])\n                    },\n                    {\n                        bound: parseFloat(datapoint[axis_x]) + parseFloat(datapoint[error_bar_x_column]),\n                        [axis_y]: parseFloat(datapoint[axis_y])\n                    }\n                ]\n\n                error_bar_x_values.push(error_bar_x);\n            }\n\n            if(error_bars.y) {\n\n                console.log(\"Y\");\n                console.log(datapoint[axis_x]);\n                console.log(error_bar_y_column);\n\n                let error_bar_y = [\n                    {\n                        bound: parseFloat(datapoint[axis_y]) - parseFloat(datapoint[error_bar_y_column]),\n                        [axis_x]: parseFloat(datapoint[axis_x])\n                    },\n                    {\n                        bound: parseFloat(datapoint[axis_y]) + parseFloat(datapoint[error_bar_y_column]),\n                        [axis_x]: parseFloat(datapoint[axis_x])\n                    }\n                ]\n\n                error_bar_y_values.push(error_bar_y);\n            }\n\n        })\n\n        if(error_bars.x) error_bars_object.x = error_bar_x_values;\n        if(error_bars.y) error_bars_object.y = error_bar_y_values;\n\n        return error_bars_object;\n    }\n\n    getSpectrumProcessedColumn(hdu_index, column_name, fits_reader_wrapper) {\n        let processed_column = [];\n\n        let sp = DataProcessorContainer.getDataProcessorContainer().getSpectrumProcessor();\n\n        let e_min_col = fits_reader_wrapper.getColumnDataFromHDU(hdu_index, \"E_MIN\");\n        let e_max_col = fits_reader_wrapper.getColumnDataFromHDU(hdu_index, \"E_MAX\");\n\n        e_min_col.forEach((e_min, index) => {\n            processed_column.push(SpectrumProcessor.spectrum_col_functions[column_name](e_min, e_max_col[index]));\n        })\n\n        return processed_column;\n    }\n\n    processDataForRange(ranges, data, error_bars = null) {\n        let temp_processed_data = [];\n        let temp_processed_error_bars = {};\n        let temp_error_bar_x = [];\n        let temp_error_bar_y = [];\n        let processed_data = [];\n\n        data.forEach((data_point, i) => {\n            let keys = Object.keys(data_point);\n            let x_column = keys[0];\n            let y_column = keys[1];\n\n            if (ranges.x === null) {\n                data_point.match_range_x = true;\n            } else if (data_point[x_column] >= ranges.x.lower_bound && data_point[x_column] <= ranges.x.upper_bound) {\n                data_point.match_range_x = true;\n            } else {\n                data_point.match_range_x = false;\n            }\n\n            if(ranges.y === null) {\n                data_point.match_range_y = true;\n            } else if(data_point[y_column] >= ranges.y.lower_bound && data_point[y_column] <= ranges.y.upper_bound) {\n                data_point.match_range_y = true;\n            } else {\n                data_point.match_range_y = false;\n            }\n\n            if(data_point.match_range_x + data_point.match_range_y == 2) {\n                temp_processed_data.push(data_point);\n                if(error_bars != null) {\n                    temp_error_bar_x.push(error_bars.x[i]);\n                    temp_error_bar_y.push(error_bars.y[i]);\n                }\n            }\n\n        })\n\n        if(error_bars != null) {\n            temp_processed_error_bars.x = temp_error_bar_x;\n            temp_processed_error_bars.y = temp_error_bar_y;\n            processed_data.error_bars = temp_processed_error_bars;\n        }\n\n        processed_data.data = temp_processed_data;\n\n        return processed_data;\n    }\n\n    processDataForRangeBokeh(ranges, data, has_error_bars = false) {\n        let processed_data = {};\n        processed_data.x = [];\n        processed_data.y = []\n\n        if(has_error_bars) {\n            processed_data.x_low = [];\n            processed_data.x_up = [];\n            processed_data.y_low = [];\n            processed_data.y_up = [];\n        }\n\n        let temp_x = [];\n        let temp_y = [];\n\n        data.x.forEach((data_point) => {\n\n            let temp_data_object = {};\n            temp_data_object.value = data_point;\n\n            if (ranges.x === null) {\n                temp_data_object.match_range_x = true;\n            } else if (data_point >= ranges.x.lower_bound && data_point <= ranges.x.upper_bound) {\n                temp_data_object.match_range_x = true;\n            } else {\n                temp_data_object.match_range_x = false;\n            }\n\n            temp_x.push(temp_data_object);\n        })\n\n        data.y.forEach((data_point) => {\n\n            let temp_data_object = {};\n            temp_data_object.value = data_point;\n\n            if (ranges.y === null) {\n                temp_data_object.match_range_y = true;\n            } else if (data_point >= ranges.y.lower_bound && data_point <= ranges.y.upper_bound) {\n                temp_data_object.match_range_y = true;\n            } else {\n                temp_data_object.match_range_y = false;\n            }\n\n            temp_y.push(temp_data_object)\n        })\n\n        temp_x.forEach((data_point_x, i) => {\n            let data_point_y = temp_y[i];\n\n            if(data_point_x.match_range_x + data_point_y.match_range_y == 2) {\n                processed_data.x.push(data_point_x.value);\n                processed_data.y.push(data_point_y.value);\n\n                if(has_error_bars) {\n                    processed_data.y_low.push(data.y_low[i]);\n                    processed_data.y_up.push(data.y_up[i]);\n                    processed_data.x_low.push(data.x_low[i]);\n                    processed_data.x_up.push(data.x_up[i]);\n                }\n            }\n        })\n\n        return processed_data;\n    }\n\n}","export class LightCurveProcessor {\n\n    static header_cards = [\n        'TIMEREF',\n        'TIMEDEL',\n        'MJDREF',\n        'TSTART',\n        'TSTOP',\n        'TELAPSE',\n        'E_MIN',\n        'E_MAX',\n        'E_UNIT']\n\n    static columns_names = {\n        time: 'TIME',\n        timedel: 'TIMEDEL',\n        rate: 'RATE',\n        error: 'ERROR',\n        fracexp: 'FRACEXP'\n    }\n\n    static binning_types = {\n        'TIME_BASED': 'time_based',\n        'EQUAL_COUNT': 'equal_count'\n    }\n\n    static bin_value_methods = [\n        'mean',\n        'weightedmean',\n        'median',\n        'wmedian',\n        'stddev',\n        'meddev',\n        'kurtosis',\n        'skewness',\n        'max',\n        'min',\n        'sum'\n    ]\n\n    static min_columns_number = 2;\n    static mandatory_columns = ['RATE'];\n    static replacement_columns = ['TIMEDEL'];\n\n    hdu;\n    hdu_index = null;\n\n    binning_type;\n    method;\n\n    fits_reader_wrapper;\n    header_values = {};\n\n    constructor(fits_reader_wrapper, hdu_index) {\n        this.fits_reader_wrapper = fits_reader_wrapper;\n        this.hdu_index = hdu_index;\n\n        this._setHDU();\n    }\n\n    _setHDU() {\n        this.hdu = this.fits_reader_wrapper.getHDU(this.hdu_index);\n    }\n\n    setHDU(hdu, hdu_index) {\n        this.hdu = hdu;\n        this.hdu_index = hdu_index;\n    }\n\n    processDataRawJSON(axis, error_bars = null) {\n        //let raw_fits_data = this.hdu.data;\n        let raw_fits_data = this.fits_reader_wrapper.getDataFromHDU(this.hdu_index);\n        let data = {};\n\n        let x;\n        let y;\n\n        let x_column = axis.x;\n        let y_column = axis.y;\n\n        raw_fits_data.getColumn(x_column, function(col){x = col});\n        raw_fits_data.getColumn(y_column, function(col){y = col});\n\n        data.x = x;\n        data.y = y;\n\n        if(error_bars) {\n\n            let dy;\n\n            let error_bar_x_column = error_bars.x;\n            let error_bar_y_column = error_bars.y;\n\n            raw_fits_data.getColumn(error_bar_y_column, function(col) {dy = col});\n\n            data.dy = dy;\n            //data.timedel = this.getTimedel(error_bar_x_column);\n            //data.timedel = this.fits_reader_wrapper.getHeaderFromHDU(this.hdu_index).get(\"TIMEDEL\");\n\n            raw_fits_data.getColumn(error_bar_x_column, function(col) {data.timedel = col});\n\n        }\n\n        return data;\n    }\n\n    processDataJSON(axis, error_bars = null) {\n        let raw_fits_data = this.hdu.data;\n        let light_curve_data = {};\n\n        if(!this._checkColumns()) {\n            throw new Error(\"\");\n        }\n\n        light_curve_data.main = this.fits_reader_wrapper.getColumnsJSONDataFromHDU(this.hdu_index);\n\n        if(error_bars) {\n            light_curve_data.error_bars = this._processErrorBarsDataJSON(error_bars, axis, light_curve_data.main);\n        }\n\n        return light_curve_data;\n    }\n\n    _processErrorBarsDataJSON(error_bars, axis, data) {\n        let error_bar_x_values = [];\n        let error_bar_y_values = [];\n\n        let axis_x = axis.x;\n        let axis_y = axis.y;\n\n        let error_bar_x_column = error_bars.x;\n        let error_bar_y_column = error_bars.y;\n\n        data.forEach(function(datapoint){\n            let error_bar_x = [\n                {\n                    bound: parseFloat(datapoint[axis_y]) - parseFloat(datapoint[error_bar_y_column]),\n                    [axis_x]: parseFloat(datapoint[axis_x])\n                },\n                {\n                    bound: parseFloat(datapoint[axis_y]) + parseFloat(datapoint[error_bar_y_column]),\n                    [axis_x]: parseFloat(datapoint[axis_x])\n                }\n            ]\n\n            let error_bar_y = [\n                {\n                    bound: parseFloat(datapoint[axis_x]) - parseFloat(datapoint[error_bar_x_column]),\n                    [axis_y]: parseFloat(datapoint[axis_y])\n                },\n                {\n                    bound: parseFloat(datapoint[axis_x]) + parseFloat(datapoint[error_bar_x_column]),\n                    [axis_y]: parseFloat(datapoint[axis_y])\n                }\n            ]\n\n            error_bar_x_values.push(error_bar_x);\n            error_bar_y_values.push(error_bar_y);\n        })\n\n        return {x: error_bar_x_values, y: error_bar_y_values}\n    }\n\n    _checkColumns(required_nb_columns) {\n        let is_checked = true;\n\n        let columns_number = this.fits_reader_wrapper.getNumberOfColumnFromHDU(this.hdu_index)\n        let columns_name = this.fits_reader_wrapper.getColumnsNameFromHDU(this.hdu_index)\n\n        if(columns_number < required_nb_columns || !columns_name.includes(LightCurveProcessor.columns_names.rate)) {\n            is_checked = false;\n        }\n\n        return is_checked;\n    }\n\n    getTimedel(error_bar_x = null) {\n        let timedel;\n\n        if(this.fits_reader_wrapper.getColumnsNameFromHDU(this.hdu_index).includes(\"TIMEDEL\")) {\n            data.getColumn(error_bar_x, function (col) {timedel = col});\n        } else {\n            let header = this.fits_reader_wrapper.getHeaderFromHDU(this.hdu_index);\n            timedel = header.get(\"TIMEDEL\");\n        }\n\n        return timedel;\n    }\n\n    _getValueFromHDUHeader() {\n        let card_value;\n        LightCurveProcessor.header_cards.forEach((card_name) => {\n            card_value = null;\n\n            card_value = this.fits_reader_wrapper.getHeaderCardValueByNameFromHDU(this.hdu_index, card_name)\n            this.header_values[card_name] = card_value;\n        })\n    }\n\n    setBinningType(binning_type) {\n        this.binning_type = binning_type\n    }\n\n    setBinValueMethod(method) {\n        this.method = method;\n    }\n\n    getBinsForMethod(rate_column, fracexp_column, bins, method) {\n        let processed_bins = [];\n\n        bins.forEach((bin) => {\n            let times = [];\n            let rates = [];\n            let fracexps = [];\n\n            bin.forEach(({ time, rate, fracexp }) => {\n                times.push(time);\n                rates.push(rate);\n                fracexps.push(fracexp);\n            });\n\n            let bin_rate_max = Math.max(...rates);\n            let bin_rate_min = Math.min(...rates);\n            let bin_rate_mean = rates.reduce((total, value) => total + value, 0) / rates.length;\n            let bin_rate_sum = rates.reduce((total, value) => total + value, 0);\n\n        })\n\n        return processed_bins;\n    }\n\n    getRateFracexpWeightedMeanBinnedData(rate_column, fracexp_column, bin_size) {\n        let num_data_points = rate_column.length;\n        let num_bins = Math.ceil(num_data_points / bin_size);\n\n        let binned_rates = [];\n\n        for (let i = 0; i < num_bins; i++) {\n            let start_pos = i * bin_size;\n            let end_pos = Math.min(start_pos + bin_size, rate_column.length);\n\n            let weighted_sum = 0;\n            let num_data_points_bin = 0;\n\n            for(let j = start_pos; j < end_pos; j++) {\n                weighted_sum += rate_column[j] * fracexp_column[j];\n                num_data_points_bin++;\n            }\n\n            let bin_rate_value = weighted_sum / num_data_points_bin;\n            binned_rates.push(bin_rate_value);\n        }\n\n        return binned_rates;\n    }\n\n    getMedianDate(dates) {\n        let sorted_dates = dates.sort((a, b) => a - b);\n\n        let median_index = Math.floor(sorted_dates.length / 2);\n\n        if (sorted_dates.length % 2 !== 0) {\n            return sorted_dates[median_index];\n        } else {\n\n        }\n    }\n\n    getDurationInSeconds(time_column) {\n        let lowest_time = Math.min(...time_column);\n        let highest_time = Math.max(...time_column);\n\n        let duration_seconds = (highest_time - lowest_time) * 86400;\n\n        return duration_seconds;\n    }\n\n}","export class SpectrumProcessor {\n\n    static processed_columns_name = ['E_HALF_WIDTH', 'E_MID', 'E_MID_LOG'];\n\n    static D_E = 'E_HALF_WIDTH';\n    static E_MID = 'E_MID';\n    static E_MID_LOG = 'E_MID_LOG';\n\n    static spectrum_col_functions = {\n        E_HALF_WIDTH: SpectrumProcessor.getEnergyHalfWidth,\n        E_MID: SpectrumProcessor.getEnergyMidPoint,\n        E_MID_LOG: SpectrumProcessor.getEnergyMidPointLog,\n    }\n\n    constructor() {\n\n    }\n\n    //D_E\n    static getEnergyHalfWidth(e_min, e_max) {\n        return ((e_max - e_min) / 2);\n    }\n\n    //E_MID\n    static getEnergyMidPoint(e_min, e_max) {\n        return ((e_max + e_min) / 2);\n    }\n\n    //E_MID_LOG\n    static getEnergyMidPointLog(e_min, e_max) {\n        return Math.sqrt(e_max * e_min);\n    }\n\n    static getAsymetricEneryErrorBar(e_min, e_max, e_mid) {\n        let e_error_up = e_max - e_mid;\n        let e_error_down = e_mid - e_min;\n\n        return {'e_error_up': e_error_up, 'e_error_down': e_error_down};\n    }\n\n}","export class EventNotFoundInRegistryError extends Error {\n    constructor(message) {\n        super(message);\n        this.name = \"EventNotFoundInRegistryError\";\n    }\n}","export class HDUNotTabularError extends Error {\n    constructor(message) {\n        super(message);\n        this.name = \"HDUNotTabularError\";\n    }\n}","export class InvalidURLError extends Error {\n    constructor(message) {\n        super(message);\n        this.name = \"InvalidURLError\";\n    }\n}","export class NoEventSubscriberError extends Error {\n    constructor(message) {\n        super(message);\n        this.name = \"NoEventSubscriberError\";\n    }\n}","export class NoEventToDispatchError extends Error {\n    constructor(message) {\n        super(message);\n        this.name = \"NoEventToDispatch\";\n    }\n}","import {RegistryContainer} from \"../containers/RegistryContainer\";\n\nexport class ConfigurationEvent {\n\n    static defaultOptions = {\n        bubbles: true,\n        composed: false,\n        cancelable: true\n    };\n\n    static name = \"configuration\";\n\n    event = null;\n\n    constructor(configuration_object, detail = {}, options = {}) {\n\n        this.detail = { ...detail, ...{'configuration_object': configuration_object}};\n        this.options = { ...ConfigurationEvent.defaultOptions, ...options };\n\n        this.event = new CustomEvent(ConfigurationEvent.name, {\n            detail: this.detail,\n            ...this.options\n        });\n    }\n\n    dispatchToSubscribers() {\n        let esr = RegistryContainer.getRegistryContainer().getEventSubscribersRegistry();\n        let subscribers_id = esr.getSubscribersForEvent(ConfigurationEvent.name)\n\n        let subscriber_element = null;\n        subscribers_id.forEach((subscriber_id) => {\n            subscriber_element = document.getElementById(subscriber_id);\n            subscriber_element.dispatchEvent(this.event);\n        })\n    }\n}\n","import {RegistryContainer} from \"../containers/RegistryContainer\";\n\nexport class FileLoadedEvent {\n\n    static defaultOptions = {\n        bubbles: true,\n        composed: false\n    };\n\n    static name = \"file-loaded\";\n    static main_root_id = 'jsvis-main';\n    static main_root_element = null;\n\n    event = null;\n\n    constructor(detail = {}, options = {}) {\n\n        this.detail = { ...detail };\n        this.options = { ...FileLoadedEvent.defaultOptions, ...options };\n\n        this.event = new CustomEvent(FileLoadedEvent.name, {\n            detail: this.detail,\n            ...this.options\n        });\n    }\n\n    dispatchToTarget(target) {\n        target.dispatchEvent(this.event);\n    }\n\n    dispatchToMainRoot() {\n        if(FileLoadedEvent.main_root_element === null) {\n            FileLoadedEvent.main_root_element = document.getElementById(FileLoadedEvent.main_root_id);\n        }\n\n        document.dispatchEvent(this.event);\n    }\n\n    dispatchToSubscribers() {\n        let esr = RegistryContainer.getRegistryContainer().getEventSubscribersRegistry();\n        let subscribers_id = esr.getSubscribersForEvent(FileLoadedEvent.name)\n\n        let subscriber_element = null;\n        subscribers_id.forEach((subscriber_id) => {\n            subscriber_element = document.getElementById(subscriber_id);\n            subscriber_element.dispatchEvent(this.event);\n        })\n    }\n}\n","import {RegistryContainer} from \"../containers/RegistryContainer\";\nimport {NoEventSubscriberError} from \"../errors/NoEventSubscriberError\";\n\nexport class FileRegistryChangeEvent {\n\n    static defaultOptions = {\n        bubbles: true,\n        composed: true\n    };\n\n    static name = \"file-registry-change\";\n    static main_root_id = 'jsvis-main';\n    static main_root_element = null;\n\n    event = null;\n\n    constructor(detail = {}, options = {}) {\n\n        this.detail = { ...detail };\n        this.options = { ...FileRegistryChangeEvent.defaultOptions, ...options };\n\n        this.event = new CustomEvent(FileRegistryChangeEvent.name, {\n            detail: this.detail,\n            ...this.options\n        });\n    }\n\n    dispatchToTarget(target) {\n        target.dispatchEvent(this.event);\n    }\n\n    dispatchToMainRoot() {\n        if(FileRegistryChangeEvent.main_root_element === null) {\n            FileRegistryChangeEvent.main_root_element = document.getElementById(FileRegistryChangeEvent.main_root_id);\n        }\n        \n        document.dispatchEvent(this.event);\n    }\n\n    dispatchToSubscribers() {\n        let esr = RegistryContainer.getRegistryContainer().getEventSubscribersRegistry();\n        let subscribers_id = esr.getSubscribersForEvent(FileRegistryChangeEvent.name);\n\n        let subscriber_element = null;\n        try {\n            subscribers_id.forEach((subscriber_id) => {\n                subscriber_element = document.getElementById(subscriber_id);\n                subscriber_element.dispatchEvent(this.event);\n            })\n        } catch(e) {\n            if(subscribers_id.length <= 0) {\n                throw new NoEventSubscriberError();\n            }\n        }\n    }\n}\n","import {NoEventToDispatchError} from \"../errors/NoEventToDispatchError\";\n\nexport class SettingsChangedEvent {\n\n    static defaultOptions = {\n        bubbles: true,\n        composed: false,\n        cancelable: true\n    };\n\n    static name = \"settings-changed\";\n\n    event = null;\n\n    constructor(settings_object, detail = {}, options = {}) {\n\n        this.detail = { ...detail, ...{'settings_object': settings_object}};\n        this.options = { ...SettingsChangedEvent.defaultOptions, ...options };\n\n        this.event = new CustomEvent(SettingsChangedEvent.name, {\n            detail: this.detail,\n            ...this.options\n        });\n    }\n\n    dispatch() {\n        if(this.event !== null) {\n            document.dispatchEvent(this.event);\n        } else {\n            throw new NoEventToDispatchError(\"No event to dispatch\");\n        }\n    }\n}\n","import { NoEventToDispatchError } from \"../errors/NoEventToDispatchError\";\n\nexport class VisualizationGenerationEvent {\n\n    static defaultOptions = {\n        bubbles: true,\n        composed: false,\n        cancelable: true\n    };\n\n    static name = \"visualization-generation\";\n\n    event = null;\n\n    constructor(settings_object, detail = {}, options = {}) {\n\n        this.detail = { ...detail, ...{'settings_object': settings_object}};\n        this.options = { ...VisualizationGenerationEvent.defaultOptions, ...options };\n\n        this.event = new CustomEvent(VisualizationGenerationEvent.name, {\n            detail: this.detail,\n            ...this.options\n        });\n    }\n\n    dispatch() {\n        if(this.event !== null) {\n            document.dispatchEvent(this.event);\n        } else {\n            throw new NoEventToDispatchError(\"No event to dispatch\");\n        }\n    }\n}\n","import {EventNotFoundInRegistryError} from \"../errors/EventNotFoundInRegistryError\";\n\nexport class EventSubscribersRegistry {\n\n    static events_subscribers = {\n        'fits-loaded': ['settings-component', 'file-component'],\n        'configuration': ['settings-component'],\n        'file-loaded': ['file-component'],\n        'file-selected': ['settings-component', 'arithmetic-column-component'],\n        'file-registry-change': ['settings-component', 'file-component', 'arithmetic-column-component'],\n        //'arithmetic-column-change': ['settings-component']\n    }\n\n    constructor() {\n\n    }\n\n    getSubscribersForEvent(event_name) {\n        if(EventSubscribersRegistry.events_subscribers.hasOwnProperty(event_name)) {\n            return EventSubscribersRegistry.events_subscribers[event_name];\n        } else {\n            throw new EventNotFoundInRegistryError(\"Event not found : \" + event_name);\n        }\n    }\n\n}","import {FileRegistryChangeEvent} from \"../events/FileRegistryChangeEvent\";\nimport {StringUtils} from \"../utils/StringUtils\";\n\nexport class FileRegistry {\n\n    static available_files = [];\n\n    static current_files = [];\n\n    static file_counter = 0;\n\n    constructor() {\n\n    }\n\n    static getAvailableFilesList() {\n        FileRegistry.available_files = FileRegistry.available_files.filter(obj => obj !== undefined);\n        return FileRegistry.available_files;\n    }\n\n    static getCurrentFilesList() {\n        FileRegistry.current_files = FileRegistry.current_files.filter(obj => obj !== undefined);\n        return FileRegistry.current_files;\n    }\n\n    static addToAvailableFiles(file_to_add) {\n        let file = { ...file_to_add,\n            id: FileRegistry.file_counter,\n            file_name: StringUtils.cleanFileName(file_to_add.file_name)\n        };\n\n        FileRegistry.available_files.push(file);\n\n        FileRegistry.file_counter++;\n    }\n\n    static _addToAvailableFiles(file) {\n        FileRegistry.available_files.push(file);\n    }\n\n    static moveToAvailableFiles(file) {\n        FileRegistry.available_files.push(file);\n    }\n\n    static removeFromAvailableFiles(file_id) {\n        FileRegistry.available_files = FileRegistry.available_files.filter(file => file.id !== parseInt(file_id));\n    }\n\n    static addToCurrentFiles(file) {\n        FileRegistry.current_files.push(file);\n        FileRegistry.removeFromAvailableFiles(file.id);\n    }\n\n    static removeFromCurrentFiles(file_id) {\n        let file = FileRegistry.current_files.find(file => file.id === parseInt(file_id));\n\n        FileRegistry.current_files = FileRegistry.current_files.filter(file => file.id !== parseInt(file_id));\n        FileRegistry.moveToAvailableFiles(file);\n    }\n\n    static getAllFiles() {\n        let available_files = FileRegistry.getAvailableFilesList();\n        let current_files = FileRegistry.getCurrentFilesList();\n\n        let files = available_files.concat(current_files);\n\n        return files;\n    }\n\n    static getFileById(file_id) {\n        let file_array = [...FileRegistry.available_files, ...FileRegistry.current_files];\n\n        let file = file_array.find(file => file.id === parseInt(file_id));\n        return file;\n    }\n\n    static getFileByName(file_name) {\n        let file_array = [...FileRegistry.available_files, ...FileRegistry.current_files];\n\n        let file = file_array.find(file => file.file_name === file_name);\n        return file;\n    }\n\n    static isFileCurrent(file_id) {\n        let is_current = false;\n\n        if(FileRegistry.current_files.some(file => file.id === parseInt(file_id))) {\n            is_current = true;\n        }\n\n        return is_current;\n    }\n\n    static setFileMetadata(file_id, metadata) {\n        let files = FileRegistry.getAllFiles();\n\n        let file = files.filter(file => file.id !== parseInt(file_id));\n\n        file = { ...file, ...metadata };\n\n        if(FileRegistry.isFileCurrent(file_id)) {\n            FileRegistry.removeFromCurrentFiles(file_id);\n            FileRegistry.addToCurrentFiles(file);\n        } else {\n            FileRegistry.removeFromAvailableFiles(file_id);\n            FileRegistry._addToAvailableFiles(file);\n        }\n    }\n\n    static sendRegistryChangeEvent() {\n        let frce = new FileRegistryChangeEvent();\n        frce.dispatchToSubscribers();\n    }\n\n}","import {ObjectUtils} from \"../utils/ObjectUtils\";\n\nexport class SettingsConfiguration {\n\n    static default_configuration = {\n        'library-settings': {\n            display: true,\n            selected: 'none'\n        },\n        'bokeh-settings': {\n            display: false,\n            'bokeh-options': {\n                tools: {\n                    display : false\n                }\n            }\n        },\n        'd3-settings': {\n            display: false,\n            'd3-options': {\n\n            }\n        },\n        'data-type-settings': {\n            display: true,\n            selected: 'generic'\n        },\n        'light-curve-settings': {\n            display: false,\n            'light-curve-options': {\n\n            }\n        },\n        'spectrum-settings': {\n            display: false,\n            'spectrum-options': {\n\n            }\n        },\n        'hdus-settings': {\n            display: false\n        },\n        'axis-settings': {\n            display: true\n        },\n        'error-bars-settings': {\n            display: true\n        },\n        'binning-settings': {\n            display: true\n        },\n        'additional-dataset-settings': {\n            display: true\n        }\n    }\n\n    configuration = null;\n\n    constructor(configuration_object = null) {\n        if(configuration_object) {\n            this.configuration = JSON.parse(JSON.stringify(SettingsConfiguration.default_configuration));\n        } else {\n            this.configuration = JSON.parse(JSON.stringify(configuration_object));\n        }\n    }\n\n    getConfigurationObject(wrapper_configuration) {\n        let configuration = null;\n\n        configuration = ObjectUtils.deep_merge(SettingsConfiguration.default_configuration, wrapper_configuration);\n\n        return configuration;\n    }\n\n    static getConfigurationObject(wrapper_configuration) {\n        let configuration = null;\n\n        configuration = ObjectUtils.deep_merge(SettingsConfiguration.default_configuration, wrapper_configuration);\n\n        return configuration;\n    }\n\n}","export class VisualizationSettings {\n\n    static default_settings = {\n        library: '',\n        data_type: '',\n        axis: {},\n        scales: {},\n        error_bars: {}\n    }\n\n    settings = {};\n\n    settings_library = null;\n    settings_data_type = null;\n    settings_hdus = null;\n    settings_axis = null;\n    settings_scales = null;\n    settings_error_bars = null;\n\n    constructor(settings_object = null) {\n        if(settings_object) {\n            this.settings = JSON.parse(JSON.stringify(settings_object))\n        } else {\n            this.settings = JSON.parse(JSON.stringify(VisualizationSettings.default_settings))\n        }\n    }\n\n    setLibrarySettings(library) {\n        this.settings_library = library;\n    }\n\n    getLibrarySettings() {\n        if(this.settings_library) {\n            return this.settings_library;\n        } else {\n            return null;\n        }\n    }\n\n    setDataTypeSettings(data_type) {\n        this.settings_data_type = data_type;\n    }\n\n    getDataTypeSettings() {\n        if(this.settings_data_type) {\n            return this.settings_data_type;\n        } else {\n            return null;\n        }\n    }\n\n    getLightCurveSettings() {\n\n    }\n\n    getSpectrumSettings() {\n\n    }\n\n    setHDUsSettings(hdus) {\n        this.settings_hdus = hdus;\n    }\n\n    getHDUsSettings() {\n        if(this.settings_hdus !== null) {\n            return this.settings_hdus;\n        } else {\n            return null;\n        }\n    }\n\n    setAxisSettings(axis) {\n        this.settings_axis = axis;\n    }\n\n    getAxisSettings() {\n        if(this.settings_axis) {\n            return this.settings_axis;\n        } else {\n            return null;\n        }\n    }\n\n    setScalesSettings(scales) {\n        this.settings_scales = scales;\n    }\n\n    getScalesSettings() {\n        if(this.settings_scales) {\n            return this.settings_scales;\n        } else {\n            return null;\n        }\n    }\n\n    setErrorBarsSettings(error_bars) {\n        this.settings_error_bars = error_bars;\n    }\n\n    getErrorBarsSettings() {\n        if(this.settings_error_bars) {\n            return this.settings_error_bars;\n        } else {\n            return null;\n        }\n    }\n\n    setRangesSettings(ranges) {\n        this.settings_ranges = ranges;\n    }\n\n    getRangesSettings() {\n        return this.settings_ranges;\n    }\n\n    getAdditionalDatasetsSettings() {\n\n    }\n\n    reset() {\n        this.settings_library = null;\n        this.settings_data_type = null;\n        this.settings_hdus = null;\n        this.settings_axis = null;\n        this.settings_scales = null;\n        this.settings_error_bars = null;\n    }\n}","export class ColumnUtils {\n\n    static getColumnSettings(column_settings) {\n        let settings = column_settings.split('$');\n\n        let column_location = settings[0].split('.');\n        let column_name = settings[1] || '';\n\n        let file_id = column_location[0];\n        let hdu_index = column_location.length > 1 ? column_location[1] : '';\n\n        return {\n            file_id: file_id,\n            hdu_index: hdu_index,\n            column_name: column_name\n        };\n    }\n\n}","export class ObjectUtils {\n\n    static deep_merge(base_object, merging_object) {\n        let merged_object = {};\n\n        for (let key in base_object) {\n            if (base_object.hasOwnProperty(key)) {\n                merged_object[key] = base_object[key];\n            }\n        }\n\n        for (let key in merging_object) {\n            if (merging_object.hasOwnProperty(key)) {\n                if(Array.isArray(merging_object[key])) {\n\n                } else if (merged_object.hasOwnProperty(key) && typeof merging_object[key] === 'object') {\n                    merged_object[key] = ObjectUtils.deep_merge(merged_object[key], merging_object[key]);\n                } else {\n                    merged_object[key] = merging_object[key];\n                }\n            }\n        }\n\n        return merged_object;\n    }\n\n}","export class StringUtils {\n\n    static cleanFileName(str) {\n        if (str.startsWith('.') || str.startsWith('/')) {\n            str = str.substring(1);\n\n            return StringUtils.cleanFileName(str);\n        } else {\n            return str;\n        }\n    }\n\n}","export class BokehGraph {\n\n    container_id = null;\n    container = null;\n\n    static plt = Bokeh.Plotting;\n\n    static scale_functions = {\n        \"linear\": Bokeh.LinearScale,\n        \"log\": Bokeh.LogScale\n    }\n\n    source = null;\n\n    y_error_bar;\n    x_error_bar;\n\n    columns;\n    data_table;\n\n    static supported_tool_array = [\n        \"pan\",\n        \"box_zoom\",\n        \"wheel_zoom\",\n        \"hover\",\n        \"crosshair\",\n        \"reset\",\n        \"save\",\n        \"lasso_select\",\n        \"poly_select\",\n        \"tap\",\n        \"examine,\",\n        \"undo\",\n        \"redo\"];\n\n    static default_tool_array = [\n        \"pan\",\n        \"box_zoom\",\n        \"wheel_zoom\",\n        \"hover\",\n        \"crosshair\",\n        \"reset\",\n        \"save\"];\n\n    static default_tool_string = \"pan,box_zoom,wheel_zoom,hover,crosshair,reset,save\";\n\n    tool_array = [];\n    tool_string = \"\";\n\n    has_data_table = false;\n\n    constructor(container_id = '#visualization-container') {\n        this.container_id = container_id;\n        this._setContainer();\n    }\n\n    _setContainer() {\n        this.container = document.getElementById(this.container_id);\n    }\n\n    initializeSettings(data, labels, scales, title, error_bars = null, custom_range = null) {\n        this.setupSource(data);\n\n        if(error_bars) {\n            this.setupPlot(title, data['y_low'], data['y_up']);\n        } else {\n            if(custom_range) {\n                let x_low = [];\n                let x_up = [];\n\n                let y_low = [];\n                let y_up = [];\n\n                if(custom_range.x !== null) {\n                    custom_range.x.lower_bound !== null ? x_low.push(custom_range.x.lower_bound) : x_low = data['x'];\n                    custom_range.x.upper_bound !== null ? x_up.push(custom_range.x.upper_bound) : x_up = data['x'];\n                } else {\n                    x_low = data['x'];\n                    x_up = data['x'];\n                }\n\n                if(custom_range.y !== null) {\n                    custom_range.y.lower_bound !== null ? y_low.push(custom_range.y.lower_bound) : y_low = data['y'];\n                    custom_range.y.upper_bound !== null ? y_up.push(custom_range.y.upper_bound) : y_up = data['y'];\n                } else {\n                    y_low = data['y'];\n                    y_up = data['y'];\n                }\n\n                this.setupPlot(title, y_low, y_up, x_low, x_up)\n            } else {\n                this.setupPlot(title, data['y'], data['y']);\n            }\n\n        }\n\n        this.setupData();\n        this.setupScales(scales);\n        this.setupLabels(labels);\n\n        if(error_bars) {\n            this.setupErrorBars();\n        }\n    }\n\n    initializeGraph() {\n\n        if(this.has_data_table) {\n            BokehGraph.plt.show(new Bokeh.Column({children: [p, data_table]}), \"#graph-container\");\n        } else {\n            BokehGraph.plt.show(this.plot, this.container_id);\n        }\n    }\n\n    setupPlot(title, y_range_low, y_range_up, x_range_low = null, x_range_up= null) {\n\n        if(x_range_low) {\n            this.plot = BokehGraph.plt.figure({\n                title: title,\n                tools: BokehGraph.default_tool_string,\n                width: 800,\n                height: 600,\n            });\n        } else {\n            this.plot = BokehGraph.plt.figure({\n                title: title,\n                tools: BokehGraph.default_tool_string,\n                width: 800,\n                height: 600,\n            });\n        }\n    }\n\n    setupSource(data_sources) {\n        this.source = new Bokeh.ColumnDataSource({\n            data: data_sources\n        });\n    }\n\n    setupData() {\n        const circles = this.plot.circle({ field: \"x\" }, { field: \"y\" }, {\n            source: this.source,\n            size: 4,\n            fill_color: \"navy\",\n            line_color: null,\n        });\n    }\n\n    setupErrorBars() {\n        this.y_error_bar = new Bokeh.Whisker({\n            dimension: \"height\",\n            source: this.source,\n            base: {field: \"x\"},\n            lower: {field: \"y_low\"},\n            upper: {field: \"y_up\"},\n            line_color: \"navy\",\n            lower_head: null,\n            upper_head: null,\n        });\n\n        this.x_error_bar = new Bokeh.Whisker({\n            dimension: \"width\",\n            source: this.source,\n            base: {field: \"y\"},\n            lower: {field: \"x_low\"},\n            upper: {field: \"x_up\"},\n            line_color: \"navy\",\n            lower_head: null,\n            upper_head: null,\n        });\n\n        this.plot.add_layout(this.y_error_bar);\n        this.plot.add_layout(this.x_error_bar);\n    }\n\n    setupScales (scales) {\n        if(scales) {\n            this.plot.x_scale = new BokehGraph.scale_functions[scales.x]();\n            this.plot.y_scale = new BokehGraph.scale_functions[scales.y]();\n        }\n    }\n\n    setupLabels(labels) {\n        this.plot.xaxis.axis_label = labels.x;\n        this.plot.yaxis.axis_label = labels.y;\n    }\n\n    setupColumns(labels, columns) {\n        this.columns = [\n            new Bokeh.Tables.TableColumn({field: 'x', title: labels.x}),\n            new Bokeh.Tables.TableColumn({field: 'y', title: labels.y})\n        ]\n    }\n\n    setupDataTable() {\n        this.data_table = new Bokeh.Tables.DataTable({\n            source: this.source,\n            columns: this.columns,\n            width: 800,\n        });\n    }\n\n    createToolArray(tool_array) {\n        this.tool_array = tool_array;\n    }\n\n    addToolToToolArray(tool_name) {\n        if (!this.tool_array.includes(tool_name) && BokehGraph.supported_tool_array.includes(tool_name)) {\n            this.tool_array.push(tool_name);\n        }\n    }\n\n    removeToolFromToolArray(tool_name) {\n        this.tool_array = this.tool_array.filter(str => str !== tool_name);\n    }\n\n    setToolStringFromToolArray() {\n        this.tool_string = this.tool_array.join(',');\n    }\n\n}","export class D3Graph {\n\n    x_scale;\n    x_scale_type;\n\n    y_scale;\n    y_scale_type;\n\n    x_axis;\n    x_axis_data_col;\n\n    y_axis;\n    y_axis_data_col;\n\n    dataset;\n    svg; plot; clip; zoom_rect;\n\n    zoom;\n\n    line_container; path;\n\n    container;\n    container_id;\n\n    margin = {top: 10, right: 30, bottom: 30, left: 60};\n    width = 800 - this.margin.left - this.margin.right;\n    height = 400 - this.margin.top - this.margin.bottom;\n\n    has_error_bars = false;\n    x_axis_data_col_error_bar;\n    y_axis_data_col_error_bar;\n\n    has_line = false;\n\n    has_multiple_plots = false;\n    additional_plots = [];\n\n    initialized;\n\n    static scale_functions = {\n        \"linear\": d3.scaleLinear,\n        \"log\": d3.scaleLog\n    };\n\n    static default_scales = {\n        \"x\": 'linear',\n        \"y\": 'linear'\n    }\n\n    static default_axis_tick_format = \".2f\";\n\n    constructor(container_id = 'visualization-container', dataset = null) {\n        this.container_id = container_id;\n        this.dataset = dataset;\n\n        this._setContainer();\n\n        this._updateChart = this._updateChart.bind(this);\n\n        this.initialized = false;\n    }\n\n    _setContainer() {\n        this.container = document.getElementById(this.container_id);\n    }\n\n    initializeSettings(data,\n                       axis,\n                       scales = D3Graph.default_scales,\n                       error_bars = null,\n                       has_line = false,\n                       additional_plots = null) {\n\n        let is_set = false;\n\n        try {\n\n            this.dataset = data;\n\n            this.x_axis_data_col = axis['x'];\n            this.y_axis_data_col = axis['y'];\n\n            this.x_scale_type = scales['x'];\n            this.y_scale_type = scales['y'];\n\n            if(error_bars) {\n                this.has_error_bars = true;\n                this.error_bars = error_bars;\n\n                console.log(error_bars);\n\n                this.x_axis_data_col_error_bar = axis['x'].value;\n                this.y_axis_data_col_error_bar = axis['y'].value;\n\n            } else {\n                this.has_error_bars = false;\n            }\n\n            if (additional_plots) {\n                this.has_multiple_plots = true;\n                this.additional_plots = [];\n\n                let additional_plots_temp = [];\n                additional_plots.forEach(function (plot) {\n                    additional_plots_temp.push(plot);\n                });\n\n                this.additional_plots = additional_plots_temp;\n            }\n\n            this.has_line = has_line;\n\n            is_set = true;\n\n        } catch(e) {\n            console.log(\"Error during graph settings process\")\n        }\n\n        return is_set;\n    }\n\n    initializeGraph() {\n        try {\n            this._setSVGContainer();\n\n            this._setXScale();\n            this._setYScale();\n\n            this._setXAxis();\n            this._setXAxisLabel();\n\n            this._setYAxis();\n            this._setYAxisLabel()\n\n            this._setDataPlot();\n\n            this._setZoomBehavior();\n\n            if(this.has_error_bars) {\n                this._setErrorBars(this.error_bars);\n            }\n\n            if(this.has_line) {\n                this._setAxisLine();\n            }\n\n            if(this.has_multiple_plots) {\n                this._setAdditionalPlots();\n            }\n\n            this.initialized = true;\n        } catch(e) {\n            console.log(\"Error during graph initialization\");\n            this.initialized = false;\n        }\n\n        return this.initialized;\n    }\n\n    _setSVGContainer() {\n\n        let full_width = this._getFullWidth();\n        let full_height = this._getFullHeight();\n\n        this.svg = d3.select(this.container)\n            .append(\"svg\")\n            .attr(\"width\", full_width)\n            .attr(\"height\", full_height)\n            .append(\"g\")\n            .attr(\"transform\",\n                \"translate(\" + this.margin.left + \",\" + this.margin.top + \")\");\n    }\n\n    _setXScale() {\n        this.x_scale = D3Graph.scale_functions[this.x_scale_type]()\n            .domain(d3.extent(this.dataset, d => d[this.x_axis_data_col]))\n            .range([ 0, this.width ]);\n    }\n\n    _setYScale() {\n        this.y_scale = D3Graph.scale_functions[this.y_scale_type]()\n            .domain(d3.extent(this.dataset, d => d[this.y_axis_data_col]))\n            .range([ this.height, 0]);\n    }\n\n    _setXAxis(tick_format = D3Graph.default_axis_tick_format) {\n         this.x_axis = this.svg.append(\"g\")\n            .attr(\"id\", \"x\")\n            .attr(\"transform\", \"translate(0,\" + this.height + \")\")\n            .call(d3.axisBottom(this.x_scale)\n                .tickFormat(d3.format(tick_format)))\n            .call(g => g.selectAll(\".tick line\").clone()\n                .attr(\"class\", \"tick-line\")\n                .attr(\"y2\", -this.height)\n                .attr(\"stroke-opacity\", 0.2))\n    }\n\n    _setYAxis(tick_format = D3Graph.default_axis_tick_format) {\n        this.y_axis = this.svg.append(\"g\")\n            .attr(\"id\", \"y\")\n            .call(d3.axisLeft(this.y_scale)\n                .tickFormat(d3.format(tick_format)))\n            .call(g => g.selectAll(\".tick line\").clone()\n                .attr(\"x2\", this.width)\n                .attr(\"stroke-opacity\", 0.2));\n    }\n\n    _setXAxisLabel() {\n        this.x_axis.select(\".tick:last-of-type text\").clone()\n            .attr(\"id\", \"x-label\")\n            .attr(\"y\", -11)\n            .attr(\"x\", 2)\n            .attr(\"text-anchor\", \"start\")\n            .attr(\"font-weight\", \"bold\")\n            .text(this.x_axis_data_col);\n    }\n\n    _setYAxisLabel() {\n        this.y_axis.select(\".tick:last-of-type text\").clone()\n            .attr(\"id\", \"y-label\")\n            .attr(\"x\", 3)\n            .attr(\"y\", -5)\n            .attr(\"text-anchor\", \"start\")\n            .attr(\"font-weight\", \"bold\")\n            .text(this.y_axis_data_col);\n    }\n\n    _setDataPlot() {\n\n        let x = this.x_scale;\n        let y = this.y_scale;\n\n        let x_col_data = this.x_axis_data_col;\n        let y_col_data = this.y_axis_data_col;\n\n        this.clip = this.svg.append(\"defs\").append(\"SVG:clipPath\")\n            .attr(\"id\", \"clip\")\n            .append(\"SVG:rect\")\n            .attr(\"width\", this.width )\n            .attr(\"height\", this.height )\n            .attr(\"x\", 0)\n            .attr(\"y\", 0);\n\n        this.plot = this.svg.append('g')\n            .attr(\"clip-path\", \"url(#clip)\")\n            .attr(\"id\", \"data-plot\")\n\n        this.plot\n            .selectAll(\"circle\")\n            .data(this.dataset)\n            .enter()\n            .append(\"circle\")\n            .attr(\"cx\", function (d) { return x(d[x_col_data]); } )\n            .attr(\"cy\", function (d) { return y(d[y_col_data]); } )\n            .attr(\"r\", 4)\n            .style(\"fill\", \"transparent\")\n            .style(\"stroke\", \"black\")\n            .style(\"opacity\", 1)\n    }\n\n    _setAdditionalPlots() {\n        let plot;\n        for(let i = 0; i < this.additional_plots.length, i++;) {\n            plot = this.additional_plots[i];\n        }\n    }\n\n    _setErrorBars(error_bars) {\n\n        this.error_bars = error_bars;\n\n        if(error_bars.y) {\n            let line_error_bar_x = d3.line()\n                .x(d => this.x_scale(d[this.x_axis_data_col]))\n                .y(d => this.y_scale(d.bound));\n\n            error_bars.y.forEach((error_bar) => {\n                d3.select('#data-plot').append(\"path\")\n                    .attr(\"class\", \"error-bar-x\")\n                    .attr(\"fill\", \"none\")\n                    .attr(\"stroke\", \"steelblue\")\n                    .attr(\"stroke-width\", 1.5)\n                    .attr(\"d\", line_error_bar_x(error_bar));\n            })\n        }\n\n        if(error_bars.x) {\n            let line_error_bar_y = d3.line()\n                .x(d => this.x_scale(d.bound))\n                .y(d => this.y_scale(d[this.y_axis_data_col]));\n\n            error_bars.x.forEach((error_bar) => {\n                d3.select('#data-plot').append(\"path\")\n                    .attr(\"class\", \"error-bar-x\")\n                    .attr(\"fill\", \"none\")\n                    .attr(\"stroke\", \"steelblue\")\n                    .attr(\"stroke-width\", 1.5)\n                    .attr(\"d\", line_error_bar_y(error_bar));\n            })\n        }\n    }\n\n    _setAxisLine() {\n        let line = d3.line()\n            .curve(d3.curveCatmullRom)\n            .x(d => this.x_axis(d[this.x_axis_data_col]))\n            .y(d => this.y_axis(d[this.y_axis_data_col]));\n\n        this.line_container = this.svg.append(\"g\")\n            .attr(\"id\", \"path-container\")\n            .attr(\"clip-path\", \"url(#clip)\");\n\n        this.path = this.line_container.append(\"path\")\n            .attr(\"id\", \"path\")\n            .attr(\"fill\", \"none\").attr(\"stroke\", \"steelblue\")\n            .attr(\"d\", line(data));\n    }\n\n    _setZoomBehavior() {\n\n        this.zoom = d3.zoom()\n            .scaleExtent([.5, 20])\n            .extent([[0, 0], [this.width, this.height]])\n            .on(\"zoom\", this._updateChart);\n\n        this.zoom_rect = this.svg.append(\"rect\")\n            .attr(\"width\", this.width)\n            .attr(\"height\", this.height)\n            .style(\"fill\", \"none\")\n            .style(\"pointer-events\", \"all\")\n            .attr('transform', 'translate(' + this.margin.left + ',' + this.margin.top + ')')\n            .call(this.zoom);\n\n    }\n\n    _updateChart(e) {\n\n        let rescaled_x = e.transform.rescaleX(this.x_scale);\n        let rescaled_y = e.transform.rescaleY(this.y_scale);\n\n        this.x_axis.call(d3.axisBottom(rescaled_x).tickFormat(d3.format(D3Graph.default_axis_tick_format)))\n        this.y_axis.call(d3.axisLeft(rescaled_y).tickFormat(d3.format(D3Graph.default_axis_tick_format)))\n\n        this.svg.selectAll(\".tick-line\").remove();\n        this.svg.selectAll(\"#y-label\").remove();\n        this.svg.selectAll(\"#x-label\").remove();\n        this.svg.selectAll(\".error-bar-x\").remove();\n\n        this.x_axis.selectAll(\".tick line\").clone()\n            .attr(\"class\", \"tick-line\")\n            .attr(\"y2\", -this.height)\n            .attr(\"stroke-opacity\", 0.2)\n\n        this.y_axis.selectAll(\".tick line\").clone()\n            .attr(\"class\", \"tick-line\")\n            .attr(\"x2\", this.width)\n            .attr(\"stroke-opacity\", 0.2)\n\n        this._setXAxisLabel();\n        this._setYAxisLabel();\n\n        let x_data_col = this.x_axis_data_col;\n        let y_data_col = this.y_axis_data_col;\n\n        this.svg.selectAll(\"circle\")\n            .data(this.dataset)\n            .transition()\n            .duration(150)\n            .attr(\"cx\", function (d) { return rescaled_x(d[x_data_col]); } )\n            .attr(\"cy\", function (d) { return rescaled_y(d[y_data_col]); } )\n\n        if(this.has_line) {\n            this.svg.selectAll(\"path\").remove();\n            this._setAxisLine();\n        }\n\n        if(this.has_error_bars) {\n\n            if(this.error_bars.y) {\n                let line_error_bar_x = d3.line()\n                    .x(d => rescaled_x(d[this.x_axis_data_col]))\n                    .y(d => rescaled_y(d.bound));\n\n                this.error_bars.y.forEach((error_bar) => {\n                    d3.select('#data-plot').append(\"path\")\n                        .attr(\"class\", \"error-bar-x\")\n                        .attr(\"fill\", \"none\")\n                        .attr(\"stroke\", \"steelblue\")\n                        .attr(\"stroke-width\", 1.5)\n                        .attr(\"d\", line_error_bar_x(error_bar));\n                })\n            }\n\n            if(this.error_bars.x) {\n                let line_error_bar_y = d3.line()\n                    .x(d => rescaled_x(d.bound))\n                    .y(d => rescaled_y(d[this.y_axis_data_col]));\n\n                this.error_bars.x.forEach((error_bar) => {\n                    d3.select('#data-plot').append(\"path\")\n                        .attr(\"class\", \"error-bar-x\")\n                        .attr(\"fill\", \"none\")\n                        .attr(\"stroke\", \"steelblue\")\n                        .attr(\"stroke-width\", 1.5)\n                        .attr(\"d\", line_error_bar_y(error_bar));\n                })\n            }\n        }\n\n    }\n\n    _getFullWidth() {\n        return this.width + this.margin.left + this.margin.right\n    }\n\n    _getFullHeight() {\n        return this.height + this.margin.top + this.margin.bottom\n    }\n}","import {ConfigurationEvent} from \"../events/ConfigurationEvent\";\nimport {DataProcessorContainer} from \"../containers/DataProcessorContainer\";\nimport {VisualizationContainer} from \"../containers/VisualizationContainer\";\nimport {WrapperContainer} from \"../containers/WrapperContainer\";\nimport {SettingsConfiguration} from \"../settings/SettingsConfiguration\";\n\nexport class BokehWrapper {\n\n    static container_id = 'visualization-container';\n\n    static library = 'bokeh';\n\n    static title = {\n        'light-curve': 'Light curve',\n        'spectrum': 'spectrum'\n    }\n\n    static specific_settings = {\n        'bokeh-settings': {\n            display: true,\n            'bokeh-options': {\n                tools: {\n                    display: false\n                }\n            }\n        }\n    };\n\n    container = null;\n\n    configuration_object = null;\n\n    constructor() {\n        this._setContainer();\n        this._setupListeners();\n    }\n\n    _setContainer() {\n        this.container = document.getElementById(BokehWrapper.container_id);\n    }\n\n    _resetContainer() {\n        this.container.innerHTML = \"\";\n    }\n\n    _setupListeners() {\n        document.addEventListener('settings-changed', this.handleSettingsChangedEvent.bind(this));\n        document.addEventListener('visualization-generation', this.handleVisualizationGenerationEvent.bind(this));\n    }\n\n    handleSettingsChangedEvent(event) {\n        let settings_object = event.detail.settings_object;\n\n        let library_settings = settings_object.getLibrarySettings();\n\n        if(library_settings.library === BokehWrapper.library) {\n            this.createConfigurationObject();\n\n            if(this.configuration_object !== null) {\n                let configuration_event = new ConfigurationEvent(this.configuration_object);\n\n                configuration_event.dispatchToSubscribers();\n            }\n        }\n    }\n\n    handleVisualizationGenerationEvent(event) {\n        this.settings_object = event.detail.settings_object;\n\n        let library_settings = this.settings_object.getLibrarySettings();\n\n        if(library_settings.library === BokehWrapper.library) {\n\n            this._resetContainer();\n\n            let dataset_settings = {};\n\n            let axis = this.settings_object.getAxisSettings();\n            let axis_settings = [];\n\n            for(let axis_column in axis) {\n                let axis_column_object = this._getColumnSettings(axis[axis_column]);\n                axis_column_object = {...axis_column_object, ...{axis: axis_column}}\n\n                axis_settings.push(axis_column_object);\n            }\n\n            dataset_settings.axis = axis_settings;\n            dataset_settings.data_type = this.settings_object.getDataTypeSettings();\n\n            let error_bars = this.settings_object.getErrorBarsSettings();\n            let has_error_bars = false;\n\n            if(error_bars !== null) {\n\n                let error_bars_settings = [];\n                for(let axis_column in error_bars) {\n                    let axis_column_object = this._getColumnSettings(error_bars[axis_column]);\n                    axis_column_object = {...axis_column_object, ...{axis: axis_column}}\n\n                    error_bars_settings.push(axis_column_object);\n                }\n\n                dataset_settings.error_bars = error_bars_settings;\n            }\n\n            let dpp = DataProcessorContainer.getDataProcessorContainer().getDataPreProcessor();\n\n            let processed_data = dpp.getProcessedDataset(dataset_settings);\n\n            let data_type = this.settings_object.getDataTypeSettings();\n\n            let scales = this.settings_object.getScalesSettings();\n\n\n            axis = {x: processed_data.axis[0].column_name, y: processed_data.axis[1].column_name};\n            let labels = axis;\n\n            processed_data.axis[0].data = processed_data.axis[0].data.map(value => isNaN(value) ? 0 : value);\n            processed_data.axis[1].data = processed_data.axis[1].data.map(value => isNaN(value) ? 0 : value);\n\n\n            let data = {x: processed_data.axis[0].data, y: processed_data.axis[1].data};\n\n            if(error_bars) {\n\n                console.log(processed_data.error_bars);\n\n                let error_bars_object = {};\n\n                processed_data.error_bars.forEach((error_bar) => {\n                    error_bar.data = error_bar.data.map(value => !isFinite(value) ? 0 : value);\n                    error_bar.data = error_bar.data.map(value => isNaN(value) ? 0 : value);\n\n                    error_bars_object[error_bar.axis] = error_bar.column_name;\n\n                    if(error_bar.axis === 'x') {\n                        data.dx = error_bar.data;\n                    } else if(error_bar.axis === 'y') {\n                        data.dy = error_bar.data;\n                    }\n                })\n\n                /*\n                error_bars = {x: processed_data.error_bars[0].column_name, y: processed_data.error_bars[1].column_name};\n\n                processed_data.error_bars[0].data = processed_data.error_bars[0].data.map(value => !isFinite(value) ? 0 : value);\n                processed_data.error_bars[1].data = processed_data.error_bars[1].data.map(value => !isFinite(value) ? 0 : value);\n\n                data.dx = processed_data.error_bars[0].data.map(value => isNaN(value) ? 0 : value);\n                data.dy = processed_data.error_bars[1].data.map(value => isNaN(value) ? 0 : value);\n                */\n\n                let asymmetric_uncertainties = false;\n\n                if(data_type === 'spectrum') {\n                    asymmetric_uncertainties = true;\n                }\n\n                data = this._processErrorBarData(data, asymmetric_uncertainties);\n\n                has_error_bars = true;\n            }\n\n            let ranges = this.settings_object.getRangesSettings();\n            let custom_range_data = null;\n\n            if(ranges != null) {\n\n                if(has_error_bars) {\n                    custom_range_data = dpp.processDataForRangeBokeh(ranges, data, true);\n                } else {\n                    custom_range_data = dpp.processDataForRangeBokeh(ranges, data);\n                }\n\n                data = custom_range_data;\n            }\n\n            let visualization = VisualizationContainer.getBokehVisualization();\n\n            visualization.initializeSettings(data, labels, scales, BokehWrapper.title['data_type'], error_bars, ranges);\n\n            visualization.initializeGraph();\n        }\n    }\n\n    _getColumnSettings(column_settings) {\n        let settings = column_settings.split('$');\n\n        let column_location = settings[0].split('.');\n        let column_name = settings[1] || '';\n\n        let file_id = column_location[0];\n        let hdu_index = column_location.length > 1 ? column_location[1] : '';\n\n        return {\n            file_id: file_id,\n            hdu_index: hdu_index,\n            column_name: column_name\n        };\n    }\n\n    _processErrorBarData(data, asymetric_uncertainties = false) {\n\n        let div_factor= 2;\n\n        if(asymetric_uncertainties) {\n            div_factor = 1;\n        }\n\n        if(data.dx) {\n            let x_low = [];\n            let x_up = [];\n\n            for(let i in data.dx) {\n                x_low[i] = data.x[i] - data.dx[i] / div_factor;\n                x_up[i] = data.x[i] + data.dx[i] / div_factor;\n            }\n\n            data.x_low = x_low;\n            data.x_up = x_up;\n\n            delete data.dx;\n        }\n\n        if(data.dy) {\n            let y_low = [];\n            let y_up = [];\n\n            for(let i in data.dy) {\n                y_low[i] = data.y[i] - data.dy[i];\n                y_up[i] = data.y[i] + data.dy[i];\n            }\n\n            data.y_low = y_low;\n            data.y_up = y_up;\n\n            delete data.dy;\n\n        }\n\n        /*\n        let y_low = [], y_up = [], x_low = [], x_up = [];\n\n        for (let i in data.dy) {\n            y_low[i] = data.y[i] - data.dy[i];\n            y_up[i] = data.y[i] + data.dy[i];\n            x_low[i] = data.x[i] - data.dx[i] / div_factor;\n            x_up[i] = data.x[i] + data.dx[i] / div_factor;\n        }\n\n        data.y_low = y_low;\n        data.y_up = y_up;\n        data.x_low = x_low;\n        data.x_up = x_up;\n\n        delete data.dy;\n        delete data.dx;\n        */\n\n        return data;\n    }\n\n    createConfigurationObject() {\n        this.configuration_object = SettingsConfiguration.getConfigurationObject(BokehWrapper.specific_settings);\n    }\n\n}","import {ConfigurationEvent} from \"../events/ConfigurationEvent\";\nimport {DataProcessorContainer} from \"../containers/DataProcessorContainer\";\nimport {VisualizationContainer} from \"../containers/VisualizationContainer\";\nimport {SettingsConfiguration} from \"../settings/SettingsConfiguration\";\n\nexport class D3Wrapper {\n\n    static library = \"d3\";\n    static container_id = \"visualization-container\";\n\n    static specific_settings = {\n        'd3-settings': {\n            display: true,\n            'd3-options': {\n                'has_line': true,\n                display: false\n            }\n        }\n    };\n\n    container;\n    container_id;\n\n    settings_object;\n    configuration_object = null;\n\n    constructor(container_id = D3Wrapper.container_id) {\n        this._setupListeners();\n\n        this.container_id = container_id;\n        this._setContainer();\n    }\n\n    _setupListeners() {\n        document.addEventListener('settings-changed', this.handleSettingsChangedEvent.bind(this));\n        document.addEventListener('visualization-generation', this.handleVisualizationGenerationEvent.bind(this));\n    }\n\n    handleSettingsChangedEvent(event) {\n        let settings_object = event.detail.settings_object;\n\n        let library_settings = settings_object.getLibrarySettings();\n\n        if(library_settings.library === D3Wrapper.library) {\n            this.createConfigurationObject();\n\n            if(this.configuration_object !== null) {\n                let configuration_event = new ConfigurationEvent(this.configuration_object);\n                configuration_event.dispatchToSubscribers();\n            }\n        }\n\n    }\n\n    handleVisualizationGenerationEvent(event) {\n        this.settings_object = event.detail.settings_object;\n\n        let library_settings = this.settings_object.getLibrarySettings();\n\n        if(library_settings.library === D3Wrapper.library) {\n\n            this.resetContainer();\n\n            let dataset_settings = {};\n\n            let data_type = this.settings_object.getDataTypeSettings();\n            let axis = this.settings_object.getAxisSettings();\n            let scales = this.settings_object.getScalesSettings();\n            let error_bars = this.settings_object.getErrorBarsSettings();\n            let ranges = this.settings_object.getRangesSettings();\n\n            let has_error_bars = false;\n\n            dataset_settings.data_type = data_type;\n\n            let axis_settings = [];\n            for(let axis_column in axis) {\n                let axis_column_object = this._getColumnSettings(axis[axis_column]);\n                axis_column_object = {...axis_column_object, ...{axis: axis_column}}\n\n                axis_settings.push(axis_column_object);\n            }\n\n            dataset_settings.axis = axis_settings;\n\n            if(error_bars !== null) {\n                has_error_bars = true;\n\n                let error_bars_settings = [];\n                for(let axis_column in error_bars) {\n                    let axis_column_object = this._getColumnSettings(error_bars[axis_column]);\n                    axis_column_object = {...axis_column_object, ...{axis: axis_column}}\n\n                    error_bars_settings.push(axis_column_object);\n                }\n\n                dataset_settings.error_bars = error_bars_settings;\n            }\n\n            let dpp = DataProcessorContainer.getDataProcessorContainer().getDataPreProcessor();\n\n            let processed_data = dpp.getProcessedDataset(dataset_settings);\n            let processed_json_data = dpp.datasetToJSONData(processed_data);\n\n            axis = {x: processed_data.axis[0].column_name, y: processed_data.axis[1].column_name};\n\n            if(has_error_bars) {\n                let error_bars_object = {};\n\n                processed_data.error_bars.forEach((error_bar) => {\n                    error_bars_object[error_bar.axis] = error_bar.column_name;\n                })\n\n                error_bars = dpp.processErrorBarDataJSON(processed_json_data, axis, error_bars_object)\n            }\n\n            if(ranges != null) {\n                let custom_range_data = null;\n\n                if(has_error_bars) {\n                    custom_range_data = dpp.processDataForRange(ranges, processed_json_data, error_bars);\n                    processed_json_data = custom_range_data.data;\n                    error_bars = custom_range_data.error_bars;\n                } else {\n                    custom_range_data = dpp.processDataForRange(ranges, processed_json_data);\n                    processed_json_data = custom_range_data.data;\n                }\n            }\n\n            let visualization = VisualizationContainer.getD3Visualization();\n\n            visualization.initializeSettings(processed_json_data, axis, scales, error_bars, false, null);\n            visualization.initializeGraph();\n        }\n\n    }\n\n    _setContainer() {\n        this.container = document.getElementById(this.container_id)\n    }\n\n    resetContainer() {\n        this.container.innerHTML = \"\";\n    }\n\n    createConfigurationObject() {\n        this.configuration_object = SettingsConfiguration.getConfigurationObject(D3Wrapper.specific_settings);\n    }\n\n    _getColumnSettings(column_settings) {\n        let settings = column_settings.split('$');\n\n        let column_location = settings[0].split('.');\n        let column_name = settings[1] || '';\n\n        let file_id = column_location[0];\n        let hdu_index = column_location.length > 1 ? column_location[1] : '';\n\n        return {\n            file_id: file_id,\n            hdu_index: hdu_index,\n            column_name: column_name\n        };\n    }\n\n}","import {InvalidURLError} from \"../errors/InvalidURLError\";\nimport {HDUNotTabularError} from \"../errors/HDUNotTabularError\";\nimport {FileRegistry} from \"../registries/FileRegistry\";\nimport {StringUtils} from \"../utils/StringUtils\";\nimport {FileLoadedEvent} from \"../events/FileLoadedEvent\";\n\nexport class FITSReaderWrapper {\n\n    file_path = null;\n    file = null;\n\n    static BINTABLE = 'BINTABLE';\n    static TABLE = 'TABLE';\n\n    constructor(file_path = null) {\n        if(file_path) {\n            console.log(file_path);\n            if (FITSReaderWrapper.is_path_valid(file_path)) {\n                this.file_path = file_path;\n                this._getFile()\n            } else {\n                throw new InvalidURLError(\"Invalid file path : \" + file_path);\n            }\n        }\n    }\n\n    initializeFromPath(file_path) {\n        if(FITSReaderWrapper.is_path_valid(file_path)) {\n            this.file_path = file_path;\n            this._getFile()\n        } else {\n            throw new InvalidURLError(\"Invalid file path : \" + file_path);\n        }\n\n    }\n\n    initializeFromBuffer(array_buffer, file_name) {\n        this.file_path = file_name;\n        this._readFile(array_buffer);\n    }\n\n    _getFile() {\n\n        return fetch(this.file_path)\n            .then((response) => {\n                if (!response.ok) {\n                    throw new Error(`HTTP error, status = ${response.status}`);\n                }\n                return response.arrayBuffer();\n            })\n            .then((buffer) => this._readFile(buffer));\n    }\n\n    _readFile(arrayBuffer) {\n        try {\n            this.file = window.FITSReader.parseFITS(arrayBuffer);\n\n            this.sendFITSLoadedEvents();\n\n        } catch(e) {\n            console.log(\"Error initializing interface\")\n        }\n    }\n\n    getFilePath() {\n        return this.file_path;\n    }\n\n    setFile(file) {\n        this.file = file;\n    }\n\n    setFileFromFileObject(file_object) {\n        this.file = file_object.file;\n        this.arf_file = file_object.arf_file_id;\n        this.rmf_file = file_object.rmf_file_id;\n    }\n\n    getHDU(hdu_index) {\n        if(hdu_index >= 0 && hdu_index < this.file.hdus.length) {\n            return this.file.hdus[hdu_index];\n        } else {\n            return null;\n        }\n    }\n\n    getHDUs() {\n\n        let HDUs = [];\n        let hdu_object;\n        let type;\n        let extname = '';\n\n        this.file.hdus.forEach(function(hdu, index) {\n\n            if (hdu.header.primary === true) {\n                type = \"PRIMARY\";\n            } else {\n                type = hdu.header.get('XTENSION');\n                extname = hdu.header.get('EXTNAME');\n            }\n\n            hdu_object = {\n                \"name\": type,\n                \"index\": index,\n                \"extname\": extname\n            };\n\n            HDUs.push(hdu_object);\n        })\n\n        return HDUs;\n    }\n\n    getTabularHDUs() {\n        let tabular_hdus_index = [];\n\n        this.file.hdus.forEach(function(hdu, index) {\n            if (hdu.header.primary !== true) {\n                if(hdu.header.get('XTENSION') === \"TABLE\" || hdu.header.get('XTENSION') === \"BINTABLE\") {\n                    tabular_hdus_index.push(index);\n                }\n            }\n        })\n\n        return tabular_hdus_index;\n    }\n\n    getNumberOfColumnFromHDU(hdu_index) {\n        let hdu = this.file.getHDU(hdu_index);\n\n        let header = hdu.header;\n        let data = hdu.data;\n\n        let type = header.get('XTENSION');\n\n        let column_number = null;\n\n        if(type === FITSReaderWrapper.BINTABLE || type === FITSReaderWrapper.TABLE) {\n            column_number = data.cols;\n        } else {\n            throw new HDUNotTabularError(\"Selected HDU is not tabular\");\n        }\n\n        return column_number;\n    }\n\n    getColumnsNameFromHDU(hdu_index) {\n        let hdu = this.file.getHDU(hdu_index);\n\n        let header = hdu.header;\n        let data = hdu.data;\n\n        let type = hdu.header.get('XTENSION');\n\n        let columns = [];\n        let column_name;\n\n        if(type === FITSReaderWrapper.BINTABLE || type === FITSReaderWrapper.TABLE) {\n            data.columns.forEach(function (column) {\n                column_name = column;\n\n                columns.push(column_name);\n            })\n        } else {\n            throw new HDUNotTabularError(\"Selected HDU is not tabular\");\n        }\n\n        return columns;\n    }\n\n    getColumnsJSONDataFromHDU(hdu_index) {\n\n        let hdu = this.file.getHDU(hdu_index);\n\n        let header = hdu.header;\n        let data = hdu.data;\n\n        let type = hdu.header.get('XTENSION');\n\n        let columns_data_json = [];\n        let raw_columns_data_array = [];\n        let column_data;\n\n        if(type === FITSReaderWrapper.BINTABLE || type === FITSReaderWrapper.TABLE) {\n            data.columns.forEach(function(column) {\n\n                try {\n                    data.getColumn(column, function (col) {\n                        column_data = col;\n                    })\n                } catch(e) {\n\n                }\n\n                raw_columns_data_array[column] = column_data;\n            })\n\n            let column_names = Object.keys(raw_columns_data_array);\n\n            for (let i = 0; i < raw_columns_data_array[column_names[0]].length; i++) {\n\n                let column_json_data_object = {};\n\n                column_names.forEach((column_name) => {\n                    column_json_data_object[column_name] = raw_columns_data_array[column_name][i];\n                });\n\n                columns_data_json.push(column_json_data_object);\n            }\n\n        } else {\n            throw new HDUNotTabularError(\"Selected HDU is not tabular\");\n        }\n\n        return columns_data_json;\n    }\n\n    getColumnDataFromHDU(hdu_index, column_name) {\n        let hdu = this.file.getHDU(hdu_index);\n\n        let header = hdu.header;\n        let data = hdu.data;\n\n        let type = hdu.header.get('XTENSION');\n\n        let col_data = [];\n        if(type === FITSReaderWrapper.BINTABLE || type === FITSReaderWrapper.TABLE) {\n\n            data.getColumn(column_name, function(col){\n                if(col[0] === undefined) {\n                    let header_col_data = hdu.header.get(column_name);\n                    col = col.map(() => header_col_data);\n                }\n\n                col_data = col;\n            })\n\n        } else {\n            throw new HDUNotTabularError(\"Selected HDU is not tabular\");\n        }\n\n        return col_data;\n    }\n\n    getHeaderFromHDU(hdu_index) {\n        let hdu = this.file.getHDU(hdu_index);\n        let header = hdu.header;\n\n        return header;\n    }\n\n    getDataFromHDU(hdu_index) {\n        let hdu = this.file.getHDU(hdu_index);\n        let data = hdu.data;\n\n        return data;\n    }\n\n    getHeaderCardValueByNameFromHDU(hdu_index, card_name) {\n        let hdu = this.file.getHDU(hdu_index);\n        let header = hdu.header;\n\n        let value = header.get(card_name);\n\n        if(value === undefined) {\n            value = '';\n        }\n\n        return value;\n    }\n\n    getHeaderCardsValueFromHDU(hdu_index) {\n        let hdu = this.file.getHDU(hdu_index);\n\n        const cards_array = [];\n\n        Object.entries(hdu.header.cards).forEach(function(item) {\n            let item_value_array = item[1];\n\n            if(typeof item_value_array === 'object' && !Array.isArray(item_value_array)) {\n                item_value_array['card_name'] = item[0];\n                cards_array.push(item_value_array);\n            }\n        })\n\n        let sorted_hdu_cards = cards_array.sort((a, b) => a.index - b.index);\n\n        return sorted_hdu_cards;\n    }\n\n    isHDUTabular(hdu_index) {\n        let hdu = this.file.getHDU(hdu_index);\n        let header = hdu.header;\n\n        let type = header.get('XTENSION');\n\n        let is_tabular = false;\n\n        if(type === FITSReaderWrapper.BINTABLE || type === FITSReaderWrapper.TABLE) {\n            is_tabular = true;\n        }\n\n        return is_tabular;\n    }\n\n    _isHDUTabular(hdu) {\n        let extension = hdu.header.get('XTENSION');\n        return extension === FITSReaderWrapper.BINTABLE || extension === FITSReaderWrapper.TABLE;\n    }\n\n    getAllColumns() {\n        let columns = [];\n\n        this.file.hdus.forEach((hdu, index) => {\n\n            if(this._isHDUTabular(hdu)) {\n                let columns_name = this.getColumnsNameFromHDU(index);\n\n                columns_name.forEach((column_name) => {\n                    let column = {\n                        name: column_name,\n                        hdu_index: index,\n                        is_from_header: false\n                    }\n\n                    columns.push(column);\n                })\n\n                if(hdu.header.get('TIMEDEL') !== null) {\n                    let column = {\n                        name: 'TIMEDEL',\n                        hdu_index: index,\n                        is_from_header: true\n                    }\n\n                    columns.push(column);\n                }\n\n                if(hdu.header.get('ANCRFILE') !== null) {\n                    let ancrfile = FileRegistry.getFileByName(\n                        StringUtils.cleanFileName(hdu.header.get('ANCRFILE'))\n                    );\n\n                    if(ancrfile !== undefined) {\n                        let frw = new FITSReaderWrapper();\n                        frw.setFile(ancrfile.file);\n                    }\n\n                } else if(this.arf_file) {\n\n                    let ancrfile = FileRegistry.getFileById(this.arf_file);\n\n                    if(ancrfile !== undefined) {\n                        let frw = new FITSReaderWrapper();\n                        frw.setFile(ancrfile.file);\n                    }\n\n                }\n\n                if(hdu.header.get('RESPFILE') !== null) {\n                    let respfile = FileRegistry.getFileByName(\n                        StringUtils.cleanFileName(hdu.header.get('RESPFILE'))\n                    );\n\n                    if(respfile !== undefined) {\n                        let frw = new FITSReaderWrapper();\n\n                        frw.setFile(respfile.file);\n\n                        let hdus_index = frw.getTabularHDUs();\n\n                        let has_e_min_max = false;\n                        hdus_index.forEach((hdu_index) => {\n                            let columns_name = frw.getColumnsNameFromHDU(hdu_index);\n                            if (columns_name.includes(\"E_MIN\") && columns_name.includes(\"E_MAX\")) {\n                                has_e_min_max = true;\n                                let e_min_max_hdus_index = hdu_index;\n\n                                let column = {\n                                    name: 'E_HALF_WIDTH',\n                                    hdu_index: hdu_index,\n                                    is_from_header: false,\n                                    is_processed: true,\n                                    from_file: respfile.id\n                                }\n\n                                columns.push(column);\n\n                                column = {\n                                    name: 'E_MID',\n                                    hdu_index: hdu_index,\n                                    is_from_header: false,\n                                    is_processed: true,\n                                    from_file: respfile.id\n                                }\n\n                                columns.push(column);\n\n                                column = {\n                                    name: 'E_MID_LOG',\n                                    hdu_index: hdu_index,\n                                    is_from_header: false,\n                                    is_processed: true,\n                                    from_file: respfile.id\n                                }\n\n                                columns.push(column);\n\n                            }\n                        })\n\n                    }\n\n                } else if(this.rmf_file) {\n                    let respfile = FileRegistry.getFileById(this.rmf_file);\n\n                    if(respfile !== undefined) {\n                        let frw = new FITSReaderWrapper();\n\n                        frw.setFile(respfile.file);\n\n                        let hdus_index = frw.getTabularHDUs();\n\n                        let has_e_min_max = false;\n                        hdus_index.forEach((hdu_index) => {\n                            let columns_name = frw.getColumnsNameFromHDU(hdu_index);\n                            if (columns_name.includes(\"E_MIN\") && columns_name.includes(\"E_MAX\")) {\n                                has_e_min_max = true;\n                                let e_min_max_hdus_index = hdu_index;\n\n                                let column = {\n                                    name: 'E_HALF_WIDTH',\n                                    hdu_index: hdu_index,\n                                    is_from_header: false,\n                                    is_processed: true,\n                                    from_file: respfile.id\n                                }\n\n                                columns.push(column);\n\n                                column = {\n                                    name: 'E_MID',\n                                    hdu_index: hdu_index,\n                                    is_from_header: false,\n                                    is_processed: true,\n                                    from_file: respfile.id\n                                }\n\n                                columns.push(column);\n\n                                column = {\n                                    name: 'E_MID_LOG',\n                                    hdu_index: hdu_index,\n                                    is_from_header: false,\n                                    is_processed: true,\n                                    from_file: respfile.id\n                                }\n\n                                columns.push(column);\n\n                            }\n                        })\n\n                    }\n                }\n            }\n        })\n\n        return columns;\n    }\n\n    sendFITSLoadedEvents() {\n        let filele = new FileLoadedEvent({\n            file_name: this.file_path,\n            type: 'fits',\n            file: this.file\n        });\n\n        filele.dispatchToSubscribers();\n    }\n\n    static is_path_valid(path) {\n        let is_valid = false;\n\n        if(FITSReaderWrapper._isPathValid(path) || FITSReaderWrapper._isURLValid(path)) {\n            is_valid = true;\n        }\n\n        return is_valid;\n    }\n\n    static _isURLValid(url) {\n        const urlRegex = /^(ftp|http|https):\\/\\/[^ \"]+$/;\n        return urlRegex.test(url);\n    }\n\n    static _isPathValid(path) {\n        const pathRegex = /^(\\/[a-zA-Z0-9._-]+)+\\/?$/;\n        return pathRegex.test(path);\n    }\n\n}","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","import { FITSReaderWrapper } from './wrappers/FITSReaderWrapper.js'\nimport { BokehWrapper } from './wrappers/BokehWrapper.js'\nimport { D3Wrapper } from './wrappers/D3Wrapper.js'\nimport { WrapperContainer } from './containers/WrapperContainer.js'\nimport { VisualizationContainer } from './containers/VisualizationContainer.js'\nimport { FileComponent } from './components/FileComponent.js'\nimport { SettingsComponent } from './components/SettingsComponent.js'\nimport { VisualizationComponent } from './components/VisualizationComponent.js'\nimport { FITSSettingsComponent } from './components/file_type/FITSSettingsComponent.js'\nimport { CSVSettingsComponent } from './components/file_type/CSVSettingsComponent.js'\nimport { D3Graph } from \"./visualizations/D3Graph\";\nimport { BokehGraph } from \"./visualizations/BokehGraph\";\nimport {FileRegistry} from \"./registries/FileRegistry\";\nimport {RegistryContainer} from \"./containers/RegistryContainer\";\nimport {ArithmeticColumnInput} from \"./components/inputs/ArithmeticColumnInput\";\n\nlet file_path = window.location.href + \"_test_files/spiacs_lc_query.fits\";\n\nlet fits_reader_wrapper = new FITSReaderWrapper(file_path);\n\nlet bokeh_wrapper = new BokehWrapper();\n\nlet d3_wrapper = new D3Wrapper();\n\nWrapperContainer.setFITSReaderWrapper(fits_reader_wrapper);\nWrapperContainer.setBokehWrapper(bokeh_wrapper);\nWrapperContainer.setD3Wrapper(d3_wrapper);\n\nVisualizationContainer.setBokehVisualization(new BokehGraph());\nVisualizationContainer.setD3Visualization(new D3Graph());\n\nRegistryContainer.setFileRegistry(new FileRegistry());\n\ncustomElements.define('file-component', FileComponent);\ncustomElements.define('settings-component', SettingsComponent);\ncustomElements.define('visualization-component', VisualizationComponent);\ncustomElements.define('fits-component', FITSSettingsComponent);\ncustomElements.define('csv-component', CSVSettingsComponent);\ncustomElements.define('arithmetic-column-component', ArithmeticColumnInput);\n"],"names":[],"sourceRoot":""} \ No newline at end of file diff --git a/pr-preview/pr-12/errors/NoEventSubscriberError.js b/pr-preview/pr-12/errors/NoEventSubscriberError.js new file mode 100644 index 0000000..6fd7527 --- /dev/null +++ b/pr-preview/pr-12/errors/NoEventSubscriberError.js @@ -0,0 +1,6 @@ +export class NoEventSubscriberError extends Error { + constructor(message) { + super(message); + this.name = "NoEventSubscriberError"; + } +} \ No newline at end of file diff --git a/pr-preview/pr-12/events/ArithmeticColumnChangeEvent.js b/pr-preview/pr-12/events/ArithmeticColumnChangeEvent.js new file mode 100644 index 0000000..1e0c8de --- /dev/null +++ b/pr-preview/pr-12/events/ArithmeticColumnChangeEvent.js @@ -0,0 +1,49 @@ +import {RegistryContainer} from "../containers/RegistryContainer"; + +export class ArithmeticColumnChangeEvent { + + static defaultOptions = { + bubbles: true, + composed: true + }; + + static name = "arithmetic-column-change"; + static main_root_id = 'jsvis-main'; + static main_root_element = null; + + event = null; + + constructor(detail = {}, options = {}) { + + this.detail = { ...detail }; + this.options = { ...ArithmeticColumnChangeEvent.defaultOptions, ...options }; + + this.event = new CustomEvent(ArithmeticColumnChangeEvent.name, { + detail: this.detail, + ...this.options + }); + } + + dispatchToTarget(target) { + target.dispatchEvent(this.event); + } + + dispatchToMainRoot() { + if(ArithmeticColumnChangeEvent.main_root_element === null) { + ArithmeticColumnChangeEvent.main_root_element = document.getElementById(ArithmeticColumnChangeEvent.main_root_id); + } + + document.dispatchEvent(this.event); + } + + dispatchToSubscribers() { + let esr = RegistryContainer.getRegistryContainer().getEventSubscribersRegistry(); + let subscribers_id = esr.getSubscribersForEvent(ArithmeticColumnChangeEvent.name); + + let subscriber_element = null; + subscribers_id.forEach((subscriber_id) => { + subscriber_element = document.getElementById(subscriber_id); + subscriber_element.dispatchEvent(this.event); + }) + } +} diff --git a/pr-preview/pr-12/events/FileRegistryChangeEvent.js b/pr-preview/pr-12/events/FileRegistryChangeEvent.js index f376eb6..4a1763a 100644 --- a/pr-preview/pr-12/events/FileRegistryChangeEvent.js +++ b/pr-preview/pr-12/events/FileRegistryChangeEvent.js @@ -1,10 +1,11 @@ import {RegistryContainer} from "../containers/RegistryContainer"; +import {NoEventSubscriberError} from "../errors/NoEventSubscriberError"; export class FileRegistryChangeEvent { static defaultOptions = { bubbles: true, - composed: false + composed: true }; static name = "file-registry-change"; @@ -41,9 +42,15 @@ export class FileRegistryChangeEvent { let subscribers_id = esr.getSubscribersForEvent(FileRegistryChangeEvent.name); let subscriber_element = null; - subscribers_id.forEach((subscriber_id) => { - subscriber_element = document.getElementById(subscriber_id); - subscriber_element.dispatchEvent(this.event); - }) + try { + subscribers_id.forEach((subscriber_id) => { + subscriber_element = document.getElementById(subscriber_id); + subscriber_element.dispatchEvent(this.event); + }) + } catch(e) { + if(subscribers_id.length <= 0) { + throw new NoEventSubscriberError(); + } + } } } diff --git a/pr-preview/pr-12/index.html b/pr-preview/pr-12/index.html index e1f34de..e6e687f 100644 --- a/pr-preview/pr-12/index.html +++ b/pr-preview/pr-12/index.html @@ -92,6 +92,10 @@ width: 100%; } + .spectrum-settings { + display: none; + } + .column-graph { padding: 20px; box-sizing: border-box; @@ -120,6 +124,71 @@ margin-top: 10px; } + #column-main-input { + width: 690px; + height: auto; + background-color: #FFFFFF; + border: 1px solid #000000; + position: relative; + left: -400px; + display: none; + } + + #column-display-list { + list-style: decimal; + } + + #column-display-list button { + margin-left: 5px; + } + + .column-input-container { + display: grid; + grid-template-columns: repeat(2, 1fr); + gap: 10px; + width: 100%; + margin: 0 auto; + padding: 20px; + } + + .column-input-keyboard { + display: grid; + grid-template-columns: repeat(4, 1fr); + gap: 10px; + margin-bottom: 15px; + } + + .button-grid button { + margin-bottom: 5px; + width: 80px; + } + + #input-display { + width: 100%; + height: 40px; + background-color: #FFFFFF; + } + + #input-display input { + width: 100%; + height: 100%; + } + + #column-input-list { + height: 170px; + padding-left: 10px; + padding-right: 10px; + overflow: scroll; + scrollbar-width: thin; + scrollbar-color: rgba(0, 0, 0, 0.5) rgba(0, 0, 0, 0.1); + list-style: none; + border: 1px solid #000000; + } + + #column-input-list li { + cursor: pointer; + } + #select-axis-x-scale { margin-bottom: 10px; } @@ -195,6 +264,10 @@ grid-template-columns: repeat(auto-fit, minmax(50%, 1fr)); } + .visible { + display: block !important; + } + @@ -305,6 +378,15 @@
        HDU Selection
        + +
        +
        +
        Column Creation
        + +
        +
        diff --git a/pr-preview/pr-12/main.js b/pr-preview/pr-12/main.js index ae8a9d2..9409bdf 100644 --- a/pr-preview/pr-12/main.js +++ b/pr-preview/pr-12/main.js @@ -10,6 +10,9 @@ import { FITSSettingsComponent } from './components/file_type/FITSSettingsCompon import { CSVSettingsComponent } from './components/file_type/CSVSettingsComponent.js' import { D3Graph } from "./visualizations/D3Graph"; import { BokehGraph } from "./visualizations/BokehGraph"; +import {FileRegistry} from "./registries/FileRegistry"; +import {RegistryContainer} from "./containers/RegistryContainer"; +import {ArithmeticColumnInput} from "./components/inputs/ArithmeticColumnInput"; let file_path = window.location.href + "_test_files/spiacs_lc_query.fits"; @@ -26,8 +29,11 @@ WrapperContainer.setD3Wrapper(d3_wrapper); VisualizationContainer.setBokehVisualization(new BokehGraph()); VisualizationContainer.setD3Visualization(new D3Graph()); +RegistryContainer.setFileRegistry(new FileRegistry()); + customElements.define('file-component', FileComponent); customElements.define('settings-component', SettingsComponent); customElements.define('visualization-component', VisualizationComponent); customElements.define('fits-component', FITSSettingsComponent); customElements.define('csv-component', CSVSettingsComponent); +customElements.define('arithmetic-column-component', ArithmeticColumnInput); diff --git a/pr-preview/pr-12/registries/EventSubscribersRegistry.js b/pr-preview/pr-12/registries/EventSubscribersRegistry.js index b4683ce..c6e7ec6 100644 --- a/pr-preview/pr-12/registries/EventSubscribersRegistry.js +++ b/pr-preview/pr-12/registries/EventSubscribersRegistry.js @@ -6,8 +6,9 @@ export class EventSubscribersRegistry { 'fits-loaded': ['settings-component', 'file-component'], 'configuration': ['settings-component'], 'file-loaded': ['file-component'], - 'file-selected': ['settings-component'], - 'file-registry-change': ['settings-component', 'file-component'] + 'file-selected': ['settings-component', 'arithmetic-column-component'], + 'file-registry-change': ['settings-component', 'file-component', 'arithmetic-column-component'], + //'arithmetic-column-change': ['settings-component'] } constructor() { diff --git a/pr-preview/pr-12/registries/FileRegistry.js b/pr-preview/pr-12/registries/FileRegistry.js index 7e82dfa..d1379c9 100644 --- a/pr-preview/pr-12/registries/FileRegistry.js +++ b/pr-preview/pr-12/registries/FileRegistry.js @@ -34,6 +34,10 @@ export class FileRegistry { FileRegistry.file_counter++; } + static _addToAvailableFiles(file) { + FileRegistry.available_files.push(file); + } + static moveToAvailableFiles(file) { FileRegistry.available_files.push(file); } @@ -54,6 +58,15 @@ export class FileRegistry { FileRegistry.moveToAvailableFiles(file); } + static getAllFiles() { + let available_files = FileRegistry.getAvailableFilesList(); + let current_files = FileRegistry.getCurrentFilesList(); + + let files = available_files.concat(current_files); + + return files; + } + static getFileById(file_id) { let file_array = [...FileRegistry.available_files, ...FileRegistry.current_files]; @@ -78,6 +91,22 @@ export class FileRegistry { return is_current; } + static setFileMetadata(file_id, metadata) { + let files = FileRegistry.getAllFiles(); + + let file = files.filter(file => file.id !== parseInt(file_id)); + + file = { ...file, ...metadata }; + + if(FileRegistry.isFileCurrent(file_id)) { + FileRegistry.removeFromCurrentFiles(file_id); + FileRegistry.addToCurrentFiles(file); + } else { + FileRegistry.removeFromAvailableFiles(file_id); + FileRegistry._addToAvailableFiles(file); + } + } + static sendRegistryChangeEvent() { let frce = new FileRegistryChangeEvent(); frce.dispatchToSubscribers(); diff --git a/pr-preview/pr-12/utils/ColumnUtils.js b/pr-preview/pr-12/utils/ColumnUtils.js new file mode 100644 index 0000000..61a9726 --- /dev/null +++ b/pr-preview/pr-12/utils/ColumnUtils.js @@ -0,0 +1,19 @@ +export class ColumnUtils { + + static getColumnSettings(column_settings) { + let settings = column_settings.split('$'); + + let column_location = settings[0].split('.'); + let column_name = settings[1] || ''; + + let file_id = column_location[0]; + let hdu_index = column_location.length > 1 ? column_location[1] : ''; + + return { + file_id: file_id, + hdu_index: hdu_index, + column_name: column_name + }; + } + +} \ No newline at end of file diff --git a/pr-preview/pr-12/utils/ExpressionBlock.js b/pr-preview/pr-12/utils/ExpressionBlock.js new file mode 100644 index 0000000..e1189a0 --- /dev/null +++ b/pr-preview/pr-12/utils/ExpressionBlock.js @@ -0,0 +1,47 @@ +import {ExpressionParser} from "./ExpressionParser"; + +export class ExpressionBlock { + + content = null; + + start_pos = null; + stop_pos = null; + + expression_parser = null; + + constructor(block, start, stop) { + this.content = block; + this.start_pos = start; + this.stop_pos = stop; + + this.expression_parser = new ExpressionParser(block); + } + + parseBlock() { + //this.expression_parser.parseExpression(this.content); + + let expression_type = this.isBlockStandard(); + + if(expression_type) { + let result = this.expression_parser.basicExpressionEvaluation(this.content); + } else if(expression_type === false) { + + } else { + + } + } + + isBlockStandard() { + + let expression_type = this.expression_parser.checkExpression(this.content); + + if(expression_type === 'standard') { + return true; + } else if(expression_type === 'custom') { + return false; + } else { + return null; + } + } + +} \ No newline at end of file diff --git a/pr-preview/pr-12/utils/ExpressionParser.js b/pr-preview/pr-12/utils/ExpressionParser.js new file mode 100644 index 0000000..a3cbee4 --- /dev/null +++ b/pr-preview/pr-12/utils/ExpressionParser.js @@ -0,0 +1,79 @@ +export class ExpressionParser { + + static standard_functions = ['Math.sqrt', + 'Math.abs', + 'Math.cos', + 'Math.sin', + 'Math.max', + 'Math.min', + 'Math.pow', + 'Math.log', + 'Math.round' + ]; + + static custom_functions = []; + + expression = null; + blocks = []; + + constructor(expression = null) { + this.expression = expression; + } + + setExpression(expression) { + this.expression = expression; + } + + parseExpression() { + if(this.expression) { + + for(let i = 0; this.expression.length; i++) { + + let curr_char = this.expression[i]; + + } + + } + } + + basicExpressionEvaluation() { + let expression_result = null; + + try { + expression_result = eval(this.expression); + } catch(e) { + + } + + return expression_result; + } + + customExpressionEvaluation() { + + } + + checkExpression() { + + let expression_type = 'standard'; + + const regex_is_operator_number = /[+\-*/0-9.]+/; + + let expression_parts = this.expression.split(/\s+/); + + expression_parts.forEach(part => { + if (!regex_is_operator_number.test(part)) { + if (ExpressionParser.standard_functions.includes(part)) { + + } else if (ExpressionParser.custom_functions.includes(part)) { + expression_type = 'custom'; + } else { + expression_type = null; + return expression_type; + } + } + }); + + return expression_type; + } + +} \ No newline at end of file diff --git a/pr-preview/pr-12/visualizations/D3Graph.js b/pr-preview/pr-12/visualizations/D3Graph.js index 7af566d..905b402 100644 --- a/pr-preview/pr-12/visualizations/D3Graph.js +++ b/pr-preview/pr-12/visualizations/D3Graph.js @@ -83,10 +83,12 @@ export class D3Graph { this.x_scale_type = scales['x']; this.y_scale_type = scales['y']; - if (error_bars) { + if(error_bars) { this.has_error_bars = true; this.error_bars = error_bars; + console.log(error_bars); + this.x_axis_data_col_error_bar = axis['x'].value; this.y_axis_data_col_error_bar = axis['y'].value; @@ -267,34 +269,35 @@ export class D3Graph { this.error_bars = error_bars; - let error_bar_x = {x: error_bars.x}; - - let line_error_bar_x = d3.line() - .x(d => this.x_scale(d[this.x_axis_data_col])) - .y(d => this.y_scale(d.bound)); - - error_bars.x.forEach((error_bar) => { - d3.select('#data-plot').append("path") - .attr("class", "error-bar-x") - .attr("fill", "none") - .attr("stroke", "steelblue") - .attr("stroke-width", 1.5) - .attr("d", line_error_bar_x(error_bar)); - }) - - let line_error_bar_y = d3.line() - .x(d => this.x_scale(d.bound)) - .y(d => this.y_scale(d[this.y_axis_data_col])); - - error_bars.y.forEach((error_bar) => { - d3.select('#data-plot').append("path") - .attr("class", "error-bar-x") - .attr("fill", "none") - .attr("stroke", "steelblue") - .attr("stroke-width", 1.5) - .attr("d", line_error_bar_y(error_bar)); - }) + if(error_bars.y) { + let line_error_bar_x = d3.line() + .x(d => this.x_scale(d[this.x_axis_data_col])) + .y(d => this.y_scale(d.bound)); + + error_bars.y.forEach((error_bar) => { + d3.select('#data-plot').append("path") + .attr("class", "error-bar-x") + .attr("fill", "none") + .attr("stroke", "steelblue") + .attr("stroke-width", 1.5) + .attr("d", line_error_bar_x(error_bar)); + }) + } + if(error_bars.x) { + let line_error_bar_y = d3.line() + .x(d => this.x_scale(d.bound)) + .y(d => this.y_scale(d[this.y_axis_data_col])); + + error_bars.x.forEach((error_bar) => { + d3.select('#data-plot').append("path") + .attr("class", "error-bar-x") + .attr("fill", "none") + .attr("stroke", "steelblue") + .attr("stroke-width", 1.5) + .attr("d", line_error_bar_y(error_bar)); + }) + } } _setAxisLine() { @@ -373,31 +376,35 @@ export class D3Graph { if(this.has_error_bars) { - let line_error_bar_x = d3.line() - .x(d => rescaled_x(d[this.x_axis_data_col])) - .y(d => rescaled_y(d.bound)); - - this.error_bars.x.forEach((error_bar) => { - d3.select('#data-plot').append("path") - .attr("class", "error-bar-x") - .attr("fill", "none") - .attr("stroke", "steelblue") - .attr("stroke-width", 1.5) - .attr("d", line_error_bar_x(error_bar)); - }) - - let line_error_bar_y = d3.line() - .x(d => rescaled_x(d.bound)) - .y(d => rescaled_y(d[this.y_axis_data_col])); + if(this.error_bars.y) { + let line_error_bar_x = d3.line() + .x(d => rescaled_x(d[this.x_axis_data_col])) + .y(d => rescaled_y(d.bound)); + + this.error_bars.y.forEach((error_bar) => { + d3.select('#data-plot').append("path") + .attr("class", "error-bar-x") + .attr("fill", "none") + .attr("stroke", "steelblue") + .attr("stroke-width", 1.5) + .attr("d", line_error_bar_x(error_bar)); + }) + } - this.error_bars.y.forEach((error_bar) => { - d3.select('#data-plot').append("path") - .attr("class", "error-bar-x") - .attr("fill", "none") - .attr("stroke", "steelblue") - .attr("stroke-width", 1.5) - .attr("d", line_error_bar_y(error_bar)); - }) + if(this.error_bars.x) { + let line_error_bar_y = d3.line() + .x(d => rescaled_x(d.bound)) + .y(d => rescaled_y(d[this.y_axis_data_col])); + + this.error_bars.x.forEach((error_bar) => { + d3.select('#data-plot').append("path") + .attr("class", "error-bar-x") + .attr("fill", "none") + .attr("stroke", "steelblue") + .attr("stroke-width", 1.5) + .attr("d", line_error_bar_y(error_bar)); + }) + } } } diff --git a/pr-preview/pr-12/webpack.dev.js b/pr-preview/pr-12/webpack.dev.js index bdadfee..ad160d3 100644 --- a/pr-preview/pr-12/webpack.dev.js +++ b/pr-preview/pr-12/webpack.dev.js @@ -15,7 +15,7 @@ module.exports = { devtool: 'inline-source-map', watch: true, watchOptions: { - aggregateTimeout: 600, + aggregateTimeout: 800, ignored: ['dist/**', '_vendors/**', '_test_files/**', '_old/**'], }, }; \ No newline at end of file diff --git a/pr-preview/pr-12/wrappers/BokehWrapper.js b/pr-preview/pr-12/wrappers/BokehWrapper.js index 5182017..a7931e7 100644 --- a/pr-preview/pr-12/wrappers/BokehWrapper.js +++ b/pr-preview/pr-12/wrappers/BokehWrapper.js @@ -108,10 +108,7 @@ export class BokehWrapper { let processed_data = dpp.getProcessedDataset(dataset_settings); - let processed_json_data = dpp.datasetToJSONData(processed_data); - let data_type = this.settings_object.getDataTypeSettings(); - let hdu = this.settings_object.getHDUsSettings(); let scales = this.settings_object.getScalesSettings(); @@ -126,6 +123,25 @@ export class BokehWrapper { let data = {x: processed_data.axis[0].data, y: processed_data.axis[1].data}; if(error_bars) { + + console.log(processed_data.error_bars); + + let error_bars_object = {}; + + processed_data.error_bars.forEach((error_bar) => { + error_bar.data = error_bar.data.map(value => !isFinite(value) ? 0 : value); + error_bar.data = error_bar.data.map(value => isNaN(value) ? 0 : value); + + error_bars_object[error_bar.axis] = error_bar.column_name; + + if(error_bar.axis === 'x') { + data.dx = error_bar.data; + } else if(error_bar.axis === 'y') { + data.dy = error_bar.data; + } + }) + + /* error_bars = {x: processed_data.error_bars[0].column_name, y: processed_data.error_bars[1].column_name}; processed_data.error_bars[0].data = processed_data.error_bars[0].data.map(value => !isFinite(value) ? 0 : value); @@ -133,6 +149,7 @@ export class BokehWrapper { data.dx = processed_data.error_bars[0].data.map(value => isNaN(value) ? 0 : value); data.dy = processed_data.error_bars[1].data.map(value => isNaN(value) ? 0 : value); + */ let asymmetric_uncertainties = false; @@ -146,7 +163,6 @@ export class BokehWrapper { } let ranges = this.settings_object.getRangesSettings(); - let has_custom_range = false; let custom_range_data = null; if(ranges != null) { @@ -168,29 +184,6 @@ export class BokehWrapper { } } - getProcessedData(data_type, hdu_index, axis, error_bars) { - let data = null; - - let dpc = DataProcessorContainer.getDataProcessorContainer(); - let data_processor; - - let frw = WrapperContainer.getFITSReaderWrapper(); - - if(data_type === 'light-curve') { - data_processor = dpc.getLightCurveProcessor(frw, hdu_index); - } else if(data_type === 'spectrum') { - data_processor = dpc.getSpectrumProcessor(frw, hdu_index); - } - - data = data_processor.processDataRawJSON(axis, error_bars); - - if(error_bars) { - data = this._processErrorBarData(data); - } - - return data; - } - _getColumnSettings(column_settings) { let settings = column_settings.split('$'); @@ -215,6 +208,38 @@ export class BokehWrapper { div_factor = 1; } + if(data.dx) { + let x_low = []; + let x_up = []; + + for(let i in data.dx) { + x_low[i] = data.x[i] - data.dx[i] / div_factor; + x_up[i] = data.x[i] + data.dx[i] / div_factor; + } + + data.x_low = x_low; + data.x_up = x_up; + + delete data.dx; + } + + if(data.dy) { + let y_low = []; + let y_up = []; + + for(let i in data.dy) { + y_low[i] = data.y[i] - data.dy[i]; + y_up[i] = data.y[i] + data.dy[i]; + } + + data.y_low = y_low; + data.y_up = y_up; + + delete data.dy; + + } + + /* let y_low = [], y_up = [], x_low = [], x_up = []; for (let i in data.dy) { @@ -231,6 +256,7 @@ export class BokehWrapper { delete data.dy; delete data.dx; + */ return data; } diff --git a/pr-preview/pr-12/wrappers/D3Wrapper.js b/pr-preview/pr-12/wrappers/D3Wrapper.js index 618064c..b52128e 100644 --- a/pr-preview/pr-12/wrappers/D3Wrapper.js +++ b/pr-preview/pr-12/wrappers/D3Wrapper.js @@ -105,8 +105,13 @@ export class D3Wrapper { axis = {x: processed_data.axis[0].column_name, y: processed_data.axis[1].column_name}; if(has_error_bars) { - error_bars = {x: processed_data.error_bars[0].column_name, y: processed_data.error_bars[1].column_name}; - error_bars = dpp.processErrorBarDataJSON(processed_json_data, axis, error_bars) + let error_bars_object = {}; + + processed_data.error_bars.forEach((error_bar) => { + error_bars_object[error_bar.axis] = error_bar.column_name; + }) + + error_bars = dpp.processErrorBarDataJSON(processed_json_data, axis, error_bars_object) } if(ranges != null) { diff --git a/pr-preview/pr-12/wrappers/FITSReaderWrapper.js b/pr-preview/pr-12/wrappers/FITSReaderWrapper.js index c084eaf..e70ac98 100644 --- a/pr-preview/pr-12/wrappers/FITSReaderWrapper.js +++ b/pr-preview/pr-12/wrappers/FITSReaderWrapper.js @@ -14,6 +14,7 @@ export class FITSReaderWrapper { constructor(file_path = null) { if(file_path) { + console.log(file_path); if (FITSReaderWrapper.is_path_valid(file_path)) { this.file_path = file_path; this._getFile() @@ -69,6 +70,12 @@ export class FITSReaderWrapper { this.file = file; } + setFileFromFileObject(file_object) { + this.file = file_object.file; + this.arf_file = file_object.arf_file_id; + this.rmf_file = file_object.rmf_file_id; + } + getHDU(hdu_index) { if(hdu_index >= 0 && hdu_index < this.file.hdus.length) { return this.file.hdus[hdu_index]; @@ -340,6 +347,15 @@ export class FITSReaderWrapper { frw.setFile(ancrfile.file); } + } else if(this.arf_file) { + + let ancrfile = FileRegistry.getFileById(this.arf_file); + + if(ancrfile !== undefined) { + let frw = new FITSReaderWrapper(); + frw.setFile(ancrfile.file); + } + } if(hdu.header.get('RESPFILE') !== null) { @@ -395,8 +411,59 @@ export class FITSReaderWrapper { }) } - } + } else if(this.rmf_file) { + let respfile = FileRegistry.getFileById(this.rmf_file); + + if(respfile !== undefined) { + let frw = new FITSReaderWrapper(); + + frw.setFile(respfile.file); + + let hdus_index = frw.getTabularHDUs(); + + let has_e_min_max = false; + hdus_index.forEach((hdu_index) => { + let columns_name = frw.getColumnsNameFromHDU(hdu_index); + if (columns_name.includes("E_MIN") && columns_name.includes("E_MAX")) { + has_e_min_max = true; + let e_min_max_hdus_index = hdu_index; + + let column = { + name: 'E_HALF_WIDTH', + hdu_index: hdu_index, + is_from_header: false, + is_processed: true, + from_file: respfile.id + } + + columns.push(column); + + column = { + name: 'E_MID', + hdu_index: hdu_index, + is_from_header: false, + is_processed: true, + from_file: respfile.id + } + + columns.push(column); + + column = { + name: 'E_MID_LOG', + hdu_index: hdu_index, + is_from_header: false, + is_processed: true, + from_file: respfile.id + } + + columns.push(column); + + } + }) + + } + } } })