@blibliki/engine 0.1.24 → 0.1.26

package/dist/build/Engine.d.ts

@@ -61,10 +61,11 @@ declare class Engine {
     addRoute(props: Optional<RouteInterface, "id">): {
         id: string;
         sourceId: string;
-        sourceIOId: string;
         destinationId: string;
+        sourceIOId: string;
         destinationIOId: string;
     };
+    validRoute(props: Optional<RouteInterface, "id">): boolean;
     removeRoute(id: string): void;
     triggerVirtualMidi(id: string, noteName: string, type: "noteOn" | "noteOff"): void;
     dispose(): void;

package/dist/build/core/IO/AudioNode.d.ts

@@ -2,7 +2,7 @@ import { InputNode } from "tone";
 import IONode, { IOType, IIONode } from "./Node";
 import MonoModule, { Connectable } from "../Module/index";
 import { AnyObject } from "../../types";
-import { ForwardInput, ForwardOutput } from "./ForwardNode";
+import { AnyAudioInput, AnyAudioOuput } from ".";
 export type AudioIO = AudioInput | AudioOutput;
 export interface IAudioInput extends IIONode {
     ioType: IOType.AudioInput;
@@ -19,8 +19,8 @@ export declare class AudioInput extends IONode implements IAudioInput {
     internalModule: InputNode;
     connections: AudioOutput[];
     constructor(plugableModule: MonoModule<Connectable, AnyObject>, props: IAudioInput);
-    plug(io: AudioOutput | ForwardOutput, plugOther?: boolean): void;
-    unPlug(io: AudioOutput | ForwardOutput, plugOther?: boolean): void;
+    plug(io: AnyAudioOuput, plugOther?: boolean): void;
+    unPlug(io: AnyAudioOuput, plugOther?: boolean): void;
     unPlugAll(): void;
 }
 export declare class AudioOutput extends IONode implements IAudioOutput {
@@ -28,8 +28,8 @@ export declare class AudioOutput extends IONode implements IAudioOutput {
     internalModule: IInternalModule;
     connections: AudioInput[];
     constructor(plugableModule: MonoModule<Connectable, AnyObject>, props: IAudioOutput);
-    plug(io: AudioInput | ForwardInput, plugOther?: boolean): void;
-    unPlug(io: AudioInput | ForwardInput, plugOther?: boolean): void;
+    plug(io: AnyAudioInput, plugOther?: boolean): void;
+    unPlug(io: AnyAudioInput, plugOther?: boolean): void;
     unPlugAll(): void;
 }
 export {};

package/dist/build/core/IO/ForwardNode/Base.d.ts

@@ -0,0 +1,18 @@
+import IONode, { IIONode } from "../Node";
+import Module, { Connectable, PolyModule } from "../../Module";
+import { AnyObject } from "../../../types";
+import { AnyIO } from "..";
+export default class ForwardBaseNode extends IONode {
+    plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>;
+    constructor(plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>, props: IIONode);
+    get voices(): number;
+    get subModules(): Module<Connectable, AnyObject>[];
+    subModule(voiceNo: number): Module<Connectable, AnyObject>;
+    get subIOs(): IONode[];
+    subIO(voiceNo: number): import("..").AudioInput | import("..").MidiInput | import("..").AudioOutput | import("..").MidiOutput;
+    plug(io: AnyIO, plugOther?: boolean): void;
+    unPlug(io: AnyIO, plugOther?: boolean): void;
+    unPlugAll(): void;
+    private plugUnplug;
+    private checkNameValidity;
+}

package/dist/build/core/IO/ForwardNode/index.d.ts

@@ -0,0 +1,27 @@
+import { IOType, IIONode } from "../Node";
+import Module, { Connectable, PolyModule } from "../../Module";
+import { AnyObject } from "../../../types";
+import { AnyAudioInput, AnyAudioOuput, AnyInput, AnyOuput } from "..";
+import ForwardBaseNode from "./Base";
+export interface IForwardAudioInput extends IIONode {
+    ioType: IOType.ForwardAudioInput;
+}
+export interface IForwardAudioOutput extends IIONode {
+    ioType: IOType.ForwardAudioOutput;
+}
+export declare class ForwardAudioInput extends ForwardBaseNode implements IForwardAudioInput {
+    plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>;
+    ioType: IOType.ForwardAudioInput;
+    connections: AnyAudioOuput[];
+    constructor(plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>, props: IForwardAudioInput);
+    plug(io: AnyOuput, plugOther?: boolean): void;
+    unPlug(io: AnyOuput, plugOther?: boolean): void;
+}
+export declare class ForwardAudioOutput extends ForwardBaseNode implements IForwardAudioOutput {
+    plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>;
+    ioType: IOType.ForwardAudioOutput;
+    connections: AnyAudioInput[];
+    constructor(plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>, props: IForwardAudioOutput);
+    plug(io: AnyInput, plugOther?: boolean): void;
+    unPlug(io: AnyInput, plugOther?: boolean): void;
+}

package/dist/build/core/IO/MidiNode.d.ts

@@ -1,6 +1,6 @@
+import { AnyMidiInput, AnyMidiOuput } from ".";
 import { AudioModule } from "../Module";
 import { MidiEvent } from "../midi";
-import { ForwardInput, ForwardOutput } from "./ForwardNode";
 import IONode, { IOType, IIONode } from "./Node";
 export interface IMidiInput extends IIONode {
     ioType: IOType.MidiInput;
@@ -14,16 +14,16 @@ export declare class MidiInput extends IONode implements IMidiInput {
     connections: MidiOutput[];
     onMidiEvent: (event: MidiEvent) => void;
     constructor(plugableModule: AudioModule, props: IMidiInput);
-    plug(io: MidiOutput | ForwardOutput, plugOther?: boolean): void;
-    unPlug(io: MidiOutput | ForwardOutput, plugOther?: boolean): void;
+    plug(io: AnyMidiOuput, plugOther?: boolean): void;
+    unPlug(io: AnyMidiOuput, plugOther?: boolean): void;
     unPlugAll(): void;
 }
 export declare class MidiOutput extends IONode implements IMidiOutput {
     ioType: IOType.MidiOutput;
     connections: MidiInput[];
     constructor(plugableModule: AudioModule, props: IIONode);
-    plug(io: MidiInput | ForwardInput, plugOther?: boolean): void;
-    unPlug(io: MidiInput | ForwardOutput, plugOther?: boolean): void;
+    plug(io: AnyMidiInput, plugOther?: boolean): void;
+    unPlug(io: AnyMidiInput, plugOther?: boolean): void;
     unPlugAll(): void;
     onMidiEvent: (event: MidiEvent) => void;
     private get midiConnections();

package/dist/build/core/IO/Node.d.ts

@@ -1,5 +1,5 @@
 import { AudioModule } from "../Module";
-import { AnyInput, AnyOuput } from ".";
+import { AnyIO } from ".";
 export interface IIONode {
     name: string;
     ioType: IOType;
@@ -16,11 +16,11 @@ export declare enum IOType {
     AudioOutput = "audioOutput",
     MidiInput = "midiInput",
     MidiOutput = "midiOutput",
-    ForwardInput = "forwardInput",
-    ForwardOutput = "forwardOutput"
+    ForwardAudioInput = "forwardAudioInput",
+    ForwardAudioOutput = "forwardAudioOutput"
 }
-export declare function plugCompatibleIO(input: AnyInput, output: AnyOuput): void;
-export declare function unPlugCompatibleIO(input: AnyInput, output: AnyOuput): void;
+export declare function plugCompatibleIO(io1: AnyIO, io2: AnyIO): void;
+export declare function unPlugCompatibleIO(io1: AnyIO, io2: AnyIO): void;
 export default abstract class IONode implements IIONode {
     id: string;
     ioType: IOType;
@@ -31,6 +31,10 @@ export default abstract class IONode implements IIONode {
     constructor(plugableModule: AudioModule, props: IIONode);
     plug(io: IONode, plugOther?: boolean): void;
     unPlug(io: IONode, plugOther?: boolean): void;
+    get isInput(): boolean;
+    get isOutput(): boolean;
+    get isAudio(): boolean;
+    get isMidi(): boolean;
     abstract unPlugAll(): void;
     serialize(): IIOSerialize;
 }

package/dist/build/core/IO/index.d.ts

@@ -2,11 +2,20 @@ import { default as IOCollection } from "./Collection";
 import { IIONode, IOType, IIOSerialize } from "./Node";
 import { AudioInput, AudioOutput, IAudioInput, IAudioOutput } from "./AudioNode";
 import { IMidiInput, IMidiOutput, MidiInput, MidiOutput } from "./MidiNode";
-import { ForwardInput, ForwardOutput, IForwardInput, IForwardOutput } from "./ForwardNode";
-type AnyInput = AudioInput | MidiInput | ForwardInput;
-type AnyOuput = AudioOutput | MidiOutput | ForwardOutput;
-type IAnyInput = IAudioInput | IMidiInput | IForwardInput;
-type IAnyOutput = IAudioOutput | IMidiOutput | IForwardOutput;
-type IAnyIO = IAnyInput | IAnyOutput | IForwardOutput;
-export { IOCollection, IOType, AudioInput, AudioOutput, MidiInput, MidiOutput, ForwardInput, ForwardOutput, };
-export type { IAnyIO, IIONode, IAudioInput, IAudioOutput, IMidiInput, IMidiOutput, IForwardInput, IForwardOutput, IAnyInput, IAnyOutput, IIOSerialize, AnyInput, AnyOuput, };
+import { ForwardAudioInput, ForwardAudioOutput, IForwardAudioInput, IForwardAudioOutput } from "./ForwardNode";
+type AnyAudioInput = AudioInput | ForwardAudioInput;
+type AnyMidiInput = MidiInput;
+type AnyAudioOuput = AudioOutput | ForwardAudioOutput;
+type AnyMidiOuput = MidiOutput;
+type AnyInput = AnyAudioInput | AnyMidiInput;
+type AnyOuput = AnyAudioOuput | AnyMidiOuput;
+type AnyIO = AnyInput | AnyOuput;
+type IAnyAudioInput = IAudioInput | IForwardAudioInput;
+type IAnyMidiInput = IMidiInput;
+type IAnyAudioOuput = IAudioOutput | IForwardAudioOutput;
+type IAnyMidiOuput = IMidiOutput;
+type IAnyInput = IAnyAudioInput | IAnyMidiInput;
+type IAnyOutput = IAnyAudioOuput | IAnyMidiOuput;
+type IAnyIO = IAnyInput | IAnyOutput;
+export { IOCollection, IOType, AudioInput, AudioOutput, MidiInput, MidiOutput, ForwardAudioInput, ForwardAudioOutput, };
+export type { IAnyIO, IIONode, IAudioInput, IAudioOutput, IMidiInput, IMidiOutput, IForwardAudioInput, IForwardAudioOutput, IAnyInput, IAnyOutput, IIOSerialize, AnyAudioInput, AnyMidiInput, AnyAudioOuput, AnyMidiOuput, AnyInput, AnyOuput, AnyIO, };

package/dist/build/core/Module/PolyModule.d.ts

@@ -1,7 +1,8 @@
 import { MidiEvent } from "../midi";
 import Module, { Connectable } from "./MonoModule";
-import { IOCollection, ForwardInput, ForwardOutput, IMidiInput, IMidiOutput, IForwardInput, IForwardOutput, MidiOutput, MidiInput } from "../IO";
+import { IOCollection, IMidiInput, IMidiOutput, MidiOutput, MidiInput, AnyInput, AnyOuput, ForwardAudioInput } from "../IO";
 import { AudioModule } from "./index";
+import { ForwardAudioOutput, IForwardAudioInput, IForwardAudioOutput } from "../IO/ForwardNode";
 interface PolyModuleInterface<MonoAudioModule, PropsInterface> {
     id?: string;
     name: string;
@@ -23,8 +24,8 @@ export default abstract class PolyModule<MonoAudioModule extends Module<Connecta
     }) => MonoAudioModule;
     _name: string;
     audioModules: MonoAudioModule[];
-    inputs: IOCollection<ForwardInput | MidiInput>;
-    outputs: IOCollection<ForwardOutput | MidiOutput>;
+    inputs: IOCollection<AnyInput>;
+    outputs: IOCollection<AnyOuput>;
     private _numberOfVoices;
     constructor(params: PolyModuleInterface<MonoAudioModule, PropsInterface>);
     get name(): string;
@@ -48,12 +49,13 @@ export default abstract class PolyModule<MonoAudioModule extends Module<Connecta
     };
     protected find(callback: (audioModule: MonoAudioModule) => boolean): MonoAudioModule;
     protected findVoice(voiceNo: number): MonoAudioModule | undefined;
-    protected registerInput(props: Omit<IForwardInput, "ioType">): ForwardInput;
-    protected registerOutput(props: Omit<IForwardOutput, "ioType">): ForwardOutput;
+    protected registerForwardAudioInput(props: Omit<IForwardAudioInput, "ioType">): ForwardAudioInput;
+    protected registerForwardAudioOutput(props: Omit<IForwardAudioOutput, "ioType">): ForwardAudioOutput;
     protected registerMidiInput(props: Omit<IMidiInput, "ioType">): MidiInput;
     protected registerMidiOutput(props: Omit<IMidiOutput, "ioType">): MidiOutput;
     protected registerBasicOutputs(): void;
     protected registerBasicInputs(): void;
+    protected registerMidiIn(): void;
     private adjustNumberOfModules;
 }
 export {};

package/dist/build/routes.d.ts

@@ -11,8 +11,8 @@ export interface RouteInterface extends RouteProps {
 export declare function createRoute(props: Optional<RouteInterface, "id">): {
     id: string;
     sourceId: string;
-    sourceIOId: string;
     destinationId: string;
+    sourceIOId: string;
     destinationIOId: string;
 };
 export declare function applyRoutes(routes: RouteInterface[]): void;