@helpwave/hightide 0.0.8 → 0.0.11

package/hooks/useLanguage.tsx

@@ -1,78 +0,0 @@
-import type { Dispatch, PropsWithChildren, SetStateAction } from 'react'
-import { createContext, useContext, useEffect, useState } from 'react'
-import useLocalStorage from './useLocalStorage'
-
-export const languages = ['en', 'de'] as const
-export type Languages = typeof languages[number]
-export const languagesLocalNames: Record<Languages, string> = {
-  en: 'English',
-  de: 'Deutsch',
-}
-
-export const DEFAULT_LANGUAGE = 'en'
-
-export type LanguageContextValue = {
-  language: Languages,
-  setLanguage: Dispatch<SetStateAction<Languages>>,
-}
-
-export const LanguageContext = createContext<LanguageContextValue>({ language: DEFAULT_LANGUAGE, setLanguage: (v) => v })
-
-export const useLanguage = () => useContext(LanguageContext)
-
-export const useLocale = (overWriteLanguage?: Languages) => {
-  const { language } = useLanguage()
-  const mapping: Record<Languages, string> = {
-    en: 'en-US',
-    de: 'de-DE'
-  }
-  return mapping[overWriteLanguage ?? language]
-}
-
-type ProvideLanguageProps = {
-  initialLanguage?: Languages,
-}
-
-export const ProvideLanguage = ({ initialLanguage, children }: PropsWithChildren<ProvideLanguageProps>) => {
-  const [language, setLanguage] = useState<Languages>(initialLanguage ?? DEFAULT_LANGUAGE)
-  const [storedLanguage, setStoredLanguage] = useLocalStorage<Languages>('language', initialLanguage ?? DEFAULT_LANGUAGE)
-
-  useEffect(() => {
-    if(language !== initialLanguage && initialLanguage){
-      console.warn('LanguageProvider initial state changed: Prefer using useLanguages\'s setLanguage instead')
-      setLanguage(initialLanguage)
-    }
-  }, [initialLanguage]) // eslint-disable-line react-hooks/exhaustive-deps
-
-  useEffect(() => {
-    // TODO set locale of html tag here as well
-    setStoredLanguage(language)
-  }, [language, setStoredLanguage])
-
-  useEffect(() => {
-    if (storedLanguage !== null) {
-      setLanguage(storedLanguage)
-      return
-    }
-
-    const languagesToTestAgainst = Object.values(languages)
-
-    const matchingBrowserLanguages = window.navigator.languages
-      .map(language => languagesToTestAgainst.find((test) => language === test || language.split('-')[0] === test))
-      .filter(entry => entry !== undefined)
-
-    if (matchingBrowserLanguages.length === 0) return
-
-    const firstMatch = matchingBrowserLanguages[0] as Languages
-    setLanguage(firstMatch)
-  }, []) // eslint-disable-line react-hooks/exhaustive-deps
-
-  return (
-    <LanguageContext.Provider value={{
-      language,
-      setLanguage
-    }}>
-      {children}
-    </LanguageContext.Provider>
-  )
-}

package/hooks/useLocalStorage.tsx

@@ -1,33 +0,0 @@
-import type { Dispatch, SetStateAction } from 'react'
-import { useCallback, useEffect, useState } from 'react'
-import { LocalStorageService } from '../util/storage'
-
-type SetValue<T> = Dispatch<SetStateAction<T>>
-const useLocalStorage = <T, >(key: string, initValue: T): [T, SetValue<T>] => {
-  const get = useCallback((): T => {
-    if (typeof window === 'undefined') {
-      return initValue
-    }
-    const storageService = new LocalStorageService()
-    const value = storageService.get<T>(key)
-    return value || initValue
-  }, [initValue, key])
-
-  const [storedValue, setStoredValue] = useState<T>(get)
-
-  const setValue: SetValue<T> = useCallback(value => {
-    const newValue = value instanceof Function ? value(storedValue) : value
-    const storageService = new LocalStorageService()
-    storageService.set(key, value)
-
-    setStoredValue(newValue)
-  }, [storedValue, setStoredValue, key])
-
-  useEffect(() => {
-    setStoredValue(get())
-  }, []) // eslint-disable-line react-hooks/exhaustive-deps
-
-  return [storedValue, setValue]
-}
-
-export default useLocalStorage

package/hooks/useOutsideClick.ts

@@ -1,25 +0,0 @@
-import { useEffect } from 'react'
-import type { RefObject } from 'react'
-
-export const useOutsideClick = <Ts extends RefObject<HTMLElement>[]>(refs: Ts, handler: () => void) => {
-  useEffect(() => {
-    const listener = (event: MouseEvent | TouchEvent) => {
-      // returning means not "not clicking outside"
-
-      // if no target exists, return
-      if (event.target === null) return
-      // if the target is a ref's element or descendent thereof, return
-      if (refs.some((ref) => !ref.current || ref.current.contains(event.target as Node))) {
-        return
-      }
-
-      handler()
-    }
-    document.addEventListener('mousedown', listener)
-    document.addEventListener('touchstart', listener)
-    return () => {
-      document.removeEventListener('mousedown', listener)
-      document.removeEventListener('touchstart', listener)
-    }
-  }, [refs, handler])
-}

package/hooks/useSaveDelay.ts

@@ -1,46 +0,0 @@
-import { useEffect, useState } from 'react'
-
-function useSaveDelay(setNotificationStatus: (isShowing: boolean) => void, delay: number) {
-  const [updateTimer, setUpdateTimer] = useState<NodeJS.Timeout | undefined>(undefined)
-  const [notificationTimer, setNotificationTimer] = useState<NodeJS.Timeout | undefined>(undefined)
-
-  const restartTimer = (onSave: () => void) => {
-    clearTimeout(updateTimer)
-    setUpdateTimer(setTimeout(() => {
-      onSave()
-      setNotificationStatus(true)
-      // Show Saved Notification for fade animation duration
-      clearTimeout(notificationTimer)
-      setNotificationTimer(setTimeout(() => {
-        setNotificationStatus(false)
-        clearTimeout(notificationTimer)
-      }, delay))
-      clearTimeout(updateTimer)
-    }, delay))
-  }
-
-  const clearUpdateTimer = (hasSaved = true) => {
-    clearTimeout(updateTimer)
-    if (hasSaved) {
-      setNotificationStatus(true)
-      clearTimeout(notificationTimer)
-      setNotificationTimer(setTimeout(() => {
-        setNotificationStatus(false)
-        clearTimeout(notificationTimer)
-      }, delay))
-    } else {
-      setNotificationStatus(false)
-    }
-  }
-
-  useEffect(() => {
-    return () => {
-      clearTimeout(updateTimer)
-      clearTimeout(notificationTimer)
-    }
-  }, []) // eslint-disable-line react-hooks/exhaustive-deps
-
-  return { restartTimer, clearUpdateTimer }
-}
-
-export default useSaveDelay

package/hooks/useTheme.tsx

@@ -1,57 +0,0 @@
-import { useContext } from 'react'
-import type { Dispatch, SetStateAction, PropsWithChildren } from 'react'
-import { createContext, useState, useEffect } from 'react'
-import type { Translation } from './useTranslation'
-
-export type ThemeType = 'light' | 'dark'
-
-export type ThemeTypeTranslation = Record<ThemeType, string>
-export const defaultThemeTypeTranslation: Translation<ThemeTypeTranslation> = {
-  en: {
-    dark: 'Dark',
-    light: 'Light'
-  },
-  de: {
-    dark: 'Dunkel',
-    light: 'Hell'
-  }
-}
-
-type ThemeContextType = {
-  theme: ThemeType,
-  setTheme: Dispatch<SetStateAction<ThemeType>>,
-}
-
-export const ThemeContext = createContext<ThemeContextType>({
-  theme: 'light',
-  setTheme: (_: SetStateAction<ThemeType>) => {
-  },
-})
-
-type ThemeProviderProps = {
-  initialTheme?: ThemeType,
-}
-
-export const ThemeProvider = ({ children, initialTheme = 'light' }: PropsWithChildren<ThemeProviderProps>) => {
-  const [theme, setTheme] = useState<ThemeType>(initialTheme)
-
-  useEffect(() => {
-    if (theme !== initialTheme) {
-      console.warn('ThemeProvider initial state changed: Prefer using useTheme\'s setTheme instead')
-      setTheme(initialTheme)
-    }
-  }, [initialTheme]) // eslint-disable-line react-hooks/exhaustive-deps
-
-  useEffect(() => {
-    document.documentElement.setAttribute('data-theme', theme)
-  }, [theme])
-
-  return (
-    <ThemeContext.Provider value={{ theme, setTheme }}>
-      {children}
-    </ThemeContext.Provider>
-  )
-}
-
-
-export const useTheme = () => useContext(ThemeContext)

package/hooks/useTranslation.ts

@@ -1,43 +0,0 @@
-import type { Languages } from './useLanguage'
-import { useLanguage } from './useLanguage'
-
-export type Translation<T> = Record<Languages, T>
-
-type OverwriteTranslationType<Translation extends Record<string, unknown>> = {
-  language?: Languages,
-  translation?: Partial<Record<Languages, Partial<Translation>>>,
-}
-
-/**
- * Adds the `language` prop to the component props.
- *
- * @param Translation the type of the translation object
- *
- * @param Props the type of the component props, defaults to `Record<string, never>`,
- *              if you don't expect any other props other than `language` and get an
- *              error when using your component (because it uses `forwardRef` etc.)
- *              you can try out `Record<string, unknown>`, this might resolve your
- *              problem as `SomeType & never` is still `never` but `SomeType & unknown`
- *              is `SomeType` which means that adding back props (like `ref` etc.)
- *              works properly
- */
-export type PropsForTranslation<
-  Translation extends Record<string, unknown>,
-  Props = Record<string, never>
-> = Props & {
-  overwriteTranslation?: OverwriteTranslationType<Translation>,
-};
-
-export const useTranslation = <Translation extends Record<string, unknown>>(
-  defaults: Record<Languages, Translation>,
-  translationOverwrite: OverwriteTranslationType<Translation> = {}
-) : Translation => {
-  const { language: languageProp, translation: overwrite } = translationOverwrite
-  const { language: inferredLanguage } = useLanguage()
-  const usedLanguage = languageProp ?? inferredLanguage
-  let defaultValues: Translation = defaults[usedLanguage]
-  if (overwrite && overwrite[usedLanguage]) {
-    defaultValues = { ...defaultValues, ...overwrite[usedLanguage] }
-  }
-  return defaultValues
-}

package/util/array.ts

@@ -1,115 +0,0 @@
-export const equalSizeGroups = <T >(array: T[], groupSize: number): T[][] => {
-  if (groupSize <= 0) {
-    console.warn(`group size should be greater than 0: groupSize = ${groupSize}`)
-    return [[...array]]
-  }
-
-  const groups = []
-  for (let i = 0; i < array.length; i += groupSize) {
-    groups.push(array.slice(i, Math.min(i + groupSize, array.length)))
-  }
-  return groups
-}
-
-/**
- * @param start
- * @param end inclusive
- * @param allowEmptyRange Whether the range can be defined empty via end < start
- */
-export const range = (start: number, end: number, allowEmptyRange: boolean = false): number[] => {
-  if (end < start) {
-    if (!allowEmptyRange) {
-      console.warn(`range: end (${end}) < start (${start}) should be allowed explicitly, set allowEmptyRange to true`)
-    }
-    return []
-  }
-  return Array.from({ length: end - start + 1 }, (_, index) => index + start)
-}
-
-/** Finds the closest match
- * @param list The list of all possible matches
- * @param firstCloser Return whether item1 is closer than item2
- */
-export const closestMatch = <T >(list: T[], firstCloser: (item1: T, item2: T) => boolean) => {
-  return list.reduce((item1, item2) => {
-    return firstCloser(item1, item2) ? item1 : item2
-  })
-}
-
-/**
- * returns the item in middle of a list and its neighbours before and after
- * e.g. [1,2,3,4,5,6] for item = 1 would return [5,6,1,2,3]
- */
-export const getNeighbours = <T >(list: T[], item: T, neighbourDistance: number = 2) => {
-  const index = list.indexOf(item)
-  const totalItems = neighbourDistance * 2 + 1
-  if (list.length < totalItems) {
-    console.warn('List is to short')
-    return list
-  }
-
-  if (index === -1) {
-    console.error('item not found in list')
-    return list.splice(0, totalItems)
-  }
-
-  let start = index - neighbourDistance
-  if (start < 0) {
-    start += list.length
-  }
-  const end = (index + neighbourDistance + 1) % list.length
-
-  const result: T[] = []
-  let ignoreOnce = list.length === totalItems
-  for (let i = start; i !== end || ignoreOnce; i = (i + 1) % list.length) {
-    result.push(list[i]!)
-    if (end === i && ignoreOnce) {
-      ignoreOnce = false
-    }
-  }
-  return result
-}
-
-export const createLoopingListWithIndex = <T >(list: T[], startIndex: number = 0, length: number = 0, forwards: boolean = true) => {
-  if (length < 0) {
-    console.warn(`createLoopingList: length must be >= 0, given ${length}`)
-  } else if (length === 0) {
-    length = list.length
-  }
-
-  const returnList: [number, T][] = []
-
-  if (forwards) {
-    for (let i = startIndex; returnList.length < length; i = (i + 1) % list.length) {
-      returnList.push([i, list[i]!])
-    }
-  } else {
-    for (let i = startIndex; returnList.length < length; i = i === 0 ? i = list.length - 1 : i - 1) {
-      returnList.push([i, list[i]!])
-    }
-  }
-
-  return returnList
-}
-
-export const createLoopingList = <T >(list: T[], startIndex: number = 0, length: number = 0, forwards: boolean = true) => {
-  return createLoopingListWithIndex(list, startIndex, length, forwards).map(([_, item]) => item)
-}
-
-export const ArrayUtil = {
-  unique: <T>(list: T[]): T[] => {
-    const seen = new Set<T>()
-    return list.filter((item) => {
-      if (seen.has(item)) {
-        return false
-      }
-      seen.add(item)
-      return true
-    })
-  },
-
-  difference: <T>(list: T[], removeList: T[]): T[] => {
-    const remove = new Set<T>(removeList)
-    return list.filter((item) => !remove.has(item))
-  }
-}

package/util/date.ts

@@ -1,180 +0,0 @@
-import { equalSizeGroups } from './array'
-
-export const monthsList = ['january', 'february', 'march', 'april', 'may', 'june', 'july', 'august', 'september', 'october', 'november', 'december'] as const
-export type Month = typeof monthsList[number]
-
-export const weekDayList = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'] as const
-export type WeekDay = typeof weekDayList[number]
-
-export const formatDate = (date: Date) => {
-  const year = date.getFullYear().toString().padStart(4, '0')
-  const month = (date.getMonth() + 1).toString().padStart(2, '0')
-  const day = (date.getDate()).toString().padStart(2, '0')
-  return `${year}-${month}-${day}`
-}
-
-export const formatDateTime = (date: Date) => {
-  const dateString = formatDate(date)
-  const hours = date.getHours().toString().padStart(2, '0')
-  const minutes = date.getMinutes().toString().padStart(2, '0')
-  return `${dateString}T${hours}:${minutes}`
-}
-
-export const getDaysInMonth = (year: number, month: number): number => {
-  const lastDayOfMonth = new Date(year, month + 1, 0)
-  return lastDayOfMonth.getDate()
-}
-
-export type Duration = {
-  years?: number,
-  months?: number,
-  days?: number,
-  hours?: number,
-  minutes?: number,
-  seconds?: number,
-  milliseconds?: number,
-}
-
-export const changeDuration = (date: Date, duration: Duration, isAdding?: boolean): Date => {
-  const {
-    years = 0,
-    months = 0,
-    days = 0,
-    hours = 0,
-    minutes = 0,
-    seconds = 0,
-    milliseconds = 0,
-  } = duration
-
-  // Check ranges
-  if (years < 0) {
-    console.error(`Range error years must be greater than 0: received ${years}`)
-    return new Date(date)
-  }
-  if (months < 0 || months > 11) {
-    console.error(`Range error month must be 0 <= month <= 11: received ${months}`)
-    return new Date(date)
-  }
-  if (days < 0) {
-    console.error(`Range error days must be greater than 0: received ${days}`)
-    return new Date(date)
-  }
-  if (hours < 0 || hours > 23) {
-    console.error(`Range error hours must be 0 <= hours <= 23: received ${hours}`)
-    return new Date(date)
-  }
-  if (minutes < 0 || minutes > 59) {
-    console.error(`Range error minutes must be 0 <= minutes <= 59: received ${minutes}`)
-    return new Date(date)
-  }
-  if (seconds < 0 || seconds > 59) {
-    console.error(`Range error seconds must be 0 <= seconds <= 59: received ${seconds}`)
-    return new Date(date)
-  }
-  if (milliseconds < 0) {
-    console.error(`Range error seconds must be greater than 0: received ${milliseconds}`)
-    return new Date(date)
-  }
-
-  const multiplier = isAdding ? 1 : -1
-
-  const newDate = new Date(date)
-
-  newDate.setFullYear(newDate.getFullYear() + multiplier * years)
-
-  newDate.setMonth(newDate.getMonth() + multiplier * months)
-
-  newDate.setDate(newDate.getDate() + multiplier * days)
-
-  newDate.setHours(newDate.getHours() + multiplier * hours)
-
-  newDate.setMinutes(newDate.getMinutes() + multiplier * minutes)
-
-  newDate.setSeconds(newDate.getSeconds() + multiplier * seconds)
-
-  newDate.setMilliseconds(newDate.getMilliseconds() + multiplier * milliseconds)
-
-  return newDate
-}
-
-export const addDuration = (date: Date, duration: Duration): Date => {
-  return changeDuration(date, duration, true)
-}
-
-export const subtractDuration = (date: Date, duration: Duration): Date => {
-  return changeDuration(date, duration, false)
-}
-
-export const getBetweenDuration = (startDate: Date, endDate: Date): Duration => {
-  const durationInMilliseconds = endDate.getTime() - startDate.getTime()
-
-  const millisecondsInSecond = 1000
-  const millisecondsInMinute = 60 * millisecondsInSecond
-  const millisecondsInHour = 60 * millisecondsInMinute
-  const millisecondsInDay = 24 * millisecondsInHour
-  const millisecondsInMonth = 30 * millisecondsInDay // Rough estimation, can be adjusted
-
-  const years = Math.floor(durationInMilliseconds / (365.25 * millisecondsInDay))
-  const months = Math.floor(durationInMilliseconds / millisecondsInMonth)
-  const days = Math.floor(durationInMilliseconds / millisecondsInDay)
-  const hours = Math.floor((durationInMilliseconds % millisecondsInDay) / millisecondsInHour)
-  const seconds = Math.floor((durationInMilliseconds % millisecondsInHour) / millisecondsInSecond)
-  const milliseconds = durationInMilliseconds % millisecondsInSecond
-
-  return {
-    years,
-    months,
-    days,
-    hours,
-    seconds,
-    milliseconds,
-  }
-}
-
-/** Checks if a given date is in the range of two dates
- *
- * An undefined value for startDate or endDate means no bound for the start or end respectively
- */
-export const isInTimeSpan = (value: Date, startDate?: Date, endDate?: Date): boolean => {
-  if(startDate && endDate) {
-    console.assert(startDate <= endDate)
-    return startDate <= value && value <= endDate
-  } else if (startDate) {
-    return startDate <= value
-  } else if(endDate) {
-    return endDate >= value
-  } else {
-    return true
-  }
-}
-
-/** Compare two dates on the year, month, day */
-export const equalDate = (date1: Date, date2: Date) => {
-  return date1.getFullYear() === date2.getFullYear()
-    && date1.getMonth() === date2.getMonth()
-    && date1.getDate() === date2.getDate()
-}
-
-export const getWeeksForCalenderMonth = (date: Date, weekStart: WeekDay, weeks: number = 6) => {
-  const month = date.getMonth()
-  const year = date.getFullYear()
-
-  const dayList: Date[] = []
-  let currentDate = new Date(year, month, 1) // Start of month
-  const weekStartIndex = weekDayList.indexOf(weekStart)
-
-  // Move the current day to the week before
-  while (currentDate.getDay() !== weekStartIndex) {
-    currentDate = subtractDuration(currentDate, { days: 1 })
-  }
-
-  while (dayList.length < 7 * weeks) {
-    const date = new Date(currentDate)
-    date.setHours(date.getHours(), date.getMinutes()) // To make sure we are not overwriting the time
-    dayList.push(date)
-    currentDate = addDuration(currentDate, { days: 1 })
-  }
-
-  // weeks
-  return equalSizeGroups(dayList, 7)
-}

package/util/easeFunctions.ts

@@ -1,37 +0,0 @@
-import { clamp } from './math'
-
-export type EaseFunction = (t: number) => number
-
-export class EaseFunctions {
-  static cubicBezierGeneric(x1: number, y1: number, x2: number, y2: number): { x: EaseFunction, y: EaseFunction } {
-    // Calculate the x and y coordinates using the cubic Bézier formula
-    const cx = 3 * x1
-    const bx = 3 * (x2 - x1) - cx
-    const ax = 1 - cx - bx
-
-    const cy = 3 * y1
-    const by = 3 * (y2 - y1) - cy
-    const ay = 1 - cy - by
-
-    // Compute x and y values at parameter t
-    const x = (t: number) => ((ax * t + bx) * t + cx) * t
-    const y = (t: number) => ((ay * t + by) * t + cy) * t
-
-    return {
-      x,
-      y
-    }
-  }
-
-  static cubicBezier(x1: number, y1: number, x2: number, y2: number): EaseFunction {
-    const { y } = EaseFunctions.cubicBezierGeneric(x1, y1, x2, y2)
-    return (t: number) => {
-      t = clamp(t)
-      return y(t) // <= equal to x(t) * 0 + y(t) * 1
-    }
-  }
-
-  static easeInEaseOut(t: number): number {
-    return EaseFunctions.cubicBezier(0.65, 0, 0.35, 1)(t)
-  };
-}

package/util/emailValidation.ts

@@ -1,3 +0,0 @@
-export const validateEmail = (email: string): boolean => {
-  return /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i.test(email)
-}