@memberjunction/react-runtime 5.26.0 → 5.27.0

package/.turbo/turbo-build.log

@@ -1,13 +1,13 @@
 
-> @memberjunction/react-runtime@5.26.0 build
+> @memberjunction/react-runtime@5.27.0 build
 > npm run build:node && npm run build:umd
 
 
-> @memberjunction/react-runtime@5.26.0 build:node
+> @memberjunction/react-runtime@5.27.0 build:node
 > tsc
 
 
-> @memberjunction/react-runtime@5.26.0 build:umd
+> @memberjunction/react-runtime@5.27.0 build:umd
 > webpack --config webpack.umd.config.cjs
 
 [BABEL] Note: The code generator has deoptimised the styling of /home/runner/work/MJ/MJ/packages/MJCoreEntities/dist/generated/entity_subclasses.js as it exceeds the max of 500KB.
@@ -26,6 +26,6 @@ cacheable modules 6.56 MiB
     ../../MJCoreEntities/dist/engines/UserViewEngine.js 19.6 KiB [built] [code generated]
   ./dist/index.js + 27 modules 426 KiB [built] [code generated]
   ../../MJCore/dist/index.js + 75 modules 1.3 MiB [built] [code generated]
-  ../../MJGlobal/dist/index.js + 16 modules 220 KiB [built] [code generated]
+  ../../MJGlobal/dist/index.js + 16 modules 221 KiB [built] [code generated]
   ../../GraphQLDataProvider/dist/index.mjs 158 KiB [built] [code generated]
-webpack 5.105.0 compiled successfully in 76682 ms
+webpack 5.105.0 compiled successfully in 85682 ms

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @memberjunction/react-runtime
 
+## 5.27.0
+
+### Patch Changes
+
+- @memberjunction/graphql-dataprovider@5.27.0
+- @memberjunction/interactive-component-types@5.27.0
+- @memberjunction/core@5.27.0
+- @memberjunction/core-entities@5.27.0
+- @memberjunction/global@5.27.0
+
 ## 5.26.0
 
 ### Patch Changes

package/dist/runtime.umd.js

@@ -19975,6 +19975,20 @@ var BaseInfo = /*#__PURE__*/function () {
       this.copyInitData(initData);
     }
   }
+  /**
+   * Default JSON serialization for BaseInfo subclasses.
+   *
+   * Emits all non-underscored direct field declarations. For `_`-prefixed private backing fields
+   * (the MJ pattern for collection storage — e.g. `_Fields`, `_RelatedEntities`, `_OrganicKeys`),
+   * emits the value of the corresponding same-named public getter instead. Purely computed getters
+   * without a backing field (display-name formatters, derived flags) are intentionally skipped —
+   * they can throw when source fields are null and don't belong on the wire anyway.
+   *
+   * Nested BaseInfo instances and arrays of them unwrap automatically via JSON.stringify's
+   * native toJSON() protocol.
+   *
+   * Subclasses may override to emit a filtered subset or custom shape (see EntityFieldValueInfo).
+   */
   return _createClass(BaseInfo, [{
     key: "copyInitData",
     value:
@@ -20003,6 +20017,32 @@ var BaseInfo = /*#__PURE__*/function () {
         }
       }
     }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      var result = {};
+      var self = this;
+      for (var _i = 0, _Object$keys = Object.keys(this); _i < _Object$keys.length; _i++) {
+        var key = _Object$keys[_i];
+        if (!key.startsWith('_')) {
+          result[key] = self[key];
+          continue;
+        }
+        // Private backing field — expose via its public getter if one exists with the same name minus the underscore
+        var publicKey = key.slice(1);
+        if (!publicKey) continue;
+        var proto = Object.getPrototypeOf(this);
+        while (proto && proto !== Object.prototype) {
+          var desc = Object.getOwnPropertyDescriptor(proto, publicKey);
+          if (desc && typeof desc.get === 'function') {
+            result[publicKey] = self[publicKey];
+            break;
+          }
+          proto = Object.getPrototypeOf(proto);
+        }
+      }
+      return result;
+    }
   }]);
 }();
 ;// ../../MJCore/dist/generic/platformVariants.js
@@ -22629,7 +22669,7 @@ var EntityOrganicKeyInfo = /*#__PURE__*/function (_BaseInfo3) {
     if (initData) {
       _this3.copyInitData(initData);
       _this3._RelatedEntities = [];
-      var re = initData.EntityOrganicKeyRelatedEntities || initData._RelatedEntities;
+      var re = initData.EntityOrganicKeyRelatedEntities || initData._RelatedEntities || initData.RelatedEntities;
       if (re && Array.isArray(re)) {
         // sort by sequence
         var sorted = entityInfo_toConsumableArray(re);
@@ -22883,8 +22923,20 @@ var EntityFieldValueInfo = /*#__PURE__*/function (_BaseInfo6) {
     _this6.copyInitData(initData);
     return _this6;
   }
+  /**
+   * Returns a plain object suitable for JSON serialization.
+   * Called automatically by JSON.stringify().
+   */
   entityInfo_inherits(EntityFieldValueInfo, _BaseInfo6);
-  return entityInfo_createClass(EntityFieldValueInfo);
+  return entityInfo_createClass(EntityFieldValueInfo, [{
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        Value: this.Value,
+        Code: this.Code
+      };
+    }
+  }]);
 }(BaseInfo);
 var GeneratedFormSectionType = {
   Top: 'Top',
@@ -23945,9 +23997,9 @@ var EntityInfo = /*#__PURE__*/function (_BaseInfo0) {
     if (initData) {
       _this0.copyInitData(initData);
       // do some special handling to create class instances instead of just data objects
-      // copy the Entity Fields
+      // copy the Entity Fields (accept EntityFields, _Fields, or Fields as input names)
       _this0._Fields = [];
-      var ef = initData.EntityFields || initData._Fields;
+      var ef = initData.EntityFields || initData._Fields || initData.Fields;
       if (ef) {
         for (var j = 0; j < ef.length; j++) {
           _this0._Fields.push(new EntityFieldInfo(ef[j]));
@@ -23971,9 +24023,9 @@ var EntityInfo = /*#__PURE__*/function (_BaseInfo0) {
       }
       // auto-populate FieldCategories from the FieldCategoryInfo setting
       _this0._FieldCategories = _this0.parseFieldCategoriesFromSettings();
-      // copy the Related Entities
+      // copy the Related Entities (accept EntityRelationships, _RelatedEntities, or RelatedEntities as input names)
       _this0._RelatedEntities = [];
-      var er = initData.EntityRelationships || initData._RelatedEntities;
+      var er = initData.EntityRelationships || initData._RelatedEntities || initData.RelatedEntities;
       if (er) {
         // check to see if ANY of the records in the er array have a non-null or non-zero sequence value. The reason is 
         // if we have any sequence values populated we want to sort by that sequence, and we want to consider null to be a high number
@@ -24009,7 +24061,7 @@ var EntityInfo = /*#__PURE__*/function (_BaseInfo0) {
       }
       // copy the Organic Keys (sorted by sequence inside EntityOrganicKeyInfo constructor)
       _this0._OrganicKeys = [];
-      var ok = initData.EntityOrganicKeys || initData._OrganicKeys;
+      var ok = initData.EntityOrganicKeys || initData._OrganicKeys || initData.OrganicKeys;
       if (ok && Array.isArray(ok)) {
         var _iterator3 = entityInfo_createForOfIteratorHelper(ok),
           _step3;
@@ -94007,12 +94059,19 @@ function util_GetGlobalObjectStore() {
 }
 /**
  * This utility function will copy all scalar and array properties from an object to a new object and return the new object.
- * This function will NOT copy functions or non-plain objects (unless resolveCircularReferences is true).
+ * This function will NOT copy non-plain object instances (unless they implement `toJSON()` or `resolveCircularReferences` is true).
+ *
+ * The function respects the standard JavaScript `toJSON()` protocol: if a value exposes a `toJSON()` method
+ * (as `Date`, `BaseInfo` subclasses, and user-defined classes can), the method is invoked and its return value
+ * is processed in place of the original. This mirrors how `JSON.stringify()` handles serialization.
+ *
+ * Arrays are recursively processed — each item is copied/toJSON'd individually — so nested objects with
+ * `toJSON()` are unwrapped to their serializable form.
  *
  * @param input - The object to copy
  * @param resolveCircularReferences - If true, handles circular references and complex objects for safe JSON serialization.
  *                                     When enabled, circular references are replaced with '[Circular Reference]',
- *                                     complex objects (Sockets, Streams, etc.) are replaced with their type names,
+ *                                     complex objects without `toJSON()` are replaced with their type names,
  *                                     Error objects are specially handled to extract name/message/stack,
  *                                     and Dates are converted to ISO strings. Default: false
  * @param maxDepth - Maximum recursion depth when resolveCircularReferences is true (default: 10)
@@ -94053,11 +94112,8 @@ function CopyScalarsAndArrays(input) {
           return _copy(item, depth + 1);
         });
       }
-      // Handle Date objects
-      if (_.isDate(value)) {
-        return value.toISOString();
-      }
       // Handle Error objects specially to get their properties
+      // (checked before toJSON so we always get name/message/stack, even if Error subclasses define toJSON)
       if (value instanceof Error) {
         return _objectSpread({
           name: value.name,
@@ -94065,6 +94121,10 @@ function CopyScalarsAndArrays(input) {
           stack: value.stack
         }, _copy(_.omit(value, ['name', 'message', 'stack']), depth + 1));
       }
+      // Respect the toJSON() protocol (covers Date, BaseInfo subclasses, and any class that implements it)
+      if (typeof value.toJSON === 'function') {
+        return _copy(value.toJSON(), depth + 1);
+      }
       // Handle plain objects (POJOs)
       if (_.isPlainObject(value)) {
         var result = {};
@@ -94075,7 +94135,7 @@ function CopyScalarsAndArrays(input) {
         }
         return result;
       }
-      // For complex objects (Socket, Stream, Buffer, etc.), just use the type name
+      // For complex objects without toJSON (Socket, Stream, Buffer, etc.), just use the type name
       var typeName = ((_value$constructor = value.constructor) === null || _value$constructor === void 0 ? void 0 : _value$constructor.name) || 'Object';
       if (typeName !== 'Object') {
         return "[".concat(typeName, "]");
@@ -94084,21 +94144,41 @@ function CopyScalarsAndArrays(input) {
     };
     return _copy(input, 0);
   } else {
-    // Original implementation for backward compatibility
+    // Simple mode: preserves existing behavior (primitives/functions pass through, class instances
+    // without toJSON get their keys dropped) while honoring the toJSON() protocol and recursing
+    // into array items so nested objects with toJSON are unwrapped.
     var result = {};
     Object.keys(input).forEach(function (key) {
       var value = input[key];
-      // Check for null or scalar types directly
+      // Primitives, null, functions — pass through
       if (value === null || util_typeof(value) !== 'object') {
         result[key] = value;
-      } else if (Array.isArray(value)) {
-        // Handle arrays by creating a new array with the same elements
-        result[key] = _toConsumableArray(value);
-      } else if (util_typeof(value) === 'object' && value.constructor === Object) {
-        // Recursively copy plain objects
+        return;
+      }
+      // toJSON protocol — use the method's output
+      var valueToJSON = value.toJSON;
+      if (typeof valueToJSON === 'function') {
+        result[key] = valueToJSON.call(value);
+        return;
+      }
+      // Arrays — process each item; items with toJSON are unwrapped, class instances without it are replaced with null to preserve array length
+      if (Array.isArray(value)) {
+        result[key] = value.map(function (item) {
+          if (item === null || util_typeof(item) !== 'object') return item;
+          var itemToJSON = item.toJSON;
+          if (typeof itemToJSON === 'function') return itemToJSON.call(item);
+          if (item.constructor === Object) return CopyScalarsAndArrays(item);
+          // Non-plain, non-toJSON class instances inside an array — can't drop without changing
+          // array length, so fall back to null (sanitized placeholder)
+          return null;
+        });
+        return;
+      }
+      // Plain objects — recurse (key omitted for class instances without toJSON)
+      if (value.constructor === Object) {
         result[key] = CopyScalarsAndArrays(value);
       }
-      // Functions and non-plain objects are intentionally ignored
+      // else: non-plain class instance without toJSON → key is dropped entirely (matches legacy)
     });
     return result;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memberjunction/react-runtime",
-  "version": "5.26.0",
+  "version": "5.27.0",
   "description": "Platform-agnostic React component runtime for MemberJunction. Provides core compilation, registry, and execution capabilities for React components in any JavaScript environment.",
   "type": "module",
   "main": "dist/index.js",
@@ -29,11 +29,11 @@
   },
   "homepage": "https://github.com/MemberJunction/MJ#readme",
   "dependencies": {
-    "@memberjunction/core": "5.26.0",
-    "@memberjunction/global": "5.26.0",
-    "@memberjunction/interactive-component-types": "5.26.0",
-    "@memberjunction/core-entities": "5.26.0",
-    "@memberjunction/graphql-dataprovider": "5.26.0",
+    "@memberjunction/core": "5.27.0",
+    "@memberjunction/global": "5.27.0",
+    "@memberjunction/interactive-component-types": "5.27.0",
+    "@memberjunction/core-entities": "5.27.0",
+    "@memberjunction/graphql-dataprovider": "5.27.0",
     "@babel/standalone": "^7.29.1",
     "rxjs": "^7.8.2"
   },