@pisell/private-materials 6.6.7 → 6.6.9

package/dist/es/pro/Selector/types.d.ts

@@ -0,0 +1,173 @@
+//#region src/pro/Selector/types.d.ts
+interface ExprRule {
+  [key: string]: any;
+}
+interface RuleConfig {
+  autoValidate?: boolean;
+  required?: 0 | 1;
+  min?: number;
+  max?: number;
+  mutex?: Array<Array<OptionKey>>;
+  customValidator?: (value: SelectionValue) => Promise<void>;
+}
+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[];
+}
+interface OptionItem {
+  id?: number;
+  title?: string;
+  label?: string;
+  value?: OptionKey;
+  cover?: string;
+  groups?: GroupItem[];
+  disabled?: boolean;
+  ruleConfig?: {
+    min?: number;
+    max?: number;
+  };
+  [key: string]: any;
+}
+type OptionKey = number | string;
+/** 复杂对象值类型：包含id、数量等额外信息 */
+interface SelectionValueObject<T = OptionKey> {
+  value?: T;
+  quantity?: number;
+  [key: string]: any;
+}
+/** 单选值类型 */
+type SelectionValueSingle<T = OptionKey> = T | SelectionValueObject<T>;
+/** 多选值类型 */
+type SelectionValueMultiple<T = OptionKey> = T[] | SelectionValueObject<T>[];
+/** 选择器值类型 */
+type SelectionValue<T = OptionKey> = SelectionValueSingle<T> | SelectionValueMultiple<T>;
+type RenderItemProps = {
+  dataSource: OptionItem;
+  actions: any;
+  optionItemValue?: any;
+  indicator: React.ReactNode;
+  numberSelector: React.ReactNode;
+  values: any;
+  quantityInfo: {
+    maxReached: boolean;
+    remainingCount: number;
+    selectedCount: number;
+  };
+};
+type ItemProps = {
+  layout?: 'vertical' | 'horizontal';
+  renderContent?: (props: {
+    dataSource: OptionItem;
+  }) => React.ReactNode;
+  styles?: {
+    [key: string]: React.CSSProperties;
+  };
+  [key: string]: any;
+};
+type LayoutType = 'flex' | 'grid' | 'antdGrid';
+type LayoutConfig = {
+  type?: LayoutType;
+  gutter?: number | object | Array<number>;
+  wrap?: boolean;
+  direction?: 'row' | 'column';
+  baseWidth?: string;
+  columns?: number;
+  align?: 'top' | 'middle' | 'bottom' | 'stretch';
+  justify?: 'start' | 'end' | 'center' | 'space-between' | 'space-around';
+  colConfig?: {
+    [key: string]: any;
+  };
+};
+interface PresetConfig {
+  variant?: '1' | '2' | '3' | '4' | '5';
+}
+type ItemLayout = 'vertical' | 'horizontal';
+type SelectorVariant = 'default' | 'select' | 'card' | 'media';
+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;
+};
+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;
+}
+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;
+}
+//#endregion
+export { ExprRule, GroupItem, HeaderProps, ItemLayout, ItemProps, LayoutConfig, LayoutType, OptionItem, OptionKey, PresetConfig, RenderItemProps, RuleConfig, SelectionValue, SelectionValueMultiple, SelectionValueObject, SelectionValueSingle, SelectorGroupProps, SelectorProps, SelectorVariant };

package/dist/es/pro/Selector/utils/index.js

@@ -0,0 +1,157 @@
+//#region src/pro/Selector/utils/index.ts
+const normalizeRules = (linkageRules) => {
+	if (Array.isArray(linkageRules)) return [...linkageRules];
+	if (linkageRules && typeof linkageRules === "object") return Object.values(linkageRules);
+	return [];
+};
+const 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;
+};
+const evalCond = (cond, valuesMap) => {
+	const selSet = getSelectedSet(valuesMap[String(cond.groupId ?? "")]);
+	const op = (() => {
+		if (cond.op) return cond.op;
+		if (Array.isArray(cond.in)) return "in";
+		return "in";
+	})();
+	if (op === "in") return (cond.values ?? cond.in ?? []).some((v) => selSet.has(v));
+	if (op === "notIn") return (cond.values ?? cond.in ?? []).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;
+};
+const isCond = (item) => {
+	return item.groupId !== void 0;
+};
+const 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;
+};
+const computeAutoHiddenGroups = (rules) => {
+	const set = /* @__PURE__ */ new Set();
+	rules.forEach((rule) => {
+		const thenActions = Array.isArray(rule?.then) ? rule.then : [];
+		const elseActions = Array.isArray(rule?.elseThen) ? rule.elseThen : [];
+		[...thenActions, ...elseActions].forEach((act) => {
+			if (act?.type === "show") {
+				const gid = String(act?.groupId ?? "");
+				if (gid) set.add(gid);
+			}
+		});
+	});
+	return set;
+};
+const 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?.priority || 0) - (a?.priority || 0));
+	for (let i = 0; i < rules.length; i++) {
+		const rule = rules[i];
+		const hit = evaluateExpr(rule?.when, valuesMap);
+		(hit ? Array.isArray(rule?.then) ? rule.then : [] : Array.isArray(rule?.elseThen) ? rule.elseThen : []).forEach((act) => {
+			if (act?.type === "show") {
+				const gid = String(act?.groupId ?? "");
+				if (gid) visibleGroups[gid] = true;
+			} else if (act?.type === "allowOnly") {
+				const gid = String(act?.groupId ?? "");
+				if (!gid) return;
+				const prev = optionEffects[gid]?.allowOnly || /* @__PURE__ */ new Set();
+				const values = act?.values || [];
+				const merged = new Set([...prev, ...values]);
+				optionEffects[gid] = {
+					...optionEffects[gid] || {},
+					allowOnly: merged
+				};
+			} else if (act?.type === "requireOneOf") {
+				const gid = String(act?.groupId ?? "");
+				if (!gid) return;
+				const values = new Set(act?.values || []);
+				optionEffects[gid] = {
+					...optionEffects[gid] || {},
+					requireOneOf: {
+						values,
+						message: act?.message
+					}
+				};
+			}
+		});
+		if (hit && rule?.stopAfterApply) break;
+	}
+	return {
+		visibleGroups,
+		optionEffects
+	};
+};
+const pruneValuesByAllowOnly = (valuesMap, effects) => {
+	const next = { ...valuesMap };
+	Object.keys(effects).forEach((gid) => {
+		const allowed = effects[gid]?.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)) next[gid] = pruneArray(current);
+		else if (typeof current === "object") if (current.value !== void 0) next[gid] = allowed.has(current.value) ? current : void 0;
+		else next[gid] = current;
+		else next[gid] = allowed.has(current) ? current : void 0;
+	});
+	return next;
+};
+const generateSimpleUUID = () => {
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+		const r = Math.random() * 16 | 0;
+		return (c === "x" ? r : r & 3 | 8).toString(16);
+	});
+};
+
+//#endregion
+export { computeAutoHiddenGroups, computeEffects, generateSimpleUUID, getSelectedSet, normalizeRules, pruneValuesByAllowOnly };

package/dist/es/utils/date.js

@@ -0,0 +1,34 @@
+import { getLocale } from "./locales.js";
+import dayjs from "dayjs";
+
+//#region src/utils/date.ts
+/**
+* @title: 格式化时间
+* @description:
+* @param {Moment} date 时间
+* @param {string} cnFormat 中文
+* @param {string} enFormat 英文
+* @return {*}
+* @Author: Wzw
+* @Date: 2022-07-28 11:57
+*/
+const formatDate = (date, cnFormat, enFormat) => {
+	let _cnFormat = cnFormat || "LL";
+	let _enFormat = enFormat || _cnFormat;
+	let format = _cnFormat;
+	let dayjs_local = "zh-cn";
+	const umi_locale = getLocale();
+	if (umi_locale !== "zh-CN" && umi_locale !== "zh-HK") {
+		dayjs_local = "en-au";
+		format = _enFormat;
+	}
+	if (umi_locale === "zh-TW") {
+		dayjs_local = "zh-tw";
+		format = _cnFormat;
+	}
+	dayjs.locale(dayjs_local);
+	return dayjs(date).format(format);
+};
+
+//#endregion
+export { formatDate };

package/dist/es/utils/index.js

@@ -0,0 +1,28 @@
+import { locales } from "@pisell/utils";
+import { PisellToast } from "@pisell/materials";
+
+//#region src/utils/index.ts
+var Request = class {
+	request = {};
+	constructor() {}
+	setRequest(val) {
+		this.request = val;
+	}
+	withCustomToast(config) {
+		return {
+			...config || {},
+			customToast: (msg) => PisellToast({ content: msg })
+		};
+	}
+	getRequest() {
+		return {
+			...this.request,
+			get: (url, params, config) => this.request.get(url, params, this.withCustomToast(config)),
+			post: (url, params, config) => this.request.post(url, params, this.withCustomToast(config))
+		};
+	}
+};
+const request = new Request();
+
+//#endregion
+export { request };

package/dist/es/utils/load.js

@@ -0,0 +1,60 @@
+//#region src/utils/load.ts
+const cache = {};
+function createScript(options) {
+	const script = document.createElement("script");
+	script.type = options.type || "text/javascript";
+	script.async = !!options.async;
+	script.id = options.id || options.url;
+	if (options.url) script.src = options.url;
+	if (options.text) script.text = options.text;
+	return script;
+}
+function loadScript(head, script) {
+	return new Promise(function(resolve, reject) {
+		let done = false;
+		script.onload = script.onreadystatechange = function() {
+			if (!done && (!script.readyState || script.readyState === "loaded" || script.readyState === "complete")) {
+				done = true;
+				script.onload = null;
+				resolve(script);
+			}
+		};
+		script.onerror = reject;
+		head.appendChild(script);
+	});
+}
+function getScriptById(id) {
+	const script = id && document.getElementById(id);
+	if (script) return script;
+}
+function getScriptByUrl(url) {
+	const script = url && document.querySelector("script[src='" + url + "']");
+	if (script) return script;
+}
+function exec(options, parent) {
+	if (typeof options === "string") options = {
+		url: options,
+		debug: false
+	};
+	const cacheId = options.id || options.url;
+	const cacheEntry = cache[cacheId];
+	if (cacheEntry) {
+		if (!!options.debug) console.log("load-js: cache hit", cacheId);
+		return cacheEntry;
+	}
+	if (options.allowExternal !== false) {
+		let el;
+		if (options.id) el = getScriptById(options.id);
+		if (!el) el = getScriptByUrl(options.url);
+		if (el) {
+			const promise = Promise.resolve(el);
+			if (cacheId) cache[cacheId] = promise;
+			return promise;
+		}
+	}
+	if (!options.url && !options.text) throw new Error("load-js: must provide a url or text to load");
+	return loadScript(parent, createScript(options));
+}
+
+//#endregion
+export { exec as default };

package/dist/es/utils/locales.js

@@ -0,0 +1,7 @@
+//#region src/utils/locales.ts
+const getLocale = () => {
+	return localStorage.getItem("umi_locale") || localStorage.getItem("CapacitorStorage.native_locale") || "en";
+};
+
+//#endregion
+export { getLocale };

package/dist/es/utils/tasks/index.js

@@ -0,0 +1,43 @@
+import { getUniqueId } from "@pisell/utils";
+
+//#region src/utils/tasks/index.ts
+/**
+* 任务管理器
+* 可以添加任务到数组
+* 每次调用runTask, 取第一个执行，执行完毕后删除此任务
+*/
+var TasksManager = class {
+	tasks = [];
+	constructor() {
+		this.tasks = [];
+	}
+	add(code) {
+		this.tasks.push({
+			id: getUniqueId(),
+			code
+		});
+	}
+	addTasks(codes) {
+		codes.forEach((code) => {
+			this.add(code);
+		});
+	}
+	getTasks() {
+		return this.tasks;
+	}
+	async run() {
+		const task = this.tasks.shift();
+		if (!task) return;
+		await task.code(this);
+		this.delete(task.id);
+	}
+	delete(id) {
+		this.tasks = this.tasks.filter((t) => t.id !== id);
+	}
+	clear() {
+		this.tasks = [];
+	}
+};
+
+//#endregion
+export { TasksManager };

package/dist/lib/_virtual/rolldown_runtime.js

@@ -0,0 +1,45 @@
+//#region rolldown:runtime
+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 __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__commonJSMin = __commonJSMin;
+exports.__export = __export;
+exports.__toESM = __toESM;

package/dist/lib/businessModel/SalesModel/Sales/index.js

@@ -0,0 +1,76 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.js');
+const require_useEngineContext = require('../../../hooks/useEngineContext.js');
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react);
+
+//#region src/businessModel/SalesModel/Sales/index.tsx
+const defaultData = {};
+const SALES_MODEL_SESSION_STORAGE_KEY = "shop_h5_sales_model_data";
+const SalesContext = (0, react.createContext)({});
+const SalesProvider = (props) => {
+	const { children, config } = props;
+	const dataRef = (0, react.useRef)({});
+	const [data, setData] = (0, react.useState)(defaultData);
+	const [hooks, setHooks] = (0, react.useState)(props.hooks);
+	const utils = require_useEngineContext.default().appHelper.utils || {};
+	const _setData = (newData) => {
+		dataRef.current = {
+			...dataRef.current,
+			...newData
+		};
+		console.log("sales_model_newData", dataRef.current);
+		if (config?.useSessionStorage) setSessionStorage();
+		setData({ ...dataRef.current });
+	};
+	const getCurrentData = () => {
+		return dataRef.current;
+	};
+	/**
+	* @title 设置sessionStorage
+	* @description 获取路由参数中的cacheId，并设置到sessionStorage中
+	*/
+	const setSessionStorage = () => {
+		const cacheId = (utils?.getHistory?.() || {})?.location?.query?.cacheId || "";
+		const sessionData = {
+			...dataRef.current || {},
+			cacheId
+		};
+		sessionStorage.setItem(`${SALES_MODEL_SESSION_STORAGE_KEY}`, JSON.stringify(sessionData || {}));
+	};
+	/**
+	* @title 获取sessionStorage
+	* @description 获取路由参数中的cacheId并与sessionStorage中的cacheId进行匹配，如果匹配成功，则返回sessionStorage中的数据
+	*/
+	const getSessionStorage = () => {
+		const history = utils?.getHistory?.() || {};
+		const strResult = sessionStorage.getItem(SALES_MODEL_SESSION_STORAGE_KEY);
+		const result = strResult ? JSON.parse(strResult || "{}") : {};
+		const cacheId = history?.location?.query?.cacheId || "";
+		if (!cacheId && !result?.cacheId) return result;
+		if (cacheId && result?.cacheId === cacheId) return result;
+		return {};
+	};
+	const removeSessionStorage = () => {
+		sessionStorage.removeItem(SALES_MODEL_SESSION_STORAGE_KEY);
+	};
+	return /* @__PURE__ */ react.default.createElement(SalesContext.Provider, { value: {
+		data,
+		setData: _setData,
+		getCurrentData,
+		hooks,
+		setHooks,
+		setSessionStorage,
+		getSessionStorage,
+		removeSessionStorage
+	} }, children);
+};
+const useSales = () => {
+	const context = react.default.useContext(SalesContext);
+	if (!context) throw new Error("useSales must be used within a SalesProvider");
+	return context;
+};
+
+//#endregion
+exports.SalesContext = SalesContext;
+exports.SalesProvider = SalesProvider;
+exports.useSales = useSales;

package/dist/lib/businessModel/SalesModel/index.js

@@ -0,0 +1,20 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.js');
+const require_useEngineContext = require('../../hooks/useEngineContext.js');
+const require_index = require('../../utils/index.js');
+const require_index$1 = require('./Sales/index.js');
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react);
+
+//#region src/businessModel/SalesModel/index.tsx
+const SalesModel = ({ children, hooks, config }) => {
+	const utils = require_useEngineContext.default().appHelper.utils || {};
+	require_index.request.setRequest(utils?.request);
+	return /* @__PURE__ */ react.default.createElement(require_index$1.SalesProvider, {
+		hooks,
+		config
+	}, children);
+};
+var SalesModel_default = SalesModel;
+
+//#endregion
+exports.default = SalesModel_default;