@jscrpt/common 6.0.0 → 6.1.0-beta.20240529033427

package/numeral/package.json

@@ -0,0 +1,8 @@
+{
+    "name": "@jscrpt/common-numeral",
+    "sideEffects": false,
+    "main": "./index.js",
+    "module": "./index.js",
+    "browser": "./index.js",
+    "typings": "./src/index.d.ts"
+  }

package/numeral/src/formats/bps.js

@@ -0,0 +1,34 @@
+export default function formatFactory(numeral) {
+    numeral.register('format', 'bps', {
+            regexps: {
+                format: /(BPS)/,
+                unformat: /(BPS)/
+            },
+            format: function(value, format, roundingFunction) {
+                var space = numeral._.includes(format, ' BPS') ? ' ' : '',
+                    output;
+
+                value = value * 10000;
+
+                // check for space before BPS
+                format = format.replace(/\s?BPS/, '');
+
+                output = numeral._.numberToFormat(value, format, roundingFunction);
+
+                if (numeral._.includes(output, ')')) {
+                    output = output.split('');
+
+                    output.splice(-1, 0, space + 'BPS');
+
+                    output = output.join('');
+                } else {
+                    output = output + space + 'BPS';
+                }
+
+                return output;
+            },
+            unformat: function(string) {
+                return +(numeral._.stringToNumber(string) * 0.0001).toFixed(15);
+            }
+        });
+};

package/numeral/src/formats/bytes.js

@@ -0,0 +1,79 @@
+export default function formatFactory(numeral) {
+    var decimal = {
+            base: 1000,
+            suffixes: ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
+        },
+        binary = {
+            base: 1024,
+            suffixes: ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']
+        };
+
+    var allSuffixes =  decimal.suffixes.concat(binary.suffixes.filter(function (item) {
+            return decimal.suffixes.indexOf(item) < 0;
+        }));
+        var unformatRegex = allSuffixes.join('|');
+        // Allow support for BPS (http://www.investopedia.com/terms/b/basispoint.asp)
+        unformatRegex = '(' + unformatRegex.replace('B', 'B(?!PS)') + ')';
+
+    numeral.register('format', 'bytes', {
+        regexps: {
+            format: /([0\s]i?b)/,
+            unformat: new RegExp(unformatRegex)
+        },
+        format: function(value, format, roundingFunction) {
+            var output,
+                bytes = numeral._.includes(format, 'ib') ? binary : decimal,
+                suffix = numeral._.includes(format, ' b') || numeral._.includes(format, ' ib') ? ' ' : '',
+                power,
+                min,
+                max;
+
+            // check for space before
+            format = format.replace(/\s?i?b/, '');
+
+            for (power = 0; power <= bytes.suffixes.length; power++) {
+                min = Math.pow(bytes.base, power);
+                max = Math.pow(bytes.base, power + 1);
+
+                if (value === null || value === 0 || value >= min && value < max) {
+                    suffix += bytes.suffixes[power];
+
+                    if (min > 0) {
+                        value = value / min;
+                    }
+
+                    break;
+                }
+            }
+
+            output = numeral._.numberToFormat(value, format, roundingFunction);
+
+            return output + suffix;
+        },
+        unformat: function(string) {
+            var value = numeral._.stringToNumber(string),
+                power,
+                bytesMultiplier;
+
+            if (value) {
+                for (power = decimal.suffixes.length - 1; power >= 0; power--) {
+                    if (numeral._.includes(string, decimal.suffixes[power])) {
+                        bytesMultiplier = Math.pow(decimal.base, power);
+
+                        break;
+                    }
+
+                    if (numeral._.includes(string, binary.suffixes[power])) {
+                        bytesMultiplier = Math.pow(binary.base, power);
+
+                        break;
+                    }
+                }
+
+                value *= (bytesMultiplier || 1);
+            }
+
+            return value;
+        }
+    });
+};

package/numeral/src/formats/currency.js

@@ -0,0 +1,62 @@
+export default function formatFactory(numeral) {
+    numeral.register('format', 'currency', {
+        regexps: {
+            format: /(\$)/
+        },
+        format: function(value, format, roundingFunction) {
+            var locale = numeral.locales[numeral.options.currentLocale],
+                symbols = {
+                    before: format.match(/^([\+|\-|\(|\s|\$]*)/)[0],
+                    after: format.match(/([\+|\-|\)|\s|\$]*)$/)[0]
+                },
+                output,
+                symbol,
+                i;
+
+            // strip format of spaces and $
+            format = format.replace(/\s?\$\s?/, '');
+
+            // format the number
+            output = numeral._.numberToFormat(value, format, roundingFunction);
+
+            // update the before and after based on value
+            if (value >= 0) {
+                symbols.before = symbols.before.replace(/[\-\(]/, '');
+                symbols.after = symbols.after.replace(/[\-\)]/, '');
+            } else if (value < 0 && (!numeral._.includes(symbols.before, '-') && !numeral._.includes(symbols.before, '('))) {
+                symbols.before = '-' + symbols.before;
+            }
+
+            // loop through each before symbol
+            for (i = 0; i < symbols.before.length; i++) {
+                symbol = symbols.before[i];
+
+                switch (symbol) {
+                    case '$':
+                        output = numeral._.insert(output, locale.currency.symbol, i);
+                        break;
+                    case ' ':
+                        output = numeral._.insert(output, ' ', i + locale.currency.symbol.length - 1);
+                        break;
+                }
+            }
+
+            // loop through each after symbol
+            for (i = symbols.after.length - 1; i >= 0; i--) {
+                symbol = symbols.after[i];
+
+                switch (symbol) {
+                    case '$':
+                        output = i === symbols.after.length - 1 ? output + locale.currency.symbol : numeral._.insert(output, locale.currency.symbol, -(symbols.after.length - (1 + i)));
+                        break;
+                    case ' ':
+                        output = i === symbols.after.length - 1 ? output + ' ' : numeral._.insert(output, ' ', -(symbols.after.length - (1 + i) + locale.currency.symbol.length - 1));
+                        break;
+                }
+            }
+
+
+            return output;
+        }
+    });
+};

package/numeral/src/formats/exponential.js

@@ -0,0 +1,34 @@
+export default function formatFactory(numeral) {
+    numeral.register('format', 'exponential', {
+        regexps: {
+            format: /(e\+|e-)/,
+            unformat: /(e\+|e-)/
+        },
+        format: function(value, format, roundingFunction) {
+            var output,
+                exponential = typeof value === 'number' && !numeral._.isNaN(value) ? value.toExponential() : '0e+0',
+                parts = exponential.split('e');
+
+            format = format.replace(/e[\+|\-]{1}0/, '');
+
+            output = numeral._.numberToFormat(Number(parts[0]), format, roundingFunction);
+
+            return output + 'e' + parts[1];
+        },
+        unformat: function(string) {
+            var parts = numeral._.includes(string, 'e+') ? string.split('e+') : string.split('e-'),
+                value = Number(parts[0]),
+                power = Number(parts[1]);
+
+            power = numeral._.includes(string, 'e-') ? power *= -1 : power;
+
+            function cback(accum, curr, currI, O) {
+                var corrFactor = numeral._.correctionFactor(accum, curr),
+                    num = (accum * corrFactor) * (curr * corrFactor) / (corrFactor * corrFactor);
+                return num;
+            }
+
+            return numeral._.reduce([value, Math.pow(10, power)], cback, 1);
+        }
+    });
+};

package/numeral/src/formats/ordinal.js

@@ -0,0 +1,21 @@
+export default function formatFactory(numeral) {
+    numeral.register('format', 'ordinal', {
+        regexps: {
+            format: /(o)/
+        },
+        format: function(value, format, roundingFunction) {
+            var locale = numeral.locales[numeral.options.currentLocale],
+                output,
+                ordinal = numeral._.includes(format, ' o') ? ' ' : '';
+
+            // check for space before
+            format = format.replace(/\s?o/, '');
+
+            ordinal += locale.ordinal(value);
+
+            output = numeral._.numberToFormat(value, format, roundingFunction);
+
+            return output + ordinal;
+        }
+    });
+};

package/numeral/src/formats/percentage.js

@@ -0,0 +1,40 @@
+export default function formatFactory(numeral) {
+    numeral.register('format', 'percentage', {
+        regexps: {
+            format: /(%)/,
+            unformat: /(%)/
+        },
+        format: function(value, format, roundingFunction) {
+            var space = numeral._.includes(format, ' %') ? ' ' : '',
+                output;
+
+            if (numeral.options.scalePercentBy100) {
+                value = value * 100;
+            }
+
+            // check for space before %
+            format = format.replace(/\s?\%/, '');
+
+            output = numeral._.numberToFormat(value, format, roundingFunction);
+
+            if (numeral._.includes(output, ')')) {
+                output = output.split('');
+
+                output.splice(-1, 0, space + '%');
+
+                output = output.join('');
+            } else {
+                output = output + space + '%';
+            }
+
+            return output;
+        },
+        unformat: function(string) {
+            var number = numeral._.stringToNumber(string);
+            if (numeral.options.scalePercentBy100) {
+                return number * 0.01;
+            }
+            return number;
+        }
+    });
+};

package/numeral/src/formats/time.js

@@ -0,0 +1,35 @@
+export default function formatFactory(numeral) {
+    numeral.register('format', 'time', {
+        regexps: {
+            format: /(:)/,
+            unformat: /(:)/
+        },
+        format: function(value, format, roundingFunction) {
+            var hours = Math.floor(value / 60 / 60),
+                minutes = Math.floor((value - (hours * 60 * 60)) / 60),
+                seconds = Math.round(value - (hours * 60 * 60) - (minutes * 60));
+
+            return hours + ':' + (minutes < 10 ? '0' + minutes : minutes) + ':' + (seconds < 10 ? '0' + seconds : seconds);
+        },
+        unformat: function(string) {
+            var timeArray = string.split(':'),
+                seconds = 0;
+
+            // turn hours and minutes into seconds and add them all up
+            if (timeArray.length === 3) {
+                // hours
+                seconds = seconds + (Number(timeArray[0]) * 60 * 60);
+                // minutes
+                seconds = seconds + (Number(timeArray[1]) * 60);
+                // seconds
+                seconds = seconds + Number(timeArray[2]);
+            } else if (timeArray.length === 2) {
+                // minutes
+                seconds = seconds + (Number(timeArray[0]) * 60);
+                // seconds
+                seconds = seconds + Number(timeArray[1]);
+            }
+            return Number(seconds);
+        }
+    });
+};

package/numeral/src/index.js

@@ -0,0 +1,89 @@
+export * from './numeral.js';
+import numeral from './numeral.js';
+
+import bpsFormatFactory from './formats/bps.js';
+import bytesFormatFactory from './formats/bytes.js';
+import currencyFormatFactory from './formats/currency.js';
+import exponentialFormatFactory from './formats/exponential.js';
+import ordinalFormatFactory from './formats/ordinal.js';
+import percentageFormatFactory from './formats/percentage.js';
+import timeFormatFactory from './formats/time.js';
+
+import bgLocaleFactory from './locales/bg.js';
+import csLocaleFactory from './locales/cs.js';
+import daDkLocaleFactory from './locales/da-dk.js';
+import deLocaleFactory from './locales/de.js';
+import deChLocaleFactory from './locales/de-ch.js';
+import enAuLocaleFactory from './locales/en-au.js';
+import enGbLocaleFactory from './locales/en-gb.js';
+import enZaLocaleFactory from './locales/en-za.js';
+import esLocaleFactory from './locales/es.js';
+import esEsLocaleFactory from './locales/es-es.js';
+import etLocaleFactory from './locales/et.js';
+import fiLocaleFactory from './locales/fi.js';
+import frLocaleFactory from './locales/fr.js';
+import frCaLocaleFactory from './locales/fr-ca.js';
+import frChLocaleFactory from './locales/fr-ch.js';
+import huLocaleFactory from './locales/hu.js';
+import chsLocaleFactory from './locales/chs.js';
+import itLocaleFactory from './locales/it.js';
+import jaLocaleFactory from './locales/ja.js';
+import lvLocaleFactory from './locales/lv.js';
+import nlBeLocaleFactory from './locales/nl-be.js';
+import nlNlLocaleFactory from './locales/nl-nl.js';
+import noLocaleFactory from './locales/no.js';
+import plLocaleFactory from './locales/pl.js';
+import ptBrLocaleFactory from './locales/pt-br.js';
+import ptPtLocaleFactory from './locales/pt-pt.js';
+import ruLocaleFactory from './locales/ru.js';
+import ruUaLocaleFactory from './locales/ru-ua.js';
+import skLocaleFactory from './locales/sk.js';
+import slLocaleFactory from './locales/sl.js';
+import thLocaleFactory from './locales/th.js';
+import trLocaleFactory from './locales/tr.js';
+import ukUaLocaleFactory from './locales/uk-ua.js';
+import viLocaleFactory from './locales/vi.js';
+
+
+bpsFormatFactory(numeral);
+bytesFormatFactory(numeral);
+currencyFormatFactory(numeral);
+exponentialFormatFactory(numeral);
+ordinalFormatFactory(numeral);
+percentageFormatFactory(numeral);
+timeFormatFactory(numeral);
+
+bgLocaleFactory(numeral);
+csLocaleFactory(numeral);
+daDkLocaleFactory(numeral);
+deLocaleFactory(numeral);
+deChLocaleFactory(numeral);
+enAuLocaleFactory(numeral);
+enGbLocaleFactory(numeral);
+enZaLocaleFactory(numeral);
+esLocaleFactory(numeral);
+esEsLocaleFactory(numeral);
+etLocaleFactory(numeral);
+fiLocaleFactory(numeral);
+frLocaleFactory(numeral);
+frCaLocaleFactory(numeral);
+frChLocaleFactory(numeral);
+huLocaleFactory(numeral);
+chsLocaleFactory(numeral);
+itLocaleFactory(numeral);
+jaLocaleFactory(numeral);
+lvLocaleFactory(numeral);
+nlBeLocaleFactory(numeral);
+nlNlLocaleFactory(numeral);
+noLocaleFactory(numeral);
+plLocaleFactory(numeral);
+ptBrLocaleFactory(numeral);
+ptPtLocaleFactory(numeral);
+ruLocaleFactory(numeral);
+ruUaLocaleFactory(numeral);
+skLocaleFactory(numeral);
+slLocaleFactory(numeral);
+thLocaleFactory(numeral);
+trLocaleFactory(numeral);
+ukUaLocaleFactory(numeral);
+viLocaleFactory(numeral);

package/numeral/src/locales/bg.js

@@ -0,0 +1,28 @@
+export default function localeFactory(numeral) {
+    numeral.register('locale', 'bg', {
+        delimiters: {
+            thousands: ' ',
+            decimal: ','
+        },
+        abbreviations: { // I found these here http://www.unicode.org/cldr/charts/28/verify/numbers/bg.html
+            thousand: 'хил',
+            million: 'млн',
+            billion: 'млрд',
+            trillion: 'трлн'
+        },
+        ordinal: function (number) {
+            // google translate suggests:
+            // 1st=1-ви; 2nd=2-ри; 7th=7-ми;
+            // 8th=8-ми and many others end with -ти
+            // for example 3rd=3-ти
+            // However since I've seen suggestions that in
+            // Bulgarian the ordinal can be taken in
+            // different forms (masculine, feminine, neuter)
+            // I've opted to wimp out on commiting that to code
+            return '';
+        },
+        currency: {
+            symbol: 'лв'
+        }
+    });
+};

package/numeral/src/locales/chs.js

@@ -0,0 +1,20 @@
+export default function localeFactory(numeral) {
+    numeral.register('locale', 'chs', {
+        delimiters: {
+            thousands: ',',
+            decimal: '.'
+        },
+        abbreviations: {
+            thousand: '千',
+            million: '百万',
+            billion: '十亿',
+            trillion: '兆'
+        },
+        ordinal: function (number) {
+            return '.';
+        },
+        currency: {
+            symbol: '¥'
+        }
+    });
+};

package/numeral/src/locales/cs.js

@@ -0,0 +1,20 @@
+export default function localeFactory(numeral) {
+    numeral.register('locale', 'cs', {
+        delimiters: {
+            thousands: ' ',
+            decimal: ','
+        },
+        abbreviations: {
+            thousand: 'tis.',
+            million: 'mil.',
+            billion: 'b',
+            trillion: 't'
+        },
+        ordinal: function () {
+            return '.';
+        },
+        currency: {
+            symbol: 'Kč'
+        }
+    });
+};

package/numeral/src/locales/da-dk.js

@@ -0,0 +1,20 @@
+export default function localeFactory(numeral) {
+    numeral.register('locale', 'da-dk', {
+        delimiters: {
+            thousands: '.',
+            decimal: ','
+        },
+        abbreviations: {
+            thousand: 'k',
+            million: 'mio',
+            billion: 'mia',
+            trillion: 'b'
+        },
+        ordinal: function (number) {
+            return '.';
+        },
+        currency: {
+            symbol: 'DKK'
+        }
+    });
+};

package/numeral/src/locales/de-ch.js

@@ -0,0 +1,20 @@
+export default function localeFactory(numeral) {
+    numeral.register('locale', 'de-ch', {
+        delimiters: {
+            thousands: ' ',
+            decimal: ','
+        },
+        abbreviations: {
+            thousand: 'k',
+            million: 'm',
+            billion: 'b',
+            trillion: 't'
+        },
+        ordinal: function (number) {
+            return '.';
+        },
+        currency: {
+            symbol: 'CHF'
+        }
+    });
+};

package/numeral/src/locales/de.js

@@ -0,0 +1,20 @@
+export default function localeFactory(numeral) {
+    numeral.register('locale', 'de', {
+        delimiters: {
+            thousands: ' ',
+            decimal: ','
+        },
+        abbreviations: {
+            thousand: 'k',
+            million: 'm',
+            billion: 'b',
+            trillion: 't'
+        },
+        ordinal: function (number) {
+            return '.';
+        },
+        currency: {
+            symbol: '€'
+        }
+    });
+};

package/numeral/src/locales/en-au.js

@@ -0,0 +1,24 @@
+export default function localeFactory(numeral) {
+    numeral.register('locale', 'en-au', {
+        delimiters: {
+            thousands: ',',
+            decimal: '.'
+        },
+        abbreviations: {
+            thousand: 'k',
+            million: 'm',
+            billion: 'b',
+            trillion: 't'
+        },
+        ordinal: function (number) {
+            var b = number % 10;
+            return (~~ (number % 100 / 10) === 1) ? 'th' :
+                (b === 1) ? 'st' :
+                (b === 2) ? 'nd' :
+                (b === 3) ? 'rd' : 'th';
+        },
+        currency: {
+            symbol: '$'
+        }
+    });
+};

package/numeral/src/locales/en-gb.js

@@ -0,0 +1,24 @@
+export default function localeFactory(numeral) {
+    numeral.register('locale', 'en-gb', {
+        delimiters: {
+            thousands: ',',
+            decimal: '.'
+        },
+        abbreviations: {
+            thousand: 'k',
+            million: 'm',
+            billion: 'b',
+            trillion: 't'
+        },
+        ordinal: function (number) {
+            var b = number % 10;
+            return (~~ (number % 100 / 10) === 1) ? 'th' :
+                (b === 1) ? 'st' :
+                (b === 2) ? 'nd' :
+                (b === 3) ? 'rd' : 'th';
+        },
+        currency: {
+            symbol: '£'
+        }
+    });
+};

package/numeral/src/locales/en-za.js

@@ -0,0 +1,24 @@
+export default function localeFactory(numeral) {
+    numeral.register('locale', 'en-za', {
+        delimiters: {
+            thousands: ' ',
+            decimal: ','
+        },
+        abbreviations: {
+            thousand: 'k',
+            million: 'm',
+            billion: 'b',
+            trillion: 't'
+        },
+        ordinal: function (number) {
+            var b = number % 10;
+            return (~~ (number % 100 / 10) === 1) ? 'th' :
+                (b === 1) ? 'st' :
+                    (b === 2) ? 'nd' :
+                        (b === 3) ? 'rd' : 'th';
+        },
+        currency: {
+            symbol: 'R'
+        }
+    });
+};

package/numeral/src/locales/es-es.js

@@ -0,0 +1,25 @@
+export default function localeFactory(numeral) {
+    numeral.register('locale', 'es-es', {
+        delimiters: {
+            thousands: '.',
+            decimal: ','
+        },
+        abbreviations: {
+            thousand: 'k',
+            million: 'mm',
+            billion: 'b',
+            trillion: 't'
+        },
+        ordinal: function (number) {
+            var b = number % 10;
+            return (b === 1 || b === 3) ? 'er' :
+                (b === 2) ? 'do' :
+                    (b === 7 || b === 0) ? 'mo' :
+                        (b === 8) ? 'vo' :
+                            (b === 9) ? 'no' : 'to';
+        },
+        currency: {
+            symbol: '€'
+        }
+    });
+};

package/numeral/src/locales/es.js

@@ -0,0 +1,25 @@
+export default function localeFactory(numeral) {
+    numeral.register('locale', 'es', {
+        delimiters: {
+            thousands: '.',
+            decimal: ','
+        },
+        abbreviations: {
+            thousand: 'k',
+            million: 'mm',
+            billion: 'b',
+            trillion: 't'
+        },
+        ordinal: function (number) {
+            var b = number % 10;
+            return (b === 1 || b === 3) ? 'er' :
+                (b === 2) ? 'do' :
+                (b === 7 || b === 0) ? 'mo' :
+		(b === 8) ? 'vo' :
+		(b === 9) ? 'no' : 'to';
+        },
+        currency: {
+            symbol: '$'
+        }
+    });
+};