[feat] update methods fixing

Author: Ibrahim Odev

src/colorResult.ts

@@ -1,25 +1,57 @@
 import chroma from 'chroma-js';
 import type { IColorResultOptions } from './types';
 
-const darkenValue = (shade: number, mainShade: number) => {
+/**
+ * Calculates the darkening value based on the provided shade and mainShade.
+ * @param shade - The shade value to darken.
+ * @param mainShade - The main shade value.
+ * @returns The darkening value.
+ */
+const calculateDarkenValue = (shade: number, mainShade: number): number => {
   return (shade - mainShade) / 100 / 2;
 };
-const shadeColor = (primaryColor: string, mainShade: number, shade: number) => {
-  return chroma(primaryColor).darken(darkenValue(shade, mainShade)).hex();
+
+/**
+ * Shades the primary color based on the provided shade and mainShade.
+ * @param primaryColor - The primary color.
+ * @param mainShade - The main shade value.
+ * @param shade - The shade value.
+ * @returns The shaded color in hexadecimal format.
+ */
+const shadeColor = (primaryColor: string, mainShade: number, shade: number): string => {
+  return chroma(primaryColor).darken(calculateDarkenValue(shade, mainShade)).hex();
 };
-const shadeColorResult = (fn: any, options: IColorResultOptions) => {
-  return options.shades.reduce((acc: any, shade: number) => {
-    acc[shade] = fn(options.primaryColor, options.mainShade, shade);
+
+/**
+ * Generates the color palette based on the provided options.
+ * @param fn - The function to apply shade to the primary color.
+ * @param options - The color result options.
+ * @returns The generated color palette.
+ */
+const generateColorPalette = (
+  fn: (primaryColor: string, mainShade: number, shade: number) => string,
+  options: IColorResultOptions,
+): Record<string, string> => {
+  return options.shades.reduce((acc: Record<string, string>, shade: number) => {
+    acc[String(shade)] = fn(options.primaryColor, options.mainShade, shade);
     return acc;
   }, {});
 };
-const colorResult = (options: IColorResultOptions) => {
-  const palette = shadeColorResult(shadeColor, options);
-  const colorPalette = {
-    ...palette,
-    DEFAULT: options.primaryColor,
-  };
-  return Object.freeze(colorPalette) ?? {};
+
+/**
+ * Generates the final color result based on the provided options.
+ * @param options - The color result options.
+ * @returns The final color result.
+ */
+const colorResult = (options: IColorResultOptions): Record<string, string> => {
+  try {
+    const palette = generateColorPalette(shadeColor, options);
+    palette.DEFAULT = options.primaryColor;
+    return Object.freeze(palette);
+  } catch (error) {
+    console.error('Error generating color result:', error);
+    return Object.create(null); // Return an empty object in case of error.
+  }
 };
 
 export default colorResult;

src/helpers.ts

@@ -1,42 +1,44 @@
 import type { IColorResultOptions, Palette } from './types';
+import { isColor } from './utils';
 
 export const initalOptions: IColorResultOptions = {
   mainShade: 500,
   primaryColor: '#FFBD00',
   shades: [50, 100, 200, 300, 400, 500, 600, 700, 800, 900],
 };
 
-export const isColor = (color: string) => {
-  const reg = /^#([\da-f]{3}){1,2}$|^#([\da-f]{6}){1,2}$|(rgb|hsl)a?\((\s*-?\d+%?\s*,){2}(\s*-?\d+%?\s*,?\s*\)?)(,\s*(0?\.\d+)?|1)?\)/gim;
-  if (typeof color === 'string' && reg.test(color)) {
-    return true;
-  } else {
-    return false;
+export const checkParam = (palette: Palette): boolean => {
+  const { color, name, shade, shades } = palette;
+
+  if (!color || typeof color !== 'string' || !isColor(color)) {
+    throw new Error(`Invalid color: '${color}'. Please provide a valid color.`);
+  }
+
+  if (!name || typeof name !== 'string') {
+    throw new Error(`Invalid name: '${name}'. Please provide a valid name.`);
+  }
+
+  if (shade && typeof shade !== 'number') {
+    throw new Error(`Invalid shade value: '${shade}'. Shade must be a number.`);
   }
-};
 
-export const checkParam = (palette: Palette) => {
-  if (palette.color && typeof palette.color === 'string' && palette.name && typeof palette.name == 'string') {
-    if (!isColor(palette.color)) {
-      throw new Error(
-        `'${palette.color}' The value you entered is not a color. e.g #ffbd00 or #ffb or rgba(255, 189, 0, 1) or rgb(255, 189, 0) or hsl(44, 100%, 50%)`,
-      );
-    } else if (!palette.shade && palette.shades) {
-      throw new Error(`If you want to specify the shades, you have to specify the main shade.`);
-    } else if (palette.shade && typeof palette.shade !== 'number') {
-      throw new Error(`'${palette.shade}' - type: ${typeof palette.shade} It must be of type number.`);
-    } else if (palette.shades && !Array.isArray(palette.shades)) {
-      throw new Error(`Shades are not array.`);
-    } else if (palette.shades && palette.shades.length <= 2) {
-      throw new Error(`Shades can consist of at least 3 elements.`);
-    } else if (palette.shade && palette.shades && !palette.shades.includes(palette.shade)) {
-      throw new Error(`'${palette.shade}' mainShade are not included in the your shades.`);
-    } else if (!palette.shades && palette.shade && !initalOptions.shades.includes(palette.shade)) {
-      throw new Error(`'${palette.shade}' mainShade can only be 50, 100, 200, 300, 400, 500, 600, 700, 800 or 900.`);
-    } else {
-      return true;
+  if (shades) {
+    if (!Array.isArray(shades)) {
+      throw new Error(`Invalid shades: '${shades}'. Shades must be an array.`);
+    }
+
+    if (shades.length < 3) {
+      throw new Error('Shades array must contain at least 3 elements.');
+    }
+
+    if (shade && !shades.includes(shade)) {
+      throw new Error(`Main shade '${shade}' is not included in the shades array.`);
     }
   } else {
-    throw new Error('Make sure the required data is included.');
+    if (shade && ![50, 100, 200, 300, 400, 500, 600, 700, 800, 900].includes(shade)) {
+      throw new Error(`Main shade '${shade}' must be one of: 50, 100, 200, 300, 400, 500, 600, 700, 800, 900.`);
+    }
   }
+
+  return true;
 };

src/main.ts

@@ -3,44 +3,48 @@ import colorResult from './colorResult';
 import { checkParam, initalOptions } from './helpers';
 import type { IColorResultOptions, Palette } from './types';
 
-const getPalette = (params: Palette[] | Palette | string): any => {
-  const palette: any = {};
+const getPalette = (params: Palette[] | Palette | string): Record<string, Record<string, string>> => {
+  const palette: Record<string, Record<string, string>> = {};
+
+  const generateColorPalette = (options: IColorResultOptions): Record<string, string> => {
+    return colorResult(options);
+  };
+
+  const getColorOptions = (colorPalette: Palette): IColorResultOptions => {
+    const { color, shade, shades } = colorPalette;
+
+    return {
+      mainShade: shade ?? initalOptions.mainShade,
+      primaryColor: chroma(color).hex() ?? initalOptions.primaryColor,
+      shades: shades ?? initalOptions.shades,
+    };
+  };
+
+  const addPalette = (name: string, options: IColorResultOptions) => {
+    palette[name] = generateColorPalette(options);
+  };
+
   if (Array.isArray(params)) {
-    for (let i = 0; i < params.length; i++) {
-      const colorPalette = params[i];
+    for (const colorPalette of params) {
       if (checkParam(colorPalette)) {
-        const options: IColorResultOptions = {
-          mainShade: colorPalette.shade ?? initalOptions.mainShade,
-          primaryColor: chroma(colorPalette.color).hex() ?? initalOptions.primaryColor,
-          shades: colorPalette.shades ?? initalOptions.shades,
-        };
-
-        palette[colorPalette.name] = colorResult(options);
+        const options = getColorOptions(colorPalette);
+        addPalette(colorPalette.name, options);
       }
     }
   } else if (typeof params !== 'string' && !Array.isArray(params)) {
     if (checkParam(params)) {
-      const options: IColorResultOptions = {
-        mainShade: params.shade ?? initalOptions.mainShade,
-        primaryColor: chroma(params.color).hex() ?? initalOptions.primaryColor,
-        shades: params.shades ?? initalOptions.shades,
-      };
-
-      palette[params.name] = colorResult(options);
+      const options = getColorOptions(params);
+      addPalette(params.name, options);
     }
   } else if (typeof params === 'string') {
-    let options: IColorResultOptions = {
+    const options: IColorResultOptions = {
       mainShade: initalOptions.mainShade,
-      primaryColor: initalOptions.primaryColor,
+      primaryColor: chroma(params).hex(),
       shades: initalOptions.shades,
     };
-
-    options = Object.assign(initalOptions, {
-      primaryColor: chroma(params).hex(),
-    });
-
-    palette['primary'] = colorResult(options);
+    addPalette('primary', options);
   }
+
   return palette;
 };
 

src/utils.ts

@@ -0,0 +1,11 @@
+export const isColor = (color: string) => {
+  const reg = new RegExp(
+    /^#([\da-f]{3}){1,2}$|^#([\da-f]{6}){1,2}$|(rgb|hsl)a?\((\s*-?\d+%?\s*,){2}(\s*-?\d+%?\s*,?\s*\)?)(,\s*(0?\.\d+)?|1)?\)/,
+    'gim',
+  );
+  if (typeof color === 'string' && reg.test(color)) {
+    return true;
+  }
+
+  return false;
+};