@pisell/private-materials 6.3.58 → 6.3.59

package/lib/pro/Selector/types.d.ts

@@ -0,0 +1,173 @@
+/// <reference types="react" />
+export interface ExprRule {
+    [key: string]: any;
+}
+export interface RuleConfig {
+    autoValidate?: boolean;
+    required?: 0 | 1;
+    min?: number;
+    max?: number;
+    mutex?: Array<Array<OptionKey>>;
+    customValidator?: (value: SelectionValue) => Promise<void>;
+}
+export interface GroupItem {
+    id?: number;
+    title?: string;
+    mode?: 'single' | 'multiple';
+    valueType?: 'primitive' | 'object';
+    preserve?: boolean;
+    fieldNames?: {
+        label?: string;
+        value?: string;
+        cover?: string;
+    };
+    ruleConfig?: RuleConfig;
+    dataSource?: OptionItem[];
+}
+export interface OptionItem {
+    id?: number;
+    title?: string;
+    label?: string;
+    value?: OptionKey;
+    cover?: string;
+    groups?: GroupItem[];
+    disabled?: boolean;
+    ruleConfig?: {
+        min?: number;
+        max?: number;
+    };
+    [key: string]: any;
+}
+export declare type OptionKey = number | string;
+/** 原始值类型：单选时为id，多选时为id[] */
+export declare type SelectionValuePrimitive<T = OptionKey> = T | T[];
+/** 复杂对象值类型：包含id、数量等额外信息 */
+export interface SelectionValueObject<T = OptionKey> {
+    value?: T;
+    quantity?: number;
+    [key: string]: any;
+}
+/** 单选值类型 */
+export declare type SelectionValueSingle<T = OptionKey> = T | SelectionValueObject<T>;
+/** 多选值类型 */
+export declare type SelectionValueMultiple<T = OptionKey> = T[] | SelectionValueObject<T>[];
+/** 选择器值类型 */
+export declare type SelectionValue<T = OptionKey> = SelectionValueSingle<T> | SelectionValueMultiple<T>;
+export declare type RenderItemProps = {
+    dataSource: OptionItem;
+    actions: any;
+    optionItemValue?: any;
+    indicator: React.ReactNode;
+    numberSelector: React.ReactNode;
+    values: any;
+    quantityInfo: {
+        maxReached: boolean;
+        remainingCount: number;
+        selectedCount: number;
+    };
+};
+export declare type ItemProps = {
+    layout?: 'vertical' | 'horizontal';
+    renderContent?: (props: {
+        dataSource: OptionItem;
+    }) => React.ReactNode;
+    styles?: {
+        [key: string]: React.CSSProperties;
+    };
+    [key: string]: any;
+};
+export declare type LayoutType = 'antdGrid' | 'custom';
+export declare type LayoutConfig = {
+    type?: LayoutType;
+    className?: string;
+    containerStyle?: React.CSSProperties;
+    columns?: number;
+    gutter?: number | object | Array<number>;
+    align?: 'top' | 'middle' | 'bottom' | 'stretch';
+    justify?: 'start' | 'end' | 'center' | 'space-between' | 'space-around';
+    wrap?: boolean;
+    colConfig?: {
+        [key: string]: any;
+    };
+};
+export interface PresetConfig {
+    variant?: '1' | '2' | '3' | '4' | '5';
+}
+export declare type ItemLayout = 'vertical' | 'horizontal';
+export declare type SelectorVariant = 'default' | 'select' | 'card' | 'media';
+export declare type HeaderProps = {
+    visible?: boolean;
+    style?: React.CSSProperties;
+    title?: {
+        visible?: boolean;
+        text?: React.ReactNode;
+        style?: React.CSSProperties;
+    };
+    icon?: {
+        visible?: boolean;
+        icon?: React.ReactNode;
+        style?: React.CSSProperties;
+    };
+    tip?: {
+        visible?: boolean;
+        text?: React.ReactNode;
+        style?: React.CSSProperties;
+    };
+    renderExtra?: (props: {
+        dataSource: OptionItem;
+        values: SelectionValue;
+    }) => React.ReactNode;
+};
+export interface SelectorProps<T = OptionKey> extends GroupItem {
+    className?: string;
+    value?: SelectionValue<T>;
+    defaultValue?: SelectionValue<T>;
+    onChange?: (value: SelectionValue<T>) => void;
+    onClear?: () => void;
+    disabled?: boolean;
+    variant?: SelectorVariant;
+    itemLayout?: ItemLayout;
+    preset?: PresetConfig;
+    layout?: LayoutConfig;
+    renderItem?: (props: RenderItemProps) => React.ReactNode;
+    itemProps?: ItemProps;
+    indicatorProps?: {
+        show?: boolean;
+        variant?: 'outlined' | 'filled';
+        render?: (props: {
+            option: OptionItem;
+            selected: boolean;
+            disabled: boolean;
+            actions: any;
+        }) => React.ReactNode;
+        [key: string]: any;
+    };
+    showStepper?: true | false | 'auto';
+    stepperProps?: {
+        size?: 'small' | 'middle' | 'large';
+        shape?: 'round' | 'square';
+    };
+    style?: React.CSSProperties;
+    /**
+     * @deprecated
+     */
+    titleProps?: HeaderProps;
+    headerProps?: HeaderProps;
+}
+export interface SelectorGroupProps {
+    allowedValuesPolicy?: 'relaxed' | 'strict';
+    className?: string;
+    customScrollParent?: HTMLElement | string;
+    dataSource: GroupItem[];
+    defaultValue?: Record<string, SelectionValue>;
+    linkageRules?: ExprRule[] | Record<string, any>;
+    onChange?: (values: Record<string, SelectionValue>) => void;
+    preserve?: boolean;
+    tabProps?: {
+        visible?: boolean;
+    };
+    style?: React.CSSProperties;
+    value?: Record<string, SelectionValue>;
+    scrollToFirstError?: boolean;
+    [key: string]: any;
+}

package/lib/pro/Selector/types.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/pro/Selector/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/pro/Selector/utils/index.d.ts

@@ -0,0 +1,49 @@
+import { SelectionValue, GroupItem } from '../types';
+export declare type OptionEffects = Record<string, {
+    allowOnly?: Set<any>;
+    requireOneOf?: {
+        values: Set<any>;
+        message?: string;
+    };
+}>;
+export interface Cond {
+    groupId: string;
+    in?: any[];
+    op?: 'in' | 'notIn' | 'eq' | 'neq' | 'contains' | 'range' | 'exists';
+    value?: any;
+    values?: any[];
+    min?: number;
+    max?: number;
+}
+export interface Expr {
+    allOf?: Array<Cond | Expr>;
+    anyOf?: Array<Cond | Expr>;
+    noneOf?: Array<Cond | Expr>;
+    and?: Array<Cond | Expr>;
+    or?: Array<Cond | Expr>;
+    not?: Array<Cond | Expr>;
+}
+export interface Action {
+    type: 'show' | 'allowOnly' | 'requireOneOf';
+    groupId: string;
+    values?: any[];
+    message?: string;
+}
+export interface Rule {
+    type?: 'expr';
+    when?: Expr;
+    then?: Action[];
+    elseThen?: Action[];
+    priority?: number;
+    stopAfterApply?: boolean;
+}
+export declare const normalizeRules: (linkageRules: any) => Rule[];
+export declare const getSelectedSet: (val: SelectionValue) => Set<any>;
+export declare const evaluateExpr: (expr: Expr | undefined, valuesMap: Record<string, SelectionValue>) => boolean;
+export declare const computeAutoHiddenGroups: (rules: Rule[]) => Set<string>;
+export declare const computeEffects: (dataSource?: GroupItem[], rawRules?: Rule[], valuesMap?: Record<string, SelectionValue>) => {
+    visibleGroups: Record<string, boolean>;
+    optionEffects: OptionEffects;
+};
+export declare const pruneValuesByAllowOnly: (valuesMap: Record<string, SelectionValue>, effects: OptionEffects) => Record<string, SelectionValue>;
+export declare const generateSimpleUUID: () => string;

package/lib/pro/Selector/utils/index.js

@@ -0,0 +1,221 @@
+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/pro/Selector/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  computeAutoHiddenGroups: () => computeAutoHiddenGroups,
+  computeEffects: () => computeEffects,
+  evaluateExpr: () => evaluateExpr,
+  generateSimpleUUID: () => generateSimpleUUID,
+  getSelectedSet: () => getSelectedSet,
+  normalizeRules: () => normalizeRules,
+  pruneValuesByAllowOnly: () => pruneValuesByAllowOnly
+});
+module.exports = __toCommonJS(utils_exports);
+var normalizeRules = (linkageRules) => {
+  if (Array.isArray(linkageRules)) return [...linkageRules];
+  if (linkageRules && typeof linkageRules === "object")
+    return Object.values(linkageRules);
+  return [];
+};
+var getSelectedSet = (val) => {
+  const result = /* @__PURE__ */ new Set();
+  if (val == null) return result;
+  if (Array.isArray(val)) {
+    val.forEach((item) => {
+      if (item && typeof item === "object") {
+        if (item.value !== void 0) result.add(item.value);
+      } else {
+        result.add(item);
+      }
+    });
+  } else if (typeof val === "object") {
+    if (val.value !== void 0) result.add(val.value);
+  } else {
+    result.add(val);
+  }
+  return result;
+};
+var evalCond = (cond, valuesMap) => {
+  const gid = String(cond.groupId ?? "");
+  const selSet = getSelectedSet(valuesMap[gid]);
+  const op = (() => {
+    if (cond.op) return cond.op;
+    if (Array.isArray(cond.in)) return "in";
+    return "in";
+  })();
+  if (op === "in") {
+    const arr = cond.values ?? cond.in ?? [];
+    return arr.some((v) => selSet.has(v));
+  }
+  if (op === "notIn") {
+    const arr = cond.values ?? cond.in ?? [];
+    return arr.every((v) => !selSet.has(v));
+  }
+  if (op === "eq" || op === "contains") {
+    return selSet.has(cond.value);
+  }
+  if (op === "neq") {
+    return !selSet.has(cond.value);
+  }
+  if (op === "range") {
+    const size = selSet.size;
+    const min = cond.min ?? Number.NEGATIVE_INFINITY;
+    const max = cond.max ?? Number.POSITIVE_INFINITY;
+    return size >= min && size <= max;
+  }
+  if (op === "exists") {
+    return selSet.size > 0;
+  }
+  return false;
+};
+var isCond = (item) => {
+  return item.groupId !== void 0;
+};
+var evaluateExpr = (expr, valuesMap) => {
+  if (!expr) return true;
+  const allList = expr.allOf ?? expr.and;
+  const anyList = expr.anyOf ?? expr.or;
+  const noneList = expr.noneOf ?? expr.not;
+  const evalItem = (item) => {
+    if (isCond(item)) return evalCond(item, valuesMap);
+    return evaluateExpr(item, valuesMap);
+  };
+  const everyTrue = (list) => {
+    if (!Array.isArray(list) || list.length === 0) return true;
+    return list.every((it) => evalItem(it));
+  };
+  const someTrue = (list) => {
+    if (!Array.isArray(list) || list.length === 0) return true;
+    return list.some((it) => evalItem(it));
+  };
+  const noneTrue = (list) => {
+    if (!Array.isArray(list) || list.length === 0) return true;
+    return list.every((it) => !evalItem(it));
+  };
+  const okAll = everyTrue(allList);
+  const okAny = someTrue(anyList);
+  const okNone = noneTrue(noneList);
+  return okAll && okAny && okNone;
+};
+var computeAutoHiddenGroups = (rules) => {
+  const set = /* @__PURE__ */ new Set();
+  rules.forEach((rule) => {
+    const thenActions = Array.isArray(rule == null ? void 0 : rule.then) ? rule.then : [];
+    const elseActions = Array.isArray(rule == null ? void 0 : rule.elseThen) ? rule.elseThen : [];
+    const actions = [...thenActions, ...elseActions];
+    actions.forEach((act) => {
+      if ((act == null ? void 0 : act.type) === "show") {
+        const gid = String((act == null ? void 0 : act.groupId) ?? "");
+        if (gid) set.add(gid);
+      }
+    });
+  });
+  return set;
+};
+var computeEffects = (dataSource = [], rawRules = [], valuesMap = {}) => {
+  const autoHiddenGroups = computeAutoHiddenGroups(rawRules);
+  const visibleGroups = {};
+  (dataSource || []).forEach((group) => {
+    const gid = String(group.id ?? "");
+    visibleGroups[gid] = autoHiddenGroups.has(gid) ? false : true;
+  });
+  const optionEffects = {};
+  const rules = [...rawRules].sort((a, b) => ((b == null ? void 0 : b.priority) || 0) - ((a == null ? void 0 : a.priority) || 0));
+  for (let i = 0; i < rules.length; i++) {
+    const rule = rules[i];
+    const hit = evaluateExpr(rule == null ? void 0 : rule.when, valuesMap);
+    const actions = hit ? Array.isArray(rule == null ? void 0 : rule.then) ? rule.then : [] : Array.isArray(rule == null ? void 0 : rule.elseThen) ? rule.elseThen : [];
+    actions.forEach((act) => {
+      var _a;
+      if ((act == null ? void 0 : act.type) === "show") {
+        const gid = String((act == null ? void 0 : act.groupId) ?? "");
+        if (gid) {
+          visibleGroups[gid] = true;
+        }
+      } else if ((act == null ? void 0 : act.type) === "allowOnly") {
+        const gid = String((act == null ? void 0 : act.groupId) ?? "");
+        if (!gid) return;
+        const prev = ((_a = optionEffects[gid]) == null ? void 0 : _a.allowOnly) || /* @__PURE__ */ new Set();
+        const values = (act == null ? void 0 : act.values) || [];
+        const merged = /* @__PURE__ */ new Set([...prev, ...values]);
+        optionEffects[gid] = { ...optionEffects[gid] || {}, allowOnly: merged };
+      } else if ((act == null ? void 0 : act.type) === "requireOneOf") {
+        const gid = String((act == null ? void 0 : act.groupId) ?? "");
+        if (!gid) return;
+        const values = new Set((act == null ? void 0 : act.values) || []);
+        optionEffects[gid] = {
+          ...optionEffects[gid] || {},
+          requireOneOf: { values, message: act == null ? void 0 : act.message }
+        };
+      }
+    });
+    if (hit && (rule == null ? void 0 : rule.stopAfterApply)) break;
+  }
+  return { visibleGroups, optionEffects };
+};
+var pruneValuesByAllowOnly = (valuesMap, effects) => {
+  const next = { ...valuesMap };
+  Object.keys(effects).forEach((gid) => {
+    var _a;
+    const allowed = (_a = effects[gid]) == null ? void 0 : _a.allowOnly;
+    if (!allowed || allowed.size === 0) return;
+    const current = next[gid];
+    if (current == null) return;
+    const pruneArray = (arr) => {
+      return arr.filter((item) => {
+        if (item && typeof item === "object") {
+          return allowed.has(item.value);
+        }
+        return allowed.has(item);
+      });
+    };
+    if (Array.isArray(current)) {
+      const pruned = pruneArray(current);
+      next[gid] = pruned;
+    } else if (typeof current === "object") {
+      const hasVal = current.value !== void 0;
+      if (hasVal) {
+        next[gid] = allowed.has(current.value) ? current : void 0;
+      } else {
+        next[gid] = current;
+      }
+    } else {
+      next[gid] = allowed.has(current) ? current : void 0;
+    }
+  });
+  return next;
+};
+var generateSimpleUUID = () => {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  computeAutoHiddenGroups,
+  computeEffects,
+  evaluateExpr,
+  generateSimpleUUID,
+  getSelectedSet,
+  normalizeRules,
+  pruneValuesByAllowOnly
+});

package/lib/pro/pisellPaymentList/example.d.ts

@@ -4,17 +4,16 @@
  * 这个文件演示了如何使用 PisellPaymentList 和 PisellPaymentListItem 组件
  * 包括如何通过 Context 访问父组件配置
  */
-import React from 'react';
-export declare const BasicExample: () => React.JSX.Element;
-export declare const ChildrenExample: () => React.JSX.Element;
-export declare const CustomItemExample: () => React.JSX.Element;
-export declare const MethodConfigExample: () => React.JSX.Element;
-export declare const FullFeatureExample: () => React.JSX.Element;
+export declare const BasicExample: () => JSX.Element;
+export declare const ChildrenExample: () => JSX.Element;
+export declare const CustomItemExample: () => JSX.Element;
+export declare const MethodConfigExample: () => JSX.Element;
+export declare const FullFeatureExample: () => JSX.Element;
 declare const _default: {
-    BasicExample: () => React.JSX.Element;
-    ChildrenExample: () => React.JSX.Element;
-    CustomItemExample: () => React.JSX.Element;
-    MethodConfigExample: () => React.JSX.Element;
-    FullFeatureExample: () => React.JSX.Element;
+    BasicExample: () => JSX.Element;
+    ChildrenExample: () => JSX.Element;
+    CustomItemExample: () => JSX.Element;
+    MethodConfigExample: () => JSX.Element;
+    FullFeatureExample: () => JSX.Element;
 };
 export default _default;

package/lib/test/setup.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom/vitest';

package/lib/test/setup.js

@@ -0,0 +1,94 @@
+// src/test/setup.ts
+var import_vitest = require("@testing-library/jest-dom/vitest");
+var import_vitest2 = require("vitest");
+import_vitest2.vi.mock("antd", async () => {
+  const actual = await import_vitest2.vi.importActual("antd");
+  return {
+    ...actual,
+    message: {
+      success: import_vitest2.vi.fn(),
+      error: import_vitest2.vi.fn(),
+      warning: import_vitest2.vi.fn(),
+      info: import_vitest2.vi.fn()
+    }
+  };
+});
+import_vitest2.vi.mock("@pisell/utils", () => ({
+  locales: {
+    init: import_vitest2.vi.fn(),
+    getLocale: () => "zh-CN",
+    getText: (key, ...args) => {
+      const mockTexts = {
+        "pisell-login2-check-email-title": "请检查您的邮箱",
+        "pisell-login2-check-phone-title": "请检查您的手机",
+        "pisell-login2-check-email-desc": "我们已向您的邮箱发送了验证码",
+        "pisell-login2-check-phone-desc": "我们已向您的手机发送了验证码",
+        "pisell-login2-no-email-received": "没有收到邮件？",
+        "pisell-login2-no-message-received": "没有收到短信？",
+        "pisell-login2-login-button": "登录",
+        "pisell-login2-back": "返回",
+        "pisell-login2-resend": "重新发送",
+        // Selector 组件相关
+        "pisell2.pro.selector.mode.single": "单选",
+        "pisell2.pro.selector.mode.multiple": "多选",
+        "pisell2.pro.selector.validate.required-msg": "请选择",
+        "pisell2.pro.selector.validate.requireOneOf-msg": "该组必须选择指定集合之一",
+        "pisell2.pro.selector.required-tag": "必选",
+        "pisell2.pro.selector.validate.min-selection": (min) => `至少选择 ${min} 个选项`,
+        "pisell2.pro.selector.validate.max-selection": (max) => `最多选择 ${max} 个选项`,
+        "pisell2.pro.selector.tip.min-max-selection": (min, max) => {
+          const _minText = `至少选择 ${min} 个选项`;
+          const _maxText = `最多选择 ${max} 个选项`;
+          return `${_minText}, ${_maxText}`;
+        }
+      };
+      const text = mockTexts[key];
+      if (typeof text === "function") {
+        return text(...args);
+      }
+      return text || key;
+    }
+  }
+}));
+import_vitest2.vi.mock("../../hooks/useEngineContext", () => ({
+  default: () => ({
+    engine: {
+      get: import_vitest2.vi.fn(),
+      set: import_vitest2.vi.fn()
+    }
+  }),
+  usePisellOS: () => ({
+    engine: {
+      get: import_vitest2.vi.fn(),
+      set: import_vitest2.vi.fn()
+    }
+  })
+}));
+import_vitest2.vi.mock("@pisell/materials", () => ({
+  Iconfont: ({ name, ...props }) => {
+    const React = require("react");
+    return React.createElement("span", { "data-testid": `icon-${name}`, ...props });
+  }
+}));
+import_vitest2.vi.mock("*.less", () => ({}));
+import_vitest2.vi.mock("classnames", () => ({
+  default: (...args) => args.filter(Boolean).join(" ")
+}));
+global.ResizeObserver = import_vitest2.vi.fn().mockImplementation(() => ({
+  observe: import_vitest2.vi.fn(),
+  unobserve: import_vitest2.vi.fn(),
+  disconnect: import_vitest2.vi.fn()
+}));
+Object.defineProperty(window, "matchMedia", {
+  writable: true,
+  value: import_vitest2.vi.fn().mockImplementation((query) => ({
+    matches: false,
+    media: query,
+    onchange: null,
+    addListener: import_vitest2.vi.fn(),
+    removeListener: import_vitest2.vi.fn(),
+    addEventListener: import_vitest2.vi.fn(),
+    removeEventListener: import_vitest2.vi.fn(),
+    dispatchEvent: import_vitest2.vi.fn()
+  }))
+});

package/lib/utils/index.d.ts

@@ -18,6 +18,6 @@ declare let modal: Omit<ModalStaticFunctions, 'warn'>;
 export declare const setModal: (m: Omit<ModalStaticFunctions, 'warn'>) => void;
 export declare const saveConfirm: () => Promise<{
     destroy: () => void;
-    update: (configUpdate: import("antd/es/modal/confirm").ConfigUpdate) => void;
+    update: (configUpdate: import("antd").ModalFuncProps | ((prevConfig: import("antd").ModalFuncProps) => import("antd").ModalFuncProps)) => void;
 }>;
 export { modal };