@blibliki/engine 0.3.5 → 0.3.7

package/src/modules/MidiSelector.ts

@@ -1,6 +1,6 @@
-import { IModule, Module, MidiOutput } from "@/core";
+import { IModule, Module, MidiOutput, SetterHooks } from "@/core";
 import MidiEvent from "@/core/midi/MidiEvent";
-import { PropSchema } from "@/core/schema";
+import { ModulePropSchema } from "@/core/schema";
 import { ICreateModule, ModuleType } from ".";
 
 export type IMidiSelector = IModule<ModuleType.MidiSelector>;
@@ -8,7 +8,7 @@ export type IMidiSelectorProps = {
   selectedId: string | undefined | null;
 };
 
-export const midiSelectorPropSchema: PropSchema<IMidiSelectorProps> = {
+export const midiSelectorPropSchema: ModulePropSchema<IMidiSelectorProps> = {
   selectedId: {
     kind: "string",
     label: "Midi device ID",
@@ -17,7 +17,10 @@ export const midiSelectorPropSchema: PropSchema<IMidiSelectorProps> = {
 
 const DEFAULT_PROPS: IMidiSelectorProps = { selectedId: undefined };
 
-export default class MidiSelector extends Module<ModuleType.MidiSelector> {
+export default class MidiSelector
+  extends Module<ModuleType.MidiSelector>
+  implements Pick<SetterHooks<IMidiSelectorProps>, "onSetSelectedId">
+{
   declare audioNode: undefined;
   midiOutput!: MidiOutput;
   _forwardMidiEvent?: (midiEvent: MidiEvent) => void;
@@ -38,12 +41,14 @@ export default class MidiSelector extends Module<ModuleType.MidiSelector> {
     this.registerOutputs();
   }
 
-  protected onSetSelectedId(value: string | null) {
-    if (!this.superInitialized) return;
-
+  onSetSelectedId: SetterHooks<IMidiSelectorProps>["onSetSelectedId"] = (
+    value,
+  ) => {
     this.removeEventListener();
     this.addEventListener(value);
-  }
+
+    return value;
+  };
 
   private get forwardMidiEvent() {
     if (this._forwardMidiEvent) return this._forwardMidiEvent;

package/src/modules/Oscillator.ts

@@ -2,9 +2,9 @@ import { ContextTime } from "@blibliki/transport";
 import { Context, dbToGain } from "@blibliki/utils";
 import { IModule, Module } from "@/core";
 import Note from "@/core/Note";
-import { IModuleConstructor } from "@/core/module/Module";
+import { IModuleConstructor, SetterHooks } from "@/core/module/Module";
 import { IPolyModuleConstructor, PolyModule } from "@/core/module/PolyModule";
-import { PropSchema } from "@/core/schema";
+import { EnumProp, ModulePropSchema } from "@/core/schema";
 import { ICreateModule, ModuleType } from ".";
 
 const LOW_GAIN = -18;
@@ -38,7 +38,12 @@ export type IOscillatorProps = {
   lowGain: boolean;
 };
 
-export const oscillatorPropSchema: PropSchema<IOscillatorProps> = {
+export const oscillatorPropSchema: ModulePropSchema<
+  IOscillatorProps,
+  {
+    wave: EnumProp<OscillatorWave>;
+  }
+> = {
   wave: {
     kind: "enum",
     options: Object.values(OscillatorWave),
@@ -67,8 +72,8 @@ export const oscillatorPropSchema: PropSchema<IOscillatorProps> = {
   },
   octave: {
     kind: "number",
-    min: -4,
-    max: 4,
+    min: -1,
+    max: 2,
     step: 1,
     label: "Octave",
   },
@@ -87,7 +92,20 @@ const DEFAULT_PROPS: IOscillatorProps = {
   lowGain: false,
 };
 
-export class MonoOscillator extends Module<ModuleType.Oscillator> {
+type OscillatorSetterHooks = Pick<
+  SetterHooks<IOscillatorProps>,
+  | "onAfterSetWave"
+  | "onAfterSetFrequency"
+  | "onAfterSetFine"
+  | "onAfterSetCoarse"
+  | "onAfterSetOctave"
+  | "onAfterSetLowGain"
+>;
+
+export class MonoOscillator
+  extends Module<ModuleType.Oscillator>
+  implements OscillatorSetterHooks
+{
   declare audioNode: OscillatorNode;
   isStated = false;
   lowOutputGain: GainNode;
@@ -114,31 +132,29 @@ export class MonoOscillator extends Module<ModuleType.Oscillator> {
     this.registerOutputs();
   }
 
-  protected onAfterSetWave(value: OscillatorWave) {
+  onAfterSetWave: OscillatorSetterHooks["onAfterSetWave"] = (value) => {
     this.audioNode.type = value;
-  }
+  };
 
-  protected onAfterSetFrequency() {
+  onAfterSetFrequency: OscillatorSetterHooks["onAfterSetFrequency"] = () => {
     this.updateFrequency();
-  }
+  };
 
-  protected onAfterSetFine() {
+  onAfterSetFine: OscillatorSetterHooks["onAfterSetFine"] = () => {
     this.updateFrequency();
-  }
+  };
 
-  protected onAfterSetCoarse() {
+  onAfterSetCoarse: OscillatorSetterHooks["onAfterSetCoarse"] = () => {
     this.updateFrequency();
-  }
+  };
 
-  protected onAfterSetOctave() {
+  onAfterSetOctave: OscillatorSetterHooks["onAfterSetOctave"] = () => {
     this.updateFrequency();
-  }
-
-  protected onAfterSetLowGain() {
-    if (!this.superInitialized) return;
+  };
 
+  onAfterSetLowGain: OscillatorSetterHooks["onAfterSetLowGain"] = () => {
     this.rePlugAll();
-  }
+  };
 
   start(time: ContextTime) {
     if (this.isStated) return;
@@ -148,6 +164,8 @@ export class MonoOscillator extends Module<ModuleType.Oscillator> {
   }
 
   stop(time: ContextTime) {
+    if (!this.isStated) return;
+
     this.audioNode.stop(time);
     this.rePlugAll(() => {
       this.audioNode = new OscillatorNode(this.context.audioContext, {
@@ -183,7 +201,6 @@ export class MonoOscillator extends Module<ModuleType.Oscillator> {
 
   private get finalFrequency(): number | undefined {
     const { frequency, coarse, octave, fine } = this.props;
-    if (!this.superInitialized) return;
 
     const transposed =
       frequency * Math.pow(2, coarse / 12 + octave + fine / 12);

package/src/modules/Scale.ts

@@ -1,6 +1,6 @@
 import { Context } from "@blibliki/utils";
-import { IModule, Module } from "@/core";
-import { PropSchema } from "@/core/schema";
+import { IModule, Module, SetterHooks } from "@/core";
+import { ModulePropSchema } from "@/core/schema";
 import { CustomWorklet, newAudioWorklet } from "@/processors";
 import { ICreateModule, ModuleType } from ".";
 
@@ -11,7 +11,7 @@ export type IScaleProps = {
   current: number;
 };
 
-export const scalePropSchema: PropSchema<IScaleProps> = {
+export const scalePropSchema: ModulePropSchema<IScaleProps> = {
   min: {
     kind: "number",
     min: -Infinity,
@@ -37,7 +37,14 @@ export const scalePropSchema: PropSchema<IScaleProps> = {
 
 const DEFAULT_PROPS: IScaleProps = { min: 0, max: 1, current: 0.5 };
 
-export default class Scale extends Module<ModuleType.Scale> {
+export default class Scale
+  extends Module<ModuleType.Scale>
+  implements
+    Pick<
+      SetterHooks<IScaleProps>,
+      "onAfterSetMin" | "onAfterSetMax" | "onAfterSetCurrent"
+    >
+{
   declare audioNode: AudioWorkletNode;
 
   constructor(engineId: string, params: ICreateModule<ModuleType.Scale>) {
@@ -66,15 +73,17 @@ export default class Scale extends Module<ModuleType.Scale> {
     return this.audioNode.parameters.get("max")!;
   }
 
-  protected onSetMin(value: number) {
+  onAfterSetMin: SetterHooks<IScaleProps>["onAfterSetMin"] = (value) => {
     this.min.value = value;
-  }
+  };
 
-  protected onSetMax(value: number) {
+  onAfterSetMax: SetterHooks<IScaleProps>["onAfterSetMax"] = (value) => {
     this.max.value = value;
-  }
+  };
 
-  protected onSetCurrent(value: number) {
+  onAfterSetCurrent: SetterHooks<IScaleProps>["onAfterSetCurrent"] = (
+    value,
+  ) => {
     this.current.value = value;
-  }
+  };
 }

package/src/modules/StepSequencer.ts

@@ -1,4 +1,4 @@
-import { INote, PropSchema, Module, IModule, MidiOutput } from "@/core";
+import { INote, Module, IModule, MidiOutput, ModulePropSchema } from "@/core";
 import { ICreateModule, ModuleType } from ".";
 
 export type IStepSequencer = IModule<ModuleType.StepSequencer>;
@@ -16,7 +16,7 @@ export type IStepSequencerProps = {
   sequences: ISequence[][];
 };
 
-export const stepSequencerPropSchema: PropSchema<
+export const stepSequencerPropSchema: ModulePropSchema<
   Omit<IStepSequencerProps, "sequences">
 > = {
   steps: {

package/src/modules/StereoPanner.ts

@@ -0,0 +1,86 @@
+import { Context } from "@blibliki/utils";
+import { IModule, Module, ModulePropSchema } from "@/core";
+import { IModuleConstructor, SetterHooks } from "@/core/module/Module";
+import { IPolyModuleConstructor, PolyModule } from "@/core/module/PolyModule";
+import { ICreateModule, ModuleType } from ".";
+
+export type IStereoPanner = IModule<ModuleType.StereoPanner>;
+export type IStereoPannerProps = {
+  pan: number;
+};
+
+export const stereoPannerPropSchema: ModulePropSchema<IStereoPannerProps> = {
+  pan: {
+    kind: "number",
+    min: -1,
+    max: 1,
+    step: 0.01,
+    label: "Pan",
+  },
+};
+
+const DEFAULT_PROPS: IStereoPannerProps = {
+  pan: 0,
+};
+
+export class MonoStereoPanner
+  extends Module<ModuleType.StereoPanner>
+  implements Pick<SetterHooks<IStereoPannerProps>, "onAfterSetPan">
+{
+  declare audioNode: StereoPannerNode;
+
+  constructor(
+    engineId: string,
+    params: ICreateModule<ModuleType.StereoPanner>,
+  ) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+    const audioNodeConstructor = (context: Context) =>
+      new StereoPannerNode(context.audioContext);
+
+    super(engineId, {
+      ...params,
+      audioNodeConstructor,
+      props,
+    });
+
+    this.registerDefaultIOs();
+    this.registerAdditionalInputs();
+  }
+
+  onAfterSetPan: SetterHooks<IStereoPannerProps>["onAfterSetPan"] = (value) => {
+    this.audioNode.pan.value = value;
+  };
+
+  private registerAdditionalInputs() {
+    this.registerAudioInput({
+      name: "pan",
+      getAudioNode: () => this.audioNode.pan,
+    });
+  }
+}
+
+export default class StereoPanner extends PolyModule<ModuleType.StereoPanner> {
+  constructor(
+    engineId: string,
+    params: IPolyModuleConstructor<ModuleType.StereoPanner>,
+  ) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+    const monoModuleConstructor = (
+      engineId: string,
+      params: IModuleConstructor<ModuleType.StereoPanner>,
+    ) => new MonoStereoPanner(engineId, params);
+
+    super(engineId, {
+      ...params,
+      props,
+      monoModuleConstructor,
+    });
+
+    this.registerAdditionalInputs();
+    this.registerDefaultIOs();
+  }
+
+  private registerAdditionalInputs() {
+    this.registerAudioInput({ name: "pan" });
+  }
+}

package/src/modules/VirtualMidi.ts

@@ -1,5 +1,5 @@
 import { ContextTime } from "@blibliki/transport";
-import { PropSchema, Module, IModule, MidiOutput, Note } from "@/core";
+import { Module, IModule, MidiOutput, Note, ModulePropSchema } from "@/core";
 import MidiEvent from "@/core/midi/MidiEvent";
 import { ICreateModule, ModuleType } from ".";
 
@@ -8,7 +8,7 @@ export type IVirtualMidiProps = {
   activeNotes: string[];
 };
 
-export const virtualMidiPropSchema: PropSchema<IVirtualMidiProps> = {
+export const virtualMidiPropSchema: ModulePropSchema<IVirtualMidiProps> = {
   activeNotes: {
     kind: "array",
     label: "Active notes",

package/src/modules/index.ts

@@ -1,20 +1,20 @@
 import { assertNever } from "@blibliki/utils";
-import { IModule, Module, PropSchema } from "@/core";
+import { IModule, Module } from "@/core";
 import { IPolyModuleConstructor } from "@/core/module/PolyModule";
 import VoiceScheduler, {
   IVoiceSchedulerProps,
   voiceSchedulerPropSchema,
 } from "@/core/module/VoiceScheduler";
-import BiquadFilter, {
-  biquadFilterPropSchema,
-  IBiquadFilterProps,
-} from "./BiquadFilter";
 import Constant, { constantPropSchema, IConstantProps } from "./Constant";
 import Envelope, { envelopePropSchema, IEnvelopeProps } from "./Envelope";
 import Filter, { filterPropSchema, IFilterProps } from "./Filter";
 import Gain, { gainPropSchema, IGainProps } from "./Gain";
 import Inspector, { IInspectorProps, inspectorPropSchema } from "./Inspector";
 import Master, { IMasterProps, masterPropSchema } from "./Master";
+import MidiMapper, {
+  IMidiMapperProps,
+  midiMapperPropSchema,
+} from "./MidiMapper";
 import MidiSelector, {
   IMidiSelectorProps,
   midiSelectorPropSchema,
@@ -28,6 +28,10 @@ import StepSequencer, {
   IStepSequencerProps,
   stepSequencerPropSchema,
 } from "./StepSequencer";
+import StereoPanner, {
+  IStereoPannerProps,
+  stereoPannerPropSchema,
+} from "./StereoPanner";
 import VirtualMidi, {
   IVirtualMidiProps,
   virtualMidiPropSchema,
@@ -40,10 +44,11 @@ export enum ModuleType {
   MidiSelector = "MidiSelector",
   Envelope = "Envelope",
   Filter = "Filter",
-  BiquadFilter = "BiquadFilter",
   Scale = "Scale",
+  StereoPanner = "StereoPanner",
   Inspector = "Inspector",
   Constant = "Constant",
+  MidiMapper = "MidiMapper",
   VirtualMidi = "VirtualMidi",
   StepSequencer = "StepSequencer",
   VoiceScheduler = "VoiceScheduler",
@@ -56,10 +61,11 @@ export type ModuleTypeToPropsMapping = {
   [ModuleType.MidiSelector]: IMidiSelectorProps;
   [ModuleType.Envelope]: IEnvelopeProps;
   [ModuleType.Filter]: IFilterProps;
-  [ModuleType.BiquadFilter]: IBiquadFilterProps;
   [ModuleType.Scale]: IScaleProps;
+  [ModuleType.StereoPanner]: IStereoPannerProps;
   [ModuleType.Inspector]: IInspectorProps;
   [ModuleType.Constant]: IConstantProps;
+  [ModuleType.MidiMapper]: IMidiMapperProps;
   [ModuleType.VirtualMidi]: IVirtualMidiProps;
   [ModuleType.StepSequencer]: IStepSequencerProps;
   [ModuleType.VoiceScheduler]: IVoiceSchedulerProps;
@@ -72,28 +78,28 @@ export type ModuleTypeToModuleMapping = {
   [ModuleType.MidiSelector]: MidiSelector;
   [ModuleType.Envelope]: Envelope;
   [ModuleType.Filter]: Filter;
-  [ModuleType.BiquadFilter]: BiquadFilter;
   [ModuleType.Scale]: Scale;
+  [ModuleType.StereoPanner]: StereoPanner;
   [ModuleType.Inspector]: Inspector;
   [ModuleType.Constant]: Constant;
+  [ModuleType.MidiMapper]: MidiMapper;
   [ModuleType.VirtualMidi]: VirtualMidi;
   [ModuleType.StepSequencer]: StepSequencer;
   [ModuleType.VoiceScheduler]: VoiceScheduler;
 };
 
-export const moduleSchemas: {
-  [K in ModuleType]: PropSchema<Partial<ModuleTypeToPropsMapping[K]>>;
-} = {
+export const moduleSchemas = {
   [ModuleType.Oscillator]: oscillatorPropSchema,
   [ModuleType.Gain]: gainPropSchema,
   [ModuleType.Master]: masterPropSchema,
   [ModuleType.MidiSelector]: midiSelectorPropSchema,
   [ModuleType.Envelope]: envelopePropSchema,
   [ModuleType.Filter]: filterPropSchema,
-  [ModuleType.BiquadFilter]: biquadFilterPropSchema,
   [ModuleType.Scale]: scalePropSchema,
+  [ModuleType.StereoPanner]: stereoPannerPropSchema,
   [ModuleType.Inspector]: inspectorPropSchema,
   [ModuleType.Constant]: constantPropSchema,
+  [ModuleType.MidiMapper]: midiMapperPropSchema,
   [ModuleType.VirtualMidi]: virtualMidiPropSchema,
   [ModuleType.StepSequencer]: stepSequencerPropSchema,
   [ModuleType.VoiceScheduler]: voiceSchedulerPropSchema,
@@ -104,11 +110,14 @@ export { OscillatorWave } from "./Oscillator";
 export type { IGain } from "./Gain";
 export type { IMaster } from "./Master";
 export type { IMidiSelector } from "./MidiSelector";
+export type { IStereoPanner } from "./StereoPanner";
 export type {
   IStepSequencer,
   IStepSequencerProps,
   ISequence,
 } from "./StepSequencer";
+export type { IMidiMapper, IMidiMapperProps, MidiMapping } from "./MidiMapper";
+export { MidiMappingMode } from "./MidiMapper";
 
 export type AnyModule = Module<ModuleType>;
 export type IAnyModule = IModule<ModuleType>;
@@ -126,7 +135,7 @@ export type ModuleParams = {
     | ModuleType.Gain
     | ModuleType.Envelope
     | ModuleType.Filter
-    | ModuleType.BiquadFilter
+    | ModuleType.StereoPanner
     | ModuleType.VoiceScheduler
     ? IPolyModuleConstructor<K>
     : ICreateModule<K>;
@@ -149,14 +158,16 @@ export function createModule(
       return new Envelope(engineId, params);
     case ModuleType.Filter:
       return new Filter(engineId, params);
-    case ModuleType.BiquadFilter:
-      return new BiquadFilter(engineId, params);
     case ModuleType.Scale:
       return new Scale(engineId, params);
+    case ModuleType.StereoPanner:
+      return new StereoPanner(engineId, params);
     case ModuleType.Inspector:
       return new Inspector(engineId, params);
     case ModuleType.Constant:
       return new Constant(engineId, params);
+    case ModuleType.MidiMapper:
+      return new MidiMapper(engineId, params);
     case ModuleType.VirtualMidi:
       return new VirtualMidi(engineId, params);
     case ModuleType.StepSequencer:

package/src/modules/BiquadFilter.ts

@@ -1,162 +0,0 @@
-import { Context } from "@blibliki/utils";
-import { IModuleConstructor, Module } from "@/core/module/Module";
-import { IPolyModuleConstructor, PolyModule } from "@/core/module/PolyModule";
-import { PropSchema } from "@/core/schema";
-import { createModule, ICreateModule, ModuleType } from ".";
-import { MonoGain } from "./Gain";
-import Scale from "./Scale";
-
-export type IBiquadFilterProps = {
-  cutoff: number;
-  envelopeAmount: number;
-  type: BiquadFilterType;
-  Q: number;
-};
-
-const MIN_FREQ = 20;
-const MAX_FREQ = 20000;
-
-const DEFAULT_PROPS: IBiquadFilterProps = {
-  cutoff: MAX_FREQ,
-  envelopeAmount: 0,
-  type: "lowpass",
-  Q: 1,
-};
-
-export const biquadFilterPropSchema: PropSchema<IBiquadFilterProps> = {
-  cutoff: {
-    kind: "number",
-    min: MIN_FREQ,
-    max: MAX_FREQ,
-    step: 1,
-    label: "Cutoff",
-  },
-  envelopeAmount: {
-    kind: "number",
-    min: -1,
-    max: 1,
-    step: 0.01,
-    label: "Envelope Amount",
-  },
-  type: {
-    kind: "enum",
-    options: ["lowpass", "highpass", "bandpass"] satisfies BiquadFilterType[],
-    label: "Type",
-  },
-  Q: {
-    kind: "number",
-    min: -100,
-    max: 100,
-    step: 0.1,
-    label: "Q",
-  },
-};
-
-class MonoBiquadFilter extends Module<ModuleType.BiquadFilter> {
-  declare audioNode: BiquadFilterNode;
-  private scale: Scale;
-  private amount: MonoGain;
-
-  constructor(
-    engineId: string,
-    params: ICreateModule<ModuleType.BiquadFilter>,
-  ) {
-    const props = { ...DEFAULT_PROPS, ...params.props };
-
-    const audioNodeConstructor = (context: Context) =>
-      new BiquadFilterNode(context.audioContext, {
-        type: props.type,
-        frequency: props.cutoff,
-        Q: props.Q,
-      });
-
-    super(engineId, {
-      ...params,
-      props,
-      audioNodeConstructor,
-    });
-
-    this.amount = new MonoGain(engineId, {
-      name: "amount",
-      moduleType: ModuleType.Gain,
-      props: { gain: props.envelopeAmount },
-    });
-
-    this.scale = createModule(engineId, {
-      name: "scale",
-      moduleType: ModuleType.Scale,
-      props: { min: MIN_FREQ, max: MAX_FREQ, current: this.props.cutoff },
-    }) as Scale;
-
-    this.amount.plug({ audioModule: this.scale, from: "out", to: "in" });
-    this.scale.audioNode.connect(this.audioNode.frequency);
-
-    this.registerDefaultIOs();
-    this.registerInputs();
-  }
-
-  protected onSetType(value: IBiquadFilterProps["type"]) {
-    this.audioNode.type = value;
-  }
-
-  protected onSetCutoff(value: IBiquadFilterProps["cutoff"]) {
-    if (!this.superInitialized) return;
-
-    this.scale.props = { current: value };
-  }
-
-  protected onSetQ(value: IBiquadFilterProps["Q"]) {
-    this.audioNode.Q.value = value;
-  }
-
-  protected onSetEnvelopeAmount(value: IBiquadFilterProps["envelopeAmount"]) {
-    if (!this.superInitialized) return;
-
-    this.amount.props = { gain: value };
-  }
-
-  private registerInputs() {
-    this.registerAudioInput({
-      name: "cutoff",
-      getAudioNode: () => this.audioNode.frequency,
-    });
-
-    this.registerAudioInput({
-      name: "cutoffMod",
-      getAudioNode: () => this.amount.audioNode,
-    });
-
-    this.registerAudioInput({
-      name: "Q",
-      getAudioNode: () => this.audioNode.Q,
-    });
-  }
-}
-
-export default class BiquadFilter extends PolyModule<ModuleType.BiquadFilter> {
-  constructor(
-    engineId: string,
-    params: IPolyModuleConstructor<ModuleType.BiquadFilter>,
-  ) {
-    const props = { ...DEFAULT_PROPS, ...params.props };
-    const monoModuleConstructor = (
-      engineId: string,
-      params: IModuleConstructor<ModuleType.BiquadFilter>,
-    ) => new MonoBiquadFilter(engineId, params);
-
-    super(engineId, {
-      ...params,
-      props,
-      monoModuleConstructor,
-    });
-
-    this.registerInputs();
-    this.registerDefaultIOs();
-  }
-
-  private registerInputs() {
-    this.registerAudioInput({ name: "cutoff" });
-    this.registerAudioInput({ name: "cutoffMod" });
-    this.registerAudioInput({ name: "Q" });
-  }
-}