common-utils-kit 1.0.5 → 1.0.6

package/index.js

@@ -2,10 +2,12 @@
 import * as test from './src/test.js';
 import * as format from './src/format.js';
 import * as tool from './src/tool.js';
-console.log(' ', tool.antiShake())
+import * as files from './src/files.js';
+console.log(' ', test.hasValue(0))
 export default {
   test: { test },
   format: { format },
-  tool: { tool }
+  tool: { tool },
+  files: { files }
 }
 // https://www.cnblogs.com/oldCode/p/learnjts.html

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "common-utils-kit",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "",
   "main": "index.js",
   "type": "module",

package/src/files.js

@@ -0,0 +1,109 @@
+/**
+ * 下载 base64 编码的文件
+ * @param {string} url - base64 编码的数据
+ * @param {string} type - 文件类型的后缀名
+ * @param {string} name - 文件名
+ * @returns {Promise<string>} - Promise 对象，包含文件下载成功时的消息或失败时的错误信息
+ * @example
+ * const base64Data = "data:image/png;base64,R0lGODlhHAAmAKIHAKqqqsvLy0hISObm5vf394uLiwAAAP///yH5B…EoqQqJKAIBaQOVKHAXr3t7txgBjboSvB8EpLoFZywOAo3LFE5lYs/QW9LT1TRk1V7S2xYJADs=";
+ * downloadBase64File(base64Data, "png", "myImage").then((message) => {
+ *   console.log(message); // 文件下载成功
+ * }).catch((error) => {
+ *   console.error(error); // 文件下载失败或其他错误信息
+ * });
+ */
+export function downloadBase64File(url, type = "pdf", name = "文件" + Date.now()) {
+  return new Promise((resolve, reject) => {
+    if (!url) return reject('文件不存在');
+    const imgType = ["png", "jpg", "gif", "jpeg", "webp", "bmp", "tif", "pcx", "tga", "exif", "fpx", "svg", "psd", "cdr", "pcd", "dxf", "ufo", "eps", "ai", "raw", "WMF",];
+    const createBlob = (data, mimeType) => {
+      try {
+        return new Blob([data], { type: mimeType });
+      } catch (e) {
+        reject('创建 Blob 失败');
+      }
+    };
+    let myBlob = null;
+    if (imgType.includes(type)) {
+      const arr = url.split(",");
+      const mime = arr[0].match(/:(.*?);/)[1];
+      const bstr = atob(arr[1]);
+      const u8arr = new Uint8Array(bstr.length);
+      let n = bstr.length;
+      for (let i = 0; i < bstr.length; i++) {
+        u8arr[i] = bstr.charCodeAt(i);
+      }
+      myBlob = createBlob(u8arr, mime);
+    } else {
+      const bstr = atob(url);
+      const u8arr = new Uint8Array(bstr.length);
+      for (let i = 0; i < bstr.length; i++) {
+        u8arr[i] = bstr.charCodeAt(i);
+      }
+      myBlob = createBlob(u8arr, type);
+    }
+    const myUrl = URL.createObjectURL(myBlob);
+    const a = document.createElement("a");
+    a.setAttribute("href", myUrl);
+    const fileName = name;
+    a.setAttribute("download", fileName);
+    a.setAttribute("target", "_blank");
+    const clickEvent = document.createEvent("MouseEvents");
+    clickEvent.initEvent("click", true, true);
+    a.addEventListener("click", () => {
+      window.requestAnimationFrame(() => {
+        setTimeout(() => {
+          URL.revokeObjectURL(myUrl);
+          resolve('文件下载成功');
+        }, 0);
+      });
+    });
+    a.dispatchEvent(clickEvent);
+  });
+}
+/**
+ * 文件地址下载文件
+ * @param {string} url - 文件地址
+ * @param {string} filename - 下载后的文件名
+ * @returns {Promise<boolean>} - Promise 对象，表示下载成功（true）或失败（false）
+ * @example
+ * const fileUrl = "https://example.com/file/document.pdf";
+ * const customFileName = "myDocument";
+ * downloadFiles(fileUrl, customFileName).then((message) => {
+ *   console.log(message); // 文件下载成功
+ * }).catch((error) => {
+ *   console.error(error); // 文件下载失败或其他错误信息
+ * });
+ */
+export function downloadFiles(url, filename) {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open("GET", url, true);
+    xhr.responseType = "blob";
+    xhr.onload = () => {
+      if (xhr.status === 200) {
+        const decodedUrl = decodeURIComponent(url);
+        const matches = decodedUrl.match(/\/([^\/?#]+)[^\/]*$/);
+        const newFileName = filename ? (filename.includes('.') ? filename : `${filename}.${matches[1].split('.').pop()}`) : matches[1]
+        if (window.navigator.msSaveOrOpenBlob) {
+          navigator.msSaveBlob(xhr.response, newFileName);
+        } else {
+          const link = document.createElement("a");
+          link.href = window.URL.createObjectURL(xhr.response);
+          link.download = newFileName;
+          link.style.position = "absolute";
+          link.style.opacity = "0";
+          link.style.pointerEvents = "none";
+          document.body.appendChild(link);
+          link.click();
+          document.body.removeChild(link);
+          window.URL.revokeObjectURL(link.href);
+        }
+        resolve("文件下载成功")
+      } else {
+        reject("文件下载失败")
+      }
+    };
+    xhr.send();
+  });
+}

package/src/format.js

@@ -3,6 +3,16 @@
 * @param {Object} obj - 要获取属性值的对象
 * @param {string} key - 属性路径，可以包含点号（'.'）表示深层嵌套属性
 * @returns {*} - 返回属性值，如果属性不存在则返回 undefined
+* @example
+* const data = {
+*   parent: {
+*     child: {
+*       value: 'Hello, World!'
+*     }
+*   }
+* };
+* const nestedValue = getProperty(data, 'parent.child.value');
+* console.log(nestedValue); // 输出: Hello, World!
 */
 export function getProperty(obj, key) {
   if (!obj) { return }
@@ -27,6 +37,11 @@ export function getProperty(obj, key) {
  * @param {array} data 需要去重的原数组对象
  * @param {string} parameter 去重数组的唯一码(关键字)
  * @returns {Array} - 返回去重后的数组对象
+ * @example
+ * // 使用示例
+ * const data = [{ id: 1, name: 'John' },{ id: 2, name: 'Jane' },{ id: 1, name: 'John' },{ id: 3, name: 'Doe' }];
+ * const uniqueData = unrepeated(data, 'id');
+ * console.log(uniqueData); // 输出: [{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }, { id: 3, name: 'Doe' }]
  */
 export function unrepeated(data, parameter) {
   var temp = {};
@@ -46,6 +61,17 @@ export function unrepeated(data, parameter) {
  * @param {Array} previous - 树形结构数据
  * @param {string} bind - 树形结构中下级节点的绑定属性，默认为 'children'
  * @returns {Array} - 一维数组
+* @example
+ * const treeData = [{ id: 1,
+ *     label: 'parent 1',
+ *     children: [{ id: 2, label: 'child 1' },{ id: 3, label: 'child 2' }]
+ *   },{id: 4,
+ *     label: 'parent 2',
+ *     children: [{ id: 5, label: 'child 3' },{ id: 6, label: 'child 4' }]
+ *   }];
+ * const flatArray = treeToFlat(treeData,'children');
+ * console.log(flatArray);
+ * // 输出：[ { id: 1, label: 'parent 1' },{ id: 2, label: 'child 1' }, { id: 3, label: 'child 2' }, { id: 4, label: 'parent 2' },{ id: 5, label: 'child 3' },{ id: 6, label: 'child 4' }]
  */
 export function treeToFlat(previous, bind = 'children') {
   const result = []
@@ -69,6 +95,31 @@ export function treeToFlat(previous, bind = 'children') {
  * @param {string} [rootValue=null] - 树形结构一级父 id，默认为 null
  * @param {string} [bind="pid"] - 父 id 的属性，默认为 "pid"
  * @returns {Array} - 树形结构
+ * @example
+ * const flatArray = [
+ *   { id: 1, label: 'Node 1', pid: null },
+ *   { id: 2, label: 'Node 2', pid: 1 },
+ *   { id: 3, label: 'Node 3', pid: 1 },
+ *   { id: 4, label: 'Node 4', pid: 2 },
+ *   { id: 5, label: 'Node 5', pid: 2 },
+ *   { id: 6, label: 'Node 6', pid: 3 },
+ *   { id: 7, label: 'Node 7', pid: null },
+ *   { id: 8, label: 'Node 8', pid: 3 },
+ * ];
+ * const treeData = flatToTree(flatArray);
+ * console.log(treeData);
+ * // 输出: [
+ * //   {
+ * //     id: 1,
+ * //     label: 'Node 1',
+ * //     pid: null,
+ * //     children: [
+ * //       { id: 2, label: 'Node 2', pid: 1, children: [ { id: 4, label: 'Node 4', pid: 2 }, { id: 5, label: 'Node 5', pid: 2 } ] },
+ * //       { id: 3, label: 'Node 3', pid: 1, children: [ { id: 6, label: 'Node 6', pid: 3, children: [ { id: 8, label: 'Node 8', pid: 6 } ] } ] },
+ * //     ],
+ * //   },
+ * //   { id: 7, label: 'Node 7', pid: null },
+ * // ]
  */
 export function flatToTree(flatArray, rootValue = null, bind = "pid") {
   const tree = [];
@@ -83,3 +134,38 @@ export function flatToTree(flatArray, rootValue = null, bind = "pid") {
   });
   return tree.length > 0 ? tree : null; // 处理不存在的根节点
 }
+/**
+ * 递归封装
+ * @param {Array} data - 待处理的数据
+ * @param {Function} funName - 处理每个节点的方法
+ * @param {string} [bind="children"] - 子节点绑定属性的名称，默认为 "children"
+ * @returns {Array} - 处理后的树形结构数据
+ * @example
+ * // 数据结构
+ * const treeData = [{ id: 1,
+ *     label: 'parent 1',
+ *     children: [{ id: 2, label: 'child 1' },{ id: 3, label: 'child 2' }]
+ *   },{id: 4,
+ *     label: 'parent 2',
+ *     children: [{ id: 5, label: 'child 3' },{ id: 6, label: 'child 4' }]
+ *   }];
+ *
+ * // 处理逻辑函数，
+ * function processFunction(node) {
+ *   return { label: node.label.toUpperCase() };
+ * }
+ * // 使用递归封装方法
+ * const processedTree = recursionFunction(treeData, processFunction);
+ */
+export function recursionFunction(data, processFunction, bind = 'children') {
+  function internalRecursion(previous, initial) {
+    return previous.map((element, i) => {
+      const menus = initial[i] ? processFunction(initial[i]) : {};
+      const children = element[bind] && Array.isArray(element[bind]) && element[bind].length > 0
+        ? internalRecursion(element[bind], initial[i][bind])
+        : [];
+      return { [bind]: children, ...menus };
+    });
+  }
+  return internalRecursion(data, data);
+}

package/src/test.js

@@ -4,6 +4,15 @@
  * @param {*} value - 要验证的值
  * @param {string} type - 类型检查（可选），当类型为 'number' 时会将 0 视为有值
  * @returns {boolean} - 如果有值返回 true，否则返回 false
+ * @example
+ * // 使用示例
+ * console.log(hasValue('   Hello   ')); // 输出: true
+ * console.log(hasValue(0, 'number'),hasValue(0)); // 传入类型number，0也是有值 输出: true  false
+ * console.log(hasValue(true)); // 输出: true
+ * console.log(hasValue([1, 2, 3]),hasValue([])); // 输出: true  false
+ * console.log(hasValue({ key: 'value' }),hasValue({})); // 输出: true false
+ * console.log(hasValue(undefined)); // 输出: false
+ * console.log(hasValue(null)); // 输出: false
  */
 export function hasValue(value, type) {
   switch (typeof value) {
@@ -29,6 +38,15 @@ export function hasValue(value, type) {
  * 获取值的数据类型
  * @param {*} value - 要获取类型的值
  * @returns {string} - 返回值的数据类型，包括 'string'、'number'、'boolean'、'function'、'array'、'object'、'null' 等
+ * @example
+ * // 使用示例
+ * console.log(valueType('Hello')); // 输出: 'string'
+ * console.log(valueType(42)); // 输出: 'number'
+ * console.log(valueType(true)); // 输出: 'boolean'
+ * console.log(valueType(function () {})); // 输出: 'function'
+ * console.log(valueType([1, 2, 3])); // 输出: 'array'
+ * console.log(valueType({ key: 'value' })); // 输出: 'object'
+ * console.log(valueType(null)); // 输出: 'null'
  */
 export function valueType(value) {
   switch (typeof value) {