.github/FUNDING.yml

@@ -0,0 +1 @@
+github: lukeed

.github/workflows/ci.yml

@@ -8,10 +8,10 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        nodejs: [6, 8, 10, 12]
+        nodejs: [8, 10, 12, 14, 16]
     steps:
-    - uses: actions/checkout@v1
-    - uses: actions/setup-node@v1
+    - uses: actions/checkout@v2
+    - uses: actions/setup-node@v2
       with:
         node-version: ${{ matrix.nodejs }}
 
@@ -25,19 +25,22 @@ jobs:
       run: npm install
 
     - name: (coverage) Install
-      if: matrix.nodejs >= 12
+      if: matrix.nodejs >= 16
       run: npm install -g nyc
 
+    - name: Build
+      run: npm run build
+
     - name: Test
       run: npm test
-      if: matrix.nodejs < 12
+      if: matrix.nodejs < 16
 
     - name: (coverage) Test
       run: nyc --include=src npm test
-      if: matrix.nodejs >= 12
+      if: matrix.nodejs >= 16
 
     - name: (coverage) Report
-      if: matrix.nodejs >= 12
+      if: matrix.nodejs >= 16
       run: |
         nyc report --reporter=text-lcov > coverage.lcov
         bash <(curl -s https://codecov.io/bash)

bin/index.js

@@ -0,0 +1,38 @@
+// @ts-check
+const fs = require('fs');
+const zlib = require('zlib');
+const { minify } = require('terser');
+const pkg = require('../package.json');
+
+if (!fs.existsSync('dist')) fs.mkdirSync('dist');
+
+/**
+ * @param {string} file
+ * @param {string} source
+ */
+function write(file, source) {
+	let isModule = !source.startsWith('!function');
+	let result = minify(source, {
+		module: isModule,
+		compress: true,
+	});
+
+	fs.writeFileSync(file, result.code);
+	console.log('~> "%s" (%d b)', file, zlib.gzipSync(result.code).byteLength);
+}
+
+let input = fs.readFileSync('src/index.js', 'utf8');
+
+// copy for ESM
+write(pkg.module, input);
+
+// transform ESM -> CJS exports
+write(pkg.main, input.replace('export function', 'function').replace(
+	'export default clsx;',
+	'module.exports = clsx;\n'
+	+ 'module.exports.clsx = clsx;'
+));
+
+// transform ESM -> UMD exports
+input = input.replace('export function', 'function').replace('export default clsx;', 'return clsx.clsx=clsx, clsx;');
+write(pkg.unpkg, '!function(global,factory){"object"==typeof exports&&"undefined"!=typeof module?module.exports=factory():"function"==typeof define&&define.amd?define(factory):global.clsx=factory()}(this,function(){' + input + '});');

clsx.d.ts

@@ -1,11 +1,6 @@
 export type ClassValue = ClassArray | ClassDictionary | string | number | null | boolean | undefined;
+export type ClassDictionary = Record<string, any>;
+export type ClassArray = ClassValue[];
 
-export interface ClassDictionary {
-	[id: string]: any;
-}
-
-export interface ClassArray extends Array<ClassValue> { }
-
-declare const clsx: (...classes: ClassValue[]) => string;
-
+export declare function clsx(...inputs: ClassValue[]): string;
 export default clsx;

package.json

@@ -1,6 +1,6 @@
 {
   "name": "clsx",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "repository": "lukeed/clsx",
   "description": "A tiny (228B) utility for constructing className strings conditionally.",
   "module": "dist/clsx.m.js",
@@ -17,9 +17,8 @@
     "node": ">=6"
   },
   "scripts": {
-    "build": "bundt",
-    "pretest": "npm run build",
-    "test": "tape -r esm test/*.js | tap-spec"
+    "build": "node bin",
+    "test": "uvu -r esm test"
   },
   "files": [
     "*.d.ts",
@@ -31,9 +30,8 @@
     "classnames"
   ],
   "devDependencies": {
-    "bundt": "1.0.1",
     "esm": "3.2.25",
-    "tap-spec": "5.0.0",
-    "tape": "4.9.1"
+    "terser": "4.8.0",
+    "uvu": "0.5.4"
   }
 }

readme.md

@@ -20,6 +20,8 @@ $ npm install --save clsx
 
 ```js
 import clsx from 'clsx';
+// or
+import { clsx } from 'clsx';
 
 // Strings (variadic)
 clsx('foo', true && 'bar', 'baz');

src/index.js

@@ -26,7 +26,7 @@ function toVal(mix) {
 	return str;
 }
 
-export default function () {
+export function clsx() {
 	var i=0, tmp, x, str='';
 	while (i < arguments.length) {
 		if (tmp = arguments[i++]) {
@@ -38,3 +38,5 @@ export default function () {
 	}
 	return str;
 }
+
+export default clsx;

test/classnames.js

@@ -2,84 +2,71 @@
  * Ported from `classnames` for compatibility checks.
  */
 
-import test from 'tape';
-import fn from '../src';
+import { test } from 'uvu';
+import * as assert from 'uvu/assert';
+import clsx from '../src';
 
-test('(compat) keeps object keys with truthy values', t => {
-	const out = fn({ a:true, b:false, c:0, d:null, e:undefined, f:1 });
-	t.is(out, 'a f');
-	t.end();
+test('(compat) keeps object keys with truthy values', () => {
+	const out = clsx({ a:true, b:false, c:0, d:null, e:undefined, f:1 });
+	assert.is(out, 'a f');
 });
 
-test('(compat) joins arrays of class names and ignore falsy values', t => {
-	const out = fn('a', 0, null, undefined, true, 1, 'b');
-	t.is(out, 'a 1 b');
-	t.end();
+test('(compat) joins arrays of class names and ignore falsy values', () => {
+	const out = clsx('a', 0, null, undefined, true, 1, 'b');
+	assert.is(out, 'a 1 b');
 });
 
-test('(compat) supports heterogenous arguments', t => {
-	t.is(fn({ a:true }, 'b', 0), 'a b');
-	t.end();
+test('(compat) supports heterogenous arguments', () => {
+	assert.is(clsx({ a:true }, 'b', 0), 'a b');
 });
 
-test('(compat) should be trimmed', t => {
-	t.is(fn('', 'b', {}, ''), 'b');
-	t.end();
+test('(compat) should be trimmed', () => {
+	assert.is(clsx('', 'b', {}, ''), 'b');
 });
 
-test('(compat) returns an empty string for an empty configuration', t => {
-	t.is(fn({}), '');
-	t.end();
+test('(compat) returns an empty string for an empty configuration', () => {
+	assert.is(clsx({}), '');
 });
 
-test('(compat) supports an array of class names', t => {
-	t.is(fn(['a', 'b']), 'a b');
-	t.end();
+test('(compat) supports an array of class names', () => {
+	assert.is(clsx(['a', 'b']), 'a b');
 });
 
-test('(compat) joins array arguments with string arguments', t => {
-	t.is(fn(['a', 'b'], 'c'), 'a b c');
-	t.is(fn('c', ['a', 'b']), 'c a b');
-	t.end();
+test('(compat) joins array arguments with string arguments', () => {
+	assert.is(clsx(['a', 'b'], 'c'), 'a b c');
+	assert.is(clsx('c', ['a', 'b']), 'c a b');
 });
 
-test('(compat) handles multiple array arguments', t => {
-	t.is(fn(['a', 'b'], ['c', 'd']), 'a b c d');
-	t.end();
+test('(compat) handles multiple array arguments', () => {
+	assert.is(clsx(['a', 'b'], ['c', 'd']), 'a b c d');
 });
 
-test('(compat) handles arrays that include falsy and true values', t => {
-	t.is(fn(['a', 0, null, undefined, false, true, 'b']), 'a b');
-	t.end();
+test('(compat) handles arrays that include falsy and true values', () => {
+	assert.is(clsx(['a', 0, null, undefined, false, true, 'b']), 'a b');
 });
 
-test('(compat) handles arrays that include arrays', t => {
-	t.is(fn(['a', ['b', 'c']]), 'a b c');
-	t.end();
+test('(compat) handles arrays that include arrays', () => {
+	assert.is(clsx(['a', ['b', 'c']]), 'a b c');
 });
 
-test('(compat) handles arrays that include objects', t => {
-	t.is(fn(['a', { b:true, c:false }]), 'a b');
-	t.end();
+test('(compat) handles arrays that include objects', () => {
+	assert.is(clsx(['a', { b:true, c:false }]), 'a b');
 });
 
-test('(compat) handles deep array recursion', t => {
-	t.is(fn(['a', ['b', ['c', { d:true }]]]), 'a b c d');
-	t.end();
+test('(compat) handles deep array recursion', () => {
+	assert.is(clsx(['a', ['b', ['c', { d:true }]]]), 'a b c d');
 });
 
-test('(compat) handles arrays that are empty', t => {
-	t.is(fn('a', []), 'a');
-	t.end();
+test('(compat) handles arrays that are empty', () => {
+	assert.is(clsx('a', []), 'a');
 });
 
-test('(compat) handles nested arrays that have empty nested arrays', t => {
-	t.is(fn('a', [[]]), 'a');
-	t.end();
+test('(compat) handles nested arrays that have empty nested arrays', () => {
+	assert.is(clsx('a', [[]]), 'a');
 });
 
-test('(compat) handles all types of truthy and falsy property values as expected', t => {
-	const out = fn({
+test('(compat) handles all types of truthy and falsy property values as expected', () => {
+	const out = clsx({
 		// falsy:
 		null: null,
 		emptyString: '',
@@ -100,6 +87,7 @@ test('(compat) handles all types of truthy and falsy property values as expected
 		greaterZero: 1
 	});
 
-	t.is(out, 'nonEmptyString whitespace function emptyObject nonEmptyObject emptyList nonEmptyList greaterZero');
-	t.end();
+	assert.is(out, 'nonEmptyString whitespace function emptyObject nonEmptyObject emptyList nonEmptyList greaterZero');
 });
+
+test.run();