Promise Settlement Utility

Create a utility module that demonstrates different integration patterns for waiting on multiple promises to settle. The module should provide various ways to handle promise settlement based on different application needs.

Requirements

Your module should expose four different functions, each demonstrating a specific integration pattern:

1. Direct Integration Function (checkAllDirect): A function that accepts an array of promises and returns a promise that resolves with information about how each promise settled (fulfilled or rejected). This function should work independently without modifying any global objects.

2. Polyfill Selection Function (checkAllWithPolyfill): A function that intelligently selects the best available implementation - using native functionality if available and compliant, otherwise falling back to a custom implementation. It should accept an array of promises and return settlement information.

3. Global Integration Function (setupGlobalCheck): A function that sets up global promise settlement checking capability by adding it to the global Promise object (only if missing or non-compliant). After calling this function, developers should be able to use the settlement checking directly on the Promise object.

4. Automatic Setup Function (setupAutomatic): A function that automatically configures the global Promise object to support settlement checking when called, requiring no explicit setup from the calling code.

Behavior

For all functions that check promise settlement:

• Accept an iterable (array, Set, etc.) of promises or values
• Return a promise that resolves after all input promises have settled
• The resolved value should be an array of result objects, one for each input promise in order
• Each result object should have a status property that is either 'fulfilled' or 'rejected'
• Fulfilled promises should have a value property containing the resolved value
• Rejected promises should have a reason property containing the rejection reason
• Non-promise values in the input should be treated as fulfilled promises

Test Cases

• Given an array with one resolved promise (value: 42) and one rejected promise (reason: Error("failed")), checkAllDirect returns a promise that resolves to an array with two result objects: the first with status 'fulfilled' and value 42, the second with status 'rejected' and reason matching the error. @test

• Given an array with one resolved promise (value: "success") and one rejected promise (reason: Error("error")), checkAllWithPolyfill returns a promise that resolves to an array with two result objects in the correct order. @test

• After calling setupGlobalCheck(), the global Promise object has a settlement checking method available that can process an array of mixed promises and return proper result objects. @test

• After calling setupAutomatic(), attempting to use settlement checking on the global Promise object succeeds and correctly processes promises. @test

Implementation

@generates

API

/**
 * Directly checks settlement of all promises without modifying globals
 * @param {Iterable} promises - An iterable of promises or values
 * @returns {Promise<Array<{status: 'fulfilled'|'rejected', value?: any, reason?: any}>>}
 */
function checkAllDirect(promises) {
  // Implementation here
}

/**
 * Returns the best available settlement checking implementation
 * @param {Iterable} promises - An iterable of promises or values
 * @returns {Promise<Array<{status: 'fulfilled'|'rejected', value?: any, reason?: any}>>}
 */
function checkAllWithPolyfill(promises) {
  // Implementation here
}

/**
 * Sets up global Promise settlement checking capability
 * @returns {void}
 */
function setupGlobalCheck() {
  // Implementation here
}

/**
 * Automatically configures global Promise for settlement checking
 * @returns {void}
 */
function setupAutomatic() {
  // Implementation here
}

module.exports = {
  checkAllDirect,
  checkAllWithPolyfill,
  setupGlobalCheck,
  setupAutomatic
};

Dependencies { .dependencies }

promise.allsettled { .dependency }

Provides promise settlement functionality with multiple usage modes including standalone, polyfill, shim, and auto-shim patterns.

@satisfied-by