gdc-common-utils-ts 2.3.0 → 2.3.2

package/dist/utils/related-person-entry-editor.js

@@ -0,0 +1,97 @@
+/**
+ * File discipline note:
+ * - Read `ARCHITECTURE.md` and `CONTRIBUTING.md` before changing this module.
+ * - This file owns only the typed editor for one staged RelatedPerson entry.
+ */
+import { RelatedPersonClaim } from '../models/interoperable-claims/related-person-claims.js';
+import { BundleEditableResourceTypes } from '../models/bundle-editor-types.js';
+import { BundleEntryEditor } from './bundle-entry-editor.js';
+import { registerBundleEntryEditor } from './bundle-editor-registry.js';
+function normalizeText(value) {
+    const normalized = String(value || '').trim();
+    return normalized || undefined;
+}
+function normalizeList(values) {
+    return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))];
+}
+/**
+ * Typed editor for one RelatedPerson/contact staged inside a Bundle.
+ *
+ * Relationship authoring is separate from access authorization. This editor
+ * does not grant Consent, build a Communication, submit or poll.
+ */
+export class RelatedPersonEntryEditor extends BundleEntryEditor {
+    setIdentifier(value) {
+        const normalized = normalizeText(value);
+        if (!normalized) {
+            this.removeClaim(RelatedPersonClaim.IdentifierValue)
+                .removeClaim(RelatedPersonClaim.Identifier)
+                .setResourceId()
+                .setFullUrl();
+            return this;
+        }
+        return this.setClaim(RelatedPersonClaim.IdentifierValue, normalized)
+            .setClaim(RelatedPersonClaim.Identifier, normalized)
+            .setResourceId(normalized)
+            .setFullUrl(normalized);
+    }
+    getIdentifier() {
+        return normalizeText(String(this.getClaim(RelatedPersonClaim.IdentifierValue)
+            || this.getClaim(RelatedPersonClaim.Identifier)
+            || this.getResourceId()
+            || this.getFullUrl()
+            || ''));
+    }
+    ensureIdentifier() {
+        const identifier = this.getIdentifier();
+        if (!identifier)
+            throw new Error('RelatedPerson entry requires a generated resource id or explicit identifier.');
+        this.setIdentifier(identifier);
+        return identifier;
+    }
+    setActive(value) {
+        return value === undefined || value === null
+            ? this.removeClaim(RelatedPersonClaim.Active)
+            : this.setClaim(RelatedPersonClaim.Active, value);
+    }
+    getActive() {
+        const value = this.getClaim(RelatedPersonClaim.Active);
+        if (typeof value === 'boolean')
+            return value;
+        if (String(value).toLowerCase() === 'true')
+            return true;
+        if (String(value).toLowerCase() === 'false')
+            return false;
+        return undefined;
+    }
+    setSubject(value) { return this.setOptionalText(RelatedPersonClaim.Patient, value); }
+    getSubject() { return this.getOptionalText(RelatedPersonClaim.Patient); }
+    setRelationship(value) { return this.setOptionalText(RelatedPersonClaim.Relationship, value); }
+    getRelationship() { return this.getOptionalText(RelatedPersonClaim.Relationship); }
+    setRoleList(values) { return this.setList(RelatedPersonClaim.Role, values); }
+    getRoleList() { return this.getList(RelatedPersonClaim.Role); }
+    setName(value) { return this.setOptionalText(RelatedPersonClaim.Name, value); }
+    getName() { return this.getOptionalText(RelatedPersonClaim.Name); }
+    setTelecom(value) { return this.setOptionalText(RelatedPersonClaim.Telecom, value); }
+    getTelecom() { return this.getOptionalText(RelatedPersonClaim.Telecom); }
+    setRelatedEntityType(value) { return this.setOptionalText(RelatedPersonClaim.RelatedEntityType, value); }
+    getRelatedEntityType() { return this.getOptionalText(RelatedPersonClaim.RelatedEntityType); }
+    setActorIdentifierList(values) { return this.setList(RelatedPersonClaim.ActorIdentifier, values); }
+    getActorIdentifierList() { return this.getList(RelatedPersonClaim.ActorIdentifier); }
+    setOptionalText(key, value) {
+        const normalized = normalizeText(value);
+        return normalized ? this.setClaim(key, normalized) : this.removeClaim(key);
+    }
+    getOptionalText(key) {
+        return normalizeText(String(this.getClaim(key) || ''));
+    }
+    setList(key, values) {
+        const normalized = normalizeList(values);
+        return normalized.length ? this.setClaim(key, normalized.join(',')) : this.removeClaim(key);
+    }
+    getList(key) {
+        const value = this.getClaim(key);
+        return normalizeList(Array.isArray(value) ? value.map(String) : String(value || '').split(','));
+    }
+}
+registerBundleEntryEditor(BundleEditableResourceTypes.relatedPerson, RelatedPersonEntryEditor);

package/dist/utils/same-as.d.ts

@@ -49,6 +49,16 @@ export declare function normalizeSameAsHash(value: string): string;
  * @param value Canonical sameAs source value(s).
  */
 export declare function normalizeSameAsHashList(value: string | readonly string[] | undefined): string[];
+/**
+ * Splits a public alias CSV without changing the aliases themselves.
+ *
+ * Use this for mixed DID/CID `sameAs` indexes. Unlike
+ * `normalizeSameAsHashList`, it deliberately does not interpret a CIDv1
+ * beginning with `z` as a bare `urn:multibase` value.
+ */
+export declare function normalizePublicAliasList(value: string | readonly string[] | undefined): string[];
+/** Derives an opaque SHA3-384 multihash URN for a global-ledger alias key. */
+export declare function buildPublicAliasLedgerAssetId(alias: string): string;
 /**
  * Joins one or more normalized `sameAs` aliases into the current flat CSV
  * storage form used by some shared VC/profile helpers.

package/dist/utils/same-as.js

@@ -1,6 +1,9 @@
-import { createHash } from 'crypto';
+import { sha3_256 } from '@noble/hashes/sha3.js';
+import { utf8ToBytes } from '@noble/hashes/utils.js';
 import { normalizePhone } from './consent.js';
 import { encodeMultibase58btc } from './multibase58.js';
+import { encodeMultibaseSha3 } from './multibasehash.js';
+import { UrnPrefixes } from '../constants/urn.js';
 /**
  * Builds the ICA-compatible multibase58(multihash(sha3-256)) payload for a
  * public controller alias.
@@ -18,8 +21,8 @@ export function multibase58MultihashSha3_256(value) {
     if (!normalized) {
         throw new Error('Cannot create multihash from empty value.');
     }
-    const digest = createHash('sha3-256').update(normalized, 'utf8').digest();
-    const multihash = Buffer.concat([Buffer.from([0x16, 0x20]), digest]);
+    const digest = sha3_256(utf8ToBytes(normalized));
+    const multihash = Uint8Array.from([0x16, 0x20, ...digest]);
     return encodeMultibase58btc(multihash);
 }
 function looksLikeBase58Multibase(value) {
@@ -96,6 +99,28 @@ export function normalizeSameAsHashList(value) {
         .filter(Boolean);
     return [...new Set(normalized)];
 }
+/**
+ * Splits a public alias CSV without changing the aliases themselves.
+ *
+ * Use this for mixed DID/CID `sameAs` indexes. Unlike
+ * `normalizeSameAsHashList`, it deliberately does not interpret a CIDv1
+ * beginning with `z` as a bare `urn:multibase` value.
+ */
+export function normalizePublicAliasList(value) {
+    const candidates = Array.isArray(value)
+        ? value.flatMap((entry) => splitCommaSeparatedValues(entry))
+        : splitCommaSeparatedValues(String(value || ''));
+    return [...new Set(candidates.map((candidate) => candidate.trim()).filter(Boolean))];
+}
+/** Derives an opaque SHA3-384 multihash URN for a global-ledger alias key. */
+export function buildPublicAliasLedgerAssetId(alias) {
+    const normalized = String(alias || '').trim().normalize('NFKC');
+    if (!normalized)
+        throw new Error('Public alias is required');
+    if (normalized.startsWith(UrnPrefixes.Multibase))
+        return normalized;
+    return `${UrnPrefixes.Multibase}${encodeMultibaseSha3(normalized)}`;
+}
 /**
  * Joins one or more normalized `sameAs` aliases into the current flat CSV
  * storage form used by some shared VC/profile helpers.

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "gdc-common-utils-ts",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "publishConfig": {
     "access": "public"
   },
   "type": "module",
   "dependencies": {
+    "@noble/hashes": "^2.0.1",
     "@noble/post-quantum": "^0.5.4",
     "@stablelib/base64": "^1.0.1",
     "@stablelib/utf8": "^1.0.2",