@types/gorilla-engine 1.1.15 → 1.1.17

gorilla-engine/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for gorilla-engine (https://gorilla-engin
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/gorilla-engine.
 
 ### Additional Details
- * Last updated: Tue, 30 Jan 2024 21:35:45 GMT
+ * Last updated: Thu, 22 Feb 2024 16:07:11 GMT
  * Dependencies: none
 
 # Credits

gorilla-engine/components/AmpEnv.d.ts

@@ -22,6 +22,7 @@ declare namespace GorillaEngine.UI {
         }>;
     }
 
+    // tslint:disable-next-line:no-empty-interface
     interface AmpEnv extends AmpEnvProps {}
     class AmpEnv extends Component {
         constructor(options: Partial<AmpEnvProps>);

gorilla-engine/components/BarStepEditor.d.ts

@@ -24,5 +24,6 @@ declare namespace GorillaEngine.UI {
     class BarStepEditor extends Component {
         constructor(options: Partial<BarStepEditorProps>);
     }
+    // tslint:disable-next-line:no-empty-interface
     interface BarStepEditor extends BarStepEditorProps {}
 }

gorilla-engine/components/ComboBox.d.ts

@@ -57,6 +57,7 @@ declare namespace GorillaEngine.UI {
         subPopup: Partial<ComboBoxPopupStyles>;
     }
 
+    // tslint:disable-next-line:no-empty-interface
     interface ComboBox extends ComboBoxProps {}
     class ComboBox extends Component {
         onChange?: (value: number) => void;

gorilla-engine/components/DragContainer.d.ts

@@ -11,6 +11,7 @@ declare namespace GorillaEngine.UI {
         onExternalDragEnd: string;
     }
 
+    // tslint:disable-next-line:no-empty-interface
     interface DragContainer extends DragContainerProps {}
 
     class DragContainer extends Component {

gorilla-engine/components/DragTarget.d.ts

@@ -8,5 +8,6 @@ declare namespace GorillaEngine.UI {
         constructor(options: Partial<DragTargetProps>);
     }
 
+    // tslint:disable-next-line:no-empty-interface
     interface DragTarget extends DragTargetProps {}
 }

gorilla-engine/components/DropZone.d.ts

@@ -5,6 +5,7 @@ declare namespace GorillaEngine.UI {
         onDroppedFile: string;
     }
 
+    // tslint:disable-next-line:no-empty-interface
     interface DropZone extends DropZoneProps {}
 
     class DropZone extends Component {

gorilla-engine/components/Knob.d.ts

@@ -13,6 +13,7 @@ declare namespace GorillaEngine.UI {
         maxRotation: number;
     }
 
+    // tslint:disable-next-line:no-empty-interface
     interface Knob extends KnobProps {}
     class Knob extends Component {
         constructor(options: Partial<KnobProps>);

gorilla-engine/components/Label.d.ts

@@ -13,5 +13,6 @@ declare namespace GorillaEngine.UI {
     class Label extends Component {
         constructor(options: Partial<LabelProps>);
     }
+    // tslint:disable-next-line:no-empty-interface
     interface Label extends LabelProps {}
 }

gorilla-engine/components/LevelMeter.d.ts

@@ -20,6 +20,7 @@ declare namespace GorillaEngine.UI {
         value: any;
     }
 
+    // tslint:disable-next-line:no-empty-interface
     interface LevelMeter extends LevelMeterProps {}
 
     class LevelMeter extends Component {

gorilla-engine/components/ListBox.d.ts

@@ -10,6 +10,7 @@ declare namespace GorillaEngine.UI {
         rowClickedAction?: string;
     }
 
+    // tslint:disable-next-line:no-empty-interface
     interface ListBox extends ListBoxProps {}
     class ListBox extends Component {
         constructor(options: Partial<ListBoxProps>);

gorilla-engine/components/LottieAnimation.d.ts

@@ -32,5 +32,6 @@ declare namespace GorillaEngine.UI {
     class LottieAnimation extends Component {
         constructor(options: Partial<LottieAnimationProps>);
     }
+    // tslint:disable-next-line:no-empty-interface
     interface LottieAnimation extends LottieAnimationProps {}
 }

gorilla-engine/components/MidiKeyboard.d.ts

@@ -29,6 +29,7 @@ declare namespace GorillaEngine.UI {
         keys: Partial<MidiKeyboardKeys>;
     }
 
+    // tslint:disable-next-line:no-empty-interface
     interface MidiKeyboard extends MidiKeyboardProps {}
 
     class MidiKeyboard extends Component {

gorilla-engine/components/Pad.d.ts

@@ -10,6 +10,7 @@ declare namespace GorillaEngine.UI {
         }>;
     }
 
+    // tslint:disable-next-line:no-empty-interface
     interface Pad extends PadProps {}
     class Pad extends Component {
         constructor(options: Partial<PadProps>);

gorilla-engine/components/Rubberband.d.ts

@@ -5,5 +5,6 @@ declare namespace GorillaEngine.UI {
     class Rubberband extends Component {
         constructor(options: Partial<RubberbandProps>);
     }
+    // tslint:disable-next-line:no-empty-interface
     interface Rubberband extends RubberbandProps {}
 }

gorilla-engine/components/ScrollView.d.ts

@@ -11,5 +11,6 @@ declare namespace GorillaEngine.UI {
     class ScrollView extends Component {
         constructor(options: Partial<ScrollViewProps>);
     }
+    // tslint:disable-next-line:no-empty-interface
     interface ScrollView extends ScrollViewProps {}
 }

gorilla-engine/components/SliceEditor.d.ts

@@ -133,6 +133,7 @@ declare namespace GorillaEngine.UI {
         modulations: Modulation[];
     }
 
+    // tslint:disable-next-line:no-empty-interface
     interface SliceEditor extends SliceEditorProps {}
 
     class SliceEditor extends Component {

gorilla-engine/components/Slider.d.ts

@@ -17,5 +17,6 @@ declare namespace GorillaEngine.UI {
     class Slider extends Component {
         constructor(options: Partial<SliderProps>);
     }
+    // tslint:disable-next-line:no-empty-interface
     interface Slider extends SliderProps {}
 }

gorilla-engine/components/StepEditor.d.ts

@@ -24,6 +24,7 @@ declare namespace GorillaEngine.UI {
         }>;
     }
 
+    // tslint:disable-next-line:no-empty-interface
     interface StepEditor extends StepEditorProps {}
     class StepEditor extends Component {
         constructor(options: Partial<StepEditorProps>);

gorilla-engine/components/TagBrowser.d.ts

@@ -7,5 +7,6 @@ declare namespace GorillaEngine.UI {
     class TagBrowser extends Component {
         constructor(options: Partial<TagBrowserProps>);
     }
+    // tslint:disable-next-line:no-empty-interface
     interface TagBrowser extends TagBrowserProps {}
 }

gorilla-engine/components/TagEditor.d.ts

@@ -10,5 +10,6 @@ declare namespace GorillaEngine.UI {
     class TagEditor extends Component {
         constructor(options: Partial<TagEditorProps>);
     }
+    // tslint:disable-next-line:no-empty-interface
     interface TagEditor extends TagEditorProps {}
 }

gorilla-engine/components/Toggle.d.ts

@@ -23,6 +23,7 @@ declare namespace GorillaEngine.UI {
         value: boolean;
         animation: LottieAnimation;
     }
+    // tslint:disable-next-line:no-empty-interface
     interface Toggle extends ToggleProps {}
     class Toggle extends Component {
         constructor(options: Partial<ToggleProps>);

gorilla-engine/components/Trigger.d.ts

@@ -9,7 +9,7 @@ declare namespace GorillaEngine.UI {
         };
         animation: LottieAnimation;
     }
-
+    // tslint:disable-next-line:no-empty-interface
     interface Trigger extends TriggerProps {}
     class Trigger extends Component {
         constructor(options: Partial<TriggerProps>);

gorilla-engine/components/Waveform.d.ts

@@ -52,6 +52,7 @@ declare namespace GorillaEngine.UI {
         markers: Partial<WaveformMarker>;
     }
 
+    // tslint:disable-next-line:no-empty-interface
     interface Waveform extends WaveformProps {}
     class Waveform extends Component {
         constructor(options: Partial<WaveformProps>);

gorilla-engine/components/Window.d.ts

@@ -6,6 +6,7 @@ declare namespace GorillaEngine.UI {
         uiScaleMin: number;
         uiScaleMax: number;
     }
+    // tslint:disable-next-line:no-empty-interface
     interface Window extends WindowProps {}
     class Window extends Component {
         constructor(options: Partial<WindowProps>);

gorilla-engine/components/XYPad.d.ts

@@ -12,6 +12,7 @@ declare namespace GorillaEngine.UI {
         thumbImage: string;
     }
 
+    // tslint:disable-next-line:no-empty-interface
     interface XYPad extends XYPadProps {}
     class XYPad extends Component {
         constructor(options: Partial<XYPadProps>);

gorilla-engine/index.d.ts

@@ -94,11 +94,40 @@ declare namespace GorillaEngine {
          * Its steps if it's a stepped paramter
          */
         readonly steps: string[];
+        /**
+         * Hint for the best type of UI control for this parameter:
+         * "default": usually a knob, could also be a slider or drag/spin control
+         * "volume": audio volume control down to silence, often a vertical slider but could be horizontal or a knob
+         * "drag": more suited to a drag/spin control because usually only a small part of the range is used
+         * "keySelect": select a MIDI note
+         * "outSelect": select an audio output (zero for default, negative values for internal busses)
+         * "modSource": select from a list of mod sources (where mod source names should be inserted instead of numbers)
+         * "voiceGroup": select from a list of voice groups (where voice group names should be inserted instead of numbers)
+         * (the above types can fall back to e.g. ControlTypeDrag if no special behaviour is implemented for them in the UI)
+         * "onOffSwitch": toggle between Off/On (could be a power switch or \"Bypass\" or \"Solo\" etc. - see parameter name)
+         * "switch": toggle between two values that are not Off/On, could also be displayed as a menu
+         * "menu": dropdown menu, could also be a multi-way switch or a stepped knob if there are not many steps
+         * "levelMeter": audio level meter: display should apply log scaling (may have multiple channels)
+         * "meter": meter that may be showing something other than audio level (may have multiple channels)
+         * "display": numeric or text display: value is not user editable
+         * "text": editable text
+         * "textBox": multi-line text with at least copy/paste of the whole text, if not full editing
+         * "array": edit multiple values e.g. as a bargraph
+         * "waveform": display a waveform overview
+         * "notVisible": not intended for display to the user
+         */
+        readonly controlType: string[];
         readonly persistence: InstrumentPropertyPersistence;
     }
 
     interface ccState {
+        /**
+         * MIDI CC number in the range of 1-119
+         */
         cc: number;
+        /**
+         * Path in the instrument, e.g. `Scripts/0/Volume`
+         */
         path: string;
     }
 
@@ -113,7 +142,23 @@ declare namespace GorillaEngine {
      * Instrument
      */
     interface Instrument {
-        on(propName: string, handler: (normValue: number) => void): void;
+        /**
+         * Attach an event listener to an instrument parameter. Whenever the instrument parameter
+         * changes the callback will be called with the current normalized value of the parameter.
+         * Does not trigger for meter parameters.
+         * @param paramName the instrument parameter name
+         * @param handler the callback
+         * @returns `1` when the handler was successfully attached
+         */
+        on(paramName: string, handler: (normValue: number) => void): number;
+        /**
+         * Dettach one or multiple event listeners for an instrument parameter. Pass in a reference
+         * to the callback to remove a specific listener. If no callback is passed then all listeners
+         * for that parameter are removed
+         * @param paramName
+         * @returns the number of removed listeners
+         */
+        off(paramName: string, handler?: (normValue: number) => void): number;
         /**
          * Method used to retrieve a serialised module from the Gorilla Engine.
          *
@@ -256,21 +301,21 @@ declare namespace GorillaEngine {
         removeModuleAtPath(path: string): boolean;
 
         /**
-         * Method used to set a normalised double at a ceterain path in the Gorilla Engine.
+         * Method used to set a normalized double at a ceterain path in the Gorilla Engine.
          *
          * @param path The path to the normalised double that should be set.
          * @param value The normalised double that should be set at the given `path`.
          * @returns `true` if the value has been set succcessfully or `false` otherwise.
          */
-        setNormalisedDoubleAtPath(path: string, value: number): boolean;
+        setNormalizedDoubleAtPath(path: string, value: number): boolean;
 
         /**
-         * Method used to retrieve a normalised double from the Gorilla Engine.
+         * Method used to retrieve a normalized double from the Gorilla Engine.
          *
-         * @param path The path to the normalised double should be retrieved.
+         * @param path The path to the normalised double that should be retrieved.
          * @returns The normalised double found at the given `path` or `false` if nothing was found.
          */
-        getNormalisedDoubleAtPath(): number | boolean;
+        getNormalizedDoubleAtPath(): number | boolean;
 
         /**
          * Method used to retrieve MIDI data from the first instrument script that implements `on midi_drag`
@@ -306,8 +351,23 @@ declare namespace GorillaEngine {
          */
         valueToStringAtPath(path: string, value: number): boolean | string;
 
+        /**
+         * Method used to retrieve a string from the Gorilla Engine.
+         * @param path The path to the string that should be retrieved.
+         * @returns the string found at the given `path` or `false` if nothing was found.
+         */
+        getStringAtPath(path: string): string;
+
+        /**
+         * Get the current MIDI CC state
+         * @returns an array of MIDI CC to instrument path mappings
+         */
         getMIDICCstate(): ccState[];
 
+        /**
+         * Set the MIDI CC state
+         * @param ccMidiSatate an array of MIDI CC to instrument path mappings
+         */
         setMIDICCstate(ccMidiSatate: ccState[]): void;
 
         renderAudioFile(
@@ -325,10 +385,6 @@ declare namespace GorillaEngine {
             minFileLength: number,
         ): void;
 
-        setNormalizedDoubleAtPath(path: string, value: number): void;
-
-        getNormalizedDoubleAtPath(path: string): number;
-
         getLoadingStatus(): boolean;
 
         getLoadingProgressPercent(): number;
@@ -337,6 +393,15 @@ declare namespace GorillaEngine {
 
         endRecallingParameterState(): boolean;
 
+        /**
+         * Add an unconnected dynamic parameter.
+         * Persistence flags:
+         * Private       = 0x000
+         * ShowInHost    = 0x001
+         * SaveInSession = 0x002
+         * SaveInPreset  = 0x004
+         * @param persistence the or'd persistence flags of the parameter
+         */
         addParameter(persistence: number): InstrumentProperty;
 
         getWaveformOverview(
@@ -347,13 +412,18 @@ declare namespace GorillaEngine {
             vertZoom: number,
         ): Uint8Array;
 
-        getStringAtPath(path: string): string;
-
         getSampleMetadata(filePath: string, overviewSize: number): { metadata: string; overview: Uint8Array };
     }
 
     interface Blob {
+        /**
+         * Load the specified instrument
+         * @param name the name of the instrument to load
+         */
         loadInstrument(name: string): Instrument;
+        /**
+         * List all instrument names contained in this blob
+         */
         getInstrumentNames(): string[];
     }
 
@@ -362,12 +432,22 @@ declare namespace GorillaEngine {
     }
 
     function registerUncaughtUIExceptionCallback(handler: (err: Error) => void): void;
+    /**
+     * Get the platform specific path where all the resources (assets, blobs, etc.) have
+     * been installed to.
+     * @returns the resource path
+     */
     function getResourcePath(): string;
     function getPluginName(): string;
     function getPluginType(): string;
     function getPluginPath(): string;
-    function quitApplication(): void;
     function getManufacturerName(): string;
+    function quitApplication(): void;
+    /**
+     * Load blob at the specified path
+     * @param blobPath the load blob
+     * @throws if the blob could not be loaded e.g. it is not there or decryption failed
+     */
     function loadBlob(blobPath: string): Blob;
     function getPluginNRTB(enable: boolean): void;
     /**
@@ -387,19 +467,52 @@ declare namespace GorillaEngine {
     function showNativeMessageBoxSync(options: MessageBoxOptions): void;
     function showNativeMessageBox(options: MessageBoxOptions): Promise<void>;
     function calculateTextWidth(text: string, font: string, fontSize: number, fontKerning: number): Promise<number>;
+    /**
+     * If Codemeter is enabled this will check if a valid license is available. If it is
+     * then the MIDI and Audio will automatically be enabled if they were disabled.
+     * @returns `true` if a valid license has been found *or* codemeter is not enabled, `false` otherwise
+     */
     function checkLicense(): boolean;
-    function checkBeatportRTO(): string;
+    /**
+     * If Codemeter is enabled this will indicate if the license checked with {@link checkLicense} is
+     * a trial license
+     * @returns `true` if it is a trial license, `false` if it isn't *or* codemeter is not enabled
+     */
     function isTrial(): boolean;
+    /**
+     * If Codemeter is enabled this can be used to query the expiration timestamp of the running trial
+     * @returns the timestamp when the trial expires. If there is no trial or codemeter is not enabled
+     * this will return `0`
+     */
     function trialExpirationTimestamp(): number;
+    function checkBeatportRTO(): string;
     function initialiseSpliceRTO(pluginName?: string): any;
     function disposeInstrument(instrument: Instrument): void;
+    /**
+     * Activates an instrument, i.e. route MIDI to the instrument and send Audio from the isntrument to
+     * the DAW. Currently only one instrument can be active. If there was
+     * another instrument active before, it will get deativated.
+     * @param instrument the instrument activate
+     */
     function setActiveInstrument(instrument: Instrument): void;
+    /**
+     * Create an empty dummy instrument. It can be modified with e.g. {@link Instrument.setModuleAtPath}
+     * @returns the empty instrument.
+     */
     function createEmptyInstrument(): Instrument;
     function setSessionSaveCallback(callback: (state: string) => string, instance: any): void;
     function setSessionLoadCallback(callback: (state: string) => string, instance: any): void;
     function setParametersDirty(dirty: boolean): void;
     function areParametersDirty(): boolean;
+    /**
+     * Set this flag to indicate that {@link signalReady} will be called once the plugin
+     * initialization has completed.
+     */
     function shouldWaitForReadySignal(): void;
+    /**
+     * Signal that the initialization is done. If this is not called although {@link shouldWaitForReadySignal}
+     * has been called, then this will cause all sorts of problmes like hanging or half working DAWs
+     */
     function signalReady(): void;
     function setParametersDirtyCallback(callback: any): void;
     function getBuildInformation(): any;
@@ -432,8 +545,26 @@ declare namespace GorillaEngine {
     let sessionSaveLoadCallbackTimeoutMs: number;
 
     namespace UI {
+        /**
+         * Load a UI laid out in a yaml file
+         * @param ymlPath The path to yaml layout file
+         */
         function loadUIfromYAML(ymlPath: string): void;
+        /**
+         * Auto generate a generic UI based on the activate blob. Useful for prototyping
+         */
+        function autoGenerate(): void;
+        /**
+         * Get the control with the given id.
+         * @param id The id of the control
+         * @returns the control
+         * @throws when there is no control with the specified id
+         */
         function getControlById(id: string): Component;
+        /**
+         * Creates the window based on the passed in window control {@link GorillaEngine.UI.Window}.
+         * @param window the window to show
+         */
         function createWindow(window: Window): void;
     }
 }

gorilla-engine/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/gorilla-engine",
-    "version": "1.1.15",
+    "version": "1.1.17",
     "description": "TypeScript definitions for gorilla-engine",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/gorilla-engine",
     "license": "MIT",
@@ -45,7 +45,7 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "e0d162a02e883cbb186e54f77250d7ea5d1c34d47c18e5b6d839f7fc8c61cd61",
+    "typesPublisherContentHash": "27b30f376d60074704e9d017e48e6935268e2a7986fc6b24ba4d16eaa759f5dd",
     "typeScriptVersion": "4.6",
     "nonNpm": true
 }