added more functions

Author: landonwjohnson

.yarn/versions/40175b34.yml

@@ -1,9 +1,8 @@
 {
   "name": "@devlander/utils",
   "description": "Utils shared between projects that are plain javascript",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "main": "dist/cjs/index.js",
-  "browser": "dist/umd/index.js",
   "types": "typings/index.d.ts",
   "module": "dist/esm/index.js",
   "type": "commonjs",

package.json

@@ -27,13 +27,7 @@ const makeExternalPredicate = externalArr => {
 export default {
   input: "src/index.ts", // Your entry point
   output: [
-    {
-      file: packageJson.browser,
-      format: "umd",
-      name: "DevlanderUtils", // Replace with your library's name
-      globals: globals,
-      sourcemap: true,
-    },
+ 
     {
       file: packageJson.main,
       format: "cjs",

rollup.config.mjs

@@ -0,0 +1,31 @@
+import { calculatePercentage } from "../calculatePercentage";
+
+describe("calculatePercentage", () => {
+  it("should calculate the percentage correctly when partial and whole are numbers", () => {
+    const partial = 25;
+    const whole = 100;
+    const expectedPercentage = 25;
+
+    const result = calculatePercentage(partial, whole);
+
+    expect(result).toBe(expectedPercentage);
+  });
+
+  it("should throw an error when partial or whole is not a number", () => {
+    const partial = "25";
+    const whole = 100;
+
+    expect(() => {
+      calculatePercentage(partial as any, whole);
+    }).toThrow("Both inputs must be numbers and 'whole' cannot be zero.");
+  });
+
+  it("should throw an error when whole is zero", () => {
+    const partial = 25;
+    const whole = 0;
+
+    expect(() => {
+      calculatePercentage(partial, whole);
+    }).toThrow("Both inputs must be numbers and 'whole' cannot be zero.");
+  });
+});

src/__tests__/calculatePercentage.test.ts

@@ -0,0 +1,31 @@
+import { convertVideoTimeStampToSeconds } from "../convertVideoTimeStampToSeconds";
+
+describe("convertVideoTimeStampToSeconds", () => {
+  it("should convert a timestamp in the format 'HH:MM:SS' to seconds", () => {
+    // Test cases
+    expect(convertVideoTimeStampToSeconds("00:00:10")).toBe(10);
+    expect(convertVideoTimeStampToSeconds("00:01:30")).toBe(90);
+    expect(convertVideoTimeStampToSeconds("01:00:00")).toBe(3600);
+    expect(convertVideoTimeStampToSeconds("02:30:45")).toBe(9045);
+  });
+
+  it("should handle timestamps with leading zeros", () => {
+    expect(convertVideoTimeStampToSeconds("00:00:01")).toBe(1);
+    expect(convertVideoTimeStampToSeconds("00:01:01")).toBe(61);
+    expect(convertVideoTimeStampToSeconds("01:01:01")).toBe(3661);
+    expect(convertVideoTimeStampToSeconds("01:01:10")).toBe(3670);
+  });
+
+  it("should handle timestamps with single-digit hours and minutes", () => {
+    expect(convertVideoTimeStampToSeconds("0:0:10")).toBe(10);
+    expect(convertVideoTimeStampToSeconds("0:10:30")).toBe(630);
+    expect(convertVideoTimeStampToSeconds("1:0:0")).toBe(3600);
+    expect(convertVideoTimeStampToSeconds("2:30:45")).toBe(9045);
+  });
+
+  it("should handle timestamps with only seconds", () => {
+    expect(convertVideoTimeStampToSeconds("0:0:1")).toBe(1);
+    expect(convertVideoTimeStampToSeconds("0:0:30")).toBe(30);
+    expect(convertVideoTimeStampToSeconds("0:0:59")).toBe(59);
+  });
+});

src/__tests__/convertVideoTimeStampToSeconds.test.ts

@@ -0,0 +1,24 @@
+import { getRange } from "../getRange";
+
+describe("getRange", () => {
+  it("should return an array of numbers starting from the specified start value", () => {
+    const start = 1;
+    const count = 5;
+    const result = getRange(start, count);
+    expect(result).toEqual([1, 2, 3, 4, 5]);
+  });
+
+  it("should return an empty array when count is 0", () => {
+    const start = 1;
+    const count = 0;
+    const result = getRange(start, count);
+    expect(result).toEqual([]);
+  });
+
+  it("should return an empty array when count is negative", () => {
+    const start = 1;
+    const count = -5;
+    const result = getRange(start, count);
+    expect(result).toEqual([]);
+  });
+});

src/__tests__/getRange.test.ts

@@ -0,0 +1,21 @@
+/**
+ * Calculates the percentage of a partial value compared to a whole value.
+ * 
+ * @param partial The partial value.
+ * @param whole The whole value.
+ * @returns The percentage value.
+ * @throws Error if either partial or whole is not a number, or if whole is zero.
+ */
+export function calculatePercentage(
+    partial: number,
+    whole: number
+  ) {
+    if (typeof partial !== 'number' || typeof whole !== 'number' || whole === 0) {
+      throw new Error("Both inputs must be numbers and 'whole' cannot be zero.");
+    }
+  
+    const percentage = (partial / whole) * 100;
+    return percentage;
+  }
+  
+  

src/calculatePercentage.ts

@@ -0,0 +1,27 @@
+/**
+ * Converts a video timestamp string to seconds.
+ * 
+ * @param timestamp - The video timestamp string in the format "HH:MM:SS".
+ * @returns The number of seconds represented by the timestamp, or NaN if the timestamp is invalid.
+ */
+export function convertVideoTimeStampToSeconds(timestamp: string): number {
+    const parts: string[] = timestamp.split(':');
+
+    if (parts.length !== 3) {
+        throw new Error('Invalid timestamp format. Expected format: "HH:MM:SS"');
+    }
+
+    const hours = parseInt(parts[0], 10);
+    const minutes = parseInt(parts[1], 10);
+    const seconds = parseInt(parts[2], 10);
+
+    if (isNaN(hours) || isNaN(minutes) || isNaN(seconds)) {
+        throw new Error('Invalid timestamp format. Expected format: "HH:MM:SS"');
+    }
+
+    if (hours < 0 || minutes < 0 || seconds < 0) {
+        throw new Error('Invalid timestamp. Negative values are not allowed.');
+    }
+
+    return hours * 3600 + minutes * 60 + seconds;
+}

src/convertVideoTimeStampToSeconds.ts

@@ -0,0 +1,38 @@
+import { dashToCamelCase } from "./dashToCamelCase";
+
+describe("dashToCamelCase", () => {
+  it("should convert a dash-case string to camelCase", () => {
+    const input = "hello-world";
+    const expectedOutput = "helloWorld";
+    const result = dashToCamelCase(input);
+    expect(result).toBe(expectedOutput);
+  });
+
+  it("should convert a single character dash-case string to camelCase", () => {
+    const input = "a-b-c";
+    const expectedOutput = "aBC";
+    const result = dashToCamelCase(input);
+    expect(result).toBe(expectedOutput);
+  });
+
+  it("should convert a dash-case string with multiple dashes to camelCase", () => {
+    const input = "this-is-a-test";
+    const expectedOutput = "thisIsATest";
+    const result = dashToCamelCase(input);
+    expect(result).toBe(expectedOutput);
+  });
+
+  it("should convert a dash-case string with leading and trailing dashes to camelCase", () => {
+    const input = "-hello-world-";
+    const expectedOutput = "helloWorld";
+    const result = dashToCamelCase(input);
+    expect(result).toBe(expectedOutput);
+  });
+
+  it("should convert an empty string to an empty camelCase string", () => {
+    const input = "";
+    const expectedOutput = "";
+    const result = dashToCamelCase(input);
+    expect(result).toBe(expectedOutput);
+  });
+});

src/dashToCamelCase.test.ts

@@ -0,0 +1,11 @@
+/**
+ * Converts a dash-separated string to camel case.
+ * 
+ * @param dashName - The dash-separated string to convert.
+ * @returns The camel case version of the input string.
+ */
+export function dashToCamelCase(dashName: string): string {
+  return dashName.replace(/^-+/, '').replace(/-+$/, '').toLowerCase().replace(/-([a-z])/g, function (_match, group1) {
+    return group1.toUpperCase();
+  });
+}