Security News
The Unpaid Backbone of Open Source: Solo Maintainers Face Increasing Security Demands
Solo open source maintainers face burnout and security challenges, with 60% unpaid and 60% considering quitting.
make-plural
Advanced tools
The make-plural npm package is a utility for handling pluralization rules in various languages. It allows developers to determine the correct plural form of a word based on a given number, which is particularly useful for internationalization (i18n) and localization (l10n) tasks.
Determine Plural Form
This feature allows you to determine the plural form of a word in a specified language based on a given number. In this example, the plural form for English ('en') is determined for the numbers 1 and 2.
const makePlural = require('make-plural');
const plural = makePlural('en');
console.log(plural(1)); // 'one'
console.log(plural(2)); // 'other'
Support for Multiple Languages
This feature demonstrates the package's support for multiple languages. It shows how to determine the plural form for both English and French.
const makePlural = require('make-plural');
const pluralEn = makePlural('en');
const pluralFr = makePlural('fr');
console.log(pluralEn(1)); // 'one'
console.log(pluralEn(2)); // 'other'
console.log(pluralFr(1)); // 'one'
console.log(pluralFr(2)); // 'other'
Custom Plural Rules
This feature allows you to define custom pluralization rules. In this example, custom rules are provided to determine the plural form.
const makePlural = require('make-plural');
const customRules = {
one: 'n == 1',
other: 'true'
};
const pluralCustom = makePlural(customRules);
console.log(pluralCustom(1)); // 'one'
console.log(pluralCustom(2)); // 'other'
The pluralize package provides simple pluralization and singularization of English words. It is less comprehensive than make-plural as it primarily focuses on English and does not support custom rules or multiple languages.
i18next is a powerful internationalization framework that supports pluralization among many other features. It is more comprehensive than make-plural, offering a full suite of i18n tools, but it may be overkill if you only need pluralization.
The messageformat package provides support for handling complex message formatting, including pluralization, gender, and other language-specific rules. It is more feature-rich compared to make-plural, but also more complex to use.
Make-plural is a JavaScript module that translates Unicode CLDR pluralization rules to JavaScript functions.
It's written in ECMAScript 6 and transpiled using Babel to CommonJS, AMD and ES6 module formats, as well as being suitable for use in browser environments.
npm install make-plural
or
bower install make-plural
or
git clone https://github.com/eemeli/make-plural.js.git
cd make-plural.js
npm install
make all
> MakePlural = require('make-plural')
{ [Function: MakePlural]
cardinals: true,
ordinals: false,
rules: { data: {}, rootPath: './data/' } }
> sk = new MakePlural('sk')
{ [Function]
obj:
{ lc: 'sk',
cardinals: true,
ordinals: false,
parser: { v0: 1, i: 1 },
tests: { obj: [Circular], ordinal: {}, cardinal: [Object] },
fn: [Circular] },
test: [Function],
toString: [Function] }
> sk(1)
'one'
> sk(3.0)
'few'
> sk('1.0')
'many'
> sk('0')
'other'
> console.log(sk.toString())
function(n) {
var s = String(n).split('.'), i = s[0], v0 = !s[1];
return (i == 1 && v0 ) ? 'one'
: ((i >= 2 && i <= 4) && v0 ) ? 'few'
: (!v0 ) ? 'many'
: 'other';
}
> en = new MakePlural('en', {ordinals:1})
{ [Function]
obj:
{ lc: 'en',
cardinals: true,
ordinals: 1,
parser: { n: 1, n10: 1, n100: 1, v0: 1 },
tests: { obj: [Circular], ordinal: [Object], cardinal: [Object] },
fn: [Circular] },
test: [Function],
toString: [Function] }
> en(2)
'other'
> en(2, true)
'two'
> console.log(en.toString())
function(n, ord) {
var s = String(n).split('.'), v0 = !s[1], t0 = Number(s[0]) == n,
n10 = t0 && s[0].slice(-1), n100 = t0 && s[0].slice(-2);
if (ord) return (n10 == 1 && n100 != 11) ? 'one'
: (n10 == 2 && n100 != 12) ? 'two'
: (n10 == 3 && n100 != 13) ? 'few'
: 'other';
return (n == 1 && v0) ? 'one' : 'other';
}
<script src="path/to/make-plural.browser.js"></script>
<script>
var ru = new MakePlural('ru', {ordinals:1});
console.log('1: ' + ru(1) + ', 3.0: ' + ru(3.0) +
', "1.0": ' + ru('1.0') + ', "0": ' + ru('0'));
console.log(ru.toString());
</script>
With outputs:
1: one, 3.0: few, "1.0": other, "0": many
function(n, ord) {
var s = String(n).split('.'), i = s[0], v0 = !s[1], i10 = i.slice(-1),
i100 = i.slice(-2);
if (ord) return 'other';
return (v0 && i10 == 1 && i100 != 11) ? 'one'
: (v0 && (i10 >= 2 && i10 <= 4) && (i100 < 12
|| i100 > 14)) ? 'few'
: (v0 && i10 == 0 || v0 && (i10 >= 5 && i10 <= 9)
|| v0 && (i100 >= 11 && i100 <= 14)) ? 'many'
: 'other';
}
The browser versions of MakePlural (./make-plural.browser.js
and
./make-plural.min.js
) are compiled to include the default CLDR rules. If that
doesn't work for you, you should either modify src/browser.js
to fit your
needs, or remove the module.exports = ...
statement from ./make-plural.js
and use that, calling MakePlural.load(cldr)
with your custom data.
$ ./bin/make-plural
Locales verified ok:
af ak am ar asa ast az be bem bez bg bh bm bn bo br brx bs ca cgg chr ckb
cs cy da de dsb dv dz ee el en eo es et eu fa ff fi fil fo fr fur fy ga
gd gl gsw gu guw gv ha haw he hi hr hsb hu hy id ig ii in is it iu iw ja
jbo jgo ji jmc jv jw ka kab kaj kcg kde kea kk kkj kl km kn ko ks ksb ksh
ku kw ky lag lb lg lkt ln lo lt lv mas mg mgo mk ml mn mo mr ms mt my nah
naq nb nd ne nl nn nnh no nqo nr nso ny nyn om or os pa pap pl prg ps pt
pt-PT rm ro rof root ru rwk sah saq se seh ses sg sh shi si sk sl sma smi
smj smn sms sn so sq sr ss ssy st sv sw syr ta te teo th ti tig tk tl tn
to tr ts tzm ug uk ur uz ve vi vo vun wa wae wo xh xog yi yo zh zu
$ ./bin/make-plural fr
function fr(n, ord) {
if (ord) return (n == 1) ? 'one' : 'other';
return (n >= 0 && n < 2) ? 'one' : 'other';
}
$ ./bin/make-plural fr 1.5
one
Returns a function that takes an argument n
and returns its plural category
for the given locale lc
.
The returned function has an overloaded toString(name)
method that may be
used to generate a clean string representation of the function, with an
optional name name
.
The optional opt
parameter may contain the following boolean members:
cardinals
— if true, rules for cardinal values (1 day, 2 days, etc.) are
includedordinals
— if true, rules for ordinal values (1st, 2nd, etc.) are includedIf both opt.ordinals
and opt.cardinals
are true, the returned function takes
a second parameter ord
. Then, if ord
is true, the function will return the
ordinal rather than cardinal category applicable to n
in locale lc
.
If lc
or the opt
values are not set, the values are taken from
MakePlural.lc
(no default value), MakePlural.cardinals
(default true
) and
MakePlural.ordinals
(default false
).
Loads CLDR rules from one or more cldr
variables, each of which may be an
object or the path to a JSON file formatted like
this.
The stored rules are kept in MakePlural.rules.cardinal
and
MakePlural.rules.ordinal
, which may also be directly accessed.
If called within a context where request()
isn't available and cldr
is a
string, it's taken as the URL of the JSON file that'll be fetched and parsed
using a synchronous XMLHttpRequest
.
By default, MakePlural()
will call MakePlural.load(cldr)
when required,
using the rules included in data/
, plurals.json
and ordinals.json
.
Make-plural has no runtime dependencies. CLDR plural rule data is included in JSON format; make-plural supports the LDML Language Plural Rules as used in CLDR release 24 and later.
Using MakePlural.load()
, you may make use of external sources of CLDR data.
For example, the following works when using together with
cldr-data:
> cldr = require('cldr-data');
> MakePlural = require('make-plural').load(
cldr('supplemental/plurals'),
cldr('supplemental/ordinals')
);
> ar = new MakePlural('ar');
> ar(3.14);
'other'
FAQs
Unicode CLDR pluralization rules as JavaScript functions
The npm package make-plural receives a total of 1,120,743 weekly downloads. As such, make-plural popularity was classified as popular.
We found that make-plural demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Solo open source maintainers face burnout and security challenges, with 60% unpaid and 60% considering quitting.
Security News
License exceptions modify the terms of open source licenses, impacting how software can be used, modified, and distributed. Developers should be aware of the legal implications of these exceptions.
Security News
A developer is accusing Tencent of violating the GPL by modifying a Python utility and changing its license to BSD, highlighting the importance of copyleft compliance.