feat: add utils

Author: Ohh-889

packages/ui/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './typed';

packages/ui/src/utils/typed.ts

@@ -0,0 +1,98 @@
+export const isSymbol = (value: any): value is symbol => {
+  return Boolean(value) && value.constructor === Symbol;
+};
+
+export const isArray = Array.isArray;
+
+export const isObject = (value: any): value is object => {
+  return Boolean(value) && value.constructor === Object;
+};
+
+/**
+ * Checks if the given value is primitive.
+ *
+ * Primitive Types: number , string , boolean , symbol, bigint, undefined, null
+ *
+ * @param {*} value value to check
+ * @returns {boolean} result
+ */
+export const isPrimitive = (value: any): boolean => {
+  return value === undefined || value === null || (typeof value !== 'object' && typeof value !== 'function');
+};
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+export const isFunction = (value: any): value is Function => {
+  return Boolean(value && value.constructor && value.call && value.apply);
+};
+
+export const isString = (value: any): value is string => {
+  return typeof value === 'string' || value instanceof String;
+};
+
+export const isNumber = (value: any): value is number => {
+  try {
+    return Number(value) === value;
+  } catch {
+    return false;
+  }
+};
+
+export const isInt = (value: any): value is number => {
+  return isNumber(value) && value % 1 === 0;
+};
+
+export const isFloat = (value: any): value is number => {
+  return isNumber(value) && value % 1 !== 0;
+};
+
+export const isDate = (value: any): value is Date => {
+  return Object.prototype.toString.call(value) === '[object Date]';
+};
+
+/**
+ * This is really a _best guess_ promise checking. You
+ * should probably use Promise.resolve(value) to be 100%
+ * sure you're handling it correctly.
+ */
+export const isPromise = (value: any): value is Promise<any> => {
+  if (!value) return false;
+  if (!value.then) return false;
+  if (!isFunction(value.then)) return false;
+  return true;
+};
+
+export const isEmpty = (value: any) => {
+  if (value === true || value === false) return true;
+  if (value === null || value === undefined) return true;
+  if (isNumber(value)) return value === 0;
+  if (isDate(value)) return Number.isNaN(value.getTime());
+  if (isFunction(value)) return false;
+  if (isSymbol(value)) return false;
+  const length = (value as any).length;
+  if (isNumber(length)) return length === 0;
+  const size = (value as any).size;
+  if (isNumber(size)) return size === 0;
+  const keys = Object.keys(value).length;
+  return keys === 0;
+};
+
+export const isEqual = <TType>(x: TType, y: TType): boolean => {
+  if (Object.is(x, y)) return true;
+  if (x instanceof Date && y instanceof Date) {
+    return x.getTime() === y.getTime();
+  }
+  if (x instanceof RegExp && y instanceof RegExp) {
+    return x.toString() === y.toString();
+  }
+  if (typeof x !== 'object' || x === null || typeof y !== 'object' || y === null) {
+    return false;
+  }
+  const keysX = Reflect.ownKeys(x as unknown as object) as (keyof typeof x)[];
+  const keysY = Reflect.ownKeys(y as unknown as object);
+  if (keysX.length !== keysY.length) return false;
+  for (let i = 0; i < keysX.length; i += 1) {
+    if (!Reflect.has(y as unknown as object, keysX[i])) return false;
+    if (!isEqual(x[keysX[i]], y[keysX[i]])) return false;
+  }
+  return true;
+};