@unitninety/site-kit 1.6.5 → 1.6.6

package/src/features/consent/loader.ts

@@ -1,248 +0,0 @@
-import {
-  ConsentStateSchema,
-  type ConsentState,
-  type IntegrationDriver,
-  type ManagedIntegration,
-} from '../contracts/consent'
-
-export class ConsentReloadRequiredError extends Error {}
-const OPERATION_TIMEOUT_MS = 10000
-function bounded<T>(operation: Promise<T>, timeout: () => void): Promise<T> {
-  let timer: ReturnType<typeof setTimeout>
-  return Promise.race([
-    operation,
-    new Promise<never>((_, reject) => {
-      timer = setTimeout(() => {
-        timeout()
-        reject(new ConsentReloadRequiredError('Consent operation timed out; reload required.'))
-      }, OPERATION_TIMEOUT_MS)
-    }),
-  ]).finally(() => clearTimeout(timer))
-}
-
-type RecordState = {
-  integration: ManagedIntegration
-  fingerprint: string
-  desired: boolean
-  attempted: boolean
-  active: boolean
-  revoked: boolean
-  start?: Promise<void>
-  stop?: Promise<void>
-  error?: string
-}
-type Store = {
-  records: Map<string, RecordState>
-  reloadRequired: boolean
-  error: string | null
-  listeners: Set<() => void>
-}
-const stores = new WeakMap<IntegrationDriver, Store>()
-function storeFor(driver: IntegrationDriver): Store {
-  let store = stores.get(driver)
-  if (!store) {
-    store = { records: new Map(), reloadRequired: false, error: null, listeners: new Set() }
-    stores.set(driver, store)
-  }
-  return store
-}
-export function executableFingerprint(integration: ManagedIntegration): string {
-  return JSON.stringify([
-    integration.src,
-    Object.entries(integration.attributes ?? {}).sort(([a], [b]) => a.localeCompare(b)),
-  ])
-}
-/** Internal diagnostics; only the fixed loader contract is exposed by the package. */
-export function consentLoaderStatus(driver: IntegrationDriver) {
-  const { reloadRequired, error } = storeFor(driver)
-  return { reloadRequired, error }
-}
-export function observeConsentLoader(driver: IntegrationDriver, listener: () => void) {
-  const listeners = storeFor(driver).listeners
-  listeners.add(listener)
-  return () => {
-    listeners.delete(listener)
-  }
-}
-function publish(store: Store) {
-  for (const listener of store.listeners) listener()
-}
-export function requireConsentReload(driver: IntegrationDriver, reason: string) {
-  const store = storeFor(driver)
-  store.reloadRequired = true
-  store.error = reason
-  for (const record of store.records.values()) {
-    record.desired = false
-    void stopRecord(driver, store, record).catch(() => {})
-  }
-  publish(store)
-}
-function stopRecord(
-  driver: IntegrationDriver,
-  store: Store,
-  record: RecordState,
-  finalize = false,
-): Promise<void> {
-  if (!record.attempted || (record.revoked && !finalize)) return record.stop ?? Promise.resolve()
-  record.revoked = true
-  record.active = false
-  // Invoke before constructing/awaiting any queue: drivers synchronously latch their veto.
-  let operation: Promise<'stopped' | 'reload-required'>
-  try {
-    operation = driver.stop(record.integration.id)
-  } catch (cause) {
-    operation = Promise.reject(cause)
-  }
-  const stop = bounded(operation, () =>
-    requireConsentReload(driver, 'Reload to apply consent changes. Integration stop timed out.'),
-  )
-    .then(
-      (result) => {
-        if (result === 'reload-required' || record.integration.revocation === 'reload')
-          requireConsentReload(
-            driver,
-            'Reload to apply consent changes. Previously started code requires a fresh document.',
-          )
-      },
-      (cause) => {
-        requireConsentReload(
-          driver,
-          `Reload to apply consent changes. Integration stop failed: ${cause instanceof Error ? cause.message : 'unavailable'}`,
-        )
-        throw cause
-      },
-    )
-    .finally(() => {
-      if (record.stop === stop) record.stop = undefined
-      publish(store)
-    })
-  record.stop = stop
-  return stop
-}
-function startRecord(driver: IntegrationDriver, store: Store, record: RecordState): Promise<void> {
-  if (record.start) return record.start
-  if (!record.desired || store.reloadRequired || record.active)
-    return record.stop ?? Promise.resolve()
-  const begin = async () => {
-    if (record.stop) await record.stop
-    if (!record.desired || store.reloadRequired || record.active) return
-    record.attempted = true
-    record.revoked = false
-    record.error = undefined
-    try {
-      let expired = false
-      const operation = driver.start(record.integration)
-      void operation.then(
-        () => {
-          if (expired) void stopRecord(driver, store, record, true).catch(() => {})
-        },
-        () => {},
-      )
-      await bounded(operation, () => {
-        expired = true
-        requireConsentReload(
-          driver,
-          'Reload to apply consent changes. Integration initialization timed out.',
-        )
-      })
-      if (!record.desired || record.revoked || store.reloadRequired) {
-        await stopRecord(driver, store, record, true)
-      } else record.active = true
-    } catch (cause) {
-      if (cause instanceof ConsentReloadRequiredError) requireConsentReload(driver, cause.message)
-      record.error = cause instanceof Error ? cause.message : 'Integration initialization failed'
-      store.error = record.error
-      publish(store)
-      throw cause
-    }
-  }
-  // begin invokes start synchronously until its first await.
-  const starting = begin().finally(() => {
-    if (record.start === starting) record.start = undefined
-    publish(store)
-  })
-  record.start = starting
-  return starting
-}
-export function createConsentLoader(driver: IntegrationDriver): {
-  apply(state: ConsentState, integrations: ManagedIntegration[]): Promise<void>
-  dispose(): void
-} {
-  const store = storeFor(driver)
-  let disposed = false
-  return {
-    async apply(input, integrations) {
-      if (disposed) return
-      const parsed = ConsentStateSchema.safeParse(input)
-      const state = parsed.success ? parsed.data : null
-      const incoming = new Map(integrations.map((row) => [row.id, row]))
-      const operations: Promise<void>[] = []
-      // Record *all* restrictions first, independently of asynchronous failures.
-      for (const [id, record] of store.records) {
-        const next = incoming.get(id)
-        if (next && executableFingerprint(next) !== record.fingerprint && record.attempted)
-          requireConsentReload(
-            driver,
-            'Reload to apply consent changes. An executed integration was replaced.',
-          )
-        record.desired = !store.reloadRequired && !!next && !!state?.ready && state[next.category]
-        if (next && executableFingerprint(next) === record.fingerprint) record.integration = next
-        if (!record.desired) operations.push(stopRecord(driver, store, record))
-      }
-      // A different ID must not slip past a stop that may latch document reload.
-      const pendingStops = [...store.records.values()].flatMap((record) =>
-        record.stop ? [record.stop] : [],
-      )
-      const stopped = pendingStops.length ? Promise.allSettled(pendingStops) : undefined
-      for (const integration of integrations) {
-        let record = store.records.get(integration.id)
-        if (
-          !record ||
-          (!record.attempted && executableFingerprint(integration) !== record.fingerprint)
-        ) {
-          record = {
-            integration,
-            fingerprint: executableFingerprint(integration),
-            desired: false,
-            attempted: false,
-            active: false,
-            revoked: false,
-          }
-          store.records.set(integration.id, record)
-        }
-        record.desired = !store.reloadRequired && !!state?.ready && state[integration.category]
-        if (record.desired) {
-          const current = record
-          operations.push(
-            (stopped
-              ? stopped.then(() => {
-                  if (!disposed) return startRecord(driver, store, current)
-                })
-              : startRecord(driver, store, current)
-            ).then(async () => {
-              // A regrant during an unresolved start/stop resumes only once both settled.
-              if (!disposed && current.desired && !current.active && !store.reloadRequired)
-                await startRecord(driver, store, current)
-            }),
-          )
-        }
-      }
-      const results = await Promise.allSettled(operations)
-      const failure = results.find(
-        (result): result is PromiseRejectedResult => result.status === 'rejected',
-      )
-      if (failure) throw failure.reason
-      if (!store.reloadRequired && ![...store.records.values()].some((record) => record.error))
-        store.error = null
-      publish(store)
-    },
-    dispose() {
-      if (disposed) return
-      disposed = true
-      for (const record of store.records.values()) {
-        record.desired = false
-        void stopRecord(driver, store, record).catch(() => {})
-      }
-    },
-  }
-}

package/src/features/consent/registry.ts

@@ -1,398 +0,0 @@
-import {
-  classifyManagedIntegration,
-  ConsentInstallationSchema,
-  ConsentStateSchema,
-  deniedConsentState,
-  type ConsentAdapter,
-  type ConsentInstallation,
-  type ConsentState,
-} from '../contracts/consent'
-import { cookieScriptAdapter } from './cookieScript'
-import { customConsentAdapter, type CustomConsentRegistration } from './custom'
-import { createBrowserConsentDriver, CONSENT_LOAD_TIMEOUT_MS } from './drivers'
-import {
-  consentLoaderStatus,
-  createConsentLoader,
-  observeConsentLoader,
-  requireConsentReload,
-} from './loader'
-
-type Snapshot = {
-  state: ConsentState
-  ready: boolean
-  error: string | null
-  reloadRequired: boolean
-}
-type Identity = {
-  endpoint: string
-  provider: string
-  source: string
-  adapter?: ConsentAdapter
-  owner?: CustomConsentRegistration
-  reopen?: () => void
-}
-const registries = new WeakMap<Document, ReturnType<typeof createRegistry>>()
-export function consentRegistry(window: Window) {
-  let registry = registries.get(window.document)
-  if (!registry) {
-    registry = createRegistry(window)
-    registries.set(window.document, registry)
-  }
-  return registry
-}
-function identity(
-  endpoint: string,
-  installation: ConsentInstallation,
-  registration?: CustomConsentRegistration,
-): Identity {
-  return {
-    endpoint,
-    provider: installation.provider,
-    source: installation.scriptURL ?? '',
-    ...(installation.provider === 'custom'
-      ? registration?.adapter
-        ? { adapter: registration.adapter }
-        : { owner: registration, reopen: registration?.openPreferences }
-      : {}),
-  }
-}
-function same(a: Identity, b: Identity) {
-  return (
-    a.endpoint === b.endpoint &&
-    a.provider === b.provider &&
-    a.source === b.source &&
-    a.adapter === b.adapter &&
-    a.owner === b.owner &&
-    a.reopen === b.reopen
-  )
-}
-function validRegistration(registration?: CustomConsentRegistration) {
-  if (!registration) return false
-  if (registration.adapter !== undefined)
-    return (
-      registration.openPreferences === undefined &&
-      !!registration.adapter &&
-      ['read', 'subscribe', 'openPreferences'].every(
-        (key) => typeof registration.adapter?.[key as keyof ConsentAdapter] === 'function',
-      )
-    )
-  return typeof registration.openPreferences === 'function'
-}
-function createRegistry(window: Window) {
-  const driver = createBrowserConsentDriver(window)
-  const loader = createConsentLoader(driver)
-  const listeners = new Set<() => void>()
-  const owners = new Set<object>()
-  let endpoint: string | undefined
-  let enabled = false
-  let installation: ConsentInstallation | undefined
-  let registration: CustomConsentRegistration | undefined
-  let installed: Identity | undefined
-  let adapter: ConsentAdapter | undefined
-  let unsubscribe: (() => void) | undefined
-  let generation = 0
-  let activated = false
-  let attempted = false
-  let script: HTMLScriptElement | undefined
-  let providerFailed = false
-  let providerError: string | null = null
-  let timer: number | undefined
-  let loadTimer: number | undefined
-  let raw = deniedConsentState()
-  let snapshot: Snapshot = { state: raw, ready: false, error: null, reloadRequired: false }
-  const clearTimer = () => {
-    if (timer !== undefined) window.clearTimeout(timer)
-    timer = undefined
-  }
-  // Embedding a banner does not make it a consent authority for U90-managed scripts.
-  const embedOnly = () => installation?.provider === 'custom' && registration === undefined
-  const registrationComplete = () =>
-    installation?.provider !== 'custom' || validRegistration(registration)
-  const effective = () =>
-    enabled && owners.size === 1 && !!unsubscribe && !providerFailed && registrationComplete()
-      ? raw
-      : deniedConsentState()
-  const publish = () => {
-    const state = effective()
-    const status = consentLoaderStatus(driver)
-    const next = {
-      state: { ...state },
-      ready: state.ready,
-      error: status.reloadRequired
-        ? status.error
-        : !registrationComplete() && !embedOnly() && enabled
-          ? 'Custom consent registration is incomplete. Supply one adapter or a preferences callback.'
-          : (providerError ?? status.error),
-      reloadRequired: status.reloadRequired,
-    }
-    if (JSON.stringify(next) !== JSON.stringify(snapshot)) {
-      snapshot = next
-      for (const listener of listeners) listener()
-    }
-  }
-  observeConsentLoader(driver, () => {
-    if (consentLoaderStatus(driver).reloadRequired)
-      driver.setPermission(deniedConsentState(), installation?.googleMode ?? 'basic')
-    publish()
-  })
-  const reconcile = () => {
-    const state = effective()
-    const mode = installation?.googleMode ?? 'basic'
-    const blocked = consentLoaderStatus(driver).reloadRequired
-    driver.configure(installation?.integrations ?? [])
-    driver.setPermission(blocked ? deniedConsentState() : state, mode)
-    // Advanced mode is a request exception only for classified Google code. Generic rows stay category-gated.
-    const advanced = !blocked && state.ready && mode === 'advanced'
-    const integrations = installation?.integrations ?? []
-    const selected = advanced
-      ? integrations.filter(
-          (row) => state[row.category] || classifyManagedIntegration(row).kind === 'ga4',
-        )
-      : integrations
-    void loader.apply(advanced ? { ...state, analytics: true } : state, selected).catch(() => {
-      publish()
-    })
-    publish()
-  }
-  const receive = (value: unknown) => {
-    const parsed = ConsentStateSchema.safeParse(value)
-    raw = parsed.success ? parsed.data : deniedConsentState()
-    providerError = raw.ready ? null : 'Consent preferences are unavailable. Retry consent setup.'
-    if (raw.ready) clearTimer()
-    reconcile()
-  }
-  const readAdapter = () => {
-    if (!adapter) {
-      reconcile()
-      return
-    }
-    try {
-      receive(adapter?.read())
-    } catch {
-      receive(undefined)
-    }
-  }
-  const disconnect = () => {
-    ++generation
-    try {
-      unsubscribe?.()
-    } catch {
-      /* authority is already invalid */
-    }
-    unsubscribe = undefined
-    clearTimer()
-    raw = deniedConsentState()
-  }
-  const subscribe = () => {
-    if (!adapter || unsubscribe) return
-    const current = ++generation
-    try {
-      unsubscribe = adapter.subscribe((value) => {
-        if (current === generation && owners.size === 1 && !providerFailed) receive(value)
-      })
-      if (typeof unsubscribe !== 'function') throw Error('Subscription unavailable')
-      activated = true
-      readAdapter()
-    } catch {
-      providerFailed = true
-      providerError = 'Consent subscription unavailable. Retry consent setup.'
-      reconcile()
-    }
-  }
-  const watchReadiness = () => {
-    clearTimer()
-    if (!raw.ready)
-      timer = window.setTimeout(() => {
-        raw = deniedConsentState()
-        providerError = 'Consent provider did not become ready. Retry consent setup.'
-        reconcile()
-      }, CONSENT_LOAD_TIMEOUT_MS)
-  }
-  const install = () => {
-    if (
-      !installation ||
-      !enabled ||
-      providerFailed ||
-      (!registrationComplete() && !embedOnly()) ||
-      owners.size !== 1 ||
-      consentLoaderStatus(driver).reloadRequired
-    )
-      return
-    if (!adapter && !embedOnly()) {
-      if (installation.provider === 'cookiescript') {
-        if ((window as Window & { CookieScript?: unknown }).CookieScript !== undefined) {
-          providerFailed = true
-          providerError =
-            'CookieScript ownership conflicts with an already installed provider. Correct setup and reload.'
-          reconcile()
-          return
-        }
-        adapter = cookieScriptAdapter(window)
-      } else {
-        if (!validRegistration(registration)) {
-          providerError =
-            'Custom consent registration is incomplete. Supply one adapter or a preferences callback.'
-          reconcile()
-          return
-        }
-        adapter = customConsentAdapter(window, registration)
-      }
-    }
-    const wasSubscribed = !!unsubscribe
-    subscribe() // subscription and immediate read precede insertion
-    if (providerFailed) return
-    if (!attempted) {
-      script = window.document.createElement('script')
-      script.async = true
-      script.src = installation.scriptURL!
-      script.dataset.u90ConsentProvider = installation.provider
-      const ownedScript = script
-      loadTimer = window.setTimeout(() => {
-        if (script !== ownedScript) return
-        providerFailed = true
-        raw = deniedConsentState()
-        providerError = 'Consent provider load timed out. Reload after checking setup.'
-        requireConsentReload(driver, providerError)
-        reconcile()
-      }, CONSENT_LOAD_TIMEOUT_MS)
-      script.onload = () => {
-        if (script !== ownedScript) return
-        window.clearTimeout(loadTimer)
-        loadTimer = undefined
-        if (!providerFailed && adapter) {
-          readAdapter()
-          watchReadiness()
-        }
-      }
-      script.onerror = () => {
-        if (script !== ownedScript) return
-        window.clearTimeout(loadTimer)
-        loadTimer = undefined
-        providerFailed = true
-        providerError = 'Consent provider failed to load. Retry consent setup.'
-        raw = deniedConsentState()
-        script?.remove()
-        script = undefined
-        clearTimer()
-        reconcile()
-      }
-      attempted = true
-      window.document.head.appendChild(script)
-    }
-    if (adapter && !wasSubscribed) watchReadiness()
-  }
-  return {
-    read: () => snapshot,
-    subscribe(listener: () => void) {
-      listeners.add(listener)
-      return () => {
-        listeners.delete(listener)
-      }
-    },
-    attach(owner: object) {
-      owners.add(owner)
-      driver.suspend(true)
-    },
-    detach(owner: object) {
-      owners.delete(owner)
-      driver.suspend(true)
-      // StrictMode's same-turn replay retains installation; a lasting owner loss revokes.
-      queueMicrotask(() => {
-        if (owners.size === 0) {
-          disconnect()
-          reconcile()
-        }
-      })
-    },
-    commit(
-      owner: object,
-      nextEndpoint: string,
-      nextEnabled: boolean,
-      input?: ConsentInstallation,
-      custom?: CustomConsentRegistration,
-    ) {
-      if (!owners.has(owner)) return
-      const parsed = input === undefined ? null : ConsentInstallationSchema.safeParse(input)
-      const next = parsed?.success ? parsed.data : undefined
-      if (endpoint !== undefined && endpoint !== nextEndpoint) {
-        disconnect()
-        enabled = false
-        reconcile()
-        if (activated || attempted || driver.attempted())
-          requireConsentReload(
-            driver,
-            'Reload to apply consent changes. The site consent authority changed.',
-          )
-        else {
-          adapter = undefined
-          installed = undefined
-        }
-      }
-      endpoint = nextEndpoint
-      if (next && installation?.googleMode !== next.googleMode && driver.googleAttempted())
-        requireConsentReload(
-          driver,
-          'Reload to apply consent changes. Google consent mode changed.',
-        )
-      installation = next
-      registration = custom
-      enabled = !!nextEnabled && !!next && next.provider !== 'none'
-      driver.suspend(owners.size !== 1)
-      if (enabled) {
-        const nextIdentity = identity(nextEndpoint, next!, custom)
-        if (installed && !same(installed, nextIdentity)) {
-          disconnect()
-          providerFailed = true
-          if (activated || attempted)
-            requireConsentReload(
-              driver,
-              'Reload to apply consent changes. The consent provider or registration changed.',
-            )
-          else {
-            adapter = undefined
-            installed = undefined
-            providerFailed = false
-          }
-        }
-        if (!installed) installed = nextIdentity
-        if (!consentLoaderStatus(driver).reloadRequired) install()
-      }
-      if (!enabled) {
-        raw = deniedConsentState()
-        providerError = parsed && !parsed.success ? 'Consent installation is invalid.' : null
-      }
-      driver.suspend(owners.size !== 1)
-      if (enabled && !providerFailed && unsubscribe) readAdapter()
-      else reconcile()
-    },
-    page(path: string) {
-      driver.page(path)
-    },
-    openPreferences() {
-      // Existing CMP controls remain necessary UI even after disable or reload latch.
-      try {
-        if (!adapter || !ConsentStateSchema.parse(adapter.read()).ready || providerFailed)
-          throw Error('unavailable')
-        adapter.openPreferences()
-        readAdapter()
-      } catch {
-        raw = deniedConsentState()
-        providerError = 'Cookie preferences are unavailable. Retry consent setup.'
-        reconcile()
-      }
-    },
-    retry() {
-      if (consentLoaderStatus(driver).reloadRequired) return
-      if (enabled && (providerFailed || !raw.ready)) {
-        // A wrapper may have caught subscribe() failure while still returning cleanup.
-        // Retry that same authority from a fresh subscription, retaining its installation.
-        disconnect()
-      }
-      if (providerFailed && attempted && !script) attempted = false
-      providerFailed = false
-      providerError = null
-      install()
-      readAdapter()
-    },
-  }
-}