@pixelated-tech/components 3.13.15 → 3.14.0

package/dist/components/admin/site-health/google.api.integration.js

@@ -6,6 +6,7 @@
 "use server";
 import { google } from 'googleapis';
 import { CacheManager } from '../../general/cache-manager';
+import { getDomain } from '../../general/utilities';
 import { calculateDateRanges, formatChartDate, getCachedData, setCachedData } from './google.api.utils';
 // Migration-time debug flag (owner requested): verbose cache traces during migration
 const debug = false; // keep as literal during migration for traceability
@@ -72,8 +73,8 @@ export async function createSearchConsoleClient(config) {
         auth: result.auth
     };
 }
-// Cache for analytics data (1 hour)
-const analyticsCache = new CacheManager({ prefix: 'sitehealth-analytics-', ttl: 60 * 60 * 1000 });
+// Cache for analytics data (1 hour) — isolated per domain
+const analyticsCache = new CacheManager({ domain: getDomain(), namespace: 'analytics', ttl: 60 * 60 * 1000 });
 /**
  * Get Google Analytics data for a site with current/previous period comparison
  */
@@ -168,8 +169,8 @@ export async function getGoogleAnalyticsData(config, siteName, startDate, endDat
         };
     }
 }
-// Cache for search console data (1 hour)
-const searchConsoleCache = new CacheManager({ prefix: 'sitehealth-searchconsole-', ttl: 60 * 60 * 1000 });
+// Cache for search console data (1 hour) — isolated per domain
+const searchConsoleCache = new CacheManager({ domain: getDomain(), namespace: 'searchconsole', ttl: 60 * 60 * 1000 });
 /**
  * Get Google Search Console data for a site with current/previous period comparison
  */

package/dist/components/admin/site-health/site-health-cloudwatch.integration.js

@@ -5,10 +5,11 @@
 "use server";
 import { CloudWatchClient, GetMetricDataCommand } from '@aws-sdk/client-cloudwatch';
 import { CacheManager } from '../../general/cache-manager';
+import { getDomain } from '../../general/utilities';
 import { getFullPixelatedConfig } from '../../config/config';
 const debug = false; // migration-time verbose logging
-// Cache for health check data (15 minutes)
-const healthCheckCache = new CacheManager({ prefix: 'sitehealth-cloudwatch-', ttl: 15 * 60 * 1000 });
+// Cache for health check data (15 minutes) — isolated per domain
+const healthCheckCache = new CacheManager({ domain: getDomain(), namespace: 'cloudwatch', ttl: 15 * 60 * 1000 });
 /**
  * Get health check data for a site using CloudWatch metrics
  */

package/dist/components/config/crypto.js

@@ -56,7 +56,23 @@ export function decrypt(payload, keyHex) {
 }
 /**
  * Checks if a string is encrypted using our format.
+ * Validates that the string has the proper structure: pxl:v1:iv:authTag:encryptedContent
  */
 export function isEncrypted(text) {
-    return typeof text === 'string' && text.startsWith(ENCRYPTED_PREFIX);
+    if (typeof text !== 'string' || !text.startsWith(ENCRYPTED_PREFIX)) {
+        return false;
+    }
+    // Remove prefix and check that we have the expected structure (3 colon-separated parts)
+    const data = text.slice(ENCRYPTED_PREFIX.length);
+    const parts = data.split(':');
+    // Must have exactly 3 parts: iv, authTag, encryptedContent
+    if (parts.length !== 3) {
+        return false;
+    }
+    // Each part should be valid hex and have minimum length
+    // IV: 12 bytes = 24 hex chars, AuthTag: 16 bytes = 32 hex chars, Content: at least 1 byte = 2 hex chars
+    const [ivHex, authTagHex, encryptedHex] = parts;
+    return (ivHex.length === 24 && /^[0-9a-f]*$/i.test(ivHex) &&
+        authTagHex.length === 32 && /^[0-9a-f]*$/i.test(authTagHex) &&
+        encryptedHex.length > 0 && /^[0-9a-f]*$/i.test(encryptedHex));
 }

package/dist/components/general/cache-manager.js

@@ -3,6 +3,19 @@
  *
  * A unified caching utility that supports Memory, LocalStorage, and SessionStorage.
  * Includes TTL (Time-To-Live) support and automatic SSR fallback.
+ *
+ * ARCHITECTURE NOTE: The `domain` parameter is required to enforce clear namespace separation and
+ * provide future-proofing. While the library is currently deployed **per-domain** (each site gets
+ * its own isolated copy of this library), the domain parameter serves important purposes:
+ * 1. **Code Clarity**: Makes the multi-tenant intent explicit in code
+ * 2. **Future-Proofing**: If architecture changes to shared backends (Redis), isolation is built-in
+ * 3. **Safety**: Prevents accidental empty prefixes that could cause collisions
+ *
+ * Each domain runs in isolation:
+ * - Client-side: Uses window.location to determine domain (e.g., pixelvivid.com → "pixelvivid")
+ * - Server-side: Defaults to 'pixelated' (safe because server caches are in-memory per process)
+ * - Memory caches: Naturally isolated to their process, so multi-tenancy doesn't apply
+ * - Local/Session storage: Browser-based, inherently isolated by domain
  */
 export class CacheManager {
     memoryCache = new Map();
@@ -10,10 +23,14 @@ export class CacheManager {
     mode;
     prefix;
     ttl;
-    constructor(options = {}) {
+    constructor(options) {
         this.mode = options.mode || 'memory';
-        this.prefix = options.prefix || 'pix_';
         this.ttl = options.ttl || this.defaultTTL;
+        // Build prefix from domain + optional namespace
+        // domain + namespace pattern: "pixelvivid_cart_" or "sitehealth_analytics_"
+        this.prefix = options.namespace
+            ? `${options.domain}_${options.namespace}_`
+            : `${options.domain}_`;
         // Fallback to memory if browser storage is requested but unavailable (SSR/Node environment)
         if (typeof window === 'undefined' && (this.mode === 'local' || this.mode === 'session')) {
             this.mode = 'memory';

package/dist/components/general/carousel.drag.js

@@ -188,28 +188,25 @@ export function DragHandler(props) {
         }
     }
     ;
-    function handleEventListeners(activeIndex) {
-        useEffect(() => {
-            // const container = document.getElementById(classSelector);
-            // { passive: true } is needed for preventDefault to work on drag events
-            document.addEventListener('touchstart', dragStart, { capture: true, passive: false });
-            document.addEventListener('touchmove', draggable, { capture: true, passive: false });
-            document.addEventListener('touchend', dragEnd, { capture: true, passive: true });
-            document.addEventListener('mousedown', dragStart, { capture: true, passive: false });
-            document.addEventListener('mousemove', draggable, { capture: true, passive: false });
-            document.addEventListener('mouseup', dragEnd, { capture: true, passive: true });
-            document.addEventListener('transitionend', transitionEnd, { capture: true, passive: true });
-            return () => {
-                // { passive: true } is not needed to match and remove an event listener
-                document.removeEventListener('touchstart', dragStart, { capture: true });
-                document.removeEventListener('touchmove', draggable, { capture: true });
-                document.removeEventListener('touchend', dragEnd, { capture: true });
-                document.removeEventListener('mousedown', dragStart, { capture: true });
-                document.removeEventListener('mousemove', draggable, { capture: true });
-                document.removeEventListener('mouseup', dragEnd, { capture: true });
-                document.removeEventListener('transitionend', transitionEnd, { capture: true });
-            };
-        }, [activeIndex]);
-    }
-    handleEventListeners(props.activeIndex);
+    useEffect(() => {
+        // const container = document.getElementById(classSelector);
+        // { passive: true } is needed for preventDefault to work on drag events
+        document.addEventListener('touchstart', dragStart, { capture: true, passive: false });
+        document.addEventListener('touchmove', draggable, { capture: true, passive: false });
+        document.addEventListener('touchend', dragEnd, { capture: true, passive: true });
+        document.addEventListener('mousedown', dragStart, { capture: true, passive: false });
+        document.addEventListener('mousemove', draggable, { capture: true, passive: false });
+        document.addEventListener('mouseup', dragEnd, { capture: true, passive: true });
+        document.addEventListener('transitionend', transitionEnd, { capture: true, passive: true });
+        return () => {
+            // { passive: true } is not needed to match and remove an event listener
+            document.removeEventListener('touchstart', dragStart, { capture: true });
+            document.removeEventListener('touchmove', draggable, { capture: true });
+            document.removeEventListener('touchend', dragEnd, { capture: true });
+            document.removeEventListener('mousedown', dragStart, { capture: true });
+            document.removeEventListener('mousemove', draggable, { capture: true });
+            document.removeEventListener('mouseup', dragEnd, { capture: true });
+            document.removeEventListener('transitionend', transitionEnd, { capture: true });
+        };
+    }, [props.activeIndex]);
 }

package/dist/components/general/intersection-observer.js

@@ -99,6 +99,8 @@ export function observeIntersection(selector, callback, options = {}) {
  * Check if an element is fully in the viewport
  */
 export function isElementInViewport(element) {
+    if (!element)
+        return false;
     const rect = element.getBoundingClientRect();
     return (rect.top >= 0 &&
         rect.left >= 0 &&
@@ -109,6 +111,8 @@ export function isElementInViewport(element) {
  * Check if an element is partially in the viewport
  */
 export function isElementPartiallyInViewport(element) {
+    if (!element)
+        return false;
     const rect = element.getBoundingClientRect();
     return (rect.top < (window.innerHeight || document.documentElement.clientHeight) &&
         rect.left < (window.innerWidth || document.documentElement.clientWidth) &&

package/dist/components/general/metadata.functions.js

@@ -6,7 +6,7 @@ export function descriptionToKeywords(descriptionText, numKeywords = 5, customSt
     // Define a default list of common English stop words
     const defaultStopWords = new Set([
         'a', 'an', 'and', 'are', 'as', 'at', 'be', 'but', 'by', 'for', 'if', 'in', 'into',
-        'is', 'it', 'no', 'not', 'of', 'on', 'or', 'such', 'that', 'the', 'their',
+        'is', 'it', 'no', 'not', 'of', 'on', 'or', 'over', 'such', 'that', 'the', 'their',
         'then', 'there', 'these', 'they', 'this', 'to', 'was', 'will', 'with'
     ]);
     const allStopWords = new Set([...defaultStopWords, ...customStopWords]);

package/dist/components/general/sitemap.js

@@ -6,6 +6,7 @@ import { getContentfulFieldValues, getContentfulAssets } from "../integrations/c
 import { getEbayAppToken, getEbayItemsSearch } from "../shoppingcart/ebay.functions";
 import { getFullPixelatedConfig } from '../config/config';
 import { CacheManager } from '../general/cache-manager';
+import { getDomain } from './utilities';
 /**
  * Helper to construct an origin string from a Next-like headers() object or plain values.
  * Accepts an object with `get(key)` method, or `undefined` and falls back to localhost origin.
@@ -386,7 +387,7 @@ export async function createContentfulAssetURLs(props) {
                         url = `${props.origin}/${url}`;
                     return {
                         title: a.fields?.title || 'Untitled Video',
-                        thumbnail_loc: '/images/placeholder.png',
+                        thumbnail_loc: `${props.origin}/images/placeholder.png`,
                         description: a.fields?.description || 'No description available',
                         publication_date: a.sys?.createdAt || new Date().toISOString(),
                         content_loc: encode(url),
@@ -438,7 +439,7 @@ export async function createEbayItemURLs(origin) {
 }
 const SITEMAP_TTL = 24 * 60 * 60 * 1000; // one day
 const EBAY_SITE_SITEMAP_KEY = 'ebay_sitemap_items';
-const ebaySitemapCache = new CacheManager({ mode: 'memory', prefix: 'ebaySitemap_', ttl: SITEMAP_TTL });
+const ebaySitemapCache = new CacheManager({ mode: 'memory', domain: getDomain(), namespace: 'ebaySitemap', ttl: SITEMAP_TTL });
 function getEbayCacheTTL(configTTL) {
     if (typeof configTTL === 'number' && configTTL > 0) {
         return configTTL;

package/dist/components/general/utilities.js

@@ -64,6 +64,74 @@ Array.prototype.contains = function(obj) {
   return this.indexOf(obj) > -1;
 };
 */
+/**
+ * Get the domain name to use as a key component for CacheManager.
+ * Safe to call in browser contexts. For server-side, use getDomainFromHeaders() instead.
+ *
+ * Extracts the domain name from the current hostname to use as a cache/storage prefix.
+ * This ensures multi-tenant applications don't have key collisions across different domain instances.
+ *
+ * @returns Domain name suitable for multi-tenant cache isolation (lowercase, no special characters)
+ *
+ * @example
+ * const domain = getDomain();
+ * const cache = new CacheManager({
+ *   mode: 'local',
+ *   domain,
+ *   namespace: 'checkout'
+ * });
+ *
+ * @example
+ * // In different environments:
+ * // www.pixelvivid.com → "pixelvivid"
+ * // manningmetalworks.com → "manningmetalworks"
+ * // localhost → "pixelated" (development)
+ */
+export function getDomain() {
+    // Browser environment
+    if (typeof window !== 'undefined' && window.location?.hostname) {
+        return extractDomainName(window.location.hostname);
+    }
+    // SSR/Node environment - return safe fallback
+    // Library is deployed per-domain, so no actual multi-tenancy at library level
+    // Each domain runs its own isolated copy of this library
+    return 'pixelated';
+}
+/**
+ * Extract the domain name from a hostname string.
+ * Handles www prefixes and multi-level TLDs.
+ *
+ * @param hostname - The hostname (e.g., "www.example.com" or "example.com")
+ * @returns The domain name without www or TLD (lowercase)
+ *
+ * @example
+ * extractDomainName('www.pixelvivid.com') // → "pixelvivid"
+ * extractDomainName('manningmetalworks.com') // → "manningmetalworks"
+ * extractDomainName('localhost') // → "pixelated"
+ */
+export function extractDomainName(hostname) {
+    if (!hostname)
+        return 'pixelated';
+    // Normalize: lowercase, trim whitespace
+    const normalized = hostname.toLowerCase().trim();
+    // Handle localhost / 127.0.0.1 - use development prefix
+    if (normalized === 'localhost' || normalized === '127.0.0.1' || normalized.startsWith('localhost:')) {
+        return 'pixelated';
+    }
+    // Split by dots
+    const parts = normalized.split('.');
+    // Single label (rare but possible in development)
+    if (parts.length === 1) {
+        return parts[0];
+    }
+    // Two labels: domain.com → domain
+    if (parts.length === 2) {
+        return parts[0];
+    }
+    // Multiple labels: www.domain.com or subdomain.domain.com → domain
+    // Take the second-to-last part (the domain before the TLD)
+    return parts[parts.length - 2];
+}
 export function attributeMap(oldAttribute) {
     // https://reactjs.org/docs/dom-elements.html
     const attributes = {
@@ -203,3 +271,41 @@ export const SERVER_ONLY_PATTERNS = [
     //	/\bNextRequest\b/,
     //	/\bNextResponse\b/
 ];
+export function stringTo1337_v1(str) {
+    return str
+        .replace(/o/gi, '0')
+        // .replace(/i/gi, '1')
+        .replace(/l/gi, '1')
+        .replace(/r/gi, '2')
+        .replace(/e/gi, '3')
+        .replace(/a/gi, '4')
+        .replace(/s/gi, '5')
+        .replace(/g/gi, '6')
+        .replace(/t/gi, '7')
+        .replace(/b/gi, '8')
+        .replace(/g/gi, '9');
+}
+export function stringTo1337(str) {
+    //converts lowercase non consecutive, non number characters (and doublets) to leet speak numbers
+    const leetMap = {
+        'o': '0', 'l': '1', 'z': '2', 'e': '3',
+        'a': '4', 's': '5', 'b': '6', 't': '7',
+        'g': '9'
+    };
+    let result = '';
+    for (const char of str) {
+        const leet = leetMap[char];
+        const last = result.slice(-1);
+        const lastIsNumber = /[0-9]/.test(last);
+        // Convert if: 
+        // 1. There is a mapping 
+        // 2. AND (the last char isn't a leet number OR it's matches for a doublet)
+        if (leet && (!lastIsNumber || last === leet)) {
+            result += leet;
+        }
+        else {
+            result += char;
+        }
+    }
+    return result;
+}

package/dist/components/integrations/contentful.delivery.js

@@ -114,10 +114,10 @@ getContentfulContentType.propTypes = {
     /** Contentful API configuration */
     apiProps: PropTypes.shape({
         proxyURL: PropTypes.string,
-        base_url: PropTypes.string.isRequired,
-        space_id: PropTypes.string.isRequired,
-        environment: PropTypes.string.isRequired,
-        access_token: PropTypes.string.isRequired,
+        base_url: PropTypes.string,
+        space_id: PropTypes.string,
+        environment: PropTypes.string,
+        access_token: PropTypes.string,
     }).isRequired,
     /** Content type ID to retrieve */
     contentType: PropTypes.string.isRequired,
@@ -142,10 +142,10 @@ getContentfulEntryByEntryID.propTypes = {
     /** Contentful API configuration */
     apiProps: PropTypes.shape({
         proxyURL: PropTypes.string,
-        base_url: PropTypes.string.isRequired,
-        space_id: PropTypes.string.isRequired,
-        environment: PropTypes.string.isRequired,
-        delivery_access_token: PropTypes.string.isRequired,
+        base_url: PropTypes.string,
+        space_id: PropTypes.string,
+        environment: PropTypes.string,
+        delivery_access_token: PropTypes.string,
     }).isRequired,
     /** Target entry ID */
     entry_id: PropTypes.string.isRequired,
@@ -239,10 +239,10 @@ getContentfulAssets.propTypes = {
     /** Contentful API configuration */
     apiProps: PropTypes.shape({
         proxyURL: PropTypes.string,
-        base_url: PropTypes.string.isRequired,
-        space_id: PropTypes.string.isRequired,
-        environment: PropTypes.string.isRequired,
-        access_token: PropTypes.string.isRequired,
+        base_url: PropTypes.string,
+        space_id: PropTypes.string,
+        environment: PropTypes.string,
+        access_token: PropTypes.string,
     }).isRequired,
 };
 export async function getContentfulAssets(props) {
@@ -263,10 +263,10 @@ getContentfulAssetURLs.propTypes = {
     /** Contentful API configuration */
     apiProps: PropTypes.shape({
         proxyURL: PropTypes.string,
-        base_url: PropTypes.string.isRequired,
-        space_id: PropTypes.string.isRequired,
-        environment: PropTypes.string.isRequired,
-        access_token: PropTypes.string.isRequired,
+        base_url: PropTypes.string,
+        space_id: PropTypes.string,
+        environment: PropTypes.string,
+        access_token: PropTypes.string,
     }).isRequired,
 };
 export async function getContentfulAssetURLs(props) {

package/dist/components/integrations/contentful.items.components.js

@@ -13,15 +13,6 @@ import { SmartImage } from "../general/smartimage";
 import "../../css/pixelated.grid.scss";
 import "./contentful.items.css";
 const debug = false;
-let ContentfulApiProps = {
-    proxyURL: 'https://proxy.pixelated.tech/prod/proxy?url=',
-    base_url: "https://cdn.contentful.com",
-    space_id: "soi9w77t7027",
-    environment: "master",
-    management_access_token: "",
-    delivery_access_token: "muY9LfpCt4qoXosDsnRkkoH3DAVVuUFEuB0WRKRdBUM",
-    preview_access_token: "",
-};
 const contentfulContentType = "item";
 /* ========== CONTENTFUL ITEMS PAGE ========== */
 /**
@@ -50,7 +41,7 @@ export function ContentfulItems(props) {
         if ((providerContentful as any).proxyURL) localContentfulApiProps.proxyURL = (providerContentful as any).proxyURL;
     } */
     const providerContentfulApiProps = usePixelatedConfig()?.contentful;
-    const mergedApiProps = { ...ContentfulApiProps, ...providerContentfulApiProps, ...props.apiProps, };
+    const mergedApiProps = { ...providerContentfulApiProps, ...props.apiProps };
     const [apiProps] = useState(mergedApiProps);
     /**
      * paintItems — Convert Contentful API items and assets into rendered list nodes.
@@ -204,7 +195,7 @@ export function ContentfulItemDetail(props) {
     const [assets, setAssets] = useState({});
     const [cards, setCards] = useState([]);
     const providerContentfulApiProps = usePixelatedConfig()?.contentful;
-    const [apiProps] = useState({ ...ContentfulApiProps, ...providerContentfulApiProps, ...props.apiProps });
+    const [apiProps] = useState({ ...providerContentfulApiProps, ...props.apiProps });
     useEffect(() => {
         if (debug)
             console.log("Running useEffect");

package/dist/components/integrations/flickr.js

@@ -1,12 +1,15 @@
 import PropTypes from 'prop-types';
 import { mergeDeep } from '../general/utilities';
+// Flickr API base URL - non-secret configuration
+const FLICKR_API_BASE_URL = 'https://api.flickr.com/services/rest/?';
 const defaultFlickr = {
     flickr: {
-        baseURL: 'https://api.flickr.com/services/rest/?',
+        baseURL: FLICKR_API_BASE_URL,
         urlProps: {
             method: 'flickr.photos.search',
-            api_key: '882cab5548d53c9e6b5fb24d59cc321d',
-            user_id: '15473210@N04',
+            // api_key and user_id must come from props or config provider - do not hardcode
+            api_key: '',
+            user_id: '',
             tags: 'pixelatedviewsgallery',
             extras: 'date_taken,description,owner_name',
             sort: 'date-taken-desc',
@@ -168,7 +171,7 @@ FlickrWrapper.propTypes = {
 export function FlickrWrapper(props) {
     const flickr = {
         flickr: {
-            baseURL: 'https://api.flickr.com/services/rest/?',
+            baseURL: FLICKR_API_BASE_URL,
             urlProps: {
                 method: props.method || 'flickr.photos.search',
                 api_key: props.api_key /* || '882cab5548d53c9e6b5fb24d59cc321d' */,

package/dist/components/integrations/googleplaces.js

@@ -0,0 +1,144 @@
+/**
+ * Google Places API Integration
+ * Handles autocomplete predictions and place details for address validation
+ */
+/**
+ * GooglePlacesService — Thin service for Google Places API interactions using googleapis
+ */
+export class GooglePlacesService {
+    apiKey = null;
+    sessionToken = null;
+    requestCache = new Map();
+    cacheTTL = 3600000; // 1 hour default
+    constructor(config) {
+        if (config) {
+            this.apiKey = config.apiKey || null;
+            this.cacheTTL = config.cacheTTL || 3600000;
+        }
+        this.sessionToken = this.generateSessionToken();
+    }
+    /**
+     * Generate or return cached session token for Places requests
+     */
+    generateSessionToken() {
+        return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * Get autocomplete predictions for a search input
+     * Uses Google Places Autocomplete API (web service version via googleapis)
+     */
+    async getPlacePredictions(input, config) {
+        if (!input || input.length < 2)
+            return [];
+        const cacheKey = `predictions_${input}`;
+        const cached = this.requestCache.get(cacheKey);
+        if (cached)
+            return cached;
+        try {
+            const apiKey = config?.googlePlaces?.apiKey || this.apiKey;
+            if (!apiKey) {
+                console.error('Google Places API key not configured');
+                return [];
+            }
+            const restrictions = config?.googlePlaces?.countryRestrictions || ['us'];
+            const componentFilter = restrictions.length > 0 ? `components=country:${restrictions.join('|country:')}` : '';
+            const apiUrl = `https://maps.googleapis.com/maps/api/place/autocomplete/json?input=${encodeURIComponent(input)}&key=${apiKey}&sessiontoken=${this.sessionToken}&${componentFilter}`;
+            // Use global proxy to avoid CORS issues
+            const proxyURL = config?.global?.proxyUrl || '';
+            const url = proxyURL ? `${proxyURL}${encodeURIComponent(apiUrl)}` : apiUrl;
+            const response = await fetch(url);
+            const data = await response.json();
+            if (!data.predictions) {
+                return [];
+            }
+            const predictions = data.predictions.map((pred) => ({
+                placeId: pred.place_id,
+                mainText: pred.structured_formatting?.main_text || pred.description,
+                secondaryText: pred.structured_formatting?.secondary_text,
+                fullText: pred.description,
+            }));
+            // Cache for TTL
+            this.requestCache.set(cacheKey, predictions);
+            setTimeout(() => this.requestCache.delete(cacheKey), this.cacheTTL);
+            return predictions;
+        }
+        catch (error) {
+            console.error('Error fetching place predictions:', error);
+            return [];
+        }
+    }
+    /**
+     * Get detailed place information including address components
+     */
+    async getPlaceDetails(placeId, config) {
+        try {
+            const apiKey = config?.googlePlaces?.apiKey || this.apiKey;
+            if (!apiKey) {
+                console.error('Google Places API key not configured');
+                return null;
+            }
+            const apiUrl = `https://maps.googleapis.com/maps/api/place/details/json?place_id=${placeId}&key=${apiKey}&fields=address_component,formatted_address&sessiontoken=${this.sessionToken}`;
+            // Use global proxy to avoid CORS issues
+            const proxyURL = config?.global?.proxyUrl || '';
+            const url = proxyURL ? `${proxyURL}${encodeURIComponent(apiUrl)}` : apiUrl;
+            const response = await fetch(url);
+            const data = await response.json();
+            if (!data.result)
+                return null;
+            const result = data.result;
+            const addressComponents = result.address_components || [];
+            // Parse address components
+            const parsed = {
+                formattedAddress: result.formatted_address || '',
+                addressComponents: addressComponents,
+            };
+            // Extract standard address fields
+            for (const component of addressComponents) {
+                const types = component.types || [];
+                if (types.includes('street_number') || types.includes('route')) {
+                    parsed.street1 = (parsed.street1 || '') + (component.long_name || '') + ' ';
+                }
+                else if (types.includes('locality')) {
+                    parsed.city = component.long_name;
+                }
+                else if (types.includes('administrative_area_level_1')) {
+                    parsed.state = component.short_name;
+                }
+                else if (types.includes('postal_code')) {
+                    parsed.zip = component.long_name;
+                }
+                else if (types.includes('country')) {
+                    parsed.country = component.short_name;
+                }
+            }
+            if (parsed.street1) {
+                parsed.street1 = parsed.street1.trim();
+            }
+            return parsed;
+        }
+        catch (error) {
+            console.error('Error fetching place details:', error);
+            return null;
+        }
+    }
+    /**
+     * Validate that address is in allowed country
+     */
+    isValidCountry(placeDetails, allowedCountries = ['US']) {
+        if (!placeDetails.country)
+            return false;
+        return allowedCountries.includes(placeDetails.country.toUpperCase());
+    }
+    /**
+     * Clear cached predictions
+     */
+    clearCache() {
+        this.requestCache.clear();
+    }
+}
+/**
+ * Factory function to get configured GooglePlacesService instance
+ */
+export function getGooglePlacesService(config) {
+    return new GooglePlacesService(config);
+}

package/dist/components/integrations/socialcard.js

@@ -42,19 +42,22 @@ SocialCards.propTypes = {
 };
 export function SocialCards(props) {
     const debug = false;
+    // Get config values from provider
+    const config = usePixelatedConfig();
+    const proxyURL = config?.global?.proxyUrl || 'https://proxy.pixelated.tech/prod/proxy';
     const [state, setState] = useState({
         loading: true,
         targetID: '#social',
         myCardData: [],
         mySocialCards: [],
         proxy: {
-            proxyURL: 'https://proxy.pixelated.tech/prod/proxy',
+            proxyURL,
             proxyURLParam: 'url'
         },
         rss2json: {
             apiURL: 'https://api.rss2json.com/v1/api.json',
             apiURLParam: 'rss_url',
-            apiKey: 'c3wsmqh4h1iydxxip3sgkr1jtk3brllbp61jc6yd'
+            apiKey: ''
         },
         toptal: {
             apiURL: 'https://www.toptal.com/developers/feed2json/convert',

package/dist/components/integrations/wordpress.components.js

@@ -8,6 +8,7 @@ import { PageGridItem } from '../general/semantic';
 import { getWordPressItems, getWordPressLastModified } from './wordpress.functions';
 import { Loading, ToggleLoading } from '../general/loading';
 import { CacheManager } from "../general/cache-manager";
+import { getDomain } from '../general/utilities';
 import "./wordpress.css";
 import { SchemaBlogPosting } from '../general/schema';
 import { mapWordPressToBlogPosting } from '../general/schema.functions';
@@ -18,7 +19,7 @@ function decodeString(str) {
     return textarea.value;
 }
 const wpCacheTTL = 1000 * 60 * 60 * 24 * 7; // 1 week
-const wpCache = new CacheManager({ mode: 'local', ttl: wpCacheTTL, prefix: 'wp_' });
+const wpCache = new CacheManager({ mode: 'local', ttl: wpCacheTTL, domain: getDomain(), namespace: 'wp' });
 const wpApiURL = "https://public-api.wordpress.com/rest/v1/sites/";
 /**
  * getCachedWordPressItems — Fetch posts from the WordPress REST API with caching. Checks local cache first and returns cached posts if available and not expired; otherwise fetches from the API, stores in cache, and returns the fresh data.