@battis/typescript-tricks 0.7.6 → 0.7.8

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [0.7.8](https://github.com/battis/typescript-config/compare/typescript-tricks/0.7.7...typescript-tricks/0.7.8) (2026-03-06)
+
+
+### Bug Fixes
+
+* improve typechecking ([af6a06e](https://github.com/battis/typescript-config/commit/af6a06ede72238bdc046dfed0dafcb33fc177fcc))
+
+## [0.7.7](https://github.com/battis/typescript-config/compare/typescript-tricks/0.7.6...typescript-tricks/0.7.7) (2026-02-10)
+
+
+### Features
+
+* isRecord<K,V>() ([fcc23b4](https://github.com/battis/typescript-config/commit/fcc23b49b0d0c2945d104f7dc88c1c902b582e0c))
+
 ## [0.7.6](https://github.com/battis/typescript-config/compare/typescript-tricks/0.7.5...typescript-tricks/0.7.6) (2026-01-04)
 
 

package/dist/Record.d.ts

@@ -0,0 +1 @@
+export declare function isRecord<K extends string | number | symbol, V>(obj: unknown, isK: (k: unknown) => k is K, isV: (v: unknown) => v is V): obj is Record<K, V>;

package/dist/Record.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRecord = isRecord;
+function isRecord(obj, isK, isV) {
+    return (typeof obj === 'object' &&
+        obj !== null &&
+        Object.keys(obj).reduce((result, key) => result && isK(key), true) &&
+        Object.keys(obj)
+            .map((key) => obj[key])
+            .reduce((result, value) => result && isV(value), true) &&
+        [
+            Function,
+            Boolean,
+            Error,
+            Number,
+            Date,
+            String,
+            RegExp,
+            Array,
+            Uint8Array,
+            Uint16Array,
+            Uint32Array,
+            Int16Array,
+            Int32Array,
+            Float32Array,
+            Float64Array,
+            Map,
+            Set,
+            WeakMap,
+            WeakSet,
+            ArrayBuffer,
+            DataView,
+            Promise,
+            DisposableStack,
+            AsyncDisposableStack
+        ].reduce((result, T) => result && !(obj instanceof T), true));
+}

package/dist/index.d.ts

@@ -9,5 +9,6 @@ export * from './Mixin';
 export * from './OneOf';
 export * from './OptionalProperty';
 export * from './PropertyRequirements';
+export * from './Record';
 export * from './Shorthand';
 export * from './StaticImplements';

package/dist/index.js

@@ -25,5 +25,6 @@ __exportStar(require("./Mixin"), exports);
 __exportStar(require("./OneOf"), exports);
 __exportStar(require("./OptionalProperty"), exports);
 __exportStar(require("./PropertyRequirements"), exports);
+__exportStar(require("./Record"), exports);
 __exportStar(require("./Shorthand"), exports);
 __exportStar(require("./StaticImplements"), exports);

package/jest.config.ts

@@ -0,0 +1,28 @@
+import type { Config } from 'jest';
+import { createDefaultEsmPreset } from 'ts-jest';
+
+const presetConfig = createDefaultEsmPreset({});
+
+export default {
+  ...presetConfig,
+  testEnvironment: 'node',
+  testMatch: [
+    '**/tests/**/*.test.ts',
+    '**/__tests__/**/*.test.ts',
+    '**/?(*.)+(spec|test).ts'
+  ],
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1'
+  },
+  testTimeout: 30000,
+  transform: {
+    '^.+\\.tsx?$': [
+      'ts-jest',
+      {
+        diagnostics: {
+          ignoreCodes: [151002]
+        }
+      }
+    ]
+  }
+} satisfies Config;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@battis/typescript-tricks",
-  "version": "0.7.6",
+  "version": "0.7.8",
   "description": "A handful of useful types and operators",
   "homepage": "https://github.com/battis/typescript-config/tree/main/packages/typescript-tricks#readme",
   "repository": {
@@ -17,9 +17,12 @@
   "types": "./dist/index.d.ts",
   "devDependencies": {
     "@tsconfig/recommended": "^1.0.13",
+    "@types/jest": "^30.0.0",
     "commit-and-tag-version": "^12.6.1",
     "del-cli": "^6.0.0",
+    "jest": "^30.2.0",
     "npm-run-all": "^4.1.5",
+    "ts-jest": "^29.4.6",
     "typescript": "^5.9.3"
   },
   "engines": {
@@ -29,8 +32,6 @@
     "build": "run-s build:*",
     "build:clean": "del ./dist/*",
     "build:compile": "tsc",
-    "release": "run-s release:*",
-    "release:build": "run-s build",
-    "release:commit": "commit-and-tag-version"
+    "version": "commit-and-tag-version"
   }
 }

package/tests/JSONValue/JSONPrimitive.test.ts

@@ -0,0 +1,25 @@
+import { JSONPrimitive } from '../../src/JSONValue.js';
+
+export function isJSONPrimitive(obj: unknown): obj is JSONPrimitive {
+  return (
+    obj === null ||
+    typeof obj === 'number' ||
+    typeof obj === 'string' ||
+    typeof obj === 'string'
+  );
+}
+
+test('truthy', () => {
+  expect(isJSONPrimitive(null)).toBeTruthy();
+  expect(isJSONPrimitive(123)).toBeTruthy();
+  expect(isJSONPrimitive(3.14159)).toBeTruthy();
+  expect(isJSONPrimitive('foo bar')).toBeTruthy();
+  expect(isJSONPrimitive(`interpolate ${new Date()}`)).toBeTruthy();
+});
+
+test('falsy', () => {
+  expect(isJSONPrimitive(undefined)).toBeFalsy();
+  expect(isJSONPrimitive([1, 2, 3])).toBeFalsy();
+  expect(isJSONPrimitive({ foo: 'bar' })).toBeFalsy();
+  expect(isJSONPrimitive(new Date())).toBeFalsy();
+});

package/tests/Record/isRecord.test.ts

@@ -0,0 +1,56 @@
+import { JSONPrimitive } from '../../src/JSONValue.js';
+import { isRecord } from '../../src/Record.js';
+import { isJSONPrimitive } from '../JSONValue/JSONPrimitive.test.js';
+
+function isKey(obj: unknown): obj is keyof object {
+  return (
+    typeof obj === 'string' ||
+    typeof obj === 'number' ||
+    typeof obj === 'symbol'
+  );
+}
+
+function isUnknown(obj: unknown): obj is unknown {
+  return true;
+}
+
+function isString(obj: unknown): obj is string {
+  return typeof obj === 'string';
+}
+
+test('Record<string,string>', () => {
+  expect(
+    isRecord<string, string>({ foo: 'bar' }, isString, isString)
+  ).toBeTruthy();
+  expect(
+    isRecord<string, string>({ foo: 123 }, isString, isString)
+  ).toBeFalsy();
+  expect(isRecord<string, string>(new Date(), isString, isString)).toBeFalsy();
+});
+
+test('Record<string,JSONPrimitive>', () => {
+  expect(
+    isRecord<string, JSONPrimitive>({ foo: 'bar' }, isString, isJSONPrimitive)
+  ).toBeTruthy();
+});
+
+test('built-in objects', () => {
+  expect(
+    isRecord<keyof object, unknown>(new String('foo bar'), isKey, isUnknown)
+  ).toBeFalsy();
+  expect(
+    isRecord<keyof object, unknown>(new Number(123), isKey, isUnknown)
+  ).toBeFalsy();
+  expect(
+    isRecord<keyof object, unknown>(Math.PI, isKey, isUnknown)
+  ).toBeFalsy();
+  expect(
+    isRecord<keyof object, unknown>(new Uint8Array(0), isKey, isUnknown)
+  ).toBeFalsy();
+  expect(
+    isRecord<keyof object, unknown>(new Map(), isKey, isUnknown)
+  ).toBeFalsy();
+  expect(
+    isRecord<keyof object, unknown>(new Date(), isKey, isUnknown)
+  ).toBeFalsy();
+});