added filtering to state generator, updated filters readme to fix err…

…or, more robust hash function

example/generator/GeneratorMetadataProvider.js

@@ -108,9 +108,16 @@ const METADATA_BY_TYPE = {
             string: 'ON'
           }
         ],
-        hints: {
-          range: 1
-        }
+        filters: [
+          {
+            singleSelectionThreshold: true,
+            comparator: 'equals',
+            possibleValues: [
+              { label: 'OFF', value: 0 },
+              { label: 'ON', value: 1 }
+            ]
+          }
+        ]
       },
       {
         key: 'value',

example/generator/GeneratorProvider.js

@@ -46,7 +46,7 @@ GeneratorProvider.prototype.canProvideTelemetry = function (domainObject) {
 GeneratorProvider.prototype.supportsRequest = GeneratorProvider.prototype.supportsSubscribe =
   GeneratorProvider.prototype.canProvideTelemetry;
 
-GeneratorProvider.prototype.makeWorkerRequest = function (domainObject, request) {
+GeneratorProvider.prototype.makeWorkerRequest = function (domainObject, options) {
   var props = [
     'amplitude',
     'period',
@@ -59,7 +59,7 @@ GeneratorProvider.prototype.makeWorkerRequest = function (domainObject, request)
     'exceedFloat32'
   ];
 
-  request = request || {};
+  options = options || {};
 
   var workerRequest = {};
 
@@ -71,8 +71,8 @@ GeneratorProvider.prototype.makeWorkerRequest = function (domainObject, request)
       workerRequest[prop] = domainObject.telemetry[prop];
     }
 
-    if (request && Object.prototype.hasOwnProperty.call(request, prop)) {
-      workerRequest[prop] = request[prop];
+    if (options && Object.prototype.hasOwnProperty.call(options, prop)) {
+      workerRequest[prop] = options[prop];
     }
 
     if (!Object.prototype.hasOwnProperty.call(workerRequest, prop)) {
@@ -88,17 +88,17 @@ GeneratorProvider.prototype.makeWorkerRequest = function (domainObject, request)
   return workerRequest;
 };
 
-GeneratorProvider.prototype.request = function (domainObject, request) {
-  var workerRequest = this.makeWorkerRequest(domainObject, request);
-  workerRequest.start = request.start;
-  workerRequest.end = request.end;
-  workerRequest.size = request.size;
-  workerRequest.strategy = request.strategy;
+GeneratorProvider.prototype.request = function (domainObject, options) {
+  var workerRequest = this.makeWorkerRequest(domainObject, options);
+  workerRequest.start = options.start;
+  workerRequest.end = options.end;
+  workerRequest.size = options.size;
+  workerRequest.strategy = options.strategy;
 
   return this.workerInterface.request(workerRequest);
 };
 
-GeneratorProvider.prototype.subscribe = function (domainObject, callback) {
+GeneratorProvider.prototype.subscribe = function (domainObject, callback, options) {
   var workerRequest = this.makeWorkerRequest(domainObject, {});
 
   return this.workerInterface.subscribe(workerRequest, callback);

example/generator/StateGeneratorProvider.js

@@ -34,14 +34,16 @@ StateGeneratorProvider.prototype.supportsSubscribe = function (domainObject) {
   return domainObject.type === 'example.state-generator';
 };
 
-StateGeneratorProvider.prototype.subscribe = function (domainObject, callback) {
+StateGeneratorProvider.prototype.subscribe = function (domainObject, callback, options) {
   var duration = domainObject.telemetry.duration * 1000;
 
-  var interval = setInterval(function () {
+  var interval = setInterval(() => {
     var now = Date.now();
     var datum = pointForTimestamp(now, duration, domainObject.name);
-    datum.value = String(datum.value);
-    callback(datum);
+    if (!this.shouldBeFiltered(datum, options)) {
+      datum.value = String(datum.value);
+      callback(datum);
+    }
   }, duration);
 
   return function () {
@@ -63,9 +65,25 @@ StateGeneratorProvider.prototype.request = function (domainObject, options) {
 
   var data = [];
   while (start <= end && data.length < 5000) {
-    data.push(pointForTimestamp(start, duration, domainObject.name));
+    const point = pointForTimestamp(start, duration, domainObject.name);
+
+    if (!this.shouldBeFiltered(point, options)) {
+      data.push(point);
+    }
     start += duration;
   }
 
   return Promise.resolve(data);
 };
+
+StateGeneratorProvider.prototype.shouldBeFiltered = function (point, options) {
+  const valueToFilter = options?.filters?.state?.equals?.[0];
+
+  if (!valueToFilter) {
+    return false;
+  }
+
+  const { value } = point;
+
+  return value !== Number(valueToFilter);
+};

src/api/telemetry/TelemetryAPI.js

@@ -278,28 +278,73 @@ export default class TelemetryAPI {
       }, {});
   }
 
+  /**
+   * Filters out class instances and functions from an object, returning a plain
+   * data object suitable for JSON serialization.
+   *
+   * @private
+   * @param {Object|Array|*} value The value to sanitize
+   * @returns {Object|Array|*} A sanitized copy with class instances and functions removed
+   */
+  #sanitizeForSerialization(value) {
+    if (value === null || value === undefined) {
+      return value;
+    }
+
+    // Handle primitive types, arrays and objects
+    if (typeof value !== 'object') {
+      return typeof value !== 'function' ? value : undefined;
+    }
+
+    if (Array.isArray(value)) {
+      return value.map((item) => this.#sanitizeForSerialization(item));
+    }
+
+    if (Object.getPrototypeOf(value) === Object.prototype) {
+      const result = {};
+
+      for (const key of Object.keys(value)) {
+        const sanitizedValue = this.#sanitizeForSerialization(value[key]);
+
+        if (sanitizedValue !== undefined) {
+          result[key] = sanitizedValue;
+        }
+      }
+      return result;
+    }
+
+    return undefined;
+  }
+
   /**
    * Generates a numeric hash value for an options object. The hash is consistent
    * for equivalent option objects regardless of property order.
    *
    * This is used to create compact, unique cache keys for telemetry subscriptions with
    * different options configurations. The hash function ensures that identical options
-   * objects will always generate the same hash value.
+   * objects will always generate the same hash value, while different options objects
+   * (even with small differences) will generate different hash values.
    *
    * @private
    * @param {Object} options The options object to hash
-   * @returns {number} A 32-bit integer hash of the options object
+   * @returns {number} A positive integer hash of the options object
    */
   #hashOptions(options) {
-    let hash = 0;
-    const canonicalOptions = this.#canonicalizeOptions(options);
+    const sanitizedOptions = this.#sanitizeForSerialization(options);
+    const canonicalOptions = this.#canonicalizeOptions(sanitizedOptions);
     const str = JSON.stringify(canonicalOptions);
 
+    let hash = 0;
+    const prime = 31;
+    const modulus = 1e9 + 9; // Large prime number
+
     for (let i = 0; i < str.length; i++) {
       const char = str.charCodeAt(i);
-      hash = hash * 31 + char;
+      // Calculate new hash value while keeping numbers manageable
+      hash = Math.floor((hash * prime + char) % modulus);
     }
-    return hash;
+
+    return Math.abs(hash);
   }
 
   /**

src/plugins/filters/README.md

@@ -27,9 +27,9 @@ To define a filter, you'll need to add a new `filter` property to the domain obj
         singleSelectionThreshold: true,
         comparator: 'equals',
         possibleValues: [
-            { name: 'Apple', value: 'apple' },
-            { name: 'Banana', value: 'banana' },
-            { name: 'Orange', value: 'orange' }
+            { label: 'Apple', value: 'apple' },
+            { label: 'Banana', value: 'banana' },
+            { label: 'Orange', value: 'orange' }
         ]
     }]
 }