@procivis/one-react-native-components 0.3.71 → 0.3.91

package/src/utils/parsers/credential-sharing-v2.tsx

@@ -0,0 +1,278 @@
+import {
+  Claim,
+  Config,
+  DataTypeEnum,
+  FailureHint,
+  PresentationDefinitionV2ClaimValue,
+  PresentationDefinitionV2CredentialClaim,
+  PresentationDefinitionV2CredentialDetail,
+} from '@procivis/react-native-one-core';
+import React from 'react';
+
+import {
+  CredentialAttribute,
+  CredentialCardNotice,
+  CredentialCardProps,
+  CredentialNoticeWarningIcon,
+  CredentialWarningIcon,
+  Selector,
+  SelectorStatus,
+} from '../../ui-components';
+import { concatTestID } from '../testID';
+import {
+  CredentialDetailsCardPropsWithoutWidth,
+  detailsCardAttributeFromClaim,
+  getCredentialCardPropsFromCredential,
+  supportsSelectiveDisclosure,
+} from '.';
+import { ShareCredentialCardLabels, validityCheckedCardFromCredential } from './credential-sharing';
+
+const v2ClaimValueToClaimValue = (value: PresentationDefinitionV2ClaimValue): string | number | boolean | Claim[] => {
+  if (!Array.isArray(value)) {
+    return value;
+  }
+  return value.map((c) => v2PresentationClaimToClaim(c));
+};
+
+const v2PresentationClaimToClaim = (claim: PresentationDefinitionV2CredentialClaim): Claim => {
+  if (Array.isArray(claim.value)) {
+    if (claim.schema.array) {
+      return {
+        array: claim.schema.array,
+        dataType: claim.schema.datatype,
+        id: claim.path,
+        key: claim.path,
+        value: v2ClaimValueToClaimValue(claim.value) as Claim[],
+      };
+    } else {
+      return {
+        array: claim.schema.array,
+        dataType: DataTypeEnum.Object,
+        id: claim.path,
+        key: claim.path,
+        value: v2ClaimValueToClaimValue(claim.value) as Claim[],
+      };
+    }
+  }
+  return {
+    array: false,
+    dataType: claim.schema.datatype,
+    id: claim.path,
+    key: claim.path,
+    value: claim.value,
+  };
+};
+
+const getAttributeSelectorStatus = (
+  claim: PresentationDefinitionV2CredentialClaim,
+  selected: boolean,
+  force: boolean,
+): SelectorStatus | undefined => {
+  if (claim.required && selected) {
+    return SelectorStatus.Required;
+  }
+  if (force && claim.value) {
+    return SelectorStatus.Required;
+  }
+  if (claim.userSelection) {
+    if (selected) {
+      return SelectorStatus.SelectedCheckmark;
+    } else {
+      return SelectorStatus.Empty;
+    }
+  }
+};
+
+export const shareCredentialCardAttributeFromV2Claim = (
+  claim: PresentationDefinitionV2CredentialClaim,
+  selection: string[] | undefined,
+  parentShared: boolean,
+  parentUserSelected: boolean,
+  config: Config,
+  testID: string,
+  nested?: boolean,
+  listValue?: boolean,
+): CredentialAttribute => {
+  const attributeShared =
+    Boolean(selection?.some((path) => path.startsWith(claim.path))) || (parentShared && claim.required);
+  const userSelected = parentUserSelected || Boolean(selection?.includes(claim.path));
+  const selected = !claim.required && attributeShared;
+  const status = selection
+    ? getAttributeSelectorStatus(claim, attributeShared, parentUserSelected || (attributeShared && !userSelected))
+    : undefined;
+  const attribute = detailsCardAttributeFromClaim(v2PresentationClaimToClaim(claim), config, testID);
+  const disabledStatus = [SelectorStatus.Disabled, SelectorStatus.Rejected, SelectorStatus.Required];
+  const disabled = attribute.disabled || !status || disabledStatus.includes(status);
+  const credentialAttribute: CredentialAttribute = {
+    ...attribute,
+    disabled,
+    id: claim.path,
+    listValue,
+    nested,
+    path: claim.path,
+    rightAccessory: status && <Selector status={status} />,
+    selected,
+    testID,
+  };
+  if (Array.isArray(claim.value)) {
+    if (claim.schema.array) {
+      return {
+        ...credentialAttribute,
+        attributes: undefined,
+        image: undefined,
+        value: undefined,
+        values: claim.value.map((v) =>
+          shareCredentialCardAttributeFromV2Claim(
+            v,
+            selection,
+            attributeShared,
+            userSelected,
+            config,
+            testID,
+            true,
+            false,
+          ),
+        ),
+      };
+    } else if (claim.schema.datatype === 'OBJECT') {
+      return {
+        ...credentialAttribute,
+        attributes: claim.value.map((v) =>
+          shareCredentialCardAttributeFromV2Claim(v, selection, attributeShared, userSelected, config, testID, true),
+        ),
+        image: undefined,
+        value: undefined,
+        valueErrorColor: undefined,
+        values: undefined,
+      };
+    }
+  }
+  return credentialAttribute;
+};
+
+export const missingCredentialCardFromFailureHint = (
+  failureHint: FailureHint['failureHint'] | undefined,
+  notice: CredentialCardNotice | undefined,
+  testID: string,
+  labels: ShareCredentialCardLabels,
+): Omit<CredentialCardProps, 'onHeaderPress' | 'style' | 'width'> => {
+  return {
+    cardImage: undefined,
+    color: undefined,
+    header: {
+      credentialDetailErrorColor: true,
+      credentialDetailPrimary: labels.missingCredential,
+      credentialDetailTestID: concatTestID(testID, 'header.missing'),
+      credentialName: failureHint?.credentialSchema?.name ?? '',
+      statusIcon: CredentialWarningIcon,
+    },
+    testID,
+    ...notice,
+  };
+};
+
+export const shareCredentialCardFromV2PresentationCredential = (
+  credential: PresentationDefinitionV2CredentialDetail | undefined,
+  failureHint: FailureHint['failureHint'] | undefined,
+  expanded: boolean,
+  multipleCredentialsAvailable: boolean,
+  selectedFields: string[] | undefined,
+  config: Config,
+  testID: string,
+  labels: ShareCredentialCardLabels,
+): CredentialDetailsCardPropsWithoutWidth => {
+  const selectiveDisclosureSupported = supportsSelectiveDisclosure(
+    credential ? { ...credential, issuer: credential.issuer?.id } : undefined,
+    config,
+  );
+  const notice: CredentialCardNotice | undefined =
+    selectiveDisclosureSupported === false
+      ? {
+          noticeIcon: CredentialNoticeWarningIcon,
+          text: labels.selectiveDisclosureNotice,
+        }
+      : undefined;
+  const cardTestId = concatTestID(testID, 'card');
+  const card = credential
+    ? validityCheckedCardFromCredential(
+        {
+          ...credential,
+          claims: [],
+        },
+        false,
+        expanded,
+        multipleCredentialsAvailable,
+        config,
+        notice,
+        cardTestId,
+        labels,
+      )
+    : missingCredentialCardFromFailureHint(failureHint, notice, cardTestId, labels);
+
+  return {
+    attributes:
+      credential?.claims.map((v) =>
+        shareCredentialCardAttributeFromV2Claim(v, selectedFields ?? [], true, false, config, testID),
+      ) ?? [],
+    card,
+  };
+};
+
+export const selectCredentialCardFromV2Credential = (
+  credential: PresentationDefinitionV2CredentialDetail,
+  selected: boolean,
+  multiple: boolean,
+  config: Config,
+  testID: string,
+  labels: ShareCredentialCardLabels,
+): CredentialDetailsCardPropsWithoutWidth => {
+  const selectiveDisclosureSupported = supportsSelectiveDisclosure(
+    credential ? { ...credential, issuer: credential.issuer?.id } : undefined,
+    config,
+  );
+  const selectedStatus = multiple ? SelectorStatus.SelectedCheckmark : SelectorStatus.SelectedRadio;
+  const rightAccessory = <Selector status={selected ? selectedStatus : SelectorStatus.Empty} />;
+  const notice: CredentialCardNotice | undefined =
+    selectiveDisclosureSupported === false
+      ? {
+          noticeIcon: CredentialNoticeWarningIcon,
+          text: labels.selectiveDisclosureNotice,
+        }
+      : undefined;
+  const { header, ...cardProps } = getCredentialCardPropsFromCredential(
+    {
+      ...credential,
+      claims: credential.claims.map(v2PresentationClaimToClaim),
+    },
+    credential.claims.map(v2PresentationClaimToClaim),
+    config,
+    notice,
+    testID,
+    labels,
+  );
+  const card = {
+    header: {
+      ...header,
+      accessory: rightAccessory,
+    },
+    ...cardProps,
+  };
+  return {
+    attributes:
+      credential?.claims.map((v) =>
+        shareCredentialCardAttributeFromV2Claim(v, undefined, false, false, config, testID),
+      ) ?? [],
+    card,
+  };
+};
+
+export const getV2CredentialClaimAllSubpaths = (claim: PresentationDefinitionV2CredentialClaim): string[] => {
+  if (!Array.isArray(claim.value)) {
+    return [claim.path];
+  }
+  return [claim.path, ...claim.value.flatMap(getV2CredentialClaimAllSubpaths)];
+};
+
+export const getV2CredentialAvailablePaths = (credential: PresentationDefinitionV2CredentialDetail): string[] => {
+  return credential.claims.flatMap(getV2CredentialClaimAllSubpaths);
+};

package/src/utils/parsers/credential-sharing.tsx

@@ -40,13 +40,13 @@ export const validityCheckedCardFromCredential = (
 ): Omit<CredentialCardProps, 'onHeaderPress' | 'style' | 'testID' | 'width'> => {
   let credentialHeaderDetail:
     | Pick<
-      CredentialHeaderProps,
-      | 'credentialDetailPrimary'
-      | 'credentialDetailSecondary'
-      | 'credentialDetailErrorColor'
-      | 'credentialDetailTestID'
-      | 'statusIcon'
-    >
+        CredentialHeaderProps,
+        | 'credentialDetailPrimary'
+        | 'credentialDetailSecondary'
+        | 'credentialDetailErrorColor'
+        | 'credentialDetailTestID'
+        | 'statusIcon'
+      >
     | undefined;
   if (invalidLVVC) {
     credentialHeaderDetail = {
@@ -94,7 +94,7 @@ export const missingCredentialCardFromRequest = (
 };
 
 interface DisplayedAttribute {
-  claim?: Claim;
+  claim?: FlatClaim;
   field?: PresentationDefinitionField;
   id: string;
   selected?: boolean;
@@ -124,16 +124,33 @@ const getAttributeSelectorStatus = (
   return selected ? SelectorStatus.SelectedCheckmark : SelectorStatus.Empty;
 };
 
+type ClaimWithOptionalPath = Claim & {
+  path?: string;
+};
+
+type FlatClaim = Claim & {
+  path: string;
+  isArrayElement?: boolean;
+};
+
 // Returns a spread list of all claims with their full JSON path as key, including all intermediate objects
-const spreadClaims = (claims: Claim[], parentClaimPath = ''): Claim[] => {
-  return claims.reduce((acc, claim) => {
+const spreadClaims = (claims: ClaimWithOptionalPath[]): FlatClaim[] => {
+  const claimsWithPath: FlatClaim[] = claims.map((c) => ({
+    ...c,
+    path: c.path ?? c.key,
+  }));
+  return claimsWithPath.reduce((acc, claim) => {
     const result = [claim];
     if (Array.isArray(claim.value)) {
-      const claimPath = parentClaimPath ? `${parentClaimPath}/${claim.key}` : claim.key;
-      result.push(...spreadClaims(claim.value, claimPath));
+      const nestedClaimsWithPath: FlatClaim[] = claim.value.map((c, i) => ({
+        ...c,
+        path: claim.array ? `${c.key}/${i}` : c.key,
+        isArrayElement: claim.array,
+      }));
+      result.push(...spreadClaims(nestedClaimsWithPath));
     }
     return [...acc, ...result];
-  }, [] as Claim[]);
+  }, [] as FlatClaim[]);
 };
 
 const getDisplayedAttributes = (
@@ -144,10 +161,13 @@ const getDisplayedAttributes = (
   selectedFields?: string[],
 ): DisplayedAttribute[] => {
   const claims = credential ? spreadClaims(credential.claims) : undefined;
+  const isApplicable = credential ? request.applicableCredentials.includes(credential.id) : false;
 
   let fields = request.fields;
   if (credential) {
-    const fieldsWithNoKeyMapping = request.fields.filter((field) => !(credential.id in field.keyMap));
+    const fieldsWithNoKeyMapping = request.fields
+      .filter((field) => !(credential.id in field.keyMap))
+      .filter((field) => !isApplicable || !field.required);
     const fullyNestedFields = getFullyNestedFields(request.fields, credential.id);
 
     fields = [...fieldsWithNoKeyMapping, ...fullyNestedFields];
@@ -156,8 +176,8 @@ const getDisplayedAttributes = (
   return fields.map((field) => {
     const selected = !field.required && selectedFields?.includes(field.id);
     const claim = credential
-      ? claims?.find(({ key }) => {
-        return key === field.keyMap[credential.id];
+      ? claims?.find(({ path }) => {
+          return path === field.keyMap[credential.id];
         })
       : undefined;
     const status =
@@ -185,11 +205,16 @@ export const shareCredentialCardAttributeFromClaim = (
   config: Config,
   testID: string,
   labels: ShareCredentialCardLabels,
-  claim?: Claim,
+  claim?: FlatClaim,
   field?: PresentationDefinitionField,
 ): CredentialAttribute => {
   if (claim) {
-    return { ...detailsCardAttributeFromClaim(claim, config, testID), id };
+    return {
+      ...detailsCardAttributeFromClaim(claim, config, testID),
+      id,
+      path: claim.path,
+      listValue: claim.isArrayElement,
+    };
   }
   return {
     id,
@@ -259,26 +284,24 @@ export const shareCredentialCardFromCredential = (
   const notice: CredentialCardNotice | undefined =
     selectiveDisclosureSupported === false
       ? {
-        text: labels.selectiveDisclosureNotice,
-        noticeIcon: CredentialNoticeWarningIcon,
-      }
+          text: labels.selectiveDisclosureNotice,
+          noticeIcon: CredentialNoticeWarningIcon,
+        }
       : undefined;
   const cardTestId = concatTestID(testID, 'card');
   const card = credential
     ? validityCheckedCardFromCredential(
-      credential,
-      invalidLVVC,
-      expanded,
-      multipleCredentialsAvailable,
-      config,
-      notice,
-      cardTestId,
-      labels,
-    )
+        credential,
+        invalidLVVC,
+        expanded,
+        multipleCredentialsAvailable,
+        config,
+        notice,
+        cardTestId,
+        labels,
+      )
     : missingCredentialCardFromRequest(request, notice, cardTestId, labels);
-  const validityState = getValidityState(
-    credential ? { ...credential, issuer: credential.issuer?.id } : undefined,
-  );
+  const validityState = getValidityState(credential ? { ...credential, issuer: credential.issuer?.id } : undefined);
   const displayedAttributes = getDisplayedAttributes(
     request,
     validityState,
@@ -315,7 +338,7 @@ export const selectCredentialCardAttributeFromClaim = (
   config: Config,
   testID: string,
   labels: ShareCredentialCardLabels,
-  claim?: Claim,
+  claim?: FlatClaim,
   field?: PresentationDefinitionField,
 ): CredentialAttribute => {
   const attribute = shareCredentialCardAttributeFromClaim(id, config, testID, labels, claim, field);
@@ -344,9 +367,9 @@ export const selectCredentialCardFromCredential = (
   const notice: CredentialCardNotice | undefined =
     selectiveDisclosureSupported === false
       ? {
-        text: labels.selectiveDisclosureNotice,
-        noticeIcon: CredentialNoticeWarningIcon,
-      }
+          text: labels.selectiveDisclosureNotice,
+          noticeIcon: CredentialNoticeWarningIcon,
+        }
       : undefined;
   const { header, ...cardProps } = getCredentialCardPropsFromCredential(
     credential,
@@ -363,9 +386,9 @@ export const selectCredentialCardFromCredential = (
     },
     ...cardProps,
   };
-  const attributes: CredentialAttribute[] = request.fields.map((field) => {
-    const claim = spreadClaims(credential.claims).find(({ key }) => {
-      return key === field.keyMap[credential.id];
+  const attributes: CredentialAttribute[] = getFullyNestedFields(request.fields, credential.id).map((field) => {
+    const claim = spreadClaims(credential.claims).find(({ path }) => {
+      return path === field.keyMap[credential.id];
     });
 
     const attribute = selectCredentialCardAttributeFromClaim(field.id, config, testID, labels, claim, field);

package/src/utils/parsers/credential.ts

@@ -8,6 +8,8 @@ import {
   DataTypeEnum,
   FormatFeatureEnum,
 } from '@procivis/react-native-one-core';
+import { FC } from 'react';
+import { SvgProps } from 'react-native-svg';
 
 import {
   CredentialAttribute,
@@ -84,60 +86,86 @@ export type CardHeaderLabels = {
   suspendedUntil: (date: string) => string;
 };
 
-export const cardHeaderFromCredential = (
+const credentialDetailFromCredential = (
   credential: CredentialDetail,
   claims: Claim[] = [],
   config: Config,
   testID: string,
   labels: CardHeaderLabels,
-): Omit<CredentialHeaderProps, 'style'> => {
-  let credentialDetailPrimary =
-    formatDateTimeLocalized(new Date(credential.issuanceDate ?? credential.createdDate)) ?? '';
-
-  let credentialDetailSecondary: string | undefined;
-  let credentialDetailErrorColor: boolean | undefined;
-  let credentialDetailTestID: string | undefined;
-  let statusIcon;
-
+): {
+  credentialDetailPrimary?: string;
+  credentialDetailSecondary?: string;
+  credentialDetailErrorColor?: boolean;
+  credentialDetailTestID?: string;
+  statusIcon?: FC<SvgProps>;
+} => {
   const { layoutProperties } = credential.schema;
 
   switch (credential.state) {
     case CredentialStateEnum.SUSPENDED:
-      credentialDetailPrimary = credential.suspendEndDate
-        ? labels.suspendedUntil(formatDateTimeLocalized(new Date(credential.suspendEndDate))!)
-        : labels.suspended;
-      credentialDetailTestID = concatTestID(testID, 'suspended');
-      statusIcon = CredentialWarningIcon;
-      break;
+      return {
+        credentialDetailPrimary: credential.suspendEndDate
+          ? labels.suspendedUntil(formatDateTimeLocalized(new Date(credential.suspendEndDate))!)
+          : labels.suspended,
+        credentialDetailTestID: concatTestID(testID, 'suspended'),
+        statusIcon: CredentialWarningIcon,
+      };
     case CredentialStateEnum.REVOKED:
-      credentialDetailPrimary = labels.revoked;
-      credentialDetailErrorColor = true;
-      credentialDetailTestID = concatTestID(testID, 'revoked');
-      statusIcon = CredentialErrorIcon;
-      break;
-    default: {
-      if (hasMsoValidityIssues(credential)) {
-        credentialDetailPrimary = labels.validityIssues;
-        credentialDetailTestID = concatTestID(testID, 'validity-issue');
-        statusIcon = CredentialWarningIcon;
-      } else {
-        const primary = findClaimByPath(layoutProperties?.primaryAttribute, claims);
+      return {
+        credentialDetailPrimary: labels.revoked,
+        credentialDetailErrorColor: true,
+        credentialDetailTestID: concatTestID(testID, 'revoked'),
+        statusIcon: CredentialErrorIcon,
+      };
+  }
 
-        if (primary) {
-          credentialDetailPrimary = formatCredentialDetail(primary, config, concatTestID(testID, 'primary'));
-        }
+  if (hasMsoValidityIssues(credential)) {
+    return {
+      credentialDetailPrimary: labels.validityIssues,
+      credentialDetailTestID: concatTestID(testID, 'validity-issue'),
+      statusIcon: CredentialWarningIcon,
+    };
+  }
 
-        const secondary = findClaimByPath(layoutProperties?.secondaryAttribute, claims);
+  let credentialDetailPrimary =
+    formatDateTimeLocalized(new Date(credential.issuanceDate ?? credential.createdDate)) ?? '';
+  let credentialDetailSecondary: string | undefined;
 
-        if (secondary) {
-          credentialDetailSecondary = formatCredentialDetail(secondary, config, concatTestID(testID, 'secondary'));
-        }
+  const primary = findClaimByPath(layoutProperties?.primaryAttribute, claims);
 
-        credentialDetailTestID = concatTestID(testID, 'detail');
-      }
-      break;
-    }
+  if (primary) {
+    credentialDetailPrimary = formatCredentialDetail(primary, config, concatTestID(testID, 'primary'));
+  }
+
+  const secondary = findClaimByPath(layoutProperties?.secondaryAttribute, claims);
+
+  if (secondary) {
+    credentialDetailSecondary = formatCredentialDetail(secondary, config, concatTestID(testID, 'secondary'));
   }
+
+  return {
+    credentialDetailPrimary,
+    credentialDetailSecondary,
+    credentialDetailTestID: concatTestID(testID, 'detail'),
+  };
+};
+
+export const cardHeaderFromCredential = (
+  credential: CredentialDetail,
+  claims: Claim[] = [],
+  config: Config,
+  testID: string,
+  labels: CardHeaderLabels,
+): Omit<CredentialHeaderProps, 'style'> => {
+  const {
+    credentialDetailPrimary,
+    credentialDetailSecondary,
+    credentialDetailErrorColor,
+    credentialDetailTestID,
+    statusIcon,
+  } = credentialDetailFromCredential(credential, claims, config, testID, labels);
+  const { layoutProperties } = credential.schema;
+
   return {
     color: layoutProperties?.logo?.backgroundColor,
     credentialDetailErrorColor,
@@ -242,7 +270,8 @@ const detailsCardAttributeValueFromClaim = (claim: Claim, config: Config, testID
           value: formatDateLocalized(new Date(date)) ?? date,
         };
       }
-      case DataTypeEnum.File: {
+      case DataTypeEnum.Picture: // fallback
+      case DataTypeEnum.SwiyuPicture: {
         if (typeConfig.params?.showAs === 'IMAGE') {
           return { image: { uri: claim.value as string }, testID: testID };
         } else {
@@ -257,7 +286,7 @@ const detailsCardAttributeValueFromClaim = (claim: Claim, config: Config, testID
 
 export type CredentialDetailsCardPropsWithoutWidth = Omit<CredentialDetailsCardProps, 'expanded' | 'card'> & {
   card: Omit<CredentialCardProps, 'width'>;
-}
+};
 
 export const detailsCardFromCredential = (
   credential: CredentialDetail,
@@ -307,9 +336,9 @@ export const nestAttributes = (attributes: CredentialAttribute[]): CredentialAtt
       const [first, ...rest] = attributePath;
       const parent = result.find((a) => a.name === first);
       if (parent) {
-        insertAttributeInObject({ ...attribute, path: rest.join('/') }, parent);
+        insertAttributeInParent({ ...attribute, path: rest.join('/') }, parent);
       } else {
-        result.push(nestAttributeInDummyObject(attribute));
+        result.push(nestAttributeInDummyParent(attribute));
       }
     }
   }
@@ -319,7 +348,7 @@ export const nestAttributes = (attributes: CredentialAttribute[]): CredentialAtt
 
 // We nest the leaf node in a (one or more) nested object(s)
 // to make sure the tree structure is correctly rendered in proof request screens.
-const nestAttributeInDummyObject = (attribute: CredentialAttribute): CredentialAttribute => {
+const nestAttributeInDummyParent = (attribute: CredentialAttribute): CredentialAttribute => {
   const pathParts = attribute.path.split('/');
   const [first, ...rest] = pathParts;
   if (!rest.length) {
@@ -328,27 +357,41 @@ const nestAttributeInDummyObject = (attribute: CredentialAttribute): CredentialA
 
   // The dummy object is not selectable, and contains a placeholder ID
   // the user can't interact with it.
-  return {
-    attributes: [nestAttributeInDummyObject({ ...attribute, path: rest.join('/') })],
-    disabled: true,
-    id: `${attribute.id}/${first}`,
-    name: first,
-    path: attribute.path,
-  };
+  if (attribute.listValue) {
+    return {
+      values: [nestAttributeInDummyParent({ ...attribute, path: rest.join('/') })],
+      disabled: true,
+      id: `${attribute.id}/${first}`,
+      name: first,
+      path: first,
+    };
+  } else {
+    return {
+      attributes: [nestAttributeInDummyParent({ ...attribute, path: rest.join('/') })],
+      disabled: true,
+      id: `${attribute.id}/${first}`,
+      name: first,
+      path: first,
+    };
+  }
 };
 
-// Recursively insert an attribute into an object
-// Will create nested objects if necessary
-const insertAttributeInObject = (attribute: CredentialAttribute, object: CredentialAttribute) => {
+// Recursively insert an attribute into an parent
+// Will create nested parents if necessary
+const insertAttributeInParent = (attribute: CredentialAttribute, parent: CredentialAttribute) => {
   const pathParts = attribute.path.split('/');
   const [first, ...rest] = pathParts;
 
-  const nextParent = object.attributes?.find((a) => a.name === first);
+  const nextParent = parent.attributes?.find((a) => a.name === first);
 
   if (!nextParent) {
-    object.attributes?.push(nestAttributeInDummyObject(attribute));
+    if (attribute.listValue) {
+      parent.values?.push(nestAttributeInDummyParent(attribute));
+    } else {
+      parent.attributes?.push(nestAttributeInDummyParent(attribute));
+    }
   } else {
-    insertAttributeInObject({ ...attribute, path: rest.join('/') }, nextParent);
+    insertAttributeInParent({ ...attribute, path: rest.join('/') }, nextParent);
   }
 };