@peax/consent-core 0.6.0 → 0.9.3

package/dist/enforcement/markup.js

@@ -109,7 +109,7 @@ function createConsentMarkupGuard({ consent, root, onIssue }) {
 				const asyncValue = read(template, "async");
 				if (asyncValue !== void 0 && asyncValue !== "true" && asyncValue !== "false") throw new TypeError("Invalid data-peax-async value.");
 				const { nonce, integrity, crossOrigin, referrerPolicy } = {
-					nonce: read(template, "nonce"),
+					nonce: template.nonce || void 0,
 					integrity: read(template, "integrity"),
 					crossOrigin: read(template, "crossOrigin"),
 					referrerPolicy: read(template, "referrerPolicy")

package/dist/enforcement/request-rules.js

@@ -253,7 +253,7 @@ function createXhrInterceptor(target, rules, permissions, report) {
 		if (args.length < 2) return Reflect.apply(nativeOpen, this, args);
 		const method = domString(args[0]);
 		const urlInput = domString(args[1]);
-		const rest = args.slice(2, 5).map((value, index) => index === 0 ? Boolean(value) : value == null ? null : domString(value));
+		const rest = args.slice(2, 5).map((value, index) => index === 0 ? value === void 0 || Boolean(value) : value == null ? null : domString(value));
 		let url;
 		try {
 			url = new target.URL(urlInput, target.document.baseURI);

package/dist/index.js

@@ -145,19 +145,12 @@ function createConsentSubscription() {
 }
 //#endregion
 //#region src/consent/evaluateConsent.ts
-/**
-* Evaluates one use without mutating inputs or performing enforcement.
-* Inputs must be validated, with unique policy use IDs and at most one choice
-* per use. Denials remain blocked regardless of their consent version.
-* A version mismatch blocks only this use, not other unchanged uses.
-*/
-function evaluateConsent({ currentAppPolicy, state, useId }) {
-	const use = currentAppPolicy.uses.find((use) => use.id === useId);
+/** Decides one use from its declaration and recorded choice, which callers look up their own way. */
+function decideConsent(use, choice) {
 	if (!use) return {
 		allowed: false,
 		reason: "unknown-use"
 	};
-	const choice = state.choices.find((choice) => choice.useId === useId);
 	if (!choice) return {
 		allowed: false,
 		reason: "undecided"
@@ -180,12 +173,9 @@ function evaluateConsent({ currentAppPolicy, state, useId }) {
 * input contract. An empty result is not blanket permission: denials are omitted.
 */
 function getMismatchedConsent({ currentAppPolicy, state }) {
+	const choices = new Map(state.choices.map((choice) => [choice.useId, choice]));
 	return currentAppPolicy.uses.flatMap((use) => {
-		const evaluation = evaluateConsent({
-			currentAppPolicy,
-			state,
-			useId: use.id
-		});
+		const evaluation = decideConsent(use, choices.get(use.id));
 		if (evaluation.allowed) return [];
 		if (evaluation.reason !== "undecided" && evaluation.reason !== "consent-version-mismatch") return [];
 		return [{
@@ -357,26 +347,46 @@ function createSnapshot(currentAppPolicy, state) {
 		state
 	});
 }
+function indexSnapshot({ currentAppPolicy, state }) {
+	const uses = new Map(currentAppPolicy.uses.map((use) => [use.id, use]));
+	const choices = new Map(state.choices.map((choice) => [choice.useId, choice]));
+	return (useId) => decideConsent(uses.get(useId), choices.get(useId));
+}
 function snapshotRequirements(snapshot) {
 	return Object.freeze(getMismatchedConsent(snapshot).map((requirement) => Object.freeze(requirement)));
 }
+var maxReentrantCommits = 100;
 /** Creates an isolated runtime from decoded data; invalid input creates no instance. */
 function createConsent(input) {
 	const result = validateWithSchema(createConsentOptionsSchema, input);
 	if (!result.success) return result;
 	let snapshot = createSnapshot(result.data.currentAppPolicy, result.data.initialState);
 	let requirements = snapshotRequirements(snapshot);
+	let evaluate = indexSnapshot(snapshot);
 	const subscriptions = createConsentSubscription();
+	let delivering = false;
+	let reentrantCommits = 0;
 	function commit(currentAppPolicy, state) {
 		if (snapshot.currentAppPolicy === currentAppPolicy && snapshot.state === state) return {
 			success: true,
 			data: snapshot
 		};
+		if (delivering && ++reentrantCommits > maxReentrantCommits) throw new RangeError("Consent subscribers kept committing changes on every notification.");
 		const next = createSnapshot(currentAppPolicy, state);
 		const nextRequirements = snapshotRequirements(next);
 		snapshot = next;
 		requirements = nextRequirements;
-		subscriptions.notify();
+		evaluate = indexSnapshot(next);
+		if (delivering) subscriptions.notify();
+		else {
+			delivering = true;
+			reentrantCommits = 0;
+			try {
+				subscriptions.notify();
+			} finally {
+				delivering = false;
+			}
+		}
 		return {
 			success: true,
 			data: next
@@ -386,10 +396,7 @@ function createConsent(input) {
 		success: true,
 		data: Object.freeze({
 			getSnapshot: () => snapshot,
-			evaluate: (useId) => evaluateConsent({
-				...snapshot,
-				useId
-			}),
+			evaluate: (useId) => evaluate(useId),
 			getMismatchedConsent: () => requirements,
 			restoreState(input) {
 				const parsed = validateWithSchema(consentStateSchema, input);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peax/consent-core",
-  "version": "0.6.0",
+  "version": "0.9.3",
   "description": "Framework-independent consent state and runtime primitives.",
   "keywords": [
     "consent-management",