@equinor/apollo-utils 0.1.3 → 0.1.4

package/src/jotai-form/formUtils.test.ts

@@ -1,36 +0,0 @@
-import { renderHook } from '@testing-library/react-hooks'
-import { useAtomValue } from 'jotai'
-import { describe, expect, it } from 'vitest'
-import { examplePerson, Person } from '../test-data/person'
-import { createFormFamily, useFormFamilyUtils } from './formUtils'
-
-describe('Test createFormFamily', () => {
-  it('should create a family', () => {
-    const family = createFormFamily<Person>()
-    expect(family).toBeTruthy()
-  })
-  it('should initialize atom as undefined', () => {
-    const family = createFormFamily<Person>()
-    const { result } = renderHook(() => useAtomValue(family(examplePerson)))
-    expect(result.current).toBeUndefined()
-  })
-})
-
-function initFormUtils() {
-  const family = createFormFamily<Person>()
-  return useFormFamilyUtils(family)
-}
-
-describe('Test useFormFamilyUtils', () => {
-  it('should initialize form as valid with values', () => {
-    const utils = initFormUtils()
-    renderHook(() => utils.useFormMutations(examplePerson).initializeForm(examplePerson))
-    const { result } = renderHook(() => utils.useFormState(examplePerson))
-    expect(result.current?.isValid).toBeTruthy()
-    expect(result.current).toStrictEqual({
-      status: 'editing',
-      values: examplePerson,
-      isValid: true,
-    })
-  })
-})

package/src/jotai-form/formUtils.ts

@@ -1,73 +0,0 @@
-import { atom, PrimitiveAtom, useAtom, useAtomValue, useSetAtom } from 'jotai'
-import { atomFamily } from 'jotai/utils'
-import { type AtomFamily } from 'jotai/vanilla/utils/atomFamily'
-import { createValidator } from '../zod-validation'
-import { FormFamilyParam, FormState } from './types'
-
-export function createFormFamily<E extends Record<string, unknown>>() {
-  return atomFamily(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    (_param: FormFamilyParam) => atom<FormState<E> | undefined>(undefined),
-    (a, b) => a.id === b.id
-  )
-}
-
-type FormFamily<T> = AtomFamily<FormFamilyParam, PrimitiveAtom<FormState<T> | undefined>>
-type FormValidator = ReturnType<typeof createValidator>
-
-type UseFormFamilyUtilsOptions = {
-  validator?: FormValidator
-}
-
-export function useFormFamilyUtils<T>(
-  family: FormFamily<T>,
-  options: UseFormFamilyUtilsOptions = {}
-) {
-  return {
-    useFormStateAtom: (param: FormFamilyParam) => useAtom(family(param)),
-    useFormState: (param: FormFamilyParam) => useAtomValue(family(param)),
-    useUpdateFormMutation: (param: FormFamilyParam) => {
-      return useFormFamilyMutation(family, param, options.validator)
-    },
-    useFormMutations(param: FormFamilyParam) {
-      const mutateAtom = useSetAtom(family(param))
-
-      return {
-        update: useFormFamilyMutation(family, param, options.validator),
-        initializeForm: (entity: T) =>
-          mutateAtom({
-            status: 'editing',
-            values: entity,
-            isValid: true,
-          }),
-        resetForm: () => mutateAtom(undefined),
-      }
-    },
-  }
-}
-
-export function useFormFamilyMutation<T>(
-  family: FormFamily<T>,
-  param: FormFamilyParam,
-  validator?: FormValidator
-) {
-  const mutate = useSetAtom(family(param))
-  return (update: Partial<T>) => {
-    return mutate((previous) => {
-      if (!previous) return
-
-      const updatedValues = {
-        ...previous.values,
-        ...update,
-      }
-      const errors = validator?.validate(updatedValues)
-
-      return {
-        status: 'editing',
-        values: updatedValues,
-        errors,
-        isValid: !errors,
-      }
-    })
-  }
-}

package/src/jotai-form/index.ts

@@ -1,2 +0,0 @@
-export * from './formUtils'
-export * from './types'

package/src/jotai-form/types.ts

@@ -1,12 +0,0 @@
-import { ValidationErrorMap } from '../zod-validation'
-
-export type FormState<T> = {
-  status: 'editing' | 'pending'
-  values: T
-  errors?: ValidationErrorMap<T>
-  isValid?: boolean
-}
-
-export type FormFamilyParam = {
-  id: number | string
-} & Record<string, unknown>

package/src/test-data/person.ts

@@ -1,15 +0,0 @@
-import { z } from 'zod'
-
-export const personSchema = z.object({
-  id: z.number(),
-  name: z.string().min(1),
-  age: z.number().min(0).max(150),
-})
-
-export type Person = z.infer<typeof personSchema>
-
-export const examplePerson: Person = {
-  id: 0,
-  name: 'Apollo',
-  age: 25,
-}

package/src/zod-validation/index.ts

@@ -1,2 +0,0 @@
-export * from './types'
-export * from './utils'

package/src/zod-validation/types.ts

@@ -1 +0,0 @@
-export type ValidationErrorMap<T> = Map<keyof T, { message: string; code: string }>

package/src/zod-validation/utils.test.ts

@@ -1,17 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { examplePerson, personSchema } from '../test-data/person'
-import { createValidator } from './utils'
-
-const validator = createValidator(personSchema)
-
-describe('Test validator creation', () => {
-  it('should return undefined on valid data', () => {
-    const errors = validator.validate(examplePerson)
-    expect(errors).toBeUndefined()
-  })
-  it('should return errors on invalid name and age', () => {
-    const errors = validator.validate({ ...examplePerson, name: '', age: 200 })
-    expect(errors?.has('name')).toBeTruthy()
-    expect(errors?.has('age')).toBeTruthy()
-  })
-})

package/src/zod-validation/utils.ts

@@ -1,29 +0,0 @@
-import { z } from 'zod'
-import { ValidationErrorMap } from './types'
-
-export function createValidator<S extends z.ZodTypeAny>(schema: S) {
-  return {
-    validate: <E extends z.infer<typeof schema>>(entity: E) => {
-      const validation = schema.safeParse(entity)
-      if (validation.success) return undefined
-      return prepareErrors<E>(validation)
-    },
-    validateAsync: async <E extends z.infer<typeof schema>>(entity: z.infer<typeof schema>) => {
-      const validation = await schema.safeParseAsync(entity)
-      if (validation.success) return undefined
-      return prepareErrors<E>(validation)
-    },
-    getSchema() {
-      return schema
-    },
-  }
-}
-
-function prepareErrors<E extends Record<string, unknown>>(errorValidation: z.SafeParseError<E>) {
-  return new Map(
-    errorValidation.error.errors.map((error) => [
-      error.path[0] as keyof E,
-      { message: error.message, code: error.code },
-    ])
-  ) as ValidationErrorMap<E>
-}

package/tsconfig.json

@@ -1,5 +0,0 @@
-{
-  "extends": "tsconfig/vite.json",
-  "include": ["src", "setupTest.ts"],
-  "compilerOptions": { "types": ["vitest/importMeta"] }
-}

package/vitest.config.ts

@@ -1,11 +0,0 @@
-import { defineConfig } from 'vitest/config'
-
-export default defineConfig({
-  define: {
-    'import.meta.vitest': 'undefined',
-  },
-  test: {
-    includeSource: ['src/**/*.ts'],
-    environment: 'jsdom',
-  },
-})