@hichchi/utils 0.0.1-alpha.0

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@hichchi/utils",
+  "version": "0.0.1-alpha.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hichchidev/hichchi.git"
+  },
+  "keywords": [],
+  "author": "Waruna Udayanga",
+  "license": "MIT",
+  "main": "./src/index.ts",
+  "typings": "./src/index.d.ts",
+  "sideEffects": false,
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "types": "./src/index.d.ts",
+  "type": "commonjs"
+}

package/readme-top.md

@@ -0,0 +1,11 @@
+# utils
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build utils` to build the library.
+
+## Running unit tests
+
+Run `nx test utils` to execute the unit tests via [Jest](https://jestjs.io).

package/src/index.d.ts

@@ -0,0 +1 @@
+export * from "./lib/utils";

package/src/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./lib/utils"), exports);
+//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/utils/src/index.ts"],"names":[],"mappings":";;;AAAA,sDAA4B"}

package/src/lib/assertions.utils.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Check if the value is an array while asserting it's an array of generic type T
+ * @template T The type of the array
+ * @param {T | T[] | undefined} value The value to check
+ * @returns {value is T[]} True if the value is an array, false otherwise
+ *
+ * @example
+ * ```TypeScript
+ * async function createUser(userOrUsers: UserDto | UserDto[] | undefined): User {
+ *     if (isArray<UserDto>(userOrUsers)) {
+ *         return userOrUsers.map(async user => await userService.createUser(user));
+ *     } else {
+ *         return await userService.createUser(userOrUsers);
+ *     }
+ * }
+ * ```
+ */
+export declare function isArray<T>(value: T | T[] | undefined): value is T[];
+/**
+ * Check if the value is an object while asserting it's an object of generic type T
+ * @template T The type of the object
+ * @param {T | T[] | undefined} [value] The value to check
+ * @returns {value is T} True if the value is an object, false otherwise
+ *
+ * @example
+ * ```TypeScript
+ * async function getUserInfo(userIdOrUser: EntityId | User | undefined): UserInfo {
+ *     if (isObject<User>(userIdOrUser)) {
+ *         return await userService.getUserInfo(userIdOrUser.id);
+ *     } else {
+ *         return await userService.getUserInfo(userIdOrUser);
+ *     }
+ * }
+ * ```
+ */
+export declare function isObject<T>(value?: T | T[] | undefined): value is T;
+/**
+ * Check if the value is an object with a given property name and asset it's an object of generic type T
+ * @template T The type of the object
+ * @param {any} value The value to check
+ * @param {keyof T} propertyName The property name to check
+ * @returns {value is T} True if the value is an object with the given property name, false otherwise
+ *
+ * @example
+ * ```TypeScript
+ * async function getUserInfo(userIdOrUser: EntityId | User | undefined): UserInfo {
+ *     if (isObjectWith<User>(userIdOrUser, "id")) {
+ *         return await userService.getUserInfo(userIdOrUser.id);
+ *     } else {
+ *         return await userService.getUserInfo(userIdOrUser);
+ *     }
+ * }
+ * ```
+ */
+export declare function isObjectWith<T extends object>(value: unknown, propertyName: keyof T): value is T;

package/src/lib/assertions.utils.js

@@ -0,0 +1,68 @@
+"use strict";
+// noinspection JSUnusedGlobalSymbols
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isArray = isArray;
+exports.isObject = isObject;
+exports.isObjectWith = isObjectWith;
+/**
+ * Check if the value is an array while asserting it's an array of generic type T
+ * @template T The type of the array
+ * @param {T | T[] | undefined} value The value to check
+ * @returns {value is T[]} True if the value is an array, false otherwise
+ *
+ * @example
+ * ```TypeScript
+ * async function createUser(userOrUsers: UserDto | UserDto[] | undefined): User {
+ *     if (isArray<UserDto>(userOrUsers)) {
+ *         return userOrUsers.map(async user => await userService.createUser(user));
+ *     } else {
+ *         return await userService.createUser(userOrUsers);
+ *     }
+ * }
+ * ```
+ */
+function isArray(value) {
+    return Array.isArray(value);
+}
+/**
+ * Check if the value is an object while asserting it's an object of generic type T
+ * @template T The type of the object
+ * @param {T | T[] | undefined} [value] The value to check
+ * @returns {value is T} True if the value is an object, false otherwise
+ *
+ * @example
+ * ```TypeScript
+ * async function getUserInfo(userIdOrUser: EntityId | User | undefined): UserInfo {
+ *     if (isObject<User>(userIdOrUser)) {
+ *         return await userService.getUserInfo(userIdOrUser.id);
+ *     } else {
+ *         return await userService.getUserInfo(userIdOrUser);
+ *     }
+ * }
+ * ```
+ */
+function isObject(value) {
+    return !Array.isArray(value) && typeof value === "object" && value !== null;
+}
+/**
+ * Check if the value is an object with a given property name and asset it's an object of generic type T
+ * @template T The type of the object
+ * @param {any} value The value to check
+ * @param {keyof T} propertyName The property name to check
+ * @returns {value is T} True if the value is an object with the given property name, false otherwise
+ *
+ * @example
+ * ```TypeScript
+ * async function getUserInfo(userIdOrUser: EntityId | User | undefined): UserInfo {
+ *     if (isObjectWith<User>(userIdOrUser, "id")) {
+ *         return await userService.getUserInfo(userIdOrUser.id);
+ *     } else {
+ *         return await userService.getUserInfo(userIdOrUser);
+ *     }
+ * }
+ * ```
+ */
+function isObjectWith(value, propertyName) {
+    return Object.prototype.hasOwnProperty.call(value, propertyName);
+}
+//# sourceMappingURL=assertions.utils.js.map

package/src/lib/assertions.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertions.utils.js","sourceRoot":"","sources":["../../../../../libs/utils/src/lib/assertions.utils.ts"],"names":[],"mappings":";AAAA,qCAAqC;;AAmBrC,0BAEC;AAmBD,4BAEC;AAoBD,oCAEC;AA9DD;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,OAAO,CAAI,KAA0B;IACjD,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAChC,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,QAAQ,CAAI,KAA2B;IACnD,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC;AAChF,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,YAAY,CAAmB,KAAc,EAAE,YAAqB;IAChF,OAAO,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;AACrE,CAAC"}

package/src/lib/file.utils.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Map of mime types to all file extensions.
+ */
+export declare const mimeTypes: Map<string, string>;
+/**
+ * Get the file extension of the given mime type.
+ * @param mimeType - Mime type.
+ * @param allowedMimeTypes - Allowed mime types.
+ * @returns File extension.
+ */
+export declare const getFileExt: (mimeType: string, allowedMimeTypes?: Map<string, string>) => string | undefined;
+/**
+ * Get file size in human-readable format.
+ * @param size - File size in bytes.
+ * @param round - Whether to round the size.
+ * @returns File size in human-readable format.
+ */
+export declare const getFileSize: (size: number, round?: boolean) => string;
+/**
+ * Save a StreamableBlob as a file.
+ * @param blob - Blob to save.
+ * @param filename - File name.
+ * @throws {Error} - Throws an error if used in a Node.js environment.
+ */
+export declare const saveAsFile: (blob: Blob, filename: string) => void;