eslint-config-alloy/site/utils.ts

AlloyTeam ESLint 规则

import url from 'url';
import cookie from 'cookie';
import querystring from 'querystring';
import type { Languages } from '../config';
import { locale, avaliableLanguages } from '../config';

/**
 * 解析描述或原因，转换 <, >, \n 等字符串
 * @param str 需要解析的文本
 */
export function parseDescription(str: string) {
  const language = getLanguage();
  const description = str.replace(/\</g, '&lt;').replace(/\>/g, '&gt;');
  if (language === 'zh-CN') {
    return description
      .replace(/[a-zA-Z0-9\(\)\[\]\{\}\\\/'"_\-\+\?\.\*!=\&\@\#$%~:; ]+/g, (codes) => {
        const matchSpaces = codes.match(/^( *)(.*?)( *)$/);
        if (matchSpaces === null) {
          return `<code>${codes}</code>`;
        }
        if (matchSpaces[2].startsWith('http')) {
          return `${matchSpaces[1]}<a href="${matchSpaces[2]}" target="_blank">${matchSpaces[2]}</a>${matchSpaces[3]}`;
        }
        return `${matchSpaces[1]}<code>${matchSpaces[2]}</code>${matchSpaces[3]}`;
      })
      .replace(/\n/g, '<br />')
      .replace(/禁止/g, '<strong style="color:#db5757; font-weight:600;">$&</strong>')
      .replace(/必须/g, '<strong style="color:#267fd9; font-weight:600;">$&</strong>');
  } else {
    let isOpen = false;
    return description
      .replace(/\n/g, '<br />')
      .split('')
      .map((letter) => {
        if (letter !== '`') {
          return letter;
        }
        isOpen = !isOpen;
        if (isOpen) {
          return '<code>';
        }
        return '</code>';
      })
      .join('');
  }
}

/** 翻译 */
export function t(str: string) {
  const language = getLanguage();
  return (locale as any)[language][str] || str;
}

/** 从 query 和 cookies 获取 language */
export function getLanguage(): Languages {
  let language: any;
  const queryLanguage = getQuery().language;
  if (Array.isArray(queryLanguage)) {
    language = queryLanguage[queryLanguage.length - 1];
  } else {
    language = queryLanguage;
  }

  // 非法的 queryLanguage
  if (!avaliableLanguages.includes(language)) {
    language = cookie.parse(document.cookie).language;
    // 非法的 cookieLanguage
    if (!avaliableLanguages.includes(language)) {
      language = avaliableLanguages[0];
    }
  }

  setCookie('language', language);
  return language;
}

export function getQuery() {
  return querystring.parse(location.search.replace(/^\?/, ''));
}

function setCookie(name: string, value: string, days = 365) {
  const cookieObject = cookie.parse(document.cookie);
  if (cookieObject[name] === value) {
    return;
  }
  let expires = '';
  if (days) {
    const date = new Date();
    date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000);
    expires = '; expires=' + date.toUTCString();
  }
  document.cookie = name + '=' + (value || '') + expires + '; path=/';
}

interface UrlOptions {
  path?: string;
  query?: {
    [key: string]: string | boolean;
  };
}

/** 生成新的 url */
export function newUrl({ path, query }: UrlOptions) {
  const parsedUrl = url.parse(location.href, true);

  const newUrlObject = {
    pathname: parsedUrl.pathname || '',
    query: parsedUrl.query,
  };
  if (path) {
    newUrlObject.pathname = url.resolve(newUrlObject.pathname, path);
  }
  if (query) {
    Object.entries(query).forEach(([key, value]) => {
      if (value === false) {
        delete newUrlObject.query[key];
      } else if (value === true) {
        newUrlObject.query[key] = '1';
      } else {
        newUrlObject.query[key] = value;
      }
    });
  }

  // 排序 query
  const newQuery: querystring.ParsedUrlQuery = {};
  Object.entries(newUrlObject.query)
    .sort(([aKey], [bKey]) => aKey.localeCompare(bKey))
    .forEach(([key, value]) => {
      newQuery[key] = value;
    });
  newUrlObject.query = newQuery;

  return url.format(newUrlObject);
}

export function replaceUrl(url: string, title?: string) {
  history.replaceState({}, title || document.title, url);
}

/** 若为空则返回默认值，可提供取值范围 */
export function defaultTo<T>(source: any, defaultValue: T, avaliableValues?: T[]): T {
  if (typeof source === 'undefined') {
    return defaultValue;
  }
  if (source === null) {
    return defaultValue;
  }
  if (typeof source === 'number' && isNaN(source)) {
    return defaultValue;
  }
  if (typeof avaliableValues !== 'undefined') {
    if (!avaliableValues.includes(source)) {
      return defaultValue;
    }
  }
  return source;
}