Skip to content

6. Clientes HTTP para o serviço de cálculo de imposto

Image

6.1. Introdução

Este capítulo reproduz, sem alterações estruturais, as três camadas sucessivas de clientes construídas no curso de TypeScript, cada uma refinando a anterior: um primeiro cliente, CLI, em que todos os cálculos permanecem no lado do servidor; um segundo cliente, CLI, em que o cálculo passa para o lado do cliente (camada [business]); um terceiro cliente, compilado para o NAVEGADOR; e, por fim, um cliente completo, HTML, com suas próprias views. Todos os quatro se apoiam no mesmo servidor NestJS, instalado no capítulo anterior.

6.2. Cliente HTTP 1

Image

6.2.1. A camada [dao]

6.2.2. script [dao1]

// dao1.dart
// Porta Dao1.ts: a camada [dao] (Data Access Object) encapsula todos os
// detalhes da comunicação HTTP com o servidor de cálculo de imposto (URL,
// método, cookie de sessão) por trás de métodos de negócio simples
// (initSession, authenticateUser, calculateTax...).
import 'package:dio/dio.dart';

class Dao1 {
  final Dio _dio;
  final String _sessionCookieName;
  String _sessionCookie = '';

  // construtor - recebe a instância de Dio a ser usada, como o script TypeScript
  // recebia a instância do axios como parâmetro
  Dao1(this._dio) : _sessionCookieName = "connect.sid";

  // inicialização da sessão
  Future<dynamic> initSession() {
    return _getRemoteData(
      'main.php',
      method: 'GET',
      queryParameters: {'action': 'init-session', 'type': 'json'},
    );
  }

  Future<dynamic> authenticateUser(String user, String password) {
    return _getRemoteData(
      'main.php',
      method: 'POST',
      queryParameters: {'action': 'authenticate-user'},
      data: {'user': user, 'password': password},
      contentType: Headers.formUrlEncodedContentType,
    );
  }

  // cálculo do imposto
  Future<dynamic> calculateTax(String married, int children, int salary) {
    return _getRemoteData(
      'main.php',
      method: 'POST',
      queryParameters: {'action': 'calculate-tax'},
      data: {'married': married, 'children': children, 'salary': salary},
      contentType: Headers.formUrlEncodedContentType,
    );
  }

  // lista de simulações
  Future<dynamic> listSimulations() {
    return _getRemoteData(
      'main.php',
      method: 'GET',
      queryParameters: {'action': 'list-simulations'},
    );
  }

  // exclusão de uma simulação
  Future<dynamic> deleteSimulation(int index) {
    return _getRemoteData(
      'main.php',
      method: 'GET',
      queryParameters: {'action': 'delete-simulation', 'number': index},
    );
  }

  Future<dynamic> _getRemoteData(
    String path, {
    required String method,
    Map<String, dynamic>? queryParameters,
    Object? data,
    String? contentType,
  }) async {
    // para o cookie de sessão
    final options = Options(
      method: method,
      contentType: contentType,
      headers: {'Cookie': _sessionCookie},
      validateStatus: (_) => true,
    );
    // execução da requisição HTTP
    final response = await _dio.request(
      path,
      queryParameters: queryParameters,
      data: data,
      options: options,
    );
    // recuperamos o cookie de sessão, se existir
    final setCookie = response.headers['set-cookie'];
    if (setCookie != null) {
      for (final header in setCookie) {
        final result = RegExp('^($_sessionCookieName.+?);').firstMatch(header);
        if (result != null) {
          _sessionCookie = result.group(1)!;
          break;
        }
      }
    }
    // a resposta do servidor está em [response.data]
    return response.data;
  }
}

Vamos comentar este código:

  • Linha 48: A camada [dao] (Data Access Object) encapsula todos os detalhes da comunicação HTTP (URL, método, cookie de sessão) por trás de métodos de negócio simples - [initSession], [authenticateUser], [calculateTax], [listSimulations], [deleteSimulation] (linha 57).
  • Linha 15: [Dao1(this._dio)] recebe a instância de [Dio] a ser usada como parâmetro do construtor, exatamente como o script TypeScript recebia a instância de [axios].
  • Linha 65: [_getRemoteData] (privado, prefixo [_]) centraliza o rastreamento manual do cookie de sessão ([response.headers['set-cookie']], [RegExp] (linha 90)) já visto em dart_dio_03.dart: cada método público do DAO se apoia nesse mesmo método privado.

6.2.3. O [main1]

6.2.4. script [main1]

// main1.dart
// Porta main1.ts.
import 'dart:convert';
import 'package:dio/dio.dart';
import 'dao1.dart';

Future<void> main() async {
  // configuração do Dio - baseUrl/timeout globais, como axios.defaults em
  // do TypeScript
  final dio = Dio(BaseOptions(
    baseUrl: 'http://localhost:3000/',
    connectTimeout: const Duration(seconds: 2),
    receiveTimeout: const Duration(seconds: 2),
  ));
  // instanciação da camada [dao]
  final dao = Dao1(dio);
  // uso da camada [dao]
  try {
    // inicialização da sessão
    log("-----------init-session");
    dynamic response = await dao.initSession();
    log(response);
    // autenticação
    log("-----------authenticate-user");
    response = await dao.authenticateUser("admin", "admin");
    log(response);
    // cálculos de imposto - Future.wait é o equivalente Dart de Promise.all
    // (já visto em async_05.dart)
    log("-----------calculate-tax x 3");
    response = await Future.wait([
      dao.calculateTax("yes", 2, 45000),
      dao.calculateTax("no", 2, 45000),
      dao.calculateTax("no", 1, 30000),
    ]);
    log(response);
    // lista de simulações
    log("-----------list-of-simulations");
    response = await dao.listSimulations();
    log(response);
    // exclusão de uma simulação
    log("-----------deleting simulation no. 1");
    response = await dao.deleteSimulation(1);
    log(response);
  } catch (error) {
    // registramos o erro no log
    print("error=$error");
  }
}

// log JSON
void log(Object? object) {
  const JsonEncoder encoder = JsonEncoder.withIndent('  ');
  print(encoder.convert(object));
}

Vamos comentar este código:

  • linha 16: [final dao = Dao1(dio);]: a camada [dao] é instanciada uma única vez e depois reutilizada em toda a sequência de chamadas (init-session, autenticação, cálculos, listagem, exclusão).
  • Linhas 30–31: [Future.wait([dao.calculateTax(...), ...])]: os três cálculos de imposto são lançados EM PARALELO, o equivalente em Dart de [Promise.all], já visto em async_05.dart.
  • Linhas 52–53: [JsonEncoder.withIndent(' ').convert(object)]: a função utilitária [log] reproduz a exibição indentada de [JSON.stringify(x, null, 2)].

O resultado da execução é o seguinte:

"-----------init-session"
{
"action": "init-session",
"status": 700,
"response": "session started with type [json]"
}
"-----------authenticate-user"
{
"action": "authenticate-user",
"status": 200,
"response": "Authentication successful [admin, admin]"
}
"-----------calculate-tax x 3"
[
{
"action": "calculate-tax",
"status": 300,
"response": {
"married": "yes",
"children": 2,
"salary": 45000,
"tax": 502,
"surcharge": 0,
"discount": 857,
"reduction": 126,
"rate": 0.14
}
},
{
"action": "calculate-tax",
"status": 300,
"response": {
"married": "no",
"children": 2,
"salary": 45000,
"tax": 3250,
"surcharge": 370,
"discount": 0,
"reduction": 0,
"rate": 0.3
}
},
{
"action": "calculate-tax",
"status": 300,
"response": {
"married": "no",
"children": 1,
"salary": 30000,
"tax": 1687,
"surcharge": 0,
"discount": 0,
"reduction": 0,
"rate": 0.14
}
}
]
"-----------list-of-simulations"
{
"action": "list-simulations",
"status": 500,
"response": [
{
"married": "yes",
"children": 2,
"salary": 45000,
"tax": 502,
"surcharge": 0,
"discount": 857,
"reduction": 126,
"rate": 0.14
},
{
"married": "no",
"children": 1,
"salary": 30000,
"tax": 1687,
"surcharge": 0,
"discount": 0,
"reduction": 0,
"rate": 0.14
}
]
}
"-----------deleting simulation no. 1"
{
"action": "delete-simulation",
"status": 600,
"response": [
{
"married": "yes",
"children": 2,
"salary": 45000,
"tax": 502,
"surcharge": 0,
"discount": 857,
"reduction": 126,
"rate": 0.14
}
]
}

6.3. Cliente HTTP 2

Image

Este segundo cliente move o CÁLCULO do imposto do servidor para o cliente: o servidor agora fornece os dados fiscais brutos (alíquotas, faixas etc.) uma única vez por meio de [get-admindata], e a camada [business] passa a realizar os cálculos.

6.3.1. O [Business]

6.3.2. script [business]

// business.dart
// Porta Business.ts: o cálculo do imposto, feito inteiramente no lado do cliente
// (no navegador em TypeScript, aqui no programa Dart), a partir
// dos dados tributários brutos obtidos uma única vez do servidor por meio de
// [Dao2.getAdminData] (veja dao2.dart).
class Business {
  // [dynamic]: a estrutura exata dos dados enviados pelo servidor de
  // imposto (alíquotas, tetos...) não está documentada aqui; como em
  // TypeScript, mantemos deliberadamente a flexibilidade nesse tipo
  final Map<String, dynamic> taxAdminData;

  Business(this.taxAdminData);

  // cálculo do imposto
  // --------------------------------------------------------------------------
  // married: sim, não
  // children: número de filhos
  // salary: salário anual
  Map<String, dynamic> calculateTax(String married, int children, num salary) {
    // cálculo do imposto com filhos
    final result1 = _calculateTax2(married, children, salary);
    final tax1 = result1['tax'] as num;
    // cálculo do imposto sem os filhos
    Map<String, dynamic> result2;
    num tax2;
    num halfShareCeiling;
    if (children != 0) {
      result2 = _calculateTax2(married, 0, salary);
      tax2 = result2['tax'] as num;
      // aplicação do teto do quociente familiar
      halfShareCeiling = taxAdminData['halfShareQfCeiling'] as num;
      if (children < 3) {
        // halfShareCeiling para os 2 primeiros filhos
        tax2 = tax2 - children * halfShareCeiling;
      } else {
        // halfShareCeiling para os 2 primeiros filhos, dobrado para os seguintes
        tax2 = tax2 - 2 * halfShareCeiling - (children - 2) * 2 * halfShareCeiling;
      }
    } else {
      // sem recálculo do imposto
      tax2 = tax1;
      result2 = result1;
    }
    // pegamos o maior imposto entre [tax1, tax2]
    num tax;
    num rate;
    num surcharge;
    if (tax1 > tax2) {
      tax = tax1;
      rate = result1['rate'] as num;
      surcharge = result1['surcharge'] as num;
    } else {
      surcharge = tax2 - tax1 + (result2['surcharge'] as num);
      tax = tax2;
      rate = result2['rate'] as num;
    }
    // cálculo de um possível desconto
    final discount = _getDiscount(married, tax);
    tax -= discount;
    // cálculo de uma possível redução de imposto
    final reduction = _getReduction(married, salary, children, tax);
    tax -= reduction;
    // resultado
    return {
      'tax': tax.floor(),
      'surcharge': surcharge,
      'discount': discount,
      'reduction': reduction,
      'rate': rate,
    };
  }

  // --------------------------------------------------------------------------
  Map<String, dynamic> _calculateTax2(String married, int children, num salary) {
    // número de partes
    married = married.toLowerCase();
    num shares;
    if (married == "yes") {
      shares = children / 2 + 2;
    } else {
      shares = children / 2 + 1;
    }
    // 1 parte por filho a partir do 3º
    if (children >= 3) {
      // mais meia parte para cada filho a partir do 3º
      shares += 0.5 * (children - 2);
    }
    // renda tributável
    final taxableIncome = _getTaxableIncome(salary);
    // sobretaxa
    num surcharge = (taxableIncome - 0.9 * salary).floor();
    // por questões de arredondamento
    if (surcharge < 0) {
      surcharge = 0;
    }
    // quociente familiar
    final quotient = taxableIncome / shares;
    // cálculo do imposto
    final List<num> limits = List<num>.from(taxAdminData['limits'] as List);
    final List<num> coeffR = List<num>.from(taxAdminData['coeffR'] as List);
    final List<num> coeffN = List<num>.from(taxAdminData['coeffN'] as List);
    // é colocado no final da lista [limits] para parar o laço seguinte
    limits[limits.length - 1] = quotient;
    // procurando a alíquota do imposto
    var i = 0;
    while (quotient > limits[i]) {
      i++;
    }
    // como colocamos quotient no final de limits, o laço anterior
    // não pode ultrapassar a lista limits
    // agora podemos calcular o imposto
    final tax = (taxableIncome * coeffR[i] - shares * coeffN[i]).floor();
    // resultado
    return {'tax': tax, 'surcharge': surcharge, 'rate': coeffR[i]};
  }

  // taxableIncome = annualSalary - allowance (a dedução tem um mínimo e um máximo)
  num _getTaxableIncome(num salary) {
    // dedução de 10% do salário
    num allowance = 0.1 * salary;
    // esta dedução não pode exceder tenPercentAllowanceMax
    final allowanceMax = taxAdminData['tenPercentAllowanceMax'] as num;
    if (allowance > allowanceMax) {
      allowance = allowanceMax;
    }
    // a dedução não pode ser inferior a tenPercentAllowanceMin
    final allowanceMin = taxAdminData['tenPercentAllowanceMin'] as num;
    if (allowance < allowanceMin) {
      allowance = allowanceMin;
    }
    // renda tributável
    final taxableIncome = salary - allowance;
    return taxableIncome.floor();
  }

  // calcula um possível desconto
  num _getDiscount(String married, num taxes) {
    // inicialmente, um desconto zero
    num discount = 0;
    // valor máximo do imposto para ter direito ao desconto
    final taxCeilingForDiscount = married == "yes"
        ? taxAdminData['coupleTaxCeilingForDiscount'] as num
        : taxAdminData['singleTaxCeilingForDiscount'] as num;
    if (taxes < taxCeilingForDiscount) {
      // valor máximo do desconto
      final discountCeiling = married == "yes"
          ? taxAdminData['coupleDiscountCeiling'] as num
          : taxAdminData['singleDiscountCeiling'] as num;
      // desconto teórico
      discount = discountCeiling - 0.75 * taxes;
      // o desconto não pode exceder o valor do imposto
      if (discount > taxes) {
        discount = taxes;
      }
      // nenhum desconto < 0
      if (discount < 0) {
        discount = 0;
      }
    }
    // resultado - ceil() é o equivalente Dart de Math.ceil()
    return discount.ceil();
  }

  // calcula uma possível redução
  num _getReduction(String married, num salary, int children, num taxes) {
    // o teto de renda para ter direito à redução de 20%
    num incomeCeilingForReduction = married == "yes"
        ? taxAdminData['coupleIncomeCeilingForReduction'] as num
        : taxAdminData['singleIncomeCeilingForReduction'] as num;
    final halfShareReductionValue = taxAdminData['halfShareReductionValue'] as num;
    incomeCeilingForReduction += children * halfShareReductionValue;
    if (children > 2) {
      incomeCeilingForReduction += (children - 2) * halfShareReductionValue;
    }
    // renda tributável
    final taxableIncome = _getTaxableIncome(salary);
    // redução
    num reduction = 0;
    if (taxableIncome < incomeCeilingForReduction) {
      // redução de 20%
      reduction = 0.2 * taxes;
    }
    return reduction.ceil();
  }
}

Vamos analisar este código:

  • linha 12: [Business(this.taxAdminData)]: o construtor recebe os dados fiscais brutos recuperados pelo DAO uma única vez —nenhuma outra chamada de rede é necessária depois disso para calcular um imposto.
  • linha 19: [Map<String, dynamic> calculateTax(String married, int children, num salary)]: uma conversão fiel, linha por linha, do algoritmo TypeScript —mesmas etapas ([_calculateTax2], [_getTaxableIncome], [_getDiscount], [_getReduction]), mesma lógica para limitar o quociente familiar.
  • [.floor()]/[.ceil()] (métodos de [num]) substituem [Math.floor(...)]/[Math.ceil(...)]: em Dart, são métodos de instância do próprio número, e não métodos estáticos de uma classe utilitária.
  • As CHAVES do [Map] retornado ([tax], [surcharge], [discount], [reduction]...) têm os mesmos nomes ASCII simples que os IDENTIFICADORES Dart (nomes de variáveis e parâmetros) —uma string pode conter acentos em Dart, mas um identificador não (veja simulation.dart, mais adiante neste capítulo).

6.3.3. O [Dao2]

6.3.4. script [dao2]

// dao2.dart
// Porta Dao2.ts: idêntico a dao1.dart para initSession e
// authenticateUser, mas expõe [getAdminData] em vez de
// [calculateTax]/[listSimulations]/[deleteSimulation] - o cálculo e
// a lista de simulações agora são tratados no lado do CLIENTE pela
// camada [business] (veja business.dart), o servidor servindo apenas para fornecer os
// dados tributários brutos (alíquotas, tetos...).
import 'package:dio/dio.dart';

class Dao2 {
  final Dio _dio;
  final String _sessionCookieName;
  String _sessionCookie = '';

  Dao2(this._dio) : _sessionCookieName = "connect.sid";

  Future<dynamic> initSession() {
    return _getRemoteData(
      'main.php',
      method: 'GET',
      queryParameters: {'action': 'init-session', 'type': 'json'},
    );
  }

  Future<dynamic> authenticateUser(String user, String password) {
    return _getRemoteData(
      'main.php',
      method: 'POST',
      queryParameters: {'action': 'authenticate-user'},
      data: {'user': user, 'password': password},
      contentType: Headers.formUrlEncodedContentType,
    );
  }

  Future<dynamic> getAdminData() {
    return _getRemoteData(
      'main.php',
      method: 'GET',
      queryParameters: {'action': 'get-admindata'},
    );
  }

  Future<dynamic> _getRemoteData(
    String path, {
    required String method,
    Map<String, dynamic>? queryParameters,
    Object? data,
    String? contentType,
  }) async {
    final options = Options(
      method: method,
      contentType: contentType,
      headers: {'Cookie': _sessionCookie},
      validateStatus: (_) => true,
    );
    final response = await _dio.request(
      path,
      queryParameters: queryParameters,
      data: data,
      options: options,
    );
    final setCookie = response.headers['set-cookie'];
    if (setCookie != null) {
      for (final header in setCookie) {
        final result = RegExp('^($_sessionCookieName.+?);').firstMatch(header);
        if (result != null) {
          _sessionCookie = result.group(1)!;
          break;
        }
      }
    }
    return response.data;
  }
}

Vamos comentar este código:

  • linha 4: Idêntico a [Dao1] para [initSession] e [authenticateUser], mas expõe [getAdminData] em vez de [calculateTax]/[listSimulations] (linha 4)/[deleteSimulation] (linha 4): essas três operações agora são tratadas no lado do CLIENTE pela camada [business] que acabamos de apresentar.

6.3.5. O [main2]

6.3.6. script [main2]

// main2.dart
// Porta main2.ts.
import 'dart:convert';
import 'package:dio/dio.dart';
import 'dao2.dart';
import 'business.dart';

Future<void> main() async {
  // configuração do Dio
  final dio = Dio(BaseOptions(
    baseUrl: 'http://localhost:3000/',
    connectTimeout: const Duration(seconds: 2),
    receiveTimeout: const Duration(seconds: 2),
  ));
  // instanciação da camada [dao]
  final dao = Dao2(dio);
  // requisições HTTP
  Map<String, dynamic> taxAdminData;
  try {
    // inicialização da sessão
    log("-----------init-session");
    dynamic response = await dao.initSession();
    log(response);
    // autenticação
    log("-----------authenticate-user");
    response = await dao.authenticateUser("admin", "admin");
    log(response);
    // dados tributários
    log("-----------get-admindata");
    response = await dao.getAdminData();
    log(response);
    taxAdminData = response['response'] as Map<String, dynamic>;
  } catch (error) {
    // registramos o erro no log
    print("error=$error");
    // fim
    return;
  }

  // instanciação da camada [business]
  final business = Business(taxAdminData);

  // cálculos de imposto
  log("-----------calculate-tax x 3");
  final List<Map<String, dynamic>> simulations = [];
  simulations.add(business.calculateTax("yes", 2, 45000));
  simulations.add(business.calculateTax("no", 2, 45000));
  simulations.add(business.calculateTax("no", 1, 30000));
  // lista de simulações
  log("-----------list-of-simulations");
  log(simulations);
  // exclusão de uma simulação
  log("-----------deleting simulation no. 1");
  simulations.removeAt(1);
  log(simulations);
}

// log JSON
void log(Object? object) {
  const JsonEncoder encoder = JsonEncoder.withIndent('  ');
  print(encoder.convert(object));
}

Vamos comentar este código:

  • linha 41: [final business = Business(taxAdminData);]: a camada [business] é instanciada apenas UMA VEZ, imediatamente após a recuperação dos dados fiscais do servidor.
  • [simulations.add(business.calculateTax(...));]: os cálculos de imposto não envolvem mais NENHUMA chamada de rede —ao contrário de main1.dart, em que cada cálculo era uma requisição HTTP separada.

O resultado da execução é o seguinte:

"-----------init-session"
{
"action": "init-session",
"status": 700,
"response": "session started with type [json]"
}
"-----------authenticate-user"
{
"action": "authenticate-user",
"status": 200,
"response": "Authentication successful [admin, admin]"
}
"-----------get-admindata"
{
"action": "get-admindata",
"status": 1000,
"response": {
"limits": [
9964,
27519,
73779,
156244,
0
],
"coeffR": [
0,
0.14,
0.3,
0.41,
0.45
],
"coeffN": [
0,
1394.96,
5798,
13913.69,
20163.45
],
"halfShareQfCeiling": 1551,
"singleIncomeCeilingForReduction": 21037,
"coupleIncomeCeilingForReduction": 42074,
"halfShareReductionValue": 3797,
"singleDiscountCeiling": 1196,
"coupleDiscountCeiling": 1970,
"coupleTaxCeilingForDiscount": 2627,
"singleTaxCeilingForDiscount": 1595,
"tenPercentAllowanceMax": 12502,
"tenPercentAllowanceMin": 437
}
}
"-----------calculate-tax x 3"
"-----------list-of-simulations"
[
{
"tax": 502,
"surcharge": 0,
"discount": 857,
"reduction": 126,
"rate": 0.14
},
{
"tax": 3250,
"surcharge": 370,
"discount": 0,
"reduction": 0,
"rate": 0.3
},
{
"tax": 1687,
"surcharge": 0,
"discount": 0,
"reduction": 0,
"rate": 0.14
}
]
"-----------deleting simulation no. 1"
[
{
"tax": 502,
"surcharge": 0,
"discount": 857,
"reduction": 126,
"rate": 0.14
},
{
"tax": 1687,
"surcharge": 0,
"discount": 0,
"reduction": 0,
"rate": 0.14
}
]

6.4. Cliente HTTP 3

Image

6.4.1. Evolução das ferramentas desde 2019

Este terceiro cliente usa o mesmo par [dao]/[business] do cliente HTTP 2, mas é COMPILADO PARA O NAVEGADOR em vez de ser executado pela linha de comando. Assim como no TypeScript, essa build exige webpack e babel, além de polyfills ([core-js/stable], [regenerator-runtime/runtime]) para que o código moderno funcione em navegadores antigos. No lado do Dart, o SDK fornece seu próprio compilador web ([dart compile js]): não são necessários polyfills; [Future]/[async]/[await], records, patterns etc. são compilados diretamente para o JavaScript equivalente, seja qual for o alvo.

6.4.2. Compilação e execução do projeto

A partir da pasta [http client 3]:

O servidor de desenvolvimento [webdev serve] não é fornecido pelo SDK do Dart: o pacote [webdev] deve primeiro ser instalado uma vez, globalmente, com [dart pub global activate webdev].

Esse comando instala o executável [webdev] no cache global do pub, uma pasta que não é adicionada automaticamente ao PATH do Windows. Para adicioná-la de uma vez por todas (para o usuário atual), abra um terminal PowerShell e execute:

[Environment]::SetEnvironmentVariable("Path", $env:Path + ";$env:LOCALAPPDATA\Pub\Cache\bin", "User")

Em seguida, é preciso fechar e reabrir o terminal (ou o VSCode) para que o novo PATH tenha efeito. Depois, ainda na pasta [http client 3]:

dart pub get
webdev serve

Em desenvolvimento, [webdev serve] inicia um servidor que recompila automaticamente a cada alteração (hot reload): o terminal exibe a URL a ser aberta em um navegador (padrão: http://localhost:8080). Para uma build de produção, o comando [dart compile js web/main.dart -o web/main.dart.js] continua disponível: a página [web/index.html] carrega então [main.dart.js] para testar o resultado —o mesmo conceito do ponto de entrada mínimo [src/index.ts] no curso de TypeScript.

6.4.3. O script [main3]

6.4.4. script [main3]

// main3.dart
// Porta main3.ts.
//
// [AVISO, diferença fundamental com o TypeScript] main3.ts precisava de
// dois polyfills (core-js/stable, regenerator-runtime) para que
// async/await e recursos recentes do JavaScript funcionem em
// navegadores antigos, depois de transpilados por babel/webpack. O
// compilador Dart para a web (`dart compile js`) NÃO precisa de nenhum
// polyfill desse tipo: Future/async/await, Records, patterns...
// são compilados diretamente para JavaScript ou WebAssembly equivalente,
// seja qual for o alvo - uma vantagem direta de compilar
// a partir de uma linguagem e de ferramentas unificadas, em vez de transpilar
// JavaScript "moderno" para JavaScript "antigo".
import 'dart:convert';
import 'package:http/browser_client.dart';
import 'dao3.dart';
import 'business.dart';

Future<void> main() async {
  // cliente HTTP específico do navegador, com withCredentials=true -
  // o equivalente Dart de "axios.defaults.withCredentials = true"
  final client = BrowserClient()..withCredentials = true;
  final dao = Dao3(client, 'http://localhost:3000');

  Map<String, dynamic> taxAdminData;
  try {
    log("-----------init-session");
    Map<String, dynamic> response = await dao.initSession();
    log(response);
    if (response['status'] != 700) {
      throw Exception(jsonEncode(response['response']));
    }
    log("-----------authenticate-user");
    response = await dao.authenticateUser("admin", "admin");
    log(response);
    if (response['status'] != 200) {
      throw Exception(jsonEncode(response['response']));
    }
    log("-----------get-admindata");
    response = await dao.getAdminData();
    log(response);
    if (response['status'] != 1000) {
      throw Exception(jsonEncode(response['response']));
    }
    taxAdminData = response['response'] as Map<String, dynamic>;
  } catch (error) {
    print("error=$error");
    return;
  } finally {
    client.close();
  }

  // instanciação da camada [business]
  final business = Business(taxAdminData);

  log("-----------calculate-tax x 3");
  final List<Map<String, dynamic>> simulations = [];
  simulations.add(business.calculateTax("yes", 2, 45000));
  simulations.add(business.calculateTax("no", 2, 45000));
  simulations.add(business.calculateTax("no", 1, 30000));
  log("-----------list-of-simulations");
  log(simulations);
  log("-----------deleting simulation no. 1");
  simulations.removeAt(1);
  log(simulations);
}

// log JSON
void log(Object? object) {
  const JsonEncoder encoder = JsonEncoder.withIndent('  ');
  print(encoder.convert(object));
}

Vamos comentar este código:

  • linha 22: [final client = BrowserClient()..withCredentials = true;]: [BrowserClient] ([package:http/browser_client.dart]) só existe quando o código é compilado para a web; sua opção [withCredentials] é o equivalente em Dart de [axios.defaults.withCredentials = true] —o NAVEGADOR passa então a cuidar sozinho do cookie de sessão.
  • O compilador web do Dart não exige NENHUM polyfill (ao contrário de main3.ts): [Future]/[async]/[await] e os recursos recentes da linguagem são compilados diretamente —um benefício direto de partir de uma linguagem e de um conjunto de ferramentas unificados, em vez de transpilar de JavaScript moderno para JavaScript legado.

6.4.5. O [Dao3]

6.4.6. script [dao3]

// dao3.dart
// Porta tax client/http client 3/src/Dao3.ts.
//
// Diferença com dao2.dart: este arquivo se destina a ser compilado para o
// NAVEGADOR (com `dart compile js`, veja o README desta pasta), e não
// executado na CLI com `dart run`. Em um navegador, o COOKIE DE SESSÃO
// é tratado automaticamente pelo próprio navegador (como para qualquer
// página web) assim que seu envio é permitido - portanto não há mais
// necessidade do controle MANUAL de cookies feito à mão em dao1.dart/dao2.dart
// (exatamente o raciocínio, já presente, que permitiu a Dao3.ts
// remover todo o código de tratamento de cookies de Dao2.ts).
//
// [correspondência com o TypeScript] "axios.defaults.withCredentials = true"
// (definido em main3.dart, e não aqui) corresponde, do lado do pacote [http] do Dart, à
// opção [withCredentials] do cliente específico para web,
// [BrowserClient] (package:http/browser_client.dart) - uma classe que
// existe SOMENTE quando o código é compilado para a web, ao contrário de
// http.Client, que funciona em qualquer lugar.
import 'dart:convert';
import 'package:http/http.dart' as http;

class Dao3 {
  final http.Client _client;
  final String _baseUrl;

  Dao3(this._client, this._baseUrl);

  Future<dynamic> initSession() {
    return _getRemoteData(
      'main.php',
      method: 'GET',
      queryParameters: {'action': 'init-session', 'type': 'json'},
    );
  }

  Future<dynamic> authenticateUser(String user, String password) {
    return _getRemoteData(
      'main.php',
      method: 'POST',
      queryParameters: {'action': 'authenticate-user'},
      body: {'user': user, 'password': password},
    );
  }

  Future<dynamic> getAdminData() {
    return _getRemoteData(
      'main.php',
      method: 'GET',
      queryParameters: {'action': 'get-admindata'},
    );
  }

  Future<dynamic> _getRemoteData(
    String path, {
    required String method,
    Map<String, dynamic>? queryParameters,
    Map<String, String>? body,
  }) async {
    final uri = Uri.parse('$_baseUrl/$path').replace(
      queryParameters: queryParameters?.map((k, v) => MapEntry(k, '$v')),
    );
    final http.Response response;
    if (method == 'POST') {
      response = await _client.post(uri, body: body);
    } else {
      response = await _client.get(uri);
    }
    // [diferença com o cliente CLI] nenhuma leitura manual do cabeçalho set-cookie
    // aqui: em um navegador, response.headers nem sequer o expõe
    // (cabeçalho protegido pelo navegador, invisível para o
    // código JavaScript/Dart, justamente porque já é tratado por ele mesmo)
    return jsonDecode(response.body);
  }
}

Vamos comentar este código:

  • NÃO há mais rastreamento manual do cookie de sessão (ao contrário de [Dao1]/[Dao2]): em um navegador, o cookie de sessão é gerenciado automaticamente pelo próprio navegador, desde que o envio de cookies seja permitido ([withCredentials], definido em main3.dart).
  • [response.headers] nem sequer expõe mais o cabeçalho [set-cookie] em um navegador: um cabeçalho protegido, invisível ao código JavaScript/Dart do lado do cliente, justamente porque já é gerenciado por conta própria.

6.4.7. Compilação e execução

Veja a seção [Compiling and Running the Project] acima: o mesmo comando [dart compile js] compila [web/main.dart], que delega a [main3.dart].

Inicie o servidor de desenvolvimento para executar a aplicação web do cliente Http3:

1
2
3
4
5
PS C:\Data\st-2026\dev\dart-sept-2026-scripts\dart-fundamentals\tax-client\dart-fundamentals\tax client\http client 3> webdev serve
[INFO] Serving `web` on http://127.0.0.1:8080
[INFO] ------------------------------------------------------------------------------------
[INFO] Injected debugging metadata for entrypoint at http://127.0.0.1:8080/main.dart.bootstr
[INFO] Injected debugging metadata for entrypoint at http://localhost:8080/main.dart.bootstrap.js

O resultado da execução é o seguinte:

Image

  • Em [1], abra um navegador e solicite a URL [http://localhost:8080];
  • em [2], o texto exibido pela página solicitada;
  • em [3], o resultado da execução pode ser encontrado no console do navegador (F12 e, em seguida, a opção Console). Obtemos o mesmo resultado de antes, mas desta vez em um navegador;

6.5. Cliente HTML

Image

6.5.1. Arquitetura da solução

Este quarto e último cliente acrescenta uma verdadeira interface HTML sobre o cliente HTTP 3: as camadas [dao] ([Dao3]) e [business] ([Business]) são REUTILIZADAS SEM MODIFICAÇÃO, e duas novas camadas são acrescentadas —VIEWS (construção do DOM) e CONTROLLER (orquestração). O projeto é organizado em duas pastas, [web/] (ponto de entrada, HTML, CSS) e [lib/] (código compartilhado), seguindo a convenção de um projeto web Dart padrão —veja o README.md desta pasta para detalhes sobre essa convenção.

6.5.2. O template HTML: o arquivo [web/index.html]

Copiado exatamente de [src/index.html] (as mesmas classes CSS: [banner], [menu], [content], [section-title], [field-row], [result], [error], [simulations]...), com uma pequena diferença: o script carregado é [main.dart.js] (um nome FIXO definido pela ferramenta web do Dart), enquanto o [index.html] de Views.ts carregava um bundle do Webpack com nome HASHEADO ([main.a44f6e1c12ab338daedc.js]).

6.5.3. A configuração [webpack.config.js] modificada

Não é necessário nenhum equivalente no lado do Dart: nenhum arquivo de configuração de bundler precisa ser escrito. [web/main.dart], simplesmente por sua POSIÇÃO na árvore de diretórios (diretamente em [web/]), desempenha o papel que a linha [entry: './src/main3.ts'] desempenhava para o [webpack.config.js] —uma convenção de nomes e de localização substitui todo um arquivo de configuração.

6.5.4. As camadas [dao] e [business]: dois arquivos reutilizados sem modificação

[lib/dao3.dart] e [lib/business.dart] são cópias EXATAS dos arquivos de mesmo nome do cliente HTTP 3 - a mesma reutilização, sem nenhuma modificação, feita por Views.ts e AppHtml.ts sobre [Dao3.ts] e [Business.ts].

6.5.5. A camada [views]: o [Views.ts]

6.5.6. scripts [simulation, views]

A camada de views se apoia em TRÊS arquivos: simulation.dart (os dados exibidos), views.dart (a construção do DOM) e app_html.dart (o controller, discutido na próxima seção). Comecemos por simulation.dart:

// simulation.dart
// O resultado de um cálculo de imposto, como retornado por business.dart,
// completado com os parâmetros informados. Porta a interface [Simulation] de Views.ts.
//
// [NOVO, Dart 3] aqui usamos um RECORD nomeado (veja
// dart-fundamentals/dart3/dart3_01_records.dart) em vez de uma classe: um
// simples alias de tipo [typedef], sem construtor nem arquivo separado a
// escrever, para dados que são apenas um "saco" simples de campos, sem comportamento
// associado - exatamente o espírito da interface TypeScript
// original.
//
// [NOTA sobre nomes de campos] ao contrário de TypeScript/JavaScript, em que
// um identificador pode conter letras acentuadas (usadas em todo o
// curso original em francês), o Dart restringe os
// identificadores a letras ASCII: acentos só são possíveis em
// STRINGS, nunca em um nome de
// variável, campo, classe ou record. De todo modo, este curso
// usa nomes ASCII simples em inglês em todo lugar (married, tax, discount...):
// os campos do record abaixo têm os mesmos nomes que as chaves do Map de
// business.dart.
typedef Simulation = ({
  String married,
  int children,
  num salary,
  num tax,
  num surcharge,
  num discount,
  num reduction,
  num rate,
});

Vamos analisar este código:

  • linhas 21–24: [typedef Simulation = ({String married, int children, num salary, ...});]: enquanto Views.ts declarava uma INTERFACE [Simulation], este arquivo usa um record NOMEADO do Dart 3 (veja dart3_01_records.dart) —um simples alias de tipo, sem construtor nem arquivo separado, para dados puramente descritivos.
  • Os nomes dos campos são ASCII simples ([married], [tax], [discount]...): os IDENTIFICADORES do Dart são restritos a letras ASCII, ao contrário do TypeScript/JavaScript, em que nomes acentuados como [marié]/[impôt] (usados no curso original em francês) são nomes de campo válidos.

[lib/views.dart], composto por DOM e [package:web]:

// views.dart
// Porta Views.ts: construção das views (DOM) da aplicação - view de
// autenticação, view de cálculo de imposto, view de lista de simulações. Este
// módulo não faz nenhuma chamada de rede: ele constrói o DOM e delega as ações do
// usuário a funções de callback fornecidas pelo
// controller (veja app_html.dart).
//
// [escolha técnica] aqui usamos [package:web] (pub.dev/packages/web),
// o substituto moderno do antigo dart:html: ele expõe uma API de DOM muito
// próxima do DOM padrão usado por Views.ts (document.createElement,
// .textContent, .addEventListener...). Uma diferença superficial a
// conhecer: um manipulador de eventos Dart (uma função simples) deve
// ser convertido em uma função JavaScript com [.toJS] (extensão de
// dart:js_interop) antes de ser passado a [addEventListener] - a "ponte"
// entre o mundo Dart e o mundo JavaScript, explicitada, onde
// o TypeScript não precisa de conversão (tudo ali já é
// JavaScript).
import 'dart:js_interop';
import 'package:web/web.dart' as web;
import 'simulation.dart';

// uma decoração genérica (não a foto do servidor PHP original)
const String _logoSvg = '''
<svg width="60" height="60" viewBox="0 0 60 60" xmlns="http://www.w3.org/2000/svg">
  <circle cx="30" cy="30" r="29" fill="#eef1ec" stroke="#ccc" />
  <g fill="none" stroke="#8a9a7a" stroke-width="2">
    <path d="M30 46 C30 32 22 28 17 19" />
    <path d="M30 46 C30 30 39 26 44 17" />
    <path d="M30 46 C30 37 30 30 30 21" />
  </g>
  <g fill="#b9c9a6">
    <circle cx="17" cy="19" r="4.5" />
    <circle cx="44" cy="17" r="4.5" />
    <circle cx="30" cy="19" r="4.5" />
  </g>
</svg>''';

// callbacks da view de [autenticação] - [diferença com o TypeScript]
// uma interface de callbacks do TypeScript se traduz naturalmente em um
// RECORD de funções em Dart (veja simulation.dart): mais leve que uma
// classe, para um simples grupo de funções
typedef AuthenticationCallbacks = ({void Function(String user, String password) onSubmit});

typedef CalculationCallbacks = ({
  void Function(String married, int children, int salary) onSubmit,
  void Function() onList,
  void Function() onEndSession,
});

typedef ListCallbacks = ({
  void Function(int number) onDelete,
  void Function() onCalculation,
  void Function() onEndSession,
});

class Views {
  final web.HTMLElement root;
  late web.HTMLDivElement _banner;
  late web.HTMLDivElement _menu;
  late web.HTMLDivElement _content;

  // constrói a estrutura fixa da página (banner + área de menu/conteúdo)
  // dentro do elemento [root]
  Views(this.root) {
    // [AVISO] ao contrário das propriedades comuns do DOM (textContent,
    // value...), o setter [innerHTML] de package:web espera um [JSAny], não
    // uma [String] Dart pura - uma peculiaridade de sua geração ligada ao
    // atributo WebIDL [LegacyNullToEmptyString] do DOM padrão: portanto
    // sempre devemos converter com [.toJS].
    root.innerHTML = ''.toJS;

    _banner = _div()..className = 'banner';
    final logo = _div()..className = 'logo';
    logo.innerHTML = _logoSvg.toJS;
    final title = web.document.createElement('h1') as web.HTMLHeadingElement;
    title.textContent = 'Calculate your tax';
    _banner
      ..appendChild(logo)
      ..appendChild(title);

    final body = _div()..className = 'page-body';
    _menu = _div()..className = 'menu';
    _content = _div()..className = 'content';
    body
      ..appendChild(_menu)
      ..appendChild(_content);

    root
      ..appendChild(_banner)
      ..appendChild(body);
  }

  // --------------------------------------------------------------------
  // ferramentas de construção do DOM
  // --------------------------------------------------------------------

  web.HTMLDivElement _div() => web.document.createElement('div') as web.HTMLDivElement;

  void _clearMenu() {
    _menu.innerHTML = ''.toJS;
    _menu.style.display = 'none';
    _content.classList.add('full-width');
  }

  web.HTMLAnchorElement _menuLink(String text, void Function() onClick) {
    final a = web.document.createElement('a') as web.HTMLAnchorElement;
    a.textContent = text;
    a.addEventListener('click', ((web.Event event) => onClick()).toJS);
    return a;
  }

  void _showMenu(List<web.HTMLAnchorElement> links) {
    _menu.innerHTML = ''.toJS;
    _menu.style.display = '';
    _content.classList.remove('full-width');
    for (final link in links) {
      _menu.appendChild(link);
    }
  }

  web.HTMLElement? _errorBanner(String? message) {
    if (message == null) return null;
    final div = _div()..className = 'error';
    div.textContent = message;
    return div;
  }

  // uma linha de formulário [rótulo + campo texto/senha/número]
  (web.HTMLDivElement row, web.HTMLInputElement input) _fieldRow(
    String labelText,
    String type,
    String initialValue, {
    String? help,
  }) {
    final row = _div()..className = 'field-row';
    final label = web.document.createElement('label') as web.HTMLLabelElement;
    label.textContent = labelText;
    final field = _div()..className = 'field';
    final input = web.document.createElement('input') as web.HTMLInputElement;
    input.type = type;
    input.value = initialValue;
    if (type == 'number') {
      input.min = '0';
    }
    field.appendChild(input);
    if (help != null) {
      final div = _div()..className = 'help';
      div.textContent = help;
      field.appendChild(div);
    }
    row
      ..appendChild(label)
      ..appendChild(field);
    return (row, input);
  }

  // --------------------------------------------------------------------
  // view de [autenticação]
  // --------------------------------------------------------------------
  void authenticationView(String? error, AuthenticationCallbacks callbacks) {
    _clearMenu();
    _content.innerHTML = ''.toJS;

    final title = _div()
      ..className = 'section-title'
      ..textContent = 'Please authenticate';
    _content.appendChild(title);

    final banner = _errorBanner(error);
    if (banner != null) _content.appendChild(banner);

    final userField = _fieldRow("Username", 'text', 'admin');
    final passwordField = _fieldRow('Password', 'password', '');
    _content
      ..appendChild(userField.$1)
      ..appendChild(passwordField.$1);

    final button = web.document.createElement('button') as web.HTMLButtonElement;
    button.textContent = 'Submit';
    button.addEventListener(
      'click',
      ((web.Event event) {
        callbacks.onSubmit(userField.$2.value.trim(), passwordField.$2.value);
      }).toJS,
    );
    _content.appendChild(button);
  }

  // --------------------------------------------------------------------
  // view de [cálculo de imposto]
  // --------------------------------------------------------------------
  void calculationView(Simulation? result, String? error, CalculationCallbacks callbacks) {
    _showMenu([
      _menuLink('List of simulations', callbacks.onList),
      _menuLink('End of session', callbacks.onEndSession),
    ]);

    _content.innerHTML = ''.toJS;

    final title = _div()
      ..className = 'section-title'
      ..textContent = 'Fill in the form below and then submit it';
    _content.appendChild(title);

    final banner = _errorBanner(error);
    if (banner != null) _content.appendChild(banner);

    // linha dos radios de [married]
    final marriedRow = _div()..className = 'field-row';
    final marriedLabel = web.document.createElement('label') as web.HTMLLabelElement;
    marriedLabel.textContent = 'Are you married or in a civil partnership?';
    final marriedField = _div()..className = 'field radios';

    final radioYes = web.document.createElement('input') as web.HTMLInputElement;
    radioYes.type = 'radio';
    radioYes.name = 'married';
    radioYes.value = 'yes';
    radioYes.checked = true;
    final labelYes = web.document.createElement('label') as web.HTMLLabelElement;
    labelYes.appendChild(radioYes);
    labelYes.appendChild(web.document.createTextNode(' Yes'));

    final radioNo = web.document.createElement('input') as web.HTMLInputElement;
    radioNo.type = 'radio';
    radioNo.name = 'married';
    radioNo.value = 'no';
    final labelNo = web.document.createElement('label') as web.HTMLLabelElement;
    labelNo.appendChild(radioNo);
    labelNo.appendChild(web.document.createTextNode(' No'));

    marriedField
      ..appendChild(labelYes)
      ..appendChild(labelNo);
    marriedRow
      ..appendChild(marriedLabel)
      ..appendChild(marriedField);
    _content.appendChild(marriedRow);

    final childrenField = _fieldRow("Number of dependent children", 'number', '0');
    _content.appendChild(childrenField.$1);

    final salaryField = _fieldRow(
      'Annual salary',
      'number',
      '',
      help: "Round down to the nearest euro",
    );
    _content.appendChild(salaryField.$1);

    final button = web.document.createElement('button') as web.HTMLButtonElement;
    button.textContent = 'Submit';
    button.addEventListener(
      'click',
      ((web.Event event) {
        final married = radioYes.checked ? 'yes' : 'no';
        final children = int.tryParse(childrenField.$2.value) ?? 0;
        final salary = int.tryParse(salaryField.$2.value) ?? 0;
        callbacks.onSubmit(married, children, salary);
      }).toJS,
    );
    _content.appendChild(button);

    // resultado da última simulação (caixa verde), se houver
    if (result != null) {
      final box = _div()..className = 'result';
      final ratePercent = (result.rate * 100).round();
      box.innerHTML = ("Tax amount: ${result.tax} euros<br>"
              "Discount: ${result.discount} euros<br>"
              "Reduction: ${result.reduction} euros<br>"
              "Surcharge: ${result.surcharge} euros<br>"
              "Tax rate: $ratePercent %")
          .toJS;
      _content.appendChild(box);
    }
  }

  // --------------------------------------------------------------------
  // view de [lista de simulações]
  // --------------------------------------------------------------------
  void listView(List<Simulation> simulations, String? error, ListCallbacks callbacks) {
    _showMenu([
      _menuLink("Tax calculation", callbacks.onCalculation),
      _menuLink('End of session', callbacks.onEndSession),
    ]);

    _content.innerHTML = ''.toJS;

    final title = _div()
      ..className = 'section-title'
      ..textContent = 'List of your simulations';
    _content.appendChild(title);

    final banner = _errorBanner(error);
    if (banner != null) _content.appendChild(banner);

    if (simulations.isEmpty) {
      final empty = _div()
        ..className = 'simulations-empty'
        ..textContent = 'No simulation recorded.';
      _content.appendChild(empty);
      return;
    }

    final table = web.document.createElement('table') as web.HTMLTableElement;
    table.className = 'simulations';
    final thead = web.document.createElement('thead') as web.HTMLTableSectionElement;
    thead.innerHTML = ("<tr><th>#</th><th>Married</th><th>Number of children</th>"
            "<th>Annual salary</th><th>Tax amount</th><th>Surcharge</th>"
            "<th>Discount</th><th>Reduction</th><th>Rate</th><th></th></tr>")
        .toJS;
    table.appendChild(thead);

    final tbody = web.document.createElement('tbody') as web.HTMLTableSectionElement;
    for (var number = 0; number < simulations.length; number++) {
      final simulation = simulations[number];
      final tr = web.document.createElement('tr') as web.HTMLTableRowElement;
      final ratePercent = (simulation.rate * 100).round();
      tr.innerHTML = ("<td>$number</td>"
              "<td>${simulation.married}</td>"
              "<td>${simulation.children}</td>"
              "<td>${simulation.salary}</td>"
              "<td>${simulation.tax}</td>"
              "<td>${simulation.surcharge}</td>"
              "<td>${simulation.discount}</td>"
              "<td>${simulation.reduction}</td>"
              "<td>$ratePercent %</td>")
          .toJS;
      final tdDelete = web.document.createElement('td') as web.HTMLTableCellElement;
      final deleteLink = web.document.createElement('a') as web.HTMLAnchorElement;
      deleteLink.className = 'delete';
      deleteLink.textContent = 'Delete';
      deleteLink.addEventListener(
        'click',
        ((web.Event event) => callbacks.onDelete(number)).toJS,
      );
      tdDelete.appendChild(deleteLink);
      tr.appendChild(tdDelete);
      tbody.appendChild(tr);
    }
    table.appendChild(tbody);
    _content.appendChild(table);
  }
}

Vamos analisar este código:

  • linha 19: [import 'package:web/web.dart' as web;]: o substituto moderno do antigo [dart:html], com uma API e um DOM muito semelhantes ao DOM padrão usado por Views.ts ([document.createElement], [.textContent], [.addEventListener]...).
  • Linhas 44–45: [typedef CalculationCallbacks = ({void Function(...) onSubmit, ...});]: uma interface de callbacks do TypeScript se traduz naturalmente em um RECORD DE FUNÇÕES em Dart 3 —mais leve que uma classe para um simples grupo de funções.
  • Linha 108: [a.addEventListener('click', ((web.Event event) { ... }).toJS);]: um manipulador de eventos Dart (uma simples função) deve ser convertido em função JavaScript usando [.toJS] (uma extensão de [dart:js_interop]) antes de ser passado a [addEventListener] - a “ponte” entre o mundo Dart e o mundo JavaScript é explicitada, enquanto o TypeScript não exige nenhuma conversão.
  • linha 141: [input.value = initialValue;], [title.textContent = '...';] (linha 76): a maioria das propriedades do tipo string continua sendo simples strings Dart, sem necessidade de conversão. [innerHTML] é a EXCEÇÃO: [dart analyze] sinaliza isso se uma [String] for atribuída diretamente a ele —seu setter espera um [JSAny] (uma peculiaridade de sua geração, relacionada ao atributo WebIDL [LegacyNullToEmptyString] do DOM padrão)—daí [root.innerHTML = ''.toJS;]: uma conversão [.toJS] adicional, além das funções apenas, que deve ser lembrada sempre que se manipular [innerHTML].
  • linha 129: [(web.HTMLDivElement row, web.HTMLInputElement input) _fieldRow(...)]: um RECORD posicional como tipo de retorno, para devolver dois elementos DOM de uma só vez sem uma classe intermediária — mais um uso prático dos records do Dart 3.

6.5.7. O controller: o arquivo [AppHtml.ts]

6.5.8. Script [app_html]

// app_html.dart
// Porta AppHtml.ts: o controller da aplicação HTML. Ele orquestra as
// chamadas ao servidor (camada [dao], dao3.dart), os cálculos
// (camada [business], business.dart) e a exibição das views (camada [views],
// views.dart).
//
// Como main3.dart, este cliente chama o servidor NestJS para apenas três
// ações: [init-session], [authenticate-user] e [get-admindata].
// Uma vez recuperados os dados tributários (alíquotas, tetos...) com
// [get-admindata], é a camada [business] que calcula o imposto no
// navegador, sem nova chamada de rede. A lista de simulações também é
// mantida apenas no navegador (campo [simulations]),
// exatamente como main3.dart faz com sua variável local
// [simulations] (`simulations.add(...)`, `simulations.removeAt(...)`).
import 'dart:js_interop';
import 'package:http/browser_client.dart';
import 'dao3.dart';
import 'business.dart';
import 'simulation.dart';
import 'views.dart';
import 'package:web/web.dart' as web;

class AppHtml {
  final Dao3 dao;
  final Views views;
  // camada [business]: só existe depois que os dados tributários foram recuperados
  // (após uma autenticação bem-sucedida) - veja [_initBusiness]. Um
  // campo NULLABLE (Business?), e não um campo late ([late]): ao contrário de
  // Views.ts, em que [business?: Business] simplesmente permanece "undefined" enquanto
  // não for atribuído, um campo [late] do Dart lançaria um erro se fosse
  // LIDO antes da atribuição (o que é justamente o que [_endSession] faz ao
  // reinicializá-lo) - portanto o tipo nullable é a escolha certa aqui, e não
  // apenas uma questão de estilo.
  Business? _business;
  // lista das simulações já calculadas, mantida no navegador
  List<Simulation> _simulations = [];

  // [diferença com o TypeScript] AppHtml.ts configura uma instância GLOBAL do axios
  // (axios.defaults.timeout/baseURL/withCredentials) e depois a entrega
  // ao Dao. Aqui, [BrowserClient] (package:http/browser_client.dart, já
  // encontrado em main3.dart) carrega o equivalente de
  // "axios.defaults.withCredentials = true"; não há equivalente direto de
  // um "timeout global" em http.Client - ele seria aplicado caso
  // a caso com `.timeout(Duration(...))` em cada chamada, como no
  // capítulo sobre [http] (dart_fetch_01.dart).
  AppHtml()
      : dao = Dao3(
          BrowserClient()..withCredentials = true,
          'http://localhost:3000',
        ),
        views = Views(web.document.getElementById('app') as web.HTMLElement);

  // ponto de entrada da aplicação
  Future<void> start() async {
    try {
      // inicialização da sessão - obrigatória antes de qualquer outra ação (veja main.php)
      final response = await dao.initSession() as Map<String, dynamic>;
      if (response['status'] != 700) {
        views.authenticationView(
          _formatError(response['response']),
          (onSubmit: (user, password) => _authenticate(user, password)),
        );
        return;
      }
    } catch (error) {
      views.authenticationView(
        "Unable to contact the server ($error)",
        (onSubmit: (user, password) => _authenticate(user, password)),
      );
      return;
    }
    // sessão inicializada: exibimos a autenticação
    _showAuthentication();
  }

  // --------------------------------------------------------------------
  // view de [autenticação]
  // --------------------------------------------------------------------
  void _showAuthentication([String? error]) {
    views.authenticationView(
      error,
      (onSubmit: (user, password) => _authenticate(user, password)),
    );
  }

  Future<void> _authenticate(String user, String password) async {
    try {
      final response = await dao.authenticateUser(user, password)
          as Map<String, dynamic>;
      if (response['status'] == 200) {
        // autenticação bem-sucedida: como em main3.dart, agora recuperamos,
        // de uma vez por todas, os dados tributários
        // necessários à camada [business]
        await _initBusiness();
      } else {
        // falha (login/senha incorretos ou parâmetros ausentes)
        _showAuthentication(_formatError(response['response']));
      }
    } catch (error) {
      _showAuthentication("Unable to contact the server ($error)");
    }
  }

  // recupera os dados da administração tributária e instancia a
  // camada [business] com esses dados - uma única chamada ao servidor para toda a
  // sessão, exatamente como main3.dart
  Future<void> _initBusiness() async {
    try {
      final response = await dao.getAdminData() as Map<String, dynamic>;
      if (response['status'] == 1000) {
        _business = Business(response['response'] as Map<String, dynamic>);
        // nova sessão de trabalho: recomeçamos de uma lista vazia
        _simulations = [];
        _showCalculation();
      } else {
        _showAuthentication(_formatError(response['response']));
      }
    } catch (error) {
      _showAuthentication("Unable to contact the server ($error)");
    }
  }

  // --------------------------------------------------------------------
  // view de [cálculo de imposto]
  // --------------------------------------------------------------------
  void _showCalculation([Simulation? result, String? error]) {
    views.calculationView(
      result,
      error,
      (
        onSubmit: (married, children, salary) =>
            _calculate(married, children, salary),
        onList: () => _showList(),
        onEndSession: () => _endSession(),
      ),
    );
  }

  // cálculo do imposto feito inteiramente no navegador (camada [business]):
  // nenhuma chamada ao servidor, ao contrário da primeira versão
  // deste cliente (http client 1 / http client 2)
  void _calculate(String married, int children, int salary) {
    // _business necessariamente foi inicializado: só chegamos à view de [cálculo]
    // depois de _initBusiness (portanto o [!] é seguro aqui, como o
    // [!] do TypeScript em [this.business!])
    final result = _business!.calculateTax(married, children, salary);
    // [diferença com o TypeScript] Views.ts constrói a simulação com um
    // simples spread de objeto: `{ married, children, salary, ...result }`.
    // Aqui, [Simulation] é um RECORD (simulation.dart), e não um Map: um
    // record não pode ser "completado" por spread de um Map, e
    // seus campos são tipados (num, int...), enquanto
    // [result], retornado por business.dart, é um Map sem tipos cujas chaves
    // apenas TÊM os mesmos nomes ('tax', 'surcharge'..., veja business.dart). Portanto
    // reconstruímos o record campo a campo - um pouco mais verboso
    // que um spread, mas inteiramente verificado pelo compilador (um campo esquecido
    // ou com tipo errado é um erro de compilação, e não uma surpresa em
    // tempo de execução).
    final Simulation simulation = (
      married: married,
      children: children,
      salary: salary,
      tax: result['tax'] as num,
      surcharge: result['surcharge'] as num,
      discount: result['discount'] as num,
      reduction: result['reduction'] as num,
      rate: result['rate'] as num,
    );
    // armazenamento no navegador (como `simulations.add(...)` em
    // main3.dart)
    _simulations.add(simulation);
    _showCalculation(simulation);
  }

  // --------------------------------------------------------------------
  // view de [lista de simulações]
  // --------------------------------------------------------------------
  // não há mais chamadas ao servidor aqui: a lista já está inteiramente em
  // [_simulations]
  void _showList([String? error]) {
    views.listView(
      _simulations,
      error,
      (
        onDelete: (number) => _deleteSimulation(number),
        onCalculation: () => _showCalculation(),
        onEndSession: () => _endSession(),
      ),
    );
  }

  void _deleteSimulation(int number) {
    // exclusão local de [_simulations], como
    // `simulations.removeAt(number)` em main3.dart - ainda sem chamada
    // ao servidor
    _simulations.removeAt(number);
    _showList();
  }

  // --------------------------------------------------------------------
  // fim da sessão
  // --------------------------------------------------------------------
  void _endSession() {
    // fim da sessão apenas no lado do cliente: esquecemos a camada [business]
    // (e, portanto, os dados tributários) e as simulações já calculadas, depois
    // voltamos à tela de autenticação. Este cliente não precisa
    // chamar o servidor para isso.
    _business = null;
    _simulations = [];
    _showAuthentication();
  }

  // --------------------------------------------------------------------
  // formata o campo [response] de uma resposta de erro do servidor, que
  // é uma string ou uma lista de strings (veja os controllers PHP)
  // --------------------------------------------------------------------
  String _formatError(Object? response) {
    if (response is List) {
      return response.join(' ; ');
    }
    return '$response';
  }
}

// execução - [diferença com o TypeScript] o manipulador de eventos
// passado a addEventListener deve ser convertido em uma função JavaScript com
// [.toJS] (veja views.dart); esta é apenas a versão "ponto de entrada" da
// mesma regra.
void main() {
  web.window.addEventListener(
    'DOMContentLoaded',
    ((web.Event event) {
      AppHtml().start();
    }).toJS,
  );
}

Vamos comentar este código:

  • linhas 46–51: [AppHtml() : dao = Dao3(BrowserClient()..withCredentials = true, ...), views = Views(...)]: construção do DAO e das VIEWS em uma LISTA DE INICIALIZAÇÃO - mesmo conceito do construtor TypeScript, usando a sintaxe específica do Dart [: field1 = ..., field2 = ...].
  • Linha 34: [Business? _business;]: um campo NULLABLE, onde AppHtml.ts usava antes [business?: Business] - o mesmo conceito (“ainda não inicializado”), usando o mesmo operador [!] para confirmar que o campo está de fato preenchido em um ponto específico do código.
  • Linhas 158–162: [final Simulation simulation = (married: married, ..., tax: result['tax'] as num, ...);]: diferentemente do spread simples [{ married, children, salary, ...result }] de AppHtml.ts, um RECORD não pode ser completado por um spread a partir de um [Map] - o record é, portanto, reconstruído CAMPO A CAMPO, o que é um pouco mais verboso, mas totalmente validado pelo compilador.
  • Linhas 229–233: [web.window.addEventListener('DOMContentLoaded', ((web.Event event) { AppHtml().start(); }).toJS);]: o mesmo ponto de entrada de AppHtml.ts, com a mesma conversão de callback ([.toJS]) de views.dart.

6.5.9. Compilação e execução

Consulte o README.md nesta pasta: [dart pub get] seguido de [webdev serve] para desenvolvimento (incluindo hot reloading), ou [dart compile js web/main.dart -o web/main.dart.js] para um build de produção — o equivalente Dart de [npm run build], sem nenhuma etapa prévia de configuração de bundler.

Se o servidor [webdev serve] ainda estiver em execução para a aplicação web [http client 3], você deve interrompê-lo (Ctrl-C no terminal que o iniciou). Em seguida, em um terminal dentro do diretório [html client]:

dart pub get
webdev serve

A linha 2 inicia o servidor web que servirá a aplicação cliente HTML:

Image

  • Em [1], no navegador, solicite a URL [http://localhost:8080];
  • em [2-3], digite as credenciais admin / admin;
  • Em [4], envie a página;

Image

  • Em [2], preencha os campos;
  • Em [3], envie a página;

Image

O valor do imposto é exibido em [1]. Execute várias simulações e, em seguida, solicite a lista em [2];

Image

  • Em [1], exclua uma simulação;

Image

  • em [1], encerre a sessão;

Image

6.6. Conclusão

Os quatro clientes deste capítulo ilustram, com Dart, exatamente a mesma progressão que com TypeScript: do processamento no lado do servidor ao processamento no lado do cliente e, depois, do script CLI ao cliente web completo. As principais diferenças a observar são o acompanhamento manual do cookie de sessão (necessário no CLI, desnecessário em um navegador), a conversão [.toJS] imposta por [dart:js_interop] para fazer a ponte entre as fronteiras Dart/JavaScript nas views, e a ausência total de polyfills na compilação web — uma clara vantagem da toolchain Dart em relação ao pipeline webpack/babel.