var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/server/modules/products/index.ts
var products_exports = {};
__export(products_exports, {
  ProductsModule: () => ProductsModule
});
module.exports = __toCommonJS(products_exports);
var import_BaseModule = require("../../../modules/BaseModule");
var import_Quotation = require("../../../modules/Quotation");
var import_types = require("./types");
var import_product = require("../../utils/product");
var INDEXDB_STORE_NAME = "products";
var PRODUCT_SYNC_DEBOUNCE_MS = 1e4;
var ProductsModule = class extends import_BaseModule.BaseModule {
  constructor(name, version) {
    super(name, version);
    this.defaultName = "products";
    this.defaultVersion = "1.0.0";
    // LoggerManager 实例
    this.otherParams = {};
    // 商品价格缓存：Map<日期, 应用了价格的商品列表>
    this.productsPriceCache = /* @__PURE__ */ new Map();
    // 缓存配置
    this.CACHE_MAX_DAYS = 7;
    // 最多缓存7天
    // 商品格式化器列表
    this.formatters = [];
    // 是否已注册内置价格格式化器
    this.isPriceFormatterRegistered = false;
    this.pendingSyncMessages = [];
  }
  async initialize(core, options) {
    var _a;
    this.core = core;
    this.store = options.store;
    this.otherParams = options.otherParams || {};
    if (Array.isArray((_a = options.initialState) == null ? void 0 : _a.list)) {
      this.store.list = options.initialState.list;
      this.syncProductsMap();
      this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
    } else {
      this.store.list = [];
      this.store.map = /* @__PURE__ */ new Map();
    }
    this.request = core.getPlugin("request");
    const appPlugin = core.getPlugin("app");
    if (appPlugin) {
      const app = appPlugin.getApp();
      this.dbManager = app.dbManager;
      this.logger = app.logger;
      if (this.dbManager) {
        console.log("[Products] IndexDB Manager 已初始化");
      } else {
        console.warn("[Products] IndexDB Manager 未找到");
      }
    }
    this.registerBuiltinPriceFormatter();
    this.initProductDataSource();
    this.setupProductSync();
    this.logInfo("模块初始化完成", {
      hasDbManager: !!this.dbManager,
      hasLogger: !!this.logger,
      initialProductCount: this.store.list.length
    });
  }
  /**
   * 记录信息日志
   * @param title 日志标题
   * @param metadata 日志元数据
   */
  logInfo(title, metadata) {
    try {
      if (this.logger) {
        this.logger.addLog({
          type: "info",
          title: `[ProductsModule] ${title}`,
          metadata: metadata || {}
        });
      }
    } catch {
    }
  }
  /**
   * 记录警告日志
   * @param title 日志标题
   * @param metadata 日志元数据
   */
  logWarning(title, metadata) {
    try {
      if (this.logger) {
        this.logger.addLog({
          type: "warning",
          title: `[ProductsModule] ${title}`,
          metadata: metadata || {}
        });
      }
    } catch {
    }
  }
  /**
   * 记录错误日志
   * @param title 日志标题
   * @param metadata 日志元数据
   */
  logError(title, metadata) {
    try {
      if (this.logger) {
        this.logger.addLog({
          type: "error",
          title: `[ProductsModule] ${title}`,
          metadata: metadata || {}
        });
      }
    } catch {
    }
  }
  /**
   * 加载商品价格（原始方法，不带缓存）
   * @private
   */
  async loadProductsPrice({
    ids = [],
    schedule_date,
    schedule_datetime,
    customer_id
  }) {
    this.logInfo("开始加载商品价格", {
      productCount: ids.length,
      schedule_date,
      schedule_datetime,
      customer_id
    });
    const startTime = Date.now();
    const datetime = schedule_datetime || schedule_date;
    try {
      await this.ensureQuotationBridgeReady(customer_id);
      const idSet = new Set(ids);
      const products = this.getProductsRef().filter((product) => idSet.has(product.id));
      const priceData = products.map((product) => this.buildPriceDataFromQuotation(product, datetime, customer_id));
      const duration = Date.now() - startTime;
      this.logInfo("加载商品价格成功", {
        productCount: ids.length,
        priceDataCount: priceData.length,
        duration: `${duration}ms`
      });
      return priceData;
    } catch (error) {
      const duration = Date.now() - startTime;
      const errorMessage = error instanceof Error ? error.message : String(error);
      this.logError("加载商品价格失败", {
        productCount: ids.length,
        duration: `${duration}ms`,
        error: errorMessage
      });
      return [];
    }
  }
  /**
   * 设置报价单价格桥接器。
   * Server 层负责传入完整 schedule 模块，Products 只负责把报价单计算结果转成价格响应形状。
   */
  async setupQuotationPriceBridge(params) {
    var _a;
    if (!this.core) {
      this.logWarning("setupQuotationPriceBridge: core 尚未初始化");
      return;
    }
    const channel = params.channel || ((_a = this.otherParams) == null ? void 0 : _a.channel);
    this.quotationBridgeChannel = channel;
    if (!this.quotationPriceBridge) {
      const quotation = new import_Quotation.QuotationModule(`${this.name}_quotation_price_bridge`);
      await quotation.initialize(this.core, {});
      this.quotationPriceBridge = quotation;
    }
    if (params.scheduleModule) {
      this.quotationPriceBridge.setScheduleResolver((id) => {
        var _a2, _b, _c, _d, _e, _f;
        const scheduleId = String(id);
        const scheduleList = ((_b = (_a2 = params.scheduleModule).getScheduleList) == null ? void 0 : _b.call(_a2)) || [];
        const schedule = scheduleList.find((item) => String(item.id) === scheduleId);
        if (schedule)
          return schedule;
        const schedules = ((_d = (_c = params.scheduleModule).getScheduleListByIds) == null ? void 0 : _d.call(_c, [id])) || ((_f = (_e = params.scheduleModule).getScheduleByIds) == null ? void 0 : _f.call(_e, [id])) || [];
        return schedules[0];
      });
    }
    await this.refreshQuotationPriceBridge({ customer_id: params.customer_id });
  }
  /**
   * 刷新桥接器内的报价单列表。
   */
  async refreshQuotationPriceBridge(params) {
    if (!this.quotationPriceBridge)
      return;
    const customerId = params && "customer_id" in params ? params.customer_id : this.quotationBridgeCustomerId;
    const refreshKey = this.getQuotationBridgeScopeKey(customerId);
    if (this.quotationBridgeRefreshPromise && this.quotationBridgeRefreshKey === refreshKey) {
      await this.quotationBridgeRefreshPromise;
      return;
    }
    if (this.quotationBridgeRefreshPromise) {
      await this.quotationBridgeRefreshPromise;
    }
    this.quotationBridgeRefreshKey = refreshKey;
    this.quotationBridgeRefreshPromise = this.quotationPriceBridge.loadQuotations({
      channel: this.quotationBridgeChannel,
      customer_id: customerId
    }).then(() => {
      this.quotationBridgeCustomerId = customerId;
    }).finally(() => {
      this.quotationBridgeRefreshPromise = void 0;
      this.quotationBridgeRefreshKey = void 0;
    });
    await this.quotationBridgeRefreshPromise;
  }
  async ensureQuotationBridgeReady(customerId) {
    var _a;
    if (!this.quotationPriceBridge) {
      await this.setupQuotationPriceBridge({
        channel: (_a = this.otherParams) == null ? void 0 : _a.channel,
        customer_id: customerId
      });
      return;
    }
    if (this.quotationBridgeRefreshPromise) {
      await this.quotationBridgeRefreshPromise;
    }
    if (this.getQuotationBridgeScopeKey(customerId) !== this.getQuotationBridgeScopeKey(this.quotationBridgeCustomerId)) {
      await this.refreshQuotationPriceBridge({ customer_id: customerId });
    }
  }
  getQuotationBridgeScopeKey(customerId) {
    return `${this.quotationBridgeChannel || ""}:${customerId ?? ""}`;
  }
  buildPriceDataFromQuotation(product, datetime, customerId) {
    var _a;
    const quotedPrice = (_a = this.quotationPriceBridge) == null ? void 0 : _a.getPriceForProduct({
      productId: product.id,
      datetime,
      customer_id: customerId
    });
    const productPrice = quotedPrice ?? product.price;
    return {
      id: product.id,
      price: String(productPrice ?? 0),
      base_price: String(product.base_price ?? product.price ?? 0),
      variant: this.buildVariantPriceData(product, datetime, customerId),
      bundle_group: this.buildBundleGroupPriceData(product, datetime, customerId)
    };
  }
  buildVariantPriceData(product, datetime, customerId) {
    if (!Array.isArray(product.variant))
      return [];
    return product.variant.map((variant) => {
      var _a;
      const quotedPrice = (_a = this.quotationPriceBridge) == null ? void 0 : _a.getPriceForProduct({
        productId: product.id,
        variantId: Number(variant.id),
        datetime,
        customer_id: customerId
      });
      const price = quotedPrice ?? variant.price ?? product.price ?? 0;
      const basePrice = variant.base_price ?? variant.price ?? product.base_price ?? product.price ?? 0;
      return {
        id: Number(variant.id),
        product_id: Number(variant.product_id ?? product.id),
        base_price: Number(basePrice),
        price: Number(price)
      };
    });
  }
  buildBundleGroupPriceData(product, datetime, customerId) {
    if (!Array.isArray(product.bundle_group))
      return [];
    return product.bundle_group.map((group) => ({
      id: Number(group.id),
      bundle_item: (group.bundle_item || []).map((item) => {
        var _a;
        const bundleProductId = Number(item.bundle_product_id);
        const bundleVariantId = Number(item.bundle_variant_id || 0);
        const quotedPrice = (_a = this.quotationPriceBridge) == null ? void 0 : _a.getPriceForProduct({
          productId: bundleProductId,
          variantId: bundleVariantId,
          datetime,
          customer_id: customerId
        });
        const price = quotedPrice ?? item.price ?? 0;
        const basePrice = item.base_price ?? item.price ?? 0;
        return {
          id: Number(item.id),
          product_id: Number(item.product_id ?? product.id),
          group_id: Number(item.group_id ?? group.id),
          bundle_product_id: bundleProductId,
          bundle_variant_id: bundleVariantId,
          price: Number(price),
          base_price: basePrice,
          price_type: item.price_type,
          price_type_ext: item.price_type_ext
        };
      })
    }));
  }
  /**
   * 获取应用了价格的商品列表（带缓存）
   * 使用日期作为缓存 key，同一天的商品价格会被缓存
   * 缓存的是已经应用了价格的完整商品列表，避免重复转换
   * @param schedule_date 日期
   * @param extraContext 额外的上下文数据（可选，由 Server 层传入）
   * @param options 可选参数
   * @param options.changedIds 变更的商品 IDs，非空时仅对这些商品增量执行 prepare 并更新缓存
   * @param options.productIds 指定商品 IDs，仅对这些商品执行价格计算；不传则处理全量
   * @returns 应用了价格的商品列表
   */
  async getProductsWithPrice(schedule_date, extraContext, options) {
    var _a;
    const t0 = performance.now();
    const scopedProductIds = this.normalizeProductIds(options == null ? void 0 : options.productIds);
    const cacheKey = this.getProductsPriceCacheKey(schedule_date, extraContext, scopedProductIds);
    const scopedProductIdSet = scopedProductIds ? new Set(scopedProductIds) : void 0;
    const changedIds = scopedProductIdSet ? (_a = options == null ? void 0 : options.changedIds) == null ? void 0 : _a.filter((id) => scopedProductIdSet.has(id)) : options == null ? void 0 : options.changedIds;
    if (this.productsPriceCache.has(cacheKey)) {
      const cachedProducts = this.productsPriceCache.get(cacheKey);
      if (changedIds && changedIds.length > 0) {
        this.logInfo("商品价格缓存命中，增量更新变更商品", {
          cacheKey,
          changedIds,
          cachedProductCount: cachedProducts.length
        });
        try {
          const updatedProducts = await this.prepareProductsWithPrice(
            schedule_date,
            extraContext,
            { productIds: changedIds }
          );
          if (updatedProducts.length > 0) {
            const updatedMap = new Map(updatedProducts.map((p) => [p.id, p]));
            const mergedCache = [];
            for (const p of cachedProducts) {
              if (updatedMap.has(p.id)) {
                mergedCache.push(updatedMap.get(p.id));
                updatedMap.delete(p.id);
              } else {
                mergedCache.push(p);
              }
            }
            for (const p of updatedMap.values()) {
              mergedCache.push(p);
            }
            this.productsPriceCache.set(cacheKey, mergedCache);
            this.logInfo("增量更新完成", {
              cacheKey,
              changedCount: updatedProducts.length,
              totalCount: mergedCache.length
            });
            (0, import_product.perfMark)("getProductsWithPrice(incrementalUpdate)", performance.now() - t0, {
              cacheKey,
              changedCount: changedIds.length,
              count: mergedCache.length
            });
            return mergedCache;
          }
        } catch (error) {
          const errorMessage = error instanceof Error ? error.message : String(error);
          this.logError("增量更新失败，返回现有缓存", {
            cacheKey,
            changedIds,
            error: errorMessage
          });
        }
        (0, import_product.perfMark)("getProductsWithPrice(incrementalUpdate)", performance.now() - t0, {
          cacheKey,
          changedCount: changedIds.length,
          count: cachedProducts.length
        });
        return cachedProducts;
      }
      (0, import_product.perfMark)("getProductsWithPrice(cacheHit)", performance.now() - t0, {
        cacheKey,
        count: cachedProducts.length
      });
      this.logInfo("商品价格缓存命中", {
        cacheKey,
        productCount: cachedProducts.length
      });
      return cachedProducts;
    }
    this.logInfo("商品价格缓存未命中，准备获取", {
      cacheKey,
      scopedProductCount: scopedProductIds == null ? void 0 : scopedProductIds.length
    });
    const result = await this.prepareProductsWithPrice(
      schedule_date,
      extraContext,
      scopedProductIds ? { productIds: scopedProductIds } : void 0
    );
    this.productsPriceCache.set(cacheKey, result);
    this.logInfo("商品价格已缓存", {
      cacheKey,
      productCount: result.length
    });
    this.cleanExpiredPriceCache();
    (0, import_product.perfMark)("getProductsWithPrice(cacheMiss)", performance.now() - t0, {
      cacheKey,
      count: result.length
    });
    return result;
  }
  /**
   * 准备带价格的商品数据（通过格式化器流程处理）
   * @param schedule_date 日期
   * @param extraContext 额外的上下文数据（可选）
   * @param options 可选参数
   * @param options.productIds 指定商品 IDs，仅处理这些商品；不传则处理全量
   * @returns 处理后的商品列表
   * @private
   */
  async prepareProductsWithPrice(schedule_date, extraContext, options) {
    var _a, _b;
    const tTotal = performance.now();
    const targetIds = options == null ? void 0 : options.productIds;
    const isIncremental = Array.isArray(targetIds);
    this.logInfo("prepareProductsWithPrice 开始处理", {
      schedule_date,
      mode: isIncremental ? "incremental" : "full",
      targetIdsCount: targetIds == null ? void 0 : targetIds.length
    });
    try {
      let products;
      let ids;
      if (isIncremental) {
        products = this.getProductsRefByIds(targetIds);
        ids = products.map((p) => p.id);
      } else {
        products = this.getProductsRef();
        const tIds = performance.now();
        ids = new Array(products.length);
        for (let i = 0; i < products.length; i++) {
          ids[i] = products[i].id;
        }
        (0, import_product.perfMark)("prepareProducts.extractIds", performance.now() - tIds, { count: ids.length });
      }
      this.logInfo("获取到商品列表", { productCount: products.length });
      const tPrice = performance.now();
      const priceData = await this.loadProductsPrice({
        ids,
        schedule_date,
        schedule_datetime: extraContext == null ? void 0 : extraContext.schedule_datetime,
        customer_id: extraContext == null ? void 0 : extraContext.customer_id
      });
      (0, import_product.perfMark)("prepareProducts.loadPrice", performance.now() - tPrice, { count: ids.length });
      this.logInfo("获取商品报价单价格成功", { priceDataCount: (priceData == null ? void 0 : priceData.length) ?? 0 });
      const context = {
        schedule_date,
        schedule_datetime: extraContext == null ? void 0 : extraContext.schedule_datetime,
        customer_id: extraContext == null ? void 0 : extraContext.customer_id,
        priceData,
        locale: (_b = (_a = this.core) == null ? void 0 : _a.context) == null ? void 0 : _b.locale,
        ...extraContext
      };
      const tFormat = performance.now();
      const processedProducts = await this.applyFormatters(products, context);
      (0, import_product.perfMark)("prepareProducts.applyFormatters", performance.now() - tFormat, {
        count: products.length,
        formatterCount: this.formatters.length
      });
      this.logInfo("prepareProductsWithPrice 处理完成", {
        mode: isIncremental ? "incremental" : "full",
        originalProductCount: products.length,
        processedProductCount: processedProducts.length,
        formatterCount: this.formatters.length
      });
      if (!isIncremental) {
        await this.core.effects.emit(
          import_types.ProductsHooks.onProductsPriceApplied,
          processedProducts
        );
      }
      (0, import_product.perfMark)("prepareProductsWithPrice", performance.now() - tTotal, {
        productCount: products.length,
        formatterCount: this.formatters.length,
        mode: isIncremental ? "incremental" : "full"
      });
      return processedProducts;
    } catch (err) {
      const errorMessage = err instanceof Error ? err.message : String(err);
      console.log(`[ProductsModule] 🌐 ERROR`, err);
      this.logError("prepareProductsWithPrice 处理失败", {
        schedule_date,
        error: errorMessage
      });
    }
    return [];
  }
  getProductsPriceCacheKey(schedule_date, extraContext, productIds) {
    const datetime = (extraContext == null ? void 0 : extraContext.schedule_datetime) || schedule_date;
    const productScope = productIds ? `:products:${productIds.join(",")}` : "";
    return `${datetime}:customer:${(extraContext == null ? void 0 : extraContext.customer_id) ?? ""}${productScope}`;
  }
  normalizeProductIds(productIds) {
    if (!Array.isArray(productIds))
      return void 0;
    return Array.from(new Set(
      productIds.map((id) => Number(id)).filter((id) => Number.isFinite(id))
    )).sort((a, b) => a - b);
  }
  /**
   * 按轻量范围返回商品 ID，不做 structuredClone。
   */
  getProductIdsByScope(scope) {
    const productIds = this.normalizeProductIds(scope.productIds) || [];
    const collectionIds = this.normalizeProductIds(scope.collectionIds) || [];
    if (scope.isAllProducts) {
      return this.getProductsRef().map((product) => product.id);
    }
    if (productIds.length === 0 && collectionIds.length === 0)
      return [];
    const result = /* @__PURE__ */ new Set();
    for (const id of productIds) {
      if (this.store.map.has(id))
        result.add(id);
    }
    if (collectionIds.length === 0)
      return Array.from(result);
    const collectionIdSet = new Set(collectionIds);
    for (const product of this.getProductsRef()) {
      if (result.has(product.id))
        continue;
      if (!Array.isArray(product.collection))
        continue;
      const isInCollection = product.collection.some((collection) => collectionIdSet.has(collection.id));
      if (isInCollection)
        result.add(product.id);
    }
    return Array.from(result);
  }
  /**
   * 应用所有已注册的格式化器
   * @param products 商品列表
   * @param context 上下文信息
   * @returns 格式化后的商品列表
   * @private
   */
  async applyFormatters(products, context) {
    let result = products;
    if (this.formatters.length === 0) {
      console.warn("[ProductsModule] ⚠️ 没有注册任何格式化器");
      this.logWarning("没有注册任何格式化器", { productCount: products.length });
      return result;
    }
    this.logInfo("开始应用格式化器", {
      productCount: products.length,
      formatterCount: this.formatters.length
    });
    for (let i = 0; i < this.formatters.length; i++) {
      const formatter = this.formatters[i];
      try {
        const tF = performance.now();
        result = await formatter(result, context);
        (0, import_product.perfMark)(`applyFormatters[${i}]`, performance.now() - tF, {
          index: i,
          total: this.formatters.length,
          productCount: result.length
        });
      } catch (error) {
        const errorMessage = error instanceof Error ? error.message : String(error);
        console.error(`[ProductsModule] ❌ 格式化器 ${i + 1} 执行失败:`, error);
        this.logError(`格式化器 ${i + 1} 执行失败`, {
          formatterIndex: i + 1,
          totalFormatters: this.formatters.length,
          error: errorMessage
        });
      }
    }
    this.logInfo("所有格式化器已应用", {
      formatterCount: this.formatters.length,
      resultProductCount: result.length
    });
    return result;
  }
  /**
   * 注册内置的价格格式化器
   * 这个格式化器负责将价格数据应用到商品上
   * @private
   */
  registerBuiltinPriceFormatter() {
    if (this.isPriceFormatterRegistered) {
      console.warn("[ProductsModule] 内置价格格式化器已注册，跳过");
      return;
    }
    const priceFormatter = (products, context) => {
      if (!context.priceData || context.priceData.length === 0) {
        console.log("[ProductsModule] 💰 没有价格数据，跳过价格应用");
        return products;
      }
      console.log(`[ProductsModule] 💰 应用价格数据到 ${products.length} 个商品`);
      return (0, import_product.applyPriceDataToProducts)(products, context.priceData);
    };
    const i18nFormatter = (products, context) => {
      return (0, import_product.applyI18nToProducts)(products, context.locale);
    };
    const detailValueFormatter = (products, context) => {
      return (0, import_product.applyDetailValueToProducts)(products, context);
    };
    this.formatters.unshift(priceFormatter);
    this.formatters.push(i18nFormatter);
    this.formatters.push(detailValueFormatter);
    this.isPriceFormatterRegistered = true;
    console.log("[ProductsModule] ✅ 内置价格格式化器已注册（第 1 个）");
  }
  /**
   * 注册商品格式化器
   * 格式化器会按注册顺序依次执行（内置价格格式化器始终是第一个）
   * @param formatter 格式化函数
   * @param prepend 是否插入到队列开头（默认 false，追加到末尾）
   * @example
   * ```ts
   * productsModule.registerFormatter((products, context) => {
   *   return products.map(p => ({
   *     ...p,
   *     custom_field: 'custom_value'
   *   }));
   * });
   * ```
   */
  registerFormatter(formatter, prepend = false) {
    if (prepend) {
      const insertIndex = this.isPriceFormatterRegistered ? 1 : 0;
      this.formatters.splice(insertIndex, 0, formatter);
      console.log(`[ProductsModule] 📌 已在位置 ${insertIndex + 1} 插入格式化器，当前共 ${this.formatters.length} 个`);
    } else {
      this.formatters.push(formatter);
      console.log(`[ProductsModule] 📌 已注册格式化器，当前共 ${this.formatters.length} 个`);
    }
  }
  /**
   * 清空所有格式化器（包括内置价格格式化器）
   * @param keepBuiltin 是否保留内置价格格式化器（默认 true）
   */
  clearFormatters(keepBuiltin = true) {
    if (keepBuiltin && this.isPriceFormatterRegistered) {
      this.formatters = [this.formatters[0]];
      console.log("[ProductsModule] 🧹 已清空自定义格式化器，保留内置价格格式化器");
    } else {
      this.formatters = [];
      this.isPriceFormatterRegistered = false;
      console.log("[ProductsModule] 🧹 已清空所有格式化器");
    }
  }
  /**
   * 清理过期的价格缓存
   * 当缓存数量超过限制时，删除最老的缓存
   * @private
   */
  cleanExpiredPriceCache() {
    if (this.productsPriceCache.size > this.CACHE_MAX_DAYS) {
      const keys = Array.from(this.productsPriceCache.keys());
      const oldestKey = keys[0];
      this.productsPriceCache.delete(oldestKey);
      console.log(`[ProductsModule] 🧹 清理过期商品价格缓存: ${oldestKey}`);
    }
  }
  /**
   * 清空商品价格缓存
   * 可用于手动刷新价格数据
   */
  clearPriceCache() {
    this.productsPriceCache.clear();
    console.log("[ProductsModule] 🗑️ 商品价格缓存已清空");
  }
  /**
   * 通过 ProductDataSource SSE 加载完整商品列表
   */
  async loadProductsByServer() {
    if (!this.productDataSource) {
      this.logWarning("loadProductsByServer: ProductDataSource 不可用");
      return [];
    }
    this.logInfo("开始通过 DataSource SSE 加载商品列表");
    const t0 = performance.now();
    try {
      const tSSE = performance.now();
      const productList = await this.productDataSource.run({ sse: {} });
      const list = productList || [];
      (0, import_product.perfMark)("loadProductsByServer.SSE", performance.now() - tSSE, { count: list.length });
      this.logInfo("通过 DataSource SSE 加载商品列表成功", {
        productCount: list.length,
        duration: `${Math.round(performance.now() - t0)}ms`
      });
      await this.saveProductsToIndexDB(list);
      await this.core.effects.emit(import_types.ProductsHooks.onProductsLoaded, list);
      (0, import_product.perfMark)("loadProductsByServer", performance.now() - t0, { count: list.length });
      return list;
    } catch (error) {
      const duration = Math.round(performance.now() - t0);
      const errorMessage = error instanceof Error ? error.message : String(error);
      console.error("[Products] 加载商品数据失败:", error);
      this.logError("通过 DataSource SSE 加载商品列表失败", {
        duration: `${duration}ms`,
        error: errorMessage
      });
      return [];
    }
  }
  /**
   * 纯请求方法：通过 HTTP 接口获取商品列表（无副作用，不触发事件、不写 IndexDB）
   * @param params 查询参数
   * @returns 商品列表
   */
  async fetchProductsByHttp(params) {
    var _a, _b;
    const {
      category_ids = [],
      product_ids = [],
      collection = [],
      customer_id,
      cacheId
    } = params || {};
    this.logInfo("fetchProductsByHttp: 开始请求", {
      categoryIdsCount: category_ids.length,
      productIdsCount: product_ids.length,
      collectionCount: Array.isArray(collection) ? collection.length : collection ? 1 : 0,
      customer_id
    });
    const startTime = Date.now();
    try {
      const productsData = await this.request.post(
        `/product/query`,
        {
          open_bundle: 1,
          exclude_extension_type: [
            "product_party",
            "product_event",
            "product_series_event",
            "product_package_ticket",
            "ticket",
            "event_item"
          ],
          force_ignore_cache_flag: 1,
          with: [
            "category",
            "collection",
            "resourceRelation",
            "bundleGroup.bundleItem",
            "optionGroup.optionItem",
            "variantGroup.variantItem"
          ],
          open_deposit: 1,
          is_append_product_description: 1,
          with_count: ["bundleGroup", "optionGroup"],
          with_category_tree: 1,
          status: "published",
          num: 500,
          skip: 1,
          category_ids,
          ids: product_ids,
          collection,
          front_end_cache_id: cacheId,
          application_code: (_a = this.otherParams) == null ? void 0 : _a.channel
        },
        { cache: void 0 }
      );
      const productList = ((_b = productsData == null ? void 0 : productsData.data) == null ? void 0 : _b.list) || [];
      const duration = Date.now() - startTime;
      this.logInfo("fetchProductsByHttp: 请求成功", {
        productCount: productList.length,
        duration: `${duration}ms`
      });
      return productList;
    } catch (error) {
      const duration = Date.now() - startTime;
      const errorMessage = error instanceof Error ? error.message : String(error);
      console.error("[Products] fetchProductsByHttp 失败:", error);
      this.logError("fetchProductsByHttp: 请求失败", {
        duration: `${duration}ms`,
        error: errorMessage
      });
      return [];
    }
  }
  /**
   * 加载完整商品列表通过接口（包含所有详细数据）
   * 包含副作用：保存到 IndexDB + 触发 onProductsLoaded 事件
   * @param params 查询参数
   */
  async loadProductsByServerHttp(params) {
    const productList = await this.fetchProductsByHttp(params);
    if (productList.length > 0) {
      await this.saveProductsToIndexDB(productList);
      await this.core.effects.emit(import_types.ProductsHooks.onProductsLoaded, productList);
    }
    return productList;
  }
  /**
   * 获取商品列表（深拷贝，供外部安全使用）
   */
  async getProducts() {
    const t0 = performance.now();
    const result = structuredClone(this.store.list);
    (0, import_product.perfMark)("ProductsModule.getProducts(structuredClone)", performance.now() - t0, { count: result.length });
    return result;
  }
  /**
   * 内部获取商品列表的直接引用（无拷贝）
   * 仅供内部 formatter 流程使用，因为 formatter 会创建新对象
   */
  getProductsRef() {
    return this.store.list;
  }
  /**
   * 按 ID 从 Map 取商品引用，供内部 formatter 流程使用。
   */
  getProductsRefByIds(ids) {
    const products = [];
    for (const id of ids) {
      const product = this.store.map.get(id);
      if (product)
        products.push(product);
    }
    return products;
  }
  /**
   * 根据ID获取单个商品（从内存缓存）
   * 使用 Map 快速查询，时间复杂度 O(1)
   */
  async getProductById(id) {
    const product = this.store.map.get(id);
    return product ? structuredClone(product) : void 0;
  }
  /**
   * 根据 ID 列表删除商品（用于 pubsub 同步删除场景）
   * 同时更新 store.list、store.map、IndexDB 和价格缓存
   */
  async removeProductsByIds(ids) {
    const idSet = new Set(ids);
    this.logInfo("removeProductsByIds", { ids, count: ids.length });
    this.store.list = this.store.list.filter((p) => !idSet.has(p.id));
    for (const id of ids) {
      this.store.map.delete(id);
    }
    if (this.dbManager) {
      try {
        for (const id of ids) {
          await this.dbManager.delete(INDEXDB_STORE_NAME, id);
        }
      } catch (error) {
        const errorMessage = error instanceof Error ? error.message : String(error);
        this.logError("removeProductsByIds: IndexDB 删除失败", { ids, error: errorMessage });
      }
    }
    for (const [dateKey, cachedProducts] of this.productsPriceCache.entries()) {
      this.productsPriceCache.set(
        dateKey,
        cachedProducts.filter((p) => !idSet.has(p.id))
      );
    }
    this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
    this.logInfo("removeProductsByIds 完成", { remaining: this.store.list.length });
  }
  /**
   * 重新从服务器加载全量商品列表并更新本地 store
   * 用于 pubsub 同步 create / update / batch_update 场景
   */
  async refreshProducts() {
    const tTotal = performance.now();
    this.logInfo("refreshProducts 开始");
    const products = await this.loadProductsByServer();
    if (products && products.length > 0) {
      this.store.list = products;
      this.syncProductsMap();
      this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
      this.logInfo("refreshProducts 完成", { productCount: products.length });
    } else {
      this.logWarning("refreshProducts: 服务器未返回数据");
    }
    (0, import_product.perfMark)("refreshProducts", performance.now() - tTotal, { count: this.store.list.length });
    return this.store.list;
  }
  /**
   * 清空缓存
   */
  async clear() {
    this.logInfo("开始清空缓存", {
      currentProductCount: this.store.list.length,
      priceCacheCount: this.productsPriceCache.size
    });
    this.store.list = [];
    this.store.map.clear();
    if (this.dbManager) {
      try {
        await this.dbManager.clear(INDEXDB_STORE_NAME);
        console.log("[Products] IndexDB 缓存已清空");
        this.logInfo("IndexDB 缓存已清空");
      } catch (error) {
        const errorMessage = error instanceof Error ? error.message : String(error);
        console.error("[Products] 清空 IndexDB 缓存失败:", error);
        this.logError("清空 IndexDB 缓存失败", { error: errorMessage });
      }
    }
    console.log("[Products] 缓存已清空");
    this.logInfo("缓存清空完成");
  }
  /**
   * 从 IndexDB 加载商品数据
   * @private
   */
  async loadProductsFromIndexDB() {
    if (!this.dbManager) {
      this.logWarning("loadProductsFromIndexDB: dbManager 不可用");
      return [];
    }
    try {
      const t0 = performance.now();
      const products = await this.dbManager.getAll(INDEXDB_STORE_NAME);
      (0, import_product.perfMark)("loadProductsFromIndexDB", performance.now() - t0, { count: (products == null ? void 0 : products.length) ?? 0 });
      this.logInfo("从 IndexDB 加载商品数据", {
        productCount: (products == null ? void 0 : products.length) ?? 0
      });
      return products || [];
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : String(error);
      console.error("[Products] 从 IndexDB 读取数据失败:", error);
      this.logError("从 IndexDB 读取数据失败", { error: errorMessage });
      return [];
    }
  }
  /**
   * 保存商品数据到 IndexDB（平铺存储）
   * @private
   */
  async saveProductsToIndexDB(products) {
    if (!this.dbManager) {
      this.logWarning("saveProductsToIndexDB: dbManager 不可用");
      return;
    }
    this.logInfo("开始保存商品数据到 IndexDB", { productCount: products.length });
    try {
      const t0 = performance.now();
      await this.dbManager.clear(INDEXDB_STORE_NAME);
      await this.dbManager.bulkUpdate(INDEXDB_STORE_NAME, products);
      (0, import_product.perfMark)("saveProductsToIndexDB", performance.now() - t0, { count: products.length });
      console.log(
        `[Products] 已将 ${products.length} 个商品平铺保存到 IndexDB`
      );
      this.logInfo("商品数据已保存到 IndexDB", { productCount: products.length });
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : String(error);
      console.error("[Products] 保存数据到 IndexDB 失败:", error);
      this.logError("保存数据到 IndexDB 失败", {
        productCount: products.length,
        error: errorMessage
      });
    }
  }
  /**
   * 同步更新商品 Map 缓存
   * 将 list 中的商品同步到 map，以 id 为 key
   * @private
   */
  syncProductsMap() {
    const t0 = performance.now();
    this.store.map.clear();
    for (const product of this.store.list) {
      this.store.map.set(product.id, product);
    }
    (0, import_product.perfMark)("syncProductsMap", performance.now() - t0, { count: this.store.map.size });
  }
  /**
   * 预加载模块数据（统一接口）
   * 在模块注册后自动调用
   */
  async preload() {
    console.log("[Products] 开始预加载数据...");
    const tTotal = performance.now();
    this.logInfo("开始预加载数据");
    try {
      const tIndexDB = performance.now();
      const cachedData = await this.loadProductsFromIndexDB();
      (0, import_product.perfMark)("preload.loadFromIndexDB", performance.now() - tIndexDB, { count: (cachedData == null ? void 0 : cachedData.length) ?? 0 });
      if (cachedData && cachedData.length > 0) {
        console.log(`[Products] 从 IndexDB 加载了 ${cachedData.length} 个商品`);
        this.store.list = cachedData;
        const tSync = performance.now();
        this.syncProductsMap();
        (0, import_product.perfMark)("preload.syncProductsMap", performance.now() - tSync, { count: cachedData.length });
        this.core.effects.emit(
          import_types.ProductsHooks.onProductsChanged,
          this.store.list
        );
        (0, import_product.perfMark)("preload(IndexDB)", performance.now() - tTotal, {
          count: cachedData.length,
          source: "IndexDB"
        });
        this.logInfo("预加载完成（从 IndexDB）", {
          productCount: cachedData.length,
          duration: `${Math.round(performance.now() - tTotal)}ms`,
          source: "IndexDB"
        });
        return;
      }
      console.log("[Products] IndexDB 中没有缓存数据，从服务器加载...");
      this.logInfo("IndexDB 中没有缓存数据，准备从服务器加载");
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : String(error);
      console.warn("[Products] 从 IndexDB 加载数据失败:", error);
      this.logWarning("从 IndexDB 加载数据失败，准备从服务器加载", { error: errorMessage });
    }
    const tServer = performance.now();
    const products = await this.loadProductsByServer();
    (0, import_product.perfMark)("preload.loadFromServer", performance.now() - tServer, { count: (products == null ? void 0 : products.length) ?? 0 });
    if (products && products.length > 0) {
      this.store.list = products;
      const tSync = performance.now();
      this.syncProductsMap();
      (0, import_product.perfMark)("preload.syncProductsMap", performance.now() - tSync, { count: products.length });
      this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
      (0, import_product.perfMark)("preload(Server)", performance.now() - tTotal, {
        count: products.length,
        source: "Server"
      });
      this.logInfo("预加载完成（从服务器）", {
        productCount: products.length,
        duration: `${Math.round(performance.now() - tTotal)}ms`,
        source: "Server"
      });
    } else {
      (0, import_product.perfMark)("preload(empty)", performance.now() - tTotal, { source: "empty" });
      this.logWarning("预加载完成但未获取到数据", {
        duration: `${Math.round(performance.now() - tTotal)}ms`
      });
    }
  }
  // =============================================
  // 商品数据同步（pubsub）
  // =============================================
  /**
   * 初始化 ProductDataSource 实例
   * 与 pubsub 订阅和数据获取分开，仅负责创建实例
   */
  initProductDataSource() {
    var _a, _b;
    const ProductDataSourceClass = (_b = (_a = this.core.serverOptions) == null ? void 0 : _a.All_DATA_SOURCES) == null ? void 0 : _b.ProductDataSource;
    if (!ProductDataSourceClass) {
      this.logWarning("initProductDataSource: ProductDataSource 不可用");
      return;
    }
    this.productDataSource = new ProductDataSourceClass();
    this.logInfo("ProductDataSource 实例已创建");
  }
  /**
   * 初始化 pubsub 订阅，监听管理后台商品变更
   * 仅负责订阅 product / product_quotation 频道，消息通过防抖合并后批量处理
   * 数据获取由 loadProductsByServer 单独负责
   */
  setupProductSync() {
    if (!this.productDataSource) {
      this.logWarning("setupProductSync: ProductDataSource 不可用，跳过同步初始化");
      return;
    }
    const createHandler = (channelKey) => (message) => {
      const data = (message == null ? void 0 : message.data) || message;
      if (!data)
        return;
      console.log(`[ProductsModule] 收到同步消息 [${channelKey}]:`, data);
      this.logInfo("收到同步消息", {
        channelKey,
        action: data.action,
        id: data.id,
        action_filed: data.action_filed
      });
      this.pendingSyncMessages.push({ ...data, _channelKey: channelKey });
      if (this.syncTimer) {
        clearTimeout(this.syncTimer);
      }
      this.syncTimer = setTimeout(() => {
        this.processProductSyncMessages();
      }, PRODUCT_SYNC_DEBOUNCE_MS);
    };
    this.productDataSource.run({
      pubsub: {
        callback: (res) => {
          console.log("sse_products_callback", res);
          this.logInfo("sse_products_callback: 收到同步消息", {
            data: res == null ? void 0 : res.data
          });
          if (!(res == null ? void 0 : res.data))
            return;
          const data = res.data;
          const channelKey = data.module || "product";
          createHandler(channelKey)(data);
        }
      }
    }).catch((err) => {
      this.logError("setupProductSync: DataSource run 出错", {
        error: err instanceof Error ? err.message : String(err)
      });
    });
    this.logInfo("setupProductSync: pubsub 订阅已建立");
  }
  /**
   * 处理防抖后的同步消息批次
   *
   * product 模块：
   *   - operation === 'delete' → 本地删除
   *   - change_types 包含 price → 仅收集变更 IDs（不拉商品数据）
   *   - 有 body → body 完整数据直接覆盖本地
   *   - 其他 → SSE 增量拉取
   *
   * product_collection / product_category：
   *   - 按 relation_product_ids SSE 拉取受影响商品
   *
   * product_quotation：
   *   - 报价单变更影响范围大，直接清除价格缓存走全量重建
   *
   * 处理完成后 emit onProductsSyncCompleted（携带 changedIds），
   * Server 层监听该事件后对变更商品增量执行 prepareProductsWithPrice 并更新缓存
   */
  async processProductSyncMessages() {
    var _a, _b, _c, _d, _e, _f;
    const messages = [...this.pendingSyncMessages];
    this.pendingSyncMessages = [];
    if (messages.length === 0)
      return;
    this.logInfo("processProductSyncMessages: 开始处理", { count: messages.length });
    const deleteIds = [];
    const bodyUpdates = /* @__PURE__ */ new Map();
    const sseRefreshIds = [];
    const priceRefreshIds = [];
    let shouldClearPriceCache = false;
    for (const msg of messages) {
      const channelKey = msg._channelKey || msg.module || "product";
      if (channelKey === "product") {
        if ((_a = msg.relation_product_ids) == null ? void 0 : _a.length) {
          sseRefreshIds.push(...msg.relation_product_ids);
        }
        if (msg.operation === "delete" || msg.action === "delete") {
          if ((_b = msg.ids) == null ? void 0 : _b.length)
            deleteIds.push(...msg.ids);
          else if (msg.id)
            deleteIds.push(msg.id);
          continue;
        }
        if ((_c = msg.change_types) == null ? void 0 : _c.includes("price")) {
          const ids = msg.ids || (msg.id ? [msg.id] : []);
          priceRefreshIds.push(...ids);
          if (msg.body) {
            const bodyId = msg.body.id;
            if (bodyId)
              bodyUpdates.set(bodyId, msg.body);
          }
          continue;
        }
        if (msg.body) {
          const bodyId = msg.body.id || msg.id;
          if (bodyId)
            bodyUpdates.set(bodyId, msg.body);
          continue;
        }
        if ((_d = msg.ids) == null ? void 0 : _d.length) {
          sseRefreshIds.push(...msg.ids);
        } else if (msg.id) {
          sseRefreshIds.push(msg.id);
        }
      } else if (channelKey === "product_quotation") {
        shouldClearPriceCache = true;
        if ((_e = msg.relation_product_ids) == null ? void 0 : _e.length) {
          sseRefreshIds.push(...msg.relation_product_ids);
        }
      } else if (["product_collection", "product_category"].includes(channelKey)) {
        if ((_f = msg.relation_product_ids) == null ? void 0 : _f.length) {
          sseRefreshIds.push(...msg.relation_product_ids);
        }
      }
    }
    const uniqueDeleteIds = [...new Set(deleteIds)];
    const uniqueSSEIds = [...new Set(sseRefreshIds)];
    const uniquePriceIds = [...new Set(priceRefreshIds)];
    if (uniqueDeleteIds.length > 0) {
      await this.removeProductsByIds(uniqueDeleteIds);
    }
    if (bodyUpdates.size > 0) {
      await this.applyBodyUpdatesToStore(bodyUpdates);
    }
    if (uniqueSSEIds.length > 0) {
      const freshProducts = await this.fetchProductsBySSE(uniqueSSEIds);
      if (freshProducts.length > 0) {
        await this.mergeProductsToStore(freshProducts);
      }
      this.logInfo("processProductSyncMessages: SSE 增量更新完成123", {
        requestedCount: uniqueSSEIds.length,
        receivedCount: freshProducts.length
      });
    }
    const allChangedIds = [.../* @__PURE__ */ new Set([
      ...Array.from(bodyUpdates.keys()),
      ...uniqueSSEIds,
      ...uniquePriceIds
    ])];
    this.logInfo("processProductSyncMessages: 处理完成123", {
      deleteCount: uniqueDeleteIds.length,
      bodyUpdateCount: bodyUpdates.size,
      sseRefreshCount: uniqueSSEIds.length,
      priceRefreshCount: uniquePriceIds.length,
      allChangedIdsCount: allChangedIds.length,
      shouldClearPriceCache
    });
    const hasChanges = uniqueDeleteIds.length > 0 || allChangedIds.length > 0 || shouldClearPriceCache;
    if (!hasChanges) {
      this.logInfo("processProductSyncMessages: 没有变更，不触发 onProductsSyncCompleted");
      return;
    }
    if (shouldClearPriceCache) {
      try {
        await this.refreshQuotationPriceBridge();
      } catch (error) {
        const errorMessage = error instanceof Error ? error.message : String(error);
        this.logError("报价单桥接刷新失败，将继续清理价格缓存", { error: errorMessage });
      }
      this.clearPriceCache();
    }
    await this.core.effects.emit(import_types.ProductsHooks.onProductsSyncCompleted, {
      changedIds: allChangedIds
    });
  }
  /**
   * 通过 SSE 按 ids 增量拉取商品数据
   * 请求 GET /shop/core/stream?type=product&ids={ids}
   */
  async fetchProductsBySSE(ids) {
    if (!this.productDataSource) {
      this.logWarning("fetchProductsBySSE: ProductDataSource 不可用");
      return [];
    }
    this.logInfo("fetchProductsBySSE: 开始", { ids, count: ids.length });
    const t0 = performance.now();
    try {
      const productList = await this.productDataSource.run({
        sse: { query: { type: "product", ids } }
      });
      const list = productList || [];
      (0, import_product.perfMark)("fetchProductsBySSE", performance.now() - t0, { count: list.length });
      this.logInfo("fetchProductsBySSE: 成功", {
        requestedCount: ids.length,
        receivedCount: list.length,
        duration: `${Math.round(performance.now() - t0)}ms`
      });
      return list;
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : String(error);
      this.logError("fetchProductsBySSE: 失败", { ids, error: errorMessage });
      return [];
    }
  }
  /**
   * 将 body 完整数据直接覆盖到本地 store（不调用报价单接口）
   * 已存在的 → 直接替换；不存在的 → 追加
   * 同时更新 Map 缓存、IndexDB，触发 onProductsChanged
   * 价格缓存由 processProductSyncMessages 末尾统一清除
   */
  async applyBodyUpdatesToStore(bodyUpdates) {
    this.logInfo("applyBodyUpdatesToStore: 开始", { count: bodyUpdates.size });
    let updatedCount = 0;
    let newCount = 0;
    const appliedIds = /* @__PURE__ */ new Set();
    this.store.list = this.store.list.map((p) => {
      if (bodyUpdates.has(p.id)) {
        updatedCount++;
        appliedIds.add(p.id);
        return bodyUpdates.get(p.id);
      }
      return p;
    });
    for (const [id, body] of bodyUpdates) {
      if (!appliedIds.has(id)) {
        this.store.list.push(body);
        newCount++;
      }
    }
    this.syncProductsMap();
    await this.saveProductsToIndexDB(this.store.list);
    this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
    this.logInfo("applyBodyUpdatesToStore: 完成", {
      updatedCount,
      newCount,
      totalCount: this.store.list.length
    });
  }
  /**
   * 将增量拉取的商品合并到 store
   * 已存在的 → 替换；新的 → 追加
   * 同时更新 store.map、IndexDB，触发 onProductsChanged
   */
  async mergeProductsToStore(freshProducts) {
    const freshMap = /* @__PURE__ */ new Map();
    for (const p of freshProducts) {
      freshMap.set(p.id, p);
    }
    const updatedList = this.store.list.map((p) => {
      if (freshMap.has(p.id)) {
        const fresh = freshMap.get(p.id);
        freshMap.delete(p.id);
        return fresh;
      }
      return p;
    });
    const newCount = freshMap.size;
    for (const p of freshMap.values()) {
      updatedList.push(p);
    }
    const updatedCount = freshProducts.length - newCount;
    this.store.list = updatedList;
    this.syncProductsMap();
    await this.saveProductsToIndexDB(this.store.list);
    this.logInfo("mergeProductsToStore: 合并完成", {
      updatedCount,
      newCount,
      totalCount: this.store.list.length
    });
    this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
  }
  /**
   * 静默全量刷新：后台重新拉取全量 SSE 数据并更新本地
   * 拿到完整数据后一次性替换 store，清除价格缓存，触发 onProductsSyncCompleted
   * @returns 刷新后的商品列表
   */
  async silentRefresh() {
    const t0 = performance.now();
    this.logInfo("silentRefresh 开始");
    try {
      const products = await this.loadProductsByServer();
      if (products && products.length > 0) {
        this.store.list = products;
        this.syncProductsMap();
        this.clearPriceCache();
        this.core.effects.emit(import_types.ProductsHooks.onProductsChanged, this.store.list);
        await this.core.effects.emit(import_types.ProductsHooks.onProductsSyncCompleted, null);
        this.logInfo("silentRefresh 完成", {
          productCount: products.length,
          duration: `${Math.round(performance.now() - t0)}ms`
        });
      } else {
        this.logWarning("silentRefresh: 服务器未返回数据");
      }
      (0, import_product.perfMark)("silentRefresh", performance.now() - t0, { count: this.store.list.length });
      return this.store.list;
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : String(error);
      this.logError("silentRefresh 失败", {
        duration: `${Math.round(performance.now() - t0)}ms`,
        error: errorMessage
      });
      return this.store.list;
    }
  }
  /**
   * 销毁同步资源（取消 pubsub 订阅、清除定时器）
   */
  destroyProductSync() {
    var _a;
    if (this.syncTimer) {
      clearTimeout(this.syncTimer);
      this.syncTimer = void 0;
    }
    if ((_a = this.productDataSource) == null ? void 0 : _a.destroy) {
      this.productDataSource.destroy();
    }
    this.pendingSyncMessages = [];
    this.logInfo("destroyProductSync: 同步资源已销毁");
  }
  /**
   * 获取模块的路由定义
   * Products 模块暂不提供路由，由 Server 层统一处理
   */
  getRoutes() {
    return [];
  }
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  ProductsModule
});
