led-matrix-controllers 0.2.2 → 0.2.3

package/src/supported-firmware/vddCore/sparkle-fw16/reports.js

@@ -1,37 +1,37 @@
-export const Reports = {
-  GLITTER_DEVICE_INFO: {
-    id: 0x01,
-    bytes: 307,
-    feature: true,
-  },
-  GLITTER_BASIC_CMD: {
-    id: 0x02,
-    bytes: 16,
-    feature: true,
-  },
-  GLITTER_GRID_PWM_CNTL: {
-    id: 0x03,
-    bytes: 306,
-    feature: true,
-  },
-  GLITTER_GRID_PWM_CNTL: {
-    id: 0x04,
-    bytes: 306,
-    feature: true,
-  }
-}
-
-export const Commands = {
-  GLITTER_CMD_REBOOT: 0x00,
-  GLITTER_CMD_SLEEP: 0x01,
-  GLITTER_CMD_WAKE_ON_COMMAND: 0x02,
-  GLITTER_CMD_SET_SLEEP_TIMEOUT: 0x03,
-  GLITTER_CMD_SET_GLOBAL_BRIGHTNESS: 0x04,
-  GLITTER_CMD_DRAW_PIXEL: 0x05,
-  GLITTER_CMD_DRAW_LINE: 0x06
-}
-
-export const BootMode = {
-  BOOTSEL: 0x00,
-  NORMAL: 0x01,
-}
+export const Reports = {
+  GLITTER_DEVICE_INFO: {
+    id: 0x01,
+    bytes: 307,
+    feature: true,
+  },
+  GLITTER_BASIC_CMD: {
+    id: 0x02,
+    bytes: 16,
+    feature: true,
+  },
+  GLITTER_GRID_PWM_CNTL: {
+    id: 0x03,
+    bytes: 306,
+    feature: true,
+  },
+  GLITTER_GRID_PWM_CNTL: {
+    id: 0x04,
+    bytes: 306,
+    feature: true,
+  }
+}
+
+export const Commands = {
+  GLITTER_CMD_REBOOT: 0x00,
+  GLITTER_CMD_SLEEP: 0x01,
+  GLITTER_CMD_WAKE_ON_COMMAND: 0x02,
+  GLITTER_CMD_SET_SLEEP_TIMEOUT: 0x03,
+  GLITTER_CMD_SET_GLOBAL_BRIGHTNESS: 0x04,
+  GLITTER_CMD_DRAW_PIXEL: 0x05,
+  GLITTER_CMD_DRAW_LINE: 0x06
+}
+
+export const BootMode = {
+  BOOTSEL: 0x00,
+  NORMAL: 0x01,
+}

package/src/web-hid/HIDOperations.js

@@ -1,47 +1,47 @@
-import { pad } from './util.js';
-
-export class HIDOperations {
-  constructor(device) {
-    this.#device = device;
-  }
-
-  async send(report, data) {
-    if (data.length < report.bytes) {
-      data = pad(data, report.bytes);
-    } else if (data.length > report.bytes) {
-      throw new Error('Unable to send report: too many bytes');
-    }
-
-    const buffer = new Uint8Array(data).buffer;
-
-    if (report.feature)  {
-      await this.#device.sendFeatureReport(report.id, buffer);
-    } else {
-      await this.#device.sendReport(report.id, buffer);
-    }
-  }
-
-  async request(report) {
-    let reply = [];
-
-    if (report.feature) {
-      reply = await this.#device.receiveFeatureReport(report.id);
-    } else {
-      /* 
-       * HID input reports are used for unprompted data.
-       * See WebHID `HIDInputReportEvent`
-       */
-      throw new Error('Invalid operation');
-    }
-
-    if (reply.byteLength != report.bytes) {
-      const exp = report.bytes;
-      const act = reply.byteLength;
-      console.error(`reply length=${act} (expected ${exp})`);
-    }
-
-    return reply;
-  }
-
-  #device;
-}
+import { pad } from './util.js';
+
+export class HIDOperations {
+  constructor(device) {
+    this.#device = device;
+  }
+
+  async send(report, data) {
+    if (data.length < report.bytes) {
+      data = pad(data, report.bytes);
+    } else if (data.length > report.bytes) {
+      throw new Error('Unable to send report: too many bytes');
+    }
+
+    const buffer = new Uint8Array(data).buffer;
+
+    if (report.feature)  {
+      await this.#device.sendFeatureReport(report.id, buffer);
+    } else {
+      await this.#device.sendReport(report.id, buffer);
+    }
+  }
+
+  async request(report) {
+    let reply = [];
+
+    if (report.feature) {
+      reply = await this.#device.receiveFeatureReport(report.id);
+    } else {
+      /* 
+       * HID input reports are used for unprompted data.
+       * See WebHID `HIDInputReportEvent`
+       */
+      throw new Error('Invalid operation');
+    }
+
+    if (reply.byteLength != report.bytes) {
+      const exp = report.bytes;
+      const act = reply.byteLength;
+      console.error(`reply length=${act} (expected ${exp})`);
+    }
+
+    return reply;
+  }
+
+  #device;
+}

package/src/web-hid/device.js

@@ -1,36 +1,36 @@
-import { PID, VID } from '../hardware-constants.js';
-
-const extraDevices = [];
-
-const filters = [
-  {
-    vendorId: VID,
-    productId: PID,
-  }
-];
-
-export class DeviceSelectionCancelled extends Error {
-  constructor() {
-    super('User cancelled device selection.');
-    this.name = this.constructor.name;
-    this.date = new Date();
-  }
-}
-
-export async function getDevice() {
-  if (extraDevices && extraDevices.length > 0) {
-    return extraDevices.pop();
-  }
-
-  extraDevices.push(...(await navigator.hid.getDevices()));
-  if (extraDevices && extraDevices.length > 0) {
-    return extraDevices.pop();
-  }
-
-  extraDevices.push(...(await navigator.hid.requestDevice({ filters })));
-  if (extraDevices && extraDevices.length > 0) {
-    return extraDevices.pop();
-  }
-
-  throw new DeviceSelectionCancelled();
-}
+import { PID, VID } from '../hardware-constants.js';
+
+const extraDevices = [];
+
+const filters = [
+  {
+    vendorId: VID,
+    productId: PID,
+  }
+];
+
+export class DeviceSelectionCancelled extends Error {
+  constructor() {
+    super('User cancelled device selection.');
+    this.name = this.constructor.name;
+    this.date = new Date();
+  }
+}
+
+export async function getDevice() {
+  if (extraDevices && extraDevices.length > 0) {
+    return extraDevices.pop();
+  }
+
+  extraDevices.push(...(await navigator.hid.getDevices()));
+  if (extraDevices && extraDevices.length > 0) {
+    return extraDevices.pop();
+  }
+
+  extraDevices.push(...(await navigator.hid.requestDevice({ filters })));
+  if (extraDevices && extraDevices.length > 0) {
+    return extraDevices.pop();
+  }
+
+  throw new DeviceSelectionCancelled();
+}

package/src/web-hid/util.js

@@ -1,3 +1,3 @@
-export function pad(arr, len, val=0x00) {
-  return arr.concat(new Array(len - arr.length).fill(val));
-}
+export function pad(arr, len, val=0x00) {
+  return arr.concat(new Array(len - arr.length).fill(val));
+}

package/src/web-serial/PortMutex.js

@@ -1,58 +1,58 @@
-export class PortMutex {
-  constructor(portOperations) {
-    this.#lockName = `port-mutex-${Math.random().toString()}`;
-    this.#deduper = new Map();
-    this.#portOps = portOperations;
-  }
-
-  async acquire(fn) {
-    const trace = new Error('created bad cb').stack;
-
-    await this.#enqueue(async () => {
-      try {
-        await fn(this.#portOps);
-      } catch (e) {
-        console.error('Error occured in anonymous callback.');
-        console.error('Original error:', e);
-        console.error('--- This callback was created at ---\n', trace);
-      }
-    });
-  }
-
-  async acquireIdempotent(key, fn) {
-    const trace = new Error('created bad cb').stack;
-
-    if  (this.#deduper.has(key)) {
-      console.info(`"${key}" request coalesced.`);
-    }
-
-    this.#deduper.set(key, async () => {
-      try {
-        await fn(this.#portOps);
-      } catch (e) {
-        console.error('Error occured in anonymous callback.');
-        console.error('Original error:', e);
-        console.error('--- This callback was created at ---\n', trace);
-      }
-    });
-
-    await this.#enqueue(() => this.#execDedupedOp(key));
-  }
-
-  async #enqueue(fn) {
-    // `navigator.locks` maintains queue and provides mutual exclusion.
-    return navigator.locks.request(this.#lockName, fn);
-  }
-
-  async #execDedupedOp(key) {
-    if (this.#deduper.has(key)) {
-      const fn = this.#deduper.get(key);
-      this.#deduper.delete(key);
-      await fn();
-    }
-  }
-
-  #lockName;
-  #deduper;
-  #portOps;
-}
+export class PortMutex {
+  constructor(portOperations) {
+    this.#lockName = `port-mutex-${Math.random().toString()}`;
+    this.#deduper = new Map();
+    this.#portOps = portOperations;
+  }
+
+  async acquire(fn) {
+    const trace = new Error('created bad cb').stack;
+
+    await this.#enqueue(async () => {
+      try {
+        await fn(this.#portOps);
+      } catch (e) {
+        console.error('Error occured in anonymous callback.');
+        console.error('Original error:', e);
+        console.error('--- This callback was created at ---\n', trace);
+      }
+    });
+  }
+
+  async acquireIdempotent(key, fn) {
+    const trace = new Error('created bad cb').stack;
+
+    if  (this.#deduper.has(key)) {
+      console.info(`"${key}" request coalesced.`);
+    }
+
+    this.#deduper.set(key, async () => {
+      try {
+        await fn(this.#portOps);
+      } catch (e) {
+        console.error('Error occured in anonymous callback.');
+        console.error('Original error:', e);
+        console.error('--- This callback was created at ---\n', trace);
+      }
+    });
+
+    await this.#enqueue(() => this.#execDedupedOp(key));
+  }
+
+  async #enqueue(fn) {
+    // `navigator.locks` maintains queue and provides mutual exclusion.
+    return navigator.locks.request(this.#lockName, fn);
+  }
+
+  async #execDedupedOp(key) {
+    if (this.#deduper.has(key)) {
+      const fn = this.#deduper.get(key);
+      this.#deduper.delete(key);
+      await fn();
+    }
+  }
+
+  #lockName;
+  #deduper;
+  #portOps;
+}

package/src/web-serial/PortOperations.js

@@ -1,66 +1,66 @@
-export class PortOperations {
-  constructor(port) {
-    this.#port = port;
-  }
-
-  async rx(length, timeout=3000) {
-    if (this.#port === null) {
-      throw new Error('attempted RX before port initialization.');
-    }
-
-    /*
-     * ReadableStream's built-in locking mechanism cannot be awaited or otherwise
-     * asynchronously acquired. A PortMutex must be used.
-     */
-    if (this.#port.readable.locked) {
-      throw new Error('attempted RX while port locked.');
-    }
-
-    const response = [];
-    const reader = this.#port.readable.getReader();
-    const timeoutHandle = setTimeout(() => reader.cancel(), timeout);
-
-    try {
-      // Response may be divided across multiple reads
-      while (response.length < length) {
-        const { value, done } = await reader.read();
-        response.push(...(value ?? []));
-        if (done || !value) break;
-      }
-    } finally {
-      clearTimeout(timeoutHandle);
-      reader.releaseLock();
-    }
-
-    return response;
-  }
-
-  async tx(buffer) {
-    if (this.#port === null) {
-      throw new Error('attempted TX before port initialization.');
-    }
-    
-    /*
-     * WritableStream's built-in locking mechanism cannot be awaited or otherwise
-     * asynchronously acquired. A PortMutex must be used.
-     */
-    if (this.#port.writable.locked) {
-      throw new Error('attempted TX while port locked.');
-    }
-
-    const writer = this.#port.writable.getWriter();
-
-    try {
-      await writer.write(new Uint8Array(buffer));
-    } finally {
-      /* 
-       * The writer must be completely torn down between every single write.
-       * Many parsers can't handle delayed flushing and write coalescing.
-       * Command sequences will fail if `releaseLock()` is used here.
-       */
-      await writer.close();
-    }
-  }
-
-  #port;
-}
+export class PortOperations {
+  constructor(port) {
+    this.#port = port;
+  }
+
+  async rx(length, timeout=3000) {
+    if (this.#port === null) {
+      throw new Error('attempted RX before port initialization.');
+    }
+
+    /*
+     * ReadableStream's built-in locking mechanism cannot be awaited or otherwise
+     * asynchronously acquired. A PortMutex must be used.
+     */
+    if (this.#port.readable.locked) {
+      throw new Error('attempted RX while port locked.');
+    }
+
+    const response = [];
+    const reader = this.#port.readable.getReader();
+    const timeoutHandle = setTimeout(() => reader.cancel(), timeout);
+
+    try {
+      // Response may be divided across multiple reads
+      while (response.length < length) {
+        const { value, done } = await reader.read();
+        response.push(...(value ?? []));
+        if (done || !value) break;
+      }
+    } finally {
+      clearTimeout(timeoutHandle);
+      reader.releaseLock();
+    }
+
+    return response;
+  }
+
+  async tx(buffer) {
+    if (this.#port === null) {
+      throw new Error('attempted TX before port initialization.');
+    }
+    
+    /*
+     * WritableStream's built-in locking mechanism cannot be awaited or otherwise
+     * asynchronously acquired. A PortMutex must be used.
+     */
+    if (this.#port.writable.locked) {
+      throw new Error('attempted TX while port locked.');
+    }
+
+    const writer = this.#port.writable.getWriter();
+
+    try {
+      await writer.write(new Uint8Array(buffer));
+    } finally {
+      /* 
+       * The writer must be completely torn down between every single write.
+       * Many parsers can't handle delayed flushing and write coalescing.
+       * Command sequences will fail if `releaseLock()` is used here.
+       */
+      await writer.close();
+    }
+  }
+
+  #port;
+}

package/src/web-serial/port.js

@@ -1,65 +1,65 @@
-import { PID, VID } from '../hardware-constants.js';
-
-const extraPorts = [];
-
-const filters = [
-  {
-    usbVendorId: VID,
-    usbProductId: PID,
-  }
-];
-
-export class PortSelectionCancelled extends Error {
-  constructor() {
-    super('User cancelled port selection.');
-    this.name = this.constructor.name;
-    this.date = new Date();
-  }
-}
-
-export class PortUnavailable extends Error {
-  constructor() {
-    super('Selected port already in use.');
-    this.name = this.constructor.name;
-    this.date = new Date();
-  }
-}
-
-export async function getPort() {
-  try {
-    if (extraPorts && extraPorts.length > 0) {
-      return extraPorts.pop();
-    }
-
-    extraPorts.push(...await navigator.serial.getPorts());
-    if (extraPorts && extraPorts.length > 0) {
-      return extraPorts.pop();
-    }
-
-    extraPorts.push(...await navigator.serial.requestPort({ filters }));
-    if (extraPorts && extraPorts.length > 0) {
-      return extraPorts.pop();
-    }
-
-  } catch (e) {
-    if (e.name == 'NotFoundError') {
-      throw new PortSelectionCancelled();
-    } else if (e.name == 'InvalidStateError') {
-      throw new PortUnavailable();
-    } else {
-      throw e;
-    }
-  }
-}
-
-export async function close(port) {
-  try {
-    await port.close();
-  } catch(e) {
-    if (e.name != 'InvalidStateError') {
-      if (e.message != "Failed to execute 'close' on 'SerialPort': The port is already closed.") {
-        throw e;
-      }
-    }
-  }
-}
+import { PID, VID } from '../hardware-constants.js';
+
+const extraPorts = [];
+
+const filters = [
+  {
+    usbVendorId: VID,
+    usbProductId: PID,
+  }
+];
+
+export class PortSelectionCancelled extends Error {
+  constructor() {
+    super('User cancelled port selection.');
+    this.name = this.constructor.name;
+    this.date = new Date();
+  }
+}
+
+export class PortUnavailable extends Error {
+  constructor() {
+    super('Selected port already in use.');
+    this.name = this.constructor.name;
+    this.date = new Date();
+  }
+}
+
+export async function getPort() {
+  try {
+    if (extraPorts && extraPorts.length > 0) {
+      return extraPorts.pop();
+    }
+
+    extraPorts.push(...await navigator.serial.getPorts());
+    if (extraPorts && extraPorts.length > 0) {
+      return extraPorts.pop();
+    }
+
+    extraPorts.push(...await navigator.serial.requestPort({ filters }));
+    if (extraPorts && extraPorts.length > 0) {
+      return extraPorts.pop();
+    }
+
+  } catch (e) {
+    if (e.name == 'NotFoundError') {
+      throw new PortSelectionCancelled();
+    } else if (e.name == 'InvalidStateError') {
+      throw new PortUnavailable();
+    } else {
+      throw e;
+    }
+  }
+}
+
+export async function close(port) {
+  try {
+    await port.close();
+  } catch(e) {
+    if (e.name != 'InvalidStateError') {
+      if (e.message != "Failed to execute 'close' on 'SerialPort': The port is already closed.") {
+        throw e;
+      }
+    }
+  }
+}