shared-features 0.0.8 → 0.1.0

package/dist/commonFeatures-CiqxxOin.cjs

@@ -0,0 +1,1276 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+const firestore = require("firebase/firestore");
+const app = require("firebase/app");
+const auth = require("firebase/auth");
+const commonFeatures = require("./commonFeatures-Cr5g1E4M.cjs");
+let state = {
+  initialized: false,
+  config: null,
+  deviceId: null
+};
+function getState() {
+  return state;
+}
+function setState(newState) {
+  state = { ...state, ...newState };
+}
+function getConfig() {
+  if (!state.initialized || !state.config) {
+    throw new Error(
+      "shared-features has not been initialized. Call initSharedFeatures() first."
+    );
+  }
+  return state.config;
+}
+function isInitialized() {
+  return state.initialized;
+}
+const SHARED_FEATURES_APP_NAME = "shared-features";
+let firebaseApp = null;
+let firestoreDb = null;
+let firebaseAuth = null;
+function generateDeviceId() {
+  const timestamp = Date.now();
+  const randomPart = Math.random().toString(36).substring(2, 15);
+  return `device_${timestamp}_${randomPart}`;
+}
+async function getOrCreateDeviceId() {
+  const STORAGE_KEY = "shared_features_device_id";
+  try {
+    const { Preferences } = await import("@capacitor/preferences");
+    const result = await Preferences.get({ key: STORAGE_KEY });
+    if (result.value) {
+      return result.value;
+    }
+    const newId = generateDeviceId();
+    await Preferences.set({ key: STORAGE_KEY, value: newId });
+    return newId;
+  } catch {
+    try {
+      const stored = localStorage.getItem(STORAGE_KEY);
+      if (stored) {
+        return stored;
+      }
+      const newId = generateDeviceId();
+      localStorage.setItem(STORAGE_KEY, newId);
+      return newId;
+    } catch {
+      return generateDeviceId();
+    }
+  }
+}
+async function initSharedFeatures(config) {
+  if (isInitialized() && firebaseApp && firestoreDb && firebaseAuth) {
+    const currentConfig = getState().config;
+    if (currentConfig && currentConfig.firebaseConfig.projectId === config.firebaseConfig.projectId) {
+      return { app: firebaseApp, db: firestoreDb, auth: firebaseAuth };
+    }
+  }
+  const existingApps = app.getApps();
+  const existingApp = existingApps.find(
+    (app2) => app2.name === SHARED_FEATURES_APP_NAME
+  );
+  if (existingApp) {
+    firebaseApp = existingApp;
+  } else {
+    firebaseApp = app.initializeApp(config.firebaseConfig, SHARED_FEATURES_APP_NAME);
+  }
+  firestoreDb = firestore.getFirestore(firebaseApp);
+  firebaseAuth = auth.getAuth(firebaseApp);
+  const deviceId = await getOrCreateDeviceId();
+  setState({
+    initialized: true,
+    config,
+    deviceId
+  });
+  if (config.debug) {
+    console.log("[shared-features] Initialized:", {
+      projectId: config.projectId,
+      projectName: config.projectName,
+      platform: config.platform,
+      deviceId
+    });
+  }
+  return { app: firebaseApp, db: firestoreDb, auth: firebaseAuth };
+}
+function getSharedFeaturesApp() {
+  if (!firebaseApp) {
+    throw new Error(
+      "shared-features has not been initialized. Call initSharedFeatures() first."
+    );
+  }
+  return firebaseApp;
+}
+function getSharedFeaturesDb() {
+  if (!firestoreDb) {
+    throw new Error(
+      "shared-features has not been initialized. Call initSharedFeatures() first."
+    );
+  }
+  return firestoreDb;
+}
+function getSharedFeaturesAuth() {
+  if (!firebaseAuth) {
+    throw new Error(
+      "shared-features has not been initialized. Call initSharedFeatures() first."
+    );
+  }
+  return firebaseAuth;
+}
+function getDeviceId() {
+  return getState().deviceId;
+}
+const COLLECTION_CAMPAIGNS = "zaions_campaigns";
+const COLLECTION_PRODUCTS = "zaions_products";
+let campaignsCache = null;
+const CACHE_TTL_MS$2 = 5 * 60 * 1e3;
+let productsCache = null;
+function isCacheValid$2() {
+  if (!campaignsCache) return false;
+  return Date.now() - campaignsCache.timestamp < CACHE_TTL_MS$2;
+}
+function docToCampaign(docId, data) {
+  return {
+    id: docId,
+    productId: data.productId,
+    name: data.name,
+    status: data.status,
+    targetPlatforms: data.targetPlatforms,
+    targetAudience: data.targetAudience,
+    targetProjects: data.targetProjects || [],
+    excludeProductUsers: data.excludeProductUsers,
+    placements: data.placements,
+    priority: data.priority,
+    frequencyDays: data.frequencyDays,
+    maxImpressions: data.maxImpressions,
+    startDate: data.startDate,
+    endDate: data.endDate,
+    variant: data.variant,
+    customTitle: data.customTitle,
+    customTagline: data.customTagline,
+    customCta: data.customCta,
+    customCtaUrl: data.customCtaUrl,
+    customDescription: data.customDescription,
+    customProductColor: data.customProductColor,
+    customIcon: data.customIcon,
+    customFeatures: data.customFeatures,
+    totalImpressions: data.totalImpressions,
+    totalClicks: data.totalClicks,
+    totalCloses: data.totalCloses,
+    createdAt: data.createdAt,
+    updatedAt: data.updatedAt,
+    createdBy: data.createdBy,
+    updatedBy: data.updatedBy
+  };
+}
+function docToProduct(docId, data) {
+  return {
+    id: docId,
+    name: data.name,
+    tagline: data.tagline,
+    description: data.description,
+    type: data.type,
+    url: data.url,
+    color: data.color,
+    features: data.features || [],
+    icon64: data.icon64,
+    icon128: data.icon128,
+    chromeStoreUrl: data.chromeStoreUrl,
+    playStoreUrl: data.playStoreUrl,
+    appStoreUrl: data.appStoreUrl,
+    webUrl: data.webUrl,
+    enabled: data.enabled,
+    createdAt: data.createdAt,
+    updatedAt: data.updatedAt
+  };
+}
+async function fetchProducts() {
+  const db = getSharedFeaturesDb();
+  const snapshot = await firestore.getDocs(firestore.collection(db, COLLECTION_PRODUCTS));
+  const products = snapshot.docs.map((d) => docToProduct(d.id, d.data()));
+  productsCache = new Map(products.map((p) => [p.id, p]));
+  return products;
+}
+async function getProductById(productId) {
+  if (productsCache?.has(productId)) {
+    return productsCache.get(productId) || null;
+  }
+  const db = getSharedFeaturesDb();
+  const docSnap = await firestore.getDoc(firestore.doc(db, COLLECTION_PRODUCTS, productId));
+  if (!docSnap.exists()) return null;
+  const product = docToProduct(docSnap.id, docSnap.data());
+  if (!productsCache) productsCache = /* @__PURE__ */ new Map();
+  productsCache.set(productId, product);
+  return product;
+}
+async function fetchCampaigns(options = {}) {
+  const config = getConfig();
+  const db = getSharedFeaturesDb();
+  if (!options.placement && !options.status && !options.productId && isCacheValid$2()) {
+    return campaignsCache.data;
+  }
+  let q = firestore.query(firestore.collection(db, COLLECTION_CAMPAIGNS));
+  if (options.status) {
+    q = firestore.query(q, firestore.where("status", "==", options.status));
+  }
+  if (options.productId) {
+    q = firestore.query(q, firestore.where("productId", "==", options.productId));
+  }
+  q = firestore.query(q, firestore.orderBy("priority", "desc"));
+  if (options.limit) {
+    q = firestore.query(q, firestore.limit(options.limit));
+  }
+  const snapshot = await firestore.getDocs(q);
+  let campaigns = snapshot.docs.map((d) => docToCampaign(d.id, d.data()));
+  if (options.placement) {
+    campaigns = campaigns.filter(
+      (c) => c.placements.includes(options.placement)
+    );
+  }
+  campaigns = campaigns.filter(
+    (c) => c.targetPlatforms.includes(config.platform) || c.targetPlatforms.length === 0
+  );
+  campaigns = campaigns.filter(
+    (c) => c.targetProjects.length === 0 || c.targetProjects.includes(config.projectId)
+  );
+  if (!options.placement && !options.status && !options.productId) {
+    campaignsCache = {
+      data: campaigns,
+      timestamp: Date.now()
+    };
+  }
+  return campaigns;
+}
+async function fetchActiveCampaigns(placement) {
+  const now = firestore.Timestamp.now();
+  const campaigns = await fetchCampaigns({ status: "active" });
+  if (!productsCache || productsCache.size === 0) {
+    await fetchProducts();
+  }
+  const eligible = campaigns.filter((c) => {
+    if (!c.placements.includes(placement)) return false;
+    if (c.startDate.toMillis() > now.toMillis()) return false;
+    if (c.endDate && c.endDate.toMillis() < now.toMillis()) return false;
+    if (c.maxImpressions !== null && c.totalImpressions >= c.maxImpressions)
+      return false;
+    return true;
+  });
+  const result = [];
+  for (const campaign of eligible) {
+    const product = await getProductById(campaign.productId);
+    if (product && product.enabled) {
+      result.push({ ...campaign, product });
+    }
+  }
+  return result;
+}
+async function getCampaignById(campaignId) {
+  const db = getSharedFeaturesDb();
+  const docSnap = await firestore.getDoc(firestore.doc(db, COLLECTION_CAMPAIGNS, campaignId));
+  if (!docSnap.exists()) return null;
+  return docToCampaign(docSnap.id, docSnap.data());
+}
+function clearCampaignsCache() {
+  campaignsCache = null;
+}
+function clearProductsCache() {
+  productsCache = null;
+}
+const COLLECTION_IMPRESSIONS = "zaions_impressions";
+const LOCAL_STORAGE_KEY = "shared_features_ad_history";
+async function getLocalAdHistory() {
+  try {
+    const { Preferences } = await import("@capacitor/preferences");
+    const result = await Preferences.get({ key: LOCAL_STORAGE_KEY });
+    if (result.value) {
+      return JSON.parse(result.value);
+    }
+  } catch {
+    try {
+      const stored = localStorage.getItem(LOCAL_STORAGE_KEY);
+      if (stored) {
+        return JSON.parse(stored);
+      }
+    } catch {
+    }
+  }
+  return {};
+}
+async function saveLocalAdHistory(history) {
+  const serialized = JSON.stringify(history);
+  try {
+    const { Preferences } = await import("@capacitor/preferences");
+    await Preferences.set({ key: LOCAL_STORAGE_KEY, value: serialized });
+  } catch {
+    try {
+      localStorage.setItem(LOCAL_STORAGE_KEY, serialized);
+    } catch {
+    }
+  }
+}
+async function updateLocalHistory(campaignId, productId, action, frequencyDays) {
+  const history = await getLocalAdHistory();
+  const now = Date.now();
+  const nextEligibleAt = now + frequencyDays * 24 * 60 * 60 * 1e3;
+  const existing = history[campaignId];
+  if (existing) {
+    history[campaignId] = {
+      ...existing,
+      lastSeenAt: now,
+      impressionCount: action === "impression" ? existing.impressionCount + 1 : existing.impressionCount,
+      clicked: existing.clicked || action === "click",
+      closed: existing.closed || action === "close",
+      nextEligibleAt: action === "impression" ? nextEligibleAt : existing.nextEligibleAt
+    };
+  } else {
+    history[campaignId] = {
+      campaignId,
+      productId,
+      lastSeenAt: now,
+      impressionCount: action === "impression" ? 1 : 0,
+      clicked: action === "click",
+      closed: action === "close",
+      nextEligibleAt
+    };
+  }
+  await saveLocalAdHistory(history);
+}
+async function isEligibleForCampaign(campaignId, _frequencyDays = 20) {
+  const history = await getLocalAdHistory();
+  const entry = history[campaignId];
+  if (!entry) return true;
+  return Date.now() >= entry.nextEligibleAt;
+}
+async function getEligibleCampaignIds() {
+  const history = await getLocalAdHistory();
+  const now = Date.now();
+  return Object.entries(history).filter(([, entry]) => now >= entry.nextEligibleAt).map(([campaignId]) => campaignId);
+}
+async function getCampaignHistory(campaignId) {
+  const history = await getLocalAdHistory();
+  return history[campaignId] || null;
+}
+async function recordImpression(input, frequencyDays = 20) {
+  const config = getConfig();
+  const state2 = getState();
+  const db = getSharedFeaturesDb();
+  const impressionData = {
+    campaignId: input.campaignId,
+    productId: input.productId,
+    projectId: config.projectId,
+    userId: null,
+    // Consumer projects don't authenticate with aoneahsan.com
+    deviceId: state2.deviceId || "unknown",
+    platform: config.platform,
+    placement: input.placement,
+    action: input.action,
+    variant: input.variant,
+    timestamp: firestore.serverTimestamp(),
+    ...input.sessionId && { sessionId: input.sessionId }
+  };
+  try {
+    await firestore.addDoc(firestore.collection(db, COLLECTION_IMPRESSIONS), impressionData);
+    if (config.debug) {
+      console.log("[shared-features] Recorded impression:", impressionData);
+    }
+  } catch (error) {
+    if (config.debug) {
+      console.error("[shared-features] Failed to record impression:", error);
+    }
+  }
+  await updateLocalHistory(
+    input.campaignId,
+    input.productId,
+    input.action,
+    frequencyDays
+  );
+}
+async function trackImpression(campaignId, productId, placement, variant, frequencyDays) {
+  await recordImpression(
+    {
+      campaignId,
+      productId,
+      placement,
+      action: "impression",
+      variant
+    },
+    frequencyDays
+  );
+}
+async function trackClick(campaignId, productId, placement, variant) {
+  await recordImpression({
+    campaignId,
+    productId,
+    placement,
+    action: "click",
+    variant
+  });
+}
+async function trackClose(campaignId, productId, placement, variant) {
+  await recordImpression({
+    campaignId,
+    productId,
+    placement,
+    action: "close",
+    variant
+  });
+}
+let flagsCache = null;
+const CACHE_TTL_MS$1 = 2 * 60 * 1e3;
+function isCacheValid$1() {
+  if (!flagsCache || !flagsCache.data) return false;
+  return Date.now() - flagsCache.timestamp < CACHE_TTL_MS$1;
+}
+function clearFeatureFlagsCache() {
+  flagsCache = null;
+}
+function docToFeatureFlags(docId, data) {
+  return {
+    id: docId,
+    globalEnabled: data.globalEnabled ?? true,
+    currentApiVersion: data.currentApiVersion ?? "v1",
+    supportedApiVersions: data.supportedApiVersions ?? ["v1"],
+    features: data.features,
+    maintenanceMode: data.maintenanceMode ?? false,
+    maintenanceMessage: data.maintenanceMessage,
+    maintenanceEndTime: data.maintenanceEndTime,
+    updatedAt: data.updatedAt,
+    updatedBy: data.updatedBy
+  };
+}
+function getConsumerVersion(featureId, consumerVersions) {
+  if (!consumerVersions) return void 0;
+  return consumerVersions[featureId];
+}
+async function fetchFeatureFlags(forceRefresh = false) {
+  if (!forceRefresh && isCacheValid$1()) {
+    return flagsCache.data;
+  }
+  try {
+    const db = getSharedFeaturesDb();
+    const docRef = firestore.doc(db, commonFeatures.COLLECTION_FEATURE_FLAGS, commonFeatures.FEATURE_FLAGS_DOC_ID);
+    const docSnap = await firestore.getDoc(docRef);
+    if (!docSnap.exists()) {
+      const config2 = getConfig();
+      if (config2.debug) {
+        console.log(
+          "[shared-features] Feature flags document not found, using defaults"
+        );
+      }
+      const defaultDoc = {
+        ...commonFeatures.DEFAULT_FEATURE_FLAGS,
+        updatedAt: firestore.Timestamp.now(),
+        updatedBy: "system"
+      };
+      flagsCache = {
+        data: defaultDoc,
+        timestamp: Date.now()
+      };
+      return defaultDoc;
+    }
+    const flags = docToFeatureFlags(docSnap.id, docSnap.data());
+    flagsCache = {
+      data: flags,
+      timestamp: Date.now()
+    };
+    const config = getConfig();
+    if (config.debug) {
+      console.log("[shared-features] Feature flags fetched:", {
+        globalEnabled: flags.globalEnabled,
+        maintenanceMode: flags.maintenanceMode,
+        apiVersion: flags.currentApiVersion
+      });
+    }
+    return flags;
+  } catch (error) {
+    const config = getConfig();
+    if (config.debug) {
+      console.error("[shared-features] Error fetching feature flags:", error);
+    }
+    if (flagsCache?.data) {
+      return flagsCache.data;
+    }
+    return null;
+  }
+}
+function subscribeToFeatureFlags(callback) {
+  const db = getSharedFeaturesDb();
+  const docRef = firestore.doc(db, commonFeatures.COLLECTION_FEATURE_FLAGS, commonFeatures.FEATURE_FLAGS_DOC_ID);
+  return firestore.onSnapshot(
+    docRef,
+    (docSnap) => {
+      if (!docSnap.exists()) {
+        callback(null);
+        return;
+      }
+      const flags = docToFeatureFlags(docSnap.id, docSnap.data());
+      flagsCache = {
+        data: flags,
+        timestamp: Date.now()
+      };
+      callback(flags);
+    },
+    (error) => {
+      const config = getConfig();
+      if (config.debug) {
+        console.error(
+          "[shared-features] Error subscribing to feature flags:",
+          error
+        );
+      }
+      callback(null);
+    }
+  );
+}
+async function checkFeatureAvailability(featureId, consumerVersions) {
+  const flags = await fetchFeatureFlags();
+  const config = getConfig();
+  const unavailable = {
+    available: false,
+    enabled: false,
+    version: 1,
+    deprecated: false,
+    upgradeRequired: false,
+    unavailableReason: "Feature flags not loaded"
+  };
+  if (!flags) {
+    return unavailable;
+  }
+  if (!flags.globalEnabled) {
+    return {
+      ...unavailable,
+      unavailableReason: "shared-features is globally disabled"
+    };
+  }
+  if (flags.maintenanceMode) {
+    return {
+      ...unavailable,
+      unavailableReason: flags.maintenanceMessage || "Maintenance in progress"
+    };
+  }
+  const featureConfig = flags.features[featureId];
+  if (!featureConfig) {
+    return {
+      ...unavailable,
+      unavailableReason: `Feature '${featureId}' not found in configuration`
+    };
+  }
+  if (!featureConfig.enabled) {
+    return {
+      ...unavailable,
+      version: featureConfig.version,
+      unavailableReason: `Feature '${featureId}' is not enabled`
+    };
+  }
+  if (featureConfig.availablePlatforms && featureConfig.availablePlatforms.length > 0) {
+    if (!featureConfig.availablePlatforms.includes(config.platform)) {
+      return {
+        ...unavailable,
+        version: featureConfig.version,
+        unavailableReason: `Feature '${featureId}' is not available on platform '${config.platform}'`
+      };
+    }
+  }
+  if (featureConfig.availableProjects && featureConfig.availableProjects.length > 0) {
+    if (!featureConfig.availableProjects.includes(config.projectId)) {
+      return {
+        ...unavailable,
+        version: featureConfig.version,
+        unavailableReason: `Feature '${featureId}' is not available for project '${config.projectId}'`
+      };
+    }
+  }
+  const consumerVersion = getConsumerVersion(featureId, consumerVersions);
+  const currentVersion = featureConfig.version;
+  const minVersion = featureConfig.minVersion;
+  const maxVersion = featureConfig.maxVersion;
+  let deprecated = false;
+  let deprecationWarning;
+  let upgradeRequired = false;
+  let upgradeMessage;
+  if (consumerVersion !== void 0) {
+    if (consumerVersion < minVersion) {
+      upgradeRequired = true;
+      upgradeMessage = `Feature '${featureId}' requires minimum version ${minVersion}, but consumer is using version ${consumerVersion}. Please upgrade.`;
+    } else if (consumerVersion < currentVersion) {
+      deprecated = true;
+      deprecationWarning = featureConfig.deprecationMessage || `Feature '${featureId}' version ${consumerVersion} is deprecated. Current version is ${currentVersion}.`;
+    } else if (consumerVersion > maxVersion) {
+      return {
+        ...unavailable,
+        version: currentVersion,
+        unavailableReason: `Feature '${featureId}' version ${consumerVersion} is not yet supported. Maximum supported version is ${maxVersion}.`
+      };
+    }
+  }
+  return {
+    available: !upgradeRequired,
+    enabled: true,
+    version: currentVersion,
+    deprecated,
+    deprecationWarning,
+    upgradeRequired,
+    upgradeMessage
+  };
+}
+function isFeatureEnabled(featureId) {
+  if (!flagsCache?.data) return false;
+  const flags = flagsCache.data;
+  if (!flags.globalEnabled || flags.maintenanceMode) return false;
+  const featureConfig = flags.features[featureId];
+  if (!featureConfig || !featureConfig.enabled) return false;
+  const config = getConfig();
+  if (featureConfig.availablePlatforms && featureConfig.availablePlatforms.length > 0) {
+    if (!featureConfig.availablePlatforms.includes(config.platform)) {
+      return false;
+    }
+  }
+  if (featureConfig.availableProjects && featureConfig.availableProjects.length > 0) {
+    if (!featureConfig.availableProjects.includes(config.projectId)) {
+      return false;
+    }
+  }
+  return true;
+}
+function getFeatureVersion(featureId) {
+  if (!flagsCache?.data) return 0;
+  return flagsCache.data.features[featureId]?.version ?? 0;
+}
+async function getSharedFeaturesStatus(consumerVersions) {
+  const flags = await fetchFeatureFlags();
+  const defaultStatus = {
+    operational: false,
+    maintenanceMode: false,
+    apiVersion: "v1",
+    features: {},
+    deprecatedFeatures: [],
+    upgradeRequiredFeatures: [],
+    fetchedAt: /* @__PURE__ */ new Date()
+  };
+  if (!flags) {
+    return defaultStatus;
+  }
+  const featureIds = [
+    "campaigns",
+    "broadcasts",
+    "contactInfo",
+    "developerInfo",
+    "socialLinks",
+    "paymentOptions",
+    "addressInfo",
+    "services",
+    "skills",
+    "testimonials",
+    "projects"
+  ];
+  const features = {};
+  const deprecatedFeatures = [];
+  const upgradeRequiredFeatures = [];
+  for (const featureId of featureIds) {
+    const availability = await checkFeatureAvailability(
+      featureId,
+      consumerVersions
+    );
+    features[featureId] = availability;
+    if (availability.deprecated) {
+      deprecatedFeatures.push(featureId);
+    }
+    if (availability.upgradeRequired) {
+      upgradeRequiredFeatures.push(featureId);
+    }
+  }
+  return {
+    operational: flags.globalEnabled && !flags.maintenanceMode,
+    maintenanceMode: flags.maintenanceMode,
+    maintenanceMessage: flags.maintenanceMessage,
+    apiVersion: flags.currentApiVersion,
+    features,
+    deprecatedFeatures,
+    upgradeRequiredFeatures,
+    fetchedAt: /* @__PURE__ */ new Date()
+  };
+}
+async function updateFeatureConfig(input, adminEmail) {
+  const db = getSharedFeaturesDb();
+  const docRef = firestore.doc(db, commonFeatures.COLLECTION_FEATURE_FLAGS, commonFeatures.FEATURE_FLAGS_DOC_ID);
+  const docSnap = await firestore.getDoc(docRef);
+  let currentFlags;
+  if (!docSnap.exists()) {
+    currentFlags = {
+      ...commonFeatures.DEFAULT_FEATURE_FLAGS,
+      updatedAt: firestore.Timestamp.now(),
+      updatedBy: adminEmail
+    };
+  } else {
+    currentFlags = docToFeatureFlags(docSnap.id, docSnap.data());
+  }
+  const featureConfig = currentFlags.features[input.featureId];
+  const updatedFeature = {
+    enabled: input.enabled ?? featureConfig.enabled,
+    version: input.version ?? featureConfig.version,
+    minVersion: input.minVersion ?? featureConfig.minVersion,
+    maxVersion: input.maxVersion ?? featureConfig.maxVersion,
+    deprecationMessage: input.deprecationMessage ?? featureConfig.deprecationMessage,
+    requiresAuth: input.requiresAuth ?? featureConfig.requiresAuth,
+    availablePlatforms: input.availablePlatforms ?? featureConfig.availablePlatforms,
+    availableProjects: input.availableProjects ?? featureConfig.availableProjects
+  };
+  await firestore.setDoc(
+    docRef,
+    {
+      ...currentFlags,
+      features: {
+        ...currentFlags.features,
+        [input.featureId]: updatedFeature
+      },
+      updatedAt: firestore.Timestamp.now(),
+      updatedBy: adminEmail
+    },
+    { merge: true }
+  );
+  clearFeatureFlagsCache();
+}
+async function updateGlobalFlags(input, adminEmail) {
+  const db = getSharedFeaturesDb();
+  const docRef = firestore.doc(db, commonFeatures.COLLECTION_FEATURE_FLAGS, commonFeatures.FEATURE_FLAGS_DOC_ID);
+  const updateData = {
+    updatedAt: firestore.Timestamp.now(),
+    updatedBy: adminEmail
+  };
+  if (input.globalEnabled !== void 0) {
+    updateData.globalEnabled = input.globalEnabled;
+  }
+  if (input.currentApiVersion !== void 0) {
+    updateData.currentApiVersion = input.currentApiVersion;
+  }
+  if (input.supportedApiVersions !== void 0) {
+    updateData.supportedApiVersions = input.supportedApiVersions;
+  }
+  if (input.maintenanceMode !== void 0) {
+    updateData.maintenanceMode = input.maintenanceMode;
+  }
+  if (input.maintenanceMessage !== void 0) {
+    updateData.maintenanceMessage = input.maintenanceMessage;
+  }
+  if (input.maintenanceEndTime !== void 0) {
+    updateData.maintenanceEndTime = input.maintenanceEndTime ? firestore.Timestamp.fromDate(input.maintenanceEndTime) : null;
+  }
+  await firestore.setDoc(docRef, updateData, { merge: true });
+  clearFeatureFlagsCache();
+}
+async function initializeFeatureFlags(adminEmail) {
+  const db = getSharedFeaturesDb();
+  const docRef = firestore.doc(db, commonFeatures.COLLECTION_FEATURE_FLAGS, commonFeatures.FEATURE_FLAGS_DOC_ID);
+  const docSnap = await firestore.getDoc(docRef);
+  if (docSnap.exists()) {
+    throw new Error("Feature flags document already exists");
+  }
+  await firestore.setDoc(docRef, {
+    ...commonFeatures.DEFAULT_FEATURE_FLAGS,
+    updatedAt: firestore.Timestamp.now(),
+    updatedBy: adminEmail
+  });
+  clearFeatureFlagsCache();
+}
+const CACHE_TTL_MS = 5 * 60 * 1e3;
+let contactInfoCache = null;
+let developerInfoCache = null;
+let addressInfoCache = null;
+let socialLinksCache = null;
+let paymentOptionsCache = null;
+let servicesCache = null;
+let skillsCache = null;
+let testimonialsCache = null;
+function isCacheValid(cache) {
+  if (!cache || !cache.data) return false;
+  return Date.now() - cache.timestamp < CACHE_TTL_MS;
+}
+function clearAllCommonFeaturesCache() {
+  contactInfoCache = null;
+  developerInfoCache = null;
+  addressInfoCache = null;
+  socialLinksCache = null;
+  paymentOptionsCache = null;
+  servicesCache = null;
+  skillsCache = null;
+  testimonialsCache = null;
+}
+function docToContactInfo(docId, data) {
+  return {
+    id: docId,
+    email: data.email || "",
+    supportEmail: data.supportEmail,
+    phone: data.phone,
+    whatsapp: data.whatsapp,
+    telegram: data.telegram,
+    skype: data.skype,
+    freelanceAvailable: data.freelanceAvailable ?? false,
+    workingHours: data.workingHours,
+    timezone: data.timezone,
+    preferredContact: data.preferredContact,
+    responseTime: data.responseTime,
+    updatedAt: data.updatedAt
+  };
+}
+async function fetchContactInfo() {
+  if (!isFeatureEnabled("contactInfo")) {
+    const config = getConfig();
+    if (config.debug) console.log("[shared-features] contactInfo feature is disabled");
+    return null;
+  }
+  if (isCacheValid(contactInfoCache)) return contactInfoCache.data;
+  try {
+    const db = getSharedFeaturesDb();
+    const docRef = firestore.doc(db, commonFeatures.COMMON_FEATURE_COLLECTIONS.CONTACT_INFO, "main");
+    const docSnap = await firestore.getDoc(docRef);
+    if (!docSnap.exists()) return null;
+    const data = docToContactInfo(docSnap.id, docSnap.data());
+    contactInfoCache = { data, timestamp: Date.now() };
+    return data;
+  } catch (error) {
+    const config = getConfig();
+    if (config.debug) console.error("[shared-features] Error fetching contact info:", error);
+    return contactInfoCache?.data ?? null;
+  }
+}
+function subscribeToContactInfo(callback) {
+  const db = getSharedFeaturesDb();
+  const docRef = firestore.doc(db, commonFeatures.COMMON_FEATURE_COLLECTIONS.CONTACT_INFO, "main");
+  return firestore.onSnapshot(docRef, (docSnap) => {
+    if (!docSnap.exists()) {
+      callback(null);
+      return;
+    }
+    const data = docToContactInfo(docSnap.id, docSnap.data());
+    contactInfoCache = { data, timestamp: Date.now() };
+    callback(data);
+  });
+}
+function clearContactInfoCache() {
+  contactInfoCache = null;
+}
+function docToDeveloperInfo(docId, data) {
+  return {
+    id: docId,
+    name: data.name || "",
+    title: data.title || "",
+    tagline: data.tagline,
+    bio: data.bio || "",
+    shortBio: data.shortBio,
+    avatar: data.avatar,
+    website: data.website,
+    github: data.github,
+    linkedin: data.linkedin,
+    twitter: data.twitter,
+    yearsOfExperience: data.yearsOfExperience,
+    location: data.location,
+    availableForHire: data.availableForHire ?? false,
+    resumeUrl: data.resumeUrl,
+    updatedAt: data.updatedAt
+  };
+}
+async function fetchDeveloperInfo() {
+  if (!isFeatureEnabled("developerInfo")) {
+    const config = getConfig();
+    if (config.debug) console.log("[shared-features] developerInfo feature is disabled");
+    return null;
+  }
+  if (isCacheValid(developerInfoCache)) return developerInfoCache.data;
+  try {
+    const db = getSharedFeaturesDb();
+    const docRef = firestore.doc(db, commonFeatures.COMMON_FEATURE_COLLECTIONS.DEVELOPER_INFO, "main");
+    const docSnap = await firestore.getDoc(docRef);
+    if (!docSnap.exists()) return null;
+    const data = docToDeveloperInfo(docSnap.id, docSnap.data());
+    developerInfoCache = { data, timestamp: Date.now() };
+    return data;
+  } catch (error) {
+    const config = getConfig();
+    if (config.debug) console.error("[shared-features] Error fetching developer info:", error);
+    return developerInfoCache?.data ?? null;
+  }
+}
+function subscribeToDeveloperInfo(callback) {
+  const db = getSharedFeaturesDb();
+  const docRef = firestore.doc(db, commonFeatures.COMMON_FEATURE_COLLECTIONS.DEVELOPER_INFO, "main");
+  return firestore.onSnapshot(docRef, (docSnap) => {
+    if (!docSnap.exists()) {
+      callback(null);
+      return;
+    }
+    const data = docToDeveloperInfo(docSnap.id, docSnap.data());
+    developerInfoCache = { data, timestamp: Date.now() };
+    callback(data);
+  });
+}
+function clearDeveloperInfoCache() {
+  developerInfoCache = null;
+}
+function docToAddressInfo(docId, data) {
+  return {
+    id: docId,
+    label: data.label,
+    streetAddress: data.streetAddress,
+    city: data.city,
+    state: data.state,
+    postalCode: data.postalCode,
+    country: data.country,
+    fullAddress: data.fullAddress,
+    googleMapsUrl: data.googleMapsUrl,
+    isPublic: data.isPublic ?? false,
+    updatedAt: data.updatedAt
+  };
+}
+async function fetchAddressInfo() {
+  if (!isFeatureEnabled("addressInfo")) {
+    const config = getConfig();
+    if (config.debug) console.log("[shared-features] addressInfo feature is disabled");
+    return null;
+  }
+  if (isCacheValid(addressInfoCache)) return addressInfoCache.data;
+  try {
+    const db = getSharedFeaturesDb();
+    const docRef = firestore.doc(db, commonFeatures.COMMON_FEATURE_COLLECTIONS.ADDRESS_INFO, "main");
+    const docSnap = await firestore.getDoc(docRef);
+    if (!docSnap.exists()) return null;
+    const data = docToAddressInfo(docSnap.id, docSnap.data());
+    if (!data.isPublic) return null;
+    addressInfoCache = { data, timestamp: Date.now() };
+    return data;
+  } catch (error) {
+    const config = getConfig();
+    if (config.debug) console.error("[shared-features] Error fetching address info:", error);
+    return addressInfoCache?.data ?? null;
+  }
+}
+function clearAddressInfoCache() {
+  addressInfoCache = null;
+}
+function docToSocialLink(docId, data) {
+  return {
+    id: docId,
+    platform: data.platform,
+    url: data.url || "",
+    displayName: data.displayName,
+    username: data.username,
+    icon: data.icon,
+    order: data.order ?? 0,
+    isActive: data.isActive ?? true,
+    showIn: data.showIn ?? ["footer"],
+    updatedAt: data.updatedAt
+  };
+}
+async function fetchSocialLinks(options = {}) {
+  if (!isFeatureEnabled("socialLinks")) {
+    const config = getConfig();
+    if (config.debug) console.log("[shared-features] socialLinks feature is disabled");
+    return [];
+  }
+  if (!options.showIn && options.activeOnly !== false && isCacheValid(socialLinksCache)) {
+    return socialLinksCache.data ?? [];
+  }
+  try {
+    const db = getSharedFeaturesDb();
+    let q = firestore.query(firestore.collection(db, commonFeatures.COMMON_FEATURE_COLLECTIONS.SOCIAL_LINKS), firestore.orderBy("order", "asc"));
+    const snapshot = await firestore.getDocs(q);
+    let links = snapshot.docs.map((d) => docToSocialLink(d.id, d.data()));
+    if (options.activeOnly !== false) {
+      links = links.filter((l) => l.isActive);
+    }
+    if (options.showIn && options.showIn.length > 0) {
+      links = links.filter((l) => options.showIn.some((loc) => l.showIn.includes(loc)));
+    }
+    if (!options.showIn && options.activeOnly !== false) {
+      socialLinksCache = { data: links, timestamp: Date.now() };
+    }
+    return links;
+  } catch (error) {
+    const config = getConfig();
+    if (config.debug) console.error("[shared-features] Error fetching social links:", error);
+    return socialLinksCache?.data ?? [];
+  }
+}
+function clearSocialLinksCache() {
+  socialLinksCache = null;
+}
+function docToPaymentOption(docId, data) {
+  return {
+    id: docId,
+    type: data.type,
+    name: data.name || "",
+    description: data.description,
+    icon: data.icon,
+    details: data.details || {},
+    isActive: data.isActive ?? true,
+    isPrimary: data.isPrimary ?? false,
+    order: data.order ?? 0,
+    updatedAt: data.updatedAt
+  };
+}
+async function fetchPaymentOptions(options = {}) {
+  if (!isFeatureEnabled("paymentOptions")) {
+    const config = getConfig();
+    if (config.debug) console.log("[shared-features] paymentOptions feature is disabled");
+    return [];
+  }
+  if (!options.type && options.activeOnly !== false && isCacheValid(paymentOptionsCache)) {
+    return paymentOptionsCache.data ?? [];
+  }
+  try {
+    const db = getSharedFeaturesDb();
+    let q = firestore.query(firestore.collection(db, commonFeatures.COMMON_FEATURE_COLLECTIONS.PAYMENT_OPTIONS), firestore.orderBy("order", "asc"));
+    const snapshot = await firestore.getDocs(q);
+    let items = snapshot.docs.map((d) => docToPaymentOption(d.id, d.data()));
+    if (options.activeOnly !== false) {
+      items = items.filter((i) => i.isActive);
+    }
+    if (options.type) {
+      items = items.filter((i) => i.type === options.type);
+    }
+    if (!options.type && options.activeOnly !== false) {
+      paymentOptionsCache = { data: items, timestamp: Date.now() };
+    }
+    return items;
+  } catch (error) {
+    const config = getConfig();
+    if (config.debug) console.error("[shared-features] Error fetching payment options:", error);
+    return paymentOptionsCache?.data ?? [];
+  }
+}
+function clearPaymentOptionsCache() {
+  paymentOptionsCache = null;
+}
+function docToService(docId, data) {
+  return {
+    id: docId,
+    title: data.title || "",
+    description: data.description || "",
+    shortDescription: data.shortDescription,
+    category: data.category,
+    icon: data.icon,
+    features: data.features,
+    technologies: data.technologies,
+    priceRange: data.priceRange,
+    isActive: data.isActive ?? true,
+    isFeatured: data.isFeatured ?? false,
+    order: data.order ?? 0,
+    updatedAt: data.updatedAt
+  };
+}
+async function fetchServices(options = {}) {
+  if (!isFeatureEnabled("services")) {
+    const config = getConfig();
+    if (config.debug) console.log("[shared-features] services feature is disabled");
+    return [];
+  }
+  if (!options.category && !options.featuredOnly && options.activeOnly !== false && isCacheValid(servicesCache)) {
+    return servicesCache.data ?? [];
+  }
+  try {
+    const db = getSharedFeaturesDb();
+    let q = firestore.query(firestore.collection(db, commonFeatures.COMMON_FEATURE_COLLECTIONS.SERVICES), firestore.orderBy("order", "asc"));
+    const snapshot = await firestore.getDocs(q);
+    let items = snapshot.docs.map((d) => docToService(d.id, d.data()));
+    if (options.activeOnly !== false) {
+      items = items.filter((i) => i.isActive);
+    }
+    if (options.featuredOnly) {
+      items = items.filter((i) => i.isFeatured);
+    }
+    if (options.category) {
+      items = items.filter((i) => i.category === options.category);
+    }
+    if (!options.category && !options.featuredOnly && options.activeOnly !== false) {
+      servicesCache = { data: items, timestamp: Date.now() };
+    }
+    return items;
+  } catch (error) {
+    const config = getConfig();
+    if (config.debug) console.error("[shared-features] Error fetching services:", error);
+    return servicesCache?.data ?? [];
+  }
+}
+function clearServicesCache() {
+  servicesCache = null;
+}
+function docToSkill(docId, data) {
+  return {
+    id: docId,
+    name: data.name || "",
+    category: data.category,
+    level: data.level,
+    yearsOfExperience: data.yearsOfExperience,
+    icon: data.icon,
+    color: data.color,
+    isActive: data.isActive ?? true,
+    isFeatured: data.isFeatured ?? false,
+    order: data.order ?? 0,
+    updatedAt: data.updatedAt
+  };
+}
+async function fetchSkills(options = {}) {
+  if (!isFeatureEnabled("skills")) {
+    const config = getConfig();
+    if (config.debug) console.log("[shared-features] skills feature is disabled");
+    return [];
+  }
+  if (!options.category && !options.featuredOnly && options.activeOnly !== false && isCacheValid(skillsCache)) {
+    return skillsCache.data ?? [];
+  }
+  try {
+    const db = getSharedFeaturesDb();
+    let q = firestore.query(firestore.collection(db, commonFeatures.COMMON_FEATURE_COLLECTIONS.SKILLS), firestore.orderBy("order", "asc"));
+    const snapshot = await firestore.getDocs(q);
+    let items = snapshot.docs.map((d) => docToSkill(d.id, d.data()));
+    if (options.activeOnly !== false) {
+      items = items.filter((i) => i.isActive);
+    }
+    if (options.featuredOnly) {
+      items = items.filter((i) => i.isFeatured);
+    }
+    if (options.category) {
+      items = items.filter((i) => i.category === options.category);
+    }
+    if (!options.category && !options.featuredOnly && options.activeOnly !== false) {
+      skillsCache = { data: items, timestamp: Date.now() };
+    }
+    return items;
+  } catch (error) {
+    const config = getConfig();
+    if (config.debug) console.error("[shared-features] Error fetching skills:", error);
+    return skillsCache?.data ?? [];
+  }
+}
+function clearSkillsCache() {
+  skillsCache = null;
+}
+function docToTestimonial(docId, data) {
+  return {
+    id: docId,
+    authorName: data.authorName || "",
+    authorTitle: data.authorTitle,
+    authorCompany: data.authorCompany,
+    authorAvatar: data.authorAvatar,
+    authorLinkedin: data.authorLinkedin,
+    content: data.content || "",
+    shortContent: data.shortContent,
+    rating: data.rating,
+    projectName: data.projectName,
+    projectUrl: data.projectUrl,
+    date: data.date,
+    isActive: data.isActive ?? true,
+    isFeatured: data.isFeatured ?? false,
+    order: data.order ?? 0,
+    updatedAt: data.updatedAt
+  };
+}
+async function fetchTestimonials(options = {}) {
+  if (!isFeatureEnabled("testimonials")) {
+    const config = getConfig();
+    if (config.debug) console.log("[shared-features] testimonials feature is disabled");
+    return [];
+  }
+  if (!options.featuredOnly && !options.limit && options.activeOnly !== false && isCacheValid(testimonialsCache)) {
+    return testimonialsCache.data ?? [];
+  }
+  try {
+    const db = getSharedFeaturesDb();
+    let q = firestore.query(firestore.collection(db, commonFeatures.COMMON_FEATURE_COLLECTIONS.TESTIMONIALS), firestore.orderBy("order", "asc"));
+    if (options.limit) {
+      q = firestore.query(q, firestore.limit(options.limit));
+    }
+    const snapshot = await firestore.getDocs(q);
+    let items = snapshot.docs.map((d) => docToTestimonial(d.id, d.data()));
+    if (options.activeOnly !== false) {
+      items = items.filter((i) => i.isActive);
+    }
+    if (options.featuredOnly) {
+      items = items.filter((i) => i.isFeatured);
+    }
+    if (!options.featuredOnly && !options.limit && options.activeOnly !== false) {
+      testimonialsCache = { data: items, timestamp: Date.now() };
+    }
+    return items;
+  } catch (error) {
+    const config = getConfig();
+    if (config.debug) console.error("[shared-features] Error fetching testimonials:", error);
+    return testimonialsCache?.data ?? [];
+  }
+}
+function clearTestimonialsCache() {
+  testimonialsCache = null;
+}
+exports.checkFeatureAvailability = checkFeatureAvailability;
+exports.clearAddressInfoCache = clearAddressInfoCache;
+exports.clearAllCommonFeaturesCache = clearAllCommonFeaturesCache;
+exports.clearCampaignsCache = clearCampaignsCache;
+exports.clearContactInfoCache = clearContactInfoCache;
+exports.clearDeveloperInfoCache = clearDeveloperInfoCache;
+exports.clearFeatureFlagsCache = clearFeatureFlagsCache;
+exports.clearPaymentOptionsCache = clearPaymentOptionsCache;
+exports.clearProductsCache = clearProductsCache;
+exports.clearServicesCache = clearServicesCache;
+exports.clearSkillsCache = clearSkillsCache;
+exports.clearSocialLinksCache = clearSocialLinksCache;
+exports.clearTestimonialsCache = clearTestimonialsCache;
+exports.fetchActiveCampaigns = fetchActiveCampaigns;
+exports.fetchAddressInfo = fetchAddressInfo;
+exports.fetchCampaigns = fetchCampaigns;
+exports.fetchContactInfo = fetchContactInfo;
+exports.fetchDeveloperInfo = fetchDeveloperInfo;
+exports.fetchFeatureFlags = fetchFeatureFlags;
+exports.fetchPaymentOptions = fetchPaymentOptions;
+exports.fetchProducts = fetchProducts;
+exports.fetchServices = fetchServices;
+exports.fetchSkills = fetchSkills;
+exports.fetchSocialLinks = fetchSocialLinks;
+exports.fetchTestimonials = fetchTestimonials;
+exports.getCampaignById = getCampaignById;
+exports.getCampaignHistory = getCampaignHistory;
+exports.getConfig = getConfig;
+exports.getDeviceId = getDeviceId;
+exports.getEligibleCampaignIds = getEligibleCampaignIds;
+exports.getFeatureVersion = getFeatureVersion;
+exports.getProductById = getProductById;
+exports.getSharedFeaturesApp = getSharedFeaturesApp;
+exports.getSharedFeaturesAuth = getSharedFeaturesAuth;
+exports.getSharedFeaturesDb = getSharedFeaturesDb;
+exports.getSharedFeaturesStatus = getSharedFeaturesStatus;
+exports.getState = getState;
+exports.initSharedFeatures = initSharedFeatures;
+exports.initializeFeatureFlags = initializeFeatureFlags;
+exports.isEligibleForCampaign = isEligibleForCampaign;
+exports.isFeatureEnabled = isFeatureEnabled;
+exports.isInitialized = isInitialized;
+exports.recordImpression = recordImpression;
+exports.subscribeToContactInfo = subscribeToContactInfo;
+exports.subscribeToDeveloperInfo = subscribeToDeveloperInfo;
+exports.subscribeToFeatureFlags = subscribeToFeatureFlags;
+exports.trackClick = trackClick;
+exports.trackClose = trackClose;
+exports.trackImpression = trackImpression;
+exports.updateFeatureConfig = updateFeatureConfig;
+exports.updateGlobalFlags = updateGlobalFlags;
+//# sourceMappingURL=commonFeatures-CiqxxOin.cjs.map