annil 1.16.0 → 1.18.0

package/src/utils/_utils.ts

@@ -1,8 +0,0 @@
-import { debounce } from "./debounce";
-import { deepClone } from "./deepClone";
-import { deepEqual } from "./deepEqual";
-import { isEmptyObject } from "./isEmptyObject";
-import { nonNullable } from "./nonNullable";
-import { throttle } from "./throttle";
-import { typeEqual } from "./typeEqual";
-export { debounce, deepClone, deepEqual, isEmptyObject, nonNullable, throttle, typeEqual };

package/src/utils/applyDebounceAndThrottle.ts

@@ -1,31 +0,0 @@
-import type { Func } from "hry-types/src/Misc/Func";
-import { debounce } from "./debounce";
-import { throttle } from "./throttle";
-
-/**
- * 对象中的函数应用防抖和节流
- * 规则 函数字段已下划线开始的后缀 如 xxx_debounced500 或 sub_xxx_throttled,无效后缀如 _debouncedxxx 不会被处理
- * @param obj
- */
-export function applyDebounceAndThrottle(obj: Record<string, Func>) {
-  for (const [key, value] of Object.entries(obj)) {
-    if (!key.includes("_")) continue;
-    const suffix = key.split("_").at(-1) as string;
-
-    const remaining = suffix.slice(9);
-    const delay = remaining === "" ? 300 : Number(remaining);
-
-    if (suffix.startsWith("debounced")) {
-      if (!isNaN(delay)) {
-        obj[key] = debounce(value, delay);
-      }
-      continue;
-    }
-
-    if (suffix.startsWith("throttled")) {
-      if (!isNaN(delay)) {
-        obj[key] = throttle(value, delay);
-      }
-    }
-  }
-}

package/src/utils/debounce.ts

@@ -1,22 +0,0 @@
-/**
- * 防抖函数
- * 例如 在input框输入内容时,只有输入停止一段时间(wait)后,才会触发输入事件.
- * @param func
- * @param wait
- * @returns
- */
-/* istanbul ignore next  */
-export function debounce<TArgs extends unknown[]>(
-  func: (...args: TArgs) => unknown,
-  wait = 300,
-): (...args: TArgs) => void {
-  let timeoutId: ReturnType<typeof setTimeout> | null = null;
-
-  return function(this: unknown, ...args: TArgs): void {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
-
-    timeoutId = setTimeout(() => func.call(this, ...args), wait);
-  };
-}

package/src/utils/deepClone.ts

@@ -1,20 +0,0 @@
-/**
- * 数组和普通对象的深度克隆,原型相同
- */
-export function deepClone<T>(value: T): T {
-  if (typeof value !== "object" || value === null) {
-    return value;
-  }
-
-  const clone = (Array.isArray(value) ? [] : {}) as T;
-
-  Object.setPrototypeOf(clone, Object.getPrototypeOf(value));
-
-  for (const key in value) {
-    if (Object.prototype.hasOwnProperty.call(value, key)) {
-      clone[key] = deepClone(value[key]);
-    }
-  }
-
-  return clone;
-}

package/src/utils/deepEqual.ts

@@ -1,32 +0,0 @@
-type PlainObject = Record<string, unknown>;
-// 非null的对象类型
-function isNonNullObject(value: unknown): value is PlainObject {
-  return value !== null && typeof value === "object";
-}
-
-export function deepEqual(value1: unknown, value2: unknown): boolean {
-  // 两个非对象类型相等或同引用对象的情况。
-  if (Object.is(value1, value2)) {
-    return true;
-  }
-  // 有一个不是非空对象,返回false。
-  if (!isNonNullObject(value1) || !isNonNullObject(value2)) {
-    return false;
-  }
-  // 到此两个值都是对象类型。
-  const value1Keys = Object.keys(value1);
-  // 使用Set提高查找效率。
-  const value2KeysSet = new Set(Object.keys(value2));
-
-  if (value1Keys.length !== value2KeysSet.size) {
-    return false;
-  }
-
-  for (const key of value1Keys) {
-    if (!value2KeysSet.has(key) || !deepEqual(value1[key], value2[key])) {
-      return false;
-    }
-  }
-
-  return true;
-}

package/src/utils/isEmptyObject.ts

@@ -1,14 +0,0 @@
-/**
- * 判断一个值是否为空的普通对象 `{}`
- * 有symblo和非枚举属性的对象会返回 `false`
- */
-export function isEmptyObject(value: unknown): boolean {
-  if (
-    typeof value !== "object" || value === null || Array.isArray(value) || value instanceof Set || value instanceof Map
-    || value instanceof WeakSet || value instanceof WeakMap
-  ) {
-    return false;
-  }
-
-  return Reflect.ownKeys(value).length === 0;
-}

package/src/utils/nonNullable.ts

@@ -1,20 +0,0 @@
-import type { IfContains } from "hry-types/src/Any/IfContains";
-
-/**
- * 使用此函数代替!断言
- * 支持可选的第二个参数作为错误消息
- * @param value 类型中必须包含 null 或 undefined
- * @param message 可选，抛出错误时的消息
- * @returns 去除 null 和 undefined 后的类型
- */
-export function nonNullable<T>(
-  value: IfContains<T, null | undefined, T, "参数类型必须包含 null 或 undefined">,
-  message?: string,
-): NonNullable<T> {
-  /* istanbul ignore next  */
-  if (value === null || value === undefined) {
-    throw new Error(message ?? `${value} should not be null or undefined`);
-  }
-
-  return value as NonNullable<T>;
-}

package/src/utils/throttle.ts

@@ -1,24 +0,0 @@
-/**
- *  节流函数
- *  规定时间内只触发第一次 例如点击按钮
- * @param callback 回调函数
- * @param interval 单位毫秒
- * @returns
- */
-/* istanbul ignore next  */
-export function throttle<TArgs extends unknown[]>(
-  callback: (...args: TArgs) => unknown,
-  interval = 200,
-): (...args: TArgs) => void {
-  let lastCall = 0;
-
-  return function(this: unknown, ...args: TArgs) {
-    const now = Date.now();
-
-    if (now - lastCall >= interval) {
-      lastCall = now;
-
-      callback.call(this, ...args);
-    }
-  };
-}

package/src/utils/typeEqual.ts

@@ -1,30 +0,0 @@
-import type { Equals } from "hry-types/src/Any/Equals";
-/**
- * 类型相等验证
- * @example
- * ```ts
- * const a = 1;
- * type A = typeof a;
- * const b = 2;
- * type B = typeof b;
- * type C = 1;
- * typeEqual<A, C>(); // 不报错
- * typeEqual<A>()(a); // 不报错
- * typeEqual<A, B>(); // B位置报错 - 类型“2”不满足约束“never”
- * typeEqual<A>()(b); // b位置报错 - 类型“2”的参数不能赋给类型“never”的参数。
- * ```
- */
-export function typeEqual<
-  const A,
->(): <B>(b: B & (Equals<A, B> extends true ? unknown : never)) => void;
-export function typeEqual<
-  const A,
-  const B extends Equals<A, B> extends true ? unknown : never,
->(): () => void;
-
-export function typeEqual<
-  const A,
-  const B extends Equals<A, B> extends true ? unknown : never = never,
->(): (b?: B) => void {
-  return () => void 0;
-}

package/src/utils/typeNotEqual.ts

@@ -1,48 +0,0 @@
-import type { Equals } from "hry-types/src/Any/Equals";
-export type InqualityCall<A> = <const B>(b: B, ...nullable: Equals<A, B> extends false ? [] : [never]) => void;
-
-/**
- * 类型和变量不等验证
- * @example
- * ```ts
- * const a = { a: 1 } as const;
- * type B = { a: number };
- * typeNotEqual<B>()(a); 不报错
- * ```
- */
-export function typeNotEqual<
-  const A,
->(): InqualityCall<A>;
-
-/**
- * 二个类型不等验证
- * @example
- * ```ts
- * const a = 1;
- * type A = typeof a;
- * const b = 2;
- * type B = typeof b;
- * typeNotEqual<A, B>(); 不报错
- */
-export function typeNotEqual<
-  const A,
-  const B extends Equals<A, B> extends false ? unknown : never = never,
->(): void;
-/**
- * 类型不等验证
- * @example
- * ```ts
- * const a = 1;
- * type A = typeof a;
- * const b = 2;
- * type B = typeof b;
- * typeNotEqual<A, B>(); // 不报错
- * typeNotEqual<A>()(b); // 不报错
- * typeNotEqual<A>()(a); // 报错
- * ```
- */
-export function typeNotEqual<
-  const A,
->(): void | InqualityCall<A> {
-  void 0;
-}

package/tsconfig.json

@@ -1,24 +0,0 @@
-{
-  "compilerOptions": {
-    "lib": ["ES2022", "DOM"], // jest中用到了DOM类型
-    "target": "ES2017",
-    "module": "es2022",
-    "moduleResolution": "bundler",
-    "skipLibCheck": true, // 跳过声明文件的类型检查(.d.ts),你引用的依然会检查, 默认false(不跳过)。
-    "esModuleInterop": true, // 默认false. 兼容非ES模块引用的写法(如 import fs from 'fs').
-    "allowSyntheticDefaultImports": true, // 默认false. 允许从没有设置默认导出的模块中默认导入。
-    "verbatimModuleSyntax": true, // 保留原始import/export语法, 与ESM写法一致。
-    "strict": true,
-    "noEmit": true, // 不生成输出文件。
-    // "resolveJsonModule": true, // 允许导入json模块。
-    // "experimentalDecorators": true, // 启用装饰器,如@observable 小程序当前还不支持
-    "strictFunctionTypes": false, // e: Dataset<{ id: string }>会报错。
-    "forceConsistentCasingInFileNames": true,
-    "exactOptionalPropertyTypes": true, // 带有?标志的属性类型不在包含undefined类型
-    "noImplicitReturns": true, // 当启用时,TypeScript会检查函数中的所有代码路径，以确保它们返回值
-    "isolatedModules": true, // 模块化(.ts文件必须有导入或导出) 默认false
-    "types": ["hry-types", "mobx", "jest", "miniprogram-api-typings", "node"]
-  },
-  "include": ["src/**/*.ts", "jest/**/*.ts"],
-  "exclude": ["node_modules", "dist", "docs"]
-}