@procivis/one-react-native-components 0.1.63 → 0.3.22

package/src/utils/parsers/credential.ts

@@ -0,0 +1,365 @@
+import {
+  Claim,
+  Config,
+  CredentialDetail,
+  CredentialListItem,
+  CredentialSchema,
+  CredentialStateEnum,
+  DataTypeEnum,
+  FormatFeatureEnum,
+} from '@procivis/react-native-one-core';
+
+import {
+  CredentialAttribute,
+  CredentialAttributeValue,
+  CredentialCardProps,
+  CredentialDetailsCardProps,
+  CredentialHeaderProps,
+} from '../../ui-components/credential';
+import { CredentialCardNotice } from '../../ui-components/credential/card/credential-card';
+import { CredentialErrorIcon, CredentialNoticeWarningIcon, CredentialWarningIcon } from '../../ui-components/icons';
+import { formatDateLocalized, formatDateTimeLocalized } from '../date';
+import { concatTestID } from '../testID';
+import { getCarouselImagesFromClaims } from './credential-images';
+
+export enum ValidityState {
+  Revoked = 'revoked',
+  Suspended = 'suspended',
+  Valid = 'valid',
+}
+
+export const getValidityState = (credential: CredentialListItem | undefined) => {
+  if (credential?.state === CredentialStateEnum.REVOKED) {
+    return ValidityState.Revoked;
+  }
+  if (credential?.state === CredentialStateEnum.SUSPENDED) {
+    return ValidityState.Suspended;
+  }
+  return ValidityState.Valid;
+};
+
+export const supportsSelectiveDisclosure = (credential: CredentialListItem | undefined, config: Config | undefined) => {
+  const formatConfig = credential && config?.format[credential.schema.format];
+  return formatConfig
+    ? Boolean(formatConfig.capabilities?.features?.includes(FormatFeatureEnum.SelectiveDisclosure))
+    : undefined;
+};
+
+const findClaimByPathParts = (path: string[], claims?: Claim[]): Claim | undefined => {
+  if (!claims?.length) {
+    return undefined;
+  }
+  const [first, second, ...rest] = path;
+  const claim = claims.find((c) => c.key === first);
+  if (claim === undefined || second === undefined || claim.dataType !== DataTypeEnum.Object) {
+    return claim;
+  }
+
+  return findClaimByPathParts([`${first}/${second}`, ...rest], claim.value as Claim[]);
+};
+
+export const findClaimByPath = (path: string | undefined, claims: Claim[] | undefined) =>
+  path ? findClaimByPathParts(path.split('/'), claims) : undefined;
+
+const formatCredentialDetail = (claim: Claim, config: Config, testID: string): string => {
+  const attributeValue = detailsCardAttributeValueFromClaim(claim, config, testID);
+  return attributeValue.value ?? '';
+};
+
+export const hasMsoValidityIssues = (credential: CredentialDetail): boolean => {
+  const mdocMsoValidity: { nextUpdate: string } | undefined =
+    'mdocMsoValidity' in credential ? (credential.mdocMsoValidity as { nextUpdate: string }) : undefined;
+
+  const mdocMsoValidityIssue = Boolean(
+    mdocMsoValidity?.nextUpdate && new Date(mdocMsoValidity.nextUpdate) < new Date(),
+  );
+
+  return mdocMsoValidityIssue;
+};
+
+export type CardHeaderLabels = {
+  validityIssues: string;
+  revoked: string;
+  suspended: string;
+  suspendedUntil: (date: string) => string;
+};
+
+export const cardHeaderFromCredential = (
+  credential: CredentialDetail,
+  claims: Claim[] = [],
+  config: Config,
+  testID: string,
+  labels: CardHeaderLabels,
+): Omit<CredentialHeaderProps, 'style'> => {
+  let credentialDetailPrimary = formatDateTimeLocalized(new Date(credential.issuanceDate)) ?? '';
+
+  let credentialDetailSecondary: string | undefined;
+  let credentialDetailErrorColor: boolean | undefined;
+  let credentialDetailTestID: string | undefined;
+  let statusIcon;
+
+  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;
+    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);
+
+        if (primary) {
+          credentialDetailPrimary = formatCredentialDetail(primary, config, concatTestID(testID, 'primary'));
+        }
+
+        const secondary = findClaimByPath(layoutProperties?.secondaryAttribute, claims);
+
+        if (secondary) {
+          credentialDetailSecondary = formatCredentialDetail(secondary, config, concatTestID(testID, 'secondary'));
+        }
+
+        credentialDetailTestID = concatTestID(testID, 'detail');
+      }
+      break;
+    }
+  }
+  return {
+    color: layoutProperties?.logo?.backgroundColor,
+    credentialDetailErrorColor,
+    credentialDetailPrimary,
+    credentialDetailSecondary,
+    credentialDetailTestID,
+    credentialName: credential.schema.name,
+    icon: layoutProperties?.logo?.image
+      ? {
+          imageSource: {
+            uri: layoutProperties.logo.image,
+          },
+        }
+      : undefined,
+    iconLabelColor: layoutProperties?.logo?.fontColor,
+    statusIcon,
+    testID,
+  };
+};
+
+export type CardLabels = CardHeaderLabels & {
+  validityIssuesNotice: string;
+};
+
+export const getCredentialCardPropsFromCredential = (
+  credential: CredentialDetail,
+  claims: Claim[] = [],
+  config: Config,
+  notice: CredentialCardNotice | undefined,
+  testID: string,
+  labels: CardLabels,
+): Omit<CredentialCardProps, 'onHeaderPress' | 'style'> => {
+  const { layoutProperties } = credential.schema;
+
+  if (hasMsoValidityIssues(credential)) {
+    notice = {
+      text: labels.validityIssuesNotice,
+      noticeIcon: CredentialNoticeWarningIcon,
+    };
+  }
+
+  const result: Omit<CredentialCardProps, 'onHeaderPress' | 'style'> = {
+    cardCarouselImages: getCarouselImagesFromClaims(claims, layoutProperties, concatTestID(testID, 'carousel')),
+    cardImage: layoutProperties?.background?.image
+      ? { imageSource: { uri: layoutProperties.background.image } }
+      : undefined,
+    color: layoutProperties?.background?.color,
+    header: cardHeaderFromCredential(credential, claims, config, concatTestID(testID, 'header'), labels),
+    testID,
+    notice,
+  };
+
+  return result;
+};
+
+export const detailsCardAttributeFromClaim = (claim: Claim, config: Config, testID: string): CredentialAttribute => {
+  const value = detailsCardAttributeValueFromClaim(claim, config, testID);
+  return {
+    id: claim.id,
+    name: claim.key.split('/').pop(),
+    path: claim.key,
+    ...value,
+  };
+};
+
+const detailsCardAttributeValueFromClaim = (claim: Claim, config: Config, testID: string): CredentialAttributeValue => {
+  const typeConfig = config?.datatype[claim.dataType];
+
+  if (claim.array) {
+    return {
+      values: (claim.value || []).map((arrayValue, index) => {
+        return detailsCardAttributeFromClaim(
+          {
+            ...arrayValue,
+            id: `${arrayValue.id}/${index}`,
+          },
+          config,
+          concatTestID(testID, index.toString()),
+        );
+      }),
+    };
+  } else {
+    switch (typeConfig?.type) {
+      case DataTypeEnum.Object: {
+        if (!Array.isArray(claim.value)) {
+          return { attributes: [] };
+        }
+        return {
+          attributes: (claim.value as Claim[]).map((nestedClaim, index) =>
+            detailsCardAttributeFromClaim(nestedClaim, config, concatTestID(testID, index.toString())),
+          ),
+        };
+      }
+      case DataTypeEnum.Date: {
+        const date = claim.value as string;
+        return {
+          testID: testID,
+          value: formatDateLocalized(new Date(date)) ?? date,
+        };
+      }
+      case DataTypeEnum.File: {
+        if (typeConfig.params?.showAs === 'IMAGE') {
+          return { image: { uri: claim.value as string }, testID: testID };
+        } else {
+          return { testID: testID, value: claim.value as string };
+        }
+      }
+      default:
+        return { testID: testID, value: String(claim.value) };
+    }
+  }
+};
+
+export const detailsCardFromCredential = (
+  credential: CredentialDetail,
+  config: Config,
+  testID: string,
+  labels: CardLabels,
+): Omit<CredentialDetailsCardProps, 'expanded'> => {
+  return detailsCardFromCredentialWithClaims(credential, credential.claims, config, testID, labels);
+};
+
+export const detailsCardFromCredentialWithClaims = (
+  credential: CredentialDetail,
+  claims: Claim[],
+  config: Config,
+  testID: string,
+  labels: CardLabels,
+): Omit<CredentialDetailsCardProps, 'expanded'> => {
+  const attributes: CredentialAttribute[] = claims.map((claim, index) =>
+    detailsCardAttributeFromClaim(claim, config, concatTestID(testID, 'attribute', index.toString())),
+  );
+
+  const card = getCredentialCardPropsFromCredential(
+    credential,
+    claims,
+    config,
+    undefined,
+    concatTestID(testID, 'card'),
+    labels,
+  );
+
+  return {
+    attributes,
+    card,
+  };
+};
+
+// Converts a flat list of attributes into a nested structure
+// modifies the names to not include slashes
+export const nestAttributes = (attributes: CredentialAttribute[]): CredentialAttribute[] => {
+  const result: CredentialAttribute[] = [];
+
+  for (const attribute of attributes) {
+    const attributePath = attribute.path.split('/');
+    if (attributePath.length === 0) {
+      result.push(attribute);
+    } else {
+      const [first, ...rest] = attributePath;
+      const parent = result.find((a) => a.name === first);
+      if (parent) {
+        insertAttributeInObject({ ...attribute, path: rest.join('/') }, parent);
+      } else {
+        result.push(nestAttributeInDummyObject(attribute));
+      }
+    }
+  }
+
+  return result;
+};
+
+// 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 pathParts = attribute.path.split('/');
+  const [first, ...rest] = pathParts;
+  if (!rest.length) {
+    return attribute;
+  }
+
+  // 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,
+  };
+};
+
+// Recursively insert an attribute into an object
+// Will create nested objects if necessary
+const insertAttributeInObject = (attribute: CredentialAttribute, object: CredentialAttribute) => {
+  const pathParts = attribute.path.split('/');
+  const [first, ...rest] = pathParts;
+
+  const nextParent = object.attributes?.find((a) => a.name === first);
+
+  if (!nextParent) {
+    object.attributes?.push(nestAttributeInDummyObject(attribute));
+  } else {
+    insertAttributeInObject({ ...attribute, path: rest.join('/') }, nextParent);
+  }
+};
+
+function parseBase64Image(image: string | undefined) {
+  return image ? '__BASE64IMAGE__' : '';
+}
+
+export function getCredentialSchemaWithoutImages(credentialSchema: CredentialSchema) {
+  return {
+    ...credentialSchema,
+    layoutProperties: {
+      ...credentialSchema.layoutProperties,
+      background: {
+        ...credentialSchema.layoutProperties?.background,
+        image: parseBase64Image(credentialSchema.layoutProperties?.background?.image),
+      },
+      logo: {
+        ...credentialSchema.layoutProperties?.logo,
+        image: parseBase64Image(credentialSchema.layoutProperties?.logo?.image),
+      },
+    },
+  };
+}

package/src/utils/parsers/index.ts

@@ -0,0 +1,5 @@
+export * from './credential';
+export * from './credential-images';
+export * from './credential-sharing';
+export * from './query';
+export * from './universal-links';

package/src/utils/parsers/query.tsx

@@ -0,0 +1,82 @@
+import {
+  CredentialListQuery,
+  CredentialSchemaListQuery,
+  DidListQuery,
+  HistoryListQuery,
+  ProofListQuery,
+  ProofSchemaListQuery,
+} from '@procivis/react-native-one-core';
+
+export const getQueryKeyFromCredentialListQueryParams = (queryParams?: Partial<CredentialListQuery>) => {
+  if (!queryParams) {
+    return [];
+  }
+  const { name, sort, sortDirection, exact, role, ids, status, include } = queryParams;
+  return [name, sort, sortDirection, exact, role, ids, status, include];
+};
+
+export const getQueryKeyFromHistoryListQueryParams = (queryParams?: Partial<HistoryListQuery>) => {
+  if (!queryParams) {
+    return [];
+  }
+
+  const {
+    entityId,
+    action,
+    entityTypes,
+    createdDateFrom,
+    createdDateTo,
+    didId,
+    credentialId,
+    credentialSchemaId,
+    searchText,
+    searchType,
+    proofSchemaId,
+  } = queryParams;
+  return [
+    entityId,
+    action,
+    entityTypes,
+    createdDateFrom,
+    createdDateTo,
+    didId,
+    credentialId,
+    credentialSchemaId,
+    searchText,
+    searchType,
+    proofSchemaId,
+  ];
+};
+
+export const getQueryKeyFromCredentialSchemaListQueryParams = (queryParams?: Partial<CredentialSchemaListQuery>) => {
+  if (!queryParams) {
+    return [];
+  }
+  const { name, sort, sortDirection, exact, ids, include } = queryParams;
+  return [name, sort, sortDirection, exact, ids, include];
+};
+
+export const getQueryKeyFromProofSchemaListQueryParams = (queryParams?: Partial<ProofSchemaListQuery>) => {
+  if (!queryParams) {
+    return [];
+  }
+  const { name, sort, sortDirection, exact, ids } = queryParams;
+  return [name, sort, sortDirection, exact, ids];
+};
+
+export const getQueryKeyFromProofListQueryParams = (queryParams?: Partial<ProofListQuery>) => {
+  if (!queryParams) {
+    return [];
+  }
+  const { name, sort, sortDirection, exact, ids, proofStates, proofSchemaIds } = queryParams;
+  return [name, sort, sortDirection, exact, ids, proofStates, proofSchemaIds];
+};
+
+export const getQueryKeyFromDidListQueryParams = (queryParams?: Partial<DidListQuery>) => {
+  if (!queryParams) {
+    return [];
+  }
+
+  const { name, did, type, deactivated, keyAlgorithms, keyRoles } = queryParams;
+  return [name, did, type, deactivated, keyAlgorithms, keyRoles];
+};

package/src/utils/parsers/universal-links.test.ts

@@ -0,0 +1,57 @@
+import { parseUniversalLink } from './universal-links';
+
+jest.mock('@react-native-community/netinfo', () => ({
+  addEventListener: () => {},
+}));
+
+jest.mock('react-native-bluetooth-state-manager', () => ({
+  onStateChange: () => {},
+}));
+
+describe('parseUniversalLink', () => {
+  test('Credential schema universal link url', () => {
+    const parsedLink = parseUniversalLink(
+      'https://desk.dev.procivis-one.com/app-link/schema?url=https%3A%2F%2Fcore.dev.procivis-one.com%2Fssi%2Fschema%2Fv1%2F2c986182-0bca-4342-b0e0-4e149b1818c7',
+    );
+    expect(parsedLink).toStrictEqual(
+      'https://core.dev.procivis-one.com/ssi/schema/v1/2c986182-0bca-4342-b0e0-4e149b1818c7',
+    );
+  });
+  test('OpenID4VC credential offer universal link url', () => {
+    const parsedLink = parseUniversalLink(
+      'https://desk.dev.procivis-one.com/app-link/openid-credential-offer?credential_offer_uri=https%3A%2F%2Fcore.dev.procivis-one.com%2Fssi%2Foidc-issuer%2Fv1%2Ffde1ca86-3ea1-410e-9da4-b210355e5dd2%2Foffer%2F4e626c92-9f20-4031-992d-242563ab5ef3',
+    );
+    expect(parsedLink).toStrictEqual(
+      'openid-credential-offer://?credential_offer_uri=https%3A%2F%2Fcore.dev.procivis-one.com%2Fssi%2Foidc-issuer%2Fv1%2Ffde1ca86-3ea1-410e-9da4-b210355e5dd2%2Foffer%2F4e626c92-9f20-4031-992d-242563ab5ef3',
+    );
+  });
+  test('OpenID4VP proof request universal link url', () => {
+    const parsedLink = parseUniversalLink(
+      'https://desk.dev.procivis-one.com/app-link/openid4vp?client_id=https%3A%2F%2Fcore.dev.procivis-one.com%2Fssi%2Foidc-verifier%2Fv1%2Fresponse&client_id_scheme=verifier_attestation&request_uri=https%3A%2F%2Fcore.dev.procivis-one.com%2Fssi%2Foidc-verifier%2Fv1%2F74fe0d75-d568-4178-9f73-5cd4e3f5a2ae%2Fclient-request',
+    );
+    expect(parsedLink).toStrictEqual(
+      'openid4vp://?client_id=https%3A%2F%2Fcore.dev.procivis-one.com%2Fssi%2Foidc-verifier%2Fv1%2Fresponse&client_id_scheme=verifier_attestation&request_uri=https%3A%2F%2Fcore.dev.procivis-one.com%2Fssi%2Foidc-verifier%2Fv1%2F74fe0d75-d568-4178-9f73-5cd4e3f5a2ae%2Fclient-request',
+    );
+  });
+
+  test('Invalid link', () => {
+    const parsedLink = parseUniversalLink('invalid');
+    expect(parsedLink).toStrictEqual(undefined);
+  });
+  test('Non-universal link', () => {
+    const parsedLink = parseUniversalLink(
+      'openid4vp://?client_id=https%3A%2F%2Fcore.dev.procivis-one.com%2Fssi%2Foidc-verifier%2Fv1%2Fresponse&client_id_scheme=verifier_attestation&request_uri=https%3A%2F%2Fcore.dev.procivis-one.com%2Fssi%2Foidc-verifier%2Fv1%2F74fe0d75-d568-4178-9f73-5cd4e3f5a2ae%2Fclient-request',
+    );
+    expect(parsedLink).toStrictEqual(undefined);
+  });
+  test('Invalid https universal link url', () => {
+    const parsedLink = parseUniversalLink(
+      'https://desk.dev.procivis-one.com/app-schema/link?url=https%3A%2F%2Fcore.dev.procivis-one.com%2Fssi%2Fschema%2Fv1%2F2c986182-0bca-4342-b0e0-4e149b1818c7',
+    );
+    expect(parsedLink).toStrictEqual(undefined);
+  });
+  test('Schema universal link url with invalid params', () => {
+    const parsedLink = parseUniversalLink('https://desk.dev.procivis-one.com/app-link/schema?key=value');
+    expect(parsedLink).toStrictEqual(undefined);
+  });
+});

package/src/utils/parsers/universal-links.ts

@@ -0,0 +1,26 @@
+import parseUrl from 'parse-url';
+
+export const parseUniversalLink = (universalLink: string): string | undefined => {
+  let parsedUrl: parseUrl.ParsedUrl;
+  try {
+    parsedUrl = parseUrl(universalLink);
+  } catch (e) {
+    return undefined;
+  }
+
+  if (parsedUrl.parse_failed) {
+    return undefined;
+  }
+  const protocol = parsedUrl.protocol as string;
+  if (!['http', 'https'].includes(protocol)) {
+    return undefined;
+  }
+  if (!parsedUrl.pathname.startsWith('/app-link/')) {
+    return undefined;
+  }
+  if (parsedUrl.pathname === '/app-link/schema') {
+    return parsedUrl.query.url;
+  }
+  const originalProtocol = parsedUrl.pathname.split('/').pop();
+  return `${originalProtocol}://?${parsedUrl.search}`;
+};

package/src/utils/ref.ts

@@ -15,7 +15,7 @@ const isWritable = <T extends Object>(obj: T, key: keyof T) => {
  *    return <RefComponent ref={forwardedRef} {...props} />;
  * }
  */
-export const useForwardedRef = <Component extends React.Component<any> | React.ComponentClass<any>>(
+export const useForwardedRef = <Component extends React.ElementType<any, any>>(
   passedRef?: React.Ref<Component>,
 ) => {
   const localRef = useRef<Component>(null);

package/src/utils/reporting.ts

@@ -0,0 +1,85 @@
+/* eslint-disable no-console */
+import { OneError } from '@procivis/react-native-one-core';
+import * as Sentry from '@sentry/react-native';
+
+export function reportError(message: string) {
+  if (!__DEV__) {
+    try {
+      Sentry.captureException(new Error(message));
+    } catch (error) {
+      // do nothing
+    }
+  } else {
+    console.warn('reportError:', message);
+  }
+}
+
+const getDebugExceptionInfo = (error: unknown, message: string | undefined) => {
+  if (error instanceof OneError) {
+    let info = `[${error.code}](${error.message})`;
+    if (error.cause) {
+      info = `${info}: ${error.cause}`;
+    }
+    return message ? `(${message}, ${info})` : info;
+  }
+
+  return message ? `(${message})` : '';
+};
+
+export function reportException(e: unknown, message?: string) {
+  if (!__DEV__) {
+    try {
+      Sentry.withScope((scope) => {
+        if (message) {
+          scope.setExtra('message', message);
+        }
+
+        if (e instanceof OneError) {
+          // prevent reporting specific errors
+          if (e.cause?.includes('BLE adapter not enabled')) {
+            return;
+          }
+
+          scope.setExtra('operation', e.operation);
+          scope.setExtra('code', e.code);
+          scope.setExtra('codeMessage', e.message);
+          if (e.cause) {
+            scope.setExtra('cause', e.cause);
+          }
+
+          Sentry.captureException(e.originalError);
+        } else {
+          Sentry.captureException(e);
+        }
+      });
+    } catch (error) {
+      // do nothing
+    }
+  } else {
+    const info = getDebugExceptionInfo(e, message);
+    console.warn(`reportException${info}`, e, e instanceof Error ? e.stack : undefined);
+  }
+}
+
+export function reportTraceInfo(category: string, message?: string, data?: Sentry.Breadcrumb['data']) {
+  if (!__DEV__) {
+    try {
+      Sentry.addBreadcrumb({
+        category,
+        data,
+        level: 'log',
+        message,
+      });
+    } catch (error) {
+      // do nothing
+    }
+  } else {
+    const logged: unknown[] = [category, message];
+
+    if (data) {
+      logged.push(data);
+    }
+
+    console.log(...logged);
+  }
+}

package/src/utils/string.ts

@@ -0,0 +1,17 @@
+export const capitalizeFirstLetter = (string: string) => {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+};
+
+export const capitalize = (str: string): string =>
+  str
+    ?.split(' ')
+    .filter((x) => x)
+    .map((x) => x.charAt(0).toUpperCase() + x.substring(1).toLowerCase())
+    .join(' ');
+
+export const replaceBreakingHyphens = (str: string): string => str.replace(/-/g, '\u2011');
+
+export const isASCII = (str: string) => {
+  // eslint-disable-next-line no-control-regex
+  return /^[\x00-\xFF]*$/.test(str);
+};

package/src/utils/useMemoAsync.ts

@@ -42,7 +42,7 @@ export function useMemoAsync<Value, FallbackValue = Value | undefined>(
         if (!abortCtrl.signal.aborted) setValue(fallbackValue ?? initialValue);
       }
     };
-    update();
+    update().catch(() => {});
     return () => abortCtrl.abort();
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, deps);

package/src/utils/uuid.ts

@@ -0,0 +1,8 @@
+import UUID from 'react-native-uuid';
+
+/**
+ * Insecure identifier generator
+ * @returns {string} UUID v4
+ * @example `11edc52b-2918-4d71-9058-f7285e29d894`
+ */
+export const generateUUID = (): string => UUID.v4() as string;