@astronox/core 0.4.18 → 0.5.1

package/README.md

@@ -63,7 +63,7 @@ component labels can extend `defaultCoreMessages` through
   claims, Firestore, and app-owned mappings.
 - [`R2 publication`](docs/integrations/r2-publication.md): full provider
   snapshots and build-time public projection.
-- [`AdSense`](docs/integrations/adsense.md): typed configuration, responsive
-  units, host policy, Privacy & Messaging, and deployment.
+- [`AdSense`](docs/integrations/adsense.md): typed configuration, Privacy &
+  Messaging policy, annotation exclusions, and deployment.
 - [`release workflow`](docs/release-workflow.md): local links, verification, and
   consumer pinning order.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astronox/core",
-  "version": "0.4.18",
+  "version": "0.5.1",
   "description": "Reusable Astro components, patterns, styles, and infrastructure for AstroNox sites.",
   "license": "MIT",
   "keywords": [

package/src/ads/adsense/AdsenseAdBlockingRecoveryHead.astro

@@ -0,0 +1,30 @@
+---
+type Props = {
+  publisherId: string;
+};
+
+const { publisherId }: Props = Astro.props;
+const scriptSource = `https://fundingchoicesmessages.google.com/i/${encodeURIComponent(publisherId)}?ers=1`;
+---
+
+<script is:inline async src={scriptSource}></script>
+<script is:inline>
+  (() => {
+    const signalGooglefcPresent = () => {
+      if (window.frames['googlefcPresent']) return;
+
+      if (!document.body) {
+        setTimeout(signalGooglefcPresent, 0);
+        return;
+      }
+
+      const frame = document.createElement('iframe');
+      frame.name = 'googlefcPresent';
+      frame.style.cssText =
+        'display: none; width: 0; height: 0; border: none; z-index: -1000; left: -1000px; top: -1000px;';
+      document.body.appendChild(frame);
+    };
+
+    signalGooglefcPresent();
+  })();
+</script>

package/src/ads/adsense/AdsenseHead.astro

@@ -1,5 +1,7 @@
 ---
 import type { AdsenseAdsConfig } from '../contracts';
+import AdsenseAdBlockingRecoveryHead from './AdsenseAdBlockingRecoveryHead.astro';
+import AdsenseMessagingBootstrap from './AdsenseMessagingBootstrap.astro';
 import { toAdsenseClientId } from './provider';
 
 type Props = {
@@ -9,30 +11,22 @@ type Props = {
 const { config }: Props = Astro.props;
 const clientId = toAdsenseClientId(config.publisherId);
 const scriptSource = `https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=${encodeURIComponent(clientId)}`;
-const adBlockingRecoverySource = `https://fundingchoicesmessages.google.com/i/${encodeURIComponent(config.publisherId)}?ers=1`;
+const adBlockingRecoveryEnabled = Boolean(
+  config.privacyMessaging?.adBlockingRecovery,
+);
 ---
 
-<script is:inline async src={adBlockingRecoverySource}></script>
-<script is:inline>
-  (() => {
-    const signalGooglefcPresent = () => {
-      if (window.frames['googlefcPresent']) return;
-
-      if (!document.body) {
-        setTimeout(signalGooglefcPresent, 0);
-        return;
-      }
-
-      const frame = document.createElement('iframe');
-      frame.name = 'googlefcPresent';
-      frame.style.cssText =
-        'display: none; width: 0; height: 0; border: none; z-index: -1000; left: -1000px; top: -1000px;';
-      document.body.appendChild(frame);
-    };
-
-    signalGooglefcPresent();
-  })();
-</script>
+{
+  config.privacyMessaging ? (
+    <AdsenseMessagingBootstrap config={config.privacyMessaging} />
+  ) : null
+}
+
+{
+  adBlockingRecoveryEnabled ? (
+    <AdsenseAdBlockingRecoveryHead publisherId={config.publisherId} />
+  ) : null
+}
 
 <meta name="google-adsense-account" content={clientId} />
 <script is:inline async crossorigin="anonymous" src={scriptSource}></script>

package/src/ads/adsense/AdsenseMessagingBootstrap.astro

@@ -0,0 +1,219 @@
+---
+import type { AdsensePrivacyMessagingConfig } from '../contracts';
+import AdsensePublisherRevocationStyle from './AdsensePublisherRevocationStyle.astro';
+
+type Props = {
+  config: AdsensePrivacyMessagingConfig;
+};
+
+const { config }: Props = Astro.props;
+const adBlockingRecovery = config.adBlockingRecovery;
+const publisherLauncher = config.consentRevocation?.launcher === 'publisher';
+const adBlockingEnabled = Boolean(adBlockingRecovery);
+const adBlockingRedisplayIntervalMs =
+  adBlockingRecovery?.redisplayIntervalMs ?? 0;
+const adBlockingStorageKey = adBlockingRecovery?.storageKey ?? '';
+---
+
+{publisherLauncher ? <AdsensePublisherRevocationStyle /> : null}
+
+<script
+  is:inline
+  define:vars={{
+    adBlockingEnabled,
+    adBlockingRedisplayIntervalMs,
+    adBlockingStorageKey,
+    publisherLauncher,
+  }}
+>
+  (() => {
+    const bootstrapKey = Symbol.for('astronox.adsense.messaging');
+    if (window[bootstrapKey]) return;
+    window[bootstrapKey] = true;
+
+    const googlefc = (window.googlefc ??= {});
+    googlefc.callbackQueue ??= [];
+
+    if (adBlockingEnabled) {
+      const now = Date.now();
+      let storageAvailable = true;
+      let storedTimestamp;
+
+      try {
+        const storedValue = window.localStorage.getItem(adBlockingStorageKey);
+        const parsedTimestamp = Number(storedValue);
+        if (
+          storedValue !== null &&
+          Number.isFinite(parsedTimestamp) &&
+          parsedTimestamp > 0 &&
+          parsedTimestamp <= now
+        ) {
+          storedTimestamp = parsedTimestamp;
+        }
+      } catch {
+        storageAvailable = false;
+      }
+
+      const cooldownActive =
+        storedTimestamp !== undefined &&
+        now - storedTimestamp < adBlockingRedisplayIntervalMs;
+      let adBlockingAuthorized = false;
+      let blockerConfirmed = false;
+      let timestampPersisted = false;
+
+      const persistAuthorizationTimestamp = () => {
+        if (
+          cooldownActive ||
+          !storageAvailable ||
+          !adBlockingAuthorized ||
+          !blockerConfirmed ||
+          timestampPersisted
+        ) {
+          return;
+        }
+
+        try {
+          window.localStorage.setItem(adBlockingStorageKey, String(Date.now()));
+          timestampPersisted = true;
+        } catch {
+          storageAvailable = false;
+        }
+      };
+
+      googlefc.controlledMessagingFunction = (message) => {
+        if (!message || typeof message.proceed !== 'function') return;
+
+        if (cooldownActive) {
+          const adBlockingType = googlefc.MessageTypeEnum?.AD_BLOCKING;
+          if (typeof adBlockingType === 'number') {
+            message.proceed(false, [adBlockingType]);
+            return;
+          }
+
+          message.proceed(true);
+          return;
+        }
+
+        adBlockingAuthorized = true;
+        message.proceed(true);
+        persistAuthorizationTimestamp();
+      };
+
+      googlefc.callbackQueue.push({
+        AD_BLOCK_DATA_READY: () => {
+          if (
+            typeof googlefc.getAdBlockerStatus !== 'function' ||
+            !googlefc.AdBlockerStatusEnum
+          ) {
+            return;
+          }
+
+          const status = googlefc.getAdBlockerStatus();
+          if (typeof status !== 'number' || !Number.isFinite(status)) return;
+
+          const statusEnum = googlefc.AdBlockerStatusEnum;
+          const blockerStatuses = new Set(
+            [
+              statusEnum.EXTENSION_AD_BLOCKER,
+              statusEnum.EXTENSION_LEVEL_AD_BLOCKER,
+              statusEnum.NETWORK_LEVEL_AD_BLOCKER,
+            ].filter(
+              (value) => typeof value === 'number' && Number.isFinite(value),
+            ),
+          );
+
+          if (!blockerStatuses.has(status)) return;
+
+          blockerConfirmed = true;
+          persistAuthorizationTimestamp();
+        },
+      });
+    }
+
+    if (!publisherLauncher) return;
+
+    const legacyLauncherSelector = '.google-revocation-link-placeholder';
+    const toolbarSelector = '#ft-floating-toolbar';
+    const hostObservers = new WeakMap();
+
+    const disconnectHostObserver = (host) => {
+      hostObservers.get(host)?.disconnect();
+      hostObservers.delete(host);
+    };
+
+    const suppressToolbarLauncher = (host, shadowRoot) => {
+      const toolbar = shadowRoot.querySelector(toolbarSelector);
+      if (!toolbar) return;
+
+      toolbar
+        .querySelectorAll('.ft-reg-button, #ft-reg-bubble')
+        .forEach((element) => element.remove());
+
+      const remainingToolbarAction = toolbar.querySelector(
+        '.ft-button-holder button, .ft-bottom-button-holder button',
+      );
+      if (remainingToolbarAction) return;
+
+      disconnectHostObserver(host);
+      host.remove();
+    };
+
+    const observeShadowRoot = (host) => {
+      const shadowRoot = host.shadowRoot;
+      if (!shadowRoot || hostObservers.has(host)) return;
+
+      suppressToolbarLauncher(host, shadowRoot);
+      if (!host.isConnected) return;
+
+      const observer = new MutationObserver(() => {
+        suppressToolbarLauncher(host, shadowRoot);
+      });
+      observer.observe(shadowRoot, { childList: true, subtree: true });
+      hostObservers.set(host, observer);
+    };
+
+    const inspectBodyChild = (element) => {
+      if (element.matches(legacyLauncherSelector)) {
+        element.remove();
+        return;
+      }
+
+      element
+        .querySelectorAll(legacyLauncherSelector)
+        .forEach((launcher) => launcher.remove());
+      observeShadowRoot(element);
+    };
+
+    const startLauncherSuppression = () => {
+      if (!document.body) return;
+
+      for (const child of [...document.body.children]) {
+        inspectBodyChild(child);
+      }
+
+      new MutationObserver((records) => {
+        for (const record of records) {
+          for (const node of record.removedNodes) {
+            if (node instanceof Element) disconnectHostObserver(node);
+          }
+          for (const node of record.addedNodes) {
+            if (node instanceof Element) inspectBodyChild(node);
+          }
+        }
+      }).observe(document.body, { childList: true });
+    };
+
+    if (document.body) {
+      startLauncherSuppression();
+      return;
+    }
+
+    const documentObserver = new MutationObserver(() => {
+      if (!document.body) return;
+
+      documentObserver.disconnect();
+      startLauncherSuppression();
+    });
+    documentObserver.observe(document.documentElement, { childList: true });
+  })();
+</script>

package/src/ads/adsense/AdsensePublisherRevocationStyle.astro

@@ -0,0 +1,5 @@
+<style is:global>
+  .google-revocation-link-placeholder {
+    display: none !important;
+  }
+</style>

package/src/ads/contracts.ts

@@ -2,10 +2,25 @@ export type DisabledAdsConfig = {
   enabled: false;
 };
 
+export type AdsenseAdBlockingRecoveryConfig = {
+  redisplayIntervalMs: number;
+  storageKey: string;
+};
+
+export type AdsenseConsentRevocationConfig = {
+  launcher: 'google' | 'publisher';
+};
+
+export type AdsensePrivacyMessagingConfig = {
+  adBlockingRecovery?: AdsenseAdBlockingRecoveryConfig;
+  consentRevocation?: AdsenseConsentRevocationConfig;
+};
+
 export type AdsenseAdsConfig = {
   enabled: true;
   provider: 'adsense';
   publisherId: string;
+  privacyMessaging?: AdsensePrivacyMessagingConfig;
 };
 
 export type AdsConfig = DisabledAdsConfig | AdsenseAdsConfig;
@@ -22,5 +37,35 @@ export function defineAdsConfig<const TConfig extends AdsConfig>(
   if (!/^pub-\d+$/.test(config.publisherId)) {
     throw new Error('Invalid AdSense publisher id');
   }
+
+  const adBlockingRecovery = config.privacyMessaging?.adBlockingRecovery;
+  if (adBlockingRecovery) {
+    if (
+      !Number.isFinite(adBlockingRecovery.redisplayIntervalMs) ||
+      adBlockingRecovery.redisplayIntervalMs <= 0
+    ) {
+      throw new Error(
+        'AdSense ad blocking recovery redisplay interval must be positive',
+      );
+    }
+    if (
+      typeof adBlockingRecovery.storageKey !== 'string' ||
+      adBlockingRecovery.storageKey.trim().length === 0
+    ) {
+      throw new Error(
+        'AdSense ad blocking recovery storage key must not be empty',
+      );
+    }
+  }
+
+  const consentLauncher = config.privacyMessaging?.consentRevocation?.launcher;
+  if (
+    consentLauncher !== undefined &&
+    consentLauncher !== 'google' &&
+    consentLauncher !== 'publisher'
+  ) {
+    throw new Error('Invalid AdSense consent revocation launcher');
+  }
+
   return config;
 }

package/src/patterns/Table/tableFilterController.ts

@@ -8,12 +8,15 @@ import {
   hasTableProgressive,
   setTableProgressiveFilters,
 } from './tableProgressiveController';
+import {
+  matchesFilterSelection,
+  normalizeFilterSelection,
+  type TableFilterValues,
+} from './tableFilterSelection';
 import { revealTableStart } from './tableViewport';
 
-type FilterValues = Readonly<Record<string, readonly string[]>>;
-
 type CachedFilterValues = {
-  values: FilterValues;
+  values: TableFilterValues;
   normalizedSearch: readonly string[];
 };
 
@@ -92,7 +95,7 @@ export function initTableFilters(root: HTMLElement): () => void {
       .normalize('NFD')
       .replace(/\p{Diacritic}/gu, '')
       .toLocaleLowerCase(locale);
-  const selections = new Map<string, string>();
+  const selections = new Map<string, readonly string[]>();
   const filterValuesCache = new WeakMap<HTMLElement, CachedFilterValues>();
   const rows: HTMLElement[] = [];
   let scheduledFrame: number | null = null;
@@ -118,7 +121,7 @@ export function initTableFilters(root: HTMLElement): () => void {
   const applyFilters = (): void => {
     const query = normalize(search?.value.trim() ?? '');
     const activeSelections = [...selections.entries()].filter(
-      ([, value]) => value.length > 0,
+      ([, values]) => values.length > 0,
     );
     const hasExternalFilter =
       root.hasAttribute(externalFiltersAttribute) ||
@@ -144,8 +147,10 @@ export function initTableFilters(root: HTMLElement): () => void {
         query.length === 0 ||
         cached.normalizedSearch.some((value) => value.includes(query));
       const matchesSelections = activeSelections.every(
-        ([field, selectedValue]) =>
-          (cached.values[field] ?? []).includes(selectedValue),
+        ([field, selectedValues]) => {
+          const rowValues = cached.values[field] ?? [];
+          return matchesFilterSelection(rowValues, selectedValues);
+        },
       );
       const visible =
         matchesSearch &&
@@ -190,7 +195,9 @@ export function initTableFilters(root: HTMLElement): () => void {
 
     const field = target.dataset.tableFilterField;
     if (!field) return;
-    selections.set(field, customEvent.detail.values[0] ?? '');
+    const values = normalizeFilterSelection(customEvent.detail.values);
+    if (values.length > 0) selections.set(field, values);
+    else selections.delete(field);
     revealTableStart(table);
     scheduleFilters();
   };
@@ -215,8 +222,10 @@ export function initTableFilters(root: HTMLElement): () => void {
 
   for (const field of fields) {
     const fieldName = field.dataset.tableFilterField;
-    const selectedValue = getComboboxValues(field)[0];
-    if (fieldName && selectedValue) selections.set(fieldName, selectedValue);
+    const selectedValues = normalizeFilterSelection(getComboboxValues(field));
+    if (fieldName && selectedValues.length > 0) {
+      selections.set(fieldName, selectedValues);
+    }
   }
   registerRows(
     Array.from(
@@ -248,12 +257,14 @@ export function initTableFilters(root: HTMLElement): () => void {
   };
 }
 
-function parseFilterValues(value: string | undefined): FilterValues {
+function parseFilterValues(value: string | undefined): TableFilterValues {
   if (!value) return {};
 
   try {
     const parsed = JSON.parse(value);
-    return parsed && typeof parsed === 'object' ? (parsed as FilterValues) : {};
+    return parsed && typeof parsed === 'object'
+      ? (parsed as TableFilterValues)
+      : {};
   } catch {
     return {};
   }

package/src/patterns/Table/tableFilterSelection.ts

@@ -0,0 +1,47 @@
+export type TableFilterValues = Readonly<Record<string, readonly string[]>>;
+
+export function normalizeFilterSelection(
+  values: readonly string[],
+): readonly string[] {
+  return [...new Set(values.filter((value) => value.length > 0))].sort();
+}
+
+export function normalizeFilterSelections(
+  selections: TableFilterValues,
+): TableFilterValues {
+  const normalized: Record<string, readonly string[]> = {};
+
+  for (const [field, values] of Object.entries(selections)) {
+    const selection = normalizeFilterSelection(values);
+    if (selection.length > 0) normalized[field] = selection;
+  }
+
+  return normalized;
+}
+
+export function matchesFilterSelection(
+  values: readonly string[],
+  selection: readonly string[],
+): boolean {
+  return selection.some((value) => values.includes(value));
+}
+
+export function areFilterSelectionsEqual(
+  left: TableFilterValues,
+  right: TableFilterValues,
+): boolean {
+  const leftEntries = Object.entries(left);
+  const rightEntries = Object.entries(right);
+
+  return (
+    leftEntries.length === rightEntries.length &&
+    leftEntries.every(([field, values]) => {
+      const rightValues = right[field];
+      return (
+        rightValues !== undefined &&
+        values.length === rightValues.length &&
+        values.every((value, index) => value === rightValues[index])
+      );
+    })
+  );
+}

package/src/patterns/Table/tableProgressiveController.ts

@@ -3,6 +3,12 @@ import type {
   TableProgressiveModel,
 } from '../../display/contracts';
 import { tableProgressiveBatchSize } from '../../display/tableProgressive';
+import {
+  areFilterSelectionsEqual,
+  matchesFilterSelection,
+  normalizeFilterSelections,
+  type TableFilterValues,
+} from './tableFilterSelection';
 import { resolveTableScrollRoot, revealTableStart } from './tableViewport';
 
 const initializedAttribute = 'data-table-progressive-initialized';
@@ -20,7 +26,7 @@ export type TableRowsAppendedDetail = {
 
 export type TableProgressiveFilterState = {
   search: string;
-  selections: Readonly<Record<string, string>>;
+  selections: TableFilterValues;
 };
 
 export type TableProgressiveSortState = {
@@ -250,9 +256,10 @@ export function initTableProgressive(root: HTMLElement): () => void {
       ) {
         return false;
       }
-      return selections.every(([field, value]) =>
-        (entry.filters?.[field] ?? []).includes(value),
-      );
+      return selections.every(([field, selectedValues]) => {
+        const entryValues = entry.filters?.[field] ?? [];
+        return matchesFilterSelection(entryValues, selectedValues);
+      });
     });
 
     if (sortState) {
@@ -455,8 +462,9 @@ export function initTableProgressive(root: HTMLElement): () => void {
     progressive: true,
     refresh,
     setFilters(state) {
-      if (areFilterStatesEqual(filterState, state)) return;
-      filterState = state;
+      const normalizedState = normalizeFilterState(state);
+      if (areFilterStatesEqual(filterState, normalizedState)) return;
+      filterState = normalizedState;
       if (prepared) prepareWindow(0, 'refreshing');
     },
     setSort(state) {
@@ -656,15 +664,21 @@ function areFilterStatesEqual(
   left: TableProgressiveFilterState,
   right: TableProgressiveFilterState,
 ): boolean {
-  if (left.search !== right.search) return false;
-  const leftEntries = Object.entries(left.selections);
-  const rightEntries = Object.entries(right.selections);
   return (
-    leftEntries.length === rightEntries.length &&
-    leftEntries.every(([key, value]) => right.selections[key] === value)
+    left.search === right.search &&
+    areFilterSelectionsEqual(left.selections, right.selections)
   );
 }
 
+function normalizeFilterState(
+  state: TableProgressiveFilterState,
+): TableProgressiveFilterState {
+  return {
+    search: state.search,
+    selections: normalizeFilterSelections(state.selections),
+  };
+}
+
 function areSortStatesEqual(
   left: TableProgressiveSortState,
   right: TableProgressiveSortState,