@pisell/utils 3.0.6 → 3.0.7

package/es/arrayUtils.d.ts

@@ -1,10 +1,9 @@
-//#region src/arrayUtils.d.ts
-declare const uniqueByKey: <T>(arr: T[], key: keyof T) => T[];
+export declare const uniqueByKey: <T>(arr: T[], key: keyof T) => T[];
 /**
  * 分组键的基础类型
  * @description 分组条件计算后得到的标量值
  */
-type GroupKey = string | number | boolean;
+export declare type GroupKey = string | number | boolean;
 /**
  * 分组规则
  * @template T - 数据项类型
@@ -13,34 +12,34 @@ type GroupKey = string | number | boolean;
  * - `string[]`：多字段组合，按顺序拼接为组合键
  * - `(item, index) => GroupKey | GroupKey[]`：完全自定义分组键
  */
-type GroupBySpec<T> = string | string[] | ((item: T, index: number) => GroupKey | GroupKey[]);
+export declare type GroupBySpec<T> = string | string[] | ((item: T, index: number) => GroupKey | GroupKey[]);
 /**
  * 单个分组的结果模型
  * @template T - 数据项类型
  */
-interface GroupResult<T> {
-  /** 分组唯一标识（默认由各分组键以 `|` 拼接） */
-  groupId: string;
-  /** 分组键值数组，与 `GroupBySpec` 顺序对应 */
-  keys: GroupKey[];
-  /** 字段名 -> 键值映射，便于头部直接按字段名取值（自定义函数分组时为空对象） */
-  keyMap: Record<string, GroupKey>;
-  /** 该分组内的原始数据项（保持原数组中的相对顺序） */
-  items: T[];
-  /** 分组的最终顺序下标 */
-  index: number;
+export interface GroupResult<T> {
+    /** 分组唯一标识（默认由各分组键以 `|` 拼接） */
+    groupId: string;
+    /** 分组键值数组，与 `GroupBySpec` 顺序对应 */
+    keys: GroupKey[];
+    /** 字段名 -> 键值映射，便于头部直接按字段名取值（自定义函数分组时为空对象） */
+    keyMap: Record<string, GroupKey>;
+    /** 该分组内的原始数据项（保持原数组中的相对顺序） */
+    items: T[];
+    /** 分组的最终顺序下标 */
+    index: number;
 }
 /**
  * 分组可选项
  * @template T - 数据项类型
  */
-interface GroupByOptions<T> {
-  /** 自定义分组 id 生成（默认 `keys.join('|')`） */
-  getGroupId?: (keys: GroupKey[]) => string;
-  /** 分组之间的排序；不传则保持各分组首次出现的顺序 */
-  sortGroups?: (a: GroupResult<T>, b: GroupResult<T>) => number;
-  /** 分组内数据项的排序；不传则保持原始相对顺序 */
-  sortItems?: (a: T, b: T) => number;
+export interface GroupByOptions<T> {
+    /** 自定义分组 id 生成（默认 `keys.join('|')`） */
+    getGroupId?: (keys: GroupKey[]) => string;
+    /** 分组之间的排序；不传则保持各分组首次出现的顺序 */
+    sortGroups?: (a: GroupResult<T>, b: GroupResult<T>) => number;
+    /** 分组内数据项的排序；不传则保持原始相对顺序 */
+    sortItems?: (a: T, b: T) => number;
 }
 /**
  * 按点路径安全取值
@@ -51,7 +50,7 @@ interface GroupByOptions<T> {
  * getByPath({ a: { b: 1 } }, 'a.b') // 1
  * getByPath({ id: 9 }, 'id') // 9
  */
-declare const getByPath: (obj: unknown, path: string) => unknown;
+export declare const getByPath: (obj: unknown, path: string) => unknown;
 /**
  * 将数组按指定条件分组
  * @template T - 数据项类型
@@ -71,6 +70,4 @@ declare const getByPath: (obj: unknown, path: string) => unknown;
  * // 自定义键
  * groupBy(list, (item) => `${item.productId}_${item.time}`);
  */
-declare const groupBy: <T>(dataSource: T[], spec: GroupBySpec<T>, options?: GroupByOptions<T>) => GroupResult<T>[];
-//#endregion
-export { GroupByOptions, GroupBySpec, GroupKey, GroupResult, getByPath, groupBy, uniqueByKey };
+export declare const groupBy: <T>(dataSource: T[], spec: GroupBySpec<T>, options?: GroupByOptions<T>) => GroupResult<T>[];

package/es/arrayUtils.js

@@ -1,103 +1,163 @@
-//#region src/arrayUtils.ts
-const uniqueByKey = (arr, key) => {
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const item of arr) {
-		const keyValue = item[key];
-		if (!seen.has(keyValue)) {
-			seen.add(keyValue);
-			result.push(item);
-		}
-	}
-	return result;
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+export var uniqueByKey = function uniqueByKey(arr, key) {
+  var seen = new Set();
+  var result = [];
+  var _iterator = _createForOfIteratorHelper(arr),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _item = _step.value;
+      var keyValue = _item[key];
+      if (!seen.has(keyValue)) {
+        seen.add(keyValue);
+        result.push(_item);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return result;
 };
+
 /**
-* 按点路径安全取值
-* @param obj - 取值对象
-* @param path - 字段路径，支持 `'a.b.c'`
-* @returns 路径对应的值，路径不存在时返回 undefined
-* @example
-* getByPath({ a: { b: 1 } }, 'a.b') // 1
-* getByPath({ id: 9 }, 'id') // 9
-*/
-const getByPath = (obj, path) => {
-	if (obj === null || obj === void 0) return;
-	if (path.indexOf(".") === -1) return obj[path];
-	return path.split(".").reduce((acc, key) => {
-		if (acc === null || acc === void 0) return;
-		return acc[key];
-	}, obj);
-};
+ * 分组键的基础类型
+ * @description 分组条件计算后得到的标量值
+ */
+
+/**
+ * 分组规则
+ * @template T - 数据项类型
+ * @description
+ * - `string`：单字段路径，支持 `'a.b.c'` 点路径
+ * - `string[]`：多字段组合，按顺序拼接为组合键
+ * - `(item, index) => GroupKey | GroupKey[]`：完全自定义分组键
+ */
+
+/**
+ * 单个分组的结果模型
+ * @template T - 数据项类型
+ */
+
 /**
-* 将任意值规范化为可用于分组的标量键
-* @description null/undefined 统一归一为空字符串，对象/数组等转为字符串，避免分组键不稳定
-*/
-const normalizeGroupKey = (value) => {
-	if (value === null || value === void 0) return "";
-	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
-	return String(value);
+ * 分组可选项
+ * @template T - 数据项类型
+ */
+
+/**
+ * 按点路径安全取值
+ * @param obj - 取值对象
+ * @param path - 字段路径，支持 `'a.b.c'`
+ * @returns 路径对应的值，路径不存在时返回 undefined
+ * @example
+ * getByPath({ a: { b: 1 } }, 'a.b') // 1
+ * getByPath({ id: 9 }, 'id') // 9
+ */
+export var getByPath = function getByPath(obj, path) {
+  if (obj === null || obj === undefined) {
+    return undefined;
+  }
+  if (path.indexOf('.') === -1) {
+    return obj[path];
+  }
+  return path.split('.').reduce(function (acc, key) {
+    if (acc === null || acc === undefined) {
+      return undefined;
+    }
+    return acc[key];
+  }, obj);
 };
+
 /**
-* 将数组按指定条件分组
-* @template T - 数据项类型
-* @param dataSource - 待分组的数据数组
-* @param spec - 分组规则，详见 {@link GroupBySpec}
-* @param options - 可选项（自定义 groupId、分组/组内排序）
-* @returns 分组结果数组，默认保持各分组首次出现的顺序、组内保持原始相对顺序
-* @description
-* 该函数为纯函数，不修改入参（排序时对内部拷贝操作）。相同分组键的数据会被归入同一分组。
-* @example
-* // 单字段
-* groupBy(list, 'productId');
-* @example
-* // 商品 + 时间组合
-* groupBy(list, ['productId', 'time']);
-* @example
-* // 自定义键
-* groupBy(list, (item) => `${item.productId}_${item.time}`);
-*/
-const groupBy = (dataSource, spec, options = {}) => {
-	const { getGroupId, sortGroups, sortItems } = options;
-	const fieldNames = Array.isArray(spec) ? spec : typeof spec === "string" ? [spec] : [];
-	const groupMap = /* @__PURE__ */ new Map();
-	const order = [];
-	(dataSource || []).forEach((item, index) => {
-		let keys;
-		if (typeof spec === "function") {
-			const result = spec(item, index);
-			keys = (Array.isArray(result) ? result : [result]).map(normalizeGroupKey);
-		} else if (Array.isArray(spec)) keys = spec.map((field) => normalizeGroupKey(getByPath(item, field)));
-		else keys = [normalizeGroupKey(getByPath(item, spec))];
-		const groupId = getGroupId ? getGroupId(keys) : keys.join("|");
-		let group = groupMap.get(groupId);
-		if (!group) {
-			const keyMap = {};
-			fieldNames.forEach((field, i) => {
-				keyMap[field] = keys[i];
-			});
-			group = {
-				groupId,
-				keys,
-				keyMap,
-				items: [],
-				index: order.length
-			};
-			groupMap.set(groupId, group);
-			order.push(groupId);
-		}
-		group.items.push(item);
-	});
-	let groups = order.map((id) => groupMap.get(id));
-	if (sortItems) groups.forEach((group) => {
-		group.items.sort(sortItems);
-	});
-	if (sortGroups) {
-		groups = groups.slice().sort(sortGroups);
-		groups.forEach((group, i) => {
-			group.index = i;
-		});
-	}
-	return groups;
+ * 将任意值规范化为可用于分组的标量键
+ * @description null/undefined 统一归一为空字符串，对象/数组等转为字符串，避免分组键不稳定
+ */
+var normalizeGroupKey = function normalizeGroupKey(value) {
+  if (value === null || value === undefined) {
+    return '';
+  }
+  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+    return value;
+  }
+  return String(value);
 };
-//#endregion
-export { getByPath, groupBy, uniqueByKey };
+
+/**
+ * 将数组按指定条件分组
+ * @template T - 数据项类型
+ * @param dataSource - 待分组的数据数组
+ * @param spec - 分组规则，详见 {@link GroupBySpec}
+ * @param options - 可选项（自定义 groupId、分组/组内排序）
+ * @returns 分组结果数组，默认保持各分组首次出现的顺序、组内保持原始相对顺序
+ * @description
+ * 该函数为纯函数，不修改入参（排序时对内部拷贝操作）。相同分组键的数据会被归入同一分组。
+ * @example
+ * // 单字段
+ * groupBy(list, 'productId');
+ * @example
+ * // 商品 + 时间组合
+ * groupBy(list, ['productId', 'time']);
+ * @example
+ * // 自定义键
+ * groupBy(list, (item) => `${item.productId}_${item.time}`);
+ */
+export var groupBy = function groupBy(dataSource, spec) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var getGroupId = options.getGroupId,
+    sortGroups = options.sortGroups,
+    sortItems = options.sortItems;
+
+  // 仅字段型分组才有可读字段名，用于 keyMap
+  var fieldNames = Array.isArray(spec) ? spec : typeof spec === 'string' ? [spec] : [];
+  var groupMap = new Map();
+  var order = [];
+  (dataSource || []).forEach(function (item, index) {
+    var keys;
+    if (typeof spec === 'function') {
+      var result = spec(item, index);
+      keys = (Array.isArray(result) ? result : [result]).map(normalizeGroupKey);
+    } else if (Array.isArray(spec)) {
+      keys = spec.map(function (field) {
+        return normalizeGroupKey(getByPath(item, field));
+      });
+    } else {
+      keys = [normalizeGroupKey(getByPath(item, spec))];
+    }
+    var groupId = getGroupId ? getGroupId(keys) : keys.join('|');
+    var group = groupMap.get(groupId);
+    if (!group) {
+      var keyMap = {};
+      fieldNames.forEach(function (field, i) {
+        keyMap[field] = keys[i];
+      });
+      group = {
+        groupId: groupId,
+        keys: keys,
+        keyMap: keyMap,
+        items: [],
+        index: order.length
+      };
+      groupMap.set(groupId, group);
+      order.push(groupId);
+    }
+    group.items.push(item);
+  });
+  var groups = order.map(function (id) {
+    return groupMap.get(id);
+  });
+  if (sortItems) {
+    groups.forEach(function (group) {
+      group.items.sort(sortItems);
+    });
+  }
+  if (sortGroups) {
+    groups = groups.slice().sort(sortGroups);
+    groups.forEach(function (group, i) {
+      group.index = i;
+    });
+  }
+  return groups;
+};

package/es/common/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 公共工具和类型导出
+ */
+export type { DisplayState, ValidationResult } from './types';
+export { getDisplayState } from './stateHelper';

package/es/common/index.js

@@ -0,0 +1,5 @@
+/**
+ * 公共工具和类型导出
+ */
+
+export { getDisplayState } from "./stateHelper";

package/es/common/stateHelper.d.ts

@@ -1,6 +1,4 @@
-import { DisplayState } from "./types.js";
-
-//#region src/common/stateHelper.d.ts
+import type { DisplayState } from './types';
 /**
  * 根据 mode 和 disabled 计算组件的显示状态
  *
@@ -17,6 +15,4 @@ import { DisplayState } from "./types.js";
  * getDisplayState('edit', true)  // 'disabled'
  * getDisplayState('read', true)  // 'disabled'
  */
-declare function getDisplayState(mode?: 'read' | 'edit', disabled?: boolean): DisplayState;
-//#endregion
-export { getDisplayState };
+export declare function getDisplayState(mode?: 'read' | 'edit', disabled?: boolean): DisplayState;

package/es/common/stateHelper.js

@@ -1,23 +1,25 @@
-//#region src/common/stateHelper.ts
 /**
-* 根据 mode 和 disabled 计算组件的显示状态
-* 
-* 状态优先级：disabled > mode
-* 当 disabled=true 时，无论 mode 是什么，都显示为禁用态
-* 
-* @param mode 状态模式（'read' | 'edit'）
-* @param disabled 是否禁用
-* @returns 显示状态（'read' | 'edit' | 'disabled'）
-* 
-* @example
-* getDisplayState('edit', false) // 'edit'
-* getDisplayState('read', false) // 'read'
-* getDisplayState('edit', true)  // 'disabled'
-* getDisplayState('read', true)  // 'disabled'
-*/
-function getDisplayState(mode, disabled) {
-	if (disabled) return "disabled";
-	return mode || "edit";
-}
-//#endregion
-export { getDisplayState };
+ * 根据 mode 和 disabled 计算组件的显示状态
+ * 
+ * 状态优先级：disabled > mode
+ * 当 disabled=true 时，无论 mode 是什么，都显示为禁用态
+ * 
+ * @param mode 状态模式（'read' | 'edit'）
+ * @param disabled 是否禁用
+ * @returns 显示状态（'read' | 'edit' | 'disabled'）
+ * 
+ * @example
+ * getDisplayState('edit', false) // 'edit'
+ * getDisplayState('read', false) // 'read'
+ * getDisplayState('edit', true)  // 'disabled'
+ * getDisplayState('read', true)  // 'disabled'
+ */
+export function getDisplayState(mode, disabled) {
+  // disabled 优先级最高
+  if (disabled) {
+    return 'disabled';
+  }
+
+  // 返回基础模式，默认为 edit
+  return mode || 'edit';
+}

package/es/common/types.d.ts

@@ -1,4 +1,3 @@
-//#region src/common/types.d.ts
 /**
  * 公共类型定义
  * 供所有输入组件使用
@@ -11,21 +10,19 @@
  * - edit: 编辑态，显示输入控件
  * - disabled: 禁用态，禁用的输入控件
  */
-type DisplayState = 'read' | 'edit' | 'disabled';
+export declare type DisplayState = 'read' | 'edit' | 'disabled';
 /**
  * 校验结果类型
  *
  * 所有输入组件的校验结果统一格式
  */
-interface ValidationResult {
-  /**
-   * 是否校验通过
-   */
-  isValid: boolean;
-  /**
-   * 错误信息数组
-   */
-  errors: string[];
+export interface ValidationResult {
+    /**
+     * 是否校验通过
+     */
+    isValid: boolean;
+    /**
+     * 错误信息数组
+     */
+    errors: string[];
 }
-//#endregion
-export { DisplayState, ValidationResult };

package/es/common/types.js

@@ -0,0 +1 @@
+export {};

package/es/componentStorage.d.ts

@@ -1,38 +1,36 @@
-//#region src/componentStorage.d.ts
 /** 生成存储 key 的路径后缀：pathname 或 pathname#memory_key（来自 URL memory_key 参数） */
-declare function getStorageKeySuffix(): string;
+export declare function getStorageKeySuffix(): string;
 /**
  * 生成组件实例的存储 key。
  * @param componentId 组件实例 id（如 __id）
  * @param prefix 前缀，如 'table-setting'、'record-board-column-visibility'
  */
-declare function getComponentStorageKey(componentId: string, prefix: string): string;
-interface ColumnSettingStorageItem {
-  key: string;
-  dataIndex: string;
-  title?: unknown;
-  titleString?: string;
-  isShow: boolean;
-  sortIndex?: number;
-  fixed?: 'left' | 'right' | boolean;
+export declare function getComponentStorageKey(componentId: string, prefix: string): string;
+export interface ColumnSettingStorageItem {
+    key: string;
+    dataIndex: string;
+    title?: unknown;
+    titleString?: string;
+    isShow: boolean;
+    sortIndex?: number;
+    fixed?: 'left' | 'right' | boolean;
 }
-declare function saveColumnSettingToLocal(params: {
-  componentId: string;
-  columnSetting: ColumnSettingStorageItem[];
+export declare function saveColumnSettingToLocal(params: {
+    componentId: string;
+    columnSetting: ColumnSettingStorageItem[];
 }): void;
-declare function getColumnSettingFromLocal(componentId?: string): ColumnSettingStorageItem[] | null;
-declare function clearColumnSettingFromLocal(componentId?: string): void;
-declare function saveColumnVisibilityToLocal(params: {
-  componentId: string;
-  columnVisibility: Record<string, boolean>; /** 列 key 顺序，用于列设置弹层拖拽排序后持久化 */
-  columnOrder?: string[];
+export declare function getColumnSettingFromLocal(componentId?: string): ColumnSettingStorageItem[] | null;
+export declare function clearColumnSettingFromLocal(componentId?: string): void;
+export declare function saveColumnVisibilityToLocal(params: {
+    componentId: string;
+    columnVisibility: Record<string, boolean>;
+    /** 列 key 顺序，用于列设置弹层拖拽排序后持久化 */
+    columnOrder?: string[];
 }): void;
-declare function getColumnVisibilityFromLocal(componentId?: string): Record<string, boolean> | null;
+export declare function getColumnVisibilityFromLocal(componentId?: string): Record<string, boolean> | null;
 /** RecordBoard 列设置（显隐 + 顺序）从 localStorage 读取，用于列设置弹层拖拽排序与显隐持久化 */
-declare function getRecordBoardColumnSettingFromLocal(componentId?: string): {
-  columnVisibility: Record<string, boolean>;
-  columnOrder: string[] | null;
+export declare function getRecordBoardColumnSettingFromLocal(componentId?: string): {
+    columnVisibility: Record<string, boolean>;
+    columnOrder: string[] | null;
 } | null;
-declare function clearColumnVisibilityFromLocal(componentId?: string): void;
-//#endregion
-export { ColumnSettingStorageItem, clearColumnSettingFromLocal, clearColumnVisibilityFromLocal, getColumnSettingFromLocal, getColumnVisibilityFromLocal, getComponentStorageKey, getRecordBoardColumnSettingFromLocal, getStorageKeySuffix, saveColumnSettingToLocal, saveColumnVisibilityToLocal };
+export declare function clearColumnVisibilityFromLocal(componentId?: string): void;