@gorilla-engine-sdk/ge-session-presets-lib 0.5.13

package/dist/PresetManager.js

@@ -0,0 +1,590 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresetManager = void 0;
+const { platform } = require('os');
+const fs = require("fs-extra");
+const path = require("path");
+const crypto = require("crypto");
+const SessionAndPresetsError_1 = require("./errors/SessionAndPresetsError");
+const utils_1 = require("./utils/utils");
+const _1 = require(".");
+class PresetManager {
+    config;
+    state;
+    _isLoadingSession = false;
+    get isLoadingSession() {
+        return this._isLoadingSession;
+    }
+    _loadedSession = false;
+    get loadedSession() {
+        return this._loadedSession;
+    }
+    get sessionInvolved() {
+        return this._isLoadingSession || this._loadedSession;
+    }
+    _isDirtySessionLoad = false;
+    get isDirtySessionLoad() {
+        return this._isDirtySessionLoad;
+    }
+    set isDirtySessionLoad(dirty) {
+        if (this.config.debug)
+            console.log(`${_1.GE_SESSION_PRESETS_LIB} PresetManager: set isDirtySessionLoad: ${dirty}`);
+        this._isDirtySessionLoad = dirty;
+    }
+    _sessionCount = 0;
+    get sessionCount() {
+        return this._sessionCount;
+    }
+    incrementSessionCount() {
+        this._sessionCount++;
+    }
+    constructor(config) {
+        this.config = config;
+    }
+    setState(state) {
+        this.state = state;
+    }
+    getInstrument() {
+        return this.state?.instrument;
+    }
+    saveSession(additionalStateString, preset) {
+        if (this.config.debug)
+            console.debug(`${_1.GE_SESSION_PRESETS_LIB} PresetManager: saveSession`);
+        if (!this.getInstrument()) {
+            if (this.config.debug)
+                console.log(`${_1.GE_SESSION_PRESETS_LIB} PresetManager: No Instrument Loaded!!!`);
+            return additionalStateString;
+        }
+        if (!this.state) {
+            return additionalStateString;
+        }
+        let stateToSave = this.createPreset(true);
+        if (this.config.retainUIScale) {
+            try {
+                stateToSave['uiScale'] = GorillaEngine.UI.getControlById('root')['uiScale'];
+            }
+            catch (err) { }
+        }
+        // add the current preset path to session
+        stateToSave['preset'] = preset?.filePath;
+        if (this.config.debug)
+            console.debug(`${_1.GE_SESSION_PRESETS_LIB} PresetManager: saveSession  stateToSave['preset']: ${stateToSave['preset']}`);
+        stateToSave['workingState'] = {
+            presetChanged: this.state.presetChanged,
+            presetChangeLog: this.state.presetChangeLog,
+        };
+        /// no sessionId yet? -> generate uuid and save
+        if (!this.state.sessionId) {
+            const uuid = crypto.randomUUID();
+            if (this.config.debug)
+                console.debug(`${_1.GE_SESSION_PRESETS_LIB} PresetManager: saveSession no sessionId generated yet, use ${uuid}`);
+            Object.assign(this.state, { sessionId: uuid });
+        }
+        /// always add to save
+        Object.assign(stateToSave, { sessionId: this.state.sessionId });
+        const additionalState = JSON.parse(additionalStateString);
+        Object.assign(additionalState, stateToSave);
+        for (const hookIn of this._additionalSaveSession)
+            hookIn(this.getInstrument(), additionalState);
+        return JSON.stringify(additionalState);
+    }
+    registerLoadSession(stateString) {
+        return stateString;
+    }
+    async loadSession(stateJSON) {
+        if (this.config.debug)
+            console.debug(`${_1.GE_SESSION_PRESETS_LIB} PresetManager: loadSession`);
+        this._isDirtySessionLoad = false;
+        try {
+            this._isLoadingSession = true;
+            for (const hookIn of this._additionalPreLoadSession)
+                await hookIn(this.getInstrument(), stateJSON);
+            if (this.config.debug)
+                console.debug(`${_1.GE_SESSION_PRESETS_LIB} PresetManager: loadSession - FINISHED PRE-HOOK-INS`);
+            await this.loadPreset(stateJSON, undefined, true);
+            let midiAssignments = stateJSON['additionalState']?.midiAssignments;
+            if (midiAssignments && this.getInstrument())
+                this.getInstrument().setMIDICCstate(midiAssignments);
+            for (const hookIn of this._additionalLoadSession)
+                await hookIn(this.getInstrument(), stateJSON, this._isDirtySessionLoad);
+            if (this.config.retainUIScale && stateJSON['uiScale'])
+                try {
+                    GorillaEngine.UI.getControlById('root')['uiScale'] = stateJSON['uiScale'];
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            this._isLoadingSession = false;
+            this._loadedSession = true;
+            if (this.config.debug)
+                console.debug(`${_1.GE_SESSION_PRESETS_LIB} PresetManager: loadSession - FINISHED`);
+            return stateJSON;
+        }
+        catch (err) {
+            this._isLoadingSession = false;
+            this._loadedSession = false;
+            if (this.config.debug)
+                console.error(err);
+            if (err instanceof SessionAndPresetsError_1.SessionAndPresetsError)
+                throw err;
+            else
+                throw new SessionAndPresetsError_1.SessionAndPresetsError(SessionAndPresetsError_1.SessionAndPresetsErrorTypes.loadingSession, 'Error loading session!', `The session could not be restored. ${err}`, { cause: err });
+        }
+    }
+    async loadPresets(dirs) {
+        if (this.config.debug)
+            console.debug(`${_1.GE_SESSION_PRESETS_LIB} PresetManager: loadPresets`);
+        const presets = [];
+        const lp = async (dir, baseDir) => {
+            try {
+                fs.ensureDirSync(dir.path, {
+                    recursive: true,
+                });
+                const files = await fs.readdir(dir.path);
+                if (!files.length)
+                    return;
+                for (const file of files) {
+                    const fullPath = path.join(dir.path, file);
+                    if (fs.lstatSync(fullPath).isDirectory()) {
+                        await lp({
+                            path: fullPath,
+                            type: dir.type,
+                            additionalData: dir.additionalData,
+                        }, baseDir);
+                    }
+                    else {
+                        if (path.basename(fullPath, path.extname(fullPath)) !== '.DS_Store') {
+                            const preset = await this.createPresetItem(file, dir, dir.path, baseDir);
+                            presets.push(preset);
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                if (err instanceof SessionAndPresetsError_1.SessionAndPresetsError)
+                    throw err;
+                else
+                    throw new SessionAndPresetsError_1.SessionAndPresetsError(SessionAndPresetsError_1.SessionAndPresetsErrorTypes.presetsLoading, 'Presets Loading Error!!', `An error occured trying to load presets. ${err}`, { cause: err });
+            }
+        };
+        for (const dir of dirs)
+            await lp(dir, dir.path);
+        return presets;
+    }
+    async createPresetItem(file, dir, presetsDir, baseDir) {
+        let category;
+        if (presetsDir.replace(baseDir, '') !== '') {
+            category = presetsDir
+                .replace(baseDir, '')
+                .substring(1)
+                .replace(platform() === 'win32' ? /\\/g : '/', '|');
+        }
+        const fullPath = path.join(presetsDir, file);
+        const preset = {
+            uuid: (0, utils_1.createHash)(fullPath),
+            type: dir.type,
+            filePath: fullPath,
+            fileName: path.basename(fullPath),
+            name: `${path.basename(fullPath, path.extname(fullPath))}`,
+            subFolderPath: presetsDir.replace(baseDir, '').substring(1),
+            category: category,
+            additionalData: structuredClone(dir.additionalData),
+        };
+        for (const hookIn of this._additionalCreatePresetItem)
+            await hookIn(preset);
+        return preset;
+    }
+    /*
+      PRESET LOADING
+    */
+    async loadPreset(presetObj, presetItem, sessionRestore = false, isInitialPreset = false) {
+        if (this.config.debug)
+            console.debug(`${_1.GE_SESSION_PRESETS_LIB} PresetManager: loadPreset sessionRestore: ${sessionRestore} isInitialPreset: ${isInitialPreset} - START`);
+        for (const hookIn of this._additionalPreLoadPreset) {
+            if (isInitialPreset && this.sessionInvolved) {
+                this.isDirtySessionLoad = true;
+                break;
+            }
+            await hookIn(this.getInstrument(), presetObj, presetItem, sessionRestore);
+        }
+        if (isInitialPreset && this.sessionInvolved) {
+            this.isDirtySessionLoad = true;
+            return false;
+        }
+        this.applyPresetInstrumentState(this.getInstrument(), presetObj.dsp_settings, sessionRestore, isInitialPreset);
+        for (const hookIn of this._additionalLoadPreset) {
+            if (isInitialPreset && this.sessionInvolved) {
+                this.isDirtySessionLoad = true;
+                break;
+            }
+            await hookIn(this.getInstrument(), presetObj, sessionRestore);
+        }
+        return true;
+    }
+    async loadPresetFromSource(source, isInitialPreset = false, instStateToRetain) {
+        // chack if youre (filePath) exists
+        if (await fs.exists(source)) {
+            // Find preset
+            const preset = this.state.presets.find((item) => item.filePath === source);
+            // Read preset file
+            const fileAsString = await fs.readFile(source, 'utf8');
+            const parsedPreset = JSON.parse(fileAsString);
+            if (isInitialPreset && this.sessionInvolved)
+                return;
+            for (const hookIn of this._additionalPreLoadPresetFromSource) {
+                if (isInitialPreset && this.sessionInvolved) {
+                    this.isDirtySessionLoad = true;
+                    break;
+                }
+                await hookIn(this.getInstrument(), preset, parsedPreset, isInitialPreset);
+            }
+            if (isInitialPreset && this.sessionInvolved) {
+                this.isDirtySessionLoad = true;
+                return;
+            }
+            if (instStateToRetain && instStateToRetain.length > 0) {
+                const dspSettings = parsedPreset['dsp_settings'];
+                for (let i = 0; i < instStateToRetain.length; i++) {
+                    const findItem = (item) => item.key === instStateToRetain[i].key;
+                    const parsedPresetItem = dspSettings.find(findItem);
+                    // if it does not exist in preset data, add it. Could be a property not flagged to retain
+                    if (!parsedPresetItem) {
+                        dspSettings.push(instStateToRetain[i]);
+                    }
+                    else {
+                        const itemIndex = dspSettings.findIndex(findItem);
+                        dspSettings[itemIndex] = instStateToRetain[i];
+                    }
+                }
+            }
+            await this.loadPreset(parsedPreset, preset, false, isInitialPreset);
+            for (const hookIn of this._additionalLoadPresetFromSource) {
+                if (isInitialPreset && this.sessionInvolved) {
+                    this.isDirtySessionLoad = true;
+                    break;
+                }
+                await hookIn(this.getInstrument(), preset, parsedPreset, isInitialPreset);
+            }
+            return true;
+        }
+        else {
+            throw new SessionAndPresetsError_1.SessionAndPresetsError(SessionAndPresetsError_1.SessionAndPresetsErrorTypes.presetFileNotFound, `Unable to load preset!`, `The preset to be loaded could not be found. ${source}`, { source: source });
+        }
+    }
+    /*
+      PRESET CREATION
+     */
+    createPreset(sessionRestore = false) {
+        //if(this.config.debug) console.debug(`PresetManager: createPreset sessionRestore: ${sessionRestore}`);
+        try {
+            // the preset object
+            const presetObj = {
+                general: this.createPresetHeader(),
+                dsp_settings: this.createPresetInstrumentState(this.getInstrument(), sessionRestore),
+            };
+            for (const hookIn of this._additionalCreatePreset)
+                hookIn(this.getInstrument(), presetObj, sessionRestore);
+            return presetObj;
+        }
+        catch (err) {
+            if (this.config.debug)
+                console.error(err);
+            if (err instanceof SessionAndPresetsError_1.SessionAndPresetsError)
+                throw err;
+            else
+                throw new SessionAndPresetsError_1.SessionAndPresetsError(SessionAndPresetsError_1.SessionAndPresetsErrorTypes.presetCreation, 'Presets Creation Error!', `An error occured trying to create the preset. ${err}`, { cause: err, sessionRestore: sessionRestore });
+        }
+    }
+    createPresetHeader() {
+        return {
+            pluginVersion: GorillaEngine.getBuildInformation().version,
+            buildNumber: GorillaEngine.getBuildInformation().buildNumber,
+            manufacturer: GorillaEngine.getManufacturerName(),
+            pluginName: GorillaEngine.getPluginName(),
+            date: new Date(),
+        };
+    }
+    createPresetInstrumentState(instrument, sessionRestore) {
+        const instState = [];
+        for (const key in this.getInstrument()) {
+            const p = this.getInstrument()[key];
+            if (p instanceof Function) {
+            }
+            else if (p !== undefined && p !== null) {
+                if (p.persistence &&
+                    (sessionRestore ? p.persistence.saveInSession : p.persistence.saveInPreset)) {
+                    const saveProps = this.getInstrumentParam(this.getInstrument(), key, sessionRestore);
+                    if (saveProps)
+                        instState.push(saveProps);
+                }
+            }
+        }
+        return instState;
+    }
+    getInstrumentParam(instrument, key, sessionRestore) {
+        const p = this.getInstrument()[key];
+        if (p.persistence &&
+            (sessionRestore ? p.persistence.saveInSession : p.persistence.saveInPreset)) {
+            const saveProps = {
+                key: key,
+                controlType: p.controlType,
+                normValue: p.normValue,
+                value: p.value,
+                valueText: p.text,
+                maxValue: p.maxValue,
+                minValue: p.minValue,
+                resolution: p.resolution,
+            };
+            if (p.steps.length > 0) {
+                saveProps['isArray'] = true;
+                saveProps['stepsLength'] = p.steps.length;
+            }
+            for (const hookIn of this._additionalGetInstrumentParam)
+                hookIn(this.getInstrument(), key, saveProps, sessionRestore);
+            return saveProps;
+        }
+        return false;
+    }
+    applyPresetInstrumentState(instrument, instStateFromPreset, sessionRestore, isInitialPreset = false) {
+        if (this.config.debug)
+            console.debug(`${_1.GE_SESSION_PRESETS_LIB} PresetManager: applyPresetInstrumentState sessionRestore: ${sessionRestore} isLoadingSession: ${this._isLoadingSession} loadedSession: ${this._loadedSession}`);
+        if (!Array.isArray(instStateFromPreset)) {
+            if (this.config.debug)
+                console.error(`PresetManager: applyPresetInstrumentState - malformed state`);
+            if (this.config.debug)
+                console.error(instStateFromPreset);
+            /*throw new SessionAndPresetsError(
+              SessionAndPresetsErrorTypes.presetInstrumentFormat,
+              'Preset Format Error',
+              `The instrument state ot this preset is not compatible with the parsing alogrithm! `
+            );*/
+            return;
+        }
+        let startedRecalling = false;
+        try {
+            const recallFirst = Object.keys(this.getInstrument()).filter((prop) => this.getInstrument()[prop].persistence &&
+                (sessionRestore
+                    ? this.getInstrument()[prop].persistence.saveInSession
+                    : this.getInstrument()[prop].persistence.saveInPreset) &&
+                this.getInstrument()[prop].persistence.recallFirst);
+            const recallLast = Object.keys(this.getInstrument()).filter((prop) => this.getInstrument()[prop].persistence &&
+                (sessionRestore
+                    ? this.getInstrument()[prop].persistence.saveInSession
+                    : this.getInstrument()[prop].persistence.saveInPreset) &&
+                this.getInstrument()[prop].persistence.recallLast);
+            this.getInstrument().startRecallingParameterState();
+            startedRecalling = true;
+            for (const param of recallFirst) {
+                this.setInstrumentParam(this.getInstrument(), instStateFromPreset, param, sessionRestore, isInitialPreset);
+            }
+            for (const key in this.getInstrument()) {
+                if (this.getInstrument()[key] instanceof Function) {
+                }
+                else if (!recallFirst.find((k) => k === key) && !recallLast.find((k) => k === key)) {
+                    this.setInstrumentParam(this.getInstrument(), instStateFromPreset, key, sessionRestore, isInitialPreset);
+                }
+            }
+            for (const param of recallLast) {
+                this.setInstrumentParam(this.getInstrument(), instStateFromPreset, param, sessionRestore, isInitialPreset);
+            }
+            this.getInstrument().endRecallingParameterState();
+        }
+        catch (err) {
+            if (this.getInstrument() && startedRecalling)
+                this.getInstrument().endRecallingParameterState();
+            if (this.config.debug)
+                console.error(err);
+            throw new SessionAndPresetsError_1.SessionAndPresetsError(SessionAndPresetsError_1.SessionAndPresetsErrorTypes.applyInstrumentState, 'Error Applying Instrument State!', `Could not apply instrument state stored in preset.`, { cause: err, instStateFromPreset: instStateFromPreset });
+        }
+        if (this.config.debug)
+            console.debug(`${_1.GE_SESSION_PRESETS_LIB} PresetManager: applyPresetInstrumentState sessionRestore: ${sessionRestore} isLoadingSession: ${this._isLoadingSession} loadedSession: ${this._loadedSession} - FINISHED`);
+    }
+    setInstrumentParam(instrument, instStateFromPreset, key, sessionRestore, isInitialPreset = false) {
+        if (isInitialPreset && this.sessionInvolved) {
+            this.isDirtySessionLoad = true;
+            if (this.config.debug)
+                console.debug(`${_1.GE_SESSION_PRESETS_LIB} PresetManager: setInstrumentParam sessionRestore: ${sessionRestore} isLoadingSession: ${this._isLoadingSession} loadedSession: ${this._loadedSession} - ABORT & FLAG SESSION DIRTY`);
+            return;
+        }
+        const instProperty = this.getInstrument()[key];
+        if (!instProperty)
+            return;
+        if (instProperty.persistence &&
+            (sessionRestore
+                ? instProperty.persistence.saveInSession
+                : instProperty.persistence.saveInPreset)) {
+            const presetProperty = instStateFromPreset.find((item) => item.key === key);
+            if (presetProperty && Object.keys(presetProperty).length === 4) {
+                // old preset format
+                instProperty.normValueAsync = presetProperty.value;
+            }
+            else if (presetProperty) {
+                // if key exists in preset
+                if (presetProperty.isArray) {
+                    // if property contains array/steps
+                    const valueIndex = instProperty.steps.indexOf(presetProperty.valueText);
+                    if (valueIndex >= 0) {
+                        // found in array
+                        instProperty.valueAsync = valueIndex;
+                    }
+                    else {
+                        instProperty.normValueAsync = presetProperty.normValue;
+                    }
+                }
+                else if (instProperty.minValue !== presetProperty.minValue ||
+                    instProperty.maxValue !== presetProperty.maxValue) {
+                    // min or max value differ between inst & preset, set value instead of normValue FOR NOW!
+                    instProperty.valueAsync = presetProperty.value;
+                }
+                else {
+                    instProperty.normValueAsync = presetProperty.normValue;
+                }
+            }
+            else {
+                // if not exist in preset, write default value
+                instProperty.normValueAsync = instProperty.defaultValue;
+            }
+            for (const hookIn of this._additionalSetInstrumentParam) {
+                if (isInitialPreset && this.sessionInvolved) {
+                    this.isDirtySessionLoad = true;
+                    return;
+                }
+                hookIn(this.getInstrument(), key, presetProperty, sessionRestore);
+            }
+        }
+    }
+    /*
+      SAVING & DELETING OF PRESET
+     */
+    async savePreset(filePath) {
+        const fileObj = {
+            filePath: filePath,
+        };
+        if (this.config.debug)
+            console.debug(`${_1.GE_SESSION_PRESETS_LIB} PresetManager: savePreset filePath: ${fileObj.filePath}`);
+        for (const hookIn of this._additionalPreSavePreset)
+            await hookIn(this.getInstrument(), fileObj);
+        const preset = await this.createPreset(false);
+        try {
+            await fs.outputFile(filePath, JSON.stringify(preset));
+            for (const hookIn of this._additionalSavePreset)
+                await hookIn(this.getInstrument(), preset, fileObj);
+        }
+        catch (err) {
+            if (err instanceof SessionAndPresetsError_1.SessionAndPresetsError)
+                throw err;
+            else
+                throw new SessionAndPresetsError_1.SessionAndPresetsError(SessionAndPresetsError_1.SessionAndPresetsErrorTypes.presetSaving, 'Presets Saving Error!', `The preset could not be saved. ${filePath} ${err}`, { cause: err, filePath: filePath, preset: preset });
+        }
+    }
+    async saveAsPreset(filePath) { }
+    async deletePreset(filePath) {
+        if (this.config.debug)
+            console.debug(`${_1.GE_SESSION_PRESETS_LIB} PresetManager: deletePreset filePath: ${filePath}`);
+        fs.unlinkSync(filePath);
+        //if (this._additionalDeletePreset) await this._additionalDeletePreset(instrument)
+    }
+    /*
+    Additional Hook-In Logic
+    */
+    _additionalSaveSession = [];
+    setAdditionalSaveSession(additionalSaveSession) {
+        this._additionalSaveSession.push(additionalSaveSession);
+    }
+    removeAdditionalSaveSession(additionalSaveSession) {
+        this._additionalSaveSession.splice(this._additionalSaveSession.indexOf(additionalSaveSession), 1);
+    }
+    _additionalPreLoadSession = [];
+    setAdditionalPreLoadSession(additionalPreLoadSession) {
+        this._additionalPreLoadSession.push(additionalPreLoadSession);
+    }
+    removeAdditionalPreLoadSession(additionalPreLoadSession) {
+        this._additionalPreLoadSession.splice(this._additionalPreLoadSession.indexOf(additionalPreLoadSession), 1);
+    }
+    _additionalLoadSession = [];
+    setAdditionalLoadSession(additionalLoadSession) {
+        this._additionalLoadSession.push(additionalLoadSession);
+    }
+    removeAdditionalLoadSession(additionalLoadSession) {
+        this._additionalLoadSession.splice(this._additionalLoadSession.indexOf(additionalLoadSession), 1);
+    }
+    _additionalCreatePresetItem = [];
+    setAdditionalCreatePresetItem(additionalCreatePresetItem) {
+        this._additionalCreatePresetItem.push(additionalCreatePresetItem);
+    }
+    removeAdditionalCreatePresetItem(additionalCreatePresetItem) {
+        this._additionalCreatePresetItem.splice(this._additionalCreatePresetItem.indexOf(additionalCreatePresetItem), 1);
+    }
+    _additionalPreLoadPreset = [];
+    setAdditionalPreLoadPreset(additionalPreLoadPreset) {
+        this._additionalPreLoadPreset.push(additionalPreLoadPreset);
+    }
+    removeAdditionalPreLoadPreset(additionalPreLoadPreset) {
+        this._additionalPreLoadPreset.splice(this._additionalPreLoadPreset.indexOf(additionalPreLoadPreset), 1);
+    }
+    _additionalLoadPreset = [];
+    setAdditionalLoadPreset(additionalLoadPreset) {
+        this._additionalLoadPreset.push(additionalLoadPreset);
+    }
+    removeAdditionalLoadPreset(additionalLoadPreset) {
+        this._additionalLoadPreset.splice(this._additionalLoadPreset.indexOf(additionalLoadPreset), 1);
+    }
+    _additionalPreLoadPresetFromSource = [];
+    setAdditionalPreLoadPresetFromSource(additionalPreLoadPresetFromSource) {
+        this._additionalPreLoadPresetFromSource.push(additionalPreLoadPresetFromSource);
+    }
+    removeAdditionalPreLoadPresetFromSource(additionalPreLoadPresetFromSource) {
+        this._additionalPreLoadPresetFromSource.splice(this._additionalPreLoadPresetFromSource.indexOf(additionalPreLoadPresetFromSource), 1);
+    }
+    _additionalLoadPresetFromSource = [];
+    setAdditionalLoadPresetFromSource(additionalLoadPresetFromSource) {
+        this._additionalLoadPresetFromSource.push(additionalLoadPresetFromSource);
+    }
+    removeAdditionalLoadPresetFromSource(additionalLoadPresetFromSource) {
+        this._additionalLoadPresetFromSource.splice(this._additionalLoadPresetFromSource.indexOf(additionalLoadPresetFromSource), 1);
+    }
+    _additionalCreatePreset = [];
+    setAdditionalCreatePreset(additionalCreatePreset) {
+        this._additionalCreatePreset.push(additionalCreatePreset);
+    }
+    removeAdditionalCreatePreset(additionalCreatePreset) {
+        this._additionalCreatePreset.splice(this._additionalCreatePreset.indexOf(additionalCreatePreset), 1);
+    }
+    _additionalGetInstrumentParam = [];
+    setAdditionalGetInstrumentParam(additionalGetInstrumentParam) {
+        this._additionalGetInstrumentParam.push(additionalGetInstrumentParam);
+    }
+    removeAdditionalGetInstrumentParam(additionalGetInstrumentParam) {
+        this._additionalGetInstrumentParam.splice(this._additionalGetInstrumentParam.indexOf(additionalGetInstrumentParam), 1);
+    }
+    _additionalSetInstrumentParam = [];
+    setAdditionalSetInstrumentParam(additionalSetInstrumentParam) {
+        this._additionalSetInstrumentParam.push(additionalSetInstrumentParam);
+    }
+    removeAdditionalSetInstrumentParam(additionalSetInstrumentParam) {
+        this._additionalSetInstrumentParam.splice(this._additionalSetInstrumentParam.indexOf(additionalSetInstrumentParam), 1);
+    }
+    _additionalPreSavePreset = [];
+    setAdditionalPreSavePreset(additionalPreSavePreset) {
+        this._additionalPreSavePreset.push(additionalPreSavePreset);
+    }
+    removeAdditionalPreSavePreset(additionalPreSavePreset) {
+        this._additionalPreSavePreset.splice(this._additionalPreSavePreset.indexOf(additionalPreSavePreset), 1);
+    }
+    _additionalSavePreset = [];
+    setAdditionalSavePreset(additionalSavePreset) {
+        this._additionalSavePreset.push(additionalSavePreset);
+    }
+    removeAdditionalSavePreset(additionalSavePreset) {
+        this._additionalSavePreset.splice(this._additionalSavePreset.indexOf(additionalSavePreset), 1);
+    }
+    _additionalDeletePreset = [];
+    setAdditionalDeletePreset(additionalDeletePreset) {
+        this._additionalDeletePreset.push(additionalDeletePreset);
+    }
+    removeAdditionalDeletePreset(additionalDeletePreset) {
+        this._additionalDeletePreset.splice(this._additionalDeletePreset.indexOf(additionalDeletePreset), 1);
+    }
+}
+exports.PresetManager = PresetManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PresetManager.js","sourceRoot":"","sources":["../src/PresetManager.ts"],"names":[],"mappings":"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"}

package/dist/SessionAndPresetErrors.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+export type SessionAndPresetsErrorsProps = {};
+export declare function SessionAndPresetsErrors(props: SessionAndPresetsErrorsProps): React.JSX.Element;