Update workers for webpack 5

.eslintrc.cjs

@@ -129,8 +129,6 @@ const config = {
  'array-callback-return': 'error',
  // https://eslint.org/docs/rules/no-invalid-this
  'no-invalid-this': 'error', // Believe this one actually surfaces some bugs
- // https://eslint.org/docs/rules/func-style
- 'func-style': ['error', 'declaration'],
  // https://eslint.org/docs/rules/no-unused-expressions
  'no-unused-expressions': 'error',
  // https://eslint.org/docs/rules/no-useless-concat

.webpack/webpack.common.mjs

@@ -45,9 +45,6 @@ const config = {
  },
  entry: {
  openmct: './openmct.js',
- generatorWorker: './example/generator/generatorWorker.js',
- couchDBChangesFeed: './src/plugins/persistence/couch/CouchChangesFeed.js',
- inMemorySearchWorker: './src/api/objects/InMemorySearchWorker.js',
  espressoTheme: './src/plugins/themes/espresso-theme.scss',
  snowTheme: './src/plugins/themes/snow-theme.scss',
  darkmatterTheme: './src/plugins/themes/darkmatter-theme.scss'

example/generator/WorkerInterface.js

@@ -23,10 +23,10 @@
 import { v4 as uuid } from 'uuid';
 
 export default function WorkerInterface(openmct, StalenessProvider) {
- // eslint-disable-next-line no-undef
- const workerUrl = `${openmct.getAssetPath()}${__OPENMCT_ROOT_RELATIVE__}generatorWorker.js`;
  this.StalenessProvider = StalenessProvider;
- this.worker = new Worker(workerUrl);
+ this.worker = new Worker(
+ /* webpackChunkName: "generatorWorker" */ new URL('./generatorWorker.js', import.meta.url)
+ );
  this.worker.onmessage = this.onMessage.bind(this);
  this.callbacks = {};
  this.staleTelemetryIds = {};

example/generator/generatorWorker.js

@@ -20,86 +20,62 @@
  * at runtime from the About dialog for additional information.
  *****************************************************************************/
 
-(function () {
- var FIFTEEN_MINUTES = 15 * 60 * 1000;
+(() => {
+ const FIFTEEN_MINUTES = 15 * 60 * 1000;
 
- var handlers = {
+ const handlers = {
  subscribe: onSubscribe,
  unsubscribe: onUnsubscribe,
  request: onRequest
  };
 
- var subscriptions = {};
+ const subscriptions = new Map();
 
  function workSubscriptions(timestamp) {
- var now = Date.now();
- var nextWork = Math.min.apply(
- Math,
- Object.values(subscriptions).map(function (subscription) {
- return subscription(now);
- })
+ const now = Date.now();
+ const nextWork = Math.min(
+ ...Array.from(subscriptions.values()).map((subscription) => subscription(now))
  );
- var wait = nextWork - now;
- if (wait < 0) {
- wait = 0;
- }
+ let wait = nextWork - now;
+ wait = wait < 0 ? 0 : wait;
 
  if (Number.isFinite(wait)) {
  setTimeout(workSubscriptions, wait);
  }
  }
 
  function onSubscribe(message) {
- var data = message.data;
+ const { data } = message;
 
- // Keep
- var start = Date.now();
- var step = 1000 / data.dataRateInHz;
- var nextStep = start - (start % step) + step;
+ const start = Date.now();
+ const step = 1000 / data.dataRateInHz;
+ let nextStep = start - (start % step) + step;
  let work;
  if (data.spectra) {
- work = function (now) {
+ work = (now) => {
  while (nextStep < now) {
- const messageCopy = Object.create(message);
- message.data.start = nextStep - 60 * 1000;
- message.data.end = nextStep;
+ const messageCopy = { ...message };
+ messageCopy.data.start = nextStep - 60 * 1000;
+ messageCopy.data.end = nextStep;
  onRequest(messageCopy);
  nextStep += step;
  }
 
  return nextStep;
  };
  } else {
- work = function (now) {
+ work = (now) => {
  while (nextStep < now) {
  self.postMessage({
  id: message.id,
  data: {
  name: data.name,
  utc: nextStep,
  yesterday: nextStep - 60 * 60 * 24 * 1000,
- sin: sin(
- nextStep,
- data.period,
- data.amplitude,
- data.offset,
- data.phase,
- data.randomness,
- data.infinityValues,
- data.exceedFloat32
- ),
+ sin: sin(nextStep, data),
  wavelengths: wavelengths(),
  intensities: intensities(),
- cos: cos(
- nextStep,
- data.period,
- data.amplitude,
- data.offset,
- data.phase,
- data.randomness,
- data.infinityValues,
- data.exceedFloat32
- )
+ cos: cos(nextStep, data)
  }
  });
  nextStep += step;
@@ -109,47 +85,36 @@
  };
  }
 
- subscriptions[message.id] = work;
+ subscriptions.set(message.id, work);
  workSubscriptions();
  }
 
  function onUnsubscribe(message) {
- delete subscriptions[message.data.id];
+ subscriptions.delete(message.data.id);
  }
 
  function onRequest(message) {
- var request = message.data;
- if (request.end === undefined) {
- request.end = Date.now();
- }
+ const request = message.data;
+ request.end = request.end ?? Date.now();
+ request.start = request.start ?? request.end - FIFTEEN_MINUTES;
 
- if (request.start === undefined) {
- request.start = request.end - FIFTEEN_MINUTES;
- }
+ const now = Date.now();
+ const { start, end: requestEnd, period, dataRateInHz, loadDelay = 0, size } = request;
+ const end = requestEnd > now ? now : requestEnd;
+ const duration = end - start;
+ const step = 1000 / dataRateInHz;
+ const maxPoints = Math.floor(duration / step);
+ let nextStep = start - (start % step) + step;
 
- var now = Date.now();
- var start = request.start;
- var end = request.end > now ? now : request.end;
- var period = request.period;
- var dataRateInHz = request.dataRateInHz;
- var loadDelay = Math.max(request.loadDelay, 0);
- var size = request.size;
- var duration = end - start;
- var step = 1000 / dataRateInHz;
- var maxPoints = Math.floor(duration / step);
- var nextStep = start - (start % step) + step;
-
- var data = [];
+ let data = [];
 
  if (request.strategy === 'minmax' && size) {
- // Calculate the number of cycles to include based on size (2 points per cycle)
- var totalCycles = Math.min(Math.floor(size / 2), Math.floor(duration / period));
+ const totalCycles = Math.min(Math.floor(size / 2), Math.floor(duration / period));
 
  for (let cycle = 0; cycle < totalCycles; cycle++) {
- // Distribute cycles evenly across the time range
  let cycleStart = start + (duration / totalCycles) * cycle;
- let minPointTime = cycleStart; // Assuming min at the start of the cycle
- let maxPointTime = cycleStart + period / 2; // Assuming max at the halfway of the cycle
+ let minPointTime = cycleStart;
+ let maxPointTime = cycleStart + period / 2;
 
  data.push(createDataPoint(minPointTime, request), createDataPoint(maxPointTime, request));
  }
@@ -174,28 +139,10 @@
  return {
  utc: time,
  yesterday: time - 60 * 60 * 24 * 1000,
- sin: sin(
- time,
- request.period,
- request.amplitude,
- request.offset,
- request.phase,
- request.randomness,
- request.infinityValues,
- request.exceedFloat32
- ),
+ sin: sin(time, request),
  wavelengths: wavelengths(),
  intensities: intensities(),
- cos: cos(
- time,
- request.period,
- request.amplitude,
- request.offset,
- request.phase,
- request.randomness,
- request.infinityValues,
- request.exceedFloat32
- )
+ cos: cos(time, request)
  };
  }
 
@@ -204,55 +151,47 @@
  id: message.id,
  data: request.spectra
  ? {
- wavelength: data.map((item) => {
- return item.wavelength;
- }),
- cos: data.map((item) => {
- return item.cos;
- })
+ wavelength: data.map((item) => item.wavelength),
+ cos: data.map((item) => item.cos)
  }
  : data
  });
  }
 
  function cos(
  timestamp,
- period,
- amplitude,
- offset,
- phase,
- randomness,
- infinityValues,
- exceedFloat32
+ { period, amplitude, offset, phase, randomness, infinityValues, exceedFloat32 }
  ) {
- if (infinityValues && exceedFloat32) {
- if (Math.random() > 0.5) {
- return Number.POSITIVE_INFINITY;
- } else if (Math.random() < 0.01) {
- return getRandomFloat32OverflowValue();
- }
- } else if (infinityValues && Math.random() > 0.5) {
- return Number.POSITIVE_INFINITY;
- } else if (exceedFloat32 && Math.random() < 0.01) {
- return getRandomFloat32OverflowValue();
- }
-
- return (
- amplitude * Math.cos(phase + (timestamp / period / 1000) * Math.PI * 2) +
- amplitude * Math.random() * randomness +
- offset
- );
+ return calculateWaveform('cos', timestamp, {
+ period,
+ amplitude,
+ offset,
+ phase,
+ randomness,
+ infinityValues,
+ exceedFloat32
+ });
  }
 
  function sin(
  timestamp,
- period,
- amplitude,
- offset,
- phase,
- randomness,
- infinityValues,
- exceedFloat32
+ { period, amplitude, offset, phase, randomness, infinityValues, exceedFloat32 }
+ ) {
+ return calculateWaveform('sin', timestamp, {
+ period,
+ amplitude,
+ offset,
+ phase,
+ randomness,
+ infinityValues,
+ exceedFloat32
+ });
+ }
+
+ function calculateWaveform(
+ type,
+ timestamp,
+ { period, amplitude, offset, phase, randomness, infinityValues, exceedFloat32 }
  ) {
  if (infinityValues && exceedFloat32) {
  if (Math.random() > 0.5) {
@@ -266,8 +205,9 @@
  return getRandomFloat32OverflowValue();
  }
 
+ const waveFunction = type === 'sin' ? Math.sin : Math.cos;
  return (
- amplitude * Math.sin(phase + (timestamp / period / 1000) * Math.PI * 2) +
+ amplitude * waveFunction(phase + (timestamp / period / 1000) * Math.PI * 2) +
  amplitude * Math.random() * randomness +
  offset
  );
@@ -276,45 +216,28 @@
  // Values exceeding float32 range (Positive: 3.4+38, Negative: -3.4+38)
  function getRandomFloat32OverflowValue() {
  const sign = Math.random() > 0.5 ? 1 : -1;
-
  return sign * 3.4e39;
  }
 
  function wavelengths() {
- let values = [];
- while (values.length < 5) {
- const randomValue = Math.random() * 100;
- if (!values.includes(randomValue)) {
- values.push(String(randomValue));
- }
- }
-
- return values;
+ return Array.from({ length: 5 }, () => String(Math.random() * 100));
  }
 
  function intensities() {
- let values = [];
- while (values.length < 5) {
- const randomValue = Math.random() * 10;
- if (!values.includes(randomValue)) {
- values.push(String(randomValue));
- }
- }
-
- return values;
+ return Array.from({ length: 5 }, () => String(Math.random() * 10));
  }
 
  function sendError(error, message) {
  self.postMessage({
- error: error.name + ': ' + error.message,
- message: message,
+ error: `${error.name}: ${error.message}`,
+ message,
  id: message.id
  });
  }
 
- self.onmessage = function handleMessage(event) {
- var message = event.data;
- var handler = handlers[message.request];
+ self.onmessage = (event) => {
+ const { data: message } = event;
+ const handler = handlers[message.request];
 
  if (!handler) {
  sendError(new Error('unknown message type'), message);