more formatters, types and validators

CHANGELOG.md

@@ -1,5 +1,11 @@
 # deverything
 
+## 0.44.0
+
+### Minor Changes
+
+- randomObject isFile and many more
+
 ## 0.43.0
 
 ### Minor Changes

README.md

@@ -18,12 +18,14 @@ Contributions always welcome!
 - `isArray()`
 - `isBoolean()`
 - `isBrowser()` to detect if you are on the browser
+- `isBuffer()`
 - `isClient()` to detect if you are ont the browser/client
 - `isEmail()` this is a relaxed check, use your own validation if you need to be strict
 - ⭐ `isEmpty()` to check for empty object, empty array, empty string, null or undefined
   - `isEmptyString()` trims the string and checks if something is left
   - `isEmptyArray()`
   - `isEmptyObject()`
+- `isFile()`
 - `isFunction()`
 - `isJsDate()` if it's a **valid** javascript's Date
   - `isFutureDate()`
@@ -98,6 +100,7 @@ Contributions always welcome!
 
 ### Formatters
 
+- `formatCamelCase()`
 - `formatNumber()` 1000 => "1,000" or "1K" or 0.112 => "11.2%"
 - `stringToUnicode()` "hello" => "\u0068\u0065\u006c\u006c\u006f"
 - `stringToCSSUnicode()` "hello" => "\000068\000065\00006c\00006c\00006f" use this for CSS
@@ -127,6 +130,7 @@ These functions are optimized for low entropy random data generation useful for
 - `randomEnumValue()` enum FRUIT { APPLE = 1, PEAR = 3 } => 3
 - `randomFile()`
 - `randomFloat()`
+- `randomObject()`
 - `randomHandle()` useful for social identifiers, or slugs
 - `randomHexColor()`
 - `randomHexValue()`
@@ -149,6 +153,7 @@ These functions are optimized for low entropy random data generation useful for
 - `randomPhoneNumber()`
 - `randomString()`
 - `randomUUID()` lightweight uuid generation, passing UUID validation
+- `randomValue()`
 - `randomWord()`
 
 ### Checks
@@ -167,20 +172,21 @@ Checks are functions that throw an error, if the validation fails
   - `MaybePromiseOrValue<>`
   - `MaybePromiseOrValueArray<>`
 - `NonUndefined`
+- `Key`
 - `ObjectKey<>`
 - `ObjectKeys<>`
 - `ObjectValue<>`
 - `ObjectValues<>`
+- `ObjectEntry<>`
 - `ObjectEntries<>`
 - ⭐ `PlainObject` use this instead of `Record<,>` or `extends object`, also makes sure it's not an array
 - `Point`
-- `PrismaSelect<>`
 - `HashMap<>`
-- `HashMapKey`
-- `NumberMap`
-- `StringMap`
-- `BoolMap`
-- `TrueMap`
+  - `BoolMap`
+  - `NumberMap`
+  - `StringMap`
+  - `TrueMap`
+- `VoidFn`
 
 ## Development
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "deverything",
-  "version": "0.43.0",
+  "version": "0.44.0",
   "description": "Everything you need for Dev",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

src/formatters/formatCamelCase.ts

@@ -0,0 +1,7 @@
+export const formatCamelCase = (str: string) => {
+  return str
+    .toLowerCase()
+    .replace(/[-_\s]([a-z\d])(\w*)/g, function replacer(_m, p1, p2) {
+      return p1.toUpperCase() + p2;
+    });
+};

src/formatters/index.ts

@@ -1,3 +1,4 @@
+export * from "./formatCamelCase";
 export * from "./formatNumber";
-export * from "./stringToUnicode";
 export * from "./stringToCSSUnicode";
+export * from "./stringToUnicode";

src/helpers/serialize.ts

@@ -1,7 +1,7 @@
 import { PlainObject } from "../types";
 
 /**
- * Serialize plain object to a deterministic string,
+ * Serialize shallow object to a deterministic string,
  * for nested objects use [json-stable-stringify](https://www.npmjs.com/package/json-stable-stringify)
  *
  * @example

src/random/randomObject.test.ts

@@ -0,0 +1,9 @@
+import { describe, it, expect } from "@jest/globals";
+import { keysLength } from "../helpers";
+import { randomObject } from "./randomObject";
+
+describe(`randomObject`, () => {
+  it(`works`, () => {
+    expect(keysLength(randomObject())).toBeGreaterThan(0);
+  });
+});

src/random/randomObject.ts

@@ -0,0 +1,19 @@
+import { array } from "../helpers";
+import { PlainObject } from "../types";
+import { randomInt } from "./randomInt";
+import { randomValue } from "./randomValue";
+import { randomNoun } from "./randomWord";
+
+export const randomObject = ({ maxDepth = 5 }: { maxDepth?: number } = {}) => {
+  const getRandomObject = (depth: number): PlainObject => {
+    if (depth >= maxDepth) return {};
+
+    const keys = array(randomInt(1, 5), randomNoun);
+    return keys.reduce((partial, key) => {
+      partial[key] = randomValue() || getRandomObject(depth + 1);
+      return partial;
+    }, {} as PlainObject);
+  };
+
+  return getRandomObject(0);
+};

src/random/randomValue.ts

@@ -0,0 +1,16 @@
+import { randomArrayItem } from "./randomArrayItem";
+import { randomBool } from "./randomBool";
+import { randomDate } from "./randomDate";
+import { randomInt } from "./randomInt";
+import { randomString } from "./randomString";
+
+export const randomValue = () => {
+  return randomArrayItem([
+    randomBool(),
+    randomString(),
+    randomInt(),
+    randomDate(),
+    undefined,
+    null,
+  ]);
+};

src/types/Function.ts

@@ -0,0 +1 @@
+export type VoidFn = () => void;

src/types/HashMap.ts

@@ -1,7 +1,8 @@
+import { Key } from "./Object";
+
 // I don't like the Dict keyword, but it's a possibility...
-export type HashMapKey = string | number | symbol;
-export type HashMap<T> = Record<HashMapKey, T>;
-export type NumberMap = Record<HashMapKey, number>;
-export type StringMap = Record<HashMapKey, string>;
-export type BoolMap = Record<HashMapKey, boolean>;
-export type TrueMap = Record<HashMapKey, true>;
+export type HashMap<T> = Record<Key, T>;
+export type NumberMap = Record<Key, number>;
+export type StringMap = Record<Key, string>;
+export type BoolMap = Record<Key, boolean>;
+export type TrueMap = Record<Key, true>;

src/types/Object.ts

@@ -1,6 +1,7 @@
+export type Key = string | number | symbol;
 export type ObjectKey<T> = keyof T;
 export type ObjectKeys<T> = ObjectKey<T>[];
 export type ObjectValue<T> = T[keyof T];
 export type ObjectValues<T> = ObjectValue<T>[];
-// ObjectEntry needed?
-export type ObjectEntries<T> = { [K in keyof T]: [K, T[K]] }[keyof T][];
+export type ObjectEntry<T> = { [K in keyof T]: [K, T[K]] }[keyof T];
+export type ObjectEntries<T> = ObjectEntry<T>[];

src/types/PlainObject.ts

@@ -1 +1,9 @@
-export type PlainObject = Record<string | symbol, any> & { length?: never }; // Excludes arrays
+import { Key } from "./Object";
+
+/**
+ * A plain object is an object that is not an array, does not have a length property, and is not a function.
+ * Would have been nice to call it just Object, but that's already taken by the built-in type.
+ */
+export type PlainObject<T = any> = Record<Key, T> & {
+  length?: never;
+}; // Excludes arrays

src/validators/index.ts

@@ -2,9 +2,11 @@ export * from "./isArray";
 export * from "./isArrayIncluded";
 export * from "./isBoolean";
 export * from "./isBrowser";
+export * from "./isBuffer";
 export * from "./isClient";
 export * from "./isEmail";
 export * from "./isEmpty";
+export * from "./isFile";
 export * from "./isFunction";
 export * from "./isFutureDate";
 export * from "./isJsDate";

src/validators/isBuffer.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, test } from "@jest/globals";
+import { isBuffer } from "./isBuffer";
+
+describe("isBuffer", () => {
+  test("mixed", async () => {
+    const buffer = Buffer.from("test");
+    expect(isBuffer(buffer)).toBe(true);
+
+    const arraybuffer = new Uint8Array([1, 2, 3]).buffer;
+    expect(isBuffer(arraybuffer)).toBe(false);
+
+    const notBuffer = { byteLength: 3, slice: () => {} };
+    expect(isBuffer(notBuffer)).toBe(false);
+  });
+});

src/validators/isBuffer.ts

@@ -0,0 +1,11 @@
+import { isFunction } from "./isFunction";
+import { isValue } from "./isValue";
+
+export const isBuffer = (val?: any): boolean => {
+  return (
+    isValue(val) &&
+    isValue(val.constructor) &&
+    isFunction(val.constructor.isBuffer) &&
+    val.constructor.isBuffer(val)
+  );
+};

src/validators/isFile.ts

@@ -0,0 +1,2 @@
+export const isFile = (arg?: any): arg is File =>
+  Object.prototype.toString.call(arg) === "[object File]";

src/validators/isKey.ts

@@ -1,6 +1,5 @@
-export const isKey = <T extends object>(
-  key: string | number | symbol,
-  obj: T
-): key is keyof T =>
+import { Key } from "../types/Object";
+
+export const isKey = <T extends object>(key: Key, obj: T): key is keyof T =>
   obj.hasOwnProperty(key) && // makes sure the prop is not in the prototype chain
   obj.propertyIsEnumerable(key); // makes sure the prop is not a getter/setter

src/validators/isObject.ts

@@ -1,2 +1,4 @@
-export const isObject = <T>(arg?: any): arg is Record<string, T> =>
+import { PlainObject } from "../types";
+
+export const isObject = <T>(arg?: any): arg is PlainObject<T> =>
   Object.prototype.toString.call(arg) === "[object Object]";