Format

styles/src/element/interactive.ts

@@ -2,28 +2,28 @@ import merge from "ts-deepmerge"
 import { DeepPartial } from "utility-types"
 
 type InteractiveState =
-  | "default"
-  | "hovered"
-  | "clicked"
-  | "selected"
-  | "disabled"
+    | "default"
+    | "hovered"
+    | "clicked"
+    | "selected"
+    | "disabled"
 
 type Interactive<T> = {
-  default: T
-  hovered?: T
-  clicked?: T
-  selected?: T
-  disabled?: T
+    default: T
+    hovered?: T
+    clicked?: T
+    selected?: T
+    disabled?: T
 }
 
 export const NO_DEFAULT_OR_BASE_ERROR =
-  "An interactive object must have a default state, or a base property."
+    "An interactive object must have a default state, or a base property."
 export const NOT_ENOUGH_STATES_ERROR =
-  "An interactive object must have a default and at least one other state."
+    "An interactive object must have a default and at least one other state."
 
 interface InteractiveProps<T> {
-  base?: T
-  state: Partial<Record<InteractiveState, DeepPartial<T>>>
+    base?: T
+    state: Partial<Record<InteractiveState, DeepPartial<T>>>
 }
 
 /**
@@ -38,60 +38,60 @@ interface InteractiveProps<T> {
  * @returns Interactive<T> object with fields from `base` and `state`.
  */
 export function interactive<T extends Object>({
-  base,
-  state,
+    base,
+    state,
 }: InteractiveProps<T>): Interactive<T> {
-  if (!base && !state.default) throw new Error(NO_DEFAULT_OR_BASE_ERROR)
+    if (!base && !state.default) throw new Error(NO_DEFAULT_OR_BASE_ERROR)
 
-  let defaultState: T
+    let defaultState: T
 
-  if (state.default && base) {
-    defaultState = merge(base, state.default) as T
-  } else {
-    defaultState = base ? base : (state.default as T)
-  }
+    if (state.default && base) {
+        defaultState = merge(base, state.default) as T
+    } else {
+        defaultState = base ? base : (state.default as T)
+    }
 
-  let interactiveObj: Interactive<T> = {
-    default: defaultState,
-  }
+    let interactiveObj: Interactive<T> = {
+        default: defaultState,
+    }
 
-  let stateCount = 0
+    let stateCount = 0
 
-  if (state.hovered !== undefined) {
-    interactiveObj.hovered = merge(
-      interactiveObj.default,
-      state.hovered
-    ) as T
-    stateCount++
-  }
+    if (state.hovered !== undefined) {
+        interactiveObj.hovered = merge(
+            interactiveObj.default,
+            state.hovered
+        ) as T
+        stateCount++
+    }
 
-  if (state.clicked !== undefined) {
-    interactiveObj.clicked = merge(
-      interactiveObj.default,
-      state.clicked
-    ) as T
-    stateCount++
-  }
+    if (state.clicked !== undefined) {
+        interactiveObj.clicked = merge(
+            interactiveObj.default,
+            state.clicked
+        ) as T
+        stateCount++
+    }
 
-  if (state.selected !== undefined) {
-    interactiveObj.selected = merge(
-      interactiveObj.default,
-      state.selected
-    ) as T
-    stateCount++
-  }
+    if (state.selected !== undefined) {
+        interactiveObj.selected = merge(
+            interactiveObj.default,
+            state.selected
+        ) as T
+        stateCount++
+    }
 
-  if (state.disabled !== undefined) {
-    interactiveObj.disabled = merge(
-      interactiveObj.default,
-      state.disabled
-    ) as T
-    stateCount++
-  }
+    if (state.disabled !== undefined) {
+        interactiveObj.disabled = merge(
+            interactiveObj.default,
+            state.disabled
+        ) as T
+        stateCount++
+    }
 
-  if (stateCount < 1) {
-    throw new Error(NOT_ENOUGH_STATES_ERROR)
-  }
+    if (stateCount < 1) {
+        throw new Error(NOT_ENOUGH_STATES_ERROR)
+    }
 
-  return interactiveObj
+    return interactiveObj
 }

styles/src/element/toggle.ts

@@ -6,12 +6,12 @@ type ToggleState = "inactive" | "active"
 type Toggleable<T> = Record<ToggleState, T>
 
 export const NO_INACTIVE_OR_BASE_ERROR =
-  "A toggleable object must have an inactive state, or a base property."
+    "A toggleable object must have an inactive state, or a base property."
 export const NO_ACTIVE_ERROR = "A toggleable object must have an active state."
 
 interface ToggleableProps<T> {
-  base?: T
-  state: Partial<Record<ToggleState, DeepPartial<T>>>
+    base?: T
+    state: Partial<Record<ToggleState, DeepPartial<T>>>
 }
 
 /**
@@ -28,20 +28,20 @@ interface ToggleableProps<T> {
  * ```
  */
 export function toggleable<T extends object>(
-  props: ToggleableProps<T>
+    props: ToggleableProps<T>
 ): Toggleable<T> {
-  const { base, state } = props
+    const { base, state } = props
 
-  if (!base && !state.inactive) throw new Error(NO_INACTIVE_OR_BASE_ERROR)
-  if (!state.active) throw new Error(NO_ACTIVE_ERROR)
+    if (!base && !state.inactive) throw new Error(NO_INACTIVE_OR_BASE_ERROR)
+    if (!state.active) throw new Error(NO_ACTIVE_ERROR)
 
-  const inactiveState = base
-    ? ((state.inactive ? merge(base, state.inactive) : base) as T)
-    : (state.inactive as T)
+    const inactiveState = base
+        ? ((state.inactive ? merge(base, state.inactive) : base) as T)
+        : (state.inactive as T)
 
-  const toggleObj: Toggleable<T> = {
-    inactive: inactiveState,
-    active: merge(base ?? {}, state.active) as T,
-  }
-  return toggleObj
+    const toggleObj: Toggleable<T> = {
+        inactive: inactiveState,
+        active: merge(base ?? {}, state.active) as T,
+    }
+    return toggleObj
 }