@olea-bps/base 1.1.7 → 1.1.9

package/components/ContactDetail/index.js

@@ -158,15 +158,15 @@ export default function ContactDetailComponent({ contact, ...restProps }) {
                 {
                     contact?.email
                         ? <TouchableOpacity
-                            key="email"
+                            key='mail'
                             onPress={() => Linking.openURL('mailto:' + contact.email)}
                         >
-                            <List.Item
+                            <IconListItem
                                 title={t('contact:email')}
                                 description={contact.email}
                                 descriptionStyle={themeStyles.textLighter}
                                 titleStyle={themeStyles.searchDetailTitle}
-                                right={props => <List.Icon {...props} icon="email" />}
+                                icon={'mail'}
                             />
                         </TouchableOpacity>
                         : null

package/components/NewsDetail/styles.js

@@ -1,77 +1,77 @@
-import {Dimensions} from "react-native";
+import { Dimensions } from 'react-native'
 
-export default function(theme) {
-    const height = Dimensions.get('window').height;
-    const width = Dimensions.get('window').width;
-    return {
-        overflow: {
-            backgroundColor: theme.colors.overlayColor,
-        },
-        image: {
-            position: 'absolute',
-            top: 0,
-            left: 0,
-            right: 0,
-            width: null,
-            resizeMode: 'cover',
-        },
-        container: {
-            flex: 1,
-            overflow: 'hidden'
-        },
-        containerInner: {
-            flex: 1
-        },
-        containerContent: {
-            backgroundColor: theme.colors.contentBackground,
-            flex: 1,
-            paddingHorizontal: 5,
-            paddingVertical: 20,
-            minHeight: height * 1.25 // To make sure the animation won't break / stop
-        },
-        activity: {
-            marginTop: 20
-        },
-        badges: {
-            flexDirection: 'row',
-            flexWrap: 'wrap',
-            paddingHorizontal: 10
-        },
-        badge: {
-            marginRight: 5,
-            marginBottom: 5
-        },
-        title: {
-            paddingLeft: 10,
-            fontSize: theme.fontSizes.title,
-            lineHeight: theme.lineHeights.titleBig
-        },
-        bar: {
-            alignItems: 'flex-start',
-            justifyContent: 'center',
-            position: 'absolute',
-            top: 5,
-            left: 0,
-            right: 0,
-        },
-        barText: {
-            color: theme.colors.primaryText,
-            ...theme.fonts.bold,
-        },
-        newsContent : {
-            marginVertical: theme.paddings.default,
-            marginHorizontal: theme.paddings.small,
-            width: width - (2 * theme.paddings.small)
-        },
-        newsContentText: {
-            fontSize: theme.fontSizes.m
-        },
-        imageDesc: {
-            backgroundColor: theme.colors.overlayColor,
-            color: theme.colors.primaryText,
-            paddingVertical: 2,
-            paddingHorizontal: theme.paddings.small,
-            fontSize: theme.fontSizes.xs
-        }
-    };
+export default function (theme) {
+  const height = Dimensions.get('window').height
+  const width = Dimensions.get('window').width
+  return {
+    overflow: {
+      backgroundColor: theme.colors.overlayColor
+    },
+    image: {
+      position: 'absolute',
+      top: 0,
+      left: 0,
+      right: 0,
+      width: null,
+      resizeMode: 'cover'
+    },
+    container: {
+      flex: 1,
+      overflow: 'hidden'
+    },
+    containerInner: {
+      flex: 1
+    },
+    containerContent: {
+      backgroundColor: theme.colors.contentBackground,
+      flex: 1,
+      paddingHorizontal: 5,
+      paddingVertical: 20,
+      minHeight: height // enough space for short news without excessive whitespace
+    },
+    activity: {
+      marginTop: 20
+    },
+    badges: {
+      flexDirection: 'row',
+      flexWrap: 'wrap',
+      paddingHorizontal: 10
+    },
+    badge: {
+      marginRight: 5,
+      marginBottom: 5
+    },
+    title: {
+      paddingLeft: 10,
+      fontSize: theme.fontSizes.title,
+      lineHeight: theme.lineHeights.titleBig
+    },
+    bar: {
+      alignItems: 'flex-start',
+      justifyContent: 'center',
+      position: 'absolute',
+      top: 5,
+      left: 0,
+      right: 0
+    },
+    barText: {
+      color: theme.colors.primaryText,
+      ...theme.fonts.bold
+    },
+    newsContent: {
+      marginVertical: theme.paddings.default,
+      marginHorizontal: theme.paddings.small,
+      width: width - (2 * theme.paddings.small)
+    },
+    newsContentText: {
+      fontSize: theme.fontSizes.m
+    },
+    imageDesc: {
+      backgroundColor: theme.colors.overlayColor,
+      color: theme.colors.primaryText,
+      paddingVertical: 2,
+      paddingHorizontal: theme.paddings.small,
+      fontSize: theme.fontSizes.xs
+    }
+  }
 }

package/context/context-timetable/TimetableService.js

@@ -1,11 +1,12 @@
-import { useSyncExternalStore } from 'react';
+import { useSyncExternalStore } from 'react'
 
-import * as SecureStore from 'expo-secure-store';
+import * as SecureStore from 'expo-secure-store'
+import { getSecureItem, secureStoreOptions } from '../../libraries/stored-state'
 
-import { groupBy } from 'lodash';
-import { DateTime, Duration } from 'luxon';
+import { groupBy } from 'lodash'
+import { DateTime, Duration } from 'luxon'
 
-import CollectorVersion2ApiProvider from './CollectorVersion2ApiProvider';
+import CollectorVersion2ApiProvider from './CollectorVersion2ApiProvider'
 
 /**
  * @typedef TimetableProvider
@@ -44,21 +45,21 @@ import CollectorVersion2ApiProvider from './CollectorVersion2ApiProvider';
  * @property {CourseTime[]} times
  */
 
-const TimetableCodeStoreKey = 'timetable.code';
-const TimetableCoursesStoreKey = 'timetable.courses';
+const TimetableCodeStoreKey = 'timetable.code'
+const TimetableCoursesStoreKey = 'timetable.courses'
 
 export class ApiProviderNotInitializedError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = this.constructor.name;
-    }
+  constructor (message) {
+    super(message)
+    this.name = this.constructor.name
+  }
 }
 
 export class TimetableCodeNotInitializedError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = this.constructor.name;
-    }
+  constructor (message) {
+    super(message)
+    this.name = this.constructor.name
+  }
 }
 
 /**
@@ -71,13 +72,12 @@ export class TimetableCodeNotInitializedError extends Error {
  * Der Service sollte über {@linkcode TimetableService.fromProviderSettingsObject} initialisert werden.
  */
 export default class TimetableService {
-
-    /**
+  /**
      * @type {TimetableProvider}
      */
-    #provider;
+  #provider
 
-    /**
+  /**
      * Konstruktor des Stundenplan-Services.
      * Es muss ein Provider Übergeben werden, damit der Stundenplan-Service Daten über den Provider abrufen kann.
      * Es wird empfohlen {@linkcode TimetableService.fromProviderSettingsObject} zu verwenden.
@@ -92,199 +92,194 @@ export default class TimetableService {
      *
      * const timetableService = TimetableService.fromProviderSettingsObject(providerSettings, language);
      */
-    constructor(provider) {
-        this.#provider = provider;
+  constructor (provider) {
+    this.#provider = provider
 
-        this.#code = SecureStore.getItem(TimetableCodeStoreKey);
-        this.#courses = JSON.parse(SecureStore.getItem(TimetableCoursesStoreKey));
-    }
+    this.#code = getSecureItem(TimetableCodeStoreKey)
+    this.#courses = JSON.parse(getSecureItem(TimetableCoursesStoreKey))
+  }
 
+  #code = undefined
+  #codeSubscribers = new Set()
 
+  code () {
+    return this.#code
+  }
 
-    #code = undefined;
-    #codeSubscribers = new Set();
+  codeCallback = () => this.code()
 
-    code() {
-        return this.#code;
-    }
-    codeCallback = () => this.code();
+  #setCode (code) {
+    this.#code = code
+    this.#codeSubscribers.forEach(subscriber => subscriber(code))
+  }
 
-    #setCode(code) {
-        this.#code = code;
-        this.#codeSubscribers.forEach(subscriber => subscriber(code));
-    }
-    async setCode(code) {
-        await SecureStore.setItemAsync(TimetableCodeStoreKey, code);
-        this.#setCode(code);
-    }
-    setCodeCallback = async (code) => this.setCode(code);
+  async setCode (code) {
+    await SecureStore.setItemAsync(TimetableCodeStoreKey, code, secureStoreOptions)
+    this.#setCode(code)
+  }
 
-    async deleteCode() {
+  setCodeCallback = async (code) => this.setCode(code)
 
-        await Promise.all([
-            SecureStore.deleteItemAsync(TimetableCodeStoreKey),
-            SecureStore.deleteItemAsync(TimetableCoursesStoreKey),
-        ]);
+  async deleteCode () {
+    await Promise.all([
+      SecureStore.deleteItemAsync(TimetableCodeStoreKey),
+      SecureStore.deleteItemAsync(TimetableCoursesStoreKey)
+    ])
 
-        this.#setCode(null);
-        this.#setCourses(null);
-    }
-    deleteCodeCallback = () => this.deleteCode();
+    this.#setCode(null)
+    this.#setCourses(null)
+  }
 
-    codeSubscribe(subscriber) {
-        this.#codeSubscribers.add(subscriber);
+  deleteCodeCallback = () => this.deleteCode()
 
-        return () => this.codeUnsubscribe(subscriber);
-    }
-    codeSubscribeCallback = (subscriber) => this.codeSubscribe(subscriber);
+  codeSubscribe (subscriber) {
+    this.#codeSubscribers.add(subscriber)
 
-    codeUnsubscribe(subscriber) {
-        return this.#codeSubscribers.delete(subscriber);
-    }
+    return () => this.codeUnsubscribe(subscriber)
+  }
 
+  codeSubscribeCallback = (subscriber) => this.codeSubscribe(subscriber)
 
+  codeUnsubscribe (subscriber) {
+    return this.#codeSubscribers.delete(subscriber)
+  }
 
-    /**
+  /**
      * @type {Object.<string, Course[]>}
      */
-    #courses = undefined;
-    #coursesSubscribers = new Set();
+  #courses = undefined
+  #coursesSubscribers = new Set()
 
-    /**
+  /**
      * Liefert die Vorlesungen, die von dem Service respeichert werden zurück.
      * Dabei werden die Vorlesungen nach Vorlesungstagen gruppiert.
      * Somit wird ein Object zurückgegeben, bei dem die Schlüssel ISO-Datums der Vorlesungstage sind und die Werte sind Listen mit Vorlesungen
      *
      * @returns {Object.<string, Course[]>} Vorlesungen gruppiert nach Vorlesungstagen
      */
-    courses() {
-        return this.#courses;
-    }
+  courses () {
+    return this.#courses
+  }
 
-    #setCourses(courses) {
-        // Neue Vorlesungsdaten im Service hinterlegen
-        this.#courses = courses;
+  #setCourses (courses) {
+    // Neue Vorlesungsdaten im Service hinterlegen
+    this.#courses = courses
 
-        // Jedem Subscriber werden die neuen Vorlesungstage bekannt gemacht
-        this.#coursesSubscribers.forEach(subscriber => subscriber(this.#courses));
-    }
+    // Jedem Subscriber werden die neuen Vorlesungstage bekannt gemacht
+    this.#coursesSubscribers.forEach(subscriber => subscriber(this.#courses))
+  }
 
-    coursesCallback = () => this.courses();
+  coursesCallback = () => this.courses()
 
-    async refreshCourses(startDate, endDate) {
+  async refreshCourses (startDate, endDate) {
+    if (this.#provider === null) {
+      throw new ApiProviderNotInitializedError('Api Provider is not initilized')
+    }
 
-        if (this.#provider === null) {
-            throw new ApiProviderNotInitializedError('Api Provider is not initilized');
-        }
+    if (this.#code === null) {
+      throw new TimetableCodeNotInitializedError('Timetable code is not initilized')
+    }
 
-        if (this.#code === null) {
-            throw new TimetableCodeNotInitializedError('Timetable code is not initilized');
+    const courses = await this.#provider.getByCode(this.#code, startDate, endDate)
+    const transformedCourses = courses.map(
+      course => {
+        // Erstes Time-Element aus dem times-Array nehmen, da im neuen Format nur noch eine Zeit enthalten ist
+        const courseTime = course?.times?.[0]
+        if (courseTime) {
+          const courseDate = DateTime.fromISO(courseTime?.date)
+          // Startzeit und Endzeit der Vorlesung in ein DateTime umwandeln
+          const courseStartTime = Duration.fromISOTime(courseTime.start)
+          const courseStartDateTime = courseDate.plus(courseStartTime)
+          const courseEndTime = Duration.fromISOTime(courseTime.end)
+          const courseEndDateTime = courseDate.plus(courseEndTime)
+
+          return {
+            ...course,
+            startDateTime: courseStartDateTime.toISO(),
+            endDateTime: courseEndDateTime.toISO()
+          }
+        } else {
+          return course
         }
-
-        const courses = await this.#provider.getByCode(this.#code, startDate, endDate);
-        const transformedCourses = courses.map(
-            course => {
-                // Erstes Time-Element aus dem times-Array nehmen, da im neuen Format nur noch eine Zeit enthalten ist
-                const courseTime = course?.times?.[0];
-                if (courseTime) {
-                    const courseDate = DateTime.fromISO(courseTime?.date);
-                    // Startzeit und Endzeit der Vorlesung in ein DateTime umwandeln
-                    const courseStartTime = Duration.fromISOTime(courseTime.start);
-                    const courseStartDateTime = courseDate.plus(courseStartTime);
-                    const courseEndTime = Duration.fromISOTime(courseTime.end);
-                    const courseEndDateTime = courseDate.plus(courseEndTime);
-
-                    return {
-                        ...course,
-                        startDateTime: courseStartDateTime.toISO(),
-                        endDateTime: courseEndDateTime.toISO(),
-                    }
-                } else {
-                    return course;
-                }
-            }
-        )
-
-        // Gruppieren der vom Provider abgeholten Vorlesungen
-        // Es wird nach dem Datum der Vorlesungen gruppiert
-        // Vorlesungen, die keinem Tag zugeordnet werden können, werden untder dem Schlüssel `undefined` zusammengefasst
-        const addingCourses = groupBy(
-            transformedCourses,
-            course => {
-                // Datum der Vorlesung aus der Vorlesung holen
-                const courseDate = course?.times?.[0]?.date;
-
-                // Prüfen ob die Vorlesung einen Wert als Datum vorweist
-                return courseDate
-                    // Ist ein Wert vorhanden, wird dieser für die Gruppierung verwendet
-                    ? courseDate
-                    // Ansonsten wird undefined zurückgeben (lerrer String, null, undefined, ...)
-                    : undefined;
-            }
-        );
-
-        //Entfernen der Vorlesungstage zwischen Startdatum und Enddatum
-        const rangeRemovedCourses = Object.fromEntries(
-            Object.entries(this.#courses ?? {})
-                .filter(([coursesDate,]) => startDate >= coursesDate && coursesDate <= endDate)
-        );
-
-        // Zusammenführen der neuen Vorlesungstagen der Vorlesungen des Providers und der schon vorhandenen Vorlesungstagen
-        const newCourses = {
-            ...rangeRemovedCourses,
-            ...addingCourses,
-        };
-
-        // Neue Vorlesungsdaten in den Cache ablegen
-        SecureStore.setItem(TimetableCoursesStoreKey, JSON.stringify(newCourses));
-
-        // Neue Vorlesungen hin Service hinterlegen und Äanderun bekannt geben
-        this.#setCourses(newCourses);
+      }
+    )
+
+    // Gruppieren der vom Provider abgeholten Vorlesungen
+    // Es wird nach dem Datum der Vorlesungen gruppiert
+    // Vorlesungen, die keinem Tag zugeordnet werden können, werden untder dem Schlüssel `undefined` zusammengefasst
+    const addingCourses = groupBy(
+      transformedCourses,
+      course => {
+        // Datum der Vorlesung aus der Vorlesung holen
+        const courseDate = course?.times?.[0]?.date
+
+        // Prüfen ob die Vorlesung einen Wert als Datum vorweist
+        return courseDate || undefined
+      }
+    )
+
+    // Entfernen der Vorlesungstage zwischen Startdatum und Enddatum
+    const rangeRemovedCourses = Object.fromEntries(
+      Object.entries(this.#courses ?? {})
+        .filter(([coursesDate]) => startDate >= coursesDate && coursesDate <= endDate)
+    )
+
+    // Zusammenführen der neuen Vorlesungstagen der Vorlesungen des Providers und der schon vorhandenen Vorlesungstagen
+    const newCourses = {
+      ...rangeRemovedCourses,
+      ...addingCourses
     }
-    refreshCoursesCallback = (startDate, endDate) => this.refreshCourses(startDate, endDate);
 
-    coursesSubscribe(subscriber) {
-        this.#coursesSubscribers.add(subscriber);
+    // Neue Vorlesungsdaten in den Cache ablegen
+    SecureStore.setItem(TimetableCoursesStoreKey, JSON.stringify(newCourses), secureStoreOptions)
 
-        return () => this.coursesUnsubscribe(subscriber);
-    }
-    coursesSubscribeCallback = (subscriber) => this.coursesSubscribe(subscriber);
+    // Neue Vorlesungen hin Service hinterlegen und Äanderun bekannt geben
+    this.#setCourses(newCourses)
+  }
 
-    coursesUnsubscribe(subscriber) {
-        return this.#coursesSubscribers.delete(subscriber);
-    }
+  refreshCoursesCallback = (startDate, endDate) => this.refreshCourses(startDate, endDate)
+
+  coursesSubscribe (subscriber) {
+    this.#coursesSubscribers.add(subscriber)
+
+    return () => this.coursesUnsubscribe(subscriber)
+  }
 
+  coursesSubscribeCallback = (subscriber) => this.coursesSubscribe(subscriber)
 
+  coursesUnsubscribe (subscriber) {
+    return this.#coursesSubscribers.delete(subscriber)
+  }
 
-    /**
+  /**
      * Erstellen eines Stundenplanservices mit Hilfe der Provider-Einstellungen und Sprache
      *
      * @param {ProviderSetting} providerSettingsObject
      * @param {string} language
      * @returns
      */
-    static fromProviderSettingsObject(providerSettingsObject, language) {
-        const provider = TimetableService.#createProvider(providerSettingsObject, language);
+  static fromProviderSettingsObject (providerSettingsObject, language) {
+    const provider = TimetableService.#createProvider(providerSettingsObject, language)
 
-        return new TimetableService(provider);
-    }
+    return new TimetableService(provider)
+  }
 
-    /**
+  /**
      * Erstellen des Providers mit Hilfe eines Provider-Einstellungen-Objektes und einer Sprache
      *
      * @param {ProviderSetting} providerSettingsObject Einstellungen welche zum auswählen und Initialisieren des Provider verwendet werden
      * @param {string} language Sprachcode welcher für den Datenabruf verwendet werden soll
      */
-    static #createProvider(providerSettingsObject, language) {
-        const { provider } = providerSettingsObject;
-
-        switch (provider) {
-            case CollectorVersion2ApiProvider.name:
-                return CollectorVersion2ApiProvider.fromSettingsObject(providerSettingsObject, language);
-            default:
-                return null;
-        }
+  static #createProvider (providerSettingsObject, language) {
+    const { provider } = providerSettingsObject
+
+    switch (provider) {
+      case CollectorVersion2ApiProvider.name:
+        return CollectorVersion2ApiProvider.fromSettingsObject(providerSettingsObject, language)
+      default:
+        return null
     }
+  }
 }
 
 /**
@@ -311,13 +306,13 @@ export default class TimetableService {
  *     </Text>
  * );
  */
-export function useSyncTimetableCode(timetableService) {
-    const timetableCode = useSyncExternalStore(
-        timetableService.codeSubscribeCallback,
-        timetableService.codeCallback,
-    );
+export function useSyncTimetableCode (timetableService) {
+  const timetableCode = useSyncExternalStore(
+    timetableService.codeSubscribeCallback,
+    timetableService.codeCallback
+  )
 
-    return [timetableCode, timetableService.setCodeCallback, timetableService.deleteCodeCallback];
+  return [timetableCode, timetableService.setCodeCallback, timetableService.deleteCodeCallback]
 }
 
 /**
@@ -347,11 +342,11 @@ export function useSyncTimetableCode(timetableService) {
  * return (
  * );
  */
-export function useSyncCourses(timetableService) {
-    const courses = useSyncExternalStore(
-        timetableService.coursesSubscribeCallback,
-        timetableService.coursesCallback,
-    );
+export function useSyncCourses (timetableService) {
+  const courses = useSyncExternalStore(
+    timetableService.coursesSubscribeCallback,
+    timetableService.coursesCallback
+  )
 
-    return [courses, timetableService.refreshCoursesCallback];
+  return [courses, timetableService.refreshCoursesCallback]
 }

package/libraries/react-native-webview-autoheight/package.json

@@ -28,7 +28,7 @@
     "README.md"
   ],
   "dependencies": {
-    "react-native-webview": "13.16.0"
+    "react-native-webview": "13.16.1"
   },
   "peerDependencies": {
     "react": "^19.0.0",