promise-logic 2.6.5 → 2.8.0

package/README.md

@@ -1,10 +1,7 @@
-
-
-
 ### **1. Core Philosophy**
 
 **Replace API Memory with Logical Concepts**  
-The design philosophy of `promise-logic` is: **Developers should focus on business logic, not the details of Promise APIs**.  
+The design philosophy of `promise-logic` is: **Developers should focus on business logic, not on details of Promise APIs**.  
 Traditional Promise combinations (such as `Promise.all`, `Promise.race`) have naming and semantics that are not intuitive enough, especially in complex asynchronous scenarios where code readability rapidly declines.  
 `promise-logic` abstracts asynchronous combinations into logical operations like `and`, `or`, `xor` through the concept of **Logic Gates**, making code semantically clear and self-explanatory.
 
@@ -12,31 +9,34 @@ Traditional Promise combinations (such as `Promise.all`, `Promise.race`) have na
 
 ### **2. Features**
 
-1. **Logical Semantics**  
-   - `and`: All tasks must succeed (equivalent to `Promise.all`)  
-   - `or`: At least one task succeeds (equivalent to `Promise.race`)  
-   - `xor`: **Exactly one task succeeds** (no direct equivalent in traditional Promise)  
-   - `nand`: All tasks fail  
-
-   - `not`: Inverts the result of a single Promise  
-   - `majority`: Most tasks succeed  
-
-2. **Zero Dependencies**  
+1. **Logical Semantics**
+   - `and`: All tasks must succeed (equivalent to native `Promise.all`)
+   - `or`: At least one task succeeds (equivalent to native `Promise.any`)
+   - `xor`: **Exactly one task succeeds**
+   - `nand`: Not all tasks succeed (at least one fails)
+   - `nor`: All tasks fail (no task succeeds)
+   - `xnor`: All tasks succeed or all fail (same state)
+   - `not`: Inverts the result of a single Promise
+   - `majority`: Most tasks succeed
+
+2. **Zero Dependencies**
    Only depends on native Promise, no additional runtime dependencies.
 
-3. **Full Test Coverage**  
+3. **Full Test Coverage**
    All logic gates have undergone rigorous unit testing to ensure behavior meets expectations.
 
-4. **Clear Error Classification**  
-   - `PromiseLogicError` unified error type  
+4. **Clear Error Classification**
+   - `PromiseLogicError` unified error type
    - `error.type` distinguishes specific logical errors (e.g., `'XOR_ERROR'`)
 
-5. **Timeout Control**  
-   - `maxTimer`: Adds timeout functionality to any Promise operation
+5. **Timeout Control**
+   - `maxTimer`: Adds timeout functionality to any Promise operation (unit: milliseconds).
 
-6. **Extended Operations**  
-   - `allFulfilled`: Returns all successful results
-   - `allRejected`: Returns all failed results
+`maxTimer` can only detect timeout of Promise operations, cannot interrupt or cancel Promise operations themselves, this is a JavaScript characteristic.
+
+6. **Extended Operations**
+   - `allFulfilled`: Returns all successful results. Returns immediately when a result exists, while maintaining input order.
+   - `allRejected`: Returns all failed results. Returns immediately when a result exists, while maintaining input order.
    - `allSettled`: Returns all results (both successful and failed)
 
 ---
@@ -52,6 +52,7 @@ npm install promise-logic
 ### **4. Quick Start**
 
 #### Example: Primary/Backup Service Call (XOR Scenario)
+
 ```javascript
 import { PromiseLogic } from 'promise-logic';
 
@@ -62,10 +63,10 @@ const backup = fetch('https://api.backup.com/data');
 
 // Execute XOR logic: exactly one success
 PromiseLogic.xor([primary, backup])
-  .then(result => {
+  .then((result) => {
     console.log('Successfully fetched data:', result);
   })
-  .catch(error => {
+  .catch((error) => {
     if (error.type === 'XOR_ERROR') {
       console.error('Both primary and backup services succeeded or failed, which does not meet XOR semantics');
     } else {
@@ -75,6 +76,7 @@ PromiseLogic.xor([primary, backup])
 ```
 
 #### Example: Majority Decision (Majority Scenario)
+
 ```javascript
 import { PromiseLogic } from 'promise-logic';
 
@@ -85,10 +87,10 @@ const services = [
 ];
 
 PromiseLogic.majority(services)
-  .then(results => {
+  .then((results) => {
     console.log('Majority of services returned success:', results);
   })
-  .catch(error => {
+  .catch((error) => {
     console.error('Majority of services failed:', error);
   });
 ```
@@ -102,35 +104,38 @@ const services = [
   fetch('https://api.node3.com/vote')
 ];
 
+// Type assertion can be done, or let PromiseLogic infer types automatically
 PromiseLogic.majority<Response>(services)
-  .then(results => {
+  .then((results) => {
     console.log('Majority of services returned success:', results);
   })
-  .catch(error => {
+  .catch((error) => {
     console.error('Majority of services failed:', error);
   });
 ```
 
 #### Example: Timeout Control
+
 ```javascript
 import { PromiseLogic } from 'promise-logic';
 
-// Execute operation with timeout
+// Execute operation with custom timeout error message
 PromiseLogic.and([
   Promise.resolve(1),
-  new Promise(resolve => setTimeout(resolve, 1000)), // 1 second operation
+  new Promise((resolve) => setTimeout(resolve, 3000)), // 3 second operation
   Promise.resolve(3)
 ])
-.maxTimer(2000) // 2 second timeout
-.then(result => {
-  console.log('Operation completed within timeout:', result);
-})
-.catch(error => {
-  console.error('Operation timed out or failed:', error.message);
-});
+  .maxTimer(2000, 'Custom timeout error: operation did not complete within 2000ms') // 2 second timeout, custom error message
+  .then((result) => {
+    console.log('Operation completed within timeout:', result);
+  })
+  .catch((error) => {
+    console.error('Operation timed out:', error.message); // Output: Custom timeout error: operation did not complete within 2000ms
+  });
 ```
 
 #### Example: Extended Operations
+
 ```javascript
 import { PromiseLogic } from 'promise-logic';
 
@@ -141,26 +146,105 @@ const operations = [
   Promise.reject('error2')
 ];
 
-// Get all successful results
-PromiseLogic.allFulfilled(operations)
-  .then(results => {
-    console.log('Successful results:', results); // ['success1', 'success2']
-  });
+// Get all successful results (returns immediately when a result exists)
+PromiseLogic.allFulfilled(operations).then((results) => {
+  console.log('Successful results:', results); // ['success1', 'success2']
+});
 
-// Get all failed results
-PromiseLogic.allRejected(operations)
-  .then(errors => {
-    console.log('Failed results:', errors); // ['error1', 'error2']
-  });
+// Get all failed results (returns immediately when a result exists)
+PromiseLogic.allRejected(operations).then((errors) => {
+  console.log('Failed results:', errors); // ['error1', 'error2']
+});
 
 // Get all results (both success and failure)
-PromiseLogic.allSettled(operations)
-  .then(results => {
-    console.log('All results:', results);
-  });
+PromiseLogic.allSettled(operations).then((results) => {
+  console.log('All results:', results);
+  // Output:
+  // [
+  //   { status: 'fulfilled', value: 'success1' },
+  //   { status: 'rejected', reason: 'error1' },
+  //   { status: 'fulfilled', value: 'success2' },
+  //   { status: 'rejected', reason: 'error2' }
+  // ]
+});
+```
+
+#### Example: allFulfilled - Execution Timing and Results
+
+```javascript
+import { PromiseLogic } from 'promise-logic';
+
+const startTime = Date.now();
+console.log('Start executing allFulfilled, time:', startTime);
+
+const allFulfilledResult = await PromiseLogic.allFulfilled([
+  new Promise(resolve => {
+    console.log('First Promise started (slow)');
+    setTimeout(() => {
+      console.log('First Promise completed:', 'success1');
+      resolve('success1');
+    }, 100);
+  }),
+  Promise.reject('error'),
+  new Promise(resolve => {
+    console.log('Third Promise started (fast)');
+    setTimeout(() => {
+      console.log('Third Promise completed:', 'success2');
+      resolve('success2');
+    }, 10);
+  })
+]);
+
+const endTime = Date.now();
+const elapsedTime = endTime - startTime;
+console.log('allFulfilled complete results:', allFulfilledResult); // ['success1', 'success2']
+```
+
+**Explanation:**
+- **First return info**: Third Promise completes at 10ms, immediately returns `['success2']`
+- **Complete return info**: First Promise completes at 100ms, final complete result is `['success1', 'success2']`
+- **Execution timing**: Returns immediately when a result exists, does not wait for all Promises to complete
+- **Order preservation**: Complete results are returned in input order, not completion order
+
+#### Example: allRejected - Execution Timing and Results
+
+```javascript
+import { PromiseLogic } from 'promise-logic';
+
+const startTime = Date.now();
+console.log('Start executing allRejected, time:', startTime);
+
+const allRejectedResult = await PromiseLogic.allRejected([
+  Promise.resolve('success1'),
+  new Promise((_, reject) => {
+    console.log('Second Promise started (fast)');
+    setTimeout(() => {
+      console.log('Second Promise completed:', 'error1');
+      reject('error1');
+    }, 10);
+  }),
+  new Promise((_, reject) => {
+    console.log('Third Promise started (slow)');
+    setTimeout(() => {
+      console.log('Third Promise completed:', 'error2');
+      reject('error2');
+    }, 100);
+  })
+]);
+
+const endTime = Date.now();
+const elapsedTime = endTime - startTime;
+console.log('allRejected complete results:', allRejectedResult); // ['error1', 'error2']
 ```
 
+**Explanation:**
+- **First return info**: Second Promise completes at 10ms, immediately returns `['error1']`
+- **Complete return info**: Third Promise completes at 100ms, final complete result is `['error1', 'error2']`
+- **Execution timing**: Returns immediately when a result exists, does not wait for all Promises to complete
+- **Order preservation**: Complete results are returned in input order, not completion order
+
 #### Example: Custom majority threshold
+
 ```javascript
 import { PromiseLogic } from 'promise-logic';
 
@@ -174,68 +258,151 @@ const services = [
 // Default threshold (0.5): requires at least 3 successes
 // Custom threshold (0.4): requires at least 2 successes
 PromiseLogic.majority(services, { max: 0.4 })
-  .then(results => {
+  .then((results) => {
     console.log('Custom threshold met, successful results:', results); // ['service1', 'service2']
   })
-  .catch(error => {
+  .catch((error) => {
     console.error('Custom threshold not met:', error);
   });
 ```
 
----
+## Recent Updates
 
-### **5. API Reference**
+### v2.8.0
+
+- **Performance optimization**: Optimized `allFulfilled` and `allRejected` implementation logic from the bottom layer, existing results return immediately while maintaining consistent input and output order
+- **Added chain timeout control with custom error messages**: Can customize timeout error messages in the `maxTimer` method
+- **Type fixes**: Fixed TypeScript version type declaration issues
+- **Test completion**: Added complete test cases for `allFulfilled`, `allRejected`, and `maxTimer`
+- **Code refactoring**: Improved code structure for better maintainability
+
+### v2.7.0
+
+- **Added modular architecture**: Separated logic gate implementations into independent modules for better code maintainability
+- **Fixed NOT Logic Gate**: Fixed potential risks in NOT logic gate in production environments
+- **Improved Error Messages**: Enhanced error message format for clearer error details
+- **Enhanced Test Coverage**: Added complete factory function tests for v1 and v2 versions
+- **Updated Documentation**: Added custom factory function usage guide
+
+
+### Using Factory Function
+
+The factory function allows you to create PromiseLogic methods with custom names:
+
+```javascript
+import { createPromiseLogic } from 'promise-logic/factory';
+
+// Create instance with custom naming
+const logic = createPromiseLogic({
+  prefix: 'api_',
+  suffix: '_call',
+  rename: {
+    and: 'all',
+    or: 'any',
+    xor: 'exclusive'
+  }
+});
+
+// Use custom-named methods
+logic.api_all_call([fetch('/api/users'), fetch('/api/posts')]);
+
+logic.api_any_call([fetch('/api/cache'), fetch('/api/database')]);
+```
 
-| API           | Description                                                                 |
-| :------------ | :-------------------------------------------------------------------------- |
-| `and`         | All Promises succeed, returns result array; any failure causes overall failure. |
-| `or`          | At least one Promise succeeds, returns first success result; all failures cause overall failure. |
-| `xor`         | **Exactly one Promise succeeds**, returns that result; otherwise throws `XOR_ERROR`. |
-| `nand`        | All Promises fail, returns error array; any success causes overall failure. |
-| `not`         | Inverts the result of a single Promise |
-| `majority`    | More than half of Promises succeed, returns success result array; otherwise overall failure. Accepts `options` parameter, where `max` property can customize threshold (default: 0.5). |
-| `allFulfilled` | Returns all successful results as an array, ignoring failures. |
-| `allRejected` | Returns all failed results as an array, ignoring successes. |
-| `allSettled`  | Returns all results (both successful and failed) as an array. |
-| `maxTimer`    | Adds timeout functionality to any Promise operation (unit: milliseconds). |
+### TypeScript Support
+
+```typescript
+import { PromiseLogic } from 'promise-logic/typescript';
+
+// Type inference
+PromiseLogic.and([Promise.resolve(1), Promise.resolve(2)]).then(
+  (results: number[]) => {
+    console.log(results);
+  }
+);
+
+// Type assertion
+PromiseLogic.and<number>([Promise.resolve(1), Promise.resolve(2)]);
+```
 
 ---
 
+### **5. API Reference**
+
+| API            | Description                                                                                                                         |
+| :------------- | :--------------------------------------------------------------------------------------------------------------------------- |
+| `and`          | All Promises succeed, returns result array; any failure causes overall failure. Equivalent to native `Promise.all`.                                                                        |
+| `or`           | At least one Promise succeeds, returns first success result; all failures cause overall failure. Equivalent to native `Promise.any`.                                                                |
+| `xor`          | **Exactly one Promise succeeds**, returns that result; otherwise throws `XOR_ERROR`.                                                            |
+| `nand`         | Not all Promises succeed (at least one fails), returns success result array; all succeed causes overall failure.                                              |
+| `nor`          | All Promises fail (no task succeeds), returns empty array; any success causes overall failure.                                                        |
+| `xnor`         | All Promises succeed or all fail (same state), returns success result array; otherwise throws `XNOR_ERROR`.                                           |
+| `not`          | Inverts the result of a single Promise: success becomes failure, failure becomes success.                                                                            |
+| `majority`     | More than specified threshold of Promises succeed, returns success result array; otherwise overall failure. Accepts `options` parameter, where `max` property can customize threshold (default: 0.5), range: (0, 1). |
+| `allFulfilled` | Returns all successful results as an array, ignoring failures. Returns immediately when a result exists, while maintaining input order.                     |
+| `allRejected`  | Returns all failed results as an array, ignoring successes. Returns immediately when a result exists, while maintaining input order.                     |
+| `allSettled`   | Returns all results (both successful and failed) as an array. Equivalent to native `Promise.allSettled`.                                                                                     |
+| `race`         | Returns the first completed Promise result (regardless of success or failure). Equivalent to native `Promise.race`.                                                                            |
+| `maxTimer`     | Adds timeout functionality to any Promise operation (unit: milliseconds). Supports custom timeout error messages.                                              |
+
+## **Note**: `maxTimer` can only detect timeout of Promise operations, cannot interrupt or cancel Promise operations themselves, this is a JavaScript characteristic.
+
 ### **6. Real-world Application Scenarios**
 
-1. **Primary/Backup Service Calls**  
-   - Use `xor` to ensure **exactly one service responds**, avoiding duplicate processing.  
-2. **Distributed Decision Making**  
-   - Use `majority` to implement majority consensus (e.g., distributed voting).  
-3. **Resource Competition**  
-   - Use `or` to get the first available resource (e.g., CDN node selection). 
-   - Use `not` to check if a resource is available.  
-4. **Full-link Validation**  
-   - Use `and` to ensure all dependent services succeed (e.g., order creation).  
+1. **Primary/Backup Service Calls**
+   - Use `xor` to ensure **exactly one service responds**, avoiding duplicate processing.
+
+2. **Distributed Decision Making**
+   - Use `majority` to implement majority consensus (e.g., distributed voting).
+
+3. **Resource Competition**
+   - Use `or` to get the first available resource (e.g., CDN node selection).
+   - Use `not` to check if a resource is available.
+
+4. **Full-link Validation**
+   - Use `and` to ensure all dependent services succeed (e.g., order creation).
+
+5. **Timeout Control**
+   - Use `maxTimer` to add timeout functionality to any Promise operation (unit: milliseconds).
+   - Returns custom error message after timeout, default: `Promise timed out after ${ms} ms`.
+
+6. **Partial Success Handling**
+   - Use `allFulfilled` to execute all Promises concurrently and return successful result array (e.g., batch API calls, suitable for high concurrency and partial failure acceptance scenarios).
+   - Use `allRejected` to execute all Promises concurrently and return failed result array (e.g., error log collection, suitable for batch failure processing scenarios).
+
+7. **Full Result Retrieval**
+   - Use `allSettled` to get results from all Promises (regardless of success or failure).
+
+8. **Fast Response**
+   - Use `race` to return the first completed Promise result (regardless of success or failure).
+
+9. **State Validation**
+   - Use `nand` to verify that not all Promises succeed (at least one fails).
+   - Use `nor` to verify that all Promises fail (no task succeeds).
+   - Use `xnor` to verify that all Promises succeed or all fail (same state).
 
 ---
 
 ### **7. Contribution Guide**
 
-1. **Development Environment**  
+1. **Development Environment**
    ```bash
-   git clone https://github.com/haowhite/promise-logic.git
+   git clone https://github.com/xier123456/promise-logic.git
    cd promise-logic
    npm install
    ```
-2. **Testing**  
+2. **Testing**
    ```bash
    npm test
    ```
-3. **Commit Guidelines**  
-   - Commit messages must include prefixes like `feat:` (new feature), `fix:` (bug fix), `docs:` (documentation).  
-   - Pull Requests must include test cases.  
+3. **Commit Guidelines**
+   - Commit messages must include prefixes like `feat:` (new feature), `fix:` (bug fix), `docs:` (documentation).
+   - Pull Requests must include test cases.
 
 ---
 
 ### **8. Resource Links**
 
-- **GitHub Repository**：[https://github.com/xier123456/promise-logic](https://github.com/xier123456/promise-logic)  
-- **npm Package**：[https://www.npmjs.com/package/promise-logic](https://www.npmjs.com/package/promise-logic)  
-- **Issue Tracking**：[GitHub Issues](https://github.com/xier123456/promise-logic/issues)  
-
+- **GitHub Repository**: [https://github.com/xier123456/promise-logic](https://github.com/xier123456/promise-logic)
+- **npm Package**: [https://www.npmjs.com/package/promise-logic](https://www.npmjs.com/package/promise-logic)
+- **Issue Tracking**: [GitHub Issues](https://github.com/xier123456/promise-logic/issues)

package/dist/factory.cjs.js

@@ -1 +1 @@
-"use strict";class e extends Error{constructor(e,t,r){super(t),this.name="PromiseLogicError",this.type=e,this.results=r}}function t(t,r,l,i){return new e(t,{XOR_ERROR:`XOR condition failed: expected exactly 1 promise to fulfill, but ${r} fulfilled.`,NAND_ERROR:`NAND condition failed: all ${l} promises fulfilled (expected at least one rejection).`,NOT_ERROR:"NOT condition failed: promise resolved (expected rejection).",NOR_ERROR:`NOR condition failed: ${r} promises fulfilled (expected all rejected).`,MAJORITY_ERROR:`Majority condition failed: ${r}/${l} fulfilled (need majority).`,ALL_SUCCESSFUL_ERROR:`All successful condition failed: ${r}/${l} promises fulfilled (expected all to succeed).`,ALL_FAILED_ERROR:`All failed condition failed: ${l-r}/${l} promises rejected (expected all to fail).`}[t]||"Logic condition failed",i)}class r{constructor(e){this.promise=e}maxTimer(e){let t;return Promise.race([this.promise,new Promise((r,l)=>{t=setTimeout(()=>{l(new Error(`Promise timed out after ${e}ms`))},e)})]).finally(()=>clearTimeout(t))}then(e,t){return new r(this.promise.then(e,t))}catch(e){return new r(this.promise.catch(e))}finally(e){return new r(this.promise.finally(e))}toPromise(){return this.promise}}class l{static and(e){return new r(Promise.all(e))}static or(e){return new r(Promise.any(e))}static not(e){return new r(Promise.resolve(e).then(e=>Promise.reject(e),e=>Promise.resolve(e)).catch(e=>Promise.resolve(e)))}static race(e){return new r(Promise.race(e))}static allSettled(e){return new r(Promise.allSettled(e))}static xor(e){return new r(Promise.allSettled(e).then(e=>{const r=e.filter(e=>"fulfilled"===e.status),l=r.length,i=e.length;if(1===l)return r[0].value;throw t("XOR_ERROR",l,i,e)}))}static nand(e){return new r(Promise.allSettled(e).then(e=>{const r=e.filter(e=>"fulfilled"===e.status),l=r.length,i=e.length;if(l===i)throw t("NAND_ERROR",l,i,e);return r.map(e=>e.value)}))}static nor(e){return new r(Promise.allSettled(e).then(e=>{const r=e.filter(e=>"fulfilled"===e.status).length,l=e.length;if(0===r)return[];throw t("NOR_ERROR",r,l,e)}))}static xnor(e){return new r(Promise.allSettled(e).then(e=>{const r=e.filter(e=>"fulfilled"===e.status),l=r.length,i=e.length;if(0===l||l===i)return r.map(e=>e.value);throw t("XNOR_ERROR",l,i,e)}))}static majority(e,l={max:.5}){return new r(Promise.allSettled(e).then(e=>{const r=e.filter(e=>"fulfilled"===e.status),i=r.length,n=e.length;if(i>n*l.max)return r.map(e=>e.value);throw t("MAJORITY_ERROR",i,n,e)}))}static allFulfilled(e){return new r(Promise.allSettled(e).then(e=>e.filter(e=>"fulfilled"===e.status).map(e=>e.value)))}static allRejected(e){return new r(Promise.allSettled(e).then(e=>e.filter(e=>"rejected"===e.status).map(e=>e.reason)))}static createFlipFlop(e=!1){let t=e,r=null,l=Promise.resolve(t);return{getState:()=>t,set(e){return t=e,r&&(r(t),r=null),l=Promise.resolve(t),this},toggle(){return this.set(!t)},waitForChange:()=>(r||(l=new Promise(e=>{r=e})),l),waitFor(e){return t===e?Promise.resolve(t):new Promise(r=>{const l=()=>{t===e?r(t):this.waitForChange().then(l)};l()})}}}}exports.createPromiseLogic=function(e={}){const{prefix:t="",suffix:r="",rename:i={}}=e,n={and:l.and.bind(l),or:l.or.bind(l),race:l.race.bind(l),allSettled:l.allSettled.bind(l),xor:l.xor.bind(l),not:l.not.bind(l),nand:l.nand.bind(l),nor:l.nor.bind(l),xnor:l.xnor.bind(l),majority:l.majority.bind(l),allFulfilled:l.allFulfilled.bind(l),allRejected:l.allRejected.bind(l)},o={};return Object.entries(n).forEach(([e,l])=>{const n=i[e]||e;o[`${t}${n}${r}`]=l}),o};
+"use strict";class e extends Error{constructor(e,t,l){super(t),this.name="PromiseLogicError",this.type=e,this.results=l}}function t(t,l,r,n,s){const i={XOR_ERROR:`XOR condition failed: expected exactly 1 promise to fulfill, but ${l} fulfilled.`,NAND_ERROR:`NAND condition failed: all ${r} promises fulfilled (expected at least one rejection).`,NOT_ERROR:"NOT condition failed: promise resolved (expected rejection).",NOR_ERROR:`NOR condition failed: ${l} promises fulfilled (expected all rejected).`,MAJORITY_ERROR:`Majority condition failed: ${l}/${r} fulfilled (need majority).`,ALL_SUCCESSFUL_ERROR:`All successful condition failed: ${l}/${r} promises fulfilled (expected all to succeed).`,ALL_FAILED_ERROR:`All failed condition failed: ${r-l}/${r} promises rejected (expected all to fail).`}[t],a=s.length>0?`\n失败原因：${s.map((e,t)=>`[${t+1}] ${e}`).join("\n")}`:"";return new e(t,i+a,n)}class l{filterFulfilledResults(e){return e.filter(e=>"fulfilled"===e.status).map(e=>e.value)}filterRejectedResults(e){return e.filter(e=>"rejected"===e.status).map(e=>e.reason)}countFulfilled(e){return e.filter(e=>"fulfilled"===e.status).length}countRejected(e){return e.filter(e=>"rejected"===e.status).length}}class r extends l{async execute(e,l={}){try{return await Promise.all(e)}catch(l){throw t("AND_ERROR",0,e.length,[...e],l)}}}class n extends l{async execute(e,l={}){try{return await Promise.any(e)}catch(l){throw t("OR_ERROR",0,e.length,[...e],l)}}}class s extends l{async execute(e,l={}){const r=await Promise.allSettled(e),n=this.filterFulfilledResults(r),s=this.filterRejectedResults(r),i=n.length,a=r.length;if(1===i)return n[0];throw t("XOR_ERROR",i,a,r,s)}}class i extends l{async execute(e,l={}){const r=await Promise.allSettled(e),n=this.filterFulfilledResults(r),s=n.length,i=r.length;if(s===i)throw t("NAND_ERROR",s,i,r,n);return n}}class a extends l{async execute(e,l={}){const r=await Promise.allSettled(e),n=this.filterFulfilledResults(r),s=n.length,i=r.length;if(0===s)return[];throw t("NOR_ERROR",s,i,r,n)}}class o extends l{async execute(e,l={}){const r=await Promise.allSettled(e),n=this.filterFulfilledResults(r),s=n.length,i=r.length;if(0===s||s===i)return n;throw t("XNOR_ERROR",s,i,r,n)}}class c extends l{async execute(e,l={max:.5}){const r=await Promise.allSettled(e),n=this.filterFulfilledResults(r),s=n.length,i=r.length;if(s>Math.floor(i*l.max))return n;throw t("MAJORITY_ERROR",s,i,r)}}class u extends l{async execute(e,t={}){return new Promise(t=>{const l=[];let r=0;0!==([...e]?.length??0)?e.forEach((e,n)=>{e.then(e=>{r++,l[n]=e}).catch(()=>{l[n]=void 0}).finally(()=>{r>0&&t(l.filter(e=>void 0!==e))})}):t(l)})}}class d extends l{async execute(e,t={}){return new Promise(t=>{const l=[];let r=0;0!==([...e]?.length??0)?e.forEach((e,n)=>{e.then(()=>{l[n]=void 0}).catch(e=>{r++,l[n]=e}).finally(()=>{r>0&&t(l.filter(e=>void 0!==e))})}):t(l)})}}class f{constructor(e){this.promise=e}maxTimer(e,t=`Promise timed out after ${e}ms`){let l;return Promise.race([this.promise,new Promise((r,n)=>{l=setTimeout(()=>{n(new Error(t))},e)})]).finally(()=>clearTimeout(l))}then(e,t){return new f(this.promise.then(e,t))}catch(e){return new f(this.promise.catch(e))}finally(e){return new f(this.promise.finally(e))}toPromise(){return this.promise}}class h{static get gates(){return{and:new r,or:new n,xor:new s,nand:new i,nor:new a,xnor:new o,majority:new c,allFulfilled:new u,allRejected:new d}}static and(e){return new f(this.gates.and.execute(e))}static or(e){return new f(this.gates.or.execute(e))}static not(e){return new f(Promise.resolve(e).then(e=>Promise.reject(new Error(`NOT: ${e}`)),e=>Promise.resolve(e)))}static race(e){return new f(Promise.race(e).then(e=>Promise.resolve(e)))}static allSettled(e){return new f(Promise.allSettled(e))}static xor(e){return new f(this.gates.xor.execute(e))}static nand(e){return new f(this.gates.nand.execute(e))}static nor(e){return new f(this.gates.nor.execute(e))}static xnor(e){return new f(this.gates.xnor.execute(e))}static majority(e,t={max:.5}){return new f(this.gates.majority.execute(e,t))}static allFulfilled(e){return new f(this.gates.allFulfilled.execute(e))}static allRejected(e){return new f(this.gates.allRejected.execute(e))}static createFlipFlop(e=!1){let t=e,l=null,r=Promise.resolve(t);return{getState:()=>t,set(e){return t=e,l&&(l(t),l=null),r=Promise.resolve(t),this},toggle(){return this.set(!t)},waitForChange:()=>(l||(r=new Promise(e=>{l=e})),r),waitFor(e){return t===e?Promise.resolve(t):new Promise(l=>{const r=()=>{t===e?l(t):this.waitForChange().then(r)};r()})}}}}exports.createPromiseLogic=function(e={}){const{prefix:t="",suffix:l="",rename:r={}}=e,n={and:h.and.bind(h),or:h.or.bind(h),race:h.race.bind(h),allSettled:h.allSettled.bind(h),xor:h.xor.bind(h),not:h.not.bind(h),nand:h.nand.bind(h),nor:h.nor.bind(h),xnor:h.xnor.bind(h),majority:h.majority.bind(h),allFulfilled:h.allFulfilled.bind(h),allRejected:h.allRejected.bind(h)},s={};return Object.entries(n).forEach(([e,n])=>{const i=r[e]||e;s[`${t}${i}${l}`]=n}),s};

package/dist/factory.esm.js

@@ -1 +1 @@
-class e extends Error{constructor(e,t,r){super(t),this.name="PromiseLogicError",this.type=e,this.results=r}}function t(t,r,l,i){return new e(t,{XOR_ERROR:`XOR condition failed: expected exactly 1 promise to fulfill, but ${r} fulfilled.`,NAND_ERROR:`NAND condition failed: all ${l} promises fulfilled (expected at least one rejection).`,NOT_ERROR:"NOT condition failed: promise resolved (expected rejection).",NOR_ERROR:`NOR condition failed: ${r} promises fulfilled (expected all rejected).`,MAJORITY_ERROR:`Majority condition failed: ${r}/${l} fulfilled (need majority).`,ALL_SUCCESSFUL_ERROR:`All successful condition failed: ${r}/${l} promises fulfilled (expected all to succeed).`,ALL_FAILED_ERROR:`All failed condition failed: ${l-r}/${l} promises rejected (expected all to fail).`}[t]||"Logic condition failed",i)}class r{constructor(e){this.promise=e}maxTimer(e){let t;return Promise.race([this.promise,new Promise((r,l)=>{t=setTimeout(()=>{l(new Error(`Promise timed out after ${e}ms`))},e)})]).finally(()=>clearTimeout(t))}then(e,t){return new r(this.promise.then(e,t))}catch(e){return new r(this.promise.catch(e))}finally(e){return new r(this.promise.finally(e))}toPromise(){return this.promise}}class l{static and(e){return new r(Promise.all(e))}static or(e){return new r(Promise.any(e))}static not(e){return new r(Promise.resolve(e).then(e=>Promise.reject(e),e=>Promise.resolve(e)).catch(e=>Promise.resolve(e)))}static race(e){return new r(Promise.race(e))}static allSettled(e){return new r(Promise.allSettled(e))}static xor(e){return new r(Promise.allSettled(e).then(e=>{const r=e.filter(e=>"fulfilled"===e.status),l=r.length,i=e.length;if(1===l)return r[0].value;throw t("XOR_ERROR",l,i,e)}))}static nand(e){return new r(Promise.allSettled(e).then(e=>{const r=e.filter(e=>"fulfilled"===e.status),l=r.length,i=e.length;if(l===i)throw t("NAND_ERROR",l,i,e);return r.map(e=>e.value)}))}static nor(e){return new r(Promise.allSettled(e).then(e=>{const r=e.filter(e=>"fulfilled"===e.status).length,l=e.length;if(0===r)return[];throw t("NOR_ERROR",r,l,e)}))}static xnor(e){return new r(Promise.allSettled(e).then(e=>{const r=e.filter(e=>"fulfilled"===e.status),l=r.length,i=e.length;if(0===l||l===i)return r.map(e=>e.value);throw t("XNOR_ERROR",l,i,e)}))}static majority(e,l={max:.5}){return new r(Promise.allSettled(e).then(e=>{const r=e.filter(e=>"fulfilled"===e.status),i=r.length,n=e.length;if(i>n*l.max)return r.map(e=>e.value);throw t("MAJORITY_ERROR",i,n,e)}))}static allFulfilled(e){return new r(Promise.allSettled(e).then(e=>e.filter(e=>"fulfilled"===e.status).map(e=>e.value)))}static allRejected(e){return new r(Promise.allSettled(e).then(e=>e.filter(e=>"rejected"===e.status).map(e=>e.reason)))}static createFlipFlop(e=!1){let t=e,r=null,l=Promise.resolve(t);return{getState:()=>t,set(e){return t=e,r&&(r(t),r=null),l=Promise.resolve(t),this},toggle(){return this.set(!t)},waitForChange:()=>(r||(l=new Promise(e=>{r=e})),l),waitFor(e){return t===e?Promise.resolve(t):new Promise(r=>{const l=()=>{t===e?r(t):this.waitForChange().then(l)};l()})}}}}function i(e={}){const{prefix:t="",suffix:r="",rename:i={}}=e,n={and:l.and.bind(l),or:l.or.bind(l),race:l.race.bind(l),allSettled:l.allSettled.bind(l),xor:l.xor.bind(l),not:l.not.bind(l),nand:l.nand.bind(l),nor:l.nor.bind(l),xnor:l.xnor.bind(l),majority:l.majority.bind(l),allFulfilled:l.allFulfilled.bind(l),allRejected:l.allRejected.bind(l)},o={};return Object.entries(n).forEach(([e,l])=>{const n=i[e]||e;o[`${t}${n}${r}`]=l}),o}export{i as createPromiseLogic};
+class e extends Error{constructor(e,t,l){super(t),this.name="PromiseLogicError",this.type=e,this.results=l}}function t(t,l,r,n,s){const i={XOR_ERROR:`XOR condition failed: expected exactly 1 promise to fulfill, but ${l} fulfilled.`,NAND_ERROR:`NAND condition failed: all ${r} promises fulfilled (expected at least one rejection).`,NOT_ERROR:"NOT condition failed: promise resolved (expected rejection).",NOR_ERROR:`NOR condition failed: ${l} promises fulfilled (expected all rejected).`,MAJORITY_ERROR:`Majority condition failed: ${l}/${r} fulfilled (need majority).`,ALL_SUCCESSFUL_ERROR:`All successful condition failed: ${l}/${r} promises fulfilled (expected all to succeed).`,ALL_FAILED_ERROR:`All failed condition failed: ${r-l}/${r} promises rejected (expected all to fail).`}[t],a=s.length>0?`\n失败原因：${s.map((e,t)=>`[${t+1}] ${e}`).join("\n")}`:"";return new e(t,i+a,n)}class l{filterFulfilledResults(e){return e.filter(e=>"fulfilled"===e.status).map(e=>e.value)}filterRejectedResults(e){return e.filter(e=>"rejected"===e.status).map(e=>e.reason)}countFulfilled(e){return e.filter(e=>"fulfilled"===e.status).length}countRejected(e){return e.filter(e=>"rejected"===e.status).length}}class r extends l{async execute(e,l={}){try{return await Promise.all(e)}catch(l){throw t("AND_ERROR",0,e.length,[...e],l)}}}class n extends l{async execute(e,l={}){try{return await Promise.any(e)}catch(l){throw t("OR_ERROR",0,e.length,[...e],l)}}}class s extends l{async execute(e,l={}){const r=await Promise.allSettled(e),n=this.filterFulfilledResults(r),s=this.filterRejectedResults(r),i=n.length,a=r.length;if(1===i)return n[0];throw t("XOR_ERROR",i,a,r,s)}}class i extends l{async execute(e,l={}){const r=await Promise.allSettled(e),n=this.filterFulfilledResults(r),s=n.length,i=r.length;if(s===i)throw t("NAND_ERROR",s,i,r,n);return n}}class a extends l{async execute(e,l={}){const r=await Promise.allSettled(e),n=this.filterFulfilledResults(r),s=n.length,i=r.length;if(0===s)return[];throw t("NOR_ERROR",s,i,r,n)}}class o extends l{async execute(e,l={}){const r=await Promise.allSettled(e),n=this.filterFulfilledResults(r),s=n.length,i=r.length;if(0===s||s===i)return n;throw t("XNOR_ERROR",s,i,r,n)}}class c extends l{async execute(e,l={max:.5}){const r=await Promise.allSettled(e),n=this.filterFulfilledResults(r),s=n.length,i=r.length;if(s>Math.floor(i*l.max))return n;throw t("MAJORITY_ERROR",s,i,r)}}class u extends l{async execute(e,t={}){return new Promise(t=>{const l=[];let r=0;0!==([...e]?.length??0)?e.forEach((e,n)=>{e.then(e=>{r++,l[n]=e}).catch(()=>{l[n]=void 0}).finally(()=>{r>0&&t(l.filter(e=>void 0!==e))})}):t(l)})}}class d extends l{async execute(e,t={}){return new Promise(t=>{const l=[];let r=0;0!==([...e]?.length??0)?e.forEach((e,n)=>{e.then(()=>{l[n]=void 0}).catch(e=>{r++,l[n]=e}).finally(()=>{r>0&&t(l.filter(e=>void 0!==e))})}):t(l)})}}class f{constructor(e){this.promise=e}maxTimer(e,t=`Promise timed out after ${e}ms`){let l;return Promise.race([this.promise,new Promise((r,n)=>{l=setTimeout(()=>{n(new Error(t))},e)})]).finally(()=>clearTimeout(l))}then(e,t){return new f(this.promise.then(e,t))}catch(e){return new f(this.promise.catch(e))}finally(e){return new f(this.promise.finally(e))}toPromise(){return this.promise}}class h{static get gates(){return{and:new r,or:new n,xor:new s,nand:new i,nor:new a,xnor:new o,majority:new c,allFulfilled:new u,allRejected:new d}}static and(e){return new f(this.gates.and.execute(e))}static or(e){return new f(this.gates.or.execute(e))}static not(e){return new f(Promise.resolve(e).then(e=>Promise.reject(new Error(`NOT: ${e}`)),e=>Promise.resolve(e)))}static race(e){return new f(Promise.race(e).then(e=>Promise.resolve(e)))}static allSettled(e){return new f(Promise.allSettled(e))}static xor(e){return new f(this.gates.xor.execute(e))}static nand(e){return new f(this.gates.nand.execute(e))}static nor(e){return new f(this.gates.nor.execute(e))}static xnor(e){return new f(this.gates.xnor.execute(e))}static majority(e,t={max:.5}){return new f(this.gates.majority.execute(e,t))}static allFulfilled(e){return new f(this.gates.allFulfilled.execute(e))}static allRejected(e){return new f(this.gates.allRejected.execute(e))}static createFlipFlop(e=!1){let t=e,l=null,r=Promise.resolve(t);return{getState:()=>t,set(e){return t=e,l&&(l(t),l=null),r=Promise.resolve(t),this},toggle(){return this.set(!t)},waitForChange:()=>(l||(r=new Promise(e=>{l=e})),r),waitFor(e){return t===e?Promise.resolve(t):new Promise(l=>{const r=()=>{t===e?l(t):this.waitForChange().then(r)};r()})}}}}function R(e={}){const{prefix:t="",suffix:l="",rename:r={}}=e,n={and:h.and.bind(h),or:h.or.bind(h),race:h.race.bind(h),allSettled:h.allSettled.bind(h),xor:h.xor.bind(h),not:h.not.bind(h),nand:h.nand.bind(h),nor:h.nor.bind(h),xnor:h.xnor.bind(h),majority:h.majority.bind(h),allFulfilled:h.allFulfilled.bind(h),allRejected:h.allRejected.bind(h)},s={};return Object.entries(n).forEach(([e,n])=>{const i=r[e]||e;s[`${t}${i}${l}`]=n}),s}export{R as createPromiseLogic};

package/dist/index.cjs.js

@@ -1 +1 @@
-"use strict";class e extends Error{constructor(e,t,r){super(t),this.name="PromiseLogicError",this.type=e,this.results=r}}function t(t,r,l,i){return new e(t,{XOR_ERROR:`XOR condition failed: expected exactly 1 promise to fulfill, but ${r} fulfilled.`,NAND_ERROR:`NAND condition failed: all ${l} promises fulfilled (expected at least one rejection).`,NOT_ERROR:"NOT condition failed: promise resolved (expected rejection).",NOR_ERROR:`NOR condition failed: ${r} promises fulfilled (expected all rejected).`,MAJORITY_ERROR:`Majority condition failed: ${r}/${l} fulfilled (need majority).`,ALL_SUCCESSFUL_ERROR:`All successful condition failed: ${r}/${l} promises fulfilled (expected all to succeed).`,ALL_FAILED_ERROR:`All failed condition failed: ${l-r}/${l} promises rejected (expected all to fail).`}[t]||"Logic condition failed",i)}class r{constructor(e){this.promise=e}maxTimer(e){let t;return Promise.race([this.promise,new Promise((r,l)=>{t=setTimeout(()=>{l(new Error(`Promise timed out after ${e}ms`))},e)})]).finally(()=>clearTimeout(t))}then(e,t){return new r(this.promise.then(e,t))}catch(e){return new r(this.promise.catch(e))}finally(e){return new r(this.promise.finally(e))}toPromise(){return this.promise}}class l{static and(e){return new r(Promise.all(e))}static or(e){return new r(Promise.any(e))}static not(e){return new r(Promise.resolve(e).then(e=>Promise.reject(e),e=>Promise.resolve(e)).catch(e=>Promise.resolve(e)))}static race(e){return new r(Promise.race(e))}static allSettled(e){return new r(Promise.allSettled(e))}static xor(e){return new r(Promise.allSettled(e).then(e=>{const r=e.filter(e=>"fulfilled"===e.status),l=r.length,i=e.length;if(1===l)return r[0].value;throw t("XOR_ERROR",l,i,e)}))}static nand(e){return new r(Promise.allSettled(e).then(e=>{const r=e.filter(e=>"fulfilled"===e.status),l=r.length,i=e.length;if(l===i)throw t("NAND_ERROR",l,i,e);return r.map(e=>e.value)}))}static nor(e){return new r(Promise.allSettled(e).then(e=>{const r=e.filter(e=>"fulfilled"===e.status).length,l=e.length;if(0===r)return[];throw t("NOR_ERROR",r,l,e)}))}static xnor(e){return new r(Promise.allSettled(e).then(e=>{const r=e.filter(e=>"fulfilled"===e.status),l=r.length,i=e.length;if(0===l||l===i)return r.map(e=>e.value);throw t("XNOR_ERROR",l,i,e)}))}static majority(e,l={max:.5}){return new r(Promise.allSettled(e).then(e=>{const r=e.filter(e=>"fulfilled"===e.status),i=r.length,n=e.length;if(i>n*l.max)return r.map(e=>e.value);throw t("MAJORITY_ERROR",i,n,e)}))}static allFulfilled(e){return new r(Promise.allSettled(e).then(e=>e.filter(e=>"fulfilled"===e.status).map(e=>e.value)))}static allRejected(e){return new r(Promise.allSettled(e).then(e=>e.filter(e=>"rejected"===e.status).map(e=>e.reason)))}static createFlipFlop(e=!1){let t=e,r=null,l=Promise.resolve(t);return{getState:()=>t,set(e){return t=e,r&&(r(t),r=null),l=Promise.resolve(t),this},toggle(){return this.set(!t)},waitForChange:()=>(r||(l=new Promise(e=>{r=e})),l),waitFor(e){return t===e?Promise.resolve(t):new Promise(r=>{const l=()=>{t===e?r(t):this.waitForChange().then(l)};l()})}}}}exports.PromiseLogic=l,exports.PromiseLogicError=e,exports.PromiseWithTimer=r,exports.createLogicError=t,exports.createPromiseLogic=function(e={}){const{prefix:t="",suffix:r="",rename:i={}}=e,n={and:l.and.bind(l),or:l.or.bind(l),race:l.race.bind(l),allSettled:l.allSettled.bind(l),xor:l.xor.bind(l),not:l.not.bind(l),nand:l.nand.bind(l),nor:l.nor.bind(l),xnor:l.xnor.bind(l),majority:l.majority.bind(l),allFulfilled:l.allFulfilled.bind(l),allRejected:l.allRejected.bind(l)},o={};return Object.entries(n).forEach(([e,l])=>{const n=i[e]||e;o[`${t}${n}${r}`]=l}),o};
+"use strict";class e extends Error{constructor(e,t,r){super(t),this.name="PromiseLogicError",this.type=e,this.results=r}}function t(t,r,l,s,n){const i={XOR_ERROR:`XOR condition failed: expected exactly 1 promise to fulfill, but ${r} fulfilled.`,NAND_ERROR:`NAND condition failed: all ${l} promises fulfilled (expected at least one rejection).`,NOT_ERROR:"NOT condition failed: promise resolved (expected rejection).",NOR_ERROR:`NOR condition failed: ${r} promises fulfilled (expected all rejected).`,MAJORITY_ERROR:`Majority condition failed: ${r}/${l} fulfilled (need majority).`,ALL_SUCCESSFUL_ERROR:`All successful condition failed: ${r}/${l} promises fulfilled (expected all to succeed).`,ALL_FAILED_ERROR:`All failed condition failed: ${l-r}/${l} promises rejected (expected all to fail).`}[t],a=n.length>0?`\n失败原因：${n.map((e,t)=>`[${t+1}] ${e}`).join("\n")}`:"";return new e(t,i+a,s)}class r{filterFulfilledResults(e){return e.filter(e=>"fulfilled"===e.status).map(e=>e.value)}filterRejectedResults(e){return e.filter(e=>"rejected"===e.status).map(e=>e.reason)}countFulfilled(e){return e.filter(e=>"fulfilled"===e.status).length}countRejected(e){return e.filter(e=>"rejected"===e.status).length}}class l extends r{async execute(e,r={}){try{return await Promise.all(e)}catch(r){throw t("AND_ERROR",0,e.length,[...e],r)}}}class s extends r{async execute(e,r={}){try{return await Promise.any(e)}catch(r){throw t("OR_ERROR",0,e.length,[...e],r)}}}class n extends r{async execute(e,r={}){const l=await Promise.allSettled(e),s=this.filterFulfilledResults(l),n=this.filterRejectedResults(l),i=s.length,a=l.length;if(1===i)return s[0];throw t("XOR_ERROR",i,a,l,n)}}class i extends r{async execute(e,r={}){const l=await Promise.allSettled(e),s=this.filterFulfilledResults(l),n=s.length,i=l.length;if(n===i)throw t("NAND_ERROR",n,i,l,s);return s}}class a extends r{async execute(e,r={}){const l=await Promise.allSettled(e),s=this.filterFulfilledResults(l),n=s.length,i=l.length;if(0===n)return[];throw t("NOR_ERROR",n,i,l,s)}}class o extends r{async execute(e,r={}){const l=await Promise.allSettled(e),s=this.filterFulfilledResults(l),n=s.length,i=l.length;if(0===n||n===i)return s;throw t("XNOR_ERROR",n,i,l,s)}}class c extends r{async execute(e,r={max:.5}){const l=await Promise.allSettled(e),s=this.filterFulfilledResults(l),n=s.length,i=l.length;if(n>Math.floor(i*r.max))return s;throw t("MAJORITY_ERROR",n,i,l)}}class u extends r{async execute(e,t={}){return new Promise(t=>{const r=[];let l=0;0!==([...e]?.length??0)?e.forEach((e,s)=>{e.then(e=>{l++,r[s]=e}).catch(()=>{r[s]=void 0}).finally(()=>{l>0&&t(r.filter(e=>void 0!==e))})}):t(r)})}}class d extends r{async execute(e,t={}){return new Promise(t=>{const r=[];let l=0;0!==([...e]?.length??0)?e.forEach((e,s)=>{e.then(()=>{r[s]=void 0}).catch(e=>{l++,r[s]=e}).finally(()=>{l>0&&t(r.filter(e=>void 0!==e))})}):t(r)})}}class f{constructor(e){this.promise=e}maxTimer(e,t=`Promise timed out after ${e}ms`){let r;return Promise.race([this.promise,new Promise((l,s)=>{r=setTimeout(()=>{s(new Error(t))},e)})]).finally(()=>clearTimeout(r))}then(e,t){return new f(this.promise.then(e,t))}catch(e){return new f(this.promise.catch(e))}finally(e){return new f(this.promise.finally(e))}toPromise(){return this.promise}}class h{static get gates(){return{and:new l,or:new s,xor:new n,nand:new i,nor:new a,xnor:new o,majority:new c,allFulfilled:new u,allRejected:new d}}static and(e){return new f(this.gates.and.execute(e))}static or(e){return new f(this.gates.or.execute(e))}static not(e){return new f(Promise.resolve(e).then(e=>Promise.reject(new Error(`NOT: ${e}`)),e=>Promise.resolve(e)))}static race(e){return new f(Promise.race(e).then(e=>Promise.resolve(e)))}static allSettled(e){return new f(Promise.allSettled(e))}static xor(e){return new f(this.gates.xor.execute(e))}static nand(e){return new f(this.gates.nand.execute(e))}static nor(e){return new f(this.gates.nor.execute(e))}static xnor(e){return new f(this.gates.xnor.execute(e))}static majority(e,t={max:.5}){return new f(this.gates.majority.execute(e,t))}static allFulfilled(e){return new f(this.gates.allFulfilled.execute(e))}static allRejected(e){return new f(this.gates.allRejected.execute(e))}static createFlipFlop(e=!1){let t=e,r=null,l=Promise.resolve(t);return{getState:()=>t,set(e){return t=e,r&&(r(t),r=null),l=Promise.resolve(t),this},toggle(){return this.set(!t)},waitForChange:()=>(r||(l=new Promise(e=>{r=e})),l),waitFor(e){return t===e?Promise.resolve(t):new Promise(r=>{const l=()=>{t===e?r(t):this.waitForChange().then(l)};l()})}}}}exports.PromiseLogic=h,exports.PromiseLogicError=e,exports.PromiseWithTimer=f,exports.createLogicError=t,exports.createPromiseLogic=function(e={}){const{prefix:t="",suffix:r="",rename:l={}}=e,s={and:h.and.bind(h),or:h.or.bind(h),race:h.race.bind(h),allSettled:h.allSettled.bind(h),xor:h.xor.bind(h),not:h.not.bind(h),nand:h.nand.bind(h),nor:h.nor.bind(h),xnor:h.xnor.bind(h),majority:h.majority.bind(h),allFulfilled:h.allFulfilled.bind(h),allRejected:h.allRejected.bind(h)},n={};return Object.entries(s).forEach(([e,s])=>{const i=l[e]||e;n[`${t}${i}${r}`]=s}),n};

package/dist/index.esm.js

@@ -1 +1 @@
-class e extends Error{constructor(e,t,r){super(t),this.name="PromiseLogicError",this.type=e,this.results=r}}function t(t,r,l,i){return new e(t,{XOR_ERROR:`XOR condition failed: expected exactly 1 promise to fulfill, but ${r} fulfilled.`,NAND_ERROR:`NAND condition failed: all ${l} promises fulfilled (expected at least one rejection).`,NOT_ERROR:"NOT condition failed: promise resolved (expected rejection).",NOR_ERROR:`NOR condition failed: ${r} promises fulfilled (expected all rejected).`,MAJORITY_ERROR:`Majority condition failed: ${r}/${l} fulfilled (need majority).`,ALL_SUCCESSFUL_ERROR:`All successful condition failed: ${r}/${l} promises fulfilled (expected all to succeed).`,ALL_FAILED_ERROR:`All failed condition failed: ${l-r}/${l} promises rejected (expected all to fail).`}[t]||"Logic condition failed",i)}class r{constructor(e){this.promise=e}maxTimer(e){let t;return Promise.race([this.promise,new Promise((r,l)=>{t=setTimeout(()=>{l(new Error(`Promise timed out after ${e}ms`))},e)})]).finally(()=>clearTimeout(t))}then(e,t){return new r(this.promise.then(e,t))}catch(e){return new r(this.promise.catch(e))}finally(e){return new r(this.promise.finally(e))}toPromise(){return this.promise}}class l{static and(e){return new r(Promise.all(e))}static or(e){return new r(Promise.any(e))}static not(e){return new r(Promise.resolve(e).then(e=>Promise.reject(e),e=>Promise.resolve(e)).catch(e=>Promise.resolve(e)))}static race(e){return new r(Promise.race(e))}static allSettled(e){return new r(Promise.allSettled(e))}static xor(e){return new r(Promise.allSettled(e).then(e=>{const r=e.filter(e=>"fulfilled"===e.status),l=r.length,i=e.length;if(1===l)return r[0].value;throw t("XOR_ERROR",l,i,e)}))}static nand(e){return new r(Promise.allSettled(e).then(e=>{const r=e.filter(e=>"fulfilled"===e.status),l=r.length,i=e.length;if(l===i)throw t("NAND_ERROR",l,i,e);return r.map(e=>e.value)}))}static nor(e){return new r(Promise.allSettled(e).then(e=>{const r=e.filter(e=>"fulfilled"===e.status).length,l=e.length;if(0===r)return[];throw t("NOR_ERROR",r,l,e)}))}static xnor(e){return new r(Promise.allSettled(e).then(e=>{const r=e.filter(e=>"fulfilled"===e.status),l=r.length,i=e.length;if(0===l||l===i)return r.map(e=>e.value);throw t("XNOR_ERROR",l,i,e)}))}static majority(e,l={max:.5}){return new r(Promise.allSettled(e).then(e=>{const r=e.filter(e=>"fulfilled"===e.status),i=r.length,n=e.length;if(i>n*l.max)return r.map(e=>e.value);throw t("MAJORITY_ERROR",i,n,e)}))}static allFulfilled(e){return new r(Promise.allSettled(e).then(e=>e.filter(e=>"fulfilled"===e.status).map(e=>e.value)))}static allRejected(e){return new r(Promise.allSettled(e).then(e=>e.filter(e=>"rejected"===e.status).map(e=>e.reason)))}static createFlipFlop(e=!1){let t=e,r=null,l=Promise.resolve(t);return{getState:()=>t,set(e){return t=e,r&&(r(t),r=null),l=Promise.resolve(t),this},toggle(){return this.set(!t)},waitForChange:()=>(r||(l=new Promise(e=>{r=e})),l),waitFor(e){return t===e?Promise.resolve(t):new Promise(r=>{const l=()=>{t===e?r(t):this.waitForChange().then(l)};l()})}}}}function i(e={}){const{prefix:t="",suffix:r="",rename:i={}}=e,n={and:l.and.bind(l),or:l.or.bind(l),race:l.race.bind(l),allSettled:l.allSettled.bind(l),xor:l.xor.bind(l),not:l.not.bind(l),nand:l.nand.bind(l),nor:l.nor.bind(l),xnor:l.xnor.bind(l),majority:l.majority.bind(l),allFulfilled:l.allFulfilled.bind(l),allRejected:l.allRejected.bind(l)},o={};return Object.entries(n).forEach(([e,l])=>{const n=i[e]||e;o[`${t}${n}${r}`]=l}),o}export{l as PromiseLogic,e as PromiseLogicError,r as PromiseWithTimer,t as createLogicError,i as createPromiseLogic};
+class e extends Error{constructor(e,t,l){super(t),this.name="PromiseLogicError",this.type=e,this.results=l}}function t(t,l,r,n,s){const i={XOR_ERROR:`XOR condition failed: expected exactly 1 promise to fulfill, but ${l} fulfilled.`,NAND_ERROR:`NAND condition failed: all ${r} promises fulfilled (expected at least one rejection).`,NOT_ERROR:"NOT condition failed: promise resolved (expected rejection).",NOR_ERROR:`NOR condition failed: ${l} promises fulfilled (expected all rejected).`,MAJORITY_ERROR:`Majority condition failed: ${l}/${r} fulfilled (need majority).`,ALL_SUCCESSFUL_ERROR:`All successful condition failed: ${l}/${r} promises fulfilled (expected all to succeed).`,ALL_FAILED_ERROR:`All failed condition failed: ${r-l}/${r} promises rejected (expected all to fail).`}[t],a=s.length>0?`\n失败原因：${s.map((e,t)=>`[${t+1}] ${e}`).join("\n")}`:"";return new e(t,i+a,n)}class l{filterFulfilledResults(e){return e.filter(e=>"fulfilled"===e.status).map(e=>e.value)}filterRejectedResults(e){return e.filter(e=>"rejected"===e.status).map(e=>e.reason)}countFulfilled(e){return e.filter(e=>"fulfilled"===e.status).length}countRejected(e){return e.filter(e=>"rejected"===e.status).length}}class r extends l{async execute(e,l={}){try{return await Promise.all(e)}catch(l){throw t("AND_ERROR",0,e.length,[...e],l)}}}class n extends l{async execute(e,l={}){try{return await Promise.any(e)}catch(l){throw t("OR_ERROR",0,e.length,[...e],l)}}}class s extends l{async execute(e,l={}){const r=await Promise.allSettled(e),n=this.filterFulfilledResults(r),s=this.filterRejectedResults(r),i=n.length,a=r.length;if(1===i)return n[0];throw t("XOR_ERROR",i,a,r,s)}}class i extends l{async execute(e,l={}){const r=await Promise.allSettled(e),n=this.filterFulfilledResults(r),s=n.length,i=r.length;if(s===i)throw t("NAND_ERROR",s,i,r,n);return n}}class a extends l{async execute(e,l={}){const r=await Promise.allSettled(e),n=this.filterFulfilledResults(r),s=n.length,i=r.length;if(0===s)return[];throw t("NOR_ERROR",s,i,r,n)}}class o extends l{async execute(e,l={}){const r=await Promise.allSettled(e),n=this.filterFulfilledResults(r),s=n.length,i=r.length;if(0===s||s===i)return n;throw t("XNOR_ERROR",s,i,r,n)}}class c extends l{async execute(e,l={max:.5}){const r=await Promise.allSettled(e),n=this.filterFulfilledResults(r),s=n.length,i=r.length;if(s>Math.floor(i*l.max))return n;throw t("MAJORITY_ERROR",s,i,r)}}class u extends l{async execute(e,t={}){return new Promise(t=>{const l=[];let r=0;0!==([...e]?.length??0)?e.forEach((e,n)=>{e.then(e=>{r++,l[n]=e}).catch(()=>{l[n]=void 0}).finally(()=>{r>0&&t(l.filter(e=>void 0!==e))})}):t(l)})}}class d extends l{async execute(e,t={}){return new Promise(t=>{const l=[];let r=0;0!==([...e]?.length??0)?e.forEach((e,n)=>{e.then(()=>{l[n]=void 0}).catch(e=>{r++,l[n]=e}).finally(()=>{r>0&&t(l.filter(e=>void 0!==e))})}):t(l)})}}class f{constructor(e){this.promise=e}maxTimer(e,t=`Promise timed out after ${e}ms`){let l;return Promise.race([this.promise,new Promise((r,n)=>{l=setTimeout(()=>{n(new Error(t))},e)})]).finally(()=>clearTimeout(l))}then(e,t){return new f(this.promise.then(e,t))}catch(e){return new f(this.promise.catch(e))}finally(e){return new f(this.promise.finally(e))}toPromise(){return this.promise}}class h{static get gates(){return{and:new r,or:new n,xor:new s,nand:new i,nor:new a,xnor:new o,majority:new c,allFulfilled:new u,allRejected:new d}}static and(e){return new f(this.gates.and.execute(e))}static or(e){return new f(this.gates.or.execute(e))}static not(e){return new f(Promise.resolve(e).then(e=>Promise.reject(new Error(`NOT: ${e}`)),e=>Promise.resolve(e)))}static race(e){return new f(Promise.race(e).then(e=>Promise.resolve(e)))}static allSettled(e){return new f(Promise.allSettled(e))}static xor(e){return new f(this.gates.xor.execute(e))}static nand(e){return new f(this.gates.nand.execute(e))}static nor(e){return new f(this.gates.nor.execute(e))}static xnor(e){return new f(this.gates.xnor.execute(e))}static majority(e,t={max:.5}){return new f(this.gates.majority.execute(e,t))}static allFulfilled(e){return new f(this.gates.allFulfilled.execute(e))}static allRejected(e){return new f(this.gates.allRejected.execute(e))}static createFlipFlop(e=!1){let t=e,l=null,r=Promise.resolve(t);return{getState:()=>t,set(e){return t=e,l&&(l(t),l=null),r=Promise.resolve(t),this},toggle(){return this.set(!t)},waitForChange:()=>(l||(r=new Promise(e=>{l=e})),r),waitFor(e){return t===e?Promise.resolve(t):new Promise(l=>{const r=()=>{t===e?l(t):this.waitForChange().then(r)};r()})}}}}function R(e={}){const{prefix:t="",suffix:l="",rename:r={}}=e,n={and:h.and.bind(h),or:h.or.bind(h),race:h.race.bind(h),allSettled:h.allSettled.bind(h),xor:h.xor.bind(h),not:h.not.bind(h),nand:h.nand.bind(h),nor:h.nor.bind(h),xnor:h.xnor.bind(h),majority:h.majority.bind(h),allFulfilled:h.allFulfilled.bind(h),allRejected:h.allRejected.bind(h)},s={};return Object.entries(n).forEach(([e,n])=>{const i=r[e]||e;s[`${t}${i}${l}`]=n}),s}export{h as PromiseLogic,e as PromiseLogicError,f as PromiseWithTimer,t as createLogicError,R as createPromiseLogic};

package/dist/v2/factory.cjs.js

@@ -1 +1 @@
-"use strict";class e{filterFulfilledResults(e){return e.filter(e=>"fulfilled"===e.status).map(e=>e.value)}filterRejectedResults(e){return e.filter(e=>"rejected"===e.status).map(e=>e.reason)}countFulfilled(e){return e.filter(e=>"fulfilled"===e.status).length}}class t extends e{async execute(e){return Promise.any(e)}}class l extends Error{constructor(e,t,l){super(t),this.type=e,this.results=l,this.name="PromiseLogicError"}}function r(e,t,r,s){return new l(e,{XOR_ERROR:`XOR condition failed: expected exactly 1 promise to fulfill, but ${t} fulfilled.`,NAND_ERROR:`NAND condition failed: all ${r} promises fulfilled (expected at least one rejection).`,NOR_ERROR:`NOR condition failed: ${t} promises fulfilled (expected all rejected).`,XNOR_ERROR:`XNOR condition failed: ${t}/${r} promises fulfilled (expected all or none).`,MAJORITY_ERROR:`Majority condition failed: ${t}/${r} fulfilled (need majority).`,ALL_SUCCESSFUL_ERROR:`All successful condition failed: ${t}/${r} promises fulfilled (expected all to succeed).`,ALL_FAILED_ERROR:`All failed condition failed: ${r-t}/${r} promises rejected (expected all to fail).`}[e]||"Logic condition failed",s)}class s extends e{async execute(e){try{return Promise.all(e)}catch(e){throw new l("AND_ERROR","AND gate failed",[e])}}}class i extends e{async execute(e,t){const l=await Promise.allSettled(e),s=this.filterFulfilledResults(l),i=s.length,n=l.length;if(i>n*t.max)return s;throw r("MAJORITY_ERROR",i,n,l)}}class n extends e{async execute(e){const t=await Promise.allSettled(e),l=this.filterFulfilledResults(t),s=l.length,i=t.length;if(s===i)throw r("NAND_ERROR",s,i,t);return l}}class a extends e{async execute(e){const t=await Promise.allSettled(e),l=this.filterFulfilledResults(t).length,s=t.length;if(0===l)return[];throw r("NOR_ERROR",l,s,t)}}class o extends e{async execute(e){const t=await Promise.allSettled(e),l=this.filterFulfilledResults(t),s=l.length,i=t.length;if(0===s||s===i)return l;throw r("XNOR_ERROR",s,i,t)}}class c extends e{async execute(e){const t=await Promise.allSettled(e),l=this.filterFulfilledResults(t),s=l.length,i=t.length;if(1===s)return l[0];throw r("XOR_ERROR",s,i,t)}}class u{constructor(e){this.promise=e}maxTimer(e){let t;return Promise.race([this.promise,new Promise((l,r)=>{t=setTimeout(()=>{r(new Error(`Promise timed out after ${e}ms,${this.promise}`))},e)})]).finally(()=>clearTimeout(t))}then(e,t){return new u(this.promise.then(e,t))}catch(e){return new u(this.promise.catch(e))}finally(e){return new u(this.promise.finally(e))}toPromise(){return this.promise}}class d{static get gates(){return{and:new s,or:new t,xor:new c,nand:new n,nor:new a,xnor:new o,majority:new i}}static and(e){return new u(this.gates.and.execute(e))}static or(e){return new u(this.gates.or.execute(e))}static xor(e){return new u(this.gates.xor.execute(e))}static nand(e){return new u(this.gates.nand.execute(e))}static nor(e){return new u(this.gates.nor.execute(e))}static xnor(e){return new u(this.gates.xnor.execute(e))}static majority(e,t={max:.5}){return new u(this.gates.majority.execute(e,t))}static allFulfilled(e){return new u(Promise.allSettled(e).then(e=>e.filter(e=>"fulfilled"===e.status).map(e=>e.value)))}static allRejected(e){return new u(Promise.allSettled(e).then(e=>e.filter(e=>"rejected"===e.status).map(e=>e.reason)))}static not(e){return new u(Promise.resolve(e).then(e=>Promise.reject(e),e=>Promise.resolve(e)))}static race(e){return new u(Promise.race(e))}static allSettled(e){return new u(Promise.allSettled(e))}static createFlipFlop(e=!1){let t=e,l=null,r=Promise.resolve(t);const s=()=>(l||(r=new Promise(e=>{l=e})),r);return{getState:()=>t,set:async e=>(t=e,l&&(l(t),l=null),r=Promise.resolve(t),t),async toggle(){return this.set(!t)},waitForChange:s,waitFor:e=>t===e?Promise.resolve(t):new Promise(l=>{const r=()=>{t===e?l(t):s().then(r)};r()})}}}exports.createPromiseLogic=function(e={}){const{prefix:t="",suffix:l="",rename:r={}}=e,s={and:d.and.bind(d),or:d.or.bind(d),not:d.not.bind(d),race:d.race.bind(d),allSettled:d.allSettled.bind(d),xor:d.xor.bind(d),nand:d.nand.bind(d),nor:d.nor.bind(d),xnor:d.xnor.bind(d),majority:d.majority.bind(d),allFulfilled:d.allFulfilled.bind(d),allRejected:d.allRejected.bind(d)},i={};return Object.entries(s).forEach(([e,s])=>{const n=r[e]||e;i[`${t}${n}${l}`]=s}),i};
+"use strict";class e extends Error{constructor(e,t,l){super(t),this.type=e,this.results=l,this.name="PromiseLogicError"}}function t(t,l,s,r,n){const i={XOR_ERROR:`XOR condition failed: expected exactly 1 promise to fulfill, but ${l} fulfilled.`,NAND_ERROR:`NAND condition failed: all ${s} promises fulfilled (expected at least one rejection).`,NOR_ERROR:`NOR condition failed: ${l} promises fulfilled (expected all rejected).`,XNOR_ERROR:`XNOR condition failed: ${l}/${s} promises fulfilled (expected all or none).`,MAJORITY_ERROR:`Majority condition failed: ${l}/${s} fulfilled (need majority).`,ALL_SUCCESSFUL_ERROR:`All successful condition failed: ${l}/${s} promises fulfilled (expected all to succeed).`,ALL_FAILED_ERROR:`All failed condition failed: ${s-l}/${s} promises rejected (expected all to fail).`}[t]||"Logic condition failed",a=n&&n?.length>0?`\n失败原因：${n.map((e,t)=>`[${t+1}] ${e}`).join("\n")}`:"";return new e(t,i+a,r)}class l{filterFulfilledResults(e){return e.filter(e=>"fulfilled"===e.status).map(e=>e.value)}filterRejectedResults(e){return e.filter(e=>"rejected"===e.status).map(e=>e.reason)}countFulfilled(e){return e.filter(e=>"fulfilled"===e.status).length}}class s extends l{async execute(e){try{return Promise.any(e)}catch(e){throw t("OR_ERROR",0,0,[],[e])}}}class r extends l{async execute(e){try{return Promise.all(e)}catch(e){throw t("AND_ERROR",0,0,[],[e])}}}class n extends l{async execute(e,l){const s=await Promise.allSettled(e),r=this.filterFulfilledResults(s),n=r.length,i=s.length,a=this.filterRejectedResults(s);if(n>Math.floor(i*l.max))return r;throw t("MAJORITY_ERROR",n,i,s,a)}}class i extends l{async execute(e){const l=await Promise.allSettled(e),s=this.filterFulfilledResults(l),r=s.length,n=l.length,i=this.filterRejectedResults(l);if(r===n)throw t("NAND_ERROR",r,n,l,i);return s}}class a extends l{async execute(e){const l=await Promise.allSettled(e),s=this.filterFulfilledResults(l).length,r=l.length,n=this.filterRejectedResults(l);if(0===s)return[];throw t("NOR_ERROR",s,r,l,n)}}class o extends l{async execute(e){const l=await Promise.allSettled(e),s=this.filterFulfilledResults(l),r=s.length,n=l.length,i=this.filterRejectedResults(l);if(0===r||r===n)return s;throw t("XNOR_ERROR",r,n,l,i)}}class c extends l{async execute(e){const l=await Promise.allSettled(e),s=this.filterFulfilledResults(l),r=s.length,n=l.length,i=this.filterRejectedResults(l);if(1===r)return s[0];throw t("XOR_ERROR",r,n,l,i)}}class u extends l{async execute(e,t={}){return new Promise(t=>{const l=[];let s=0;const r=[...e];0!==(r?.length??0)?r.forEach((e,r)=>{Promise.resolve(e).then(e=>{s++,l[r]=e}).catch(()=>{l[r]=void 0}).finally(()=>{s>0&&t(l.filter(e=>void 0!==e))})}):t(l)})}}class d extends l{async execute(e,t={}){return new Promise(t=>{const l=[];let s=0;const r=[...e];0!==(r?.length??0)?r.forEach((e,r)=>{Promise.resolve(e).then(()=>{l[r]=void 0}).catch(e=>{s++,l[r]=e}).finally(()=>{s>0&&t(l.filter(e=>void 0!==e))})}):t(l)})}}class f{constructor(e){this.promise=e}maxTimer(e,t=`Promise timed out after ${e}ms`){let l;return Promise.race([this.promise,new Promise((s,r)=>{l=setTimeout(()=>{r(new Error(t))},e)})]).finally(()=>clearTimeout(l))}then(e,t){return new f(this.promise.then(e,t))}catch(e){return new f(this.promise.catch(e))}finally(e){return new f(this.promise.finally(e))}toPromise(){return this.promise}}class R{static get gates(){return{and:new r,or:new s,xor:new c,nand:new i,nor:new a,xnor:new o,majority:new n,allFulfilled:new u,allRejected:new d}}static and(e){return new f(this.gates.and.execute(e))}static or(e){return new f(this.gates.or.execute(e))}static xor(e){return new f(this.gates.xor.execute(e))}static nand(e){return new f(this.gates.nand.execute(e))}static nor(e){return new f(this.gates.nor.execute(e))}static xnor(e){return new f(this.gates.xnor.execute(e))}static majority(e,t={max:.5}){return new f(this.gates.majority.execute(e,t))}static allFulfilled(e){return new f(this.gates.allFulfilled.execute(e))}static allRejected(e){return new f(this.gates.allRejected.execute(e))}static not(e){return new f(Promise.resolve(e).then(e=>Promise.reject(new Error(`NOT: ${e}`)),e=>Promise.resolve(e)))}static race(e){return new f(Promise.race(e))}static allSettled(e){return new f(Promise.allSettled(e))}static createFlipFlop(e=!1){let t=e,l=null,s=Promise.resolve(t);const r=()=>(l||(s=new Promise(e=>{l=e})),s);return{getState:()=>t,set:async e=>(t=e,l&&(l(t),l=null),s=Promise.resolve(t),t),async toggle(){return this.set(!t)},waitForChange:r,waitFor:e=>t===e?Promise.resolve(t):new Promise(l=>{const s=()=>{t===e?l(t):r().then(s)};s()})}}}exports.createPromiseLogic=function(e={}){const{prefix:t="",suffix:l="",rename:s={}}=e,r={and:R.and.bind(R),or:R.or.bind(R),not:R.not.bind(R),race:R.race.bind(R),allSettled:R.allSettled.bind(R),xor:R.xor.bind(R),nand:R.nand.bind(R),nor:R.nor.bind(R),xnor:R.xnor.bind(R),majority:R.majority.bind(R),allFulfilled:R.allFulfilled.bind(R),allRejected:R.allRejected.bind(R)},n={};return Object.entries(r).forEach(([e,r])=>{const i=s[e]||e;n[`${t}${i}${l}`]=r}),n};

package/dist/v2/factory.esm.js

@@ -1 +1 @@
-class e{filterFulfilledResults(e){return e.filter(e=>"fulfilled"===e.status).map(e=>e.value)}filterRejectedResults(e){return e.filter(e=>"rejected"===e.status).map(e=>e.reason)}countFulfilled(e){return e.filter(e=>"fulfilled"===e.status).length}}class t extends e{async execute(e){return Promise.any(e)}}class l extends Error{constructor(e,t,l){super(t),this.type=e,this.results=l,this.name="PromiseLogicError"}}function r(e,t,r,n){return new l(e,{XOR_ERROR:`XOR condition failed: expected exactly 1 promise to fulfill, but ${t} fulfilled.`,NAND_ERROR:`NAND condition failed: all ${r} promises fulfilled (expected at least one rejection).`,NOR_ERROR:`NOR condition failed: ${t} promises fulfilled (expected all rejected).`,XNOR_ERROR:`XNOR condition failed: ${t}/${r} promises fulfilled (expected all or none).`,MAJORITY_ERROR:`Majority condition failed: ${t}/${r} fulfilled (need majority).`,ALL_SUCCESSFUL_ERROR:`All successful condition failed: ${t}/${r} promises fulfilled (expected all to succeed).`,ALL_FAILED_ERROR:`All failed condition failed: ${r-t}/${r} promises rejected (expected all to fail).`}[e]||"Logic condition failed",n)}class n extends e{async execute(e){try{return Promise.all(e)}catch(e){throw new l("AND_ERROR","AND gate failed",[e])}}}class s extends e{async execute(e,t){const l=await Promise.allSettled(e),n=this.filterFulfilledResults(l),s=n.length,i=l.length;if(s>i*t.max)return n;throw r("MAJORITY_ERROR",s,i,l)}}class i extends e{async execute(e){const t=await Promise.allSettled(e),l=this.filterFulfilledResults(t),n=l.length,s=t.length;if(n===s)throw r("NAND_ERROR",n,s,t);return l}}class a extends e{async execute(e){const t=await Promise.allSettled(e),l=this.filterFulfilledResults(t).length,n=t.length;if(0===l)return[];throw r("NOR_ERROR",l,n,t)}}class o extends e{async execute(e){const t=await Promise.allSettled(e),l=this.filterFulfilledResults(t),n=l.length,s=t.length;if(0===n||n===s)return l;throw r("XNOR_ERROR",n,s,t)}}class c extends e{async execute(e){const t=await Promise.allSettled(e),l=this.filterFulfilledResults(t),n=l.length,s=t.length;if(1===n)return l[0];throw r("XOR_ERROR",n,s,t)}}class u{constructor(e){this.promise=e}maxTimer(e){let t;return Promise.race([this.promise,new Promise((l,r)=>{t=setTimeout(()=>{r(new Error(`Promise timed out after ${e}ms,${this.promise}`))},e)})]).finally(()=>clearTimeout(t))}then(e,t){return new u(this.promise.then(e,t))}catch(e){return new u(this.promise.catch(e))}finally(e){return new u(this.promise.finally(e))}toPromise(){return this.promise}}class d{static get gates(){return{and:new n,or:new t,xor:new c,nand:new i,nor:new a,xnor:new o,majority:new s}}static and(e){return new u(this.gates.and.execute(e))}static or(e){return new u(this.gates.or.execute(e))}static xor(e){return new u(this.gates.xor.execute(e))}static nand(e){return new u(this.gates.nand.execute(e))}static nor(e){return new u(this.gates.nor.execute(e))}static xnor(e){return new u(this.gates.xnor.execute(e))}static majority(e,t={max:.5}){return new u(this.gates.majority.execute(e,t))}static allFulfilled(e){return new u(Promise.allSettled(e).then(e=>e.filter(e=>"fulfilled"===e.status).map(e=>e.value)))}static allRejected(e){return new u(Promise.allSettled(e).then(e=>e.filter(e=>"rejected"===e.status).map(e=>e.reason)))}static not(e){return new u(Promise.resolve(e).then(e=>Promise.reject(e),e=>Promise.resolve(e)))}static race(e){return new u(Promise.race(e))}static allSettled(e){return new u(Promise.allSettled(e))}static createFlipFlop(e=!1){let t=e,l=null,r=Promise.resolve(t);const n=()=>(l||(r=new Promise(e=>{l=e})),r);return{getState:()=>t,set:async e=>(t=e,l&&(l(t),l=null),r=Promise.resolve(t),t),async toggle(){return this.set(!t)},waitForChange:n,waitFor:e=>t===e?Promise.resolve(t):new Promise(l=>{const r=()=>{t===e?l(t):n().then(r)};r()})}}}function f(e={}){const{prefix:t="",suffix:l="",rename:r={}}=e,n={and:d.and.bind(d),or:d.or.bind(d),not:d.not.bind(d),race:d.race.bind(d),allSettled:d.allSettled.bind(d),xor:d.xor.bind(d),nand:d.nand.bind(d),nor:d.nor.bind(d),xnor:d.xnor.bind(d),majority:d.majority.bind(d),allFulfilled:d.allFulfilled.bind(d),allRejected:d.allRejected.bind(d)},s={};return Object.entries(n).forEach(([e,n])=>{const i=r[e]||e;s[`${t}${i}${l}`]=n}),s}export{f as createPromiseLogic};
+class e extends Error{constructor(e,t,l){super(t),this.type=e,this.results=l,this.name="PromiseLogicError"}}function t(t,l,s,r,n){const i={XOR_ERROR:`XOR condition failed: expected exactly 1 promise to fulfill, but ${l} fulfilled.`,NAND_ERROR:`NAND condition failed: all ${s} promises fulfilled (expected at least one rejection).`,NOR_ERROR:`NOR condition failed: ${l} promises fulfilled (expected all rejected).`,XNOR_ERROR:`XNOR condition failed: ${l}/${s} promises fulfilled (expected all or none).`,MAJORITY_ERROR:`Majority condition failed: ${l}/${s} fulfilled (need majority).`,ALL_SUCCESSFUL_ERROR:`All successful condition failed: ${l}/${s} promises fulfilled (expected all to succeed).`,ALL_FAILED_ERROR:`All failed condition failed: ${s-l}/${s} promises rejected (expected all to fail).`}[t]||"Logic condition failed",a=n&&n?.length>0?`\n失败原因：${n.map((e,t)=>`[${t+1}] ${e}`).join("\n")}`:"";return new e(t,i+a,r)}class l{filterFulfilledResults(e){return e.filter(e=>"fulfilled"===e.status).map(e=>e.value)}filterRejectedResults(e){return e.filter(e=>"rejected"===e.status).map(e=>e.reason)}countFulfilled(e){return e.filter(e=>"fulfilled"===e.status).length}}class s extends l{async execute(e){try{return Promise.any(e)}catch(e){throw t("OR_ERROR",0,0,[],[e])}}}class r extends l{async execute(e){try{return Promise.all(e)}catch(e){throw t("AND_ERROR",0,0,[],[e])}}}class n extends l{async execute(e,l){const s=await Promise.allSettled(e),r=this.filterFulfilledResults(s),n=r.length,i=s.length,a=this.filterRejectedResults(s);if(n>Math.floor(i*l.max))return r;throw t("MAJORITY_ERROR",n,i,s,a)}}class i extends l{async execute(e){const l=await Promise.allSettled(e),s=this.filterFulfilledResults(l),r=s.length,n=l.length,i=this.filterRejectedResults(l);if(r===n)throw t("NAND_ERROR",r,n,l,i);return s}}class a extends l{async execute(e){const l=await Promise.allSettled(e),s=this.filterFulfilledResults(l).length,r=l.length,n=this.filterRejectedResults(l);if(0===s)return[];throw t("NOR_ERROR",s,r,l,n)}}class o extends l{async execute(e){const l=await Promise.allSettled(e),s=this.filterFulfilledResults(l),r=s.length,n=l.length,i=this.filterRejectedResults(l);if(0===r||r===n)return s;throw t("XNOR_ERROR",r,n,l,i)}}class c extends l{async execute(e){const l=await Promise.allSettled(e),s=this.filterFulfilledResults(l),r=s.length,n=l.length,i=this.filterRejectedResults(l);if(1===r)return s[0];throw t("XOR_ERROR",r,n,l,i)}}class u extends l{async execute(e,t={}){return new Promise(t=>{const l=[];let s=0;const r=[...e];0!==(r?.length??0)?r.forEach((e,r)=>{Promise.resolve(e).then(e=>{s++,l[r]=e}).catch(()=>{l[r]=void 0}).finally(()=>{s>0&&t(l.filter(e=>void 0!==e))})}):t(l)})}}class d extends l{async execute(e,t={}){return new Promise(t=>{const l=[];let s=0;const r=[...e];0!==(r?.length??0)?r.forEach((e,r)=>{Promise.resolve(e).then(()=>{l[r]=void 0}).catch(e=>{s++,l[r]=e}).finally(()=>{s>0&&t(l.filter(e=>void 0!==e))})}):t(l)})}}class f{constructor(e){this.promise=e}maxTimer(e,t=`Promise timed out after ${e}ms`){let l;return Promise.race([this.promise,new Promise((s,r)=>{l=setTimeout(()=>{r(new Error(t))},e)})]).finally(()=>clearTimeout(l))}then(e,t){return new f(this.promise.then(e,t))}catch(e){return new f(this.promise.catch(e))}finally(e){return new f(this.promise.finally(e))}toPromise(){return this.promise}}class R{static get gates(){return{and:new r,or:new s,xor:new c,nand:new i,nor:new a,xnor:new o,majority:new n,allFulfilled:new u,allRejected:new d}}static and(e){return new f(this.gates.and.execute(e))}static or(e){return new f(this.gates.or.execute(e))}static xor(e){return new f(this.gates.xor.execute(e))}static nand(e){return new f(this.gates.nand.execute(e))}static nor(e){return new f(this.gates.nor.execute(e))}static xnor(e){return new f(this.gates.xnor.execute(e))}static majority(e,t={max:.5}){return new f(this.gates.majority.execute(e,t))}static allFulfilled(e){return new f(this.gates.allFulfilled.execute(e))}static allRejected(e){return new f(this.gates.allRejected.execute(e))}static not(e){return new f(Promise.resolve(e).then(e=>Promise.reject(new Error(`NOT: ${e}`)),e=>Promise.resolve(e)))}static race(e){return new f(Promise.race(e))}static allSettled(e){return new f(Promise.allSettled(e))}static createFlipFlop(e=!1){let t=e,l=null,s=Promise.resolve(t);const r=()=>(l||(s=new Promise(e=>{l=e})),s);return{getState:()=>t,set:async e=>(t=e,l&&(l(t),l=null),s=Promise.resolve(t),t),async toggle(){return this.set(!t)},waitForChange:r,waitFor:e=>t===e?Promise.resolve(t):new Promise(l=>{const s=()=>{t===e?l(t):r().then(s)};s()})}}}function h(e={}){const{prefix:t="",suffix:l="",rename:s={}}=e,r={and:R.and.bind(R),or:R.or.bind(R),not:R.not.bind(R),race:R.race.bind(R),allSettled:R.allSettled.bind(R),xor:R.xor.bind(R),nand:R.nand.bind(R),nor:R.nor.bind(R),xnor:R.xnor.bind(R),majority:R.majority.bind(R),allFulfilled:R.allFulfilled.bind(R),allRejected:R.allRejected.bind(R)},n={};return Object.entries(r).forEach(([e,r])=>{const i=s[e]||e;n[`${t}${i}${l}`]=r}),n}export{h as createPromiseLogic};

package/dist/v2/index.cjs.js

@@ -1 +1 @@
-"use strict";class e{filterFulfilledResults(e){return e.filter(e=>"fulfilled"===e.status).map(e=>e.value)}filterRejectedResults(e){return e.filter(e=>"rejected"===e.status).map(e=>e.reason)}countFulfilled(e){return e.filter(e=>"fulfilled"===e.status).length}}class t extends e{async execute(e){return Promise.any(e)}}class r extends Error{constructor(e,t,r){super(t),this.type=e,this.results=r,this.name="PromiseLogicError"}}function l(e,t,l,s){return new r(e,{XOR_ERROR:`XOR condition failed: expected exactly 1 promise to fulfill, but ${t} fulfilled.`,NAND_ERROR:`NAND condition failed: all ${l} promises fulfilled (expected at least one rejection).`,NOR_ERROR:`NOR condition failed: ${t} promises fulfilled (expected all rejected).`,XNOR_ERROR:`XNOR condition failed: ${t}/${l} promises fulfilled (expected all or none).`,MAJORITY_ERROR:`Majority condition failed: ${t}/${l} fulfilled (need majority).`,ALL_SUCCESSFUL_ERROR:`All successful condition failed: ${t}/${l} promises fulfilled (expected all to succeed).`,ALL_FAILED_ERROR:`All failed condition failed: ${l-t}/${l} promises rejected (expected all to fail).`}[e]||"Logic condition failed",s)}class s extends e{async execute(e){try{return Promise.all(e)}catch(e){throw new r("AND_ERROR","AND gate failed",[e])}}}class i extends e{async execute(e,t){const r=await Promise.allSettled(e),s=this.filterFulfilledResults(r),i=s.length,n=r.length;if(i>n*t.max)return s;throw l("MAJORITY_ERROR",i,n,r)}}class n extends e{async execute(e){const t=await Promise.allSettled(e),r=this.filterFulfilledResults(t),s=r.length,i=t.length;if(s===i)throw l("NAND_ERROR",s,i,t);return r}}class a extends e{async execute(e){const t=await Promise.allSettled(e),r=this.filterFulfilledResults(t).length,s=t.length;if(0===r)return[];throw l("NOR_ERROR",r,s,t)}}class o extends e{async execute(e){const t=await Promise.allSettled(e),r=this.filterFulfilledResults(t),s=r.length,i=t.length;if(0===s||s===i)return r;throw l("XNOR_ERROR",s,i,t)}}class c extends e{async execute(e){const t=await Promise.allSettled(e),r=this.filterFulfilledResults(t),s=r.length,i=t.length;if(1===s)return r[0];throw l("XOR_ERROR",s,i,t)}}class u{constructor(e){this.promise=e}maxTimer(e){let t;return Promise.race([this.promise,new Promise((r,l)=>{t=setTimeout(()=>{l(new Error(`Promise timed out after ${e}ms,${this.promise}`))},e)})]).finally(()=>clearTimeout(t))}then(e,t){return new u(this.promise.then(e,t))}catch(e){return new u(this.promise.catch(e))}finally(e){return new u(this.promise.finally(e))}toPromise(){return this.promise}}class d{static get gates(){return{and:new s,or:new t,xor:new c,nand:new n,nor:new a,xnor:new o,majority:new i}}static and(e){return new u(this.gates.and.execute(e))}static or(e){return new u(this.gates.or.execute(e))}static xor(e){return new u(this.gates.xor.execute(e))}static nand(e){return new u(this.gates.nand.execute(e))}static nor(e){return new u(this.gates.nor.execute(e))}static xnor(e){return new u(this.gates.xnor.execute(e))}static majority(e,t={max:.5}){return new u(this.gates.majority.execute(e,t))}static allFulfilled(e){return new u(Promise.allSettled(e).then(e=>e.filter(e=>"fulfilled"===e.status).map(e=>e.value)))}static allRejected(e){return new u(Promise.allSettled(e).then(e=>e.filter(e=>"rejected"===e.status).map(e=>e.reason)))}static not(e){return new u(Promise.resolve(e).then(e=>Promise.reject(e),e=>Promise.resolve(e)))}static race(e){return new u(Promise.race(e))}static allSettled(e){return new u(Promise.allSettled(e))}static createFlipFlop(e=!1){let t=e,r=null,l=Promise.resolve(t);const s=()=>(r||(l=new Promise(e=>{r=e})),l);return{getState:()=>t,set:async e=>(t=e,r&&(r(t),r=null),l=Promise.resolve(t),t),async toggle(){return this.set(!t)},waitForChange:s,waitFor:e=>t===e?Promise.resolve(t):new Promise(r=>{const l=()=>{t===e?r(t):s().then(l)};l()})}}}exports.PromiseLogic=d,exports.PromiseLogicError=r,exports.PromiseWithTimer=u,exports.createPromiseLogic=function(e={}){const{prefix:t="",suffix:r="",rename:l={}}=e,s={and:d.and.bind(d),or:d.or.bind(d),not:d.not.bind(d),race:d.race.bind(d),allSettled:d.allSettled.bind(d),xor:d.xor.bind(d),nand:d.nand.bind(d),nor:d.nor.bind(d),xnor:d.xnor.bind(d),majority:d.majority.bind(d),allFulfilled:d.allFulfilled.bind(d),allRejected:d.allRejected.bind(d)},i={};return Object.entries(s).forEach(([e,s])=>{const n=l[e]||e;i[`${t}${n}${r}`]=s}),i};
+"use strict";class e extends Error{constructor(e,t,l){super(t),this.type=e,this.results=l,this.name="PromiseLogicError"}}function t(t,l,r,s,i){const n={XOR_ERROR:`XOR condition failed: expected exactly 1 promise to fulfill, but ${l} fulfilled.`,NAND_ERROR:`NAND condition failed: all ${r} promises fulfilled (expected at least one rejection).`,NOR_ERROR:`NOR condition failed: ${l} promises fulfilled (expected all rejected).`,XNOR_ERROR:`XNOR condition failed: ${l}/${r} promises fulfilled (expected all or none).`,MAJORITY_ERROR:`Majority condition failed: ${l}/${r} fulfilled (need majority).`,ALL_SUCCESSFUL_ERROR:`All successful condition failed: ${l}/${r} promises fulfilled (expected all to succeed).`,ALL_FAILED_ERROR:`All failed condition failed: ${r-l}/${r} promises rejected (expected all to fail).`}[t]||"Logic condition failed",o=i&&i?.length>0?`\n失败原因：${i.map((e,t)=>`[${t+1}] ${e}`).join("\n")}`:"";return new e(t,n+o,s)}class l{filterFulfilledResults(e){return e.filter(e=>"fulfilled"===e.status).map(e=>e.value)}filterRejectedResults(e){return e.filter(e=>"rejected"===e.status).map(e=>e.reason)}countFulfilled(e){return e.filter(e=>"fulfilled"===e.status).length}}class r extends l{async execute(e){try{return Promise.any(e)}catch(e){throw t("OR_ERROR",0,0,[],[e])}}}class s extends l{async execute(e){try{return Promise.all(e)}catch(e){throw t("AND_ERROR",0,0,[],[e])}}}class i extends l{async execute(e,l){const r=await Promise.allSettled(e),s=this.filterFulfilledResults(r),i=s.length,n=r.length,o=this.filterRejectedResults(r);if(i>Math.floor(n*l.max))return s;throw t("MAJORITY_ERROR",i,n,r,o)}}class n extends l{async execute(e){const l=await Promise.allSettled(e),r=this.filterFulfilledResults(l),s=r.length,i=l.length,n=this.filterRejectedResults(l);if(s===i)throw t("NAND_ERROR",s,i,l,n);return r}}class o extends l{async execute(e){const l=await Promise.allSettled(e),r=this.filterFulfilledResults(l).length,s=l.length,i=this.filterRejectedResults(l);if(0===r)return[];throw t("NOR_ERROR",r,s,l,i)}}class a extends l{async execute(e){const l=await Promise.allSettled(e),r=this.filterFulfilledResults(l),s=r.length,i=l.length,n=this.filterRejectedResults(l);if(0===s||s===i)return r;throw t("XNOR_ERROR",s,i,l,n)}}class c extends l{async execute(e){const l=await Promise.allSettled(e),r=this.filterFulfilledResults(l),s=r.length,i=l.length,n=this.filterRejectedResults(l);if(1===s)return r[0];throw t("XOR_ERROR",s,i,l,n)}}class u extends l{async execute(e,t={}){return new Promise(t=>{const l=[];let r=0;const s=[...e];0!==(s?.length??0)?s.forEach((e,s)=>{Promise.resolve(e).then(e=>{r++,l[s]=e}).catch(()=>{l[s]=void 0}).finally(()=>{r>0&&t(l.filter(e=>void 0!==e))})}):t(l)})}}class d extends l{async execute(e,t={}){return new Promise(t=>{const l=[];let r=0;const s=[...e];0!==(s?.length??0)?s.forEach((e,s)=>{Promise.resolve(e).then(()=>{l[s]=void 0}).catch(e=>{r++,l[s]=e}).finally(()=>{r>0&&t(l.filter(e=>void 0!==e))})}):t(l)})}}class f{constructor(e){this.promise=e}maxTimer(e,t=`Promise timed out after ${e}ms`){let l;return Promise.race([this.promise,new Promise((r,s)=>{l=setTimeout(()=>{s(new Error(t))},e)})]).finally(()=>clearTimeout(l))}then(e,t){return new f(this.promise.then(e,t))}catch(e){return new f(this.promise.catch(e))}finally(e){return new f(this.promise.finally(e))}toPromise(){return this.promise}}class R{static get gates(){return{and:new s,or:new r,xor:new c,nand:new n,nor:new o,xnor:new a,majority:new i,allFulfilled:new u,allRejected:new d}}static and(e){return new f(this.gates.and.execute(e))}static or(e){return new f(this.gates.or.execute(e))}static xor(e){return new f(this.gates.xor.execute(e))}static nand(e){return new f(this.gates.nand.execute(e))}static nor(e){return new f(this.gates.nor.execute(e))}static xnor(e){return new f(this.gates.xnor.execute(e))}static majority(e,t={max:.5}){return new f(this.gates.majority.execute(e,t))}static allFulfilled(e){return new f(this.gates.allFulfilled.execute(e))}static allRejected(e){return new f(this.gates.allRejected.execute(e))}static not(e){return new f(Promise.resolve(e).then(e=>Promise.reject(new Error(`NOT: ${e}`)),e=>Promise.resolve(e)))}static race(e){return new f(Promise.race(e))}static allSettled(e){return new f(Promise.allSettled(e))}static createFlipFlop(e=!1){let t=e,l=null,r=Promise.resolve(t);const s=()=>(l||(r=new Promise(e=>{l=e})),r);return{getState:()=>t,set:async e=>(t=e,l&&(l(t),l=null),r=Promise.resolve(t),t),async toggle(){return this.set(!t)},waitForChange:s,waitFor:e=>t===e?Promise.resolve(t):new Promise(l=>{const r=()=>{t===e?l(t):s().then(r)};r()})}}}exports.PromiseLogic=R,exports.PromiseLogicError=e,exports.PromiseWithTimer=f,exports.createPromiseLogic=function(e={}){const{prefix:t="",suffix:l="",rename:r={}}=e,s={and:R.and.bind(R),or:R.or.bind(R),not:R.not.bind(R),race:R.race.bind(R),allSettled:R.allSettled.bind(R),xor:R.xor.bind(R),nand:R.nand.bind(R),nor:R.nor.bind(R),xnor:R.xnor.bind(R),majority:R.majority.bind(R),allFulfilled:R.allFulfilled.bind(R),allRejected:R.allRejected.bind(R)},i={};return Object.entries(s).forEach(([e,s])=>{const n=r[e]||e;i[`${t}${n}${l}`]=s}),i};

package/dist/v2/index.esm.js

@@ -1 +1 @@
-class e{filterFulfilledResults(e){return e.filter(e=>"fulfilled"===e.status).map(e=>e.value)}filterRejectedResults(e){return e.filter(e=>"rejected"===e.status).map(e=>e.reason)}countFulfilled(e){return e.filter(e=>"fulfilled"===e.status).length}}class t extends e{async execute(e){return Promise.any(e)}}class l extends Error{constructor(e,t,l){super(t),this.type=e,this.results=l,this.name="PromiseLogicError"}}function r(e,t,r,n){return new l(e,{XOR_ERROR:`XOR condition failed: expected exactly 1 promise to fulfill, but ${t} fulfilled.`,NAND_ERROR:`NAND condition failed: all ${r} promises fulfilled (expected at least one rejection).`,NOR_ERROR:`NOR condition failed: ${t} promises fulfilled (expected all rejected).`,XNOR_ERROR:`XNOR condition failed: ${t}/${r} promises fulfilled (expected all or none).`,MAJORITY_ERROR:`Majority condition failed: ${t}/${r} fulfilled (need majority).`,ALL_SUCCESSFUL_ERROR:`All successful condition failed: ${t}/${r} promises fulfilled (expected all to succeed).`,ALL_FAILED_ERROR:`All failed condition failed: ${r-t}/${r} promises rejected (expected all to fail).`}[e]||"Logic condition failed",n)}class n extends e{async execute(e){try{return Promise.all(e)}catch(e){throw new l("AND_ERROR","AND gate failed",[e])}}}class s extends e{async execute(e,t){const l=await Promise.allSettled(e),n=this.filterFulfilledResults(l),s=n.length,i=l.length;if(s>i*t.max)return n;throw r("MAJORITY_ERROR",s,i,l)}}class i extends e{async execute(e){const t=await Promise.allSettled(e),l=this.filterFulfilledResults(t),n=l.length,s=t.length;if(n===s)throw r("NAND_ERROR",n,s,t);return l}}class a extends e{async execute(e){const t=await Promise.allSettled(e),l=this.filterFulfilledResults(t).length,n=t.length;if(0===l)return[];throw r("NOR_ERROR",l,n,t)}}class o extends e{async execute(e){const t=await Promise.allSettled(e),l=this.filterFulfilledResults(t),n=l.length,s=t.length;if(0===n||n===s)return l;throw r("XNOR_ERROR",n,s,t)}}class c extends e{async execute(e){const t=await Promise.allSettled(e),l=this.filterFulfilledResults(t),n=l.length,s=t.length;if(1===n)return l[0];throw r("XOR_ERROR",n,s,t)}}class u{constructor(e){this.promise=e}maxTimer(e){let t;return Promise.race([this.promise,new Promise((l,r)=>{t=setTimeout(()=>{r(new Error(`Promise timed out after ${e}ms,${this.promise}`))},e)})]).finally(()=>clearTimeout(t))}then(e,t){return new u(this.promise.then(e,t))}catch(e){return new u(this.promise.catch(e))}finally(e){return new u(this.promise.finally(e))}toPromise(){return this.promise}}class d{static get gates(){return{and:new n,or:new t,xor:new c,nand:new i,nor:new a,xnor:new o,majority:new s}}static and(e){return new u(this.gates.and.execute(e))}static or(e){return new u(this.gates.or.execute(e))}static xor(e){return new u(this.gates.xor.execute(e))}static nand(e){return new u(this.gates.nand.execute(e))}static nor(e){return new u(this.gates.nor.execute(e))}static xnor(e){return new u(this.gates.xnor.execute(e))}static majority(e,t={max:.5}){return new u(this.gates.majority.execute(e,t))}static allFulfilled(e){return new u(Promise.allSettled(e).then(e=>e.filter(e=>"fulfilled"===e.status).map(e=>e.value)))}static allRejected(e){return new u(Promise.allSettled(e).then(e=>e.filter(e=>"rejected"===e.status).map(e=>e.reason)))}static not(e){return new u(Promise.resolve(e).then(e=>Promise.reject(e),e=>Promise.resolve(e)))}static race(e){return new u(Promise.race(e))}static allSettled(e){return new u(Promise.allSettled(e))}static createFlipFlop(e=!1){let t=e,l=null,r=Promise.resolve(t);const n=()=>(l||(r=new Promise(e=>{l=e})),r);return{getState:()=>t,set:async e=>(t=e,l&&(l(t),l=null),r=Promise.resolve(t),t),async toggle(){return this.set(!t)},waitForChange:n,waitFor:e=>t===e?Promise.resolve(t):new Promise(l=>{const r=()=>{t===e?l(t):n().then(r)};r()})}}}function f(e={}){const{prefix:t="",suffix:l="",rename:r={}}=e,n={and:d.and.bind(d),or:d.or.bind(d),not:d.not.bind(d),race:d.race.bind(d),allSettled:d.allSettled.bind(d),xor:d.xor.bind(d),nand:d.nand.bind(d),nor:d.nor.bind(d),xnor:d.xnor.bind(d),majority:d.majority.bind(d),allFulfilled:d.allFulfilled.bind(d),allRejected:d.allRejected.bind(d)},s={};return Object.entries(n).forEach(([e,n])=>{const i=r[e]||e;s[`${t}${i}${l}`]=n}),s}export{d as PromiseLogic,l as PromiseLogicError,u as PromiseWithTimer,f as createPromiseLogic};
+class e extends Error{constructor(e,t,l){super(t),this.type=e,this.results=l,this.name="PromiseLogicError"}}function t(t,l,s,r,n){const i={XOR_ERROR:`XOR condition failed: expected exactly 1 promise to fulfill, but ${l} fulfilled.`,NAND_ERROR:`NAND condition failed: all ${s} promises fulfilled (expected at least one rejection).`,NOR_ERROR:`NOR condition failed: ${l} promises fulfilled (expected all rejected).`,XNOR_ERROR:`XNOR condition failed: ${l}/${s} promises fulfilled (expected all or none).`,MAJORITY_ERROR:`Majority condition failed: ${l}/${s} fulfilled (need majority).`,ALL_SUCCESSFUL_ERROR:`All successful condition failed: ${l}/${s} promises fulfilled (expected all to succeed).`,ALL_FAILED_ERROR:`All failed condition failed: ${s-l}/${s} promises rejected (expected all to fail).`}[t]||"Logic condition failed",a=n&&n?.length>0?`\n失败原因：${n.map((e,t)=>`[${t+1}] ${e}`).join("\n")}`:"";return new e(t,i+a,r)}class l{filterFulfilledResults(e){return e.filter(e=>"fulfilled"===e.status).map(e=>e.value)}filterRejectedResults(e){return e.filter(e=>"rejected"===e.status).map(e=>e.reason)}countFulfilled(e){return e.filter(e=>"fulfilled"===e.status).length}}class s extends l{async execute(e){try{return Promise.any(e)}catch(e){throw t("OR_ERROR",0,0,[],[e])}}}class r extends l{async execute(e){try{return Promise.all(e)}catch(e){throw t("AND_ERROR",0,0,[],[e])}}}class n extends l{async execute(e,l){const s=await Promise.allSettled(e),r=this.filterFulfilledResults(s),n=r.length,i=s.length,a=this.filterRejectedResults(s);if(n>Math.floor(i*l.max))return r;throw t("MAJORITY_ERROR",n,i,s,a)}}class i extends l{async execute(e){const l=await Promise.allSettled(e),s=this.filterFulfilledResults(l),r=s.length,n=l.length,i=this.filterRejectedResults(l);if(r===n)throw t("NAND_ERROR",r,n,l,i);return s}}class a extends l{async execute(e){const l=await Promise.allSettled(e),s=this.filterFulfilledResults(l).length,r=l.length,n=this.filterRejectedResults(l);if(0===s)return[];throw t("NOR_ERROR",s,r,l,n)}}class o extends l{async execute(e){const l=await Promise.allSettled(e),s=this.filterFulfilledResults(l),r=s.length,n=l.length,i=this.filterRejectedResults(l);if(0===r||r===n)return s;throw t("XNOR_ERROR",r,n,l,i)}}class c extends l{async execute(e){const l=await Promise.allSettled(e),s=this.filterFulfilledResults(l),r=s.length,n=l.length,i=this.filterRejectedResults(l);if(1===r)return s[0];throw t("XOR_ERROR",r,n,l,i)}}class u extends l{async execute(e,t={}){return new Promise(t=>{const l=[];let s=0;const r=[...e];0!==(r?.length??0)?r.forEach((e,r)=>{Promise.resolve(e).then(e=>{s++,l[r]=e}).catch(()=>{l[r]=void 0}).finally(()=>{s>0&&t(l.filter(e=>void 0!==e))})}):t(l)})}}class d extends l{async execute(e,t={}){return new Promise(t=>{const l=[];let s=0;const r=[...e];0!==(r?.length??0)?r.forEach((e,r)=>{Promise.resolve(e).then(()=>{l[r]=void 0}).catch(e=>{s++,l[r]=e}).finally(()=>{s>0&&t(l.filter(e=>void 0!==e))})}):t(l)})}}class f{constructor(e){this.promise=e}maxTimer(e,t=`Promise timed out after ${e}ms`){let l;return Promise.race([this.promise,new Promise((s,r)=>{l=setTimeout(()=>{r(new Error(t))},e)})]).finally(()=>clearTimeout(l))}then(e,t){return new f(this.promise.then(e,t))}catch(e){return new f(this.promise.catch(e))}finally(e){return new f(this.promise.finally(e))}toPromise(){return this.promise}}class R{static get gates(){return{and:new r,or:new s,xor:new c,nand:new i,nor:new a,xnor:new o,majority:new n,allFulfilled:new u,allRejected:new d}}static and(e){return new f(this.gates.and.execute(e))}static or(e){return new f(this.gates.or.execute(e))}static xor(e){return new f(this.gates.xor.execute(e))}static nand(e){return new f(this.gates.nand.execute(e))}static nor(e){return new f(this.gates.nor.execute(e))}static xnor(e){return new f(this.gates.xnor.execute(e))}static majority(e,t={max:.5}){return new f(this.gates.majority.execute(e,t))}static allFulfilled(e){return new f(this.gates.allFulfilled.execute(e))}static allRejected(e){return new f(this.gates.allRejected.execute(e))}static not(e){return new f(Promise.resolve(e).then(e=>Promise.reject(new Error(`NOT: ${e}`)),e=>Promise.resolve(e)))}static race(e){return new f(Promise.race(e))}static allSettled(e){return new f(Promise.allSettled(e))}static createFlipFlop(e=!1){let t=e,l=null,s=Promise.resolve(t);const r=()=>(l||(s=new Promise(e=>{l=e})),s);return{getState:()=>t,set:async e=>(t=e,l&&(l(t),l=null),s=Promise.resolve(t),t),async toggle(){return this.set(!t)},waitForChange:r,waitFor:e=>t===e?Promise.resolve(t):new Promise(l=>{const s=()=>{t===e?l(t):r().then(s)};s()})}}}function h(e={}){const{prefix:t="",suffix:l="",rename:s={}}=e,r={and:R.and.bind(R),or:R.or.bind(R),not:R.not.bind(R),race:R.race.bind(R),allSettled:R.allSettled.bind(R),xor:R.xor.bind(R),nand:R.nand.bind(R),nor:R.nor.bind(R),xnor:R.xnor.bind(R),majority:R.majority.bind(R),allFulfilled:R.allFulfilled.bind(R),allRejected:R.allRejected.bind(R)},n={};return Object.entries(r).forEach(([e,r])=>{const i=s[e]||e;n[`${t}${i}${l}`]=r}),n}export{R as PromiseLogic,e as PromiseLogicError,f as PromiseWithTimer,h as createPromiseLogic};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "promise-logic",
-  "version": "2.6.5",
+  "version": "2.8.0",
   "description": "Compose promises with logic gate semantics (AND, OR, XOR, NAND, NOR, XNOR, Majority). Forget APIs, remember logic.",
   "type": "module",
   "main": "dist/index.cjs.js",
@@ -12,11 +12,6 @@
       "require": "./dist/index.cjs.js",
       "types": "./dist/types/index.d.ts"
     },
-    "./factory": {
-      "import": "./dist/factory.esm.js",
-      "require": "./dist/factory.cjs.js",
-      "types": "./dist/types/factory.d.ts"
-    },
     "./typescript": {
       "import": "./dist/v2/index.esm.js",
       "require": "./dist/v2/index.cjs.js",