c15t 0.0.1-rc.3

package/dist/store.cjs

@@ -0,0 +1,248 @@
+'use strict';
+var __webpack_require__ = {};
+(() => {
+	__webpack_require__.d = function (exports1, definition) {
+		for (var key in definition)
+			if (
+				__webpack_require__.o(definition, key) &&
+				!__webpack_require__.o(exports1, key)
+			)
+				Object.defineProperty(exports1, key, {
+					enumerable: true,
+					get: definition[key],
+				});
+	};
+})();
+(() => {
+	__webpack_require__.o = function (obj, prop) {
+		return Object.prototype.hasOwnProperty.call(obj, prop);
+	};
+})();
+(() => {
+	__webpack_require__.r = function (exports1) {
+		if ('undefined' != typeof Symbol && Symbol.toStringTag)
+			Object.defineProperty(exports1, Symbol.toStringTag, {
+				value: 'Module',
+			});
+		Object.defineProperty(exports1, '__esModule', {
+			value: true,
+		});
+	};
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+	createConsentManagerStore: () => createConsentManagerStore,
+	default: () => store_rslib_entry_,
+});
+const vanilla_namespaceObject = require('zustand/vanilla');
+const consent_utils_cjs_namespaceObject = require('./libs/consent-utils.cjs');
+const tracking_blocker_cjs_namespaceObject = require('./libs/tracking-blocker.cjs');
+const external_store_initial_state_cjs_namespaceObject = require('./store.initial-state.cjs');
+const index_cjs_namespaceObject = require('./types/index.cjs');
+const STORAGE_KEY = 'privacy-consent-storage';
+const getStoredConsent = () => {
+	if ('undefined' == typeof window) return null;
+	const stored = localStorage.getItem(STORAGE_KEY);
+	if (!stored) return null;
+	try {
+		return JSON.parse(stored);
+	} catch (e) {
+		console.error('Failed to parse stored consent:', e);
+		return null;
+	}
+};
+const createConsentManagerStore = (namespace = 'c15tStore', config) => {
+	const storedConsent = getStoredConsent();
+	const trackingBlocker =
+		'undefined' != typeof window
+			? (0, tracking_blocker_cjs_namespaceObject.createTrackingBlocker)(
+					config?.trackingBlockerConfig || {},
+					storedConsent?.consents ||
+						external_store_initial_state_cjs_namespaceObject.initialState
+							.consents
+				)
+			: null;
+	const store = (0, vanilla_namespaceObject.createStore)((set, get) => ({
+		...external_store_initial_state_cjs_namespaceObject.initialState,
+		...(storedConsent
+			? {
+					consents: storedConsent.consents,
+					consentInfo: storedConsent.consentInfo,
+					showPopup: false,
+				}
+			: {
+					showPopup: true,
+				}),
+		setConsent: (name, value) => {
+			set((state) => {
+				const consentType = state.consentTypes.find(
+					(type) => type.name === name
+				);
+				if (consentType?.disabled) return state;
+				const newConsents = {
+					...state.consents,
+					[name]: value,
+				};
+				trackingBlocker?.updateConsents(newConsents);
+				return {
+					consents: newConsents,
+				};
+			});
+			get().updateConsentMode();
+		},
+		setShowPopup: (show, force = false) => {
+			const state = get();
+			const storedConsent = getStoredConsent();
+			if (force || (!storedConsent && !state.consentInfo && show))
+				set({
+					showPopup: show,
+				});
+		},
+		setIsPrivacyDialogOpen: (isOpen) => {
+			set({
+				isPrivacyDialogOpen: isOpen,
+			});
+		},
+		saveConsents: (type) => {
+			const {
+				callbacks,
+				updateConsentMode,
+				consents,
+				consentTypes,
+				includeNonDisplayedConsents,
+			} = get();
+			const newConsents = {
+				...consents,
+			};
+			if ('all' === type)
+				for (const consent of consentTypes) newConsents[consent.name] = true;
+			else if ('necessary' === type)
+				for (const consent of consentTypes)
+					newConsents[consent.name] = 'necessary' === consent.name;
+			const consentInfo = {
+				time: Date.now(),
+				type: type,
+			};
+			localStorage.setItem(
+				STORAGE_KEY,
+				JSON.stringify({
+					consents: newConsents,
+					consentInfo,
+				})
+			);
+			trackingBlocker?.updateConsents(newConsents);
+			set({
+				consents: newConsents,
+				showPopup: false,
+				consentInfo,
+			});
+			updateConsentMode();
+			callbacks.onConsentGiven?.();
+			callbacks.onPreferenceExpressed?.();
+		},
+		resetConsents: () => {
+			set((state) => {
+				const resetState = {
+					consents: index_cjs_namespaceObject.consentTypes.reduce(
+						(acc, consent) => {
+							acc[consent.name] = consent.defaultValue;
+							return acc;
+						},
+						{}
+					),
+					consentInfo: null,
+				};
+				localStorage.removeItem(STORAGE_KEY);
+				return resetState;
+			});
+		},
+		setGdprTypes: (types) =>
+			set({
+				gdprTypes: types,
+			}),
+		setComplianceSetting: (region, settings) =>
+			set((state) => ({
+				complianceSettings: {
+					...state.complianceSettings,
+					[region]: {
+						...state.complianceSettings[region],
+						...settings,
+					},
+				},
+			})),
+		resetComplianceSettings: () =>
+			set({
+				complianceSettings:
+					external_store_initial_state_cjs_namespaceObject.initialState
+						.complianceSettings,
+			}),
+		setCallback: (name, callback) =>
+			set((state) => ({
+				callbacks: {
+					...state.callbacks,
+					[name]: callback,
+				},
+			})),
+		setDetectedCountry: (country) =>
+			set({
+				detectedCountry: country,
+			}),
+		getDisplayedConsents: () => {
+			const { gdprTypes, consentTypes } = get();
+			return consentTypes.filter((consent) => gdprTypes.includes(consent.name));
+		},
+		hasConsented: () => {
+			const { consentInfo } = get();
+			return (0, consent_utils_cjs_namespaceObject.hasConsented)(consentInfo);
+		},
+		clearAllData: () => {
+			set(external_store_initial_state_cjs_namespaceObject.initialState);
+			localStorage.removeItem(STORAGE_KEY);
+		},
+		updateConsentMode: () => {
+			get().getEffectiveConsents();
+		},
+		setPrivacySettings: (settings) =>
+			set((state) => ({
+				privacySettings: {
+					...state.privacySettings,
+					...settings,
+				},
+			})),
+		getEffectiveConsents: () => {
+			const { consents, privacySettings } = get();
+			return (0, consent_utils_cjs_namespaceObject.getEffectiveConsents)(
+				consents,
+				privacySettings.honorDoNotTrack
+			);
+		},
+		hasConsentFor: (consentType) => {
+			const { consents, privacySettings } = get();
+			return (0, consent_utils_cjs_namespaceObject.hasConsentFor)(
+				consentType,
+				consents,
+				privacySettings.honorDoNotTrack
+			);
+		},
+		setIncludeNonDisplayedConsents: (include) =>
+			set({
+				includeNonDisplayedConsents: include,
+			}),
+		setTranslationConfig: (config) => {
+			set({
+				translationConfig: config,
+			});
+		},
+	}));
+	if ('undefined' != typeof window) window[namespace] = store;
+	return store;
+};
+const store_rslib_entry_ = createConsentManagerStore;
+var __webpack_export_target__ = exports;
+for (var __webpack_i__ in __webpack_exports__)
+	__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule)
+	Object.defineProperty(__webpack_export_target__, '__esModule', {
+		value: true,
+	});

package/dist/store.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @packageDocumentation
+ * Implements the core consent management store using Zustand.
+ * This module provides the main store creation and management functionality.
+ */
+import type { TrackingBlockerConfig } from './libs/tracking-blocker';
+import type { PrivacyConsentState } from './store.type';
+interface StoreConfig {
+	trackingBlockerConfig?: TrackingBlockerConfig;
+}
+/**
+ * Creates a new consent manager store instance.
+ *
+ * @remarks
+ * This function initializes a new consent management store with:
+ * - Persistence through localStorage
+ * - Initial state handling
+ * - Consent management methods
+ * - Privacy settings
+ * - Compliance configuration
+ *
+ * The store is typically used through React hooks but can also be
+ * accessed directly for non-React applications.
+ *
+ * @param namespace - Optional namespace for the store instance
+ * @returns A Zustand store instance with consent management functionality
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const store = createConsentManagerStore();
+ *
+ * // Subscribe to state changes
+ * const unsubscribe = store.subscribe(
+ *   state => console.log('Consent updated:', state.consents)
+ * );
+ *
+ * // Update consent
+ * store.getState().setConsent('analytics', true);
+ * ```
+ *
+ * @example
+ * Custom namespace:
+ * ```typescript
+ * const store = createConsentManagerStore('MyApp');
+ *
+ * // Access from window
+ * const state = window.MyApp.getState();
+ * ```
+ *
+ * @public
+ */
+export declare const createConsentManagerStore: (
+	namespace?: string | undefined,
+	config?: StoreConfig
+) => import('zustand/vanilla').StoreApi<PrivacyConsentState>;
+export default createConsentManagerStore;
+//# sourceMappingURL=store.d.ts.map

package/dist/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAErE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAoDxD,UAAU,WAAW;IACpB,qBAAqB,CAAC,EAAE,qBAAqB,CAAC;CAC9C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,yBAAyB,eAC1B,MAAM,GAAG,SAAS,WACpB,WAAW,4DA4UpB,CAAC;AAEF,eAAe,yBAAyB,CAAC"}

package/dist/store.initial-state.cjs

@@ -0,0 +1,105 @@
+'use strict';
+var __webpack_require__ = {};
+(() => {
+	__webpack_require__.d = function (exports1, definition) {
+		for (var key in definition)
+			if (
+				__webpack_require__.o(definition, key) &&
+				!__webpack_require__.o(exports1, key)
+			)
+				Object.defineProperty(exports1, key, {
+					enumerable: true,
+					get: definition[key],
+				});
+	};
+})();
+(() => {
+	__webpack_require__.o = function (obj, prop) {
+		return Object.prototype.hasOwnProperty.call(obj, prop);
+	};
+})();
+(() => {
+	__webpack_require__.r = function (exports1) {
+		if ('undefined' != typeof Symbol && Symbol.toStringTag)
+			Object.defineProperty(exports1, Symbol.toStringTag, {
+				value: 'Module',
+			});
+		Object.defineProperty(exports1, '__esModule', {
+			value: true,
+		});
+	};
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+	initialState: () => initialState,
+});
+const index_cjs_namespaceObject = require('./translations/index.cjs');
+const external_types_index_cjs_namespaceObject = require('./types/index.cjs');
+const initialState = {
+	consents: external_types_index_cjs_namespaceObject.consentTypes.reduce(
+		(acc, consent) => {
+			acc[consent.name] = consent.defaultValue;
+			return acc;
+		},
+		{}
+	),
+	consentInfo: null,
+	showPopup: true,
+	gdprTypes: ['necessary', 'marketing'],
+	isPrivacyDialogOpen: false,
+	complianceSettings: {
+		gdpr: {
+			enabled: true,
+			appliesGlobally: true,
+			applies: true,
+		},
+		ccpa: {
+			enabled: true,
+			appliesGlobally: false,
+			applies: void 0,
+		},
+		lgpd: {
+			enabled: false,
+			appliesGlobally: false,
+			applies: void 0,
+		},
+		usStatePrivacy: {
+			enabled: true,
+			appliesGlobally: false,
+			applies: void 0,
+		},
+	},
+	callbacks: {},
+	detectedCountry: 'US',
+	privacySettings: {
+		honorDoNotTrack: true,
+	},
+	translationConfig: index_cjs_namespaceObject.defaultTranslationConfig,
+	includeNonDisplayedConsents: false,
+	consentTypes: external_types_index_cjs_namespaceObject.consentTypes,
+	setConsent: () => {},
+	setShowPopup: () => {},
+	setIsPrivacyDialogOpen: () => {},
+	saveConsents: () => {},
+	resetConsents: () => {},
+	setGdprTypes: () => {},
+	setComplianceSetting: () => {},
+	resetComplianceSettings: () => {},
+	setCallback: () => {},
+	setDetectedCountry: () => {},
+	getDisplayedConsents: () => [],
+	hasConsented: () => false,
+	setTranslationConfig: () => {},
+	clearAllData: () => {},
+	updateConsentMode: () => {},
+	setPrivacySettings: () => {},
+	setIncludeNonDisplayedConsents: () => {},
+};
+var __webpack_export_target__ = exports;
+for (var __webpack_i__ in __webpack_exports__)
+	__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule)
+	Object.defineProperty(__webpack_export_target__, '__esModule', {
+		value: true,
+	});

package/dist/store.initial-state.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @packageDocumentation
+ * Provides the default initial state configuration for the consent management store.
+ */
+import type { PrivacyConsentState } from './store.type';
+/**
+ * Default initial state for the consent management store.
+ *
+ * @remarks
+ * This configuration establishes the baseline state for the consent manager,
+ * including default consent values, compliance settings, and privacy preferences.
+ *
+ * Notable defaults include:
+ * - All consents start with their type-specific default values
+ * - GDPR compliance is globally enabled
+ * - CCPA compliance is enabled for US users only
+ * - Do Not Track is respected by default
+ * - Only necessary and marketing consents are included in gdprTypes
+ *
+ * @example
+ * Using the initial state:
+ * ```typescript
+ * const store = createConsentManagerStore();
+ *
+ * // Reset to initial state
+ * store.setState(initialState);
+ *
+ * // Extend initial state
+ * const customState = {
+ *   ...initialState,
+ *   privacySettings: {
+ *     honorDoNotTrack: false
+ *   }
+ * };
+ * ```
+ *
+ * @public
+ */
+export declare const initialState: Omit<
+	PrivacyConsentState,
+	'getEffectiveConsents' | 'hasConsentFor'
+>;
+//# sourceMappingURL=store.initial-state.d.ts.map

package/dist/store.initial-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.initial-state.d.ts","sourceRoot":"","sources":["../src/store.initial-state.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAIxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,YAAY,EAAE,IAAI,CAC9B,mBAAmB,EACnB,sBAAsB,GAAG,eAAe,CA8ExC,CAAC"}

package/dist/store.initial-state.js

@@ -0,0 +1,66 @@
+import * as __WEBPACK_EXTERNAL_MODULE__translations_index_js_8dbce45e__ from './translations/index.js';
+import * as __WEBPACK_EXTERNAL_MODULE__types_index_js_63ede62f__ from './types/index.js';
+const initialState = {
+	consents:
+		__WEBPACK_EXTERNAL_MODULE__types_index_js_63ede62f__.consentTypes.reduce(
+			(acc, consent) => {
+				acc[consent.name] = consent.defaultValue;
+				return acc;
+			},
+			{}
+		),
+	consentInfo: null,
+	showPopup: true,
+	gdprTypes: ['necessary', 'marketing'],
+	isPrivacyDialogOpen: false,
+	complianceSettings: {
+		gdpr: {
+			enabled: true,
+			appliesGlobally: true,
+			applies: true,
+		},
+		ccpa: {
+			enabled: true,
+			appliesGlobally: false,
+			applies: void 0,
+		},
+		lgpd: {
+			enabled: false,
+			appliesGlobally: false,
+			applies: void 0,
+		},
+		usStatePrivacy: {
+			enabled: true,
+			appliesGlobally: false,
+			applies: void 0,
+		},
+	},
+	callbacks: {},
+	detectedCountry: 'US',
+	privacySettings: {
+		honorDoNotTrack: true,
+	},
+	translationConfig:
+		__WEBPACK_EXTERNAL_MODULE__translations_index_js_8dbce45e__.defaultTranslationConfig,
+	includeNonDisplayedConsents: false,
+	consentTypes:
+		__WEBPACK_EXTERNAL_MODULE__types_index_js_63ede62f__.consentTypes,
+	setConsent: () => {},
+	setShowPopup: () => {},
+	setIsPrivacyDialogOpen: () => {},
+	saveConsents: () => {},
+	resetConsents: () => {},
+	setGdprTypes: () => {},
+	setComplianceSetting: () => {},
+	resetComplianceSettings: () => {},
+	setCallback: () => {},
+	setDetectedCountry: () => {},
+	getDisplayedConsents: () => [],
+	hasConsented: () => false,
+	setTranslationConfig: () => {},
+	clearAllData: () => {},
+	updateConsentMode: () => {},
+	setPrivacySettings: () => {},
+	setIncludeNonDisplayedConsents: () => {},
+};
+export { initialState };