codeforlife 2.8.2 → 2.9.0

package/src/utils/schema.ts

@@ -1,290 +0,0 @@
-import {
-  type AnyObject,
-  type BooleanSchema,
-  type DateSchema,
-  type DefaultFromShape,
-  type Flags,
-  type InferType,
-  type MakePartial,
-  type NumberSchema,
-  type ObjectSchema,
-  type ObjectShape,
-  type Schema,
-  type StringSchema,
-  type TypeFromShape,
-  type ValidateOptions,
-  ValidationError,
-  number as YupNumber,
-  string as YupString,
-} from "yup"
-
-export type _<T> = T extends {}
-  ? {
-      [k in keyof T]: T[k]
-    }
-  : T
-
-export type MakeKeysOptional<T> = T extends AnyObject ? _<MakePartial<T>> : T
-
-export type ObjectFromShape<Shape extends ObjectShape> = MakeKeysOptional<
-  _<TypeFromShape<Shape, AnyObject>>
->
-
-export type ObjectSchemaFromShape<Shape extends ObjectShape> = ObjectSchema<
-  _<TypeFromShape<Shape, AnyObject>>,
-  AnyObject,
-  _<DefaultFromShape<Shape>>,
-  ""
->
-
-export type SchemaMap<
-  TType,
-  TContext = AnyObject,
-  TDefault = any,
-  TFlags extends Flags = "",
-> =
-  NonNullable<TType> extends string
-    ? StringSchema<
-        // @ts-expect-error type is fine
-        TType extends undefined ? TType | undefined : TType,
-        TContext,
-        TDefault,
-        TFlags
-      >
-    : NonNullable<TType> extends number
-      ? NumberSchema<
-          // @ts-expect-error type is fine
-          TType extends undefined ? TType | undefined : TType,
-          TContext,
-          TDefault,
-          TFlags
-        >
-      : NonNullable<TType> extends boolean
-        ? BooleanSchema<
-            // @ts-expect-error type is fine
-            TType extends undefined ? TType | undefined : TType,
-            TContext,
-            TDefault,
-            TFlags
-          >
-        : NonNullable<TType> extends Date
-          ? DateSchema<
-              // @ts-expect-error type is fine
-              TType extends undefined ? TType | undefined : TType,
-              TContext,
-              TDefault,
-              TFlags
-            >
-          : NonNullable<TType> extends object
-            ? ObjectSchema<
-                // @ts-expect-error type is fine
-                TType extends undefined ? TType | undefined : TType,
-                TContext,
-                TDefault,
-                TFlags
-              >
-            : Schema<TType, TContext, TDefault, TFlags>
-
-export function numericId(schema: NumberSchema = YupNumber()) {
-  return schema.min(1)
-}
-
-// -----------------------------------------------------------------------------
-// Limited Character Sets
-// -----------------------------------------------------------------------------
-
-export type MatchesCharSetOptions = Partial<{
-  schema: StringSchema
-  flags: string
-}>
-
-export function matchesCharSet(
-  charSet: string,
-  message: string,
-  options: MatchesCharSetOptions = {},
-) {
-  const { schema = YupString(), flags } = options
-
-  return schema.matches(new RegExp(`^[${charSet}]*$`, flags), message)
-}
-
-export type BuildCharSetOptions = MatchesCharSetOptions &
-  Partial<{ spaces: boolean; specialChars: string }>
-
-export function buildCharSet(
-  charSet: string,
-  description: string,
-  options: BuildCharSetOptions = {},
-) {
-  const { spaces = false, specialChars, ...matchesCharSetOptions } = options
-
-  let message = `can only contain: ${description}`
-
-  if (spaces) {
-    charSet += " "
-    message += ", spaces"
-  }
-  if (specialChars) {
-    charSet += specialChars
-    message += `, special characters (${specialChars})`
-  }
-
-  return matchesCharSet(charSet, message, matchesCharSetOptions)
-}
-
-export function buildUnicodeCharSet(
-  charSet: string,
-  description: string,
-  options: BuildCharSetOptions = {},
-) {
-  let { flags = "u" } = options
-
-  if (!flags.includes("u")) flags += "u"
-
-  return buildCharSet(charSet, description, { ...options, flags })
-}
-
-export function asciiAlphaString(options?: BuildCharSetOptions) {
-  return buildCharSet("a-zA-Z", "ASCII alpha characters (a-z, A-Z)", options)
-}
-
-export function lowercaseAsciiAlphaString(options?: BuildCharSetOptions) {
-  return buildCharSet("a-z", "lowercase ASCII alpha characters (a-z)", options)
-}
-
-export function uppercaseAsciiAlphaString(options?: BuildCharSetOptions) {
-  return buildCharSet("A-Z", "uppercase ASCII alpha characters (A-Z)", options)
-}
-
-export function asciiNumericString(options?: BuildCharSetOptions) {
-  return buildCharSet("0-9", "ASCII numbers (0-9)", options)
-}
-
-export function asciiAlphanumericString(options?: BuildCharSetOptions) {
-  return buildCharSet(
-    "a-zA-Z0-9",
-    "ASCII alphanumeric characters (a-z, A-Z, 0-9)",
-    options,
-  )
-}
-
-export function lowercaseAsciiAlphanumericString(
-  options?: BuildCharSetOptions,
-) {
-  return buildCharSet(
-    "a-z0-9",
-    "lowercase ASCII alphanumeric characters (a-z, 0-9)",
-    options,
-  )
-}
-
-export function uppercaseAsciiAlphanumericString(
-  options?: BuildCharSetOptions,
-) {
-  return buildCharSet(
-    "A-Z0-9",
-    "uppercase ASCII alphanumeric characters (A-Z, 0-9)",
-    options,
-  )
-}
-
-export function unicodeAlphaString(options?: BuildCharSetOptions) {
-  return buildUnicodeCharSet("\\p{L}", "unicode alpha characters", options)
-}
-
-export function lowercaseUnicodeAlphaString(options?: BuildCharSetOptions) {
-  return buildUnicodeCharSet(
-    "\\p{Ll}",
-    "lowercase unicode alpha characters",
-    options,
-  )
-}
-
-export function uppercaseUnicodeAlphaString(options?: BuildCharSetOptions) {
-  return buildUnicodeCharSet(
-    "\\p{Lu}",
-    "uppercase unicode alpha characters",
-    options,
-  )
-}
-
-export function unicodeNumericString(options?: BuildCharSetOptions) {
-  return buildUnicodeCharSet("\\p{N}", "unicode numbers", options)
-}
-
-export function unicodeAlphanumericString(options?: BuildCharSetOptions) {
-  return buildUnicodeCharSet(
-    "\\p{L}\\p{N}",
-    "unicode alphanumeric characters",
-    options,
-  )
-}
-
-export function lowercaseUnicodeAlphanumericString(
-  options?: BuildCharSetOptions,
-) {
-  return buildUnicodeCharSet(
-    "\\p{Ll}\\p{N}",
-    "lowercase unicode alphanumeric characters",
-    options,
-  )
-}
-
-export function uppercaseUnicodeAlphanumericString(
-  options?: BuildCharSetOptions,
-) {
-  return buildUnicodeCharSet(
-    "\\p{Lu}\\p{N}",
-    "uppercase unicode alphanumeric characters",
-    options,
-  )
-}
-
-// -----------------------------------------------------------------------------
-// Try Validate Sync
-// -----------------------------------------------------------------------------
-
-export type TryValidateSyncOnErrorRT<S extends Schema> = InferType<S> | void
-
-export type TryValidateSyncRT<
-  S extends Schema,
-  OnErrorRT extends TryValidateSyncOnErrorRT<S>,
-> = OnErrorRT extends InferType<S> ? InferType<S> : InferType<S> | undefined
-
-export type TryValidateSyncOptions<
-  S extends Schema,
-  OnErrorRT extends TryValidateSyncOnErrorRT<S>,
-> = ValidateOptions & {
-  onError?: (error: ValidationError) => OnErrorRT
-}
-
-export function tryValidateSync<S extends Schema>(
-  value: any,
-  schema: S,
-  options?: ValidateOptions,
-): InferType<S> | undefined
-
-export function tryValidateSync<
-  S extends Schema,
-  OnErrorRT extends TryValidateSyncOnErrorRT<S>,
->(
-  value: any,
-  schema: S,
-  options?: ValidateOptions & {
-    onError: (error: ValidationError) => OnErrorRT
-  },
-): TryValidateSyncRT<S, OnErrorRT>
-
-export function tryValidateSync<
-  S extends Schema,
-  OnErrorRT extends TryValidateSyncOnErrorRT<S>,
->(value: any, schema: S, options?: TryValidateSyncOptions<S, OnErrorRT>) {
-  const { onError, ...validateOptions } = options || {}
-
-  try {
-    return schema.validateSync(value, validateOptions) as unknown
-  } catch (error) {
-    if (!(error instanceof ValidationError)) throw error
-    else if (onError) return onError(error) as unknown
-  }
-}

package/src/utils/store.ts

@@ -1,31 +0,0 @@
-import type { Middleware, Reducer } from "@reduxjs/toolkit"
-import { configureStore } from "@reduxjs/toolkit"
-import { setupListeners } from "@reduxjs/toolkit/query"
-
-// The store setup is wrapped in `makeStore` to allow reuse
-// when setting up tests that need the same store config
-export function makeStore<R extends Reducer>({
-  reducer,
-  middlewares = [],
-  preloadedState = {},
-}: {
-  reducer: R
-  middlewares?: Middleware[]
-  preloadedState?: Partial<ReturnType<R>>
-}) {
-  const store = configureStore({
-    reducer,
-    // Adding the api middleware enables caching, invalidation, polling,
-    // and other useful features of `rtk-query`.
-    middleware: getDefaultMiddleware => {
-      return getDefaultMiddleware().concat(middlewares)
-    },
-    preloadedState,
-  })
-
-  // configure listeners using the provided defaults
-  // optional, but required for `refetchOnFocus`/`refetchOnReconnect` behaviors
-  setupListeners(store.dispatch)
-
-  return store
-}

package/src/utils/test.tsx

@@ -1,82 +0,0 @@
-import type { Middleware, Reducer, Store } from "@reduxjs/toolkit"
-import type { PropsWithChildren, ReactElement } from "react"
-import { Provider } from "react-redux"
-import type { RenderOptions } from "@testing-library/react"
-import { render } from "@testing-library/react"
-import userEvent from "@testing-library/user-event"
-
-import { makeStore } from "./store"
-
-export function renderWithUser(
-  ui: ReactElement,
-  renderOptions: RenderOptions = {},
-) {
-  return {
-    user: userEvent.setup(),
-    ...render(ui, renderOptions),
-  }
-}
-
-/**
- * Renders the given React element with Redux Provider and custom store.
- * This function is useful for testing components that are connected to the
- * Redux store.
- *
- * @param ui - The React component or element to render.
- * @param reducer - The root reducer to use for the store.
- * @param extendedRenderOptions - Optional configuration options for rendering.
- *  This includes `preloadedState` for initial Redux state and `store` for a
- *  specific Redux store instance. Any additional properties are passed to React
- *  Testing Library's render function.
- * @returns An object containing the Redux store used in the render, User event
- *  API for simulating user interactions in tests, and all of React Testing
- *  Library's query functions for testing the component.
- */
-export function renderWithStore<R extends Reducer>(
-  ui: ReactElement,
-  reducer: R,
-  extendedRenderOptions: RenderOptions & {
-    /**
-     * The middlewares used to create the Redux store.
-     */
-    middlewares?: Middleware[]
-
-    /**
-     * Defines a specific portion or the entire initial state for the Redux store.
-     * This is particularly useful for initializing the state in a
-     * controlled manner during testing, allowing components to be rendered
-     * with predetermined state conditions.
-     */
-    preloadedState?: Partial<ReturnType<R>>
-
-    /**
-     * Allows the use of a specific Redux store instance instead of a
-     * default or global store. This flexibility is beneficial when
-     * testing components with unique store requirements or when isolating
-     * tests from a global store state. The custom store should be configured
-     * to match the structure and middleware of the store used by the application.
-     *
-     * @default makeStore({reducer,middlewares,preloadedState})
-     */
-    store?: Store
-  } = {},
-) {
-  const {
-    middlewares,
-    preloadedState,
-    // Automatically create a store instance if no store was passed in
-    store = makeStore({ reducer, middlewares, preloadedState }),
-    ...renderOptions
-  } = extendedRenderOptions
-
-  const Wrapper = ({ children }: PropsWithChildren) => (
-    <Provider store={store}>{children}</Provider>
-  )
-
-  // Return an object with the store and all of RTL's query functions
-  return {
-    store,
-    user: userEvent.setup(),
-    ...render(ui, { wrapper: Wrapper, ...renderOptions }),
-  }
-}

package/src/utils/theme.tsx

@@ -1,83 +0,0 @@
-import { Divider, type DividerProps, type ThemeOptions } from "@mui/material"
-import { type CommonProps } from "@mui/material/OverridableComponent"
-import { type ReactElement } from "react"
-
-import _components from "../theme/components"
-
-export function insertDividerBetweenElements({
-  elements,
-  dividerProps,
-}: {
-  elements: ReactElement[]
-  dividerProps?: DividerProps
-}): ReactElement[] {
-  return elements.map((element, index) => (
-    <>
-      {element}
-      {index !== elements.length - 1 ? (
-        <Divider {...dividerProps} />
-      ) : undefined}
-    </>
-  ))
-}
-
-export function getStyleOverrides(
-  ownerState: CommonProps,
-  componentKey: keyof NonNullable<ThemeOptions["components"]>,
-  muiClassName: string = "root",
-  components: ThemeOptions["components"] = _components,
-): object {
-  if (components !== undefined) {
-    const component = components[componentKey]
-
-    if (
-      component !== undefined &&
-      "styleOverrides" in component &&
-      typeof component.styleOverrides === "object" &&
-      muiClassName in component.styleOverrides
-    ) {
-      const muiClass = (component.styleOverrides as Record<string, any>)[
-        muiClassName
-      ] as object
-
-      switch (typeof muiClass) {
-        case "function":
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-          return muiClass({ ownerState }) as object
-        case "object":
-          return muiClass
-      }
-    }
-  }
-
-  return {}
-}
-
-export function getClassNames(props: CommonProps): string[] {
-  return props.className?.split(" ") ?? []
-}
-
-export function includesClassNames(
-  propsOrClassNames: CommonProps | string[],
-  includes: string[],
-): boolean {
-  const classNames = Array.isArray(propsOrClassNames)
-    ? propsOrClassNames
-    : getClassNames(propsOrClassNames)
-
-  return includes.every(className => classNames.includes(className))
-}
-
-export function matchClassNames(
-  propsOrClassNames: CommonProps | string[],
-  pattern: string | RegExp,
-): RegExpMatchArray[] {
-  const classNames = Array.isArray(propsOrClassNames)
-    ? propsOrClassNames
-    : getClassNames(propsOrClassNames)
-
-  return classNames
-    .map(className => className.match(pattern))
-    .filter(match => match !== null)
-    .map(match => match)
-}

package/src/utils/window.ts

@@ -1,11 +0,0 @@
-export function configureFreshworksWidget(display: "open" | "hide"): void {
-  // @ts-expect-error defined in external script
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-  window.FreshworksWidget(display)
-}
-
-export function toggleOneTrustInfoDisplay(): void {
-  // @ts-expect-error defined in external script
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
-  window.Optanon.ToggleInfoDisplay()
-}

package/src/vite-env.d.ts

@@ -1 +0,0 @@
-/// <reference types="vite/client" />

package/tsconfig.app.json

@@ -1,4 +0,0 @@
-{
-  "extends": "../configs/frontend/tsconfig.app.json",
-  "include": ["src"]
-}

package/tsconfig.json

@@ -1,7 +0,0 @@
-{
-  "files": [],
-  "references": [
-    { "path": "./tsconfig.app.json" },
-    { "path": "./tsconfig.node.json" }
-  ]
-}

package/tsconfig.node.json

@@ -1,4 +0,0 @@
-{
-  "extends": "../configs/frontend/tsconfig.node.json",
-  "include": ["vite.config.ts"]
-}

package/types/fixes.d.ts

@@ -1,18 +0,0 @@
-/*
- * Namespace 'React' has no exported member 'StatelessComponent'
- * in formik, react-mapbox-gl
- */
-declare namespace React {
-  type StatelessComponent<P> = React.FunctionComponent<P>
-}
-
-declare module "*.svg" {
-  const content: string
-  export default content
-}
-
-/*
- * Don't care about the typings of external libraries.
- * All libraries without typings will be imported as `any`.
- */
-declare module "*" {}

package/vite.config.ts

@@ -1,23 +0,0 @@
-import { defineConfig } from "vitest/config"
-import react from "@vitejs/plugin-react"
-
-// https://vitejs.dev/config/
-// TODO: https://vite.dev/guide/build.html#library-mode
-// TODO: import common configs from src/vite.config.ts
-export default defineConfig({
-  plugins: [react()],
-  server: {
-    open: true,
-  },
-  test: {
-    globals: true,
-    environment: "jsdom",
-    setupFiles: "src/setupTests",
-    mockReset: true,
-    coverage: {
-      enabled: true,
-      provider: "istanbul",
-      reporter: ["html", "cobertura"],
-    },
-  },
-})