@pisell/pisellos 0.10.9 → 0.10.11

package/dist/solution/BaseSales/index.js

@@ -3012,8 +3012,8 @@ export var BaseSalesImpl = /*#__PURE__*/function (_BaseModule) {
     key: "buildVirtualSettlementSubmitData",
     value: function () {
       var _buildVirtualSettlementSubmitData = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee29() {
-        var _tempOrder$metadata$c, _tempOrder$metadata2, _paymentMethod$custom;
-        var tempOrder, snapshot, currencyProductId, summary, amount, customerId, asset, currencyCode, currencySymbol, currencyFormat, balance, paymentMethods, paymentMethod, amountText, payment;
+        var _tempOrder$metadata$c, _tempOrder$metadata2;
+        var tempOrder, snapshot, currencyProductId, summary, amount, customerId, asset, currencyCode, currencySymbol, currencyFormat, balance, amountText, paymentNumber, payment, _paymentMethod$custom, paymentMethods, paymentMethod;
         return _regeneratorRuntime().wrap(function _callee29$(_context29) {
           while (1) switch (_context29.prev = _context29.next) {
             case 0:
@@ -3090,22 +3090,44 @@ export var BaseSalesImpl = /*#__PURE__*/function (_BaseModule) {
               }
               throw new Error('Insufficient virtual currency balance.');
             case 28:
-              _context29.next = 30;
+              amountText = amount.toFixed(2);
+              paymentNumber = "LOCAL_".concat(createUuidV4());
+              if (!this.store.order.isOnlineStorePlatform()) {
+                _context29.next = 34;
+                break;
+              }
+              payment = {
+                payment_number: paymentNumber,
+                amount: amount.toNumber(),
+                metadata: {
+                  unique_payment_number: createUuidV4()
+                },
+                tag: asset.tag,
+                voucher_id: asset.id,
+                wallet_pass_usage_unit: {
+                  price: 1,
+                  points: 1
+                },
+                wallet_pass_use_value: amountText
+              };
+              _context29.next = 41;
+              break;
+            case 34:
+              _context29.next = 36;
               return this.getPaymentMethodsAsync();
-            case 30:
+            case 36:
               paymentMethods = _context29.sent;
               paymentMethod = paymentMethods.find(function (method) {
                 return String(method.code || '').toUpperCase() === 'PRODUCTVOUCHER';
               });
               if (paymentMethod) {
-                _context29.next = 34;
+                _context29.next = 40;
                 break;
               }
               throw new Error('PRODUCTVOUCHER payment method is unavailable.');
-            case 34:
-              amountText = amount.toFixed(2);
+            case 40:
               payment = {
-                payment_number: "LOCAL_".concat(createUuidV4()),
+                payment_number: paymentNumber,
                 amount: amountText,
                 origin_amount: amountText,
                 code: paymentMethod.code,
@@ -3122,6 +3144,7 @@ export var BaseSalesImpl = /*#__PURE__*/function (_BaseModule) {
                 wallet_pass_use_value: amountText,
                 metadata: {}
               };
+            case 41:
               return _context29.abrupt("return", {
                 payments: [payment],
                 snapshot: snapshot,
@@ -3130,7 +3153,7 @@ export var BaseSalesImpl = /*#__PURE__*/function (_BaseModule) {
                 currencySymbol: currencySymbol,
                 currencyFormat: currencyFormat
               });
-            case 37:
+            case 42:
             case "end":
               return _context29.stop();
           }

package/dist/solution/BookingTicket/index.js

@@ -2322,14 +2322,16 @@ export var BookingTicketImpl = /*#__PURE__*/function (_BaseSalesImpl) {
       var bookingContextState = this.store.bookingContext.getState();
       var date = (_extra$date2 = extra === null || extra === void 0 ? void 0 : extra.date) !== null && _extra$date2 !== void 0 ? _extra$date2 : bookingContextState.date;
       var orderCustomerId = (_ref12 = (_this$getOrderCustome4 = (_this$getOrderCustome5 = this.getOrderCustomerSnapshot()) === null || _this$getOrderCustome5 === void 0 ? void 0 : _this$getOrderCustome5.id) !== null && _this$getOrderCustome4 !== void 0 ? _this$getOrderCustome4 : (_this$store$order$get4 = this.store.order.getTempOrder()) === null || _this$store$order$get4 === void 0 ? void 0 : _this$store$order$get4.customer_id) !== null && _ref12 !== void 0 ? _ref12 : undefined;
-      return _objectSpread({
+      return _objectSpread(_objectSpread({
         bookingConfig: bookingContextState.bookingConfig,
         resourcesOrigin: bookingContextState.resourcesOrigin,
         resourcesOriginMap: bookingContextState.resourcesOriginMap,
         date: date,
         presetStartTime: (_extra$presetStartTim2 = extra === null || extra === void 0 ? void 0 : extra.presetStartTime) !== null && _extra$presetStartTim2 !== void 0 ? _extra$presetStartTim2 : derivePresetStartTimeFromDate(date),
         customerId: orderCustomerId
-      }, extra || {});
+      }, extra || {}), {}, {
+        channel: this.getSubmitOrderSalesChannel()
+      });
     }
 
     /**

package/dist/solution/BookingTicket/utils/addProductDecision.d.ts

@@ -5,7 +5,7 @@ import type { OrderProduct, OrderProductIdentity, AddProductBookingInput } from
  * cart.addProduct 两阶段决策（与 ticketBooking `handleSelectProduct` 对齐）：
  *
  * 1. `requiresDetail`：规格 / SKU / 套餐 / Session / 称重弹窗（门禁：`isOpenDetailModal` / `cartDetailValue` / `open_sold_weight`）
- * 2. `requiresBookingEdit`：资源 / 时间编辑抽屉（门禁：`getIsAutoClose` on prepared cacheItem）
+ * 2. `requiresBookingEdit`：资源 / 时间编辑抽屉（kiosk 强制进入；其他渠道由 `getIsAutoClose` 决定）
  * 3. `add`：两关均通过，直接 transform + 加车
  */
 export type AddProductDecision = {
@@ -65,6 +65,7 @@ export interface AddProductDecideContext extends BookingCalcContext {
     type?: 'select' | 'detail';
     quantity?: number;
     customerId?: number | string;
+    channel?: string;
 }
 /**
  * 统一补齐预约商品的运行态字段。

package/dist/solution/BookingTicket/utils/addProductDecision.js

@@ -13,7 +13,7 @@ import { buildProductSkuFromCacheItem } from "./weighingProductSku";
  * cart.addProduct 两阶段决策（与 ticketBooking `handleSelectProduct` 对齐）：
  *
  * 1. `requiresDetail`：规格 / SKU / 套餐 / Session / 称重弹窗（门禁：`isOpenDetailModal` / `cartDetailValue` / `open_sold_weight`）
- * 2. `requiresBookingEdit`：资源 / 时间编辑抽屉（门禁：`getIsAutoClose` on prepared cacheItem）
+ * 2. `requiresBookingEdit`：资源 / 时间编辑抽屉（kiosk 强制进入；其他渠道由 `getIsAutoClose` 决定）
  * 3. `add`：两关均通过，直接 transform + 加车
  */
 
@@ -30,10 +30,11 @@ function needsSpecDetailModal(item) {
 }
 
 /**
- * 第二段：预约商品是否仍需打开资源 / 时间编辑（与 info2 `cacheItem.autoClose` 等价）。
+ * 第二段：预约商品是否仍需打开资源 / 时间编辑（kiosk 强制打开，其他渠道与 info2 `cacheItem.autoClose` 等价）。
  */
 function needsBookingEdit(cacheItem, ctx) {
   if (isNormalBookingProduct(cacheItem)) return false;
+  if ((ctx === null || ctx === void 0 ? void 0 : ctx.channel) === 'kiosk') return true;
   var isAutoAllocationOn = (ctx === null || ctx === void 0 ? void 0 : ctx.isAutoAllocationOn) || function () {
     return true;
   };

package/dist/solution/UnifiedBookingSales/index.d.ts

@@ -1,12 +1,13 @@
-import type { Module } from '../../types';
+import type { Module, ModuleOptions, PisellCore } from '../../types';
 import type { ProductData } from '../../modules';
 import type { OpenDataConfig } from '../../modules/OpenData';
 import type { LoadScheduleAvailableDateParams, ScheduleItem } from '../../modules/Schedule/types';
 import type { ProductListLoadProductsParams } from '../../modules/ProductList';
-import type { ResourcePlannerAssignment, ResourcePlannerAssignableSlotResult, ResourcePlannerEvent, ResourcePlannerProduct, ResourcePlannerProjection, ResourcePlannerQuery, ResourcePlannerResource, ResourcePlannerSelectionPatch, ResourcePlannerSnapshot, ResourcePlannerValidationResult } from '../../modules/ResourcePlanner';
-import type { UnifiedBookingSalesCommitPlannerSelectionParams, UnifiedBookingSalesCommitResult, UnifiedBookingSalesAddRetailProductParams, UnifiedBookingSalesApplyPlannerDiscountsParams, UnifiedBookingSalesDiscountResult, UnifiedBookingSalesLoadProductsByScheduleDateParams, UnifiedBookingSalesLoadPlannerContextParams, UnifiedBookingSalesLoadOpenDataParams, UnifiedBookingSalesStagePlannerProductsParams, UnifiedBookingSalesStageRetailProductsParams, UnifiedBookingSalesState } from './types';
+import type { AvailabilityDateRange, AvailabilityOccupancy, AvailabilityProduct, AvailabilityResource, GetProductTimeRangesRequest } from '../../modules/ResourcePlanner';
+import type { AvailabilityContextRef, ContextualAvailabilityQuery, ContextualAvailabilityQueryResult, ContextualCommitAvailabilitySelectionParams, ContextualProductTimeRangeGroup, UnifiedBookingSalesAddRetailProductParams, UnifiedBookingSalesApplyPlannerDiscountsParams, UnifiedBookingSalesCommitAvailabilitySelectionResult, UnifiedBookingSalesDiscountResult, UnifiedBookingSalesLoadProductsByScheduleDateParams, UnifiedBookingSalesLoadOpenDataParams, UnifiedBookingSalesPrepareAvailabilityProjectionParams, UnifiedBookingSalesStageRetailProductsParams, UnifiedBookingSalesState } from './types';
 import { BookingTicket } from '../BookingTicket';
 export * from './types';
+export { AvailabilityError } from '../../modules/ResourcePlanner';
 /**
  * Converts Rules/Order discount internals into a small UI-facing diagnostic. The result keeps
  * candidate-card state separate from line-level applications: a selected card is not proof that
@@ -22,39 +23,37 @@ export declare function buildPlannerDiscountResult(params: {
     preferredDiscountId?: number | string;
     preferredDiscountFound?: boolean;
 }): UnifiedBookingSalesDiscountResult;
-/** Converts a ProductList record into the pure input shape consumed by ResourcePlanner. */
-export declare function normalizeProductForPlanner(product: ProductData | Record<string, any>): ResourcePlannerProduct;
+/** Converts ProductList and schedule records into the pure Availability vocabulary. */
+export declare function normalizeProductForAvailability(product: ProductData | Record<string, any>, scheduleList?: ScheduleItem[], fixedOffsetMinutes?: number): AvailabilityProduct;
 /**
  * Materializes resource work windows locally from v2's schedule ids, then keeps its flat
- * event_list as planner events. This deliberately avoids the older API's times -> event_list
+ * event_list as resource occupancy records. This deliberately avoids the older API's times -> event_list
  * response nesting and lets one resource response serve any requested date range.
  */
-export declare function buildPlannerResourcesFromV2(params: {
+export declare function buildAvailabilityResourcesFromV2(params: {
     rawResources: Record<string, any>[];
     scheduleList: ScheduleItem[];
-    dateRange?: ResourcePlannerQuery['dateRange'];
+    dateRange?: AvailabilityDateRange;
+    fixedOffsetMinutes?: number;
 }): {
-    resources: ResourcePlannerResource[];
-    externalEvents: ResourcePlannerEvent[];
+    resources: AvailabilityResource[];
+    resourceOccupancies: AvailabilityOccupancy[];
 };
 /** Combines URL-locked resources with every resource referenced by the selected products. */
-export declare function collectPlannerResourceIds(products: ResourcePlannerProduct[], explicitResourceIds?: Array<number | string>): Array<number | string>;
-/** Convenience wrapper for the usual one-resource booking case. */
-export declare function buildBookingFromAssignment(params: {
-    assignment: ResourcePlannerAssignment;
-    product: ResourcePlannerProduct;
+export declare function collectAvailabilityResourceIds(products: AvailabilityProduct[], explicitResourceIds?: Array<number | string>): Array<number | string>;
+export declare function buildAvailabilityLineIdentity(product: Record<string, any>): Record<string, any>;
+export declare function buildBookingFromAvailabilityAssignment(params: {
+    assignment: Record<string, any>;
+    product: AvailabilityProduct;
+    timezone?: string;
+    fixedOffsetMinutes?: number;
 }): Record<string, any>;
-/**
- * Converts all resources needed by one product/time interval into the one booking expected by
- * OrderModule. Callers must group assignments before this function so a multi-form booking does
- * not become several competing bookings.
- */
-export declare function buildBookingFromAssignments(params: {
-    assignments: ResourcePlannerAssignment[];
-    product: ResourcePlannerProduct;
+export declare function buildBookingFromAvailabilityAssignments(params: {
+    assignments: Record<string, any>[];
+    product: AvailabilityProduct;
+    timezone?: string;
+    fixedOffsetMinutes?: number;
 }): Record<string, any>;
-/** Builds the exact identity BaseSales needs to remove only this solution's order lines. */
-export declare function buildPlannerLineIdentity(product: Record<string, any>): Record<string, any>;
 export declare class UnifiedBookingSalesImpl extends BookingTicket {
     protected defaultName: string;
     protected defaultVersion: string;
@@ -63,7 +62,52 @@ export declare class UnifiedBookingSalesImpl extends BookingTicket {
     private openDataTarget;
     private loadOpenDataInFlight;
     private loadOpenDataInFlightTarget;
+    private availabilityRuntimeOffsetMinutes;
+    private availabilityScheduleCatalog;
+    private availabilityProjectionSequence;
+    private availabilityContextSequence;
+    private availabilityLifecycleGeneration;
+    private availabilityContextRegistry;
+    private availabilityProjectionPool;
+    private availabilityPrepareInFlight;
+    private availabilityProjectionRefreshInFlight;
+    private availabilityRemoteOccupancyCache;
+    private availabilityRemoteResourceQueryInFlight;
+    private availabilityRemoteResourceQuerySequence;
+    private availabilityRemoteResourceEpoch;
+    private availabilityCommitLocks;
+    initialize(core: PisellCore, options?: ModuleOptions): Promise<void>;
     protected getSubmitOrderSalesChannel(): string;
+    private createAvailabilityFacadeError;
+    private getAvailabilityScopeDescriptor;
+    private normalizeAvailabilityIdList;
+    private normalizeAvailabilityStringList;
+    private normalizeAvailabilityPrepareDescriptor;
+    private resolveAvailabilityPrepareDefaults;
+    private buildAvailabilityPrepareKey;
+    private clearAvailabilityRemoteResourceState;
+    private buildAvailabilityRemoteResourceScopeKey;
+    private buildAvailabilityRemoteResourceQueryKey;
+    setOtherParams(params: Record<string, any>, { cover }?: {
+        cover?: boolean;
+    }): Promise<void>;
+    destroy(): Promise<void>;
+    private createAvailabilityContextId;
+    private buildAvailabilityProjectionKey;
+    private getAvailabilityRuntimeOffsetMinutes;
+    private getAvailabilityRuntimeDateTime;
+    private cloneAvailabilityPrepareParams;
+    private getAvailabilityDurationCandidateAnchorAt;
+    private createAvailabilityContextRef;
+    private emitAvailabilityDiagnostic;
+    private touchAvailabilityContext;
+    private touchAvailabilityProjection;
+    private removeAvailabilityProjection;
+    private removeAvailabilityContext;
+    private evictAvailabilityProjectionPool;
+    private evictAvailabilityContextRegistry;
+    private invalidateAvailabilityContextsAfterCommit;
+    private resetAvailabilityProjectionState;
     protected isSessionStoragePersistEnabled(): boolean;
     protected shouldUseSessionStorageForSubModule(moduleName?: string): boolean;
     /**
@@ -133,17 +177,10 @@ export declare class UnifiedBookingSalesImpl extends BookingTicket {
      * diagnostic boundary for new booking skins: no pricing logic is duplicated in the planner.
      */
     applyPlannerDiscounts(params?: UnifiedBookingSalesApplyPlannerDiscountsParams): Promise<UnifiedBookingSalesDiscountResult>;
-    /** ResourcePlanner is a required child module; fail early instead of producing partial availability. */
-    private getPlanner;
     private buildUnifiedOrderProduct;
     /** Replacing a staged selection is idempotent and never removes unrelated cart lines. */
     private removeExistingStagedLines;
     private stageProducts;
-    /**
-     * Adds the current product choice to an otherwise clean planner cart without creating bookings.
-     * This separates "what the customer wants" from the later time/resource confirmation step.
-     */
-    stagePlannerProducts(params: UnifiedBookingSalesStagePlannerProductsParams): Promise<Record<string, any> | null>;
     /**
      * Adds ordinary retail products without asking ResourcePlanner for booking facts.
      * Its staged lines have separate ownership so planner and retail skins can coexist safely.
@@ -155,50 +192,50 @@ export declare class UnifiedBookingSalesImpl extends BookingTicket {
      * "replace the staged selection" for demo and wizard-like callers.
      */
     addRetailProduct(params: UnifiedBookingSalesAddRetailProductParams): Promise<Record<string, any>[]>;
-    /** Normalizes caller-provided products or loads the catalog before any resource request is made. */
-    private loadPlannerProducts;
-    /** Loads the reusable store-level schedule catalog on demand. */
-    private ensurePlannerSchedulesLoaded;
-    /**
-     * v2 resources reference schedule ids rather than expanded work times. Refresh once when the
-     * cached schedule catalog cannot materialize all referenced ids.
-     */
-    private ensurePlannerSchedulesForResources;
+    private normalizeAvailabilityDateRange;
+    private assertAvailabilityPrepareParams;
+    private captureAvailabilityScheduleCatalog;
+    /** Returns the solution-lifetime schedule snapshot captured after initialization. */
+    private getAvailabilityScheduleCatalog;
+    private buildAvailabilityOperatingHoursSnapshot;
+    private loadAvailabilityProducts;
     /**
      * Fetches resource metadata plus flat occupied events. Work windows are intentionally derived
-     * locally in buildPlannerResourcesFromV2 from /schedule, rather than requested from the legacy
+     * locally in buildAvailabilityResourcesFromV2 from /schedule, rather than requested from the legacy
      * resource dates endpoint.
      */
-    private fetchPlannerResourcesV2;
-    /**
-     * Resolves the Planner context in precedence order: explicit normalized context, test raw data,
-     * then the v2 resource API inferred from selected product requirements and any URL lock.
-     */
-    private loadPlannerResources;
-    /**
-     * Boundary between IO and pure planning. Once this returns, all later availability/slot calls
-     * operate on the ResourcePlanner snapshot and do not issue resource requests themselves.
-     */
-    loadPlannerContext(params?: UnifiedBookingSalesLoadPlannerContextParams): Promise<ResourcePlannerSnapshot>;
-    /** Returns cells, date summaries and a derived grid; cells are continuous ranges, not UI slots. */
-    queryPlannerAvailability(query?: ResourcePlannerQuery): Promise<ResourcePlannerProjection>;
-    /** Turns compatible availability ranges into user-selectable intervals and ready-to-commit assignments. */
-    resolveAssignableSlots(query?: ResourcePlannerQuery): ResourcePlannerAssignableSlotResult;
-    /** Stores a UI choice only. It is deliberately side-effect free with respect to tempOrder. */
-    setPlannerSelection(patch: ResourcePlannerSelectionPatch): ResourcePlannerSnapshot;
-    /**
-     * Legacy-friendly automatic assignment for already fixed intervals. Duration products without a
-     * start time intentionally remain unresolved; callers offering a picker should use slots.
-     */
-    autoAssignPlanner(query?: ResourcePlannerQuery): Promise<ResourcePlannerSnapshot>;
-    /** Rechecks remote events, capacity and conflicts among the current selection before committing. */
-    validatePlannerSelection(): ResourcePlannerValidationResult;
-    /** Read-only snapshot for UI diagnostics and progressive flow steps. */
-    getPlannerSnapshot(): ResourcePlannerSnapshot;
-    /**
-     * Validates then writes assignments to tempOrder. Real order submission is opt-in so UI callers
-     * can safely preview the cart; pass submitAfterCommit only after an explicit confirmation.
-     */
-    commitPlannerSelection(params?: UnifiedBookingSalesCommitPlannerSelectionParams): Promise<UnifiedBookingSalesCommitResult>;
+    private fetchAvailabilityResourcesV2;
+    private fetchAndPublishAvailabilityResourcesV2;
+    private refreshAvailabilityRemoteResourceQuery;
+    private loadAvailabilityResources;
+    private resolveEditingOccupancyExclusions;
+    private occupancyIsExcluded;
+    private collectCartResourceOccupancies;
+    private getCurrentOrderRevision;
+    private getAvailabilityContextEntry;
+    private getAvailabilityProjectionByKey;
+    private getActiveAvailabilityProjectionEntry;
+    private decorateAvailabilityCandidate;
+    private assertAvailabilityCandidateFreshness;
+    private assertContextualQueryFreshness;
+    private storeAvailabilityProjectionEntry;
+    private buildAvailabilityProjectionSnapshot;
+    private getSharedPreparedAvailabilitySnapshot;
+    private refreshAvailabilityContextProjection;
+    private ensureAvailabilityContextProjection;
+    private tryAcquireAvailabilityCommitLock;
+    private releaseAvailabilityCommitLock;
+    /** IO boundary: loads catalog, schedules, resources, occupancies, and registers one context. */
+    prepareAvailabilityProjection(params: UnifiedBookingSalesPrepareAvailabilityProjectionParams): Promise<AvailabilityContextRef>;
+    /** Pure configuration calculation over the current context projection. */
+    getProductTimeRanges(contextId: string, request?: GetProductTimeRangesRequest): Promise<ContextualProductTimeRangeGroup[]>;
+    /** Thin facade: auto-refresh on cart drift, then delegate to the pure projection query. */
+    queryBookingAvailability(contextId: string, request: ContextualAvailabilityQuery): Promise<ContextualAvailabilityQueryResult>;
+    releaseAvailabilityContext(contextId: string): void;
+    private assertAvailabilityCommitWriteCAS;
+    private findProductLineByUid;
+    private findLinkedBooking;
+    /** Revalidates against the latest landed occupancy cache, then mutates exactly one product line. */
+    commitAvailabilitySelection(contextId: string, params: ContextualCommitAvailabilitySelectionParams): Promise<UnifiedBookingSalesCommitAvailabilitySelectionResult>;
 }
 export declare const UnifiedBookingSales: typeof UnifiedBookingSalesImpl;