spessasynth_core 1.0.0

package/spessasynth_core/utils/byte_functions.js

@@ -0,0 +1,141 @@
+import { ShiftableByteArray } from './shiftable_array.js'
+
+/**
+ * byte_functions.js
+ * purpose: contains various useful functions for bit manipulation and reading
+ */
+
+/**
+ * Reads as little endian
+ * @param dataArray {ShiftableByteArray}
+ * @param bytesAmount {number}
+ * @returns {number}
+ */
+export function readBytesAsUintLittleEndian(dataArray, bytesAmount){
+    let out = 0;
+    for(let i = 0; i < bytesAmount; i++)
+    {
+        out |= (readByte(dataArray) << i * 8);
+    }
+    // make sure it stays unsigned
+    return out >>> 0;
+}
+
+/**
+ * Reads as Big endian
+ * @param dataArray {ShiftableByteArray}
+ * @param bytesAmount {number}
+ * @returns {number}
+ */
+export function readBytesAsUintBigEndian(dataArray, bytesAmount){
+    let out = 0;
+    for (let i = 8 * (bytesAmount - 1); i >= 0; i -= 8) {
+        out |= (readByte(dataArray) << i);
+    }
+    return out >>> 0;
+}
+
+/**
+ * @param dataArray {ShiftableByteArray}
+ * @returns {number}
+ */
+export function readByte(dataArray){
+    if(!dataArray.shift)
+    {
+        dataArray.currentIndex = 0;
+        dataArray.shift = function () {
+            this.currentIndex++;
+            return this[this.currentIndex - 1];
+        }
+    }
+    return dataArray.shift();
+
+}
+
+/**
+ * @param dataArray {ShiftableByteArray}
+ * @param bytes {number}
+ * @param encoding {string} the textElement encoding
+ * @param trimEnd {boolean} if we should trim once we reach an invalid byte
+ * @returns {string}
+ */
+export function readBytesAsString(dataArray, bytes, encoding=undefined, trimEnd=true){
+    if(!encoding) {
+        let finished = false;
+        let string = "";
+        for (let i = 0; i < bytes; i++) {
+            let byte = readByte(dataArray);
+            if(byte < 32 || byte > 127 || finished)
+            {
+                if(trimEnd) {
+                    finished = true;
+                    continue;
+                }
+                else
+                {
+                    if(byte === 0)
+                    {
+                        finished = true;
+                        continue;
+                    }
+                }
+            }
+            string += String.fromCharCode(byte);
+        }
+        return string;
+    }
+    else {
+        let byteBuffer = dataArray.slice(dataArray.currentIndex, dataArray.currentIndex + bytes)
+        dataArray.currentIndex += bytes;
+        let decoder = new TextDecoder(encoding);
+        return decoder.decode(byteBuffer.buffer);
+    }
+}
+
+/**
+ * @param byte1 {number}
+ * @param byte2 {number}
+ * @returns {number}
+ */
+export function signedInt16(byte1, byte2){
+    let val = (byte2 << 8) | byte1;
+    if(val > 32767)
+    {
+        return val - 65536;
+    }
+    return val;
+}
+
+/**
+ * @param byte {number}
+ * @returns {number}
+ */
+export function signedInt8(byte) {
+    if(byte > 127)
+    {
+        return byte - 256;
+    }
+    return byte;
+}
+
+/**
+ * Reads VLQ From a MIDI byte array
+ * @param MIDIbyteArray {ShiftableByteArray}
+ * @returns {number}
+ */
+export function readVariableLengthQuantity(MIDIbyteArray){
+    let out = 0;
+    while(MIDIbyteArray)
+    {
+        const byte = readByte(MIDIbyteArray);
+        // extract the first 7 bytes
+        out = (out << 7) | (byte & 127);
+
+        // if the last byte isn't 1, stop reading
+        if((byte >> 7) !== 1)
+        {
+            break;
+        }
+    }
+    return out;
+}

package/spessasynth_core/utils/loggin.js

@@ -0,0 +1,79 @@
+let ENABLE_INFO = true;
+let ENABLE_WARN = true;
+let ENABLE_GROUP = true;
+let ENABLE_TABLE = true;
+
+/**
+ * Enables or disables looging
+ * @param enableInfo {boolean} - enables info
+ * @param enableWarn {boolean} - enables warning
+ * @param enableGroup {boolean} - enables groups
+ * @param enableTable {boolean} - enables tables
+ */
+export function SpessaSynthLogging(enableInfo, enableWarn, enableGroup, enableTable)
+{
+    ENABLE_INFO = enableInfo;
+    ENABLE_WARN = enableWarn;
+    ENABLE_GROUP = enableGroup;
+    ENABLE_TABLE = enableTable;
+}
+
+/**
+ * @param message {...any}
+ */
+export function SpessaSynthInfo(...message)
+{
+    if(ENABLE_INFO)
+    {
+        console.info(...message);
+    }
+}
+
+/**
+ * @param message {...any}
+ */
+export function SpessaSynthWarn(...message)
+{
+    if(ENABLE_WARN)
+    {
+        console.warn(...message);
+    }
+}
+
+export function SpessaSynthTable(...args)
+{
+    if(ENABLE_TABLE)
+    {
+        console.table(...args);
+    }
+}
+
+/**
+ * @param message {...any} the message
+ */
+export function SpessaSynthGroup(...message)
+{
+    if(ENABLE_GROUP)
+    {
+        console.group(...message);
+    }
+}
+
+/**
+ * @param message {...any} the message
+ */
+export function SpessaSynthGroupCollapsed(...message)
+{
+    if(ENABLE_GROUP)
+    {
+        console.groupCollapsed(...message);
+    }
+}
+
+export function SpessaSynthGroupEnd()
+{
+    if(ENABLE_GROUP)
+    {
+        console.groupEnd();
+    }
+}

package/spessasynth_core/utils/other.js

@@ -0,0 +1,49 @@
+/**
+ * other.js
+ * purpose: contains some useful functions that don't belong in any specific category
+ */
+
+/**
+ * Formats the given seconds to nice readable time
+ * @param totalSeconds {number} time in seconds
+ * @return {{seconds: number, minutes: number, time: string}}
+ */
+export function formatTime(totalSeconds) {
+    let minutes = Math.floor(totalSeconds / 60);
+    let seconds = Math.round(totalSeconds - (minutes * 60));
+    return {"minutes": minutes, "seconds": seconds, "time": `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`}
+}
+
+/**
+ * @param fileName {string}
+ * @returns {string}
+ */
+export function formatTitle(fileName)
+{
+    return fileName.replaceAll(".mid", "").replaceAll("_", " ");
+}
+
+/**
+ * Does what it says
+ * @param arr {number[]}
+ * @returns {string}
+ */
+export function arrayToHexString(arr) {
+    let hexString = '';
+
+    for (let i = 0; i < arr.length; i++) {
+        const hex = arr[i].toString(16).padStart(2, '0').toUpperCase();
+        hexString += hex;
+        hexString += ' ';
+    }
+
+    return hexString;
+}
+
+export const consoleColors = {
+    warn: "color: orange;",
+    unrecognized: "color: red;",
+    info: "color: aqua;",
+    recognized: "color: lime",
+    value: "color: yellow; background-color: black;"
+}

package/spessasynth_core/utils/shiftable_array.js

@@ -0,0 +1,26 @@
+/**
+ * shiftable_array.js
+ * purpose: exteds Uint8Array with the Array.shift() function
+ */
+
+export class ShiftableByteArray extends Uint8Array
+{
+    /**
+     * Creates a new instance of an Uint8Array with Array.shift() function
+     * @param args {any} same as for Uint8Array
+     */
+    constructor(args) {
+        super(args);
+        this.currentIndex = 0;
+    }
+
+    /**
+     * @param amount {number} - Amount of bytes to shift
+     * @returns {number} - The shifted byte
+     */
+    shift = (amount = 1) =>
+    {
+        this.currentIndex += amount;
+        return this[this.currentIndex - amount];
+    };
+}