ranuts 0.1.0-alpha.1 → 0.1.0-alpha.2

package/src/colors/isColorSupported.ts

@@ -1,13 +0,0 @@
-import tty from 'node:tty'
-import process from 'node:process'
-
-const isColorSupported =
-  !('NO_COLOR' in process.env || process.argv.includes('--no-color')) &&
-  ('FORCE_COLOR' in process.env ||
-    process.argv.includes('--color') ||
-    process.platform === 'win32' ||
-    (tty.isatty(1) && process.env.TERM !== 'dumb') ||
-    'CI' in process.env)
-
-
-export default isColorSupported

package/src/file/appendFile.ts

@@ -1,29 +0,0 @@
-import fs from './fs'
-import readFile from './readFile'
-
-type Error = NodeJS.ErrnoException | null
-
-/**
- * @description: 给一个已经存在的文件追加内容
- * @param {string} path 文件路径
- * @param {string} content 新加的内容
- * @return {Promise}
- */
-
-const appendFile = (
-  path: string,
-  content: string,
-): Promise<Ranuts.Identification> =>
-  new Promise((resolve, reject) => {
-    if (!fs._identification)
-      return reject({ _identification: false, data: 'fs is not loaded' })
-    fs.appendFile(path, content, (err: Error) => {
-      err
-        ? reject({ _identification: false, data: err })
-        : readFile(path).then((result: Ranuts.Identification) => {
-            resolve(result)
-          })
-    })
-  })
-
-export default appendFile

package/src/file/fileInfo.ts

@@ -1,22 +0,0 @@
-import fs from './fs'
-
-type Error = NodeJS.ErrnoException | null
-
-/**
- * @description: 查询一个文件的详细信息，一般用于区分文件还是目录（data.isDirectory()）
- * @param {string} path 文件路径
- * @return {Promise}
- */
-
-const queryFileInfo = (path: string): Promise<Ranuts.Identification> =>
-  new Promise((resolve, reject) => {
-    if (!fs._identification)
-      return reject({ _identification: false, data: 'fs is not loaded' })
-    fs.stat(path, (err: Error, data: string) => {
-      err
-        ? reject({ _identification: false, data: err })
-        : resolve({ _identification: true, data })
-    })
-  })
-
-export default queryFileInfo

package/src/file/fs.ts

@@ -1,9 +0,0 @@
-const fs = {}
-let fileSystem: any = fs
-if (typeof process !== 'undefined' && typeof fileSystem.Stats === 'function') {
-  fileSystem._identification = true
-} else {
-  fileSystem = { _identification: false, message: 'require is not defined' }
-}
-
-export default fileSystem

package/src/file/readDir.ts

@@ -1,18 +0,0 @@
-import fs from './fs'
-
-interface Options {
-  dirPath: string
-  ignores?: Array<string>
-}
-
-const readDir = (options: Options): Array<string> => {
-  const { dirPath } = options
-  try {
-    return fs.readdirSync(dirPath)
-  } catch (error) {
-    console.log('readDir error', error)
-    throw error
-  }
-}
-
-export default readDir

package/src/file/readFile.ts

@@ -1,26 +0,0 @@
-import fs from './fs'
-
-type Error = NodeJS.ErrnoException | null
-
-/**
- * @description: 读取一个文件，读取成功返回状态码和文件内容
- * @param {string} path 文件路径
- * @param {string} format 读取格式，默认utf-8
- * @return {Promise}
- */
-
-const readFile = (
-  path: string,
-  format: string = 'utf-8',
-): Promise<Ranuts.Identification> =>
-  new Promise((resolve, reject) => {
-    if (!fs._identification)
-      return reject({ _identification: false, data: 'fs is not loaded' })
-    fs.readFile(path, format, (err: Error, data: string) => {
-      err
-        ? reject({ _identification: false, data: err })
-        : resolve({ _identification: true, data })
-    })
-  })
-
-export default readFile

package/src/file/watchFile.ts

@@ -1,31 +0,0 @@
-import type { Stats } from 'node:fs'
-import fs from './fs'
-
-/**
- * @description: 观察一个文件是否被改变，返回状态
- * @param {string} path 监听的文件路径
- * @param {number} interval 监听的时间，单位毫秒，默认20毫秒
- * @return {Promise}
- */
-
-const watchFile = (
-  path: string,
-  interval: number = 20,
-): Promise<Ranuts.Identification> =>
-  new Promise((resolve, reject) => {
-    if (!fs._identification)
-      return reject({ _identification: false, data: 'fs is not loaded' })
-    fs.watchFile(path, { interval }, (curr: Stats, prev: Stats) => {
-      if (curr.mtime !== prev.mtime) {
-        fs.unwatchFile(path)
-        resolve({ _identification: true, data: { msg: 'file is changed' } })
-      } else {
-        resolve({
-          _identification: false,
-          data: { msg: 'file is not changed' },
-        })
-      }
-    })
-  })
-
-export default watchFile

package/src/file/writeFile.ts

@@ -1,38 +0,0 @@
-import fs from './fs'
-
-type Error = NodeJS.ErrnoException | null
-
-/**
- * @description: 根据文件路径创建文件，如果文件存在会清空再写入，如果不存在会创建
- * @param {string} path 文件路径
- * @param {string} content 文件内容
- * @return {Promise}
- */
-
-const writeFile = (
-  path: string,
-  content: string,
-): Promise<Ranuts.Identification> =>
-  new Promise((resolve, reject) => {
-    if (!fs._identification)
-      return reject({ _identification: false, data: 'fs is not loaded' })
-    fs.writeFile(
-      path,
-      content,
-      {
-        mode: 438, // 可读可写666，转化为十进制就是438
-        flag: 'w+', // r+并不会清空再写入，w+会清空再写入
-        encoding: 'utf-8',
-      },
-      (err: Error) => {
-        if (err) {
-          reject({ _identification: false, data: err })
-          throw err
-        } else {
-          resolve({ _identification: true, data: { path, content } })
-        }
-      },
-    )
-  })
-
-export default writeFile

package/src/mode/subscribe.ts

@@ -1,89 +0,0 @@
-type Callback = (...args: any) => unknown
-
-type EventName = string | symbol
-
-type EventItem = {
-  name?: string | symbol
-  callback: Callback
-  initialCallback?: Callback
-}
-
-class Subscribe {
-  _events: Record<EventName, Array<EventItem>>
-  constructor() {
-    this._events = {}
-  }
-
-  on = (eventName: EventName, eventItem: EventItem | Callback): void => {
-    if (this._events[eventName] && eventName !== Symbol.for('new-listener')) {
-      // 注册一个 newListener 用于监听新的事件订阅
-      this.emit(Symbol.for('new-listener'), eventName)
-    }
-    // 由于一个事件可能注册多个回调函数，所以使用数组来存储事件队列
-    const callbacks = this._events[eventName] || []
-    if (typeof eventItem === 'function') {
-      callbacks.push({
-        name: eventName,
-        callback: eventItem,
-      })
-    } else {
-      callbacks.push(eventItem)
-    }
-    this._events[eventName] = callbacks
-  }
-
-  emit = (eventName: EventName, ...args: Array<unknown>): void => {
-    const callbacks = this._events[eventName] || []
-    callbacks.forEach((item) => {
-      const { callback } = item
-      callback(...args)
-    })
-  }
-
-  once = (eventName: EventName, eventItem: EventItem | Callback): void => {
-    let one: EventItem
-    if (typeof eventItem === 'function') {
-      one = {
-        name: eventName,
-        callback: (...args: Array<unknown>) => {
-          eventItem(...args)
-          this.off(eventName, one)
-        },
-        initialCallback: eventItem,
-      }
-    } else {
-      const { callback } = eventItem
-      one = {
-        name: eventName,
-        callback: (...args: Array<unknown>) => {
-          callback(...args)
-          this.off(eventName, one)
-        },
-        initialCallback: callback,
-      }
-    }
-    // 由于需要在回调函数执行后，取消订阅当前事件，所以需要对传入的回调函数做一层包装,然后绑定包装后的函数
-
-    // 考虑：如果当前事件在未执行，被用户取消订阅，能否取消？
-    // 由于：我们订阅事件的时候，修改了原回调函数的引用，所以，用户触发 off 的时候不能找到对应的回调函数
-    // 所以，我们需要在当前函数与用户传入的回调函数做一个绑定，我们通过自定义属性来实现
-    this.on(eventName, one)
-  }
-
-  off = (eventName: EventName, eventItem: EventItem | Callback): void => {
-    // 找到事件对应的回调函数，删除对应的回调函数
-    const callbacks = this._events[eventName] || []
-    const newCallbacks = callbacks.filter((item) => {
-      if (typeof eventItem === 'function') {
-        return item.callback !== eventItem && item.initialCallback !== eventItem
-      } else {
-        const { callback } = eventItem
-        /* 用于once的取消订阅 */
-        return item.callback !== callback && item.initialCallback !== callback
-      }
-    })
-    this._events[eventName] = newCallbacks
-  }
-}
-
-export default Subscribe

package/src/ranlog/behavior.ts

@@ -1,5 +0,0 @@
-import { Noop } from './utils'
-
-export const handleClick = (hooks:(event: MouseEvent) => void = Noop): void => {
-    document.addEventListener('click', function (event) { hooks(event) }, true);
-}

package/src/ranlog/console.ts

@@ -1,16 +0,0 @@
-import { Noop, replaceOld } from './utils'
-
-export const consoleHooks = (hooks: (...args: unknown[]) => void = Noop): void => {
-    const consoleTypeList = ['log', 'info', 'warn', 'error', 'assert'];
-    consoleTypeList.forEach((type: string) => {
-        const replacement = (originalConsole: any) => {
-            return function (...args: any[]): void {
-                if (originalConsole) {
-                    hooks(type, ...args)
-                    originalConsole.apply(console, args)
-                }
-            };
-        }
-        replaceOld(console, type, replacement)
-    });
-}

package/src/ranlog/env.ts

@@ -1,29 +0,0 @@
-
-import { isString } from './utils'
-/**
- * @description: Gets the current environment configuration
- * @return {string}
- */
-export const getHost = (env?: string): string => {
-    let host = ''
-    if (env && isString(env)) {
-        if (/trunk|neibu|release/.test(env)) {
-            host = `.${env}`
-        } else if (/test/.test(env)) {
-            host = env
-        } else if (/prod/.test(env)) {
-            host = ''
-        } else {
-            host = ''
-        }
-
-    } else {
-        const env = /\w(\.trunk|\.neibu|\.release|test)\./.exec(
-            window.location.hostname
-        );
-        if (env) {
-            host = env[1]
-        }
-    }
-    return host ? `https://log${host}.chaxus.com` : "https://log.chaxus.com";
-}

package/src/ranlog/error.ts

@@ -1,11 +0,0 @@
-import { Noop } from './utils'
-import type { Hooks } from './utils'
-
-export const handleError = (hooks: Hooks = Noop): void => {
-    window.addEventListener('unhandledrejection', (error) => {hooks(error)}, true);
-    window.addEventListener('error', (error) => {
-        hooks(error)
-        return false // 取消默认事件
-    }, true) // 捕获阶段
-}
-

package/src/ranlog/performance.ts

@@ -1,65 +0,0 @@
-
-interface BasicType {
-    [x:string]: number | undefined
-    dnsSearch: number; // DNS 解析耗时
-    tcpConnect: number; // TCP 连接耗时
-    sslConnect: number; // SSL安全连接耗时
-    request: number; // TTFB 网络请求耗时
-    response: number; // 数据传输耗时
-    parseDomTree: number; // DOM 解析耗时
-    resource: number; // 资源加载耗时
-    domReady: number; // DOM Ready
-    httpHead: number; // http 头部大小
-    interactive: number; // 首次可交互时间
-    complete: number; // 页面完全加载
-    redirect: number; // 重定向次数
-    redirectTime: number; // 重定向耗时
-    duration: number; // 资源请求的总耗时 responseEnd-startTime
-    fp: number | undefined; // 渲染出第一个像素点，白屏时间
-    fcp: number | undefined; // 渲染出第一个内容，首屏结束时间
-}
-
-export function getPerformance(): BasicType {
-    const [performanceNavigationTiming] = performance.getEntriesByType('navigation')
-    const [firstPaint, firstContentfulPaint] = performance.getEntriesByType('paint')
-    const {
-        domainLookupEnd,
-        domainLookupStart,
-        connectEnd,
-        connectStart,
-        secureConnectionStart,
-        loadEventStart,
-        domInteractive,
-        domContentLoadedEventEnd,
-        duration,
-        responseStart,
-        requestStart,
-        responseEnd,
-        fetchStart,
-        transferSize,
-        encodedBodySize,
-        redirectEnd,
-        redirectStart,
-        redirectCount
-    } = performanceNavigationTiming as PerformanceNavigationTiming;
-    const { startTime: fp } = firstPaint;
-    const { startTime: fcp } = firstContentfulPaint;
-    return {
-        dnsSearch: domainLookupEnd - domainLookupStart,
-        tcpConnect: connectEnd - connectStart,
-        sslConnect: connectEnd - secureConnectionStart,
-        request: responseStart - requestStart,
-        response: responseEnd - responseStart,
-        parseDomTree: domInteractive - responseEnd,
-        resource: loadEventStart - domContentLoadedEventEnd,
-        domReady: domContentLoadedEventEnd - fetchStart,
-        interactive: domInteractive - fetchStart,
-        complete: loadEventStart - fetchStart,
-        httpHead: transferSize - encodedBodySize,
-        redirect: redirectCount,
-        redirectTime: redirectEnd - redirectStart,
-        duration: duration,
-        fp: fp,
-        fcp: fcp,
-    };
-}

package/src/ranlog/report.ts

@@ -1,33 +0,0 @@
-import { querystring } from './utils'
-import { getHost } from './env'
-
-interface BeaconPayload {
-    url?: string,
-    type?: string,
-    payload: Record<string, unknown>
-}
-
-
-const sendBeacon = ({ url = '', type = 'application/json; charset=UTF-8', payload = {} }: BeaconPayload) => {
-    const requestUrl = url ? url : getHost()
-    if (navigator.sendBeacon) {  // 判断sendBeacon是否支持可用
-        const param = new Blob([JSON.stringify(payload)], { type });
-        return navigator.sendBeacon(requestUrl, param)
-    }
-}
-
-const sendImage = ({ url = "", payload = {} }) => {
-    const requestUrl = url ? url : getHost()
-    const image = new Image();
-    image.width = 1;
-    image.height = 1;
-    image.src = `${requestUrl}?${querystring(payload)}`
-}
-
-export const report = ({ url = '', type = 'application/json; charset=UTF-8', payload = {} }: BeaconPayload): boolean | undefined | void => {
-    const requestUrl = url ? url : getHost()
-    if (typeof navigator.sendBeacon !== 'undefined') {  // 判断sendBeacon是否支持可用
-        return sendBeacon({ url: requestUrl, type, payload })
-    }
-    return sendImage({ url: requestUrl, payload })
-}

package/src/ranlog/request.ts

@@ -1,60 +0,0 @@
-import { Noop, replaceOld } from './utils'
-import type { Hooks } from './utils'
-
-interface Options {
-    requestHook: Hooks,
-    responseHook: Hooks,
-    errorHook: Hooks
-}
-/**
- * @description: fetch
- * @param {Partial} options
- */
-export const handleFetchHook = (options: Partial<Options> = {}): void => {
-    if (typeof window !== 'undefined') {
-        const { requestHook = Noop, responseHook = Noop, errorHook = Noop } = options
-        const replacement = (originalFetch: any) => {
-            return (url: string, config?: any) => {
-                requestHook(url, config)
-                return originalFetch.apply(window, [url, config])
-                    .then((response: Response) => {
-                        responseHook(url, config, response)
-                        return response
-                    })
-                    .catch((error: Error) => {
-                        errorHook(url, error)
-                        throw error;
-                    })
-            }
-        }
-        replaceOld(window, 'fetch', replacement)
-    }
-}
-/**
- * @description: xhr
- * @param {Partial} options
- * @return {*}
- */
-export const handleXhrHook = (options: Partial<Options> = {}): void => {
-    const originalXhrProto = XMLHttpRequest.prototype;
-    const { requestHook = Noop, responseHook = Noop, errorHook = Noop } = options
-    const replacementXhrOpen = (originalOpen: any) => {
-        return function (this: XMLHttpRequest, ...args: unknown[]): void {
-            requestHook(args)
-            originalOpen.apply(this, args);
-        };
-    }
-    replaceOld(originalXhrProto, 'open', replacementXhrOpen);
-    const replacementXhrSend = (originalSend: any) => {
-        return function (this: any, ...args: any[]): void {
-            this.addEventListener('loadend', function (this: unknown) {
-                responseHook(this)
-            });
-            this.addEventListener('error', function (this: unknown) {
-                errorHook(this)
-            });
-            originalSend.apply(this, args);
-        };
-    }
-    replaceOld(originalXhrProto, 'send', replacementXhrSend);
-}

package/src/ranlog/utils.ts

@@ -1,92 +0,0 @@
-
-export function querystring(data = {}): string {
-    if (typeof data !== "object") {
-        throw new TypeError("param must be object");
-    }
-    return Object.entries(data).reduce((searchParams, [name, value]) => value === undefined || value == null ? searchParams : (searchParams.append(decodeURIComponent(name), decodeURIComponent(value)), searchParams), new URLSearchParams()).toString();
-}
-
-export function randomString(len: number = 8): string {
-    const chars = 'ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678';
-    const maxPos = chars.length;
-    let pwd = '';
-    for (let i = 0; i < len; i++) {
-        pwd += chars.charAt(Math.floor(Math.random() * maxPos))
-    }
-    return `${Date.now()}-${pwd}`;
-}
-
-export function getCookie(name: string): string {
-    const cookieList = window.document.cookie.match(
-        new RegExp(`(^| )${name}(?:=([^;]*))?(;|$)`)
-    );
-    if (cookieList && cookieList[2]) return cookieList[2];
-    return "";
-}
-
-export function createData(params: Record<string, unknown> = {}): Record<string, unknown> {
-    return Object.assign({}, {
-        id: randomString(),
-        path: window.location.href,
-        time: Date.now(),
-        userAgent: window.navigator.userAgent,
-        referrer: document.referrer,
-        ip: window.returnCitySN || { cid: "", cip: "", cname: "" },
-        userId: getCookie('chaxus_prod')
-    }, params)
-}
-
-export const throttle = (fn: Function, wait: number = 300): Function => {
-    let timer: NodeJS.Timeout | null = null;
-    return function (this: unknown, ...args: unknown[]) {
-        const context = this;
-        if (!timer) {
-            timer = setTimeout(() => {
-                timer = null;
-                fn.apply(context, args);
-            }, wait);
-        }
-    };
-};
-
-export const Noop = ():void => {}
-
-export function changeHumpToLowerCase(str: string): string {  // str ====> fullName
-    const arr = str.split("");     // 将字符串用split拆为单个字母为元素的数组，fullName ====> ["f", "u", "l", "l", "N", "a", "m", "e"]
-    const lowerCase = arr.map(val => {
-        if (val.toUpperCase() === val) {     // 由此判断出，当前字符为大写字母
-            return "_" + val.toLowerCase();   // 在大写字母前面加上下划线，并将该大写字母转为小写字母
-        } else {
-            return val;
-        }
-    });
-    // 此时lowerCase =====>  ["f", "u", "l", "l", "_n", "a", "m", "e"]
-    str = lowerCase.join(""); // 将数组元素连接起来，不用分隔符，这里必须用"" ,若省略的话，join方法会默认用逗号连接
-    return str; // 此时，str ====> full_name
-}
-
-/**
- * 重写对象上面的某个属性
- *
- * @export
- * @param {IAnyObject} source 需要被重写的对象
- * @param {string} name 需要被重写对象的key
- * @param {(...args: any[]) => any} replacement 以原有的函数作为参数，执行并重写原有函数
- * @param {boolean} isForced 是否强制重写（可能原先没有该属性）
- */
-export function replaceOld(source: any, name: string, replacement: (...args: unknown[]) => unknown, isForced?: boolean): void {
-    if (typeof source === "undefined") return;
-    if (name in source || isForced) {
-        const original = source[name];
-        const wrapped = replacement(original);
-        if (typeof wrapped === 'function') {
-            source[name] = wrapped;
-        }
-    }
-}
-
-export const isString = (obj: unknown): boolean => {
-    return toString.call(obj) === '[object String]';
-}
-
-export type Hooks = (...args: unknown[]) => void