@pisell/pisellos 2.2.314 → 2.2.316

package/lib/shared/payment/loadPaymentMethods.d.ts

@@ -0,0 +1,9 @@
+import type { RequestPlugin } from '../../plugins/request';
+import type { PaymentMethod } from '../../modules/Payment/types';
+/** Shared read-only transport; customer hosts route the remote path under /h5. */
+export declare function loadPaymentMethods(request: RequestPlugin, options: {
+    transport: 'remote' | 'os-server';
+    filterPaymentMethods: boolean;
+}): Promise<PaymentMethod[]>;
+/** Enrich a copy: never overwrite historical names or change payment amounts. */
+export declare function withPaymentMethodNames(order: Record<string, any>, methods: PaymentMethod[]): Record<string, any>;

package/lib/shared/payment/loadPaymentMethods.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadPaymentMethods = loadPaymentMethods;
+exports.withPaymentMethodNames = withPaymentMethodNames;
+/** Shared read-only transport; customer hosts route the remote path under /h5. */
+async function loadPaymentMethods(request, options) {
+  const response = await request.get('/pay/custom-payment/all', {
+    filterPaymentMethods: options.filterPaymentMethods
+  }, options.transport === 'os-server' ? {
+    osServer: true
+  } : {
+    manualErrorHandling: true,
+    skipErrorHandler: true
+  });
+  const methods = response?.data ?? response;
+  if (!Array.isArray(methods)) throw new Error('Payment methods are unavailable');
+  return methods;
+}
+
+/** Enrich a copy: never overwrite historical names or change payment amounts. */
+function withPaymentMethodNames(order, methods) {
+  if (!Array.isArray(order.payments)) return order;
+  return {
+    ...order,
+    payments: order.payments.map(payment => {
+      if (payment.name || payment.title || payment.payment_method_name || payment.method_name) return payment;
+      const id = payment.custom_payment_id;
+      const hasId = id !== undefined && id !== null && String(id).trim() !== '';
+      const code = payment.code || payment.type || payment.payment_method || payment.method;
+      const method = methods.find(candidate => hasId ? String(candidate.id) === String(id) : !!code && candidate.code === code);
+      return method?.name ? {
+        ...payment,
+        payment_method_name: method.name
+      } : payment;
+    })
+  };
+}

package/lib/shared/receipt/customerInvoiceLanguages.d.ts

@@ -0,0 +1,8 @@
+export type CustomerInvoiceLanguageCode = 'en' | 'zh_CN' | 'zh_HK' | 'ja' | 'pt' | 'cn_en';
+export interface CustomerInvoiceLanguageOption {
+    code: CustomerInvoiceLanguageCode;
+    locales: string[];
+}
+export declare function normalizeCustomerInvoiceLanguage(value: string): CustomerInvoiceLanguageCode | undefined;
+/** Preserve configured insertion order; a print count never repeats an option. */
+export declare function resolveCustomerInvoiceLanguages(language: Record<string, unknown>, pageLocale: string): CustomerInvoiceLanguageOption[];

package/lib/shared/receipt/customerInvoiceLanguages.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeCustomerInvoiceLanguage = normalizeCustomerInvoiceLanguage;
+exports.resolveCustomerInvoiceLanguages = resolveCustomerInvoiceLanguages;
+const aliases = {
+  en: 'en',
+  en_us: 'en',
+  en_gb: 'en',
+  en_au: 'en',
+  cn: 'zh_CN',
+  zh: 'zh_CN',
+  zh_cn: 'zh_CN',
+  zh_hans: 'zh_CN',
+  zh_sg: 'zh_CN',
+  hk: 'zh_HK',
+  zh_hk: 'zh_HK',
+  zh_tw: 'zh_HK',
+  zh_hant: 'zh_HK',
+  ja: 'ja',
+  ja_jp: 'ja',
+  jp: 'ja',
+  pt: 'pt',
+  pt_br: 'pt',
+  pt_pt: 'pt',
+  cn_en: 'cn_en',
+  en_cn: 'cn_en'
+};
+function normalizeCustomerInvoiceLanguage(value) {
+  return aliases[value.trim().toLowerCase().replace(/-/g, '_')];
+}
+function option(code) {
+  return {
+    code,
+    locales: code === 'cn_en' ? ['en', 'zh_CN'] : [code]
+  };
+}
+
+/** Preserve configured insertion order; a print count never repeats an option. */
+function resolveCustomerInvoiceLanguages(language, pageLocale) {
+  const options = [];
+  const seen = new Set();
+  Object.entries(language).forEach(([key, count]) => {
+    if (typeof count !== 'number' || !Number.isFinite(count) || count <= 0) return;
+    const code = normalizeCustomerInvoiceLanguage(key);
+    if (!code || seen.has(code)) return;
+    seen.add(code);
+    options.push(option(code));
+  });
+  if (options.length) return options;
+  const normalized = normalizeCustomerInvoiceLanguage(pageLocale);
+  // A page locale is a single language, never a bilingual printer mode.
+  const requested = pageLocale.toLowerCase().replace(/_/g, '-');
+  const fallback = normalized && normalized !== 'cn_en' ? normalized : requested.startsWith('zh-tw') || requested.startsWith('zh-hk') ? 'zh_HK' : requested.startsWith('zh') ? 'zh_CN' : requested.startsWith('ja') ? 'ja' : requested.startsWith('pt') ? 'pt' : 'en';
+  return [option(fallback)];
+}

package/lib/shared/receipt/loadCustomerInvoiceLayout.d.ts

@@ -0,0 +1,27 @@
+import type { RequestPlugin } from '../../plugins/request';
+import { type InvoiceLayoutConfig } from '../../modules/OpenData';
+export interface PublicInvoiceDocumentResponse {
+    status: boolean;
+    code: number;
+    message?: string;
+    data: {
+        id: number;
+        data?: {
+            template_settings?: unknown;
+        } | null;
+    } | null;
+}
+export interface CustomerInvoiceTemplate {
+    layout: InvoiceLayoutConfig;
+    language: Record<string, unknown>;
+}
+interface TemplateScope {
+    tenantId: string | number;
+    shopId: string | number;
+    identity: string;
+    businessCode: string;
+    channel: string;
+}
+export declare function loadCustomerInvoiceTemplate(request: RequestPlugin, scope: TemplateScope): Promise<CustomerInvoiceTemplate>;
+export declare function loadCustomerInvoiceLayout(request: RequestPlugin, scope: TemplateScope): Promise<InvoiceLayoutConfig>;
+export {};

package/lib/shared/receipt/loadCustomerInvoiceLayout.js

@@ -0,0 +1,124 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadCustomerInvoiceLayout = loadCustomerInvoiceLayout;
+exports.loadCustomerInvoiceTemplate = loadCustomerInvoiceTemplate;
+var _OpenData = require("../../modules/OpenData");
+// Page-runtime caches: also retain DEFAULT on failure, without automatic retries.
+const caches = new WeakMap();
+const isRecord = value => !!value && typeof value === 'object' && !Array.isArray(value);
+function documentId(value) {
+  if (typeof value !== 'string' && typeof value !== 'number') return null;
+  const text = String(value).trim();
+  if (!/^\d+$/.test(text)) return null;
+  const id = Number(text);
+  return Number.isSafeInteger(id) && id > 0 ? String(id) : null;
+}
+function loadCustomerInvoiceTemplate(request, scope) {
+  let cache = caches.get(request);
+  if (!cache) {
+    cache = {
+      scopes: new Map(),
+      documents: new Map()
+    };
+    caches.set(request, cache);
+  }
+  const target = `${scope.businessCode}+${scope.channel}`;
+  const key = JSON.stringify([scope.tenantId, scope.shopId, scope.identity, scope.businessCode, scope.channel]);
+  const cached = cache.scopes.get(key);
+  if (cached) return cached;
+  let id = null;
+  const task = (async () => {
+    const response = await request.post(`/open/my-pisell/${encodeURIComponent(String(scope.shopId))}/setting`, {
+      scope: 'board',
+      target,
+      section_code: ['documents']
+    }, {
+      pisell2: true,
+      prefix: false,
+      headers: scope.tenantId ? {
+        'Tenant-Id': String(scope.tenantId)
+      } : {},
+      manualErrorHandling: true,
+      skipErrorHandler: true,
+      timeout: 15000
+    });
+    if (response?.status !== true || response.code !== 200 || !isRecord(response.data)) throw new Error(response?.message || 'Invoice OpenData is unavailable');
+    const config = response.data;
+    const raw = config['documents.invoice_template'];
+    id = documentId(raw);
+    if (!id) {
+      // Preserve the existing non-numeric legacy template / invoice_edit contract.
+      const numericLike = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i;
+      return typeof raw === 'string' && raw.trim() && !numericLike.test(raw.trim()) ? {
+        layout: (0, _OpenData.normalizeInvoiceLayoutFromTemplateSettings)((0, _OpenData.normalizeInvoiceTemplateSettings)(config)),
+        language: readLanguage(config['documents.invoice_edit'])
+      } : defaultTemplate();
+    }
+    const docKey = JSON.stringify([key, id]);
+    let pending = cache.documents.get(docKey);
+    if (!pending) {
+      const expectedId = id;
+      pending = (async () => {
+        const result = await request.get(`/open/document/${expectedId}`, {}, {
+          publicInvoiceDocument: true
+        });
+        if (result?.status !== true || result.code !== 200) throw new Error(result?.message || 'Invoice Document request failed');
+        const doc = result.data;
+        if (!doc || documentId(doc.id) !== expectedId) throw new Error('Invoice Document is unavailable or its ID does not match');
+        if (!isRecord(doc.data) || !isRecord(doc.data.template_settings)) throw new Error('Invoice Document has no template_settings');
+        const settings = (0, _OpenData.normalizeRawInvoiceTemplateSettings)(doc.data.template_settings);
+        if (settings.modules.length === 0) throw new Error('Invoice Document has no usable template modules');
+        return {
+          layout: (0, _OpenData.normalizeInvoiceLayoutFromTemplateSettings)(settings),
+          language: readLanguage(doc.data.template_settings)
+        };
+      })().catch(error => fallback(error, target, expectedId));
+      cache.documents.set(docKey, pending);
+    }
+    return pending;
+  })().catch(error => fallback(error, target, id));
+  cache.scopes.set(key, task);
+  return task;
+}
+function fallback(error, target, id) {
+  console.warn('[OrderInvoicePreview] Template unavailable; using DEFAULT', {
+    target,
+    documentId: id,
+    message: error instanceof Error ? error.message : 'Template request failed'
+  });
+  return defaultTemplate();
+}
+
+// Keep the existing layout-only API and its in-flight promise identity intact.
+const layoutPromises = new WeakMap();
+function loadCustomerInvoiceLayout(request, scope) {
+  const template = loadCustomerInvoiceTemplate(request, scope);
+  let layout = layoutPromises.get(template);
+  if (!layout) {
+    layout = template.then(value => value.layout);
+    layoutPromises.set(template, layout);
+  }
+  return layout;
+}
+function defaultTemplate() {
+  return {
+    layout: (0, _OpenData.getDefaultInvoiceLayoutConfig)(),
+    language: {}
+  };
+}
+function readLanguage(value) {
+  let settings = value;
+  if (typeof settings === 'string') {
+    try {
+      settings = JSON.parse(settings);
+    } catch {
+      return {};
+    }
+  }
+  return isRecord(settings) && isRecord(settings.language) ? {
+    ...settings.language
+  } : {};
+}

package/lib/shared/receipt/small-ticket.d.ts

@@ -0,0 +1,96 @@
+export interface SmallTicketShopInfo {
+    name?: string;
+    phone?: string;
+    address?: string;
+    address_street?: string;
+    address_detail?: string;
+    city?: string;
+    province?: string;
+    country?: string;
+    zip?: string;
+    tax_number?: string;
+    tax_title?: string;
+    is_price_include_tax?: 0 | 1 | boolean;
+    currency_symbol?: string;
+    currency_code?: string;
+    primary_locale?: string;
+    timezone?: string;
+    [key: string]: any;
+}
+export interface BuildSmallTicketDataParams {
+    order: Record<string, any>;
+    shopInfo?: SmallTicketShopInfo | null;
+    locales?: string[];
+    productMap?: Record<string | number, Record<string, any>>;
+    /** Resolved template settings or layout; omitted settings preserve native compatibility. */
+    templateSettings?: unknown;
+    /** Customer preview only: stable source identities for bilingual rows. */
+    includeReceiptKeys?: boolean;
+}
+export interface SmallTicketItem {
+    receipt_key?: string;
+    receipt_value_kind?: 'shared' | 'text';
+    receipt_item_kind?: 'shared';
+    item: string;
+    value: string;
+    size?: number;
+    align?: string;
+    product_uid?: string | number;
+    booking_uid?: string | number;
+}
+export interface SmallTicketProduct {
+    receipt_key?: string;
+    receipt_source_index?: number;
+    product_title: string;
+    product_quantity: number;
+    selling_price: string;
+    total_selling_price: string;
+    original_price: string;
+    base_price?: string;
+    total_original_price: string;
+    options_total_price?: string;
+    package_items_total_price?: string;
+    extension_list: any[];
+    product_uid?: string | number;
+    booking_uid?: string | number;
+    product_note?: string;
+    allergy?: string;
+    options?: Array<{
+        receipt_key?: string;
+        receipt_source_index?: number;
+        name: string;
+        num?: number;
+        price?: string;
+        total_price: string;
+        value?: string;
+    }>;
+    variant?: string;
+    combinations?: any[];
+}
+export type SmallTicketAppointment = SmallTicketItem[];
+export interface SmallTicketLocaleData {
+    base_data: Record<string, any>;
+    products: SmallTicketProduct[];
+    fees: {
+        fees: SmallTicketItem[];
+        countFee: Record<string, any>;
+    };
+    customer: SmallTicketItem[];
+    appointment: SmallTicketAppointment;
+    delivery?: SmallTicketItem[];
+    resources: Array<{
+        id: string | number;
+        code: string;
+        title: string;
+        form_title: string;
+    }>;
+    payment_data: SmallTicketItem[][];
+    wallets: SmallTicketItem[][];
+    tickets: any[];
+    source_shop: any[];
+    refund_data: SmallTicketItem[][];
+    expend_data: any[];
+}
+export type SmallTicketData = Record<string, SmallTicketLocaleData>;
+export declare function buildSmallTicketData(params: BuildSmallTicketDataParams): SmallTicketData;
+export declare function hasSmallTicketData(value: any): boolean;