@signpostmarv/ts-assert 0.1.0--beta → 0.1.0

package/.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: [SignpostMarv]
+ko_fi: signpostmarv

package/.github/workflows/ci.yml

@@ -0,0 +1,25 @@
+name: CI
+on:
+    push:
+    pull_request:
+        branches: [main]
+
+jobs:
+    basic-checks:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v4
+            - uses: actions/setup-node@v4
+              with:
+                  node-version: 21.x
+                  cache: 'npm'
+            - run: npm ci
+            - run: make lint
+            - name: Generate coverage
+              run: ./node_modules/.bin/c8 --config=./.c8rc.coveralls.json npm test
+              env:
+                  NODE_OPTIONS: '--enable-source-maps --no-warnings=ExperimentalWarning --loader ts-node/esm'
+            - name: Coveralls GitHub Action
+              uses: coverallsapp/github-action@v2.2.3
+              with:
+                  file: './coverage/lcov.info'

package/README.md

@@ -1,3 +1,6 @@
+[![Coverage Status](https://coveralls.io/repos/github/SignpostMarv/ts-assert/badge.svg?branch=main)](https://coveralls.io/github/SignpostMarv/ts-assert?branch=main)
+[![Workflow Status](https://github.com/SignpostMarv/ts-assert/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/SignpostMarv/ts-assert/actions/workflows/ci.yml?query=branch%3Amain)
+
 # @signpostmarv/ts-assert
 
 Code-generated assertions for TypeScript type guarding functions.
@@ -6,18 +9,73 @@ Code-generated assertions for TypeScript type guarding functions.
 
 ```ts
 import {describe, it} from 'node:test';
+import assert from 'node:assert/strict';
 import ts_assert from '@signpostmarv/ts-assert';
 import ts from 'typescript';
 
-void describe('example', () => {
-	void it('replaces this', () => {
-		assert.equal(
-			ts.isEmptyBindingPattern(ts.factory.createIdentifier('foo')),
-			true
+void describe('isIdentifier', () => {
+	void it('throws', () => {
+		assert.throws(() =>
+			ts_assert.isIdentifier(ts.factory.createStringLiteral('foo'))
+		);
+	});
+});
+
+void describe('isEmptyBindingPattern', () => {
+	void it('throws', () => {
+		assert.throws(() =>
+			ts_assert.isEmptyBindingPattern(ts.factory.createIdentifier('foo'))
+		);
+	});
+});
+
+void describe('isBooleanLiteral', () => {
+	void it('throws', () => {
+		assert.throws(() =>
+			ts_assert.isBooleanLiteral(
+				ts.factory.createStringLiteral('foo'),
+				true
+			)
+		);
+		assert.throws(() =>
+			ts_assert.isBooleanLiteral(ts.factory.createFalse(), true)
+		);
+		assert.throws(() =>
+			ts_assert.isBooleanLiteral(ts.factory.createTrue(), false)
+		);
+	});
+	void it('does not throw', () => {
+		assert.doesNotThrow(() =>
+			ts_assert.isBooleanLiteral(ts.factory.createTrue(), true)
+		);
+		assert.doesNotThrow(() =>
+			ts_assert.isBooleanLiteral(ts.factory.createFalse(), false)
+		);
+	});
+});
+
+void describe('isTokenWithExpectedKind', () => {
+	void it('throws', () => {
+		assert.throws(() =>
+			ts_assert.isTokenWithExpectedKind(
+				ts.factory.createStringLiteral('foo'),
+				ts.SyntaxKind.StringKeyword
+			)
+		);
+		assert.throws(() =>
+			ts_assert.isTokenWithExpectedKind(
+				ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+				ts.SyntaxKind.NumberKeyword
+			)
 		);
 	});
-	void it('with this', () => {
-		ts_assert.isEmptyBindingPattern(ts.factory.createIdentifier('foo'));
+	void it('does not throw', () => {
+		assert.doesNotThrow(() =>
+			ts_assert.isTokenWithExpectedKind(
+				ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+				ts.SyntaxKind.StringKeyword
+			)
+		);
 	});
 });
 ```