anymany API reference

anymany is a list formatter built entirely on the native Intl browser API. One function, one options object. Sorted right, joined right, in any locale. Stable since 1.0 — the public API follows semver.

The browser already knows how to join and collate lists in 200+ languages. anymany just makes that API pleasant to use.

import { anymany } from 'anymany'

anymany(['banana', 'apple', 'cherry'])
// "banana, apple, and cherry"

anymany(['S', 'M', 'L'], { type: 'disjunction' })
// "S, M, or L"

anymany(['x', 'y', 'z', 'a', 'b', 'c', 'd'], { max: 3 })
// "x, y, z, and +4"

npm install anymany
# or
pnpm add anymany
# or
yarn add anymany

Or take the whole family at once with npm install anyfamily.

The single entry point. Pass the items — an array, a Set, any iterable — and optionally options. Non-string items are coerced via String(). An empty array returns ""; a single item is returned as-is.

anymany(items)
anymany(items, options?)

anymany(['read', 'write'])
// "read and write"

anymany(['a', 'b', 'c'], { style: 'short' })
// "a, b, & c"

anymany(['4 kg', '2 m'], { type: 'unit' })
// "4 kg, 2 m"

anymany(['cherry', 'apple', 'Banana'], { sort: true })
// "apple, Banana, and cherry"

2.0 removed the separate anymanyParts— they are the same functions and values, reached through the one name the package exports.

- import { anymany, anymanyParts } from 'anymany'
+ import { anymany } from 'anymany'

- anymanyParts(items)
+ anymany.parts(items)

Arguments, return values and throwing behaviour are unchanged, and nothing else in the API moved. Every any* package follows this shape from 2.0 on: the bare call does the job, everything else hangs off the same name.

Same arguments as anymany(), but returns the output as { type, value } parts instead of a string — style the items apart from the separators, or rebuild the output your own way.

import { anymany } from 'anymany'

anymany.parts(['a', 'b'])
// [
//   { type: 'element', value: 'a' },
//   { type: 'literal', value: ' and ' },
//   { type: 'element', value: 'b' },
// ]

// React: bold the items
anymany.parts(tags).map((p, i) =>
  p.type === 'element' ? <b key={i}>{p.value}</b> : p.value,
)

sort runs the items through Intl.Collator before joining — real language-aware collation, not code-point order. The input array is never mutated.

anymany(['cherry', 'apple', 'Banana'], { sort: true })
// "apple, Banana, and cherry"   ← plain .sort() puts "Banana" first

anymany(['file10', 'file2'], { sort: 'numeric' })
// "file2 and file10"            ← numbers compared by value

anymany(['a', 'A'], { sort: { caseFirst: 'upper' } })
// "A and a"                     ← any Intl.CollatorOptions

max caps the visible items; the rest collapse into a trailing "+N" counter. Digits come from Intl.NumberFormat, so they localize — no words, locale-safe.

anymany(['x', 'y', 'z', 'a', 'b', 'c', 'd'], { max: 3 })
// "x, y, z, and +4"

anymany(['x', 'y', 'z', 'a', 'b'], { max: 3, overflow: (n) => `${n} more` })
// "x, y, z, and 2 more"

The overflow item is just another list element, so the default typeplaces an "and" before it. That is intentional — no hidden joiner magic. Prefer a plain comma list? Combine max with type: 'unit'.

Every one of these is a line people write by hand, and each is wrong somewhere.

Copy, paste, move on.

// Tag list
anymany(post.tags, { locale: 'en' })
// "design, typography, and color"

// Sizes / options — "or" instead of "and"
anymany(product.sizes, { type: 'disjunction' })
// "S, M, or L"

// Plain comma list, no joiner word
anymany(['4 kg', '2 m'], { type: 'unit' })
// "4 kg, 2 m"

// Alphabetical the way the language actually orders letters
anymany(names, { sort: true, locale: 'de' })
// "Apfel, Öl und Zebra"

// Filenames with numbers, ordered by value
anymany(files, { sort: 'numeric' })
// "file2 and file10"

// Cap a long list
anymany(participants, { max: 3 })
// "Ann, Bob, Cy, and +4"

// …with your own overflow wording
anymany(participants, { max: 3, overflow: (n) => `${n} more` })
// "Ann, Bob, Cy, and 2 more" 

anymany is pure and synchronous, so it works in a component as-is. Whatanyfamily-react adds is a shared locale: set it once onAnyfamilyProvider and every hook below picks it up, so you do not thread locale through every call.

import { AnyfamilyProvider, useAnymany } from 'anyfamily-react'

function Tags({ tags }: { tags: string[] }) {
  return <p>{useAnymany(tags, { sort: true, max: 5 })}</p>
}

<AnyfamilyProvider locale="en">
  <Tags tags={post.tags} />
</AnyfamilyProvider>

Same calls in a few languages — no extra setup, no locale files.

anymany(['a', 'b', 'c'], { locale: 'en' })   // "a, b, and c"
anymany(['a', 'b', 'c'], { locale: 'ru' })   // "a, b и c"
anymany(['a', 'b', 'c'], { locale: 'de' })   // "a, b und c"
anymany(['a', 'b', 'c'], { locale: 'ja' })   // "a、b、c"

anymany(['a', 'b', 'c'], { type: 'disjunction', locale: 'ru' })
// "a, b или c"

anymany(['Öl', 'Zebra', 'Apfel'], { sort: true, locale: 'de' })
// "Apfel, Öl und Zebra"   ← Ö sorts after A, not after Z

anymany(['файл10', 'файл2'], { sort: 'numeric', locale: 'ru' })
// "файл2 и файл10"

anymany(['a', 'b', 'c', 'd', 'e', 'f', 'g'], { max: 3, locale: 'ar-EG' })
// "a وb وc و+٤"           ← localized overflow digits

Pass any valid BCP 47 language tag — including regional variants like en-GB, zh-TW, or pt-BR. Locale is optional; when omitted, native Intl uses the runtime locale. Fallback arrays like ['sr-Latn-RS', 'en'] also work.

anymany is pure — same input, same output, no clocks, no randomness, no DOM. Server and client render identically as long as the locale is passed explicitly (the runtime locale may differ between server and browser).

import { anymany } from 'anymany'

export function TagList({ tags }: { tags: string[] }) {
  return <p>{anymany(tags, { locale: 'en', sort: true, max: 5 })}</p>
}

What you would otherwise reach for, and what changes if you do.

The honest comparison for anymany is the native API rather than a library, because there is barely a library to compare against. At 0.7kb gzipped it adds the sorting, the overflow and the fallback chain around Intl.ListFormat, and saves you constructing a formatter per call.

anymany uses Intl.ListFormat, Intl.Collator, and Intl.NumberFormat — all widely supported.

A few things worth knowing before you ship: