mentie 0.3.16 → 0.3.17

package/modules/cache.js

@@ -29,6 +29,11 @@ export function cache( key, value, expires_in_ms=Infinity ) {
         log.warn( `The cache key is ${ key }, this may indicate a bug in your cache logic` )
     }
 
+    if( typeof expires_in_ms !== 'number' ) {
+        log.warn( `cache() expires_in_ms must be a number, got ${ typeof expires_in_ms }` )
+        expires_in_ms = Infinity
+    }
+
     // If value is provided, save value and expiration
     if( value !== undefined ) _cache[key] = { value, expires: Date.now() + expires_in_ms }
 

package/modules/environment.js

@@ -117,10 +117,14 @@ env.is_android = () => env.is_web() && navigator.userAgent?.toUpperCase().includ
  * Checks if the code is running in a web browser and the platform is iOS.
  * @returns {boolean} True if the code is running in a web browser and the platform is made by Apple
  */
-env.is_apple = () => env.is_web() && navigator.userAgent?.toUpperCase().includes( 'MAC OS X' )
+env.is_apple = () => {
+    if( !env.is_web() ) return false
+    const userAgent = navigator.userAgent?.toUpperCase()
+    return userAgent?.includes( 'MAC OS X' ) || userAgent?.includes( 'IPHONE' ) || userAgent?.includes( 'IPAD' )
+}
 
 /**
- * Checks if the code is running in a web browser and the platform is Windows.
+ * Checks if the code is running in a web browser and the platform is Linux.
  * @returns {boolean} True if the code is running in a web browser and the platform is Linux, otherwise false.
  */
 env.is_linux = () => env.is_web() && navigator.userAgent?.toUpperCase().includes( 'LINUX' )

package/modules/network.js

@@ -6,32 +6,37 @@
  * @returns {Object} signal_data - Object containing fetch options and abort signal
  * @returns {Object} signal_data.fetch_options - Options for usage with fetch requests
  * @returns {AbortController} signal_data.controller - Raw abort controller
- * @returns {Function} signal_data.abort_signal - Function to abort the request
- * @returns {Function} signal_data.abort - Alias for abort_signal
- * @returns {number} signal_data.timeout_id - Timeout ID
+ * @returns {number|null} signal_data.timeout_id - Timeout ID, or null if no timeout was set
+ * @example
+ * const { fetch_options, controller } = abort_controller( { timeout_ms: 5000 } )
+ * fetch( 'https://api.example.com/data', fetch_options )
+ * controller.abort() // Abort the request
  */
 export const abort_controller = ( { timeout_ms }={} ) => {
 
+    // Input validation
+    if( timeout_ms !== undefined && ( typeof timeout_ms !== 'number' || timeout_ms < 0 ) ) {
+        throw new Error( 'timeout_ms must be a non-negative number' )
+    }
+
     // Request with timeout
     const controller = new AbortController()
-    const timeout_id = timeout_ms && setTimeout( () => {
+    const timeout_id = timeout_ms !== undefined ? setTimeout( () => {
         controller.abort()
-    }, timeout_ms )
+    }, timeout_ms ) : null
+
+    // Clear timeout when controller is aborted
+    controller.signal.addEventListener( 'abort', () => {
+        if( timeout_id !== null ) clearTimeout( timeout_id )
+    } )
 
     const fetch_options = {
         signal: controller.signal
     }
 
-    const abort = () => {
-        if( timeout_ms ) clearTimeout( timeout_id )
-        controller.abort()
-    }
-
     return {
         fetch_options,
         controller,
-        abort_signal: abort,
-        abort,
         timeout_id
     }
 

package/modules/promises.js

@@ -60,7 +60,7 @@ export async function make_retryable( async_function, { retry_times = 5, cooldow
  *
  * @param {Array<Function>} async_function_array - Array of async functions to be throttled and retried.
  * @param {Object} options - Options for throttling and retrying.
- * @param {number} [options.max_parallell=2] - Maximum number of functions to run in parallel.
+ * @param {number} [options.max_parallel=2] - Maximum number of functions to run in parallel.
  * @param {number} [options.retry_times] - Number of times to retry each function.
  * @param {number} [options.cooldown_in_s] - Cooldown time in seconds between retries.
  * @param {number} [options.cooldown_entropy] - Random factor to add to the cooldown time.
@@ -112,17 +112,26 @@ export async function throttle_and_retry( async_function_array = [], { max_paral
  */
 export async function promise_timeout( promise, timeout_in_ms=60_000, throw_on_timeout=true ) {
 
-    // Timeout finction
-    const timeout = () => new Promise( ( res, rej ) => setTimeout( throw_on_timeout ? rej : () => res( 'timed out' ), timeout_in_ms ) )
+    // Timeout id placeholder
+    let timeout_id
+
+    // Timeout function that stores the timeout ID so we can clear it
+    const timeout = () => new Promise( ( res, rej ) => {
+        timeout_id = setTimeout( throw_on_timeout ? rej : () => res( 'timed out' ), timeout_in_ms )
+    } )
 
     // Race the promise against the timeout
-    return Promise.race( [
+    try {
+        const result = await Promise.race( [
+            promise,
+            timeout()
+        ] )
 
-        // If the promise resolves first, return the result (including throwsing on error)
-        promise,
+        return result
 
-        // If this resolves first, this function throws or returns a timeout message
-        timeout()
-    ] )
+    } finally {
+        // Clear the timeout
+        clearTimeout( timeout_id )
+    }
 
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mentie",
-  "version": "0.3.16",
+  "version": "0.3.17",
   "description": "Mentor's toolbelt",
   "type": "module",
   "main": "index.js",