@pisell/pisellos 0.0.5 → 0.0.7

package/lib/modules/Step/index.d.ts

@@ -0,0 +1,19 @@
+import { Module, PisellCore, ModuleOptions } from "../../types";
+import { BaseModule } from "../BaseModule";
+import { IStep, IStepModuleAPI } from "./tyeps";
+export declare class StepModule extends BaseModule implements Module, IStepModuleAPI {
+    protected defaultName: string;
+    protected defaultVersion: string;
+    private store;
+    constructor(name?: string, version?: string);
+    initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
+    init(steps: IStep[]): void;
+    private setSteps;
+    private setCurrentStep;
+    getStepList(): IStep[];
+    getCurrentStep(): IStep;
+    getCurrentStepIndex(): number;
+    prevStep(): void;
+    nextStep(): void;
+    gotoStep(stepIndex: number): void;
+}

package/lib/modules/Step/index.js

@@ -0,0 +1,76 @@
+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/modules/Step/index.ts
+var Step_exports = {};
+__export(Step_exports, {
+  StepModule: () => StepModule
+});
+module.exports = __toCommonJS(Step_exports);
+var import_BaseModule = require("../BaseModule");
+var StepModule = class extends import_BaseModule.BaseModule {
+  constructor(name, version) {
+    super(name, version);
+    this.defaultName = "step";
+    this.defaultVersion = "1.0.0";
+  }
+  async initialize(core, options) {
+    this.core = core;
+    this.store = options.store;
+  }
+  init(steps) {
+    this.setSteps(steps);
+    this.setCurrentStep(0);
+  }
+  setSteps(stepList) {
+    this.store.stepList = stepList;
+  }
+  setCurrentStep(stepIndex) {
+    if (stepIndex < 0 || stepIndex >= this.store.stepList.length) {
+      return;
+    }
+    this.store.currentStepIndex = stepIndex;
+    this.store.currentStep = this.store.stepList[stepIndex];
+  }
+  getStepList() {
+    return this.store.stepList;
+  }
+  getCurrentStep() {
+    return this.store.currentStep;
+  }
+  getCurrentStepIndex() {
+    return this.store.currentStepIndex;
+  }
+  prevStep() {
+    if (this.store.currentStepIndex > 0) {
+      this.setCurrentStep(this.store.currentStepIndex - 1);
+    }
+  }
+  nextStep() {
+    if (this.store.currentStepIndex < this.store.stepList.length - 1) {
+      this.setCurrentStep(this.store.currentStepIndex + 1);
+    }
+  }
+  gotoStep(stepIndex) {
+    this.setCurrentStep(stepIndex);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StepModule
+});

package/lib/modules/Step/tyeps.d.ts

@@ -0,0 +1,18 @@
+export interface IStepState {
+    stepList: IStep[];
+    currentStep: IStep;
+    currentStepIndex: number;
+}
+export interface IStep {
+    index: number;
+    key: string;
+    [key: string]: any;
+}
+export interface IStepModuleAPI {
+    getStepList: () => IStep[];
+    getCurrentStep: () => IStep;
+    getCurrentStepIndex: () => number;
+    nextStep: () => void;
+    prevStep: () => void;
+    gotoStep: (stepIndex: number) => void;
+}

package/lib/modules/Step/tyeps.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/modules/Step/tyeps.ts
+var tyeps_exports = {};
+module.exports = __toCommonJS(tyeps_exports);

package/lib/plugins/request.d.ts

@@ -8,7 +8,7 @@ export interface RequestPlugin extends Plugin {
      * @param url 请求地址
      * @param options 请求选项
      */
-    get: <T = any>(url: string, options?: RequestOptions) => Promise<T>;
+    get: <T = any>(url: string, data?: any, options?: RequestOptions) => Promise<T>;
     /**
      * 发起 POST 请求
      * @param url 请求地址

package/lib/solution/BookingByStep/index.d.ts

@@ -1,5 +1,8 @@
-import { Module, PisellCore } from '../../types';
+import { Module, PisellCore } from "../../types";
 import { BaseModule } from "../../modules/BaseModule";
+import { BookingByStepState } from "./types";
+import { Account } from "../../modules/Account/types";
+import { IStep } from "../../modules/Step/tyeps";
 export declare class BookingByStepImpl extends BaseModule implements Module {
     protected defaultName: string;
     protected defaultVersion: string;
@@ -9,4 +12,29 @@ export declare class BookingByStepImpl extends BaseModule implements Module {
     private store;
     private otherParams;
     initialize(core: PisellCore, options: any): Promise<void>;
+    initStep(stepList: (keyof BookingByStepState)[]): void;
+    getCurrentStep(): {
+        index: number;
+        step: IStep;
+    };
+    next(): void;
+    getStoreCart(key?: string): Promise<any>;
+    loadProducts({ category_ids, product_ids }: {
+        category_ids?: number[];
+        product_ids?: number[];
+    }): Promise<void>;
+    storeProducts(productData: any[]): Promise<void>;
+    addAccount(accounts: Account[]): Promise<void>;
+    getAccounts(): Promise<import("../../modules/Account").AccountModule[]>;
+    setDateRange(dateRange: string[]): Promise<void>;
+    getRangeDate(): Promise<string>;
+    getAvailableDate(): Promise<void>;
+    getResourceTimeslot(): Promise<void>;
+    getProducts(): Promise<import("../../modules").ProductData[]>;
+    storeResources(resources: any[]): Promise<void>;
+    setLoginAccount(account: Account): Promise<void>;
+    generateCartData(): Promise<void>;
+    submitOrder(): Promise<void>;
+    pay(): Promise<void>;
+    getPayInfo(): Promise<void>;
 }

package/lib/solution/BookingByStep/index.js

@@ -36,15 +36,109 @@ var BookingByStepImpl = class extends import_BaseModule.BaseModule {
     this.core = core;
     this.store = options.store || {};
     this.otherParams = options.otherParams || {};
-    console.log("[BuyTickets] 初始化完成");
+    console.log("[BookingByStep] 初始化完成");
     this.request = core.getPlugin("request");
     this.window = core.getPlugin("window");
     if (!this.request) {
-      throw new Error("tickets解决方案需要 request 插件支持");
+      throw new Error("bookingByStep解决方案需要 request 插件支持");
     }
-    if (this.otherParams.prodctIds) {
-    }
-    await this.core.effects.emit(import_types.BookingByStepHooks.onInited, {});
+    const moduleArr = ["cart", "step", "products", "guests", "date", "accountList", "order", "payment"];
+    moduleArr.forEach((step) => {
+      const targetModule = (0, import_types.createModule)(step, this.name);
+      if (targetModule) {
+        this.store[step] = targetModule;
+        this.core.registerModule(targetModule);
+      } else {
+        throw new Error(`模块 ${step} 不存在`);
+      }
+    });
+    this.core.effects.emit(import_types.BookingByStepHooks.onInited, {});
+  }
+  // 初始化step
+  initStep(stepList) {
+    this.store.step.init(stepList);
+  }
+  getCurrentStep() {
+    return {
+      index: this.store.step.getCurrentStepIndex(),
+      step: this.store.step.getCurrentStep()
+    };
+  }
+  next() {
+    this.store.step.nextStep();
+  }
+  // 获取购物车里 temp.xxx的方法
+  async getStoreCart(key) {
+    return this.store.cart.getTemp(key);
+  }
+  // 加载商品，然后导到商品列表里去
+  async loadProducts({ category_ids, product_ids }) {
+    const productsData = await this.request.post(`${this.core.context.apiBasePath}/h5/product/query`, {
+      open_quotation: 1,
+      open_bundle: 1,
+      extension_type: ["product_appointment", "appointment_ticket"],
+      status: "published",
+      num: 500,
+      skip: 1,
+      category_ids,
+      ids: product_ids
+    });
+    this.store.products.addProduct(productsData.data.list);
+  }
+  // 往购物车里加一些商品/服务相关的选中数据
+  async storeProducts(productData) {
+    this.store.cart.storeTemp("products", productData);
+  }
+  // 添加账户或者 guest
+  async addAccount(accounts) {
+    accounts.forEach((account) => {
+      this.store.accountList.addAccount(account);
+    });
+  }
+  // 获取所有账户
+  async getAccounts() {
+    return this.store.accountList.getAccounts();
+  }
+  // 设置日期范围,注入到日期模块中
+  async setDateRange(dateRange) {
+  }
+  // 获取日期模块里选中的日期
+  async getRangeDate() {
+    return "2024-01-01";
+  }
+  // 获取商品/服务的可用日期
+  async getAvailableDate() {
+    const products = await this.getStoreCart("products");
+    console.log(products);
+  }
+  // 获取具体资源的可用时段
+  async getResourceTimeslot() {
+  }
+  // 获取可选择的商品、服务列表
+  async getProducts() {
+    return this.store.products.getProducts();
+  }
+  // 往购物车里加一些资源相关的选中数据
+  async storeResources(resources) {
+    this.store.cart.storeTemp("resources", resources);
+  }
+  // 如果用户登录
+  async setLoginAccount(account) {
+    const accounts = await this.getAccounts();
+    const mainAccount = accounts.find((n) => n.getLoginStatus());
+    mainAccount == null ? void 0 : mainAccount.setAccountInfo(account);
+  }
+  // 生成购物车的正规数据
+  async generateCartData() {
+  }
+  // 购物车提交订单
+  async submitOrder() {
+  }
+  // 拉起支付模块
+  async pay() {
+  }
+  // 获取支付信息
+  async getPayInfo() {
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/lib/solution/BookingByStep/types.d.ts

@@ -1,21 +1,25 @@
 import { ProductList, CartModule } from "../../modules";
 import { AccountModule } from "../../modules/Account";
+import { AccountListModule } from "../../modules/AccountList";
 import { DateModule } from "../../modules/Date";
 import { GuestListModule } from "../../modules/Guests";
 import { OrderModule } from "../../modules/Order";
 import { PaymentModule } from "../../modules/Payment";
 import { ResourceListModule } from "../../modules/Resource";
+import { StepModule } from "../../modules/Step";
 export interface BookingByStepState {
     cart: CartModule;
-    currentStep: number;
+    step: StepModule;
     products: ProductList;
     guests: GuestListModule;
     date: DateModule;
-    resources: ResourceListModule[];
+    resources?: ResourceListModule;
     account: AccountModule;
+    accountList: AccountListModule;
     order: OrderModule;
     payment: PaymentModule;
 }
+export declare function createModule<T extends keyof BookingByStepState>(moduleName: T, solutionName: string, name?: string, version?: string): BookingByStepState[T];
 export declare enum BookingByStepHooks {
     onInited = "bookingByStep:onInited",
     onDestroy = "bookingByStep:onDestroy",

package/lib/solution/BookingByStep/types.js

@@ -19,9 +19,39 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/solution/BookingByStep/types.ts
 var types_exports = {};
 __export(types_exports, {
-  BookingByStepHooks: () => BookingByStepHooks
+  BookingByStepHooks: () => BookingByStepHooks,
+  createModule: () => createModule
 });
 module.exports = __toCommonJS(types_exports);
+var import_modules = require("../../modules");
+var import_AccountList = require("../../modules/AccountList");
+var import_Date = require("../../modules/Date");
+var import_Guests = require("../../modules/Guests");
+var import_Order = require("../../modules/Order");
+var import_Payment = require("../../modules/Payment");
+var import_Step = require("../../modules/Step");
+function createModule(moduleName, solutionName, name, version) {
+  switch (moduleName) {
+    case "cart":
+      return new import_modules.CartModule(`${solutionName}_${name || moduleName}`, version);
+    case "step":
+      return new import_Step.StepModule(`${solutionName}_${name || moduleName}`, version);
+    case "products":
+      return new import_modules.ProductList(`${solutionName}_${name || moduleName}`, version);
+    case "guests":
+      return new import_Guests.GuestListModule(`${solutionName}_${name || moduleName}`, version);
+    case "date":
+      return new import_Date.DateModule(`${solutionName}_${name || moduleName}`, version);
+    case "accountList":
+      return new import_AccountList.AccountListModule(`${solutionName}_${name || moduleName}`, version);
+    case "order":
+      return new import_Order.OrderModule(`${solutionName}_${name || moduleName}`, version);
+    case "payment":
+      return new import_Payment.PaymentModule(`${solutionName}_${name || moduleName}`, version);
+    default:
+      throw new Error(`Unknown module type: ${moduleName}`);
+  }
+}
 var BookingByStepHooks = /* @__PURE__ */ ((BookingByStepHooks2) => {
   BookingByStepHooks2["onInited"] = "bookingByStep:onInited";
   BookingByStepHooks2["onDestroy"] = "bookingByStep:onDestroy";
@@ -34,5 +64,6 @@ var BookingByStepHooks = /* @__PURE__ */ ((BookingByStepHooks2) => {
 })(BookingByStepHooks || {});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  BookingByStepHooks
+  BookingByStepHooks,
+  createModule
 });

package/lib/solution/BookingByStep/utils/resources.d.ts

@@ -0,0 +1,61 @@
+import { Dayjs } from 'dayjs';
+/**
+ * 1. 获取资源列表
+ * 2. 根据当前选择的商品过滤出来对应的资源列表  getResourcesByProduct
+ * 3. 格式化资源相关 格式化资源列表 --> 格式化资源 --> 获取时间切片列表 --> 判断单个时间切片是否可用 formatResources
+ *
+ */
+type DateType = Dayjs | string;
+interface TimeSliceItem {
+    start: DateType;
+    end: DateType;
+    start_at: DateType;
+    end_at: DateType;
+    [key: string]: any;
+}
+interface ResourceItem {
+    [key: string]: any;
+}
+interface BookingItem {
+    [key: string]: any;
+}
+interface ProductItem {
+    [key: string]: any;
+}
+/**
+ * @title: 获取商品下绑定的资源列表
+ * @description:
+ * @param {any} resourcesMap
+ * @param {any} product
+ * @return {*}
+ * @Author: zhiwei.Wang
+ */
+export declare const getResourcesByProduct: (resourcesMap: Record<string, ResourceItem>, product: ProductItem) => any;
+export declare const getSumCapacity: () => number;
+/**
+ * @title: 获取资源列表
+ * @description:
+ * @return {*}
+ * @Author: zhiwei.Wang
+ * @Date: 2024-01-09 13:38
+ */
+export declare const formatResources: ({ booking, resources }: {
+    booking: BookingItem;
+    resources: ResourceItem[];
+}) => {
+    list: ResourceItem[];
+    maps: any;
+};
+/**
+ * @title: 获取资源的时间切片列表
+ * @description:
+ * @return {*}
+ * @Author: zhiwei.Wang
+ */
+export declare const getTimeSlicesByResource: ({ resource, duration, split, currentDate }: {
+    resource: ResourceItem;
+    duration: number;
+    split: number;
+    currentDate: DateType;
+}) => TimeSliceItem[];
+export {};

package/lib/solution/BookingByStep/utils/resources.js

@@ -0,0 +1,215 @@
+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 __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/BookingByStep/utils/resources.ts
+var resources_exports = {};
+__export(resources_exports, {
+  formatResources: () => formatResources,
+  getResourcesByProduct: () => getResourcesByProduct,
+  getSumCapacity: () => getSumCapacity,
+  getTimeSlicesByResource: () => getTimeSlicesByResource
+});
+module.exports = __toCommonJS(resources_exports);
+var import_dayjs = __toESM(require("dayjs"));
+var getUseableEventCount = (eventList, current) => {
+  return (eventList || []).reduce((pre, event) => {
+    return pre - event.pax;
+  }, current || 0);
+};
+var isConflict = (event, current) => {
+  const eventStart = (0, import_dayjs.default)(event.start_at);
+  const eventEnd = (0, import_dayjs.default)(event.end_at);
+  const currentStart = (0, import_dayjs.default)(current.start_at);
+  const _isBefore = currentStart.isBefore(eventEnd);
+  let _isAfter = true;
+  if (current.end_at) {
+    const currentEnd = (0, import_dayjs.default)(current.end_at);
+    _isAfter = currentEnd.isAfter(eventStart);
+  }
+  return _isBefore && _isAfter;
+};
+var checkAfterToDay = (date, today = (0, import_dayjs.default)()) => {
+  return (0, import_dayjs.default)(date).isAfter((0, import_dayjs.default)(today));
+};
+var formatResource = (resourceItem, booking) => {
+  let _resourceItem = { ...resourceItem };
+  _resourceItem.timeSlices = getTimeSlicesByResource({
+    resource: _resourceItem,
+    duration: booking.duration,
+    split: 10,
+    currentDate: (0, import_dayjs.default)().format("YYYY-MM-DD")
+  });
+  _resourceItem.labelText = _resourceItem.main_field;
+  return _resourceItem;
+};
+var checkCapacity = ({ event_list, timeSlice, resource, currentCount = 1 }) => {
+  let conflict = (event_list || []).filter((d) => {
+    return isConflict({ start_at: d.start_at, end_at: d.end_at }, { start_at: timeSlice.start_at, end_at: timeSlice.end_at });
+  });
+  if (resource.resourceType === "single") {
+    if (conflict.length === 0) {
+      return true;
+    } else {
+      return false;
+    }
+  } else {
+    let conflictCount = getUseableEventCount(conflict, resource.capacity);
+    if (currentCount <= conflictCount) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+};
+var getIsUsableByTimeItem = ({ timeSlice, time, resource, currentCount = 1 }) => {
+  let status = {
+    afterToDay: false,
+    capacity: false,
+    usable: false
+  };
+  let earliest = (0, import_dayjs.default)();
+  if (!checkAfterToDay(timeSlice.start_at, earliest)) {
+    return status;
+  }
+  status.afterToDay = true;
+  if (!checkCapacity({ event_list: time == null ? void 0 : time.event_list, timeSlice, resource, currentCount })) {
+    return status;
+  }
+  status.capacity = true;
+  status.usable = true;
+  return status;
+};
+var getResourcesByProduct = (resourcesMap, product) => {
+  var _a;
+  let _resources = (((_a = product == null ? void 0 : product.product_resource) == null ? void 0 : _a.resources) || []).filter((d) => d.status == 1);
+  for (let item of _resources) {
+    const form_id = item.id;
+    item.optional_resource = (item.optional_resource || []).filter(
+      (d) => item.default_resource.indexOf(d) == -1
+    );
+    let optional_resource = item.optional_resource.map(
+      (d) => (
+        // 合并数据, 将资源配置项添加到每一条内
+        resourcesMap[d] ? Object.assign({}, resourcesMap[d], {
+          form_id,
+          resourceType: item.type
+        }) : null
+      )
+    ).filter((d) => d);
+    let default_resource = item.default_resource.map((d) => {
+      let item2 = resourcesMap[d];
+      if (item2) {
+        item2.is_default = 1;
+        return Object.assign({}, item2, {
+          form_id,
+          resourceType: item2.type
+        });
+      } else {
+        return null;
+      }
+    }).filter((d) => d);
+    item.renderList = optional_resource.concat(default_resource);
+    item.form_id = form_id;
+  }
+  console.log("_resources", _resources);
+  return _resources;
+};
+var getSumCapacity = () => {
+  return 1;
+};
+var formatResources = ({ booking, resources }) => {
+  try {
+    let _list = [...resources];
+    let maps = {};
+    for (let item of _list) {
+      let renderListMaps = {};
+      item.renderList = item.renderList.map((d) => {
+        let res = formatResource(d, booking);
+        renderListMaps[res.id] = res;
+        return res;
+      }).sort((a, b) => b.usable ? 1 : -1);
+      maps[item.form_id] = {
+        ...item,
+        renderListMaps
+      };
+    }
+    return { list: _list, maps };
+  } catch (err) {
+    console.log("formatResourcesErr", err);
+  }
+  return {
+    list: [],
+    maps: {}
+  };
+};
+var getTimeSlicesByResource = ({
+  resource,
+  duration,
+  split = 10,
+  currentDate = (0, import_dayjs.default)()
+}) => {
+  const { times } = resource;
+  const timeSlices = [];
+  times.forEach((time) => {
+    const today = (0, import_dayjs.default)(currentDate).format("YYYY-MM-DD");
+    const startTime = (0, import_dayjs.default)(`${today} ${time.start_time}`);
+    const endTime = (0, import_dayjs.default)(`${today} ${time.end_time}`);
+    let currentStart = startTime;
+    while (true) {
+      const currentEnd = currentStart.add(duration, "minute");
+      if (currentEnd.isAfter(endTime)) {
+        break;
+      }
+      const timeSlice = {
+        start: currentStart.format("HH:mm"),
+        end: currentEnd.format("HH:mm"),
+        start_at: currentStart,
+        end_at: currentEnd
+      };
+      timeSlices.push({
+        ...timeSlice,
+        // 这里需要补充这个时间段内是否可预约
+        _status: getIsUsableByTimeItem({
+          timeSlice,
+          time,
+          resource,
+          currentCount: getSumCapacity()
+        })
+      });
+      currentStart = currentStart.add(split, "minute");
+    }
+  });
+  return timeSlices;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatResources,
+  getResourcesByProduct,
+  getSumCapacity,
+  getTimeSlicesByResource
+});

package/lib/solution/BuyTickets/index.js

@@ -54,7 +54,7 @@ var BuyTicketsImpl = class extends import_BaseModule.BaseModule {
   // 通过 ids 获取产品，在当前解决方案下，获取到的就是主商品
   async loadProductsByIds(ids) {
     const productsData = await this.request.post(
-      `${this.core.context.apiBasePath}/shop/product/query`,
+      "/product/query",
       {
         ids,
         open_quotation: 1,

package/lib/store/createStore.js

@@ -30,7 +30,7 @@ function createStore(initialState, moduleName, onChange) {
     },
     set(target, prop, value, receiver) {
       const result = Reflect.set(target, prop, value, receiver);
-      onChange == null ? void 0 : onChange(`${moduleName}.${String(prop)}`, value);
+      onChange == null ? void 0 : onChange(`${String(prop)}`, value);
       return result;
     },
     deleteProperty(target, prop) {