@blibliki/engine 0.1.27 → 0.3.1

package/dist/src/modules/Envelope/Base.d.ts

@@ -1,67 +0,0 @@
-import { default as Note } from '../../core/Note';
-import { default as Module, PolyModule, Connectable, Triggerable } from '../../core/Module';
-import { Envelope as Env } from 'tone';
-
-export declare const enum EnvelopeStages {
-    Attack = "attack",
-    Decay = "decay",
-    Sustain = "sustain",
-    Release = "release"
-}
-export interface EnvelopeInterface {
-    attack: number;
-    decay: number;
-    sustain: number;
-    release: number;
-}
-export default abstract class EnvelopeModule<EnvelopeLike extends Env> extends Module<EnvelopeLike, EnvelopeInterface> implements Triggerable {
-    activeNote?: string;
-    triggeredAt: number;
-    constructor(params: {
-        id?: string;
-        name: string;
-        internalModule: EnvelopeLike;
-        props: EnvelopeInterface;
-    });
-    get attack(): number;
-    set attack(value: number);
-    get decay(): number;
-    set decay(value: number);
-    get sustain(): number;
-    set sustain(value: number);
-    get release(): number;
-    set release(value: number);
-    setStage(stage: EnvelopeStages, value: number): void;
-    triggerAttack: (note: Note, triggeredAt: number) => void;
-    triggerRelease: (note: Note, triggeredAt: number) => void;
-    private maxTime;
-    private minTime;
-}
-export declare abstract class PolyBase<EnvelopeModule extends Module<Connectable, EnvelopeInterface>> extends PolyModule<EnvelopeModule, EnvelopeInterface> {
-    constructor(params: {
-        id?: string;
-        name: string;
-        child: new (params: {
-            id?: string;
-            name: string;
-            props: EnvelopeInterface;
-        }) => EnvelopeModule;
-        props: Partial<EnvelopeInterface>;
-    });
-}
-declare class MonoEnvelope extends EnvelopeModule<Env> {
-    constructor(params: {
-        id?: string;
-        name: string;
-        props: EnvelopeInterface;
-    });
-}
-export declare class Envelope extends PolyBase<MonoEnvelope> {
-    static moduleName: string;
-    constructor(params: {
-        id?: string;
-        name: string;
-        props: Partial<EnvelopeInterface>;
-    });
-}
-export {};

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

@@ -1,26 +0,0 @@
-import { default as Base, EnvelopeInterface, PolyBase } from './Base';
-import { default as Filter } from '../Filter';
-import { FrequencyEnvelope } from 'tone';
-
-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/src/modules/Envelope/index.d.ts

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

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

@@ -1,43 +0,0 @@
-import { default as Module, PolyModule } from '../core/Module';
-import { Filter as InternalFilter, FilterRollOff } from 'tone';
-
-interface FilterInterface {
-    cutoff: number;
-    filterType: BiquadFilterType;
-    resonance: number;
-    slope: FilterRollOff;
-    envelopeAmount: number;
-}
-type FilterProps = Partial<FilterInterface>;
-declare class MonoFilter extends Module<InternalFilter, FilterInterface> {
-    private _cutoff;
-    private _amount;
-    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);
-    private registerOutputs;
-    private updateAmountFactor;
-}
-export default class Filter extends PolyModule<MonoFilter, FilterInterface> {
-    static moduleName: string;
-    constructor(params: {
-        id?: string;
-        name: string;
-        props: Partial<FilterInterface>;
-    });
-    private registerOutputs;
-}
-export {};

package/dist/src/modules/LFO.d.ts

@@ -1,45 +0,0 @@
-import { default as Note } from '../core/Note';
-import { TWave } from './Oscillator';
-import { default as Module, PolyModule, Startable } from '../core/Module';
-import { LFO as LFOInternal } from 'tone';
-
-export interface LFOInterface {
-    wave: TWave;
-    frequency: number;
-    min: number;
-    max: number;
-    amount: number;
-}
-declare class MonoLFO extends Module<LFOInternal, LFOInterface> implements Startable {
-    constructor(params: {
-        id?: string;
-        name: string;
-        props: Partial<LFOInterface>;
-    });
-    get wave(): TWave;
-    set wave(value: TWave);
-    get min(): number;
-    set min(value: number);
-    get max(): number;
-    set max(value: number);
-    get frequency(): number;
-    set frequency(value: number);
-    get amount(): number;
-    set amount(value: number);
-    start(time: number): void;
-    stop(time?: number): void;
-    triggerAttack: (_: Note, triggeredAt: number) => void;
-    triggerRelease: () => void;
-    private registerInputs;
-}
-export default class LFO extends PolyModule<MonoLFO, LFOInterface> {
-    static moduleName: string;
-    constructor(params: {
-        id?: string;
-        name: string;
-        props: Partial<LFOInterface>;
-    });
-    start(time: number): void;
-    stop(time?: number): void;
-}
-export {};

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

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

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

@@ -1,22 +0,0 @@
-import { MidiOutput } from '../core/IO';
-import { default as Module, DummnyInternalModule } from '../core/Module';
-
-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/src/modules/Oscillator.d.ts

@@ -1,56 +0,0 @@
-import { default as Module, PolyModule, Startable } from '../core/Module';
-import { default as Note } from '../core/Note';
-import { Oscillator as Osc, Signal } from 'tone';
-
-export type TWave = "sine" | "triangle" | "square" | "sawtooth";
-export interface OscillatorInterface {
-    noteName: string;
-    fine: number;
-    coarse: number;
-    wave: TWave;
-    volume: number;
-    range: number;
-}
-export declare class MonoOscillator extends Module<Osc, OscillatorInterface> implements Startable {
-    private _note;
-    private _fineMulti;
-    private _fineSignal;
-    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 fineSingal(): Signal<"number">;
-    get fine(): number;
-    set fine(value: number);
-    get coarse(): number;
-    set coarse(value: number);
-    get wave(): TWave;
-    set wave(value: TWave);
-    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;
-    private registerInputs;
-}
-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;
-}

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

@@ -1,20 +0,0 @@
-import { default as Effect, EffectInterface } from './Effect';
-import { Reverb as InternalReverb } from 'tone';
-
-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/src/modules/Sequencer.d.ts

@@ -1,43 +0,0 @@
-import { MidiOutput } from '../core/IO';
-import { INote } from '../core/Note';
-import { default as Module, DummnyInternalModule } from '../core/Module';
-
-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/src/modules/VirtualMidi.d.ts

@@ -1,33 +0,0 @@
-import { MidiOutput } from '../core/IO';
-import { default as Module, DummnyInternalModule } from '../core/Module';
-import { default as Note } from '../core/Note';
-import { MidiEvent } from '../core/midi';
-
-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/src/modules/VoiceScheduler.d.ts

@@ -1,45 +0,0 @@
-import { MidiOutput } from '../core/IO';
-import { default as Module, PolyModule, DummnyInternalModule } from '../core/Module';
-import { MidiEvent } from '../core/midi';
-
-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;
-        numberOfVoices: number;
-        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/src/modules/Volume.d.ts

@@ -1,27 +0,0 @@
-import { default as Note } from '../core/Note';
-import { default as Module, PolyModule } from '../core/Module';
-import { Volume as Vol } from 'tone';
-
-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/src/modules/index.d.ts

@@ -1,18 +0,0 @@
-import { AudioModule } from '../core/Module';
-
-export { default as Master } from './Master';
-export { default as Filter } from './Filter';
-export { default as Oscillator, MonoOscillator } 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;
-    numberOfVoices?: number;
-    type: string;
-    props: any;
-}
-export declare function createModule(params: ICreateModule): AudioModule;

package/dist/src/routes.d.ts

@@ -1,19 +0,0 @@
-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/src/types.d.ts

@@ -1,5 +0,0 @@
-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/src/utils.d.ts

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

package/dist/test/MockingModules.d.ts

@@ -1,22 +0,0 @@
-import { default as Module, PolyModule } from '../src/core/Module';
-
-interface IMonoMocking {
-}
-export declare class MockInternalModule {
-    connect(): void;
-    disconnect(): void;
-    dispose(): void;
-}
-export declare class MonoMocking extends Module<MockInternalModule, IMonoMocking> {
-    constructor(params: {
-        name: string;
-        props: Partial<IMonoMocking>;
-    });
-}
-export declare class PolyMocking extends PolyModule<MonoMocking, IMonoMocking> {
-    constructor(params: {
-        name: string;
-        props: Partial<IMonoMocking>;
-    });
-}
-export {};

package/dist/test/Module/Oscillator.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/core/IO.test.d.ts

@@ -1 +0,0 @@
-export {};

package/src/core/IO/AudioNode.ts

@@ -1,82 +0,0 @@
-import { InputNode } from "tone";
-import IONode, { IOType, IIONode } from "./Node";
-import MonoModule, { Connectable } from "../Module/index";
-import { AnyObject } from "../../types";
-import { ForwardAudioInput } from "./ForwardNode";
-import { AnyAudioInput, AnyAudioOuput } from ".";
-
-export type AudioIO = AudioInput | AudioOutput;
-
-export interface IAudioInput extends IIONode {
-  ioType: IOType.AudioInput;
-  internalModule: InputNode;
-}
-
-export interface IAudioOutput extends IIONode {
-  ioType: IOType.AudioOutput;
-  internalModule: IInternalModule;
-}
-
-interface IInternalModule extends Connectable {}
-
-export class AudioInput extends IONode implements IAudioInput {
-  declare ioType: IOType.AudioInput;
-  internalModule!: InputNode;
-  declare connections: AudioOutput[];
-
-  constructor(
-    plugableModule: MonoModule<Connectable, AnyObject>,
-    props: IAudioInput
-  ) {
-    super(plugableModule, props);
-    this.internalModule = props.internalModule;
-  }
-
-  plug(io: AnyAudioOuput, plugOther: boolean = true) {
-    super.plug(io, plugOther);
-  }
-
-  unPlug(io: AnyAudioOuput, plugOther: boolean = true) {
-    super.unPlug(io, plugOther);
-  }
-
-  unPlugAll() {
-    IONode.unPlugAll(this);
-  }
-}
-
-export class AudioOutput extends IONode implements IAudioOutput {
-  declare ioType: IOType.AudioOutput;
-  internalModule!: IInternalModule;
-  declare connections: AudioInput[];
-
-  constructor(
-    plugableModule: MonoModule<Connectable, AnyObject>,
-    props: IAudioOutput
-  ) {
-    super(plugableModule, props);
-    this.internalModule = props.internalModule;
-  }
-
-  plug(io: AnyAudioInput, plugOther: boolean = true) {
-    super.plug(io, plugOther);
-    if (io instanceof ForwardAudioInput) return;
-
-    this.internalModule.connect(io.internalModule);
-  }
-
-  unPlug(io: AnyAudioInput, plugOther: boolean = true) {
-    super.unPlug(io, plugOther);
-    if (io instanceof ForwardAudioInput) return;
-
-    try {
-      this.internalModule.disconnect(io.internalModule);
-    } catch (e) {
-      console.error(e);
-    }
-  }
-
-  unPlugAll() {
-    IONode.unPlugAll(this);
-  }
-}