promise-logic 2.8.5 → 2.9.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 xier123456
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,49 +1,153 @@
-### **1. Core Philosophy**
+## Core Philosophy
+
+**Replace API Memory with Logical Concepts**
+
+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.
 
-**Replace API Memory with Logical Concepts**  
-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.
 
+### Example Scenario: E-commerce Order Processing
+
+```javascript
+import { PromiseLogic } from 'promise-logic';
+
+
+
+
+
+// Order processing flow
+async function createOrder() {
+  // Unified error types
+  const PAYMENT_OR_INVENTORY_ERROR = 'PAYMENT_OR_INVENTORY_ERROR';
+  const ORDER_ERROR = 'ORDER_ERROR';
+  const LOGISTICS_ERROR = 'LOGISTICS_ERROR';
+  const COUPON_ERROR = 'COUPON_ERROR';
+
+  // Destructure and, or methods from PromiseLogic for simpler syntax and understand the logical relationship of the current scenario
+  const { and, or } = PromiseLogic;
+
+  try {
+    // Execute payment and inventory operations (both must succeed)
+
+    const [
+      [paymentResult, inventoryResult], // Payment and inventory operation results
+      logistics,                        // Logistics operation result
+      coupon                            // Coupon operation result
+      ] = await and([
+        and([paymentAPI(), inventoryAPI()],{
+          errorType: PAYMENT_OR_INVENTORY_ERROR,// Custom payment or inventory error type
+        }),
+        or([oneLogisticsAPI(), twoLogisticsAPI()], {  
+          errorType: LOGISTICS_ERROR,// Custom logistics error type
+        }),
+        or([couponAPI1(), couponAPI2()], {
+          errorType: COUPON_ERROR,// Custom coupon error type
+        })
+    ], {
+      errorType: ORDER_ERROR,// Custom order error type
+      errorMessage: 'Order creation failed' // Custom order error message
+    });
+
+    // Order creation successful, return payment result, inventory result, logistics result and coupon result
+    return {
+      payment: paymentResult,
+      inventory: inventoryResult,
+      logistics: logistics,
+      coupon: coupon,
+      status: 'success'
+    };
+  } catch (error) {
+    // Analyze error type
+    switch (error.type) {
+      case ORDER_ERROR:
+        return {
+          status: 'error',
+          errorType: 'order_error',
+          message: 'Order creation failed',
+          details: error
+        };
+      case PAYMENT_OR_INVENTORY_ERROR:
+        return {
+          status: 'error',
+          errorType: 'payment_or_inventory_failed',
+          message: 'Payment or inventory operation failed',
+          details: error
+        };
+      case LOGISTICS_ERROR:
+        return {
+          status: 'error',
+          errorType: 'logistics_unavailable',
+          message: 'All logistics services are unavailable',
+          details: error
+        };
+      case COUPON_ERROR:
+        return {
+          status: 'error',
+          errorType: 'coupon_error',
+          message: 'All coupons are unavailable',
+          details: error
+        };
+      default:
+        return {
+          status: 'error',
+          errorType: 'default_error',
+          message: 'Unknown error occurred during order creation',
+          details: error
+        };
+    }
+  }
+}
+```
+
+As you can see, the code structure is completely consistent with business rules. Code is documentation, and logic is self-explanatory.
+
 ---
 
-### **2. Features**
+## Features
+
+### 1. Logical Semantics
+
+- `and`: All tasks must succeed (equivalent to `Promise.all`)
+- `or`: At least one task succeeds (equivalent to `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
 
-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
+All logic gates have undergone rigorous unit testing to ensure behavior meets expectations.
 
-2. **Zero Dependencies**
-   Only depends on native Promise, no additional runtime dependencies.
+### 4. Clear Error Classification
 
-3. **Full Test Coverage**
-   All logic gates have undergone rigorous unit testing to ensure behavior meets expectations.
+- `PromiseLogicError` unified error type
+- `error.type` distinguishes specific logical errors (e.g., `'XOR_ERROR'`)
+- Supports custom error types and messages
 
-4. **Clear Error Classification**
-   - `PromiseLogicError` unified error type
-   - `error.type` distinguishes specific logical errors (e.g., `'XOR_ERROR'`)
+### 5. Timeout Control
 
-5. **Timeout Control**
-   - `maxTimer`: Adds timeout functionality to any Promise operation (unit: milliseconds).
+- `maxTimer`: Adds timeout functionality to any Promise operation (unit: milliseconds)
+- Supports custom timeout error messages
 
-**Note**:
-- After timeout, it immediately interrupts the execution of the current Promise chain and jumps to error handling
-- However, please note that this does not cancel underlying asynchronous operations that have already started (such as network requests, file read/write, etc.)
+**Note**: After timeout, it immediately interrupts the execution of the current Promise chain and jumps to error handling, but does not cancel underlying asynchronous operations that have already started (such as network requests, file read/write, etc.).
 
-6. **Extended Operations**
-   - `allFulfilled`: Returns all successful results in order. Returns immediately when a result exists.
-   - `allRejected`: Returns all failed results in order. Returns immediately when a result exists.
-   - `allSettled`: Returns all results (both successful and failed)
+### 6. Extended Operations
+
+- `allFulfilled`: Returns all successful results in order, immediately tries to return when there are successful results
+- `allRejected`: Returns all failed results in order, immediately tries to return when there are failed results
+- `allSettled`: Returns all results (both successful and failed)
 
 ---
 
-### **3. Installation**
+## Installation
 
 ```bash
 npm install promise-logic
@@ -51,33 +155,58 @@ npm install promise-logic
 
 ---
 
-### **4. Quick Start**
+## Quick Start
+
+### Basic Usage Examples
 
-#### Example: Primary/Backup Service Call (XOR Scenario)
+#### Destructuring Assignment
 
 ```javascript
 import { PromiseLogic } from 'promise-logic';
 
-// Primary service call
-const primary = fetch('https://api.main.com/data');
-// Backup service call
-const backup = fetch('https://api.backup.com/data');
+// Destructure methods from PromiseLogic for simpler syntax
+const { and, or, xor, not, race } = PromiseLogic;
+
+// Use destructured methods
+and([
+  fetch('/api/user').then(r => r.json()),
+  fetch('/api/profile').then(r => r.json())
+]).then(results => console.log(results));
+
+or([
+  fetch('/api/primary').then(r => r.json()).catch(() => { throw new Error('primary failed'); }),
+  fetch('/api/backup').then(r => r.json())
+]).then(result => console.log(result));
+
+xor([
+  fetch('/api/method1').then(r => r.json()),
+  fetch('/api/method2').then(r => r.json())
+]).then(result => console.log(result));
+```
+
+#### Security Audit (XOR Scenario)
+
+```javascript
+import { PromiseLogic } from 'promise-logic';
 
 // Execute XOR logic: exactly one success
-PromiseLogic.xor([primary, backup])
+PromiseLogic.xor([
+  biometricAuth(), // Biometric authentication
+  hardwareKeyAuth() // Hardware key authentication
+])
   .then((result) => {
-    console.log('Successfully fetched data:', result);
+    console.log('Successfully authenticated:', result);
   })
   .catch((error) => {
     if (error.type === 'XOR_ERROR') {
-      console.error('Both primary and backup services succeeded or failed, which does not meet XOR semantics');
+      console.error('Conflict between biometric and hardware key authentication');
     } else {
-      console.error('Network error:', error);
+      console.error('Authentication error:', error);
     }
   });
 ```
 
-#### Example: Majority Decision (Majority Scenario)
+#### Majority Decision (Majority Scenario)
 
 ```javascript
 import { PromiseLogic } from 'promise-logic';
@@ -88,35 +217,17 @@ const services = [
   fetch('https://api.node3.com/vote')
 ];
 
-PromiseLogic.majority(services)
-  .then((results) => {
-    console.log('Majority of services returned success:', results);
-  })
-  .catch((error) => {
-    console.error('Majority of services failed:', error);
-  });
-```
-
-```typescript
-import { PromiseLogic } from 'promise-logic/typescript';
-
-const services = [
-  fetch('https://api.node1.com/vote'),
-  fetch('https://api.node2.com/vote'),
-  fetch('https://api.node3.com/vote')
-];
-
-// Type assertion can be done, or let PromiseLogic infer types automatically
-PromiseLogic.majority<Response>(services)
+// Custom threshold 0.6 (60%)
+PromiseLogic.majority(services, { max: 0.6 })
   .then((results) => {
-    console.log('Majority of services returned success:', results);
+    console.log('Custom threshold met, successful results:', results);
   })
   .catch((error) => {
-    console.error('Majority of services failed:', error);
+    console.error('Custom threshold not met:', error);
   });
 ```
 
-#### Example: Timeout Control
+#### Timeout Control
 
 ```javascript
 import { PromiseLogic } from 'promise-logic';
@@ -127,16 +238,16 @@ PromiseLogic.and([
   new Promise((resolve) => setTimeout(resolve, 3000)), // 3 second operation
   Promise.resolve(3)
 ])
-  .maxTimer(2000, 'Custom timeout error: operation did not complete within 2000ms') // 2 second timeout, custom error message
+  .maxTimer(2000, 'Custom timeout error: operation did not complete within 2000ms') // 2 second timeout
   .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
+    console.error('Operation timed out:', error.message);
   });
 ```
 
-#### Example: Extended Operations
+#### Extended Operations
 
 ```javascript
 import { PromiseLogic } from 'promise-logic';
@@ -148,12 +259,12 @@ const operations = [
   Promise.reject('error2')
 ];
 
-// Get all successful results (returns immediately when a result exists)
+// Get all successful results (returns immediately when there are successes)
 PromiseLogic.allFulfilled(operations).then((results) => {
   console.log('Successful results:', results); // ['success1', 'success2']
 });
 
-// Get all failed results (returns immediately when a result exists)
+// Get all failed results (returns immediately when there are failures)
 PromiseLogic.allRejected(operations).then((errors) => {
   console.log('Failed results:', errors); // ['error1', 'error2']
 });
@@ -161,138 +272,44 @@ PromiseLogic.allRejected(operations).then((errors) => {
 // Get all results (both success and failure)
 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
+### Custom Error Types and Messages
 
 ```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';
+// Custom error type
+const CUSTOM_ERROR_TYPE = 'CUSTOM_ERROR';
 
-const services = [
-  Promise.resolve('service1'),
-  Promise.resolve('service2'),
-  Promise.reject('service3'),
-  Promise.reject('service4')
-];
+// Custom error message
+const CUSTOM_ERROR_MESSAGE = 'Custom error message';
 
-// Default threshold (0.5): requires at least 3 successes
-// Custom threshold (0.4): requires at least 2 successes
-PromiseLogic.majority(services, { max: 0.4 })
+// Use custom error type and message
+PromiseLogic.and([Promise.resolve('success1'), Promise.reject('error1')], {
+  errorType: CUSTOM_ERROR_TYPE,
+  errorMessage: CUSTOM_ERROR_MESSAGE
+})
   .then((results) => {
-    console.log('Custom threshold met, successful results:', results); // ['service1', 'service2']
+    console.log(results);
   })
   .catch((error) => {
-    console.error('Custom threshold not met:', error);
+    if (error.type === CUSTOM_ERROR_TYPE) {
+      console.error(error); // Output: Custom error message
+    } else {
+      console.error(error);
+    }
   });
 ```
 
-## Recent Updates
-
-### 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';
+import { createPromiseLogic } from 'promise-logic';
 
 // Create instance with custom naming
 const logic = createPromiseLogic({
@@ -307,7 +324,6 @@ const logic = createPromiseLogic({
 
 // Use custom-named methods
 logic.api_all_call([fetch('/api/users'), fetch('/api/posts')]);
-
 logic.api_any_call([fetch('/api/cache'), fetch('/api/database')]);
 ```
 
@@ -327,9 +343,30 @@ PromiseLogic.and([Promise.resolve(1), Promise.resolve(2)]).then(
 PromiseLogic.and<number>([Promise.resolve(1), Promise.resolve(2)]);
 ```
 
+### Dynamic Logic Nested
+
+```javascript
+import { PromiseLogic } from 'promise-logic';
+
+
+// Dynamic nesting example: adjust logistics strategy based on user level
+const orderFlow = async (userLevel) => {
+  // VIP users: dual high-availability logistics guarantee (at least one success)
+  // Normal users: priority standard logistics, failover to economy logistics (at least one success)
+  const logisticsStrategy = userLevel === 'VIP'
+    ? PromiseLogic.or([premiumLogistics(), backupLogistics()])
+    : PromiseLogic.or([standardLogistics(), economyLogistics()]);
+
+  return await PromiseLogic.and([
+    PromiseLogic.and([paymentAPI(), inventoryAPI()]), // Payment + inventory atomic operations
+    logisticsStrategy,                                // Logistics strategy
+    couponValidation()                                // Coupon validation
+  ]);
+};
+```
 ---
 
-### **5. API Reference**
+## API Reference
 
 | API            | Description                                                                                                                         |
 | :------------- | :--------------------------------------------------------------------------------------------------------------------------- |
@@ -347,62 +384,54 @@ PromiseLogic.and<number>([Promise.resolve(1), Promise.resolve(2)]);
 | `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.                                              |
 
+---
+
+## Changelog
 
-### **6. Real-world Application Scenarios**
+### v2.9.0
 
-1. **Primary/Backup Service Calls**
-   - Use `xor` to ensure **exactly one service responds**, avoiding duplicate processing.
+**Error Mechanism Improvements**
+- Added `errorType` and `errorMessage` parameters to logic gates, supporting custom error types and messages, further fitting business scenarios
+- Optimized the existing error type system to ensure correct TypeScript type definitions
+- Optimized TypeScript type compatibility issues
+- Optimized allSettled gate return type error messages
+- Improved test scripts, covering most promise combination logic boundaries and tricky scenario issues, ensuring more stable operation of logic gates
+- Optimized logic gate execution efficiency, reducing unnecessary Promise wrapping
 
-2. **Distributed Decision Making**
-   - Use `majority` to implement majority consensus (e.g., distributed voting).
+### v2.8.0
 
-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.
+- **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
 
-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`.
+## Contribution Guide
 
-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).
+### 1. Development Environment
 
-7. **Full Result Retrieval**
-   - Use `allSettled` to get results from all Promises (regardless of success or failure).
+```bash
+git clone https://github.com/xier123456/promise-logic.git
+cd promise-logic
+npm install
+```
 
-8. **Fast Response**
-   - Use `race` to return the first completed Promise result (regardless of success or failure).
+### 2. Testing
 
-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).
+```bash
+npm test
+```
 
----
+### 3. Commit Guidelines
 
-### **7. Contribution Guide**
-
-1. **Development Environment**
-   ```bash
-   git clone https://github.com/xier123456/promise-logic.git
-   cd promise-logic
-   npm install
-   ```
-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.
+- Commit messages must include prefixes like `feat:` (new feature), `fix:` (bug fix), `docs:` (documentation).
+- Pull Requests must include test cases.
 
 ---
 
-### **8. Resource Links**
+## 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)

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,n,s){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=s.length>0?`\n失败原因：${s.map((e,t)=>`[${t+1}] ${e}`).join("\n")}`:"";return new e(t,i+a,n)}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 n extends r{async execute(e,r={}){try{return await Promise.any(e)}catch(r){throw t("OR_ERROR",0,e.length,[],r)}}}class s extends r{async execute(e,r={}){const l=await Promise.allSettled(e),n=this.filterFulfilledResults(l),s=this.filterRejectedResults(l),i=n.length,a=l.length;if(1===i)return n[0];throw t("XOR_ERROR",i,a,l,s)}}class i extends r{async execute(e,r={}){const l=await Promise.allSettled(e),n=this.filterFulfilledResults(l),s=n.length,i=l.length;if(s===i)throw t("NAND_ERROR",s,i,l,n);return n}}class a extends r{async execute(e,r={}){const l=await Promise.allSettled(e),n=this.filterFulfilledResults(l),s=n.length,i=l.length;if(0===s)return[];throw t("NOR_ERROR",s,i,l,n)}}class o extends r{async execute(e,r={}){const l=await Promise.allSettled(e),n=this.filterFulfilledResults(l),s=n.length,i=l.length;if(0===s||s===i)return n;throw t("XNOR_ERROR",s,i,l,n)}}class c extends r{async execute(e,r={max:.5}){const l=await Promise.allSettled(e),n=this.filterFulfilledResults(l),s=n.length,i=l.length;if(s>Math.floor(i*r.max))return n;throw t("MAJORITY_ERROR",s,i,l)}}class u extends r{async execute(e,t={}){return new Promise(t=>{const r=[];let l=0,n=0;const s=[...e],i=s?.length??0;0!==i?s.forEach((e,s)=>{Promise.resolve(e).then(e=>{n++,r[s]=e}).catch(()=>{r[s]=void 0}).finally(()=>{l++,n>0?t(r.filter(e=>void 0!==e)):l===i&&t([])})}):t(r)})}}class d extends r{async execute(e,t={}){return new Promise(t=>{const r=[];let l=0,n=0;const s=[...e],i=s?.length??0;0!==i?s.forEach((e,s)=>{Promise.resolve(e).then(()=>{r[s]=void 0}).catch(e=>{n++,r[s]=e}).finally(()=>{l++,n>0?t(r.filter(e=>void 0!==e)):l===i&&t([])})}):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,n)=>{r=setTimeout(()=>{n(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 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,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:l={}}=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=l[e]||e;s[`${t}${i}${r}`]=n}),s};
+"use strict";class e extends Error{constructor(e,t,r,s){super(t),this.name="PromiseLogicError",this.type=e,this.results=r,this.errors=s}}function t(t,r,s,n){return new e(t,r,s,n)}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 s extends r{async execute(e,r){try{return await Promise.all(e)}catch(s){const n=await Promise.allSettled(e),l=r.errorMessage||"AND condition failed: at least one promise rejected";throw t(r.errorType,l,n,s)}}}class n extends r{async execute(e,r){try{return await Promise.any(e)}catch(e){const s=r.errorMessage||"OR condition failed: all promises rejected.";throw t(r.errorType,s,[],[e])}}}class l extends r{async execute(e,r){const s=await Promise.allSettled(e),n=this.filterFulfilledResults(s),l=this.filterRejectedResults(s),a=n.length,i=s.length;if(1===a)return n[0];{const e=r.errorMessage||(a>1?`XOR condition failed: ${a} promises fulfilled (expected exactly 1)`:`XOR condition failed: all ${i} promises rejected (expected exactly 1)`);throw t(r.errorType,e,s,l)}}}class a extends r{async execute(e,r){const s=await Promise.allSettled(e),n=this.filterFulfilledResults(s),l=n.length,a=s.length;if(0===a)return[];if(l===a){const e=r.errorMessage||`NAND condition failed: ${l}/${a} fulfilled (need not majority)`;throw t(r.errorType,e,s,n)}return n}}class i extends r{async execute(e,r){const s=await Promise.allSettled(e),n=this.filterFulfilledResults(s),l=n.length;if(0===l)return[];{const e=r.errorMessage||`NOR condition failed: ${l} promises fulfilled (expected all rejected)`;throw t(r.errorType,e,s,n)}}}class o extends r{async execute(e,r){const s=await Promise.allSettled(e),n=this.filterFulfilledResults(s),l=n.length,a=s.length;if(0===l||l===a)return n;{const e=r.errorMessage||`XNOR condition failed: ${l}/${a} promises fulfilled (expected all or none)`;throw t(r.errorType,e,s,n)}}}class c extends r{async execute(e,r){const s=await Promise.allSettled(e),n=this.filterFulfilledResults(s),l=n.length,a=s.length;if(0===a)return[];if(l>Math.floor(a*r.max))return n;{const e=r.errorMessage||`MAJORITY condition failed: ${l}/${a} fulfilled (need majority)`;throw t(r.errorType,e,s,n)}}}class d extends r{async execute(e,t={}){return new Promise(t=>{const r=[];let s=0;const n=[...e],l=n?.length??0;let a=!1;0!==l?n.forEach((e,n)=>{Promise.resolve(e).then(e=>{r[n]=e,a=!0,t(r.filter(Boolean))}).catch(()=>{}).finally(()=>{s++,s!==l||a||t([])})}):t([])})}}class u extends r{async execute(e,t={}){return new Promise(t=>{const r=[];let s=0;const n=[...e],l=n?.length??0;let a=!1;0!==l?n.forEach((e,n)=>{Promise.resolve(e).then(()=>{}).catch(e=>{r[n]=e,a=!0,t(r.filter(Boolean))}).finally(()=>{s++,s!==l||a||t([])})}):t([])})}}class h extends r{async execute(e,r){try{return await Promise.resolve(e).then(e=>Promise.reject(new Error(`NOT: ${e}`)),e=>Promise.resolve(e))}catch(e){throw t(r.errorType,r.errorMessage||"NOT condition failed",[],e)}}}class f extends r{async execute(e,r){try{return await Promise.allSettled(e)}catch(s){const n=await Promise.allSettled(e),l=r.errorMessage||"ALL_SETTLED condition failed: at least one promise rejected";throw t(r.errorType,l,n,s)}}}class m extends r{async execute(e,r){if(0!==e.length)try{return await Promise.race(e)}catch(s){const n=await Promise.allSettled(e),l=r.errorMessage||"RACE condition failed: all promises rejected";throw t(r.errorType,l,n,s)}}}class w{constructor(e){this.promise=e}maxTimer(e,t=`Promise timed out after ${e}ms`){let r;return Promise.race([this.promise,new Promise((s,n)=>{r=setTimeout(()=>{n(new Error(t))},e)})]).finally(()=>clearTimeout(r))}then(e,t){return new w(this.promise.then(e,t))}catch(e){return new w(this.promise.catch(e))}finally(e){return new w(this.promise.finally(e))}toPromise(){return this.promise}}class x{static get gates(){return{and:new s,or:new n,xor:new l,nand:new a,nor:new i,xnor:new o,not:new h,race:new m,allSettled:new f,majority:new c,allFulfilled:new d,allRejected:new u}}static and(e,t={errorType:"AND_ERROR",errorMessage:""}){return new w(this.gates.and.execute(e,t))}static or(e,t={errorType:"OR_ERROR",errorMessage:""}){return new w(this.gates.or.execute(e,t))}static not(e,t={errorType:"NOT_ERROR",errorMessage:""}){return new w(this.gates.not.execute(e,t))}static race(e,t={errorType:"RACE_ERROR",errorMessage:""}){return new w(this.gates.race.execute(e,t))}static allSettled(e,t={errorType:"ALL_SETTLED_ERROR",errorMessage:""}){return new w(this.gates.allSettled.execute(e,t))}static xor(e,t={errorType:"XOR_ERROR",errorMessage:""}){return new w(this.gates.xor.execute(e,t))}static nand(e,t={errorType:"NAND_ERROR",errorMessage:""}){return new w(this.gates.nand.execute(e,t))}static nor(e,t={errorType:"NOR_ERROR",errorMessage:""}){return new w(this.gates.nor.execute(e,t))}static xnor(e,t={errorType:"XNOR_ERROR",errorMessage:""}){return new w(this.gates.xnor.execute(e,t))}static majority(e,t={max:.5,errorType:"MAJORITY_ERROR",errorMessage:""}){return new w(this.gates.majority.execute(e,t))}static allFulfilled(e){return new w(this.gates.allFulfilled.execute(e))}static allRejected(e){return new w(this.gates.allRejected.execute(e))}static createFlipFlop(e=!1){let t=e,r=null,s=Promise.resolve(t);return{getState:()=>t,set(e){return t=e,r&&(r(t),r=null),s=Promise.resolve(t),this},toggle(){return this.set(!t)},waitForChange:()=>(r||(s=new Promise(e=>{r=e})),s),waitFor(e){return t===e?Promise.resolve(t):new Promise(r=>{const s=()=>{t===e?r(t):this.waitForChange().then(s)};s()})}}}}exports.createPromiseLogic=function(e={}){const{prefix:t="",suffix:r="",rename:s={}}=e,n={and:x.and.bind(x),or:x.or.bind(x),race:x.race.bind(x),allSettled:x.allSettled.bind(x),xor:x.xor.bind(x),not:x.not.bind(x),nand:x.nand.bind(x),nor:x.nor.bind(x),xnor:x.xnor.bind(x),majority:x.majority.bind(x),allFulfilled:x.allFulfilled.bind(x),allRejected:x.allRejected.bind(x)},l={};return Object.entries(n).forEach(([e,n])=>{const a=s[e]||e;l[`${t}${a}${r}`]=n}),l};

package/dist/factory.esm.js

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

package/dist/index.esm.js

@@ -1 +1 @@
-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,[],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,n=0;const s=[...e],i=s?.length??0;0!==i?s.forEach((e,s)=>{Promise.resolve(e).then(e=>{n++,l[s]=e}).catch(()=>{l[s]=void 0}).finally(()=>{r++,n>0?t(l.filter(e=>void 0!==e)):r===i&&t([])})}):t(l)})}}class d extends l{async execute(e,t={}){return new Promise(t=>{const l=[];let r=0,n=0;const s=[...e],i=s?.length??0;0!==i?s.forEach((e,s)=>{Promise.resolve(e).then(()=>{l[s]=void 0}).catch(e=>{n++,l[s]=e}).finally(()=>{r++,n>0?t(l.filter(e=>void 0!==e)):r===i&&t([])})}):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};
+class e extends Error{constructor(e,t,r,s){super(t),this.name="PromiseLogicError",this.type=e,this.results=r,this.errors=s}}function t(t,r,s,n){return new e(t,r,s,n)}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 s extends r{async execute(e,r){try{return await Promise.all(e)}catch(s){const n=await Promise.allSettled(e),l=r.errorMessage||"AND condition failed: at least one promise rejected";throw t(r.errorType,l,n,s)}}}class n extends r{async execute(e,r){try{return await Promise.any(e)}catch(e){const s=r.errorMessage||"OR condition failed: all promises rejected.";throw t(r.errorType,s,[],[e])}}}class l extends r{async execute(e,r){const s=await Promise.allSettled(e),n=this.filterFulfilledResults(s),l=this.filterRejectedResults(s),a=n.length,o=s.length;if(1===a)return n[0];{const e=r.errorMessage||(a>1?`XOR condition failed: ${a} promises fulfilled (expected exactly 1)`:`XOR condition failed: all ${o} promises rejected (expected exactly 1)`);throw t(r.errorType,e,s,l)}}}class a extends r{async execute(e,r){const s=await Promise.allSettled(e),n=this.filterFulfilledResults(s),l=n.length,a=s.length;if(0===a)return[];if(l===a){const e=r.errorMessage||`NAND condition failed: ${l}/${a} fulfilled (need not majority)`;throw t(r.errorType,e,s,n)}return n}}class o extends r{async execute(e,r){const s=await Promise.allSettled(e),n=this.filterFulfilledResults(s),l=n.length;if(0===l)return[];{const e=r.errorMessage||`NOR condition failed: ${l} promises fulfilled (expected all rejected)`;throw t(r.errorType,e,s,n)}}}class i extends r{async execute(e,r){const s=await Promise.allSettled(e),n=this.filterFulfilledResults(s),l=n.length,a=s.length;if(0===l||l===a)return n;{const e=r.errorMessage||`XNOR condition failed: ${l}/${a} promises fulfilled (expected all or none)`;throw t(r.errorType,e,s,n)}}}class c extends r{async execute(e,r){const s=await Promise.allSettled(e),n=this.filterFulfilledResults(s),l=n.length,a=s.length;if(0===a)return[];if(l>Math.floor(a*r.max))return n;{const e=r.errorMessage||`MAJORITY condition failed: ${l}/${a} fulfilled (need majority)`;throw t(r.errorType,e,s,n)}}}class d extends r{async execute(e,t={}){return new Promise(t=>{const r=[];let s=0;const n=[...e],l=n?.length??0;let a=!1;0!==l?n.forEach((e,n)=>{Promise.resolve(e).then(e=>{r[n]=e,a=!0,t(r.filter(Boolean))}).catch(()=>{}).finally(()=>{s++,s!==l||a||t([])})}):t([])})}}class u extends r{async execute(e,t={}){return new Promise(t=>{const r=[];let s=0;const n=[...e],l=n?.length??0;let a=!1;0!==l?n.forEach((e,n)=>{Promise.resolve(e).then(()=>{}).catch(e=>{r[n]=e,a=!0,t(r.filter(Boolean))}).finally(()=>{s++,s!==l||a||t([])})}):t([])})}}class h extends r{async execute(e,r){try{return await Promise.resolve(e).then(e=>Promise.reject(new Error(`NOT: ${e}`)),e=>Promise.resolve(e))}catch(e){throw t(r.errorType,r.errorMessage||"NOT condition failed",[],e)}}}class f extends r{async execute(e,r){try{return await Promise.allSettled(e)}catch(s){const n=await Promise.allSettled(e),l=r.errorMessage||"ALL_SETTLED condition failed: at least one promise rejected";throw t(r.errorType,l,n,s)}}}class m extends r{async execute(e,r){if(0!==e.length)try{return await Promise.race(e)}catch(s){const n=await Promise.allSettled(e),l=r.errorMessage||"RACE condition failed: all promises rejected";throw t(r.errorType,l,n,s)}}}class w{constructor(e){this.promise=e}maxTimer(e,t=`Promise timed out after ${e}ms`){let r;return Promise.race([this.promise,new Promise((s,n)=>{r=setTimeout(()=>{n(new Error(t))},e)})]).finally(()=>clearTimeout(r))}then(e,t){return new w(this.promise.then(e,t))}catch(e){return new w(this.promise.catch(e))}finally(e){return new w(this.promise.finally(e))}toPromise(){return this.promise}}class x{static get gates(){return{and:new s,or:new n,xor:new l,nand:new a,nor:new o,xnor:new i,not:new h,race:new m,allSettled:new f,majority:new c,allFulfilled:new d,allRejected:new u}}static and(e,t={errorType:"AND_ERROR",errorMessage:""}){return new w(this.gates.and.execute(e,t))}static or(e,t={errorType:"OR_ERROR",errorMessage:""}){return new w(this.gates.or.execute(e,t))}static not(e,t={errorType:"NOT_ERROR",errorMessage:""}){return new w(this.gates.not.execute(e,t))}static race(e,t={errorType:"RACE_ERROR",errorMessage:""}){return new w(this.gates.race.execute(e,t))}static allSettled(e,t={errorType:"ALL_SETTLED_ERROR",errorMessage:""}){return new w(this.gates.allSettled.execute(e,t))}static xor(e,t={errorType:"XOR_ERROR",errorMessage:""}){return new w(this.gates.xor.execute(e,t))}static nand(e,t={errorType:"NAND_ERROR",errorMessage:""}){return new w(this.gates.nand.execute(e,t))}static nor(e,t={errorType:"NOR_ERROR",errorMessage:""}){return new w(this.gates.nor.execute(e,t))}static xnor(e,t={errorType:"XNOR_ERROR",errorMessage:""}){return new w(this.gates.xnor.execute(e,t))}static majority(e,t={max:.5,errorType:"MAJORITY_ERROR",errorMessage:""}){return new w(this.gates.majority.execute(e,t))}static allFulfilled(e){return new w(this.gates.allFulfilled.execute(e))}static allRejected(e){return new w(this.gates.allRejected.execute(e))}static createFlipFlop(e=!1){let t=e,r=null,s=Promise.resolve(t);return{getState:()=>t,set(e){return t=e,r&&(r(t),r=null),s=Promise.resolve(t),this},toggle(){return this.set(!t)},waitForChange:()=>(r||(s=new Promise(e=>{r=e})),s),waitFor(e){return t===e?Promise.resolve(t):new Promise(r=>{const s=()=>{t===e?r(t):this.waitForChange().then(s)};s()})}}}}function R(e={}){const{prefix:t="",suffix:r="",rename:s={}}=e,n={and:x.and.bind(x),or:x.or.bind(x),race:x.race.bind(x),allSettled:x.allSettled.bind(x),xor:x.xor.bind(x),not:x.not.bind(x),nand:x.nand.bind(x),nor:x.nor.bind(x),xnor:x.xnor.bind(x),majority:x.majority.bind(x),allFulfilled:x.allFulfilled.bind(x),allRejected:x.allRejected.bind(x)},l={};return Object.entries(n).forEach(([e,n])=>{const a=s[e]||e;l[`${t}${a}${r}`]=n}),l}export{x as PromiseLogic,e as PromiseLogicError,w as PromiseWithTimer,t as createLogicError,R as createPromiseLogic};

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 declare class PromiseWithTimer<T> {
-  maxTimer(ms: number): Promise<T>;
+  maxTimer(ms: number, errorMessage?: string): Promise<T>;
   then<U>(onfulfilled?: ((value: T) => U | PromiseLike<U>) | null, onrejected?: ((reason: Error) => U | PromiseLike<U>) | null): PromiseWithTimer<U>;
   catch<U>(onrejected?: ((reason: Error) => U | PromiseLike<U>) | null): PromiseWithTimer<U>;
   finally(onfinally?: (() => void) | null): PromiseWithTimer<T>;
@@ -7,11 +7,18 @@ declare class PromiseWithTimer<T> {
 }
 
 declare class PromiseLogicError extends Error {
-  type: 'XOR_ERROR' | 'NAND_ERROR' | 'NOR_ERROR' | 'XNOR_ERROR' | 'MAJORITY_ERROR' | 'ALL_SUCCESSFUL_ERROR' | 'ALL_FAILED_ERROR';
+  type: string;
   results: PromiseSettledResult<unknown>[];
   constructor(type: string, message: string, results: PromiseSettledResult<unknown>[]);
 }
 
+interface LogicGateOptions {
+  errorType?: string;
+  errorMessage?: string;
+  max?: number;
+  [key: string]: string | number | boolean | undefined;
+}
+
 interface FlipFlop {
   getState(): boolean;
   toggle(): Promise<boolean>;
@@ -19,20 +26,20 @@ interface FlipFlop {
 }
 
 declare class PromiseLogic {
-  static and<T>(iterable: Iterable<T | PromiseLike<T>>): PromiseWithTimer<T[]>;
-  static or<T>(iterable: Iterable<T | PromiseLike<T>>): PromiseWithTimer<T>;
-  static race<T>(iterable: Iterable<T | PromiseLike<T>>): PromiseWithTimer<T>;
-  static not<T>(promise: T | PromiseLike<T>): PromiseWithTimer<unknown>;
-  static allSettled<T>(iterable: Iterable<T | PromiseLike<T>>): PromiseWithTimer<PromiseSettledResult<T>[]>;
+  static and<T>(iterable: Iterable<T | PromiseLike<T>>, options?: LogicGateOption): PromiseWithTimer<T[]>;
+  static or<T>(iterable: Iterable<T | PromiseLike<T>>, options?: LogicGateOptions): PromiseWithTimer<T>;
+  static race<T>(iterable: Iterable<T | PromiseLike<T>>, options?: LogicGateOptions): PromiseWithTimer<T>;
+  static not<T>(promise: T | PromiseLike<T>, options?: LogicGateOptions): PromiseWithTimer<T>;
+  static allSettled<T>(iterable: Iterable<T | PromiseLike<T>>, options?: LogicGateOptions): PromiseWithTimer<PromiseSettledResult<T>[]>;
   
-  static xor<T>(iterable: Iterable<T | PromiseLike<T>>): PromiseWithTimer<T>;
-  static nand<T>(iterable: Iterable<T | PromiseLike<T>>): PromiseWithTimer<T[]>;
-  static nor<T>(iterable: Iterable<T | PromiseLike<T>>): PromiseWithTimer<T[]>;
-  static xnor<T>(iterable: Iterable<T | PromiseLike<T>>): PromiseWithTimer<T[]>;
-  static majority<T>(iterable: Iterable<T | PromiseLike<T>>, options?: { max: number }): PromiseWithTimer<T[]>;
+  static xor<T>(iterable: Iterable<T | PromiseLike<T>>, options?: LogicGateOptions): PromiseWithTimer<T>;
+  static nand<T>(iterable: Iterable<T | PromiseLike<T>>, options?: LogicGateOptions): PromiseWithTimer<T[]>;
+  static nor<T>(iterable: Iterable<T | PromiseLike<T>>, options?: LogicGateOptions): PromiseWithTimer<T[]>;
+  static xnor<T>(iterable: Iterable<T | PromiseLike<T>>, options?: LogicGateOptions): PromiseWithTimer<T[]>;
+  static majority<T>(iterable: Iterable<T | PromiseLike<T>>, options?: LogicGateOptions): PromiseWithTimer<T[]>;
   
   static allFulfilled<T>(iterable: Iterable<T | PromiseLike<T>>): PromiseWithTimer<T[]>;
-  static allRejected<T>(iterable: Iterable<T | PromiseLike<T>>): PromiseWithTimer<unknown[]>;
+  static allRejected<T>(iterable: Iterable<T | PromiseLike<T>>): PromiseWithTimer<Error[]>;
   
   static createFlipFlop(initialState?: boolean): FlipFlop;
 }
@@ -50,4 +57,4 @@ declare function createPromiseLogic(options?: CreatePromiseLogicOptions): {
 declare function createLogicError(type: string, fulfilledCount: number, total: number, results: PromiseSettledResult<unknown>[]): PromiseLogicError;
 
 export { PromiseLogic, PromiseLogicError, PromiseWithTimer, createLogicError, createPromiseLogic };
-export type { CreatePromiseLogicOptions, FlipFlop };
+export type { CreatePromiseLogicOptions, FlipFlop, LogicGateOptions };

package/dist/v2/factory.cjs.js

@@ -1 +1 @@
-"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,r=0;const n=[...e],i=n?.length??0;0!==i?n.forEach((e,n)=>{Promise.resolve(e).then(e=>{r++,l[n]=e}).catch(()=>{l[n]=void 0}).finally(()=>{s++,r>0?t(l.filter(e=>void 0!==e)):s===i&&t([])})}):t(l)})}}class d extends l{async execute(e){return new Promise(t=>{const l=[];let s=0,r=0;const n=[...e],i=n?.length??0;0!==i?n.forEach((e,n)=>{Promise.resolve(e).then(()=>{l[n]=void 0}).catch(e=>{r++,l[n]=e}).finally(()=>{s++,r>0?t(l.filter(e=>void 0!==e)):s===i&&t([])})}):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};
+"use strict";class e extends Error{constructor(e,t,r){super(t),this.type=e,this.results=r,this.name="PromiseLogicError"}}function t(t,r,s,l){return new e(t,r,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}}class s extends r{async execute(e,r){try{return await Promise.any(e)}catch(s){const l=await Promise.allSettled(e),n=r.errorMessage||"OR condition failed";throw t(r.errorType||"OR_ERROR",n,l)}}}class l extends r{async execute(e,r){try{return await Promise.all(e)}catch(s){const l=await Promise.allSettled(e),n=r.errorMessage||"AND condition failed";throw t(r.errorType||"AND_ERROR",n,l)}}}class n extends r{async execute(e,r){const s=r.max||.5,l=await Promise.allSettled(e),n=l.length;if(0===n)return[];const i=this.filterFulfilledResults(l),o=i.length;if(this.filterRejectedResults(l),o>Math.floor(n*s))return i;{const e=r.errorMessage||`Majority condition failed: ${o}/${n} fulfilled (need majority)`;throw t(r.errorType||"MAJORITY_ERROR",e,l)}}}class i extends r{async execute(e,r){const s=await Promise.allSettled(e),l=this.filterFulfilledResults(s),n=l.length,i=s.length;if(this.filterRejectedResults(s),n===i){const e=r.errorMessage||`NAND condition failed: all ${i} promises fulfilled (expected at least one rejection)`;throw t(r.errorType||"NAND_ERROR",e,s)}return l}}class o extends r{async execute(e,r){const s=await Promise.allSettled(e),l=this.filterFulfilledResults(s).length;if(s.length,this.filterRejectedResults(s),0===l)return[];{const e=r.errorMessage||`NOR condition failed: ${l} promises fulfilled (expected all rejected)`;throw t(r.errorType||"NOR_ERROR",e,s)}}}class a extends r{async execute(e,r){const s=await Promise.allSettled(e),l=this.filterFulfilledResults(s),n=l.length,i=s.length;if(this.filterRejectedResults(s),0===n||n===i)return l;{const e=r.errorMessage||`XNOR condition failed: ${n}/${i} promises fulfilled (expected all or none)`;throw t(r.errorType||"XNOR_ERROR",e,s)}}}class c extends r{async execute(e,r){const s=await Promise.allSettled(e),l=this.filterFulfilledResults(s),n=l.length,i=s.length;if(this.filterRejectedResults(s),1===n)return l[0];{const e=r.errorMessage||(n>1?`XOR condition failed: ${n} promises fulfilled (expected exactly 1)`:`XOR condition failed: all ${i} promises rejected (expected exactly 1)`);throw t(r.errorType||"XOR_ERROR",e,s)}}}class d extends r{async execute(e,t={}){return new Promise(t=>{const r=[];let s=0,l=!1;const n=[...e],i=n?.length??0;0!==i?n.forEach((e,n)=>{Promise.resolve(e).then(e=>{r[n]=e,l=!0,t(r.filter(e=>void 0!==e))}).catch(()=>{}).finally(()=>{s++,s!==i||l||t([])})}):t([])})}}class u extends r{async execute(e,t={}){return new Promise(t=>{const r=[];let s=0,l=!1;const n=[...e],i=n?.length??0;0!==i?n.forEach((e,n)=>{Promise.resolve(e).then(()=>{}).catch(e=>{r[n]=e,l=!0,t(r.filter(e=>void 0!==e))}).finally(()=>{s++,s!==i||l||t([])})}):t([])})}}class R extends r{async execute(e,r={}){let s;if("function"==typeof e[Symbol.iterator]){const l=[...e];if(0===l.length)throw t(r.errorType||"NOT_ERROR",r.errorMessage||"NOT gate requires exactly one promise",[]);if(l.length>1)throw t(r.errorType||"NOT_ERROR",r.errorMessage||"NOT gate only accepts one promise",[]);s=l[0]}else s=e;return Promise.resolve(s).then(e=>{throw t(r.errorType||"NOT_ERROR",r.errorMessage||`NOT condition failed: ${e}`,[])},e=>e)}}class f extends r{async execute(e,r){if(0===Array.from(e).length)return{};try{return await Promise.race(e)}catch(s){const l=await Promise.allSettled(e),n=r.errorMessage||"RACE condition failed: all promises rejected";throw t(r.errorType||"RACE_ERROR",n,l)}}}class h extends r{async execute(e,r){try{return await Promise.allSettled(e)}catch(s){const l=await Promise.allSettled(e),n=r.errorMessage||"ALL_SETTLED condition failed: at least one promise rejected";throw t(r.errorType||"ALL_SETTLED_ERROR",n,l)}}}class m{constructor(e){this.promise=e}maxTimer(e,t=`Promise timed out after ${e}ms`){let r;const s=Promise.race([this.promise,new Promise((s,l)=>{r=setTimeout(()=>{l(new Error(t))},e)})]).finally(()=>clearTimeout(r));return new m(s)}then(e,t){return new m(this.promise.then(e,t))}catch(e){return new m(this.promise.catch(e))}finally(e){return new m(this.promise.finally(e))}toPromise(){return this.promise}}class w{static get gates(){return{and:new l,or:new s,xor:new c,nand:new i,nor:new o,xnor:new a,not:new R,race:new f,allSettled:new h,majority:new n,allFulfilled:new d,allRejected:new u}}static and(e,t={errorType:"AND_ERROR",errorMessage:""}){return new m(this.gates.and.execute(e,t))}static or(e,t={errorType:"OR_ERROR",errorMessage:""}){return new m(this.gates.or.execute(e,t))}static not(e,t={errorType:"NOT_ERROR",errorMessage:""}){return new m(this.gates.not.execute(e,t))}static race(e,t={errorType:"RACE_ERROR",errorMessage:""}){return new m(this.gates.race.execute(e,t))}static allSettled(e,t={errorType:"ALL_SETTLED_ERROR",errorMessage:""}){return new m(this.gates.allSettled.execute(e,t))}static xor(e,t={errorType:"XOR_ERROR",errorMessage:""}){return new m(this.gates.xor.execute(e,t))}static nand(e,t={errorType:"NAND_ERROR",errorMessage:""}){return new m(this.gates.nand.execute(e,t))}static nor(e,t={errorType:"NOR_ERROR",errorMessage:""}){return new m(this.gates.nor.execute(e,t))}static xnor(e,t={errorType:"XNOR_ERROR",errorMessage:""}){return new m(this.gates.xnor.execute(e,t))}static majority(e,t={max:.5,errorType:"MAJORITY_ERROR",errorMessage:""}){return new m(this.gates.majority.execute(e,t))}static allFulfilled(e){return new m(this.gates.allFulfilled.execute(e))}static allRejected(e){return new m(this.gates.allRejected.execute(e))}static createFlipFlop(e=!1){let t=e,r=null,s=Promise.resolve(t);return{getState:()=>t,set(e){return t=e,r&&(r(t),r=null),s=Promise.resolve(t),this},toggle(){return this.set(!t)},waitForChange:()=>(r||(s=new Promise(e=>{r=e})),s),waitFor(e){return t===e?Promise.resolve(t):new Promise(r=>{const s=()=>{t===e?r(t):this.waitForChange().then(s)};s()})}}}}exports.createPromiseLogic=function(e={}){const{prefix:t="",suffix:r="",rename:s={}}=e,l={and:w.and.bind(w),or:w.or.bind(w),not:w.not.bind(w),race:w.race.bind(w),allSettled:w.allSettled.bind(w),xor:w.xor.bind(w),nand:w.nand.bind(w),nor:w.nor.bind(w),xnor:w.xnor.bind(w),majority:w.majority.bind(w),allFulfilled:w.allFulfilled.bind(w),allRejected:w.allRejected.bind(w)},n={};return Object.entries(l).forEach(([e,l])=>{const i=s[e]||e;n[`${t}${i}${r}`]=l}),n};

package/dist/v2/factory.esm.js

@@ -1 +1 @@
-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,r=0;const n=[...e],i=n?.length??0;0!==i?n.forEach((e,n)=>{Promise.resolve(e).then(e=>{r++,l[n]=e}).catch(()=>{l[n]=void 0}).finally(()=>{s++,r>0?t(l.filter(e=>void 0!==e)):s===i&&t([])})}):t(l)})}}class d extends l{async execute(e){return new Promise(t=>{const l=[];let s=0,r=0;const n=[...e],i=n?.length??0;0!==i?n.forEach((e,n)=>{Promise.resolve(e).then(()=>{l[n]=void 0}).catch(e=>{r++,l[n]=e}).finally(()=>{s++,r>0?t(l.filter(e=>void 0!==e)):s===i&&t([])})}):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};
+class e extends Error{constructor(e,t,r){super(t),this.type=e,this.results=r,this.name="PromiseLogicError"}}function t(t,r,s,l){return new e(t,r,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}}class s extends r{async execute(e,r){try{return await Promise.any(e)}catch(s){const l=await Promise.allSettled(e),n=r.errorMessage||"OR condition failed";throw t(r.errorType||"OR_ERROR",n,l)}}}class l extends r{async execute(e,r){try{return await Promise.all(e)}catch(s){const l=await Promise.allSettled(e),n=r.errorMessage||"AND condition failed";throw t(r.errorType||"AND_ERROR",n,l)}}}class n extends r{async execute(e,r){const s=r.max||.5,l=await Promise.allSettled(e),n=l.length;if(0===n)return[];const i=this.filterFulfilledResults(l),o=i.length;if(this.filterRejectedResults(l),o>Math.floor(n*s))return i;{const e=r.errorMessage||`Majority condition failed: ${o}/${n} fulfilled (need majority)`;throw t(r.errorType||"MAJORITY_ERROR",e,l)}}}class i extends r{async execute(e,r){const s=await Promise.allSettled(e),l=this.filterFulfilledResults(s),n=l.length,i=s.length;if(this.filterRejectedResults(s),n===i){const e=r.errorMessage||`NAND condition failed: all ${i} promises fulfilled (expected at least one rejection)`;throw t(r.errorType||"NAND_ERROR",e,s)}return l}}class o extends r{async execute(e,r){const s=await Promise.allSettled(e),l=this.filterFulfilledResults(s).length;if(s.length,this.filterRejectedResults(s),0===l)return[];{const e=r.errorMessage||`NOR condition failed: ${l} promises fulfilled (expected all rejected)`;throw t(r.errorType||"NOR_ERROR",e,s)}}}class a extends r{async execute(e,r){const s=await Promise.allSettled(e),l=this.filterFulfilledResults(s),n=l.length,i=s.length;if(this.filterRejectedResults(s),0===n||n===i)return l;{const e=r.errorMessage||`XNOR condition failed: ${n}/${i} promises fulfilled (expected all or none)`;throw t(r.errorType||"XNOR_ERROR",e,s)}}}class c extends r{async execute(e,r){const s=await Promise.allSettled(e),l=this.filterFulfilledResults(s),n=l.length,i=s.length;if(this.filterRejectedResults(s),1===n)return l[0];{const e=r.errorMessage||(n>1?`XOR condition failed: ${n} promises fulfilled (expected exactly 1)`:`XOR condition failed: all ${i} promises rejected (expected exactly 1)`);throw t(r.errorType||"XOR_ERROR",e,s)}}}class d extends r{async execute(e,t={}){return new Promise(t=>{const r=[];let s=0,l=!1;const n=[...e],i=n?.length??0;0!==i?n.forEach((e,n)=>{Promise.resolve(e).then(e=>{r[n]=e,l=!0,t(r.filter(e=>void 0!==e))}).catch(()=>{}).finally(()=>{s++,s!==i||l||t([])})}):t([])})}}class u extends r{async execute(e,t={}){return new Promise(t=>{const r=[];let s=0,l=!1;const n=[...e],i=n?.length??0;0!==i?n.forEach((e,n)=>{Promise.resolve(e).then(()=>{}).catch(e=>{r[n]=e,l=!0,t(r.filter(e=>void 0!==e))}).finally(()=>{s++,s!==i||l||t([])})}):t([])})}}class R extends r{async execute(e,r={}){let s;if("function"==typeof e[Symbol.iterator]){const l=[...e];if(0===l.length)throw t(r.errorType||"NOT_ERROR",r.errorMessage||"NOT gate requires exactly one promise",[]);if(l.length>1)throw t(r.errorType||"NOT_ERROR",r.errorMessage||"NOT gate only accepts one promise",[]);s=l[0]}else s=e;return Promise.resolve(s).then(e=>{throw t(r.errorType||"NOT_ERROR",r.errorMessage||`NOT condition failed: ${e}`,[])},e=>e)}}class f extends r{async execute(e,r){if(0===Array.from(e).length)return{};try{return await Promise.race(e)}catch(s){const l=await Promise.allSettled(e),n=r.errorMessage||"RACE condition failed: all promises rejected";throw t(r.errorType||"RACE_ERROR",n,l)}}}class h extends r{async execute(e,r){try{return await Promise.allSettled(e)}catch(s){const l=await Promise.allSettled(e),n=r.errorMessage||"ALL_SETTLED condition failed: at least one promise rejected";throw t(r.errorType||"ALL_SETTLED_ERROR",n,l)}}}class m{constructor(e){this.promise=e}maxTimer(e,t=`Promise timed out after ${e}ms`){let r;const s=Promise.race([this.promise,new Promise((s,l)=>{r=setTimeout(()=>{l(new Error(t))},e)})]).finally(()=>clearTimeout(r));return new m(s)}then(e,t){return new m(this.promise.then(e,t))}catch(e){return new m(this.promise.catch(e))}finally(e){return new m(this.promise.finally(e))}toPromise(){return this.promise}}class w{static get gates(){return{and:new l,or:new s,xor:new c,nand:new i,nor:new o,xnor:new a,not:new R,race:new f,allSettled:new h,majority:new n,allFulfilled:new d,allRejected:new u}}static and(e,t={errorType:"AND_ERROR",errorMessage:""}){return new m(this.gates.and.execute(e,t))}static or(e,t={errorType:"OR_ERROR",errorMessage:""}){return new m(this.gates.or.execute(e,t))}static not(e,t={errorType:"NOT_ERROR",errorMessage:""}){return new m(this.gates.not.execute(e,t))}static race(e,t={errorType:"RACE_ERROR",errorMessage:""}){return new m(this.gates.race.execute(e,t))}static allSettled(e,t={errorType:"ALL_SETTLED_ERROR",errorMessage:""}){return new m(this.gates.allSettled.execute(e,t))}static xor(e,t={errorType:"XOR_ERROR",errorMessage:""}){return new m(this.gates.xor.execute(e,t))}static nand(e,t={errorType:"NAND_ERROR",errorMessage:""}){return new m(this.gates.nand.execute(e,t))}static nor(e,t={errorType:"NOR_ERROR",errorMessage:""}){return new m(this.gates.nor.execute(e,t))}static xnor(e,t={errorType:"XNOR_ERROR",errorMessage:""}){return new m(this.gates.xnor.execute(e,t))}static majority(e,t={max:.5,errorType:"MAJORITY_ERROR",errorMessage:""}){return new m(this.gates.majority.execute(e,t))}static allFulfilled(e){return new m(this.gates.allFulfilled.execute(e))}static allRejected(e){return new m(this.gates.allRejected.execute(e))}static createFlipFlop(e=!1){let t=e,r=null,s=Promise.resolve(t);return{getState:()=>t,set(e){return t=e,r&&(r(t),r=null),s=Promise.resolve(t),this},toggle(){return this.set(!t)},waitForChange:()=>(r||(s=new Promise(e=>{r=e})),s),waitFor(e){return t===e?Promise.resolve(t):new Promise(r=>{const s=()=>{t===e?r(t):this.waitForChange().then(s)};s()})}}}}function x(e={}){const{prefix:t="",suffix:r="",rename:s={}}=e,l={and:w.and.bind(w),or:w.or.bind(w),not:w.not.bind(w),race:w.race.bind(w),allSettled:w.allSettled.bind(w),xor:w.xor.bind(w),nand:w.nand.bind(w),nor:w.nor.bind(w),xnor:w.xnor.bind(w),majority:w.majority.bind(w),allFulfilled:w.allFulfilled.bind(w),allRejected:w.allRejected.bind(w)},n={};return Object.entries(l).forEach(([e,l])=>{const i=s[e]||e;n[`${t}${i}${r}`]=l}),n}export{x as createPromiseLogic};

package/dist/v2/index.cjs.js

@@ -1 +1 @@
-"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,s=0;const i=[...e],n=i?.length??0;0!==n?i.forEach((e,i)=>{Promise.resolve(e).then(e=>{s++,l[i]=e}).catch(()=>{l[i]=void 0}).finally(()=>{r++,s>0?t(l.filter(e=>void 0!==e)):r===n&&t([])})}):t(l)})}}class d extends l{async execute(e){return new Promise(t=>{const l=[];let r=0,s=0;const i=[...e],n=i?.length??0;0!==n?i.forEach((e,i)=>{Promise.resolve(e).then(()=>{l[i]=void 0}).catch(e=>{s++,l[i]=e}).finally(()=>{r++,s>0?t(l.filter(e=>void 0!==e)):r===n&&t([])})}):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};
+"use strict";class e extends Error{constructor(e,t,r){super(t),this.type=e,this.results=r,this.name="PromiseLogicError"}}function t(t,r,s,l){return new e(t,r,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}}class s extends r{async execute(e,r){try{return await Promise.any(e)}catch(s){const l=await Promise.allSettled(e),n=r.errorMessage||"OR condition failed";throw t(r.errorType||"OR_ERROR",n,l)}}}class l extends r{async execute(e,r){try{return await Promise.all(e)}catch(s){const l=await Promise.allSettled(e),n=r.errorMessage||"AND condition failed";throw t(r.errorType||"AND_ERROR",n,l)}}}class n extends r{async execute(e,r){const s=r.max||.5,l=await Promise.allSettled(e),n=l.length;if(0===n)return[];const i=this.filterFulfilledResults(l),o=i.length;if(this.filterRejectedResults(l),o>Math.floor(n*s))return i;{const e=r.errorMessage||`Majority condition failed: ${o}/${n} fulfilled (need majority)`;throw t(r.errorType||"MAJORITY_ERROR",e,l)}}}class i extends r{async execute(e,r){const s=await Promise.allSettled(e),l=this.filterFulfilledResults(s),n=l.length,i=s.length;if(this.filterRejectedResults(s),n===i){const e=r.errorMessage||`NAND condition failed: all ${i} promises fulfilled (expected at least one rejection)`;throw t(r.errorType||"NAND_ERROR",e,s)}return l}}class o extends r{async execute(e,r){const s=await Promise.allSettled(e),l=this.filterFulfilledResults(s).length;if(s.length,this.filterRejectedResults(s),0===l)return[];{const e=r.errorMessage||`NOR condition failed: ${l} promises fulfilled (expected all rejected)`;throw t(r.errorType||"NOR_ERROR",e,s)}}}class a extends r{async execute(e,r){const s=await Promise.allSettled(e),l=this.filterFulfilledResults(s),n=l.length,i=s.length;if(this.filterRejectedResults(s),0===n||n===i)return l;{const e=r.errorMessage||`XNOR condition failed: ${n}/${i} promises fulfilled (expected all or none)`;throw t(r.errorType||"XNOR_ERROR",e,s)}}}class c extends r{async execute(e,r){const s=await Promise.allSettled(e),l=this.filterFulfilledResults(s),n=l.length,i=s.length;if(this.filterRejectedResults(s),1===n)return l[0];{const e=r.errorMessage||(n>1?`XOR condition failed: ${n} promises fulfilled (expected exactly 1)`:`XOR condition failed: all ${i} promises rejected (expected exactly 1)`);throw t(r.errorType||"XOR_ERROR",e,s)}}}class d extends r{async execute(e,t={}){return new Promise(t=>{const r=[];let s=0,l=!1;const n=[...e],i=n?.length??0;0!==i?n.forEach((e,n)=>{Promise.resolve(e).then(e=>{r[n]=e,l=!0,t(r.filter(e=>void 0!==e))}).catch(()=>{}).finally(()=>{s++,s!==i||l||t([])})}):t([])})}}class u extends r{async execute(e,t={}){return new Promise(t=>{const r=[];let s=0,l=!1;const n=[...e],i=n?.length??0;0!==i?n.forEach((e,n)=>{Promise.resolve(e).then(()=>{}).catch(e=>{r[n]=e,l=!0,t(r.filter(e=>void 0!==e))}).finally(()=>{s++,s!==i||l||t([])})}):t([])})}}class R extends r{async execute(e,r={}){let s;if("function"==typeof e[Symbol.iterator]){const l=[...e];if(0===l.length)throw t(r.errorType||"NOT_ERROR",r.errorMessage||"NOT gate requires exactly one promise",[]);if(l.length>1)throw t(r.errorType||"NOT_ERROR",r.errorMessage||"NOT gate only accepts one promise",[]);s=l[0]}else s=e;return Promise.resolve(s).then(e=>{throw t(r.errorType||"NOT_ERROR",r.errorMessage||`NOT condition failed: ${e}`,[])},e=>e)}}class h extends r{async execute(e,r){if(0===Array.from(e).length)return{};try{return await Promise.race(e)}catch(s){const l=await Promise.allSettled(e),n=r.errorMessage||"RACE condition failed: all promises rejected";throw t(r.errorType||"RACE_ERROR",n,l)}}}class f extends r{async execute(e,r){try{return await Promise.allSettled(e)}catch(s){const l=await Promise.allSettled(e),n=r.errorMessage||"ALL_SETTLED condition failed: at least one promise rejected";throw t(r.errorType||"ALL_SETTLED_ERROR",n,l)}}}class m{constructor(e){this.promise=e}maxTimer(e,t=`Promise timed out after ${e}ms`){let r;const s=Promise.race([this.promise,new Promise((s,l)=>{r=setTimeout(()=>{l(new Error(t))},e)})]).finally(()=>clearTimeout(r));return new m(s)}then(e,t){return new m(this.promise.then(e,t))}catch(e){return new m(this.promise.catch(e))}finally(e){return new m(this.promise.finally(e))}toPromise(){return this.promise}}class x{static get gates(){return{and:new l,or:new s,xor:new c,nand:new i,nor:new o,xnor:new a,not:new R,race:new h,allSettled:new f,majority:new n,allFulfilled:new d,allRejected:new u}}static and(e,t={errorType:"AND_ERROR",errorMessage:""}){return new m(this.gates.and.execute(e,t))}static or(e,t={errorType:"OR_ERROR",errorMessage:""}){return new m(this.gates.or.execute(e,t))}static not(e,t={errorType:"NOT_ERROR",errorMessage:""}){return new m(this.gates.not.execute(e,t))}static race(e,t={errorType:"RACE_ERROR",errorMessage:""}){return new m(this.gates.race.execute(e,t))}static allSettled(e,t={errorType:"ALL_SETTLED_ERROR",errorMessage:""}){return new m(this.gates.allSettled.execute(e,t))}static xor(e,t={errorType:"XOR_ERROR",errorMessage:""}){return new m(this.gates.xor.execute(e,t))}static nand(e,t={errorType:"NAND_ERROR",errorMessage:""}){return new m(this.gates.nand.execute(e,t))}static nor(e,t={errorType:"NOR_ERROR",errorMessage:""}){return new m(this.gates.nor.execute(e,t))}static xnor(e,t={errorType:"XNOR_ERROR",errorMessage:""}){return new m(this.gates.xnor.execute(e,t))}static majority(e,t={max:.5,errorType:"MAJORITY_ERROR",errorMessage:""}){return new m(this.gates.majority.execute(e,t))}static allFulfilled(e){return new m(this.gates.allFulfilled.execute(e))}static allRejected(e){return new m(this.gates.allRejected.execute(e))}static createFlipFlop(e=!1){let t=e,r=null,s=Promise.resolve(t);return{getState:()=>t,set(e){return t=e,r&&(r(t),r=null),s=Promise.resolve(t),this},toggle(){return this.set(!t)},waitForChange:()=>(r||(s=new Promise(e=>{r=e})),s),waitFor(e){return t===e?Promise.resolve(t):new Promise(r=>{const s=()=>{t===e?r(t):this.waitForChange().then(s)};s()})}}}}exports.PromiseLogic=x,exports.PromiseLogicError=e,exports.PromiseWithTimer=m,exports.createPromiseLogic=function(e={}){const{prefix:t="",suffix:r="",rename:s={}}=e,l={and:x.and.bind(x),or:x.or.bind(x),not:x.not.bind(x),race:x.race.bind(x),allSettled:x.allSettled.bind(x),xor:x.xor.bind(x),nand:x.nand.bind(x),nor:x.nor.bind(x),xnor:x.xnor.bind(x),majority:x.majority.bind(x),allFulfilled:x.allFulfilled.bind(x),allRejected:x.allRejected.bind(x)},n={};return Object.entries(l).forEach(([e,l])=>{const i=s[e]||e;n[`${t}${i}${r}`]=l}),n};

package/dist/v2/index.esm.js

@@ -1 +1 @@
-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,r=0;const n=[...e],i=n?.length??0;0!==i?n.forEach((e,n)=>{Promise.resolve(e).then(e=>{r++,l[n]=e}).catch(()=>{l[n]=void 0}).finally(()=>{s++,r>0?t(l.filter(e=>void 0!==e)):s===i&&t([])})}):t(l)})}}class d extends l{async execute(e){return new Promise(t=>{const l=[];let s=0,r=0;const n=[...e],i=n?.length??0;0!==i?n.forEach((e,n)=>{Promise.resolve(e).then(()=>{l[n]=void 0}).catch(e=>{r++,l[n]=e}).finally(()=>{s++,r>0?t(l.filter(e=>void 0!==e)):s===i&&t([])})}):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};
+class e extends Error{constructor(e,t,r){super(t),this.type=e,this.results=r,this.name="PromiseLogicError"}}function t(t,r,s,l){return new e(t,r,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}}class s extends r{async execute(e,r){try{return await Promise.any(e)}catch(s){const l=await Promise.allSettled(e),n=r.errorMessage||"OR condition failed";throw t(r.errorType||"OR_ERROR",n,l)}}}class l extends r{async execute(e,r){try{return await Promise.all(e)}catch(s){const l=await Promise.allSettled(e),n=r.errorMessage||"AND condition failed";throw t(r.errorType||"AND_ERROR",n,l)}}}class n extends r{async execute(e,r){const s=r.max||.5,l=await Promise.allSettled(e),n=l.length;if(0===n)return[];const i=this.filterFulfilledResults(l),o=i.length;if(this.filterRejectedResults(l),o>Math.floor(n*s))return i;{const e=r.errorMessage||`Majority condition failed: ${o}/${n} fulfilled (need majority)`;throw t(r.errorType||"MAJORITY_ERROR",e,l)}}}class i extends r{async execute(e,r){const s=await Promise.allSettled(e),l=this.filterFulfilledResults(s),n=l.length,i=s.length;if(this.filterRejectedResults(s),n===i){const e=r.errorMessage||`NAND condition failed: all ${i} promises fulfilled (expected at least one rejection)`;throw t(r.errorType||"NAND_ERROR",e,s)}return l}}class o extends r{async execute(e,r){const s=await Promise.allSettled(e),l=this.filterFulfilledResults(s).length;if(s.length,this.filterRejectedResults(s),0===l)return[];{const e=r.errorMessage||`NOR condition failed: ${l} promises fulfilled (expected all rejected)`;throw t(r.errorType||"NOR_ERROR",e,s)}}}class a extends r{async execute(e,r){const s=await Promise.allSettled(e),l=this.filterFulfilledResults(s),n=l.length,i=s.length;if(this.filterRejectedResults(s),0===n||n===i)return l;{const e=r.errorMessage||`XNOR condition failed: ${n}/${i} promises fulfilled (expected all or none)`;throw t(r.errorType||"XNOR_ERROR",e,s)}}}class c extends r{async execute(e,r){const s=await Promise.allSettled(e),l=this.filterFulfilledResults(s),n=l.length,i=s.length;if(this.filterRejectedResults(s),1===n)return l[0];{const e=r.errorMessage||(n>1?`XOR condition failed: ${n} promises fulfilled (expected exactly 1)`:`XOR condition failed: all ${i} promises rejected (expected exactly 1)`);throw t(r.errorType||"XOR_ERROR",e,s)}}}class d extends r{async execute(e,t={}){return new Promise(t=>{const r=[];let s=0,l=!1;const n=[...e],i=n?.length??0;0!==i?n.forEach((e,n)=>{Promise.resolve(e).then(e=>{r[n]=e,l=!0,t(r.filter(e=>void 0!==e))}).catch(()=>{}).finally(()=>{s++,s!==i||l||t([])})}):t([])})}}class u extends r{async execute(e,t={}){return new Promise(t=>{const r=[];let s=0,l=!1;const n=[...e],i=n?.length??0;0!==i?n.forEach((e,n)=>{Promise.resolve(e).then(()=>{}).catch(e=>{r[n]=e,l=!0,t(r.filter(e=>void 0!==e))}).finally(()=>{s++,s!==i||l||t([])})}):t([])})}}class R extends r{async execute(e,r={}){let s;if("function"==typeof e[Symbol.iterator]){const l=[...e];if(0===l.length)throw t(r.errorType||"NOT_ERROR",r.errorMessage||"NOT gate requires exactly one promise",[]);if(l.length>1)throw t(r.errorType||"NOT_ERROR",r.errorMessage||"NOT gate only accepts one promise",[]);s=l[0]}else s=e;return Promise.resolve(s).then(e=>{throw t(r.errorType||"NOT_ERROR",r.errorMessage||`NOT condition failed: ${e}`,[])},e=>e)}}class f extends r{async execute(e,r){if(0===Array.from(e).length)return{};try{return await Promise.race(e)}catch(s){const l=await Promise.allSettled(e),n=r.errorMessage||"RACE condition failed: all promises rejected";throw t(r.errorType||"RACE_ERROR",n,l)}}}class h extends r{async execute(e,r){try{return await Promise.allSettled(e)}catch(s){const l=await Promise.allSettled(e),n=r.errorMessage||"ALL_SETTLED condition failed: at least one promise rejected";throw t(r.errorType||"ALL_SETTLED_ERROR",n,l)}}}class m{constructor(e){this.promise=e}maxTimer(e,t=`Promise timed out after ${e}ms`){let r;const s=Promise.race([this.promise,new Promise((s,l)=>{r=setTimeout(()=>{l(new Error(t))},e)})]).finally(()=>clearTimeout(r));return new m(s)}then(e,t){return new m(this.promise.then(e,t))}catch(e){return new m(this.promise.catch(e))}finally(e){return new m(this.promise.finally(e))}toPromise(){return this.promise}}class w{static get gates(){return{and:new l,or:new s,xor:new c,nand:new i,nor:new o,xnor:new a,not:new R,race:new f,allSettled:new h,majority:new n,allFulfilled:new d,allRejected:new u}}static and(e,t={errorType:"AND_ERROR",errorMessage:""}){return new m(this.gates.and.execute(e,t))}static or(e,t={errorType:"OR_ERROR",errorMessage:""}){return new m(this.gates.or.execute(e,t))}static not(e,t={errorType:"NOT_ERROR",errorMessage:""}){return new m(this.gates.not.execute(e,t))}static race(e,t={errorType:"RACE_ERROR",errorMessage:""}){return new m(this.gates.race.execute(e,t))}static allSettled(e,t={errorType:"ALL_SETTLED_ERROR",errorMessage:""}){return new m(this.gates.allSettled.execute(e,t))}static xor(e,t={errorType:"XOR_ERROR",errorMessage:""}){return new m(this.gates.xor.execute(e,t))}static nand(e,t={errorType:"NAND_ERROR",errorMessage:""}){return new m(this.gates.nand.execute(e,t))}static nor(e,t={errorType:"NOR_ERROR",errorMessage:""}){return new m(this.gates.nor.execute(e,t))}static xnor(e,t={errorType:"XNOR_ERROR",errorMessage:""}){return new m(this.gates.xnor.execute(e,t))}static majority(e,t={max:.5,errorType:"MAJORITY_ERROR",errorMessage:""}){return new m(this.gates.majority.execute(e,t))}static allFulfilled(e){return new m(this.gates.allFulfilled.execute(e))}static allRejected(e){return new m(this.gates.allRejected.execute(e))}static createFlipFlop(e=!1){let t=e,r=null,s=Promise.resolve(t);return{getState:()=>t,set(e){return t=e,r&&(r(t),r=null),s=Promise.resolve(t),this},toggle(){return this.set(!t)},waitForChange:()=>(r||(s=new Promise(e=>{r=e})),s),waitFor(e){return t===e?Promise.resolve(t):new Promise(r=>{const s=()=>{t===e?r(t):this.waitForChange().then(s)};s()})}}}}function x(e={}){const{prefix:t="",suffix:r="",rename:s={}}=e,l={and:w.and.bind(w),or:w.or.bind(w),not:w.not.bind(w),race:w.race.bind(w),allSettled:w.allSettled.bind(w),xor:w.xor.bind(w),nand:w.nand.bind(w),nor:w.nor.bind(w),xnor:w.xnor.bind(w),majority:w.majority.bind(w),allFulfilled:w.allFulfilled.bind(w),allRejected:w.allRejected.bind(w)},n={};return Object.entries(l).forEach(([e,l])=>{const i=s[e]||e;n[`${t}${i}${r}`]=l}),n}export{w as PromiseLogic,e as PromiseLogicError,m as PromiseWithTimer,x as createPromiseLogic};

package/dist/v2/types/index.d.ts

@@ -1,11 +1,22 @@
 // v2版本类型定义 (TypeScript版本 - 现代化设计)
 
+/**
+ * 选项参数接口
+ */
+interface LogicGateOptions {
+  errorType?: string | undefined;
+  errorMessage?: string | undefined;
+  max?: number | undefined;
+  [key: string]: string | number | boolean | undefined;
+  
+}
+
 /**
  * PromiseWithTimer 包装类 - 提供超时控制功能
  */
 declare class PromiseWithTimer<T> {
   /** 添加超时控制 */
-  maxTimer(ms: number): Promise<T>;
+  maxTimer(ms: number, errorMessage?: string): PromiseWithTimer<T>;
   
   /** Promise 链式调用 */
   then<U>(onfulfilled?: ((value: T) => U | PromiseLike<U>) | null, onrejected?: ((reason: Error) => U | PromiseLike<U>) | null): PromiseWithTimer<U>;
@@ -22,10 +33,9 @@ declare class PromiseWithTimer<T> {
 
 /**
  * Promise逻辑错误类
- * @deprecated 在v2版本中建议使用更具体的错误类型
  */
 declare class PromiseLogicError extends Error {
-  readonly type: 'XOR_ERROR' | 'NAND_ERROR' | 'NOR_ERROR' | 'XNOR_ERROR' | 'MAJORITY_ERROR' | 'ALL_SUCCESSFUL_ERROR' | 'ALL_FAILED_ERROR';
+  readonly type: string;
   readonly results: PromiseSettledResult<unknown>[];
   
   constructor(type: string, message: string, results: PromiseSettledResult<unknown>[]);
@@ -56,22 +66,22 @@ interface FlipFlop {
  */
 declare class PromiseLogic {
   // 基础逻辑门
-  static and<T>(iterable: Iterable<T | PromiseLike<T>>): PromiseWithTimer<T[]>;
-  static or<T>(iterable: Iterable<T | PromiseLike<T>>): PromiseWithTimer<T>;
-  static race<T>(iterable: Iterable<T | PromiseLike<T>>): PromiseWithTimer<T>;
-  static allSettled<T>(iterable: Iterable<T | PromiseLike<T>>): PromiseWithTimer<PromiseSettledResult<T>[]>;
+  static and<T>(iterable: Iterable<T | PromiseLike<T>>, options?: LogicGateOptions): PromiseWithTimer<T[]>;
+  static or<T>(iterable: Iterable<T | PromiseLike<T>>, options?: LogicGateOptions): PromiseWithTimer<T>;
+  static race<T>(iterable: Iterable<T | PromiseLike<T>>, options?: LogicGateOptions): PromiseWithTimer<T | undefined>;
+  static allSettled<T>(iterable: Iterable<T | PromiseLike<T>>, options?: LogicGateOptions): PromiseWithTimer<PromiseSettledResult<T>[]>;
   
   // 扩展逻辑门
-  static xor<T>(iterable: Iterable<T | PromiseLike<T>>): PromiseWithTimer<T>;
-  static not<T>(promise: T | PromiseLike<T>): PromiseWithTimer<unknown>;
-  static nand<T>(iterable: Iterable<T | PromiseLike<T>>): PromiseWithTimer<T[]>;
-  static nor<T>(iterable: Iterable<T | PromiseLike<T>>): PromiseWithTimer<T[]>;
-  static xnor<T>(iterable: Iterable<T | PromiseLike<T>>): PromiseWithTimer<T[]>;
-  static majority<T>(iterable: Iterable<T | PromiseLike<T>>, options?: { max: number }): PromiseWithTimer<T[]>;
+  static xor<T>(iterable: Iterable<T | PromiseLike<T>>, options?: LogicGateOptions): PromiseWithTimer<T>;
+  static not<T>(promise: T | PromiseLike<T>, options?: LogicGateOptions): PromiseWithTimer<T>;
+  static nand<T>(iterable: Iterable<T | PromiseLike<T>>, options?: LogicGateOptions): PromiseWithTimer<T[]>;
+  static nor<T>(iterable: Iterable<T | PromiseLike<T>>, options?: LogicGateOptions): PromiseWithTimer<T[]>;
+  static xnor<T>(iterable: Iterable<T | PromiseLike<T>>, options?: LogicGateOptions): PromiseWithTimer<T[]>;
+  static majority<T>(iterable: Iterable<T | PromiseLike<T>>, options?: LogicGateOptions): PromiseWithTimer<T[]>;
   
   // 实用方法
-  static allFulfilled(iterable: Iterable<PromiseLike<unknown>>): PromiseWithTimer<unknown[]>;
-  static allRejected<T>(iterable: Iterable<T | PromiseLike<T>>): PromiseWithTimer<unknown[]>;
+  static allFulfilled<T>(iterable: Iterable<T | PromiseLike<T>>, options?: LogicGateOptions): PromiseWithTimer<T[]>;
+  static allRejected<T>(iterable: Iterable<T | PromiseLike<T>>, options?: LogicGateOptions): PromiseWithTimer<Error[]>;
   
   // 状态管理
   static createFlipFlop(initialState?: boolean): FlipFlop;
@@ -98,9 +108,8 @@ declare function createPromiseLogic(options?: CreatePromiseLogicOptions): Record
 
 /**
  * 创建逻辑错误
- * @deprecated 在v2版本中建议使用更具体的错误构造器
  */
-declare function createLogicError(type: string, fulfilledCount: number, total: number, results: PromiseSettledResult<unknown>[]): PromiseLogicError;
+declare function createLogicError(type: string, message: string, results: PromiseSettledResult<unknown>[], error?: unknown): PromiseLogicError;
 
 export { PromiseLogic, PromiseLogicError, PromiseWithTimer, createLogicError, createPromiseLogic };
-export type { CreatePromiseLogicOptions, FlipFlop };
+export type { CreatePromiseLogicOptions, FlipFlop, LogicGateOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "promise-logic",
-  "version": "2.8.5",
+  "version": "2.9.1",
   "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",