codeforlife 2.6.1

package/src/utils/form.ts

@@ -0,0 +1,153 @@
+import type { TypedMutationTrigger } from "@reduxjs/toolkit/query/react"
+import type { FieldValidator, FormikHelpers } from "formik"
+import { ValidationError, type Schema, type ValidateOptions } from "yup"
+
+import { excludeKeyPaths } from "./general"
+
+export type FormValues = Record<string, any>
+
+export function isFormError(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "status" in error &&
+    error.status === 400 &&
+    "data" in error &&
+    typeof error.data === "object" &&
+    error.data !== null
+  )
+}
+
+export function setFormErrors(
+  error: unknown,
+  setErrors: (errors: object) => void,
+): void {
+  if (!isFormError(error)) throw error
+
+  const data = Object.fromEntries(
+    Object.entries((error as { data: object }).data).map(([field, errors]) => {
+      if (Array.isArray(errors)) errors = errors.join(". ")
+      return [field, errors]
+    }),
+  )
+
+  setErrors(data)
+}
+
+export type SubmitFormOptions<
+  Values extends FormValues,
+  QueryArg extends FormValues,
+  ResultType,
+> = Partial<{
+  exclude: string[]
+  then: (
+    result: ResultType,
+    values: Values,
+    helpers: FormikHelpers<Values>,
+  ) => void
+  catch: (
+    error: unknown,
+    values: Values,
+    helpers: FormikHelpers<Values>,
+  ) => void
+  finally: (values: Values, helpers: FormikHelpers<Values>) => void
+}> &
+  (Values extends QueryArg
+    ? { clean?: (values: Values) => QueryArg }
+    : { clean: (values: Values) => QueryArg })
+
+export type SubmitFormHandler<Values extends FormValues> = (
+  values: Values,
+  helpers: FormikHelpers<Values>,
+) => void | Promise<any>
+
+export function submitForm<
+  Values extends QueryArg,
+  QueryArg extends FormValues,
+  ResultType,
+>(
+  trigger: TypedMutationTrigger<ResultType, QueryArg, any>,
+  options?: SubmitFormOptions<Values, QueryArg, ResultType>,
+): SubmitFormHandler<Values>
+
+export function submitForm<
+  Values extends FormValues,
+  QueryArg extends FormValues,
+  ResultType,
+>(
+  trigger: TypedMutationTrigger<ResultType, QueryArg, any>,
+  options: SubmitFormOptions<Values, QueryArg, ResultType>,
+): SubmitFormHandler<Values>
+
+export function submitForm<
+  Values extends FormValues,
+  QueryArg extends FormValues,
+  ResultType,
+>(
+  trigger: TypedMutationTrigger<ResultType, QueryArg, any>,
+  options?: SubmitFormOptions<Values, QueryArg, ResultType>,
+): SubmitFormHandler<Values> {
+  const { exclude, then, catch: _catch, finally: _finally } = options || {}
+
+  return (values, helpers) => {
+    let arg =
+      options && options.clean
+        ? options.clean(values as QueryArg & FormValues)
+        : (values as unknown as QueryArg)
+
+    if (exclude) arg = excludeKeyPaths(arg, exclude)
+
+    trigger(arg)
+      .unwrap()
+      .then(result => {
+        if (then) then(result, values, helpers)
+      })
+      .catch(error => {
+        if (_catch) _catch(error, values, helpers)
+        setFormErrors(error, helpers.setErrors)
+      })
+      .finally(() => {
+        if (_finally) _finally(values, helpers)
+      })
+  }
+}
+
+export function schemaToFieldValidator(
+  schema: Schema,
+  options?: ValidateOptions,
+): FieldValidator {
+  return async value => {
+    try {
+      await schema.validate(value, options)
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        return error.errors.join(". ")
+      }
+
+      throw error
+    }
+  }
+}
+
+// Checking if individual fields are dirty is not currently supported.
+// https://github.com/jaredpalmer/formik/issues/1421
+export function getDirty<
+  Values extends FormValues,
+  Names extends Array<keyof Values>,
+>(
+  values: Values,
+  initialValues: Values,
+  names: Names,
+): Record<Names[number], boolean> {
+  return Object.fromEntries(
+    names.map(name => [name, isDirty(values, initialValues, name)]),
+  ) as Record<Names[number], boolean>
+}
+
+export function isDirty<Values extends FormValues, Name extends keyof Values>(
+  values: Values,
+  initialValues: Values,
+  name: Name,
+): boolean {
+  return values[name] !== initialValues[name]
+}

package/src/utils/general.test.ts

@@ -0,0 +1,42 @@
+import { excludeKeyPaths, getNestedProperty, withKeyPaths } from "./general"
+
+// getNestedProperty
+
+const PERSON = { father: { father: { name: "John" } } }
+
+test("get a nested property with dot notation", () => {
+  const name = getNestedProperty(PERSON, "father.father.name")
+
+  expect(name).equal("John")
+})
+
+test("get a nested property with string array", () => {
+  const name = getNestedProperty(PERSON, ["father", "father", "name"])
+
+  expect(name).equal("John")
+})
+
+test("get a nested property that doesn't exist", () => {
+  const name = getNestedProperty(PERSON, "mother.mother.name")
+
+  expect(name).toBeUndefined()
+})
+
+// withKeyPaths
+
+test("get the paths of nested keys", () => {
+  const obj = withKeyPaths({ a: 1, b: { c: 2, d: { e: 3 } } })
+
+  expect(obj).toMatchObject({ a: 1, b: { "b.c": 2, "b.d": { "b.d.e": 3 } } })
+})
+
+// excludeKeyPaths
+
+test("exclude nested keys by their path", () => {
+  const obj = excludeKeyPaths({ a: 1, b: { c: 2, d: { e: 3 } } }, [
+    "b.c",
+    "b.d.e",
+  ])
+
+  expect(obj).toMatchObject({ a: 1, b: { d: {} } })
+})

package/src/utils/general.ts

@@ -0,0 +1,498 @@
+export type Required<T, K extends keyof T> = { [P in K]-?: T[P] }
+export type Optional<T, K extends keyof T> = Partial<Pick<T, K>>
+
+export function openInNewTab(url: string, target = "_blank"): void {
+  window.open(url, target)
+}
+
+export function wrap(
+  newFn: {
+    before?: (...args: any[]) => void
+    after?: (...args: any[]) => void
+  },
+  fn?: (...args: any[]) => any,
+): (...args: any[]) => any {
+  return (...args) => {
+    if (newFn.before !== undefined) {
+      newFn.before(...args)
+    }
+    let value
+    if (fn !== undefined) {
+      value = fn(...args)
+    }
+    if (newFn.after !== undefined) {
+      newFn.after(...args)
+    }
+    return value
+  }
+}
+
+export function snakeCaseToCamelCase(obj: Record<string, any>): void {
+  Object.entries(obj).forEach(([snakeKey, value]) => {
+    if (typeof value === "object") snakeCaseToCamelCase(value)
+
+    const camelKey = snakeKey.replace(/_+[a-z]/g, _char =>
+      _char[_char.length - 1].toUpperCase(),
+    )
+
+    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+    delete obj[snakeKey]
+    obj[camelKey] = value
+  })
+}
+
+export function camelCaseToSnakeCase(obj: Record<string, any>): void {
+  Object.entries(obj).forEach(([camelKey, value]) => {
+    if (typeof value === "object") camelCaseToSnakeCase(value)
+
+    const snakeKey = camelKey.replace(
+      /[A-Z]/g,
+      char => `_${char.toLowerCase()}`,
+    )
+
+    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+    delete obj[camelKey]
+    obj[snakeKey] = value
+  })
+}
+
+export const MIN_DATE = new Date(0, 0, 0)
+
+export const COUNTRY_ISO_CODES = [
+  "AF",
+  "AX",
+  "AL",
+  "DZ",
+  "AS",
+  "AD",
+  "AO",
+  "AI",
+  "AQ",
+  "AG",
+  "AR",
+  "AM",
+  "AW",
+  "AU",
+  "AT",
+  "AZ",
+  "BS",
+  "BH",
+  "BD",
+  "BB",
+  "BY",
+  "BE",
+  "BZ",
+  "BJ",
+  "BM",
+  "BT",
+  "BO",
+  "BQ",
+  "BA",
+  "BW",
+  "BV",
+  "BR",
+  "IO",
+  "BN",
+  "BG",
+  "BF",
+  "BI",
+  "KH",
+  "CM",
+  "CA",
+  "CV",
+  "KY",
+  "CF",
+  "TD",
+  "CL",
+  "CN",
+  "CX",
+  "CC",
+  "CO",
+  "KM",
+  "CG",
+  "CD",
+  "CK",
+  "CR",
+  "CI",
+  "HR",
+  "CU",
+  "CW",
+  "CY",
+  "CZ",
+  "DK",
+  "DJ",
+  "DM",
+  "DO",
+  "EC",
+  "EG",
+  "SV",
+  "GQ",
+  "ER",
+  "EE",
+  "ET",
+  "FK",
+  "FO",
+  "FJ",
+  "FI",
+  "FR",
+  "GF",
+  "PF",
+  "TF",
+  "GA",
+  "GM",
+  "GE",
+  "DE",
+  "GH",
+  "GI",
+  "GR",
+  "GL",
+  "GD",
+  "GP",
+  "GU",
+  "GT",
+  "GG",
+  "GN",
+  "GW",
+  "GY",
+  "HT",
+  "HM",
+  "VA",
+  "HN",
+  "HK",
+  "HU",
+  "IS",
+  "IN",
+  "ID",
+  "IR",
+  "IQ",
+  "IE",
+  "IM",
+  "IL",
+  "IT",
+  "JM",
+  "JP",
+  "JE",
+  "JO",
+  "KZ",
+  "KE",
+  "KI",
+  "KP",
+  "KR",
+  "KW",
+  "KG",
+  "LA",
+  "LV",
+  "LB",
+  "LS",
+  "LR",
+  "LY",
+  "LI",
+  "LT",
+  "LU",
+  "MO",
+  "MK",
+  "MG",
+  "MW",
+  "MY",
+  "MV",
+  "ML",
+  "MT",
+  "MH",
+  "MQ",
+  "MR",
+  "MU",
+  "YT",
+  "MX",
+  "FM",
+  "MD",
+  "MC",
+  "MN",
+  "ME",
+  "MS",
+  "MA",
+  "MZ",
+  "MM",
+  "NA",
+  "NR",
+  "NP",
+  "NL",
+  "NC",
+  "NZ",
+  "NI",
+  "NE",
+  "NG",
+  "NU",
+  "NF",
+  "MP",
+  "NO",
+  "OM",
+  "PK",
+  "PW",
+  "PS",
+  "PA",
+  "PG",
+  "PY",
+  "PE",
+  "PH",
+  "PN",
+  "PL",
+  "PT",
+  "PR",
+  "QA",
+  "RE",
+  "RO",
+  "RU",
+  "RW",
+  "BL",
+  "SH",
+  "KN",
+  "LC",
+  "MF",
+  "PM",
+  "VC",
+  "WS",
+  "SM",
+  "ST",
+  "SA",
+  "SN",
+  "RS",
+  "SC",
+  "SL",
+  "SG",
+  "SX",
+  "SK",
+  "SI",
+  "SB",
+  "SO",
+  "ZA",
+  "GS",
+  "SS",
+  "ES",
+  "LK",
+  "SD",
+  "SR",
+  "SJ",
+  "SZ",
+  "SE",
+  "CH",
+  "SY",
+  "TW",
+  "TJ",
+  "TZ",
+  "TH",
+  "TL",
+  "TG",
+  "TK",
+  "TO",
+  "TT",
+  "TN",
+  "TR",
+  "TM",
+  "TC",
+  "TV",
+  "UG",
+  "UA",
+  "AE",
+  "GB",
+  "US",
+  "UM",
+  "UY",
+  "UZ",
+  "VU",
+  "VE",
+  "VN",
+  "VG",
+  "VI",
+  "WF",
+  "EH",
+  "YE",
+  "ZM",
+  "ZW",
+] as const
+
+export type CountryIsoCodes = (typeof COUNTRY_ISO_CODES)[number]
+
+export const UK_COUNTIES = [
+  "Aberdeen City",
+  "Aberdeenshire",
+  "Angus",
+  "Argyll and Bute",
+  "Bedfordshire",
+  "Belfast",
+  "Belfast Greater",
+  "Berkshire",
+  "Blaenau Gwent",
+  "Bridgend",
+  "Buckinghamshire",
+  "Caerphilly",
+  "Cambridgeshire",
+  "Cardiff",
+  "Carmarthenshire",
+  "Ceredigion",
+  "Channel Islands",
+  "Cheshire",
+  "City of Edinburgh",
+  "Clackmannanshire",
+  "Conwy",
+  "Cornwall",
+  "County Antrim",
+  "County Armagh",
+  "County Down",
+  "County Fermanagh",
+  "County Londonderry",
+  "County Tyrone",
+  "County of Bristol",
+  "Cumbria",
+  "Denbighshire",
+  "Derbyshire",
+  "Devon",
+  "Dorset",
+  "Dumfries and Galloway",
+  "Dunbartonshire",
+  "Dundee City",
+  "Durham",
+  "East Ayrshire",
+  "East Dunbartonshire",
+  "East Lothian",
+  "East Renfrewshire",
+  "East Riding of Yorkshire",
+  "East Sussex",
+  "Essex",
+  "Falkirk",
+  "Fife",
+  "Flintshire",
+  "Glasgow City",
+  "Gloucestershire",
+  "Greater London",
+  "Greater Manchester",
+  "Guernsey Channel Islands",
+  "Gwynedd",
+  "Hampshire",
+  "Hereford and Worcester",
+  "Herefordshire",
+  "Hertfordshire",
+  "Highland",
+  "Inverclyde",
+  "Inverness",
+  "Isle of Anglesey",
+  "Isle of Barra",
+  "Isle of Man",
+  "Isle of Wight",
+  "Jersey Channel Islands",
+  "Kent",
+  "Lancashire",
+  "Leicestershire",
+  "Lincolnshire",
+  "Merseyside",
+  "Merthyr Tydfil",
+  "Midlothian",
+  "Monmouthshire",
+  "Moray",
+  "Neath Port Talbot",
+  "Newport",
+  "Norfolk",
+  "North Ayrshire",
+  "North Lanarkshire",
+  "North Yorkshire",
+  "Northamptonshire",
+  "Northumberland",
+  "Nottinghamshire",
+  "Orkney",
+  "Orkney Islands",
+  "Oxfordshire",
+  "Pembrokeshire",
+  "Perth and Kinross",
+  "Powys",
+  "Renfrewshire",
+  "Rhondda Cynon Taff",
+  "Rutland",
+  "Scottish Borders",
+  "Shetland Islands",
+  "Shropshire",
+  "Somerset",
+  "South Ayrshire",
+  "South Lanarkshire",
+  "South Yorkshire",
+  "Staffordshire",
+  "Stirling",
+  "Suffolk",
+  "Surrey",
+  "Swansea",
+  "Torfaen",
+  "Tyne and Wear",
+  "Vale of Glamorgan",
+  "Warwickshire",
+  "West Dunbart",
+  "West Lothian",
+  "West Midlands",
+  "West Sussex",
+  "West Yorkshire",
+  "Western Isles",
+  "Wiltshire",
+  "Worcestershire",
+  "Wrexham",
+] as const
+
+export type UkCounties = (typeof UK_COUNTIES)[number]
+
+export function getNestedProperty(
+  obj: Record<string, any>,
+  dotPath: string | string[],
+): any {
+  if (typeof dotPath === "string") dotPath = dotPath.split(".")
+
+  let value: unknown = obj
+  for (let i = 0; i < dotPath.length; i++) {
+    value = (value as Record<string, any>)[dotPath[i]]
+    if (
+      i !== dotPath.length - 1 &&
+      (typeof value !== "object" || value === null)
+    )
+      return
+  }
+
+  return value
+}
+
+export function withKeyPaths(obj: object, delimiter: string = "."): object {
+  function _withKeyPaths(obj: object, path: string[]) {
+    return Object.fromEntries(
+      Object.entries(obj).map(([key, value]) => {
+        const _path = [...path, key]
+
+        if (typeof value === "object") value = _withKeyPaths(value, _path)
+
+        return [_path.join(delimiter), value]
+      }),
+    )
+  }
+
+  return _withKeyPaths(obj, [])
+}
+
+export function excludeKeyPaths(
+  obj: object,
+  exclude: string[],
+  delimiter: string = ".",
+): any {
+  function _excludeKeyPaths(obj: object, path: string[]) {
+    return Object.fromEntries(
+      Object.entries(obj)
+        .map(([key, value]: [string, unknown]) => {
+          const _path = [...path, key]
+
+          if (
+            typeof value === "object" &&
+            value !== null &&
+            !(value instanceof Date)
+          )
+            value = _excludeKeyPaths(value, _path)
+
+          return exclude.includes(_path.join(delimiter)) ? [] : [key, value]
+        })
+        .filter(entry => entry.length),
+    )
+  }
+
+  return exclude.length ? _excludeKeyPaths(obj, []) : obj
+}