nhanh-pure-function 1.3.13 → 1.3.15

package/lib/User/User.d.ts

@@ -184,9 +184,9 @@ export class _LocalDrag {
 }
 
 /** 进入全屏模式 */
-export function _EnterFullscreen(content: HTMLElement): void;
+export function _EnterFullscreen(content: HTMLElement): Promise<void>;
 /** 退出全屏模式 */
-export function _ExitFullscreen(): void;
+export function _ExitFullscreen(): Promise<void>;
 /** 判断是否处于全屏模式 */
 export function _IsFullscreen(): HTMLElement | undefined;
 

package/lib/User/User.js

@@ -485,33 +485,34 @@ export class _LocalDrag {
 
 /** 进入全屏模式 */
 export function _EnterFullscreen(content) {
-  if (!content) return console.error("No DOM: ", content);
-  if (content.requestFullscreen) {
-    content.requestFullscreen();
+  if (!content) {
+    return Promise.reject("No DOM: ", content);
+  } else if (content.requestFullscreen) {
+    return content.requestFullscreen();
   } else if (content.mozRequestFullScreen) {
     // Firefox
-    content.mozRequestFullScreen();
+    return content.mozRequestFullScreen();
   } else if (content.webkitRequestFullscreen) {
     // Chrome, Safari and Opera
-    content.webkitRequestFullscreen();
+    return content.webkitRequestFullscreen();
   } else if (content.msRequestFullscreen) {
     // IE/Edge
-    content.msRequestFullscreen();
+    return content.msRequestFullscreen();
   }
 }
 /** 退出全屏模式 */
 export function _ExitFullscreen() {
   if (document.exitFullscreen) {
-    document.exitFullscreen();
+    return document.exitFullscreen();
   } else if (document.mozCancelFullScreen) {
     // Firefox
-    document.mozCancelFullScreen();
+    return document.mozCancelFullScreen();
   } else if (document.webkitExitFullscreen) {
     // Chrome, Safari and Opera
-    document.webkitExitFullscreen();
+    return document.webkitExitFullscreen();
   } else if (document.msExitFullscreen) {
     // IE/Edge
-    document.msExitFullscreen();
+    return document.msExitFullscreen();
   }
 }
 /** 判断是否处于全屏模式 */

package/lib/Utility/Utility.d.ts

@@ -65,7 +65,7 @@ export function _MergeObjects<T, T1>(A: T, B: T1): T & T1;
  */
 export function _TimeTransition(
   time: number | Date,
-  template: string,
+  template?: string,
   pad?: boolean
 ): string;
 
@@ -91,7 +91,7 @@ export function _GetHrefName(href: string, defaultName = "file"): string;
  * @param {string} href 文件路径
  * @param {string} fileName 导出文件名
  */
-export function _DownloadFile(href: string, fileName?: string): void;
+export function _DownloadFile(href: string, fileName?: string): Promise<void>;
 
 /**
  * 获取帧率
@@ -258,3 +258,65 @@ export function _CheckConnectionWithXHR(url: string): Promise<any>;
  * @returns {boolean} - 如果URL指向安全上下文，则返回true；否则返回false
  */
 export function _IsSecureContext(url: string): boolean;
+
+/**
+ * 文件类型检查器类
+ * 用于检查和验证文件的类型
+ */
+export class _FileTypeChecker {
+  // 定义每种文件类型的扩展名数组
+  private static fileExtensions: {
+    image: string[];
+    ppt: string[];
+    word: string[];
+    excel: string[];
+    pdf: string[];
+    text: string[];
+    audio: string[];
+    video: string[];
+    archive: string[];
+  };
+
+  /**
+   * 检查文件是否符合某种类型
+   *
+   * @param url 文件的URL或路径，用于检查文件类型
+   * @param type 文件类型，必须是fileExtensions属性中定义的键之一
+   * @returns 如果文件符合指定类型，则返回true；否则返回false
+   */
+  static check(
+    url: string,
+    type: keyof typeof FileTypeChecker.fileExtensions
+  ): boolean;
+
+  /**
+   * 内部方法：检查文件扩展名
+   *
+   * @param url 文件的URL或路径，用于提取文件扩展名
+   * @param validExtensions 有效的文件扩展名数组，用于比较
+   * @returns 如果文件扩展名在有效扩展名列表中，则返回true；否则返回false
+   */
+  private static _checkExtension(
+    url: string,
+    validExtensions: string[]
+  ): boolean;
+}
+
+/**
+ * 旋转列表函数
+ *
+ * 该函数接受一个列表作为参数，并返回一个二维数组，其中每个内部数组都是原列表的一种旋转形式
+ * 旋转列表的原理是将原列表分割成两部分，并将这两部分重新组合，形成一个新的列表
+ *
+ * @param list T[] - 需要旋转的列表，列表元素类型为泛型T
+ * @returns T[][] - 返回一个二维数组，每个内部数组代表原列表的一种旋转形式
+ */
+export function _RotateList<T>(list: T[]): T[][];
+
+/**
+ * 克隆给定值的函数
+ * 该函数尝试使用window.structuredClone方法进行深克隆，如果失败则使用自定义方法
+ * @param {any} val - 需要克隆的值
+ * @returns {any} - 克隆后的值
+ */
+export function _Clone<T>(val: T): T;

package/lib/Utility/Utility.js

@@ -86,34 +86,47 @@ export function _CapitalizeFirstLetter(string) {
  * @param {Object | Array} B
  * @returns A&B || B
  */
-export function _MergeObjects(A, B, visitedObjects = []) {
+export function _MergeObjects(
+  A,
+  B,
+  visitedObjects = [],
+  outTime = +new Date()
+) {
+  /** 疑似死循环 */
+  if (outTime < +new Date() - 300) {
+    console.error("_MergeObjects 合并异常：疑似死循环");
+    return null;
+  }
+
   const getType = (v) => (Array.isArray(v) ? "array" : typeof v);
   const TA = getType(A);
   const TB = getType(B);
 
   if (TA != TB) return B;
-  if (visitedObjects.some((item) => item == B)) return B;
-
-  if (TA == "object") {
-    visitedObjects.push(A, B);
-    for (const key in B) {
-      if (Object.prototype.hasOwnProperty.call(B, key)) {
-        const BC = B[key];
-        const AC = A[key];
-        const fianlValue = _MergeObjects(AC, BC, visitedObjects);
-        A[key] = fianlValue;
+
+  if (TA == "object" || TA == "array") {
+    if (visitedObjects.some(([a, b]) => a == A && b == B)) return A;
+    visitedObjects.push([A, B]);
+
+    if (TA == "object") {
+      for (const key in B) {
+        if (Object.prototype.hasOwnProperty.call(B, key)) {
+          const BC = B[key];
+          const AC = A[key];
+          const fianlValue = _MergeObjects(AC, BC, visitedObjects, outTime);
+          A[key] = fianlValue;
+        }
       }
+      return A;
+    } else if (TA == "array") {
+      B.forEach((item, index) => {
+        const BC = item;
+        const AC = A[index];
+        const fianlValue = _MergeObjects(AC, BC, visitedObjects, outTime);
+        A[index] = fianlValue;
+      });
+      return A;
     }
-    return A;
-  } else if (TA == "array") {
-    visitedObjects.push(A, B);
-    B.forEach((item, index) => {
-      const BC = item;
-      const AC = A[index];
-      const fianlValue = _MergeObjects(AC, BC, visitedObjects);
-      A[index] = fianlValue;
-    });
-    return A;
   } else return B;
 }
 
@@ -123,7 +136,11 @@ export function _MergeObjects(A, B, visitedObjects = []) {
  * @param {String} template 完整模板 -->  YYYY MM DD hh mm ss ms
  * @param {Boolean} pad 补0
  */
-export function _TimeTransition(time, template, pad = true) {
+export function _TimeTransition(
+  time,
+  template = "YYYY-MM-DD hh:mm:ss",
+  pad = true
+) {
   try {
     time = new Date(time);
   } catch (error) {
@@ -566,3 +583,148 @@ export function _IsSecureContext(url) {
   // 如果找到匹配的安全协议前缀，则返回true，表示URL指向安全上下文；否则返回false
   return secureProtocols.some((protocol) => url.startsWith(protocol));
 }
+
+/**
+ * 文件类型检查器类
+ * 用于检查和验证文件的类型
+ */
+export class _FileTypeChecker {
+  static fileExtensions = {
+    // 图片文件
+    image: [
+      ".jpg",
+      ".jpeg",
+      ".png",
+      ".gif",
+      ".bmp",
+      ".webp",
+      ".tiff",
+      ".svg",
+      ".heif",
+      ".heic",
+      ".ico",
+      ".raw",
+      ".jfif",
+    ],
+    // 演示文稿文件（PPT）
+    ppt: [".ppt", ".pptx"],
+    // Word 文件
+    word: [".doc", ".docx"],
+    // Excel 文件
+    excel: [".xls", ".xlsx"],
+    // PDF 文件
+    pdf: [".pdf"],
+    // 文本文件
+    text: [".txt", ".csv"],
+    // 音频文件
+    audio: [
+      ".mp3",
+      ".wav",
+      ".ogg",
+      ".flac",
+      ".aac",
+      ".wma",
+      ".m4a",
+      ".alac",
+      ".ape",
+      ".opus",
+      ".amr",
+      ".ra",
+    ],
+    // 视频文件
+    video: [
+      ".mp4",
+      ".avi",
+      ".mkv",
+      ".mov",
+      ".wmv",
+      ".flv",
+      ".webm",
+      ".mpg",
+      ".mpeg",
+      ".3gp",
+      ".vob",
+      ".ogv",
+      ".m4v",
+      ".ts",
+      ".rm",
+      ".rmvb",
+    ],
+    // 压缩包文件
+    archive: [
+      ".zip",
+      ".rar",
+      ".tar",
+      ".gz",
+      ".bz2",
+      ".xz",
+      ".7z",
+      ".tar.gz",
+      ".tar.bz2",
+      ".tar.xz",
+    ],
+  };
+
+  // 判断文件类型
+  static check(url, type) {
+    const extensions = FileTypeChecker.fileExtensions[type];
+    return FileTypeChecker._checkExtension(url, extensions);
+  }
+
+  // 通用的检查扩展名的函数
+  static _checkExtension(url, validExtensions) {
+    const lowerCaseUrl = url.toLowerCase();
+    return validExtensions.some((extension) =>
+      lowerCaseUrl.endsWith(extension)
+    );
+  }
+}
+
+/**
+ * 旋转列表函数
+ *
+ * 该函数接受一个列表作为参数，并返回一个二维数组，其中每个内部数组都是原列表的一种旋转形式
+ * 旋转列表的原理是将原列表分割成两部分，并将这两部分重新组合，形成一个新的列表
+ *
+ * @param list T[] - 需要旋转的列表，列表元素类型为泛型T
+ * @returns T[][] - 返回一个二维数组，每个内部数组代表原列表的一种旋转形式
+ */
+export function _RotateList(list) {
+  // 使用map函数遍历列表，对于列表中的每个元素（这里不需要元素本身，所以用_表示）
+  // i表示当前元素的索引，利用这个索引对列表进行分割和重组
+  return list.map((_, i) => {
+    // 将当前索引i之后的元素与从列表开头到索引i之前的元素拼接成一个新的列表
+    // 这样做可以实现列表的旋转效果
+    return list.slice(i).concat(list.slice(0, i));
+  });
+}
+
+/**
+ * 克隆给定值的函数
+ * 该函数尝试使用window.structuredClone方法进行深克隆，如果失败则使用自定义方法
+ * @param {any} val - 需要克隆的值
+ * @returns {any} - 克隆后的值
+ */
+export function _Clone(val) {
+  // 保存原始的structuredClone方法引用
+  const oldClone = window.structuredClone;
+
+  // 定义一个新的克隆方法，用于处理非对象或null值，以及对象的合并
+  const newClone = (val) => {
+    // 如果val为null或不是对象，则直接返回val
+    if (val === null || typeof val !== "object") return val;
+    // 使用_MergeObjects函数合并对象，如果是数组则传递空数组作为第一个参数，否则传递空对象
+    return _MergeObjects(Array.isArray(val) ? [] : {}, val);
+  };
+
+  // 尝试使用原始的structuredClone方法或自定义的newClone方法进行克隆
+  try {
+    // 如果oldClone存在，则使用oldClone方法进行克隆，否则使用newClone方法
+    return oldClone ? oldClone(val) : newClone(val);
+  } catch (error) {
+    // 使用日志系统或其他方式记录错误信息
+    console.error("structuredClone error:", error);
+    // 如果oldClone存在且之前的尝试失败，则再次使用newClone方法尝试克隆
+    return oldClone && newClone(val);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nhanh-pure-function",
-  "version": "1.3.13",
+  "version": "1.3.15",
   "description": "纯函数工具",
   "main": "lib/Index.js",
   "scripts": {