Initial implementation of IfThenElseCondition.

packages/taco/src/conditions/compound-condition.ts

@@ -4,6 +4,7 @@ import { contractConditionSchema } from './base/contract';
 import { rpcConditionSchema } from './base/rpc';
 import { timeConditionSchema } from './base/time';
 import { baseConditionSchema, Condition, ConditionProps } from './condition';
+import { ifThenElseConditionSchema } from './if-then-else-condition';
 import { maxNestedDepth } from './multi-condition';
 import { sequentialConditionSchema } from './sequential';
 import { OmitConditionType } from './shared';
@@ -25,6 +26,7 @@ export const compoundConditionSchema: z.ZodSchema = baseConditionSchema
             contractConditionSchema,
             compoundConditionSchema,
             sequentialConditionSchema,
+            ifThenElseConditionSchema,
           ]),
         ),
       )

packages/taco/src/conditions/if-then-else-condition.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+
+import { contractConditionSchema } from './base/contract';
+import { rpcConditionSchema } from './base/rpc';
+import { timeConditionSchema } from './base/time';
+import { compoundConditionSchema } from './compound-condition';
+import { baseConditionSchema, Condition } from './condition';
+import { maxNestedDepth } from './multi-condition';
+import { sequentialConditionSchema } from './sequential';
+import { OmitConditionType } from './shared';
+
+export const IfThenElseConditionType = 'if-then-else';
+
+export const ifThenElseConditionSchema: z.ZodSchema = baseConditionSchema
+  .extend({
+    conditionType: z
+      .literal(IfThenElseConditionType)
+      .default(IfThenElseConditionType),
+    ifCondition: z.lazy(() =>
+      z.union([
+        rpcConditionSchema,
+        timeConditionSchema,
+        contractConditionSchema,
+        compoundConditionSchema,
+        sequentialConditionSchema,
+        ifThenElseConditionSchema,
+      ]),
+    ),
+    thenCondition: z.lazy(() =>
+      z.union([
+        rpcConditionSchema,
+        timeConditionSchema,
+        contractConditionSchema,
+        compoundConditionSchema,
+        sequentialConditionSchema,
+        ifThenElseConditionSchema,
+      ]),
+    ),
+    elseCondition: z.lazy(() =>
+      z.union([
+        // Condition
+        rpcConditionSchema,
+        timeConditionSchema,
+        contractConditionSchema,
+        compoundConditionSchema,
+        sequentialConditionSchema,
+        ifThenElseConditionSchema,
+        // boolean
+        z.boolean(),
+      ]),
+    ),
+  })
+  .refine(
+    (condition) => maxNestedDepth(2)(condition),
+    {
+      message: 'Exceeded max nested depth of 2 for multi-condition type',
+    }, // Max nested depth of 2
+  );
+
+export type IfThenElseConditionProps = z.infer<
+  typeof ifThenElseConditionSchema
+>;
+
+export class IfThenElseCondition extends Condition {
+  constructor(value: OmitConditionType<IfThenElseConditionProps>) {
+    super(sequentialConditionSchema, {
+      conditionType: IfThenElseConditionType,
+      ...value,
+    });
+  }
+}

packages/taco/src/conditions/multi-condition.ts

@@ -1,13 +1,17 @@
+import { boolean } from 'zod';
+
 import { CompoundConditionType } from './compound-condition';
 import { ConditionProps } from './condition';
+import { IfThenElseConditionType } from './if-then-else-condition';
 import { ConditionVariableProps, SequentialConditionType } from './sequential';
 
 export const maxNestedDepth =
   (maxDepth: number) =>
-  (condition: ConditionProps, currentDepth = 1) => {
+  (condition: ConditionProps, currentDepth = 1): boolean => {
     if (
       condition.conditionType === CompoundConditionType ||
-      condition.conditionType === SequentialConditionType
+      condition.conditionType === SequentialConditionType ||
+      condition.conditionType === IfThenElseConditionType
     ) {
       if (currentDepth > maxDepth) {
         // no more multi-condition types allowed at this level
@@ -18,11 +22,20 @@ export const maxNestedDepth =
         return condition.operands.every((child: ConditionProps) =>
           maxNestedDepth(maxDepth)(child, currentDepth + 1),
         );
-      } else {
+      } else if (condition.conditionType == SequentialConditionType) {
         return condition.conditionVariables.every(
           (child: ConditionVariableProps) =>
             maxNestedDepth(maxDepth)(child.condition, currentDepth + 1),
         );
+      } else {
+        // do something
+        const ifThenElseConditions = [];
+        ifThenElseConditions.push(condition.ifCondition);
+        ifThenElseConditions.push(condition.thenCondition);
+        if (!(condition.elseCondition instanceof boolean)) {
+          ifThenElseConditions.push(condition.elseCondition);
+        }
+        return maxNestedDepth(maxDepth)(ifThenElseConditions, currentDepth + 1);
       }
     }
 

packages/taco/src/conditions/sequential.ts

@@ -5,6 +5,7 @@ import { rpcConditionSchema } from './base/rpc';
 import { timeConditionSchema } from './base/time';
 import { compoundConditionSchema } from './compound-condition';
 import { baseConditionSchema, Condition } from './condition';
+import { ifThenElseConditionSchema } from './if-then-else-condition';
 import { maxNestedDepth } from './multi-condition';
 import { OmitConditionType, plainStringSchema } from './shared';
 
@@ -19,6 +20,7 @@ export const conditionVariableSchema: z.ZodSchema = z.object({
       contractConditionSchema,
       compoundConditionSchema,
       sequentialConditionSchema,
+      ifThenElseConditionSchema,
     ]),
   ),
 });