code: function interceptPropertySet ({ entity, properties }) {
    // Create a proxy .interceptPropertySet(...) methods, per property
    this.interceptPropertySet = _.reduce(properties, (interceptPropertySet, propertyConfiguration, propertyName) => {
  
      // Fetch extensions implementing .interceptPropertySet(...) method for this property's interceptor functions
      let setterInterceptors = _.compact(
        _.map(this.extensions, (extension) => {
          // Check if implementing .interceptPropertySet(...) method
          if (extension.implemented.interceptPropertySet) {
            // Return the setter interceptor function (if returned for this property)
            return extension.interceptPropertySet(propertyName, propertyConfiguration);
          }
        })
      );
  
      // Initialize a per-property setter intercepting function and returns the updated value
      interceptPropertySet[propertyName] = (currentValue, newValue) => {
  
        // Initialize the EnTTExtValueEvent event
        let changes = [ currentValue, newValue ],
            event = new EnTTExtValueEvent({
          changes,
          currentValue,
          value: newValue,
        });
  
        // Cycle through all the setter interceptors
        _.forEach(setterInterceptors, (setterInterceptor) => {
          // Execute the extensino intercaptor
          setterInterceptor(entity, properties, event);
          // Update the changes array for the next interceptor
          changes.push(event.value);
        });
  
        // Return the updated value
        return event.value;
  
      };
  
      // Return composed interceptors
      return interceptPropertySet;
  
    }, {});
  }
docs: Creates a method used to call all extensions' .interceptPropertySet(...) method when needed (if the extension is implementing it)
  @param {any} entity Reference to the parent entity instance
  @param {any} properties Properties configuration