@helpwave/hightide 0.0.9 → 0.0.12

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)
-}

package/util/loopingArray.ts

@@ -1,94 +0,0 @@
-/**
- *  1 is forwards
- *
- * -1 is backwards
- */
-export type Direction = 1 | -1
-
-export class LoopingArrayCalculator {
-  length: number
-  isLooping: boolean
-  allowedOverScroll: number
-
-  constructor(length: number, isLooping: boolean = true, allowedOverScroll: number = 0.1) {
-    if (allowedOverScroll < 0 || length < 1) {
-      throw new Error('Invalid parameters: allowedOverScroll >= 0 and length >= 1 must be true')
-    }
-
-    this.length = length
-    this.isLooping = isLooping
-    this.allowedOverScroll = allowedOverScroll
-  }
-
-  getCorrectedPosition(position: number): number {
-    if (!this.isLooping) {
-      return Math.max(-this.allowedOverScroll, Math.min(this.allowedOverScroll + this.length - 1, position))
-    }
-    if (position >= this.length) {
-      return position % this.length
-    }
-    if (position < 0) {
-      return this.length - (Math.abs(position) % this.length)
-    }
-    return position
-  }
-
-  static withoutOffset(position: number): number {
-    return position + LoopingArrayCalculator.getOffset(position)
-  }
-
-  static getOffset(position: number): number {
-    return Math.round(position) - position // For example: 45.5 => 46 - 45.5 = 0.5
-  }
-
-  /**
-   * @return absolute distance forwards or Infinity when the target cannot be reached (only possible when not isLooping)
-   */
-  getDistanceDirectional(position: number, target: number, direction: Direction): number {
-    if (!this.isLooping && (position < -this.allowedOverScroll || position > this.allowedOverScroll + this.length - 1)) {
-      throw new Error('Invalid parameters: position is out of bounds.')
-    }
-
-    const isForwardInvalid = (direction === 1 && position > target)
-    const isBackwardInvalid = (direction === -1 && target < position)
-
-    if (!this.isLooping && (isForwardInvalid || isBackwardInvalid)) {
-      return Infinity
-    }
-
-    if (direction === -1) {
-      return this.getDistanceDirectional(target, position, 1)
-    }
-
-    position = this.getCorrectedPosition(position)
-    target = this.getCorrectedPosition(target)
-
-    let distance = (target - position) * direction
-    if (distance < 0) {
-      distance = this.length - (Math.abs(position) % this.length) + target
-    }
-
-    return distance
-  }
-
-  getDistanceForward(position: number, target: number): number {
-    return this.getDistanceDirectional(position, target, 1)
-  }
-
-  getDistanceBackward(position: number, target: number): number {
-    return this.getDistanceDirectional(position, target, -1)
-  }
-
-  getDistance(position: number, target: number): number {
-    const forwardDistance = this.getDistanceForward(position, target)
-    const backwardDistance = this.getDistanceBackward(position, target)
-
-    return Math.min(forwardDistance, backwardDistance)
-  }
-
-  getBestDirection(position: number, target: number): Direction {
-    const forwardDistance = this.getDistanceForward(position, target)
-    const backwardDistance = this.getDistanceBackward(position, target)
-    return forwardDistance < backwardDistance ? 1 : -1
-  }
-}

package/util/math.ts

@@ -1,3 +0,0 @@
-export const clamp = (value: number, min: number = 0, max: number = 1): number => {
-  return Math.min(Math.max(value, min), max)
-}

package/util/news.ts

@@ -1,43 +0,0 @@
-import { z } from 'zod'
-import type { Languages } from '../hooks/useLanguage'
-import { languages } from '../hooks/useLanguage'
-
-export type News = {
-  title: string,
-  date: Date,
-  description: (string | URL)[],
-  externalResource?: URL,
-  keys: string[],
-}
-
-export type LocalizedNews = Record<Languages, News[]>
-
-export const newsSchema = z.object({
-  title: z.string(),
-  description: z.string(),
-  date: z.string(),
-  image: z.string().url().optional(),
-  externalResource: z.string().url().optional(),
-  keys: z.array(z.string())
-}).transform<News>((obj) => {
-  let description: (string | URL)[] = [obj.description]
-  if (obj.image) {
-    description = [new URL(obj.image), ...description]
-  }
-
-  return {
-    title: obj.title,
-    date: new Date(obj.date),
-    description,
-    externalResource: obj.externalResource ? new URL(obj.externalResource) : undefined,
-    keys: obj.keys
-  }
-})
-
-export const newsListSchema = z.array(newsSchema)
-
-export const localizedNewsSchema = z.record(z.enum(languages), newsListSchema)
-
-export const filterNews = (localizedNews: News[], requiredKeys: string[]) => {
-  return localizedNews.filter(news => requiredKeys.every(value => news.keys.includes(value)))
-}

package/util/noop.ts

@@ -1 +0,0 @@
-export const noop = () => undefined

package/util/storage.ts

@@ -1,37 +0,0 @@
-class StorageService {
-  // this seems to be a bug in eslint as 'paramter-properties' is a special syntax of typescript
-
-  constructor(private storage: Storage) {}
-
-  public get<T>(key: string): T | null {
-    const value = this.storage.getItem(key)
-    if (value === null) {
-      return null
-    }
-    return JSON.parse(value)
-  }
-
-  public set<T>(key: string, value: T) {
-    this.storage.setItem(key, JSON.stringify(value))
-  }
-
-  public delete(key: string) {
-    this.storage.removeItem(key)
-  }
-
-  public deleteAll() {
-    this.storage.clear()
-  }
-}
-
-export class LocalStorageService extends StorageService {
-  constructor() {
-    super(window.localStorage)
-  }
-}
-
-export class SessionStorageService extends StorageService {
-  constructor() {
-    super(window.sessionStorage)
-  }
-}

package/util/types.ts

@@ -1,4 +0,0 @@
-export type NativeProps<
-  NativeElement extends keyof React.ReactHTML,
-  OmittedKeys extends string | number | symbol | undefined = undefined
-> = Omit<React.JSX.IntrinsicElements[NativeElement], OmittedKeys extends undefined ? 'ref' : 'ref' | OmittedKeys>