From c99cee1305198df0185cbef159d579fbabc96054 Mon Sep 17 00:00:00 2001 From: burstein Date: Fri, 25 Oct 2024 16:07:47 +0300 Subject: [PATCH] Added div-switch in scheme commit_hash:8603f98382fbe5cefd0cb43e8949940dbb572894 --- .mapping.json | 30 + .../com/yandex/div/core/state/DivPathUtils.kt | 1 + .../com/yandex/div/core/util/DivTreeWalk.kt | 1 + .../java/com/yandex/div/core/util/DivUtil.kt | 4 + .../com/yandex/div/core/view2/DivBinder.kt | 2 + .../yandex/div/core/view2/DivViewCreator.kt | 2 + .../core/view2/animations/DivComparator.kt | 1 + .../div/core/view2/reuse/ExistingToken.kt | 1 + .../yandex/div/core/view2/reuse/NewToken.kt | 1 + .../internal/core/DivCollectionExtensions.kt | 1 + .../yandex/div/internal/core/DivVisitor.kt | 1 + .../DivContainer+Accessibility.swift | 1 + .../DivData/DivDataPatchExtensions.swift | 1 + .../ios/DivKit/Extensions/DivExtensions.swift | 1 + .../Extensions/DivSwitchExtensions.swift | 29 + client/ios/DivKit/generated_sources/Div.swift | 7 + .../DivKit/generated_sources/DivSwitch.swift | 300 ++++++ .../generated_sources/DivSwitchTemplate.swift | 879 ++++++++++++++++++ .../generated_sources/DivTemplate.swift | 27 + .../ios/DivKitExtensions/DivExtensions.swift | 1 + .../LayoutKit/Blocks/SwitchBlock.swift | 18 +- .../SwitchBlock+UIViewRenderableBlock.swift | 5 +- .../base-properties_375@2x_step0.png | Bin 0 -> 2334 bytes .../base-properties_375@2x_step1.png | Bin 0 -> 2337 bytes .../base-properties_375@2x_step2.png | Bin 0 -> 2793 bytes .../base-properties_375@2x_step3.png | Bin 0 -> 3978 bytes .../base-properties_375@2x_step4.png | Bin 0 -> 3978 bytes .../base-properties_375@2x_step5.png | Bin 0 -> 3978 bytes .../base-properties_375@2x_step6.png | Bin 0 -> 5862 bytes .../base-properties_375@2x_step7.png | Bin 0 -> 4897 bytes .../base-properties_414@3x_step0.png | Bin 0 -> 3719 bytes .../base-properties_414@3x_step1.png | Bin 0 -> 3749 bytes .../base-properties_414@3x_step2.png | Bin 0 -> 4870 bytes .../base-properties_414@3x_step3.png | Bin 0 -> 7071 bytes .../base-properties_414@3x_step4.png | Bin 0 -> 7071 bytes .../base-properties_414@3x_step5.png | Bin 0 -> 7071 bytes .../base-properties_414@3x_step6.png | Bin 0 -> 10430 bytes .../base-properties_414@3x_step7.png | Bin 0 -> 8416 bytes .../switch-properties_375@2x_step0.png | Bin 0 -> 2878 bytes .../switch-properties_375@2x_step1.png | Bin 0 -> 2593 bytes .../switch-properties_375@2x_step2.png | Bin 0 -> 2866 bytes .../switch-properties_375@2x_step3.png | Bin 0 -> 2652 bytes .../switch-properties_414@3x_step0.png | Bin 0 -> 4583 bytes .../switch-properties_414@3x_step1.png | Bin 0 -> 4432 bytes .../switch-properties_414@3x_step2.png | Bin 0 -> 4512 bytes .../switch-properties_414@3x_step3.png | Bin 0 -> 4246 bytes schema/div-switch.json | 38 + schema/div.json | 4 + schema/translations.json | 20 + .../div-switch/base-properties.json | 244 +++++ .../div-switch/switch-properties.json | 68 ++ 51 files changed, 1684 insertions(+), 4 deletions(-) create mode 100644 client/ios/DivKit/Extensions/DivSwitchExtensions.swift create mode 100644 client/ios/DivKit/generated_sources/DivSwitch.swift create mode 100644 client/ios/DivKit/generated_sources/DivSwitchTemplate.swift create mode 100644 client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step0.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step1.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step2.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step3.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step4.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step5.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step6.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step7.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step0.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step1.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step2.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step3.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step4.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step5.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step6.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step7.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/switch-properties_375@2x_step0.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/switch-properties_375@2x_step1.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/switch-properties_375@2x_step2.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/switch-properties_375@2x_step3.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/switch-properties_414@3x_step0.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/switch-properties_414@3x_step1.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/switch-properties_414@3x_step2.png create mode 100644 client/ios/Tests/reference_snapshots/div-switch/switch-properties_414@3x_step3.png create mode 100644 schema/div-switch.json create mode 100644 test_data/interactive_snapshot_test_data/div-switch/base-properties.json create mode 100644 test_data/interactive_snapshot_test_data/div-switch/switch-properties.json diff --git a/.mapping.json b/.mapping.json index b102db490..94ad48e34 100644 --- a/.mapping.json +++ b/.mapping.json @@ -11464,6 +11464,7 @@ "client/ios/DivKit/Extensions/DivSizeUnitExtensions.swift":"divkit/public/client/ios/DivKit/Extensions/DivSizeUnitExtensions.swift", "client/ios/DivKit/Extensions/DivSliderExtensions.swift":"divkit/public/client/ios/DivKit/Extensions/DivSliderExtensions.swift", "client/ios/DivKit/Extensions/DivStateExtensions.swift":"divkit/public/client/ios/DivKit/Extensions/DivStateExtensions.swift", + "client/ios/DivKit/Extensions/DivSwitchExtensions.swift":"divkit/public/client/ios/DivKit/Extensions/DivSwitchExtensions.swift", "client/ios/DivKit/Extensions/DivTabsExtensions.swift":"divkit/public/client/ios/DivKit/Extensions/DivTabsExtensions.swift", "client/ios/DivKit/Extensions/DivTextExtensions.swift":"divkit/public/client/ios/DivKit/Extensions/DivTextExtensions.swift", "client/ios/DivKit/Extensions/DivTooltipExtensions.swift":"divkit/public/client/ios/DivKit/Extensions/DivTooltipExtensions.swift", @@ -11795,6 +11796,8 @@ "client/ios/DivKit/generated_sources/DivStretchIndicatorItemPlacementTemplate.swift":"divkit/public/client/ios/DivKit/generated_sources/DivStretchIndicatorItemPlacementTemplate.swift", "client/ios/DivKit/generated_sources/DivStroke.swift":"divkit/public/client/ios/DivKit/generated_sources/DivStroke.swift", "client/ios/DivKit/generated_sources/DivStrokeTemplate.swift":"divkit/public/client/ios/DivKit/generated_sources/DivStrokeTemplate.swift", + "client/ios/DivKit/generated_sources/DivSwitch.swift":"divkit/public/client/ios/DivKit/generated_sources/DivSwitch.swift", + "client/ios/DivKit/generated_sources/DivSwitchTemplate.swift":"divkit/public/client/ios/DivKit/generated_sources/DivSwitchTemplate.swift", "client/ios/DivKit/generated_sources/DivTabs.swift":"divkit/public/client/ios/DivKit/generated_sources/DivTabs.swift", "client/ios/DivKit/generated_sources/DivTabsTemplate.swift":"divkit/public/client/ios/DivKit/generated_sources/DivTabsTemplate.swift", "client/ios/DivKit/generated_sources/DivTemplate.swift":"divkit/public/client/ios/DivKit/generated_sources/DivTemplate.swift", @@ -13917,6 +13920,30 @@ "client/ios/Tests/reference_snapshots/div-states/borders_414@3x.png":"divkit/public/client/ios/Tests/reference_snapshots/div-states/borders_414@3x.png", "client/ios/Tests/reference_snapshots/div-states/default-state_375@2x.png":"divkit/public/client/ios/Tests/reference_snapshots/div-states/default-state_375@2x.png", "client/ios/Tests/reference_snapshots/div-states/default-state_414@3x.png":"divkit/public/client/ios/Tests/reference_snapshots/div-states/default-state_414@3x.png", + "client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step0.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step0.png", + "client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step1.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step1.png", + "client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step2.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step2.png", + "client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step3.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step3.png", + "client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step4.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step4.png", + "client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step5.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step5.png", + "client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step6.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step6.png", + "client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step7.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step7.png", + "client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step0.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step0.png", + "client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step1.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step1.png", + "client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step2.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step2.png", + "client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step3.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step3.png", + "client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step4.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step4.png", + "client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step5.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step5.png", + "client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step6.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step6.png", + "client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step7.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step7.png", + "client/ios/Tests/reference_snapshots/div-switch/switch-properties_375@2x_step0.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/switch-properties_375@2x_step0.png", + "client/ios/Tests/reference_snapshots/div-switch/switch-properties_375@2x_step1.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/switch-properties_375@2x_step1.png", + "client/ios/Tests/reference_snapshots/div-switch/switch-properties_375@2x_step2.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/switch-properties_375@2x_step2.png", + "client/ios/Tests/reference_snapshots/div-switch/switch-properties_375@2x_step3.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/switch-properties_375@2x_step3.png", + "client/ios/Tests/reference_snapshots/div-switch/switch-properties_414@3x_step0.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/switch-properties_414@3x_step0.png", + "client/ios/Tests/reference_snapshots/div-switch/switch-properties_414@3x_step1.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/switch-properties_414@3x_step1.png", + "client/ios/Tests/reference_snapshots/div-switch/switch-properties_414@3x_step2.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/switch-properties_414@3x_step2.png", + "client/ios/Tests/reference_snapshots/div-switch/switch-properties_414@3x_step3.png":"divkit/public/client/ios/Tests/reference_snapshots/div-switch/switch-properties_414@3x_step3.png", "client/ios/Tests/reference_snapshots/div-tabs/corners_radius_375@2x.png":"divkit/public/client/ios/Tests/reference_snapshots/div-tabs/corners_radius_375@2x.png", "client/ios/Tests/reference_snapshots/div-tabs/corners_radius_414@3x.png":"divkit/public/client/ios/Tests/reference_snapshots/div-tabs/corners_radius_414@3x.png", "client/ios/Tests/reference_snapshots/div-tabs/custom-background-border_375@2x.png":"divkit/public/client/ios/Tests/reference_snapshots/div-tabs/custom-background-border_375@2x.png", @@ -17471,6 +17498,7 @@ "schema/div-state.json":"divkit/public/schema/div-state.json", "schema/div-stretch-indicator-item-placement.json":"divkit/public/schema/div-stretch-indicator-item-placement.json", "schema/div-stroke.json":"divkit/public/schema/div-stroke.json", + "schema/div-switch.json":"divkit/public/schema/div-switch.json", "schema/div-tabs.json":"divkit/public/schema/div-tabs.json", "schema/div-text-alignment-vertical.json":"divkit/public/schema/div-text-alignment-vertical.json", "schema/div-text-gradient.json":"divkit/public/schema/div-text-gradient.json", @@ -17725,6 +17753,8 @@ "test_data/interactive_snapshot_test_data/div-slider/visibility.json":"divkit/public/test_data/interactive_snapshot_test_data/div-slider/visibility.json", "test_data/interactive_snapshot_test_data/div-state/base-properties.json":"divkit/public/test_data/interactive_snapshot_test_data/div-state/base-properties.json", "test_data/interactive_snapshot_test_data/div-state/visibility.json":"divkit/public/test_data/interactive_snapshot_test_data/div-state/visibility.json", + "test_data/interactive_snapshot_test_data/div-switch/base-properties.json":"divkit/public/test_data/interactive_snapshot_test_data/div-switch/base-properties.json", + "test_data/interactive_snapshot_test_data/div-switch/switch-properties.json":"divkit/public/test_data/interactive_snapshot_test_data/div-switch/switch-properties.json", "test_data/interactive_snapshot_test_data/div-tabs/select-elements.json":"divkit/public/test_data/interactive_snapshot_test_data/div-tabs/select-elements.json", "test_data/interactive_snapshot_test_data/div-text/background-image-blur.json":"divkit/public/test_data/interactive_snapshot_test_data/div-text/background-image-blur.json", "test_data/interactive_snapshot_test_data/div-text/text-properties.json":"divkit/public/test_data/interactive_snapshot_test_data/div-text/text-properties.json", diff --git a/client/android/div/src/main/java/com/yandex/div/core/state/DivPathUtils.kt b/client/android/div/src/main/java/com/yandex/div/core/state/DivPathUtils.kt index 67e78f24f..cdab0640c 100644 --- a/client/android/div/src/main/java/com/yandex/div/core/state/DivPathUtils.kt +++ b/client/android/div/src/main/java/com/yandex/div/core/state/DivPathUtils.kt @@ -121,6 +121,7 @@ internal object DivPathUtils { is Div.Separator -> null is Div.Select -> null is Div.Video -> null + is Div.Switch -> null } } diff --git a/client/android/div/src/main/java/com/yandex/div/core/util/DivTreeWalk.kt b/client/android/div/src/main/java/com/yandex/div/core/util/DivTreeWalk.kt index c0d7841a7..c6f8003ae 100644 --- a/client/android/div/src/main/java/com/yandex/div/core/util/DivTreeWalk.kt +++ b/client/android/div/src/main/java/com/yandex/div/core/util/DivTreeWalk.kt @@ -172,6 +172,7 @@ private fun Div.getItems(resolver: ExpressionResolver): List emptyList() is Div.Select -> emptyList() is Div.Video -> emptyList() + is Div.Switch -> emptyList() is Div.Container -> value.buildItems(resolver) is Div.Grid -> value.itemsToDivItemBuilderResult(resolver) is Div.Gallery -> value.buildItems(resolver) diff --git a/client/android/div/src/main/java/com/yandex/div/core/util/DivUtil.kt b/client/android/div/src/main/java/com/yandex/div/core/util/DivUtil.kt index 6f64d7c9e..3a46389c5 100644 --- a/client/android/div/src/main/java/com/yandex/div/core/util/DivUtil.kt +++ b/client/android/div/src/main/java/com/yandex/div/core/util/DivUtil.kt @@ -35,6 +35,7 @@ import com.yandex.div2.DivSelect import com.yandex.div2.DivSeparator import com.yandex.div2.DivSlider import com.yandex.div2.DivState +import com.yandex.div2.DivSwitch import com.yandex.div2.DivTabs import com.yandex.div2.DivText import com.yandex.div2.DivVariable @@ -60,6 +61,7 @@ internal val Div.type: String is Div.Tabs -> DivTabs.TYPE is Div.Custom -> DivCustom.TYPE is Div.Select -> DivSelect.TYPE + is Div.Switch -> DivSwitch.TYPE } } @@ -176,6 +178,7 @@ internal fun Div.containsStateInnerTransitions(resolver: ExpressionResolver): Bo is Div.Slider -> false is Div.Video -> false is Div.Input -> false + is Div.Switch -> false } } @@ -197,6 +200,7 @@ internal val Div.isBranch: Boolean is Div.Custom -> false is Div.Select -> false is Div.Video -> false + is Div.Switch -> false is Div.Container -> true is Div.Grid -> true is Div.Gallery -> true diff --git a/client/android/div/src/main/java/com/yandex/div/core/view2/DivBinder.kt b/client/android/div/src/main/java/com/yandex/div/core/view2/DivBinder.kt index 1d716da17..e68e3487e 100644 --- a/client/android/div/src/main/java/com/yandex/div/core/view2/DivBinder.kt +++ b/client/android/div/src/main/java/com/yandex/div/core/view2/DivBinder.kt @@ -124,6 +124,7 @@ internal class DivBinder @Inject constructor( is Div.Input -> bindInput(context, view, div.value, path) is Div.Select -> bindSelect(context, view, div.value, path) is Div.Video -> bindVideo(context, view, div.value, path) + is Div.Switch -> Unit }.also { // extensionController bound new CustomView in DivCustomBinder after replacing in parent if (div !is Div.Custom) { @@ -222,6 +223,7 @@ internal class DivBinder @Inject constructor( is Div.Input -> (view as DivInputView).setDataWithoutBinding(context, div.value) is Div.Select -> (view as DivSelectView).setDataWithoutBinding(context, div.value) is Div.Video -> (view as DivVideoView).setDataWithoutBinding(context, div.value) + is Div.Switch -> Unit } private fun DivHolderView.setDataWithoutBinding(context: BindingContext, newDiv: T) { diff --git a/client/android/div/src/main/java/com/yandex/div/core/view2/DivViewCreator.kt b/client/android/div/src/main/java/com/yandex/div/core/view2/DivViewCreator.kt index 1fc9ff7a8..019970ff5 100644 --- a/client/android/div/src/main/java/com/yandex/div/core/view2/DivViewCreator.kt +++ b/client/android/div/src/main/java/com/yandex/div/core/view2/DivViewCreator.kt @@ -152,6 +152,7 @@ internal class DivViewCreator @Inject constructor( const val TAG_SLIDER = "DIV2.SLIDER" const val TAG_INPUT = "DIV2.INPUT" const val TAG_SELECT = "DIV2.SELECT" + const val TAG_SWITCH = "DIV2.SWITCH" const val TAG_VIDEO = "DIV2.VIDEO" val TAGS = arrayOf( @@ -191,6 +192,7 @@ internal class DivViewCreator @Inject constructor( is Div.Pager -> TAG_PAGER is Div.Select -> TAG_SELECT is Div.Slider -> TAG_SLIDER + is Div.Switch -> TAG_SWITCH is Div.State -> TAG_STATE is Div.Tabs -> TAG_TABS is Div.Text -> TAG_TEXT diff --git a/client/android/div/src/main/java/com/yandex/div/core/view2/animations/DivComparator.kt b/client/android/div/src/main/java/com/yandex/div/core/view2/animations/DivComparator.kt index b1644d9c3..381476695 100644 --- a/client/android/div/src/main/java/com/yandex/div/core/view2/animations/DivComparator.kt +++ b/client/android/div/src/main/java/com/yandex/div/core/view2/animations/DivComparator.kt @@ -123,6 +123,7 @@ internal object DivComparator { is Div.Indicator -> emptyList() is Div.Slider -> emptyList() is Div.Video -> emptyList() + is Div.Switch -> emptyList() } } diff --git a/client/android/div/src/main/java/com/yandex/div/core/view2/reuse/ExistingToken.kt b/client/android/div/src/main/java/com/yandex/div/core/view2/reuse/ExistingToken.kt index 3bb6e94cb..0b07b1340 100644 --- a/client/android/div/src/main/java/com/yandex/div/core/view2/reuse/ExistingToken.kt +++ b/client/android/div/src/main/java/com/yandex/div/core/view2/reuse/ExistingToken.kt @@ -40,6 +40,7 @@ internal class ExistingToken( is Div.Input -> emptyList() is Div.Select -> emptyList() is Div.Video -> emptyList() + is Div.Switch -> emptyList() is Div.Container -> div.value.itemsToExistingTokenList(item.expressionResolver, parentToken) is Div.Custom -> div.value.itemsToExistingTokenList(item.expressionResolver, parentToken) is Div.Grid -> div.value.itemsToExistingTokenList(item.expressionResolver, parentToken) diff --git a/client/android/div/src/main/java/com/yandex/div/core/view2/reuse/NewToken.kt b/client/android/div/src/main/java/com/yandex/div/core/view2/reuse/NewToken.kt index ba0b1eb21..05a75f7b6 100644 --- a/client/android/div/src/main/java/com/yandex/div/core/view2/reuse/NewToken.kt +++ b/client/android/div/src/main/java/com/yandex/div/core/view2/reuse/NewToken.kt @@ -27,6 +27,7 @@ internal class NewToken( is Div.Input -> listOf() is Div.Select -> listOf() is Div.Video -> listOf() + is Div.Switch -> listOf() is Div.Container -> div.value.buildItems(resolver).itemsToNewTokenList() is Div.Custom -> div.value.nonNullItems.toDivItemBuilderResult(resolver).itemsToNewTokenList() is Div.Grid -> div.value.itemsToDivItemBuilderResult(resolver).itemsToNewTokenList() diff --git a/client/android/div/src/main/java/com/yandex/div/internal/core/DivCollectionExtensions.kt b/client/android/div/src/main/java/com/yandex/div/internal/core/DivCollectionExtensions.kt index 74ccaf6f3..7ca7c9f3c 100644 --- a/client/android/div/src/main/java/com/yandex/div/internal/core/DivCollectionExtensions.kt +++ b/client/android/div/src/main/java/com/yandex/div/internal/core/DivCollectionExtensions.kt @@ -109,6 +109,7 @@ private fun Div.copy(id: String? = value().id): Div { is Div.Input -> Div.Input(value.copy(id = id)) is Div.Select -> Div.Select(value.copy(id = id)) is Div.Video -> Div.Video(value.copy(id = id)) + is Div.Switch -> Div.Switch(value.copy(id = id)) } } diff --git a/client/android/div/src/main/java/com/yandex/div/internal/core/DivVisitor.kt b/client/android/div/src/main/java/com/yandex/div/internal/core/DivVisitor.kt index ed28acb9b..dd62f8023 100644 --- a/client/android/div/src/main/java/com/yandex/div/internal/core/DivVisitor.kt +++ b/client/android/div/src/main/java/com/yandex/div/internal/core/DivVisitor.kt @@ -22,6 +22,7 @@ abstract class DivVisitor { is Div.Input -> visit(div, resolver) is Div.Select -> visit(div, resolver) is Div.Video -> visit(div, resolver) + is Div.Switch -> visit(div, resolver) } } diff --git a/client/ios/DivKit/Extensions/DivContainer/DivContainer+Accessibility.swift b/client/ios/DivKit/Extensions/DivContainer/DivContainer+Accessibility.swift index 927f81679..e5413d635 100644 --- a/client/ios/DivKit/Extensions/DivContainer/DivContainer+Accessibility.swift +++ b/client/ios/DivKit/Extensions/DivContainer/DivContainer+Accessibility.swift @@ -56,6 +56,7 @@ extension Div { .divSeparator, .divSlider, .divState, + .divSwitch, .divTabs, .divVideo: return accessibility?.resolveDescription(expressionResolver) diff --git a/client/ios/DivKit/Extensions/DivData/DivDataPatchExtensions.swift b/client/ios/DivKit/Extensions/DivData/DivDataPatchExtensions.swift index bd3ea16a7..2647eed7b 100644 --- a/client/ios/DivKit/Extensions/DivData/DivDataPatchExtensions.swift +++ b/client/ios/DivKit/Extensions/DivData/DivDataPatchExtensions.swift @@ -81,6 +81,7 @@ extension Div { .divSelect, .divSeparator, .divSlider, + .divSwitch, .divVideo, .divText: // no children diff --git a/client/ios/DivKit/Extensions/DivExtensions.swift b/client/ios/DivKit/Extensions/DivExtensions.swift index db80b328f..5c9a462ab 100644 --- a/client/ios/DivKit/Extensions/DivExtensions.swift +++ b/client/ios/DivKit/Extensions/DivExtensions.swift @@ -17,6 +17,7 @@ extension Div { .divSelect, .divSeparator, .divSlider, + .divSwitch, .divVideo, .divText: [] diff --git a/client/ios/DivKit/Extensions/DivSwitchExtensions.swift b/client/ios/DivKit/Extensions/DivSwitchExtensions.swift new file mode 100644 index 000000000..f9510274f --- /dev/null +++ b/client/ios/DivKit/Extensions/DivSwitchExtensions.swift @@ -0,0 +1,29 @@ +import LayoutKit + +extension DivSwitch: DivBlockModeling { + public func makeBlock(context: DivBlockModelingContext) throws -> Block { + let resolver = context.expressionResolver + let switchVariable = context.makeBinding( + variableName: isOnVariable, + defaultValue: false + ) + + return try applyBaseProperties( + to: { + SwitchBlock( + on: switchVariable, + enabled: resolveIsEnabled(resolver), + action: nil, + onTintColor: resolveOnColor(resolver) + ) + }, + context: context, + actionsHolder: nil, + customAccessibilityParams: CustomAccessibilityParams( + defaultTraits: .switchButton + ) { [unowned self] in + accessibility?.resolveDescription(resolver) + } + ) + } +} diff --git a/client/ios/DivKit/generated_sources/Div.swift b/client/ios/DivKit/generated_sources/Div.swift index da5700688..754816ac2 100644 --- a/client/ios/DivKit/generated_sources/Div.swift +++ b/client/ios/DivKit/generated_sources/Div.swift @@ -19,6 +19,7 @@ public enum Div { case divCustom(DivCustom) case divIndicator(DivIndicator) case divSlider(DivSlider) + case divSwitch(DivSwitch) case divInput(DivInput) case divSelect(DivSelect) case divVideo(DivVideo) @@ -51,6 +52,8 @@ public enum Div { return value case let .divSlider(value): return value + case let .divSwitch(value): + return value case let .divInput(value): return value case let .divSelect(value): @@ -88,6 +91,8 @@ public enum Div { return value.id case let .divSlider(value): return value.id + case let .divSwitch(value): + return value.id case let .divInput(value): return value.id case let .divSelect(value): @@ -128,6 +133,8 @@ extension Div: Equatable { return l == r case let (.divSlider(l), .divSlider(r)): return l == r + case let (.divSwitch(l), .divSwitch(r)): + return l == r case let (.divInput(l), .divInput(r)): return l == r case let (.divSelect(l), .divSelect(r)): diff --git a/client/ios/DivKit/generated_sources/DivSwitch.swift b/client/ios/DivKit/generated_sources/DivSwitch.swift new file mode 100644 index 000000000..8963c13de --- /dev/null +++ b/client/ios/DivKit/generated_sources/DivSwitch.swift @@ -0,0 +1,300 @@ +// Generated code. Do not modify. + +import Foundation +import Serialization +import VGSL + +public final class DivSwitch: DivBase { + public static let type: String = "switch" + public let accessibility: DivAccessibility? + public let alignmentHorizontal: Expression? + public let alignmentVertical: Expression? + public let alpha: Expression // constraint: number >= 0.0 && number <= 1.0; default value: 1.0 + public let animators: [DivAnimator]? + public let background: [DivBackground]? + public let border: DivBorder? + public let columnSpan: Expression? // constraint: number >= 0 + public let disappearActions: [DivDisappearAction]? + public let extensions: [DivExtension]? + public let focus: DivFocus? + public let functions: [DivFunction]? + public let height: DivSize // default value: .divWrapContentSize(DivWrapContentSize()) + public let id: String? + public let isEnabled: Expression // default value: true + public let isOnVariable: String + public let layoutProvider: DivLayoutProvider? + public let margins: DivEdgeInsets? + public let onColor: Expression? + public let paddings: DivEdgeInsets? + public let reuseId: Expression? + public let rowSpan: Expression? // constraint: number >= 0 + public let selectedActions: [DivAction]? + public let tooltips: [DivTooltip]? + public let transform: DivTransform? + public let transitionChange: DivChangeTransition? + public let transitionIn: DivAppearanceTransition? + public let transitionOut: DivAppearanceTransition? + public let transitionTriggers: [DivTransitionTrigger]? // at least 1 elements + public let variableTriggers: [DivTrigger]? + public let variables: [DivVariable]? + public let visibility: Expression // default value: visible + public let visibilityAction: DivVisibilityAction? + public let visibilityActions: [DivVisibilityAction]? + public let width: DivSize // default value: .divMatchParentSize(DivMatchParentSize()) + + public func resolveAlignmentHorizontal(_ resolver: ExpressionResolver) -> DivAlignmentHorizontal? { + resolver.resolveEnum(alignmentHorizontal) + } + + public func resolveAlignmentVertical(_ resolver: ExpressionResolver) -> DivAlignmentVertical? { + resolver.resolveEnum(alignmentVertical) + } + + public func resolveAlpha(_ resolver: ExpressionResolver) -> Double { + resolver.resolveNumeric(alpha) ?? 1.0 + } + + public func resolveColumnSpan(_ resolver: ExpressionResolver) -> Int? { + resolver.resolveNumeric(columnSpan) + } + + public func resolveIsEnabled(_ resolver: ExpressionResolver) -> Bool { + resolver.resolveNumeric(isEnabled) ?? true + } + + public func resolveOnColor(_ resolver: ExpressionResolver) -> Color? { + resolver.resolveColor(onColor) + } + + public func resolveReuseId(_ resolver: ExpressionResolver) -> String? { + resolver.resolveString(reuseId) + } + + public func resolveRowSpan(_ resolver: ExpressionResolver) -> Int? { + resolver.resolveNumeric(rowSpan) + } + + public func resolveVisibility(_ resolver: ExpressionResolver) -> DivVisibility { + resolver.resolveEnum(visibility) ?? DivVisibility.visible + } + + static let alphaValidator: AnyValueValidator = + makeValueValidator(valueValidator: { $0 >= 0.0 && $0 <= 1.0 }) + + static let columnSpanValidator: AnyValueValidator = + makeValueValidator(valueValidator: { $0 >= 0 }) + + static let rowSpanValidator: AnyValueValidator = + makeValueValidator(valueValidator: { $0 >= 0 }) + + static let transitionTriggersValidator: AnyArrayValueValidator = + makeArrayValidator(minItems: 1) + + init( + accessibility: DivAccessibility? = nil, + alignmentHorizontal: Expression? = nil, + alignmentVertical: Expression? = nil, + alpha: Expression? = nil, + animators: [DivAnimator]? = nil, + background: [DivBackground]? = nil, + border: DivBorder? = nil, + columnSpan: Expression? = nil, + disappearActions: [DivDisappearAction]? = nil, + extensions: [DivExtension]? = nil, + focus: DivFocus? = nil, + functions: [DivFunction]? = nil, + height: DivSize? = nil, + id: String? = nil, + isEnabled: Expression? = nil, + isOnVariable: String, + layoutProvider: DivLayoutProvider? = nil, + margins: DivEdgeInsets? = nil, + onColor: Expression? = nil, + paddings: DivEdgeInsets? = nil, + reuseId: Expression? = nil, + rowSpan: Expression? = nil, + selectedActions: [DivAction]? = nil, + tooltips: [DivTooltip]? = nil, + transform: DivTransform? = nil, + transitionChange: DivChangeTransition? = nil, + transitionIn: DivAppearanceTransition? = nil, + transitionOut: DivAppearanceTransition? = nil, + transitionTriggers: [DivTransitionTrigger]? = nil, + variableTriggers: [DivTrigger]? = nil, + variables: [DivVariable]? = nil, + visibility: Expression? = nil, + visibilityAction: DivVisibilityAction? = nil, + visibilityActions: [DivVisibilityAction]? = nil, + width: DivSize? = nil + ) { + self.accessibility = accessibility + self.alignmentHorizontal = alignmentHorizontal + self.alignmentVertical = alignmentVertical + self.alpha = alpha ?? .value(1.0) + self.animators = animators + self.background = background + self.border = border + self.columnSpan = columnSpan + self.disappearActions = disappearActions + self.extensions = extensions + self.focus = focus + self.functions = functions + self.height = height ?? .divWrapContentSize(DivWrapContentSize()) + self.id = id + self.isEnabled = isEnabled ?? .value(true) + self.isOnVariable = isOnVariable + self.layoutProvider = layoutProvider + self.margins = margins + self.onColor = onColor + self.paddings = paddings + self.reuseId = reuseId + self.rowSpan = rowSpan + self.selectedActions = selectedActions + self.tooltips = tooltips + self.transform = transform + self.transitionChange = transitionChange + self.transitionIn = transitionIn + self.transitionOut = transitionOut + self.transitionTriggers = transitionTriggers + self.variableTriggers = variableTriggers + self.variables = variables + self.visibility = visibility ?? .value(.visible) + self.visibilityAction = visibilityAction + self.visibilityActions = visibilityActions + self.width = width ?? .divMatchParentSize(DivMatchParentSize()) + } +} + +#if DEBUG +extension DivSwitch: Equatable { + public static func ==(lhs: DivSwitch, rhs: DivSwitch) -> Bool { + guard + lhs.accessibility == rhs.accessibility, + lhs.alignmentHorizontal == rhs.alignmentHorizontal, + lhs.alignmentVertical == rhs.alignmentVertical + else { + return false + } + guard + lhs.alpha == rhs.alpha, + lhs.animators == rhs.animators, + lhs.background == rhs.background + else { + return false + } + guard + lhs.border == rhs.border, + lhs.columnSpan == rhs.columnSpan, + lhs.disappearActions == rhs.disappearActions + else { + return false + } + guard + lhs.extensions == rhs.extensions, + lhs.focus == rhs.focus, + lhs.functions == rhs.functions + else { + return false + } + guard + lhs.height == rhs.height, + lhs.id == rhs.id, + lhs.isEnabled == rhs.isEnabled + else { + return false + } + guard + lhs.isOnVariable == rhs.isOnVariable, + lhs.layoutProvider == rhs.layoutProvider, + lhs.margins == rhs.margins + else { + return false + } + guard + lhs.onColor == rhs.onColor, + lhs.paddings == rhs.paddings, + lhs.reuseId == rhs.reuseId + else { + return false + } + guard + lhs.rowSpan == rhs.rowSpan, + lhs.selectedActions == rhs.selectedActions, + lhs.tooltips == rhs.tooltips + else { + return false + } + guard + lhs.transform == rhs.transform, + lhs.transitionChange == rhs.transitionChange, + lhs.transitionIn == rhs.transitionIn + else { + return false + } + guard + lhs.transitionOut == rhs.transitionOut, + lhs.transitionTriggers == rhs.transitionTriggers, + lhs.variableTriggers == rhs.variableTriggers + else { + return false + } + guard + lhs.variables == rhs.variables, + lhs.visibility == rhs.visibility, + lhs.visibilityAction == rhs.visibilityAction + else { + return false + } + guard + lhs.visibilityActions == rhs.visibilityActions, + lhs.width == rhs.width + else { + return false + } + return true + } +} +#endif + +extension DivSwitch: Serializable { + public func toDictionary() -> [String: ValidSerializationValue] { + var result: [String: ValidSerializationValue] = [:] + result["type"] = Self.type + result["accessibility"] = accessibility?.toDictionary() + result["alignment_horizontal"] = alignmentHorizontal?.toValidSerializationValue() + result["alignment_vertical"] = alignmentVertical?.toValidSerializationValue() + result["alpha"] = alpha.toValidSerializationValue() + result["animators"] = animators?.map { $0.toDictionary() } + result["background"] = background?.map { $0.toDictionary() } + result["border"] = border?.toDictionary() + result["column_span"] = columnSpan?.toValidSerializationValue() + result["disappear_actions"] = disappearActions?.map { $0.toDictionary() } + result["extensions"] = extensions?.map { $0.toDictionary() } + result["focus"] = focus?.toDictionary() + result["functions"] = functions?.map { $0.toDictionary() } + result["height"] = height.toDictionary() + result["id"] = id + result["is_enabled"] = isEnabled.toValidSerializationValue() + result["is_on_variable"] = isOnVariable + result["layout_provider"] = layoutProvider?.toDictionary() + result["margins"] = margins?.toDictionary() + result["on_color"] = onColor?.toValidSerializationValue() + result["paddings"] = paddings?.toDictionary() + result["reuse_id"] = reuseId?.toValidSerializationValue() + result["row_span"] = rowSpan?.toValidSerializationValue() + result["selected_actions"] = selectedActions?.map { $0.toDictionary() } + result["tooltips"] = tooltips?.map { $0.toDictionary() } + result["transform"] = transform?.toDictionary() + result["transition_change"] = transitionChange?.toDictionary() + result["transition_in"] = transitionIn?.toDictionary() + result["transition_out"] = transitionOut?.toDictionary() + result["transition_triggers"] = transitionTriggers?.map { $0.rawValue } + result["variable_triggers"] = variableTriggers?.map { $0.toDictionary() } + result["variables"] = variables?.map { $0.toDictionary() } + result["visibility"] = visibility.toValidSerializationValue() + result["visibility_action"] = visibilityAction?.toDictionary() + result["visibility_actions"] = visibilityActions?.map { $0.toDictionary() } + result["width"] = width.toDictionary() + return result + } +} diff --git a/client/ios/DivKit/generated_sources/DivSwitchTemplate.swift b/client/ios/DivKit/generated_sources/DivSwitchTemplate.swift new file mode 100644 index 000000000..fe9729484 --- /dev/null +++ b/client/ios/DivKit/generated_sources/DivSwitchTemplate.swift @@ -0,0 +1,879 @@ +// Generated code. Do not modify. + +import Foundation +import Serialization +import VGSL + +public final class DivSwitchTemplate: TemplateValue { + public static let type: String = "switch" + public let parent: String? + public let accessibility: Field? + public let alignmentHorizontal: Field>? + public let alignmentVertical: Field>? + public let alpha: Field>? // constraint: number >= 0.0 && number <= 1.0; default value: 1.0 + public let animators: Field<[DivAnimatorTemplate]>? + public let background: Field<[DivBackgroundTemplate]>? + public let border: Field? + public let columnSpan: Field>? // constraint: number >= 0 + public let disappearActions: Field<[DivDisappearActionTemplate]>? + public let extensions: Field<[DivExtensionTemplate]>? + public let focus: Field? + public let functions: Field<[DivFunctionTemplate]>? + public let height: Field? // default value: .divWrapContentSize(DivWrapContentSize()) + public let id: Field? + public let isEnabled: Field>? // default value: true + public let isOnVariable: Field? + public let layoutProvider: Field? + public let margins: Field? + public let onColor: Field>? + public let paddings: Field? + public let reuseId: Field>? + public let rowSpan: Field>? // constraint: number >= 0 + public let selectedActions: Field<[DivActionTemplate]>? + public let tooltips: Field<[DivTooltipTemplate]>? + public let transform: Field? + public let transitionChange: Field? + public let transitionIn: Field? + public let transitionOut: Field? + public let transitionTriggers: Field<[DivTransitionTrigger]>? // at least 1 elements + public let variableTriggers: Field<[DivTriggerTemplate]>? + public let variables: Field<[DivVariableTemplate]>? + public let visibility: Field>? // default value: visible + public let visibilityAction: Field? + public let visibilityActions: Field<[DivVisibilityActionTemplate]>? + public let width: Field? // default value: .divMatchParentSize(DivMatchParentSize()) + + public convenience init(dictionary: [String: Any], templateToType: [TemplateName: String]) throws { + self.init( + parent: dictionary["type"] as? String, + accessibility: dictionary.getOptionalField("accessibility", templateToType: templateToType), + alignmentHorizontal: dictionary.getOptionalExpressionField("alignment_horizontal"), + alignmentVertical: dictionary.getOptionalExpressionField("alignment_vertical"), + alpha: dictionary.getOptionalExpressionField("alpha"), + animators: dictionary.getOptionalArray("animators", templateToType: templateToType), + background: dictionary.getOptionalArray("background", templateToType: templateToType), + border: dictionary.getOptionalField("border", templateToType: templateToType), + columnSpan: dictionary.getOptionalExpressionField("column_span"), + disappearActions: dictionary.getOptionalArray("disappear_actions", templateToType: templateToType), + extensions: dictionary.getOptionalArray("extensions", templateToType: templateToType), + focus: dictionary.getOptionalField("focus", templateToType: templateToType), + functions: dictionary.getOptionalArray("functions", templateToType: templateToType), + height: dictionary.getOptionalField("height", templateToType: templateToType), + id: dictionary.getOptionalField("id"), + isEnabled: dictionary.getOptionalExpressionField("is_enabled"), + isOnVariable: dictionary.getOptionalField("is_on_variable"), + layoutProvider: dictionary.getOptionalField("layout_provider", templateToType: templateToType), + margins: dictionary.getOptionalField("margins", templateToType: templateToType), + onColor: dictionary.getOptionalExpressionField("on_color", transform: Color.color(withHexString:)), + paddings: dictionary.getOptionalField("paddings", templateToType: templateToType), + reuseId: dictionary.getOptionalExpressionField("reuse_id"), + rowSpan: dictionary.getOptionalExpressionField("row_span"), + selectedActions: dictionary.getOptionalArray("selected_actions", templateToType: templateToType), + tooltips: dictionary.getOptionalArray("tooltips", templateToType: templateToType), + transform: dictionary.getOptionalField("transform", templateToType: templateToType), + transitionChange: dictionary.getOptionalField("transition_change", templateToType: templateToType), + transitionIn: dictionary.getOptionalField("transition_in", templateToType: templateToType), + transitionOut: dictionary.getOptionalField("transition_out", templateToType: templateToType), + transitionTriggers: dictionary.getOptionalArray("transition_triggers"), + variableTriggers: dictionary.getOptionalArray("variable_triggers", templateToType: templateToType), + variables: dictionary.getOptionalArray("variables", templateToType: templateToType), + visibility: dictionary.getOptionalExpressionField("visibility"), + visibilityAction: dictionary.getOptionalField("visibility_action", templateToType: templateToType), + visibilityActions: dictionary.getOptionalArray("visibility_actions", templateToType: templateToType), + width: dictionary.getOptionalField("width", templateToType: templateToType) + ) + } + + init( + parent: String?, + accessibility: Field? = nil, + alignmentHorizontal: Field>? = nil, + alignmentVertical: Field>? = nil, + alpha: Field>? = nil, + animators: Field<[DivAnimatorTemplate]>? = nil, + background: Field<[DivBackgroundTemplate]>? = nil, + border: Field? = nil, + columnSpan: Field>? = nil, + disappearActions: Field<[DivDisappearActionTemplate]>? = nil, + extensions: Field<[DivExtensionTemplate]>? = nil, + focus: Field? = nil, + functions: Field<[DivFunctionTemplate]>? = nil, + height: Field? = nil, + id: Field? = nil, + isEnabled: Field>? = nil, + isOnVariable: Field? = nil, + layoutProvider: Field? = nil, + margins: Field? = nil, + onColor: Field>? = nil, + paddings: Field? = nil, + reuseId: Field>? = nil, + rowSpan: Field>? = nil, + selectedActions: Field<[DivActionTemplate]>? = nil, + tooltips: Field<[DivTooltipTemplate]>? = nil, + transform: Field? = nil, + transitionChange: Field? = nil, + transitionIn: Field? = nil, + transitionOut: Field? = nil, + transitionTriggers: Field<[DivTransitionTrigger]>? = nil, + variableTriggers: Field<[DivTriggerTemplate]>? = nil, + variables: Field<[DivVariableTemplate]>? = nil, + visibility: Field>? = nil, + visibilityAction: Field? = nil, + visibilityActions: Field<[DivVisibilityActionTemplate]>? = nil, + width: Field? = nil + ) { + self.parent = parent + self.accessibility = accessibility + self.alignmentHorizontal = alignmentHorizontal + self.alignmentVertical = alignmentVertical + self.alpha = alpha + self.animators = animators + self.background = background + self.border = border + self.columnSpan = columnSpan + self.disappearActions = disappearActions + self.extensions = extensions + self.focus = focus + self.functions = functions + self.height = height + self.id = id + self.isEnabled = isEnabled + self.isOnVariable = isOnVariable + self.layoutProvider = layoutProvider + self.margins = margins + self.onColor = onColor + self.paddings = paddings + self.reuseId = reuseId + self.rowSpan = rowSpan + self.selectedActions = selectedActions + self.tooltips = tooltips + self.transform = transform + self.transitionChange = transitionChange + self.transitionIn = transitionIn + self.transitionOut = transitionOut + self.transitionTriggers = transitionTriggers + self.variableTriggers = variableTriggers + self.variables = variables + self.visibility = visibility + self.visibilityAction = visibilityAction + self.visibilityActions = visibilityActions + self.width = width + } + + private static func resolveOnlyLinks(context: TemplatesContext, parent: DivSwitchTemplate?) -> DeserializationResult { + let accessibilityValue = { parent?.accessibility?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + let alignmentHorizontalValue = { parent?.alignmentHorizontal?.resolveOptionalValue(context: context) ?? .noValue }() + let alignmentVerticalValue = { parent?.alignmentVertical?.resolveOptionalValue(context: context) ?? .noValue }() + let alphaValue = { parent?.alpha?.resolveOptionalValue(context: context, validator: ResolvedValue.alphaValidator) ?? .noValue }() + let animatorsValue = { parent?.animators?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + let backgroundValue = { parent?.background?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + let borderValue = { parent?.border?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + let columnSpanValue = { parent?.columnSpan?.resolveOptionalValue(context: context, validator: ResolvedValue.columnSpanValidator) ?? .noValue }() + let disappearActionsValue = { parent?.disappearActions?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + let extensionsValue = { parent?.extensions?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + let focusValue = { parent?.focus?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + let functionsValue = { parent?.functions?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + let heightValue = { parent?.height?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + let idValue = { parent?.id?.resolveOptionalValue(context: context) ?? .noValue }() + let isEnabledValue = { parent?.isEnabled?.resolveOptionalValue(context: context) ?? .noValue }() + let isOnVariableValue = { parent?.isOnVariable?.resolveValue(context: context) ?? .noValue }() + let layoutProviderValue = { parent?.layoutProvider?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + let marginsValue = { parent?.margins?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + let onColorValue = { parent?.onColor?.resolveOptionalValue(context: context, transform: Color.color(withHexString:)) ?? .noValue }() + let paddingsValue = { parent?.paddings?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + let reuseIdValue = { parent?.reuseId?.resolveOptionalValue(context: context) ?? .noValue }() + let rowSpanValue = { parent?.rowSpan?.resolveOptionalValue(context: context, validator: ResolvedValue.rowSpanValidator) ?? .noValue }() + let selectedActionsValue = { parent?.selectedActions?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + let tooltipsValue = { parent?.tooltips?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + let transformValue = { parent?.transform?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + let transitionChangeValue = { parent?.transitionChange?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + let transitionInValue = { parent?.transitionIn?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + let transitionOutValue = { parent?.transitionOut?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + let transitionTriggersValue = { parent?.transitionTriggers?.resolveOptionalValue(context: context, validator: ResolvedValue.transitionTriggersValidator) ?? .noValue }() + let variableTriggersValue = { parent?.variableTriggers?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + let variablesValue = { parent?.variables?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + let visibilityValue = { parent?.visibility?.resolveOptionalValue(context: context) ?? .noValue }() + let visibilityActionValue = { parent?.visibilityAction?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + let visibilityActionsValue = { parent?.visibilityActions?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + let widthValue = { parent?.width?.resolveOptionalValue(context: context, useOnlyLinks: true) ?? .noValue }() + var errors = mergeErrors( + accessibilityValue.errorsOrWarnings?.map { .nestedObjectError(field: "accessibility", error: $0) }, + alignmentHorizontalValue.errorsOrWarnings?.map { .nestedObjectError(field: "alignment_horizontal", error: $0) }, + alignmentVerticalValue.errorsOrWarnings?.map { .nestedObjectError(field: "alignment_vertical", error: $0) }, + alphaValue.errorsOrWarnings?.map { .nestedObjectError(field: "alpha", error: $0) }, + animatorsValue.errorsOrWarnings?.map { .nestedObjectError(field: "animators", error: $0) }, + backgroundValue.errorsOrWarnings?.map { .nestedObjectError(field: "background", error: $0) }, + borderValue.errorsOrWarnings?.map { .nestedObjectError(field: "border", error: $0) }, + columnSpanValue.errorsOrWarnings?.map { .nestedObjectError(field: "column_span", error: $0) }, + disappearActionsValue.errorsOrWarnings?.map { .nestedObjectError(field: "disappear_actions", error: $0) }, + extensionsValue.errorsOrWarnings?.map { .nestedObjectError(field: "extensions", error: $0) }, + focusValue.errorsOrWarnings?.map { .nestedObjectError(field: "focus", error: $0) }, + functionsValue.errorsOrWarnings?.map { .nestedObjectError(field: "functions", error: $0) }, + heightValue.errorsOrWarnings?.map { .nestedObjectError(field: "height", error: $0) }, + idValue.errorsOrWarnings?.map { .nestedObjectError(field: "id", error: $0) }, + isEnabledValue.errorsOrWarnings?.map { .nestedObjectError(field: "is_enabled", error: $0) }, + isOnVariableValue.errorsOrWarnings?.map { .nestedObjectError(field: "is_on_variable", error: $0) }, + layoutProviderValue.errorsOrWarnings?.map { .nestedObjectError(field: "layout_provider", error: $0) }, + marginsValue.errorsOrWarnings?.map { .nestedObjectError(field: "margins", error: $0) }, + onColorValue.errorsOrWarnings?.map { .nestedObjectError(field: "on_color", error: $0) }, + paddingsValue.errorsOrWarnings?.map { .nestedObjectError(field: "paddings", error: $0) }, + reuseIdValue.errorsOrWarnings?.map { .nestedObjectError(field: "reuse_id", error: $0) }, + rowSpanValue.errorsOrWarnings?.map { .nestedObjectError(field: "row_span", error: $0) }, + selectedActionsValue.errorsOrWarnings?.map { .nestedObjectError(field: "selected_actions", error: $0) }, + tooltipsValue.errorsOrWarnings?.map { .nestedObjectError(field: "tooltips", error: $0) }, + transformValue.errorsOrWarnings?.map { .nestedObjectError(field: "transform", error: $0) }, + transitionChangeValue.errorsOrWarnings?.map { .nestedObjectError(field: "transition_change", error: $0) }, + transitionInValue.errorsOrWarnings?.map { .nestedObjectError(field: "transition_in", error: $0) }, + transitionOutValue.errorsOrWarnings?.map { .nestedObjectError(field: "transition_out", error: $0) }, + transitionTriggersValue.errorsOrWarnings?.map { .nestedObjectError(field: "transition_triggers", error: $0) }, + variableTriggersValue.errorsOrWarnings?.map { .nestedObjectError(field: "variable_triggers", error: $0) }, + variablesValue.errorsOrWarnings?.map { .nestedObjectError(field: "variables", error: $0) }, + visibilityValue.errorsOrWarnings?.map { .nestedObjectError(field: "visibility", error: $0) }, + visibilityActionValue.errorsOrWarnings?.map { .nestedObjectError(field: "visibility_action", error: $0) }, + visibilityActionsValue.errorsOrWarnings?.map { .nestedObjectError(field: "visibility_actions", error: $0) }, + widthValue.errorsOrWarnings?.map { .nestedObjectError(field: "width", error: $0) } + ) + if case .noValue = isOnVariableValue { + errors.append(.requiredFieldIsMissing(field: "is_on_variable")) + } + guard + let isOnVariableNonNil = isOnVariableValue.value + else { + return .failure(NonEmptyArray(errors)!) + } + let result = DivSwitch( + accessibility: { accessibilityValue.value }(), + alignmentHorizontal: { alignmentHorizontalValue.value }(), + alignmentVertical: { alignmentVerticalValue.value }(), + alpha: { alphaValue.value }(), + animators: { animatorsValue.value }(), + background: { backgroundValue.value }(), + border: { borderValue.value }(), + columnSpan: { columnSpanValue.value }(), + disappearActions: { disappearActionsValue.value }(), + extensions: { extensionsValue.value }(), + focus: { focusValue.value }(), + functions: { functionsValue.value }(), + height: { heightValue.value }(), + id: { idValue.value }(), + isEnabled: { isEnabledValue.value }(), + isOnVariable: { isOnVariableNonNil }(), + layoutProvider: { layoutProviderValue.value }(), + margins: { marginsValue.value }(), + onColor: { onColorValue.value }(), + paddings: { paddingsValue.value }(), + reuseId: { reuseIdValue.value }(), + rowSpan: { rowSpanValue.value }(), + selectedActions: { selectedActionsValue.value }(), + tooltips: { tooltipsValue.value }(), + transform: { transformValue.value }(), + transitionChange: { transitionChangeValue.value }(), + transitionIn: { transitionInValue.value }(), + transitionOut: { transitionOutValue.value }(), + transitionTriggers: { transitionTriggersValue.value }(), + variableTriggers: { variableTriggersValue.value }(), + variables: { variablesValue.value }(), + visibility: { visibilityValue.value }(), + visibilityAction: { visibilityActionValue.value }(), + visibilityActions: { visibilityActionsValue.value }(), + width: { widthValue.value }() + ) + return errors.isEmpty ? .success(result) : .partialSuccess(result, warnings: NonEmptyArray(errors)!) + } + + public static func resolveValue(context: TemplatesContext, parent: DivSwitchTemplate?, useOnlyLinks: Bool) -> DeserializationResult { + if useOnlyLinks { + return resolveOnlyLinks(context: context, parent: parent) + } + var accessibilityValue: DeserializationResult = .noValue + var alignmentHorizontalValue: DeserializationResult> = { parent?.alignmentHorizontal?.value() ?? .noValue }() + var alignmentVerticalValue: DeserializationResult> = { parent?.alignmentVertical?.value() ?? .noValue }() + var alphaValue: DeserializationResult> = { parent?.alpha?.value() ?? .noValue }() + var animatorsValue: DeserializationResult<[DivAnimator]> = .noValue + var backgroundValue: DeserializationResult<[DivBackground]> = .noValue + var borderValue: DeserializationResult = .noValue + var columnSpanValue: DeserializationResult> = { parent?.columnSpan?.value() ?? .noValue }() + var disappearActionsValue: DeserializationResult<[DivDisappearAction]> = .noValue + var extensionsValue: DeserializationResult<[DivExtension]> = .noValue + var focusValue: DeserializationResult = .noValue + var functionsValue: DeserializationResult<[DivFunction]> = .noValue + var heightValue: DeserializationResult = .noValue + var idValue: DeserializationResult = { parent?.id?.value() ?? .noValue }() + var isEnabledValue: DeserializationResult> = { parent?.isEnabled?.value() ?? .noValue }() + var isOnVariableValue: DeserializationResult = { parent?.isOnVariable?.value() ?? .noValue }() + var layoutProviderValue: DeserializationResult = .noValue + var marginsValue: DeserializationResult = .noValue + var onColorValue: DeserializationResult> = { parent?.onColor?.value() ?? .noValue }() + var paddingsValue: DeserializationResult = .noValue + var reuseIdValue: DeserializationResult> = { parent?.reuseId?.value() ?? .noValue }() + var rowSpanValue: DeserializationResult> = { parent?.rowSpan?.value() ?? .noValue }() + var selectedActionsValue: DeserializationResult<[DivAction]> = .noValue + var tooltipsValue: DeserializationResult<[DivTooltip]> = .noValue + var transformValue: DeserializationResult = .noValue + var transitionChangeValue: DeserializationResult = .noValue + var transitionInValue: DeserializationResult = .noValue + var transitionOutValue: DeserializationResult = .noValue + var transitionTriggersValue: DeserializationResult<[DivTransitionTrigger]> = { parent?.transitionTriggers?.value(validatedBy: ResolvedValue.transitionTriggersValidator) ?? .noValue }() + var variableTriggersValue: DeserializationResult<[DivTrigger]> = .noValue + var variablesValue: DeserializationResult<[DivVariable]> = .noValue + var visibilityValue: DeserializationResult> = { parent?.visibility?.value() ?? .noValue }() + var visibilityActionValue: DeserializationResult = .noValue + var visibilityActionsValue: DeserializationResult<[DivVisibilityAction]> = .noValue + var widthValue: DeserializationResult = .noValue + _ = { + // Each field is parsed in its own lambda to keep the stack size managable + // Otherwise the compiler will allocate stack for each intermediate variable + // upfront even when we don't actually visit a relevant branch + for (key, __dictValue) in context.templateData { + _ = { + if key == "accessibility" { + accessibilityValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivAccessibilityTemplate.self).merged(with: accessibilityValue) + } + }() + _ = { + if key == "alignment_horizontal" { + alignmentHorizontalValue = deserialize(__dictValue).merged(with: alignmentHorizontalValue) + } + }() + _ = { + if key == "alignment_vertical" { + alignmentVerticalValue = deserialize(__dictValue).merged(with: alignmentVerticalValue) + } + }() + _ = { + if key == "alpha" { + alphaValue = deserialize(__dictValue, validator: ResolvedValue.alphaValidator).merged(with: alphaValue) + } + }() + _ = { + if key == "animators" { + animatorsValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivAnimatorTemplate.self).merged(with: animatorsValue) + } + }() + _ = { + if key == "background" { + backgroundValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivBackgroundTemplate.self).merged(with: backgroundValue) + } + }() + _ = { + if key == "border" { + borderValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivBorderTemplate.self).merged(with: borderValue) + } + }() + _ = { + if key == "column_span" { + columnSpanValue = deserialize(__dictValue, validator: ResolvedValue.columnSpanValidator).merged(with: columnSpanValue) + } + }() + _ = { + if key == "disappear_actions" { + disappearActionsValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivDisappearActionTemplate.self).merged(with: disappearActionsValue) + } + }() + _ = { + if key == "extensions" { + extensionsValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivExtensionTemplate.self).merged(with: extensionsValue) + } + }() + _ = { + if key == "focus" { + focusValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivFocusTemplate.self).merged(with: focusValue) + } + }() + _ = { + if key == "functions" { + functionsValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivFunctionTemplate.self).merged(with: functionsValue) + } + }() + _ = { + if key == "height" { + heightValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivSizeTemplate.self).merged(with: heightValue) + } + }() + _ = { + if key == "id" { + idValue = deserialize(__dictValue).merged(with: idValue) + } + }() + _ = { + if key == "is_enabled" { + isEnabledValue = deserialize(__dictValue).merged(with: isEnabledValue) + } + }() + _ = { + if key == "is_on_variable" { + isOnVariableValue = deserialize(__dictValue).merged(with: isOnVariableValue) + } + }() + _ = { + if key == "layout_provider" { + layoutProviderValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivLayoutProviderTemplate.self).merged(with: layoutProviderValue) + } + }() + _ = { + if key == "margins" { + marginsValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivEdgeInsetsTemplate.self).merged(with: marginsValue) + } + }() + _ = { + if key == "on_color" { + onColorValue = deserialize(__dictValue, transform: Color.color(withHexString:)).merged(with: onColorValue) + } + }() + _ = { + if key == "paddings" { + paddingsValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivEdgeInsetsTemplate.self).merged(with: paddingsValue) + } + }() + _ = { + if key == "reuse_id" { + reuseIdValue = deserialize(__dictValue).merged(with: reuseIdValue) + } + }() + _ = { + if key == "row_span" { + rowSpanValue = deserialize(__dictValue, validator: ResolvedValue.rowSpanValidator).merged(with: rowSpanValue) + } + }() + _ = { + if key == "selected_actions" { + selectedActionsValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivActionTemplate.self).merged(with: selectedActionsValue) + } + }() + _ = { + if key == "tooltips" { + tooltipsValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivTooltipTemplate.self).merged(with: tooltipsValue) + } + }() + _ = { + if key == "transform" { + transformValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivTransformTemplate.self).merged(with: transformValue) + } + }() + _ = { + if key == "transition_change" { + transitionChangeValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivChangeTransitionTemplate.self).merged(with: transitionChangeValue) + } + }() + _ = { + if key == "transition_in" { + transitionInValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivAppearanceTransitionTemplate.self).merged(with: transitionInValue) + } + }() + _ = { + if key == "transition_out" { + transitionOutValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivAppearanceTransitionTemplate.self).merged(with: transitionOutValue) + } + }() + _ = { + if key == "transition_triggers" { + transitionTriggersValue = deserialize(__dictValue, validator: ResolvedValue.transitionTriggersValidator).merged(with: transitionTriggersValue) + } + }() + _ = { + if key == "variable_triggers" { + variableTriggersValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivTriggerTemplate.self).merged(with: variableTriggersValue) + } + }() + _ = { + if key == "variables" { + variablesValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivVariableTemplate.self).merged(with: variablesValue) + } + }() + _ = { + if key == "visibility" { + visibilityValue = deserialize(__dictValue).merged(with: visibilityValue) + } + }() + _ = { + if key == "visibility_action" { + visibilityActionValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivVisibilityActionTemplate.self).merged(with: visibilityActionValue) + } + }() + _ = { + if key == "visibility_actions" { + visibilityActionsValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivVisibilityActionTemplate.self).merged(with: visibilityActionsValue) + } + }() + _ = { + if key == "width" { + widthValue = deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivSizeTemplate.self).merged(with: widthValue) + } + }() + _ = { + if key == parent?.accessibility?.link { + accessibilityValue = accessibilityValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivAccessibilityTemplate.self) }) + } + }() + _ = { + if key == parent?.alignmentHorizontal?.link { + alignmentHorizontalValue = alignmentHorizontalValue.merged(with: { deserialize(__dictValue) }) + } + }() + _ = { + if key == parent?.alignmentVertical?.link { + alignmentVerticalValue = alignmentVerticalValue.merged(with: { deserialize(__dictValue) }) + } + }() + _ = { + if key == parent?.alpha?.link { + alphaValue = alphaValue.merged(with: { deserialize(__dictValue, validator: ResolvedValue.alphaValidator) }) + } + }() + _ = { + if key == parent?.animators?.link { + animatorsValue = animatorsValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivAnimatorTemplate.self) }) + } + }() + _ = { + if key == parent?.background?.link { + backgroundValue = backgroundValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivBackgroundTemplate.self) }) + } + }() + _ = { + if key == parent?.border?.link { + borderValue = borderValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivBorderTemplate.self) }) + } + }() + _ = { + if key == parent?.columnSpan?.link { + columnSpanValue = columnSpanValue.merged(with: { deserialize(__dictValue, validator: ResolvedValue.columnSpanValidator) }) + } + }() + _ = { + if key == parent?.disappearActions?.link { + disappearActionsValue = disappearActionsValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivDisappearActionTemplate.self) }) + } + }() + _ = { + if key == parent?.extensions?.link { + extensionsValue = extensionsValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivExtensionTemplate.self) }) + } + }() + _ = { + if key == parent?.focus?.link { + focusValue = focusValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivFocusTemplate.self) }) + } + }() + _ = { + if key == parent?.functions?.link { + functionsValue = functionsValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivFunctionTemplate.self) }) + } + }() + _ = { + if key == parent?.height?.link { + heightValue = heightValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivSizeTemplate.self) }) + } + }() + _ = { + if key == parent?.id?.link { + idValue = idValue.merged(with: { deserialize(__dictValue) }) + } + }() + _ = { + if key == parent?.isEnabled?.link { + isEnabledValue = isEnabledValue.merged(with: { deserialize(__dictValue) }) + } + }() + _ = { + if key == parent?.isOnVariable?.link { + isOnVariableValue = isOnVariableValue.merged(with: { deserialize(__dictValue) }) + } + }() + _ = { + if key == parent?.layoutProvider?.link { + layoutProviderValue = layoutProviderValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivLayoutProviderTemplate.self) }) + } + }() + _ = { + if key == parent?.margins?.link { + marginsValue = marginsValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivEdgeInsetsTemplate.self) }) + } + }() + _ = { + if key == parent?.onColor?.link { + onColorValue = onColorValue.merged(with: { deserialize(__dictValue, transform: Color.color(withHexString:)) }) + } + }() + _ = { + if key == parent?.paddings?.link { + paddingsValue = paddingsValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivEdgeInsetsTemplate.self) }) + } + }() + _ = { + if key == parent?.reuseId?.link { + reuseIdValue = reuseIdValue.merged(with: { deserialize(__dictValue) }) + } + }() + _ = { + if key == parent?.rowSpan?.link { + rowSpanValue = rowSpanValue.merged(with: { deserialize(__dictValue, validator: ResolvedValue.rowSpanValidator) }) + } + }() + _ = { + if key == parent?.selectedActions?.link { + selectedActionsValue = selectedActionsValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivActionTemplate.self) }) + } + }() + _ = { + if key == parent?.tooltips?.link { + tooltipsValue = tooltipsValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivTooltipTemplate.self) }) + } + }() + _ = { + if key == parent?.transform?.link { + transformValue = transformValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivTransformTemplate.self) }) + } + }() + _ = { + if key == parent?.transitionChange?.link { + transitionChangeValue = transitionChangeValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivChangeTransitionTemplate.self) }) + } + }() + _ = { + if key == parent?.transitionIn?.link { + transitionInValue = transitionInValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivAppearanceTransitionTemplate.self) }) + } + }() + _ = { + if key == parent?.transitionOut?.link { + transitionOutValue = transitionOutValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivAppearanceTransitionTemplate.self) }) + } + }() + _ = { + if key == parent?.transitionTriggers?.link { + transitionTriggersValue = transitionTriggersValue.merged(with: { deserialize(__dictValue, validator: ResolvedValue.transitionTriggersValidator) }) + } + }() + _ = { + if key == parent?.variableTriggers?.link { + variableTriggersValue = variableTriggersValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivTriggerTemplate.self) }) + } + }() + _ = { + if key == parent?.variables?.link { + variablesValue = variablesValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivVariableTemplate.self) }) + } + }() + _ = { + if key == parent?.visibility?.link { + visibilityValue = visibilityValue.merged(with: { deserialize(__dictValue) }) + } + }() + _ = { + if key == parent?.visibilityAction?.link { + visibilityActionValue = visibilityActionValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivVisibilityActionTemplate.self) }) + } + }() + _ = { + if key == parent?.visibilityActions?.link { + visibilityActionsValue = visibilityActionsValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivVisibilityActionTemplate.self) }) + } + }() + _ = { + if key == parent?.width?.link { + widthValue = widthValue.merged(with: { deserialize(__dictValue, templates: context.templates, templateToType: context.templateToType, type: DivSizeTemplate.self) }) + } + }() + } + }() + if let parent = parent { + _ = { accessibilityValue = accessibilityValue.merged(with: { parent.accessibility?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + _ = { animatorsValue = animatorsValue.merged(with: { parent.animators?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + _ = { backgroundValue = backgroundValue.merged(with: { parent.background?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + _ = { borderValue = borderValue.merged(with: { parent.border?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + _ = { disappearActionsValue = disappearActionsValue.merged(with: { parent.disappearActions?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + _ = { extensionsValue = extensionsValue.merged(with: { parent.extensions?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + _ = { focusValue = focusValue.merged(with: { parent.focus?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + _ = { functionsValue = functionsValue.merged(with: { parent.functions?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + _ = { heightValue = heightValue.merged(with: { parent.height?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + _ = { layoutProviderValue = layoutProviderValue.merged(with: { parent.layoutProvider?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + _ = { marginsValue = marginsValue.merged(with: { parent.margins?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + _ = { paddingsValue = paddingsValue.merged(with: { parent.paddings?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + _ = { selectedActionsValue = selectedActionsValue.merged(with: { parent.selectedActions?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + _ = { tooltipsValue = tooltipsValue.merged(with: { parent.tooltips?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + _ = { transformValue = transformValue.merged(with: { parent.transform?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + _ = { transitionChangeValue = transitionChangeValue.merged(with: { parent.transitionChange?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + _ = { transitionInValue = transitionInValue.merged(with: { parent.transitionIn?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + _ = { transitionOutValue = transitionOutValue.merged(with: { parent.transitionOut?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + _ = { variableTriggersValue = variableTriggersValue.merged(with: { parent.variableTriggers?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + _ = { variablesValue = variablesValue.merged(with: { parent.variables?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + _ = { visibilityActionValue = visibilityActionValue.merged(with: { parent.visibilityAction?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + _ = { visibilityActionsValue = visibilityActionsValue.merged(with: { parent.visibilityActions?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + _ = { widthValue = widthValue.merged(with: { parent.width?.resolveOptionalValue(context: context, useOnlyLinks: true) }) }() + } + var errors = mergeErrors( + accessibilityValue.errorsOrWarnings?.map { .nestedObjectError(field: "accessibility", error: $0) }, + alignmentHorizontalValue.errorsOrWarnings?.map { .nestedObjectError(field: "alignment_horizontal", error: $0) }, + alignmentVerticalValue.errorsOrWarnings?.map { .nestedObjectError(field: "alignment_vertical", error: $0) }, + alphaValue.errorsOrWarnings?.map { .nestedObjectError(field: "alpha", error: $0) }, + animatorsValue.errorsOrWarnings?.map { .nestedObjectError(field: "animators", error: $0) }, + backgroundValue.errorsOrWarnings?.map { .nestedObjectError(field: "background", error: $0) }, + borderValue.errorsOrWarnings?.map { .nestedObjectError(field: "border", error: $0) }, + columnSpanValue.errorsOrWarnings?.map { .nestedObjectError(field: "column_span", error: $0) }, + disappearActionsValue.errorsOrWarnings?.map { .nestedObjectError(field: "disappear_actions", error: $0) }, + extensionsValue.errorsOrWarnings?.map { .nestedObjectError(field: "extensions", error: $0) }, + focusValue.errorsOrWarnings?.map { .nestedObjectError(field: "focus", error: $0) }, + functionsValue.errorsOrWarnings?.map { .nestedObjectError(field: "functions", error: $0) }, + heightValue.errorsOrWarnings?.map { .nestedObjectError(field: "height", error: $0) }, + idValue.errorsOrWarnings?.map { .nestedObjectError(field: "id", error: $0) }, + isEnabledValue.errorsOrWarnings?.map { .nestedObjectError(field: "is_enabled", error: $0) }, + isOnVariableValue.errorsOrWarnings?.map { .nestedObjectError(field: "is_on_variable", error: $0) }, + layoutProviderValue.errorsOrWarnings?.map { .nestedObjectError(field: "layout_provider", error: $0) }, + marginsValue.errorsOrWarnings?.map { .nestedObjectError(field: "margins", error: $0) }, + onColorValue.errorsOrWarnings?.map { .nestedObjectError(field: "on_color", error: $0) }, + paddingsValue.errorsOrWarnings?.map { .nestedObjectError(field: "paddings", error: $0) }, + reuseIdValue.errorsOrWarnings?.map { .nestedObjectError(field: "reuse_id", error: $0) }, + rowSpanValue.errorsOrWarnings?.map { .nestedObjectError(field: "row_span", error: $0) }, + selectedActionsValue.errorsOrWarnings?.map { .nestedObjectError(field: "selected_actions", error: $0) }, + tooltipsValue.errorsOrWarnings?.map { .nestedObjectError(field: "tooltips", error: $0) }, + transformValue.errorsOrWarnings?.map { .nestedObjectError(field: "transform", error: $0) }, + transitionChangeValue.errorsOrWarnings?.map { .nestedObjectError(field: "transition_change", error: $0) }, + transitionInValue.errorsOrWarnings?.map { .nestedObjectError(field: "transition_in", error: $0) }, + transitionOutValue.errorsOrWarnings?.map { .nestedObjectError(field: "transition_out", error: $0) }, + transitionTriggersValue.errorsOrWarnings?.map { .nestedObjectError(field: "transition_triggers", error: $0) }, + variableTriggersValue.errorsOrWarnings?.map { .nestedObjectError(field: "variable_triggers", error: $0) }, + variablesValue.errorsOrWarnings?.map { .nestedObjectError(field: "variables", error: $0) }, + visibilityValue.errorsOrWarnings?.map { .nestedObjectError(field: "visibility", error: $0) }, + visibilityActionValue.errorsOrWarnings?.map { .nestedObjectError(field: "visibility_action", error: $0) }, + visibilityActionsValue.errorsOrWarnings?.map { .nestedObjectError(field: "visibility_actions", error: $0) }, + widthValue.errorsOrWarnings?.map { .nestedObjectError(field: "width", error: $0) } + ) + if case .noValue = isOnVariableValue { + errors.append(.requiredFieldIsMissing(field: "is_on_variable")) + } + guard + let isOnVariableNonNil = isOnVariableValue.value + else { + return .failure(NonEmptyArray(errors)!) + } + let result = DivSwitch( + accessibility: { accessibilityValue.value }(), + alignmentHorizontal: { alignmentHorizontalValue.value }(), + alignmentVertical: { alignmentVerticalValue.value }(), + alpha: { alphaValue.value }(), + animators: { animatorsValue.value }(), + background: { backgroundValue.value }(), + border: { borderValue.value }(), + columnSpan: { columnSpanValue.value }(), + disappearActions: { disappearActionsValue.value }(), + extensions: { extensionsValue.value }(), + focus: { focusValue.value }(), + functions: { functionsValue.value }(), + height: { heightValue.value }(), + id: { idValue.value }(), + isEnabled: { isEnabledValue.value }(), + isOnVariable: { isOnVariableNonNil }(), + layoutProvider: { layoutProviderValue.value }(), + margins: { marginsValue.value }(), + onColor: { onColorValue.value }(), + paddings: { paddingsValue.value }(), + reuseId: { reuseIdValue.value }(), + rowSpan: { rowSpanValue.value }(), + selectedActions: { selectedActionsValue.value }(), + tooltips: { tooltipsValue.value }(), + transform: { transformValue.value }(), + transitionChange: { transitionChangeValue.value }(), + transitionIn: { transitionInValue.value }(), + transitionOut: { transitionOutValue.value }(), + transitionTriggers: { transitionTriggersValue.value }(), + variableTriggers: { variableTriggersValue.value }(), + variables: { variablesValue.value }(), + visibility: { visibilityValue.value }(), + visibilityAction: { visibilityActionValue.value }(), + visibilityActions: { visibilityActionsValue.value }(), + width: { widthValue.value }() + ) + return errors.isEmpty ? .success(result) : .partialSuccess(result, warnings: NonEmptyArray(errors)!) + } + + private func mergedWithParent(templates: [TemplateName: Any]) throws -> DivSwitchTemplate { + guard let parent = parent, parent != Self.type else { return self } + guard let parentTemplate = templates[parent] as? DivSwitchTemplate else { + throw DeserializationError.unknownType(type: parent) + } + let mergedParent = try parentTemplate.mergedWithParent(templates: templates) + + return DivSwitchTemplate( + parent: nil, + accessibility: accessibility ?? mergedParent.accessibility, + alignmentHorizontal: alignmentHorizontal ?? mergedParent.alignmentHorizontal, + alignmentVertical: alignmentVertical ?? mergedParent.alignmentVertical, + alpha: alpha ?? mergedParent.alpha, + animators: animators ?? mergedParent.animators, + background: background ?? mergedParent.background, + border: border ?? mergedParent.border, + columnSpan: columnSpan ?? mergedParent.columnSpan, + disappearActions: disappearActions ?? mergedParent.disappearActions, + extensions: extensions ?? mergedParent.extensions, + focus: focus ?? mergedParent.focus, + functions: functions ?? mergedParent.functions, + height: height ?? mergedParent.height, + id: id ?? mergedParent.id, + isEnabled: isEnabled ?? mergedParent.isEnabled, + isOnVariable: isOnVariable ?? mergedParent.isOnVariable, + layoutProvider: layoutProvider ?? mergedParent.layoutProvider, + margins: margins ?? mergedParent.margins, + onColor: onColor ?? mergedParent.onColor, + paddings: paddings ?? mergedParent.paddings, + reuseId: reuseId ?? mergedParent.reuseId, + rowSpan: rowSpan ?? mergedParent.rowSpan, + selectedActions: selectedActions ?? mergedParent.selectedActions, + tooltips: tooltips ?? mergedParent.tooltips, + transform: transform ?? mergedParent.transform, + transitionChange: transitionChange ?? mergedParent.transitionChange, + transitionIn: transitionIn ?? mergedParent.transitionIn, + transitionOut: transitionOut ?? mergedParent.transitionOut, + transitionTriggers: transitionTriggers ?? mergedParent.transitionTriggers, + variableTriggers: variableTriggers ?? mergedParent.variableTriggers, + variables: variables ?? mergedParent.variables, + visibility: visibility ?? mergedParent.visibility, + visibilityAction: visibilityAction ?? mergedParent.visibilityAction, + visibilityActions: visibilityActions ?? mergedParent.visibilityActions, + width: width ?? mergedParent.width + ) + } + + public func resolveParent(templates: [TemplateName: Any]) throws -> DivSwitchTemplate { + let merged = try mergedWithParent(templates: templates) + + return DivSwitchTemplate( + parent: nil, + accessibility: merged.accessibility?.tryResolveParent(templates: templates), + alignmentHorizontal: merged.alignmentHorizontal, + alignmentVertical: merged.alignmentVertical, + alpha: merged.alpha, + animators: merged.animators?.tryResolveParent(templates: templates), + background: merged.background?.tryResolveParent(templates: templates), + border: merged.border?.tryResolveParent(templates: templates), + columnSpan: merged.columnSpan, + disappearActions: merged.disappearActions?.tryResolveParent(templates: templates), + extensions: merged.extensions?.tryResolveParent(templates: templates), + focus: merged.focus?.tryResolveParent(templates: templates), + functions: merged.functions?.tryResolveParent(templates: templates), + height: merged.height?.tryResolveParent(templates: templates), + id: merged.id, + isEnabled: merged.isEnabled, + isOnVariable: merged.isOnVariable, + layoutProvider: merged.layoutProvider?.tryResolveParent(templates: templates), + margins: merged.margins?.tryResolveParent(templates: templates), + onColor: merged.onColor, + paddings: merged.paddings?.tryResolveParent(templates: templates), + reuseId: merged.reuseId, + rowSpan: merged.rowSpan, + selectedActions: merged.selectedActions?.tryResolveParent(templates: templates), + tooltips: merged.tooltips?.tryResolveParent(templates: templates), + transform: merged.transform?.tryResolveParent(templates: templates), + transitionChange: merged.transitionChange?.tryResolveParent(templates: templates), + transitionIn: merged.transitionIn?.tryResolveParent(templates: templates), + transitionOut: merged.transitionOut?.tryResolveParent(templates: templates), + transitionTriggers: merged.transitionTriggers, + variableTriggers: merged.variableTriggers?.tryResolveParent(templates: templates), + variables: merged.variables?.tryResolveParent(templates: templates), + visibility: merged.visibility, + visibilityAction: merged.visibilityAction?.tryResolveParent(templates: templates), + visibilityActions: merged.visibilityActions?.tryResolveParent(templates: templates), + width: merged.width?.tryResolveParent(templates: templates) + ) + } +} diff --git a/client/ios/DivKit/generated_sources/DivTemplate.swift b/client/ios/DivKit/generated_sources/DivTemplate.swift index 16dbc4f78..56f4425f3 100644 --- a/client/ios/DivKit/generated_sources/DivTemplate.swift +++ b/client/ios/DivKit/generated_sources/DivTemplate.swift @@ -19,6 +19,7 @@ public enum DivTemplate: TemplateValue { case divCustomTemplate(DivCustomTemplate) case divIndicatorTemplate(DivIndicatorTemplate) case divSliderTemplate(DivSliderTemplate) + case divSwitchTemplate(DivSwitchTemplate) case divInputTemplate(DivInputTemplate) case divSelectTemplate(DivSelectTemplate) case divVideoTemplate(DivVideoTemplate) @@ -51,6 +52,8 @@ public enum DivTemplate: TemplateValue { return value case let .divSliderTemplate(value): return value + case let .divSwitchTemplate(value): + return value case let .divInputTemplate(value): return value case let .divSelectTemplate(value): @@ -88,6 +91,8 @@ public enum DivTemplate: TemplateValue { return .divIndicatorTemplate(try value.resolveParent(templates: templates)) case let .divSliderTemplate(value): return .divSliderTemplate(try value.resolveParent(templates: templates)) + case let .divSwitchTemplate(value): + return .divSwitchTemplate(try value.resolveParent(templates: templates)) case let .divInputTemplate(value): return .divInputTemplate(try value.resolveParent(templates: templates)) case let .divSelectTemplate(value): @@ -251,6 +256,17 @@ public enum DivTemplate: TemplateValue { } } else { return nil } }() + result = result ?? { + if case let .divSwitchTemplate(value) = parent { + let result = value.resolveValue(context: context, useOnlyLinks: useOnlyLinks) + switch result { + case let .success(value): return .success(.divSwitch(value)) + case let .partialSuccess(value, warnings): return .partialSuccess(.divSwitch(value), warnings: warnings) + case let .failure(errors): return .failure(errors) + case .noValue: return .noValue + } + } else { return nil } + }() result = result ?? { if case let .divInputTemplate(value) = parent { let result = value.resolveValue(context: context, useOnlyLinks: useOnlyLinks) @@ -412,6 +428,15 @@ public enum DivTemplate: TemplateValue { case .noValue: return .noValue } } else { return nil } }() + result = result ?? { if type == DivSwitch.type { + let result = { DivSwitchTemplate.resolveValue(context: context, useOnlyLinks: useOnlyLinks) }() + switch result { + case let .success(value): return .success(.divSwitch(value)) + case let .partialSuccess(value, warnings): return .partialSuccess(.divSwitch(value), warnings: warnings) + case let .failure(errors): return .failure(errors) + case .noValue: return .noValue + } + } else { return nil } }() result = result ?? { if type == DivInput.type { let result = { DivInputTemplate.resolveValue(context: context, useOnlyLinks: useOnlyLinks) }() switch result { @@ -475,6 +500,8 @@ extension DivTemplate { self = .divIndicatorTemplate(try DivIndicatorTemplate(dictionary: dictionary, templateToType: templateToType)) case DivSliderTemplate.type: self = .divSliderTemplate(try DivSliderTemplate(dictionary: dictionary, templateToType: templateToType)) + case DivSwitchTemplate.type: + self = .divSwitchTemplate(try DivSwitchTemplate(dictionary: dictionary, templateToType: templateToType)) case DivInputTemplate.type: self = .divInputTemplate(try DivInputTemplate(dictionary: dictionary, templateToType: templateToType)) case DivSelectTemplate.type: diff --git a/client/ios/DivKitExtensions/DivExtensions.swift b/client/ios/DivKitExtensions/DivExtensions.swift index e22bda4ac..f5814fdb9 100644 --- a/client/ios/DivKitExtensions/DivExtensions.swift +++ b/client/ios/DivKitExtensions/DivExtensions.swift @@ -35,6 +35,7 @@ extension Div { .divSeparator, .divSlider, .divState, + .divSwitch, .divVideo, .divTabs: break diff --git a/client/ios/LayoutKit/LayoutKit/Blocks/SwitchBlock.swift b/client/ios/LayoutKit/LayoutKit/Blocks/SwitchBlock.swift index 1f2c50567..c0276660c 100644 --- a/client/ios/LayoutKit/LayoutKit/Blocks/SwitchBlock.swift +++ b/client/ios/LayoutKit/LayoutKit/Blocks/SwitchBlock.swift @@ -4,7 +4,7 @@ import Foundation import VGSL public final class SwitchBlock: Block { - public let on: Bool + public let on: Binding public let enabled: Bool public let action: UserInterfaceAction? public let onTintColor: Color? @@ -16,6 +16,20 @@ public final class SwitchBlock: Block { action: UserInterfaceAction?, onTintColor: Color? = nil, accessibilityElement: AccessibilityElement? = nil + ) { + self.on = Binding(name: "", value: Property(booleanLiteral: on)) + self.enabled = enabled + self.action = action + self.onTintColor = onTintColor + self.accessibilityElement = accessibilityElement + } + + public init( + on: Binding, + enabled: Bool, + action: UserInterfaceAction?, + onTintColor: Color? = nil, + accessibilityElement: AccessibilityElement? = nil ) { self.on = on self.enabled = enabled @@ -65,7 +79,7 @@ public final class SwitchBlock: Block { } public func ==(lhs: SwitchBlock, rhs: SwitchBlock) -> Bool { - lhs.on == rhs.on && + lhs.on.value == rhs.on.value && lhs.enabled == rhs.enabled && lhs.action == rhs.action && lhs.onTintColor == rhs.onTintColor && diff --git a/client/ios/LayoutKit/LayoutKit/UI/Blocks/SwitchBlock+UIViewRenderableBlock.swift b/client/ios/LayoutKit/LayoutKit/UI/Blocks/SwitchBlock+UIViewRenderableBlock.swift index 901d0c254..d2dc0c7b4 100644 --- a/client/ios/LayoutKit/LayoutKit/UI/Blocks/SwitchBlock+UIViewRenderableBlock.swift +++ b/client/ios/LayoutKit/LayoutKit/UI/Blocks/SwitchBlock+UIViewRenderableBlock.swift @@ -28,7 +28,7 @@ extension SwitchBlock { private final class SwitchBlockView: BlockView, VisibleBoundsTrackingLeaf { struct Model { - let on: Bool + let on: Binding let enabled: Bool let action: UserInterfaceAction? let onTintColor: Color? @@ -37,7 +37,7 @@ private final class SwitchBlockView: BlockView, VisibleBoundsTrackingLeaf { var model: Model! { didSet { - aSwitch.isOn = model.on + aSwitch.isOn = model.on.value aSwitch.isEnabled = model.enabled aSwitch.onTintColor = model.onTintColor?.systemColor applyAccessibility(model.accessibility) @@ -73,5 +73,6 @@ private final class SwitchBlockView: BlockView, VisibleBoundsTrackingLeaf { if let action = model.action { action.perform(sendingFrom: self) } + model.on.value = aSwitch.isOn } } diff --git a/client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step0.png b/client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step0.png new file mode 100644 index 0000000000000000000000000000000000000000..cb883ae9bd05f43adecda9b738dfa44a311d5139 GIT binary patch literal 2334 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 literal 0 HcmV?d00001 diff --git a/client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step1.png b/client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step1.png new file mode 100644 index 0000000000000000000000000000000000000000..9fe076f5e3c1a14b2a7238a559de2b5156f4d95f GIT binary patch literal 2337 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 literal 0 HcmV?d00001 diff --git a/client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step3.png b/client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step3.png new file mode 100644 index 0000000000000000000000000000000000000000..2bee6e300f371d54a99484e91075517b04d823b1 GIT binary patch literal 3978 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%0D3J=HDjWlB}xqy z#YNt7E0m~!zQ!6VfU?1>IN}T3(Nqhnrw0%wmZ<>bKxP2x1%&tjfE)nwzsdlBHt@taP4seN4F+wc6V!FNmCu%d>>_Ddyvp5S~IX-^o4|Rf0ykR~w0tzdU ze*j$0CAl9;WBC8}g-3*ZeAfEd#X-^7+`rlV5zZ2KR!QkdpG27icYsJTqqqs?CC$rr z?f#`vA>SKlBWOYe2NOJro|ugrNC( ztC_LIZw0L89setMa20jdiVSd%l))x3&!>{0AT#M0nA51>Lc+e|?ZUaBr|X38GX4h- z&kQl4J`x}FSTP>>d?*+S!7d@BBzpu!@75mv( zQ=1=xK4s*k;Zh@X&`D@)%mW_*$b(A=l97y?zU3>+`11ia9cr#2dc~59Xi;#Z zJDe274u_xOMv^L5yO78guPiqzeSGT;HM)6ncpJSU{AD8og1-r3ucLeR$g+G*JK;L$ z(lr}&S2QU^0q9lN7X6Omtn?v(G}m(x#+cTa%FQ79qUl%bl`?#+w<1Gj`AV6Z6y-kd zr>V2{r$RoM^`|yI&jEe7u5BaUlR4a-u^QpS!N!Fo=xVH?bCZwfFMCAy_3lazZg!MX z-0CNX_fik7L7-dw?~)B2>!X}ts`Pk{Iafw(f%T?QQ})Y>EZxo(Z?Z8Q5Uz2sMl$rG zHY8IR#aN`x&j=NK@+4ba*0y&=2E8cRULZV%o%gW&$^-wEbn8BqX-z0DAv*oD z*eDGss%#t_kZmQ5$B$R&t9c5(M!^9{<3M^YI!^eZ%|~rI^mfjxI)!M%9|{12k7x=| z6a#u$OhIH;t>xf0jKoKNzPFPUpF*Pm7l&aB6pNc&yJ!^slmA<#C4#b@lIu*2^j>^- zc^DH9rxMCDy6C<&cv`)U61i}fktrf;5%scfhpOZ)CARbdo*EPdQn=?qX*<(V6*7m# z8t%2Uw7hfJ-WZvkU81hYzN8Zp5Rmt-xVV8y$G~7K6Rt24S{+Zj9i_mxm3OuK_~sq*^4o?JqFN@|%N zaW5>8RMtOO^1*F-3KskHAkd?|0}z+KK(e3@P;}JyJcwhv8xVU0FV6u!(m6E3L_a;Ve!=3}cfFJgv0O@##VS77yABRQ+*Zms>Fy z%*SXD_nf(bHTp!)aym2Z7HGRRUYdJ5atbu{ z5g;^vJDimfKkWXpGibe_ho5Z3*=cllcXw@Pb?AKfjY%%2CaDXrUS?B&qUAKrV};p( z-oiq`R$2gjO)0jsKD~SP{k-kj$jGZ6ry-UVnvMru>B?D}7L>V-_&ub0w@!tttW!PN zkPjX2o&K^L`SdTiL)eB66Ms}|7QlP)tRF3n((?X-= z%c^Q#spsDmC=A23^aRLnCrFZg9B)4k-mugH+PW4rkY>`TDR7l1lP-y`e=DAVth$}q zL;*ux*LXCB2x z4tk9PY=!yccy&VskzxtGQ)Q*4rH*!Xc4Jc4pA|$`=IZ__P!wOy)iiH+ZRLOX$Y6hd z5irxyvFOX!NOU?SY2EcRVoA|T8^ZL253)>Sbz(q5nK7t;=ua5JGsH|eDG%_PUY$imn1J3Z=dL61UE01?YzCwY>}LxPt{BsnkihF8JlJ6?(Y7j zuU~mOQL@KetTDN>%Y3Lqmjy9b0&Kgl4pTX#=R$5dcu@Kd_RpLsI@<&;vpT9^!j0E6 z;e(@uft0yYEe*lQIc)4|gB-QBudiEi#`5{A^rVOy?h70VGD8_QvsJf#0;Ojxl*|LS zZ2@AaNA>_9X_9`_r%!mH-;}Tcy=gg9@mHOHfqS>c-xJpoBG|f#LJ+=iCH;9IyR7rE zk$@mvNDR5RbV+g=xkCoud)95WD&rO^p2~z^d`1cQBg;9wH6uP=&!gPB@kstRxnUQN zl+5CIiYoWsW6z{JDe-xZ8+NqV4;F$L=#|mFQAQH+GG%y!r``U;;Aaa zP-cwD?;fJ4@Xr^ne)WdMoI{I#3mv+U_mAGlc2`@K%sXixuD?i))RY67m{bRk!4J0P znn&%Mp2o;^##8RRa770-CTYoSF?$6u7`_yxPJ)pLr@BI1(G3Axp8Hw9e$Jq(FnV2Y zGhN~Y5dpC>{3m;D+A7x(q1pv$u^d|~18>iNN-w_Cw}PT8-tRzu6|MpbzPw@760`{l z3KDfi$H&Jv6KM>K1lh&jdt2vwZ##btOoyAaJr*muuJ)Ds!-P|!T6}F&)0u5KJIL>c zz~aEb0JrwP99mgfnN8r>+Ql8D1r5MIj3&pievN}xVNT5cMP+JwXK&H2Lcum2?1Ks> z%r-uKy!(=1$U64XA}-+M(49s0-|c)7a;sF)Gd{g%sdu8x>R6+k4dkbcsPBYVRr%&C z`ViX^*=%j9Ma8Yva%YGGRN7A1S$&QX=~A__ylMS`c1^J>z(#vPZwRQJ#LpYd=Jo8^ znavm+~)5DL6**fSO^X04$ncFm&8S~9c6Y}LL zG`qX2Ojse7hkCVFKz>SAMEmjTe48S3zk6g}gb7;P5#zBZE})`QfkFi~S`0*2<}-Xf zWU$g}Fu0W>jV2I?2c~6<1wHELji25yHZfP!)xm9ie1xxf>@bdbFyJv%vhIJUPwQSSeiU- zVv`K*4;PrMN3o1tP>Ij4h0eQ?o(d^Uj+>R^KR+dAciC(HZ9~mcoO>=u&hLi?l=&Li zV-K*KD)Q)z`A>r3?UV{DH`eEe4;rdfS;6MVUtAQTI^Hs$1=;fRE`$?~W;b&0WDKR# z80|PpV$5S!R5Nu&9;NECE=-nL=g33%9fHh610?ufbxa4U7{BdYt3d^JX;v?(=KHXrSj#=}{$HEt{aK(Vi;lK3-$w$Z#tDqz z3J+O#)IuR`X*F#p46E_GZ<_Q3I;Vg7r_r$Z(4LOu<9+0!(b>yw{&bY8{XNK-F6$h->DJlQjJA1p2aBu7{qgV=8!>l&JGO{}c;2}p zQG(l0qv`!R2>aFjT&l}Iqj4--)BD29|ICqe=d8Q!yS1{J?qlvsNV47WVCS$B;G>5R zhd!H^_B8~);XG%ZXsOPNQoZUX7bm}1=q6LP;~^)SaAlNp++5PRJGSF3k~HO-j>>1S z!A`(h5XYA)$WCkMw7}KUn-Iw9!qyVJej(eZ9oIpR8|Eh;j&3c2)>PzUs&Ws@FC z;=`FYJlgfjhrX)u87V8Ul8i~jNj0RydjVBxO$XLLQ)pvl{-6}PmliqsF_+^x=!^J{ znJ5c)b?6A>LtmtKGG@!84>|y~xWfjSs{UN4I`MVTx;~A5xN&!+vqQB6j)cJ4%@nWC zrr;-NMW}6G{74I^>N(=s56XHd6tH1hMz`3Z$0q&g#O?S%JSzl67yVFw6n2N+ef+Af zgFrR|L9XmwGTlETU9fXMq!hY?$m#Fzk86o3FqVyge9TM<{0#2m=-cxgfC?J8)2>Qd z3R=kN#;6TVMz-S3DArW6yr+%W=?kAiDdAoq4=*M~3sSf5OD2&p%fhJ5yJ`m3XWjS-ykc zt17hVbyN`laItGdT!|=e=z!aw#%Df@iuBt$(WBHwnUY3aY+!m;I`nlNaNM@eT`!1C zBcfJwSRNFlnHA3eU$Z9ZIY%|9Mf5te!_p~}SPl=EnMYJdQU>s8$&PL#Oqu`0uf0%F zhtnsv@?f!1Iy{3e=Cn}6)JKA1ABKAr=gA`d*e`Z_q1igPw$fa7((Co7CPX79l=rXd zH}cA_9HGX2=cF4bvro4|o-b?&#MjC5h4ZH4TCPrx7Ce@%XIcr>$xc5fY}*A^XCFG* zgMWT+<^1!R4J93FlEk-nay^>cm7bn@p`_98SE=@gSVvUbZPCf3IuhTbC6RP&b#!^i zXumjpgIdshGVAP>GtPj@;U)Q7vKc^mNMQ>{hDn!V99})nNw4{7C;ynp^QQ%}-q5yn z4LPP=L>Si_Ya8Dga%eUY-RWq1yY7W_7L~a_I0K>VbNx1O?COi0_u?o~;&Qm`c*0xfJruP%@Z$C_CXnuM}l z2t1+|idkaMB7k5IJ*P>a1@Il0sS(#tLKKeSBo{##PQ_*65xouCc5XxPV3LZHu5syPfH-Mc-A<2xR1 zF*v)DZ%>jM&*@^a`3}Cm33DW)3oB5P09Bb9)FQk5D{EFFS|$;prOGqYm}3gHgrxP` z^2RmhsGE!I{w;(=5_|zux z9in%z)@)w`)}i+pCzRkfX9uLY?phdW+BB@=1E#^Oh%ws>>Sl@CtN-``U*4+VbW zNp72iSpql2&ySMwNDIkfin=;rf34zb@GY;^BY@9P5uKc8F~W+`0Q~mswD^uj`wS3~ zcr+UM-L0*Z*h+!!kn^R(!IJr{a&MnY2_Cn4f;cJDJQ1diA(khVF6`XLxtBO38C5-3 zq3qp%@;O4;KBwd?ctM^YFn)0ftaVRctxUxx G{Qm%f8st9! literal 0 HcmV?d00001 diff --git a/client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step7.png b/client/ios/Tests/reference_snapshots/div-switch/base-properties_375@2x_step7.png new file mode 100644 index 0000000000000000000000000000000000000000..b7aa7909ad4d412b98f21cce88d8105adb060464 GIT binary patch literal 4897 zcmd5=i9eKG8y?1*Eh(CjEo&It4C6(1X)-8njIFYbUG{wm*=8szd&rWqGnGBU5HpM= zYe9JqzK9{Zh z004f;V=y2rBsS>}&$$|!-=H&nkpC8IdMiW6G1I{=dmqAyru)2uFx0yd%`*}36`X-j_}$ri$CvvX@az_7i_7;BkM<<1L!8ptJcFXWbYYtl z_)Pue&b1zhYmpjz8E&lfONQc#R(jdAJS`QM9_Zq{tDN{IsB|`a{y>X1NJt$oJr#91 zn(6Fp=I0%>AqlEf5pb^gw z2*|L-2bN;ai9+`hEuY;$W+X*#3_jFt^QTPPPiSWyI)r|o+t|Gn#-*VHx8&nWmcExf zc^=;%=Tgsmrsn)9nTdg=veYu|(y8AtLLo-rBF{Z+miW#KrC?DZ#%OKoO!rlo=1HA`nHH8PtiK1KQ z7Qh1FXnqfhdw^!sR%r&SrfJEYjE;uYWCB;^pmA7AL*f~X6q->H}Wei8R7?B!XGEb|_n-}N6L}x9%E6MUD)Uh1otK5&-$ecdM7j`>( zCS`UvD_X2tRr7*9a@pD1_xf@dVRnjA&CSNY?GHc`Q#{#2ifg>0vt$U-kW0F=fJu1CoQvtD3Sp%|y%@0gc5e-wdcl_V`G+I9m^jtYq9;Dn17yP;0>FRPqeBhe*r zaLvzxa0wr=A2qk^Z7i*=TN<02HCkI+wdz}K1Ydn}6PJ^d%hV4oBFJd2#0ad!HOHR> zzQVxlDv}=SUj7n3JFkZFbiA)DA1mp}i3448u_uc?H5n0v+UbI7P*rLwg7qj1DrNCc zc^H)MAvMkmT=S{>a)z8m%3@dK+3G1QXU##@vxUdZ21=q>fpV&-LSkh`G#m~$-re1; z5f&1fRoB*T5AgN%J=osf9tdrVWL5l~8lnDh_er3;wRq)06rhuBKL9UN$D7zI5D$w4m{*QE(%CJA^85btjS_qTU*7I zy(DQQl4Zq3q(8d85IO9-|74-0zHu-d_WUJ2C2d*sM`>y4R%d4?Hjk~i@o`f|ydR9B_$kk2Y*X|P%xW&g^o;}$E0hiTXT81s z0DnqxDdWQI69y-vYy*{o6or>1@Rw3P_wTbCKEsdNB0V({Cwd~9y*Qo2c=|E*36AZR z4bMy90@FdErtF5d@F~ukkm*dt_k!=(KQB4Rv{WaoYaFx^HC7R!er}8c0-3swPFfe= zj!top(yZixCIhYXK^aYNQAoI%yUYk8|!p**9y;AobJ zlA1L|c!z91dt-Jg5r<9a9edLoXd3g-f8I;n zK^}5TId!v@57Aw;Zk+Ew&e0ic^?5X7`vKH8U6)|Eh+~!o3!K5F1#a$5o9OV^Y!l9;U zJ$9i4lWP_DJr{k`OJK7*gTLw1R?yTKmoF_*YWm58g)!cq?6%w$-`VvP`q& zIjRt=3SOmM2^}bYR~eA5i@xgWnad|f^pfh%ehD)5?4S^wTT;acUS(&zBkT~~w;ofd zh5s8j-!g{!#F84fB-+mSq%bdN8l;H1Z-=6eFFoC+^jja%6Re}7L@{v=dM0%CI0IVC zCz{yYK8ue}*Dr#UdV({M)6`-_`3(zO3EoV-dhTyLC%52^8C6yo4j?Zt$k2z^ps2A< z5N=^()x2B=sUuy{AAW{9QT-XY0Szsy>7@;-lRx_nwJq@~>=FVfb77Giw7iX`(b0_I z`N^HhXm@KnyF&?Ll|_i%>l?Dzs#_IUi5Ya~Ti$HrZz0akhbzCs8?AGcdz)-gU3Hjm z1+z}7CtXOIR!dp+I$;82t;JLi4r&MPbmzvAh zyu7`muEEG+<|=7La8&_*eubB|U)(}zQhQewN@6Z+0@&(LFVZ)*pD#c>A?YC{RQ1M@ z&4^ogYZPkb=?fbxs|y0e;Jyrk!*{#^azw#LwM~@?WTFpz90+**Ng&fKx!yu{q>r-9 zYl_Ujb3*d-HPdd1wMO^Qlpb$vxSQw*H(=0vmlhZpcw%(O!0yKbNk{UpvzB^O33<1RP16)>fJ%S-zkL&(PrYWVgBx>XmG zpxZ~0>Ta&9Q_cz^i}8f02;cis9B)8ocGPNVV(*kv#rxP16T&8t3EFmvrl$69gs=jS zsINb*NH!%izaaYA^XyiG6b(o3US(FkgOx@uh-W*A3^7@chn|GIrElAxA!1z@a}S10 zjs{&kd%@=F8cgJ(?l%XaG@8kx7IAgK?*7pF^g5bb5eFU$@-!whJ8Ll+ruyWdfW)_k zq|PW~o?UcKmKV9s+XV$j=_yKpj4gn7b$@-Hc_VDt+SCO44L18+d_mp}uH03*7EYX* z+8^HLPna=OP(7)pBvP}eo5HKIBNpYyuq(Ck6G#1EE%nTZZ}hwIXznA&a|o_DhQ%-) z_`5OpOMjIX8o=z`N8@kLbo#fm-Y9tpYwKB1du+lL7q_UnwzAO~haQP1Ep=V&qe!l= z`I`znU*7CXk~d`)at-B6$B4g*+4NL92(7-r!WJG75FpAM={)4p`Q|=Pz1lcZU^*^j zoSsA(W}kXZJt^U!eZjXRBfTZBM@ytS$$e(G7^GOT9D5RJOkV5`W;@Lkt6c!ukv30t z(-9dM@ZlQsZ7hor$ywI_HD@~>q0xQS>z}z0yX%y%22^x^ zrf*G)s@%~id4O)fjp2%G6?pG+@W6LH)#WwLx-WbNjn_Po##gjivR+2_! zJ{DZGZv3%wFojoUadT0`N{xz5_~U)V#(gbxU~~85*BNuaxCObpJr4mshpGdH<@=I;{Wr1d%H4eDq*mMM(;JiAH5>hml|XGfyLN zLw*H$Gs#H_WpJ^N>gnLb6^^JhU?L(|dFf1!?=qzS8ga(kE7L~lc_aBVgFst=#;XJ^4-OF6kW(1FVs7BqI9A($VN#jGVePXz=55p zVq`=;D6>JuvXFgp2~Jf@RhsW-FSJD078sKQ27*yX+|#QFn2aRIG&DG9@>c-%S>X+iv&rL&_gNQtE)eIt#I9QAP3{@IALWtJQj2^TZIZ*?8z0|9KK8 zj;tb#E9+Bg?~;kx{LLXy&Z={9&tu=38;6r?x18sx(uFEO^c*VJDz}`z&lmC7*7|VD z@uKBH8^j*sjmqCeT!Nr^|e!8D$Tj{Q%n)a$U;|ye4!wh)3t0${sK_V=i#gM=o z=GotYE@>Br4yV6{9(L({;iLfXRGM{+h=ObPSPU_|?w&@;%I9`q`CZptw4Y?v+-w-_ zz~8gvY%l!PIXv_=>tvlFlGoa^vtc-TN(8QGHJU$#u7*pk(QW}1SQ@9uDQVw*iv0~q zo3(;D%Hh!SmlDt1dpIffa5~e{v~n#XLNq=?BQrxo^Wnl5XIgk5U@x?i8g^Q_Hd;;H ziIn{g6(ySu=ve`JhFEbjItZKd%aHUVj7~`RS|2R6Zghlddfruy53$HHqA+mztSyGj zj&&|E2no5a4d9IUZ7V|zDtZ0D)xa+QKjI(1OSku@i8|09HvnPIj5od^E`S7zde literal 0 HcmV?d00001 diff --git a/client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step0.png b/client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step0.png new file mode 100644 index 0000000000000000000000000000000000000000..e68462fc041621e79929fcbf76a549d155bb2b7c GIT binary patch literal 3719 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 F{s(5Z{OAAx literal 0 HcmV?d00001 diff --git a/client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step1.png b/client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step1.png new file mode 100644 index 0000000000000000000000000000000000000000..e20f35a78bdc445942659926fa692e9d47851589 GIT binary patch literal 3749 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 literal 0 HcmV?d00001 diff --git a/client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step3.png b/client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step3.png new file mode 100644 index 0000000000000000000000000000000000000000..7f966fcc2320da75c272c2a09423d469e5baf2db GIT binary patch literal 7071 zcmeHMXIzuX)(@!bf`ulyA_7vv(pywIs3-&otUy3YKt+O~E(8c2yA)Ac2!v({p@Z}; ziUbx(KthKAnn36R(h22#V7>d{-cRrQ<^6J>{3bJb=FBNG=YM8SCh`wcgA<&BoFEYB z1k_O990X#60fpz+Uw}7z^{a+J#fCOFxB@Eb5Sj*l1UTP>B4IF)4AA}+bcBr;bZDOh z_<-01K}QbSAdnH;*?-#RY`_1cVF!Vpp+JX!(%1s^{xbj+VD!(L{T2JaDA-`H4*k>S z*(ddMuxJ1(jz0};&>+xxwf(|&ElK$n@KOk+Z)OS9fRKYH68QcdDEoB;V4bKWZk7%L z9iM~hU$zWjn@eYT@wf7~ZYIcLA(GspUvGU#PW;+m5mTbabNLE8kIX4ak0Eg4T2&7C zq@<2;Xale?lIwqNx? z?A-T3hyUCB-_OIvt6wMD&uLbFyx*y}-T49eBXiyTA*hX4*Cyh;a*xY>T`6`6A&yp; zSI;}|C#d8w;Z14kXr?vo)(02S4wny~g;Uje^zepaFC-$cG5l0tDxvTfRD8rmo^L$Q zj#A4nqGis*BzO#Xn?JX3qBKxct49#1erm*G#HT|j+f;RIEI2+woa2tO(-TNK1eJdo zFYyMZAJF{m0i=+UW@N|*ZH_x!Qd)8aZ;CJP6@~G3fyK1wi+cDzq^Tq!Qi5*y@aEvn z^DrsckZUYB@*W?Luy=qc%uO|$m#WX}EpfTPy&#sD0QR_Gn4n)C`RhwHtyp43iUkKs zEK)6A)as&@VK+3PQjh=@8`6JlAS7(qJw(oZ42jbhf^y5Al_g9Qpmryy5TU!HN!hv4NzwI{i(<3Pq3EFgb_E-vDW7UE8<8EYR+ap9g zYl9K@X?CP`)Oy&7-aiYQ=QHyjG0}1j<@)K?o{(=yBr+@^p0$%WE^@b|P>K|m(dpMy z$v@WCHmyx>=o;wR()j5kZj!XQxw+!(Y#0Ar1L?q3@sD9+cBxtyp1l56zae|ljg;Fr z`O`DYWWSj!x@0p)AYA>$bCryp3Jy!}KeSHaiUNAKe)}6l6l7DbL4v8}9JC?rQL%U( zpOmTaVBYX-55Tjv1 z_v-x@MjIAHbV33ay51VBXX=D*jk$DYXa~mamcwmc&IUG^7WcDO!sfFZ7Gi{6I#?v= z@k^0pTZ{VSf8sg4q<3(5b-X8OFv}R{!en}Gd!ta(m3KFMj_sC<%$u=#cZdCoFwZO6 zRMVA)?3T}94qyZuq4ucYdaj02L%OL&)g0hNQ5S3Rq}RhE>B98AJ5T^X-L7$R{L$kyz>y0 zwTlb=UuI3TJJ?7KcfG|97Wy-e7$lU>VG-XoKU-XkFli4JZag#L0V~u9s}Qe}-m|#( zxiqj*z&nY?(BBW4S*2OIHHB-jTI~|;6KnIs{Z-fPyjmT4GH8{wKB8Rex*K=))0wP} zf3e3BJKhk5nVnLhrF!L9OVbRYbG7Kn4%+bR+Cpv43gdYT&D42MPSvsE%V`?wmUJ7x z1Mioyz}pt%9&avNi$?(b`EnJstGzk*P$@SINA1vMd@$-ZmC0!Jl=g@ zhI@MBjHWz(&V3y5DMHZIpJSO;V;0=if4fMEw3=bfBC&ZFt*9AS3riiq1$!Qr&JWWj z96~e+ojIc|u$rnf8@cG02?Qs-G{z%T^6ur8vgw0e2(LoO&CL0$fy@*lj{nJM!Gs4Q zY7)1DfGAd}mMZo5#}4(`%+~btzdrdMOmmbXrTku?i>;OFmpNyoG$DF@?TvlNC*vOa zd4-fNTjMw*95L*eQD$Zi{qH$$2HYhD(Uf>fKtLdDG5!W2s9Dn3Vi-?4Q}YvOC0V)Z z(xGs3sykP^?%sB^nRq0bb(16&ty;#{ss-sBrUs{OMLGA>!2X7`J8I^6ptT}8ARu6B zcZapNByfYU)ohT4r<3K%l$I-fy{~I0yg0xxz3}p1i~RayqEjbQ;@u^`0{UY$ z>oBl5y&ilJWWhy{?jy)CN>k5bsWip*z1?WBJ1JM5qScrZoDygka#wG=kf5Njt%HL@l$`Q{(`iL-x9GC` zDw{2CL}tDrosc~!T`?b~M1*vI3BlCia+@3f{MJ-ZEz=xsvQ(7T zzL=&EzD7748CZ3h*6dX=iWJ6AdbC~j4SoM6BH>$Lc26biV*u4;Ru$t1U8a+aUFw}J z%tPr_c*t-AB|huSG=>_-^k1X%&HvWYDr*DO-=18pgKCk_pH6T5-l?~&Qq2?`t}wm={|V?sTzKn&f=1$ z970g*gV(=P;w6|P0!wzr_=@9Q!40EfOo*oQ$49b<=}?Q)LP?Ni6>-U0&uzlBa6Eq_ zxl~=hf4ju9!q5U2brrwieS&?7kP^TChaLVIm&h3hhuyJ9yX805>quro{WBiSO+Ytq z2URE2%Sk$dkj%#2m*3d6)(j@ zmj5(w%LrpVy?_r5u-GnzkSZF!AU-V%KAoDzJc?xswtUS!2go*KM~xOrQ%+A8bGcaV zSuMF4S%j$0YGvCzf?Sx;GwU{p**gm4aC_e%M}mR;=hc4RGoL=|b*lf&Ga&2X=jG)a z>vwYsslqI!-@NwNcw>;R6Hq8p&dTOcyT9@=`Ie#>+Wu>T=sWfG+jD|CDu;EXEQWW zC&m8ZL8H-b;UU0*WF6CkOTQ1ek3ZVmyF>)V1i$(Xb1D;ZT0mf{n-I9nq!gFQKEgza zP~9)#l9Gbrkk1v`3n@#`vJublSTIHLef1B6e^>+t)*StZ1wwMs0S{4h*xtYlVn1q< zxKNd;`T6;+|FA&&`R&}qLt0x}vdjCpcb@QZUs}3~pJxsYrMxv%y~IYUe!D@)z28?V zZb$Qs9K8pT+CM$X+MlVvN^9=C>0f7B=2|wHZKimFBxX{PK$?G|cF7dw`inLUKNf;! zDE_XLcE9>OjFP6fex7ng|5UdrBN3VJx22DVbf&ZJi61bEC4wJVjTzvTH}hjFTcjx! z6%`mNL0wBr1!%2`KnAqgmUye=s0Bk!YpbiPPKIUNJf!k&wXEC^85tQK10)TIK)?G7 zQ<+UKTD5mpu=660F6l`>twFSrMAa^lA0$7{tyCe}M7S}qMB@RSIdj(PCQ(j)~!;TUVdp+PUSPZeYvKn2jn=%TLY|JAbKEf>a*AqWdUCR0i3}8B!uL@sbNd@rrz2-aH}YjkX;F>ZjP7d< zs0Hq!g%C;1s4@LukOdpzSisGS>6dONPo8vhU(T$ka^eJe^N8fD!0`0sM4~79#)KWB z+4sRo$K;?FkT@h5Rm-;hma#RoqFB}N&Kt(@krGi<8+>#pksdR&Yoygo$}?F~@rT~t zTK^@F9)QfRfDksIpMOv42LvMHiR|^guB*0m7Qz>9k(!$7*w+^;eN;i%%GoH*%DJz^ zO&E=ZX4yn2RdiRobQX$zNlwg<5;WSrdph*)UEj5~1Su|y?HhHDk&gnBA#i6rq`Q_G zmW9H+D)*Q>He8Xc-B)4~9jqIE%))TT-~I$jCIXT$nmgp{rqSC03@)6|p>^u$Ocy zYflg*MmZEmeE1o`hWgNqGIr~c$Epd�}PlTtc+wGFG1q=6>#Z=)YITgcqockf1t? zS$wR0&A3ePcz$g^*V1pD1Y-ek2NLc6dWPP!G_97ln|it)i@%17oz9wB#iFsw%+Ho!;Bp&T*HW)G}?_$yIzOqs7RVz(&w9y9IM4j zQT6f9z_5I^Uiers-4{DWTb=E1jG7P=am^me_kZ?lS@%sOymn$H-nym!Ocsu%0#G&^(Q&sM2!zeE|xvBg2Yi zGoC&*%fDquPOX2R1oFo{g#@i$;fnU5jmoAK#m_v!RWy#W#;CG!aND>5V1_**_d|D( zw*38t>uC)QJ7uR8?Cbwr7~L5*&A2u)@dLXSzPn9YcI_PIEQ>0eu&s8e@Joh5!H(iE zLP{z`eq#k|4CBtC337?tq6O+mNy&m z>0F$4a!N+=>896Cl*lPlF>U!Py@t^g&q@H5Ouz(UExIULV?4Us@vs-Qyl_0L^_hrg z8jwxSU|H)6W21wEfnnUdy^~YRD>Yjo!?^k3O5UtCbB~Hj7k*^Hh!3JLN9Od{)b;qb z#>;ph2%~I8YnPNp21`-wKS(JB8j^~9wq9Pv?*moC*X9P%nc=&Wx*ndp^E2yXdy8E1 zhlYlRf=YpzAQ!&gp2o7etcq8Icj|Uc!;9CaceaE=GeRq&)JoT9+95W16hB^K>N$~| zrd1{RwNlSGFjdYH&uJeMNuf|y)!BAv&bZ`JiB893mhc?H>8*i$2T5Z-LgR%Su5KPG zHK}rCzHLtVO6#@sc5T12b#oGM05!*O#3R|Wr6O1@0|T=cP*bpsqeIa5XiB&z_Rb}{ zz0lp|@%IHM!0qKTD(X*jIWoryFJo>KIm!wc$+p+WlcHCr>Ic;Cv}1>l-5~Di@?WlA z!k5Fl$emRX8%SxU);eE~V$&sUvncc8^#o^IKU9KF$+2!2HKw}w!&?4XQ|HYfcNxc> zZFxgcKbl8{C&oLOj^PNQ!CiK2h4#P?z!Q`0Dw|%Y;%@zE>!kN`3BArfPicL(Tg-2} z)>C1NX*u0N?FHV^kYnB#sbt=Fo)5M)i)4pq^J<^g)iJ7}9hE4txfRXemmZR>Hk#OsGrgyShl|loXjY=+{!AIlADWic?JR2FC;qeP$a)%Nqr|904ack z_Yj-%eV~VfFIFkg`odgs2v+Vtdo05y^0$BJNC5)?@IsFtZUzBF5+-_0En0tWtR_p|jNFyP;Mu1;9L|E#!xez>oz zKE7E`?>I0V+H_dLWE6gaCF|%M{U1HYv5uQEjrE-z|Ecy*gZ87xznS`9gMhXBXN4#a zvo>e>-qp3c{lUAgt}e*nAw%`yN0 literal 0 HcmV?d00001 diff --git a/client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step4.png b/client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step4.png new file mode 100644 index 0000000000000000000000000000000000000000..7f966fcc2320da75c272c2a09423d469e5baf2db GIT binary patch literal 7071 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�}PlTtc+wGFG1q=6>#Z=)YITgcqockf1t? zS$wR0&A3ePcz$g^*V1pD1Y-ek2NLc6dWPP!G_97ln|it)i@%17oz9wB#iFsw%+Ho!;Bp&T*HW)G}?_$yIzOqs7RVz(&w9y9IM4j zQT6f9z_5I^Uiers-4{DWTb=E1jG7P=am^me_kZ?lS@%sOymn$H-nym!Ocsu%0#G&^(Q&sM2!zeE|xvBg2Yi zGoC&*%fDquPOX2R1oFo{g#@i$;fnU5jmoAK#m_v!RWy#W#;CG!aND>5V1_**_d|D( zw*38t>uC)QJ7uR8?Cbwr7~L5*&A2u)@dLXSzPn9YcI_PIEQ>0eu&s8e@Joh5!H(iE zLP{z`eq#k|4CBtC337?tq6O+mNy&m z>0F$4a!N+=>896Cl*lPlF>U!Py@t^g&q@H5Ouz(UExIULV?4Us@vs-Qyl_0L^_hrg z8jwxSU|H)6W21wEfnnUdy^~YRD>Yjo!?^k3O5UtCbB~Hj7k*^Hh!3JLN9Od{)b;qb z#>;ph2%~I8YnPNp21`-wKS(JB8j^~9wq9Pv?*moC*X9P%nc=&Wx*ndp^E2yXdy8E1 zhlYlRf=YpzAQ!&gp2o7etcq8Icj|Uc!;9CaceaE=GeRq&)JoT9+95W16hB^K>N$~| zrd1{RwNlSGFjdYH&uJeMNuf|y)!BAv&bZ`JiB893mhc?H>8*i$2T5Z-LgR%Su5KPG zHK}rCzHLtVO6#@sc5T12b#oGM05!*O#3R|Wr6O1@0|T=cP*bpsqeIa5XiB&z_Rb}{ zz0lp|@%IHM!0qKTD(X*jIWoryFJo>KIm!wc$+p+WlcHCr>Ic;Cv}1>l-5~Di@?WlA z!k5Fl$emRX8%SxU);eE~V$&sUvncc8^#o^IKU9KF$+2!2HKw}w!&?4XQ|HYfcNxc> zZFxgcKbl8{C&oLOj^PNQ!CiK2h4#P?z!Q`0Dw|%Y;%@zE>!kN`3BArfPicL(Tg-2} z)>C1NX*u0N?FHV^kYnB#sbt=Fo)5M)i)4pq^J<^g)iJ7}9hE4txfRXemmZR>Hk#OsGrgyShl|loXjY=+{!AIlADWic?JR2FC;qeP$a)%Nqr|904ack z_Yj-%eV~VfFIFkg`odgs2v+Vtdo05y^0$BJNC5)?@IsFtZUzBF5+-_0En0tWtR_p|jNFyP;Mu1;9L|E#!xez>oz zKE7E`?>I0V+H_dLWE6gaCF|%M{U1HYv5uQEjrE-z|Ecy*gZ87xznS`9gMhXBXN4#a zvo>e>-qp3c{lUAgt}e*nAw%`yN0 literal 0 HcmV?d00001 diff --git a/client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step5.png b/client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step5.png new file mode 100644 index 0000000000000000000000000000000000000000..7f966fcc2320da75c272c2a09423d469e5baf2db GIT binary patch literal 7071 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�}PlTtc+wGFG1q=6>#Z=)YITgcqockf1t? zS$wR0&A3ePcz$g^*V1pD1Y-ek2NLc6dWPP!G_97ln|it)i@%17oz9wB#iFsw%+Ho!;Bp&T*HW)G}?_$yIzOqs7RVz(&w9y9IM4j zQT6f9z_5I^Uiers-4{DWTb=E1jG7P=am^me_kZ?lS@%sOymn$H-nym!Ocsu%0#G&^(Q&sM2!zeE|xvBg2Yi zGoC&*%fDquPOX2R1oFo{g#@i$;fnU5jmoAK#m_v!RWy#W#;CG!aND>5V1_**_d|D( zw*38t>uC)QJ7uR8?Cbwr7~L5*&A2u)@dLXSzPn9YcI_PIEQ>0eu&s8e@Joh5!H(iE zLP{z`eq#k|4CBtC337?tq6O+mNy&m z>0F$4a!N+=>896Cl*lPlF>U!Py@t^g&q@H5Ouz(UExIULV?4Us@vs-Qyl_0L^_hrg z8jwxSU|H)6W21wEfnnUdy^~YRD>Yjo!?^k3O5UtCbB~Hj7k*^Hh!3JLN9Od{)b;qb z#>;ph2%~I8YnPNp21`-wKS(JB8j^~9wq9Pv?*moC*X9P%nc=&Wx*ndp^E2yXdy8E1 zhlYlRf=YpzAQ!&gp2o7etcq8Icj|Uc!;9CaceaE=GeRq&)JoT9+95W16hB^K>N$~| zrd1{RwNlSGFjdYH&uJeMNuf|y)!BAv&bZ`JiB893mhc?H>8*i$2T5Z-LgR%Su5KPG zHK}rCzHLtVO6#@sc5T12b#oGM05!*O#3R|Wr6O1@0|T=cP*bpsqeIa5XiB&z_Rb}{ zz0lp|@%IHM!0qKTD(X*jIWoryFJo>KIm!wc$+p+WlcHCr>Ic;Cv}1>l-5~Di@?WlA z!k5Fl$emRX8%SxU);eE~V$&sUvncc8^#o^IKU9KF$+2!2HKw}w!&?4XQ|HYfcNxc> zZFxgcKbl8{C&oLOj^PNQ!CiK2h4#P?z!Q`0Dw|%Y;%@zE>!kN`3BArfPicL(Tg-2} z)>C1NX*u0N?FHV^kYnB#sbt=Fo)5M)i)4pq^J<^g)iJ7}9hE4txfRXemmZR>Hk#OsGrgyShl|loXjY=+{!AIlADWic?JR2FC;qeP$a)%Nqr|904ack z_Yj-%eV~VfFIFkg`odgs2v+Vtdo05y^0$BJNC5)?@IsFtZUzBF5+-_0En0tWtR_p|jNFyP;Mu1;9L|E#!xez>oz zKE7E`?>I0V+H_dLWE6gaCF|%M{U1HYv5uQEjrE-z|Ecy*gZ87xznS`9gMhXBXN4#a zvo>e>-qp3c{lUAgt}e*nAw%`yN0 literal 0 HcmV?d00001 diff --git a/client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step6.png b/client/ios/Tests/reference_snapshots/div-switch/base-properties_414@3x_step6.png new file mode 100644 index 0000000000000000000000000000000000000000..5869ec3df6f9275547149f79228a9bd165ebeca7 GIT binary patch literal 10430 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 literal 0 HcmV?d00001 diff --git a/client/ios/Tests/reference_snapshots/div-switch/switch-properties_414@3x_step0.png b/client/ios/Tests/reference_snapshots/div-switch/switch-properties_414@3x_step0.png new file mode 100644 index 0000000000000000000000000000000000000000..f4573af356f05b828edc298a3f8a4b0f6d70ec08 GIT binary patch literal 4583 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 literal 0 HcmV?d00001 diff --git a/client/ios/Tests/reference_snapshots/div-switch/switch-properties_414@3x_step3.png b/client/ios/Tests/reference_snapshots/div-switch/switch-properties_414@3x_step3.png new file mode 100644 index 0000000000000000000000000000000000000000..285299a145257fce223fbe4fc76be5292b6578b3 GIT binary patch literal 4246 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 PHyxm_W2{}Nk`Ig literal 0 HcmV?d00001 diff --git a/schema/div-switch.json b/schema/div-switch.json new file mode 100644 index 000000000..9f066837e --- /dev/null +++ b/schema/div-switch.json @@ -0,0 +1,38 @@ +{ + "$description": "translations.json#/div_switch", + "allOf": [ + { + "$ref": "div-base.json" + }, + { + "properties": { + "type": { + "type": "string", + "enum": [ + "switch" + ] + }, + "is_on_variable": { + "$ref": "div-variable-name.json", + "$description": "translations.json#/div_switch_is_on_variable" + }, + "is_enabled": { + "$ref": "common.json#/boolean_int", + "default_value": "true", + "$description": "translations.json#/div_switch_is_enabled" + }, + "on_color": { + "$ref": "common.json#/color", + "$description": "translations.json#/div_switch_on_color" + } + } + } + ], + "platforms": [ + "ios" + ], + "required": [ + "type", + "is_on_variable" + ] +} diff --git a/schema/div.json b/schema/div.json index 588350f7b..ad774a29d 100644 --- a/schema/div.json +++ b/schema/div.json @@ -54,6 +54,10 @@ "$ref": "div-slider.json", "$description": "translations.json#/div_slider_short" }, + { + "$ref": "div-switch.json", + "$description": "translations.json#/div_switch_short" + }, { "$ref": "div-input.json", "$description": "translations.json#/div_input_short" diff --git a/schema/translations.json b/schema/translations.json index 8f3d736b0..8a74c46c4 100644 --- a/schema/translations.json +++ b/schema/translations.json @@ -2071,6 +2071,26 @@ "en": "Stroke width.", "ru": "Толщина рамки." }, + "div_switch": { + "en": "A two-state switch that allows user to toggle a boolean variable. The element has a different appearance depending on the platform. On iOS, the switch size is fixed.", + "ru": "Переключатель с двумя состояниями, который позволяет пользователю переключать булевую переменную. Элемент имеет разный вид в зависимости от платформы. На iOS размер переключателя фиксированный." + }, + "div_switch_short": { + "en": "Switch.", + "ru": "Переключатель." + }, + "div_switch_is_on_variable": { + "en": "The name of the boolean variable for the switch.", + "ru": "Название булевой переменной для переключателя." + }, + "div_switch_is_enabled": { + "en": "Enables or disables the ability to switch an element.", + "ru": "Включает или отключает возможность переключения элемента." + }, + "div_switch_on_color": { + "en": "The color of the switch when it is on. If no color is specified, the default system color is used on iOS, and the color specified in `Div2Context` is used on Android.", + "ru": "Цвет переключателя во включенном состоянии. Если цвет не указан, то на iOS используется стандартный системный цвет, на Android используется цвет, указанный в `Div2Context`." + }, "div_tabs": { "en": "Tabs. Height of the first tab is determined by its contents, and height of the remaining [depends on the platform](../../location#tabs).", "ru": "Табы. Высота первого таба определяется его содержимым, а высота остальных [зависит от платформы](../../location#tabs)." diff --git a/test_data/interactive_snapshot_test_data/div-switch/base-properties.json b/test_data/interactive_snapshot_test_data/div-switch/base-properties.json new file mode 100644 index 000000000..051a45691 --- /dev/null +++ b/test_data/interactive_snapshot_test_data/div-switch/base-properties.json @@ -0,0 +1,244 @@ +{ + "description": "Switch with base properties", + "platforms": [ + "ios" + ], + "div_data": { + "card": { + "log_id": "tests", + "variables": [ + { + "name": "alpha", + "type": "number", + "value": 1.0 + }, + { + "name": "background_color", + "type": "color", + "value": "#FFFFCC" + }, + { + "name": "border_corner_radius", + "type": "integer", + "value": 0 + }, + { + "name": "border_stroke_color", + "type": "color", + "value": "#0000FF" + }, + { + "name": "border_stroke_width", + "type": "number", + "value": 1 + }, + { + "name": "margins", + "type": "integer", + "value": 0 + }, + { + "name": "paddings", + "type": "integer", + "value": 0 + }, + { + "name": "height_value", + "type": "integer", + "value": 250 + }, + { + "name": "width_value", + "type": "integer", + "value": 300 + }, + { + "name": "alignment_horizontal", + "type": "string", + "value": "left" + }, + { + "name": "alignment_vertical", + "type": "string", + "value": "top" + }, + { + "name": "switch_value", + "type": "boolean", + "value": false + } + ], + "states": [ + { + "state_id": 0, + "div": { + "type": "switch", + "is_on_variable": "switch_value", + "alpha": "@{alpha}", + "alignment_horizontal": "@{alignment_horizontal}", + "alignment_vertical": "@{alignment_vertical}", + "background": [ + { + "type": "solid", + "color": "@{background_color}" + } + ], + "border": { + "corner_radius": "@{border_corner_radius}", + "stroke": { + "color": "@{border_stroke_color}", + "width": "@{border_stroke_width}" + } + }, + "paddings": { + "left": "@{paddings}", + "top": "@{paddings}", + "right": "@{paddings}", + "bottom": "@{paddings}" + }, + "margins": { + "left": "@{margins}", + "top": "@{margins}", + "right": "@{margins}", + "bottom": "@{margins}" + }, + "width": { + "type": "fixed", + "value": "@{width_value}" + }, + "height": { + "type": "fixed", + "value": "@{height_value}" + } + } + } + ] + } + }, + "steps": [ + { + "expected_screenshot": "step0.png" + }, + { + "div_actions": [ + { + "url": "div-action://set_variable?name=background_color&value=%2370A1A1A1", + "log_id": "background_color" + } + ] + }, + { + "div_actions": [ + { + "url": "div-action://set_variable?name=margins&value=15", + "log_id": "margins" + } + ] + }, + { + "div_actions": [ + { + "url": "div-action://set_variable?name=paddings&value=15", + "log_id": "paddings" + } + ] + }, + { + "div_actions": [ + { + "url": "div-action://set_variable?name=width_value&value=150", + "log_id": "width" + }, + { + "url": "div-action://set_variable?name=height_value&value=100", + "log_id": "height" + } + ] + }, + { + "div_actions": [ + { + "url": "div-action://set_variable?name=alignment_vertical&value=bottom", + "log_id": "alignment_vertical" + }, + { + "url": "div-action://set_variable?name=alignment_horizontal&value=right", + "log_id": "alignment_horizontal" + } + ] + }, + { + "div_actions": [ + { + "url": "div-action://set_variable?name=border_corner_radius&value=15", + "log_id": "border_corner_radius" + }, + { + "url": "div-action://set_variable?name=border_stroke_color&value=%237000FF00", + "log_id": "border_stroke_color" + }, + { + "url": "div-action://set_variable?name=border_stroke_width&value=3", + "log_id": "border_stroke_width" + } + ] + }, + { + "div_actions": [ + { + "url": "div-action://set_variable?name=alpha&value=0.2", + "log_id": "alpha" + } + ] + }, + { + "div_actions": [ + { + "url": "div-action://set_variable?name=alpha&value=1.0", + "log_id": "restore: alpha" + }, + { + "url": "div-action://set_variable?name=background_color&value=%23FFFFCC", + "log_id": "restore: background_color" + }, + { + "url": "div-action://set_variable?name=border_corner_radius&value=0", + "log_id": "restore: border_corner_radius" + }, + { + "url": "div-action://set_variable?name=border_stroke_color&value=%230000FF", + "log_id": "restore: border_stroke_color" + }, + { + "url": "div-action://set_variable?name=border_stroke_width&value=1", + "log_id": "restore: border_stroke_width" + }, + { + "url": "div-action://set_variable?name=margins&value=0", + "log_id": "restore: margins" + }, + { + "url": "div-action://set_variable?name=paddings&value=0", + "log_id": "restore: paddings" + }, + { + "url": "div-action://set_variable?name=height_value&value=250", + "log_id": "restore: height_value" + }, + { + "url": "div-action://set_variable?name=width_value&value=300", + "log_id": "restore: width_value" + }, + { + "url": "div-action://set_variable?name=alignment_horizontal&value=left", + "log_id": "restore: alignment_horizontal" + }, + { + "url": "div-action://set_variable?name=alignment_vertical&value=top", + "log_id": "restore: alignment_vertical" + } + ], + "expected_screenshot": "step0.png" + } + ] +} diff --git a/test_data/interactive_snapshot_test_data/div-switch/switch-properties.json b/test_data/interactive_snapshot_test_data/div-switch/switch-properties.json new file mode 100644 index 000000000..f162fcd30 --- /dev/null +++ b/test_data/interactive_snapshot_test_data/div-switch/switch-properties.json @@ -0,0 +1,68 @@ +{ + "description": "Switch properties", + "platforms": [ + "ios" + ], + "div_data": { + "card": { + "log_id": "tests", + "variables": [ + { + "name": "switch_value", + "type": "boolean", + "value": false + }, + { + "name": "on_color_var", + "type": "color", + "value": "#FFFFFF" + }, + { + "name": "switch_enabled", + "type": "boolean", + "value": true + } + ], + "states": [ + { + "state_id": 0, + "div": { + "type": "switch", + "is_on_variable": "switch_value", + "is_enabled": "@{switch_enabled}", + "on_color": "@{on_color_var}" + } + } + ] + } + }, + "steps": [ + { + "expected_screenshot": "step0.png" + }, + { + "div_actions": [ + { + "url": "div-action://set_variable?name=switch_value&value=true", + "log_id": "switch_value" + } + ] + }, + { + "div_actions": [ + { + "url": "div-action://set_variable?name=on_color_var&value=%232a35ad", + "log_id": "change_color" + } + ] + }, + { + "div_actions": [ + { + "url": "div-action://set_variable?name=switch_enabled&value=false", + "log_id": "disable_switch" + } + ] + } + ] +}