ddmt-tool/dist/index.cjs

'use strict';

/* 
 * @Author: ddmt
 * @Date: 2024-9-29 20:50:12
 * @LastEditTime: 2024-9-30 0:12:12
 * @LastEditors: ddmt
 * @Description: ddmt-index file
 * @FilePath: /Tool/animate.js
 */

/**
 * 动画函数
 * @param {HTMLElement} HTMLElement 
 * @param {string} classname 
 * @param {boolean} forceExecute 
 * @returns {void}
 */
function animateStart(HTMLElement, className, forceExecute = false) {
  if (forceExecute) HTMLElement.target.classList.remove(className); // 清洗动画
  HTMLElement.classList.add(className);
  HTMLElement.addEventListener('animationend', event => {
    event.target.classList.remove(className); // 清洗动画
  });
}

/**
 * 设置CSS变量值
 * @param {string} varName 
 * @param {string} value 
 */
function setClassVar(varName, value) {
  document.documentElement.style.setProperty(varName, value);
}

/**
 * 获取CSS变量值
 * @param {string} varName 
 * @returns 
 */
function getStyleVar(varName) {
  return getComputedStyle(document.documentElement).getPropertyValue(varName);
}

/* 
 * @Author: ddmt
 * @Date: 2024-9-29 20:50:12
 * @LastEditTime: 2025-2-18 00:55:00
 * @LastEditors: ddmt
 * @Description: ddmt-index file
 * @FilePath: /Tool/number.js
 */

/**
 * 生成从minNum到maxNum的随机数
 * @param {number} minNum - 最小值
 * @param {number} [maxNum] - 最大值
 * @returns {number} - 生成的随机数
 */
function randomNum(minNum, maxNum) {
  switch (arguments.length) {
    case 1:
      return parseInt(Math.random() * minNum + 1, 10);
    case 2:
      return parseInt(Math.random() * (maxNum - minNum + 1) + minNum, 10);
    default:
      return 0;
  }
}

/**
 * 数组循环函数
 * @param {Array} arr - 数组
 * @param {number} index - 索引
 * @returns {Array} - 循环后的数组
 */
function nextArray(arr, index) {
  index--;
  return arr.slice(index + 1, arr.length).concat(arr.slice(0, index + 1));
}

/**
 * 数组去重函数
 * @param {Array} arr - 数组
 * @returns {Array} - 去重后的数组
 */
function ArrayDeHeavy(arr) {
  let newArr = new Set();
  arr.forEach(item => {
    newArr.add(item);
  });
  return Array.from(newArr);
}

/**
 * 获取相对时间(中文)
 * @param {Date} date - 日期对象
 * @returns {string} - 相对时间字符串
 */
function getRelativeTime(date) {
  const now = new Date();
  const diffInSeconds = Math.floor((now.getTime() - date.getTime()) / 1000);
  if (diffInSeconds < 60) {
    return '刚刚';
  }
  const diffInMinutes = Math.floor(diffInSeconds / 60);
  if (diffInMinutes < 60) {
    return `${diffInMinutes}分钟前`;
  }
  const diffInHours = Math.floor(diffInMinutes / 60);
  if (diffInHours < 24) {
    return `${diffInHours}小时前`;
  }
  const diffInDays = Math.floor(diffInHours / 24);
  if (diffInDays < 30) {
    return `${diffInDays}天前`;
  }
  const diffInMonths = Math.floor(diffInDays / 30);
  if (diffInMonths < 12) {
    return `${diffInMonths}个月前`;
  }
  const diffInYears = Math.floor(diffInMonths / 12);
  if (diffInYears < 5) {
    return `${diffInYears}年前`;
  }
  return '很久以前';
}

/**
 * 解析nginx日志(单行)
 * @param {string} log - 日志字符串
 * @returns {Object|null} - 解析后的日志对象或null
 */
function parseNginxLog(log) {
  const logPattern = /^(\S+) - - \[([^\]]+)\] "(\S+) (\S+) HTTP\/\d\.\d" (\d+) (\d+) "([^"]*)" "([^"]*)"/;
  try {
    const match = log.match(logPattern);
    if (match) {
      return {
        ip: match[1],
        timestamp: match[2],
        method: match[3],
        url: match[4],
        status: parseInt(match[5]),
        responseSize: parseInt(match[6]),
        referrer: match[7],
        userAgent: match[8]
      };
    }
  } catch (error) {
    return error;
  }
  return null;
}

/**
 * cookies 解析函数
 * @param {string} cookies - cookies字符串
 * @returns {Object} - 解析后的cookies对象
 */
function toCookiesArray(cookies) {
  if (!cookies || cookies.length === 0) return;

  // 解析旧的 cookies
  const cookieMap = {};
  cookies.split("; ").forEach(cookie => {
    const [key, value] = cookie.split("=");
    if (key) cookieMap[key] = value;
  });
  return cookieMap;
}

/**
 * cookies 更新函数
 * @param {string} cookies - 原始cookies字符串
 * @param {Array} setCookieArray - 新的 Set-Cookie 数组
 * @returns {string} - 更新后的cookies字符串
 */
function updateCookies(cookies, setCookieArray) {
  if (!setCookieArray || setCookieArray.length === 0) return;

  // 解析旧的 cookies
  const cookieMap = toCookiesArray(cookies);

  // 解析新的 Set-Cookie 数组并更新
  setCookieArray.forEach(cookieStr => {
    const cookiePair = cookieStr.split(";")[0]; // 只取 key=value
    const [key, value] = cookiePair.split("=");
    if (key) cookieMap[key] = value;
  });

  // 重新拼接成字符串存回全局 cookies
  return Object.entries(cookieMap).map(([key, value]) => `${key}=${value}`).join("; ");
}

/**
 * object 转 json
 * @param {string} ObjectText - 对象字符串
 * @returns {string|undefined} - 标准 JSON 字符串或undefined
 */
function objectToJSON(ObjectText) {
  try {
    // 修复键没有双引号的问题
    let fixedString = ObjectText.replace(/(\w+):/g, '"$1":');

    // 修复单引号字符串值的问题
    fixedString = fixedString.replace(/'/g, '"');

    // 修复尾随逗号的问题
    fixedString = fixedString.replace(/,\s*([}\]])/g, '$1');

    // 解析为对象
    const outputObj = JSON.parse(fixedString);

    // 转换为标准 JSON 字符串
    return JSON.stringify(outputObj);
  } catch (error) {
    console.error("解析失败：", error);
  }
}

/* 
 * @Author: ddmt
 * @version: 1.0.11
 * @Date: 2024-9-29 20:50:12
 * @LastEditTime: 2025-2-18 00:55:00
 * @LastEditors: ddmt
 * @Description: ddmt-index file
 * @FilePath: /index.js
 */


// CommonJS 导出
if (typeof module !== 'undefined' && module.exports) {
  module.exports = {
    animateStart,
    setClassVar,
    getStyleVar,
    randomNum,
    nextArray,
    ArrayDeHeavy,
    getRelativeTime,
    parseNginxLog,
    toCookiesArray,
    updateCookies,
    objectToJSON
  };
}
console.log('ddmt-tool Loading successfully!! 😺');

exports.ArrayDeHeavy = ArrayDeHeavy;
exports.animateStart = animateStart;
exports.getRelativeTime = getRelativeTime;
exports.getStyleVar = getStyleVar;
exports.nextArray = nextArray;
exports.objectToJSON = objectToJSON;
exports.parseNginxLog = parseNginxLog;
exports.randomNum = randomNum;
exports.setClassVar = setClassVar;
exports.toCookiesArray = toCookiesArray;
exports.updateCookies = updateCookies;