fix: add equality checks to domain-raw and interplote

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---

Author: Sachinn-64

lib/node_modules/@stdlib/plot/vega/scale/base/ctor/lib/domain-raw/set.js

@@ -23,6 +23,7 @@
 // MODULES //
 
 var logger = require( 'debug' );
+var hasSameValues = require( '@stdlib/array/base/assert/has-same-values' );
 var isCollection = require( '@stdlib/assert/is-collection' );
 var isUndefined = require( '@stdlib/assert/is-undefined' );
 var copy = require( '@stdlib/utils/copy' );
@@ -51,16 +52,34 @@ var debug = logger( 'vega:scale:set:'+prop.name );
 * @returns {void}
 */
 function set( value ) {
-	if ( !isCollection( value ) && !isUndefined( value ) ) {
+	var curr;
+	var flg;
+
+	flg = isCollection( value );
+	if ( !flg && !isUndefined( value ) ) {
 		throw new TypeError( format( 'invalid assignment. `%s` must be an array-like object. Value: `%s`.', prop.name, value ) );
 	}
+	curr = this[ prop.private ];
 
-	// FIXME: should we perform a deep equal check here in order to avoid a potential false positive change event?
-
-	value = copy( value );
-	debug( 'Current value: %s. New value: %s.', JSON.stringify( this[ prop.private ] ), JSON.stringify( value ) );
-	this[ prop.private ] = value;
-	this.emit( 'change', changeEvent( prop.name ) );
+	// Case: collection ?= current
+	if ( flg ) {
+		// Check for element-wise equality...
+		if ( isCollection( curr ) && hasSameValues( value, curr ) ) {
+			return;
+		}
+		value = copy( value ); // TODO: is deep copying necessary here? If the domain can include, e.g., objects, it is. If only primitives, it is less necessary.
+		debug( 'Current value: %s. New value: %s.', JSON.stringify( this[ prop.private ] ), JSON.stringify( value ) );
+		this[ prop.private ] = value;
+		this.emit( 'change', changeEvent( prop.name ) );
+		return;
+	}
+	// Case: void ?= current
+	if ( curr !== value ) {
+		value = copy( value );
+		debug( 'Current value: %s. New value: %s.', JSON.stringify( this[ prop.private ] ), JSON.stringify( value ) );
+		this[ prop.private ] = value;
+		this.emit( 'change', changeEvent( prop.name ) );
+	}
 }
 
 

lib/node_modules/@stdlib/plot/vega/scale/base/ctor/lib/interpolate/set.js

@@ -23,6 +23,7 @@
 // MODULES //
 
 var logger = require( 'debug' );
+var isDeepEqual = require( '@stdlib/assert/deep-equal' );
 var isInterpolationMethod = require( '@stdlib/plot/vega/base/assert/is-scale-range-interpolation-method' );
 var isObject = require( '@stdlib/assert/is-object' );
 var isUndefined = require( '@stdlib/assert/is-undefined' );
@@ -56,13 +57,13 @@ function set( value ) {
 	if ( !flg && !isObject( value ) && !isUndefined( value ) ) {
 		throw new TypeError( format( 'invalid assignment. `%s` must be either an object or a valid interpolation method. Value: `%s`.', prop.name, value ) );
 	}
-	value = copy( value );
-
-	// FIXME: should we perform a deep equal comparison to avoid triggering a false positive change event?
-
-	debug( 'Current value: %s. New value: %s.', this[ prop.private ], value );
-	this[ prop.private ] = value;
-	this.emit( 'change', changeEvent( prop.name ) );
+	// TODO: explore whether we can be more intelligent when performing deep equality checks for an interpolation object rather than relying on a general deep equality check.
+	if ( !isDeepEqual( value, this[ prop.private ] ) ) {
+		value = copy( value );
+		debug( 'Current value: %s. New value: %s.', this[ prop.private ], value );
+		this[ prop.private ] = value;
+		this.emit( 'change', changeEvent( prop.name ) );
+	}
 }