codeforlife 2.8.2 → 2.9.0

package/src/utils/auth.ts

@@ -1,78 +0,0 @@
-import Cookies from "js-cookie"
-
-import {
-  CSRF_COOKIE_NAME,
-  SESSION_COOKIE_NAME,
-  SESSION_METADATA_COOKIE_NAME,
-} from "../settings"
-import { generateSecureRandomString } from "./general"
-
-export function logout() {
-  Cookies.remove(SESSION_COOKIE_NAME)
-  Cookies.remove(SESSION_METADATA_COOKIE_NAME)
-}
-
-// https://docs.djangoproject.com/en/3.2/ref/csrf/
-export function getCsrfCookie() {
-  return Cookies.get(CSRF_COOKIE_NAME)
-}
-
-export function makeOAuth2StorageKey(provider: string, key: string) {
-  return `oauth2.${provider}.${key}`
-}
-
-export const OAUTH2_CODE_CHALLENGE_METHODS = ["S256"] as const
-
-export type OAuth2CodeChallengeMethods =
-  (typeof OAUTH2_CODE_CHALLENGE_METHODS)[number]
-
-export const OAUTH2_CODE_CHALLENGE_LENGTHS = [
-  43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
-  62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
-  81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
-  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
-  115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128,
-] as const
-
-export type OAuth2CodeChallengeLengths =
-  (typeof OAUTH2_CODE_CHALLENGE_LENGTHS)[number]
-
-export type OAuth2RequestCodeUrlSearchParams = {
-  client_id: string
-  redirect_uri: string
-  scope: string
-  response_type: string
-  access_type: string
-  prompt?: string
-  state: string
-  code_challenge: string
-  code_challenge_method: string
-}
-
-export type OAuth2ReceiveCodeUrlSearchParams = {
-  code: string
-  state: string
-}
-
-export type OAuth2CodeChallenge = {
-  verifier: string
-  challenge: string
-  method: OAuth2CodeChallengeMethods
-}
-
-export async function generateOAuth2CodeChallenge(
-  length: OAuth2CodeChallengeLengths,
-): Promise<OAuth2CodeChallenge> {
-  const verifier = generateSecureRandomString(length)
-  const data = new TextEncoder().encode(verifier)
-  const digest = await window.crypto.subtle.digest("SHA-256", data)
-
-  return {
-    verifier,
-    challenge: btoa(String.fromCharCode(...new Uint8Array(digest)))
-      .replace(/\+/g, "-")
-      .replace(/\//g, "_")
-      .replace(/=+$/, ""),
-    method: "S256",
-  }
-}

package/src/utils/form.test.ts

@@ -1,50 +0,0 @@
-import { getCleanNames, getDirty, isDirty } from "./form"
-
-const VALUES = {
-  name: { first: "Peter", last: "Parker" },
-}
-const INITIAL_VALUES: typeof VALUES = {
-  name: { first: "Peter", last: "Robbins" },
-}
-
-// isDirty
-
-test("value is dirty", () => {
-  const value = isDirty(VALUES, INITIAL_VALUES, "name.last")
-
-  expect(value).toBe(true)
-})
-
-test("value is clean", () => {
-  const value = isDirty(VALUES, INITIAL_VALUES, "name.first")
-
-  expect(value).toBe(false)
-})
-
-// getDirty
-
-test("get dirty values", () => {
-  const dirty = getDirty(VALUES, INITIAL_VALUES)
-
-  expect(dirty).toMatchObject({ "name.first": false, "name.last": true })
-})
-
-test("get subset of dirty values", () => {
-  const dirty = getDirty(VALUES, INITIAL_VALUES, ["name.first"])
-
-  expect(dirty).toMatchObject({ "name.first": false })
-})
-
-// getCleanNames
-
-test("get clean names", () => {
-  const cleanNames = getCleanNames(VALUES, INITIAL_VALUES)
-
-  expect(cleanNames).toMatchObject(["name.first"])
-})
-
-test("get subset of clean names", () => {
-  const cleanNames = getCleanNames(VALUES, INITIAL_VALUES, ["name.last"])
-
-  expect(cleanNames).toMatchObject([])
-})

package/src/utils/form.ts

@@ -1,193 +0,0 @@
-import type { FieldValidator, FormikHelpers } from "formik"
-import { type Schema, type ValidateOptions, ValidationError } from "yup"
-import type { TypedMutationTrigger } from "@reduxjs/toolkit/query/react"
-
-import { excludeKeyPaths, getKeyPaths, getNestedProperty } 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[]
-  include: string[]
-  onlyDirtyValues: boolean
-  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>,
-  initialValues: Values,
-  options?: SubmitFormOptions<Values, QueryArg, ResultType>,
-): SubmitFormHandler<Values>
-
-export function submitForm<
-  Values extends FormValues,
-  QueryArg extends FormValues,
-  ResultType,
->(
-  trigger: TypedMutationTrigger<ResultType, QueryArg, any>,
-  initialValues: Values,
-  options: SubmitFormOptions<Values, QueryArg, ResultType>,
-): SubmitFormHandler<Values>
-
-export function submitForm<
-  Values extends FormValues,
-  QueryArg extends FormValues,
-  ResultType,
->(
-  trigger: TypedMutationTrigger<ResultType, QueryArg, any>,
-  initialValues: Values,
-  options?: SubmitFormOptions<Values, QueryArg, ResultType>,
-): SubmitFormHandler<Values> {
-  const {
-    include,
-    onlyDirtyValues = false,
-    then,
-    catch: _catch,
-    finally: _finally,
-  } = options || {}
-  let { exclude = [] } = options || {}
-
-  return (values, helpers) => {
-    let arg =
-      options && options.clean
-        ? options.clean(values as QueryArg & FormValues)
-        : (values as unknown as QueryArg)
-
-    if (onlyDirtyValues) {
-      exclude = [
-        ...exclude,
-        ...getCleanNames(values, initialValues).filter(
-          cleanName => !exclude.includes(cleanName),
-        ),
-      ]
-    }
-
-    if (include) exclude = exclude.filter(name => !include.includes(name))
-
-    if (exclude.length) arg = excludeKeyPaths(arg, exclude) as QueryArg
-
-    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>(
-  values: Values,
-  initialValues: Values,
-  names?: string[],
-): Record<string, boolean> {
-  if (!names) names = getKeyPaths(values)
-
-  return Object.fromEntries(
-    names.map(name => [name, isDirty(values, initialValues, name)]),
-  )
-}
-
-export function isDirty<Values extends FormValues>(
-  values: Values,
-  initialValues: Values,
-  name: string,
-): boolean {
-  const value: unknown = getNestedProperty(values, name)
-  const initialValue: unknown = getNestedProperty(initialValues, name)
-
-  return value !== initialValue
-}
-
-export function getCleanNames<Values extends FormValues>(
-  values: Values,
-  initialValues: Values,
-  names?: string[],
-): string[] {
-  return Object.entries(getDirty(values, initialValues, names))
-    .filter(
-      ([
-        _, // eslint-disable-line @typescript-eslint/no-unused-vars
-        isDirty,
-      ]) => !isDirty,
-    )
-    .map(([name]) => name)
-}

package/src/utils/general.test.ts

@@ -1,55 +0,0 @@
-import {
-  excludeKeyPaths,
-  getKeyPaths,
-  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") as string
-
-  expect(name).toEqual("John")
-})
-
-test("get a nested property with string array", () => {
-  const name = getNestedProperty(PERSON, ["father", "father", "name"]) as string
-
-  expect(name).toEqual("John")
-})
-
-test("get a nested property that doesn't exist", () => {
-  const name = getNestedProperty(PERSON, "mother.mother.name") as undefined
-
-  expect(name).toBeUndefined()
-})
-
-// withKeyPaths
-
-test("set 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 } } })
-})
-
-// getKeyPaths
-
-test("get the paths of nested keys", () => {
-  const keyPaths = getKeyPaths({ a: 1, b: { c: 2, d: { e: 3 } } })
-
-  expect(keyPaths).toMatchObject(["a", "b", "b.c", "b.d", "b.d.e"])
-})
-
-// excludeKeyPaths
-
-test("exclude nested keys by their path", () => {
-  const obj = excludeKeyPaths({ a: 1, b: { c: 2, d: { e: 3 } } }, [
-    "b.c",
-    "b.d.e",
-  ]) as object
-
-  expect(obj).toMatchObject({ a: 1, b: { d: {} } })
-})

package/src/utils/router.test.ts

@@ -1,156 +0,0 @@
-import { type Parameters, type Path, path as p } from "./router"
-
-const m = <SubMatches extends Record<string, Path>>(
-  _: string,
-  __: string | Parameters,
-  subMatches: SubMatches = {} as SubMatches,
-) => ({ _, __, ...subMatches })
-
-function testPaths({
-  name,
-  paths,
-  match,
-}: {
-  name: string
-  paths: Path
-  match: Path
-}) {
-  test(name, () => {
-    expect(paths).toMatchObject(match)
-  })
-}
-
-testPaths({
-  name: "no nested paths",
-  paths: p(""),
-  match: m("/", ""),
-})
-
-testPaths({
-  name: "nested paths",
-  paths: p("", {
-    a: p("/a", {
-      b: p("/b"),
-    }),
-  }),
-  match: m("/", "", {
-    a: m("/a", "/a"),
-  }),
-})
-
-testPaths({
-  name: "one param",
-  paths: p("", {
-    person: p("/person", {
-      name: p("/:name", {
-        sam: p({ name: "samantha" }),
-      }),
-    }),
-  }),
-  match: m("/", "", {
-    person: m("/person", "/person", {
-      name: m("/person/:name", "/:name", {
-        sam: m("/person/samantha", { name: "samantha" }),
-      }),
-    }),
-  }),
-})
-
-testPaths({
-  name: "multiple params",
-  paths: p("", {
-    hero: p("/hero", {
-      firstAndLastName: p("/:firstName/:lastName", {
-        spiderMan: p(
-          { firstName: "peter", lastName: "parker" },
-          {
-            mainVillain: p("/green-goblin"),
-          },
-        ),
-      }),
-    }),
-  }),
-  match: m("/", "", {
-    hero: m("/hero", "/hero", {
-      firstAndLastName: m(
-        "/hero/:firstName/:lastName",
-        "/:firstName/:lastName",
-        {
-          spiderMan: m(
-            "/hero/peter/parker",
-            { firstName: "peter", lastName: "parker" },
-            {
-              mainVillain: m(
-                "/hero/peter/parker/green-goblin",
-                "/green-goblin",
-              ),
-            },
-          ),
-        },
-      ),
-    }),
-  }),
-})
-
-testPaths({
-  name: "nested params",
-  paths: p("", {
-    hero: p("/hero", {
-      firstName: p("/:firstName", {
-        spiderMan: p({ firstName: "peter" }),
-        lastName: p("/:lastName?", {
-          superMan: p(
-            { firstName: "clark" },
-            {
-              superMan: p({ lastName: "kent" }),
-            },
-          ),
-        }),
-        batMan: p(
-          { firstName: "bruce" },
-          {
-            lastName: p("/:lastName", {
-              batMan: p(
-                { lastName: "wayne" },
-                {
-                  mainVillain: p("/joker"),
-                },
-              ),
-            }),
-          },
-        ),
-      }),
-    }),
-  }),
-  match: m("/", "", {
-    hero: m("/hero", "/hero", {
-      firstName: m("/hero/:firstName", "/:firstName", {
-        spiderMan: m("/hero/peter", { firstName: "peter" }),
-        lastName: m("/hero/:firstName/:lastName?", "/:lastName?", {
-          superMan: m(
-            "/hero/clark",
-            { firstName: "clark" },
-            {
-              superMan: m("/hero/clark/kent", { lastName: "kent" }),
-            },
-          ),
-        }),
-        batMan: m(
-          "/hero/bruce",
-          { firstName: "bruce" },
-          {
-            lastName: m("/hero/bruce/:lastName", "/:lastName", {
-              batMan: m(
-                "/hero/bruce/wayne",
-                { lastName: "wayne" },
-                {
-                  mainVillain: m("/hero/bruce/wayne/joker", "/joker"),
-                },
-              ),
-            }),
-          },
-        ),
-      }),
-    }),
-  }),
-})

package/src/utils/router.ts

@@ -1,67 +0,0 @@
-import {
-  type To,
-  type LinkProps as _LinkProps,
-  generatePath,
-} from "react-router-dom"
-
-import { type PageState } from "../components/page/Page"
-
-export type LinkProps<
-  Override extends "delta" | "to",
-  State extends Record<string, any> = Record<string, any>,
-> = Omit<_LinkProps, "to" | "state"> &
-  (Override extends "delta"
-    ? { to: number }
-    : { to: To; state?: State & Partial<PageState> })
-
-export type ReadOnly<T> = {
-  readonly [P in keyof T]: T[P]
-}
-
-export type Parameters = Record<string, string>
-
-export interface Path {
-  _: string
-  __: string | Parameters
-  [subpath: string]: string | Path | Parameters
-}
-
-export function path<Subpaths extends Record<string, Path>>(
-  _: string | Parameters,
-  subpaths: Subpaths = {} as Subpaths,
-): Path & Subpaths {
-  function updatePath(path: Path, root: boolean, params?: Parameters) {
-    if (typeof path.__ === "object") {
-      params = params ? { ...params, ...path.__ } : path.__
-    }
-
-    const _path = typeof _ === "string" && params ? generatePath(_, params) : _
-
-    Object.entries(path).forEach(([key, subpath]) => {
-      if (key !== "__") {
-        subpath = subpath as string | Path
-        if (typeof subpath === "string") {
-          if (typeof _path === "string" && (!root || key !== "_")) {
-            let __path = _path + subpath
-            if (__path.endsWith("/")) __path = __path.slice(0, -1)
-            path[key] = __path
-          }
-        } else {
-          updatePath(subpath, false, params)
-        }
-      }
-    })
-  }
-
-  const path = { ...subpaths, _: typeof _ === "string" ? _ : "", __: _ }
-  if (_ === "") {
-    path._ = "/"
-  } else {
-    updatePath(path, true)
-  }
-  return path
-}
-
-export function getParam(path: Path, key: string) {
-  return (path.__ as Parameters)[key]
-}