ali-skills 0.0.21 → 0.0.22

package/node_modules/utility/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "utility",
+  "version": "2.5.0",
+  "description": "A collection of useful utilities.",
+  "scripts": {
+    "lint": "eslint src test --ext ts",
+    "pretest": "npm run lint -- --fix && npm run prepublishOnly",
+    "test": "egg-bin test",
+    "test-local": "egg-bin test",
+    "preci": "npm run lint && npm run prepublishOnly && attw --pack",
+    "ci": "egg-bin cov",
+    "prepublishOnly": "tshy && tshy-after"
+  },
+  "dependencies": {
+    "escape-html": "^1.0.3",
+    "unescape": "^1.0.1",
+    "ylru": "^2.0.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.17.1",
+    "@eggjs/tsconfig": "^1.3.3",
+    "@types/escape-html": "^1.0.4",
+    "@types/mocha": "^10.0.6",
+    "@types/node": "22",
+    "beautify-benchmark": "^0.2.4",
+    "benchmark": "^2.1.4",
+    "egg-bin": "^6.5.2",
+    "eslint": "^8.54.0",
+    "eslint-config-egg": "^13.0.0",
+    "moment": "^2.22.2",
+    "object-assign": "^4.1.1",
+    "optimized": "^1.2.0",
+    "time-require": "^0.1.2",
+    "tsd": "^0.28.1",
+    "tshy": "^3.0.2",
+    "tshy-after": "^1.0.0",
+    "typescript": "^5.2.2"
+  },
+  "homepage": "https://github.com/node-modules/utility",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/node-modules/utility.git"
+  },
+  "keywords": [
+    "utility",
+    "util",
+    "utils",
+    "sha256",
+    "sha1",
+    "hash",
+    "hex"
+  ],
+  "engines": {
+    "node": ">= 16.0.0"
+  },
+  "author": "fengmk2 <fengmk2@gmail.com> (https://github.com/fengmk2)",
+  "license": "MIT",
+  "type": "module",
+  "tshy": {
+    "exports": {
+      "./package.json": "./package.json",
+      ".": "./src/index.ts"
+    }
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/index.d.ts",
+        "default": "./dist/commonjs/index.js"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "main": "./dist/commonjs/index.js",
+  "types": "./dist/commonjs/index.d.ts",
+  "module": "./dist/esm/index.js"
+}

package/node_modules/utility/src/array.ts

@@ -0,0 +1,44 @@
+/**
+ * Array random slice with items count
+ */
+export function randomSlice<T = any>(arr: T[], num?: number): T[] {
+  if (!num || num >= arr.length) {
+    return arr.slice();
+  }
+  const index = Math.floor(Math.random() * arr.length);
+  const a: T[] = [];
+  for (let i = 0, j = index; i < num; i++) {
+    a.push(arr[j++]);
+    if (j === arr.length) {
+      j = 0;
+    }
+  }
+  return a;
+}
+
+/**
+ * Remove one exists element from an array
+ * @param {Array} arr input array
+ * @param  {Number} index - remove element index
+ * @return {Array} the array instance
+ */
+export function spliceOne<T = any>(arr: T[], index: number): T[] {
+  if (index < 0) {
+    index = arr.length + index;
+    // still negative, not found element
+    if (index < 0) {
+      return arr;
+    }
+  }
+
+  // don't touch
+  if (index >= arr.length) {
+    return arr;
+  }
+
+  for (let i = index, k = i + 1, n = arr.length; k < n; i += 1, k += 1) {
+    arr[i] = arr[k];
+  }
+  arr.pop();
+  return arr;
+}

package/node_modules/utility/src/crypto.ts

@@ -0,0 +1,160 @@
+import { createHash, createHmac, BinaryToTextEncoding } from 'node:crypto';
+import crypto from 'node:crypto';
+
+type HashInput = string | Buffer | ArrayBuffer | DataView | object;
+type HashMethod = (method: string, data: HashInput, outputEncoding?: BinaryToTextEncoding) => string;
+
+const nativeHash = 'hash' in crypto ? crypto.hash as HashMethod : null;
+
+/**
+ * hash
+ *
+ * @param {String} method hash method, e.g.: 'md5', 'sha1'
+ * @param {String|Buffer|ArrayBuffer|TypedArray|DataView|Object} s input value
+ * @param {String} [format] output string format, could be 'hex' or 'base64'. default is 'hex'.
+ * @return {String} md5 hash string
+ * @public
+ */
+export function hash(method: string, s: HashInput, format?: BinaryToTextEncoding): string {
+  if (s instanceof ArrayBuffer) {
+    s = Buffer.from(s);
+  }
+  const isBuffer = Buffer.isBuffer(s) || ArrayBuffer.isView(s);
+  if (!isBuffer && typeof s === 'object') {
+    s = JSON.stringify(sortObject(s));
+  }
+
+  if (nativeHash) {
+    // try to use crypto.hash first
+    // https://nodejs.org/en/blog/release/v21.7.0#crypto-implement-cryptohash
+    return nativeHash(method, s, format);
+  }
+
+  const sum = createHash(method);
+  sum.update(s as string, isBuffer ? 'binary' : 'utf8');
+  return sum.digest(format || 'hex');
+}
+
+/**
+ * md5 hash
+ *
+ * @param {String|Buffer|Object} s input value
+ * @param {String} [format] output string format, could be 'hex' or 'base64'. default is 'hex'.
+ * @return {String} md5 hash string
+ * @public
+ */
+export function md5(s: HashInput, format?: BinaryToTextEncoding): string {
+  return hash('md5', s, format);
+}
+
+/**
+ * sha1 hash
+ *
+ * @param {String|Buffer|Object} s input value
+ * @param {String} [format] output string format, could be 'hex' or 'base64'. default is 'hex'.
+ * @return {String} sha1 hash string
+ * @public
+ */
+export function sha1(s: HashInput, format?: BinaryToTextEncoding): string {
+  return hash('sha1', s, format);
+}
+
+/**
+ * sha256 hash
+ *
+ * @param {String|Buffer|Object} s input value
+ * @param {String} [format] output string format, could be 'hex' or 'base64'. default is 'hex'.
+ * @return {String} sha256 hash string
+ * @public
+ */
+export function sha256(s: HashInput, format?: BinaryToTextEncoding): string {
+  return hash('sha256', s, format);
+}
+
+/**
+ * sha512 hash
+ *
+ * @param {String|Buffer|Object} s input value
+ * @param {String} [format] output string format, could be 'hex' or 'base64'. default is 'hex'.
+ * @return {String} sha512 hash string
+ * @public
+ */
+export function sha512(s: HashInput, format?: BinaryToTextEncoding): string {
+  return hash('sha512', s, format);
+}
+
+/**
+ * HMAC algorithm.
+ *
+ * Equal bash:
+ *
+ * ```bash
+ * $ echo -n "$data" | openssl dgst -binary -$algorithm -hmac "$key" | openssl $encoding
+ * ```
+ *
+ * @param {String} algorithm dependent on the available algorithms supported by the version of OpenSSL on the platform.
+ *   Examples are 'sha1', 'md5', 'sha256', 'sha512', etc.
+ *   On recent releases, `openssl list-message-digest-algorithms` will display the available digest algorithms.
+ * @param {String} key the hmac key to be used.
+ * @param {String|Buffer} data content string.
+ * @param {String} [encoding='base64'] default encoding is base64
+ * @return {String} digest string.
+ */
+export function hmac(algorithm: string, key: string, data: string | Buffer, encoding?: BinaryToTextEncoding): string {
+  encoding = encoding || 'base64';
+  const hmac = createHmac(algorithm, key);
+  hmac.update(data as string, Buffer.isBuffer(data) ? 'binary' : 'utf8');
+  return hmac.digest(encoding);
+}
+
+/**
+ * Base64 encode string.
+ *
+ * @param {String|Buffer} s input value
+ * @param {Boolean} [urlSafe=false] Encode string s using a URL-safe alphabet,
+ *   which substitutes - instead of + and _ instead of / in the standard Base64 alphabet.
+ * @return {String} base64 encode format string.
+ */
+export function base64encode(s: string | Buffer, urlSafe?: boolean): string {
+  if (!Buffer.isBuffer(s)) {
+    s = Buffer.from(s);
+  }
+  let encode = s.toString('base64');
+  if (urlSafe) {
+    encode = encode.replace(/\+/g, '-').replace(/\//g, '_');
+  }
+  return encode;
+}
+
+/**
+ * Base64 string decode.
+ *
+ * @param {String} encodeStr base64 encoding string.
+ * @param {Boolean} [urlSafe=false] Decode string s using a URL-safe alphabet,
+ *   which substitutes - instead of + and _ instead of / in the standard Base64 alphabet.
+ * @param {encoding} [encoding=utf8] if encoding = buffer, will return Buffer instance
+ * @return {String|Buffer} plain text.
+ */
+export function base64decode(encodeStr: string, urlSafe?: boolean, encoding?: BufferEncoding | 'buffer'): string | Buffer {
+  if (urlSafe) {
+    encodeStr = encodeStr.replace(/\-/g, '+').replace(/_/g, '/');
+  }
+  const buf = Buffer.from(encodeStr, 'base64');
+  if (encoding === 'buffer') {
+    return buf;
+  }
+  return buf.toString(encoding || 'utf8');
+}
+
+function sortObject(o: any) {
+  if (!o || Array.isArray(o) || typeof o !== 'object') {
+    return o;
+  }
+  const keys = Object.keys(o);
+  keys.sort();
+  const values: any[] = [];
+  for (const k of keys) {
+    values.push([ k, sortObject(o[k]) ]);
+  }
+  return values;
+}

package/node_modules/utility/src/date.ts

@@ -0,0 +1,232 @@
+import { LRU } from 'ylru';
+const lru = new LRU(1000); // Cache up to 1000 entries
+
+export function resetTimezone(date: Date) {
+  let TIMEZONE: string = '';
+  const offsetInMinutes = date.getTimezoneOffset();
+  const _hourOffset: number = Math.floor(-offsetInMinutes / 60);
+  const _minuteOffset: number = Math.abs(offsetInMinutes % 60);
+
+  TIMEZONE += _hourOffset >= 0 ? '+' : '-';
+  TIMEZONE += `${String(Math.abs(_hourOffset)).padStart(2, '0')}${String(_minuteOffset).padStart(2, '0')}`;
+
+  return TIMEZONE;
+}
+
+const MONTHS: Record<string, string> = {
+  '01': 'Jan',
+  '02': 'Feb',
+  '03': 'Mar',
+  '04': 'Apr',
+  '05': 'May',
+  '06': 'Jun',
+  '07': 'Jul',
+  '08': 'Aug',
+  '09': 'Sep',
+  // eslint-disable-next-line quote-props
+  '10': 'Oct',
+  // eslint-disable-next-line quote-props
+  '11': 'Nov',
+  // eslint-disable-next-line quote-props
+  '12': 'Dec',
+};
+
+/**
+ * return `[ YYYY, MM, DD, HH, mm, ss ]` date string array
+ */
+export function getDateStringParts(d?: Date, onlyDate?: boolean) {
+  d = d || new Date();
+  const monthNum = d.getMonth() + 1;
+  const month = monthNum < 10 ? `0${monthNum}` : `${monthNum}`;
+  const dateNum = d.getDate();
+  const date = dateNum < 10 ? `0${dateNum}` : `${dateNum}`;
+  if (onlyDate) {
+    return [ `${d.getFullYear()}`, month, date ];
+  }
+  const hoursNum = d.getHours();
+  const hours = hoursNum < 10 ? `0${hoursNum}` : `${hoursNum}`;
+  const minutesNum = d.getMinutes();
+  const minutes = minutesNum < 10 ? `0${minutesNum}` : `${minutesNum}`;
+  const secondsNum = d.getSeconds();
+  const seconds = secondsNum < 10 ? `0${secondsNum}` : `${secondsNum}`;
+  return [ `${d.getFullYear()}`, month, date, hours, minutes, seconds ];
+}
+
+/**
+ * Access log format date. format: `moment().format('DD/MMM/YYYY:HH:mm:ss ZZ')`
+ */
+export function accessLogDate(d?: Date): string {
+  // 16/Apr/2013:16:40:09 +0800
+  d = d || new Date();
+  const [ year, month, date, hours, minutes, seconds ] = getDateStringParts(d);
+  const TIMEZONE = getTimezone(d);
+  return `${date}/${MONTHS[month]}/${year}:${hours}:${minutes}:${seconds} ${TIMEZONE}`;
+}
+
+export function getTimezone(d: Date) {
+  const key = d.getFullYear() + '-' + (d.getMonth() + 1) + '-' + d.getDate();
+  const timeZone = lru.get(key);
+  if (timeZone === undefined) {
+    lru.set(key, resetTimezone(d), { maxAge: 86400000 }); // Cache for 24 hours
+    return lru.get(key);
+  }
+  return timeZone;
+}
+/**
+ * Normal log format date. format: `moment().format('YYYY-MM-DD HH:mm:ss.SSS')`
+ */
+export function logDate(msSep?: string): string;
+export function logDate(d?: Date): string;
+export function logDate(d?: Date | null, msSep?: string): string;
+export function logDate(d?: Date | string | null, msSep?: string): string {
+  if (typeof d === 'string') {
+    // logDate(msSep)
+    msSep = d;
+    d = new Date();
+  } else {
+    // logDate(d, msSep)
+    d = d || new Date();
+  }
+  const [ year, month, date, hours, minutes, seconds ] = getDateStringParts(d);
+  const millisecondsNum = d.getMilliseconds();
+  let milliseconds = `${millisecondsNum}`;
+  if (millisecondsNum < 10) {
+    milliseconds = `00${millisecondsNum}`;
+  } else if (millisecondsNum < 100) {
+    milliseconds = `0${millisecondsNum}`;
+  }
+  msSep = msSep || '.';
+  return `${year}-${month}-${date} ${hours}:${minutes}:${seconds}${msSep}${milliseconds}`;
+}
+
+export const YYYYMMDDHHmmssSSS = logDate;
+
+export interface YYYYMMDDHHmmssOptions {
+  dateSep?: string;
+  timeSep?: string;
+}
+
+/**
+ * `moment().format('YYYY-MM-DD HH:mm:ss')` format date string.
+ */
+export function YYYYMMDDHHmmss(d?: Date | string | number, options?: YYYYMMDDHHmmssOptions): string {
+  d = d || new Date();
+  if (!(d instanceof Date)) {
+    d = new Date(d);
+  }
+
+  let dateSep = '-';
+  let timeSep = ':';
+  if (options?.dateSep) {
+    dateSep = options.dateSep;
+  }
+  if (options?.timeSep) {
+    timeSep = options.timeSep;
+  }
+  const [ year, month, date, hours, minutes, seconds ] = getDateStringParts(d);
+  return `${year}${dateSep}${month}${dateSep}${date} ${hours}${timeSep}${minutes}${timeSep}${seconds}`;
+}
+
+/**
+ * `moment().format('YYYY-MM-DD')` format date string.
+ */
+export function YYYYMMDD(d?: Date | string, sep?: string): string {
+  if (typeof d === 'string') {
+    // YYYYMMDD(sep)
+    sep = d;
+    d = new Date();
+  } else {
+    // YYYYMMDD(d, sep)
+    d = d || new Date();
+    if (typeof sep !== 'string') {
+      sep = '-';
+    }
+  }
+  const [ year, month, date ] = getDateStringParts(d, true);
+  return `${year}${sep}${month}${sep}${date}`;
+}
+
+export interface DateStruct {
+  YYYYMMDD: number;
+  H: number;
+}
+
+/**
+ * return datetime struct.
+ *
+ * @return {Object} date
+ *  - {Number} YYYYMMDD, 20130401
+ *  - {Number} H, 0, 1, 9, 12, 23
+ */
+export function datestruct(now?: Date): DateStruct {
+  now = now || new Date();
+  return {
+    YYYYMMDD: now.getFullYear() * 10000 + (now.getMonth() + 1) * 100 + now.getDate(),
+    H: now.getHours(),
+  } satisfies DateStruct;
+}
+
+/**
+ * Get Unix's timestamp in seconds.
+ */
+export function timestamp(t?: number | string): number | Date {
+  if (t) {
+    // convert timestamp to Date
+    // timestamp(timestampValue)
+    let v: number;
+    if (typeof t === 'string') {
+      v = Number(t);
+    } else {
+      v = t;
+    }
+    if (String(v).length === 10) {
+      v *= 1000;
+    }
+    return new Date(v);
+  }
+  // get current timestamp
+  return Math.round(Date.now() / 1000);
+}
+
+/**
+ * Parse timestamp to Date
+ */
+export function parseTimestamp(t: number | string): Date {
+  return timestamp(t) as Date;
+}
+
+/**
+ * Convert Date object to Unix timestamp in seconds.
+ */
+export function dateToUnixTimestamp(date: Date): number {
+  return Math.round(date.getTime() / 1000);
+}
+
+export enum DateFormat {
+  DateTimeWithTimeZone = 'DateTimeWithTimeZone',
+  DateTimeWithMilliSeconds = 'DateTimeWithMilliSeconds',
+  DateTimeWithSeconds = 'DateTimeWithSeconds',
+  UnixTimestamp = 'UnixTimestamp',
+}
+
+/**
+ * Provide milliseconds, return a formatted string.
+ */
+export function getDateFromMilliseconds(milliseconds: number, format?: DateFormat): string {
+  if (!Number.isFinite(milliseconds)) {
+    throw new Error('Invalid milliseconds value');
+  }
+
+  switch (format) {
+    case DateFormat.DateTimeWithTimeZone:
+      return accessLogDate(new Date(milliseconds));
+    case DateFormat.DateTimeWithMilliSeconds:
+      return logDate(new Date(milliseconds));
+    case DateFormat.DateTimeWithSeconds:
+      return YYYYMMDDHHmmss(new Date(milliseconds));
+    case DateFormat.UnixTimestamp:
+      return dateToUnixTimestamp(new Date(milliseconds)).toString();
+    default:
+      return YYYYMMDD(new Date(milliseconds));
+  }
+}

package/node_modules/utility/src/fs.ts

@@ -0,0 +1,17 @@
+import { Stats } from 'node:fs';
+import { stat } from 'node:fs/promises';
+
+/**
+ * Check if a file exists.
+ * Returns the file stats if it exists, or `false` if it doesn't.
+ */
+export async function exists(file: string): Promise<Stats | false> {
+  try {
+    return await stat(file);
+  } catch (err: any) {
+    if (err.code === 'ENOENT') {
+      return false;
+    }
+    throw err;
+  }
+}

package/node_modules/utility/src/function.ts

@@ -0,0 +1,30 @@
+import assert from 'node:assert';
+
+/**
+ * A empty function.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function noop(..._args: any[]): any {
+  // noop
+}
+
+/**
+ * Get a function parameter's names.
+ *
+ * @param {Function} func any function
+ * @param {Boolean} [cache] default is true
+ * @return {Array} names
+ */
+export function getParamNames(func: (...args: any[]) => any, cache?: boolean): string[] {
+  const type = typeof func;
+  assert.equal(type, 'function', `The "func" must be a function. Received type "${type}"`);
+
+  cache = cache !== false;
+  if (cache && '__cache_names' in func) {
+    return func.__cache_names as string[];
+  }
+  const str = func.toString();
+  const names = str.slice(str.indexOf('(') + 1, str.indexOf(')')).match(/([^\s,]+)/g) || [];
+  Reflect.set(func, '__cache_names', names);
+  return names;
+}

package/node_modules/utility/src/index.ts

@@ -0,0 +1,12 @@
+export * from './array.js';
+export * from './crypto.js';
+export * from './date.js';
+export * from './function.js';
+export * from './web.js';
+export * from './json.js';
+export * from './number.js';
+export * from './string.js';
+export * from './optimize.js';
+export * from './object.js';
+export * from './timeout.js';
+export * from './fs.js';

package/node_modules/utility/src/json.ts

@@ -0,0 +1,48 @@
+import { dirname } from 'node:path';
+import { readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { readFile, mkdir, writeFile } from 'node:fs/promises';
+
+export function strictJSONParse<T extends object = object>(content: string): T {
+  const obj = JSON.parse(content) as T;
+  if (!obj || typeof obj !== 'object') {
+    throw new Error('JSON string is not object');
+  }
+  return obj;
+}
+
+export function readJSONSync<T = any>(filepath: string): T {
+  return JSON.parse(readFileSync(filepath, 'utf8')) as T;
+}
+
+export interface JSONStringifyOptions {
+  /**
+   * A string or number that's used to insert white space (including indentation, line break characters, etc.)
+   * into the output JSON string for readability purposes.
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#space
+   */
+  space?: number | string;
+  replacer?: (this: any, key: string, value: any) => any;
+}
+
+export function writeJSONSync(filepath: string, content: string | object, options: JSONStringifyOptions = {}) {
+  options.space = options.space ?? 2;
+  if (typeof content === 'object') {
+    content = JSON.stringify(content, options.replacer, options.space) + '\n';
+  }
+  mkdirSync(dirname(filepath), { recursive: true });
+  writeFileSync(filepath, content);
+}
+
+export async function readJSON<T = any>(filepath: string): Promise<T> {
+  const content = await readFile(filepath, 'utf8');
+  return JSON.parse(content) as T;
+}
+
+export async function writeJSON(filepath: string, content: string | object, options: JSONStringifyOptions = {}) {
+  options.space = options.space ?? 2;
+  if (typeof content === 'object') {
+    content = JSON.stringify(content, options.replacer, options.space) + '\n';
+  }
+  await mkdir(dirname(filepath), { recursive: true });
+  await writeFile(filepath, content, 'utf8');
+}

package/node_modules/utility/src/number.ts

@@ -0,0 +1,63 @@
+// http://www.2ality.com/2013/10/safe-integers.html
+// http://es6.ruanyifeng.com/#docs/number
+export const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || Math.pow(2, 53) - 1;
+export const MIN_SAFE_INTEGER = -MAX_SAFE_INTEGER;
+export const MAX_SAFE_INTEGER_STR = String(MAX_SAFE_INTEGER);
+const MAX_SAFE_INTEGER_STR_LENGTH = MAX_SAFE_INTEGER_STR.length;
+
+/**
+ * Detect a number string can safe convert to Javascript Number.
+ *
+ * @param {String} s number format string, like `"123"`, `"-1000123123123123123123"`
+ */
+export function isSafeNumberString(s: string) {
+  if (s[0] === '-') {
+    s = s.substring(1);
+  }
+  if (s.length < MAX_SAFE_INTEGER_STR_LENGTH ||
+    (s.length === MAX_SAFE_INTEGER_STR_LENGTH && s <= MAX_SAFE_INTEGER_STR)) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Convert string to Number if string in safe Number scope.
+ *
+ * @param {String} s number format string.
+ * @return {Number|String} success will return Number, otherwise return the original string.
+ */
+export function toSafeNumber(s: string | number): number | string {
+  if (typeof s === 'number') {
+    return s;
+  }
+
+  return isSafeNumberString(s) ? Number(s) : s;
+}
+
+/**
+ * Produces a random integer between the inclusive `lower` and `upper` bounds.
+ *
+ * @param {Number} lower The lower bound.
+ * @param {Number} upper The upper bound.
+ * @return {Number} Returns the random number.
+ */
+export function random(lower?: number, upper?: number): number {
+  // random()
+  if (lower === undefined) {
+    return 0;
+  }
+  // random(lower) => random(0, lower)
+  if (upper === undefined) {
+    upper = lower;
+    lower = 0;
+  }
+  let temp: number;
+  // random(upper, lower)
+  if (lower > upper) {
+    temp = lower;
+    lower = upper;
+    upper = temp;
+  }
+  return Math.floor(lower + Math.random() * (upper - lower));
+}