@nativerent/js-utils 1.0.1 → 1.0.2

package/jest.config.mjs

@@ -0,0 +1,5 @@
+export default {
+  preset: "ts-jest",
+  testEnvironment: "jsdom",
+  testMatch: ["**/tests/**"],
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nativerent/js-utils",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -12,11 +12,15 @@
   "author": "NativeRent",
   "license": "GPL-3.0-or-later",
   "devDependencies": {
+    "@types/jest": "^29.5.11",
     "eslint": "^8.56.0",
+    "jest": "^29.7.0",
     "prettier": "^3.1.1",
     "rollup": "^4.9.4",
     "rollup-plugin-dts": "^6.1.0",
     "rollup-plugin-esbuild": "^6.1.0",
-    "typescript": "^5.3.3"
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.3.3",
+    "jest-environment-jsdom": "^29.7.0"
   }
 }

package/src/index.ts

@@ -3,9 +3,9 @@ import { FlattenableObject, Primitive, SimpleObject } from "./types";
 export function debounce(fn: Function, delay: number): () => void {
   let timeout: ReturnType<typeof setTimeout>;
 
-  return function (this: any, ...args: any[]) {
+  return function (...args: any[]) {
     clearTimeout(timeout);
-    timeout = setTimeout(() => fn.apply(this, args), delay);
+    timeout = setTimeout(() => fn.apply(null, args), delay);
   };
 }
 
@@ -38,6 +38,13 @@ export function isString(str: any): str is string {
   return typeof str === "string";
 }
 
+/**
+ * Check if the given argument is a string which is not empty
+ */
+export function isNotEmptyString(str: any) {
+  return typeof str === "string" && str.length;
+}
+
 export function isHTMLElement(el: any): el is HTMLElement {
   return el instanceof HTMLElement || el instanceof SVGElement;
 }
@@ -117,15 +124,24 @@ export function getObjectKeys(object: object): string[] {
 }
 
 /**
- * Works with primitive objects, see JSDoc @param
+ * Convert an object to a query string
+ * Works with primitive objects
  */
 export function objectToQueryString(object: {
-  [key: string]: SimpleObject | { [key: string]: SimpleObject };
+  [key: string | number]:
+    | Primitive
+    | Array<Primitive | null | undefined>
+    | SimpleObject
+    | { [key: string | number]: SimpleObject }
+    | undefined
+    | null;
 }): string {
   return Object.entries(object)
     .map(([k, v]) => {
       if (Array.isArray(v)) {
-        return v.map((item) => `${k}[]=${encodeURIComponent(item)}`).join("&");
+        return v
+          .map((item) => `${k}[]=${encodeURIComponent(item || "")}`)
+          .join("&");
       } else if (isObject(v)) {
         return `${k}=${encodeURIComponent(JSON.stringify(v))}`;
       }
@@ -155,10 +171,7 @@ export function countObjectInnerLength(object: {
 /**
  * Check if the element is in viewport
  */
-export const isElementVisible = (
-  element: HTMLElement,
-  minVisiblePercent = 50,
-) => {
+export function isElementVisible(element: HTMLElement, minVisiblePercent = 50) {
   const elementCoords = element.getBoundingClientRect();
   const elementHeight = elementCoords.height;
 
@@ -178,13 +191,6 @@ export const isElementVisible = (
         elementBottom;
 
   return (elementVisibleHeight / elementHeight) * 100 >= minVisiblePercent;
-};
-
-/**
- * Find a DOM element where an ad unit should be rendered to
- */
-export function getHtmlElement(id: string) {
-  return document.getElementById(id);
 }
 
 export function decodeSafeURL(url: string): string {
@@ -195,7 +201,8 @@ export function decodeSafeURL(url: string): string {
   }
 }
 
-export function getSafeURL(url: string): string {
+export function getSafeURL(url?: string): string {
+  url = url ? url : location.href;
   return encodeURI(decodeSafeURL(url));
 }
 
@@ -236,6 +243,13 @@ export function toBinaryStr(str: string) {
   return String.fromCharCode(...charCodes);
 }
 
+/**
+ * Find a DOM element where an ad unit should be rendered to
+ */
+export function getHtmlElement(id: string) {
+  return document.getElementById(id);
+}
+
 /**
  * Convert an HTML string into a list of nodes
  */
@@ -269,7 +283,7 @@ export function createHtmlElement(
  */
 export function insertHtmlElements(
   nodes: NodeListOf<Node>,
-  appendTo: Element | null = null,
+  appendTo?: Element,
 ) {
   appendTo = appendTo || document.body;
 
@@ -295,7 +309,11 @@ export function insertHtmlElements(
             flatHtmlAttributes(node.attributes),
           );
         } else {
-          newNode = createScriptElement(node.innerHTML, true);
+          newNode = createScriptElement(
+            node.innerHTML,
+            true,
+            flatHtmlAttributes(node.attributes),
+          );
         }
         break;
 
@@ -426,6 +444,21 @@ export function createSvgElement(
   return element;
 }
 
+/**
+ * Create an image element to use as a tracking pixel
+ */
+export function createPixelElement(src: string) {
+  const image = document.createElement("img");
+
+  image.src = src;
+  image.width = 1;
+  image.height = 1;
+  image.style.position = "absolute";
+  image.style.left = "-99999px";
+
+  return image;
+}
+
 /**
  * Append a new script element to the DOM head
  */
@@ -438,11 +471,7 @@ export function insertJs(js: string, inline = false) {
 /**
  * Append a new style element to the DOM head
  */
-export const insertCss = (
-  css: string,
-  className?: string,
-  external = false,
-) => {
+export function insertCss(css: string, className?: string, external = false) {
   const element = external ? createLinkElement(css) : createStyleElement(css);
 
   if (className) {
@@ -450,7 +479,7 @@ export const insertCss = (
   }
 
   document.head.appendChild(element);
-};
+}
 
 /**
  * Get screen sizes
@@ -482,21 +511,6 @@ export function getRandomInt(min = 0, max = 4294967295) {
   return Math.floor(Math.random() * (max - min)) + min;
 }
 
-/**
- * Create an image element to use as a tracking pixel
- */
-export function createPixelElement(src: string) {
-  const image = document.createElement("img");
-
-  image.src = src;
-  image.width = 1;
-  image.height = 1;
-  image.style.position = "absolute";
-  image.style.left = "-99999px";
-
-  return image;
-}
-
 /**
  * Implementation of Java's String.hashCode() method
  */

package/src/types.d.ts

@@ -3,5 +3,5 @@ export type FlattenableObject = { [key: string]: any };
 export type Primitive = boolean | number | string;
 
 export type SimpleObject = {
-  [key: string]: Primitive | Primitive[] | null | undefined;
+  [key: string | number]: Primitive | Primitive[] | null | undefined;
 };

package/tests/tests.ts

@@ -1,6 +1,15 @@
 import {
+  areDiff,
   arrayDiff,
+  capitalize,
   debounce,
+  filterObjectKeysByValues,
+  formatNumber,
+  formatNumberWithSign,
+  formatWithSign,
+  getFromObject,
+  getRandomItem,
+  getRandomStr,
   isBool,
   isDefined,
   isFn,
@@ -11,9 +20,208 @@ import {
   isUndef,
   objectHasProp,
   objectToQueryString,
+  parseObjectPathStr,
   parseURL,
+  roundBigNum,
+  roundDown,
+  roundUp,
+  sortByAlphabet,
+  sumArray,
+  toCamelCase,
+  toPercent,
+  toSnakeCase,
 } from "../src";
 
+test.each([
+  [20, 40, 50],
+  [12, 56, 21.428571428571427],
+  [489, 232, 210.77586206896552],
+])("toPercent", (a, b, expected) => {
+  const res = toPercent(a, b);
+  expect(res).toBe(expected);
+  expect(typeof res).toBe("number");
+});
+
+test.each([
+  ["camelcase", "camelcase"],
+  ["camelCase", "camelCase"],
+  ["camel-case", "camelCase"],
+  ["CAMEL_CASE", "CAMELCASE"],
+  ["CAMEL.CASE", "CAMELCASE"],
+  ["CAMELCASE", "CAMELCASE"],
+  ["fullScreenTGB", "fullScreenTGB"],
+  ["typesWith-POPUP_TEASER", "typesWithPOPUPTEASER"],
+  ["typesWith-ADVICE", "typesWithADVICE"],
+  ["typesWith-button_phone", "typesWithButtonPhone"],
+  ["typesWith-buttonPhone", "typesWithButtonPhone"],
+  ["item.button_phone", "itemButtonPhone"],
+  ["item.buttonPhone", "itemButtonPhone"],
+  ["camel.case-camel_CASE", "camelCaseCamelCASE"],
+])("toCamelCase", (str, expected) => {
+  expect(toCamelCase(str)).toBe(expected);
+});
+
+test.each([
+  ["camelcase", "camelcase"],
+  ["camelCase", "camel_case"],
+  ["camel-case", "camel_case"],
+  ["CAMEL_CASE", "c_a_m_e_l_c_a_s_e"],
+  ["CAMEL.CASE", "c_a_m_e_l_c_a_s_e"],
+  ["CAMELCASE", "c_a_m_e_l_c_a_s_e"],
+  ["fullScreenTGB", "full_screen_t_g_b"],
+  ["typesWith-POPUP_TEASER", "types_with_p_o_p_u_p_t_e_a_s_e_r"],
+  ["typesWith-ADVICE", "types_with_a_d_v_i_c_e"],
+  ["typesWith-button_phone", "types_with_button_phone"],
+  ["typesWith-buttonPhone", "types_with_button_phone"],
+  ["item.button_phone", "item_button_phone"],
+  ["item.buttonPhone", "item_button_phone"],
+  ["camel.case-camel_CASE", "camel_case_camel_c_a_s_e"],
+])("toSnakeCase", (str, expected) => {
+  expect(toSnakeCase(str)).toBe(expected);
+});
+
+test.each([
+  ["title", "Title"],
+  ["another title", "Another title"],
+  ["UPPER CASE TITLE", "UPPER CASE TITLE"],
+  ["CapitalizedTitle", "CapitalizedTitle"],
+  ["item.title", "Item.title"],
+  ["item-title", "Item-title"],
+  ["item_title", "Item_title"],
+])("capitalize", (str, expected) => {
+  expect(capitalize(str)).toBe(expected);
+});
+
+test.each([
+  ["title", "Title", -1],
+  ["another title", "title", -1],
+  ["simple title", "compound title", 1],
+  ["UPPER CASE TITLE", "TITLE", 1],
+  ["кириллица", "сортировка", -1],
+  ["ясень", "береза", 1],
+  ["Водолей", "Лев", -1],
+  ["питер", "мск", 1],
+  ["zebra", "зебра", -1],
+  ["аббревиатура", "York", 1],
+])("sortByAlphabet", (first, second, expected) => {
+  expect(sortByAlphabet(first, second)).toBe(expected);
+});
+
+test.each([
+  [undefined, 10],
+  [1, 1],
+  [43, 43],
+  [71, 71],
+  [100, 100],
+  [450, 100],
+])("getRandomStr", (len, expectedLen) => {
+  const str = getRandomStr(len);
+  expect(str.length).toBe(expectedLen);
+  expect(typeof str).toBe("string");
+});
+
+test.each([
+  [[3, "ff", 3434]],
+  [[423434234]],
+  [[{ ff: "dd" }, 7, ["rrr", "tt", "y"]]],
+])("getRandomItem", (arr) => {
+  expect(arr).toContain(getRandomItem(arr));
+  expect(arr).toEqual(arr);
+});
+
+test.each([
+  [[2, 2, 1, 2], 7],
+  [[52, 122, 17, 368], 559],
+  [[0.099999999, 1.3028475, 1556.54677, 1000000.02], 1001557.969617499],
+  [[undefined, 456, "99", 13, "qwerty", null, 0.46778], 568.46778],
+])("sumArray", (arr, expected) => {
+  expect(sumArray(arr)).toBe(expected);
+});
+
+test.each([
+  [{ wq: "qwqw", q: 22, add: { s: [1, 2] } }, [22, "qwqw"], ["add"]],
+  [{ wq: "qwqw", q: 22, add: { s: [1, 2] } }, ["q", 22], ["wq", "add"]],
+  [{ 1: 2, key: "value", t: [1, 2], tt: false }, [false], ["1", "key", "t"]],
+  [{ type: undefined, enabled: true, date: null }, [undefined, null, true], []],
+])("filterObjectKeysByValues", (array, value, expected) => {
+  expect(filterObjectKeysByValues(array, value)).toEqual(expected);
+});
+
+test.each([
+  [{ k: "d" }, "k", "d"],
+  [{ title: null }, "title", null],
+  [{ 2: null, POS: undefined, g: { f: "roubles" } }, "POS", undefined],
+  [{ 2: null, POS: undefined, g: { f: "roubles" } }, "g", { f: "roubles" }],
+  [
+    {
+      array: [5, 657, 7],
+      obj: { q: 3, fdf: "gdfg", d: null, e: undefined },
+    },
+    "obj",
+    { q: 3, fdf: "gdfg", d: null, e: undefined },
+  ],
+  [
+    {
+      array: [5, 657, 7],
+      obj: {
+        q: 3,
+        fdf: "gdfg",
+        d: null,
+        e: undefined,
+        g: () => {},
+      },
+    },
+    "array",
+    [5, 657, 7],
+  ],
+])("getFromObject", (obj, key, expected) => {
+  expect(getFromObject(obj, key)).toEqual(expected);
+});
+
+test.each([
+  ["item.title.value", ["item", "title", "value"]],
+  ["item[title][value]", ["item", "title", "value"]],
+  ["rules[1][fields.title]", ["rules", "1", "fields", "title"]],
+  ["rules[1][fields[title]]", ["rules", "1", "fields", "title"]],
+  ["rules.1[fields.title]", ["rules", "1", "fields", "title"]],
+  [
+    "rules.1[fields.title[regular][NR]]",
+    ["rules", "1", "fields", "title", "regular", "NR"],
+  ],
+])("parseObjectPathStr", (path, expected) => {
+  expect(parseObjectPathStr(path)).toEqual(expected);
+});
+
+test.each([
+  [34, 5, "34.00000"],
+  ["4546.77", 1, "4 546.8"],
+  ["1000.009", 4, "1 000.0090"],
+  ["1000.009", 2, "1 000.01"],
+])("formatNumber", (num, digits, expected) => {
+  expect(formatNumber(num, digits)).toBe(expected);
+});
+
+test.each([
+  [34, 5, "+34.00000"],
+  [-4545, 2, "-4 545.00"],
+  ["4546.77", 1, "+4 546.8"],
+  ["-1000.009", 4, "-1 000.0090"],
+  ["1000.009", 2, "+1 000.01"],
+])("formatNumberWithSign", (num, digits, expected) => {
+  expect(formatNumberWithSign(num, digits)).toBe(expected);
+});
+
+test.each([
+  [34, undefined, "+34"],
+  [4545, undefined, "+4545"],
+  [4546.77, "4 546.77 руб", "+4 546.77 руб"],
+  [-1000.009, "1 000.01 ₽", "1 000.01 ₽"],
+  [1000.009, "1000.01$", "+1000.01$"],
+  [-0.009, undefined, "-0.009"],
+])("formatWithSign", (num, numStr, expected) => {
+  expect(formatWithSign(num, numStr)).toBe(expected);
+});
+
 test.each([
   [
     [1, 2, 3],
@@ -222,3 +430,92 @@ test.each([
 ])("objectHasProp", (obj, prop, expected) => {
   expect(objectHasProp(obj, prop)).toBe(expected);
 });
+
+test.each([
+  ["str", null, true, true],
+  ["str", null, false, true],
+  ["", null, false, false],
+  ["", null, true, true],
+  ["", undefined, false, false],
+  ["", undefined, true, true],
+  ["", "", true, false],
+  ["", "", false, false],
+  ["1", "11", false, true],
+  ["1", "11", true, true],
+  ["{}", "object", true, true],
+  ["{}", "object", false, true],
+  ["{}", "[]", true, true],
+  ["{}", "[]", false, true],
+  ["{}", "[]", true, true],
+  ["title", "Title", false, true],
+  ["title", "Title", true, true],
+  ["title", "title", true, false],
+  [true, "true", true, true],
+  [true, "true", false, true],
+  ["4", 4, false, false],
+  ["4", 4, true, true],
+  [1, true, false, false],
+  ["1", true, false, false],
+  [1, true, true, true],
+  [0, false, false, false],
+  [0, false, true, true],
+  ["0", false, false, false],
+])("areDiff", (val1, val2, strict, expected) => {
+  expect(areDiff(val1, val2, strict)).toBe(expected);
+});
+
+test.each([
+  [0, 0],
+  [27, 27],
+  [99, 99],
+  [101, 100],
+  [277, 300],
+  [937, 900],
+  [967, 1000],
+  [1836, 1800],
+  [9284, 9300],
+  [29487, 30000],
+  [2569424, 2570000],
+  [11111111, 11110000],
+  [9999999000, 10000000000],
+])("roundBigNum", (num, expected) => {
+  expect(roundBigNum(num)).toBe(expected);
+});
+
+test.each([
+  [0.9999889999, 0, 1.0],
+  [0.9999889999, 1, 1.0],
+  [0.9999889999, 2, 1.0],
+  [0.0000000001, 0, 1],
+  [0.0000000001, 1, 0.1],
+  [0.0000000001, 2, 0.01],
+  [0.0000000001, 3, 0.001],
+  [0.0000000001, 14, 0.0000000001],
+  [78.3333333333, 1, 78.4],
+  [78.3333333333, 0, 79],
+  [10000.354, 3, 10000.354],
+  [10000.354, 2, 10000.36],
+  [10000.354, 1, 10000.4],
+  [10000.354, 0, 10001],
+])("roundUp", (num, precision, expected) => {
+  expect(roundUp(num, precision)).toBe(expected);
+});
+
+test.each([
+  [0.9999889999, 0, 0],
+  [0.9999889999, 1, 0.9],
+  [0.9999889999, 2, 0.99],
+  [0.0000000001, 0, 0],
+  [0.0000000001, 1, 0],
+  [0.0000000001, 2, 0],
+  [0.0000000001, 3, 0],
+  [0.0000000001, 14, 0.0000000001],
+  [78.3333333333, 1, 78.3],
+  [78.3333333333, 0, 78],
+  [10000.354, 3, 10000.354],
+  [10000.354, 2, 10000.35],
+  [10000.354, 1, 10000.3],
+  [10000.354, 0, 10000],
+])("roundDown", (num, precision, expected) => {
+  expect(roundDown(num, precision)).toBe(expected);
+});