@blibliki/engine 0.1.18 → 0.1.20

package/dist/build/modules/Envelope/FreqEnvelope.d.ts

@@ -0,0 +1,25 @@
+import { FrequencyEnvelope } from "tone";
+import Filter from "../Filter";
+import Base, { EnvelopeInterface, PolyBase } from "./Base";
+export declare class MonoFreqEnvelope extends Base<FrequencyEnvelope> {
+    private _frequency;
+    private _amount;
+    filter: Filter;
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: EnvelopeInterface;
+    });
+    get frequency(): number;
+    set frequency(value: number);
+    get amount(): number;
+    set amount(value: number);
+}
+export default class FreqEnvelope extends PolyBase<MonoFreqEnvelope> {
+    static moduleName: string;
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: Partial<EnvelopeInterface>;
+    });
+}

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

@@ -0,0 +1,3 @@
+export { default, Envelope, EnvelopeStages } from "./Base";
+export { default as AmpEnvelope } from "./AmpEnvelope";
+export { default as FreqEnvelope, MonoFreqEnvelope } from "./FreqEnvelope";

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

@@ -0,0 +1,37 @@
+import { Filter as InternalFilter, FilterRollOff } from "tone";
+import Module, { PolyModule } from "../core/Module";
+interface FilterInterface {
+    cutoff: number;
+    filterType: BiquadFilterType;
+    resonance: number;
+    slope: FilterRollOff;
+    envelopeAmount: number;
+}
+type FilterProps = Partial<FilterInterface>;
+declare class MonoFilter extends Module<InternalFilter, FilterInterface> {
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: FilterProps;
+    });
+    get cutoff(): number;
+    set cutoff(value: number);
+    get filterType(): BiquadFilterType;
+    set filterType(value: BiquadFilterType);
+    get slope(): FilterRollOff;
+    set slope(value: FilterRollOff);
+    get frequency(): import("tone").Signal<"frequency">;
+    get resonance(): number;
+    set resonance(value: number);
+    get envelopeAmount(): number;
+    set envelopeAmount(value: number);
+}
+export default class Filter extends PolyModule<MonoFilter, FilterInterface> {
+    static moduleName: string;
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: Partial<FilterInterface>;
+    });
+}
+export {};

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

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

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

@@ -0,0 +1,21 @@
+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: MidiOutput;
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: Partial<MidiSelectorInterface>;
+    });
+    get selectedId(): string | null;
+    set selectedId(value: string | null);
+    dispose(): void;
+    private registerOutputs;
+    private addEventListener;
+    private forwardMidiEvent;
+    private removeEventListener;
+}

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

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

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

@@ -0,0 +1,19 @@
+import { Reverb as InternalReverb } from "tone";
+import Effect, { EffectInterface } from "./Effect";
+interface ReverbInterface extends EffectInterface {
+    decay: number;
+    preDelay: number;
+}
+export default class Reverb extends Effect<InternalReverb, ReverbInterface> {
+    static moduleName: string;
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: Partial<ReverbInterface>;
+    });
+    get decay(): number;
+    set decay(value: number);
+    get preDelay(): number;
+    set preDelay(value: number);
+}
+export {};

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

@@ -0,0 +1,42 @@
+import Module, { DummnyInternalModule } from "../core/Module";
+import { INote } from "../core/Note";
+import { MidiOutput } from "../core/IO";
+export interface ISequence {
+    active: boolean;
+    time: string;
+    notes: INote[];
+}
+interface ISequencer {
+    sequences: ISequence[][];
+    steps: number;
+    bars: number;
+}
+export default class Sequencer extends Module<DummnyInternalModule, ISequencer> {
+    static moduleName: string;
+    midiOutput: MidiOutput;
+    private part;
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: Partial<ISequencer>;
+    });
+    get props(): ISequencer;
+    set props(value: ISequencer);
+    get steps(): number;
+    set steps(value: number);
+    get bars(): number;
+    set bars(value: number);
+    get sequences(): ISequence[][];
+    set sequences(value: ISequence[][]);
+    start(time: number): void;
+    stop(): void;
+    private registerOutputs;
+    private initializePart;
+    private adjust;
+    private adjustNumberOfBars;
+    private adjustNumberOfSteps;
+    private updateBarParts;
+    private get loopEnd();
+    private onPartEvent;
+}
+export {};

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

@@ -0,0 +1,32 @@
+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: MidiOutput;
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: VirtualMidiInterface;
+    });
+    get activeNotes(): string[];
+    set activeNotes(value: string[]);
+    sendMidi(midiEvent: MidiEvent): void;
+    triggerAttack: (note: Note, triggerAttack: number) => void;
+    triggerRelease: (note: Note, triggerAttack: number) => void;
+    serialize(): {
+        activeNotes: string[];
+        id: string;
+        name: string;
+        type: string;
+        props: VirtualMidiInterface;
+        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/dist/build/routes.d.ts

@@ -0,0 +1,18 @@
+import { Optional } from "./types";
+export interface RouteProps {
+    sourceId: string;
+    sourceIOId: string;
+    destinationId: string;
+    destinationIOId: string;
+}
+export interface RouteInterface extends RouteProps {
+    id: string;
+}
+export declare function createRoute(props: Optional<RouteInterface, "id">): {
+    id: string;
+    sourceId: string;
+    sourceIOId: string;
+    destinationId: 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;