x25 17.7.0 → 17.7.2

package/src/utility/numeric.ts

@@ -1,103 +0,0 @@
-type This = any;
-import { normalizeNumber } from "./numbers";
-
-export const handleBlur = (that: This) => {
-  const {
-      state,
-      props,
-    } = that,
-    {
-      input,
-      normalizeValue,
-      optional,
-    } = props,
-    {
-      onBlur,
-    } = input,
-    {
-      value: currentValue,
-    } = state,
-
-    performBlur = (value: number | null, shouldRenderAgain: boolean) => {
-      input.onChange(value);
-
-      /*
-     * Swallow the event to prevent Redux Form from
-     * extracting the form value
-     */
-      onBlur();
-
-      if (shouldRenderAgain) {
-        const setState = that.setState.bind(that);
-
-        return setState({
-          value,
-        });
-      }
-
-      return null;
-    },
-
-    shouldNotChange = currentValue === "" && optional;
-
-  if (shouldNotChange) {
-    if (input.value === "") {
-      return null;
-    }
-
-    return performBlur(null, true);
-  }
-
-  const normalizedValue = normalizeValue(currentValue),
-    shouldRenderAgain = !isNaN(normalizedValue) && currentValue !== normalizedValue;
-
-  return performBlur(normalizedValue, shouldRenderAgain);
-};
-export const normalizeFloat = (raw: string): number => {
-  /* eslint-disable no-magic-numbers */
-  const value = normalizeNumber(raw),
-    shouldNotNormalize = value.trim() === "" || isNaN(Number(value));
-
-  if (shouldNotNormalize) {
-    return NaN;
-  }
-
-  const result = Number(value),
-    truncateTo = (unRouned: number, nrOfDecimals = 2): number => {
-      const parts = String(unRouned).split(".");
-
-      if (parts.length !== 2) {
-      // ex. 12
-        return unRouned;
-      }
-
-      const newDecimals = parts[1].slice(0, nrOfDecimals),
-        newString = `${parts[0]}.${newDecimals}`;
-
-      return Number(newString);
-    },
-    normalized = truncateTo(result);
-
-  return normalized;
-};
-export const cwrp = (that: This, nextany: any) => {
-  const {
-      state,
-    } = that,
-    {
-      input: {
-        value: newValue,
-      },
-    } = nextany,
-    {
-      value: currentValue,
-    } = state,
-    shouldRenderAgain = !isNaN(newValue) && currentValue !== newValue,
-    setState = that.setState.bind(that);
-
-  if (shouldRenderAgain) {
-    setState({
-      value: newValue,
-    });
-  }
-};

package/src/utility/others.tsx

@@ -1,53 +0,0 @@
-
-// type ReduxError = {
-//   error: any;
-// };
-
-import type { List as ImmutableList, Map as ImmutableMap } from "immutable";
-import React from "react";
-
-type PropsType = {
-  // Define your props type here
-  [key: string]: undefined | any;
-};
-
-export const
-  propsAreEqualCreator = <T extends PropsType>(objects :  (keyof T)[], primitives :  (keyof T)[]) => (prevProps : T, nextProps : T) => {
-    const
-      result = [
-        ...objects.map((field : any) => (
-          JSON.stringify(prevProps[field]) === JSON.stringify(nextProps[field])
-        )),
-        ...primitives.map((field: any) => prevProps[field] === nextProps[field]),
-      ].
-        filter((current) => current);
-
-    return result.length === (objects.length + primitives.length);
-  },
-  getDateSortNumber = (item: string) => Number(new Date(item).getTime()),
-  isAdministratorAccount = (current: number) => current === 0,
-  createModal = (modalType: string, modalProps?: any) => ({
-    type    : "SHOW_MODAL",
-    payload : {
-      modalType,
-      modalProps,
-    },
-  }),
-  noError = "",
-  rowsPerLoad = 50,
-  nothingFetched = -1,
-  removeID = (payload: ImmutableMap<string, any>) => (list: ImmutableList<string>) => (
-    list.delete(list.findIndex((current: string) => current === String(payload.get("ID"))))
-  ),
-  addID = (payload: ImmutableMap<string, any>) => (
-    (list: ImmutableList<string>) => list.push(String(payload.get("ID")))
-  ),
-  delay = () => (new Promise((resolve) => {
-    setTimeout(resolve);
-  }) as Promise<any>),
-  showCheck = (value: boolean) => value ? <i className="fa fa-check text-success" /> : null,
-  tryToCloseModalDefault = (cb?: () => any) => {
-    if (typeof cb === "function") {
-      cb();
-    }
-  };

package/src/utility/strings.test.ts

@@ -1,123 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { firstToUppercase, toLower, toTitle, toUpper } from "./strings";
-
-// toTitle
-(() => {
-  describe("Test toTitle", () => {
-    const tests = [
-      {
-        input  : "",
-        output : "",
-      }, {
-        input  : "cosovei",
-        output : "Cosovei",
-      }, {
-        input  : "simona cosovei",
-        output : "Simona Cosovei",
-      }, {
-        input  : "ștefănică țepeș",
-        output : "Ștefănică Țepeș",
-      }, {
-        input  : "this is 4 long name 5",
-        output : "This Is 4 Long Name 5",
-      },
-    ];
-
-    for (const {
-      input,
-      output,
-    } of tests) {
-      describe(`Given the raw string "${input}"`, () => {
-        test(`should be transformed to "${output}"`, () => {
-          expect(toTitle(input)).toEqual(output);
-        });
-      });
-    }
-  });
-})();
-
-// firstToUppercase
-(() => {
-  describe("Test firstToUppercase", () => {
-    const tests = [
-      {
-        input  : "",
-        output : "",
-      }, {
-        input  : "sima",
-        output : "Sima",
-      }, {
-        input  : "Simona Cosovei",
-        output : "Simona Cosovei",
-      }, {
-        input  : "this is 4 long name 5",
-        output : "This is 4 long name 5",
-      },
-    ];
-
-    for (const {
-      input,
-      output,
-    } of tests) {
-      describe(`given "${input}"`, () => {
-        test(`should be transformed to "${output}"`, () => {
-          expect(firstToUppercase(input)).toEqual(output);
-        });
-      });
-    }
-  });
-})();
-
-// toUpper
-(() => {
-  const tests = [
-    {
-      input  : "",
-      output : "",
-    }, {
-      input  : "sima",
-      output : "SIMA",
-    }, {
-      input  : "this is 4 long name 5",
-      output : "THIS IS 4 LONG NAME 5",
-    },
-  ];
-
-  for (const {
-    input,
-    output,
-  } of tests) {
-    describe(`given "${input}"`, () => {
-      test(`should be transformed to "${output}"`, () => {
-        expect(toUpper(input)).toEqual(output);
-      });
-    });
-  }
-})();
-
-// toLower
-(() => {
-  const tests = [
-    {
-      input  : "",
-      output : "",
-    }, {
-      input  : "siMa",
-      output : "sima",
-    }, {
-      input  : "This is 4 long Name 5",
-      output : "this is 4 long name 5",
-    },
-  ];
-
-  for (const {
-    input,
-    output,
-  } of tests) {
-    describe(`given "${input}"`, () => {
-      test(`should be transformed to "${output}"`, () => {
-        expect(toLower(input)).toEqual(output);
-      });
-    });
-  }
-})();

package/src/utility/strings.ts

@@ -1,22 +0,0 @@
-export const toTitle = (str: string): string => {
-  const transform = (txt: string): string => {
-    const firstPart = txt.charAt(0).toUpperCase(),
-      secondPart = txt.substr(1).toLowerCase();
-
-    return `${firstPart}${secondPart}`;
-  };
-
-  return str.replace(/\S+/gu, transform);
-};
-// this is an example ---> This is an example
-export const firstToUppercase = (str: string): string => {
-  const firstPart = str.charAt(0).toUpperCase(),
-    secondPart = str.slice(1);
-
-  return `${firstPart}${secondPart}`;
-};
-
-// This is ---> THIS IS
-export const toUpper = (str: string): string => String(str ? str : "").toUpperCase();
-// This is ---> this is
-export const toLower = (str: string): string => String(str ? str : "").toLowerCase();

package/src/utility/uuid.ts

@@ -1,30 +0,0 @@
-/* eslint-disable no-magic-numbers */
-const 
-  generatedUUIDs = new Set(),
-  generateUUIDv4 = () => {
-    let uuid = "";
-    const HEX_BASE = 16,
-      HEX_LENGTH = 16,
-      UUID_LENGTH = 32,
-      UUID_SECTIONS = [8, 12, 16, 20];
-
-    for (let index = 0; index < UUID_LENGTH; index+=1) {
-      if (UUID_SECTIONS.includes(index)) {
-        uuid += "-";
-      }
-      uuid += Math.floor(Math.random() * HEX_BASE).toString(HEX_LENGTH);
-    }
-    return uuid;
-  };
-
-export const generateUniqueUUIDv4 = () => {
-  let uuid =generateUUIDv4();
-  
-  while (generatedUUIDs.has(uuid)) {
-    uuid =generateUUIDv4();
-  }
-
-  generatedUUIDs.add(uuid);
-
-  return uuid;
-};

package/src/utility/validation/common.ts

@@ -1,255 +0,0 @@
-/* eslint-disable no-undefined */
-
-import { toNumeric } from "../";
-import { words } from "../words";
-import { isValidDateStamp, isValidEmail } from "./validate";
-
-import {
-  Checker, CheckerWithOptions, ComponentsOfNumberVerification,
-  ComponentsOfStringTenseVerification, ComponentsOfStringVerification, FloatOptions,
-  MessageOption, NumberRange, OptionalOption, StringOptions,
-} from "./types";
-
-export const 
-  parseNumericExceptBlank = (value: any) => value === "" ? "" : toNumeric(value);
-
-const
-  isInt = (value : number) => (
-    !isNaN(value) &&
-    parseInt(String(value), 10) === value &&
-    !isNaN(parseInt(String(value), 10))
-  ),
-  // eslint-disable-next-line complexity
-  validateNumberRange = ({ min, max, value, integer }: NumberRange) => {
-    if (typeof value !== "number") {
-      return false;
-    }
-
-    const
-      numeric = Number(value),
-      hasMin = typeof min === "number",
-      hasMax = typeof max === "number",
-      isInteger = isInt(value),
-      parsedValue = parseFloat(value);
-
-    return (
-      (typeof value !== "undefined") &&
-        (value !== "") &&
-        !isNaN(value) &&
-        (!integer || (integer && isInteger)) &&
-        (
-          (
-            integer && (
-              (!hasMin || (typeof min === "number" && numeric >= min)) &&
-              (!hasMax || (typeof max === "number" && numeric <= max))
-            )
-          ) ||
-          (
-            !integer && (
-              (!hasMin || (typeof min === "number" && parsedValue >= min)) &&
-              (!hasMax || (typeof max === "number" && parsedValue <= max))
-            )
-          )
-
-        )
-    );
-  },
-  getNumberRangeError = ({ min, max, integer } : ComponentsOfNumberVerification) => {
-    const
-      minTense = typeof min === "number" ? words.getNumberTense(min) : "",
-      maxTense = typeof max === "number" ? words.getNumberTense(max) : "",
-      range = (
-        (typeof min === "number" && typeof max === "number") ? (
-          ` ${words.NumberBetween} ${minTense} ${words.NumberAnd} ${maxTense}`
-        ) : (
-          typeof max === "number" ? ` ${words.NumberUpTo} ${maxTense}` : (
-            typeof min === "number" ? ` ${words.NumberGreaterThan} ${minTense}` : ""
-          )
-        )
-      );
-
-    return `${words.NumberMustBe} ${integer ? words.NumberInteger : words.NumberFloat} ${range}`;
-  },
-  getStringTense = ({ min, max, what } : ComponentsOfStringTenseVerification) => {
-    const
-      maxTense = max ? words.getNumberTense(max) : "",
-      minTense = min ? words.getNumberTense(min) : "",
-      isBetween = (typeof max === "number" && typeof min === "number"),
-      rangeError = isBetween ? `${words.NumberBetween} ${minTense} ${words.NumberAnd} ${maxTense}` : (
-        typeof max === "number" ? `${words.NumberUpTo} ${maxTense}` : (
-          typeof min === "number" ? `${words.NumberGreaterThan} ${minTense}` : ""
-        )
-      );
-
-    return `${what} ${words.Has} ${rangeError} ${words.Chars}`;
-  },
-  validateStringRange = ({ min, max, value } : ComponentsOfStringVerification) => {
-    if (typeof value !== "string") {
-      return false;
-    }
-
-    const
-      length = typeof value === "undefined" ? 0 : value.length,
-      hasMin = typeof min === "number",
-      hasMax = typeof max === "number";
-
-    return (
-      (!hasMin || (typeof min === "number" && length >= min)) &&
-       (!hasMax || (typeof max === "number" && length <= max)
-       )
-    );
-  };
-
-// ----------- Checkers
-
-export const
-  validateEmail : CheckerWithOptions<OptionalOption> = ({ optional }) => (raw : string) => {
-    const
-      value = typeof raw === "string" ? String(raw).trim() : raw,
-      notValid = (
-        optional && (
-          typeof value !== "undefined" && value !== "" && !isValidEmail(value)
-        )
-      ) || (
-        !optional && (
-          typeof value === "undefined" || !isValidEmail(value)
-        )
-      ),
-      error = notValid ? words.EnterValidEmail : undefined;
-
-    return error;
-  },
-  validateOptionalDate : Checker = (value : string) => {
-    const
-      notValid = !(
-        typeof value === "undefined" || value === "" || value === null || (
-          isValidDateStamp(value)
-        )
-      ),
-      error = notValid ? words.EnterValidDate : undefined;
-
-    return error;
-  },
-  validateDate : Checker = (value : string) => {
-    const
-      notValid = !(
-        (typeof value !== "undefined") && isValidDateStamp(value)
-      ),
-      error = notValid ? words.EnterValidDate : undefined;
-
-    return error;
-  },
-  validateFloat : CheckerWithOptions<FloatOptions> = (props) => (value) => {
-    const { min, max, optional, integer } = props,
-
-      whenOptional = optional && !(
-        typeof value === "undefined" || value === null || (
-          validateNumberRange({
-            min,
-            max,
-            value,
-            integer,
-          })
-        )
-      ),
-      whenRequired = !optional && !(
-        (typeof value !== "undefined" && value !== null) && validateNumberRange({
-          min,
-          max,
-          value,
-          integer,
-        })
-      ),
-      notValid = whenOptional || whenRequired;
-
-
-    if (notValid) {
-      return getNumberRangeError({
-        min,
-        max,
-        integer,
-      });
-    }
-
-    return undefined;
-  },
-  validateString : CheckerWithOptions<StringOptions> = (props) => (value) => {
-    const { what = words.TheField, min, max, optional } = props,
-
-      whenOptional = optional && !(
-        typeof value === "undefined" || value === null || (
-          validateStringRange({
-            min,
-            max,
-            value,
-          })
-        )
-      ),
-      whenRequired = !optional && !(
-        (typeof value !== "undefined" && value !== null) && validateStringRange({
-          min,
-          max,
-          value,
-        })
-      ),
-      notValid = whenOptional || whenRequired;
-
-    if (notValid) {
-      return getStringTense({
-        min,
-        max,
-        what,
-      });
-    }
-
-    return undefined;
-  },
-  validateSelect : CheckerWithOptions<MessageOption> = ({ message }) => (value) => {
-    const
-      notValid = (
-        (typeof value === "undefined") || value === null || value === ""
-      ),
-      error = notValid ? (typeof message === "undefined" ? words.PleaseSelect : message) : undefined;
-
-    return error;
-  },
-  validateNumericSelect = (value : any) => (value === "" || value === 0) ? words.PleaseSelect : undefined,
-  validateID : CheckerWithOptions<MessageOption> = ({ message }) => (value) => {
-    const
-      notValid = !(
-        typeof value === "number" && !isNaN(value)
-      ),
-      error = notValid ? (typeof message === "undefined" ? words.PleaseSelect : message) : undefined;
-
-    return error;
-  },
-  validateCaptchaSolution : Checker = (value : string) => {
-    const
-      pattern = /^\d{6}$/u,
-      notValid = (
-        typeof value !== "undefined" && !pattern.test(value)
-      ),
-      error = notValid ? words.Has6Digits : undefined;
-
-    return error;
-  },
-  validateResetToken : Checker = (value : string) => {
-    const
-      tokenSize = 64,
-      notValid = (
-        typeof value === "undefined" ||
-                                                        String(value).length !== tokenSize
-      ),
-      error = notValid ? words.CodeNotValid : undefined;
-
-    return error;
-  },
-  validateHumanName : Checker = validateString({
-    min : 3,
-    max : 40,
-  }),
-  validatePassword : Checker = validateString({
-    min : 6,
-    max : 25,
-  });
-

package/src/utility/validation/index.ts

@@ -1,24 +0,0 @@
-import { Checkers, Errors } from "./types";
-
-export * from "./common";
-export * from "./specific";
-export * from "./validate";
-
-
-export const extractErrorsFromCheckers = (checkers: Checkers) => (values: any) => {
-  const errors : Errors = {};
-
-  for (const field in checkers) {
-    // eslint-disable-next-line prefer-object-has-own
-    if (Object.prototype.hasOwnProperty.call(checkers, field) && typeof field === "string") {
-      const checker = checkers[field],
-        error = checker(values[field], values, checkers);
-
-      if (typeof error !== "undefined") {
-        errors[field] = error;
-      }
-    }
-  }
-
-  return errors;
-};

package/src/utility/validation/specific.ts

@@ -1,18 +0,0 @@
-import { words } from "../words";
-import { validateFloat } from "./common";
-
-export const
-  validateDay = validateFloat({
-    min     : 1,
-    max     : 31,
-    integer : true,
-  }),
-  validateChecked = (value : string) => {
-    const
-      notValid = (
-        typeof value !== "boolean" || value !== true
-      );
-
-    // eslint-disable-next-line no-undefined
-    return notValid ? words.MustAgree : undefined;
-  };

package/src/utility/validation/types.ts

@@ -1,53 +0,0 @@
-export type ErrorMessage = string | undefined;
-
-export type Checker = (value : string, values? : any, checkers? : Checkers) => ErrorMessage;
-
-export type ComponentsOfStringVerification = {
-  max?: number;
-  min?: number;
-  value?: string;
-}
-
-export type ComponentsOfStringTenseVerification = {
-  max?: number;
-  min?: number;
-  what: string;
-}
-
-export type ComponentsOfNumberVerification = {
-  max?: number;
-  min?: number;
-  integer?: boolean;
-}
-
-export type NumberRange = ComponentsOfNumberVerification & {
-  value: string;
-}
-export type StringOptions = {
-  min?: number;
-  max?: number;
-  what?: string;
-  optional?: boolean;
-};
-
-export type FloatOptions = ComponentsOfNumberVerification & {
-  optional?: boolean;
-};
-
-export type OptionalOption = {
-  optional: boolean;
-}
-
-export type CheckerWithOptions<Options> = (options : Options) => Checker;
-
-export type Checkers = {
-  [key : string] : Checker;
-}
-
-export type Errors = {
-  [key : string] : ErrorMessage;
-}
-
-export type MessageOption = {
-  message?: string;
-}