promise-logic 1.3.2 → 2.4.3

package/dist/index.esm.js

@@ -12,6 +12,7 @@ function createLogicError(type, fulfilledCount, total, results) {
   const messages = {
     XOR_ERROR: `XOR condition failed: expected exactly 1 promise to fulfill, but ${fulfilledCount} fulfilled.`,
     NAND_ERROR: `NAND condition failed: all ${total} promises fulfilled (expected at least one rejection).`,
+    NOT_ERROR: `NOT condition failed: promise resolved (expected rejection).`,
     NOR_ERROR: `NOR condition failed: ${fulfilledCount} promises fulfilled (expected all rejected).`,
     MAJORITY_ERROR: `Majority condition failed: ${fulfilledCount}/${total} fulfilled (need majority).`,
     ALL_SUCCESSFUL_ERROR: `All successful condition failed: ${fulfilledCount}/${total} promises fulfilled (expected all to succeed).`,
@@ -30,6 +31,15 @@ class PromiseLogic {
     return Promise.any(iterable);
   }
 
+  
+static  not(promise) {
+  return Promise.resolve(promise).then(
+    (value) => Promise.reject(value),
+    (reason) => Promise.resolve(reason)
+  )
+  .catch((error) => Promise.resolve(error));
+}
+
   static race(iterable) {
     return Promise.race(iterable);
   }
@@ -119,6 +129,7 @@ class PromiseLogic {
     });
   }
 
+
   // 返回所有成功的Promise结果
   static allFulfilled(iterable) {
     return Promise.allSettled(iterable).then((results) => {
@@ -201,10 +212,13 @@ function createPromiseLogic(options = {}) {
     race: PromiseLogic.race,
     allSettled: PromiseLogic.allSettled,
     xor: PromiseLogic.xor,
+    not: PromiseLogic.not,
     nand: PromiseLogic.nand,
     nor: PromiseLogic.nor,
     xnor: PromiseLogic.xnor,
-    majority: PromiseLogic.majority
+    majority: PromiseLogic.majority,
+    allFulfilled: PromiseLogic.allFulfilled,
+    allRejected: PromiseLogic.allRejected
   };
   
   // 应用命名转换
@@ -220,4 +234,3 @@ function createPromiseLogic(options = {}) {
 }
 
 export { PromiseLogic, PromiseLogicError, createLogicError, createPromiseLogic };
-//# sourceMappingURL=index.esm.js.map

package/dist/v2/factory.cjs.js

@@ -0,0 +1,286 @@
+'use strict';
+
+class BaseGate {
+    filterResults(results, status) {
+        if (status === 'fulfilled') {
+            return results
+                .filter((result) => result.status === 'fulfilled')
+                .map(result => result.value);
+        }
+        else {
+            return results
+                .filter((result) => result.status === 'rejected')
+                .map(result => result.reason);
+        }
+    }
+    countFulfilled(results) {
+        return results.filter(result => result.status === 'fulfilled').length;
+    }
+}
+
+class OrGate extends BaseGate {
+    async execute(iterable) {
+        return Promise.any(iterable);
+    }
+}
+
+class AndGate extends BaseGate {
+    async execute(iterable) {
+        try {
+            return Promise.all(iterable);
+        }
+        catch (error) {
+            throw new PromiseLogicError('AND_ERROR', 'AND gate failed', [error]);
+        }
+    }
+}
+
+let PromiseLogicError$1 = class PromiseLogicError extends Error {
+    constructor(type, message, results) {
+        super(message);
+        this.type = type;
+        this.results = results;
+        this.name = 'PromiseLogicError';
+    }
+};
+// Error factory function
+function createLogicError(type, fulfilledCount, total, results) {
+    const messages = {
+        XOR_ERROR: `XOR condition failed: expected exactly 1 promise to fulfill, but ${fulfilledCount} fulfilled.`,
+        NAND_ERROR: `NAND condition failed: all ${total} promises fulfilled (expected at least one rejection).`,
+        NOR_ERROR: `NOR condition failed: ${fulfilledCount} promises fulfilled (expected all rejected).`,
+        XNOR_ERROR: `XNOR condition failed: ${fulfilledCount}/${total} promises fulfilled (expected all or none).`,
+        MAJORITY_ERROR: `Majority condition failed: ${fulfilledCount}/${total} fulfilled (need majority).`,
+        ALL_SUCCESSFUL_ERROR: `All successful condition failed: ${fulfilledCount}/${total} promises fulfilled (expected all to succeed).`,
+        ALL_FAILED_ERROR: `All failed condition failed: ${total - fulfilledCount}/${total} promises rejected (expected all to fail).`
+    };
+    return new PromiseLogicError$1(type, messages[type] || 'Logic condition failed', results);
+}
+
+class MajorityGate extends BaseGate {
+    async execute(iterable) {
+        const results = await Promise.allSettled(iterable);
+        const fulfilled = this.filterResults(results, 'fulfilled');
+        const fulfilledCount = fulfilled.length;
+        const total = results.length;
+        // Majority logic: success count > failure count
+        if (fulfilledCount > total - fulfilledCount) {
+            return fulfilled;
+        }
+        else {
+            throw createLogicError('MAJORITY_ERROR', fulfilledCount, total, results);
+        }
+    }
+}
+
+class NandGate extends BaseGate {
+    async execute(iterable) {
+        const results = await Promise.allSettled(iterable);
+        const fulfilled = this.filterResults(results, 'fulfilled');
+        const fulfilledCount = fulfilled.length;
+        const total = results.length;
+        if (fulfilledCount === total) {
+            // 全部成功，抛出NAND_ERROR
+            throw createLogicError('NAND_ERROR', fulfilledCount, total, results);
+        }
+        else {
+            // 不是所有都成功，返回成功的值数组
+            return fulfilled;
+        }
+    }
+}
+
+class NorGate extends BaseGate {
+    async execute(iterable) {
+        const results = await Promise.allSettled(iterable);
+        const fulfilled = this.filterResults(results, 'fulfilled');
+        const fulfilledCount = fulfilled.length;
+        const total = results.length;
+        if (fulfilledCount === 0) {
+            // 全部失败，返回空数组表示成功
+            return [];
+        }
+        else {
+            // 任意成功，抛出NOR_ERROR
+            throw createLogicError('NOR_ERROR', fulfilledCount, total, results);
+        }
+    }
+}
+
+class XnorGate extends BaseGate {
+    async execute(iterable) {
+        const results = await Promise.allSettled(iterable);
+        const fulfilled = this.filterResults(results, 'fulfilled');
+        const fulfilledCount = fulfilled.length;
+        const total = results.length;
+        if (fulfilledCount === 0 || fulfilledCount === total) {
+            // 全部成功或全部失败，返回成功的值数组
+            return fulfilled;
+        }
+        else {
+            // 部分成功部分失败，抛出XNOR_ERROR
+            throw createLogicError('XNOR_ERROR', fulfilledCount, total, results);
+        }
+    }
+}
+
+class XorGate extends BaseGate {
+    async execute(iterable) {
+        const results = await Promise.allSettled(iterable);
+        const fulfilled = results.filter(result => result.status === 'fulfilled');
+        const fulfilledCount = fulfilled.length;
+        const total = results.length;
+        if (fulfilledCount === 1) {
+            return fulfilled[0].value;
+        }
+        else {
+            throw createLogicError('XOR_ERROR', fulfilledCount, total, results);
+        }
+    }
+}
+
+class PromiseLogicError extends Error {
+    constructor(type, message, results) {
+        super(message);
+        this.type = type;
+        this.results = results;
+        this.name = 'PromiseLogicError';
+    }
+}
+class PromiseLogic {
+    static get gates() {
+        return {
+            and: new AndGate(),
+            or: new OrGate(),
+            xor: new XorGate(),
+            nand: new NandGate(),
+            nor: new NorGate(),
+            xnor: new XnorGate(),
+            majority: new MajorityGate()
+        };
+    }
+    // Core Logic Gates
+    static and(iterable) {
+        return this.gates.and.execute(iterable);
+    }
+    static or(iterable) {
+        return this.gates.or.execute(iterable);
+    }
+    static xor(iterable) {
+        return this.gates.xor.execute(iterable);
+    }
+    static nand(iterable) {
+        return this.gates.nand.execute(iterable);
+    }
+    static nor(iterable) {
+        return this.gates.nor.execute(iterable);
+    }
+    static xnor(iterable) {
+        return this.gates.xnor.execute(iterable);
+    }
+    static majority(iterable) {
+        return this.gates.majority.execute(iterable);
+    }
+    // Extended Operations
+    static allFulfilled(iterable) {
+        return Promise.allSettled(iterable).then((results) => {
+            const fulfilled = results.filter(result => result.status === 'fulfilled');
+            return fulfilled.map(result => result.value);
+        });
+    }
+    static allRejected(iterable) {
+        return Promise.allSettled(iterable).then((results) => {
+            return results
+                .filter((result) => result.status === 'rejected')
+                .map(result => result.reason);
+        });
+    }
+    // NOT logic - Inverts promise resolution
+    static not(promise) {
+        return Promise.resolve(promise).then((value) => Promise.reject(value), (reason) => Promise.resolve(reason));
+    }
+    // Utility Methods
+    static race(iterable) {
+        return Promise.race(iterable);
+    }
+    static allSettled(iterable) {
+        return Promise.allSettled(iterable);
+    }
+    static createFlipFlop(initialState = false) {
+        let state = initialState;
+        let resolveCurrent = null;
+        let currentPromise = Promise.resolve(state);
+        const waitForChange = () => {
+            if (!resolveCurrent) {
+                currentPromise = new Promise((resolve) => {
+                    resolveCurrent = resolve;
+                });
+            }
+            return currentPromise;
+        };
+        return {
+            getState() {
+                return state;
+            },
+            async set(newState) {
+                state = newState;
+                if (resolveCurrent) {
+                    resolveCurrent(state);
+                    resolveCurrent = null;
+                }
+                currentPromise = Promise.resolve(state);
+                return state;
+            },
+            async toggle() {
+                return this.set(!state);
+            },
+            waitForChange,
+            waitFor(targetState) {
+                if (state === targetState) {
+                    return Promise.resolve(state);
+                }
+                return new Promise((resolve) => {
+                    const checkState = () => {
+                        if (state === targetState) {
+                            resolve(state);
+                        }
+                        else {
+                            waitForChange().then(checkState);
+                        }
+                    };
+                    checkState();
+                });
+            }
+        };
+    }
+}
+
+function createPromiseLogic(options = {}) {
+    const { prefix = '', suffix = '', rename = {} } = options;
+    // 基础方法映射
+    const methods = {
+        and: PromiseLogic.and,
+        or: PromiseLogic.or,
+        not: PromiseLogic.not,
+        race: PromiseLogic.race,
+        allSettled: PromiseLogic.allSettled,
+        xor: PromiseLogic.xor,
+        nand: PromiseLogic.nand,
+        nor: PromiseLogic.nor,
+        xnor: PromiseLogic.xnor,
+        majority: PromiseLogic.majority,
+        allFulfilled: PromiseLogic.allFulfilled,
+        allRejected: PromiseLogic.allRejected
+    };
+    // 应用命名转换
+    const result = {};
+    Object.entries(methods).forEach(([key, fn]) => {
+        // 优先使用rename映射，然后应用prefix和suffix
+        const baseName = rename[key] || key;
+        const finalName = `${prefix}${baseName}${suffix}`;
+        result[finalName] = fn;
+    });
+    return result;
+}
+
+exports.createPromiseLogic = createPromiseLogic;

package/dist/v2/factory.esm.js

@@ -0,0 +1,284 @@
+class BaseGate {
+    filterResults(results, status) {
+        if (status === 'fulfilled') {
+            return results
+                .filter((result) => result.status === 'fulfilled')
+                .map(result => result.value);
+        }
+        else {
+            return results
+                .filter((result) => result.status === 'rejected')
+                .map(result => result.reason);
+        }
+    }
+    countFulfilled(results) {
+        return results.filter(result => result.status === 'fulfilled').length;
+    }
+}
+
+class OrGate extends BaseGate {
+    async execute(iterable) {
+        return Promise.any(iterable);
+    }
+}
+
+class AndGate extends BaseGate {
+    async execute(iterable) {
+        try {
+            return Promise.all(iterable);
+        }
+        catch (error) {
+            throw new PromiseLogicError('AND_ERROR', 'AND gate failed', [error]);
+        }
+    }
+}
+
+let PromiseLogicError$1 = class PromiseLogicError extends Error {
+    constructor(type, message, results) {
+        super(message);
+        this.type = type;
+        this.results = results;
+        this.name = 'PromiseLogicError';
+    }
+};
+// Error factory function
+function createLogicError(type, fulfilledCount, total, results) {
+    const messages = {
+        XOR_ERROR: `XOR condition failed: expected exactly 1 promise to fulfill, but ${fulfilledCount} fulfilled.`,
+        NAND_ERROR: `NAND condition failed: all ${total} promises fulfilled (expected at least one rejection).`,
+        NOR_ERROR: `NOR condition failed: ${fulfilledCount} promises fulfilled (expected all rejected).`,
+        XNOR_ERROR: `XNOR condition failed: ${fulfilledCount}/${total} promises fulfilled (expected all or none).`,
+        MAJORITY_ERROR: `Majority condition failed: ${fulfilledCount}/${total} fulfilled (need majority).`,
+        ALL_SUCCESSFUL_ERROR: `All successful condition failed: ${fulfilledCount}/${total} promises fulfilled (expected all to succeed).`,
+        ALL_FAILED_ERROR: `All failed condition failed: ${total - fulfilledCount}/${total} promises rejected (expected all to fail).`
+    };
+    return new PromiseLogicError$1(type, messages[type] || 'Logic condition failed', results);
+}
+
+class MajorityGate extends BaseGate {
+    async execute(iterable) {
+        const results = await Promise.allSettled(iterable);
+        const fulfilled = this.filterResults(results, 'fulfilled');
+        const fulfilledCount = fulfilled.length;
+        const total = results.length;
+        // Majority logic: success count > failure count
+        if (fulfilledCount > total - fulfilledCount) {
+            return fulfilled;
+        }
+        else {
+            throw createLogicError('MAJORITY_ERROR', fulfilledCount, total, results);
+        }
+    }
+}
+
+class NandGate extends BaseGate {
+    async execute(iterable) {
+        const results = await Promise.allSettled(iterable);
+        const fulfilled = this.filterResults(results, 'fulfilled');
+        const fulfilledCount = fulfilled.length;
+        const total = results.length;
+        if (fulfilledCount === total) {
+            // 全部成功，抛出NAND_ERROR
+            throw createLogicError('NAND_ERROR', fulfilledCount, total, results);
+        }
+        else {
+            // 不是所有都成功，返回成功的值数组
+            return fulfilled;
+        }
+    }
+}
+
+class NorGate extends BaseGate {
+    async execute(iterable) {
+        const results = await Promise.allSettled(iterable);
+        const fulfilled = this.filterResults(results, 'fulfilled');
+        const fulfilledCount = fulfilled.length;
+        const total = results.length;
+        if (fulfilledCount === 0) {
+            // 全部失败，返回空数组表示成功
+            return [];
+        }
+        else {
+            // 任意成功，抛出NOR_ERROR
+            throw createLogicError('NOR_ERROR', fulfilledCount, total, results);
+        }
+    }
+}
+
+class XnorGate extends BaseGate {
+    async execute(iterable) {
+        const results = await Promise.allSettled(iterable);
+        const fulfilled = this.filterResults(results, 'fulfilled');
+        const fulfilledCount = fulfilled.length;
+        const total = results.length;
+        if (fulfilledCount === 0 || fulfilledCount === total) {
+            // 全部成功或全部失败，返回成功的值数组
+            return fulfilled;
+        }
+        else {
+            // 部分成功部分失败，抛出XNOR_ERROR
+            throw createLogicError('XNOR_ERROR', fulfilledCount, total, results);
+        }
+    }
+}
+
+class XorGate extends BaseGate {
+    async execute(iterable) {
+        const results = await Promise.allSettled(iterable);
+        const fulfilled = results.filter(result => result.status === 'fulfilled');
+        const fulfilledCount = fulfilled.length;
+        const total = results.length;
+        if (fulfilledCount === 1) {
+            return fulfilled[0].value;
+        }
+        else {
+            throw createLogicError('XOR_ERROR', fulfilledCount, total, results);
+        }
+    }
+}
+
+class PromiseLogicError extends Error {
+    constructor(type, message, results) {
+        super(message);
+        this.type = type;
+        this.results = results;
+        this.name = 'PromiseLogicError';
+    }
+}
+class PromiseLogic {
+    static get gates() {
+        return {
+            and: new AndGate(),
+            or: new OrGate(),
+            xor: new XorGate(),
+            nand: new NandGate(),
+            nor: new NorGate(),
+            xnor: new XnorGate(),
+            majority: new MajorityGate()
+        };
+    }
+    // Core Logic Gates
+    static and(iterable) {
+        return this.gates.and.execute(iterable);
+    }
+    static or(iterable) {
+        return this.gates.or.execute(iterable);
+    }
+    static xor(iterable) {
+        return this.gates.xor.execute(iterable);
+    }
+    static nand(iterable) {
+        return this.gates.nand.execute(iterable);
+    }
+    static nor(iterable) {
+        return this.gates.nor.execute(iterable);
+    }
+    static xnor(iterable) {
+        return this.gates.xnor.execute(iterable);
+    }
+    static majority(iterable) {
+        return this.gates.majority.execute(iterable);
+    }
+    // Extended Operations
+    static allFulfilled(iterable) {
+        return Promise.allSettled(iterable).then((results) => {
+            const fulfilled = results.filter(result => result.status === 'fulfilled');
+            return fulfilled.map(result => result.value);
+        });
+    }
+    static allRejected(iterable) {
+        return Promise.allSettled(iterable).then((results) => {
+            return results
+                .filter((result) => result.status === 'rejected')
+                .map(result => result.reason);
+        });
+    }
+    // NOT logic - Inverts promise resolution
+    static not(promise) {
+        return Promise.resolve(promise).then((value) => Promise.reject(value), (reason) => Promise.resolve(reason));
+    }
+    // Utility Methods
+    static race(iterable) {
+        return Promise.race(iterable);
+    }
+    static allSettled(iterable) {
+        return Promise.allSettled(iterable);
+    }
+    static createFlipFlop(initialState = false) {
+        let state = initialState;
+        let resolveCurrent = null;
+        let currentPromise = Promise.resolve(state);
+        const waitForChange = () => {
+            if (!resolveCurrent) {
+                currentPromise = new Promise((resolve) => {
+                    resolveCurrent = resolve;
+                });
+            }
+            return currentPromise;
+        };
+        return {
+            getState() {
+                return state;
+            },
+            async set(newState) {
+                state = newState;
+                if (resolveCurrent) {
+                    resolveCurrent(state);
+                    resolveCurrent = null;
+                }
+                currentPromise = Promise.resolve(state);
+                return state;
+            },
+            async toggle() {
+                return this.set(!state);
+            },
+            waitForChange,
+            waitFor(targetState) {
+                if (state === targetState) {
+                    return Promise.resolve(state);
+                }
+                return new Promise((resolve) => {
+                    const checkState = () => {
+                        if (state === targetState) {
+                            resolve(state);
+                        }
+                        else {
+                            waitForChange().then(checkState);
+                        }
+                    };
+                    checkState();
+                });
+            }
+        };
+    }
+}
+
+function createPromiseLogic(options = {}) {
+    const { prefix = '', suffix = '', rename = {} } = options;
+    // 基础方法映射
+    const methods = {
+        and: PromiseLogic.and,
+        or: PromiseLogic.or,
+        not: PromiseLogic.not,
+        race: PromiseLogic.race,
+        allSettled: PromiseLogic.allSettled,
+        xor: PromiseLogic.xor,
+        nand: PromiseLogic.nand,
+        nor: PromiseLogic.nor,
+        xnor: PromiseLogic.xnor,
+        majority: PromiseLogic.majority,
+        allFulfilled: PromiseLogic.allFulfilled,
+        allRejected: PromiseLogic.allRejected
+    };
+    // 应用命名转换
+    const result = {};
+    Object.entries(methods).forEach(([key, fn]) => {
+        // 优先使用rename映射，然后应用prefix和suffix
+        const baseName = rename[key] || key;
+        const finalName = `${prefix}${baseName}${suffix}`;
+        result[finalName] = fn;
+    });
+    return result;
+}
+
+export { createPromiseLogic };