@jcoreio/zod-forms 1.0.0

package/src/useSubmit.ts

@@ -0,0 +1,29 @@
+import z from 'zod'
+import { Handlers } from './actions/addHandlers'
+import React from 'react'
+import { useFormContext } from './useFormContext'
+
+export function useSubmit<T extends z.ZodTypeAny>(handlers?: Handlers<T>) {
+  const handlersRef = React.useRef<Handlers<T> | undefined>(handlers)
+  handlersRef.current = handlers
+  const { addHandlers, removeHandlers } = useFormContext<T>()
+  React.useEffect(() => {
+    const handlers: Handlers<T> = {
+      onSubmit: (...args) => handlersRef.current?.onSubmit?.(...args),
+      onSubmitSucceeded: (...args) =>
+        handlersRef.current?.onSubmitSucceeded?.(...args),
+      onSubmitFailed: (...args) =>
+        handlersRef.current?.onSubmitFailed?.(...args),
+    }
+    addHandlers(handlers)
+    return () => {
+      removeHandlers(handlers)
+    }
+  }, [])
+  const { submit } = useFormContext()
+  return React.useCallback((e: React.FormEvent) => {
+    e.preventDefault()
+    e.stopPropagation()
+    submit()
+  }, [])
+}

package/src/util/PathInSchema.ts

@@ -0,0 +1,7 @@
+import z from 'zod'
+import { PathInType, PathstringInType } from './PathInType'
+
+export type PathInSchema<T extends z.ZodTypeAny> = PathInType<z.input<T>>
+export type PathstringInSchema<T extends z.ZodTypeAny> = PathstringInType<
+  z.input<T>
+>

package/src/util/PathInType.ts

@@ -0,0 +1,26 @@
+import { BasePath } from '../FieldPath'
+import { pathstring } from './pathstring'
+
+export type PathInType<T> = [] | SubPathInType<T>
+
+type SubPathInType<T> = 0 extends 1 & T
+  ? BasePath
+  : T extends
+      | string
+      | number
+      | boolean
+      | bigint
+      | symbol
+      | null
+      | undefined
+      | void
+      | never
+      | ((...args: any[]) => any)
+  ? []
+  : T extends readonly any[]
+  ? { [K in keyof T & number]-?: [K, ...PathInType<T[K]>] }[keyof T & number]
+  : {
+      [K in keyof T]-?: K extends symbol ? never : [K, ...PathInType<T[K]>]
+    }[keyof T]
+
+export type PathstringInType<T> = pathstring<PathInType<T>>

package/src/util/SchemaAt.ts

@@ -0,0 +1,68 @@
+import z from 'zod'
+
+type BasePath = (string | number)[]
+
+export type SchemaAt<T extends z.ZodTypeAny, Path> = 0 extends 1 & Path
+  ? z.ZodTypeAny
+  : 0 extends 1 & T
+  ? z.ZodTypeAny
+  : 0 extends 1 & z.input<T>
+  ? z.ZodTypeAny
+  : Path extends [infer Head, ...infer Tail extends BasePath]
+  ? T extends z.ZodLazy<infer U>
+    ? SchemaAt<U, Path>
+    : T extends z.ZodCatch<infer U>
+    ? SchemaAt<U, Path>
+    : T extends z.ZodBranded<infer U, any>
+    ? SchemaAt<U, Path>
+    : T extends z.ZodOptional<infer U>
+    ? SchemaAt<U, Path>
+    : T extends z.ZodDefault<infer U>
+    ? SchemaAt<U, Path>
+    : T extends z.ZodNullable<infer U>
+    ? SchemaAt<U, Path>
+    : T extends z.ZodUnion<infer Options>
+    ? SchemaAt<Options[number], Path>
+    : T extends z.ZodDiscriminatedUnion<any, infer Options>
+    ? SchemaAt<Options[number], Path>
+    : T extends z.ZodPipeline<infer In, any>
+    ? SchemaAt<In, Path>
+    : T extends z.ZodEffects<infer U>
+    ? SchemaAt<U, Path>
+    : T extends z.ZodReadonly<infer U>
+    ? SchemaAt<U, Path>
+    : T extends z.ZodRecord<infer Key, infer Value>
+    ? Head extends z.input<Key>
+      ? SchemaAt<Value, Tail>
+      : never
+    : T extends z.ZodMap<infer Key, infer Value>
+    ? Head extends z.input<Key>
+      ? SchemaAt<Value, Tail>
+      : never
+    : T extends z.ZodObject<
+        infer Shape,
+        infer UnknownKeys,
+        infer Catchall extends z.ZodTypeAny
+      >
+    ? Head extends keyof Shape
+      ? SchemaAt<Shape[Head], Tail>
+      : UnknownKeys extends 'passthrough'
+      ? SchemaAt<Catchall, Tail>
+      : never
+    : T extends z.ZodTuple<
+        infer Elements extends [z.ZodTypeAny, ...z.ZodTypeAny[]],
+        infer Rest
+      >
+    ? Head extends number & keyof Elements
+      ? SchemaAt<Elements[Head], Tail>
+      : Rest extends z.ZodTypeAny
+      ? Head extends number
+        ? SchemaAt<Rest, Tail>
+        : never
+      : never
+    : T extends z.ZodArray<infer Element>
+    ? Head extends number
+      ? SchemaAt<Element, Tail>
+      : never
+    : never
+  : T

package/src/util/acceptsArray.ts

@@ -0,0 +1,72 @@
+import z from 'zod'
+
+export function acceptsArray(schema: z.ZodTypeAny): boolean {
+  switch (schema._def.typeName) {
+    case z.ZodFirstPartyTypeKind.ZodArray:
+    case z.ZodFirstPartyTypeKind.ZodTuple:
+      return true
+    case z.ZodFirstPartyTypeKind.ZodUnion: {
+      const { options } = schema as z.ZodUnion<z.ZodUnionOptions>
+      return options.some(acceptsArray)
+    }
+    case z.ZodFirstPartyTypeKind.ZodIntersection: {
+      const {
+        _def: { left, right },
+      } = schema as z.ZodIntersection<z.ZodTypeAny, z.ZodTypeAny>
+      return acceptsArray(left) && acceptsArray(right)
+    }
+    case z.ZodFirstPartyTypeKind.ZodLazy: {
+      const { schema: innerSchema } = schema as z.ZodLazy<z.ZodTypeAny>
+      return acceptsArray(innerSchema)
+    }
+    case z.ZodFirstPartyTypeKind.ZodLiteral: {
+      const { value } = schema as z.ZodLiteral<any>
+      return typeof value === 'number'
+    }
+    case z.ZodFirstPartyTypeKind.ZodEffects: {
+      const {
+        _def: { schema: innerSchema },
+      } = schema as z.ZodEffects<z.ZodTypeAny>
+      return acceptsArray(innerSchema)
+    }
+    case z.ZodFirstPartyTypeKind.ZodOptional: {
+      const innerSchema = (schema as z.ZodOptional<z.ZodTypeAny>).unwrap()
+      return acceptsArray(innerSchema)
+    }
+    case z.ZodFirstPartyTypeKind.ZodNullable: {
+      const innerSchema = (schema as z.ZodNullable<z.ZodTypeAny>).unwrap()
+      return acceptsArray(innerSchema)
+    }
+    case z.ZodFirstPartyTypeKind.ZodDefault: {
+      const {
+        _def: { innerType },
+      } = schema as z.ZodDefault<z.ZodTypeAny>
+      return acceptsArray(innerType)
+    }
+    case z.ZodFirstPartyTypeKind.ZodCatch: {
+      const {
+        _def: { innerType },
+      } = schema as z.ZodCatch<z.ZodTypeAny>
+      return acceptsArray(innerType)
+    }
+    case z.ZodFirstPartyTypeKind.ZodBranded: {
+      const {
+        _def: { type: innerType },
+      } = schema as z.ZodBranded<z.ZodTypeAny, string | number | symbol>
+      return acceptsArray(innerType)
+    }
+    case z.ZodFirstPartyTypeKind.ZodPipeline: {
+      const {
+        _def: { in: input },
+      } = schema as z.ZodPipeline<z.ZodTypeAny, z.ZodTypeAny>
+      return acceptsArray(input)
+    }
+    case z.ZodFirstPartyTypeKind.ZodReadonly: {
+      const {
+        _def: { innerType },
+      } = schema as z.ZodReadonly<z.ZodTypeAny>
+      return acceptsArray(innerType)
+    }
+  }
+  return false
+}

package/src/util/acceptsBigint.ts

@@ -0,0 +1,71 @@
+import z from 'zod'
+
+export function acceptsBigint(schema: z.ZodTypeAny): boolean {
+  switch (schema._def.typeName) {
+    case z.ZodFirstPartyTypeKind.ZodBigInt:
+      return true
+    case z.ZodFirstPartyTypeKind.ZodUnion: {
+      const { options } = schema as z.ZodUnion<z.ZodUnionOptions>
+      return options.some(acceptsBigint)
+    }
+    case z.ZodFirstPartyTypeKind.ZodIntersection: {
+      const {
+        _def: { left, right },
+      } = schema as z.ZodIntersection<z.ZodTypeAny, z.ZodTypeAny>
+      return acceptsBigint(left) && acceptsBigint(right)
+    }
+    case z.ZodFirstPartyTypeKind.ZodLazy: {
+      const { schema: innerSchema } = schema as z.ZodLazy<z.ZodTypeAny>
+      return acceptsBigint(innerSchema)
+    }
+    case z.ZodFirstPartyTypeKind.ZodLiteral: {
+      const { value } = schema as z.ZodLiteral<any>
+      return typeof value === 'bigint'
+    }
+    case z.ZodFirstPartyTypeKind.ZodEffects: {
+      const {
+        _def: { schema: innerSchema },
+      } = schema as z.ZodEffects<z.ZodTypeAny>
+      return acceptsBigint(innerSchema)
+    }
+    case z.ZodFirstPartyTypeKind.ZodOptional: {
+      const innerSchema = (schema as z.ZodOptional<z.ZodTypeAny>).unwrap()
+      return acceptsBigint(innerSchema)
+    }
+    case z.ZodFirstPartyTypeKind.ZodNullable: {
+      const innerSchema = (schema as z.ZodNullable<z.ZodTypeAny>).unwrap()
+      return acceptsBigint(innerSchema)
+    }
+    case z.ZodFirstPartyTypeKind.ZodDefault: {
+      const {
+        _def: { innerType },
+      } = schema as z.ZodDefault<z.ZodTypeAny>
+      return acceptsBigint(innerType)
+    }
+    case z.ZodFirstPartyTypeKind.ZodCatch: {
+      const {
+        _def: { innerType },
+      } = schema as z.ZodCatch<z.ZodTypeAny>
+      return acceptsBigint(innerType)
+    }
+    case z.ZodFirstPartyTypeKind.ZodBranded: {
+      const {
+        _def: { type: innerType },
+      } = schema as z.ZodBranded<z.ZodTypeAny, string | number | symbol>
+      return acceptsBigint(innerType)
+    }
+    case z.ZodFirstPartyTypeKind.ZodPipeline: {
+      const {
+        _def: { in: input },
+      } = schema as z.ZodPipeline<z.ZodTypeAny, z.ZodTypeAny>
+      return acceptsBigint(input)
+    }
+    case z.ZodFirstPartyTypeKind.ZodReadonly: {
+      const {
+        _def: { innerType },
+      } = schema as z.ZodReadonly<z.ZodTypeAny>
+      return acceptsBigint(innerType)
+    }
+  }
+  return false
+}

package/src/util/acceptsNumber.ts

@@ -0,0 +1,71 @@
+import z from 'zod'
+
+export function acceptsNumber(schema: z.ZodTypeAny): boolean {
+  switch (schema._def.typeName) {
+    case z.ZodFirstPartyTypeKind.ZodNumber:
+      return true
+    case z.ZodFirstPartyTypeKind.ZodUnion: {
+      const { options } = schema as z.ZodUnion<z.ZodUnionOptions>
+      return options.some(acceptsNumber)
+    }
+    case z.ZodFirstPartyTypeKind.ZodIntersection: {
+      const {
+        _def: { left, right },
+      } = schema as z.ZodIntersection<z.ZodTypeAny, z.ZodTypeAny>
+      return acceptsNumber(left) && acceptsNumber(right)
+    }
+    case z.ZodFirstPartyTypeKind.ZodLazy: {
+      const { schema: innerSchema } = schema as z.ZodLazy<z.ZodTypeAny>
+      return acceptsNumber(innerSchema)
+    }
+    case z.ZodFirstPartyTypeKind.ZodLiteral: {
+      const { value } = schema as z.ZodLiteral<any>
+      return typeof value === 'number'
+    }
+    case z.ZodFirstPartyTypeKind.ZodEffects: {
+      const {
+        _def: { schema: innerSchema },
+      } = schema as z.ZodEffects<z.ZodTypeAny>
+      return acceptsNumber(innerSchema)
+    }
+    case z.ZodFirstPartyTypeKind.ZodOptional: {
+      const innerSchema = (schema as z.ZodOptional<z.ZodTypeAny>).unwrap()
+      return acceptsNumber(innerSchema)
+    }
+    case z.ZodFirstPartyTypeKind.ZodNullable: {
+      const innerSchema = (schema as z.ZodNullable<z.ZodTypeAny>).unwrap()
+      return acceptsNumber(innerSchema)
+    }
+    case z.ZodFirstPartyTypeKind.ZodDefault: {
+      const {
+        _def: { innerType },
+      } = schema as z.ZodDefault<z.ZodTypeAny>
+      return acceptsNumber(innerType)
+    }
+    case z.ZodFirstPartyTypeKind.ZodCatch: {
+      const {
+        _def: { innerType },
+      } = schema as z.ZodCatch<z.ZodTypeAny>
+      return acceptsNumber(innerType)
+    }
+    case z.ZodFirstPartyTypeKind.ZodBranded: {
+      const {
+        _def: { type: innerType },
+      } = schema as z.ZodBranded<z.ZodTypeAny, string | number | symbol>
+      return acceptsNumber(innerType)
+    }
+    case z.ZodFirstPartyTypeKind.ZodPipeline: {
+      const {
+        _def: { in: input },
+      } = schema as z.ZodPipeline<z.ZodTypeAny, z.ZodTypeAny>
+      return acceptsNumber(input)
+    }
+    case z.ZodFirstPartyTypeKind.ZodReadonly: {
+      const {
+        _def: { innerType },
+      } = schema as z.ZodReadonly<z.ZodTypeAny>
+      return acceptsNumber(innerType)
+    }
+  }
+  return false
+}

package/src/util/bindActionsToField.ts

@@ -0,0 +1,22 @@
+import { FieldPath } from '../FieldPath'
+
+export function bindActionsToField<
+  Actions extends { [K in string]: (field: FieldPath, ...rest: any[]) => any }
+>(
+  actions: Actions,
+  field: FieldPath
+): {
+  [K in keyof Actions]: Actions[K] extends (
+    field: FieldPath,
+    ...rest: infer Rest
+  ) => infer Return
+    ? (...rest: Rest) => Return
+    : never
+} {
+  return Object.fromEntries(
+    Object.entries(actions).map(([key, action]: any) => [
+      key,
+      (...args: any[]) => action(field, ...args),
+    ])
+  ) as any
+}

package/src/util/get.ts

@@ -0,0 +1,10 @@
+export function get(
+  from: unknown,
+  path: (string | number | symbol)[]
+): unknown {
+  return path.reduce(
+    (from: any, next) =>
+      from instanceof Object && next in from ? from[next] : undefined,
+    from
+  )
+}

package/src/util/getArrayElementSchema.ts

@@ -0,0 +1,74 @@
+import z from 'zod'
+
+export function getArrayElementSchema(
+  schema: z.ZodTypeAny
+): z.ZodTypeAny | undefined {
+  switch (schema._def.typeName) {
+    case z.ZodFirstPartyTypeKind.ZodArray: {
+      const { element } = schema as z.ZodArray<z.ZodTypeAny>
+      return element
+    }
+    case z.ZodFirstPartyTypeKind.ZodUnion: {
+      const { options } = schema as z.ZodUnion<z.ZodUnionOptions>
+      const elements = options
+        .map(getArrayElementSchema)
+        .filter((s): s is z.ZodTypeAny => s != null)
+      return elements.length > 1 ? z.union(elements as any) : elements[0]
+    }
+    case z.ZodFirstPartyTypeKind.ZodLazy: {
+      const { schema: innerSchema } = schema as z.ZodLazy<z.ZodTypeAny>
+      return getArrayElementSchema(innerSchema)
+    }
+    case z.ZodFirstPartyTypeKind.ZodEffects: {
+      const {
+        _def: { schema: innerSchema },
+      } = schema as z.ZodEffects<z.ZodTypeAny>
+      return getArrayElementSchema(innerSchema)
+    }
+    case z.ZodFirstPartyTypeKind.ZodOptional: {
+      const innerSchema = (schema as z.ZodOptional<z.ZodTypeAny>).unwrap()
+      return getArrayElementSchema(innerSchema)
+    }
+    case z.ZodFirstPartyTypeKind.ZodNullable: {
+      const innerSchema = (schema as z.ZodNullable<z.ZodTypeAny>).unwrap()
+      return getArrayElementSchema(innerSchema)
+    }
+    case z.ZodFirstPartyTypeKind.ZodDefault: {
+      const {
+        _def: { innerType },
+      } = schema as z.ZodDefault<z.ZodTypeAny>
+      return getArrayElementSchema(innerType)
+    }
+    case z.ZodFirstPartyTypeKind.ZodCatch: {
+      const {
+        _def: { innerType },
+      } = schema as z.ZodCatch<z.ZodTypeAny>
+      return getArrayElementSchema(innerType)
+    }
+    case z.ZodFirstPartyTypeKind.ZodPromise: {
+      const {
+        _def: { type: innerType },
+      } = schema as z.ZodPromise<z.ZodTypeAny>
+      return getArrayElementSchema(innerType)
+    }
+    case z.ZodFirstPartyTypeKind.ZodBranded: {
+      const {
+        _def: { type: innerType },
+      } = schema as z.ZodBranded<z.ZodTypeAny, string | number | symbol>
+      return getArrayElementSchema(innerType)
+    }
+    case z.ZodFirstPartyTypeKind.ZodPipeline: {
+      const {
+        _def: { in: input },
+      } = schema as z.ZodPipeline<z.ZodTypeAny, z.ZodTypeAny>
+      return getArrayElementSchema(input)
+    }
+    case z.ZodFirstPartyTypeKind.ZodReadonly: {
+      const {
+        _def: { innerType },
+      } = schema as z.ZodReadonly<z.ZodTypeAny>
+      return getArrayElementSchema(innerType)
+    }
+  }
+  return undefined
+}

package/src/util/maybeParse.ts

@@ -0,0 +1,9 @@
+import z from 'zod'
+
+export function maybeParse<T extends z.ZodTypeAny>(
+  schema: T,
+  rawValue: unknown
+): z.output<T> | undefined {
+  const parsed = schema.safeParse(rawValue)
+  return parsed.success ? parsed.data : undefined
+}

package/src/util/parsePathstring.ts

@@ -0,0 +1,119 @@
+import { BasePath } from '../FieldPath'
+
+export type parsePathstring<Path extends string, IsTail = false> = [
+  Path
+] extends ['']
+  ? []
+  : [Path] extends [`[${infer Rest}`]
+  ? Rest extends `${infer N extends number}]${infer Tail}`
+    ? [N, ...parsePathstring<Tail, true>]
+    : ExtractInitialStringLiteral<Rest> extends infer StringLiteral extends string
+    ? [
+        ProcessStringLiteral<StringLiteral>,
+        ...(Rest extends `${StringLiteral}]${infer Tail}`
+          ? parsePathstring<Tail, true>
+          : never)
+      ]
+    : never
+  : [IsTail] extends [true]
+  ? [Path] extends [`.${infer Rest}`]
+    ? parsePathstring<Rest>
+    : never
+  : [Path] extends [`${infer Head}[${infer Tail}`]
+  ? [Path] extends [`${infer Head2}.${infer Tail2}`]
+    ? Head2 extends `${Head}[${string}` // make sure we pick up to . or [, whichever comes first
+      ? [Head, ...parsePathstring<`[${Tail}`, true>]
+      : [Head2, ...parsePathstring<`.${Tail2}`, true>]
+    : [Head, ...parsePathstring<`[${Tail}`, true>]
+  : [Path] extends [`${infer Head}.${infer Tail}`]
+  ? [Head, ...parsePathstring<`.${Tail}`, true>]
+  : [Path]
+
+/**
+ * If T starts with a quoted string literal, returns that string literal.
+ * Otherwise returns never
+ */
+type ExtractInitialStringLiteral<T extends string> = [T] extends [
+  `"${infer Rest}`
+]
+  ? `"${RestOfStringLiteral<Rest, '"'>}`
+  : [T] extends [`'${infer Rest}`]
+  ? `'${RestOfStringLiteral<Rest, "'">}`
+  : never
+
+type RestOfStringLiteral<
+  /**
+   * A substring right after an opening quote
+   */
+  T extends string,
+  /**
+   * The opening quote type
+   */
+  Q extends '"' | "'"
+> = [T] extends [`${infer A}${Q}${infer B}`] // find the next quote
+  ? A extends `${infer C}\\${infer D}` // the quote may be escaped, so find the first backslash
+    ? D extends '' // nothing after the backslash, so it escapes the quote Q
+      ? `${A}${Q}${RestOfStringLiteral<B, Q>}` // keep scanning until the closing quote
+      : D extends `${infer E extends keyof EscapeChars}${infer F}`
+      ? `${C}\\${E}${RestOfStringLiteral<`${F}${Q}${B}`, Q>}` // keep scanning until the closing quote
+      : never
+    : `${A}${Q}` // no backslash, Q is a closing quote and we're done!
+  : never
+
+type EscapeChars = typeof EscapeChars
+const EscapeChars = {
+  "'": "'",
+  '"': '"',
+  '\\': '\\',
+  b: '\b',
+  f: '\f',
+  n: '\n',
+  r: '\r',
+  t: '\t',
+  v: '\v',
+} as const
+
+type ProcessEscapes<T extends string> = T extends `${infer A}\\${infer B}`
+  ? B extends `${infer C extends keyof EscapeChars}${infer D}`
+    ? `${A}${EscapeChars[C]}${ProcessEscapes<D>}`
+    : never
+  : T
+
+type ProcessStringLiteral<T extends string> = T extends `"${infer Content}"`
+  ? ProcessEscapes<Content>
+  : T extends `'${infer Content}'`
+  ? ProcessEscapes<Content>
+  : never
+
+const pathstringRx =
+  /((?:^|\.)([^.[\]]+))|\[((\d+)|("(?:[^\\"]|\\['"\\bfnrtv])+"|'(?:[^\\']|\\['"\\bfnrtv])+'))\]/g
+
+export function parsePathstring(pathstring: string): BasePath {
+  const path: BasePath = []
+  let lastIndex = 0
+  for (const match of pathstring.matchAll(pathstringRx)) {
+    if (
+      match.index !== lastIndex ||
+      (match.index === 0 && match[0][0] === '.')
+    ) {
+      throw new Error(`invalid pathstring: ${pathstring} (at ${match.index})`)
+    }
+    lastIndex = match.index + match[0].length
+    if (match[2]) path.push(match[2])
+    else if (match[4]) path.push(parseInt(match[4]))
+    else if (match[5]) {
+      path.push(
+        match[5]
+          .substring(1, match[5].length - 1)
+          .replace(
+            /\\['"\\bfnrtv]/g,
+            (m) => EscapeChars[m[1] as keyof EscapeChars]
+          )
+      )
+    }
+  }
+  if (lastIndex !== pathstring.length) {
+    throw new Error(`invalid pathstring: ${pathstring} (at ${lastIndex})`)
+  }
+  return path
+}

package/src/util/pathstring.ts

@@ -0,0 +1,32 @@
+type PathElem = string | number
+type BasePath = PathElem[]
+
+export type pathstring<Path> = Path extends [
+  infer Head extends PathElem,
+  ...infer Tail extends PathElem[]
+]
+  ? `${Head extends number ? `[${Head}]` : Head}${pathstringTail<Tail>}`
+  : ''
+
+type pathstringTail<Path extends BasePath> = Path extends [
+  infer Head extends PathElem,
+  ...infer Tail extends PathElem[]
+]
+  ? `${Head extends number ? `[${Head}]` : `.${Head}`}${pathstringTail<Tail>}`
+  : ''
+
+export function pathstring<Path extends BasePath>(
+  path: Path
+): pathstring<Path> {
+  return path
+    .map((elem, index) =>
+      typeof elem === 'string' && isValidIdentifier(elem)
+        ? `${index > 0 ? '.' : ''}${elem}`
+        : `[${JSON.stringify(elem)}]`
+    )
+    .join('') as any
+}
+
+function isValidIdentifier(s: string): boolean {
+  return /^[_$a-z][_$a-z0-9]*$/i.test(s)
+}

package/src/util/set.ts

@@ -0,0 +1,25 @@
+export function set(
+  from: unknown,
+  path: (string | number | symbol)[],
+  value: unknown,
+  index = 0
+): unknown {
+  if (index === path.length) return value
+  if (from instanceof Map) {
+    const oldValue = from.get(path[index])
+    const newValue = set(oldValue, path, value, index + 1)
+    if (Object.is(oldValue, newValue)) return from
+    const result = new Map(from)
+    result.set(path[index], newValue)
+    return result
+  }
+  if (from instanceof Object) {
+    const oldValue = (from as any)[path[index]]
+    const newValue = set(oldValue, path, value, index + 1)
+    if (Object.is(oldValue, newValue)) return from
+    const result: any = Array.isArray(from) ? [...from] : { ...from }
+    result[path[index]] = newValue
+    return result
+  }
+  return set(typeof path[index] === 'number' ? [] : {}, path, value, index)
+}

package/src/util/setAdd.ts

@@ -0,0 +1,6 @@
+export function setAdd<T>(set: Set<T>, elem: T) {
+  if (set.has(elem)) return set
+  set = new Set(set)
+  set.add(elem)
+  return set
+}

package/src/util/setDelete.ts

@@ -0,0 +1,6 @@
+export function setDelete<T>(set: Set<T>, elem: T) {
+  if (!set.has(elem)) return set
+  set = new Set(set)
+  set.delete(elem)
+  return set
+}