NavigatorSwift

NavigatorSwift is a framework to easily navigate between your views.

How does it work

Create a navigator

// NavigationController container based navigator
let navigator = NavNavigator(window: UIWindow())

// TabBarController container based navigator
let navigator = TabNavigator(window: UIWindow())

// Custom container based navigator
let navigator = ContainerNavigator(window: UIWindow())

The navigator is the main entry point. It's the one you told were you want go and how.

Create a Scene and register it

extension SceneName {
	static let login: SceneName = "Login"
}

class LoginScene: SceneHandler {
	var name: SceneName {
		return .login
	}

	func view(with parameters: Parameters) -> UIViewController {
		let vc = UIViewController()
		vc.view.backgroundColor = .red
		return vc
	}
	
	// Optional
	func reload(_ viewController: UIViewController, parameters: Parameters) {
		// Do nothing by default
	}
	
	// Optional
	var isReloadable: Bool {
		return true
	}
}

navigator.register(LoginScene())

Set root scene and navigate!

navigator.root(.login)
navigator.push(.someScene)

The root scene is the one which it's going to be set as rootViewController of the UIWindow.

Features

Present:

navigator.present(.login)

Present inside navigation controller:

navigator.presentNavigation(.someScene)

Dismiss all views:

navigator.dismissAll()

Dismiss first view:

navigator.dismiss()

Dismiss by scene:

navigator.dismiss(.someScene)

Push:

navigator.push(.someScene)

Pop to root view:

navigator.popToRoot()

Pop first view:

navigator.pop()

Reload:

navigator.reload(.someScene)

Calls the method reload from the scene handler.

URLs:

navigator.url(someURL)

Force touch preview.

navigator.preview(.someScene, from: someViewController, at: someSourceView)

Popover presentation:

navigator.popover(.someScene, from: somView)

Transition:

navigator.transition(to: .someScene, with: someInteractiveTransition)

View creation:

let loginView = navigator.view(for: .login)

Traverse (get the current stack hierarchy; sceneName and presentationType):

navigator.traverse { state in
	if state.names.contains(.collection) {
		// Do something
	}
}

Relative stack navigation using builder:

navigator.build { builder in
	builder.modal(.contact)
	builder.modalNavigation(.detail) // Modal presentation with a navigation controller.
	builder.push(.avatar)
}

If you use relative navigation, you can add new scenes over the current hierarchy.

Absolute stack navigation using builder (the current stack will be recycled and reloaded if possible):

navigator.build { builder in
	builder.root(name: .home)
	builder.modalNavigation(.login)
}

If you use absolute navigation, the hierarchy will be rebuilded from root. If the current hierarchy match the targeted hierarchy, the view controllers will be recycled and reloaded.

Use absolute navigation to show a certain hierarchy no matter what is the current state.

Operation based navigation:

For more complex navigation you can create and concatenate operations that will be executed serially. This can be easyly archived by creating a new SceneOperation and extending the Navigator protocol.

class SomeOperation {
	fileprivate var scenes: [Scene]
	fileprivate let renderer: SceneRenderer

	init(scenes: [Scene], renderer: SceneRenderer) {
		self.scenes = scenes
		self.renderer = renderer
	}
}

extension SomeOperation: SceneOperation {
	func execute(with completion: CompletionBlock?) {
		let dismissAllOperation = renderer.dismissAll(animated: true)
		let addScenes = renderer.add(scenes: scenes)
		let reloadLast = renderer.reload(scene: scenes.last!)

		let complexOperation = dismissAllOperation
			.then(addScenes)
			.then(reloadLast)
			.execute(with: completion)
	}
}

Interceptors:

By implementing the protocol SceneOperationInterceptor you can intercept all the operations being executed by the navigator. This protocol allows you to change the behavior of the navigator in some cases.

For example for displaying the contacts persmissions alert just before presenting some edit contact view:

class ContactsPermissionsInterceptor: SceneOperationInterceptor {
	func operation(with operation: SceneOperation, context: SceneOperationContext) -> SceneOperation? {
		return ShowContactPermissionsIfNeededSceneOperation().then(operation)
	}

	func shouldIntercept(operation: SceneOperation, context: SceneOperationContext) -> Bool {
		return context.targetState.names.contains(.editContact)
	}
}

If you want to stop the execution of the operation, you must return nil on operation(with:context:)

To start intercepting, a registration of the interceptor is needed.