Binary expression

scripts/lib/buildExpressionContainer.ts

@@ -5,15 +5,18 @@ import {
   ExpressionParams,
   FunctionExpressionParams,
   ConditionalExpressionParams,
-  VariableExpressionParams
+  VariableExpressionParams,
+  BinaryExpressionParams
 } from 'src/types/ExpressionParamTypes'
 import {
   NonExecutableStepCall,
   StepChild,
   StepFunction,
   StepConditional,
+  StepBinary,
   StepVariable
 } from 'src/types/ExpressionTypes'
+import calculateNumLeafNodes from 'scripts/lib/calculateNumLeafNodes'
 
 export default function buildExpressionContainer(
   expressionParams: VariableExpressionParams
@@ -27,14 +30,19 @@ export default function buildExpressionContainer(
 export default function buildExpressionContainer(
   expressionParams: ConditionalExpressionParams
 ): ContainerWithState<'needsPrioritize', StepConditional>
+export default function buildExpressionContainer(
+  expressionParams: BinaryExpressionParams
+): ContainerWithState<'needsPrioritize', StepBinary>
 export default function buildExpressionContainer(
   expressionParams: ExpressionParams
 ): ContainerWithState<'needsPrioritize', StepChild>
 export default function buildExpressionContainer(
   expressionParams: ExpressionParams
 ): ContainerWithState<'needsPrioritize', StepChild> {
+  const expression = buildExpressionFromParams(expressionParams)
   return {
-    expression: buildExpressionFromParams(expressionParams),
+    expression,
+    numLeafNodes: calculateNumLeafNodes(expression),
     containerState: 'needsPrioritize',
     previouslyChangedExpressionState: 'default'
   }

scripts/lib/buildExpressionContainers.ts

@@ -13,6 +13,7 @@ const buildExpressionContainers = ({
   showAllShowSteps,
   skipAlphaConvert,
   skipActive,
+  showDefaultAndActiveOnly,
   skipToTheEnd,
   hideControls,
   lastAllowedExpressionState,
@@ -116,7 +117,16 @@ const buildExpressionContainers = ({
       }
     }
 
-    return results
+    if (showDefaultAndActiveOnly) {
+      return results.filter(
+        x =>
+          x.previouslyChangedExpressionState === 'conditionActive' ||
+          x.previouslyChangedExpressionState === 'default' ||
+          x.previouslyChangedExpressionState === 'active'
+      )
+    } else {
+      return results
+    }
   } else if (initialExpressionContainers) {
     return initialExpressionContainers
   } else {

scripts/lib/buildExpressionFromParams.ts

@@ -7,7 +7,8 @@ import {
   isConditionalParams,
   isVariableShorthandFuncParams,
   isQuestionPlusOrMinusOneParams,
-  isQuestionShorthandNumberAfterConvertParams
+  isQuestionShorthandNumberAfterConvertParams,
+  isRepeatExpressionParams
 } from 'scripts/lib/expressionParamGuards'
 import {
   CallExpressionParams,
@@ -20,7 +21,8 @@ import {
   RepeatExpressionParams,
   QuestionPlusOrMinusOneParams,
   QuestionShorthandNumberAfterConvertParams,
-  VariableShorthandFuncParams
+  VariableShorthandFuncParams,
+  BinaryExpressionParams
 } from 'src/types/ExpressionParamTypes'
 import {
   NonExecutableStepCall,
@@ -29,6 +31,7 @@ import {
   StepVariable,
   StepVariableShorthandNumber,
   StepConditional,
+  StepBinary,
   RepeatExpression
 } from 'src/types/ExpressionTypes'
 import { VariableNames } from 'src/types/VariableNames'
@@ -89,6 +92,9 @@ export default function buildExpressionFromParams(
 export default function buildExpressionFromParams(
   expressionParams: ConditionalExpressionParams
 ): StepConditional
+export default function buildExpressionFromParams(
+  expressionParams: BinaryExpressionParams
+): StepBinary
 export default function buildExpressionFromParams(
   expressionParams: RepeatExpressionParams
 ): RepeatExpression
@@ -192,12 +198,21 @@ export default function buildExpressionFromParams(
       ),
       shorthandNumberAfterConvert: expressionParams.shorthandNumberAfterConvert
     }
-  } else {
+  } else if (isRepeatExpressionParams(expressionParams)) {
     return {
       type: 'repeat',
       count: expressionParams.count,
       countVariable: expressionParams.countVariable,
       child: buildExpressionFromParams(expressionParams.child)
     }
+  } else {
+    return {
+      type: 'binary',
+      binaryType: expressionParams.binaryType,
+      first: buildExpressionFromParams(expressionParams.first),
+      second: buildExpressionFromParams(expressionParams.second),
+      state: 'default',
+      priority: 0
+    }
   }
 }

scripts/lib/buildExpressionRunnerConfigFromShorthand.ts

@@ -9,7 +9,6 @@ import {
   isExpressionRunnerSingleStepConfig
 } from 'scripts/lib/expressionRunnerShorthandConfig'
 import { ExpressionContainer } from 'src/types/ExpressionContainerTypes'
-import { allMaxWidths } from 'src/lib/theme/maxWidths'
 import {
   InitializeInstruction,
   ExpressionRunnerContextProps,
@@ -25,16 +24,15 @@ export interface ExpressionRunnerConfig {
   hideBottomRightBadges: ExpressionRunnerContextProps['hideBottomRightBadges']
   hideControls: boolean
   explanationsVisibility: 'visible' | 'hidden' | 'hiddenInitialPausedOnly'
-  variableSize: ExpressionRunnerContextProps['variableSize']
   initializeInstructions: readonly InitializeInstruction[]
   lastAllowedExpressionState?: ExpressionContainer['previouslyChangedExpressionState']
   lastAllowedExpressionStateAfterIterations?: number
-  containerSize: keyof typeof allMaxWidths
   hidePlayButton?: boolean
   speed: number
   showAllShowSteps?: boolean
   skipAlphaConvert?: boolean
   skipActive?: boolean
+  showDefaultAndActiveOnly?: boolean
   skipToTheEnd: boolean
   hideFuncUnboundBadgeOnExplanation: boolean
   highlightOverridesCallArgAndFuncUnboundOnly: boolean
@@ -51,9 +49,7 @@ const expressionRunnerDefaults = {
   hideBottomRightBadges: expressionRunnerContextDefault.hideBottomRightBadges,
   hideControls: false,
   explanationsVisibility: 'visible',
-  variableSize: expressionRunnerContextDefault.variableSize,
   initializeInstructions: [],
-  containerSize: 'xxs',
   skipToTheEnd: false,
   hidePlayButton: false,
   speed: 1,
@@ -119,13 +115,12 @@ const buildExpressionRunnerConfigFromShorthand = (
       isDone,
       skipAlphaConvert,
       skipActive,
+      showDefaultAndActiveOnly,
       nextIterations,
       showPriorities,
       showAllShowSteps,
       explanationsVisibility,
       bottomRightBadgeOverrides,
-      variableSize,
-      containerSize,
       highlightOverrides,
       highlightOverrideActiveAfterStart,
       highlightOverridesCallArgAndFuncUnboundOnly,
@@ -142,11 +137,10 @@ const buildExpressionRunnerConfigFromShorthand = (
       hidePriorities: !showPriorities,
       explanationsVisibility,
       showAllShowSteps,
-      variableSize,
       highlightOverridesCallArgAndFuncUnboundOnly,
-      containerSize,
       skipAlphaConvert,
       skipActive,
+      showDefaultAndActiveOnly,
       bottomRightBadgeOverrides,
       highlightOverrides,
       highlightFunctions,
@@ -172,8 +166,7 @@ const buildExpressionRunnerConfigFromShorthand = (
       speed,
       skipAlphaConvert,
       skipActive,
-      variableSize,
-      containerSize,
+      showDefaultAndActiveOnly,
       highlightOverrides,
       explanationsVisibility
     } = mergeWithDefault<
@@ -189,10 +182,9 @@ const buildExpressionRunnerConfigFromShorthand = (
       showAllShowSteps,
       hideFuncUnboundBadgeOnExplanation,
       skipToTheEnd,
-      variableSize,
-      containerSize,
       skipAlphaConvert,
       skipActive,
+      showDefaultAndActiveOnly,
       explanationsVisibility:
         explanationsVisibility || 'hiddenInitialPausedOnly',
       lastAllowedExpressionState,
@@ -211,18 +203,15 @@ const buildExpressionRunnerConfigFromShorthand = (
       showPriorities,
       explanationsVisibility,
       showAllShowSteps,
-      variableSize,
-      containerSize,
       nextIterations,
-      skipActive
+      skipActive,
+      showDefaultAndActiveOnly
     } = mergeWithDefault<
       typeof config,
       typeof expressionRunnerSingleStepConfigDefault
     >(config, expressionRunnerSingleStepConfigDefault)
 
     runnerProps = {
-      variableSize,
-      containerSize,
       initialExpressionContainer,
       hidePriorities: !showPriorities,
       hideFuncUnboundBadgeOnExplanation,
@@ -232,6 +221,7 @@ const buildExpressionRunnerConfigFromShorthand = (
       lastAllowedExpressionStateAfterIterations: nextIterations,
       showAllShowSteps,
       skipActive,
+      showDefaultAndActiveOnly,
       initializeInstructions: buildInitializeInstructions({
         nextIterations,
         initialState
@@ -244,8 +234,6 @@ const buildExpressionRunnerConfigFromShorthand = (
       showPriorities,
       explanationsVisibility,
       showAllShowSteps,
-      variableSize,
-      containerSize,
       nextIterations,
       skipToTheEnd,
       convert
@@ -256,8 +244,6 @@ const buildExpressionRunnerConfigFromShorthand = (
 
     runnerProps = {
       initialExpressionContainers,
-      variableSize,
-      containerSize,
       hidePriorities: !showPriorities,
       hideFuncUnboundBadgeOnExplanation,
       hidePlayButton: false,

scripts/lib/calculateNumLeafNodes.ts

@@ -0,0 +1,38 @@
+import {
+  isCall,
+  isVariable,
+  isFunction,
+  isConditional,
+  isBinary
+} from 'src/lib/expressionTypeGuards'
+import { Expression } from 'src/types/ExpressionTypes'
+
+export default function calculateNumLeafNodes(expression: Expression): number {
+  if (isVariable(expression)) {
+    if (expression.shorthandNumberAfterConvert !== undefined) {
+      return 2
+    } else {
+      return 1
+    }
+  } else if (isCall(expression)) {
+    return (
+      calculateNumLeafNodes(expression.arg) +
+      calculateNumLeafNodes(expression.func)
+    )
+  } else if (isFunction(expression)) {
+    return calculateNumLeafNodes(expression.body)
+  } else if (isConditional(expression)) {
+    return (
+      calculateNumLeafNodes(expression.condition) +
+      calculateNumLeafNodes(expression.trueCase) +
+      calculateNumLeafNodes(expression.falseCase)
+    )
+  } else if (isBinary(expression)) {
+    return (
+      calculateNumLeafNodes(expression.first) +
+      calculateNumLeafNodes(expression.second)
+    )
+  } else {
+    return calculateNumLeafNodes(expression.child)
+  }
+}

scripts/lib/expressionParamGuards.ts

@@ -8,7 +8,8 @@ import {
   ConditionalExpressionParams,
   VariableShorthandFuncParams,
   QuestionPlusOrMinusOneParams,
-  QuestionShorthandNumberAfterConvertParams
+  QuestionShorthandNumberAfterConvertParams,
+  RepeatExpressionParams
 } from 'src/types/ExpressionParamTypes'
 
 export function isHighlightedVariableExpressionParams(
@@ -85,3 +86,9 @@ export function isQuestionShorthandNumberAfterConvertParams(
   return !!(expressionParams as QuestionShorthandNumberAfterConvertParams)
     .shorthandNumberAfterConvert
 }
+
+export function isRepeatExpressionParams(
+  expressionParams: ExpressionParams
+): expressionParams is RepeatExpressionParams {
+  return !!(expressionParams as RepeatExpressionParams).child
+}

scripts/lib/expressionRunnerShorthandConfig.ts

@@ -7,7 +7,6 @@ export const expressionRunnerSimpleConfigDefault = {
   initialState: 'default',
   showPriorities: false,
   explanationsVisibility: 'hidden',
-  variableSize: 'lg',
   skipAlphaConvert: false
 }
 
@@ -18,13 +17,12 @@ interface ExpressionRunnerSimpleConfig {
   isDone?: boolean
   skipAlphaConvert?: boolean
   skipActive?: boolean
+  showDefaultAndActiveOnly?: boolean
   nextIterations?: number
   showPriorities?: boolean
   showAllShowSteps?: ExpressionRunnerProps['showAllShowSteps']
   explanationsVisibility?: ExpressionRunnerProps['explanationsVisibility']
   bottomRightBadgeOverrides?: ExpressionRunnerProps['bottomRightBadgeOverrides']
-  variableSize?: ExpressionRunnerProps['variableSize']
-  containerSize?: ExpressionRunnerProps['containerSize']
   highlightOverrides?: ExpressionRunnerProps['highlightOverrides']
   highlightOverrideActiveAfterStart?: ExpressionRunnerProps['highlightOverrideActiveAfterStart']
   highlightOverridesCallArgAndFuncUnboundOnly?: ExpressionRunnerProps['highlightOverridesCallArgAndFuncUnboundOnly']
@@ -45,7 +43,6 @@ export const expressionRunnerPlayButtonOnlyConfigDefault = {
   showPriorities: false,
   speed: 1,
   skipAlphaConvert: false,
-  variableSize: 'lg',
   explanationsVisibility: 'hiddenInitialPausedOnly'
 }
 
@@ -69,17 +66,15 @@ interface ExpressionRunnerPlayButtonOnlyConfig {
   speed?: number
   skipAlphaConvert?: boolean
   skipActive?: boolean
-  variableSize?: ExpressionRunnerProps['variableSize']
-  containerSize?: ExpressionRunnerProps['containerSize']
+  showDefaultAndActiveOnly?: boolean
   highlightOverrides?: ExpressionRunnerProps['highlightOverrides']
   explanationsVisibility?: ExpressionRunnerProps['explanationsVisibility']
 }
 
 export const expressionRunnerSingleStepConfigDefault = {
   hideFuncUnboundBadgeOnExplanation: false,
   showPriorities: false,
-  explanationsVisibility: 'hiddenInitialPausedOnly',
-  variableSize: 'lg'
+  explanationsVisibility: 'hiddenInitialPausedOnly'
 }
 
 export function isExpressionRunnerSingleStepConfig(
@@ -96,9 +91,8 @@ interface ExpressionRunnerSingleStepConfig {
   hideFuncUnboundBadgeOnExplanation?: boolean
   showPriorities?: boolean
   skipActive?: boolean
+  showDefaultAndActiveOnly?: boolean
   nextIterations?: number
-  variableSize?: ExpressionRunnerProps['variableSize']
-  containerSize?: ExpressionRunnerProps['containerSize']
   explanationsVisibility?: ExpressionRunnerProps['explanationsVisibility']
   showAllShowSteps?: ExpressionRunnerProps['showAllShowSteps']
 }
@@ -113,7 +107,6 @@ export const expressionRunnerPredefinedConfigDefault = {
   hideFuncUnboundBadgeOnExplanation: false,
   showPriorities: false,
   explanationsVisibility: 'hiddenInitialPausedOnly',
-  variableSize: 'lg',
   skipToTheEnd: true
 }
 
@@ -123,8 +116,6 @@ interface ExpressionRunnerPredefinedConfig {
   hideFuncUnboundBadgeOnExplanation?: boolean
   showPriorities?: boolean
   nextIterations?: number
-  variableSize?: ExpressionRunnerProps['variableSize']
-  containerSize?: ExpressionRunnerProps['containerSize']
   explanationsVisibility?: ExpressionRunnerProps['explanationsVisibility']
   showAllShowSteps?: ExpressionRunnerProps['showAllShowSteps']
   skipToTheEnd?: boolean