@helpwave/hightide 0.0.1

package/util/loopingArray.ts

@@ -0,0 +1,94 @@
+/**
+ *  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

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

package/util/news.ts

@@ -0,0 +1,43 @@
+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

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

package/util/simpleSearch.ts

@@ -0,0 +1,65 @@
+/**
+ *  Finds all values matching the search values by first mapping the values to a string array and then checking each entry for matches.
+ *  Returns the list of all matches.
+ *
+ *  @param search The list of search strings e.g. `[name, type]`
+ *
+ *  @param objects The list of objects to be searched in
+ *
+ *  @param mapping The mapping of objects to the string properties they fulfil
+ *
+ *  @return The list of objects that match all search strings
+ */
+export const MultiSubjectSearchWithMapping = <T>(search: string[], objects: T[], mapping: (value:T) => (string| undefined)[]) => {
+  return objects.filter(object => {
+    const mappedSearchKeywords = mapping(object).map(value => value ? value.toLowerCase().trim() : undefined)
+    return search.every(searchValue => !!mappedSearchKeywords.find(value => !!value && value.includes(searchValue.toLowerCase().trim())))
+  })
+}
+
+/**
+ *  Finds all values matching the search value by first mapping the values to a string array and then checking each entry for matches.
+ *  Returns the list of all matches.
+ *
+ *  @param search The search string e.g `name`
+ *
+ *  @param objects The list of objects to be searched in
+ *
+ *  @param mapping The mapping of objects to the string properties they fulfil
+ *
+ *  @return The list of objects that match the search string
+ */
+export const MultiSearchWithMapping = <T>(search: string, objects: T[], mapping: (value:T) => string[]) => {
+  return objects.filter(object => {
+    const mappedSearchKeywords = mapping(object).map(value => value.toLowerCase().trim())
+    return !!mappedSearchKeywords.find(value => value.includes(search.toLowerCase().trim()))
+  })
+}
+
+/**
+ *  Finds all values matching the search value by first mapping the values to a string and returns the list of all matches.
+ *
+ *  @param search The search string e.g `name`
+ *
+ *  @param objects The list of objects to be searched in
+ *
+ *  @param mapping The mapping of objects to a string that is compared to the search
+ *
+ *  @return The list of objects that match the search string
+ */
+export const SimpleSearchWithMapping = <T>(search: string, objects: T[], mapping: (value:T) => string) => {
+  return MultiSearchWithMapping(search, objects, value => [mapping(value)])
+}
+
+/**
+ *  Finds all values matching the search value and returns the list of all matches.
+ *
+ *  @param search The search string e.g `name`
+ *
+ *  @param objects The list of objects to be searched in
+ *
+ *  @return The list of objects that match the search string
+ */
+export const SimpleSearch = (search: string, objects: string[]) => {
+  return SimpleSearchWithMapping(search, objects, value => value)
+}

package/util/storage.ts

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,4 @@
+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>