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

package/dist/hooks/useSessionAndPresets.js

@@ -0,0 +1,339 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSessionAndPresets = useSessionAndPresets;
+const fs = require("fs-extra");
+const react_1 = require("react");
+const SessionAndPresetsState_1 = require("../state/SessionAndPresetsState");
+const __1 = require("..");
+/**
+ * Primary hook for interacting with the session and preset system.
+ *
+ * Must be called from within a component tree that is wrapped by
+ * {@link SessionAndPresetsStateProvider} and {@link SessionAndPresetsWrapper}.
+ *
+ * @returns An object with functions for session I/O and preset management.
+ *   See {@link UseSessionAndPresetsReturnValue} for the full list.
+ *
+ * @example
+ * ```tsx
+ * function PresetToolbar() {
+ *   const { prevPreset, nextPreset, getLoadedPreset } = useSessionAndPresets();
+ *
+ *   return (
+ *     <geLabel width={200} height={30}>
+ *       <geButton x={0}  width={30} height={30} text="<" onClick={prevPreset} />
+ *       <geLabel  x={35} width={130} height={30} text={getLoadedPreset()?.name ?? ''} />
+ *       <geButton x={170} width={30} height={30} text=">" onClick={nextPreset} />
+ *     </geLabel>
+ *   );
+ * }
+ * ```
+ */
+function useSessionAndPresets() {
+    const presetManager = (0, SessionAndPresetsState_1.useSessionAndPresetsManager)();
+    const configState = (0, SessionAndPresetsState_1.useSessionAndPresetsConfig)();
+    const dispatch = (0, SessionAndPresetsState_1.useSessionAndPresetsStateDispatch)();
+    const state = (0, SessionAndPresetsState_1.useSessionAndPresetsState)();
+    const stateRef = (0, react_1.useRef)(state);
+    stateRef.current = state;
+    const saveSession = (additionalStateString) => {
+        try {
+            const preset = getLoadedPreset();
+            if (configState.debug)
+                console.debug(`${__1.GE_SESSION_PRESETS_LIB} useSessionAndPresets: saveSession preset: ${preset?.filePath}`);
+            /**
+             * Experimental feature: Check preset-changed/dirty during session save
+             */
+            if (configState.flagPresetChanged && preset?.json && stateRef.current.instrument) {
+                const instProps = stateRef.current.instrument;
+                const presetInstProps = preset.json.dsp_settings;
+                let presetChanged = false;
+                const propsChangedLog = [];
+                for (const prop of presetInstProps) {
+                    const key = prop.key;
+                    if (instProps[key]) {
+                        if (instProps[key].normValue != prop.value) {
+                            propsChangedLog.push({
+                                type: 'instrumentProp',
+                                key: key,
+                                presetProp: prop.value,
+                                instrumentProp: instProps[key].normValue,
+                            });
+                            presetChanged = true;
+                        }
+                        else {
+                            if (stateRef.current.presetChangeLog && stateRef.current.presetChangeLog.length > 0)
+                                stateRef.current.presetChangeLog.find((entry) => entry.type === 'instrumentProp' && entry.key === key);
+                        }
+                    }
+                }
+                dispatchPresetChanged(presetChanged, propsChangedLog);
+            }
+            // create the save session-string
+            const saveString = presetManager.saveSession(additionalStateString, stateRef.current.presets.find((p) => p.uuid === stateRef.current.loadPresetUUID));
+            return saveString;
+        }
+        catch (err) {
+            dispatchError(err);
+        }
+    };
+    const isValidSession = (sessionJson) => {
+        let valid = true;
+        if (!sessionJson['dsp_settings'])
+            valid = false;
+        if (sessionJson['dsp_settings'].length === 0)
+            valid = false;
+        //if(!sessionJson['preset']) valid = false
+        if (configState.blockAAXInitialSession &&
+            configState.pluginType === 'AAX' &&
+            presetManager.sessionCount === 0)
+            valid = false;
+        if (configState.debug)
+            console.log(`${__1.GE_SESSION_PRESETS_LIB} useSessionAndPresets: : isValidSession sessionCount: ${presetManager.sessionCount} pluginType: ${configState.pluginType} valid: ${valid} `);
+        presetManager.incrementSessionCount();
+        return valid;
+    };
+    const loadSession = async (stateJSON) => {
+        if (!isValidSession(stateJSON)) {
+            if (configState.debug)
+                console.debug(`${__1.GE_SESSION_PRESETS_LIB} useSessionAndPresets: loadSession - NO VALID SESSION!`);
+            return stateJSON;
+        }
+        let sessionJSON = await presetManager.loadSession(stateJSON);
+        const filePath = sessionJSON['preset'];
+        if (configState.debug)
+            console.debug(`${__1.GE_SESSION_PRESETS_LIB} useSessionAndPresets: loadSession sessionJSON['preset']: ${filePath} exists: ${fs.existsSync(filePath)} isDirtySessionLoad: ${presetManager.isDirtySessionLoad}`);
+        if (!presetManager.isDirtySessionLoad && filePath) {
+            if (await fs.exists(filePath)) {
+                if (configState.debug)
+                    console.debug(`${__1.GE_SESSION_PRESETS_LIB} useSessionAndPresets: loadSession - DISPATCH PRESET`);
+                dispatchSetPreset(stateRef.current.presets.find((item) => item.filePath === filePath), filePath);
+                dispatchPresetChanged(sessionJSON.workingState.presetChanged, sessionJSON.workingState.presetChangeLog);
+            }
+        }
+        if (presetManager.isDirtySessionLoad) {
+            // if we end up in a state that is considered "dirty" load again
+            if (configState.debug)
+                console.debug(`${__1.GE_SESSION_PRESETS_LIB} useSessionAndPresets: loadSession presetManager.isDirtySessionLoad: ${presetManager.isDirtySessionLoad} - LOAD AGAIN`);
+            sessionJSON = await loadSession(stateJSON);
+        }
+        /// dispatch sessionId
+        if (sessionJSON?.sessionId) {
+            if (configState.debug)
+                console.debug(`${__1.GE_SESSION_PRESETS_LIB} useSessionAndPresets: loadSession - DISPATCH SESSION_ID ${sessionJSON.sessionId}`);
+            dispatchSetSessionId(sessionJSON.sessionId);
+        }
+        if (configState.debug)
+            console.debug(`${__1.GE_SESSION_PRESETS_LIB} useSessionAndPresets: loadSession sessionJSON['preset']: ${sessionJSON['preset']} - FINISHED`);
+        return sessionJSON;
+    };
+    const loadPresets = async (dirs) => {
+        try {
+            if (configState.debug)
+                console.debug(`${__1.GE_SESSION_PRESETS_LIB} useSessionAndPresets: loadPresets ${stateRef.current.presetIndex} sessionInvolved; ${presetManager.sessionInvolved} filePath: ${stateRef.current.presetFilePath}`);
+            const presets = await presetManager.loadPresets(dirs);
+            dispatch({
+                type: SessionAndPresetsState_1.SessionAndPresetsDispatchTypes.setPresets,
+                payload: {
+                    presets: presets,
+                },
+            });
+            if (presetManager.sessionInvolved) {
+                dispatchSetPreset(presets.find((item) => item.filePath === stateRef.current.presetFilePath), stateRef.current.presetFilePath);
+            }
+        }
+        catch (e) {
+            if (configState.debug)
+                console.error(e);
+            dispatchError(e);
+        }
+    };
+    const getPreset = (uuid) => {
+        return stateRef.current.presets.find((p) => p.uuid === uuid);
+    };
+    const getLoadedPreset = () => {
+        return stateRef.current.presets.find((p) => p.uuid === stateRef.current.loadPresetUUID);
+    };
+    const loadPreset = async (presetObj, sessionRestore = false) => {
+        try {
+            if (configState.debug)
+                console.debug(`${__1.GE_SESSION_PRESETS_LIB} useSessionAndPresets: loadPreset - sessionRestore: ${sessionRestore}`);
+            setPresetLoadingIndicator(true);
+            await presetManager.loadPreset(presetObj, undefined, sessionRestore);
+            setPresetLoadingIndicator(false);
+        }
+        catch (e) {
+            if (configState.debug)
+                console.error(e);
+            setPresetLoadingIndicator(false);
+            dispatchError(e);
+        }
+    };
+    const loadPresetFromSource = async (filePath, isInitialPreset = false, instStateToRetain) => {
+        try {
+            if (configState.debug)
+                console.debug(`${__1.GE_SESSION_PRESETS_LIB} useSessionAndPresets: loadPresetFromSource ${filePath} isInitialPreset: ${isInitialPreset}`);
+            // if it is the initial preset & it is loading a session or it has already loaded a session -> abort
+            if (isInitialPreset && presetManager.sessionInvolved)
+                return;
+            setPresetLoadingIndicator(true);
+            if (await presetManager.loadPresetFromSource(filePath, isInitialPreset, instStateToRetain))
+                dispatchSetPreset(stateRef.current.presets.find((item) => item.filePath === filePath), filePath);
+            setPresetLoadingIndicator(false);
+        }
+        catch (e) {
+            if (configState.debug)
+                console.error(e.name);
+            setPresetLoadingIndicator(false);
+            dispatchError(e);
+        }
+    };
+    const savePreset = async (filePath) => {
+        try {
+            if (configState.debug)
+                console.debug(`${__1.GE_SESSION_PRESETS_LIB} useSessionAndPresets: savePreset ${filePath}`);
+            await presetManager.savePreset(filePath);
+        }
+        catch (e) {
+            if (configState.debug)
+                console.error(e);
+            dispatchError(e);
+        }
+    };
+    const saveAsPreset = async () => {
+        try {
+            if (configState.debug)
+                console.debug(`${__1.GE_SESSION_PRESETS_LIB} useSessionAndPresets: saveAsPreset`);
+            let fileName = undefined;
+            const selectedPath = await GorillaEngine.openFileChooser({
+                hint: 'Save Preset',
+                saveDialog: true,
+                warnOnOverwrite: true,
+                allowedExtensions: 'json',
+                defaultLocation: configState.userPresetPath,
+            });
+            fileName = selectedPath[0];
+            const filePath = `${fileName}`;
+            if (configState.debug)
+                console.debug(`${__1.GE_SESSION_PRESETS_LIB} useSessionAndPresets: saveAsPreset ${filePath}`);
+            savePreset(filePath);
+        }
+        catch (e) {
+            if (configState.debug)
+                console.error(e);
+            dispatchError(e);
+        }
+    };
+    const deletePreset = async (filePath) => {
+        try {
+            if (configState.debug)
+                console.debug(`${__1.GE_SESSION_PRESETS_LIB} useSessionAndPresets: deletePreset filePath: ${filePath}`);
+            await presetManager.deletePreset(filePath);
+            await loadPresetFromSource(stateRef.current.presets[0].filePath);
+        }
+        catch (err) {
+            if (configState.debug)
+                console.error(err);
+            dispatchError(err);
+        }
+    };
+    const resetInstrumentProperty = (propertyName) => {
+        const preset = getLoadedPreset();
+        if (preset) {
+            stateRef.current.instrument[propertyName].normValue = preset.json.instrument[propertyName];
+        }
+    };
+    const prevPreset = () => {
+        if (stateRef.current.loadingPreset)
+            return;
+        const presetIndex = stateRef.current.presetIndex - 1 >= 0
+            ? stateRef.current.presetIndex - 1
+            : stateRef.current.presets.length - 1;
+        loadPresetFromSource(stateRef.current.presets[presetIndex].filePath);
+    };
+    const nextPreset = () => {
+        if (stateRef.current.loadingPreset)
+            return;
+        const presetIndex = stateRef.current.presetIndex + 1 <= stateRef.current.presets.length - 1
+            ? stateRef.current.presetIndex + 1
+            : 0;
+        loadPresetFromSource(stateRef.current.presets[presetIndex].filePath);
+    };
+    const randomize = () => {
+        if (stateRef.current.loadingPreset)
+            return;
+    };
+    const randomizeInCategory = () => {
+        if (stateRef.current.loadingPreset)
+            return;
+    };
+    const createPreset = async () => {
+        try {
+            return await presetManager.createPreset();
+        }
+        catch (err) {
+            if (configState.debug)
+                console.error(err);
+            dispatchError(err);
+        }
+    };
+    const setPresetLoadingIndicator = (active) => {
+        dispatch({
+            type: SessionAndPresetsState_1.SessionAndPresetsDispatchTypes.loadingPreset,
+            payload: {
+                loadingPreset: active,
+            },
+        });
+    };
+    const dispatchSetPreset = (preset, filePath) => {
+        dispatch({
+            type: SessionAndPresetsState_1.SessionAndPresetsDispatchTypes.setPreset,
+            payload: {
+                preset: preset,
+                filePath: filePath,
+            },
+        });
+    };
+    const dispatchPresetChanged = (presetChanged, presetChangeLog) => {
+        dispatch({
+            type: SessionAndPresetsState_1.SessionAndPresetsDispatchTypes.setPresetChanged,
+            payload: {
+                presetChanged: presetChanged,
+                presetChangeLog: presetChangeLog,
+            },
+        });
+    };
+    const dispatchSetSessionId = (sessionId) => {
+        dispatch({
+            type: SessionAndPresetsState_1.SessionAndPresetsDispatchTypes.setSessionId,
+            payload: {
+                sessionId,
+            },
+        });
+    };
+    const dispatchError = (e) => {
+        dispatch({
+            type: SessionAndPresetsState_1.SessionAndPresetsDispatchTypes.setError,
+            payload: { error: e },
+        });
+    };
+    return {
+        saveSession,
+        loadSession,
+        loadPresets,
+        getPreset,
+        getLoadedPreset,
+        loadPreset,
+        loadPresetFromSource,
+        createPreset,
+        savePreset,
+        saveAsPreset,
+        deletePreset,
+        resetInstrumentProperty,
+        prevPreset,
+        nextPreset,
+        randomize,
+        randomizeInCategory,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"useSessionAndPresets.js","sourceRoot":"","sources":["../../src/hooks/useSessionAndPresets.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="gorilla-engine" preserve="true" />
+import { useSessionAndPresets } from './hooks/useSessionAndPresets';
+import { SessionAndPresetsState, useSessionAndPresetsConfig, useSessionAndPresetsState, SessionAndPresetsDispatchTypes, useSessionAndPresetsManager, useSessionAndPresetsStateDispatch } from './state/SessionAndPresetsState';
+import { SessionAndPresetsConfig } from './types/SessionAndPresetsConfig';
+import SessionAndPresetsWrapper from './SessionAndPresetsWrapper';
+import { SessionAndPresetsStateProvider } from './state/SessionAndPresetsStateProvider';
+import { SessionAndPresetsError, SessionAndPresetsErrorTypes } from './errors/SessionAndPresetsError';
+import { IPresetManager, AdditionalSaveSessionSignature, AdditionalPreLoadSessionSignature, AdditionalLoadSessionSignature, AdditionalPreLoadPresetSignature, AdditionalLoadPresetSignature, AdditionalPreLoadPresetFromSourceSignature, AdditionalLoadPresetFromSourceSignature, AdditionalCreatePresetSignature, AdditionalSavePresetSignature, AdditionalDeletePresetSignature } from './types/IPresetManager';
+import { PresetManager } from './PresetManager';
+import { Preset } from './types/Preset';
+import { defaultSessionAndPresetsConfig } from './defaultSessionAndPresetsConfig';
+import { defaultSessionAndPresetsState } from './defaultSessionAndPresetsState';
+export declare const GE_SESSION_PRESETS_LIB = "[ge-session-presets-lib]";
+export { useSessionAndPresets, useSessionAndPresetsConfig, useSessionAndPresetsState, SessionAndPresetsWrapper, SessionAndPresetsStateProvider, SessionAndPresetsState, SessionAndPresetsConfig, IPresetManager, PresetManager, Preset, SessionAndPresetsDispatchTypes, useSessionAndPresetsManager, useSessionAndPresetsStateDispatch, SessionAndPresetsError, SessionAndPresetsErrorTypes, AdditionalSaveSessionSignature, AdditionalPreLoadSessionSignature, AdditionalLoadSessionSignature, AdditionalPreLoadPresetSignature, AdditionalLoadPresetSignature, AdditionalPreLoadPresetFromSourceSignature, AdditionalLoadPresetFromSourceSignature, AdditionalCreatePresetSignature, AdditionalSavePresetSignature, AdditionalDeletePresetSignature, defaultSessionAndPresetsConfig, defaultSessionAndPresetsState, };

package/dist/index.js

@@ -0,0 +1,30 @@
+"use strict";
+/// <reference types="gorilla-engine" preserve="true" />
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultSessionAndPresetsState = exports.defaultSessionAndPresetsConfig = exports.SessionAndPresetsErrorTypes = exports.SessionAndPresetsError = exports.useSessionAndPresetsStateDispatch = exports.useSessionAndPresetsManager = exports.SessionAndPresetsDispatchTypes = exports.PresetManager = exports.SessionAndPresetsStateProvider = exports.SessionAndPresetsWrapper = exports.useSessionAndPresetsState = exports.useSessionAndPresetsConfig = exports.useSessionAndPresets = exports.GE_SESSION_PRESETS_LIB = void 0;
+const useSessionAndPresets_1 = require("./hooks/useSessionAndPresets");
+Object.defineProperty(exports, "useSessionAndPresets", { enumerable: true, get: function () { return useSessionAndPresets_1.useSessionAndPresets; } });
+const SessionAndPresetsState_1 = require("./state/SessionAndPresetsState");
+Object.defineProperty(exports, "useSessionAndPresetsConfig", { enumerable: true, get: function () { return SessionAndPresetsState_1.useSessionAndPresetsConfig; } });
+Object.defineProperty(exports, "useSessionAndPresetsState", { enumerable: true, get: function () { return SessionAndPresetsState_1.useSessionAndPresetsState; } });
+Object.defineProperty(exports, "SessionAndPresetsDispatchTypes", { enumerable: true, get: function () { return SessionAndPresetsState_1.SessionAndPresetsDispatchTypes; } });
+Object.defineProperty(exports, "useSessionAndPresetsManager", { enumerable: true, get: function () { return SessionAndPresetsState_1.useSessionAndPresetsManager; } });
+Object.defineProperty(exports, "useSessionAndPresetsStateDispatch", { enumerable: true, get: function () { return SessionAndPresetsState_1.useSessionAndPresetsStateDispatch; } });
+const SessionAndPresetsWrapper_1 = __importDefault(require("./SessionAndPresetsWrapper"));
+exports.SessionAndPresetsWrapper = SessionAndPresetsWrapper_1.default;
+const SessionAndPresetsStateProvider_1 = require("./state/SessionAndPresetsStateProvider");
+Object.defineProperty(exports, "SessionAndPresetsStateProvider", { enumerable: true, get: function () { return SessionAndPresetsStateProvider_1.SessionAndPresetsStateProvider; } });
+const SessionAndPresetsError_1 = require("./errors/SessionAndPresetsError");
+Object.defineProperty(exports, "SessionAndPresetsError", { enumerable: true, get: function () { return SessionAndPresetsError_1.SessionAndPresetsError; } });
+Object.defineProperty(exports, "SessionAndPresetsErrorTypes", { enumerable: true, get: function () { return SessionAndPresetsError_1.SessionAndPresetsErrorTypes; } });
+const PresetManager_1 = require("./PresetManager");
+Object.defineProperty(exports, "PresetManager", { enumerable: true, get: function () { return PresetManager_1.PresetManager; } });
+const defaultSessionAndPresetsConfig_1 = require("./defaultSessionAndPresetsConfig");
+Object.defineProperty(exports, "defaultSessionAndPresetsConfig", { enumerable: true, get: function () { return defaultSessionAndPresetsConfig_1.defaultSessionAndPresetsConfig; } });
+const defaultSessionAndPresetsState_1 = require("./defaultSessionAndPresetsState");
+Object.defineProperty(exports, "defaultSessionAndPresetsState", { enumerable: true, get: function () { return defaultSessionAndPresetsState_1.defaultSessionAndPresetsState; } });
+exports.GE_SESSION_PRESETS_LIB = '[ge-session-presets-lib]';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLHdEQUF3RDs7Ozs7O0FBa0N4RCx1RUFBb0U7QUF3Q2xFLHFHQXhDTywyQ0FBb0IsT0F3Q1A7QUF2Q3RCLDJFQU93QztBQWlDdEMsMkdBdENBLG1EQUEwQixPQXNDQTtBQUMxQiwwR0F0Q0Esa0RBQXlCLE9Bc0NBO0FBUXpCLCtHQTdDQSx1REFBOEIsT0E2Q0E7QUFDOUIsNEdBN0NBLG9EQUEyQixPQTZDQTtBQUMzQixrSEE3Q0EsMERBQWlDLE9BNkNBO0FBekNuQywwRkFBa0U7QUFnQ2hFLG1DQWhDSyxrQ0FBd0IsQ0FnQ0w7QUEvQjFCLDJGQUF3RjtBQWdDdEYsK0dBaENPLCtEQUE4QixPQWdDUDtBQS9CaEMsNEVBR3lDO0FBcUN2Qyx1R0F2Q0EsK0NBQXNCLE9BdUNBO0FBQ3RCLDRHQXZDQSxvREFBMkIsT0F1Q0E7QUF2QjdCLG1EQUFnRDtBQWlCOUMsOEZBakJPLDZCQUFhLE9BaUJQO0FBZGYscUZBQWtGO0FBK0JoRiwrR0EvQk8sK0RBQThCLE9BK0JQO0FBOUJoQyxtRkFBZ0Y7QUErQjlFLDhHQS9CTyw2REFBNkIsT0ErQlA7QUE3QmxCLFFBQUEsc0JBQXNCLEdBQUcsMEJBQTBCLENBQUMifQ==

package/dist/state/SessionAndPresetsState.d.ts

@@ -0,0 +1,118 @@
+import { Preset } from '../types/Preset';
+import { SessionAndPresetsConfig } from '../types/SessionAndPresetsConfig';
+import { IPresetManager } from '../types/IPresetManager';
+import { SessionAndPresetsError } from '../errors/SessionAndPresetsError';
+export type SessionAndPresetsState = {
+    /**
+     * A reference to the instrument used
+     */
+    instrument?: GorillaEngine.Instrument;
+    /**
+     * An array of presets, populated by PresetManager-parsing of factory & user-presets
+     */
+    presets: Preset[];
+    /**
+     * The index of the currently loaded preset
+     */
+    presetIndex: number;
+    /**
+     * The file-path of the currently loaded preset
+     */
+    presetFilePath?: string;
+    /**
+     * A hash based on file-name of preset, used to identify current loaded preset
+     */
+    loadPresetUUID?: String;
+    /**
+     * The display name of the currently laoded preset
+     */
+    /**
+     * A boolean flag indicating if we are in a loading-state
+     */
+    loadingPreset?: boolean;
+    /**
+     * A boolean flag indicating if changes has happened on the currently loaded preset
+     */
+    presetChanged: boolean;
+    /**
+     * A log tracking preset/instrument changes
+     */
+    presetChangeLog?: any[];
+    /**
+     * Used to store the session information
+     */
+    session?: JSON;
+    /**
+     * A uuid which gets persisted within session save - used for logging and offline tracking paths
+     */
+    sessionId?: string;
+    /**
+     * The path to initial preset that should be loaded
+     */
+    initialPresetPath?: string;
+    /**
+     * Capturing the last error that got thrown
+     */
+    error?: Error | SessionAndPresetsError;
+};
+export declare enum SessionAndPresetsDispatchTypes {
+    setInstrument = "SET_INSTRUMENT",
+    setPresets = "SET_PRESETS",
+    setPreset = "SET_PRESET",
+    setPresetChanged = "SET_PRESET_CHANGED",
+    savePreset = "SAVE_PRESET",
+    deletePreset = "DELETE_PRESET",
+    setSession = "SET_SESSION",
+    setSessionId = "SET_SESSION_ID",
+    loadingPreset = "LOADING_PRESET",
+    setError = "ERROR"
+}
+type SessionAndPresetsStatePayload = {
+    [SessionAndPresetsDispatchTypes.setInstrument]: {
+        instrument: GorillaEngine.Instrument;
+    };
+    [SessionAndPresetsDispatchTypes.setPresets]: {
+        presets: Preset[];
+    };
+    [SessionAndPresetsDispatchTypes.setPreset]: {
+        preset: Preset;
+        filePath: string;
+    };
+    [SessionAndPresetsDispatchTypes.setPresetChanged]: {
+        presetChanged: boolean;
+        presetChangeLog: any[];
+    };
+    [SessionAndPresetsDispatchTypes.setSession]: {
+        session: JSON;
+    };
+    [SessionAndPresetsDispatchTypes.setSessionId]: {
+        sessionId: string;
+    };
+    [SessionAndPresetsDispatchTypes.loadingPreset]: {
+        loadingPreset: boolean;
+    };
+    [SessionAndPresetsDispatchTypes.setError]: {
+        error: SessionAndPresetsError;
+    };
+};
+export type SessionAndPresetsStateActions = ActionMap<SessionAndPresetsStatePayload>[keyof ActionMap<SessionAndPresetsStatePayload>];
+export declare const SessionAndPresetsReducer: (state: SessionAndPresetsState, action: SessionAndPresetsStateActions) => SessionAndPresetsState;
+export declare const SessionAndPresetsStateContext: React.Context<any>;
+export declare const SessionAndPresetsStateDispatchContext: React.Context<any>;
+export declare const SessionAndPresetsConfigContext: React.Context<any>;
+export declare function useSessionAndPresetsConfig(): SessionAndPresetsConfig;
+export declare function useSessionAndPresetsState(): SessionAndPresetsState;
+export declare function useSessionAndPresetsStateDispatch(): any;
+export declare const SessionAndPresetsManagerContext: React.Context<any>;
+export declare function useSessionAndPresetsManager(): IPresetManager;
+type ActionMap<M extends {
+    [index: string]: any;
+}> = {
+    [Key in keyof M]: M[Key] extends undefined ? {
+        type: Key;
+    } : {
+        type: Key;
+        payload: M[Key];
+    };
+};
+export {};

package/dist/state/SessionAndPresetsState.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionAndPresetsManagerContext = exports.SessionAndPresetsConfigContext = exports.SessionAndPresetsStateDispatchContext = exports.SessionAndPresetsStateContext = exports.SessionAndPresetsReducer = exports.SessionAndPresetsDispatchTypes = void 0;
+exports.useSessionAndPresetsConfig = useSessionAndPresetsConfig;
+exports.useSessionAndPresetsState = useSessionAndPresetsState;
+exports.useSessionAndPresetsStateDispatch = useSessionAndPresetsStateDispatch;
+exports.useSessionAndPresetsManager = useSessionAndPresetsManager;
+const react_1 = require("react");
+var SessionAndPresetsDispatchTypes;
+(function (SessionAndPresetsDispatchTypes) {
+    SessionAndPresetsDispatchTypes["setInstrument"] = "SET_INSTRUMENT";
+    SessionAndPresetsDispatchTypes["setPresets"] = "SET_PRESETS";
+    SessionAndPresetsDispatchTypes["setPreset"] = "SET_PRESET";
+    SessionAndPresetsDispatchTypes["setPresetChanged"] = "SET_PRESET_CHANGED";
+    SessionAndPresetsDispatchTypes["savePreset"] = "SAVE_PRESET";
+    SessionAndPresetsDispatchTypes["deletePreset"] = "DELETE_PRESET";
+    SessionAndPresetsDispatchTypes["setSession"] = "SET_SESSION";
+    SessionAndPresetsDispatchTypes["setSessionId"] = "SET_SESSION_ID";
+    SessionAndPresetsDispatchTypes["loadingPreset"] = "LOADING_PRESET";
+    SessionAndPresetsDispatchTypes["setError"] = "ERROR";
+})(SessionAndPresetsDispatchTypes || (exports.SessionAndPresetsDispatchTypes = SessionAndPresetsDispatchTypes = {}));
+const SessionAndPresetsReducer = (state, action) => {
+    switch (action.type) {
+        case SessionAndPresetsDispatchTypes.setSession:
+            return {
+                ...state,
+                session: action.payload.session,
+            };
+        case SessionAndPresetsDispatchTypes.setSessionId:
+            return {
+                ...state,
+                sessionId: action.payload.sessionId,
+            };
+        case SessionAndPresetsDispatchTypes.setInstrument:
+            return {
+                ...state,
+                instrument: action.payload.instrument,
+            };
+        case SessionAndPresetsDispatchTypes.setPresets:
+            const newState = {
+                ...state,
+                presets: action.payload.presets,
+            };
+            if (state.presetIndex > -1 && state.loadPresetUUID) {
+                const presetIndex = newState.presets.findIndex((item) => item.uuid === state.loadPresetUUID);
+                newState.presetIndex = presetIndex;
+            }
+            return newState;
+        case SessionAndPresetsDispatchTypes.setPreset:
+            const presetIndex = state.presets.findIndex((item) => item.filePath === action.payload.filePath);
+            const preset = state.presets.find((item) => item.filePath === action.payload.filePath);
+            return {
+                ...state,
+                presetIndex: presetIndex,
+                presetFilePath: action.payload.filePath,
+                //presetName: action.payload.preset.name,
+                //preset: action.payload.preset,
+                loadPresetUUID: preset?.uuid,
+                presetChanged: false,
+                presetChangeLog: undefined,
+            };
+        case SessionAndPresetsDispatchTypes.setPresetChanged:
+            const presetChangeLog = Array.isArray(state.presetChangeLog)
+                ? state.presetChangeLog.concat(action.payload.presetChangeLog)
+                : [];
+            return {
+                ...state,
+                presetChanged: action.payload.presetChanged,
+                presetChangeLog: presetChangeLog,
+            };
+        case SessionAndPresetsDispatchTypes.loadingPreset:
+            return {
+                ...state,
+                loadingPreset: action.payload.loadingPreset,
+            };
+        case SessionAndPresetsDispatchTypes.setError:
+            return {
+                ...state,
+                error: action.payload.error,
+                // TODO: double-check...
+                // Reason: if flag was set to true, but an error aborted further excecution, flag might not get reset
+                loadingPreset: false,
+            };
+        default:
+            return state;
+    }
+};
+exports.SessionAndPresetsReducer = SessionAndPresetsReducer;
+exports.SessionAndPresetsStateContext = (0, react_1.createContext)(null);
+exports.SessionAndPresetsStateDispatchContext = (0, react_1.createContext)(null);
+exports.SessionAndPresetsConfigContext = (0, react_1.createContext)(null);
+function useSessionAndPresetsConfig() {
+    return (0, react_1.useContext)(exports.SessionAndPresetsConfigContext);
+}
+function useSessionAndPresetsState() {
+    return (0, react_1.useContext)(exports.SessionAndPresetsStateContext);
+}
+function useSessionAndPresetsStateDispatch() {
+    return (0, react_1.useContext)(exports.SessionAndPresetsStateDispatchContext);
+}
+exports.SessionAndPresetsManagerContext = (0, react_1.createContext)(null);
+function useSessionAndPresetsManager() {
+    return (0, react_1.useContext)(exports.SessionAndPresetsManagerContext);
+}
+//# sourceMappingURL=data:application/json;base64,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