@yuuvis/client-core 3.7.0 → 3.8.0

package/fesm2022/yuuvis-client-core.mjs

@@ -109,7 +109,7 @@ const RelationshipTypeField = {
     TARGET_ID: 'system:targetId'
 };
 const LockField = {
-    LOCK_TAG: 'system:lock:resistent'
+    LOCK_TAG: 'system:lock:resistant'
 };
 const CatalogTypeField = {
     NATIVE_ID: 'system:nativeId',
@@ -2001,29 +2001,59 @@ class SystemService {
      * @param objectTypesQA Quick access object of all object types
      * @param raw If set to 'true' only the properties of the object type itself will be returned (without SOTs)
      */
-    #resolveObjectTypeFields(schemaTypeDefinition, propertiesQA, objectTypesQA) {
-        const objectTypeFieldIDs = schemaTypeDefinition.propertyReference.map((propertyRef) => propertyRef.value);
+    #resolveObjectTypeFields(schemaTypeDefinition, propertiesQA, objectTypesQA, seen = new Set()) {
+        // guard against cycles in the static-SOT or base-type chain
+        if (seen.has(schemaTypeDefinition.id)) {
+            return [];
+        }
+        seen.add(schemaTypeDefinition.id);
+        // fields defined directly on the type, keeping each reference's own 'required' flag
+        let fields = schemaTypeDefinition.propertyReference.flatMap((propertyRef) => {
+            const propDef = propertiesQA[propertyRef.value];
+            if (!propDef) {
+                return [];
+            }
+            return [
+                {
+                    ...propDef,
+                    required: propertyRef.required ?? propDef.required,
+                    _internalType: this.getInternalFormElementType(propDef.propertyType, propDef.classifications)
+                }
+            ];
+        });
+        // fields contributed by static secondary object types. Resolved recursively so that
+        // a static SOT's own static SOTs and base fields are included too, and so each field
+        // keeps the 'required' flag from the SOT's own property reference.
         if (schemaTypeDefinition.secondaryObjectTypeId) {
             schemaTypeDefinition.secondaryObjectTypeId
                 .filter((sot) => sot.static)
-                .map((sot) => sot.value)
-                .forEach((sotID) => objectTypesQA[sotID].propertyReference.forEach((propertyRef) => objectTypeFieldIDs.push(propertyRef.value)));
+                .map((sot) => objectTypesQA[sot.value])
+                .filter((sotDef) => !!sotDef)
+                .forEach((sotDef) => {
+                fields = fields.concat(this.#resolveObjectTypeFields(sotDef, propertiesQA, objectTypesQA, seen));
+            });
         }
-        let fields = objectTypeFieldIDs.map((id) => {
-            const propDef = propertiesQA[id];
-            const propRef = schemaTypeDefinition.propertyReference.find((propertyRef) => propertyRef.value === id);
-            const required = propRef?.required ?? propDef.required;
-            return {
-                ...propDef,
-                required,
-                _internalType: this.getInternalFormElementType(propertiesQA[id].propertyType, propertiesQA[id].classifications)
-            };
-        });
-        // also resolve properties of the base type
+        // fields inherited from the base type
         if (schemaTypeDefinition.baseId !== schemaTypeDefinition.id && !!objectTypesQA[schemaTypeDefinition.baseId]) {
-            fields = fields.concat(this.#resolveObjectTypeFields(objectTypesQA[schemaTypeDefinition.baseId], propertiesQA, objectTypesQA));
+            fields = fields.concat(this.#resolveObjectTypeFields(objectTypesQA[schemaTypeDefinition.baseId], propertiesQA, objectTypesQA, seen));
         }
-        return fields;
+        // de-dupe by id, keeping the first occurrence so direct fields win over those
+        // inherited from static SOTs or the base type
+        return this.#dedupeFieldsById(fields);
+    }
+    /**
+     * De-duplicate a list of fields by id, keeping the first occurrence.
+     * @param fields Fields to de-duplicate
+     */
+    #dedupeFieldsById(fields) {
+        const seen = new Set();
+        return fields.filter((field) => {
+            if (seen.has(field.id)) {
+                return false;
+            }
+            seen.add(field.id);
+            return true;
+        });
     }
     #isCreatable(objectTypeId) {
         return ![SystemType.FOLDER, SystemType.DOCUMENT].includes(objectTypeId);