@blibliki/engine 0.1.18 → 0.1.20

package/package.json

@@ -1,10 +1,15 @@
 {
   "name": "@blibliki/engine",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "source": "src/index.ts",
   "main": "dist/main.cjs.js",
   "module": "dist/main.esm.js",
   "types": "dist/build/index.d.ts",
+  "files": [
+    "README.md",
+    "src",
+    "dist"
+  ],
   "dependencies": {
     "@types/lodash": "^4.14.186",
     "crypto-js": "^4.2.0",
@@ -12,13 +17,6 @@
     "tone": "^14.7.77",
     "uuid": "^8.3.2"
   },
-  "scripts": {
-    "start": "tsc -w -p tsconfig.json",
-    "build": "rollup -c",
-    "lint": "eslint src",
-    "ts:check": "tsc --noEmit",
-    "test": "jest"
-  },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^25.0.7",
     "@rollup/plugin-node-resolve": "^15.2.3",
@@ -37,5 +35,12 @@
     "ts-jest": "^29.0.3",
     "typescript": "^5.2.2",
     "typescript-language-server": "^4.0.0"
+  },
+  "scripts": {
+    "start": "tsc -w -p tsconfig.json",
+    "build": "rollup -c",
+    "lint": "eslint src",
+    "ts:check": "tsc --noEmit",
+    "test": "jest"
   }
-}
+}

package/src/modules/Envelope/Base.ts

@@ -105,7 +105,10 @@ export default abstract class EnvelopeModule<EnvelopeLike extends Env>
   };
 
   triggerRelease = (note: Note, triggeredAt: number) => {
+    if (this.activeNote && this.activeNote !== note.fullName) return;
+
     this.internalModule.triggerRelease(triggeredAt);
+    this.activeNote = undefined;
   };
 
   private maxTime(stage: EnvelopeStages): number {

package/src/modules/MidiSelector.ts

@@ -59,10 +59,10 @@ export default class MidiSelector extends Module<
     if (!this.onMidiEvent || !midiId) return; // Ugly hack because of weird super bug
 
     const midiDevice = Engine.midiDeviceManager.find(midiId);
-    midiDevice?.addEventListener(this.onMidiEvent);
+    midiDevice?.addEventListener(this.forwardMidiEvent);
   }
 
-  private _onMidiEvent = (midiEvent: MidiEvent) => {
+  private forwardMidiEvent = (midiEvent: MidiEvent) => {
     this.midiOutput.onMidiEvent(midiEvent);
   };
 
@@ -70,6 +70,6 @@ export default class MidiSelector extends Module<
     if (!this.selectedId) return;
 
     const midiDevice = Engine.midiDeviceManager.find(this.selectedId);
-    midiDevice?.removeEventListener(this._onMidiEvent);
+    midiDevice?.removeEventListener(this.forwardMidiEvent);
   }
 }

package/src/modules/VirtualMidi.ts

@@ -48,16 +48,18 @@ export default class VirtualMidi extends Module<
     this.midiOutput.onMidiEvent(midiEvent);
   }
 
-  triggerAttack = (note: Note) => {
+  triggerAttack = (note: Note, triggerAttack: number) => {
     this.activeNotes = [...this.activeNotes, note.fullName];
     Engine._triggerPropsUpdate(this.id, this.props);
+    this.sendMidi(MidiEvent.fromNote(note, true, triggerAttack));
   };
 
-  triggerRelease = (note: Note) => {
+  triggerRelease = (note: Note, triggerAttack: number) => {
     this.activeNotes = this.activeNotes.filter(
       (name) => name !== note.fullName
     );
     Engine._triggerPropsUpdate(this.id, this.props);
+    this.sendMidi(MidiEvent.fromNote(note, false, triggerAttack));
   };
 
   serialize() {

package/.eslintrc.js

@@ -1,14 +0,0 @@
-module.exports = {
-  extends: [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/recommended",
-    "plugin:@typescript-eslint/recommended-requiring-type-checking",
-  ],
-  parser: "@typescript-eslint/parser",
-  plugins: ["@typescript-eslint"],
-  parserOptions: {
-    project: true,
-    tsconfigRootDir: __dirname,
-  },
-  root: true,
-};

package/.parcerc

@@ -1,6 +0,0 @@
-{
-  "extends": "@parcel/config-default",
-    "transformers": {
-      "*.{ts,tsx}": ["@parcel/transformer-typescript-tsc"]
-    }
-}

package/jest.config.js

@@ -1,19 +0,0 @@
-/** @type {import('ts-jest').JestConfigWithTsJest} */
-module.exports = {
-  preset: "ts-jest",
-  testEnvironment: "node",
-  rootDir: "test",
-  moduleNameMapper: {
-    "^src/(.*)$": "<rootDir>/../src/$1",
-  },
-  transform: {
-    // '^.+\\.[tj]sx?$' to process js/ts with `ts-jest`
-    // '^.+\\.m?[tj]sx?$' to process js/ts/mjs/mts with `ts-jest`
-    "^.+\\.tsx?$": [
-      "ts-jest",
-      {
-        diagnostics: false,
-      },
-    ],
-  },
-};

package/rollup.config.mjs

@@ -1,21 +0,0 @@
-import typescript from "@rollup/plugin-typescript";
-import { nodeResolve } from "@rollup/plugin-node-resolve";
-import commonjs from "@rollup/plugin-commonjs";
-import terser from "@rollup/plugin-terser";
-
-export default {
-  input: "src/index.ts", // Entry point
-  output: [
-    {
-      file: "dist/main.cjs.js",
-      format: "cjs", // CommonJS
-      sourcemap: true,
-    },
-    {
-      file: "dist/main.esm.js",
-      format: "esm", // ES Modules
-      sourcemap: true,
-    },
-  ],
-  plugins: [typescript(), nodeResolve(), commonjs(), terser()],
-};

package/test/MockingModules.ts

@@ -1,27 +0,0 @@
-import Module, { DummnyInternalModule, PolyModule } from "../src/core/Module";
-
-interface IMonoMocking {}
-
-export class MonoMocking extends Module<DummnyInternalModule, IMonoMocking> {
-  constructor(name: string, props: Partial<IMonoMocking>) {
-    super(new DummnyInternalModule(), {
-      name,
-      props,
-    });
-    this.registerDefaultMidiInput();
-    this.registerMidiOutput({ name: "midi out" });
-  }
-}
-
-export class PolyMocking extends PolyModule<MonoMocking, IMonoMocking> {
-  constructor(name: string, props: Partial<IMonoMocking>) {
-    super({
-      name,
-      child: MonoMocking,
-      props,
-    });
-
-    this.registerInput({ name: "midi in" });
-    this.registerOutput({ name: "midi out" });
-  }
-}

package/test/Module/Oscillator.test.ts

@@ -1,9 +0,0 @@
-import { describe, expect, it } from "@jest/globals";
-
-import { Oscillator } from "../../src/modules";
-
-describe("Oscillator", () => {
-  it("has proper module name", () => {
-    expect(Oscillator.moduleName).toBe("Oscillator");
-  });
-});

package/test/core/IO.test.ts

@@ -1,172 +0,0 @@
-import { describe, expect, it, beforeEach } from "@jest/globals";
-import { MonoMocking, PolyMocking } from "../MockingModules";
-import {
-  ForwardInput,
-  ForwardOutput,
-  MidiInput,
-  MidiOutput,
-} from "../../src/core/IO";
-
-describe("IO", () => {
-  let monoModule1: MonoMocking, monoModule2: MonoMocking;
-  let polyModule: PolyMocking;
-  let midiIn: MidiInput, midiOut: MidiOutput;
-  let forwardMidiIn: ForwardInput, forwardMidiOut: ForwardOutput;
-
-  beforeEach(() => {
-    monoModule1 = new MonoMocking("module1", {});
-    monoModule2 = new MonoMocking("module2", {});
-    polyModule = new PolyMocking("polyModule", {});
-
-    midiIn = monoModule1.inputs.findByName("midi in") as MidiInput;
-    midiOut = monoModule2.outputs.findByName("midi out") as MidiOutput;
-    forwardMidiIn = polyModule.inputs.findByName("midi in") as ForwardInput;
-    forwardMidiOut = polyModule.outputs.findByName("midi out") as ForwardOutput;
-  });
-
-  describe("plug midi with midi", () => {
-    beforeEach(() => {
-      midiOut.plug(midiIn);
-    });
-
-    it("has one connection", () => {
-      expect(midiIn.connections.length).toBe(1);
-      expect(midiOut.connections.length).toBe(1);
-    });
-
-    it("has midi in connected with midi out", () => {
-      expect(
-        midiIn.connections.find((con) => con.id === midiOut.id)
-      ).toBeDefined();
-    });
-
-    it("has midi out connected with midi in", () => {
-      expect(
-        midiOut.connections.find((con) => con.id === midiIn.id)
-      ).toBeDefined();
-    });
-
-    describe("unplug midi", () => {
-      beforeEach(() => {
-        midiOut.unPlug(midiIn);
-      });
-
-      it("unplugged midi in from midi out", () => {
-        expect(
-          midiIn.connections.find((con) => con.id === midiOut.id)
-        ).toBeUndefined();
-      });
-
-      it("unplugged midi out from midi in", () => {
-        expect(
-          midiOut.connections.find((con) => con.id === midiIn.id)
-        ).toBeUndefined();
-      });
-    });
-
-    describe("unplug all", () => {
-      beforeEach(() => {
-        midiOut.unPlugAll();
-      });
-
-      it("unplugged midi in from midi out", () => {
-        expect(midiIn.connections.length).toBe(0);
-      });
-
-      it("unplugged midi out from midi in", () => {
-        expect(midiOut.connections.length).toBe(0);
-      });
-    });
-  });
-
-  describe("plug midi out with forward in", () => {
-    beforeEach(() => {
-      midiOut.plug(forwardMidiIn);
-    });
-
-    it("has one connection", () => {
-      expect(forwardMidiIn.connections.length).toBe(1);
-      expect(midiOut.connections.length).toBe(2);
-    });
-
-    describe("unplug all", () => {
-      beforeEach(() => {
-        midiOut.unPlugAll();
-      });
-
-      it("unplugged midi in from midi out", () => {
-        expect(forwardMidiIn.connections.length).toBe(0);
-        expect(
-          forwardMidiIn.subInputs.map((input) => input.connections).flat()
-            .length
-        ).toBe(0);
-      });
-
-      it("unplugged midi out from midi in", () => {
-        expect(midiOut.connections.length).toBe(0);
-      });
-    });
-  });
-
-  describe("plug forwardMidiOut with midiIn", () => {
-    beforeEach(() => {
-      forwardMidiOut.plug(midiIn);
-    });
-
-    it("has one connection", () => {
-      expect(forwardMidiOut.connections.length).toBe(1);
-      expect(midiIn.connections.length).toBe(2);
-    });
-
-    describe("unplug all", () => {
-      beforeEach(() => {
-        forwardMidiOut.unPlugAll();
-      });
-
-      it("unplugged midi in from midi out", () => {
-        expect(forwardMidiOut.connections.length).toBe(0);
-        expect(
-          forwardMidiOut.subOutputs.map((input) => input.connections).flat()
-            .length
-        ).toBe(0);
-      });
-
-      it("unplugged midi out from midi in", () => {
-        expect(midiIn.connections.length).toBe(0);
-      });
-    });
-  });
-
-  describe("plug forwardMidiOut with forwardMidiIn", () => {
-    beforeEach(() => {
-      forwardMidiOut.plug(forwardMidiIn);
-    });
-
-    it("has one connection", () => {
-      expect(forwardMidiOut.connections.length).toBe(1);
-      expect(forwardMidiIn.connections.length).toBe(1);
-    });
-
-    describe("unplug all", () => {
-      beforeEach(() => {
-        forwardMidiOut.unPlugAll();
-      });
-
-      it("unplugged midi in from midi out", () => {
-        expect(forwardMidiOut.connections.length).toBe(0);
-        expect(
-          forwardMidiOut.subOutputs.map((input) => input.connections).flat()
-            .length
-        ).toBe(0);
-      });
-
-      it("unplugged midi out from midi in", () => {
-        expect(forwardMidiIn.connections.length).toBe(0);
-        expect(
-          forwardMidiIn.subInputs.map((input) => input.connections).flat()
-            .length
-        ).toBe(0);
-      });
-    });
-  });
-});

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "esnext",
-    "moduleResolution": "node",
-    "target": "esnext",
-    "declaration": true,
-    "lib": ["dom", "dom.iterable", "esnext"],
-    "strict": true,
-    "allowJs": true,
-    "skipLibCheck": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "strictPropertyInitialization": false,
-    "forceConsistentCasingInFileNames": true,
-    "noFallthroughCasesInSwitch": true,
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "sourceMap": true,
-    "outDir": "build"
-  },
-  "include": ["src"]
-}