@apexnative/navigation 0.0.0-stage → 1.0.0-alpha.0

package/ios/Options/ANNViewAnimationOptions.h

@@ -0,0 +1,26 @@
+#import "ANNAnimationPropertyOptions.h"
+#import "ANNOptions.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// `ViewAnimationOptions`: the animated properties of a view.
+@interface ANNViewAnimationOptions : ANNOptions
+
+@property(nonatomic, strong) ANNAnimationPropertyOptions *x;
+@property(nonatomic, strong) ANNAnimationPropertyOptions *y;
+@property(nonatomic, strong) ANNAnimationPropertyOptions *translationX;
+@property(nonatomic, strong) ANNAnimationPropertyOptions *translationY;
+@property(nonatomic, strong) ANNAnimationPropertyOptions *alpha;
+@property(nonatomic, strong) ANNAnimationPropertyOptions *scaleX;
+@property(nonatomic, strong) ANNAnimationPropertyOptions *scaleY;
+@property(nonatomic, strong) ANNAnimationPropertyOptions *rotationX;
+@property(nonatomic, strong) ANNAnimationPropertyOptions *rotationY;
+@property(nonatomic, strong) ANNAnimationPropertyOptions *rotation;
+
+/// The ten properties in one order, the one every reader uses: `x`, `y`, `translationX`, `translationY`, `alpha`,
+/// `scaleX`, `scaleY`, `rotationX`, `rotationY`, `rotation`.
+- (NSArray<ANNAnimationPropertyOptions *> *)animatedProperties;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Options/ANNViewAnimationOptions.mm

@@ -0,0 +1,58 @@
+#import "ANNViewAnimationOptions.h"
+
+@implementation ANNViewAnimationOptions
+
++ (NSArray<ANNOptionField *> *)optionFields {
+    return @[
+        [ANNOptionField groupField:@"x" class:ANNAnimationPropertyOptions.class],
+        [ANNOptionField groupField:@"y" class:ANNAnimationPropertyOptions.class],
+        [ANNOptionField groupField:@"translationX" class:ANNAnimationPropertyOptions.class],
+        [ANNOptionField groupField:@"translationY" class:ANNAnimationPropertyOptions.class],
+        [ANNOptionField groupField:@"alpha" class:ANNAnimationPropertyOptions.class],
+        [ANNOptionField groupField:@"scaleX" class:ANNAnimationPropertyOptions.class],
+        [ANNOptionField groupField:@"scaleY" class:ANNAnimationPropertyOptions.class],
+        [ANNOptionField groupField:@"rotationX" class:ANNAnimationPropertyOptions.class],
+        [ANNOptionField groupField:@"rotationY" class:ANNAnimationPropertyOptions.class],
+        [ANNOptionField groupField:@"rotation" class:ANNAnimationPropertyOptions.class],
+    ];
+}
+
+- (NSArray<ANNAnimationPropertyOptions *> *)animatedProperties {
+    return @[
+        _x, _y, _translationX, _translationY, _alpha, _scaleX, _scaleY, _rotationX, _rotationY,
+        _rotation
+    ];
+}
+
+// The set of animated properties of a side is replaced whole when the upper layer's side has any property with a value
+// (the properties of two layers never add up); otherwise this layer's stay. The side's flags (`enabled`,
+// `waitForRender` of the subclasses) merge by key, independently: the field table merges them below. Every merge goes
+// through here (`copy`, `withDefault:`, the layers of a resolution), so a subclass needs nothing of its own.
+- (void)mergeOptions:(ANNOptions *)options {
+    if ([options isKindOfClass:ANNViewAnimationOptions.class] && options != self) {
+        BOOL upperHasProperties = NO;
+        NSArray<ANNAnimationPropertyOptions *> *upper =
+            [(ANNViewAnimationOptions *)options animatedProperties];
+        for (ANNAnimationPropertyOptions *property in upper) {
+            if (property.hasValue) {
+                upperHasProperties = YES;
+                break;
+            }
+        }
+        if (upperHasProperties) {
+            _x = [ANNAnimationPropertyOptions new];
+            _y = [ANNAnimationPropertyOptions new];
+            _translationX = [ANNAnimationPropertyOptions new];
+            _translationY = [ANNAnimationPropertyOptions new];
+            _alpha = [ANNAnimationPropertyOptions new];
+            _scaleX = [ANNAnimationPropertyOptions new];
+            _scaleY = [ANNAnimationPropertyOptions new];
+            _rotationX = [ANNAnimationPropertyOptions new];
+            _rotationY = [ANNAnimationPropertyOptions new];
+            _rotation = [ANNAnimationPropertyOptions new];
+        }
+    }
+    [super mergeOptions:options];
+}
+
+@end

package/ios/Options/ANNWindowOptions.h

@@ -0,0 +1,12 @@
+#import "ANNOptions.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// `window` (`WindowOptions`): the app's window, from the default options only.
+@interface ANNWindowOptions : ANNOptions
+
+@property(nonatomic, strong) Color *backgroundColor;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Options/ANNWindowOptions.mm

@@ -0,0 +1,9 @@
+#import "ANNWindowOptions.h"
+
+@implementation ANNWindowOptions
+
++ (NSArray<ANNOptionField *> *)optionFields {
+    return @[ [ANNOptionField colorField:@"backgroundColor"] ];
+}
+
+@end

package/ios/Options/ANNZoomTransitionOptions.h

@@ -0,0 +1,13 @@
+#import "ANNOptions.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// `ZoomTransitionOptions`: the zoom of a screen out of the view with `fromId`; `null` takes the zoom away.
+@interface ANNZoomTransitionOptions : ANNOptions
+
+@property(nonatomic, strong) Text *fromId;
+@property(nonatomic, strong) Bool *enabled;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Options/ANNZoomTransitionOptions.mm

@@ -0,0 +1,12 @@
+#import "ANNZoomTransitionOptions.h"
+
+@implementation ANNZoomTransitionOptions
+
++ (NSArray<ANNOptionField *> *)optionFields {
+    return @[
+        [ANNOptionField textField:@"fromId"],
+        [ANNOptionField boolField:@"enabled"],
+    ];
+}
+
+@end

package/ios/Options/Params/ANNIntegerParam.h

@@ -0,0 +1,14 @@
+#import "ANNParam.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// A whole number, or the value of an enumeration the options name by a string.
+@interface ANNIntegerParam : ANNParam
+
+/// The value; 0 without one.
+- (NSInteger)get;
+- (NSInteger)withDefault:(NSInteger)defaultValue;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Options/Params/ANNIntegerParam.mm

@@ -0,0 +1,13 @@
+#import "ANNIntegerParam.h"
+
+@implementation ANNIntegerParam
+
+- (NSInteger)get {
+    return [self.value isKindOfClass:NSNumber.class] ? [self.value integerValue] : 0;
+}
+
+- (NSInteger)withDefault:(NSInteger)defaultValue {
+    return [self.value isKindOfClass:NSNumber.class] ? [self.value integerValue] : defaultValue;
+}
+
+@end

package/ios/Options/Params/ANNParam.h

@@ -0,0 +1,28 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// A JSON boolean: `true` or `false` as React Native gives them (a `CFBoolean`), never a number.
+BOOL ANNJSONIsBoolean(id _Nullable value);
+
+/// A JSON number that is finite: never a boolean, `NaN` or an infinity.
+BOOL ANNJSONIsNumber(id _Nullable value);
+
+/// One value of the options as the JSON gave it. Immutable: trees of options may share it. `null` is a value too where
+/// the kind has an explicit "none" (a text, a color): it takes the place of what the layers under it gave.
+@interface ANNParam : NSObject
+
+- (instancetype)initWithValue:(nullable id)value;
+
+/// What the JSON gave, `NSNull` for `null`; nil when the key was not there or had a value of another type.
+@property(nonatomic, strong, readonly, nullable) id value;
+
+/// The options gave a value, `null` included.
+- (BOOL)hasValue;
+
+/// The options gave `null`.
+- (BOOL)isNull;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Options/Params/ANNParam.mm

@@ -0,0 +1,29 @@
+#import "ANNParam.h"
+
+BOOL ANNJSONIsBoolean(id value) {
+    return [value isKindOfClass:NSNumber.class] &&
+           CFGetTypeID((__bridge CFTypeRef)value) == CFBooleanGetTypeID();
+}
+
+BOOL ANNJSONIsNumber(id value) {
+    return [value isKindOfClass:NSNumber.class] && !ANNJSONIsBoolean(value) && isfinite([value doubleValue]);
+}
+
+@implementation ANNParam
+
+- (instancetype)initWithValue:(id)value {
+    if (self = [super init]) {
+        _value = value;
+    }
+    return self;
+}
+
+- (BOOL)hasValue {
+    return _value != nil;
+}
+
+- (BOOL)isNull {
+    return _value == NSNull.null;
+}
+
+@end

package/ios/Options/Params/Bool.h

@@ -0,0 +1,17 @@
+#import "ANNParam.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// A true or false value.
+@interface Bool : ANNParam
+
+/// A value set by the native side, as a user choice the options keep.
++ (Bool *)withValue:(BOOL)value;
+
+/// The value; 0 without one.
+- (BOOL)get;
+- (BOOL)withDefault:(BOOL)defaultValue;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Options/Params/Bool.mm

@@ -0,0 +1,17 @@
+#import "Bool.h"
+
+@implementation Bool
+
++ (Bool *)withValue:(BOOL)value {
+    return [[Bool alloc] initWithValue:@(value)];
+}
+
+- (BOOL)get {
+    return [self.value isKindOfClass:NSNumber.class] ? [self.value boolValue] : 0;
+}
+
+- (BOOL)withDefault:(BOOL)defaultValue {
+    return [self.value isKindOfClass:NSNumber.class] ? [self.value boolValue] : defaultValue;
+}
+
+@end

package/ios/Options/Params/BoolParser.h

@@ -0,0 +1,12 @@
+#import "Bool.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Reads `key` of the options' JSON: `true` or `false`; anything else, a number included, is no value.
+@interface BoolParser : NSObject
+
++ (Bool *)parse:(nullable NSDictionary *)json key:(NSString *)key;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Options/Params/BoolParser.mm

@@ -0,0 +1,10 @@
+#import "BoolParser.h"
+
+@implementation BoolParser
+
++ (Bool *)parse:(NSDictionary *)json key:(NSString *)key {
+    id value = [json isKindOfClass:NSDictionary.class] ? json[key] : nil;
+    return [[Bool alloc] initWithValue:ANNJSONIsBoolean(value) ? value : nil];
+}
+
+@end

package/ios/Options/Params/Color.h

@@ -0,0 +1,43 @@
+#import "Param.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// A color of the options: a color, a light and dark pair (UIKit switches it by itself), a pair with one side only, or
+/// an explicit "no color". A color replaces the color of the layers under it as a whole.
+@interface Color : Param
+
+/// A color the JSON gave; an explicit "no color" is `noColor`.
+- (instancetype)initWithColor:(UIColor *)color;
+
+/// A pair for the light and the dark style. With both sides it is one dynamic color; with one side the other style
+/// shows the place's own color (`withDefault:`).
+- (instancetype)initWithLight:(nullable UIColor *)light dark:(nullable UIColor *)dark;
+
+/// `null` or `'NoColor'`: the place as the platform draws it without the option, over what the layers under it give.
++ (Color *)noColor;
+
+/// The side of a pair for the light style; nil without one, and for a single color.
+@property(nonatomic, strong, readonly, nullable) UIColor *light;
+/// The side of a pair for the dark style; nil without one, and for a single color.
+@property(nonatomic, strong, readonly, nullable) UIColor *dark;
+
+/// The color; nil without one, for "no color", and for a pair with one side (use `withDefault:` there).
+- (nullable UIColor *)get;
+
+/// The color, or `defaultValue` without one. A pair with one side gives a dynamic color whose missing side is
+/// `defaultValue` (the place's own color, which may be dynamic itself); "no color" gives nil.
+- (nullable UIColor *)withDefault:(nullable UIColor *)defaultValue;
+
+/// The color for these traits: the side of a pair (nil where the side is missing), a dynamic color resolved.
+- (nullable UIColor *)colorForTraitCollection:(UITraitCollection *)traitCollection;
+
+/// The options gave `null` or `'NoColor'`.
+- (BOOL)isNoColor;
+
+/// A pair that has only one of its sides.
+- (BOOL)isPartial;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Options/Params/Color.mm

@@ -0,0 +1,65 @@
+#import "Color.h"
+
+@implementation Color
+
+- (instancetype)initWithColor:(UIColor *)color {
+    return [super initWithValue:color];
+}
+
+- (instancetype)initWithLight:(UIColor *)light dark:(UIColor *)dark {
+    UIColor *both = nil;
+    if (light && dark) {
+        both = [UIColor colorWithDynamicProvider:^UIColor *(UITraitCollection *traits) {
+          return traits.userInterfaceStyle == UIUserInterfaceStyleDark ? dark : light;
+        }];
+    }
+    if (self = [super initWithValue:both]) {
+        _light = light;
+        _dark = dark;
+    }
+    return self;
+}
+
++ (Color *)noColor {
+    return [[Color alloc] initWithValue:NSNull.null];
+}
+
+- (BOOL)hasValue {
+    return self.value != nil || _light != nil || _dark != nil;
+}
+
+- (BOOL)isNoColor {
+    return self.isNull;
+}
+
+- (BOOL)isPartial {
+    return self.value == nil && (_light != nil || _dark != nil);
+}
+
+- (UIColor *)get {
+    return [super get];
+}
+
+- (UIColor *)withDefault:(UIColor *)defaultValue {
+    if (!self.isPartial) {
+        return self.hasValue ? self.get : defaultValue;
+    }
+    if (!defaultValue) {
+        return nil;
+    }
+    UIColor *light = _light;
+    UIColor *dark = _dark;
+    return [UIColor colorWithDynamicProvider:^UIColor *(UITraitCollection *traits) {
+      UIColor *side = traits.userInterfaceStyle == UIUserInterfaceStyleDark ? dark : light;
+      return side ?: [defaultValue resolvedColorWithTraitCollection:traits];
+    }];
+}
+
+- (UIColor *)colorForTraitCollection:(UITraitCollection *)traitCollection {
+    if (_light || _dark) {
+        return traitCollection.userInterfaceStyle == UIUserInterfaceStyleDark ? _dark : _light;
+    }
+    return [self.get resolvedColorWithTraitCollection:traitCollection];
+}
+
+@end

package/ios/Options/Params/ColorParser.h

@@ -0,0 +1,14 @@
+#import "Color.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Reads `key` of the options' JSON as a color, in the forms JS sends on iOS: an ARGB number, `{ dynamic: { light, dark
+/// } }` with a number or a platform color on each side, `{ semantic: [...] }`, and `'NoColor'` (or `null`) for "no
+/// color". A value it can't read is no value and a warning in development.
+@interface ColorParser : NSObject
+
++ (Color *)parse:(nullable NSDictionary *)json key:(NSString *)key;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Options/Params/ColorParser.mm

@@ -0,0 +1,95 @@
+#import "ColorParser.h"
+#import "ANNOptionsReader.h"
+#import <React/RCTConvert.h>
+#import <React/RCTLog.h>
+
+// A system color of UIKit by its name, as React Native names them: `systemBackground` or `systemBackgroundColor`.
+// Only a class method of UIColor that takes no argument and gives a color counts.
+static UIColor *ANNSystemColorNamed(NSString *name) {
+    NSString *selectorName = [name hasSuffix:@"Color"] ? name : [name stringByAppendingString:@"Color"];
+    SEL selector = NSSelectorFromString(selectorName);
+    if (![UIColor respondsToSelector:selector]) {
+        return nil;
+    }
+    NSMethodSignature *signature = [UIColor methodSignatureForSelector:selector];
+    if (signature.numberOfArguments != 2 || signature.methodReturnType[0] != '@') {
+        return nil;
+    }
+    IMP implementation = [UIColor methodForSelector:selector];
+    id color = ((id (*)(id, SEL))implementation)(UIColor.class, selector);
+    return [color isKindOfClass:UIColor.class] ? color : nil;
+}
+
+// `{ semantic: [...] }`: the first name that exists, the app's asset catalog first, then UIKit.
+static UIColor *ANNSemanticColor(id names) {
+    NSArray *list = [names isKindOfClass:NSString.class] ? @[ names ] : names;
+    if (![list isKindOfClass:NSArray.class]) {
+        return nil;
+    }
+    for (id name in list) {
+        if (![name isKindOfClass:NSString.class]) {
+            continue;
+        }
+        UIColor *color = [UIColor colorNamed:name] ?: ANNSystemColorNamed(name);
+        if (color) {
+            return color;
+        }
+    }
+    return nil;
+}
+
+// One color: an ARGB number in sRGB through React Native's converter, or a platform color.
+static UIColor *ANNOneColor(id value) {
+    if (ANNJSONIsNumber(value)) {
+        return [RCTConvert UIColor:value];
+    }
+    if ([value isKindOfClass:NSDictionary.class] && value[@"semantic"]) {
+        return ANNSemanticColor(value[@"semantic"]);
+    }
+    return nil;
+}
+
+@implementation ColorParser
+
++ (Color *)parse:(NSDictionary *)json key:(NSString *)key {
+    id value = [json isKindOfClass:NSDictionary.class] ? json[key] : nil;
+    if (!value) {
+        return [[Color alloc] initWithValue:nil];
+    }
+    if (value == NSNull.null || [value isEqual:@"NoColor"]) {
+        return Color.noColor;
+    }
+    UIColor *color = ANNOneColor(value);
+    if (color) {
+        return [[Color alloc] initWithColor:color];
+    }
+    NSString *path = [ANNOptionsReader pathOfKey:key];
+    NSDictionary *pair = [value isKindOfClass:NSDictionary.class] ? value[@"dynamic"] : nil;
+    if ([pair isKindOfClass:NSDictionary.class]) {
+        UIColor *light = [self side:pair[@"light"] name:@"light" path:path];
+        UIColor *dark = [self side:pair[@"dark"] name:@"dark" path:path];
+        if (light || dark) {
+            return [[Color alloc] initWithLight:light dark:dark];
+        }
+        return [[Color alloc] initWithValue:nil];
+    }
+    RCTLogWarn(@"[ApexNavigation] the color of '%@' can't be read, so it is left out: %@", path, value);
+    return [[Color alloc] initWithValue:nil];
+}
+
+// A side of `{ dynamic: { light, dark } }`. A side that is not there is a partial pair and is silent (the sides are
+// optional); a side that is there but can't be read is missing too, with a warning.
++ (UIColor *)side:(id)value name:(NSString *)name path:(NSString *)path {
+    if (!value || value == NSNull.null) {
+        return nil;
+    }
+    UIColor *color = ANNOneColor(value);
+    if (!color) {
+        RCTLogWarn(@"[ApexNavigation] the %@ side of the color of '%@' can't be read, so that style shows the "
+                   @"platform's color: %@",
+                   name, path, value);
+    }
+    return color;
+}
+
+@end

package/ios/Options/Params/Double.h

@@ -0,0 +1,14 @@
+#import "ANNParam.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// A number with a fraction (a radius, a fraction of the width).
+@interface Double : ANNParam
+
+/// The value; 0 without one.
+- (double)get;
+- (double)withDefault:(double)defaultValue;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Options/Params/Double.mm

@@ -0,0 +1,13 @@
+#import "Double.h"
+
+@implementation Double
+
+- (double)get {
+    return [self.value isKindOfClass:NSNumber.class] ? [self.value doubleValue] : 0;
+}
+
+- (double)withDefault:(double)defaultValue {
+    return [self.value isKindOfClass:NSNumber.class] ? [self.value doubleValue] : defaultValue;
+}
+
+@end

package/ios/Options/Params/DoubleParser.h

@@ -0,0 +1,16 @@
+#import "Double.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Reads `key` of the options' JSON as a number with a fraction.
+@interface DoubleParser : NSObject
+
+/// A finite number; a boolean, `NaN` or an infinity is no value.
++ (Double *)parse:(nullable NSDictionary *)json key:(NSString *)key;
+
+/// A duration in milliseconds: a finite number that is not negative.
++ (Double *)parseDuration:(nullable NSDictionary *)json key:(NSString *)key;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Options/Params/DoubleParser.mm

@@ -0,0 +1,16 @@
+#import "DoubleParser.h"
+
+@implementation DoubleParser
+
++ (Double *)parse:(NSDictionary *)json key:(NSString *)key {
+    id value = [json isKindOfClass:NSDictionary.class] ? json[key] : nil;
+    return [[Double alloc] initWithValue:ANNJSONIsNumber(value) ? value : nil];
+}
+
++ (Double *)parseDuration:(NSDictionary *)json key:(NSString *)key {
+    id value = [json isKindOfClass:NSDictionary.class] ? json[key] : nil;
+    BOOL readable = ANNJSONIsNumber(value) && [value doubleValue] >= 0;
+    return [[Double alloc] initWithValue:readable ? value : nil];
+}
+
+@end

package/ios/Options/Params/Image.h

@@ -0,0 +1,15 @@
+#import "Param.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// An image of the options, loaded when the options were read. An image that didn't load is no value: the element shows
+/// without it.
+@interface Image : Param
+
+- (nullable UIImage *)get;
+- (nullable UIImage *)withDefault:(nullable UIImage *)defaultValue;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Options/Params/Image.mm

@@ -0,0 +1,13 @@
+#import "Image.h"
+
+@implementation Image
+
+- (UIImage *)get {
+    return [super get];
+}
+
+- (UIImage *)withDefault:(UIImage *)defaultValue {
+    return [super withDefault:defaultValue];
+}
+
+@end

package/ios/Options/Params/ImageParser.h

@@ -0,0 +1,16 @@
+#import "Image.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Reads `key` of the options' JSON as an image and loads it at once, on the main queue: `{ system, fallback? }` is an
+/// SF Symbol, else the fallback source; a source (a string, or an object with `uri`, `bundle`, `scale`, `width`,
+/// `height` and Metro's asset flag) loads a file, an asset of the app's bundle, a `data:` address, or in development a
+/// Metro asset. Remote addresses and arrays of sources are not loaded. A failure is no image and an error in the React
+/// Native log; it never throws.
+@interface ImageParser : NSObject
+
++ (Image *)parse:(nullable NSDictionary *)json key:(NSString *)key;
+
+@end
+
+NS_ASSUME_NONNULL_END