@silexpert/core 1.1.52 → 1.1.53

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (13) hide show
  1. package/es/types/Enum/BrandClementine.d.ts.map +1 -1
  2. package/es/types/Enum/BrandClementine.js +31 -0
  3. package/es/types/Enum/BrandClementine.js.map +1 -1
  4. package/es/utils/amount.d.ts.map +1 -1
  5. package/es/utils/amount.js +74 -293
  6. package/es/utils/amount.js.map +1 -1
  7. package/js/types/Enum/BrandClementine.js +30 -0
  8. package/js/types/Enum/BrandClementine.js.map +1 -1
  9. package/js/utils/amount.js +65 -230
  10. package/js/utils/amount.js.map +1 -1
  11. package/package.json +1 -1
  12. package/ts/types/Enum/BrandClementine.ts +31 -0
  13. package/ts/utils/amount.ts +86 -161
package/ts/utils/amount.ts CHANGED
@@ -50,172 +50,97 @@ export function integerToFormattedAmountObject(
50
50
  }
51
51
 
52
52
  /**
53
- * Convertit jusqu'à 999 999 999 999 999 (billion) *
53
+ * Convertit les nombres à virgule de 0 à 100 000 000 (100 millions) *
54
54
  * @param nombre
55
55
  * @returns {string}
56
56
  */
57
- function getUnite(nombre: number):string {
58
- let unite;
59
- switch (nombre) {
60
- // case 0: unite = 'zéro'; break;
61
- case 1: unite = 'un'; break;
62
- case 2: unite = 'deux'; break;
63
- case 3: unite = 'trois'; break;
64
- case 4: unite = 'quatre'; break;
65
- case 5: unite = 'cinq'; break;
66
- case 6: unite = 'six'; break;
67
- case 7: unite = 'sept'; break;
68
- case 8: unite = 'huit'; break;
69
- case 9: unite = 'neuf'; break;
70
- default: unite = 'zéro'; break;
71
- }// fin switch
72
- return unite;
57
+ const unites: string[] = [
58
+ '', 'un', 'deux', 'trois', 'quatre', 'cinq', 'six', 'sept', 'huit', 'neuf', 'dix',
59
+ 'onze', 'douze', 'treize', 'quatorze', 'quinze', 'seize', 'dix-sept', 'dix-huit', 'dix-neuf',
60
+ ];
61
+
62
+ const dizaines: string[] = [
63
+ '', '', 'vingt', 'trente', 'quarante', 'cinquante', 'soixante', 'soixante',
64
+ 'quatre-vingt', 'quatre-vingt',
65
+ ];
66
+
67
+ const groupes: string[] = ['', 'mille', 'million'];
68
+
69
+ function convertirGroupeEnLettres(groupe: number): string {
70
+ let groupeEnLettres = '';
71
+
72
+ const centaines = Math.floor(groupe / 100);
73
+ const dizainesEtUnites = groupe % 100;
74
+
75
+ if (centaines > 0) {
76
+ groupeEnLettres += `${unites[centaines] === 'un' ? '' : unites[centaines]} cent `;
77
+ }
78
+
79
+ if (dizainesEtUnites > 0) {
80
+ if (dizainesEtUnites <= 19) {
81
+ groupeEnLettres += unites[dizainesEtUnites];
82
+ } else {
83
+ const unite = dizainesEtUnites % 10;
84
+ const dizaine = Math.floor(dizainesEtUnites / 10);
85
+ groupeEnLettres += dizaines[dizaine];
86
+
87
+ if (unite > 0) {
88
+ if (dizaine === 7 || dizaine === 9) {
89
+ /* const dizaineTexte = */dizaines[dizaine].slice(0, -1);
90
+ const uniteTexte = unites[unite];
91
+ groupeEnLettres += `-${uniteTexte}`;
92
+ } else {
93
+ const uniteTexte = unites[unite];
94
+ groupeEnLettres += `-${uniteTexte}`;
95
+ }
96
+ }
97
+ }
98
+ }
99
+
100
+ return groupeEnLettres.trim();
73
101
  }
102
+ function convertirNombreEntierEnLettres(ent: number): string {
103
+ let entier = ent;
104
+ if (entier === 0) {
105
+ return 'zéro';
106
+ }
107
+
108
+ let resultat = '';
74
109
 
75
- function getDizaine(nombre: number):string {
76
- let dizaine;
77
- switch (nombre) {
78
- // case 10: dizaine = 'dix'; break;
79
- case 11: dizaine = 'onze'; break;
80
- case 12: dizaine = 'douze'; break;
81
- case 13: dizaine = 'treize'; break;
82
- case 14: dizaine = 'quatorze'; break;
83
- case 15: dizaine = 'quinze'; break;
84
- case 16: dizaine = 'seize'; break;
85
- case 17: dizaine = 'dix-sept'; break;
86
- case 18: dizaine = 'dix-huit'; break;
87
- case 19: dizaine = 'dix-neuf'; break;
88
- case 20: dizaine = 'vingt'; break;
89
- case 30: dizaine = 'trente'; break;
90
- case 40: dizaine = 'quarante'; break;
91
- case 50: dizaine = 'cinquante'; break;
92
- case 60: dizaine = 'soixante'; break;
93
- case 70: dizaine = 'soixante-dix'; break;
94
- case 80: dizaine = 'quatre-vingt'; break;
95
- case 90: dizaine = 'quatre-vingt-dix'; break;
96
- default: dizaine = 'dix'; break;
97
- }// fin switch
98
- return dizaine;
99
- }//-----------------------------------------------------------------------
110
+ let groupeIndex = 0;
111
+ while (entier > 0) {
112
+ const groupe = entier % 1000;
113
+ const groupeEnLettres = convertirGroupeEnLettres(groupe);
100
114
 
115
+ if (groupeEnLettres !== '') {
116
+ resultat = `${groupeEnLettres === 'un' && ['mille', 'cent'].includes(groupes[groupeIndex]) ? '' : groupeEnLettres} ${groupes[groupeIndex]}${groupeIndex === 2 && groupeEnLettres !== 'un' ? 's' : ''} ${resultat}`;
117
+ }
118
+
119
+ entier = Math.floor(entier / 1000);
120
+ groupeIndex += 1;
121
+ }
122
+
123
+ return resultat.trim();
124
+ }
125
+ function convertirNombreDecimalEnLettres(decimal: number): string {
126
+ const decimalArrondi = Math.round(decimal * 100);
127
+ return `virgule ${convertirNombreEntierEnLettres(decimalArrondi)}`;
128
+ }
101
129
  export function convertNumberToLetter(nombre: number): string {
102
- let quotient: number; let reste: number;
103
- let numberToLetter = '';
104
-
105
- if (nombre.toString().replace(/ /gi, '').length > 15) return 'dépassement de capacité';
106
- if (Number.isNaN(nombre.toString().replace(/ /gi, ''))) return 'Nombre non valide';
107
-
108
- const nb = parseFloat(nombre.toString().replace(/ /gi, ''));
109
- if (Math.ceil(nb) !== nb) return 'Nombre avec virgule non géré.';
110
-
111
- const n = nb.toString().length;
112
- switch (n) {
113
- // case 1: numberToLetter = getUnite(nb); break;
114
- case 2: if (nb > 19) {
115
- quotient = Math.floor(nb / 10);
116
- reste = nb % 10;
117
- if (nb < 71 || (nb > 79 && nb < 91)) {
118
- if (reste === 0) numberToLetter = getDizaine(quotient * 10);
119
- if (reste === 1) numberToLetter = `${getDizaine(quotient * 10)}-et-${getUnite(reste)}`;
120
- if (reste > 1) numberToLetter = `${getDizaine(quotient * 10)}-${getUnite(reste)}`;
121
- } else numberToLetter = `${getDizaine((quotient - 1) * 10)}-${getDizaine(10 + reste)}`;
122
- } else numberToLetter = getDizaine(nb);
123
- break;
124
- case 3: quotient = Math.floor(nb / 100);
125
- reste = nb % 100;
126
- if (quotient === 1 && reste === 0) numberToLetter = 'cent';
127
- if (quotient === 1 && reste !== 0) numberToLetter = `${'cent '}${convertNumberToLetter(reste)}`;
128
- if (quotient > 1 && reste === 0) numberToLetter = `${getUnite(quotient)} cents`;
129
- if (quotient > 1 && reste !== 0) numberToLetter = `${getUnite(quotient)} cent ${convertNumberToLetter(reste)}`;
130
- break;
131
- case 4: quotient = Math.floor(nb / 1000);
132
- reste = nb - quotient * 1000;
133
- if (quotient === 1 && reste === 0) numberToLetter = 'mille';
134
- if (quotient === 1 && reste !== 0) numberToLetter = `${'mille '}${convertNumberToLetter(reste)}`;
135
- if (quotient > 1 && reste === 0) numberToLetter = `${convertNumberToLetter(quotient)} mille`;
136
- if (quotient > 1 && reste !== 0) numberToLetter = `${convertNumberToLetter(quotient)} mille ${convertNumberToLetter(reste)}`;
137
- break;
138
- case 5: quotient = Math.floor(nb / 1000);
139
- reste = nb - quotient * 1000;
140
- if (quotient === 1 && reste === 0) numberToLetter = 'mille';
141
- if (quotient === 1 && reste !== 0) numberToLetter = `${'mille '}${convertNumberToLetter(reste)}`;
142
- if (quotient > 1 && reste === 0) numberToLetter = `${convertNumberToLetter(quotient)} mille`;
143
- if (quotient > 1 && reste !== 0) numberToLetter = `${convertNumberToLetter(quotient)} mille ${convertNumberToLetter(reste)}`;
144
- break;
145
- case 6: quotient = Math.floor(nb / 1000);
146
- reste = nb - quotient * 1000;
147
- if (quotient === 1 && reste === 0) numberToLetter = 'mille';
148
- if (quotient === 1 && reste !== 0) numberToLetter = `${'mille '}${convertNumberToLetter(reste)}`;
149
- if (quotient > 1 && reste === 0) numberToLetter = `${convertNumberToLetter(quotient)} mille`;
150
- if (quotient > 1 && reste !== 0) numberToLetter = `${convertNumberToLetter(quotient)} mille ${convertNumberToLetter(reste)}`;
151
- break;
152
- case 7: quotient = Math.floor(nb / 1000000);
153
- reste = nb % 1000000;
154
- if (quotient === 1 && reste === 0) numberToLetter = 'un million';
155
- if (quotient === 1 && reste !== 0) numberToLetter = `${'un million '}${convertNumberToLetter(reste)}`;
156
- if (quotient > 1 && reste === 0) numberToLetter = `${convertNumberToLetter(quotient)} millions`;
157
- if (quotient > 1 && reste !== 0) numberToLetter = `${convertNumberToLetter(quotient)} millions ${convertNumberToLetter(reste)}`;
158
- break;
159
- case 8: quotient = Math.floor(nb / 1000000);
160
- reste = nb % 1000000;
161
- if (quotient === 1 && reste === 0) numberToLetter = 'un million';
162
- if (quotient === 1 && reste !== 0) numberToLetter = `${'un million '}${convertNumberToLetter(reste)}`;
163
- if (quotient > 1 && reste === 0) numberToLetter = `${convertNumberToLetter(quotient)} millions`;
164
- if (quotient > 1 && reste !== 0) numberToLetter = `${convertNumberToLetter(quotient)} millions ${convertNumberToLetter(reste)}`;
165
- break;
166
- case 9: quotient = Math.floor(nb / 1000000);
167
- reste = nb % 1000000;
168
- if (quotient === 1 && reste === 0) numberToLetter = 'un million';
169
- if (quotient === 1 && reste !== 0) numberToLetter = `${'un million '}${convertNumberToLetter(reste)}`;
170
- if (quotient > 1 && reste === 0) numberToLetter = `${convertNumberToLetter(quotient)} millions`;
171
- if (quotient > 1 && reste !== 0) numberToLetter = `${convertNumberToLetter(quotient)} millions ${convertNumberToLetter(reste)}`;
172
- break;
173
- case 10: quotient = Math.floor(nb / 1000000000);
174
- reste = nb - quotient * 1000000000;
175
- if (quotient === 1 && reste === 0) numberToLetter = 'un milliard';
176
- if (quotient === 1 && reste !== 0) numberToLetter = `${'un milliard '}${convertNumberToLetter(reste)}`;
177
- if (quotient > 1 && reste === 0) numberToLetter = `${convertNumberToLetter(quotient)} milliards`;
178
- if (quotient > 1 && reste !== 0) numberToLetter = `${convertNumberToLetter(quotient)} milliards ${convertNumberToLetter(reste)}`;
179
- break;
180
- case 11: quotient = Math.floor(nb / 1000000000);
181
- reste = nb - quotient * 1000000000;
182
- if (quotient === 1 && reste === 0) numberToLetter = 'un milliard';
183
- if (quotient === 1 && reste !== 0) numberToLetter = `${'un milliard '}${convertNumberToLetter(reste)}`;
184
- if (quotient > 1 && reste === 0) numberToLetter = `${convertNumberToLetter(quotient)} milliards`;
185
- if (quotient > 1 && reste !== 0) numberToLetter = `${convertNumberToLetter(quotient)} milliards ${convertNumberToLetter(reste)}`;
186
- break;
187
- case 12: quotient = Math.floor(nb / 1000000000);
188
- reste = nb - quotient * 1000000000;
189
- if (quotient === 1 && reste === 0) numberToLetter = 'un milliard';
190
- if (quotient === 1 && reste !== 0) numberToLetter = `${'un milliard '}${convertNumberToLetter(reste)}`;
191
- if (quotient > 1 && reste === 0) numberToLetter = `${convertNumberToLetter(quotient)} milliards`;
192
- if (quotient > 1 && reste !== 0) numberToLetter = `${convertNumberToLetter(quotient)} milliards ${convertNumberToLetter(reste)}`;
193
- break;
194
- case 13: quotient = Math.floor(nb / 1000000000000);
195
- reste = nb - quotient * 1000000000000;
196
- if (quotient === 1 && reste === 0) numberToLetter = 'un billion';
197
- if (quotient === 1 && reste !== 0) numberToLetter = `${'un billion '}${convertNumberToLetter(reste)}`;
198
- if (quotient > 1 && reste === 0) numberToLetter = `${convertNumberToLetter(quotient)} billions`;
199
- if (quotient > 1 && reste !== 0) numberToLetter = `${convertNumberToLetter(quotient)} billions ${convertNumberToLetter(reste)}`;
200
- break;
201
- case 14: quotient = Math.floor(nb / 1000000000000);
202
- reste = nb - quotient * 1000000000000;
203
- if (quotient === 1 && reste === 0) numberToLetter = 'un billion';
204
- if (quotient === 1 && reste !== 0) numberToLetter = `${'un billion '}${convertNumberToLetter(reste)}`;
205
- if (quotient > 1 && reste === 0) numberToLetter = `${convertNumberToLetter(quotient)} billions`;
206
- if (quotient > 1 && reste !== 0) numberToLetter = `${convertNumberToLetter(quotient)} billions ${convertNumberToLetter(reste)}`;
207
- break;
208
- case 15: quotient = Math.floor(nb / 1000000000000);
209
- reste = nb - quotient * 1000000000000;
210
- if (quotient === 1 && reste === 0) numberToLetter = 'un billion';
211
- if (quotient === 1 && reste !== 0) numberToLetter = `${'un billion '}${convertNumberToLetter(reste)}`;
212
- if (quotient > 1 && reste === 0) numberToLetter = `${convertNumberToLetter(quotient)} billions`;
213
- if (quotient > 1 && reste !== 0) numberToLetter = `${convertNumberToLetter(quotient)} billions ${convertNumberToLetter(reste)}`;
214
- break;
215
- default: numberToLetter = getUnite(nb); break;
216
- } // fin switch
217
- /* respect de l'accord de quatre-vingt */
218
- if (numberToLetter.substr(numberToLetter.length - 'quatre-vingt'.length, 'quatre-vingt'.length) === 'quatre-vingt') numberToLetter += 's';
219
-
220
- return numberToLetter;
130
+ const partieEntiere = Math.floor(nombre);
131
+ const partieDecimale = nombre - partieEntiere;
132
+
133
+ let resultat = '';
134
+
135
+ if (partieEntiere === 0) {
136
+ resultat = 'zéro';
137
+ } else {
138
+ resultat = convertirNombreEntierEnLettres(partieEntiere);
139
+ }
140
+
141
+ if (partieDecimale > 0) {
142
+ resultat += ` ${convertirNombreDecimalEnLettres(partieDecimale)}`;
143
+ }
144
+
145
+ return resultat;
221
146
  }