worked on logging function

Author: landonwjohnson

.yarn/versions/3788a52d.yml

@@ -1,7 +1,7 @@
 {
   "name": "@devlander/utils",
   "description": "Utils shared between projects that are plain javascript",
-  "version": "0.0.25",
+  "version": "0.0.26",
   "browser": "dist/umd/index.js",
   "main": "dist/cjs/index.js",
   "types": "typings/index.d.ts",

package.json

@@ -0,0 +1,30 @@
+import { getRandomValFromArray } from "../getRandomValFromArray";
+
+describe("getRandomValFromArray", () => {
+  it("should return the fallback value if the array is empty", () => {
+    const arr: number[] = [];
+    const fallbackValue = 0;
+
+    const result = getRandomValFromArray(arr, fallbackValue);
+
+    expect(result).toBe(fallbackValue);
+  });
+
+  it("should return a random value from the array", () => {
+    const arr = [1, 2, 3, 4, 5];
+    const fallbackValue = 0;
+
+    const result = getRandomValFromArray(arr, fallbackValue);
+
+    expect(arr).toContain(result);
+  });
+
+  it("should return the fallback value if the array contains only undefined values", () => {
+    const arr: (number | undefined)[] = [undefined, undefined, undefined];
+    const fallbackValue = 0;
+
+    const result = getRandomValFromArray(arr, fallbackValue);
+
+    expect(result).toBe(fallbackValue);
+  });
+});

src/__tests__/getRandomValFromArray.test.ts

@@ -0,0 +1,31 @@
+import { hslToRgb } from "../hslToRgb";
+
+describe("hslToRgb", () => {
+  it("should convert HSL values to RGB correctly", () => {
+    // Test case 1
+    let h = 0;
+    let s = 100;
+    let l = 50;
+    let expectedRgb = [255, 0, 0];
+    let result = hslToRgb(h, s, l);
+    expect(result).toEqual(expectedRgb);
+
+    // Test case 2
+    h = 120;
+    s = 100;
+    l = 50;
+    expectedRgb = [0, 255, 0];
+    result = hslToRgb(h, s, l);
+    expect(result).toEqual(expectedRgb);
+
+    // Test case 3
+    h = 240;
+    s = 100;
+    l = 50;
+    expectedRgb = [0, 0, 255];
+    result = hslToRgb(h, s, l);
+    expect(result).toEqual(expectedRgb);
+
+    // Add more test cases as needed
+  });
+});

src/__tests__/hslToRgb.test.ts

@@ -0,0 +1,51 @@
+import { isPlainObject } from "../isPlainObject";
+
+describe("isPlainObject", () => {
+  it("should return true for a plain object", () => {
+    const obj = { name: "John", age: 30 };
+
+    const result = isPlainObject(obj);
+
+    expect(result).toBe(true);
+  });
+
+  it("should return false for an array", () => {
+    const arr = [1, 2, 3];
+
+    const result = isPlainObject(arr);
+
+    expect(result).toBe(false);
+  });
+
+  it("should return false for a string", () => {
+    const str = "Hello, world!";
+
+    const result = isPlainObject(str);
+
+    expect(result).toBe(false);
+  });
+
+  it("should return false for a number", () => {
+    const num = 42;
+
+    const result = isPlainObject(num);
+
+    expect(result).toBe(false);
+  });
+
+  it("should return false for null", () => {
+    const value = null;
+
+    const result = isPlainObject(value);
+
+    expect(result).toBe(false);
+  });
+
+  it("should return false for undefined", () => {
+    const value = undefined;
+
+    const result = isPlainObject(value);
+
+    expect(result).toBe(false);
+  });
+});

src/__tests__/isPlainObject.test.ts

@@ -0,0 +1,24 @@
+import { isValidHex } from "../isValidHex";
+
+describe("isValidHex", () => {
+  it("should return true for valid hex colors", () => {
+    expect(isValidHex("#000")).toBe(true);
+    expect(isValidHex("#ffffff")).toBe(true);
+    expect(isValidHex("#12345678")).toBe(true);
+  });
+
+  it("should return false for invalid hex colors", () => {
+    expect(isValidHex("000")).toBe(false);
+    expect(isValidHex("#12345")).toBe(false);
+    expect(isValidHex("#gggggg")).toBe(false);
+    expect(isValidHex("#123456789")).toBe(false);
+  });
+
+  it("should return false for non-string input", () => {
+    expect(isValidHex(null)).toBe(false);
+    expect(isValidHex(undefined)).toBe(false);
+    expect(isValidHex(123)).toBe(false);
+    expect(isValidHex({})).toBe(false);
+    expect(isValidHex([])).toBe(false);
+  });
+});

src/__tests__/isValidHex.test.ts

@@ -0,0 +1,25 @@
+import { applyFormatters } from "../../logFormattedPhrases/applyFormatters";
+import { PhraseItem, PhraseOrderType } from "../../logFormattedPhrases/formattedPhrase.types";
+import { defaultPhraseOrder } from "../../logFormattedPhrases/getPhraseStylesFromOrder";
+
+
+describe("applyFormatters", () => {
+  it("Expect apply formatters to return correct values", () => {
+    const phraseItem: PhraseItem = {
+      background: "red", color: "blue",
+      phrase: ""
+    };
+    const orderItems:PhraseOrderType[] =  defaultPhraseOrder
+
+    const result = applyFormatters(phraseItem, orderItems);
+
+    // console.log(result, 'result in applyFormatters test');
+
+    const hasBlueForColor = result.some((formatter) => formatter.value === "blue" && formatter.name === "color");
+
+    const hasRedValueForBackground = result.some((formatter) => formatter.value === "red" && formatter.name === "background");
+    expect(hasRedValueForBackground).toBe(true);
+    expect(hasBlueForColor).toBe(true);
+  });
+
+});

src/__tests__/logFormattedPhrases/applyFormatters.test.ts

@@ -0,0 +1,44 @@
+
+import { formatPhrase } from '../../logFormattedPhrases/formatPhrase';
+import { PhraseItem } from '../../logFormattedPhrases/formattedPhrase.types';
+
+
+describe("formatPhrase", () => {
+  it("should be able to log with just text", () => {
+    const item: PhraseItem = {
+      phrase: "Hello, world!",
+    };
+
+    const expectedFormattedPhrase = "Hello, world!"; // Update this with the expected formatted phrase
+
+    
+ 
+    // Call the formatPhrase function
+   const result = formatPhrase(item);
+    if(result) {
+    expect(result.message).toBe(expectedFormattedPhrase);
+    }
+  });
+
+  it("it should work with color and background", () => {
+    const item: PhraseItem = {
+      phrase: "Hello, world!",
+      color: "blue",
+      background: "red"
+    };
+
+
+    
+ 
+    // Call the formatPhrase function
+   const result = formatPhrase(item);
+
+   console.log(result, 'result in formatPhrase test');
+    
+    if(result) {
+      expect(result.formattersApplied.includes("color")).toBe(true);
+      expect(result.formattersApplied.includes("background")).toBe(true);
+
+    }
+  });
+});

src/__tests__/logFormattedPhrases/formatPhrase.test.ts

@@ -0,0 +1,28 @@
+// Mock the module
+jest.mock("../../logFormattedPhrases/getPhraseStylesFromOrder", () => ({
+  getPhraseStylesFromOrder: jest.fn().mockReturnValue([]),
+}));
+
+import * as pico from "picocolors";
+import { PhraseColors } from "../../logFormattedPhrases/formattedPhrase.types";
+import { getPhraseBackground } from "../../logFormattedPhrases/getPhraseBackground";
+
+describe("getPhraseBackground", () => {
+  it("should return the correct background function for a given color", () => {
+    const color = "red";
+    const expectedFunction = pico.bgRed;
+
+    const result = getPhraseBackground(color);
+
+    expect(result).toBe(expectedFunction);
+  });
+
+  it("should return the default background function when color is not found", () => {
+    const color = "purple";
+    const expectedFunction = pico.bgBlack;
+
+    const result = getPhraseBackground(color as PhraseColors);
+
+    expect(result).toBe(expectedFunction);
+  });
+});

src/__tests__/logFormattedPhrases/getPhraseBackground.test.ts

@@ -0,0 +1,52 @@
+// Source: do not remove the comment above. It's used to verify the path of the snippet when it's being
+// referenced in conversations about the code.
+// Path: ./src/__tests__/logFormattedPhrases/getPhraseStylesFromOrder.test.ts
+
+import { AppliedFormatter, PhraseItem } from "../../logFormattedPhrases/formattedPhrase.types";
+import { getPhraseStylesFromOrder } from "../../logFormattedPhrases/getPhraseStylesFromOrder";
+
+const hasValueInFormatters = (formatters: AppliedFormatter[], property: string) => {
+  return formatters.some((formatter) => formatter.name === property);
+}
+
+describe("getPhraseStylesFromOrder", () => {
+
+
+  // it("should return an empty array when item.orderToApplyStyles is empty", () => {
+  //   const item: PhraseItem = {
+  //     orderToApplyStyles: [],
+  //     phrase: ""
+  //   };
+  //   const result = getPhraseStylesFromOrder(item);
+  //   expect(result).toEqual([]);
+  // });
+
+  // it("should return an empty array when item.orderToApplyStyles is not an array", () => {
+   
+  //   const item: PhraseItem = {
+  //     orderToApplyStyles: "invalid" as any,
+  //     phrase: ""
+  //   };
+  //   const result = getPhraseStylesFromOrder(item);
+  //   expect(result).toEqual([]);
+  // });
+
+  it("Should change just color and fontWeight to false", () => {
+    // look at this one RIGHT HERE
+
+    const item: PhraseItem = {
+      phrase: "",
+      color: "red",
+      orderToApplyStyles: [
+        { property: "color", enabled: false, order: 1 } as any,
+        { property: "fontWeight", enabled: false, order: 2 } as any,
+      ],
+    };
+    const result: AppliedFormatter[] = getPhraseStylesFromOrder(item);
+   expect(result).toBeDefined();
+
+  });
+
+  // Add more test cases for different scenarios
+
+});