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

package/dist/SessionAndPresetErrors.js

@@ -0,0 +1,94 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionAndPresetsErrors = SessionAndPresetsErrors;
+const React = __importStar(require("react"));
+const ge_dialogs_lib_1 = require("@gorilla-engine-sdk/ge-dialogs-lib");
+const react_1 = require("react");
+const SessionAndPresetsState_1 = require("./state/SessionAndPresetsState");
+const SessionAndPresetsError_1 = require("./errors/SessionAndPresetsError");
+const _1 = require(".");
+function SessionAndPresetsErrors(props) {
+    const sessionAndPresetState = (0, SessionAndPresetsState_1.useSessionAndPresetsState)();
+    const defaultModalProps = {
+        width: 400,
+        height: 200,
+        title: 'An Error Occured!',
+        message: 'Error message',
+        cancelTrigger: true,
+        cancelTriggerLabel: 'Ok',
+        onCancelTrigger: onCancel,
+        approveTrigger: false,
+        closeTrigger: true,
+    };
+    const [modalProps, setModalProps] = (0, react_1.useState)({
+        ...defaultModalProps,
+    });
+    const modalPropsRef = (0, react_1.useRef)(modalProps);
+    modalPropsRef.current = modalProps;
+    const [showModal, hideModal] = (0, ge_dialogs_lib_1.useModal)(() => React.createElement(ge_dialogs_lib_1.DefaultModal, { ...modalPropsRef.current }), [true, false]);
+    function onCancel() {
+        hideModal();
+    }
+    (0, react_1.useEffect)(() => {
+        const e = sessionAndPresetState.error;
+        if (e) {
+            console.error(`${_1.GE_SESSION_PRESETS_LIB} SessionAndPresetsErrors: useEffect [sessionAndPresetState.error] ${sessionAndPresetState.error}`);
+            if (e instanceof SessionAndPresetsError_1.SessionAndPresetsError) {
+                console.error(`${_1.GE_SESSION_PRESETS_LIB} SessionAndPresetsErrors: useEffect [sessionAndPresetState.error] ${e.defaultTitle} ${e.defaultMessage}`);
+                /*console.log(e);
+                console.log(e.type);
+                console.log(e.stack);*/
+                setModalProps({
+                    ...defaultModalProps,
+                    title: e.defaultTitle,
+                    message: e.defaultMessage,
+                });
+                showModal();
+            }
+            else {
+                const err = e;
+                setModalProps({
+                    ...defaultModalProps,
+                    title: 'An Error occured!',
+                    message: err.message,
+                });
+                showModal();
+            }
+        }
+    }, [sessionAndPresetState.error]);
+    return React.createElement(React.Fragment, null);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/SessionAndPresetsWrapper.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+type SessionAndPresetsWrapper = {
+    children?: React.ReactNode;
+};
+/**
+ * Orchestrator component that handles DAW session callbacks, preset
+ * directory scanning, file-system watching, and initial preset loading.
+ *
+ * Must be placed **inside** {@link SessionAndPresetsStateProvider}.  Wrap
+ * your plugin UI with this component so that presets and sessions are ready
+ * before your UI renders.
+ *
+ * @example
+ * ```tsx
+ * <SessionAndPresetsStateProvider config={config} instrument={instrument}>
+ *   <SessionAndPresetsWrapper>
+ *     <App />
+ *   </SessionAndPresetsWrapper>
+ * </SessionAndPresetsStateProvider>
+ * ```
+ */
+declare function SessionAndPresetsWrapper(props: SessionAndPresetsWrapper): React.JSX.Element;
+export default SessionAndPresetsWrapper;

package/dist/SessionAndPresetsWrapper.js

@@ -0,0 +1,182 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const React = __importStar(require("react"));
+const fs = require("fs-extra");
+const util = require('util');
+const react_1 = require("react");
+const SessionAndPresetsState_1 = require("./state/SessionAndPresetsState");
+const useSessionAndPresets_1 = require("./hooks/useSessionAndPresets");
+const SessionAndPresetErrors_1 = require("./SessionAndPresetErrors");
+const SessionAndPresetsError_1 = require("./errors/SessionAndPresetsError");
+const _1 = require(".");
+/**
+ * Orchestrator component that handles DAW session callbacks, preset
+ * directory scanning, file-system watching, and initial preset loading.
+ *
+ * Must be placed **inside** {@link SessionAndPresetsStateProvider}.  Wrap
+ * your plugin UI with this component so that presets and sessions are ready
+ * before your UI renders.
+ *
+ * @example
+ * ```tsx
+ * <SessionAndPresetsStateProvider config={config} instrument={instrument}>
+ *   <SessionAndPresetsWrapper>
+ *     <App />
+ *   </SessionAndPresetsWrapper>
+ * </SessionAndPresetsStateProvider>
+ * ```
+ */
+function SessionAndPresetsWrapper(props) {
+    const sessionAndPresetState = (0, SessionAndPresetsState_1.useSessionAndPresetsState)();
+    const sessionAndPresetStateRef = (0, react_1.useRef)(sessionAndPresetState);
+    sessionAndPresetStateRef.current = sessionAndPresetState;
+    const dispatch = (0, SessionAndPresetsState_1.useSessionAndPresetsStateDispatch)();
+    const sessionAndPresetsConfig = (0, SessionAndPresetsState_1.useSessionAndPresetsConfig)();
+    const sessionAndPresetsConfigRef = (0, react_1.useRef)(sessionAndPresetsConfig);
+    sessionAndPresetsConfigRef.current = sessionAndPresetsConfig;
+    const [initialized, setInitialized] = (0, react_1.useState)(false);
+    const initializedRef = (0, react_1.useRef)(initialized);
+    initializedRef.current = initialized;
+    const presetManager = (0, SessionAndPresetsState_1.useSessionAndPresetsManager)();
+    const { saveSession, loadSession, loadPresets, loadPresetFromSource } = (0, useSessionAndPresets_1.useSessionAndPresets)();
+    /**
+     * When presetManager is ready/available.
+     * - if handleSession = true - attaches listeners for save & loadSession
+     * - sets watcher to user-preset-dir to re-load presets on changes
+     * - triggeres loadPresets logic
+     */
+    (0, react_1.useEffect)(() => {
+        if (sessionAndPresetsConfigRef.current.debug)
+            console.debug(`${_1.GE_SESSION_PRESETS_LIB} SessionAndPresetsWrapper: useEffect [presetManager] `);
+        if (presetManager && presetManager.config.handleSession) {
+            // Session load callback
+            GorillaEngine.setSessionLoadCallback((stateString) => {
+                if (sessionAndPresetsConfigRef.current.debug)
+                    console.debug(`${_1.GE_SESSION_PRESETS_LIB} SessionAndPresetsWrapper: GorillaEngine.setSessionLoadCallback`);
+                const session = loadSession(JSON.parse(stateString));
+                //return JSON.stringify(session)
+                return stateString;
+            }, {});
+            // Session save callback
+            GorillaEngine.setSessionSaveCallback((additionalStateString) => {
+                return saveSession(additionalStateString);
+            }, {});
+        }
+        const fb = async () => {
+            if (presetManager.config.handlePresets && presetManager.config.autoLoadPresets) {
+                const presetLoacations = [
+                    {
+                        type: sessionAndPresetsConfig.factoryPresetType,
+                        path: sessionAndPresetsConfig.factoryPresetPath,
+                    },
+                    {
+                        type: sessionAndPresetsConfig.userPresetType,
+                        path: sessionAndPresetsConfig.userPresetPath,
+                    },
+                ];
+                // load presets via hook
+                await loadPresets(presetLoacations);
+                // add watch to presets dir
+                fs.watch(sessionAndPresetsConfig.userPresetPath, { recursive: true }, (eventType, fileName) => {
+                    if (!fileName.includes('.DS_Store')) {
+                        // re-load content via hook
+                        loadPresets(presetLoacations);
+                    }
+                });
+            }
+            return;
+        };
+        if (presetManager) {
+            fb();
+        }
+    }, [presetManager]);
+    /**
+     * When presets are loaded
+     * - checks if we have to handle a session or a new instantiation scenario
+     * - loads session if available
+     * - otherwise loads default preset
+     */
+    (0, react_1.useEffect)(() => {
+        if (sessionAndPresetState.presets && sessionAndPresetState.instrument) {
+            if (sessionAndPresetsConfigRef.current.debug)
+                console.debug(`${_1.GE_SESSION_PRESETS_LIB} SessionAndPresetsWrapper: useEffect [sessionAndPresetState.presets] - presetManager.sessionInvolved: ${presetManager?.sessionInvolved}`);
+        }
+        // if already initialised we don't need to run buildup-logic
+        if (initialized)
+            return;
+        if (sessionAndPresetState.presets &&
+            sessionAndPresetState.presets.length > 0 &&
+            sessionAndPresetState.instrument &&
+            !presetManager.sessionInvolved) {
+            // if loadInitialPreset=true in config
+            if ((sessionAndPresetsConfigRef.current.loadInitialPreset && !presetManager.isLoadingSession) ||
+                !presetManager.loadedSession) {
+                // Pick the first preset as fallback
+                let initialPreset = sessionAndPresetStateRef.current.presets[0];
+                // if initialPresetPath is set & successfully validated
+                if (sessionAndPresetStateRef.current.initialPresetPath) {
+                    const initialPresetPath = sessionAndPresetStateRef.current.initialPresetPath;
+                    const presetItem = sessionAndPresetStateRef.current.presets.find((preset) => preset.filePath === initialPresetPath);
+                    if (fs.existsSync(initialPresetPath) &&
+                        presetItem &&
+                        presetItem.type === sessionAndPresetsConfigRef.current.factoryPresetType) {
+                        initialPreset = presetItem;
+                    }
+                    else {
+                        // if an initialPresetPath is provided but preset can not be found, lets inform about it!
+                        const e = new SessionAndPresetsError_1.SessionAndPresetsError(SessionAndPresetsError_1.SessionAndPresetsErrorTypes.initialPresetLoading, 'Loading Initial Preset Failed!', `No preset found for initialPresetPath ${initialPresetPath}`, { path: initialPresetPath });
+                        dispatch({
+                            type: SessionAndPresetsState_1.SessionAndPresetsDispatchTypes.setError,
+                            payload: { error: e },
+                        });
+                    }
+                }
+                console.debug(`${_1.GE_SESSION_PRESETS_LIB} SessionAndPresetsWrapper: useEffect [sessionAndPresetState.presets] - load initial preset:  ${initialPreset.filePath}`);
+                loadPresetFromSource(initialPreset.filePath, true); //await
+            }
+            else {
+                console.debug(`${_1.GE_SESSION_PRESETS_LIB} SessionAndPresetsWrapper: useEffect [sessionAndPresetState.presets] - do nothing - presetManager.sessionInvolved: ${presetManager.sessionInvolved}`);
+            }
+            setInitialized(true);
+        }
+    }, [sessionAndPresetState.presets, sessionAndPresetState.instrument]);
+    return (React.createElement(React.Fragment, null,
+        sessionAndPresetsConfig.handleErrors && React.createElement(SessionAndPresetErrors_1.SessionAndPresetsErrors, null),
+        props.children));
+    //return <>{initialized && <>{props.children}</>}</>
+}
+exports.default = SessionAndPresetsWrapper;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/defaultSessionAndPresetsConfig.d.ts

@@ -0,0 +1,2 @@
+import { SessionAndPresetsConfig } from './types/SessionAndPresetsConfig';
+export declare const defaultSessionAndPresetsConfig: SessionAndPresetsConfig;

package/dist/defaultSessionAndPresetsConfig.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultSessionAndPresetsConfig = void 0;
+exports.defaultSessionAndPresetsConfig = {
+    presetFileSuffix: ".patch",
+    factoryPresetType: 'FACTORY',
+    userPresetType: 'USER',
+    handleSession: true,
+    handlePresets: true,
+    autoLoadPresets: true,
+    loadInitialPreset: true,
+    handleErrors: true,
+    flagPresetChanged: false,
+    retainUIScale: true,
+    blockAAXInitialSession: false,
+    debug: false
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdFNlc3Npb25BbmRQcmVzZXRzQ29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2RlZmF1bHRTZXNzaW9uQW5kUHJlc2V0c0NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFFYSxRQUFBLDhCQUE4QixHQUE0QjtJQUNyRSxnQkFBZ0IsRUFBRSxRQUFRO0lBQzFCLGlCQUFpQixFQUFFLFNBQVM7SUFDNUIsY0FBYyxFQUFFLE1BQU07SUFFdEIsYUFBYSxFQUFFLElBQUk7SUFDbkIsYUFBYSxFQUFFLElBQUk7SUFFbkIsZUFBZSxFQUFFLElBQUk7SUFDckIsaUJBQWlCLEVBQUUsSUFBSTtJQUN2QixZQUFZLEVBQUUsSUFBSTtJQUNsQixpQkFBaUIsRUFBQyxLQUFLO0lBRXZCLGFBQWEsRUFBRSxJQUFJO0lBQ25CLHNCQUFzQixFQUFFLEtBQUs7SUFFN0IsS0FBSyxFQUFFLEtBQUs7Q0FDYixDQUFDIn0=

package/dist/defaultSessionAndPresetsState.d.ts

@@ -0,0 +1,2 @@
+import { SessionAndPresetsState } from './state/SessionAndPresetsState';
+export declare const defaultSessionAndPresetsState: SessionAndPresetsState;

package/dist/defaultSessionAndPresetsState.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultSessionAndPresetsState = void 0;
+exports.defaultSessionAndPresetsState = {
+    presets: [],
+    presetIndex: -1,
+    presetChanged: false,
+    instrument: undefined,
+    initialPresetPath: undefined,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdFNlc3Npb25BbmRQcmVzZXRzU3RhdGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvZGVmYXVsdFNlc3Npb25BbmRQcmVzZXRzU3RhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBRWEsUUFBQSw2QkFBNkIsR0FBMkI7SUFDbkUsT0FBTyxFQUFFLEVBQUU7SUFDWCxXQUFXLEVBQUUsQ0FBQyxDQUFDO0lBQ2YsYUFBYSxFQUFFLEtBQUs7SUFDcEIsVUFBVSxFQUFFLFNBQVM7SUFDckIsaUJBQWlCLEVBQUUsU0FBUztDQUM3QixDQUFDIn0=

package/dist/errors/SessionAndPresetsError.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Enumeration of all error types that can be thrown by the session and preset
+ * management system.  Use this to distinguish error categories in your error
+ * handling code.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await loadPresetFromSource(filePath);
+ * } catch (err) {
+ *   if (err instanceof SessionAndPresetsError) {
+ *     if (err.type === SessionAndPresetsErrorTypes.presetFileNotFound) {
+ *       // show "preset not found" UI
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare enum SessionAndPresetsErrorTypes {
+    /** Catch-all for errors that do not match any specific category */
+    unspecific = "unspecific",
+    /** Application-specific custom error */
+    custom = "custom",
+    /** Error while scanning or reading the preset directory */
+    presetsLoading = "presetsLoading",
+    /** Error while loading a single preset */
+    presetLoading = "presetLoading",
+    /** The instrument state stored in the preset is in an unexpected format */
+    presetInstrumentFormat = "presetInstrumentFormat",
+    /** Failed to load the initial (default) preset on startup */
+    initialPresetLoading = "initialPresetLoading",
+    /** Error while creating an in-memory preset object */
+    presetCreation = "presetCreation",
+    /** Error while writing a preset to disk */
+    presetSaving = "presetSaving",
+    /** The requested preset file does not exist at the expected path */
+    presetFileNotFound = "presetFileNotFound",
+    /** Operation attempted before an instrument was loaded */
+    noInstrumentLoaded = "noInstrumentLoaded",
+    /** Error during DAW session restore */
+    loadingSession = "loadingSession",
+    /** Failed to apply the instrument parameter state from a preset */
+    applyInstrumentState = "applyInstrumentState"
+}
+/**
+ * Typed error class thrown by the session and preset management system.
+ *
+ * Every `SessionAndPresetsError` carries a {@link type} for programmatic
+ * handling, a short {@link defaultTitle} for display in error dialogs, a
+ * human-readable {@link defaultMessage}, and optional {@link details} for
+ * debugging.
+ *
+ * @example
+ * ```ts
+ * throw new SessionAndPresetsError(
+ *   SessionAndPresetsErrorTypes.presetFileNotFound,
+ *   'Unable to load preset',
+ *   `The preset file does not exist: ${filePath}`,
+ *   { filePath }
+ * );
+ * ```
+ */
+export declare class SessionAndPresetsError extends Error {
+    /** Identifies the category of error — use {@link SessionAndPresetsErrorTypes} or a custom string */
+    readonly type: SessionAndPresetsErrorTypes | string;
+    /** Short, user-facing title suitable for an error dialog header */
+    readonly defaultTitle: string;
+    /** Detailed, user-facing message describing what went wrong */
+    readonly defaultMessage: string;
+    /** Optional additional debugging context (file paths, raw error, etc.) */
+    readonly details: any;
+    constructor(type: SessionAndPresetsErrorTypes | string, defaultTitle: string, defaultMessage: string, details?: any);
+}

package/dist/errors/SessionAndPresetsError.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionAndPresetsError = exports.SessionAndPresetsErrorTypes = void 0;
+/**
+ * Enumeration of all error types that can be thrown by the session and preset
+ * management system.  Use this to distinguish error categories in your error
+ * handling code.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await loadPresetFromSource(filePath);
+ * } catch (err) {
+ *   if (err instanceof SessionAndPresetsError) {
+ *     if (err.type === SessionAndPresetsErrorTypes.presetFileNotFound) {
+ *       // show "preset not found" UI
+ *     }
+ *   }
+ * }
+ * ```
+ */
+var SessionAndPresetsErrorTypes;
+(function (SessionAndPresetsErrorTypes) {
+    /** Catch-all for errors that do not match any specific category */
+    SessionAndPresetsErrorTypes["unspecific"] = "unspecific";
+    /** Application-specific custom error */
+    SessionAndPresetsErrorTypes["custom"] = "custom";
+    /** Error while scanning or reading the preset directory */
+    SessionAndPresetsErrorTypes["presetsLoading"] = "presetsLoading";
+    /** Error while loading a single preset */
+    SessionAndPresetsErrorTypes["presetLoading"] = "presetLoading";
+    /** The instrument state stored in the preset is in an unexpected format */
+    SessionAndPresetsErrorTypes["presetInstrumentFormat"] = "presetInstrumentFormat";
+    /** Failed to load the initial (default) preset on startup */
+    SessionAndPresetsErrorTypes["initialPresetLoading"] = "initialPresetLoading";
+    /** Error while creating an in-memory preset object */
+    SessionAndPresetsErrorTypes["presetCreation"] = "presetCreation";
+    /** Error while writing a preset to disk */
+    SessionAndPresetsErrorTypes["presetSaving"] = "presetSaving";
+    /** The requested preset file does not exist at the expected path */
+    SessionAndPresetsErrorTypes["presetFileNotFound"] = "presetFileNotFound";
+    /** Operation attempted before an instrument was loaded */
+    SessionAndPresetsErrorTypes["noInstrumentLoaded"] = "noInstrumentLoaded";
+    /** Error during DAW session restore */
+    SessionAndPresetsErrorTypes["loadingSession"] = "loadingSession";
+    /** Failed to apply the instrument parameter state from a preset */
+    SessionAndPresetsErrorTypes["applyInstrumentState"] = "applyInstrumentState";
+})(SessionAndPresetsErrorTypes || (exports.SessionAndPresetsErrorTypes = SessionAndPresetsErrorTypes = {}));
+/**
+ * Typed error class thrown by the session and preset management system.
+ *
+ * Every `SessionAndPresetsError` carries a {@link type} for programmatic
+ * handling, a short {@link defaultTitle} for display in error dialogs, a
+ * human-readable {@link defaultMessage}, and optional {@link details} for
+ * debugging.
+ *
+ * @example
+ * ```ts
+ * throw new SessionAndPresetsError(
+ *   SessionAndPresetsErrorTypes.presetFileNotFound,
+ *   'Unable to load preset',
+ *   `The preset file does not exist: ${filePath}`,
+ *   { filePath }
+ * );
+ * ```
+ */
+class SessionAndPresetsError extends Error {
+    /** Identifies the category of error — use {@link SessionAndPresetsErrorTypes} or a custom string */
+    type;
+    /** Short, user-facing title suitable for an error dialog header */
+    defaultTitle;
+    /** Detailed, user-facing message describing what went wrong */
+    defaultMessage;
+    /** Optional additional debugging context (file paths, raw error, etc.) */
+    details;
+    constructor(type, defaultTitle, defaultMessage, details) {
+        super(defaultTitle);
+        Object.setPrototypeOf(this, SessionAndPresetsError.prototype);
+        Error.captureStackTrace?.(this, this.constructor);
+        this.name = 'SessionAndPresetsError';
+        this.type = type;
+        this.defaultTitle = defaultTitle;
+        this.defaultMessage = defaultMessage;
+        this.details = details;
+    }
+}
+exports.SessionAndPresetsError = SessionAndPresetsError;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2Vzc2lvbkFuZFByZXNldHNFcnJvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9lcnJvcnMvU2Vzc2lvbkFuZFByZXNldHNFcnJvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQTs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FpQkc7QUFDSCxJQUFZLDJCQXlCWDtBQXpCRCxXQUFZLDJCQUEyQjtJQUNyQyxtRUFBbUU7SUFDbkUsd0RBQXlCLENBQUE7SUFDekIsd0NBQXdDO0lBQ3hDLGdEQUFpQixDQUFBO0lBQ2pCLDJEQUEyRDtJQUMzRCxnRUFBaUMsQ0FBQTtJQUNqQywwQ0FBMEM7SUFDMUMsOERBQStCLENBQUE7SUFDL0IsMkVBQTJFO0lBQzNFLGdGQUFpRCxDQUFBO0lBQ2pELDZEQUE2RDtJQUM3RCw0RUFBNkMsQ0FBQTtJQUM3QyxzREFBc0Q7SUFDdEQsZ0VBQWlDLENBQUE7SUFDakMsMkNBQTJDO0lBQzNDLDREQUE2QixDQUFBO0lBQzdCLG9FQUFvRTtJQUNwRSx3RUFBeUMsQ0FBQTtJQUN6QywwREFBMEQ7SUFDMUQsd0VBQXlDLENBQUE7SUFDekMsdUNBQXVDO0lBQ3ZDLGdFQUFpQyxDQUFBO0lBQ2pDLG1FQUFtRTtJQUNuRSw0RUFBNkMsQ0FBQTtBQUMvQyxDQUFDLEVBekJXLDJCQUEyQiwyQ0FBM0IsMkJBQTJCLFFBeUJ0QztBQUVEOzs7Ozs7Ozs7Ozs7Ozs7OztHQWlCRztBQUNILE1BQWEsc0JBQXVCLFNBQVEsS0FBSztJQUMvQyxvR0FBb0c7SUFDcEYsSUFBSSxDQUF1QztJQUMzRCxtRUFBbUU7SUFDbkQsWUFBWSxDQUFTO0lBQ3JDLCtEQUErRDtJQUMvQyxjQUFjLENBQVM7SUFDdkMsMEVBQTBFO0lBQzFELE9BQU8sQ0FBTTtJQUU3QixZQUNFLElBQTBDLEVBQzFDLFlBQW9CLEVBQ3BCLGNBQXNCLEVBQ3RCLE9BQWE7UUFFYixLQUFLLENBQUMsWUFBWSxDQUFDLENBQUM7UUFFcEIsTUFBTSxDQUFDLGNBQWMsQ0FBQyxJQUFJLEVBQUUsc0JBQXNCLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDOUQsS0FBSyxDQUFDLGlCQUFpQixFQUFFLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUVsRCxJQUFJLENBQUMsSUFBSSxHQUFHLHdCQUF3QixDQUFDO1FBRXJDLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDO1FBRWpCLElBQUksQ0FBQyxZQUFZLEdBQUcsWUFBWSxDQUFDO1FBQ2pDLElBQUksQ0FBQyxjQUFjLEdBQUcsY0FBYyxDQUFDO1FBRXJDLElBQUksQ0FBQyxPQUFPLEdBQUcsT0FBTyxDQUFDO0lBQ3pCLENBQUM7Q0FDRjtBQTlCRCx3REE4QkMifQ==

package/dist/hooks/useSessionAndPresets.d.ts

@@ -0,0 +1,125 @@
+import { Preset } from '../types/Preset';
+/**
+ * The return value of {@link useSessionAndPresets}.
+ *
+ * Provides functions for loading and saving sessions, scanning and navigating
+ * presets, and creating or deleting user presets.  All functions dispatch state
+ * updates through the {@link SessionAndPresetsStateProvider} context, so any
+ * component subscribed to that context will re-render when relevant state
+ * changes.
+ */
+type UseSessionAndPresetsReturnValue = {
+    /**
+     * Save Session for DAW
+     * @param additionalStateString
+     * @returns
+     */
+    saveSession: (additionalStateString: string) => string;
+    /**
+     * Load Session from DAW
+     * @param stateJSON
+     * @returns
+     */
+    loadSession: (stateJSON: JSON) => Promise<any>;
+    /**
+     * Load Presets from an array of Directories
+     * @param dirs
+     * @returns
+     */
+    loadPresets: (dirs: any[]) => Promise<any>;
+    /**
+     * Get preset by it's uuid
+     * @param uuid
+     * @returns
+     */
+    getPreset: (uuid: string) => Preset;
+    /**
+     * Get the current loaded preset-item
+     * @returns the currently loaded preset item
+     */
+    getLoadedPreset: () => Preset;
+    /**
+     * Load Preset from Object
+     * @param presetObj
+     * @param sessionRestore
+     * @returns
+     */
+    loadPreset: (presetObj: any, sessionRestore?: boolean) => Promise<void>;
+    /**
+     * Load Preset from file
+     * @param filePath
+     * @param isInitialPreset
+     * @returns
+     */
+    loadPresetFromSource: (filePath: string, isInitialPreset: boolean, instStateToRetain?: any[]) => Promise<void>;
+    /**
+     * Create a Preset-Object
+     * @returns
+     */
+    createPreset: () => any;
+    /**
+     * Save Preset to path
+     * @param filePath Path to the new file
+     * @returns
+     */
+    savePreset: (filePath: string) => Promise<any>;
+    saveAsPreset: (filePath: string) => Promise<any>;
+    /**
+     * Delete Preset at given path
+     * @param filePath
+     * @returns
+     */
+    deletePreset: (filePath: string) => Promise<any>;
+    /**
+     * Reset an instrument property back to value provided by Preset
+     * @param propertyName
+     * @returns
+     */
+    resetInstrumentProperty: (propertyName: string) => void;
+    /**
+     * Load previous Preset
+     * @returns
+     */
+    prevPreset: () => void;
+    /**
+     * Load next Preset
+     * @returns
+     */
+    nextPreset: () => void;
+    /**
+     * Load a random Preset
+     * @returns
+     */
+    randomize: () => void;
+    /**
+     * Load a random preset within the same category as the current one
+     * @returns
+     */
+    randomizeInCategory: () => void;
+};
+/**
+ * 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>
+ *   );
+ * }
+ * ```
+ */
+export declare function useSessionAndPresets(): UseSessionAndPresetsReturnValue;
+export {};