From 01573b9c84eec77464bae19f6b7fb4e7cfa680b6 Mon Sep 17 00:00:00 2001 From: Osni Pezzini Junior Date: Thu, 19 Jun 2025 01:17:18 -0300 Subject: [PATCH 1/2] Added pt-BR translation to units of measurement --- lib/src/units_of_measurement/area.dart | 69 +++--- lib/src/units_of_measurement/area.i18n.dart | 127 +++++++++++ lib/src/units_of_measurement/information.dart | 145 ++++++------ .../information.i18n.dart | 179 +++++++++++++++ lib/src/units_of_measurement/length.dart | 65 +++--- lib/src/units_of_measurement/length.i18n.dart | 87 +++++++ lib/src/units_of_measurement/quantity.dart | 29 ++- .../units_of_measurement/quantity.i18n.dart | 48 ++++ lib/src/units_of_measurement/shared.dart | 21 +- lib/src/units_of_measurement/shared.i18n.dart | 33 +++ lib/src/units_of_measurement/temperature.dart | 33 +-- .../temperature.i18n.dart | 62 +++++ lib/src/units_of_measurement/time.dart | 69 +++--- lib/src/units_of_measurement/time.i18n.dart | 83 +++++++ lib/src/units_of_measurement/volume.dart | 147 ++++++------ lib/src/units_of_measurement/volume.i18n.dart | 213 ++++++++++++++++++ lib/src/units_of_measurement/weight.dart | 49 ++-- lib/src/units_of_measurement/weight.i18n.dart | 78 +++++++ pubspec.lock | 28 ++- pubspec.yaml | 3 +- 20 files changed, 1252 insertions(+), 316 deletions(-) create mode 100644 lib/src/units_of_measurement/area.i18n.dart create mode 100644 lib/src/units_of_measurement/information.i18n.dart create mode 100644 lib/src/units_of_measurement/length.i18n.dart create mode 100644 lib/src/units_of_measurement/quantity.i18n.dart create mode 100644 lib/src/units_of_measurement/shared.i18n.dart create mode 100644 lib/src/units_of_measurement/temperature.i18n.dart create mode 100644 lib/src/units_of_measurement/time.i18n.dart create mode 100644 lib/src/units_of_measurement/volume.i18n.dart create mode 100644 lib/src/units_of_measurement/weight.i18n.dart diff --git a/lib/src/units_of_measurement/area.dart b/lib/src/units_of_measurement/area.dart index c628ca2..7bd7b83 100644 --- a/lib/src/units_of_measurement/area.dart +++ b/lib/src/units_of_measurement/area.dart @@ -1,4 +1,5 @@ import 'package:humanizer/humanizer.dart'; +import 'package:humanizer/src/units_of_measurement/area.i18n.dart'; import 'package:humanizer/src/units_of_measurement/area_constants.dart'; import 'package:humanizer/src/units_of_measurement/rationals.dart'; import 'package:meta/meta.dart'; @@ -330,41 +331,41 @@ extension AreaUnitExtensions on AreaUnit { switch (this) { // SI. case AreaUnit.squareNanometer: - return 'square nanometer'; + return squareNanometer.i18n(locale: locale); case AreaUnit.squareMicrometer: - return 'square micrometer'; + return squareMicrometer.i18n(locale: locale); case AreaUnit.squareMillimeter: - return 'square millimeter'; + return squareMillimeter.i18n(locale: locale); case AreaUnit.squareCentimeter: - return 'square centimeter'; + return squareCentimeter.i18n(locale: locale); case AreaUnit.squareDecimeter: - return 'square decimeter'; + return squareDecimeter.i18n(locale: locale); case AreaUnit.squareMeter: - return 'square meter'; + return squareMeter.i18n(locale: locale); case AreaUnit.squareDecameter: - return 'square decameter'; + return squareDecameter.i18n(locale: locale); case AreaUnit.hectare: - return 'hectare'; + return hectare.i18n(locale: locale); case AreaUnit.squareKilometer: - return 'square kilometer'; + return squareKilometer.i18n(locale: locale); case AreaUnit.squareMegameter: - return 'square megameter'; + return squareMegameter.i18n(locale: locale); case AreaUnit.squareGigameter: - return 'square gigameter'; + return squareGigameter.i18n(locale: locale); // Imperial. case AreaUnit.squareThou: - return 'square thou'; + return squareThou.i18n(locale: locale); case AreaUnit.squareInch: - return 'square inch'; + return squareInch.i18n(locale: locale); case AreaUnit.squareFoot: - return 'square foot'; + return squareFoot.i18n(locale: locale); case AreaUnit.squareYard: - return 'square yard'; + return squareYard.i18n(locale: locale); case AreaUnit.acre: - return 'acre'; + return acre.i18n(locale: locale); case AreaUnit.squareMile: - return 'square mile'; + return squareMile.i18n(locale: locale); } } @@ -375,41 +376,41 @@ extension AreaUnitExtensions on AreaUnit { switch (this) { // SI. case AreaUnit.squareNanometer: - return 'nm²'; + return squareNanometerSymbol.i18n(locale: locale); case AreaUnit.squareMicrometer: - return 'μm²'; + return squareMicrometerSymbol.i18n(locale: locale); case AreaUnit.squareMillimeter: - return 'mm²'; + return squareMillimeterSymbol.i18n(locale: locale); case AreaUnit.squareCentimeter: - return 'cm²'; + return squareCentimeterSymbol.i18n(locale: locale); case AreaUnit.squareDecimeter: - return 'dm²'; + return squareDecimeterSymbol.i18n(locale: locale); case AreaUnit.squareMeter: - return 'm²'; + return squareMeterSymbol.i18n(locale: locale); case AreaUnit.squareDecameter: - return 'dam²'; + return squareDecameterSymbol.i18n(locale: locale); case AreaUnit.hectare: - return 'ha'; + return hectareSymbol.i18n(locale: locale); case AreaUnit.squareKilometer: - return 'km²'; + return squareKilometerSymbol.i18n(locale: locale); case AreaUnit.squareMegameter: - return 'Mm²'; + return squareMegameterSymbol.i18n(locale: locale); case AreaUnit.squareGigameter: - return 'Gm²'; + return squareGigameterSymbol.i18n(locale: locale); // Imperial. case AreaUnit.squareThou: - return 'thou²'; + return squareThouSymbol.i18n(locale: locale); case AreaUnit.squareInch: - return 'in²'; + return squareInchSymbol.i18n(locale: locale); case AreaUnit.squareFoot: - return 'ft²'; + return squareFootSymbol.i18n(locale: locale); case AreaUnit.squareYard: - return 'yd²'; + return squareYardSymbol.i18n(locale: locale); case AreaUnit.acre: - return 'ac'; + return acreSymbol.i18n(locale: locale); case AreaUnit.squareMile: - return 'mi²'; + return squareMileSymbol.i18n(locale: locale); } } diff --git a/lib/src/units_of_measurement/area.i18n.dart b/lib/src/units_of_measurement/area.i18n.dart new file mode 100644 index 0000000..2bdeeb3 --- /dev/null +++ b/lib/src/units_of_measurement/area.i18n.dart @@ -0,0 +1,127 @@ +import 'package:i18n_extension_core/i18n_extension_core.dart'; +import 'package:intl/intl.dart'; + +// Variáveis para os nomes completos das unidades de área (para getName) +final squareNanometer = Object(); +final squareMicrometer = Object(); +final squareMillimeter = Object(); +final squareCentimeter = Object(); +final squareDecimeter = Object(); +final squareMeter = Object(); +final squareDecameter = Object(); +final hectare = Object(); +final squareKilometer = Object(); +final squareMegameter = Object(); +final squareGigameter = Object(); + +final squareThou = Object(); +final squareInch = Object(); +final squareFoot = Object(); +final squareYard = Object(); +final acre = Object(); +final squareMile = Object(); + +// Variáveis para os SÍMBOLOS das unidades de área (para getSymbol) +final squareNanometerSymbol = Object(); +final squareMicrometerSymbol = Object(); +final squareMillimeterSymbol = Object(); +final squareCentimeterSymbol = Object(); +final squareDecimeterSymbol = Object(); +final squareMeterSymbol = Object(); +final squareDecameterSymbol = Object(); +final hectareSymbol = Object(); +final squareKilometerSymbol = Object(); +final squareMegameterSymbol = Object(); +final squareGigameterSymbol = Object(); + +final squareThouSymbol = Object(); +final squareInchSymbol = Object(); +final squareFootSymbol = Object(); +final squareYardSymbol = Object(); +final acreSymbol = Object(); +final squareMileSymbol = Object(); + +extension AreaUnitI18n on Object { + static final _t = Translations.byId('en-US', { + // Nomes completos das unidades (para getName) - SI + squareNanometer: { + 'en-US': 'square nanometer', + 'pt-BR': 'nanômetro quadrado' + }, + squareMicrometer: { + 'en-US': 'square micrometer', + 'pt-BR': 'micrômetro quadrado' + }, + squareMillimeter: { + 'en-US': 'square millimeter', + 'pt-BR': 'milímetro quadrado' + }, + squareCentimeter: { + 'en-US': 'square centimeter', + 'pt-BR': 'centímetro quadrado' + }, + squareDecimeter: { + 'en-US': 'square decimeter', + 'pt-BR': 'decímetro quadrado' + }, + squareMeter: {'en-US': 'square meter', 'pt-BR': 'metro quadrado'}, + squareDecameter: { + 'en-US': 'square decameter', + 'pt-BR': 'decâmetro quadrado' + }, + hectare: {'en-US': 'hectare', 'pt-BR': 'hectare'}, + squareKilometer: { + 'en-US': 'square kilometer', + 'pt-BR': 'quilômetro quadrado' + }, + squareMegameter: { + 'en-US': 'square megameter', + 'pt-BR': 'megâmetro quadrado' + }, + squareGigameter: { + 'en-US': 'square gigameter', + 'pt-BR': 'gigâmetro quadrado' + }, + + // Nomes completos das unidades (para getName) - Imperial + squareThou: { + 'en-US': 'square thou', + 'pt-BR': 'milésimo de polegada quadrado' + }, + squareInch: {'en-US': 'square inch', 'pt-BR': 'polegada quadrada'}, + squareFoot: {'en-US': 'square foot', 'pt-BR': 'pé quadrado'}, + squareYard: {'en-US': 'square yard', 'pt-BR': 'jarda quadrada'}, + acre: {'en-US': 'acre', 'pt-BR': 'acre'}, + squareMile: {'en-US': 'square mile', 'pt-BR': 'milha quadrada'}, + + // Símbolos das unidades (para getSymbol) - SI + squareNanometerSymbol: {'en-US': 'nm²', 'pt-BR': 'nm²'}, + squareMicrometerSymbol: {'en-US': 'μm²', 'pt-BR': 'μm²'}, + squareMillimeterSymbol: {'en-US': 'mm²', 'pt-BR': 'mm²'}, + squareCentimeterSymbol: {'en-US': 'cm²', 'pt-BR': 'cm²'}, + squareDecimeterSymbol: {'en-US': 'dm²', 'pt-BR': 'dm²'}, + squareMeterSymbol: {'en-US': 'm²', 'pt-BR': 'm²'}, + squareDecameterSymbol: {'en-US': 'dam²', 'pt-BR': 'dam²'}, + hectareSymbol: {'en-US': 'ha', 'pt-BR': 'ha'}, + squareKilometerSymbol: {'en-US': 'km²', 'pt-BR': 'km²'}, + squareMegameterSymbol: {'en-US': 'Mm²', 'pt-BR': 'Mm²'}, + squareGigameterSymbol: {'en-US': 'Gm²', 'pt-BR': 'Gm²'}, + + // Símbolos das unidades (para getSymbol) - Imperial + squareThouSymbol: {'en-US': 'thou²', 'pt-BR': 'thou²'}, + squareInchSymbol: { + 'en-US': 'in²', + 'pt-BR': 'pol²' + }, // 'pol²' é um símbolo comum para polegada quadrada + squareFootSymbol: {'en-US': 'ft²', 'pt-BR': 'pé²'}, + squareYardSymbol: {'en-US': 'yd²', 'pt-BR': 'jd²'}, + acreSymbol: {'en-US': 'ac', 'pt-BR': 'ac'}, + squareMileSymbol: {'en-US': 'mi²', 'pt-BR': 'mi²'}, + }); + + String i18n({ + String? locale, + }) => + localize(this, _t, locale: locale ?? Intl.getCurrentLocale()); + String plural(value) => localizePlural(value, this, _t); +} diff --git a/lib/src/units_of_measurement/information.dart b/lib/src/units_of_measurement/information.dart index 1d32aab..41eed65 100644 --- a/lib/src/units_of_measurement/information.dart +++ b/lib/src/units_of_measurement/information.dart @@ -1,4 +1,5 @@ import 'package:humanizer/humanizer.dart'; +import 'package:humanizer/src/units_of_measurement/information.i18n.dart'; import 'package:humanizer/src/units_of_measurement/information_constants.dart'; import 'package:humanizer/src/units_of_measurement/rationals.dart'; import 'package:meta/meta.dart'; @@ -587,79 +588,79 @@ extension InformationUnitExtensions on InformationUnit { switch (this) { // SI. case InformationUnit.bit: - return 'bit'; + return bit.i18n(locale: locale); case InformationUnit.crumb: - return 'crumb'; + return crumb.i18n(locale: locale); case InformationUnit.nibble: - return 'nibble'; + return nibble.i18n(locale: locale); case InformationUnit.kilobit: - return 'kilobit'; + return kilobit.i18n(locale: locale); case InformationUnit.megabit: - return 'megabit'; + return megabit.i18n(locale: locale); case InformationUnit.gigabit: - return 'gigabit'; + return gigabit.i18n(locale: locale); case InformationUnit.terabit: - return 'terabit'; + return terabit.i18n(locale: locale); case InformationUnit.petabit: - return 'petabit'; + return petabit.i18n(locale: locale); case InformationUnit.exabit: - return 'exabit'; + return exabit.i18n(locale: locale); case InformationUnit.zettabit: - return 'zettabit'; + return zettabit.i18n(locale: locale); case InformationUnit.yottabit: - return 'yottabit'; + return yottabit.i18n(locale: locale); case InformationUnit.byte: - return 'byte'; + return byte.i18n(locale: locale); case InformationUnit.kilobyte: - return 'kilobyte'; + return kilobyte.i18n(locale: locale); case InformationUnit.megabyte: - return 'megabyte'; + return megabyte.i18n(locale: locale); case InformationUnit.gigabyte: - return 'gigabyte'; + return gigabyte.i18n(locale: locale); case InformationUnit.terabyte: - return 'terabyte'; + return terabyte.i18n(locale: locale); case InformationUnit.petabyte: - return 'petabyte'; + return petabyte.i18n(locale: locale); case InformationUnit.exabyte: - return 'exabyte'; + return exabyte.i18n(locale: locale); case InformationUnit.zettabyte: - return 'zettabyte'; + return zettabyte.i18n(locale: locale); case InformationUnit.yottabyte: - return 'yottabyte'; + return yottabyte.i18n(locale: locale); // IEC. case InformationUnit.kibibit: - return 'kibibit'; + return kibibit.i18n(locale: locale); case InformationUnit.mebibit: - return 'mebibit'; + return mebibit.i18n(locale: locale); case InformationUnit.gibibit: - return 'gibibit'; + return gibibit.i18n(locale: locale); case InformationUnit.tebibit: - return 'tebibit'; + return tebibit.i18n(locale: locale); case InformationUnit.pebibit: - return 'pebibit'; + return pebibit.i18n(locale: locale); case InformationUnit.exbibit: - return 'exbibit'; + return exbibit.i18n(locale: locale); case InformationUnit.zebibit: - return 'zebibit'; + return zebibit.i18n(locale: locale); case InformationUnit.yobibit: - return 'yobibit'; + return yobibit.i18n(locale: locale); case InformationUnit.kibibyte: - return 'kibibyte'; + return kibibyte.i18n(locale: locale); case InformationUnit.mebibyte: - return 'mebibyte'; + return mebibyte.i18n(locale: locale); case InformationUnit.gibibyte: - return 'gibibyte'; + return gibibyte.i18n(locale: locale); case InformationUnit.tebibyte: - return 'tebibyte'; + return tebibyte.i18n(locale: locale); case InformationUnit.pebibyte: - return 'pebibyte'; + return pebibyte.i18n(locale: locale); case InformationUnit.exbibyte: - return 'exbibyte'; + return exbibyte.i18n(locale: locale); case InformationUnit.zebibyte: - return 'zebibyte'; + return zebibyte.i18n(locale: locale); case InformationUnit.yobibyte: - return 'yobibyte'; + return yobibyte.i18n(locale: locale); } } @@ -670,79 +671,79 @@ extension InformationUnitExtensions on InformationUnit { switch (this) { // SI. case InformationUnit.bit: - return 'b'; + return bitSymbol.i18n(locale: locale); case InformationUnit.crumb: - return 'crumb'; + return crumbSymbol.i18n(locale: locale); case InformationUnit.nibble: - return 'nibble'; + return nibbleSymbol.i18n(locale: locale); case InformationUnit.kilobit: - return 'kbit'; + return kilobitSymbol.i18n(locale: locale); case InformationUnit.megabit: - return 'Mbit'; + return megabitSymbol.i18n(locale: locale); case InformationUnit.gigabit: - return 'Gbit'; + return gigabitSymbol.i18n(locale: locale); case InformationUnit.terabit: - return 'Tbit'; + return terabitSymbol.i18n(locale: locale); case InformationUnit.petabit: - return 'Pbit'; + return petabitSymbol.i18n(locale: locale); case InformationUnit.exabit: - return 'Ebit'; + return exabitSymbol.i18n(locale: locale); case InformationUnit.zettabit: - return 'Zbit'; + return zettabitSymbol.i18n(locale: locale); case InformationUnit.yottabit: - return 'Ybit'; + return yottabitSymbol.i18n(locale: locale); case InformationUnit.byte: - return 'B'; + return byteSymbol.i18n(locale: locale); case InformationUnit.kilobyte: - return 'KB'; + return kilobyteSymbol.i18n(locale: locale); case InformationUnit.megabyte: - return 'MB'; + return megabyteSymbol.i18n(locale: locale); case InformationUnit.gigabyte: - return 'GB'; + return gigabyteSymbol.i18n(locale: locale); case InformationUnit.terabyte: - return 'TB'; + return terabyteSymbol.i18n(locale: locale); case InformationUnit.petabyte: - return 'PB'; + return petabyteSymbol.i18n(locale: locale); case InformationUnit.exabyte: - return 'EB'; + return exabyteSymbol.i18n(locale: locale); case InformationUnit.zettabyte: - return 'ZB'; + return zettabyteSymbol.i18n(locale: locale); case InformationUnit.yottabyte: - return 'YB'; + return yottabyteSymbol.i18n(locale: locale); // IEC. case InformationUnit.kibibit: - return 'Kibit'; + return kibibitSymbol.i18n(locale: locale); case InformationUnit.mebibit: - return 'Mibit'; + return mebibitSymbol.i18n(locale: locale); case InformationUnit.gibibit: - return 'Gibit'; + return gibibitSymbol.i18n(locale: locale); case InformationUnit.tebibit: - return 'Tibit'; + return tebibitSymbol.i18n(locale: locale); case InformationUnit.pebibit: - return 'Pibit'; + return pebibitSymbol.i18n(locale: locale); case InformationUnit.exbibit: - return 'Eibit'; + return exbibitSymbol.i18n(locale: locale); case InformationUnit.zebibit: - return 'Zibit'; + return zebibitSymbol.i18n(locale: locale); case InformationUnit.yobibit: - return 'Yibit'; + return yobibitSymbol.i18n(locale: locale); case InformationUnit.kibibyte: - return 'KiB'; + return kibibyteSymbol.i18n(locale: locale); case InformationUnit.mebibyte: - return 'MiB'; + return mebibyteSymbol.i18n(locale: locale); case InformationUnit.gibibyte: - return 'GiB'; + return gibibyteSymbol.i18n(locale: locale); case InformationUnit.tebibyte: - return 'TiB'; + return tebibyteSymbol.i18n(locale: locale); case InformationUnit.pebibyte: - return 'PiB'; + return pebibyteSymbol.i18n(locale: locale); case InformationUnit.exbibyte: - return 'EiB'; + return exbibyteSymbol.i18n(locale: locale); case InformationUnit.zebibyte: - return 'ZiB'; + return zebibyteSymbol.i18n(locale: locale); case InformationUnit.yobibyte: - return 'YiB'; + return yobibyteSymbol.i18n(locale: locale); } } diff --git a/lib/src/units_of_measurement/information.i18n.dart b/lib/src/units_of_measurement/information.i18n.dart new file mode 100644 index 0000000..bb8337f --- /dev/null +++ b/lib/src/units_of_measurement/information.i18n.dart @@ -0,0 +1,179 @@ +import 'package:i18n_extension_core/i18n_extension_core.dart'; +import 'package:intl/intl.dart'; + +// Variáveis para os nomes completos das unidades de informação (usados no getName) +final bit = Object(); +final crumb = Object(); +final nibble = Object(); +final kilobit = Object(); +final megabit = Object(); +final gigabit = Object(); +final terabit = Object(); +final petabit = Object(); +final exabit = Object(); +final zettabit = Object(); +final yottabit = Object(); +final byte = Object(); +final kilobyte = Object(); +final megabyte = Object(); +final gigabyte = Object(); +final terabyte = Object(); +final petabyte = Object(); +final exabyte = Object(); +final zettabyte = Object(); +final yottabyte = Object(); + +final kibibit = Object(); +final mebibit = Object(); +final gibibit = Object(); +final tebibit = Object(); +final pebibit = Object(); +final exbibit = Object(); +final zebibit = Object(); +final yobibit = Object(); +final kibibyte = Object(); +final mebibyte = Object(); +final gibibyte = Object(); +final tebibyte = Object(); +final pebibyte = Object(); +final exbibyte = Object(); +final zebibyte = Object(); +final yobibyte = Object(); + +// Variáveis para os SÍMBOLOS das unidades de informação (usados no getSymbol) +final bitSymbol = Object(); +final crumbSymbol = Object(); +final nibbleSymbol = Object(); +final kilobitSymbol = Object(); +final megabitSymbol = Object(); +final gigabitSymbol = Object(); +final terabitSymbol = Object(); +final petabitSymbol = Object(); +final exabitSymbol = Object(); +final zettabitSymbol = Object(); +final yottabitSymbol = Object(); +final byteSymbol = Object(); +final kilobyteSymbol = Object(); +final megabyteSymbol = Object(); +final gigabyteSymbol = Object(); +final terabyteSymbol = Object(); +final petabyteSymbol = Object(); +final exabyteSymbol = Object(); +final zettabyteSymbol = Object(); +final yottabyteSymbol = Object(); + +final kibibitSymbol = Object(); +final mebibitSymbol = Object(); +final gibibitSymbol = Object(); +final tebibitSymbol = Object(); +final pebibitSymbol = Object(); +final exbibitSymbol = Object(); +final zebibitSymbol = Object(); +final yobibitSymbol = Object(); +final kibibyteSymbol = Object(); +final mebibyteSymbol = Object(); +final gibibyteSymbol = Object(); +final tebibyteSymbol = Object(); +final pebibyteSymbol = Object(); +final exbibyteSymbol = Object(); +final zebibyteSymbol = Object(); +final yobibyteSymbol = Object(); + +extension InformationUnitI18n on Object { + static final _t = Translations.byId('en-US', { + // Nomes completos das unidades (para getName) - SI + bit: {'en-US': 'bit', 'pt-BR': 'bit'}, + crumb: { + 'en-US': 'crumb', + 'pt-BR': 'crumb' + }, // Manter como "crumb" se não houver tradução comum + nibble: { + 'en-US': 'nibble', + 'pt-BR': 'nibble' + }, // Manter como "nibble" se não houver tradução comum + kilobit: {'en-US': 'kilobit', 'pt-BR': 'quilobit'}, + megabit: {'en-US': 'megabit', 'pt-BR': 'megabit'}, + gigabit: {'en-US': 'gigabit', 'pt-BR': 'gigabit'}, + terabit: {'en-US': 'terabit', 'pt-BR': 'terabit'}, + petabit: {'en-US': 'petabit', 'pt-BR': 'petabit'}, + exabit: {'en-US': 'exabit', 'pt-BR': 'exabit'}, + zettabit: {'en-US': 'zettabit', 'pt-BR': 'zettabit'}, + yottabit: {'en-US': 'yottabit', 'pt-BR': 'yottabit'}, + byte: {'en-US': 'byte', 'pt-BR': 'byte'}, + kilobyte: {'en-US': 'kilobyte', 'pt-BR': 'quilobyte'}, + megabyte: {'en-US': 'megabyte', 'pt-BR': 'megabyte'}, + gigabyte: {'en-US': 'gigabyte', 'pt-BR': 'gigabyte'}, + terabyte: {'en-US': 'terabyte', 'pt-BR': 'terabyte'}, + petabyte: {'en-US': 'petabyte', 'pt-BR': 'petabyte'}, + exabyte: {'en-US': 'exabyte', 'pt-BR': 'exabyte'}, + zettabyte: {'en-US': 'zettabyte', 'pt-BR': 'zettabyte'}, + yottabyte: {'en-US': 'yottabyte', 'pt-BR': 'yottabyte'}, + + // Nomes completos das unidades (para getName) - IEC + kibibit: {'en-US': 'kibibit', 'pt-BR': 'kibibit'}, + mebibit: {'en-US': 'mebibit', 'pt-BR': 'mebibit'}, + gibibit: {'en-US': 'gibibit', 'pt-BR': 'gibibit'}, + tebibit: {'en-US': 'tebibit', 'pt-BR': 'tebibit'}, + pebibit: {'en-US': 'pebibit', 'pt-BR': 'pebibit'}, + exbibit: {'en-US': 'exbibit', 'pt-BR': 'exbibit'}, + zebibit: {'en-US': 'zebibit', 'pt-BR': 'zebibit'}, + yobibit: {'en-US': 'yobibit', 'pt-BR': 'yobibit'}, + kibibyte: {'en-US': 'kibibyte', 'pt-BR': 'kibibyte'}, + mebibyte: {'en-US': 'mebibyte', 'pt-BR': 'mebibyte'}, + gibibyte: {'en-US': 'gibibyte', 'pt-BR': 'gibibyte'}, + tebibyte: {'en-US': 'tebibyte', 'pt-BR': 'tebibyte'}, + pebibyte: {'en-US': 'pebibyte', 'pt-BR': 'pebibyte'}, + exbibyte: {'en-US': 'exbibyte', 'pt-BR': 'exbibyte'}, + zebibyte: {'en-US': 'zebibyte', 'pt-BR': 'zebibyte'}, + yobibyte: {'en-US': 'yobibyte', 'pt-BR': 'yobibyte'}, + + // Símbolos das unidades (para getSymbol) - SI + bitSymbol: {'en-US': 'b', 'pt-BR': 'b'}, + crumbSymbol: {'en-US': 'crumb', 'pt-BR': 'crumb'}, // Símbolo para 'crumb' + nibbleSymbol: { + 'en-US': 'nibble', + 'pt-BR': 'nibble' + }, // Símbolo para 'nibble' + kilobitSymbol: {'en-US': 'kbit', 'pt-BR': 'kbit'}, + megabitSymbol: {'en-US': 'Mbit', 'pt-BR': 'Mbit'}, + gigabitSymbol: {'en-US': 'Gbit', 'pt-BR': 'Gbit'}, + terabitSymbol: {'en-US': 'Tbit', 'pt-BR': 'Tbit'}, + petabitSymbol: {'en-US': 'Pbit', 'pt-BR': 'Pbit'}, + exabitSymbol: {'en-US': 'Ebit', 'pt-BR': 'Ebit'}, + zettabitSymbol: {'en-US': 'Zbit', 'pt-BR': 'Zbit'}, + yottabitSymbol: {'en-US': 'Ybit', 'pt-BR': 'Ybit'}, + byteSymbol: {'en-US': 'B', 'pt-BR': 'B'}, + kilobyteSymbol: {'en-US': 'KB', 'pt-BR': 'KB'}, + megabyteSymbol: {'en-US': 'MB', 'pt-BR': 'MB'}, + gigabyteSymbol: {'en-US': 'GB', 'pt-BR': 'GB'}, + terabyteSymbol: {'en-US': 'TB', 'pt-BR': 'TB'}, + petabyteSymbol: {'en-US': 'PB', 'pt-BR': 'PB'}, + exabyteSymbol: {'en-US': 'EB', 'pt-BR': 'EB'}, + zettabyteSymbol: {'en-US': 'ZB', 'pt-BR': 'ZB'}, + yottabyteSymbol: {'en-US': 'YB', 'pt-BR': 'YB'}, + + // Símbolos das unidades (para getSymbol) - IEC + kibibitSymbol: {'en-US': 'Kibit', 'pt-BR': 'Kibit'}, + mebibitSymbol: {'en-US': 'Mibit', 'pt-BR': 'Mibit'}, + gibibitSymbol: {'en-US': 'Gibit', 'pt-BR': 'Gibit'}, + tebibitSymbol: {'en-US': 'Tibit', 'pt-BR': 'Tibit'}, + pebibitSymbol: {'en-US': 'Pibit', 'pt-BR': 'Pibit'}, + exbibitSymbol: {'en-US': 'Eibit', 'pt-BR': 'Eibit'}, + zebibitSymbol: {'en-US': 'Zibit', 'pt-BR': 'Zibit'}, + yobibitSymbol: {'en-US': 'Yibit', 'pt-BR': 'Yibit'}, + kibibyteSymbol: {'en-US': 'KiB', 'pt-BR': 'KiB'}, + mebibyteSymbol: {'en-US': 'MiB', 'pt-BR': 'MiB'}, + gibibyteSymbol: {'en-US': 'GiB', 'pt-BR': 'GiB'}, + tebibyteSymbol: {'en-US': 'TiB', 'pt-BR': 'TiB'}, + pebibyteSymbol: {'en-US': 'PiB', 'pt-BR': 'PiB'}, + exbibyteSymbol: {'en-US': 'EiB', 'pt-BR': 'EiB'}, + zebibyteSymbol: {'en-US': 'ZiB', 'pt-BR': 'ZiB'}, + yobibyteSymbol: {'en-US': 'YiB', 'pt-BR': 'YiB'}, + }); + + String i18n({ + String? locale, + }) => + localize(this, _t, locale: locale ?? Intl.getCurrentLocale()); + String plural(value) => localizePlural(value, this, _t); +} diff --git a/lib/src/units_of_measurement/length.dart b/lib/src/units_of_measurement/length.dart index 7cd42d9..c895d19 100644 --- a/lib/src/units_of_measurement/length.dart +++ b/lib/src/units_of_measurement/length.dart @@ -1,4 +1,5 @@ import 'package:humanizer/humanizer.dart'; +import 'package:humanizer/src/units_of_measurement/length.i18n.dart'; import 'package:humanizer/src/units_of_measurement/length_constants.dart'; import 'package:humanizer/src/units_of_measurement/rationals.dart'; import 'package:meta/meta.dart'; @@ -314,39 +315,39 @@ extension LengthUnitExtensions on LengthUnit { switch (this) { // SI. case LengthUnit.nanometer: - return 'nanometer'; + return nanometer.i18n(locale: locale); case LengthUnit.micrometer: - return 'micrometer'; + return micrometer.i18n(locale: locale); case LengthUnit.millimeter: - return 'millimeter'; + return millimeter.i18n(locale: locale); case LengthUnit.centimeter: - return 'centimeter'; + return centimeter.i18n(locale: locale); case LengthUnit.decimeter: - return 'decimeter'; + return decimeter.i18n(locale: locale); case LengthUnit.meter: - return 'meter'; + return meter.i18n(locale: locale); case LengthUnit.decameter: - return 'decameter'; + return decameter.i18n(locale: locale); case LengthUnit.hectometer: - return 'hectometer'; + return hectometer.i18n(locale: locale); case LengthUnit.kilometer: - return 'kilometer'; + return kilometer.i18n(locale: locale); case LengthUnit.megameter: - return 'megameter'; + return megameter.i18n(locale: locale); case LengthUnit.gigameter: - return 'gigameter'; + return gigameter.i18n(locale: locale); // Imperial. case LengthUnit.thou: - return 'thou'; + return thou.i18n(locale: locale); case LengthUnit.inch: - return 'inch'; + return inch.i18n(locale: locale); case LengthUnit.foot: - return 'foot'; + return foot.i18n(locale: locale); case LengthUnit.yard: - return 'yard'; + return yard.i18n(locale: locale); case LengthUnit.mile: - return 'mile'; + return mile.i18n(locale: locale); } } @@ -357,39 +358,39 @@ extension LengthUnitExtensions on LengthUnit { switch (this) { // SI. case LengthUnit.nanometer: - return 'nm'; + return nanometerSymbol.i18n(locale: locale); case LengthUnit.micrometer: - return 'μm'; + return micrometerSymbol.i18n(locale: locale); case LengthUnit.millimeter: - return 'mm'; + return millimeterSymbol.i18n(locale: locale); case LengthUnit.centimeter: - return 'cm'; + return centimeterSymbol.i18n(locale: locale); case LengthUnit.decimeter: - return 'dm'; + return decimeterSymbol.i18n(locale: locale); case LengthUnit.meter: - return 'm'; + return meterSymbol.i18n(locale: locale); case LengthUnit.decameter: - return 'dam'; + return decameterSymbol.i18n(locale: locale); case LengthUnit.hectometer: - return 'hm'; + return hectometerSymbol.i18n(locale: locale); case LengthUnit.kilometer: - return 'km'; + return kilometerSymbol.i18n(locale: locale); case LengthUnit.megameter: - return 'Mm'; + return megameterSymbol.i18n(locale: locale); case LengthUnit.gigameter: - return 'Gm'; + return gigameterSymbol.i18n(locale: locale); // Imperial. case LengthUnit.thou: - return 'thou'; + return thouUnitSymbol.i18n(locale: locale); case LengthUnit.inch: - return 'in'; + return inchSymbol.i18n(locale: locale); case LengthUnit.foot: - return 'ft'; + return footSymbol.i18n(locale: locale); case LengthUnit.yard: - return 'yd'; + return yardSymbol.i18n(locale: locale); case LengthUnit.mile: - return 'mi'; + return mileSymbol.i18n(locale: locale); } } diff --git a/lib/src/units_of_measurement/length.i18n.dart b/lib/src/units_of_measurement/length.i18n.dart new file mode 100644 index 0000000..38c160c --- /dev/null +++ b/lib/src/units_of_measurement/length.i18n.dart @@ -0,0 +1,87 @@ +import 'package:i18n_extension_core/i18n_extension_core.dart'; +import 'package:intl/intl.dart'; + +final nanometer = Object(); +final micrometer = Object(); +final millimeter = Object(); +final centimeter = Object(); +final decimeter = Object(); +final meter = Object(); +final decameter = Object(); +final hectometer = Object(); +final kilometer = Object(); +final megameter = Object(); +final gigameter = Object(); +final thou = Object(); +final inch = Object(); +final foot = Object(); +final yard = Object(); +final mile = Object(); + +final nanometerSymbol = Object(); +final micrometerSymbol = Object(); +final millimeterSymbol = Object(); +final centimeterSymbol = Object(); +final decimeterSymbol = Object(); +final meterSymbol = Object(); +final decameterSymbol = Object(); +final hectometerSymbol = Object(); +final kilometerSymbol = Object(); +final megameterSymbol = Object(); +final gigameterSymbol = Object(); + +final thouUnitSymbol = Object(); +final inchSymbol = Object(); +final footSymbol = Object(); +final yardSymbol = Object(); +final mileSymbol = Object(); + +extension LengthUnitI18n on Object { + static final _t = Translations.byId('en-US', { + // SI + nanometer: {'en-US': 'nanometer', 'pt-BR': 'nanômetro'}, + micrometer: {'en-US': 'micrometer', 'pt-BR': 'micrômetro'}, + millimeter: {'en-US': 'millimeter', 'pt-BR': 'milímetro'}, + centimeter: {'en-US': 'centimeter', 'pt-BR': 'centímetro'}, + decimeter: {'en-US': 'decimeter', 'pt-BR': 'decímetro'}, + meter: {'en-US': 'meter', 'pt-BR': 'metro'}, + decameter: {'en-US': 'decameter', 'pt-BR': 'decâmetro'}, + hectometer: {'en-US': 'hectometer', 'pt-BR': 'hectômetro'}, + kilometer: {'en-US': 'kilometer', 'pt-BR': 'quilômetro'}, + megameter: {'en-US': 'megameter', 'pt-BR': 'megâmetro'}, + gigameter: {'en-US': 'gigameter', 'pt-BR': 'gigâmetro'}, + + // Imperial + thou: {'en-US': 'thou', 'pt-BR': 'milésimo de polegada'}, + inch: {'en-US': 'inch', 'pt-BR': 'polegada'}, + foot: {'en-US': 'foot', 'pt-BR': 'pé'}, + yard: {'en-US': 'yard', 'pt-BR': 'jarda'}, + mile: {'en-US': 'mile', 'pt-BR': 'milha'}, + + //SI + nanometerSymbol: {'en-US': 'nm', 'pt-BR': 'nm'}, + micrometerSymbol: {'en-US': 'μm', 'pt-BR': 'μm'}, + millimeterSymbol: {'en-US': 'mm', 'pt-BR': 'mm'}, + centimeterSymbol: {'en-US': 'cm', 'pt-BR': 'cm'}, + decimeterSymbol: {'en-US': 'dm', 'pt-BR': 'dm'}, + meterSymbol: {'en-US': 'm', 'pt-BR': 'm'}, + decameterSymbol: {'en-US': 'dam', 'pt-BR': 'dam'}, + hectometerSymbol: {'en-US': 'hm', 'pt-BR': 'hm'}, + kilometerSymbol: {'en-US': 'km', 'pt-BR': 'km'}, + megameterSymbol: {'en-US': 'Mm', 'pt-BR': 'Mm'}, + gigameterSymbol: {'en-US': 'Gm', 'pt-BR': 'Gm'}, + + // Imperial + thouUnitSymbol: {'en-US': 'thou', 'pt-BR': 'thou'}, + inchSymbol: {'en-US': 'in', 'pt-BR': 'pol'}, + footSymbol: {'en-US': 'ft', 'pt-BR': 'pé'}, + yardSymbol: {'en-US': 'yd', 'pt-BR': 'jd'}, + mileSymbol: {'en-US': 'mi', 'pt-BR': 'mi'}, + }); + + String i18n({ + String? locale, + }) => + localize(this, _t, locale: locale ?? Intl.getCurrentLocale()); + String plural(value) => localizePlural(value, this, _t); +} diff --git a/lib/src/units_of_measurement/quantity.dart b/lib/src/units_of_measurement/quantity.dart index a4ab893..d670ef8 100644 --- a/lib/src/units_of_measurement/quantity.dart +++ b/lib/src/units_of_measurement/quantity.dart @@ -1,4 +1,5 @@ import 'package:humanizer/humanizer.dart'; +import 'package:humanizer/src/units_of_measurement/quantity.i18n.dart'; import 'package:humanizer/src/units_of_measurement/quantity_constants.dart'; import 'package:humanizer/src/units_of_measurement/rationals.dart'; import 'package:meta/meta.dart'; @@ -118,15 +119,15 @@ extension QuantityUnitExtensions on QuantityUnit { }) { switch (this) { case QuantityUnit.one: - return ''; + return quantityOne.i18n(locale: locale); case QuantityUnit.thousand: - return 'thousand'; + return quantityThousand.i18n(locale: locale); case QuantityUnit.million: - return 'million'; + return quantityMillion.i18n(locale: locale); case QuantityUnit.billion: - return 'billion'; + return quantityBillion.i18n(locale: locale); case QuantityUnit.trillion: - return 'trillion'; + return quantityTrillion.i18n(locale: locale); } } @@ -138,15 +139,23 @@ extension QuantityUnitExtensions on QuantityUnit { switch (this) { case QuantityUnit.one: - return ''; + return quantityOne.i18n(locale: locale); // Ainda vazio case QuantityUnit.thousand: - return isUnitedKingdom ? 'k' : 'K'; + return isUnitedKingdom + ? quantityThousandSymbolUK.i18n(locale: locale) + : quantityThousandSymbolUS.i18n(locale: locale); case QuantityUnit.million: - return isUnitedKingdom ? 'm' : 'M'; + return isUnitedKingdom + ? quantityMillionSymbolUK.i18n(locale: locale) + : quantityMillionSymbolUS.i18n(locale: locale); case QuantityUnit.billion: - return isUnitedKingdom ? 'bn' : 'B'; + return isUnitedKingdom + ? quantityBillionSymbolUK.i18n(locale: locale) + : quantityBillionSymbolUS.i18n(locale: locale); case QuantityUnit.trillion: - return isUnitedKingdom ? 'tn' : 'T'; + return isUnitedKingdom + ? quantityTrillionSymbolUK.i18n(locale: locale) + : quantityTrillionSymbolUS.i18n(locale: locale); } } diff --git a/lib/src/units_of_measurement/quantity.i18n.dart b/lib/src/units_of_measurement/quantity.i18n.dart new file mode 100644 index 0000000..6d5962f --- /dev/null +++ b/lib/src/units_of_measurement/quantity.i18n.dart @@ -0,0 +1,48 @@ +import 'package:i18n_extension_core/i18n_extension_core.dart'; +import 'package:intl/intl.dart'; + +// Variáveis para os nomes completos das unidades de quantidade (para getName) +final quantityOne = Object(); +final quantityThousand = Object(); +final quantityMillion = Object(); +final quantityBillion = Object(); +final quantityTrillion = Object(); + +// Variáveis para os SÍMBOLOS das unidades de quantidade (para getSymbol) +final quantityThousandSymbolUS = Object(); // K +final quantityThousandSymbolUK = Object(); // k +final quantityMillionSymbolUS = Object(); // M +final quantityMillionSymbolUK = Object(); // m +final quantityBillionSymbolUS = Object(); // B +final quantityBillionSymbolUK = Object(); // bn +final quantityTrillionSymbolUS = Object(); // T +final quantityTrillionSymbolUK = Object(); // tn + +extension QuantityUnitI18n on Object { + static final _t = Translations.byId('en-US', { + // Nomes completos das unidades (para getName) + quantityOne: {'en-US': '', 'pt-BR': ''}, // Vazio para "one" + quantityThousand: {'en-US': 'thousand', 'pt-BR': 'mil'}, + quantityMillion: {'en-US': 'million', 'pt-BR': 'milhão'}, + quantityBillion: {'en-US': 'billion', 'pt-BR': 'bilhão'}, + quantityTrillion: {'en-US': 'trillion', 'pt-BR': 'trilhão'}, + + // Símbolos das unidades (para getSymbol) - US (padrão) + quantityThousandSymbolUS: {'en-US': 'K', 'pt-BR': 'K'}, + quantityMillionSymbolUS: {'en-US': 'M', 'pt-BR': 'M'}, + quantityBillionSymbolUS: {'en-US': 'B', 'pt-BR': 'B'}, + quantityTrillionSymbolUS: {'en-US': 'T', 'pt-BR': 'T'}, + + // Símbolos das unidades (para getSymbol) - UK + quantityThousandSymbolUK: {'en-US': 'k', 'pt-BR': 'k'}, + quantityMillionSymbolUK: {'en-US': 'm', 'pt-BR': 'm'}, + quantityBillionSymbolUK: {'en-US': 'bn', 'pt-BR': 'bi'}, + quantityTrillionSymbolUK: {'en-US': 'tn', 'pt-BR': 'tri'}, + }); + + String i18n({ + String? locale, + }) => + localize(this, _t, locale: locale ?? Intl.getCurrentLocale()); + String plural(value) => localizePlural(value, this, _t); +} diff --git a/lib/src/units_of_measurement/shared.dart b/lib/src/units_of_measurement/shared.dart index bf06527..42333ea 100644 --- a/lib/src/units_of_measurement/shared.dart +++ b/lib/src/units_of_measurement/shared.dart @@ -3,6 +3,7 @@ import 'package:decimal/intl.dart'; import 'package:humanizer/humanizer.dart'; import 'package:humanizer/src/string_predicate_extensions.dart'; import 'package:humanizer/src/units_of_measurement/rationals.dart'; +import 'package:humanizer/src/units_of_measurement/shared.i18n.dart'; import 'package:intl/intl.dart'; import 'package:meta/meta.dart'; @@ -233,15 +234,15 @@ extension RateUnitExtensions on RateUnit { }) { switch (this) { case RateUnit.second: - return 'second'; + return second.i18n(locale: locale); case RateUnit.minute: - return 'minute'; + return minute.i18n(locale: locale); case RateUnit.hour: - return 'hour'; + return hour.i18n(locale: locale); case RateUnit.day: - return 'day'; + return day.i18n(locale: locale); case RateUnit.week: - return 'week'; + return week.i18n(locale: locale); } } @@ -249,15 +250,15 @@ extension RateUnitExtensions on RateUnit { String getSymbol({required String locale}) { switch (this) { case RateUnit.second: - return 's'; + return s.i18n(locale: locale); case RateUnit.minute: - return 'min'; + return min.i18n(locale: locale); case RateUnit.hour: - return 'hr'; + return hr.i18n(locale: locale); case RateUnit.day: - return 'day'; + return day.i18n(locale: locale); case RateUnit.week: - return 'wk'; + return wk.i18n(locale: locale); } } diff --git a/lib/src/units_of_measurement/shared.i18n.dart b/lib/src/units_of_measurement/shared.i18n.dart new file mode 100644 index 0000000..f2abd16 --- /dev/null +++ b/lib/src/units_of_measurement/shared.i18n.dart @@ -0,0 +1,33 @@ +import 'package:i18n_extension_core/i18n_extension_core.dart'; +import 'package:intl/intl.dart'; + +final second = Object(); +final minute = Object(); +final hour = Object(); +final day = Object(); +final week = Object(); + +final s = Object(); +final min = Object(); +final hr = Object(); +final wk = Object(); + +extension RateUnitExtensions on Object { + static final _t = Translations.byId('en-US', { + second: {'en-US': 'second', 'pt-BR': 'segundo'}, + minute: {'en-US': 'minute', 'pt-BR': 'minuto'}, + hour: {'en-US': 'hour', 'pt-BR': 'hora'}, + day: {'en-US': 'day', 'pt-BR': 'dia'}, + week: {'en-US': 'week', 'pt-BR': 'semana'}, + s: {'en-US': 's', 'pt-BR': 's'}, + min: {'en-US': 'min', 'pt-BR': 'min'}, + hr: {'en-US': 'hr', 'pt-BR': 'h'}, + wk: {'en-US': 'wk', 'pt-BR': 'sem'}, + }); + + String i18n({ + String? locale, + }) => + localize(this, _t, locale: locale ?? Intl.getCurrentLocale()); + String plural(value) => localizePlural(value, this, _t); +} diff --git a/lib/src/units_of_measurement/temperature.dart b/lib/src/units_of_measurement/temperature.dart index 0a62ab1..416bff5 100644 --- a/lib/src/units_of_measurement/temperature.dart +++ b/lib/src/units_of_measurement/temperature.dart @@ -1,5 +1,6 @@ import 'package:humanizer/humanizer.dart'; import 'package:humanizer/src/units_of_measurement/rationals.dart'; +import 'package:humanizer/src/units_of_measurement/temperature.i18n.dart'; import 'package:humanizer/src/units_of_measurement/temperature_constants.dart'; import 'package:meta/meta.dart'; @@ -212,25 +213,25 @@ extension TemperatureUnitExtensions on TemperatureUnit { switch (this) { // SI. case TemperatureUnit.nanokelvin: - return 'nanokelvin'; + return nanokelvin.i18n(locale: locale); case TemperatureUnit.microkelvin: - return 'microkelvin'; + return microkelvin.i18n(locale: locale); case TemperatureUnit.millikelvin: - return 'millikelvin'; + return millikelvin.i18n(locale: locale); case TemperatureUnit.centikelvin: - return 'centikelvin'; + return centikelvin.i18n(locale: locale); case TemperatureUnit.decikelvin: - return 'decikelvin'; + return decikelvin.i18n(locale: locale); case TemperatureUnit.kelvin: - return 'kelvin'; + return kelvin.i18n(locale: locale); // Celsius. case TemperatureUnit.celsius: - return 'Celsius'; + return celsius.i18n(locale: locale); // Fahrenheit. case TemperatureUnit.fahrenheit: - return 'Fahrenheit'; + return fahrenheit.i18n(locale: locale); } } @@ -241,25 +242,25 @@ extension TemperatureUnitExtensions on TemperatureUnit { switch (this) { // SI. case TemperatureUnit.nanokelvin: - return 'nK'; + return nanokelvinSymbol.i18n(locale: locale); case TemperatureUnit.microkelvin: - return 'μK'; + return microkelvinSymbol.i18n(locale: locale); case TemperatureUnit.millikelvin: - return 'mK'; + return millikelvinSymbol.i18n(locale: locale); case TemperatureUnit.centikelvin: - return 'cK'; + return centikelvinSymbol.i18n(locale: locale); case TemperatureUnit.decikelvin: - return 'dK'; + return decikelvinSymbol.i18n(locale: locale); case TemperatureUnit.kelvin: - return 'K'; + return kelvinSymbol.i18n(locale: locale); // Celsius. case TemperatureUnit.celsius: - return '°C'; + return celsiusSymbol.i18n(locale: locale); // Fahrenheit. case TemperatureUnit.fahrenheit: - return '°F'; + return fahrenheitSymbol.i18n(locale: locale); } } diff --git a/lib/src/units_of_measurement/temperature.i18n.dart b/lib/src/units_of_measurement/temperature.i18n.dart new file mode 100644 index 0000000..372c5ec --- /dev/null +++ b/lib/src/units_of_measurement/temperature.i18n.dart @@ -0,0 +1,62 @@ +import 'package:i18n_extension_core/i18n_extension_core.dart'; +import 'package:intl/intl.dart'; + +// Variáveis para os nomes completos das unidades de temperatura (para getName) +final nanokelvin = Object(); +final microkelvin = Object(); +final millikelvin = Object(); +final centikelvin = Object(); +final decikelvin = Object(); +final kelvin = Object(); + +final celsius = Object(); +final fahrenheit = Object(); + +// Variáveis para os SÍMBOLOS das unidades de temperatura (para getSymbol) +final nanokelvinSymbol = Object(); +final microkelvinSymbol = Object(); +final millikelvinSymbol = Object(); +final centikelvinSymbol = Object(); +final decikelvinSymbol = Object(); +final kelvinSymbol = Object(); + +final celsiusSymbol = Object(); +final fahrenheitSymbol = Object(); + +extension TemperatureUnitI18n on Object { + static final _t = Translations.byId('en-US', { + // Nomes completos das unidades (para getName) - SI + nanokelvin: {'en-US': 'nanokelvin', 'pt-BR': 'nanokelvin'}, + microkelvin: {'en-US': 'microkelvin', 'pt-BR': 'microkelvin'}, + millikelvin: {'en-US': 'millikelvin', 'pt-BR': 'millikelvin'}, + centikelvin: {'en-US': 'centikelvin', 'pt-BR': 'centikelvin'}, + decikelvin: {'en-US': 'decikelvin', 'pt-BR': 'decikelvin'}, + kelvin: {'en-US': 'kelvin', 'pt-BR': 'kelvin'}, + + // Nomes completos das unidades (para getName) - Celsius + celsius: {'en-US': 'Celsius', 'pt-BR': 'Celsius'}, + + // Nomes completos das unidades (para getName) - Fahrenheit + fahrenheit: {'en-US': 'Fahrenheit', 'pt-BR': 'Fahrenheit'}, + + // Símbolos das unidades (para getSymbol) - SI + nanokelvinSymbol: {'en-US': 'nK', 'pt-BR': 'nK'}, + microkelvinSymbol: {'en-US': 'μK', 'pt-BR': 'μK'}, + millikelvinSymbol: {'en-US': 'mK', 'pt-BR': 'mK'}, + centikelvinSymbol: {'en-US': 'cK', 'pt-BR': 'cK'}, + decikelvinSymbol: {'en-US': 'dK', 'pt-BR': 'dK'}, + kelvinSymbol: {'en-US': 'K', 'pt-BR': 'K'}, + + // Símbolos das unidades (para getSymbol) - Celsius + celsiusSymbol: {'en-US': '°C', 'pt-BR': '°C'}, + + // Símbolos das unidades (para getSymbol) - Fahrenheit + fahrenheitSymbol: {'en-US': '°F', 'pt-BR': '°F'}, + }); + + String i18n({ + String? locale, + }) => + localize(this, _t, locale: locale ?? Intl.getCurrentLocale()); + String plural(value) => localizePlural(value, this, _t); +} diff --git a/lib/src/units_of_measurement/time.dart b/lib/src/units_of_measurement/time.dart index 4275d2d..f9e1a19 100644 --- a/lib/src/units_of_measurement/time.dart +++ b/lib/src/units_of_measurement/time.dart @@ -1,5 +1,6 @@ import 'package:humanizer/humanizer.dart'; import 'package:humanizer/src/units_of_measurement/rationals.dart'; +import 'package:humanizer/src/units_of_measurement/time.i18n.dart'; import 'package:humanizer/src/units_of_measurement/time_constants.dart'; import 'package:meta/meta.dart'; @@ -290,39 +291,39 @@ extension TimeUnitExtensions on TimeUnit { }) { switch (this) { case TimeUnit.nanosecond: - return 'nanosecond'; + return nanosecond.i18n(locale: locale); case TimeUnit.microsecond: - return 'microsecond'; + return microsecond.i18n(locale: locale); case TimeUnit.millisecond: - return 'millisecond'; + return millisecond.i18n(locale: locale); case TimeUnit.centisecond: - return 'centisecond'; + return centisecond.i18n(locale: locale); case TimeUnit.decisecond: - return 'decisecond'; + return decisecond.i18n(locale: locale); case TimeUnit.second: - return 'second'; + return second.i18n(locale: locale); case TimeUnit.decasecond: - return 'decasecond'; + return decasecond.i18n(locale: locale); case TimeUnit.minute: - return 'minute'; + return minute.i18n(locale: locale); case TimeUnit.hour: - return 'hour'; + return hour.i18n(locale: locale); case TimeUnit.day: - return 'day'; + return day.i18n(locale: locale); case TimeUnit.week: - return 'week'; + return week.i18n(locale: locale); case TimeUnit.fortnight: - return 'fortnight'; + return fortnight.i18n(locale: locale); case TimeUnit.month: - return 'month'; + return month.i18n(locale: locale); case TimeUnit.quarter: - return 'quarter'; + return quarter.i18n(locale: locale); case TimeUnit.year: - return 'year'; + return year.i18n(locale: locale); case TimeUnit.decade: - return 'decade'; + return decade.i18n(locale: locale); case TimeUnit.century: - return 'century'; + return century.i18n(locale: locale); } } @@ -332,39 +333,39 @@ extension TimeUnitExtensions on TimeUnit { }) { switch (this) { case TimeUnit.nanosecond: - return 'ns'; + return ns.i18n(locale: locale); case TimeUnit.microsecond: - return 'μs'; + return us.i18n(locale: locale); case TimeUnit.millisecond: - return 'ms'; + return ms.i18n(locale: locale); case TimeUnit.centisecond: - return 'cs'; + return cs.i18n(locale: locale); case TimeUnit.decisecond: - return 'ds'; + return ds.i18n(locale: locale); case TimeUnit.second: - return 's'; + return s.i18n(locale: locale); case TimeUnit.decasecond: - return 'das'; + return das.i18n(locale: locale); case TimeUnit.minute: - return 'min'; + return min.i18n(locale: locale); case TimeUnit.hour: - return 'hr'; + return hr.i18n(locale: locale); case TimeUnit.day: - return 'd'; + return d.i18n(locale: locale); case TimeUnit.week: - return 'wk'; + return wk.i18n(locale: locale); case TimeUnit.fortnight: - return 'fn'; + return fn.i18n(locale: locale); case TimeUnit.month: - return 'mo'; + return mo.i18n(locale: locale); case TimeUnit.quarter: - return 'qr'; + return qr.i18n(locale: locale); case TimeUnit.year: - return 'yr'; + return yr.i18n(locale: locale); case TimeUnit.decade: - return 'dec'; + return dec.i18n(locale: locale); case TimeUnit.century: - return 'c'; + return c.i18n(locale: locale); } } diff --git a/lib/src/units_of_measurement/time.i18n.dart b/lib/src/units_of_measurement/time.i18n.dart new file mode 100644 index 0000000..cd2c4fb --- /dev/null +++ b/lib/src/units_of_measurement/time.i18n.dart @@ -0,0 +1,83 @@ +import 'package:i18n_extension_core/i18n_extension_core.dart'; +import 'package:intl/intl.dart'; + +final nanosecond = Object(); +final microsecond = Object(); +final millisecond = Object(); +final centisecond = Object(); +final decisecond = Object(); +final second = Object(); +final decasecond = Object(); +final minute = Object(); +final hour = Object(); +final day = Object(); +final week = Object(); +final fortnight = Object(); +final month = Object(); +final quarter = Object(); +final year = Object(); +final decade = Object(); +final century = Object(); + +final ns = Object(); +final us = Object(); +final ms = Object(); +final cs = Object(); +final ds = Object(); +final s = Object(); +final das = Object(); +final min = Object(); +final hr = Object(); +final d = Object(); +final wk = Object(); +final fn = Object(); +final mo = Object(); +final qr = Object(); +final yr = Object(); +final dec = Object(); +final c = Object(); + +extension TimeUnitI18n on Object { + static final _t = Translations.byId('en-US', { + nanosecond: {'en-US': 'nanosecond', 'pt-BR': 'nanosegundo'}, + microsecond: {'en-US': 'microsecond', 'pt-BR': 'microssegundo'}, + millisecond: {'en-US': 'millisecond', 'pt-BR': 'milissegundo'}, + centisecond: {'en-US': 'centisecond', 'pt-BR': 'centissegundo'}, + decisecond: {'en-US': 'decisecond', 'pt-BR': 'decissegundo'}, + second: {'en-US': 'second', 'pt-BR': 'segundo'}, + decasecond: {'en-US': 'decasecond', 'pt-BR': 'decassegundo'}, + minute: {'en-US': 'minute', 'pt-BR': 'minuto'}, + hour: {'en-US': 'hour', 'pt-BR': 'hora'}, + day: {'en-US': 'day', 'pt-BR': 'dia'}, + week: {'en-US': 'week', 'pt-BR': 'semana'}, + fortnight: {'en-US': 'fortnight', 'pt-BR': 'quinzena'}, + month: {'en-US': 'month', 'pt-BR': 'mês'}, + quarter: {'en-US': 'quarter', 'pt-BR': 'trimestre'}, + year: {'en-US': 'year', 'pt-BR': 'ano'}, + decade: {'en-US': 'decade', 'pt-BR': 'década'}, + century: {'en-US': 'century', 'pt-BR': 'século'}, + ns: {'en-US': 'ns', 'pt-BR': 'ns'}, + us: {'en-US': 'μs', 'pt-BR': 'μs'}, + ms: {'en-US': 'ms', 'pt-BR': 'ms'}, + cs: {'en-US': 'cs', 'pt-BR': 'cs'}, + ds: {'en-US': 'ds', 'pt-BR': 'ds'}, + s: {'en-US': 's', 'pt-BR': 's'}, + das: {'en-US': 'das', 'pt-BR': 'das'}, + min: {'en-US': 'min', 'pt-BR': 'min'}, + hr: {'en-US': 'hr', 'pt-BR': 'h'}, + d: {'en-US': 'd', 'pt-BR': 'd'}, + wk: {'en-US': 'wk', 'pt-BR': 'sem'}, + fn: {'en-US': 'fn', 'pt-BR': 'qnz'}, + mo: {'en-US': 'mo', 'pt-BR': 'mês'}, + qr: {'en-US': 'qr', 'pt-BR': 'tri'}, + yr: {'en-US': 'yr', 'pt-BR': 'a'}, + dec: {'en-US': 'dec', 'pt-BR': 'déc'}, + c: {'en-US': 'c', 'pt-BR': 'séc'}, + }); + + String i18n({ + String? locale, + }) => + localize(this, _t, locale: locale ?? Intl.getCurrentLocale()); + String plural(value) => localizePlural(value, this, _t); +} diff --git a/lib/src/units_of_measurement/volume.dart b/lib/src/units_of_measurement/volume.dart index caca687..a721dd4 100644 --- a/lib/src/units_of_measurement/volume.dart +++ b/lib/src/units_of_measurement/volume.dart @@ -1,5 +1,6 @@ import 'package:humanizer/humanizer.dart'; import 'package:humanizer/src/units_of_measurement/rationals.dart'; +import 'package:humanizer/src/units_of_measurement/volume.i18n.dart'; import 'package:humanizer/src/units_of_measurement/volume_constants.dart'; import 'package:meta/meta.dart'; @@ -507,69 +508,69 @@ extension VolumeUnitExtensions on VolumeUnit { switch (this) { // SI. case VolumeUnit.cubicNanometer: - return 'cubic nanometer'; + return cubicNanometer.i18n(locale: locale); case VolumeUnit.cubicMicrometer: - return 'cubic micrometer'; + return cubicMicrometer.i18n(locale: locale); case VolumeUnit.cubicMillimeter: - return 'cubic millimeter'; + return cubicMillimeter.i18n(locale: locale); case VolumeUnit.milliliter: - return 'milliliter'; + return milliliter.i18n(locale: locale); case VolumeUnit.liter: - return 'Liter'; + return liter.i18n(locale: locale); case VolumeUnit.cubicMeter: - return 'Cubic meter'; + return cubicMeter.i18n(locale: locale); case VolumeUnit.cubicDecameter: - return 'Cubic decameter'; + return cubicDecameter.i18n(locale: locale); case VolumeUnit.cubicKilometer: - return 'Cubic kilometer'; + return cubicKilometer.i18n(locale: locale); case VolumeUnit.cubicMegameter: - return 'Cubic megameter'; + return cubicMegameter.i18n(locale: locale); case VolumeUnit.cubicGigameter: - return 'Cubic gigameter'; + return cubicGigameter.i18n(locale: locale); // Imperial. case VolumeUnit.cubicThou: - return 'cubic thou'; + return cubicThou.i18n(locale: locale); case VolumeUnit.imperialTeaspoon: - return 'imperial teaspoon'; + return imperialTeaspoon.i18n(locale: locale); case VolumeUnit.imperialTablespoon: - return 'Imperial tablespoon'; + return imperialTablespoon.i18n(locale: locale); case VolumeUnit.imperialFluidOunce: - return 'Imperial fluid ounce'; + return imperialFluidOunce.i18n(locale: locale); case VolumeUnit.imperialCup: - return 'Imperial cup'; + return imperialCup.i18n(locale: locale); case VolumeUnit.imperialPint: - return 'Imperial pint'; + return imperialPint.i18n(locale: locale); case VolumeUnit.imperialQuart: - return 'Imperial quart'; + return imperialQuart.i18n(locale: locale); case VolumeUnit.imperialGallon: - return 'Imperial gallon'; + return imperialGallon.i18n(locale: locale); case VolumeUnit.cubicInch: - return 'Cubic inch'; + return cubicInch.i18n(locale: locale); case VolumeUnit.cubicFoot: - return 'Cubic foot'; + return cubicFoot.i18n(locale: locale); case VolumeUnit.cubicYard: - return 'Cubic yard'; + return cubicYard.i18n(locale: locale); case VolumeUnit.cubicMile: - return 'Cubic mile'; + return cubicMile.i18n(locale: locale); // US. case VolumeUnit.usTeaspoon: - return 'US teaspoon'; + return usTeaspoon.i18n(locale: locale); case VolumeUnit.usTablespoon: - return 'US tablespoon'; + return usTablespoon.i18n(locale: locale); case VolumeUnit.usFluidOunce: - return 'US fluid ounce'; + return usFluidOunce.i18n(locale: locale); case VolumeUnit.usCustomaryCup: - return 'US customary cup'; + return usCustomaryCup.i18n(locale: locale); case VolumeUnit.usLegalCup: - return 'US legal cup'; + return usLegalCup.i18n(locale: locale); case VolumeUnit.usLiquidPint: - return 'US liquid pint'; + return usLiquidPint.i18n(locale: locale); case VolumeUnit.usLiquidQuart: - return 'US liquid quart'; + return usLiquidQuart.i18n(locale: locale); case VolumeUnit.usLiquidGallon: - return 'US liquid gallon'; + return usLiquidGallon.i18n(locale: locale); } } @@ -580,69 +581,69 @@ extension VolumeUnitExtensions on VolumeUnit { switch (this) { // SI. case VolumeUnit.cubicNanometer: - return 'nm³'; + return cubicNanometerSymbol.i18n(locale: locale); case VolumeUnit.cubicMicrometer: - return 'μm³'; + return cubicMicrometerSymbol.i18n(locale: locale); case VolumeUnit.cubicMillimeter: - return 'mm³'; + return cubicMillimeterSymbol.i18n(locale: locale); case VolumeUnit.milliliter: - return 'mL'; + return milliliterSymbol.i18n(locale: locale); case VolumeUnit.liter: - return 'L'; + return literSymbol.i18n(locale: locale); case VolumeUnit.cubicMeter: - return 'm³'; + return cubicMeterSymbol.i18n(locale: locale); case VolumeUnit.cubicDecameter: - return 'dam³'; + return cubicDecameterSymbol.i18n(locale: locale); case VolumeUnit.cubicKilometer: - return 'km³'; + return cubicKilometerSymbol.i18n(locale: locale); case VolumeUnit.cubicMegameter: - return 'Mm³'; + return cubicMegameterSymbol.i18n(locale: locale); case VolumeUnit.cubicGigameter: - return 'Gm³'; + return cubicGigameterSymbol.i18n(locale: locale); // Imperial. case VolumeUnit.cubicThou: - return 'thou³'; + return cubicThouSymbol.i18n(locale: locale); case VolumeUnit.imperialTeaspoon: - return 'tsp'; + return imperialTeaspoonSymbol.i18n(locale: locale); case VolumeUnit.imperialTablespoon: - return 'Tbsp'; + return imperialTablespoonSymbol.i18n(locale: locale); case VolumeUnit.imperialFluidOunce: - return 'fl oz'; + return imperialFluidOunceSymbol.i18n(locale: locale); case VolumeUnit.imperialCup: - return 'c'; + return imperialCupSymbol.i18n(locale: locale); case VolumeUnit.imperialPint: - return 'pt'; + return imperialPintSymbol.i18n(locale: locale); case VolumeUnit.imperialQuart: - return 'qt'; + return imperialQuartSymbol.i18n(locale: locale); case VolumeUnit.imperialGallon: - return 'gal'; + return imperialGallonSymbol.i18n(locale: locale); case VolumeUnit.cubicInch: - return 'in³'; + return cubicInchSymbol.i18n(locale: locale); case VolumeUnit.cubicFoot: - return 'ft³'; + return cubicFootSymbol.i18n(locale: locale); case VolumeUnit.cubicYard: - return 'yd³'; + return cubicYardSymbol.i18n(locale: locale); case VolumeUnit.cubicMile: - return 'mi³'; + return cubicMileSymbol.i18n(locale: locale); // US. case VolumeUnit.usTeaspoon: - return 'tsp'; + return usTeaspoonSymbol.i18n(locale: locale); case VolumeUnit.usTablespoon: - return 'Tbsp'; + return usTablespoonSymbol.i18n(locale: locale); case VolumeUnit.usFluidOunce: - return 'fl oz'; + return usFluidOunceSymbol.i18n(locale: locale); case VolumeUnit.usCustomaryCup: - return 'c'; + return usCustomaryCupSymbol.i18n(locale: locale); case VolumeUnit.usLegalCup: - return 'c'; + return usLegalCupSymbol.i18n(locale: locale); case VolumeUnit.usLiquidPint: - return 'pt'; + return usLiquidPintSymbol.i18n(locale: locale); case VolumeUnit.usLiquidQuart: - return 'qt'; + return usLiquidQuartSymbol.i18n(locale: locale); case VolumeUnit.usLiquidGallon: - return 'gal'; + return usLiquidGallonSymbol.i18n(locale: locale); } } @@ -651,33 +652,33 @@ extension VolumeUnitExtensions on VolumeUnit { switch (this) { // Imperial. case VolumeUnit.imperialTeaspoon: - return 'tsp_imp'; + return imperialTeaspoonPattern.i18n(); case VolumeUnit.imperialTablespoon: - return 'Tbsp_imp'; + return imperialTablespoonPattern.i18n(); case VolumeUnit.imperialFluidOunce: - return 'fl_oz_imp'; + return imperialFluidOuncePattern.i18n(); case VolumeUnit.imperialCup: - return 'c_imp'; + return imperialCupPattern.i18n(); case VolumeUnit.imperialPint: - return 'pt_imp'; + return imperialPintPattern.i18n(); case VolumeUnit.imperialGallon: - return 'gal_imp'; + return imperialGallonPattern.i18n(); // US. case VolumeUnit.usTeaspoon: - return 'tsp_us'; + return usTeaspoonPattern.i18n(); case VolumeUnit.usTablespoon: - return 'Tbsp_us'; + return usTablespoonPattern.i18n(); case VolumeUnit.usCustomaryCup: - return 'c_us_customary'; + return usCustomaryCupPattern.i18n(); case VolumeUnit.usLegalCup: - return 'c_us_legal'; + return usLegalCupPattern.i18n(); case VolumeUnit.usFluidOunce: - return 'fl_oz_us'; + return usFluidOuncePattern.i18n(); case VolumeUnit.usLiquidPint: - return 'pt_us'; + return usLiquidPintPattern.i18n(); case VolumeUnit.usLiquidGallon: - return 'gal_us'; + return usLiquidGallonPattern.i18n(); default: return getSymbol( diff --git a/lib/src/units_of_measurement/volume.i18n.dart b/lib/src/units_of_measurement/volume.i18n.dart new file mode 100644 index 0000000..8a9f7fb --- /dev/null +++ b/lib/src/units_of_measurement/volume.i18n.dart @@ -0,0 +1,213 @@ +import 'package:i18n_extension_core/i18n_extension_core.dart'; +import 'package:intl/intl.dart'; + +// Variáveis para os nomes completos das unidades de volume (para getName) +final cubicNanometer = Object(); +final cubicMicrometer = Object(); +final cubicMillimeter = Object(); +final milliliter = Object(); +final liter = Object(); +final cubicMeter = Object(); +final cubicDecameter = Object(); +final cubicKilometer = Object(); +final cubicMegameter = Object(); +final cubicGigameter = Object(); + +final cubicThou = Object(); +final imperialTeaspoon = Object(); +final imperialTablespoon = Object(); +final imperialFluidOunce = Object(); +final imperialCup = Object(); +final imperialPint = Object(); +final imperialQuart = Object(); +final imperialGallon = Object(); +final cubicInch = Object(); +final cubicFoot = Object(); +final cubicYard = Object(); +final cubicMile = Object(); + +final usTeaspoon = Object(); +final usTablespoon = Object(); +final usFluidOunce = Object(); +final usCustomaryCup = Object(); +final usLegalCup = Object(); +final usLiquidPint = Object(); +final usLiquidQuart = Object(); +final usLiquidGallon = Object(); + +final cubicNanometerSymbol = Object(); +final cubicMicrometerSymbol = Object(); +final cubicMillimeterSymbol = Object(); +final milliliterSymbol = Object(); +final literSymbol = Object(); +final cubicMeterSymbol = Object(); +final cubicDecameterSymbol = Object(); +final cubicKilometerSymbol = Object(); +final cubicMegameterSymbol = Object(); +final cubicGigameterSymbol = Object(); + +final cubicThouSymbol = Object(); +final imperialTeaspoonSymbol = Object(); +final imperialTablespoonSymbol = Object(); +final imperialFluidOunceSymbol = Object(); +final imperialCupSymbol = Object(); +final imperialPintSymbol = Object(); +final imperialQuartSymbol = Object(); +final imperialGallonSymbol = Object(); +final cubicInchSymbol = Object(); +final cubicFootSymbol = Object(); +final cubicYardSymbol = Object(); +final cubicMileSymbol = Object(); + +final usTeaspoonSymbol = Object(); +final usTablespoonSymbol = Object(); +final usFluidOunceSymbol = Object(); +final usCustomaryCupSymbol = Object(); +final usLegalCupSymbol = Object(); +final usLiquidPintSymbol = Object(); +final usLiquidQuartSymbol = Object(); +final usLiquidGallonSymbol = Object(); + +// Variáveis para os patternSpecifiers +final imperialTeaspoonPattern = Object(); +final imperialTablespoonPattern = Object(); +final imperialFluidOuncePattern = Object(); +final imperialCupPattern = Object(); +final imperialPintPattern = Object(); +final imperialGallonPattern = Object(); + +final usTeaspoonPattern = Object(); +final usTablespoonPattern = Object(); +final usCustomaryCupPattern = Object(); +final usLegalCupPattern = Object(); +final usFluidOuncePattern = Object(); +final usLiquidPintPattern = Object(); +final usLiquidGallonPattern = Object(); + +extension VolumeUnitI18n on Object { + static final _t = Translations.byId('en-US', { + // SI + cubicNanometer: {'en-US': 'cubic nanometer', 'pt-BR': 'nanômetro cúbico'}, + cubicMicrometer: { + 'en-US': 'cubic micrometer', + 'pt-BR': 'micrômetro cúbico' + }, + cubicMillimeter: {'en-US': 'cubic millimeter', 'pt-BR': 'milímetro cúbico'}, + milliliter: {'en-US': 'milliliter', 'pt-BR': 'mililitro'}, + liter: {'en-US': 'Liter', 'pt-BR': 'Litro'}, + cubicMeter: {'en-US': 'Cubic meter', 'pt-BR': 'Metro cúbico'}, + cubicDecameter: {'en-US': 'Cubic decameter', 'pt-BR': 'Decâmetro cúbico'}, + cubicKilometer: {'en-US': 'Cubic kilometer', 'pt-BR': 'Quilômetro cúbico'}, + cubicMegameter: {'en-US': 'Cubic megameter', 'pt-BR': 'Megâmetro cúbico'}, + cubicGigameter: {'en-US': 'Cubic gigameter', 'pt-BR': 'Gigâmetro cúbico'}, + + // Imperial + cubicThou: {'en-US': 'cubic thou', 'pt-BR': 'milésimo de polegada cúbico'}, + imperialTeaspoon: { + 'en-US': 'imperial teaspoon', + 'pt-BR': 'colher de chá imperial' + }, + imperialTablespoon: { + 'en-US': 'Imperial tablespoon', + 'pt-BR': 'colher de sopa imperial' + }, + imperialFluidOunce: { + 'en-US': 'Imperial fluid ounce', + 'pt-BR': 'onça fluida imperial' + }, + imperialCup: {'en-US': 'Imperial cup', 'pt-BR': 'xícara imperial'}, + imperialPint: {'en-US': 'Imperial pint', 'pt-BR': 'pinta imperial'}, + imperialQuart: {'en-US': 'Imperial quart', 'pt-BR': 'quarto imperial'}, + imperialGallon: {'en-US': 'Imperial gallon', 'pt-BR': 'galão imperial'}, + cubicInch: {'en-US': 'Cubic inch', 'pt-BR': 'Polegada cúbica'}, + cubicFoot: {'en-US': 'Cubic foot', 'pt-BR': 'Pé cúbico'}, + cubicYard: {'en-US': 'Cubic yard', 'pt-BR': 'Jarda cúbica'}, + cubicMile: {'en-US': 'Cubic mile', 'pt-BR': 'Milha cúbica'}, + + // US + usTeaspoon: {'en-US': 'US teaspoon', 'pt-BR': 'colher de chá americana'}, + usTablespoon: { + 'en-US': 'US tablespoon', + 'pt-BR': 'colher de sopa americana' + }, + usFluidOunce: {'en-US': 'US fluid ounce', 'pt-BR': 'onça fluida americana'}, + usCustomaryCup: { + 'en-US': 'US customary cup', + 'pt-BR': 'xícara comum americana' + }, + usLegalCup: {'en-US': 'US legal cup', 'pt-BR': 'xícara legal americana'}, + usLiquidPint: { + 'en-US': 'US liquid pint', + 'pt-BR': 'pinta líquida americana' + }, + usLiquidQuart: { + 'en-US': 'US liquid quart', + 'pt-BR': 'quarto líquido americano' + }, + usLiquidGallon: { + 'en-US': 'US liquid gallon', + 'pt-BR': 'galão líquido americano' + }, + + // SI + cubicNanometerSymbol: {'en-US': 'nm³', 'pt-BR': 'nm³'}, + cubicMicrometerSymbol: {'en-US': 'μm³', 'pt-BR': 'μm³'}, + cubicMillimeterSymbol: {'en-US': 'mm³', 'pt-BR': 'mm³'}, + milliliterSymbol: {'en-US': 'mL', 'pt-BR': 'mL'}, + literSymbol: {'en-US': 'L', 'pt-BR': 'L'}, + cubicMeterSymbol: {'en-US': 'm³', 'pt-BR': 'm³'}, + cubicDecameterSymbol: {'en-US': 'dam³', 'pt-BR': 'dam³'}, + cubicKilometerSymbol: {'en-US': 'km³', 'pt-BR': 'km³'}, + cubicMegameterSymbol: {'en-US': 'Mm³', 'pt-BR': 'Mm³'}, + cubicGigameterSymbol: {'en-US': 'Gm³', 'pt-BR': 'Gm³'}, + + // Imperial + cubicThouSymbol: {'en-US': 'thou³', 'pt-BR': 'thou³'}, + imperialTeaspoonSymbol: {'en-US': 'tsp', 'pt-BR': 'col.chá imp.'}, + imperialTablespoonSymbol: {'en-US': 'Tbsp', 'pt-BR': 'col.sopa imp.'}, + imperialFluidOunceSymbol: {'en-US': 'fl oz', 'pt-BR': 'oz.fl. imp.'}, + imperialCupSymbol: {'en-US': 'c', 'pt-BR': 'xíc. imp.'}, + imperialPintSymbol: {'en-US': 'pt', 'pt-BR': 'pt. imp.'}, + imperialQuartSymbol: {'en-US': 'qt', 'pt-BR': 'qt. imp.'}, + imperialGallonSymbol: {'en-US': 'gal', 'pt-BR': 'gal. imp.'}, + cubicInchSymbol: {'en-US': 'in³', 'pt-BR': 'pol³'}, + cubicFootSymbol: {'en-US': 'ft³', 'pt-BR': 'pé³'}, + cubicYardSymbol: {'en-US': 'yd³', 'pt-BR': 'jd³'}, + cubicMileSymbol: {'en-US': 'mi³', 'pt-BR': 'mi³'}, + + // US + usTeaspoonSymbol: {'en-US': 'tsp', 'pt-BR': 'col.chá EUA'}, + usTablespoonSymbol: {'en-US': 'Tbsp', 'pt-BR': 'col.sopa EUA'}, + usFluidOunceSymbol: {'en-US': 'fl oz', 'pt-BR': 'oz.fl. EUA'}, + usCustomaryCupSymbol: {'en-US': 'c', 'pt-BR': 'xíc. comum EUA'}, + usLegalCupSymbol: {'en-US': 'c', 'pt-BR': 'xíc. legal EUA'}, + usLiquidPintSymbol: {'en-US': 'pt', 'pt-BR': 'pt. líquida EUA'}, + usLiquidQuartSymbol: {'en-US': 'qt', 'pt-BR': 'qt. líquida EUA'}, + usLiquidGallonSymbol: {'en-US': 'gal', 'pt-BR': 'gal. líquida EUA'}, + + // Pattern Specifiers (generally not translatable, but for consistency) + imperialTeaspoonPattern: {'en-US': 'tsp_imp', 'pt-BR': 'tsp_imp'}, + imperialTablespoonPattern: {'en-US': 'Tbsp_imp', 'pt-BR': 'Tbsp_imp'}, + imperialFluidOuncePattern: {'en-US': 'fl_oz_imp', 'pt-BR': 'fl_oz_imp'}, + imperialCupPattern: {'en-US': 'c_imp', 'pt-BR': 'c_imp'}, + imperialPintPattern: {'en-US': 'pt_imp', 'pt-BR': 'pt_imp'}, + imperialGallonPattern: {'en-US': 'gal_imp', 'pt-BR': 'gal_imp'}, + + usTeaspoonPattern: {'en-US': 'tsp_us', 'pt-BR': 'tsp_us'}, + usTablespoonPattern: {'en-US': 'Tbsp_us', 'pt-BR': 'Tbsp_us'}, + usCustomaryCupPattern: { + 'en-US': 'c_us_customary', + 'pt-BR': 'c_us_customary' + }, + usLegalCupPattern: {'en-US': 'c_us_legal', 'pt-BR': 'c_us_legal'}, + usFluidOuncePattern: {'en-US': 'fl_oz_us', 'pt-BR': 'fl_oz_us'}, + usLiquidPintPattern: {'en-US': 'pt_us', 'pt-BR': 'pt_us'}, + usLiquidGallonPattern: {'en-US': 'gal_us', 'pt-BR': 'gal_us'}, + }); + + String i18n({ + String? locale, + }) => + localize(this, _t, locale: locale ?? Intl.getCurrentLocale()); + String plural(value) => localizePlural(value, this, _t); +} diff --git a/lib/src/units_of_measurement/weight.dart b/lib/src/units_of_measurement/weight.dart index 17be10a..b68afe1 100644 --- a/lib/src/units_of_measurement/weight.dart +++ b/lib/src/units_of_measurement/weight.dart @@ -1,5 +1,6 @@ import 'package:humanizer/humanizer.dart'; import 'package:humanizer/src/units_of_measurement/rationals.dart'; +import 'package:humanizer/src/units_of_measurement/weight.i18n.dart'; import 'package:humanizer/src/units_of_measurement/weight_constants.dart'; import 'package:meta/meta.dart'; @@ -259,33 +260,33 @@ extension WeightUnitExtensions on WeightUnit { switch (this) { // SI. case WeightUnit.nanogram: - return 'nanogram'; + return nanogram.i18n(locale: locale); case WeightUnit.microgram: - return 'microgram'; + return microgram.i18n(locale: locale); case WeightUnit.milligram: - return 'milligram'; + return milligram.i18n(locale: locale); case WeightUnit.gram: - return 'gram'; + return gram.i18n(locale: locale); case WeightUnit.kilogram: - return 'kilogram'; + return kilogram.i18n(locale: locale); case WeightUnit.tonne: - return 'tonne'; + return tonne.i18n(locale: locale); case WeightUnit.megatonne: - return 'megatonne'; + return megatonne.i18n(locale: locale); case WeightUnit.gigatonne: - return 'gigatonne'; + return gigatonne.i18n(locale: locale); // Imperial. case WeightUnit.ounce: - return 'ounce'; + return ounce.i18n(locale: locale); case WeightUnit.pound: - return 'pound'; + return pound.i18n(locale: locale); case WeightUnit.imperialTon: - return 'ton'; + return imperialTon.i18n(locale: locale); // US. case WeightUnit.usTon: - return 'ton'; + return usTon.i18n(locale: locale); } } @@ -296,33 +297,33 @@ extension WeightUnitExtensions on WeightUnit { switch (this) { // SI. case WeightUnit.nanogram: - return 'ng'; + return nanogramSymbol.i18n(locale: locale); case WeightUnit.microgram: - return 'µg'; + return microgramSymbol.i18n(locale: locale); case WeightUnit.milligram: - return 'mg'; + return milligramSymbol.i18n(locale: locale); case WeightUnit.gram: - return 'g'; + return gramSymbol.i18n(locale: locale); case WeightUnit.kilogram: - return 'kg'; + return kilogramSymbol.i18n(locale: locale); case WeightUnit.tonne: - return 't'; + return tonneSymbol.i18n(locale: locale); case WeightUnit.megatonne: - return 'Mt'; + return megatonneSymbol.i18n(locale: locale); case WeightUnit.gigatonne: - return 'Gt'; + return gigatonneSymbol.i18n(locale: locale); // Imperial. case WeightUnit.ounce: - return 'oz'; + return ounceSymbol.i18n(locale: locale); case WeightUnit.pound: - return 'lb'; + return poundSymbol.i18n(locale: locale); case WeightUnit.imperialTon: - return 'ton'; + return imperialTonSymbol.i18n(locale: locale); // US. case WeightUnit.usTon: - return 'ton'; + return usTonSymbol.i18n(locale: locale); } } diff --git a/lib/src/units_of_measurement/weight.i18n.dart b/lib/src/units_of_measurement/weight.i18n.dart new file mode 100644 index 0000000..764e9a7 --- /dev/null +++ b/lib/src/units_of_measurement/weight.i18n.dart @@ -0,0 +1,78 @@ +import 'package:i18n_extension_core/i18n_extension_core.dart'; +import 'package:intl/intl.dart'; + +final nanogram = Object(); +final microgram = Object(); +final milligram = Object(); +final gram = Object(); +final kilogram = Object(); +final tonne = Object(); +final megatonne = Object(); +final gigatonne = Object(); + +final ounce = Object(); +final pound = Object(); +final imperialTon = Object(); + +final usTon = Object(); + +final nanogramSymbol = Object(); +final microgramSymbol = Object(); +final milligramSymbol = Object(); +final gramSymbol = Object(); +final kilogramSymbol = Object(); +final tonneSymbol = Object(); +final megatonneSymbol = Object(); +final gigatonneSymbol = Object(); + +final ounceSymbol = Object(); +final poundSymbol = Object(); +final imperialTonSymbol = Object(); + +final usTonSymbol = Object(); + +extension WeightUnitI18n on Object { + static final _t = Translations.byId('en-US', { + // SI + nanogram: {'en-US': 'nanogram', 'pt-BR': 'nanograma'}, + microgram: {'en-US': 'microgram', 'pt-BR': 'micrograma'}, + milligram: {'en-US': 'milligram', 'pt-BR': 'miligrama'}, + gram: {'en-US': 'gram', 'pt-BR': 'grama'}, + kilogram: {'en-US': 'kilogram', 'pt-BR': 'quilograma'}, + tonne: {'en-US': 'tonne', 'pt-BR': 'tonelada'}, + megatonne: {'en-US': 'megatonne', 'pt-BR': 'megatonelada'}, + gigatonne: {'en-US': 'gigatonne', 'pt-BR': 'gigatonelada'}, + + // Imperial + ounce: {'en-US': 'ounce', 'pt-BR': 'onça'}, + pound: {'en-US': 'pound', 'pt-BR': 'libra'}, + imperialTon: {'en-US': 'ton', 'pt-BR': 'tonelada imperial'}, + + // US + usTon: {'en-US': 'ton', 'pt-BR': 'tonelada americana'}, + + // SI + nanogramSymbol: {'en-US': 'ng', 'pt-BR': 'ng'}, + microgramSymbol: {'en-US': 'µg', 'pt-BR': 'µg'}, + milligramSymbol: {'en-US': 'mg', 'pt-BR': 'mg'}, + gramSymbol: {'en-US': 'g', 'pt-BR': 'g'}, + kilogramSymbol: {'en-US': 'kg', 'pt-BR': 'kg'}, + tonneSymbol: {'en-US': 't', 'pt-BR': 't'}, + megatonneSymbol: {'en-US': 'Mt', 'pt-BR': 'Mt'}, + gigatonneSymbol: {'en-US': 'Gt', 'pt-BR': 'Gt'}, + + // Símbolos das unidades (para getSymbol) - Imperial + ounceSymbol: {'en-US': 'oz', 'pt-BR': 'oz'}, + poundSymbol: {'en-US': 'lb', 'pt-BR': 'lb'}, + imperialTonSymbol: {'en-US': 'ton', 'pt-BR': 'ton imp.'}, + + // Símbolos das unidades (para getSymbol) - US + usTonSymbol: {'en-US': 'ton', 'pt-BR': 'ton EUA'}, + }); + + String i18n({ + String? locale, + }) => + localize(this, _t, locale: locale ?? Intl.getCurrentLocale()); + String plural(value) => localizePlural(value, this, _t); +} diff --git a/pubspec.lock b/pubspec.lock index e4fb4d7..ec3205c 100644 --- a/pubspec.lock +++ b/pubspec.lock @@ -118,14 +118,6 @@ packages: url: "https://pub.dev" source: hosted version: "2.1.2" - http: - dependency: transitive - description: - name: http - sha256: b9c29a161230ee03d3ccf545097fccd9b87a5264228c5d348202e0f0c28f9010 - url: "https://pub.dev" - source: hosted - version: "1.2.2" http_multi_server: dependency: transitive description: @@ -142,14 +134,22 @@ packages: url: "https://pub.dev" source: hosted version: "4.1.2" + i18n_extension_core: + dependency: "direct main" + description: + name: i18n_extension_core + sha256: "7923af27a4f643a21d5aea5203bed4859d42c9d38c08939e22d6d10f1fa4afb5" + url: "https://pub.dev" + source: hosted + version: "5.0.1" intl: dependency: "direct main" description: name: intl - sha256: "00f33b908655e606b86d2ade4710a231b802eec6f11e87e4ea3783fd72077a50" + sha256: "3df61194eb431efc39c4ceba583b95633a403f46c9fd341e550ce0bfa50e9aa5" url: "https://pub.dev" source: hosted - version: "0.20.1" + version: "0.20.2" io: dependency: transitive description: @@ -318,6 +318,14 @@ packages: url: "https://pub.dev" source: hosted version: "1.10.1" + sprintf: + dependency: transitive + description: + name: sprintf + sha256: "1fc9ffe69d4df602376b52949af107d8f5703b77cda567c4d7d86a0693120f23" + url: "https://pub.dev" + source: hosted + version: "7.0.0" stack_trace: dependency: transitive description: diff --git a/pubspec.yaml b/pubspec.yaml index 3995a80..b317ebb 100644 --- a/pubspec.yaml +++ b/pubspec.yaml @@ -8,10 +8,11 @@ environment: dependencies: decimal: ^3.0.0 + i18n_extension_core: ^5.0.1 intl: ^0.20.0 meta: ^1.3.0 rational: ^2.1.0 dev_dependencies: lints: ^5.1.1 - test: ^1.21.1 + test: ^1.21.1 \ No newline at end of file From 0ca427a1b277f3c630553ab32eb2356af3981863 Mon Sep 17 00:00:00 2001 From: Osni Pezzini Junior Date: Thu, 19 Jun 2025 01:23:09 -0300 Subject: [PATCH 2/2] Added transformations pt-BR translations --- lib/src/transformations/approximate_time.dart | 28 +++++++++----- .../approximate_time.i18n.dart | 38 +++++++++++++++++++ 2 files changed, 56 insertions(+), 10 deletions(-) create mode 100644 lib/src/transformations/approximate_time.i18n.dart diff --git a/lib/src/transformations/approximate_time.dart b/lib/src/transformations/approximate_time.dart index 17ef7d1..2b996e9 100644 --- a/lib/src/transformations/approximate_time.dart +++ b/lib/src/transformations/approximate_time.dart @@ -1,4 +1,5 @@ import 'package:humanizer/humanizer.dart'; +import 'package:humanizer/src/transformations/approximate_time.i18n.dart'; import 'package:humanizer/src/units_of_measurement/rationals.dart'; import 'package:meta/meta.dart'; @@ -169,16 +170,18 @@ class ApproximateTimeTransformation extends Transformation { } if (!isRelativeToNow && time == Time.zero) { - return 'zero'; + return zero.i18n(locale: locale); } else if (isRelativeToNow && primaryUnit == TimeUnit.second && truncatedPrimaryValue == BigInt.zero) { - return 'now'; + return now.i18n(locale: locale); } else if (isRelativeToNow && primaryUnit == TimeUnit.day && truncatedPrimaryValue == BigInt.one && (truncatedSecondaryValue ?? 0) == 0) { - return sign == _Sign.negative ? 'yesterday' : 'tomorrow'; + return sign == _Sign.negative + ? yesterday.i18n(locale: locale) + : tomorrow.i18n(locale: locale); } else { final primaryUnitName = primaryUnit.getName(locale: locale).toPluralFormForQuantity( @@ -190,13 +193,18 @@ class ApproximateTimeTransformation extends Transformation { return [ if (secondaryQuantifierText != null) secondaryQuantifierText, if (isRelativeToNow && truncatedPrimaryValue == BigInt.one) - // TODO: should be generalized and localized?? - if (primaryUnit == TimeUnit.hour) 'an' else 'a' + if (primaryUnit == TimeUnit.hour) + an.i18n(locale: locale) + else + a.i18n(locale: locale) else truncatedPrimaryValue.toString(), primaryUnitName, if (isRelativeToNow) - if (sign == _Sign.negative) 'ago' else 'from now', + if (sign == _Sign.negative) + ago.i18n(locale: locale) + else + fromNow.i18n(locale: locale), ].join(' '); } } @@ -230,13 +238,13 @@ extension _SecondaryQuantifierExtensions on _SecondaryQuantifier { case _SecondaryQuantifier.none: return ''; case _SecondaryQuantifier.justOver: - return 'just over'; + return justOver.i18n(locale: locale); case _SecondaryQuantifier.over: - return 'over'; + return over.i18n(locale: locale); case _SecondaryQuantifier.under: - return 'under'; + return under.i18n(locale: locale); case _SecondaryQuantifier.justUnder: - return 'just under'; + return justUnder.i18n(locale: locale); } } } diff --git a/lib/src/transformations/approximate_time.i18n.dart b/lib/src/transformations/approximate_time.i18n.dart new file mode 100644 index 0000000..463708f --- /dev/null +++ b/lib/src/transformations/approximate_time.i18n.dart @@ -0,0 +1,38 @@ +import 'package:i18n_extension_core/i18n_extension_core.dart'; +import 'package:intl/intl.dart'; + +final justOver = Object(); +final over = Object(); +final under = Object(); +final justUnder = Object(); +final zero = Object(); +final now = Object(); +final yesterday = Object(); +final tomorrow = Object(); +final a = Object(); +final an = Object(); +final ago = Object(); +final fromNow = Object(); + +extension ApproximateTimeLocalization on Object { + static final _t = Translations.byId('en', { + justOver: {'en': 'just over', 'pt': 'um pouco mais'}, + over: {'en-US': 'over', 'pt-BR': 'mais de'}, + under: {'en-US': 'under', 'pt-BR': 'menos de'}, + justUnder: {'en-US': 'just under', 'pt-BR': 'um pouco menos'}, + zero: {'en-US': 'zero', 'pt-BR': 'zero'}, + now: {'en-US': 'now', 'pt-BR': 'agora'}, + yesterday: {'en-US': 'yesterday', 'pt-BR': 'ontem'}, + tomorrow: {'en-US': 'tomorrow', 'pt-BR': 'amanhã'}, + an: {'en-US': 'an', 'pt-BR': 'uma'}, + a: {'en-US': 'a', 'pt-BR': 'um'}, + ago: {'en-US': 'ago', 'pt-BR': 'atrás'}, + fromNow: {'en-US': 'from now', 'pt-BR': 'a partir de agora'}, + }); + + String i18n({ + String? locale, + }) => + localize(this, _t, locale: locale ?? Intl.getCurrentLocale()); + String plural(value) => localizePlural(value, this, _t); +}