@bifold/oca 1.0.0

package/src/types/base/BaseOverlay.ts

@@ -0,0 +1,18 @@
+import { IBaseOverlayData } from '../../interfaces/data'
+
+export default class BaseOverlay {
+  #capture_base: string
+
+  type: string
+  digest: string
+
+  constructor(overlay: IBaseOverlayData) {
+    this.type = overlay.type
+    this.#capture_base = overlay.capture_base
+    this.digest = overlay.digest ?? ''
+  }
+
+  get captureBase(): string {
+    return this.#capture_base
+  }
+}

package/src/types/branding/BrandingOverlay.ts

@@ -0,0 +1,61 @@
+import { IBrandingOverlayData } from '../../interfaces/data'
+import { generateColor } from '../../utils/color'
+import BaseOverlay from '../base/BaseOverlay'
+
+export default class BrandingOverlay extends BaseOverlay {
+  #background_image?: string
+  #background_image_slice?: string
+  #primary_background_color: string
+  #secondary_background_color?: string
+  #primary_attribute?: string
+  #secondary_attribute?: string
+  #issued_date_attribute?: string
+  #expiry_date_attribute?: string
+
+  logo?: string
+
+  constructor(credentialDefinitionId: string, overlay: IBrandingOverlayData) {
+    super(overlay)
+    this.logo = overlay.logo
+    this.#background_image = overlay.background_image
+    this.#background_image_slice = overlay.background_image_slice
+    this.#primary_background_color = overlay.primary_background_color ?? generateColor(credentialDefinitionId)
+    this.#secondary_background_color = overlay.secondary_background_color
+    this.#primary_attribute = overlay.primary_attribute
+    this.#secondary_attribute = overlay.secondary_attribute
+    this.#issued_date_attribute = overlay.issued_date_attribute
+    this.#expiry_date_attribute = overlay.expiry_date_attribute
+  }
+
+  get backgroundImage(): string | undefined {
+    return this.#background_image
+  }
+
+  get backgroundImageSlice(): string | undefined {
+    return this.#background_image_slice
+  }
+
+  get primaryBackgroundColor(): string | undefined {
+    return this.#primary_background_color
+  }
+
+  get secondaryBackgroundColor(): string | undefined {
+    return this.#secondary_background_color
+  }
+
+  get primaryAttribute(): string | undefined {
+    return this.#primary_attribute
+  }
+
+  get secondaryAttribute(): string | undefined {
+    return this.#secondary_attribute
+  }
+
+  get issuedDateAttribute(): string | undefined {
+    return this.#issued_date_attribute
+  }
+
+  get expiryDateAttribute(): string | undefined {
+    return this.#expiry_date_attribute
+  }
+}

package/src/types/branding/LegacyBrandingOverlay.ts

@@ -0,0 +1,47 @@
+import { ILegacyBrandingOverlayData } from '../../interfaces/data'
+import { generateColor } from '../../utils/color'
+import BaseOverlay from '../base/BaseOverlay'
+
+export default class LegacyBrandingOverlay extends BaseOverlay {
+  #background_color: string
+  #image_source?: string
+  header?: {
+    color?: string
+    backgroundColor?: string
+    imageSource?: string
+    hideIssuer?: boolean
+  }
+  footer?: {
+    color?: string
+    backgroundColor?: string
+  }
+
+  constructor(credentialDefinitionId: string, overlay: ILegacyBrandingOverlayData) {
+    super(overlay)
+
+    this.#background_color = overlay.background_color ?? generateColor(credentialDefinitionId)
+    this.#image_source = overlay.image_source
+    if (overlay.header) {
+      this.header = {
+        color: overlay.header?.color,
+        backgroundColor: overlay.header?.background_color,
+        imageSource: overlay.header?.image_source,
+        hideIssuer: overlay.header?.hide_issuer,
+      }
+    }
+    if (overlay.footer) {
+      this.footer = {
+        color: overlay.footer?.color,
+        backgroundColor: overlay.footer?.background_color,
+      }
+    }
+  }
+
+  public get backgroundColor(): string {
+    return this.#background_color
+  }
+
+  public get imageSource(): string | undefined {
+    return this.#image_source
+  }
+}

package/src/types/bundle/OverlayBundle.ts

@@ -0,0 +1,203 @@
+import { IBrandingOverlayData, ILegacyBrandingOverlayData, IOverlayBundleData } from '../../interfaces/data'
+import { IOverlayBundleAttribute, IOverlayBundleMetadata } from '../../interfaces/overlay'
+import OverlayTypeMap from '../OverlayTypeMap'
+import { OverlayType } from '../TypeEnums'
+import BaseOverlay from '../base/BaseOverlay'
+import BrandingOverlay from '../branding/BrandingOverlay'
+import LegacyBrandingOverlay from '../branding/LegacyBrandingOverlay'
+import CaptureBase from '../capture-base/CaptureBase'
+import CharacterEncodingOverlay from '../semantic/CharacterEncodingOverlay'
+import FormatOverlay from '../semantic/FormatOverlay'
+import InformationOverlay from '../semantic/InformationOverlay'
+import LabelOverlay from '../semantic/LabelOverlay'
+import MetaOverlay from '../semantic/MetaOverlay'
+import StandardOverlay from '../semantic/StandardOverlay'
+
+class OverlayBundle {
+  credentialDefinitionId!: string
+  captureBase!: CaptureBase
+  overlays!: BaseOverlay[]
+  languages!: string[]
+  metadata!: IOverlayBundleMetadata
+  attributes!: IOverlayBundleAttribute[]
+  flaggedAttributes!: IOverlayBundleAttribute[]
+
+  constructor(credentialDefinitionId: string, bundle: IOverlayBundleData) {
+    this.credentialDefinitionId = credentialDefinitionId
+    this.captureBase = new CaptureBase(bundle.capture_base)
+    this.overlays = bundle.overlays
+      .filter((overlay) => !overlay.type.startsWith('aries/overlays/branding/'))
+      .map((overlay) => {
+        const OverlayClass = (OverlayTypeMap.get(overlay.type) || BaseOverlay) as typeof BaseOverlay
+        return new OverlayClass(overlay)
+      })
+    this.overlays.push(
+      ...bundle.overlays
+        .filter((overlay) => overlay.type === OverlayType.Branding01)
+        .map((overlay) => {
+          const OverlayClass = (OverlayTypeMap.get(overlay.type) ||
+            LegacyBrandingOverlay) as typeof LegacyBrandingOverlay
+          return new OverlayClass(credentialDefinitionId, overlay as ILegacyBrandingOverlayData)
+        })
+    )
+    this.overlays.push(
+      ...bundle.overlays
+        .filter((overlay) => overlay.type === OverlayType.Branding10 || overlay.type === OverlayType.Branding11)
+        .map((overlay) => {
+          const OverlayClass = (OverlayTypeMap.get(overlay.type) || BrandingOverlay) as typeof BrandingOverlay
+          return new OverlayClass(credentialDefinitionId, overlay as IBrandingOverlayData)
+        })
+    )
+    this.languages = this.#processLanguages()
+    this.metadata = this.#processMetadata()
+    this.attributes = this.#processOverlayAttributes()
+    this.flaggedAttributes = this.attributes.filter((attribute) =>
+      this.captureBase.flaggedAttributes.includes(attribute.name)
+    )
+  }
+
+  get branding(): BrandingOverlay | undefined {
+    return (
+      this.#overlaysForType<BrandingOverlay>(OverlayType.Branding10)[0] ||
+      this.#overlaysForType<BrandingOverlay>(OverlayType.Branding11)[0]
+    )
+  }
+
+  getAttribute(name: string): IOverlayBundleAttribute | undefined {
+    return this.attributes.find((attribute) => attribute.name === name)
+  }
+
+  getFlaggedAttribute(name: string): IOverlayBundleAttribute | undefined {
+    return this.flaggedAttributes.find((attribute) => attribute.name === name)
+  }
+
+  #processMetadata(): IOverlayBundleMetadata {
+    const metadata: IOverlayBundleMetadata & {
+      credentialHelpText: Record<string, string>
+      credentialSupportUrl: Record<string, string>
+      issuer: Record<string, string>
+      issuerDescription: Record<string, string>
+      issuerUrl: Record<string, string>
+    } = {
+      name: {},
+      description: {},
+      credentialHelpText: {},
+      credentialSupportUrl: {},
+      issuer: {},
+      issuerDescription: {},
+      issuerUrl: {},
+    }
+    for (const overlay of this.#overlaysForType<MetaOverlay>(OverlayType.Meta10)) {
+      const language = overlay.language ?? 'en'
+      const { name, description, credentialHelpText, credentialSupportUrl, issuer, issuerDescription, issuerUrl } =
+        overlay
+
+      if (name) {
+        metadata.name[language] = name
+      }
+      if (description) {
+        metadata.description[language] = description
+      }
+      if (credentialHelpText) {
+        metadata.credentialHelpText[language] = credentialHelpText
+      }
+      if (credentialSupportUrl) {
+        metadata.credentialSupportUrl[language] = credentialSupportUrl
+      }
+      if (issuer) {
+        metadata.issuer[language] = issuer
+      }
+      if (issuerDescription) {
+        metadata.issuerDescription[language] = issuerDescription
+      }
+      if (issuerUrl) {
+        metadata.issuerUrl[language] = issuerUrl
+      }
+    }
+    return metadata
+  }
+
+  #processLanguages(): string[] {
+    const languages: string[] = []
+    for (const overlay of this.#overlaysForType<MetaOverlay>(OverlayType.Meta10)) {
+      const language = overlay.language
+      if (language && !languages.includes(language)) {
+        languages.push(language)
+      }
+    }
+    languages.sort((a, b) => a.localeCompare(b))
+    return languages
+  }
+
+  #processOverlayAttributes(): IOverlayBundleAttribute[] {
+    const attributes: IOverlayBundleAttribute[] = []
+    const attributeMap = new Map(Object.entries(this.captureBase.attributes))
+    for (const [name, type] of attributeMap) {
+      attributes.push({
+        name,
+        type,
+        information: this.#processInformationForAttribute(name),
+        label: this.#processLabelForAttribute(name),
+        characterEncoding: this.#processCharacterEncodingForAttribute(name),
+        standard: this.#processStandardForAttribute(name),
+        format: this.#processFormatForAttribute(name),
+      })
+    }
+    return attributes
+  }
+
+  #processInformationForAttribute(key: string): Record<string, string> {
+    const information: Record<string, string> = {}
+    for (const overlay of this.#overlaysForType<InformationOverlay>(OverlayType.Information10)) {
+      if (overlay.attributeInformation?.[key]) {
+        const language = overlay.language ?? 'en'
+        information[language] = overlay.attributeInformation[key]
+      }
+    }
+    return information
+  }
+
+  #processLabelForAttribute(key: string): Record<string, string> {
+    const label: Record<string, string> = {}
+    for (const overlay of this.#overlaysForType<LabelOverlay>(OverlayType.Label10)) {
+      if (overlay.attributeLabels?.[key]) {
+        const language = overlay.language ?? 'en'
+        label[language] = overlay.attributeLabels[key]
+      }
+    }
+    return label
+  }
+
+  #processCharacterEncodingForAttribute(key: string): string | undefined {
+    for (const overlay of this.#overlaysForType<CharacterEncodingOverlay>(OverlayType.CharacterEncoding10)) {
+      if (overlay.attributeCharacterEncoding?.[key]) {
+        return overlay.attributeCharacterEncoding[key]
+      }
+    }
+    return
+  }
+
+  #processStandardForAttribute(key: string): string | undefined {
+    for (const overlay of this.#overlaysForType<StandardOverlay>(OverlayType.Standard10)) {
+      if (overlay.attributeStandards?.[key]) {
+        return overlay.attributeStandards[key]
+      }
+    }
+    return
+  }
+
+  #processFormatForAttribute(key: string): string | undefined {
+    for (const overlay of this.#overlaysForType<FormatOverlay>(OverlayType.Format10)) {
+      if (overlay.attributeFormats?.[key]) {
+        return overlay.attributeFormats[key]
+      }
+    }
+    return
+  }
+
+  #overlaysForType<T>(type: string): T[] {
+    return this.overlays.filter((overlay) => overlay.type === type) as T[]
+  }
+}
+
+export default OverlayBundle

package/src/types/capture-base/CaptureBase.ts

@@ -0,0 +1,22 @@
+import { ICaptureBaseData } from '../../interfaces/data'
+
+export default class CaptureBase {
+  #flagged_attributes: string[]
+
+  type: string
+  classification: string
+  attributes: Record<string, string>
+  digest: string
+
+  constructor(captureBase: ICaptureBaseData) {
+    this.type = captureBase.type
+    this.classification = captureBase.classification
+    this.attributes = captureBase.attributes
+    this.#flagged_attributes = captureBase.flagged_attributes
+    this.digest = captureBase.digest ?? ''
+  }
+
+  get flaggedAttributes(): string[] {
+    return this.#flagged_attributes
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,30 @@
+import OverlayTypeMap from './OverlayTypeMap'
+import { OverlayType, CaptureBaseAttributeType } from './TypeEnums'
+import BaseOverlay from './base/BaseOverlay'
+import BrandingOverlay from './branding/BrandingOverlay'
+import LegacyBrandingOverlay from './branding/LegacyBrandingOverlay'
+import OverlayBundle from './bundle/OverlayBundle'
+import CaptureBase from './capture-base/CaptureBase'
+import CharacterEncodingOverlay from './semantic/CharacterEncodingOverlay'
+import FormatOverlay from './semantic/FormatOverlay'
+import InformationOverlay from './semantic/InformationOverlay'
+import LabelOverlay from './semantic/LabelOverlay'
+import MetaOverlay from './semantic/MetaOverlay'
+import StandardOverlay from './semantic/StandardOverlay'
+
+export {
+  OverlayType,
+  CaptureBaseAttributeType,
+  BaseOverlay,
+  CaptureBase,
+  OverlayBundle,
+  BrandingOverlay,
+  LegacyBrandingOverlay,
+  CharacterEncodingOverlay,
+  FormatOverlay,
+  InformationOverlay,
+  LabelOverlay,
+  MetaOverlay,
+  StandardOverlay,
+  OverlayTypeMap,
+}

package/src/types/semantic/CharacterEncodingOverlay.ts

@@ -0,0 +1,30 @@
+import { ICharacterEncodingOverlayData } from '../../interfaces/data'
+import BaseOverlay from '../base/BaseOverlay'
+
+export default class CharacterEncodingOverlay extends BaseOverlay {
+  #default_character_encoding?: string
+  // DEPRECATED - Use #attribute_character_encoding instead
+  #attr_character_encoding?: Record<string, string>
+  #attribute_character_encoding?: Record<string, string>
+
+  constructor(overlay: ICharacterEncodingOverlayData) {
+    super(overlay)
+    this.#default_character_encoding = overlay.default_character_encoding
+    // DEPRECATED - Use #attribute_character_encoding instead
+    this.#attr_character_encoding = overlay.attr_character_encoding
+    this.#attribute_character_encoding = overlay.attribute_character_encoding
+  }
+
+  get defaultCharacterEncoding(): string | undefined {
+    return this.#default_character_encoding
+  }
+
+  // DEPRECATED - Use attributeCharacterEncoding instead
+  get attrCharacterEncoding(): Record<string, string> | undefined {
+    return this.#attr_character_encoding
+  }
+
+  get attributeCharacterEncoding(): Record<string, string> | undefined {
+    return this.#attribute_character_encoding
+  }
+}

package/src/types/semantic/FormatOverlay.ts

@@ -0,0 +1,15 @@
+import { IFormatOverlayData } from '../../interfaces/data'
+import BaseOverlay from '../base/BaseOverlay'
+
+export default class FormatOverlay extends BaseOverlay {
+  #attribute_formats: Record<string, string>
+
+  constructor(overlay: IFormatOverlayData) {
+    super(overlay)
+    this.#attribute_formats = overlay.attribute_formats
+  }
+
+  get attributeFormats(): Record<string, string> {
+    return this.#attribute_formats
+  }
+}

package/src/types/semantic/InformationOverlay.ts

@@ -0,0 +1,18 @@
+import { IInformationOverlayData } from '../../interfaces/data'
+import BaseOverlay from '../base/BaseOverlay'
+
+export default class InformationOverlay extends BaseOverlay {
+  #attribute_information: Record<string, string>
+
+  language: string
+
+  constructor(overlay: IInformationOverlayData) {
+    super(overlay)
+    this.language = overlay.language
+    this.#attribute_information = overlay.attribute_information
+  }
+
+  get attributeInformation(): Record<string, string> {
+    return this.#attribute_information
+  }
+}

package/src/types/semantic/LabelOverlay.ts

@@ -0,0 +1,30 @@
+import { ILabelOverlayData } from '../../interfaces/data'
+import BaseOverlay from '../base/BaseOverlay'
+
+export default class LabelOverlay extends BaseOverlay {
+  #attribute_labels: Record<string, string>
+  #attribute_categories?: string[]
+  #category_labels?: Record<string, string>
+
+  language: string
+
+  constructor(overlay: ILabelOverlayData) {
+    super(overlay)
+    this.language = overlay.language
+    this.#attribute_labels = overlay.attribute_labels
+    this.#attribute_categories = overlay.attribute_categories
+    this.#category_labels = overlay.category_labels
+  }
+
+  get attributeLabels(): Record<string, string> {
+    return this.#attribute_labels
+  }
+
+  get attributeCategories(): string[] | undefined {
+    return this.#attribute_categories
+  }
+
+  get categoryLabels(): Record<string, string> | undefined {
+    return this.#category_labels
+  }
+}

package/src/types/semantic/MetaOverlay.ts

@@ -0,0 +1,48 @@
+import { IMetaOverlayData } from '../../interfaces/data'
+import BaseOverlay from '../base/BaseOverlay'
+
+export default class MetaOverlay extends BaseOverlay {
+  #credential_help_text?: string
+  #credential_support_url?: string
+  #issuer_description?: string
+  #issuer_url?: string
+  #watermark?: string
+
+  language: string
+  name?: string
+  description?: string
+  issuer?: string
+
+  constructor(overlay: IMetaOverlayData) {
+    super(overlay)
+    this.language = overlay.language
+    this.name = overlay.name
+    this.description = overlay.description
+    this.#credential_help_text = overlay.credential_help_text
+    this.#credential_support_url = overlay.credential_support_url
+    this.issuer = overlay.issuer
+    this.#issuer_description = overlay.issuer_description
+    this.#issuer_url = overlay.issuer_url
+    this.#watermark = overlay.watermark
+  }
+
+  get credentialHelpText(): string | undefined {
+    return this.#credential_help_text
+  }
+
+  get credentialSupportUrl(): string | undefined {
+    return this.#credential_support_url
+  }
+
+  get issuerDescription(): string | undefined {
+    return this.#issuer_description
+  }
+
+  get issuerUrl(): string | undefined {
+    return this.#issuer_url
+  }
+
+  get watermark(): string | undefined {
+    return this.#watermark
+  }
+}

package/src/types/semantic/StandardOverlay.ts

@@ -0,0 +1,24 @@
+import { IStandardOverlayData } from '../../interfaces/data'
+import BaseOverlay from '../base/BaseOverlay'
+
+export default class StandardOverlay extends BaseOverlay {
+  // DEPRECATED - Use #attribute_standards instead
+  #attr_standards?: Record<string, string>
+  #attribute_standards: Record<string, string>
+
+  constructor(overlay: IStandardOverlayData) {
+    super(overlay)
+    // DEPRECATED - Use #attribute_standards instead
+    this.#attr_standards = overlay.attr_standards
+    this.#attribute_standards = overlay.attribute_standards
+  }
+
+  // DEPRECATED - Use attributeStandards instead
+  get attrStandards(): Record<string, string> | undefined {
+    return this.#attr_standards
+  }
+
+  get attributeStandards(): Record<string, string> {
+    return this.#attribute_standards
+  }
+}

package/src/utils/color/generateColor.ts

@@ -0,0 +1,8 @@
+import hashCode from './hashCode'
+import hashToRGBA from './hashToRGBA'
+
+const generateColor = (seed: string): string => {
+  return hashToRGBA(hashCode(seed))
+}
+
+export default generateColor

package/src/utils/color/hashCode.ts

@@ -0,0 +1,11 @@
+/**
+ * Generates a numerical hash based on a given string
+ * @see https://stackoverflow.com/questions/3426404/create-a-hexadecimal-colour-based-on-a-string-with-javascript
+ * @param { string } s given string
+ * @returns { number } numerical hash value
+ */
+const hashCode = (s: string): number => {
+  return s.split('').reduce((hash, char) => char.charCodeAt(0) + ((hash << 5) - hash), 0)
+}
+
+export default hashCode

package/src/utils/color/hashToRGBA.ts

@@ -0,0 +1,22 @@
+import mulberry32 from './mulberry32'
+
+/**
+ * Converts a numerical hash into a hexidecimal color string
+ * @see https://helderesteves.com/generating-random-colors-js/#Generating_random_dark_colors
+ * @param { number } hash numerical hash value (generated by hashCode function above)
+ * @returns { string } hexidecimal string eg. #32d3cc
+ */
+const hashToRGBA = (hash: number): string => {
+  let color = '#'
+  const colorRangeUpperBound = 256
+
+  // once for r, g, b
+  for (let i = 0; i < 3; i++) {
+    // append a pseudorandom two-char hexidecimal value from the lower half of the color spectrum (to limit to darker colors)
+    color += ('0' + Math.floor((mulberry32(hash + i) * colorRangeUpperBound) / 2).toString(16)).slice(-2)
+  }
+
+  return color
+}
+
+export default hashToRGBA

package/src/utils/color/index.ts

@@ -0,0 +1,7 @@
+import generateColor from './generateColor'
+// Remove hashCode and hashToRGBA when deprecated OCA resolver is removed
+import hashCode from './hashCode'
+import hashToRGBA from './hashToRGBA'
+import { textColorForBackground } from './textColorForBackground'
+
+export { generateColor, textColorForBackground, hashCode, hashToRGBA }

package/src/utils/color/luminanceForHexColor.ts

@@ -0,0 +1,19 @@
+/**
+ * Converts a hexidecimal color string into a luminance value
+ * @param hex color string in hexidecimal format
+ * @returns { number | undefined } between 0 and 255
+ */
+const luminanceForHexColor = (hex: string): number | undefined => {
+  if (!/^#([A-Fa-f0-9]{6})$/.test(hex)) {
+    return
+  }
+
+  const hexAsNumber = Number(`0x${hex.slice(1)}`)
+  const [r, g, b] = [(hexAsNumber >> 16) & 255, (hexAsNumber >> 8) & 255, hexAsNumber & 255]
+  // Scalars below defined [here](https://en.wikipedia.org/wiki/Relative_luminance)
+  const y = 0.2126 * r + 0.7152 * g + 0.0722 * b
+
+  return Math.round(y)
+}
+
+export default luminanceForHexColor

package/src/utils/color/mulberry32.ts

@@ -0,0 +1,15 @@
+/**
+ * Generates a pseudorandom number between 0 and 1 based on a seed
+ * @see https://gist.github.com/tommyettinger/46a874533244883189143505d203312c
+ * @see https://stackoverflow.com/questions/521295/seeding-the-random-number-generator-in-javascript
+ * @param { number } seed any number
+ * @returns { number } pseudorandom number between 0 and 1
+ */
+const mulberry32 = (seed: number): number => {
+  let t = (seed += 0x6d2b79f5)
+  t = Math.imul(t ^ (t >>> 15), t | 1)
+  t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
+  return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+}
+
+export default mulberry32

package/src/utils/color/textColorForBackground.ts

@@ -0,0 +1,18 @@
+import luminanceForHexColor from './luminanceForHexColor'
+
+export const textColorForBackground = (background: string): string => {
+  const spectrum = {
+    black: '#000000',
+    darkGrey: '#313132',
+    mediumGrey: '#606060',
+    lightGrey: '#D3D3D3',
+    veryLightGrey: '#F2F2F2',
+    white: '#FFFFFF',
+  }
+
+  const midpoint = 255 / 2
+  if ((luminanceForHexColor(background ?? '') ?? 0) >= midpoint) {
+    return spectrum.darkGrey
+  }
+  return spectrum.white
+}