@pisell/pisellos 2.1.119 → 2.1.120

package/lib/solution/ScanOrder/index.js

@@ -0,0 +1,1071 @@
+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 __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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/solution/ScanOrder/index.ts
+var ScanOrder_exports = {};
+__export(ScanOrder_exports, {
+  ScanOrderImpl: () => ScanOrderImpl
+});
+module.exports = __toCommonJS(ScanOrder_exports);
+var import_BaseModule = require("../../modules/BaseModule");
+var import_types = require("./types");
+var import_utils = require("./utils");
+var import_types2 = require("../BookingByStep/types");
+var import_dayjs = __toESM(require("dayjs"));
+var import_itemRule = require("../../model/strategy/adapter/itemRule");
+__reExport(ScanOrder_exports, require("./types"), module.exports);
+var ScanOrderImpl = class extends import_BaseModule.BaseModule {
+  constructor(name, version) {
+    super(name, version);
+    this.defaultName = "scanOrder";
+    this.defaultVersion = "1.0.0";
+    this.isSolution = true;
+    this.initializeOptions = {};
+    this.store = {
+      entryContext: null,
+      status: "idle",
+      config: null,
+      resource: null,
+      flow: {},
+      error: null,
+      products: void 0,
+      itemRuleQuantityLimits: [],
+      cartValidation: {
+        passed: null,
+        failures: []
+      }
+    };
+    this.otherParams = {};
+    this.itemRuleEvaluator = new import_itemRule.ItemRuleEvaluator();
+    this.itemRuleConfigs = [];
+    this.itemRuleConfigsPromise = null;
+    this.itemRulePrefillApplied = false;
+    this.itemRuleRuntimeConfig = {};
+  }
+  getScanOrderLoggerContext() {
+    return {
+      cacheId: this.cacheId,
+      solutionName: this.name,
+      moduleName: "scanOrder"
+    };
+  }
+  serializeError(error) {
+    if (error instanceof Error) {
+      return {
+        name: error.name,
+        message: error.message,
+        stack: error.stack
+      };
+    }
+    return {
+      message: String(error)
+    };
+  }
+  async addScanOrderLog(params) {
+    const payload = {
+      cacheId: this.cacheId,
+      ...params.payload || {}
+    };
+    const extra = {
+      ...params.extra || {}
+    };
+    const logger = this.store.scanOrderLogger;
+    if (!logger) {
+      if ((params.level || "info") === "error") {
+        console.error("[ScanOrder][log-fallback]", params.title, { payload, extra });
+      } else {
+        console.log("[ScanOrder][log-fallback]", params.title, { payload, extra });
+      }
+      return;
+    }
+    await logger.addLog({
+      ...params,
+      payload,
+      extra
+    });
+  }
+  logMethodStart(method, payload = {}) {
+    void this.addScanOrderLog({
+      level: "info",
+      title: `[ScanOrder] ${method} start`,
+      payload: {
+        method,
+        ...payload
+      }
+    });
+  }
+  logMethodSuccess(method, payload = {}) {
+    void this.addScanOrderLog({
+      level: "info",
+      title: `[ScanOrder] ${method} success`,
+      payload: {
+        method,
+        ...payload
+      }
+    });
+  }
+  logMethodError(method, error, payload = {}) {
+    void this.addScanOrderLog({
+      level: "error",
+      title: `[ScanOrder] ${method} failed`,
+      payload: {
+        method,
+        ...payload,
+        error: this.serializeError(error)
+      }
+    });
+  }
+  async addLog(params) {
+    await this.addScanOrderLog({
+      ...params,
+      payload: {
+        source: "ui-bridge",
+        ...params.payload || {}
+      }
+    });
+  }
+  async initialize(core, options = {}) {
+    var _a, _b, _c, _d, _e, _f;
+    this.logMethodStart("initialize");
+    this.core = core;
+    this.initializeOptions = options || {};
+    this.store = { ...this.store, ...options.store };
+    this.store.entryContext = ((_a = options.otherParams) == null ? void 0 : _a.entryContext) || this.store.entryContext;
+    this.store.status = "initializing";
+    this.store.error = null;
+    this.otherParams = options.otherParams || {};
+    this.cacheId = (_b = this.otherParams) == null ? void 0 : _b.cacheId;
+    this.itemRuleRuntimeConfig = ((_c = this.otherParams) == null ? void 0 : _c.scanOrderItemRule) || ((_d = this.otherParams) == null ? void 0 : _d.itemRule) || {};
+    this.itemRuleConfigs = [];
+    this.itemRuleConfigsPromise = null;
+    this.itemRulePrefillApplied = false;
+    this.store.itemRuleQuantityLimits = [];
+    this.store.cartValidation = {
+      passed: null,
+      failures: []
+    };
+    this.window = core.getPlugin("window");
+    this.request = core.getPlugin("request");
+    if (!this.window) {
+      this.logMethodError("initialize", "window plugin missing");
+      throw new Error("scanOrder解决方案需要 window 插件支持");
+    }
+    if (!this.request) {
+      this.logMethodError("initialize", "request plugin missing");
+      throw new Error("scanOrder解决方案需要 request 插件支持");
+    }
+    const moduleArr = [
+      "scanOrderLogger",
+      "products",
+      "order",
+      "salesSummary"
+    ];
+    moduleArr.forEach((step) => {
+      var _a2, _b2, _c2, _d2, _e2, _f2;
+      const targetModule = (0, import_types2.createModule)(step, this.name);
+      if (targetModule) {
+        this.store[step] = targetModule;
+        const initialState = step === "salesSummary" ? {
+          summary: ((_b2 = (_a2 = this.store.order) == null ? void 0 : _a2.getTempOrder()) == null ? void 0 : _b2.summary) || (0, import_utils.createEmptySummary)()
+        } : {};
+        const loggerProvider = ((_c2 = this.otherParams) == null ? void 0 : _c2.scanOrderLoggerProvider) || "feishu";
+        const loggerConfig = ((_d2 = this.otherParams) == null ? void 0 : _d2.scanOrderLoggerConfig) || {
+          feishu: {
+            // webhook: 'https://open.feishu.cn/open-apis/bot/v2/hook/216b3fe6-af98-424e-8706-f0471241a7ed',
+          }
+        };
+        this.core.registerModule(targetModule, {
+          initialState,
+          otherParams: {
+            ...this.otherParams,
+            fatherModule: this.name,
+            openCache: ((_e2 = this.otherParams) == null ? void 0 : _e2.cacheId) ? true : false,
+            cacheId: (_f2 = this.otherParams) == null ? void 0 : _f2.cacheId,
+            salesSummaryModuleName: `${this.name}_salesSummary`,
+            provider: loggerProvider,
+            providerConfig: loggerConfig,
+            context: this.getScanOrderLoggerContext()
+          }
+        });
+      } else {
+        this.logMethodError("initialize", `module ${step} missing`);
+        throw new Error(`模块 ${step} 不存在`);
+      }
+    });
+    if (this.store.scanOrderLogger) {
+      this.store.scanOrderLogger.setContext(this.getScanOrderLoggerContext());
+    }
+    console.log("[ScanOrder] 初始化开始");
+    try {
+      await ((_e = this.store.order) == null ? void 0 : _e.recalculateSummary({ createIfMissing: false }));
+      (_f = this.store.order) == null ? void 0 : _f.persistTempOrder();
+      await this.loadRuntimeConfigs();
+      await this.refreshItemRuleQuantityLimits();
+      this.store.status = "ready";
+      console.log("[ScanOrder] 初始化完成");
+      await this.core.effects.emit(import_types.ScanOrderHooks.onInited, {
+        status: this.store.status
+      });
+      this.logMethodSuccess("initialize", {
+        status: this.store.status
+      });
+    } catch (error) {
+      this.store.status = "error";
+      this.store.error = error instanceof Error ? error.message : "初始化失败";
+      console.error("[ScanOrder] 初始化失败", error);
+      this.logMethodError("initialize", error, {
+        status: this.store.status
+      });
+      throw error;
+    }
+  }
+  async destroy() {
+    this.logMethodStart("destroy");
+    await this.core.effects.emit(import_types.ScanOrderHooks.onDestroy, {});
+    console.log("[ScanOrder] 已销毁");
+    this.logMethodSuccess("destroy");
+  }
+  async retryInit() {
+    this.logMethodStart("retryInit");
+    console.log("[ScanOrder] retryInit 调用");
+    await this.core.effects.emit(import_types.ScanOrderHooks.onRetryInit, {});
+    try {
+      await this.initialize(this.core, this.initializeOptions);
+      this.logMethodSuccess("retryInit");
+    } catch (error) {
+      this.logMethodError("retryInit", error);
+      throw error;
+    }
+  }
+  async refresh() {
+    this.logMethodStart("refresh");
+    console.log("[ScanOrder] refresh 调用");
+    try {
+      this.store.status = "initializing";
+      await this.loadRuntimeConfigs();
+      await this.refreshItemRuleQuantityLimits();
+      this.store.status = "ready";
+      await this.core.effects.emit(import_types.ScanOrderHooks.onRefresh, {
+        status: this.store.status
+      });
+      this.logMethodSuccess("refresh", {
+        status: this.store.status
+      });
+    } catch (error) {
+      this.logMethodError("refresh", error);
+      throw error;
+    }
+  }
+  getStatus() {
+    this.logMethodStart("getStatus");
+    const result = this.store.status;
+    this.logMethodSuccess("getStatus", {
+      status: result
+    });
+    return result;
+  }
+  getEntryContext() {
+    this.logMethodStart("getEntryContext");
+    const result = this.store.entryContext;
+    this.logMethodSuccess("getEntryContext", {
+      hasEntryContext: Boolean(result)
+    });
+    return result;
+  }
+  getConfig() {
+    this.logMethodStart("getConfig");
+    const result = this.store.config || {};
+    this.logMethodSuccess("getConfig", {
+      configKeys: Object.keys(result || {})
+    });
+    return result;
+  }
+  getItemRuleQuantityLimits() {
+    this.logMethodStart("getItemRuleQuantityLimits");
+    const result = this.store.itemRuleQuantityLimits || [];
+    this.logMethodSuccess("getItemRuleQuantityLimits", {
+      limitCount: result.length
+    });
+    return result;
+  }
+  getCartValidationPassed() {
+    var _a;
+    this.logMethodStart("getCartValidationPassed");
+    const result = ((_a = this.store.cartValidation) == null ? void 0 : _a.passed) ?? null;
+    this.logMethodSuccess("getCartValidationPassed", {
+      cartValidationPassed: result
+    });
+    return result;
+  }
+  getCartValidation() {
+    this.logMethodStart("getCartValidation");
+    const result = this.store.cartValidation || {
+      passed: null,
+      failures: []
+    };
+    this.logMethodSuccess("getCartValidation", {
+      cartValidationPassed: result.passed,
+      failureCount: Array.isArray(result.failures) ? result.failures.length : 0
+    });
+    return result;
+  }
+  getTempOrder() {
+    var _a, _b, _c;
+    this.logMethodStart("getTempOrder");
+    const result = ((_a = this.store.order) == null ? void 0 : _a.getTempOrder()) || null;
+    this.logMethodSuccess("getTempOrder", {
+      hasTempOrder: Boolean(result),
+      productCount: ((_b = result == null ? void 0 : result.products) == null ? void 0 : _b.length) || 0,
+      noteLength: ((_c = result == null ? void 0 : result.note) == null ? void 0 : _c.length) || 0
+    });
+    return result;
+  }
+  updateTempOrderNote(note) {
+    this.logMethodStart("updateTempOrderNote", {
+      noteLength: String(note || "").length
+    });
+    try {
+      if (!this.store.order)
+        throw new Error("order 模块未初始化");
+      const result = this.store.order.updateTempOrderNote(note);
+      this.logMethodSuccess("updateTempOrderNote", {
+        noteLength: result.length
+      });
+      return result;
+    } catch (error) {
+      this.logMethodError("updateTempOrderNote", error);
+      throw error;
+    }
+  }
+  ensureTempOrder() {
+    if (!this.store.order)
+      throw new Error("order 模块未初始化");
+    return this.store.order.ensureTempOrder();
+  }
+  // 主动创建临时订单；若已存在则直接返回已有订单
+  async addNewOrder() {
+    this.logMethodStart("addNewOrder");
+    try {
+      if (!this.store.order)
+        throw new Error("order 模块未初始化");
+      const tempOrder = await this.store.order.addNewOrder();
+      this.logMethodSuccess("addNewOrder", {
+        productCount: tempOrder.products.length
+      });
+      return tempOrder;
+    } catch (error) {
+      this.logMethodError("addNewOrder", error);
+      throw error;
+    }
+  }
+  getOrderProducts() {
+    this.logMethodStart("getOrderProducts");
+    if (!this.store.order)
+      throw new Error("order 模块未初始化");
+    const products = this.store.order.getOrderProducts();
+    this.logMethodSuccess("getOrderProducts", {
+      productCount: products.length
+    });
+    return products;
+  }
+  async getSummary() {
+    this.logMethodStart("getSummary");
+    try {
+      if (!this.store.order)
+        throw new Error("order 模块未初始化");
+      const summary = await this.store.order.getScanOrderSummary();
+      this.logMethodSuccess("getSummary", {
+        totalAmount: summary.total_amount
+      });
+      return summary;
+    } catch (error) {
+      this.logMethodError("getSummary", error);
+      throw error;
+    }
+  }
+  async submitScanOrder() {
+    var _a;
+    this.logMethodStart("submitScanOrder");
+    try {
+      await this.validateBeforeSubmitByItemRule();
+      if (!this.store.order) {
+        throw new Error("scanOrder解决方案需要 order 模块支持");
+      }
+      const result = await this.store.order.submitTempOrder({
+        cacheId: this.cacheId
+      });
+      const tempOrder = this.store.order.getTempOrder();
+      this.logMethodSuccess("submitScanOrder", {
+        productCount: ((_a = tempOrder == null ? void 0 : tempOrder.products) == null ? void 0 : _a.length) || 0
+      });
+      return result;
+    } catch (error) {
+      this.logMethodError("submitScanOrder", error);
+      throw error;
+    }
+  }
+  async addProductToOrder(product) {
+    this.logMethodStart("addProductToOrder", {
+      product_id: product.product_id,
+      product_variant_id: product.product_variant_id
+    });
+    try {
+      if (!this.store.order)
+        throw new Error("order 模块未初始化");
+      const products = await this.store.order.addProductToOrder(product);
+      await this.refreshItemRuleQuantityLimits();
+      await this.refreshCartValidationPassed();
+      this.logMethodSuccess("addProductToOrder", {
+        productCount: products.length
+      });
+      return products;
+    } catch (error) {
+      this.logMethodError("addProductToOrder", error);
+      throw error;
+    }
+  }
+  async updateProductInOrder(params) {
+    this.logMethodStart("updateProductInOrder", {
+      product_id: params.product_id,
+      product_variant_id: params.product_variant_id
+    });
+    try {
+      if (!this.store.order)
+        throw new Error("order 模块未初始化");
+      const products = await this.store.order.updateProductInOrder(params);
+      await this.refreshItemRuleQuantityLimits();
+      await this.refreshCartValidationPassed();
+      this.logMethodSuccess("updateProductInOrder", {
+        productCount: products.length
+      });
+      return products;
+    } catch (error) {
+      this.logMethodError("updateProductInOrder", error);
+      throw error;
+    }
+  }
+  async removeProductFromOrder(identity) {
+    this.logMethodStart("removeProductFromOrder", {
+      product_id: identity.product_id,
+      product_variant_id: identity.product_variant_id
+    });
+    try {
+      if (!this.store.order)
+        throw new Error("order 模块未初始化");
+      const products = await this.store.order.removeProductFromOrder(identity);
+      await this.refreshItemRuleQuantityLimits();
+      await this.refreshCartValidationPassed();
+      this.logMethodSuccess("removeProductFromOrder", {
+        productCount: products.length
+      });
+      return products;
+    } catch (error) {
+      this.logMethodError("removeProductFromOrder", error);
+      throw error;
+    }
+  }
+  async loadRuntimeConfigs() {
+    const itemRuleConfigs = await this.ensureItemRuleConfigsLoaded();
+    this.logMethodSuccess("loadRuntimeConfigs", {
+      itemRuleCount: itemRuleConfigs.length
+    });
+    return {
+      itemRuleConfigs
+    };
+  }
+  async syncItemRuleConfigsFromDineInConfig(dineInConfig) {
+    const enableItemRules = (0, import_utils.toBoolean)(dineInConfig == null ? void 0 : dineInConfig["sale.enable_item_rules"]);
+    const strategyModelIds = (0, import_utils.normalizeEnabledItemRuleIds)(
+      dineInConfig == null ? void 0 : dineInConfig["sale.enabled_item_rules"]
+    );
+    if (!enableItemRules || !strategyModelIds.length) {
+      this.itemRuleConfigs = [];
+      this.itemRuleConfigsPromise = Promise.resolve([]);
+      this.itemRuleEvaluator.setStrategyConfigs([]);
+      this.logMethodSuccess("syncItemRuleConfigsFromDineInConfig", {
+        enabled: enableItemRules,
+        strategyModelIds: [],
+        itemRuleCount: 0
+      });
+      return [];
+    }
+    const itemRuleConfigs = await this.fetchItemRuleConfigsByModelIds(
+      strategyModelIds
+    );
+    this.itemRuleConfigs = itemRuleConfigs;
+    this.itemRuleConfigsPromise = Promise.resolve(itemRuleConfigs);
+    this.itemRuleEvaluator.setStrategyConfigs(itemRuleConfigs);
+    this.logMethodSuccess("syncItemRuleConfigsFromDineInConfig", {
+      enabled: enableItemRules,
+      strategyModelIds,
+      itemRuleCount: itemRuleConfigs.length
+    });
+    return itemRuleConfigs;
+  }
+  async fetchItemRuleConfigsByModelIds(strategyModelIds) {
+    this.logMethodStart("fetchItemRuleConfigsByModelIds", {
+      strategyModelIds
+    });
+    if (!strategyModelIds.length)
+      return [];
+    try {
+      const result = await this.request.get("/promotion", {
+        skip: 1,
+        num: 99,
+        status: "active",
+        ids: strategyModelIds
+      });
+      let configs = [];
+      if (result.code === 200) {
+        configs = result.data.list.map((item) => {
+          return item.metadata;
+        });
+      }
+      this.logMethodSuccess("fetchItemRuleConfigsByModelIds", {
+        strategyModelIds,
+        strategyCount: configs.length
+      });
+      return configs;
+    } catch (error) {
+      this.logMethodError("fetchItemRuleConfigsByModelIds", error, {
+        strategyModelIds
+      });
+      return [];
+    }
+  }
+  async buildPrefillProductSourceMap() {
+    const sourceMap = /* @__PURE__ */ new Map();
+    try {
+      const productList = await this.getProductList();
+      if (!Array.isArray(productList))
+        return sourceMap;
+      const visited = /* @__PURE__ */ new Set();
+      const collectFromValue = (value) => {
+        if (!value || typeof value !== "object")
+          return;
+        if (visited.has(value))
+          return;
+        visited.add(value);
+        if (Array.isArray(value)) {
+          for (const item of value)
+            collectFromValue(item);
+          return;
+        }
+        const node = value;
+        const rawProductId = node.product_id ?? node.id;
+        const productId = Number(rawProductId);
+        if (Number.isFinite(productId) && productId > 0) {
+          const productVariantId = Number(
+            node.product_variant_id ?? node.variant_id ?? 0
+          );
+          const normalizedVariantId = Number.isNaN(productVariantId) ? 0 : productVariantId;
+          const key = (0, import_utils.buildProductKey)(productId, normalizedVariantId);
+          if (!sourceMap.has(key)) {
+            sourceMap.set(key, node);
+          }
+        }
+        for (const childValue of Object.values(node)) {
+          if (childValue && typeof childValue === "object") {
+            collectFromValue(childValue);
+          }
+        }
+      };
+      collectFromValue(productList);
+    } catch (error) {
+      this.logMethodError("buildPrefillProductSourceMap", error);
+    }
+    return sourceMap;
+  }
+  getItemRuleRuntimeConfig() {
+    return this.itemRuleRuntimeConfig || {};
+  }
+  async ensureItemRuleConfigsLoaded() {
+    if (this.itemRuleConfigs.length > 0)
+      return this.itemRuleConfigs;
+    if (this.itemRuleConfigsPromise)
+      return this.itemRuleConfigsPromise;
+    this.itemRuleConfigsPromise = (async () => {
+      const runtimeConfig = this.getItemRuleRuntimeConfig();
+      const staticConfigs = (0, import_utils.normalizeItemRuleStrategies)(runtimeConfig.strategyConfigs);
+      if (staticConfigs.length > 0) {
+        this.itemRuleConfigs = staticConfigs;
+        this.itemRuleEvaluator.setStrategyConfigs(staticConfigs);
+        return this.itemRuleConfigs;
+      }
+      this.itemRuleConfigs = [];
+      this.itemRuleEvaluator.setStrategyConfigs([]);
+      return this.itemRuleConfigs;
+    })();
+    const loadedConfigs = await this.itemRuleConfigsPromise;
+    return loadedConfigs;
+  }
+  async refreshItemRuleQuantityLimits() {
+    try {
+      const strategyConfigs = await this.ensureItemRuleConfigsLoaded();
+      if (!strategyConfigs.length) {
+        this.store.itemRuleQuantityLimits = [];
+        return [];
+      }
+      const businessData = (0, import_utils.buildItemRuleBusinessData)({
+        tempOrder: this.ensureTempOrder(),
+        runtimeConfig: this.getItemRuleRuntimeConfig(),
+        itemRuleConfigs: this.itemRuleConfigs
+      });
+      const limits = this.itemRuleEvaluator.getQuantityLimits(businessData);
+      this.store.itemRuleQuantityLimits = limits;
+      this.logMethodSuccess("refreshItemRuleQuantityLimits", {
+        limitCount: limits.length
+      });
+      return limits;
+    } catch (error) {
+      this.store.itemRuleQuantityLimits = [];
+      this.logMethodError("refreshItemRuleQuantityLimits", error);
+      return [];
+    }
+  }
+  async applyPrefillByItemRule() {
+    var _a, _b, _c;
+    if (this.itemRulePrefillApplied)
+      return;
+    if (!this.store.order)
+      return;
+    const strategyConfigs = await this.ensureItemRuleConfigsLoaded();
+    if (!strategyConfigs.length)
+      return;
+    const businessData = (0, import_utils.buildItemRuleBusinessData)({
+      tempOrder: this.ensureTempOrder(),
+      runtimeConfig: this.getItemRuleRuntimeConfig(),
+      itemRuleConfigs: this.itemRuleConfigs
+    });
+    const prefillItems = this.itemRuleEvaluator.getPrefillItems(businessData);
+    if (!prefillItems.length) {
+      this.itemRulePrefillApplied = true;
+      return;
+    }
+    const productSourceMap = await this.buildPrefillProductSourceMap();
+    const tempOrder = this.ensureTempOrder();
+    let hasChanges = false;
+    for (const prefillItem of prefillItems) {
+      const productId = Number(prefillItem.product_id);
+      const productVariantId = Number(prefillItem.product_variant_id ?? 0);
+      const targetQuantity = (0, import_utils.toNonNegativeInt)(prefillItem.quantity);
+      if (!Number.isFinite(productId) || targetQuantity <= 0)
+        continue;
+      if (Number.isNaN(productVariantId))
+        continue;
+      const sourceItem = productSourceMap.get(
+        (0, import_utils.buildProductKey)(productId, productVariantId)
+      ) || productSourceMap.get((0, import_utils.buildProductKey)(productId, 0)) || null;
+      const productIndex = (0, import_utils.getProductIdentityIndex)(tempOrder.products, {
+        product_id: productId,
+        product_variant_id: productVariantId
+      });
+      if (productIndex === -1) {
+        const sellingPrice = (0, import_utils.toPriceString)(
+          (sourceItem == null ? void 0 : sourceItem.price) ?? (sourceItem == null ? void 0 : sourceItem.selling_price),
+          "0.00"
+        );
+        const originalPrice = (0, import_utils.toPriceString)(
+          (sourceItem == null ? void 0 : sourceItem.original_price) ?? (sourceItem == null ? void 0 : sourceItem.price) ?? sellingPrice,
+          sellingPrice
+        );
+        const paymentPrice = (0, import_utils.toPriceString)(
+          (sourceItem == null ? void 0 : sourceItem.payment_price) ?? (sourceItem == null ? void 0 : sourceItem.price) ?? sellingPrice,
+          sellingPrice
+        );
+        tempOrder.products.push(
+          (0, import_utils.normalizeOrderProduct)({
+            product_id: productId,
+            product_variant_id: productVariantId,
+            num: targetQuantity,
+            selling_price: sellingPrice,
+            original_price: originalPrice,
+            payment_price: paymentPrice,
+            metadata: {
+              item_rule_prefill: true,
+              item_rule_id: prefillItem.ruleId
+            },
+            _origin: {
+              ...sourceItem || {},
+              item_rule_prefill: true,
+              item_rule_id: prefillItem.ruleId
+            }
+          })
+        );
+        hasChanges = true;
+        continue;
+      }
+      const targetProduct = tempOrder.products[productIndex];
+      const existedQuantity = (0, import_utils.toNonNegativeInt)(targetProduct.num);
+      const delta = targetQuantity - existedQuantity;
+      const nextProduct = {
+        ...targetProduct,
+        ...delta > 0 ? { num: (0, import_utils.getSafeProductNum)(existedQuantity + delta) } : {},
+        metadata: {
+          ...targetProduct.metadata || {},
+          item_rule_prefill: true,
+          item_rule_id: prefillItem.ruleId
+        },
+        _origin: sourceItem ? {
+          ...targetProduct._origin || {},
+          ...sourceItem
+        } : targetProduct._origin
+      };
+      const hasQuantityChanged = delta > 0;
+      const hasOriginChanged = Boolean(
+        sourceItem && (!targetProduct._origin || ((_a = targetProduct._origin) == null ? void 0 : _a.name) !== (sourceItem == null ? void 0 : sourceItem.name) || ((_b = targetProduct._origin) == null ? void 0 : _b.title) !== (sourceItem == null ? void 0 : sourceItem.title) || ((_c = targetProduct._origin) == null ? void 0 : _c.price) !== (sourceItem == null ? void 0 : sourceItem.price))
+      );
+      if (hasQuantityChanged || hasOriginChanged) {
+        tempOrder.products[productIndex] = nextProduct;
+        hasChanges = true;
+      }
+    }
+    if (hasChanges) {
+      await this.store.order.recalculateSummary({ createIfMissing: true });
+      this.store.order.persistTempOrder();
+    }
+    await this.refreshItemRuleQuantityLimits();
+    this.itemRulePrefillApplied = true;
+    this.logMethodSuccess("applyPrefillByItemRule", {
+      prefillCount: prefillItems.length,
+      hasChanges
+    });
+  }
+  async applyItemRulePrefill() {
+    this.logMethodStart("applyItemRulePrefill");
+    await this.applyPrefillByItemRule();
+    await this.refreshItemRuleQuantityLimits();
+    await this.refreshCartValidationPassed();
+  }
+  async evaluateCartValidationByItemRule() {
+    const strategyConfigs = await this.ensureItemRuleConfigsLoaded();
+    if (!strategyConfigs.length) {
+      return {
+        passed: true,
+        failures: []
+      };
+    }
+    const businessData = (0, import_utils.buildItemRuleBusinessData)({
+      tempOrder: this.ensureTempOrder(),
+      runtimeConfig: this.getItemRuleRuntimeConfig(),
+      itemRuleConfigs: this.itemRuleConfigs
+    });
+    return this.itemRuleEvaluator.validateCart(businessData);
+  }
+  async validateBeforeSubmitByItemRule() {
+    const validationResult = await this.evaluateCartValidationByItemRule();
+    if (validationResult.passed)
+      return;
+    const firstFailure = validationResult.failures[0];
+    const errorMessage = (firstFailure == null ? void 0 : firstFailure.validationMessage) || "当前购物车未满足商品规则，请调整后再提交";
+    const error = new Error(String(errorMessage));
+    error.failures = validationResult.failures;
+    throw error;
+  }
+  async refreshCartValidationPassed() {
+    const previous = this.store.cartValidation || {
+      passed: null,
+      failures: []
+    };
+    let nextState = {
+      passed: null,
+      failures: []
+    };
+    try {
+      const validationResult = await this.evaluateCartValidationByItemRule();
+      nextState = {
+        passed: validationResult.passed,
+        failures: validationResult.failures || []
+      };
+    } catch (error) {
+      nextState = {
+        passed: false,
+        failures: []
+      };
+    }
+    this.store.cartValidation = nextState;
+    const changed = previous.passed !== nextState.passed || previous.failures !== nextState.failures;
+    if (changed) {
+      await this.core.effects.emit(import_types.ScanOrderHooks.onCartValidationChanged, {
+        cartValidation: nextState,
+        cartValidationPassed: nextState.passed
+      });
+    }
+    return nextState.passed;
+  }
+  async setItemRuleRuntimeConfig(config = {}) {
+    var _a, _b;
+    this.logMethodStart("setItemRuleRuntimeConfig");
+    this.itemRuleRuntimeConfig = {
+      ...this.itemRuleRuntimeConfig,
+      ...config,
+      pax: {
+        ...((_a = this.itemRuleRuntimeConfig) == null ? void 0 : _a.pax) || {},
+        ...(config == null ? void 0 : config.pax) || {}
+      },
+      custom: {
+        ...((_b = this.itemRuleRuntimeConfig) == null ? void 0 : _b.custom) || {},
+        ...(config == null ? void 0 : config.custom) || {}
+      }
+    };
+    if ("strategyConfigs" in config) {
+      this.itemRuleConfigs = [];
+      this.itemRuleConfigsPromise = null;
+      this.itemRuleEvaluator.setStrategyConfigs([]);
+    }
+    this.itemRulePrefillApplied = false;
+    await this.refreshItemRuleQuantityLimits();
+    await this.refreshCartValidationPassed();
+    this.logMethodSuccess("setItemRuleRuntimeConfig", {
+      strategyCount: Array.isArray(this.itemRuleRuntimeConfig.strategyConfigs) ? this.itemRuleRuntimeConfig.strategyConfigs.length : 0
+    });
+  }
+  normalizeResourceState(config, hasOrderId) {
+    var _a, _b;
+    const orderNumberPrefix = Array.isArray(config == null ? void 0 : config.order_number_prefix) ? (config == null ? void 0 : config.order_number_prefix) || [] : [];
+    const tableMaxNumber = Number((config == null ? void 0 : config.table_max_number) || 1);
+    const orderCount = (0, import_utils.toNonNegativeNumber)(config == null ? void 0 : config.order_count);
+    const currentOrderId = (0, import_utils.toPositiveString)(config == null ? void 0 : config.order_id);
+    const lastOrderId = (0, import_utils.toPositiveString)(config == null ? void 0 : config.last_order_id);
+    const relationId = (0, import_utils.toPositiveString)(config == null ? void 0 : config.relation_id);
+    const tableFormId = (0, import_utils.toPositiveString)(config == null ? void 0 : config.table_form_id);
+    const allowSnack = ((_b = (_a = this.otherParams) == null ? void 0 : _a.dineInConfig) == null ? void 0 : _b["workflow.allow_add_items"]) || false;
+    const deskmateValid = false;
+    const isExclusive = tableMaxNumber > 0 ? tableMaxNumber <= 1 : false;
+    const isFull = tableMaxNumber > 0 ? orderCount >= tableMaxNumber : false;
+    const isBlock = tableMaxNumber === -1;
+    let availabilityInfo = {
+      mode: "idle",
+      deskmate_valid: deskmateValid
+    };
+    if (currentOrderId) {
+      if (!hasOrderId) {
+        availabilityInfo = {
+          mode: "resource_busy",
+          order_id: currentOrderId,
+          relation_id: relationId,
+          table_form_id: tableFormId,
+          deskmate_valid: deskmateValid
+        };
+      } else {
+        availabilityInfo = {
+          mode: allowSnack ? "additional_order" : "resource_busy",
+          order_id: currentOrderId,
+          relation_id: relationId,
+          table_form_id: tableFormId,
+          deskmate_valid: deskmateValid
+        };
+      }
+    } else if (lastOrderId) {
+      availabilityInfo = allowSnack ? {
+        mode: deskmateValid ? "additional_order_with_code" : "additional_order",
+        order_id: lastOrderId,
+        relation_id: relationId,
+        table_form_id: tableFormId,
+        deskmate_valid: deskmateValid
+      } : {
+        mode: "resource_busy",
+        order_id: lastOrderId,
+        relation_id: relationId,
+        table_form_id: tableFormId,
+        deskmate_valid: deskmateValid
+      };
+    }
+    if (isBlock) {
+      availabilityInfo = {
+        mode: "resource_block",
+        order_id: lastOrderId,
+        relation_id: relationId,
+        table_form_id: tableFormId,
+        deskmate_valid: deskmateValid
+      };
+    }
+    return {
+      ...availabilityInfo,
+      tableMaxNumber,
+      orderCount,
+      currentOrderId,
+      lastOrderId,
+      relationId,
+      tableFormId,
+      allowSnack,
+      deskmateValid,
+      isExclusive,
+      isFull,
+      orderNumberPrefix,
+      raw: config
+    };
+  }
+  async fetchTableConfigByResourceId(resourceId) {
+    const tableResourceId = Number(resourceId);
+    if (!Number.isFinite(tableResourceId) || tableResourceId <= 0) {
+      throw new Error(`[ScanOrder] 非法桌台 resourceId: ${resourceId}`);
+    }
+    const response = await this.request.get(
+      "/order/dining/table/config",
+      {
+        table_resource_id: tableResourceId,
+        with_table_form_info: 1
+      }
+    );
+    if (!(response == null ? void 0 : response.status)) {
+      throw new Error((response == null ? void 0 : response.message) || "获取桌台配置失败");
+    }
+    return (response == null ? void 0 : response.data) || null;
+  }
+  // 检测当前链接是否可用
+  // 通过 resource_id + 店铺配置
+  // hasOrderId 表示 url 上是否有 orderid，如果是的话，后续的流程会走加单
+  async checkResourceAvailable(resourceId, hasOrderId) {
+    var _a, _b, _c, _d, _e, _f;
+    this.logMethodStart("checkResourceAvailable", {
+      resourceId
+    });
+    try {
+      const openData = await ((_b = (_a = this.otherParams) == null ? void 0 : _a.getOpenData) == null ? void 0 : _b.call(_a, {
+        scope: "board",
+        target: "dine_in+scan_to_order",
+        section_code: ["basic", "fulfillment", "reservation", "sale", "menu", "availability", "workflow"]
+      }));
+      if ((openData == null ? void 0 : openData.status) === false) {
+        throw new Error((openData == null ? void 0 : openData.message) || "获取店铺配置失败");
+      }
+      const dineInConfig = (openData == null ? void 0 : openData.data) || {};
+      this.otherParams.dineInConfig = dineInConfig;
+      await this.syncItemRuleConfigsFromDineInConfig(dineInConfig);
+      const shopClosedInfo = () => ({
+        mode: "shop_closed",
+        order_id: void 0,
+        relation_id: void 0,
+        table_form_id: void 0,
+        deskmate_valid: false,
+        errorTips: (dineInConfig == null ? void 0 : dineInConfig["availability.pause_message"]) || (dineInConfig == null ? void 0 : dineInConfig["availability.closed_message"]) || (dineInConfig == null ? void 0 : dineInConfig["availability.message"]) || (dineInConfig == null ? void 0 : dineInConfig["basic.closed_message"])
+      });
+      if ((0, import_utils.toBoolean)(dineInConfig == null ? void 0 : dineInConfig["availability.paused"])) {
+        if ((dineInConfig == null ? void 0 : dineInConfig["availability.pause_behavior"]) === "hide_all") {
+          return shopClosedInfo();
+        }
+      }
+      const config = await this.fetchTableConfigByResourceId(resourceId);
+      const resourceState = this.normalizeResourceState(config, hasOrderId);
+      this.store.resource = resourceState;
+      const availabilityInfo = {
+        mode: resourceState.mode,
+        order_id: resourceState.order_id,
+        relation_id: resourceState.relationId,
+        table_form_id: resourceState.tableFormId,
+        deskmate_valid: resourceState.deskmate_valid,
+        policy: (_c = config == null ? void 0 : config.table_form_record) == null ? void 0 : _c.policy,
+        partyroom_booking: (_d = config == null ? void 0 : config.table_form_record) == null ? void 0 : _d.partyroom_booking
+      };
+      const tempOrder = this.ensureTempOrder();
+      tempOrder.relation_id = resourceId || ((_e = this.otherParams) == null ? void 0 : _e.relation_id);
+      tempOrder.table_form_id = resourceState.tableFormId;
+      tempOrder.resource_id = resourceId;
+      (_f = this.store.order) == null ? void 0 : _f.persistTempOrder();
+      if (availabilityInfo.mode === "idle") {
+        await this.addNewOrder();
+      }
+      if (availabilityInfo.mode === "additional_order" || availabilityInfo.mode === "additional_order_with_code") {
+        tempOrder.order_id = resourceState.lastOrderId;
+      }
+      await this.refreshItemRuleQuantityLimits();
+      await this.refreshCartValidationPassed();
+      this.logMethodSuccess("checkResourceAvailable", {
+        resourceId,
+        mode: availabilityInfo.mode,
+        orderId: availabilityInfo.order_id,
+        relationId: availabilityInfo.relation_id,
+        tableFormId: availabilityInfo.table_form_id,
+        persistedRelationId: tempOrder.relation_id,
+        persistedResourceId: tempOrder.resource_id,
+        deskmateValid: availabilityInfo.deskmate_valid,
+        orderCount: resourceState.orderCount,
+        tableMaxNumber: resourceState.tableMaxNumber,
+        isExclusive: resourceState.isExclusive,
+        isFull: resourceState.isFull
+      });
+      return availabilityInfo;
+    } catch (error) {
+      this.logMethodError("checkResourceAvailable", error, {
+        resourceId
+      });
+      throw error;
+    }
+  }
+  // 如果是加单的情况，提供返回当前订单相关信息的能力
+  async getAdditionalOrderInfo() {
+    this.logMethodStart("getAdditionalOrderInfo");
+    const result = {
+      orderId: "123567890",
+      orderStatus: "pending",
+      orderTime: "2026-03-31 10:00:00",
+      orderAmount: 100,
+      orderItems: []
+    };
+    this.logMethodSuccess("getAdditionalOrderInfo", {
+      orderId: result.orderId,
+      orderStatus: result.orderStatus
+    });
+    return result;
+  }
+  // 获取商品列表
+  async getProductList() {
+    var _a, _b, _c;
+    this.logMethodStart("getProductList");
+    const menu_list_ids = ((_b = (_a = this.otherParams) == null ? void 0 : _a.dineInConfig) == null ? void 0 : _b["menu.associated_menus"].map((n) => Number(n.value))) || [];
+    try {
+      const res = await ((_c = this.store.products) == null ? void 0 : _c.loadProducts({
+        menu_list_ids,
+        cacheId: this.cacheId,
+        schedule_date: (0, import_dayjs.default)().format("YYYY-MM-DD"),
+        schedule_datetime: (0, import_dayjs.default)().format("YYYY-MM-DD HH:mm:ss")
+      }));
+      const formattedRes = (0, import_utils.attachItemRuleLimitsToTopLevelProducts)(
+        res,
+        this.store.itemRuleQuantityLimits || []
+      );
+      this.logMethodSuccess("getProductList", {
+        menuCount: menu_list_ids.length
+      });
+      return formattedRes;
+    } catch (error) {
+      this.logMethodError("getProductList", error);
+      throw error;
+    }
+  }
+  getOtherParams() {
+    return this.otherParams;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ScanOrderImpl,
+  ...require("./types")
+});