feat: add "match" util

Author: acd02

src/pages/_error.tsx

@@ -1,16 +1,22 @@
 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)
+    .with(
+      code => code === 404,
+      () => 'Oops, missing page'
+    )
+    .with(
+      code => !!code,
+      () => `An error ${statusCode} occurred on the server`
+    )
+    .otherwise(() => 'An error occurred on the client')
 
   return (
     <Box
@@ -27,13 +33,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,
+  })
+    .with(
+      ({ error }) => !!error,
+      ({ error }) => error?.statusCode
+    )
+    .with(
+      ({ response }) => !!response,
+      ({ response }) => response?.statusCode
+    )
+    .otherwise(() => 404)
 
-  return { statusCode }
+  return {
+    statusCode,
+  }
 }
 
 export default Error

src/utils/match.ts

@@ -0,0 +1,61 @@
+// 🙏 shoutout to -> https://github.com/gvergnaud/ts-pattern
+
+type Union<a, b> = [b] extends [a] ? a : [a] extends [b] ? b : a | b
+
+type Match<T, InferredOutput = never> = {
+  /**
+   * if the `predicate` func returns true, the value returned by the `handler` will be the one returned when calling `otherwise`
+   */
+  with: <O>(
+    predicate: (value: T) => boolean,
+    handler: (value: T) => O
+  ) => Match<T, Union<InferredOutput, O>>
+  /**
+   * takes a function allowing one to return a fallback value in case no match were found
+   */
+  otherwise: <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 .with(predicate, handler) clauses
+ *
+ * @example
+ *
+ * type Status = 'idle' | 'loading' | 'success' | 'error'
+ *
+ * const result = match(status)
+ *   .with(s => s === 'idle', (s) => <p>is {s}</p>) // s === "idle"
+ *   .with(s => s === 'loading', (s) => <Loader />) // s === "loading"
+ *   .otherwise(() => <p>either in success or in error</p>) // s === "success" | "error"
+ *
+ */
+/* eslint-disable fp/no-mutation, fp/no-let */
+export function match<T, U = never>(value?: T) {
+  let outputValue: any
+
+  function self(passedValue: T) {
+    const matchBuilder = {} as Match<T, U>
+
+    function with_<O>(
+      predicate: (value: T) => boolean,
+      handler: (value: T) => O
+    ): Match<T, Union<U, O>> {
+      if (!outputValue && predicate(passedValue)) outputValue = handler(passedValue)
+
+      return self(passedValue) as unknown as Match<T, Union<U, O>>
+    }
+
+    function otherwise<O>(fallback: () => O) {
+      return outputValue || fallback()
+    }
+
+    matchBuilder.with = with_
+    matchBuilder.otherwise = otherwise
+
+    return matchBuilder
+  }
+
+  return self(value as T)
+}