@olea-bps/base 1.1.8 → 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/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",

package/libraries/redux-offline/package.json

@@ -31,33 +31,33 @@
     "src/**/*"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.27.1",
+    "@babel/runtime": "^7.29.7",
     "redux-persist": "^6.0.0"
   },
   "devDependencies": {
-    "@babel/cli": "^7.27.2",
-    "@babel/core": "^7.27.1",
+    "@babel/cli": "^7.29.7",
+    "@babel/core": "^7.29.7",
     "@babel/plugin-proposal-class-properties": "^7.18.6",
     "@babel/plugin-syntax-object-rest-spread": "^7.8.3",
-    "@babel/plugin-transform-flow-strip-types": "^7.27.1",
-    "@babel/plugin-transform-runtime": "^7.27.1",
-    "@babel/preset-env": "^7.27.2",
+    "@babel/plugin-transform-flow-strip-types": "^7.29.7",
+    "@babel/plugin-transform-runtime": "^7.29.7",
+    "@babel/preset-env": "^7.29.7",
     "babel-core": "^7.0.0-bridge.0",
     "babel-eslint": "^10.1.0",
     "babel-jest": "^29.7.0",
-    "eslint": "^8.2.0",
+    "eslint": "^8.57.1",
     "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-config-prettier": "^10.1.5",
+    "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-babel": "^5.3.1",
     "eslint-plugin-flowtype": "^8.0.3",
-    "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-prettier": "^5.4.0",
-    "flow-bin": "^0.272.1",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-prettier": "^5.5.6",
+    "flow-bin": "^0.334.0",
     "husky": "^9.1.7",
     "jest": "^29.7.0",
-    "lint-staged": "^16.0.0",
-    "prettier": "^3.5.3",
-    "redux": "^4.0.5",
+    "lint-staged": "^16.4.0",
+    "prettier": "^3.9.9",
+    "redux": "^4.2.1",
     "redux-devtools-instrument": "^1.10.0",
     "redux-logger": "^3.0.6",
     "redux-persist-node-storage": "^2.0.0",