@zk-tech/bedrock 0.0.1

package/src/math/vector.test.ts

@@ -0,0 +1,73 @@
+import { Vector } from './vector';
+
+describe('Vector', () => {
+  let vector: Vector;
+
+  beforeEach(() => {
+    // 在每个测试用例之前创建一个新的实例
+    vector = new Vector(2, 3);
+  });
+
+  it('should return the correct x value', () => {
+    expect(vector.x).toBe(2);
+  });
+
+  it('should return the correct y value', () => {
+    expect(vector.y).toBe(3);
+  });
+
+  it('should rotate the vector correctly', () => {
+    vector.rotate(Math.PI / 2);
+    expect(vector.pair()).toEqual([-3, 2]);
+  });
+
+  it('should calculate the dot product correctly', () => {
+    const otherVector = new Vector(4, 5);
+    const dotProduct = vector.dot(otherVector);
+    expect(dotProduct).toBe(23);
+  });
+
+  it('should add another vector correctly', () => {
+    const otherVector = new Vector(1, 2);
+    vector.add(otherVector);
+    expect(vector.pair()).toEqual([3, 5]);
+  });
+
+  it('should subtract another vector correctly', () => {
+    const otherVector = new Vector(1, 2);
+    vector.subtract(otherVector);
+    expect(vector.pair()).toEqual([1, 1]);
+  });
+
+  it('should multiply with another vector correctly', () => {
+    const otherVector = new Vector(2, 3);
+    vector.multiply(otherVector);
+    expect(vector.pair()).toEqual([4, 9]);
+  });
+
+  it('should divide by another vector correctly', () => {
+    const otherVector = new Vector(2, 3);
+    vector.divide(otherVector);
+    expect(vector.pair()).toEqual([1, 1]);
+  });
+
+  it('should multiply by a scalar correctly', () => {
+    vector.multiplyScalar(2);
+    expect(vector.pair()).toEqual([4, 6]);
+  });
+
+  it('should divide by a scalar correctly', () => {
+    vector.divideScalar(2);
+    expect(vector.pair()).toEqual([1, 1.5]);
+  });
+
+  it('should normalize the vector correctly', () => {
+    vector.normalize();
+    expect(vector.pair()).toEqual([0.5547001962252291, 0.8320502943378437]);
+  });
+
+  it('should calculate the length correctly', () => {
+    const length = vector.length();
+    expect(length).toBeCloseTo(3.605551275463989);
+  });
+});

package/src/math/vector.ts

@@ -0,0 +1,114 @@
+export class Vector {
+  constructor(
+    private _x: number,
+    private _y: number,
+  ) {}
+
+  get x() {
+    return this._x;
+  }
+
+  get y() {
+    return this._y;
+  }
+
+  /**
+   * 以原点为中心，渲染
+   */
+  rotate(angle: number) {
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+
+    const x = this._x;
+    const y = this._y;
+
+    this._x = x * c - y * s;
+    this._y = x * s + y * c;
+
+    return this;
+  }
+
+  /**
+   * 与另外一个向量的点积
+   */
+  dot(v: Vector) {
+    return this._x * v._x + this._y * v._y;
+  }
+
+  /**
+   * 与另外一个向量相乘
+   */
+  add(v: Vector) {
+    this._x += v._x;
+    this._y += v._y;
+    return this;
+  }
+
+  /**
+   * 与另外一个向量相减
+   */
+  subtract(v: Vector) {
+    this._x -= v._x;
+    this._y -= v._y;
+    return this;
+  }
+
+  /**
+   * 与另外一个向量相乘
+   */
+  multiply(v: Vector) {
+    this._x *= v._x;
+    this._y *= v._y;
+    return this;
+  }
+
+  /**
+   * 与另外一个向量相除
+   */
+  divide(v: Vector) {
+    this._x /= v._x;
+    this._y /= v._y;
+    return this;
+  }
+
+  /**
+   * 乘以某个系数
+   */
+  multiplyScalar(scalar: number) {
+    this._x *= scalar;
+    this._y *= scalar;
+    return this;
+  }
+
+  /**
+   * 除以某个系数
+   */
+  divideScalar(scalar: number) {
+    return this.multiplyScalar(1 / scalar);
+  }
+
+  /**
+   * 归一化
+   */
+  normalize() {
+    return this.divideScalar(this.length() || 1);
+  }
+
+  /**
+   * 模长
+   */
+  length() {
+    return Math.sqrt(this._x * this._x + this._y * this._y);
+  }
+
+  /**
+   * 克隆
+   */
+  clone() {
+    return new Vector(this._x, this._y);
+  }
+
+  pair() {
+    return [this._x, this._y];
+  }
+}

package/src/network/client.interface.ts

@@ -0,0 +1,104 @@
+import type {
+  AxiosRequestConfig,
+  AxiosResponse,
+  AxiosInstance,
+  AxiosError,
+  AxiosRequestHeaders,
+  AxiosInterceptorOptions,
+} from 'axios';
+
+export const HostNameTypeNameSpace = 'custom-host-name-type';
+
+export interface FetchOptions {
+  url: string;
+  params?: Record<string, any>;
+  method?: 'GET' | 'POST';
+  header?: Record<string, any>;
+  data?: Record<string, any>;
+  needCommonParams?: boolean;
+  needTiming?: boolean;
+}
+
+// 请求配置
+export interface NetworkRequestConfig<D = any> extends AxiosRequestConfig<D> {
+  // web扩展，只对web生效
+  [HostNameTypeNameSpace]?: string;
+}
+
+interface BaseNetworkErrorOptions<T = unknown, D = any> {
+  message?: string;
+  error?: Error;
+  code?: string;
+  config?: NetworkMiddleRequestConfig;
+  request?: any;
+  response?: NetworkResponse<T, D>;
+}
+
+interface NetworkErrorFromMessageOptions<T = unknown, D = any> extends BaseNetworkErrorOptions<T, D> {
+  message: string;
+}
+
+interface NetworkErrorFromErrorOptions<T = unknown, D = any> extends BaseNetworkErrorOptions<T, D> {
+  error: Error;
+}
+
+export type NetworkErrorOptions<T = unknown, D = any> =
+  | NetworkErrorFromMessageOptions<T, D>
+  | NetworkErrorFromErrorOptions<T, D>;
+
+// 请求结果
+export type NetworkResponse<T = any, D = any> = Omit<AxiosResponse<T, D>, 'config'> & {
+  // 覆盖config字段，增加扩展
+  // 注意：不是写错，就是NetworkMiddleRequestConfig，并非NetworkRequestConfig
+  config: NetworkMiddleRequestConfig<D>;
+};
+
+// 请求失败时，reject获取的对象
+export type NetworkError<T = unknown, D = any> = AxiosError<T, D> & {
+  // 平替isAxiosError标记，表示内部错误
+  isNetworkError: boolean;
+};
+
+// 请求经过中间件时配置
+export interface NetworkMiddleRequestConfig<D = any> extends NetworkRequestConfig<D> {
+  headers: AxiosRequestHeaders;
+}
+
+// 为了支持中间件req、res类型扩展，单独声明InterceptorManager类型
+export interface InterceptorManager<V> {
+  use(
+    onFulfilled?: ((value: V) => V | Promise<V>) | null,
+    onRejected?: ((error: any) => any) | null,
+    options?: AxiosInterceptorOptions,
+  ): number;
+  eject(id: number): void;
+  clear(): void;
+}
+
+// axios实例
+export type NetworkClientInstance = Omit<AxiosInstance, 'interceptors'> & {
+  // 支持中间件req、res类型扩展，覆盖interceptors
+  interceptors: {
+    request: InterceptorManager<NetworkMiddleRequestConfig>;
+    response: InterceptorManager<NetworkResponse>;
+  };
+
+  // 重新声明，为了参数覆盖
+  request: <T = any, R = NetworkResponse<T>, D = any>(
+    configOrUrl: NetworkRequestConfig<D> | string,
+    config?: NetworkRequestConfig<D>,
+  ) => Promise<R>;
+  get: <T = any, R = NetworkResponse<T>, D = any>(
+    url: string,
+    config?: Omit<NetworkRequestConfig<D>, 'url'>,
+  ) => Promise<R>;
+  post: <T = any, R = NetworkResponse<T>, D = any>(
+    url: string,
+    data?: D,
+    config?: Omit<NetworkRequestConfig<D>, 'url'>,
+  ) => Promise<R>;
+
+  // 重新声明可直接调用，否则会丢失该能力
+  <T = any, R = NetworkResponse<T>, D = any>(config: NetworkRequestConfig<D>): Promise<R>;
+  <T = any, R = NetworkResponse<T>, D = any>(url: string, config?: NetworkRequestConfig<D>): Promise<R>;
+};

package/src/network/client.web.ts

@@ -0,0 +1,24 @@
+import axios, { AxiosError } from 'axios';
+import type { NetworkRequestConfig, NetworkClientInstance } from '.';
+import type { NetworkErrorOptions } from './client.interface';
+
+export function createClient(config?: NetworkRequestConfig): NetworkClientInstance {
+  return axios.create(config);
+}
+
+export class NetworkError<T = unknown, D = any> extends AxiosError<T, D> {
+  constructor(opts: NetworkErrorOptions<T, D>) {
+    let message;
+
+    if (opts.message) {
+      message = opts.message;
+    } else if (opts.error) {
+      message = opts.error.message;
+    }
+    super(message, opts.code, opts.config, opts.request, opts.response);
+  }
+
+  get isNetworkError() {
+    return true;
+  }
+}

package/src/network/index.common.ts

@@ -0,0 +1,10 @@
+export { HostNameTypeNameSpace } from './client.interface';
+export type { NetworkRequestConfig } from './client.interface';
+export type { NetworkResponse } from './client.interface';
+
+export type { NetworkMiddleRequestConfig } from './client.interface';
+export type { NetworkError } from './client.interface';
+
+export type { NetworkClientInstance } from './client.interface';
+
+export { addRetryPlugin } from './plugins/retry';

package/src/network/index.ts

@@ -0,0 +1,2 @@
+export * from './index.common';
+export { createClient, NetworkError } from './client.web';

package/src/network/plugins/retry.ts

@@ -0,0 +1,98 @@
+import type {
+  NetworkClientInstance,
+  NetworkError,
+  NetworkRequestConfig,
+} from '../client.interface';
+
+export const NAME_SPACE = 'network-client-retry-plugin';
+
+type RetryConfig = {
+  lastRequestTime: number;
+  retryCount: number;
+  canRetry?: boolean;
+};
+
+type CustomNetworkConfig = NetworkRequestConfig & {
+  [NAME_SPACE]?: RetryConfig;
+};
+
+type RetryOptions = {
+  retries?: number; // default retry times
+  resetTimeout?: boolean; // if reset timeout between retries, default is true
+  isRetry?: (error: NetworkError) => boolean;
+  retryDelay?: ((count: number) => number) | number;
+};
+
+function getCurrentState(config: CustomNetworkConfig): RetryConfig {
+  const currentState = config[NAME_SPACE] || ({
+    lastRequestTime: 0,
+    retryCount: 0,
+  } satisfies RetryConfig);
+  return currentState;
+}
+
+function fixConfig(networkClient: NetworkClientInstance, config: any) {
+  // @ts-expect-error type error
+  if (networkClient.defaults.agent === config.agent) {
+    delete config.agent;
+  }
+  if (networkClient.defaults.httpAgent === config.httpAgent) {
+    delete config.httpAgent;
+  }
+  if (networkClient.defaults.httpsAgent === config.httpsAgent) {
+    delete config.httpsAgent;
+  }
+}
+
+export function addRetryPlugin(
+  networkClient: NetworkClientInstance,
+  options: RetryOptions = {},
+): NetworkClientInstance {
+  networkClient.interceptors.request.use((config) => {
+    const state = getCurrentState(config as NetworkRequestConfig);
+    state.lastRequestTime = Date.now();
+    (config as CustomNetworkConfig)[NAME_SPACE] = state;
+    return config;
+  });
+
+  networkClient.interceptors.response.use(undefined, (error) => {
+    const config = error?.config;
+    if (!config) {
+      return Promise.reject(error);
+    }
+
+    const {
+      retries = 1,
+      isRetry = () => true, // isNetworkOrIdempotentRequestError
+      retryDelay = 200,
+      resetTimeout = true,
+    } = { ...options, ...config?.[NAME_SPACE] };
+
+    const state = getCurrentState(config);
+
+    // canRetry & isRetry just need one
+    const needRetry = (isRetry(error) || state.canRetry) && state.retryCount < retries;
+    if (needRetry) {
+      state.retryCount += 1;
+      const delay = typeof retryDelay === 'number' ? retryDelay : retryDelay(state.retryCount, error);
+
+      // Axios fails merging this configuration to the default configuration because it has an issue
+      // with circular structures: https://github.com/mzabriskie/axios/issues/370
+      fixConfig(networkClient, config);
+
+      if (!resetTimeout && config.timeout && state.lastRequestTime) {
+        const lastRequestDuration = Date.now() - state.lastRequestTime;
+        // Minimum 1ms timeout (passing 0 or less to XHR means no timeout)
+        config.timeout = Math.max(config.timeout - lastRequestDuration - delay, 1);
+      }
+
+      config.transformRequest = [(data: any) => data];
+
+      return new Promise((resolve) => setTimeout(() => resolve(networkClient(config)), delay));
+    }
+
+    return Promise.reject(error);
+  });
+
+  return networkClient;
+}

package/src/objects/deep-clone.test.ts

@@ -0,0 +1,40 @@
+import { deepClone } from './deep-clone';
+
+describe('deepClone function', () => {
+  test('should return null when given null', () => {
+    expect(deepClone(null)).toBeNull();
+  });
+
+  test('should return undefined when given undefined', () => {
+    expect(deepClone(undefined)).toBeUndefined();
+  });
+
+  test('should return the same value when given a non-object primitive', () => {
+    expect(deepClone(123)).toBe(123);
+    expect(deepClone('hello')).toBe('hello');
+    expect(deepClone(true)).toBe(true);
+  });
+
+  test('should return a deep clone of the object', () => {
+    const obj = {
+      name: 'John',
+      age: 25,
+      hobbies: ['reading', 'coding'],
+      address: {
+        city: 'New York',
+        country: 'USA',
+      },
+    };
+    const clonedObj = deepClone(obj);
+
+    expect(clonedObj).toEqual(obj);
+    expect(clonedObj === obj).toBe(false); // check if it's a deep clone
+    expect(clonedObj.address === obj.address).toBe(false); // check if nested objects are also deeply cloned
+    expect(Array.isArray(clonedObj.hobbies)).toBe(true); // check if arrays are cloned
+  });
+
+  test('should return the same RegExp object when an instance of a RegExp is passed', () => {
+    const regex = /abc/;
+    expect(deepClone(regex)).toBe(regex);
+  });
+});

package/src/objects/deep-clone.ts

@@ -0,0 +1,13 @@
+export function deepClone<T>(obj: T): T {
+  if (!obj || typeof obj !== 'object') {
+    return obj;
+  }
+  if (obj instanceof RegExp) {
+    return obj;
+  }
+  const result: any = Array.isArray(obj) ? [] : {};
+  Object.entries(obj).forEach(([key, value]) => {
+    result[key] = value && typeof value === 'object' ? deepClone(value) : value;
+  });
+  return result;
+}

package/src/objects/deep-equal.test.ts

@@ -0,0 +1,86 @@
+import { deepEqual } from './deep-equal';
+
+describe('deep-equal', () => {
+  it('deep-equal', () => {
+    expect(deepEqual(null, null)).toBeTruthy();
+    expect(deepEqual(undefined, undefined)).toBeTruthy();
+    expect(deepEqual(1234, 1234)).toBeTruthy();
+    expect(deepEqual('', '')).toBeTruthy();
+    expect(deepEqual('1234', '1234')).toBeTruthy();
+    expect(deepEqual([], [])).toBeTruthy();
+    expect(
+      deepEqual(
+        [
+          [1, 2, 3],
+          [4, 5, 6],
+        ],
+        [
+          [1, 2, 3],
+          [4, 5, 6],
+        ],
+      ),
+    ).toBeTruthy();
+    expect(deepEqual({}, {})).toBeTruthy();
+    expect(deepEqual({ a: 1, b: '123' }, { a: 1, b: '123' })).toBeTruthy();
+    expect(deepEqual({ a: { b: 1, c: 2 }, b: 3 }, { a: { b: 1, c: 2 }, b: 3 })).toBeTruthy();
+
+    expect(deepEqual(null, undefined)).toBeFalsy();
+    expect(deepEqual(null, '')).toBeFalsy();
+    expect(deepEqual(null, [])).toBeFalsy();
+    expect(deepEqual(null, {})).toBeFalsy();
+    expect(deepEqual(null, 0)).toBeFalsy();
+    expect(deepEqual(undefined, '')).toBeFalsy();
+    expect(deepEqual(undefined, [])).toBeFalsy();
+    expect(deepEqual(undefined, {})).toBeFalsy();
+    expect(deepEqual(undefined, 0)).toBeFalsy();
+    expect(deepEqual('', [])).toBeFalsy();
+    expect(deepEqual('', {})).toBeFalsy();
+    expect(deepEqual('', 0)).toBeFalsy();
+    expect(deepEqual([], {})).toBeFalsy();
+    expect(deepEqual([], 0)).toBeFalsy();
+    expect(deepEqual('1234', 1234)).toBeFalsy();
+    expect(
+      deepEqual(
+        [
+          [1, 2, 3],
+          [4, 5, 6],
+        ],
+        [
+          [1, 2, 3],
+          [4, 5, 6000],
+        ],
+      ),
+    ).toBeFalsy();
+    expect(deepEqual({ a: { b: 1, c: 2 }, b: 3 }, { b: 3, a: { b: 9, c: 2 } })).toBeFalsy();
+
+    // 判断一下循环引用
+    const a1: any = {};
+    // b1存在循环引用
+    const b1 = { a: a1, b: 1 };
+    a1.b = b1;
+
+    // b2没有循环引用
+    const b2 = { a: {}, b: 1 };
+    expect(deepEqual(b1, b2)).toBeFalsy();
+    expect(deepEqual(b2, b1)).toBeFalsy();
+
+    const a3: any = {};
+    const b3 = { a: a3, b: 1 };
+    a3.b = b3;
+    expect(() => {
+      deepEqual(b3, b1);
+    }).toThrow();
+    expect(() => {
+      deepEqual(b1, b3);
+    }).toThrow();
+
+    const a4 = { a: 111 };
+    // b4出现key指向同一个地址，但是并没有成为环，不会error
+    const b4 = { a: a4, aa: a4 };
+    expect(() => {
+      deepEqual(b4, { a: { a: 111 }, aa: {} });
+    }).not.toThrow();
+    expect(deepEqual(b4, { a: { a: 111 }, aa: {} })).toBeFalsy();
+    expect(deepEqual(b4, { a: { a: 111 }, aa: { a: 111 } })).toBeTruthy();
+  });
+});

package/src/objects/deep-equal.ts

@@ -0,0 +1,60 @@
+import { lvAssert } from '../assert';
+
+function equalsInternal(lhs: any, rhs: any, seen: Set<any>): boolean {
+  if (lhs === rhs) {
+    return true;
+  }
+  if (lhs === null || lhs === undefined || rhs === null || rhs === undefined) {
+    return false;
+  }
+  if (typeof lhs !== typeof rhs) {
+    return false;
+  }
+  if (typeof lhs !== 'object') {
+    return false;
+  }
+  lvAssert(!seen.has(lhs), 'arguments object has circular.');
+  seen.add(lhs);
+  if (Array.isArray(lhs) !== Array.isArray(rhs)) {
+    return false;
+  }
+
+  if (Array.isArray(lhs)) {
+    if (lhs.length !== rhs.length) {
+      return false;
+    }
+    for (let i = 0; i < lhs.length; i++) {
+      if (!equalsInternal(lhs[i], rhs[i], seen)) {
+        return false;
+      }
+    }
+  } else {
+    const lhsKeys: string[] = Object.keys(lhs);
+    lhsKeys.sort();
+
+    const rhsKeys: string[] = Object.keys(rhs);
+    rhsKeys.sort();
+
+    if (!equalsInternal(lhsKeys, rhsKeys, seen)) {
+      return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let i = 0; i < lhsKeys.length; i++) {
+      if (!equalsInternal(lhs[lhsKeys[i]], rhs[lhsKeys[i]], seen)) {
+        return false;
+      }
+    }
+  }
+  seen.delete(lhs);
+  return true;
+}
+
+/**
+ * 提供对象的深度对比是否相等
+ *
+ * 目前支持的是js中的基础类型，如果需要支持一些高级类型，请联系基建侧同学。
+ * 注意：对象内部出现循环依赖时，会throw error
+ */
+export function deepEqual(lhs: any, rhs: any): boolean {
+  return equalsInternal(lhs, rhs, new Set());
+}

package/src/objects/index.ts

@@ -0,0 +1,4 @@
+// 两个对象深度比较
+export { deepEqual } from './deep-equal';
+// 对象深拷贝
+export { deepClone } from './deep-clone';

package/src/platform/index.ts

@@ -0,0 +1,64 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+let _isWindows = false;
+let _isMac = false;
+let _isLinux = false;
+let _isWeb = false;
+let _isIOS = false;
+let _isAndroid = false;
+let _isMobile = false;
+let _isIPad = false;
+let _isFirefox = false;
+let _isChrome = false;
+let _isSafari = false;
+let _userAgent: string | undefined;
+
+// Web environment
+if (typeof navigator === 'object') {
+  _userAgent = navigator.userAgent;
+  _isWindows = _userAgent.indexOf('Windows') >= 0;
+  _isIOS =
+    (_userAgent.indexOf('Macintosh') >= 0 ||
+      _userAgent.indexOf('iPad') >= 0 ||
+      _userAgent.indexOf('iPhone') >= 0) &&
+    Boolean(navigator.maxTouchPoints) &&
+    navigator.maxTouchPoints > 0;
+  _isAndroid = _userAgent.indexOf('Android') >= 0;
+  _isLinux = _userAgent.indexOf('Linux') >= 0;
+  _isMobile = _userAgent.indexOf('Mobi') >= 0;
+  _isIPad = _userAgent.indexOf('iPad') >= 0;
+  _isMac = !_isMobile && _userAgent.indexOf('Macintosh') >= 0;
+  _isFirefox = /firefox/i.test(_userAgent);
+  _isChrome = /chrome/i.test(_userAgent);
+  _isSafari = /^((?!chrome|android).)*safari/i.test(_userAgent);
+  _isWeb = true;
+}
+
+export const isWindows = _isWindows;
+export const isMac = _isMac;
+export const isLinux = _isLinux;
+export const isWeb = _isWeb;
+export const isIOS = _isIOS;
+export const isAndroid = _isAndroid;
+export const isIPad = _isIPad;
+export const isMobile = _isMobile;
+export const isChrome = _isChrome;
+export const isFirefox = _isFirefox;
+export const isSafari = _isSafari;
+
+/**
+ * 判断是否为 Arc 浏览器
+ * arc 浏览器判定方式比较奇特，无法通过 UA 判断
+ * https://stackoverflow.com/questions/76123232/can-javascript-detect-the-arc-browser
+ */
+export function isArcBrowser(): boolean {
+  return getComputedStyle(document.documentElement).getPropertyValue('--arc-palette-title') ? true : false;
+};
+
+/** ace2.0 不再提供这个方法  用于判断是否为浏览器环境*/
+export function isBrowser(): boolean {
+  return (
+    typeof window !== 'undefined' &&
+    typeof window.document !== 'undefined' &&
+    typeof window.document.createElement !== 'undefined'
+  );
+}