@blibliki/engine 0.1.17 → 0.1.19

package/{build/Module → dist/build/modules}/Filter.d.ts

@@ -1,20 +1,19 @@
 import { Filter as InternalFilter, FilterRollOff } from "tone";
-import { FreqEnvelope, MonoFreqEnvelope } from "./Envelope";
-import Module, { Voicable } from "./Base";
-import PolyModule from "./PolyModule";
-interface FilterInterface extends Voicable {
+import Module, { PolyModule } from "../core/Module";
+interface FilterInterface {
     cutoff: number;
     filterType: BiquadFilterType;
     resonance: number;
     slope: FilterRollOff;
     envelopeAmount: number;
-    voiceNo?: number;
-}
-interface FilterProps extends Partial<FilterInterface> {
 }
+type FilterProps = Partial<FilterInterface>;
 declare class MonoFilter extends Module<InternalFilter, FilterInterface> {
-    private _envelope;
-    constructor(name: string, props: FilterProps);
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: FilterProps;
+    });
     get cutoff(): number;
     set cutoff(value: number);
     get filterType(): BiquadFilterType;
@@ -26,12 +25,13 @@ declare class MonoFilter extends Module<InternalFilter, FilterInterface> {
     set resonance(value: number);
     get envelopeAmount(): number;
     set envelopeAmount(value: number);
-    conntectedEnvelope(envelope: MonoFreqEnvelope): void;
 }
 export default class Filter extends PolyModule<MonoFilter, FilterInterface> {
     static moduleName: string;
-    constructor(name: string, props: Partial<FilterInterface>);
-    private registerInputs;
-    conntectedEnvelope(freqEnvelope: FreqEnvelope): void;
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: Partial<FilterInterface>;
+    });
 }
 export {};

package/{build/Module → dist/build/modules}/Master.d.ts

@@ -1,8 +1,11 @@
 import { Destination } from "tone";
-import Module from "./Base";
+import Module from "../core/Module";
 export interface MasterInterface {
 }
 export default class Master extends Module<typeof Destination, MasterInterface> {
     static moduleName: string;
-    constructor();
+    constructor({ id }: {
+        id?: string;
+    });
+    dispose(): void;
 }

package/{build/Module → dist/build/modules}/MidiSelector.d.ts

@@ -1,17 +1,21 @@
-import Module, { DummnyInternalModule } from "./Base";
-import { Output } from "./IO";
+import Module, { DummnyInternalModule } from "../core/Module";
+import { MidiOutput } from "../core/IO";
 export interface MidiSelectorInterface {
     selectedId: string | null;
 }
 export default class MidiSelector extends Module<DummnyInternalModule, MidiSelectorInterface> {
     static moduleName: string;
-    midiOutput: Output;
-    constructor(name: string, props: Partial<MidiSelectorInterface>);
+    midiOutput: MidiOutput;
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: Partial<MidiSelectorInterface>;
+    });
     get selectedId(): string | null;
     set selectedId(value: string | null);
     dispose(): void;
     private registerOutputs;
-    private onMidiEvent;
     private addEventListener;
+    private _onMidiEvent;
     private removeEventListener;
 }

package/{build/Module → dist/build/modules}/Oscillator.d.ts

@@ -1,8 +1,7 @@
 import { Oscillator as Osc } from "tone";
-import Note from "../Note";
-import Module, { Voicable } from "./Base";
-import PolyModule from "./PolyModule";
-export interface OscillatorInterface extends Voicable {
+import Note from "../core/Note";
+import Module, { PolyModule, Startable } from "../core/Module";
+export interface OscillatorInterface {
     noteName: string;
     fine: number;
     coarse: number;
@@ -10,9 +9,13 @@ export interface OscillatorInterface extends Voicable {
     volume: number;
     range: number;
 }
-declare class MonoOscillator extends Module<Osc, OscillatorInterface> {
+declare class MonoOscillator extends Module<Osc, OscillatorInterface> implements Startable {
     private _note;
-    constructor(name: string, props: Partial<OscillatorInterface>);
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: Partial<OscillatorInterface>;
+    });
     get note(): Note;
     setNoteAt(value: Note | string, time: number): void;
     set note(value: Note | string);
@@ -31,15 +34,18 @@ declare class MonoOscillator extends Module<Osc, OscillatorInterface> {
     start(time: number): void;
     stop(time?: number): void;
     triggerAttack: (note: Note, triggeredAt: number) => void;
-    triggerRelease: (note: Note, triggeredAt: number) => void;
+    triggerRelease: () => void;
     private updateFrequency;
     private getNote;
 }
 export default class Oscillator extends PolyModule<MonoOscillator, OscillatorInterface> {
     static moduleName: string;
-    constructor(name: string, props: Partial<OscillatorInterface>);
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: Partial<OscillatorInterface>;
+    });
     start(time: number): void;
     stop(time?: number): void;
-    private registerInputs;
 }
 export {};

package/{build/Module → dist/build/modules}/Reverb.d.ts

@@ -6,7 +6,11 @@ interface ReverbInterface extends EffectInterface {
 }
 export default class Reverb extends Effect<InternalReverb, ReverbInterface> {
     static moduleName: string;
-    constructor(name: string, props: Partial<ReverbInterface>);
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: Partial<ReverbInterface>;
+    });
     get decay(): number;
     set decay(value: number);
     get preDelay(): number;

package/{build/Module → dist/build/modules}/Sequencer.d.ts

@@ -1,6 +1,6 @@
-import Module, { DummnyInternalModule } from "./Base";
-import { INote } from "../Note";
-import { Output } from "./IO";
+import Module, { DummnyInternalModule } from "../core/Module";
+import { INote } from "../core/Note";
+import { MidiOutput } from "../core/IO";
 export interface ISequence {
     active: boolean;
     time: string;
@@ -13,9 +13,13 @@ interface ISequencer {
 }
 export default class Sequencer extends Module<DummnyInternalModule, ISequencer> {
     static moduleName: string;
-    midiOutput: Output;
+    midiOutput: MidiOutput;
     private part;
-    constructor(name: string, props: Partial<ISequencer>);
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: Partial<ISequencer>;
+    });
     get props(): ISequencer;
     set props(value: ISequencer);
     get steps(): number;

package/{build/Module → dist/build/modules}/VirtualMidi.d.ts

@@ -1,14 +1,18 @@
-import MidiEvent from "../MidiEvent";
-import Note from "../Note";
-import Module, { DummnyInternalModule } from "./Base";
-import { Output } from "./IO";
+import { MidiEvent } from "../core/midi";
+import Note from "../core/Note";
+import Module, { DummnyInternalModule } from "../core/Module";
+import { MidiOutput } from "../core/IO";
 export interface VirtualMidiInterface {
     activeNotes: string[];
 }
 export default class VirtualMidi extends Module<DummnyInternalModule, VirtualMidiInterface> {
     static moduleName: string;
-    midiOutput: Output;
-    constructor(name: string, props: VirtualMidiInterface);
+    midiOutput: MidiOutput;
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: VirtualMidiInterface;
+    });
     get activeNotes(): string[];
     set activeNotes(value: string[]);
     sendMidi(midiEvent: MidiEvent): void;
@@ -20,8 +24,8 @@ export default class VirtualMidi extends Module<DummnyInternalModule, VirtualMid
         name: string;
         type: string;
         props: VirtualMidiInterface;
-        inputs: import("./IO").SerializeInterface[];
-        outputs: import("./IO").SerializeInterface[];
+        inputs: import("../core/IO").IIOSerialize[];
+        outputs: import("../core/IO").IIOSerialize[];
     };
     private registerInputs;
     private registerOutputs;

package/dist/build/modules/VoiceScheduler.d.ts

@@ -0,0 +1,43 @@
+import { MidiEvent } from "../core/midi";
+import Module, { PolyModule, DummnyInternalModule } from "../core/Module";
+import { MidiOutput } from "../core/IO";
+export interface VoiceSchedulerInterface {
+    polyNumber: number;
+}
+export default class VoiceScheduler extends PolyModule<Voice, VoiceSchedulerInterface> {
+    static moduleName: string;
+    midiOutput: MidiOutput;
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: VoiceSchedulerInterface;
+    });
+    set polyNumber(value: number);
+    get polyNumber(): number;
+    onMidiEvent: (midiEvent: MidiEvent) => void;
+    serialize(): {
+        props: {
+            polyNumber: number;
+        };
+        id: string;
+        type: string;
+        inputs: import("../core/IO").IIOSerialize[];
+        outputs: import("../core/IO").IIOSerialize[];
+        name: string;
+    };
+    private findFreeVoice;
+    private registerInputs;
+    private registerOutputs;
+}
+declare class Voice extends Module<DummnyInternalModule, VoiceSchedulerInterface> {
+    midiEvent: MidiEvent | null;
+    activeNote: string | null;
+    triggeredAt: number;
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: VoiceSchedulerInterface;
+    });
+    midiTriggered: (midiEvent: MidiEvent) => void;
+}
+export {};

package/dist/build/modules/Volume.d.ts

@@ -0,0 +1,26 @@
+import { Volume as Vol } from "tone";
+import Module, { PolyModule } from "../core/Module";
+import Note from "../core/Note";
+export interface VolumeInterface {
+    volume: number;
+}
+declare class MonoVolume extends Module<Vol, VolumeInterface> {
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: Partial<VolumeInterface>;
+    });
+    get volume(): number;
+    set volume(value: number);
+    triggerAttack: (note: Note, triggeredAt: number) => void;
+    triggerRelease: () => void;
+}
+export default class Volume extends PolyModule<MonoVolume, VolumeInterface> {
+    static moduleName: string;
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: Partial<VolumeInterface>;
+    });
+}
+export {};

package/dist/build/modules/index.d.ts

@@ -0,0 +1,16 @@
+import { AudioModule } from "../core/Module";
+export { default as Master } from "./Master";
+export { default as Filter } from "./Filter";
+export { default as Oscillator } from "./Oscillator";
+export { default as VirtualMidi } from "./VirtualMidi";
+export { default as VoiceScheduler } from "./VoiceScheduler";
+export { default as Sequencer } from "./Sequencer";
+export type { ISequence } from "./Sequencer";
+export { Envelope, AmpEnvelope, FreqEnvelope, EnvelopeStages, } from "./Envelope";
+export interface ICreateModule {
+    id?: string;
+    name: string;
+    type: string;
+    props: any;
+}
+export declare function createModule(params: ICreateModule): AudioModule;

package/{build → dist/build}/routes.d.ts

@@ -1,17 +1,18 @@
+import { Optional } from "./types";
 export interface RouteProps {
     sourceId: string;
-    outputName: string;
+    sourceIOId: string;
     destinationId: string;
-    inputName: string;
+    destinationIOId: string;
 }
 export interface RouteInterface extends RouteProps {
     id: string;
 }
-export declare function createRoute(props: RouteProps): {
+export declare function createRoute(props: Optional<RouteInterface, "id">): {
     id: string;
     sourceId: string;
-    outputName: string;
+    sourceIOId: string;
     destinationId: string;
-    inputName: string;
+    destinationIOId: string;
 };
 export declare function applyRoutes(routes: RouteInterface[]): void;

package/dist/build/types.d.ts

@@ -0,0 +1,5 @@
+export type AnyObject = {
+    [Key: string]: any;
+};
+export type AtLeast<T, K extends keyof T> = Partial<T> & Pick<T, K>;
+export type Optional<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;

package/dist/build/utils.d.ts

@@ -0,0 +1 @@
+export declare function deterministicId(originalId: string, additionalString: string): string;