feat: add "match" util

Author: acd02

src/pages/_error.tsx

@@ -1,16 +1,16 @@
 import { Box } from 'components/atoms/Box'
 import type { NextPage } from 'next'
+import { __, match } from 'utils/match'
 
 type Props = {
   statusCode?: number
 }
 
 const Error: NextPage<Props, unknown> = ({ statusCode }) => {
-  const content = (() => {
-    if (statusCode === 404) return 'Oops, missing page'
-    if (statusCode) return `An error ${statusCode} occurred on the server`
-    else return 'An error occurred on the client'
-  })()
+  const content = match(statusCode)
+    .if(__.isEqual(404), () => 'Oops, missing page')
+    .if(__.isDefined, code => `An error ${code} occurred on the server`)
+    .else(() => 'An error occurred on the client')
 
   return (
     <Box
@@ -27,13 +27,23 @@ const Error: NextPage<Props, unknown> = ({ statusCode }) => {
 }
 
 Error.getInitialProps = ({ err, res }): Props => {
-  const statusCode = (() => {
-    if (err) return err.statusCode
-    if (res) return res.statusCode
-    else return 404
-  })()
+  const statusCode = match({
+    error: err,
+    response: res,
+  })
+    .if(
+      ({ error }) => __.isDefined(error),
+      ({ error }) => error?.statusCode
+    )
+    .if(
+      ({ response }) => __.isDefined(response),
+      ({ response }) => response?.statusCode
+    )
+    .else(() => 404)
 
-  return { statusCode }
+  return {
+    statusCode,
+  }
 }
 
 export default Error

src/utils/match/helpers.ts

@@ -0,0 +1,44 @@
+export const __ = {
+  isEqual<T extends string | number | boolean>(value: T) {
+    return (
+      check: T extends boolean | null
+        ? boolean | null
+        : T extends null | string
+        ? string | null
+        : T extends null | number
+        ? number | null
+        : T extends string | number
+        ? string | number
+        : T extends string
+        ? string
+        : T extends number
+        ? number
+        : boolean
+    ): boolean => {
+      return value === (check as unknown as T)
+    }
+  },
+
+  isTruthy<T>(value: T) {
+    return !!value
+  },
+  isNil<T>(a: T) {
+    return a === undefined || a === null
+  },
+  isDefined<T>(a: T): boolean {
+    return a !== undefined && a !== null
+  },
+  isArray(x: any): boolean {
+    return !!x && x.constructor === Array
+  },
+  isObject(x: any) {
+    return !!x && x.constructor === Object
+  },
+  isEmpty<T>(a: T): boolean {
+    if (typeof a === 'string') return !a.length
+    if (typeof a === 'number' || typeof a === 'boolean') return false
+    if (__.isArray(a)) return !(a as unknown as []).length
+    if (__.isObject(a)) return !Object.keys(a).length
+    else return true
+  },
+}

src/utils/match/index.ts

@@ -0,0 +1,104 @@
+// 🙏 shoutout to -> https://github.com/gvergnaud/ts-pattern
+
+type Union<a, b> = [b] extends [a] ? a : [a] extends [b] ? b : a | b
+
+type Match<Value, InferredOutput = never> = {
+  /**
+   * if the `predicate` func returns true, the value returned by the `handler` will be the one returned when calling `else`.
+   *
+   * The matching `handler` func will be invoked only after `else` is called.
+   */
+  if: <Output>(
+    predicate: (value: NonNullable<Value>) => boolean,
+    handler: (value: NonNullable<Value>) => Output
+  ) => Match<Value, Union<InferredOutput, Output>>
+  /**
+   * takes a function allowing one to return a fallback value in case no match were found
+   */
+  else: <O>(fallback: () => O) => Union<InferredOutput, O>
+}
+
+/**
+ * Entry point to create some sort of a matching expression
+ *
+ * It returns a Match builder, on which you can chain several
+ * `.if(predicate, handler)` clauses
+ *
+ * @example
+ *
+ * import { match, __ } from 'match'
+ *
+ * type Status = 'idle' | 'loading' | 'success' | 'error'
+ *
+ * const predicate: boolean
+ * const status: Status
+ *
+ * const someExample = match(status)
+ *   .if(__.isEqual<Status>('idle'), s => <p>is {s}</p>) // s === idle
+ *   .if(__.isEqual<Status>('loading'), s => <p>is {s}</p>) // s === loading
+ *   .else(() => <p>no matches were found</p>)
+ *
+ * const otherExample = match({ status, predicate })
+ *   .if(
+ *     ({ status, predicate }) => status === 'success' && predicate,
+ *     () => <p>ok</p>
+ *   )
+ *   .if(
+ *     ({ status, predicate }) => status === 'error' && !predicate,
+ *     () => <p>great</p>
+ *   )
+ *   .else(() => <p>no matches were found</p>)
+ */
+/* eslint-disable fp/no-mutation, fp/no-let */
+function match<Value, InferredOutput = never>(value?: Value) {
+  let getMatchingHandlerValue: () => any = () => undefined
+  let hasFoundMatch = false
+  let hasPredicatePassed = false
+
+  function makeMatchBuilder(passedValue: NonNullable<Value>) {
+    const matchBuilder = {} as Match<Value, InferredOutput>
+
+    function if_<Output>(
+      predicate: (value: NonNullable<Value>) => boolean,
+      handler: (value: NonNullable<Value>) => Output
+    ): Match<Value, Union<InferredOutput, Output>> {
+      try {
+        if (predicate(passedValue)) hasPredicatePassed = true
+      } catch (error) {}
+
+      if (!hasFoundMatch && hasPredicatePassed) {
+        hasFoundMatch = true
+        getMatchingHandlerValue = () => handler(passedValue)
+      }
+
+      return makeMatchBuilder(passedValue) as unknown as Match<
+        Value,
+        Union<InferredOutput, Output>
+      >
+    }
+
+    function else_<E>(fallback: () => E) {
+      let handlerValue
+      let hasError = false
+      try {
+        handlerValue = getMatchingHandlerValue()
+      } catch (error) {
+        hasError = true
+        console.error('Match: There was a problem inside your handler function 👇')
+        console.error(error)
+      }
+
+      return hasError || !hasFoundMatch ? fallback() : handlerValue
+    }
+
+    matchBuilder.if = if_
+    matchBuilder.else = else_
+
+    return matchBuilder
+  }
+
+  return makeMatchBuilder(value as NonNullable<Value>)
+}
+
+export { match }
+export { __ } from './helpers'