diff --git a/manifest.json b/manifest.json index 396897e..983a0bb 100644 --- a/manifest.json +++ b/manifest.json @@ -40,6 +40,7 @@ "src/background/gvl-service.js", "src/core/binary-utils.js", "src/core/tcf-core-metadata-decoder.js", + "src/core/consent-diff.js", "src/background.js" ] }, diff --git a/src/background.js b/src/background.js index c4b3fb8..3aafc9b 100644 --- a/src/background.js +++ b/src/background.js @@ -224,6 +224,7 @@ async function handleVendorGetMessage(message, sender) { } const latestPingData = tabId !== null ? getLatestTcfPing(tabId) : null; + const activeConsentCaptureSession = getActiveConsentCaptureSession(sender); const consentState = buildConsentStateV1( message.payload.payload, @@ -235,7 +236,7 @@ async function handleVendorGetMessage(message, sender) { stableStringify(consentState.fingerprintSource) ); - const captureSessionId = getActiveConsentCaptureSessionId(sender); + const captureSessionId = activeConsentCaptureSession?.captureSessionId ?? null; rememberLatestConsentState(consentState); @@ -245,12 +246,19 @@ async function handleVendorGetMessage(message, sender) { ); if (captureSessionId) { - await persistConsentExecutionEvent({ + const consentExecutionEvent = await persistConsentExecutionEvent({ captureSessionId, consentState, rawCapture: message.payload.payload, sender }); + + await persistConsentDiffEvent({ + captureSessionId, + providerAnnouncementEvent: + activeConsentCaptureSession?.providerAnnouncementEvents?.[0] ?? null, + consentExecutionEvent + }); } completeConsentCaptureSession(sender); @@ -1044,17 +1052,20 @@ async function handleStartPreConsentCaptureMessage(message) { session.status = "recording"; session.captureSessionId = createCaptureSessionId(); + session.providerAnnouncementEvents = []; updateConsentCaptureBadge(session); const bufferedEvents = session.bufferedPreConsentEvents; session.bufferedPreConsentEvents = []; for (const bufferedEvent of bufferedEvents) { - await persistProviderAnnouncementEvent({ + const providerAnnouncementEvent = await persistProviderAnnouncementEvent({ captureSessionId: session.captureSessionId, rawCapture: bufferedEvent.rawCapture, sender: bufferedEvent.sender }); + + session.providerAnnouncementEvents.push(providerAnnouncementEvent); } return { @@ -2393,6 +2404,7 @@ function startAttentionConsentCaptureSession(rawCapture, sender) { status: "attention", captureSessionId: null, bufferedPreConsentEvents: [], + providerAnnouncementEvents: [], timeoutId: null, page: buildConsentEventPageContext(rawCapture, sender), detectedAt: new Date().toISOString(), @@ -2440,11 +2452,14 @@ async function handlePreConsentTcfEvent(rawCapture, sender) { } if (session?.status === "recording") { - await persistProviderAnnouncementEvent({ + const providerAnnouncementEvent = await persistProviderAnnouncementEvent({ captureSessionId: session.captureSessionId, rawCapture, sender }); + session.providerAnnouncementEvents = + session.providerAnnouncementEvents ?? []; + session.providerAnnouncementEvents.push(providerAnnouncementEvent); return; } @@ -2452,6 +2467,12 @@ async function handlePreConsentTcfEvent(rawCapture, sender) { } function getActiveConsentCaptureSessionId(sender) { + const session = getActiveConsentCaptureSession(sender); + + return session?.captureSessionId ?? null; +} + +function getActiveConsentCaptureSession(sender) { const sessionKey = getConsentCaptureSessionKey(sender); const session = sessionKey ? consentCaptureSessions.get(sessionKey) : null; @@ -2459,7 +2480,7 @@ function getActiveConsentCaptureSessionId(sender) { return null; } - return session.captureSessionId ?? null; + return session; } function hasCompletedConsentCaptureSessionForTab(tabId) { @@ -2492,6 +2513,7 @@ function completeConsentCaptureSession(sender) { status: "completed", captureSessionId: null, bufferedPreConsentEvents: [], + providerAnnouncementEvents: [], timeoutId: null }; @@ -3094,16 +3116,59 @@ async function persistConsentExecutionEvent({ }); } +async function persistConsentDiffEvent({ + captureSessionId, + providerAnnouncementEvent, + consentExecutionEvent +}) { + const db = await openVendorGetDb(); + const now = new Date().toISOString(); + const consentDiff = buildConsentDiff({ + captureSessionId, + providerAnnouncement: providerAnnouncementEvent, + consentExecution: consentExecutionEvent, + derivedAt: now + }); + + return addConsentEventRecord(db, { + eventType: "consent_diff", + capturedAt: now, + recordedAt: now, + recordingSource: EVIDENCE_RECORDING_SOURCE, + captureSessionId, + stateFingerprint: consentExecutionEvent?.stateFingerprint ?? null, + page: consentExecutionEvent?.page ?? null, + rawEventName: "consent_diff", + ruleId: CONSENT_DIFF_RULE_ID, + ruleVersion: CONSENT_DIFF_RULE_VERSION, + consentDiff, + diagnostics: { + consentEvidenceRole: "consentDiff", + ruleId: CONSENT_DIFF_RULE_ID, + ruleVersion: CONSENT_DIFF_RULE_VERSION, + sourceProviderAnnouncementId: providerAnnouncementEvent?.id ?? null, + sourceConsentExecutionId: consentExecutionEvent?.id ?? null + } + }); +} + function addConsentEventRecord(db, record) { return new Promise((resolve, reject) => { const tx = db.transaction(["consent_events"], "readwrite"); const eventsStore = tx.objectStore("consent_events"); const request = eventsStore.add(record); + let storedRecord = record; request.onerror = () => reject(request.error); + request.onsuccess = () => { + storedRecord = { + ...record, + id: request.result + }; + }; tx.onerror = () => reject(tx.error); tx.onabort = () => reject(tx.error); - tx.oncomplete = () => resolve(record); + tx.oncomplete = () => resolve(storedRecord); }); } diff --git a/src/consent-explorer/consent-explorer.css b/src/consent-explorer/consent-explorer.css index 7c94b2f..316679d 100644 --- a/src/consent-explorer/consent-explorer.css +++ b/src/consent-explorer/consent-explorer.css @@ -27,6 +27,7 @@ body { h1, h2, h3, +h4, p { margin: 0; } @@ -49,6 +50,11 @@ h3 { color: #cbd5e1; } +h4 { + font-size: 12px; + color: #cbd5e1; +} + p { max-width: 760px; font-size: 13px; @@ -139,6 +145,165 @@ th { margin-top: 18px; } +.finding-overview { + display: grid; + gap: 10px; + margin-bottom: 16px; +} + +.finding-note { + max-width: 900px; +} + +.finding-list { + display: grid; + grid-template-columns: repeat(2, minmax(0, 1fr)); + gap: 1px; + margin: 0; + overflow: hidden; + border: 1px solid #334155; + border-radius: 4px; + background: #334155; + font-size: 13px; +} + +.finding-list div { + display: grid; + grid-template-columns: minmax(160px, 220px) 1fr; + gap: 10px; + min-width: 0; + padding: 10px 12px; + background: #1f2937; +} + +.finding-list dt { + color: #cbd5e1; + font-weight: 700; +} + +.finding-list dd { + margin: 0; + overflow-wrap: anywhere; + color: #e5edf5; +} + +.consent-diff { + display: grid; + gap: 10px; + margin-top: 10px; + padding: 10px; + border: 1px solid #334155; + border-radius: 4px; + background: #172033; +} + +.compact-definition-list { + display: grid; + gap: 6px; + margin: 0; + font-size: 12px; +} + +.compact-definition-list div { + display: grid; + grid-template-columns: minmax(150px, 220px) 1fr; + gap: 10px; + min-width: 0; +} + +.compact-definition-list dt { + color: #cbd5e1; + font-weight: 700; +} + +.compact-definition-list dd { + margin: 0; + overflow-wrap: anywhere; +} + +.diff-note { + max-width: none; + font-size: 12px; + color: #cbd5e1; +} + +.consent-diff-primary { + display: grid; + gap: 8px; +} + +.consent-diff-findings { + display: grid; + gap: 6px; + margin: 0; + padding: 0; + list-style: none; +} + +.consent-diff-findings li { + padding: 9px 10px; + border: 1px solid #334155; + border-radius: 4px; + color: #e5edf5; + background: #1f2937; + overflow-wrap: anywhere; +} + +.consent-diff-finding-details summary { + cursor: pointer; + font-weight: 700; +} + +.consent-diff-finding-body { + display: grid; + gap: 8px; + margin-top: 10px; + padding-top: 10px; + border-top: 1px solid #334155; +} + +.consent-change-categories, +.consent-change-category-body { + display: grid; + gap: 10px; +} + +.consent-change-category { + padding: 8px 10px; + border: 1px solid #334155; + border-radius: 4px; + background: #172033; +} + +.consent-change-category summary, +.consent-change-collapsed-list summary { + cursor: pointer; + font-weight: 700; +} + +.consent-change-list-block { + display: grid; + gap: 6px; +} + +.inline-id-list { + display: flex; + flex-wrap: wrap; + gap: 6px; + margin: 0; + padding: 0; + list-style: none; +} + +.inline-id-list li { + padding: 3px 6px; + border: 1px solid #334155; + border-radius: 3px; + background: #0f172a; + font-size: 12px; + color: #e5edf5; +} + .inspector-table th, .inspector-table td { vertical-align: top; @@ -227,4 +392,12 @@ th { .inspector-table .inspector-explanation { width: auto; } + + .finding-list { + grid-template-columns: 1fr; + } + + .finding-list div { + grid-template-columns: 1fr; + } } diff --git a/src/consent-explorer/consent-explorer.html b/src/consent-explorer/consent-explorer.html index 9837215..a5bf673 100644 --- a/src/consent-explorer/consent-explorer.html +++ b/src/consent-explorer/consent-explorer.html @@ -47,6 +47,7 @@
+ diff --git a/src/consent-explorer/consent-explorer.js b/src/consent-explorer/consent-explorer.js index 5718bc5..66b6e3f 100644 --- a/src/consent-explorer/consent-explorer.js +++ b/src/consent-explorer/consent-explorer.js @@ -15,6 +15,7 @@ const consentDetailSummary = document.getElementById("consent-detail-summary"); const consentDetailPublisher = document.getElementById( "consent-detail-publisher" ); +const consentDetailDiff = document.getElementById("consent-detail-diff"); const consentDetailFieldPaths = document.getElementById( "consent-detail-field-paths" ); @@ -103,7 +104,7 @@ async function renderDocumentedConsentStates() { } renderDocumentedConsentStateList(); - renderSelectedConsentState(); + await renderSelectedConsentState(); } catch (error) { documentedConsentEmpty.hidden = false; documentedConsentContent.hidden = true; @@ -190,7 +191,7 @@ function selectDocumentedConsentState(stateFingerprint) { renderSelectedConsentState(); } -function renderSelectedConsentState() { +async function renderSelectedConsentState() { const consentState = findDocumentedConsentState(selectedConsentStateFingerprint); clearConsentStateDetails(); @@ -309,6 +310,16 @@ function renderSelectedConsentState() { ] ]); + consentDetailObservation.textContent = ""; + consentDetailBasics.textContent = ""; + consentDetailSummary.textContent = ""; + consentDetailPublisher.textContent = ""; + + const consentDiffCount = await renderConsentDiffs(consentState); + + renderFindingOverview(consentState, consentDiffCount); + renderTechnicalDeepDive(consentState); + consentDetailFieldPaths.textContent = JSON.stringify( buildConsentStateFieldPathOverview(), null, @@ -333,6 +344,965 @@ function renderSelectedConsentState() { consentDetailJson.textContent = JSON.stringify(consentState, null, 2); } +function renderFindingOverview(consentState, consentDiffCount) { + const heading = document.createElement("h3"); + const note = document.createElement("p"); + const rows = [ + ["Seite / Origin", formatNullable(consentState?.page?.origin)], + ["Vollständige URL", formatLongString(consentState?.page?.url)], + ["Erste Beobachtung", formatNullable(consentState?.firstSeenAt)], + ["Letzte Beobachtung", formatNullable(consentState?.lastSeenAt)], + [ + "Beobachteter Consent-Status", + formatNullable(consentState?.observation?.eventStatus) + ], + ["CMP-Status", formatNullable(consentState?.observation?.cmpStatus)], + [ + "Gemeldete Vendorlisten-Version", + formatNullable(consentState?.gvl?.vendorListVersion) + ], + [ + "Zwecke mit Consent", + String(countTruthyObjectValues(consentState?.purposes?.consents)) + ], + [ + "Zwecke mit Legitimate Interest", + String(countTruthyObjectValues(consentState?.purposes?.legitimateInterests)) + ], + [ + "Firmen mit Consent", + String(countTruthyObjectValues(consentState?.vendors?.consents)) + ], + [ + "Firmen mit Legitimate Interest", + String(countTruthyObjectValues(consentState?.vendors?.legitimateInterests)) + ], + [ + "Aktivierte Special Features", + String(countTruthyObjectValues(consentState?.specialFeatureOptins)) + ], + [ + "Offengelegte Firmen im beobachteten Kontext", + String(countTruthyObjectValues(consentState?.vendors?.disclosedVendors)) + ], + [ + "Consent-Diff", + consentDiffCount > 0 + ? `${consentDiffCount} Übergangsbefund vorhanden` + : "kein gespeicherter Übergangsbefund vorhanden" + ] + ]; + + heading.textContent = "Befundübersicht"; + note.className = "finding-note"; + note.textContent = + "Diese Übersicht zeigt beobachtete Rohbefunde und daraus abgeleitete Anzeige-Zählungen, ohne rechtliche Bewertung oder GVL-Semantikbewertung."; + + consentDetailObservation.className = "finding-overview"; + consentDetailObservation.append(heading, note, createFindingList(rows)); +} + +function renderTechnicalDeepDive(consentState) { + const technicalDetails = createDetailsSection("Technischer Deep Dive", true); + const publisherDetails = createDetailsSection( + "Publisher-Angaben und abgeleitete Zählungen", + false + ); + + renderDetailSection(technicalDetails.content, "Technische Basisdaten", [ + ["State-Fingerprint", formatLongString(consentState?.stateFingerprint), "stateFingerprint"], + [ + "Beobachteter TC-String / euconsent-v2", + summarizeRawString(consentState?.consent?.tcString), + "consent.tcString" + ], + [ + "Beobachteter Google Additional Consent String", + summarizeRawString(consentState?.consent?.addtlConsent), + "consent.addtlConsent" + ], + [ + "Vom Consent-System gemeldete TCF-Policy-Version", + formatNullable(consentState?.cmp?.tcfPolicyVersion), + "cmp.tcfPolicyVersion" + ], + [ + "Vom Consent-System gemeldete DSGVO-Anwendbarkeit", + formatBoolean(consentState?.cmp?.gdprApplies), + "cmp.gdprApplies" + ], + ["Anzahl Beobachtungen", formatNullable(consentState?.seenCount), "seenCount"] + ]); + + renderDetailSection(publisherDetails.content, "Publisher-Angaben", [ + [ + "Publisher Consents: Anzahl aktiv", + String(countTruthyObjectValues(consentState?.publisher?.consents)), + "publisher.consents" + ], + [ + "Publisher Legitimate Interests: Anzahl aktiv", + String(countTruthyObjectValues(consentState?.publisher?.legitimateInterests)), + "publisher.legitimateInterests" + ], + [ + "Publisher Restrictions: Anzahl Einträge", + String(countObjectKeys(consentState?.publisher?.restrictions)), + "publisher.restrictions" + ] + ]); + + consentDetailBasics.append(technicalDetails.details); + consentDetailSummary.append(publisherDetails.details); +} + +async function renderConsentDiffs(consentState) { + consentDetailDiff.textContent = ""; + + try { + const result = await browser.runtime.sendMessage({ + type: "get_consent_evidence_chain", + payload: { + stateFingerprint: consentState?.stateFingerprint ?? null + } + }); + + if (!result?.success) { + throw new Error(result?.error ?? "get_consent_evidence_chain_failed"); + } + + const consentDiffEvents = ( + result.chain?.consentEvents?.records ?? [] + ).filter((eventRecord) => eventRecord?.eventType === "consent_diff"); + + if (consentDiffEvents.length === 0) { + return 0; + } + + const heading = document.createElement("h3"); + + heading.textContent = "Consent-Diff"; + consentDetailDiff.append(heading); + + consentDiffEvents.forEach((eventRecord) => { + consentDetailDiff.append(createConsentDiffView(eventRecord, consentState)); + }); + + return consentDiffEvents.length; + } catch (error) { + const message = document.createElement("p"); + + message.className = "diff-note"; + message.textContent = "Consent-Diff konnte nicht geladen werden."; + consentDetailDiff.append(message); + console.warn("VendorGet-IV consent diff load failed", error); + return 0; + } +} + +function createConsentDiffView(eventRecord, consentState) { + const diff = eventRecord?.consentDiff ?? {}; + const section = document.createElement("section"); + const metaRows = [ + ["Capture-Session", formatNullable(diff.captureSessionId)], + ["Regel-ID", formatNullable(diff.ruleId ?? eventRecord?.ruleId)], + ["Regelversion", formatNullable(diff.ruleVersion ?? eventRecord?.ruleVersion)], + ["Ableitungszeitpunkt", formatNullable(diff.derivedAt)] + ]; + const technicalDetails = createDetailsSection("Technische Diff-Metadaten", false); + + section.className = "consent-diff"; + section.append(createConsentDiffAxisTable(diff.axes ?? {})); + section.append(createConsentChangeDetail(diff.axes ?? {}, consentState)); + + technicalDetails.content.append( + createDiffNote("Quellen, Regel und Ableitungszeitpunkt des Befunds.") + ); + technicalDetails.content.append(createCompactDefinitionList(metaRows)); + technicalDetails.content.append(createConsentDiffSourceView(diff.sources ?? {})); + section.append(technicalDetails.details); + section.append(createConsentDiffKeyDetails(diff.axes ?? {})); + + if (Array.isArray(diff.notes) && diff.notes.length > 0) { + const notes = document.createElement("p"); + + notes.className = "diff-note"; + notes.textContent = `Hinweise: ${diff.notes.join(", ")}`; + section.append(notes); + } + + const rawDetails = document.createElement("details"); + const rawSummary = document.createElement("summary"); + const rawPre = document.createElement("pre"); + + rawDetails.className = "inspector-details"; + rawSummary.textContent = "Rohdaten consent_diff"; + rawPre.textContent = JSON.stringify(eventRecord, null, 2); + rawDetails.append(rawSummary, rawPre); + section.append(rawDetails); + + return section; +} + +function createConsentDiffSourceView(sources) { + const provider = sources.providerAnnouncement ?? {}; + const execution = sources.consentExecution ?? {}; + + return createCompactDefinitionList([ + [ + "Quelle provider_announcement", + formatConsentDiffSource(provider) + ], + [ + "Quelle consent_execution", + formatConsentDiffSource(execution) + ] + ]); +} + +function createConsentDiffAxisTable(axes) { + const container = document.createElement("div"); + const summary = document.createElement("p"); + const list = document.createElement("ul"); + const axisEntries = Object.entries(axes); + const changedEntries = axisEntries.filter(([, axis]) => { + return ["changed", "added", "removed"].includes(axis?.status); + }); + const unchangedCount = axisEntries.filter(([, axis]) => { + return axis?.status === "unchanged"; + }).length; + + container.className = "consent-diff-primary"; + summary.className = "diff-note"; + summary.textContent = [ + `Geprüfte Vergleichsachsen: ${axisEntries.length}`, + `erkannte Unterschiede: ${changedEntries.length}`, + `unveränderte Achsen: ${unchangedCount}` + ].join(", "); + list.className = "consent-diff-findings"; + + if (changedEntries.length === 0) { + const item = document.createElement("li"); + + item.textContent = "Keine Unterschiede in den gespeicherten Vergleichsachsen erkannt."; + list.append(item); + } else { + changedEntries.forEach(([axisName, axis]) => { + list.append(createConsentDiffFindingItem(axisName, axis)); + }); + } + + container.append(summary, list); + + return container; +} + +function createConsentChangeDetail(axes, consentState) { + const details = document.createElement("details"); + const summary = document.createElement("summary"); + const content = document.createElement("div"); + const categories = buildConsentChangeCategories(consentState); + + details.className = "inspector-details consent-change-detail"; + summary.textContent = "Consent-Änderungen im Detail"; + content.className = "consent-change-categories"; + content.append( + createDiffNote( + "Fachliche Sicht auf gespeicherte Rohzustände: IDs werden ohne GVL-Semantikbewertung angezeigt." + ) + ); + + categories.forEach((category) => { + content.append(createConsentChangeCategoryView(category, axes)); + }); + + details.append(summary, content); + + return details; +} + +function buildConsentChangeCategories(consentState) { + return [ + { + title: "Zwecke mit Zustimmung", + technicalField: "purpose.consents", + axisName: "purpose.consents", + currentValues: consentState?.purposes?.consents + }, + { + title: "Zwecke mit berechtigtem Interesse", + technicalField: "purpose.legitimateInterests", + axisName: "purpose.legitimateInterests", + currentValues: consentState?.purposes?.legitimateInterests + }, + { + title: "Firmen mit Zustimmung", + technicalField: "vendor.consents", + axisName: "vendor.consents", + currentValues: consentState?.vendors?.consents + }, + { + title: "Firmen mit berechtigtem Interesse", + technicalField: "vendor.legitimateInterests", + axisName: "vendor.legitimateInterests", + currentValues: consentState?.vendors?.legitimateInterests + }, + { + title: "Special Features", + technicalField: "specialFeatureOptins", + axisName: "specialFeatureOptins", + currentValues: consentState?.specialFeatureOptins + }, + { + title: "Publisher-Angaben", + technicalField: "publisher.consents / publisher.legitimateInterests", + axisName: null, + currentValues: { + consents: consentState?.publisher?.consents ?? {}, + legitimateInterests: + consentState?.publisher?.legitimateInterests ?? {}, + restrictions: consentState?.publisher?.restrictions ?? {} + }, + isPublisher: true + } + ]; +} + +function createConsentChangeCategoryView(category, axes) { + const details = document.createElement("details"); + const summary = document.createElement("summary"); + const content = document.createElement("div"); + const axis = category.axisName ? axes?.[category.axisName] : null; + + details.className = "consent-change-category"; + summary.textContent = category.title; + content.className = "consent-change-category-body"; + + if (category.technicalField) { + content.append( + createDiffNote(`Technisches Feld: ${category.technicalField}`) + ); + } + + if (category.isPublisher) { + content.append(createPublisherChangeCurrentView(category.currentValues)); + } else if (axis?.kind === "object") { + content.append(createObjectAxisChangeView(axis)); + } else { + content.append(createUnavailableAxisChangeView(category.currentValues)); + } + + details.append(summary, content); + + return details; +} + +function createObjectAxisChangeView(axis) { + const fragment = document.createDocumentFragment(); + const providerKeys = axis?.provider?.keys ?? []; + const executionKeys = axis?.execution?.keys ?? []; + const addedTrue = filterConsentDiffEntriesByValue( + axis?.addedKeys, + "executionValue", + true + ); + const addedFalse = filterConsentDiffEntriesByValue( + axis?.addedKeys, + "executionValue", + false + ); + const removedTrue = filterConsentDiffEntriesByValue( + axis?.removedKeys, + "providerValue", + true + ); + const changedEntries = axis?.changedKeys ?? []; + + fragment.append( + createConsentChangeListBlock( + "Vorher", + providerKeys, + providerKeys.length === 0 + ? "keine Werte im Provider-Announcement beobachtet" + : null + ), + createConsentChangeListBlock( + "Nachher", + executionKeys, + executionKeys.length === 0 + ? "keine Werte in der Consent-Execution beobachtet" + : null + ), + createConsentChangeListBlock( + "Hinzugekommen (aktive true-Werte)", + addedTrue.map((entry) => entry.key), + addedTrue.length === 0 ? "keine aktiven true-Werte hinzugekommen" : null + ), + createConsentChangeListBlock( + "Hinzugekommen (false-Werte)", + addedFalse.map((entry) => entry.key), + addedFalse.length === 0 ? "keine false-Werte hinzugekommen" : null + ), + createConsentChangeListBlock( + "Entfallen", + removedTrue.map((entry) => entry.key), + removedTrue.length === 0 ? "keine aktiven true-Werte entfallen" : null + ), + createConsentChangedValuesBlock(changedEntries) + ); + + if (Array.isArray(axis?.unchangedKeys) && axis.unchangedKeys.length > 0) { + fragment.append( + createConsentChangeCollapsedList( + "Unverändert", + axis.unchangedKeys + ) + ); + } + + fragment.append( + createDiffNote( + "Vorher/Nachher zeigt beobachtete Rohkeys. Konkrete Werte sind im gespeicherten Diff für hinzugekommene, entfallene und geänderte Keys enthalten." + ) + ); + + return fragment; +} + +function createUnavailableAxisChangeView(currentValues) { + const fragment = document.createDocumentFragment(); + const currentActiveKeys = getTruthyObjectKeys(currentValues); + + fragment.append( + createConsentChangeListBlock( + "Aktueller gespeicherter Consent-State", + currentActiveKeys, + currentActiveKeys.length === 0 + ? "keine aktiven Werte im aktuellen Consent-State gespeichert" + : null + ), + createDiffNote( + "Für diese Kategorie ist im aktuellen consent_diff keine Vorher/Nachher-Achse gespeichert. Eine konkrete Änderungsliste kann daraus nicht abgeleitet werden." + ) + ); + + return fragment; +} + +function createPublisherChangeCurrentView(publisherValues) { + const fragment = document.createDocumentFragment(); + + fragment.append( + createConsentChangeListBlock( + "Publisher-Zustimmungen", + getTruthyObjectKeys(publisherValues?.consents), + "keine aktiven Publisher-Zustimmungen gespeichert" + ), + createConsentChangeListBlock( + "Publisher berechtigtes Interesse", + getTruthyObjectKeys(publisherValues?.legitimateInterests), + "keine aktiven Publisher-Legitimate-Interest-Werte gespeichert" + ), + createConsentChangeListBlock( + "Publisher Restrictions", + getObjectKeys(publisherValues?.restrictions), + "keine Publisher Restrictions gespeichert" + ), + createDiffNote( + "Publisher-Angaben sind im aktuellen consent_diff nicht als eigene Vorher/Nachher-Achsen gespeichert." + ) + ); + + return fragment; +} + +function createConsentChangeListBlock(title, values, emptyText) { + const section = document.createElement("section"); + const heading = document.createElement("h4"); + const normalizedValues = Array.isArray(values) ? values : []; + + section.className = "consent-change-list-block"; + heading.textContent = title; + section.append(heading); + + if (normalizedValues.length === 0) { + const empty = document.createElement("p"); + + empty.className = "diff-note"; + empty.textContent = emptyText ?? "keine Werte beobachtet"; + section.append(empty); + return section; + } + + section.append(createInlineIdList(normalizedValues)); + + return section; +} + +function createConsentChangeCollapsedList(title, values) { + const details = document.createElement("details"); + const summary = document.createElement("summary"); + + details.className = "consent-change-collapsed-list"; + summary.textContent = `${title} (${values.length})`; + details.append(summary, createInlineIdList(values)); + + return details; +} + +function createConsentChangedValuesBlock(changedEntries) { + const section = document.createElement("section"); + const heading = document.createElement("h4"); + + section.className = "consent-change-list-block"; + heading.textContent = "Geändert"; + section.append(heading); + + if (!Array.isArray(changedEntries) || changedEntries.length === 0) { + const empty = document.createElement("p"); + + empty.className = "diff-note"; + empty.textContent = "keine geänderten Rohwerte beobachtet"; + section.append(empty); + return section; + } + + section.append( + createInlineIdList( + changedEntries.map((entry) => { + return `${entry.key}: ${formatShortPrimitiveValue( + entry.providerValue + )} → ${formatShortPrimitiveValue(entry.executionValue)}`; + }) + ) + ); + + return section; +} + +function createInlineIdList(values) { + const list = document.createElement("ul"); + + list.className = "inline-id-list"; + + values.forEach((value) => { + const item = document.createElement("li"); + + item.textContent = String(value); + list.append(item); + }); + + return list; +} + +function filterConsentDiffEntriesByValue(entries, valueField, expectedValue) { + if (!Array.isArray(entries)) { + return []; + } + + return entries.filter((entry) => entry?.[valueField] === expectedValue); +} + +function getTruthyObjectKeys(value) { + if (!value || typeof value !== "object" || Array.isArray(value)) { + return []; + } + + return Object.entries(value) + .filter(([, entryValue]) => Boolean(entryValue)) + .map(([key]) => key) + .sort(compareNumericStrings); +} + +function getObjectKeys(value) { + if (!value || typeof value !== "object" || Array.isArray(value)) { + return []; + } + + return Object.keys(value).sort(compareNumericStrings); +} + +function compareNumericStrings(a, b) { + const numericA = Number(a); + const numericB = Number(b); + + if (Number.isFinite(numericA) && Number.isFinite(numericB)) { + return numericA - numericB; + } + + return String(a).localeCompare(String(b)); +} + +function createConsentDiffFindingItem(axisName, axis) { + const item = document.createElement("li"); + const details = document.createElement("details"); + const summary = document.createElement("summary"); + + details.className = "consent-diff-finding-details"; + summary.textContent = formatConsentDiffAxisFinding(axisName, axis); + details.append(summary); + + if (axis?.kind === "object") { + details.append(createConsentDiffObjectDetail(axis)); + } else { + details.append(createConsentDiffScalarDetailView(axis)); + } + + item.append(details); + + return item; +} + +function createConsentDiffScalarDetailView(axis) { + const container = document.createElement("div"); + const note = createDiffNote(formatConsentDiffScalarDetailNote(axis)); + const provider = summarizeConsentDiffScalarSide(axis?.provider); + const execution = summarizeConsentDiffScalarSide(axis?.execution); + + container.className = "consent-diff-finding-body"; + container.append( + createCompactDefinitionList([ + ["Wert vorher vorhanden", provider.present], + ["Wert nachher vorhanden", execution.present], + ["Länge vorher", provider.length], + ["Länge nachher", execution.length], + ["Anfangssequenz vorher", provider.prefix], + ["Anfangssequenz nachher", execution.prefix] + ]), + note + ); + + return container; +} + +function formatConsentDiffScalarDetailNote(axis) { + if (axis?.status === "added") { + return "Der technische Rohwert wurde in der Consent-Execution beobachtet, aber nicht im Provider-Announcement."; + } + + if (axis?.status === "removed") { + return "Der technische Rohwert wurde im Provider-Announcement beobachtet, aber nicht in der Consent-Execution."; + } + + return "Der technische Rohwert hat sich zwischen Provider-Announcement und Consent-Execution geändert."; +} + +function createConsentDiffObjectDetail(axis) { + const container = document.createElement("div"); + const added = countConsentDiffEntryValues(axis?.addedKeys, "executionValue"); + const examples = getConsentDiffEntryExamples(axis?.addedKeys, "executionValue"); + + container.className = "consent-diff-finding-body"; + container.append( + createCompactDefinitionList([ + ["Hinzugekommene Rohkeys gesamt", String(added.total)], + ["Davon true", String(added.trueValues)], + ["Davon false", String(added.falseValues)], + [ + "Beispiel-Keys", + examples.length > 0 ? examples.join(", ") : "keine Beispiele vorhanden" + ] + ]), + createDiffNote( + "Dies ist eine Rohkey-Differenz aus gespeicherten Diff-Werten, keine GVL-Semantikbewertung." + ) + ); + + return container; +} + +function createConsentDiffKeyDetails(axes) { + const details = document.createElement("details"); + const summary = document.createElement("summary"); + const pre = document.createElement("pre"); + const objectAxisDetails = {}; + + Object.entries(axes).forEach(([axisName, axis]) => { + if (axis?.kind !== "object") { + return; + } + + objectAxisDetails[axisName] = { + providerKeys: axis.provider?.keys ?? [], + executionKeys: axis.execution?.keys ?? [], + addedKeys: axis.addedKeys ?? [], + removedKeys: axis.removedKeys ?? [], + changedKeys: axis.changedKeys ?? [], + unchangedKeys: axis.unchangedKeys ?? [] + }; + }); + + details.className = "inspector-details"; + summary.textContent = "Keylisten und gespeicherte Rohwert-Deltas"; + details.append( + summary, + createDiffNote( + "Technische Prüfdaten für die Nachvollziehbarkeit der gezählten Rohkeys." + ), + pre + ); + pre.textContent = JSON.stringify(objectAxisDetails, null, 2); + + return details; +} + +function createFindingList(rows) { + const list = document.createElement("dl"); + + list.className = "finding-list"; + + rows.forEach(([label, value]) => { + const row = document.createElement("div"); + const term = document.createElement("dt"); + const description = document.createElement("dd"); + + term.textContent = label; + description.textContent = value; + row.append(term, description); + list.append(row); + }); + + return list; +} + +function createDetailsSection(summaryText, isOpen) { + const details = document.createElement("details"); + const summary = document.createElement("summary"); + const content = document.createElement("div"); + + details.className = "inspector-details"; + details.open = isOpen; + summary.textContent = summaryText; + details.append(summary, content); + + return { + details, + content + }; +} + +function createCompactDefinitionList(rows) { + const list = document.createElement("dl"); + + list.className = "compact-definition-list"; + + rows.forEach(([label, value]) => { + const row = document.createElement("div"); + const term = document.createElement("dt"); + const description = document.createElement("dd"); + + term.textContent = label; + description.textContent = value; + row.append(term, description); + list.append(row); + }); + + return list; +} + +function formatConsentDiffSource(source) { + if (!source?.available) { + return formatNullable(source?.reason); + } + + return [ + `Store ${formatNullable(source.store)}`, + `ID ${formatNullable(source.id)}`, + formatNullable(source.eventType), + formatNullable(source.rawEventName), + formatNullable(source.capturedAt) + ].join(" | "); +} + +function createDiffNote(text) { + const note = document.createElement("p"); + + note.className = "diff-note"; + note.textContent = text; + + return note; +} + +function summarizeConsentDiffScalarSide(side) { + const present = side?.present === true; + const value = present ? side?.value : null; + const stringValue = + value === null || value === undefined ? "" : String(value); + + return { + present: present ? "ja" : "nein", + length: present ? String(stringValue.length) : "-", + prefix: present ? summarizeConsentDiffPrefix(stringValue) : "-" + }; +} + +function summarizeConsentDiffPrefix(value) { + const prefixLength = 32; + + if (!value) { + return "-"; + } + + return value.length > prefixLength + ? `${value.slice(0, prefixLength)}...` + : value; +} + +function getConsentDiffEntryExamples(entries, valueField) { + if (!Array.isArray(entries)) { + return []; + } + + return entries.slice(0, 5).map((entry) => { + return `${formatNullable(entry?.key)}=${formatShortPrimitiveValue( + entry?.[valueField] + )}`; + }); +} + +function formatShortPrimitiveValue(value) { + if (value === true) { + return "true"; + } + + if (value === false) { + return "false"; + } + + if (value === null) { + return "null"; + } + + if (value === undefined) { + return "undefined"; + } + + return shortenLongString(String(value), 24); +} + +function formatConsentDiffAxisFinding(axisName, axis) { + const label = formatConsentDiffAxisLabel(axisName); + + if (axis?.kind === "object") { + return `${label}: ${formatConsentDiffObjectFinding(axis)}`; + } + + return `${label}: ${formatConsentDiffScalarFinding(axis)}`; +} + +function formatConsentDiffAxisLabel(axisName) { + const labels = { + tcString: "TCF-String", + addtlConsent: "Google Additional Consent", + vendorListVersion: "Vendorlisten-Version", + cmpId: "CMP-ID", + cmpVersion: "CMP-Version", + tcfPolicyVersion: "TCF-Policy-Version", + gdprApplies: "DSGVO-Anwendbarkeit", + cmpStatus: "CMP-Status", + "purpose.consents": "Purpose Consents", + "vendor.consents": "Vendor Consents", + specialFeatureOptins: "Special Features" + }; + + return labels[axisName] ?? axisName; +} + +function formatConsentDiffScalarFinding(axis) { + if (axis?.status === "changed") { + return "Unterschied erkannt"; + } + + if (axis?.status === "added") { + return "Rohwert hinzugekommen"; + } + + if (axis?.status === "removed") { + return "Rohwert entfallen"; + } + + return formatNullable(axis?.status); +} + +function formatConsentDiffObjectFinding(axis) { + const counts = axis?.counts ?? {}; + const added = countConsentDiffEntryValues(axis?.addedKeys, "executionValue"); + + return [ + `${formatNullable(counts.added)} Rohkeys hinzugekommen`, + `davon ${added.trueValues} true`, + `${added.falseValues} false`, + `${formatNullable(counts.changed)} geänderte Rohwerte`, + `${formatNullable(counts.removed)} entfallene Rohkeys` + ].join(", "); +} + +function formatConsentDiffObjectKeyDiff(axis) { + const counts = axis?.counts ?? {}; + + return [ + `Provider-Keys: ${formatNullable(counts.providerKeys)}`, + `Execution-Keys: ${formatNullable(counts.executionKeys)}`, + `hinzugekommene Rohkeys: ${formatNullable(counts.added)}`, + `entfallene Rohkeys: ${formatNullable(counts.removed)}`, + `unveränderte Rohkeys: ${formatNullable(counts.unchanged)}` + ].join(", "); +} + +function formatConsentDiffAddedValueBreakdown(axis) { + const breakdown = countConsentDiffEntryValues(axis?.addedKeys, "executionValue"); + + return [ + `gesamt: ${breakdown.total}`, + `davon true: ${breakdown.trueValues}`, + `davon false: ${breakdown.falseValues}`, + `davon sonstige Werte: ${breakdown.otherValues}`, + "abgeleitete Darstellung aus gespeicherten Rohwerten" + ].join(", "); +} + +function formatConsentDiffObjectOtherDeltas(axis) { + const counts = axis?.counts ?? {}; + const changedProvider = countConsentDiffEntryValues( + axis?.changedKeys, + "providerValue" + ); + const changedExecution = countConsentDiffEntryValues( + axis?.changedKeys, + "executionValue" + ); + const removed = countConsentDiffEntryValues(axis?.removedKeys, "providerValue"); + + return [ + `geänderte Rohwerte: ${formatNullable(counts.changed)}`, + `geändert provider true/false/sonstige: ${changedProvider.trueValues}/${changedProvider.falseValues}/${changedProvider.otherValues}`, + `geändert execution true/false/sonstige: ${changedExecution.trueValues}/${changedExecution.falseValues}/${changedExecution.otherValues}`, + `entfallen true/false/sonstige: ${removed.trueValues}/${removed.falseValues}/${removed.otherValues}` + ].join(", "); +} + +function formatConsentDiffObjectCounts(axis) { + const counts = axis?.counts ?? {}; + + return [ + `unverändert ${formatNullable(counts.unchanged)}`, + `verändert ${formatNullable(counts.changed)}`, + `hinzugekommen ${formatNullable(counts.added)}`, + `entfallen ${formatNullable(counts.removed)}` + ].join(", "); +} + +function formatConsentDiffScalarDetail(axis) { + return [ + `provider: ${formatPresence(axis?.provider)}`, + `execution: ${formatPresence(axis?.execution)}` + ].join(", "); +} + +function formatPresence(side) { + return side?.present ? "vorhanden" : "nicht vorhanden"; +} + function renderDetailSection(container, title, rows) { const heading = document.createElement("h3"); const table = document.createElement("table"); @@ -392,6 +1362,7 @@ function clearConsentStateDetails() { consentDetailBasics.textContent = ""; consentDetailSummary.textContent = ""; consentDetailPublisher.textContent = ""; + consentDetailDiff.textContent = ""; consentDetailFieldPaths.textContent = ""; consentDetailRawStrings.textContent = ""; consentDetailDiagnostics.textContent = ""; @@ -484,6 +1455,39 @@ function countTruthyObjectValues(obj) { return Object.values(obj).filter(Boolean).length; } +function countConsentDiffEntryValues(entries, valueField) { + const result = { + total: 0, + trueValues: 0, + falseValues: 0, + otherValues: 0 + }; + + if (!Array.isArray(entries)) { + return result; + } + + entries.forEach((entry) => { + const value = entry?.[valueField]; + + result.total += 1; + + if (value === true) { + result.trueValues += 1; + return; + } + + if (value === false) { + result.falseValues += 1; + return; + } + + result.otherValues += 1; + }); + + return result; +} + function countObjectKeys(obj) { if (!obj || typeof obj !== "object" || Array.isArray(obj)) { return 0; diff --git a/src/core/consent-diff.js b/src/core/consent-diff.js new file mode 100644 index 0000000..a3ee699 --- /dev/null +++ b/src/core/consent-diff.js @@ -0,0 +1,374 @@ +"use strict"; + +var CONSENT_DIFF_RULE_ID = "consent_diff"; +var CONSENT_DIFF_RULE_VERSION = 1; + +const CONSENT_DIFF_SCALAR_AXES = [ + "tcString", + "addtlConsent", + "vendorListVersion", + "cmpId", + "cmpVersion", + "tcfPolicyVersion", + "gdprApplies", + "cmpStatus" +]; + +const CONSENT_DIFF_OBJECT_AXES = [ + "purpose.consents", + "vendor.consents", + "specialFeatureOptins" +]; + +function buildConsentDiff({ + captureSessionId, + providerAnnouncement, + consentExecution, + derivedAt +}) { + const providerRaw = cloneConsentDiffValue( + providerAnnouncement?.rawTcData ?? null + ); + const executionRaw = cloneConsentDiffValue(consentExecution?.rawTcData ?? null); + const providerWork = buildConsentDiffWorkCopy( + providerAnnouncement, + providerRaw + ); + const executionWork = buildConsentDiffWorkCopy(consentExecution, executionRaw); + const axes = {}; + + CONSENT_DIFF_SCALAR_AXES.forEach((axis) => { + axes[axis] = compareConsentDiffScalarAxis( + axis, + providerWork, + executionWork + ); + }); + + CONSENT_DIFF_OBJECT_AXES.forEach((axis) => { + axes[axis] = compareConsentDiffObjectAxis( + axis, + providerWork, + executionWork + ); + }); + + return { + ruleId: CONSENT_DIFF_RULE_ID, + ruleVersion: CONSENT_DIFF_RULE_VERSION, + derivedAt, + captureSessionId, + sources: { + providerAnnouncement: buildConsentDiffSourceReference( + providerAnnouncement + ), + consentExecution: buildConsentDiffSourceReference(consentExecution) + }, + sourceSelection: { + providerAnnouncement: + "first_provider_announcement_for_capture_session_available_in_memory", + consentExecution: "current_useractioncomplete_execution_event" + }, + comparisonAxes: [ + ...CONSENT_DIFF_SCALAR_AXES, + ...CONSENT_DIFF_OBJECT_AXES + ], + axes, + notes: buildConsentDiffNotes(providerAnnouncement, consentExecution) + }; +} + +function buildConsentDiffWorkCopy(eventRecord, rawTcData) { + return { + eventRecord: cloneConsentDiffValue(eventRecord ?? null), + rawTcData: rawTcData ?? null + }; +} + +function compareConsentDiffScalarAxis(axis, providerWork, executionWork) { + const providerValue = readConsentDiffAxisValue(providerWork, axis); + const executionValue = readConsentDiffAxisValue(executionWork, axis); + + return { + kind: "scalar", + status: getConsentDiffScalarStatus(providerValue, executionValue), + provider: buildConsentDiffAxisSide(providerValue), + execution: buildConsentDiffAxisSide(executionValue) + }; +} + +function compareConsentDiffObjectAxis(axis, providerWork, executionWork) { + const providerValue = readConsentDiffAxisValue(providerWork, axis); + const executionValue = readConsentDiffAxisValue(executionWork, axis); + const providerObject = isConsentDiffPlainObject(providerValue.value) + ? providerValue.value + : null; + const executionObject = isConsentDiffPlainObject(executionValue.value) + ? executionValue.value + : null; + const providerKeys = providerObject ? Object.keys(providerObject).sort() : []; + const executionKeys = executionObject ? Object.keys(executionObject).sort() : []; + const allKeys = Array.from(new Set([...providerKeys, ...executionKeys])).sort(); + const added = []; + const removed = []; + const changed = []; + const unchanged = []; + + allKeys.forEach((key) => { + const inProvider = providerObject + ? Object.prototype.hasOwnProperty.call(providerObject, key) + : false; + const inExecution = executionObject + ? Object.prototype.hasOwnProperty.call(executionObject, key) + : false; + + if (inProvider && !inExecution) { + removed.push({ + key, + providerValue: cloneConsentDiffValue(providerObject[key]) + }); + return; + } + + if (!inProvider && inExecution) { + added.push({ + key, + executionValue: cloneConsentDiffValue(executionObject[key]) + }); + return; + } + + if ( + stableConsentDiffValue(providerObject[key]) === + stableConsentDiffValue(executionObject[key]) + ) { + unchanged.push(key); + return; + } + + changed.push({ + key, + providerValue: cloneConsentDiffValue(providerObject[key]), + executionValue: cloneConsentDiffValue(executionObject[key]) + }); + }); + + return { + kind: "object", + status: getConsentDiffObjectStatus( + providerValue, + executionValue, + added, + removed, + changed + ), + provider: { + present: providerValue.present, + sourcePath: providerValue.sourcePath, + keys: providerKeys + }, + execution: { + present: executionValue.present, + sourcePath: executionValue.sourcePath, + keys: executionKeys + }, + addedKeys: added, + removedKeys: removed, + changedKeys: changed, + unchangedKeys: unchanged, + counts: { + providerKeys: providerKeys.length, + executionKeys: executionKeys.length, + added: added.length, + removed: removed.length, + changed: changed.length, + unchanged: unchanged.length + } + }; +} + +function readConsentDiffAxisValue(workCopy, axis) { + const rawValue = readConsentDiffPath(workCopy.rawTcData, axis); + + if (rawValue.present) { + return { + ...rawValue, + sourcePath: `rawTcData.${axis}` + }; + } + + const eventValue = readConsentDiffPath(workCopy.eventRecord, axis); + + if (eventValue.present) { + return { + ...eventValue, + sourcePath: axis + }; + } + + return { + present: false, + value: undefined, + sourcePath: null + }; +} + +function readConsentDiffPath(value, path) { + if (value === null || value === undefined) { + return { + present: false, + value: undefined + }; + } + + const parts = path.split("."); + let current = value; + + for (const part of parts) { + if ( + current === null || + current === undefined || + !Object.prototype.hasOwnProperty.call(Object(current), part) + ) { + return { + present: false, + value: undefined + }; + } + + current = current[part]; + } + + return { + present: true, + value: cloneConsentDiffValue(current) + }; +} + +function getConsentDiffScalarStatus(providerValue, executionValue) { + if (!providerValue.present && !executionValue.present) { + return "absent"; + } + + if (providerValue.present && !executionValue.present) { + return "removed"; + } + + if (!providerValue.present && executionValue.present) { + return "added"; + } + + return stableConsentDiffValue(providerValue.value) === + stableConsentDiffValue(executionValue.value) + ? "unchanged" + : "changed"; +} + +function getConsentDiffObjectStatus( + providerValue, + executionValue, + added, + removed, + changed +) { + if (!providerValue.present && !executionValue.present) { + return "absent"; + } + + if (providerValue.present && !executionValue.present) { + return "removed"; + } + + if (!providerValue.present && executionValue.present) { + return "added"; + } + + return added.length === 0 && removed.length === 0 && changed.length === 0 + ? "unchanged" + : "changed"; +} + +function buildConsentDiffAxisSide(axisValue) { + return { + present: axisValue.present, + sourcePath: axisValue.sourcePath, + value: axisValue.present ? cloneConsentDiffValue(axisValue.value) : null + }; +} + +function buildConsentDiffSourceReference(eventRecord) { + if (!eventRecord) { + return { + available: false, + reason: "missing_source_event" + }; + } + + return { + available: true, + store: "consent_events", + id: eventRecord.id ?? null, + eventType: eventRecord.eventType ?? null, + rawEventName: eventRecord.rawEventName ?? null, + capturedAt: eventRecord.capturedAt ?? null, + recordedAt: eventRecord.recordedAt ?? null, + captureSessionId: eventRecord.captureSessionId ?? null + }; +} + +function buildConsentDiffNotes(providerAnnouncement, consentExecution) { + const notes = []; + + if (!providerAnnouncement) { + notes.push("provider_announcement_source_missing"); + } + + if (!consentExecution) { + notes.push("consent_execution_source_missing"); + } + + notes.push("primary_evidence_not_modified"); + notes.push("no_legal_assessment"); + notes.push("no_gvl_semantic_assessment"); + + return notes; +} + +function stableConsentDiffValue(value) { + if (value === undefined) { + return "[[undefined]]"; + } + + if (value === null || typeof value !== "object") { + return JSON.stringify(value); + } + + if (Array.isArray(value)) { + return `[${value.map((item) => stableConsentDiffValue(item)).join(",")}]`; + } + + return `{${Object.keys(value) + .sort() + .map((key) => `${JSON.stringify(key)}:${stableConsentDiffValue(value[key])}`) + .join(",")}}`; +} + +function cloneConsentDiffValue(value) { + if (value === undefined) { + return undefined; + } + + if (value === null || typeof value !== "object") { + return value; + } + + return JSON.parse(JSON.stringify(value)); +} + +function isConsentDiffPlainObject(value) { + return ( + value !== null && + typeof value === "object" && + !Array.isArray(value) + ); +}