Nylo

https://nylo.dev/docs/6.x
Admin
Nylo is a Flutter micro-framework that provides a robust foundation for building modern...
Tokens:194,299
Snippets:1,641
Trust Score:6.6
Update:1 year ago
Show doc for...
Tokens:
Raw
### Example Output of Metro CLI Commands

Source: https://nylo.dev/docs/6.x/6

This snippet shows the typical output when running 'metro' without arguments, listing all available commands categorized into Widget Commands and App Commands, providing a quick reference for developers.

```Text
All commands:

[Widget Commands]
  make:page
  make:stateful_widget
  make:stateless_widget
  make:state_managed_widget
  make:navigation_hub
  make:journey_widget
  make:form

[App Commands]
  make:model
  make:provider
  make:api_service
  make:controller
  make:event
  make:theme
  make:route_guard
  make:config
  make:interceptor
  make:command

```

--------------------------------

### Example of Using Metro CLI Command

Source: https://nylo.dev/docs/6.x/6

This command demonstrates how to use the 'metro' alias to generate a new controller named 'profile_controller' within a Nylo project, showcasing the simplified command syntax after alias setup.

```Dart
metro make:controller profile_controller
```

--------------------------------

### Copy Nylo Environment File

Source: https://nylo.dev/docs/6.x/2.x/installation

This command copies the example environment file (.env-example) to create the actual .env file at the project root. The .env file is crucial for project configuration and is required for the application to build successfully.

```Bash
cp .env-example .env
```

--------------------------------

### Initialize Nylo Project with Metro CLI

Source: https://nylo.dev/docs/6.x/2.x/installation

This command uses the Nylo Metro CLI tool to initialize the project, which can also handle the .env file setup. It provides an automated way to set up the initial project configuration, serving as an alternative to manually copying the .env file.

```Bash
flutter pub run nylo_framework:main project:init
```

--------------------------------

### Nylo Metro CLI: Available Commands Reference

Source: https://nylo.dev/docs/6.x/5.20.0/installation

This output displays the full list of commands available through the Nylo Metro CLI tool. It categorizes commands under 'make' for component generation and 'slate' for publishing and installation tasks, providing a comprehensive reference for developers.

```CLI
Metro - Nylo's Companion to Build Flutter apps by Anthony Gordon

Usage:
    command [options] [arguments]

Options
    -h

All commands:

 make
  make:controller
  make:model
  make:page
  make:stateful_widget
  make:stateless_widget
  make:provider
  make:event
  make:api_service
  make:interceptor
  make:theme
  make:form
  make:route_guard
  make:config

slate
  slate:publish
  slate:install
```

--------------------------------

### Nylo Metro CLI: Create a Controller using Alias

Source: https://nylo.dev/docs/6.x/5.20.0/installation

This example demonstrates using the 'metro' alias to generate a new controller. After setting up the alias, you can use this shorthand command to quickly create components like 'profile_controller' in your Nylo project.

```CLI
metro make:controller profile_controller
```

--------------------------------

### Verifying Metro Alias Installation (macOS)

Source: https://nylo.dev/docs/6.x/6

After adding the 'metro' alias, run this command to confirm that the alias is correctly set up and the Metro CLI menu appears, indicating successful installation and readiness for use.

```Bash
metro
```

--------------------------------

### Clone Nylo Project Repository

Source: https://nylo.dev/docs/6.x/3.x/installation

Instructions to clone the Nylo framework's Git repository to start a new project. After cloning, it's essential to run 'flutter pub get' to fetch all project dependencies.

```bash
git clone https://github.com/nylo-core/nylo.git nylo_app
```

--------------------------------

### Fetch Nylo Project Dependencies

Source: https://nylo.dev/docs/6.x/2.x/installation

After cloning the project, run this command to fetch all the necessary Dart and Flutter packages. This ensures all dependencies are resolved and the project is ready to build.

```Bash
flutter pub get
```

--------------------------------

### Simple `withSpinner` for Dependency Installation

Source: https://nylo.dev/docs/6.x/6.x/metro

Shows a straightforward application of `withSpinner` to display progress during a `flutter pub get` command, ensuring user feedback for dependency installation.

```Dart
@override
Future<void> handle(CommandResult result) async {
  await withSpinner(
    task: () async {
      // Install dependencies
      await runProcess('flutter pub get', silent: true);
      return true;
    },
    message: 'Installing dependencies',
    successMessage: 'Dependencies installed successfully',
  );
}
```

--------------------------------

### Metro CLI available commands output

Source: https://nylo.dev/docs/6.x/6.x/installation

Example output from running the 'metro' command, listing all available commands categorized into Widget Commands and App Commands.

```Text
All commands:

[Widget Commands]
  make:page
  make:stateful_widget
  make:stateless_widget
  make:state_managed_widget
  make:navigation_hub
  make:journey_widget
  make:form

[App Commands]
  make:model
  make:provider
  make:api_service
  make:controller
  make:event
  make:theme
  make:route_guard
  make:config
  make:interceptor
  make:command

```

--------------------------------

### Clone Nylo Project Repository

Source: https://nylo.dev/docs/6.x/6

This command clones the Nylo framework's GitHub repository into a new directory named 'nylo_app'. After cloning, it's crucial to run 'flutter pub get' to fetch all project dependencies for a successful build.

```Shell
git clone https://github.com/nylo-core/nylo.git nylo_app
```

--------------------------------

### Example Metro command usage with alias

Source: https://nylo.dev/docs/6.x/6.x/installation

Demonstrates how to use the 'metro' alias to execute a specific command, such as creating a new controller named 'profile_controller'.

```Bash
metro make:controller profile_controller
```

--------------------------------

### Example Metro CLI command to create a model

Source: https://nylo.dev/docs/6.x/6.x/installation

Demonstrates how to use the 'dart run nylo_framework:main' command to create a new model, specifically a 'Post' model, within a Nylo project.

```Dart
dart run nylo_framework:main make:model Post
```

--------------------------------

### Create Nylo Model using Metro CLI

Source: https://nylo.dev/docs/6.x/5.x/installation

Example command demonstrating how to use the Metro CLI tool to generate a new model, such as a 'Property' model, within your Nylo project.

```Shell
dart run nylo_framework:main make:model Property
```

--------------------------------

### Clone Nylo Project Repository

Source: https://nylo.dev/docs/6.x/1.x/installation

This command initiates the process of setting up a Nylo project by cloning the official framework repository from GitHub. It creates a new directory named "nylo_app" containing all the necessary project files. This is the essential first step to get the Nylo source code onto your local machine.

```Shell
git clone https://github.com/nylo-core/nylo.git nylo_app
```

--------------------------------

### Clone Nylo Project Repository

Source: https://nylo.dev/docs/6.x/2.x/installation

This command clones the Nylo framework's GitHub repository into a new directory named 'nylo_app'. It's the initial step to obtain the project source code and begin development.

```Bash
git clone https://github.com/nylo-core/nylo.git nylo_app
```

--------------------------------

### Initialize Nylo Framework and Boot Providers (Dart)

Source: https://nylo.dev/docs/6.x/3.x/providers

This Dart code snippet from `main.dart` demonstrates the core application setup in Nylo. It shows how `WidgetsFlutterBinding.ensureInitialized()` is called, followed by `Nylo.init()` to initialize the framework and automatically boot registered providers. The `setup` and `setupFinished` callbacks define the provider lifecycle, ensuring necessary services are ready before `runApp` is called.

```Dart
import 'package:flutter/material.dart';
import 'package:flutter_app/bootstrap/app.dart';
import 'package:nylo_framework/nylo_framework.dart';
import 'bootstrap/boot.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  Nylo nylo = await Nylo.init(setup: Boot.nylo, setupFinished: Boot.finished);

  runApp(
    AppBuild(
      navigatorKey: NyNavigator.instance.router.navigatorKey,
      onGenerateRoute: nylo.router!.generator(),
      debugShowCheckedModeBanner: false,
    ),
  );
}
```

--------------------------------

### Nylo Metro CLI: Access Main Menu

Source: https://nylo.dev/docs/6.x/5.20.0/installation

Execute this command in your terminal to display the main menu of the Nylo Metro CLI tool. This provides an overview of all available commands and options for project management.

```dart
dart run nylo_framework:main
```

--------------------------------

### Accessing Metro CLI Menu

Source: https://nylo.dev/docs/6.x/6

This command runs the Nylo framework's main executable to display the Metro CLI tool's main menu, listing all available commands and providing an overview of its capabilities.

```Dart
dart run nylo_framework:main
```

--------------------------------

### Clone Nylo project repository

Source: https://nylo.dev/docs/6.x/4.x/installation

Clones the Nylo framework's Git repository into a new directory named 'nylo_app'. After cloning, ensure to run `flutter pub get` to fetch all project dependencies.

```Bash
git clone https://github.com/nylo-core/nylo.git nylo_app
```

--------------------------------

### Clone Nylo Project Repository

Source: https://nylo.dev/docs/6.x/5.20.0/installation

Use this command to clone the Nylo framework's Git repository to your local machine, creating a new project directory named 'nylo_app'. This is the primary method for obtaining the Nylo source code.

```bash
git clone https://github.com/nylo-core/nylo.git nylo_app
```

--------------------------------

### Access Singleton Nylo API Service Instance

Source: https://nylo.dev/docs/6.x/5.20.0/networking

Once configured as a singleton, this example demonstrates how to retrieve and use the single instance of the `ApiService` using the `api` helper function in Nylo.

```Dart
api<ApiService>((request) => request.fetchUsers());
```

--------------------------------

### Clone Nylo Project Repository

Source: https://nylo.dev/docs/6.x/6.x/installation

This command is used to clone the Nylo framework's Git repository from GitHub into a new local directory named 'nylo_app'. After cloning, it is crucial to run 'flutter pub get' within the project directory to download and install all necessary dependencies.

```Git
git clone https://github.com/nylo-core/nylo.git nylo_app
```

--------------------------------

### Nylo Page Syntax (New)

Source: https://nylo.dev/docs/6.x/6.x/upgrade-guide

This snippet presents the updated syntax for defining pages in Nylo 6.x, now extending `NyPage`. Key changes include `static RouteView path`, `get init => () async`, `LoadingStyle` property replacing `useSkeletonizer`, and the `view()` method replacing `build()`. The `boot` method has been replaced by `init`.

```Dart
...class HomePage extends NyStatefulWidget<HomeController> {
  static RouteView path = ("/home", (_) => HomePage());

  HomePage() : super(child: () => _HomePageState());
}

class _HomePageState extends NyPage<HomePage> {

  @override
  get init => () async {

  };

  /// Define the Loading style for the page.
  /// Options: LoadingStyle.normal(), LoadingStyle.skeletonizer(), LoadingStyle.none()
  /// uncomment the code below.
  LoadingStyle get loadingStyle => LoadingStyle.normal();

  /// The [view] method displays your page.
  @override
  Widget view(BuildContext context) {
  }

```

--------------------------------

### Nylo Localization JSON File Structure (with Arguments)

Source: https://nylo.dev/docs/6.x/5.x/localization

Examples of English and Spanish localization JSON files showcasing how to define translation strings with placeholders (arguments) for dynamic content, such as names.

```JSON
{
  "changelog": "changelog",
  "intros": {
    "hello_name": "hello {{first_name}}",
  }
}
```

```JSON
{
  "changelog": "registro de cambios",
  "intros": {
    "hello_name": "hola {{first_name}}"
  }
}
```

--------------------------------

### Opening PowerShell Profile in Text Editor (Windows)

Source: https://nylo.dev/docs/6.x/6

This command opens the PowerShell profile file in Notepad, allowing the user to easily add or modify custom functions, aliases, and other configurations for their PowerShell environment.

```PowerShell
notepad $PROFILE
```

--------------------------------

### Install Metro CLI Alias on Mac

Source: https://nylo.dev/docs/6.x/5.20.0/installation

This command creates a 'metro' alias in your bash_profile, allowing you to use 'metro' instead of the full 'dart run nylo_framework:main' command. It then reloads the bash_profile to apply the changes immediately.

```bash
sudo echo "alias metro='dart run nylo_framework:main'" >>~/.bash_profile && source ~/.bash_profile
```

--------------------------------

### Install and Publish Nylo Slate Package

Source: https://nylo.dev/docs/6.x/5.x/slates

Demonstrates how to install a Nylo Slate package from pub.dev and publish its files using the `publish:slate` command. This can be done directly with `dart run nylo_framework:main` or more conveniently via the `metro` CLI tool.

```Shell
dart run nylo_framework:main publish:slate example_slate_package
// or with Metro
metro publish:slate example_slate_package
```

--------------------------------

### Nylo Route Definition Syntax (New)

Source: https://nylo.dev/docs/6.x/6.x/upgrade-guide

This snippet demonstrates the new, streamlined syntax for defining routes in Nylo 6.x's `routes.dart` file. Routes are now added using `router.add(path)` with chained methods like `initialRoute()` for the starting page.

```Dart
appRouter() => nyRoutes((router) {
    router.add(HomePage.path).initialRoute();

    router.add(SecondPage.path);

    router.add(ThirdPage.path);
    ...
```

--------------------------------

### Nylo Metro CLI: Create a Model

Source: https://nylo.dev/docs/6.x/5.20.0/installation

This command demonstrates how to use the Metro CLI tool to generate a new model within your Nylo project. Replace 'Property' with your desired model name to create a new model file.

```dart
dart run nylo_framework:main make:model Property
```

--------------------------------

### Nylo Model Decoders Configuration Example

Source: https://nylo.dev/docs/6.x/4.x/networking

This configuration file (`config/decoders.dart`) illustrates how to register model decoders for `User` and `List<User>`, enabling automatic JSON-to-model conversion in Nylo API requests.

```Dart
/// file 'config/decoders.dart'

final modelDecoders = {
  List<User>: (data) => List.from(data).map((json) => User.fromJson(json)).toList(),

  User: (data) => User.fromJson(data),

  // ...
};
```

--------------------------------

### Install Nylo Auth Slate Package

Source: https://nylo.dev/docs/6.x/5.20.0/slates

This command installs the `ny_auth_slate` package, providing pre-built authentication pages and components. It can be run using either `dart run nylo_framework:main` or the `metro` utility.

```Shell
dart run nylo_framework:main slate:publish ny_auth_slate
// or with Metro
metro slate:publish ny_auth_slate
```

--------------------------------

### Generate Basic Nylo API Service

Source: https://nylo.dev/docs/6.x/4.x/networking

Use this command to create a new API service in your Nylo project. The service will be named 'user' in this example, generating a basic service structure.

```shell
flutter pub run nylo_framework:main make:api_service user
```

--------------------------------

### Define Spanish Localization with Arguments

Source: https://nylo.dev/docs/6.x/4.x/localization

This JSON snippet provides an example of a Spanish localization string (`lang/es.json`) that incorporates arguments. The 'intros.hello_name' key uses the `{{first_name}}` placeholder, allowing for personalized translations.

```JSON
{
  "changelog": "changelog",
  "intros": {
    "hello_name": "hola {{first_name}}"
  }
}
```

--------------------------------

### Nylo Localization JSON File Structure (Basic)

Source: https://nylo.dev/docs/6.x/5.x/localization

Examples of basic English and Spanish localization JSON files, defining simple key-value pairs for common terms and a nested greeting. These files are placed in the `lang/` directory.

```JSON
{
  "documentation": "documentation",
  "changelog": "changelog",
  "intros": {
    "hello": "hello {{first_name}}",
  }
}
```

```JSON
{
  "documentation": "documentación",
  "changelog": "registro de cambios",
  "intros": {
    "hello": "hola {{first_name}}",
  }
}
```

--------------------------------

### Initialize Nylo Application and Boot Providers

Source: https://nylo.dev/docs/6.x/5.20.0/providers

This Dart code snippet from `main.dart` demonstrates the entry point of a Nylo application. It shows how `Nylo.init` is called to initialize the framework, which includes the crucial step of booting all registered providers. The `setup` and `setupFinished` callbacks (`Boot.nylo` and `Boot.finished`) define the provider lifecycle.

```Dart
import 'package:flutter/material.dart';
import 'package:flutter_app/bootstrap/app.dart';
import 'package:nylo_framework/nylo_framework.dart';
import 'bootstrap/boot.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  Nylo nylo = await Nylo.init(setup: Boot.nylo, setupFinished: Boot.finished); // This is where providers are booted

  runApp(
    AppBuild(
      navigatorKey: NyNavigator.instance.router.navigatorKey,
      onGenerateRoute: nylo.router!.generator(),
      debugShowCheckedModeBanner: false,
    ),
  );
}
```

--------------------------------

### Nylo Generated User API Service Structure

Source: https://nylo.dev/docs/6.x/4.x/networking

Example of the `UserApiService` class generated by Nylo, showcasing common CRUD (Create, Read, Update, Delete) methods for interacting with user data via network requests.

```Dart
class UserApiService extends BaseApiService {
  ...

  /// Return a list of users
  Future<List<User>?> fetchAll({dynamic query}) async {
    return await network<List<User>>(
        request: (request) => request.get("/endpoint-path", queryParameters: query),
    );
  }

  /// Find a User
  Future<User?> find({required int id}) async {
    return await network<User>(
      request: (request) => request.get("/endpoint-path/$id"),
    );
  }

  /// Create a User
  Future<User?> create({required dynamic data}) async {
    return await network<User>(
      request: (request) => request.post("/endpoint-path", data: data),
    );
  }

  /// Update a User
  Future<User?> update({dynamic query}) async {
    return await network<User>(
      request: (request) => request.put("/endpoint-path", queryParameters: query),
    );
  }

  /// Delete a User
  Future<bool?> delete({required int id}) async {
    return await network<bool>(
      request: (request) => request.delete("/endpoint-path/$id"),
    );
  }
}
```

--------------------------------

### Example Nylo DashboardController implementation

Source: https://nylo.dev/docs/6.x/5.x/ny-page

This Dart code defines a `DashboardController`, extending Nylo's `Controller` class. It showcases how to add custom business logic, such as the `isProUser()` method, and includes the `construct` method for controller-specific setup.

```dart
import 'controller.dart';
import 'package:flutter/widgets.dart';

class DashboardController extends Controller {

  // add variables/methods/functions here

  construct(BuildContext context) {
    super.construct(context);

  }

  // Example method
  bool isProUser() {
    User user = Backpack.instance.auth();
    if (user.isPro) {
      return true;
    }
    return false;
  }
}
```

--------------------------------

### Update Nylo main.dart File

Source: https://nylo.dev/docs/6.x/6.x/upgrade-guide

This snippet shows the updated `main.dart` file for Nylo 6.x, which serves as the main entry point for the application. It initializes the Nylo framework using `Nylo.init`, setting up `Boot.nylo` and `Boot.finished` callbacks, and includes an option to show a splash screen.

```Dart
import 'package:nylo_framework/nylo_framework.dart';
import 'bootstrap/boot.dart';

/// Nylo - Framework for Flutter Developers
/// Docs: https://nylo.dev/docs/6.x

/// Main entry point for the application.
void main() async {
  await Nylo.init(
    setup: Boot.nylo,
    setupFinished: Boot.finished,

    // showSplashScreen: true,
    // Uncomment showSplashScreen to show the splash screen
    // File: lib/resources/widgets/splash_screen.dart
  );
}
```

--------------------------------

### Execute Nylo Metro CLI Tool

Source: https://nylo.dev/docs/6.x/2.x/installation

This command executes the Nylo Metro CLI tool, providing access to various utilities for project management, such as creating models, controllers, and pages. It's the primary way to interact with Metro's functionalities for streamlining development tasks.

```Bash
flutter pub run nylo_framework:main
```

--------------------------------

### Install and Publish Nylo Slate Package

Source: https://nylo.dev/docs/6.x/6.x/metro

This command installs a specified Slate package and then automatically publishes all its associated files into your project. It streamlines the process of integrating new Slate packages.

```Dart
dart run nylo_framework:main slate:install my_slate_package
# or with the alias metro
metro slate:install my_slate_package
```

--------------------------------

### Define Nylo API Service with Base URL and Interceptors

Source: https://nylo.dev/docs/6.x/5.20.0/networking

This snippet shows the basic structure of an `ApiService` class extending `NyApiService`. It demonstrates how to override the `baseUrl` for the API endpoint and register `LoggingInterceptor`. It also includes an example `fetchUsers` method to make a GET request.

```Dart
class ApiService extends NyApiService {
  ApiService({BuildContext? buildContext}) : super(buildContext);

  @override
  String get baseUrl => "https://jsonplaceholder.typicode.com";

  @override
  get interceptors => {
    LoggingInterceptor: LoggingInterceptor()
  };

  Future<User?> fetchUsers() async {
    return await network<User>(
        request: (request) => request.get("/users"),
    );
  }
}
```

--------------------------------

### Nylo Route Definition Syntax (Old)

Source: https://nylo.dev/docs/6.x/6.x/upgrade-guide

This snippet illustrates the previous syntax for defining routes in Nylo's `routes.dart` file. Routes were declared using `router.route` with a path and a context builder function, and `initialRoute: true` for the starting route.

```Dart
appRouter() => nyRoutes((router) {
    router.route(HomePage.path, (context) => HomePage(), initialRoute: true);

    router.route(SecondPage.path, (context) => SecondPage());

    router.route(ThirdPage.path, (context) => ThirdPage());
    ...
```

--------------------------------

### Implement User Registration and Session Saving in Nylo

Source: https://nylo.dev/docs/6.x/5.x/authentication

This comprehensive example illustrates a user registration and login flow. It covers making an API call to register a user, handling the returned session token, and then saving the authenticated `User` object to the device using `Auth.set()` for persistent session management.

```Dart
TextEditingController _tfEmail = TextEditingController();
TextEditingController _tfPassword = TextEditingController();

_login() async {
  // 1 - Example register via an API Service
  User? user = await api<AuthApiService>((request) => request.register(email: _tfEmail.text, password: _tfPassword.text));

  // 2 - Returns the users session token
  print(user?.token);

  // 3 - Save the user to Nylo
  await Auth.set(user);
}
```

--------------------------------

### Define a Custom API Service in Nylo

Source: https://nylo.dev/docs/6.x/4.x/networking

This Dart code defines a custom API service extending `BaseApiService` in Nylo. It sets a base URL, configures interceptors like `LoggingInterceptor`, and includes an example method `fetchUsers` for making a GET request to retrieve user data.

```Dart
class ApiService extends BaseApiService {
  ApiService({BuildContext? buildContext}) : super(buildContext);

  @override
  String get baseUrl => "https://jsonplaceholder.typicode.com";

  @override
  final interceptors = {
    LoggingInterceptor: LoggingInterceptor()
  };

  Future<User?> fetchUsers() async {
    return await network<User>(
        request: (request) => request.get("/users"),
    );
}
```

--------------------------------

### Verify Metro CLI installation and display commands

Source: https://nylo.dev/docs/6.x/2.x/metro

Running the 'metro' command without arguments verifies its successful installation and displays a list of all available commands and options provided by the Metro CLI tool.

```bash
metro
```

--------------------------------

### Spanish Language File Example with Argument Placeholder

Source: https://nylo.dev/docs/6.x/3.x/localization

Presents a Spanish translation file (`lang/es.json`) with a string containing an argument placeholder, similar to the English example. This ensures consistency in argument handling across different languages.

```JSON
{
  "changelog": "registro de cambios",
  "intros": {
    "hello_name": "hola {{first_name}}"
  }
}
```

--------------------------------

### Verify Metro CLI Installation

Source: https://nylo.dev/docs/6.x/5.x/metro

After installing the Metro alias, run this command to confirm that the Metro CLI tool is correctly set up and accessible from your terminal. A successful execution will display a list of all available Metro commands, indicating proper installation.

```Shell
metro
```

--------------------------------

### Perform Various HTTP Requests using Nylo's network Method

Source: https://nylo.dev/docs/6.x/5.20.0/networking

This snippet illustrates how to use the `network` method within an `ApiService` to perform different types of HTTP requests (GET, PUT, POST, DELETE). It shows commented-out examples for each request type, demonstrating how to pass data for PUT and POST requests.

```Dart
class ApiService extends NyApiService {
  ApiService({BuildContext? buildContext}) : super(buildContext, decoders: modelDecoders);

  @override
  String get baseUrl => "https://jsonplaceholder.typicode.com";

  Future<dynamic> fetchUsers() async {
    return await network(
        request: (request) {
          // [GET] return request.get("/users");
          // [PUT] return request.put("/users", data: {"user": "data"});
          // [POST] return request.post("/users", data: {"user": "data"});
          // [DELETE] return request.delete("/users/1");

          return request.get("/users");
        },
    );
  }
```

--------------------------------

### Deep Linking URL Examples in Nylo

Source: https://nylo.dev/docs/6.x/5.20.0/router

This section provides examples of how deep linking URLs are structured in Nylo. It demonstrates basic navigation to specific pages and how to pass query parameters to a page using the URL.

```APIDOC
// Example URL

https://<web domain>/profile - navigates to the profile page
https://<web domain>/settings - navigates to the settings page

// Passing parameters to the Page
https://<web domain>/profile?user=7 - navigates to the profile page with the user ID 7
```

--------------------------------

### Verify Metro CLI Installation

Source: https://nylo.dev/docs/6.x/4.x/metro

This command executes the 'metro' alias to confirm that the installation was successful and the CLI tool is accessible. It should display the Metro CLI's usage information and available commands.

```bash
metro
```

--------------------------------

### Dart: Example Logging Interceptor in Nylo

Source: https://nylo.dev/docs/6.x/5.20.0/networking

A practical example of a `LoggingInterceptor` that extends `Interceptor`. It demonstrates how to log request details, response status, and error information using `print` and `log` within the `onRequest`, `onResponse`, and `onError` methods.

```Dart
import 'dart:developer';
import 'package:nylo_framework/nylo_framework.dart';

class LoggingInterceptor extends Interceptor {
  @override
  void onRequest(RequestOptions options, RequestInterceptorHandler handler) {

    print('REQUEST[${options.method}] => PATH: ${options.path}');

    return super.onRequest(options, handler);
  }

  @override
  void onResponse(Response response, ResponseInterceptorHandler handler) {

      print(
          'RESPONSE[${response.statusCode}] => PATH: ${response.requestOptions
              .path}');

      print('DATA: ${response.requestOptions.path}');

      log(response.data.toString());

    handler.next(response);
  }

  @override
  void onError(DioError err, ErrorInterceptorHandler handler) {

      print('ERROR[${err.response?.statusCode}] => PATH: ${err.requestOptions
          .path}');

    handler.next(err);
  }
}
```

--------------------------------

### Navigate to a New Page

Source: https://nylo.dev/docs/6.x/6.x/router

Example of using the `routeTo` helper function to navigate to a new page, specifically `SettingsPage.path`.

```Dart
void _pressedSettings() {
    routeTo(SettingsPage.path);
}
```

--------------------------------

### Implement Custom Nylo Provider Boot Logic (Dart)

Source: https://nylo.dev/docs/6.x/3.x/providers

This Dart example demonstrates how to implement a custom provider by extending `NyProvider`. The `boot(Nylo nylo)` method is the entry point for provider-specific initialization, such as setting up localization. It's crucial to return the `Nylo` instance or `null` from this asynchronous method.

```Dart
class AppProvider implements NyProvider {

  boot(Nylo nylo) async {
    await NyLocalization.instance.init(
        localeType: localeType,
        languageCode: languageCode,
        languagesList: languagesList,
        assetsDirectory: assetsDirectory,
        valuesAsMap: valuesAsMap);

    return nylo;
  }
}
```

--------------------------------

### Nylo Logging Interceptor Example

Source: https://nylo.dev/docs/6.x/4.x/networking

This snippet provides a practical example of a `LoggingInterceptor` that logs request, response, and error details to the console. It conditionally logs information based on the `APP_DEBUG` environment variable, making it useful for debugging during development.

```Dart
import 'dart:developer';
import 'package:nylo_framework/nylo_framework.dart';

class LoggingInterceptor extends Interceptor {
  @override
  void onRequest(RequestOptions options, RequestInterceptorHandler handler) {
    if (getEnv('APP_DEBUG') == true) {
      print('REQUEST[${options.method}] => PATH: ${options.path}');
    }
    return super.onRequest(options, handler);
  }

  @override
  void onResponse(Response response, ResponseInterceptorHandler handler) {
    if (getEnv('APP_DEBUG') == true) {
      print(
          'RESPONSE[${response.statusCode}] => PATH: ${response.requestOptions
              .path}');
      print('DATA: ${response.requestOptions.path}');
      log(response.data.toString());
    }
    handler.next(response);
  }

  @override
  void onError(DioError err, ErrorInterceptorHandler handler) {
    if (getEnv('APP_DEBUG') == true) {
      print('ERROR[${err.response?.statusCode}] => PATH: ${err.requestOptions
          .path}');
    }
    handler.next(err);
  }
}
```

--------------------------------

### Install Nylo Slate Package via Flutter Command

Source: https://nylo.dev/docs/6.x/4.x/slates

This command line snippet demonstrates how to install a specific Nylo Slate package, such as `ny_auth_slate`, into your project. Running `publish:all` executes the package's scaffolding logic to integrate its components.

```Shell
flutter pub run ny_auth_slate:main publish:all
```

--------------------------------

### Check Flutter Version

Source: https://nylo.dev/docs/6.x/5.x/requirements

Use this command to display the currently installed Flutter version on your system. This helps verify if your setup meets Nylo's minimum requirements.

```Shell
flutter --version
```

--------------------------------

### Dispatch PaymentSuccessfulEvent After Purchase

Source: https://nylo.dev/docs/6.x/3.x/events

Example of dispatching the `PaymentSuccessfulEvent` after a successful order creation, passing the `order` data as a payload to the event's listeners.

```dart
stripePay(List<Product> products) async {

  // create the order
  Order? order = await api<OrderApiService>((api) => api.createOrder(products));
  if (order == null) {
    return;
  }

  // send event
  await event<PaymentSuccessfulEvent>(data: {'order': order});
...
```

--------------------------------

### Boot Method for Async Initialization in Nylo

Source: https://nylo.dev/docs/6.x/4.x/ny-state

The `boot` method facilitates asynchronous operations during page loading, displaying a loader via `afterLoad` until the async task completes. It allows `await` calls on Future methods, ensuring a smooth user experience by showing a loading indicator.

```Dart
class _HomePageState extends NyState<HomePage> {

  @override
  boot() async {
    await Future.delayed(Duration(seconds: 4), () {
      print('Wait 4 seconds');
    });
  }

  @override
  Widget build(BuildContext context) {
      return Scaffold(
          body: Center(
              child: afterLoad(child: () {
                return Text("The page loaded");
              })
          )
      );
  }

```

--------------------------------

### Full Navigation Hub Example with Custom Loading Widget

Source: https://nylo.dev/docs/6.x/6.x/navigation-hub

This comprehensive code block illustrates a complete Navigation Hub implementation, including the setup of navigation tabs and the integration of a custom loading style. It demonstrates how to define a custom loading widget within the Navigation Hub's state class to provide visual feedback during tab transitions.

```Dart
class _MyNavigationHubState extends NavigationHub<MyNavigationHub> {
    ...
     _BaseNavigationHubState() : super(() async {

      await sleep(3); // simulate loading for 3 seconds

      return {
        0: NavigationTab(
          title: "Home",
          page: HomeTab(),
          icon: Icon(Icons.home),
          activeIcon: Icon(Icons.home),
        ),
        1: NavigationTab(
          title: "Settings",
          page: SettingsTab(),
          icon: Icon(Icons.settings),
          activeIcon: Icon(Icons.settings),
        ),
      };
    });

    @override
    LoadingStyle get loadingStyle => LoadingStyle.normal(
        child: Center(
            child: Text("Loading..."),
        ),
    );
    ...
}
```

--------------------------------

### Verify Metro CLI installation

Source: https://nylo.dev/docs/6.x/1.x/metro

Runs the 'metro' command to verify its successful installation and alias configuration, expecting an output showing available Metro commands.

```Shell
metro
```

--------------------------------

### Initialize Page Data with NyPage init Method (Dart)

Source: https://nylo.dev/docs/6.x/5.x/ny-page

The `init` method in `NyPage` is called when the page is created, allowing for initial data setup or class instantiation. This example demonstrates its use, including an optional Firebase initialization and a method to fetch a list of strings asynchronously. It's recommended to use a controller for setting data rather than directly in `NyPage`.

```Dart
import 'package:flutter/material.dart';
import 'package:nylo_framework/nylo_framework.dart';
import '/app/controllers/dashboard_controller.dart';
import 'package:firebase_core/firebase_core.dart';

class DashboardPage extends NyPage<DashboardController> {

  static String path = '/dashboard';

  @override
  init() async {
    /* Example with Firebase
    await Firebase.initializeApp(
      options: DefaultFirebaseOptions.currentPlatform,
    );
    */
  }

  Future<List<String>> _getFavouriteFood() async {
    await Future.delayed(Duration(seconds: 2));
    return ["Rice", "Pasta", "Burger"];
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
          title: Text("Dashboard")
      ),
      body: SafeArea(
        child: NyListView(
            child: (BuildContext context, dynamic food) {
              return ListTile(
                  title: Text(food)
              );
            },
            data: _getFavouriteFood
        ),
      ),
    );
  }

}
```

--------------------------------

### Implement Nylo Provider with Boot and AfterBoot Methods

Source: https://nylo.dev/docs/6.x/6.x/providers

This Dart code snippet demonstrates how to implement the `NyProvider` interface. The `boot` method initializes localization settings and returns the `Nylo` instance, which is crucial for the framework's startup. The `afterBoot` method illustrates post-boot logic, such as checking a user's subscription status and performing actions like logging out if the user is not subscribed.

```Dart
class AppProvider implements NyProvider {

  boot(Nylo nylo) async {
    await NyLocalization.instance.init(
        localeType: localeType,
        languageCode: languageCode,
        languagesList: languagesList,
        assetsDirectory: assetsDirectory,
        valuesAsMap: valuesAsMap);

    return nylo;
  }

  afterBoot(Nylo nylo) async {
    User user = await Auth.user();
    if (!user.isSubscribed) {
      await Auth.remove();
    }
  }
}
```

--------------------------------

### Verify Metro CLI Installation and Alias

Source: https://nylo.dev/docs/6.x/3.x/metro

After configuring the 'metro' alias, run this command in your terminal to verify that Metro is correctly installed and the alias is working. A successful output will display a list of available Metro commands.

```bash
metro
```

--------------------------------

### Call API Service by Instantiating ApiService

Source: https://nylo.dev/docs/6.x/5.x/networking

Demonstrates calling an API service by creating a new instance of `ApiService` and invoking its methods. Shows how to fetch a list of users.

```Dart
class _MyHomePageState extends NyState<MyHomePage> {

  ApiService _apiService = ApiService();

  @override
  init() async {
    List<User>? users = await _apiService.fetchUsers();
    print(users); // List<User>? instance
...


```

--------------------------------

### Dispatch LoginEvent with User Data

Source: https://nylo.dev/docs/6.x/3.x/events

Generic example of dispatching an event, specifically `LoginEvent`, after a user logs in, passing the `User` object as event data to its registered listeners.

```dart
loginUser() async {
    User user = await _apiService.loginUser('email': '...', 'password': '...');

    event<LoginEvent>(data: {'user': user});
}
```

--------------------------------

### Nylo Page Syntax (Old)

Source: https://nylo.dev/docs/6.x/6.x/upgrade-guide

This snippet shows the previous syntax for defining pages in Nylo, extending `NyStatefulWidget` and `NyState`. It includes the old `static const path`, `init()`, `boot()`, `useSkeletonizer` property, and `loading()` and `build()` methods.

```Dart
...class HomePage extends NyStatefulWidget<HomeController> {
  static const path = '/home';

  HomePage({super.key}) : super(path, child: () => _HomePageState());
}

class _HomePageState extends NyState<HomePage> {

  @override
   init() async {

   }

   @override
   boot() async {

   }

 bool get useSkeletonizer => true;

@override
 Widget loading(BuildContext context) {
   return Scaffold(
       body: Center(child: Text("Loading..."))
   );
 }

  /// The [view] method should display your page.
  @override
  Widget build(BuildContext context) {
    ...
  }
```

--------------------------------

### Initialize Nylo Application Main Entry Point

Source: https://nylo.dev/docs/6.x/6.x/providers

This Dart code snippet demonstrates the main entry point for a Nylo Flutter application. It initializes the Nylo framework using `Nylo.init()`, specifying `Boot.nylo` for initial setup and `Boot.finished` for post-setup actions. It also shows how to optionally enable a splash screen.

```Dart
import 'package:nylo_framework/nylo_framework.dart';
import 'bootstrap/boot.dart';

/// Nylo - Framework for Flutter Developers
/// Docs: https://nylo.dev/docs/6.x

/// Main entry point for the application.
void main() async {
  await Nylo.init(
    setup: Boot.nylo,
    setupFinished: Boot.finished,

    // showSplashScreen: true,
    // Uncomment showSplashScreen to show the splash screen
    // File: lib/resources/widgets/splash_screen.dart
  );
}
```

--------------------------------

### Example JSON Translation File (Spanish)

Source: https://nylo.dev/docs/6.x/2.x/localization

Demonstrates a basic JSON structure for Spanish translations, including nested keys for organizing strings.

```JSON
{
  "changelog": "registro de cambios",
  "intros": {
    "hello": "hola"
  }
}
```

--------------------------------

### Reloading PowerShell Profile (Windows)

Source: https://nylo.dev/docs/6.x/6

This command reloads the current PowerShell profile, applying any changes made to it, such as new functions or aliases, without needing to restart the PowerShell session.

```PowerShell
. $PROFILE
```

--------------------------------

### NyForm Widget Example Usage (Dart)

Source: https://nylo.dev/docs/6.x/6.x/forms

This example demonstrates how to instantiate and configure the `NyForm` widget with various parameters. It shows how to set `initialData`, include `header` and `footer` widgets, define an `onChanged` callback, enable `validateOnFocusChange`, and customize spacing.

```Dart
NyForm(
  form: LoginForm(),
  initialData: {
    "email": "user@example.com",
    "password": ""
  },
  header: Text("Login"),
  footer: SubmitButton(),
  onChanged: (field, data) {
    print("Field $field changed. New data: $data");
  },
  validateOnFocusChange: true,
  crossAxisSpacing: 16,
  mainAxisSpacing: 20,
)
```

--------------------------------

### Validate Capitalized String in Dart

Source: https://nylo.dev/docs/6.x/5.20.0/validation

This snippet shows how to use the `capitalized` validation rule to check if a string starts with an uppercase letter. It provides an example for 'Hello world', confirming its capitalization.

```Dart
String helloWorld = "Hello world";
validate(rules: {
  "Hello World": [helloWorld, "capitalized"]
}, onSuccess: () {
    print("Success! The input is capitalized");
});
```

--------------------------------

### Initialize Nylo and Boot Providers in main.dart

Source: https://nylo.dev/docs/6.x/4.x/providers

This Dart code snippet from `main.dart` illustrates the core application initialization process in Nylo. It shows how `WidgetsFlutterBinding.ensureInitialized()` is called, followed by `Nylo.init()` which handles the booting of registered providers, and finally `runApp()` to start the Flutter application. Providers are booted via `Boot.nylo`.

```Dart
import 'package:flutter/material.dart';
import 'package:flutter_app/bootstrap/app.dart';
import 'package:nylo_framework/nylo_framework.dart';
import 'bootstrap/boot.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  Nylo nylo = await Nylo.init(setup: Boot.nylo, setupFinished: Boot.finished); // This is where providers are booted

  runApp(
    AppBuild(
      navigatorKey: NyNavigator.instance.router.navigatorKey,
      onGenerateRoute: nylo.router!.generator(),
      debugShowCheckedModeBanner: false,
    ),
  );
}
```

--------------------------------

### Validate Phone Number in Nylo

Source: https://nylo.dev/docs/6.x/5.x/validation

Shows how to validate a UK phone number using Nylo's `validate` method with the `phone_uk` rule. This example integrates with a `TextEditingController` to get the input value.

```Dart
class _ExampleState extends NyState<ExamplePage> {
  TextEditingController _textFieldController = TextEditingController();
  ...

  handleForm() {
    String textFieldValue = _textFieldController.text;

    validate(rules: {
      "phone number": "phone_uk" // validation rule 'phone_uk'
    }, data: {
      "phone number": textFieldValue
    }, onSuccess: () {
      print('looks good');
      // do something...
    });
  }
}
```

--------------------------------

### Clone Nylo Project Repository

Source: https://nylo.dev/docs/6.x/5.x/installation

Use this command to clone the Nylo framework's Git repository into a new directory named 'nylo_app'. This is the initial step for setting up a new Nylo project locally.

```Shell
git clone https://github.com/nylo-core/nylo.git nylo_app
```

--------------------------------

### Dispatching a Payment Successful Event in Nylo

Source: https://nylo.dev/docs/6.x/5.x/events

This example demonstrates how to dispatch the `PaymentSuccessfulEvent` after a successful payment, passing order data to its listeners. This triggers the associated event handling logic.

```dart
stripePay(List<Product> products) async {

  // create the order
  Order? order = await api<OrderApiService>((api) => api.createOrder(products));
  if (order == null) {
    return;
  }

  // send event
  await event<PaymentSuccessfulEvent>(data: {'order': order});
...
```

--------------------------------

### Example output of Metro CLI available commands

Source: https://nylo.dev/docs/6.x/2.x/metro

This snippet shows the expected output when running the 'metro' command, detailing the structure and available commands like 'project', 'make', and 'appicons' for various development tasks.

```bash
Metro - Nylo\'s Companion to Build Flutter apps by Anthony Gordon

Usage:
    command [options] [arguments]

Options
    -h

All commands:
 project
  project:init

 make
  make:controller
  make:model
  make:page
  make:stateless_widget
  make:stateful_widget
  make:theme

 appicons
  appicons:build
```

--------------------------------

### Nylo Localization JSON File Structure (Nested Keys)

Source: https://nylo.dev/docs/6.x/5.x/localization

Examples of English and Spanish localization JSON files demonstrating the use of nested keys to organize translation strings hierarchically for better structure.

```JSON
{
  "changelog": "changelog",
  "intros": {
    "hello": "hello"
  }
}
```

```JSON
{
  "changelog": "registro de cambios",
  "intros": {
    "hello": "hola"
  }
}
```

--------------------------------

### Generate a new model using Nylo Metro CLI

Source: https://nylo.dev/docs/6.x/4.x/installation

Demonstrates how to use the Nylo Metro CLI tool to create a new 'Property' model. The Metro CLI simplifies the generation of various project components like models, controllers, and pages.

```Bash
flutter pub run nylo_framework:main make:model Property
```

--------------------------------

### Nylo Application Initialization and Provider Bootstrapping

Source: https://nylo.dev/docs/6.x/5.x/providers

This Dart code snippet from `main.dart` demonstrates the core initialization of a Nylo application. It highlights where the `Nylo.init` method is called, which is responsible for booting all registered providers as defined in `config/providers.dart`.

```Dart
import 'package:flutter/material.dart';
import 'package:flutter_app/bootstrap/app.dart';
import 'package:nylo_framework/nylo_framework.dart';
import 'bootstrap/boot.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  Nylo nylo = await Nylo.init(setup: Boot.nylo, setupFinished: Boot.finished); // This is where providers are booted

  runApp(
    AppBuild(
      navigatorKey: NyNavigator.instance.router.navigatorKey,
      onGenerateRoute: nylo.router!.generator(),
      debugShowCheckedModeBanner: false,
    ),
  );
}
```

--------------------------------

### Upgrade Flutter to Stable Release

Source: https://nylo.dev/docs/6.x/1.x/requirements

These commands update your Flutter installation to the latest stable channel, ensuring you meet the minimum version requirements for Nylo. It also runs `flutter doctor -v` to verify the setup after the upgrade.

```shell
flutter channel stable
flutter upgrade
flutter doctor -v
```

--------------------------------

### Implement Async Operations with Nylo Boot and AfterLoad

Source: https://nylo.dev/docs/6.x/5.20.0/ny-state

Demonstrates the usage of the `boot()` method for performing asynchronous operations before a widget is displayed, in conjunction with `afterLoad()` to show a loader during the async call and then display the child widget.

```Dart
class _HomePageState extends NyState<HomePage> {

  @override
  boot() async {
    await Future.delayed(Duration(seconds: 4));
    print('After 4 seconds...');
  }

  @override
  Widget build(BuildContext context) {
      return Scaffold(
          body: Center(
              child: afterLoad(child: () {
                return Text("The page loaded");
              })
          )
      );
  }

}
```

--------------------------------

### Implementing Nylo Provider with Boot and AfterBoot Methods

Source: https://nylo.dev/docs/6.x/5.x/providers

This Dart code demonstrates how to implement the `NyProvider` interface. The `boot` method is executed first during app startup, handling initializations like localization and returning the `Nylo` instance. The `afterBoot` method runs after Nylo has completed its booting process, suitable for post-initialization logic such as user authentication checks.

```Dart
class AppProvider implements NyProvider {

  boot(Nylo nylo) async {
    await NyLocalization.instance.init(
        localeType: localeType,
        languageCode: languageCode,
        languagesList: languagesList,
        assetsDirectory: assetsDirectory,
        valuesAsMap: valuesAsMap);

    return nylo;
  }

  afterBoot(Nylo nylo) async {

    User user = await Auth.user();
    if (!user.isSubscribed) {
      await Auth.remove();
    }

  }
}
```

--------------------------------

### Example JSON Translation File with Arguments (English)

Source: https://nylo.dev/docs/6.x/2.x/localization

Illustrates a JSON structure for English translations that includes a placeholder (e.g., `{{first_name}}`) for dynamic values to be filled at runtime.

```JSON
{
  "changelog": "changelog",
  "intros": {
    "hello_name": "hello {{first_name}}"
  }
}
```
Tokens:
Raw