[ios] MGLTransition implemented for style layer properties

12 files changed, 722 insertions, 33 deletions

diff --git a/platform/darwin/src/MGLBackgroundStyleLayer.mm b/platform/darwin/src/MGLBackgroundStyleLayer.mm
index bcad0aa11b..63c687b77a 100644
--- a/platform/darwin/src/MGLBackgroundStyleLayer.mm
+++ b/platform/darwin/src/MGLBackgroundStyleLayer.mm
@@ -4,6 +4,7 @@
 #import "MGLSource.h"
 #import "MGLMapView_Private.h"
 #import "NSPredicate+MGLAdditions.h"
+#import "NSDate+MGLAdditions.h"
 #import "MGLStyleLayer_Private.h"
 #import "MGLStyleValue_Private.h"
 #import "MGLBackgroundStyleLayer.h"
@@ -84,6 +85,16 @@
 
 #pragma mark - Accessing the Paint Attributes
 
+- (NSArray *)transitionKeys
+{
+    NSMutableArray *transitionKeys = [NSMutableArray array];
+    [transitionKeys addObject:@"backgroundColor"];
+    [transitionKeys addObject:@"backgroundOpacity"];
+    [transitionKeys addObject:@"backgroundPattern"];
+
+    return transitionKeys;
+}
+
 - (void)setBackgroundColor:(MGLStyleValue<MGLColor *> *)backgroundColor {
     MGLAssertStyleLayerIsValid();
 
@@ -91,6 +102,16 @@
     self.rawLayer->setBackgroundColor(mbglValue);
 }
 
+- (void)mbx_setBackgroundColorTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setBackgroundColorTransition(options);
+}
+
 - (MGLStyleValue<MGLColor *> *)backgroundColor {
     MGLAssertStyleLayerIsValid();
 
@@ -108,6 +129,16 @@
     self.rawLayer->setBackgroundOpacity(mbglValue);
 }
 
+- (void)mbx_setBackgroundOpacityTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setBackgroundOpacityTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)backgroundOpacity {
     MGLAssertStyleLayerIsValid();
 
@@ -125,6 +156,16 @@
     self.rawLayer->setBackgroundPattern(mbglValue);
 }
 
+- (void)mbx_setBackgroundPatternTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setBackgroundPatternTransition(options);
+}
+
 - (MGLStyleValue<NSString *> *)backgroundPattern {
     MGLAssertStyleLayerIsValid();
 
diff --git a/platform/darwin/src/MGLCircleStyleLayer.mm b/platform/darwin/src/MGLCircleStyleLayer.mm
index 808e00bc38..362667121a 100644
--- a/platform/darwin/src/MGLCircleStyleLayer.mm
+++ b/platform/darwin/src/MGLCircleStyleLayer.mm
@@ -4,6 +4,7 @@
 #import "MGLSource.h"
 #import "MGLMapView_Private.h"
 #import "NSPredicate+MGLAdditions.h"
+#import "NSDate+MGLAdditions.h"
 #import "MGLStyleLayer_Private.h"
 #import "MGLStyleValue_Private.h"
 #import "MGLCircleStyleLayer.h"
@@ -134,6 +135,26 @@ namespace mbgl {
 
 #pragma mark - Accessing the Paint Attributes
 
+- (NSArray *)transitionKeys
+{
+    NSMutableArray *transitionKeys = [NSMutableArray array];
+    [transitionKeys addObject:@"circleBlur"];
+    [transitionKeys addObject:@"circleColor"];
+    [transitionKeys addObject:@"circleOpacity"];
+    [transitionKeys addObject:@"circleRadius"];
+    [transitionKeys addObject:@"circleScaleAlignment"];
+    [transitionKeys addObject:@"circlePitchScale"];
+    [transitionKeys addObject:@"circleStrokeColor"];
+    [transitionKeys addObject:@"circleStrokeOpacity"];
+    [transitionKeys addObject:@"circleStrokeWidth"];
+    [transitionKeys addObject:@"circleTranslation"];
+    [transitionKeys addObject:@"circleTranslate"];
+    [transitionKeys addObject:@"circleTranslationAnchor"];
+    [transitionKeys addObject:@"circleTranslateAnchor"];
+
+    return transitionKeys;
+}
+
 - (void)setCircleBlur:(MGLStyleValue<NSNumber *> *)circleBlur {
     MGLAssertStyleLayerIsValid();
 
@@ -141,6 +162,16 @@ namespace mbgl {
     self.rawLayer->setCircleBlur(mbglValue);
 }
 
+- (void)mbx_setCircleBlurTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setCircleBlurTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)circleBlur {
     MGLAssertStyleLayerIsValid();
 
@@ -158,6 +189,16 @@ namespace mbgl {
     self.rawLayer->setCircleColor(mbglValue);
 }
 
+- (void)mbx_setCircleColorTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setCircleColorTransition(options);
+}
+
 - (MGLStyleValue<MGLColor *> *)circleColor {
     MGLAssertStyleLayerIsValid();
 
@@ -175,6 +216,16 @@ namespace mbgl {
     self.rawLayer->setCircleOpacity(mbglValue);
 }
 
+- (void)mbx_setCircleOpacityTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setCircleOpacityTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)circleOpacity {
     MGLAssertStyleLayerIsValid();
 
@@ -192,6 +243,16 @@ namespace mbgl {
     self.rawLayer->setCircleRadius(mbglValue);
 }
 
+- (void)mbx_setCircleRadiusTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setCircleRadiusTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)circleRadius {
     MGLAssertStyleLayerIsValid();
 
@@ -209,6 +270,16 @@ namespace mbgl {
     self.rawLayer->setCirclePitchScale(mbglValue);
 }
 
+- (void)mbx_setCircleScaleAlignmentTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setCirclePitchScaleTransition(options);
+}
+
 - (MGLStyleValue<NSValue *> *)circleScaleAlignment {
     MGLAssertStyleLayerIsValid();
 
@@ -233,6 +304,16 @@ namespace mbgl {
     self.rawLayer->setCircleStrokeColor(mbglValue);
 }
 
+- (void)mbx_setCircleStrokeColorTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setCircleStrokeColorTransition(options);
+}
+
 - (MGLStyleValue<MGLColor *> *)circleStrokeColor {
     MGLAssertStyleLayerIsValid();
 
@@ -250,6 +331,16 @@ namespace mbgl {
     self.rawLayer->setCircleStrokeOpacity(mbglValue);
 }
 
+- (void)mbx_setCircleStrokeOpacityTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setCircleStrokeOpacityTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)circleStrokeOpacity {
     MGLAssertStyleLayerIsValid();
 
@@ -267,6 +358,16 @@ namespace mbgl {
     self.rawLayer->setCircleStrokeWidth(mbglValue);
 }
 
+- (void)mbx_setCircleStrokeWidthTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setCircleStrokeWidthTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)circleStrokeWidth {
     MGLAssertStyleLayerIsValid();
 
@@ -284,6 +385,16 @@ namespace mbgl {
     self.rawLayer->setCircleTranslate(mbglValue);
 }
 
+- (void)mbx_setCircleTranslationTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setCircleTranslateTransition(options);
+}
+
 - (MGLStyleValue<NSValue *> *)circleTranslation {
     MGLAssertStyleLayerIsValid();
 
@@ -308,6 +419,16 @@ namespace mbgl {
     self.rawLayer->setCircleTranslateAnchor(mbglValue);
 }
 
+- (void)mbx_setCircleTranslationAnchorTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setCircleTranslateAnchorTransition(options);
+}
+
 - (MGLStyleValue<NSValue *> *)circleTranslationAnchor {
     MGLAssertStyleLayerIsValid();
 
diff --git a/platform/darwin/src/MGLFillStyleLayer.mm b/platform/darwin/src/MGLFillStyleLayer.mm
index 6716e0efb1..81df8f4e0e 100644
--- a/platform/darwin/src/MGLFillStyleLayer.mm
+++ b/platform/darwin/src/MGLFillStyleLayer.mm
@@ -4,6 +4,7 @@
 #import "MGLSource.h"
 #import "MGLMapView_Private.h"
 #import "NSPredicate+MGLAdditions.h"
+#import "NSDate+MGLAdditions.h"
 #import "MGLStyleLayer_Private.h"
 #import "MGLStyleValue_Private.h"
 #import "MGLFillStyleLayer.h"
@@ -129,6 +130,23 @@ namespace mbgl {
 
 #pragma mark - Accessing the Paint Attributes
 
+- (NSArray *)transitionKeys
+{
+    NSMutableArray *transitionKeys = [NSMutableArray array];
+    [transitionKeys addObject:@"fillAntialiased"];
+    [transitionKeys addObject:@"fillAntialias"];
+    [transitionKeys addObject:@"fillColor"];
+    [transitionKeys addObject:@"fillOpacity"];
+    [transitionKeys addObject:@"fillOutlineColor"];
+    [transitionKeys addObject:@"fillPattern"];
+    [transitionKeys addObject:@"fillTranslation"];
+    [transitionKeys addObject:@"fillTranslate"];
+    [transitionKeys addObject:@"fillTranslationAnchor"];
+    [transitionKeys addObject:@"fillTranslateAnchor"];
+
+    return transitionKeys;
+}
+
 - (void)setFillAntialiased:(MGLStyleValue<NSNumber *> *)fillAntialiased {
     MGLAssertStyleLayerIsValid();
 
@@ -136,6 +154,16 @@ namespace mbgl {
     self.rawLayer->setFillAntialias(mbglValue);
 }
 
+- (void)mbx_setFillAntialiasedTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setFillAntialiasTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)isFillAntialiased {
     MGLAssertStyleLayerIsValid();
 
@@ -160,6 +188,16 @@ namespace mbgl {
     self.rawLayer->setFillColor(mbglValue);
 }
 
+- (void)mbx_setFillColorTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setFillColorTransition(options);
+}
+
 - (MGLStyleValue<MGLColor *> *)fillColor {
     MGLAssertStyleLayerIsValid();
 
@@ -177,6 +215,16 @@ namespace mbgl {
     self.rawLayer->setFillOpacity(mbglValue);
 }
 
+- (void)mbx_setFillOpacityTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setFillOpacityTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)fillOpacity {
     MGLAssertStyleLayerIsValid();
 
@@ -194,6 +242,16 @@ namespace mbgl {
     self.rawLayer->setFillOutlineColor(mbglValue);
 }
 
+- (void)mbx_setFillOutlineColorTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setFillOutlineColorTransition(options);
+}
+
 - (MGLStyleValue<MGLColor *> *)fillOutlineColor {
     MGLAssertStyleLayerIsValid();
 
@@ -211,6 +269,16 @@ namespace mbgl {
     self.rawLayer->setFillPattern(mbglValue);
 }
 
+- (void)mbx_setFillPatternTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setFillPatternTransition(options);
+}
+
 - (MGLStyleValue<NSString *> *)fillPattern {
     MGLAssertStyleLayerIsValid();
 
@@ -228,6 +296,16 @@ namespace mbgl {
     self.rawLayer->setFillTranslate(mbglValue);
 }
 
+- (void)mbx_setFillTranslationTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setFillTranslateTransition(options);
+}
+
 - (MGLStyleValue<NSValue *> *)fillTranslation {
     MGLAssertStyleLayerIsValid();
 
@@ -252,6 +330,16 @@ namespace mbgl {
     self.rawLayer->setFillTranslateAnchor(mbglValue);
 }
 
+- (void)mbx_setFillTranslationAnchorTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setFillTranslateAnchorTransition(options);
+}
+
 - (MGLStyleValue<NSValue *> *)fillTranslationAnchor {
     MGLAssertStyleLayerIsValid();
 
diff --git a/platform/darwin/src/MGLLineStyleLayer.mm b/platform/darwin/src/MGLLineStyleLayer.mm
index 80b1e907e6..1b44f620f1 100644
--- a/platform/darwin/src/MGLLineStyleLayer.mm
+++ b/platform/darwin/src/MGLLineStyleLayer.mm
@@ -4,6 +4,7 @@
 #import "MGLSource.h"
 #import "MGLMapView_Private.h"
 #import "NSPredicate+MGLAdditions.h"
+#import "NSDate+MGLAdditions.h"
 #import "MGLStyleLayer_Private.h"
 #import "MGLStyleValue_Private.h"
 #import "MGLLineStyleLayer.h"
@@ -211,6 +212,26 @@ namespace mbgl {
 
 #pragma mark - Accessing the Paint Attributes
 
+- (NSArray *)transitionKeys
+{
+    NSMutableArray *transitionKeys = [NSMutableArray array];
+    [transitionKeys addObject:@"lineBlur"];
+    [transitionKeys addObject:@"lineColor"];
+    [transitionKeys addObject:@"lineDashPattern"];
+    [transitionKeys addObject:@"lineDasharray"];
+    [transitionKeys addObject:@"lineGapWidth"];
+    [transitionKeys addObject:@"lineOffset"];
+    [transitionKeys addObject:@"lineOpacity"];
+    [transitionKeys addObject:@"linePattern"];
+    [transitionKeys addObject:@"lineTranslation"];
+    [transitionKeys addObject:@"lineTranslate"];
+    [transitionKeys addObject:@"lineTranslationAnchor"];
+    [transitionKeys addObject:@"lineTranslateAnchor"];
+    [transitionKeys addObject:@"lineWidth"];
+
+    return transitionKeys;
+}
+
 - (void)setLineBlur:(MGLStyleValue<NSNumber *> *)lineBlur {
     MGLAssertStyleLayerIsValid();
 
@@ -218,6 +239,16 @@ namespace mbgl {
     self.rawLayer->setLineBlur(mbglValue);
 }
 
+- (void)mbx_setLineBlurTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setLineBlurTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)lineBlur {
     MGLAssertStyleLayerIsValid();
 
@@ -235,6 +266,16 @@ namespace mbgl {
     self.rawLayer->setLineColor(mbglValue);
 }
 
+- (void)mbx_setLineColorTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setLineColorTransition(options);
+}
+
 - (MGLStyleValue<MGLColor *> *)lineColor {
     MGLAssertStyleLayerIsValid();
 
@@ -252,6 +293,16 @@ namespace mbgl {
     self.rawLayer->setLineDasharray(mbglValue);
 }
 
+- (void)mbx_setLineDashPatternTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setLineDasharrayTransition(options);
+}
+
 - (MGLStyleValue<NSArray<NSNumber *> *> *)lineDashPattern {
     MGLAssertStyleLayerIsValid();
 
@@ -276,6 +327,16 @@ namespace mbgl {
     self.rawLayer->setLineGapWidth(mbglValue);
 }
 
+- (void)mbx_setLineGapWidthTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setLineGapWidthTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)lineGapWidth {
     MGLAssertStyleLayerIsValid();
 
@@ -293,6 +354,16 @@ namespace mbgl {
     self.rawLayer->setLineOffset(mbglValue);
 }
 
+- (void)mbx_setLineOffsetTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setLineOffsetTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)lineOffset {
     MGLAssertStyleLayerIsValid();
 
@@ -310,6 +381,16 @@ namespace mbgl {
     self.rawLayer->setLineOpacity(mbglValue);
 }
 
+- (void)mbx_setLineOpacityTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setLineOpacityTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)lineOpacity {
     MGLAssertStyleLayerIsValid();
 
@@ -327,6 +408,16 @@ namespace mbgl {
     self.rawLayer->setLinePattern(mbglValue);
 }
 
+- (void)mbx_setLinePatternTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setLinePatternTransition(options);
+}
+
 - (MGLStyleValue<NSString *> *)linePattern {
     MGLAssertStyleLayerIsValid();
 
@@ -344,6 +435,16 @@ namespace mbgl {
     self.rawLayer->setLineTranslate(mbglValue);
 }
 
+- (void)mbx_setLineTranslationTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setLineTranslateTransition(options);
+}
+
 - (MGLStyleValue<NSValue *> *)lineTranslation {
     MGLAssertStyleLayerIsValid();
 
@@ -368,6 +469,16 @@ namespace mbgl {
     self.rawLayer->setLineTranslateAnchor(mbglValue);
 }
 
+- (void)mbx_setLineTranslationAnchorTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setLineTranslateAnchorTransition(options);
+}
+
 - (MGLStyleValue<NSValue *> *)lineTranslationAnchor {
     MGLAssertStyleLayerIsValid();
 
@@ -392,6 +503,16 @@ namespace mbgl {
     self.rawLayer->setLineWidth(mbglValue);
 }
 
+- (void)mbx_setLineWidthTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setLineWidthTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)lineWidth {
     MGLAssertStyleLayerIsValid();
 
diff --git a/platform/darwin/src/MGLRasterStyleLayer.mm b/platform/darwin/src/MGLRasterStyleLayer.mm
index 2108a5a0c8..b4d1a10f0d 100644
--- a/platform/darwin/src/MGLRasterStyleLayer.mm
+++ b/platform/darwin/src/MGLRasterStyleLayer.mm
@@ -4,6 +4,7 @@
 #import "MGLSource.h"
 #import "MGLMapView_Private.h"
 #import "NSPredicate+MGLAdditions.h"
+#import "NSDate+MGLAdditions.h"
 #import "MGLStyleLayer_Private.h"
 #import "MGLStyleValue_Private.h"
 #import "MGLRasterStyleLayer.h"
@@ -91,6 +92,23 @@
 
 #pragma mark - Accessing the Paint Attributes
 
+- (NSArray *)transitionKeys
+{
+    NSMutableArray *transitionKeys = [NSMutableArray array];
+    [transitionKeys addObject:@"maximumRasterBrightness"];
+    [transitionKeys addObject:@"rasterBrightnessMax"];
+    [transitionKeys addObject:@"minimumRasterBrightness"];
+    [transitionKeys addObject:@"rasterBrightnessMin"];
+    [transitionKeys addObject:@"rasterContrast"];
+    [transitionKeys addObject:@"rasterFadeDuration"];
+    [transitionKeys addObject:@"rasterHueRotation"];
+    [transitionKeys addObject:@"rasterHueRotate"];
+    [transitionKeys addObject:@"rasterOpacity"];
+    [transitionKeys addObject:@"rasterSaturation"];
+
+    return transitionKeys;
+}
+
 - (void)setMaximumRasterBrightness:(MGLStyleValue<NSNumber *> *)maximumRasterBrightness {
     MGLAssertStyleLayerIsValid();
 
@@ -98,6 +116,16 @@
     self.rawLayer->setRasterBrightnessMax(mbglValue);
 }
 
+- (void)mbx_setMaximumRasterBrightnessTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setRasterBrightnessMaxTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)maximumRasterBrightness {
     MGLAssertStyleLayerIsValid();
 
@@ -122,6 +150,16 @@
     self.rawLayer->setRasterBrightnessMin(mbglValue);
 }
 
+- (void)mbx_setMinimumRasterBrightnessTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setRasterBrightnessMinTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)minimumRasterBrightness {
     MGLAssertStyleLayerIsValid();
 
@@ -146,6 +184,16 @@
     self.rawLayer->setRasterContrast(mbglValue);
 }
 
+- (void)mbx_setRasterContrastTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setRasterContrastTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)rasterContrast {
     MGLAssertStyleLayerIsValid();
 
@@ -163,6 +211,16 @@
     self.rawLayer->setRasterFadeDuration(mbglValue);
 }
 
+- (void)mbx_setRasterFadeDurationTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setRasterFadeDurationTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)rasterFadeDuration {
     MGLAssertStyleLayerIsValid();
 
@@ -180,6 +238,16 @@
     self.rawLayer->setRasterHueRotate(mbglValue);
 }
 
+- (void)mbx_setRasterHueRotationTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setRasterHueRotateTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)rasterHueRotation {
     MGLAssertStyleLayerIsValid();
 
@@ -204,6 +272,16 @@
     self.rawLayer->setRasterOpacity(mbglValue);
 }
 
+- (void)mbx_setRasterOpacityTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setRasterOpacityTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)rasterOpacity {
     MGLAssertStyleLayerIsValid();
 
@@ -221,6 +299,16 @@
     self.rawLayer->setRasterSaturation(mbglValue);
 }
 
+- (void)mbx_setRasterSaturationTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setRasterSaturationTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)rasterSaturation {
     MGLAssertStyleLayerIsValid();
 
diff --git a/platform/darwin/src/MGLStyle.h b/platform/darwin/src/MGLStyle.h
index 925abbaaee..0dddec307b 100644
--- a/platform/darwin/src/MGLStyle.h
+++ b/platform/darwin/src/MGLStyle.h
@@ -30,7 +30,6 @@ NS_ASSUME_NONNULL_BEGIN
  */
 static MGL_EXPORT const NSInteger MGLStyleDefaultVersion = 9;
 
-
 /**
  The proxy object for the current map style.
 
@@ -195,7 +194,8 @@ MGL_EXPORT
 @property (nonatomic, strong) NS_SET_OF(__kindof MGLSource *) *sources;
 
 /**
- Transition values.
+ Values describing animated transitions to styling changes, either to the style URL 
+ or to individual properties.
  */
 @property (nonatomic) MGLTransition transition;
 
diff --git a/platform/darwin/src/MGLStyle.mm b/platform/darwin/src/MGLStyle.mm
index ab0155a40c..d93e0d4326 100644
--- a/platform/darwin/src/MGLStyle.mm
+++ b/platform/darwin/src/MGLStyle.mm
@@ -574,42 +574,22 @@ static NSURL *MGLStyleURL_emerald;
 
 - (void)setTransition:(MGLTransition)transition
 {
-    [self setTransitionDuration:transition.duration];
-    [self setTransitionDelay:transition.delay];
-}
-
-- (MGLTransition)transition
-{
-    MGLTransition transition;
-    transition.delay = [self transitionDelay];
-    transition.duration = [self transitionDuration];
-    
-    return transition;
-}
-- (void)setTransitionDuration:(NSTimeInterval)duration
-{
     auto transitionOptions = self.mapView.mbglMap->getTransitionOptions();
-    transitionOptions.duration = MGLDurationFromTimeInterval(duration);
+    transitionOptions.duration = MGLDurationInSecondsFromTimeInterval(transition.duration);
+    transitionOptions.delay = MGLDurationInSecondsFromTimeInterval(transition.delay);
+    
     self.mapView.mbglMap->setTransitionOptions(transitionOptions);
 }
 
-- (NSTimeInterval)transitionDuration
+- (MGLTransition)transition
 {
+    MGLTransition transition;
     const mbgl::style::TransitionOptions transitionOptions = self.mapView.mbglMap->getTransitionOptions();
-    return MGLTimeIntervalFromDuration(transitionOptions.duration.value_or(mbgl::Duration::zero()));
-}
 
-- (void)setTransitionDelay:(NSTimeInterval)delay
-{
-    auto transitionOptions = self.mapView.mbglMap->getTransitionOptions();
-    transitionOptions.delay = MGLDurationFromTimeInterval(delay);
-    self.mapView.mbglMap->setTransitionOptions(transitionOptions);
-}
-
-- (NSTimeInterval)transitionDelay
-{
-    const mbgl::style::TransitionOptions transitionOptions = self.mapView.mbglMap->getTransitionOptions();
-    return MGLTimeIntervalFromDuration(transitionOptions.delay.value_or(mbgl::Duration::zero()));
+    transition.delay = MGLTimeIntervalFromDurationInSeconds(transitionOptions.delay.value_or(mbgl::Duration::zero()));
+    transition.duration = MGLTimeIntervalFromDurationInSeconds(transitionOptions.duration.value_or(mbgl::Duration::zero()));
+    
+    return transition;
 }
 
 - (NSString *)description
diff --git a/platform/darwin/src/MGLStyleLayer.h b/platform/darwin/src/MGLStyleLayer.h
index 55f1a56490..2f1a777455 100644
--- a/platform/darwin/src/MGLStyleLayer.h
+++ b/platform/darwin/src/MGLStyleLayer.h
@@ -69,6 +69,17 @@ MGL_EXPORT
  */
 @property (nonatomic, assign) float minimumZoomLevel;
 
+#pragma mark Layer Transitions
+
+- (void)setTransition:(MGLTransition)transition forKey:(NSString *)key;
+
+- (MGLTransition)transitionForKey:(NSString *)key;
+
+/**
+ Returns an array of strings that identify transition keys attached to the layer.
+ */
+- (NSArray *)transitionKeys;
+
 @end
 
 NS_ASSUME_NONNULL_END
diff --git a/platform/darwin/src/MGLStyleLayer.mm b/platform/darwin/src/MGLStyleLayer.mm
index 47f41e0388..60226a6842 100644
--- a/platform/darwin/src/MGLStyleLayer.mm
+++ b/platform/darwin/src/MGLStyleLayer.mm
@@ -65,6 +65,55 @@
     return self.rawLayer->getMinZoom();
 }
 
+- (void)setTransition:(MGLTransition)transition forKey:(NSString *)key
+{
+    SEL setPropertyTransitionSelector = [self mbx_selectorForKey:key];
+    
+    if ([self respondsToSelector:setPropertyTransitionSelector]) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+        [self performSelector:setPropertyTransitionSelector withObject:[NSValue value:&transition withObjCType:@encode(MGLTransition)] ];
+#pragma clang diagnostic pop
+    }
+}
+
+- (MGLTransition)transitionForKey:(NSString *)key
+{
+    MGLTransition transition;
+    
+    SEL getPropertyTransitionSelector = [self mbx_selectorForKey:key];
+    
+    if ([self respondsToSelector:getPropertyTransitionSelector]) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+        NSValue *transitionValue = [self performSelector:getPropertyTransitionSelector];
+        [transitionValue getValue:&transition];
+#pragma clang diagnostic pop
+    }
+    
+    return transition;
+}
+
+- (SEL)mbx_selectorForKey:(NSString *)key
+{
+    NSString *camelCaseKey;
+    if ([key length] > 1) {
+        camelCaseKey = [NSString stringWithFormat:@"%@%@", [[key substringToIndex:1] uppercaseString], [key substringFromIndex:1]];
+    } else {
+        camelCaseKey = [key uppercaseString];
+    }
+    NSString *setPropertyTransitionString = [NSString stringWithFormat:@"mbx_set%@Transition:", camelCaseKey];
+    SEL propertyTransitionSelector = NSSelectorFromString(setPropertyTransitionString);
+    
+    return propertyTransitionSelector;
+}
+
+- (NSArray *)transitionKeys
+{
+    // This is overridden by subclasses
+    return nil;
+}
+
 - (NSString *)description
 {
     return [NSString stringWithFormat:@"<%@: %p; identifier = %@; visible = %@>",
diff --git a/platform/darwin/src/MGLStyleLayer.mm.ejs b/platform/darwin/src/MGLStyleLayer.mm.ejs
index 24aff7fca8..de293fe6bf 100644
--- a/platform/darwin/src/MGLStyleLayer.mm.ejs
+++ b/platform/darwin/src/MGLStyleLayer.mm.ejs
@@ -10,6 +10,7 @@
 #import "MGLSource.h"
 #import "MGLMapView_Private.h"
 #import "NSPredicate+MGLAdditions.h"
+#import "NSDate+MGLAdditions.h"
 #import "MGLStyleLayer_Private.h"
 #import "MGLStyleValue_Private.h"
 #import "MGL<%- camelize(type) %>StyleLayer.h"
@@ -229,6 +230,19 @@ namespace mbgl {
 <% if (paintProperties.length) { -%>
 #pragma mark - Accessing the Paint Attributes
 
+- (NSArray *)transitionKeys
+{
+    NSMutableArray *transitionKeys = [NSMutableArray array];
+<% for (const property of paintProperties) { -%>
+    [transitionKeys addObject:@"<%- camelizeWithLeadingLowercase(property.name) %>"];
+<% if (property.original) { -%>
+    [transitionKeys addObject:@"<%- camelizeWithLeadingLowercase(originalPropertyName(property)) %>"];
+<% } -%>
+<% } -%>
+
+    return transitionKeys;
+}
+
 <% for (const property of paintProperties) { -%>
 - (void)set<%- camelize(property.name) %>:(MGLStyleValue<<%- propertyType(property, true) %>> *)<%- objCName(property) %> {
     MGLAssertStyleLayerIsValid();
@@ -247,6 +261,16 @@ namespace mbgl {
     self.rawLayer->set<%- camelize(originalPropertyName(property)) %>(mbglValue);
 }
 
+- (void)mbx_set<%- camelize(property.name) %>Transition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->set<%- camelize(originalPropertyName(property)) %>Transition(options);
+}
+
 - (MGLStyleValue<<%- propertyType(property, true) %>> *)<%- objCGetter(property) %> {
     MGLAssertStyleLayerIsValid();
 
diff --git a/platform/darwin/src/MGLSymbolStyleLayer.mm b/platform/darwin/src/MGLSymbolStyleLayer.mm
index 52648e7a05..16d0db7d09 100644
--- a/platform/darwin/src/MGLSymbolStyleLayer.mm
+++ b/platform/darwin/src/MGLSymbolStyleLayer.mm
@@ -4,6 +4,7 @@
 #import "MGLSource.h"
 #import "MGLMapView_Private.h"
 #import "NSPredicate+MGLAdditions.h"
+#import "NSDate+MGLAdditions.h"
 #import "MGLStyleLayer_Private.h"
 #import "MGLStyleValue_Private.h"
 #import "MGLSymbolStyleLayer.h"
@@ -887,6 +888,31 @@ namespace mbgl {
 
 #pragma mark - Accessing the Paint Attributes
 
+- (NSArray *)transitionKeys
+{
+    NSMutableArray *transitionKeys = [NSMutableArray array];
+    [transitionKeys addObject:@"iconColor"];
+    [transitionKeys addObject:@"iconHaloBlur"];
+    [transitionKeys addObject:@"iconHaloColor"];
+    [transitionKeys addObject:@"iconHaloWidth"];
+    [transitionKeys addObject:@"iconOpacity"];
+    [transitionKeys addObject:@"iconTranslation"];
+    [transitionKeys addObject:@"iconTranslate"];
+    [transitionKeys addObject:@"iconTranslationAnchor"];
+    [transitionKeys addObject:@"iconTranslateAnchor"];
+    [transitionKeys addObject:@"textColor"];
+    [transitionKeys addObject:@"textHaloBlur"];
+    [transitionKeys addObject:@"textHaloColor"];
+    [transitionKeys addObject:@"textHaloWidth"];
+    [transitionKeys addObject:@"textOpacity"];
+    [transitionKeys addObject:@"textTranslation"];
+    [transitionKeys addObject:@"textTranslate"];
+    [transitionKeys addObject:@"textTranslationAnchor"];
+    [transitionKeys addObject:@"textTranslateAnchor"];
+
+    return transitionKeys;
+}
+
 - (void)setIconColor:(MGLStyleValue<MGLColor *> *)iconColor {
     MGLAssertStyleLayerIsValid();
 
@@ -894,6 +920,16 @@ namespace mbgl {
     self.rawLayer->setIconColor(mbglValue);
 }
 
+- (void)mbx_setIconColorTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setIconColorTransition(options);
+}
+
 - (MGLStyleValue<MGLColor *> *)iconColor {
     MGLAssertStyleLayerIsValid();
 
@@ -911,6 +947,16 @@ namespace mbgl {
     self.rawLayer->setIconHaloBlur(mbglValue);
 }
 
+- (void)mbx_setIconHaloBlurTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setIconHaloBlurTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)iconHaloBlur {
     MGLAssertStyleLayerIsValid();
 
@@ -928,6 +974,16 @@ namespace mbgl {
     self.rawLayer->setIconHaloColor(mbglValue);
 }
 
+- (void)mbx_setIconHaloColorTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setIconHaloColorTransition(options);
+}
+
 - (MGLStyleValue<MGLColor *> *)iconHaloColor {
     MGLAssertStyleLayerIsValid();
 
@@ -945,6 +1001,16 @@ namespace mbgl {
     self.rawLayer->setIconHaloWidth(mbglValue);
 }
 
+- (void)mbx_setIconHaloWidthTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setIconHaloWidthTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)iconHaloWidth {
     MGLAssertStyleLayerIsValid();
 
@@ -962,6 +1028,16 @@ namespace mbgl {
     self.rawLayer->setIconOpacity(mbglValue);
 }
 
+- (void)mbx_setIconOpacityTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setIconOpacityTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)iconOpacity {
     MGLAssertStyleLayerIsValid();
 
@@ -979,6 +1055,16 @@ namespace mbgl {
     self.rawLayer->setIconTranslate(mbglValue);
 }
 
+- (void)mbx_setIconTranslationTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setIconTranslateTransition(options);
+}
+
 - (MGLStyleValue<NSValue *> *)iconTranslation {
     MGLAssertStyleLayerIsValid();
 
@@ -1003,6 +1089,16 @@ namespace mbgl {
     self.rawLayer->setIconTranslateAnchor(mbglValue);
 }
 
+- (void)mbx_setIconTranslationAnchorTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setIconTranslateAnchorTransition(options);
+}
+
 - (MGLStyleValue<NSValue *> *)iconTranslationAnchor {
     MGLAssertStyleLayerIsValid();
 
@@ -1027,6 +1123,16 @@ namespace mbgl {
     self.rawLayer->setTextColor(mbglValue);
 }
 
+- (void)mbx_setTextColorTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setTextColorTransition(options);
+}
+
 - (MGLStyleValue<MGLColor *> *)textColor {
     MGLAssertStyleLayerIsValid();
 
@@ -1044,6 +1150,16 @@ namespace mbgl {
     self.rawLayer->setTextHaloBlur(mbglValue);
 }
 
+- (void)mbx_setTextHaloBlurTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setTextHaloBlurTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)textHaloBlur {
     MGLAssertStyleLayerIsValid();
 
@@ -1061,6 +1177,16 @@ namespace mbgl {
     self.rawLayer->setTextHaloColor(mbglValue);
 }
 
+- (void)mbx_setTextHaloColorTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setTextHaloColorTransition(options);
+}
+
 - (MGLStyleValue<MGLColor *> *)textHaloColor {
     MGLAssertStyleLayerIsValid();
 
@@ -1078,6 +1204,16 @@ namespace mbgl {
     self.rawLayer->setTextHaloWidth(mbglValue);
 }
 
+- (void)mbx_setTextHaloWidthTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setTextHaloWidthTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)textHaloWidth {
     MGLAssertStyleLayerIsValid();
 
@@ -1095,6 +1231,16 @@ namespace mbgl {
     self.rawLayer->setTextOpacity(mbglValue);
 }
 
+- (void)mbx_setTextOpacityTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setTextOpacityTransition(options);
+}
+
 - (MGLStyleValue<NSNumber *> *)textOpacity {
     MGLAssertStyleLayerIsValid();
 
@@ -1112,6 +1258,16 @@ namespace mbgl {
     self.rawLayer->setTextTranslate(mbglValue);
 }
 
+- (void)mbx_setTextTranslationTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setTextTranslateTransition(options);
+}
+
 - (MGLStyleValue<NSValue *> *)textTranslation {
     MGLAssertStyleLayerIsValid();
 
@@ -1136,6 +1292,16 @@ namespace mbgl {
     self.rawLayer->setTextTranslateAnchor(mbglValue);
 }
 
+- (void)mbx_setTextTranslationAnchorTransition:(NSValue *)transitionValue {
+    MGLAssertStyleLayerIsValid();
+
+    MGLTransition transition;
+    [transitionValue getValue:&transition];
+
+    mbgl::style::TransitionOptions options { { MGLDurationInSecondsFromTimeInterval(transition.duration) }, { MGLDurationInSecondsFromTimeInterval(transition.delay) } };
+    self.rawLayer->setTextTranslateAnchorTransition(options);
+}
+
 - (MGLStyleValue<NSValue *> *)textTranslationAnchor {
     MGLAssertStyleLayerIsValid();
 
diff --git a/platform/darwin/src/MGLTypes.h b/platform/darwin/src/MGLTypes.h
index 8bc6f67fac..fc1d40a1f5 100644
--- a/platform/darwin/src/MGLTypes.h
+++ b/platform/darwin/src/MGLTypes.h
@@ -71,7 +71,7 @@ typedef NS_OPTIONS(NSUInteger, MGLMapDebugMaskOptions) {
 };
 
 /**
- A structure containing information about a transition values.
+ A structure containing information about a transition.
  */
 typedef struct MGLTransition {
     /**
@@ -80,7 +80,7 @@ typedef struct MGLTransition {
     NSTimeInterval duration;
     
     /**
-     The delay in seconds to before applying any changes to the style URL or to layout and paint attributes.
+     The delay in seconds before applying any changes to the style URL or to layout and paint attributes.
      */
     NSTimeInterval delay;
 } MGLTransition;