ts-data-forge 3.2.0 → 3.3.0

package/README.md

@@ -132,7 +132,7 @@ Here are some examples of how to use utilities from `ts-data-forge`:
 
 The `expectType` utility allows you to make assertions about types at compile time. This is useful for ensuring type correctness in complex type manipulations or when refactoring.
 
-```typescript
+```tsx
 import { expectType } from 'ts-data-forge';
 
 type User = { id: number; name: string };
@@ -158,7 +158,7 @@ expectType<User, any>('!='); // Error: Comparisons with `any` are also strictly
 
 Handle nullable values and error-prone operations safely.
 
-```typescript
+```tsx
 import { match, Optional, pipe, Result } from 'ts-data-forge';
 
 // Optional for nullable values
@@ -212,7 +212,7 @@ assert(processResult(Result.err('Failed')) === 'Error: Failed');
 
 The `Num` object provides safe and convenient functions for numerical operations.
 
-```typescript
+```tsx
 import { Num } from 'ts-data-forge';
 
 // Basic conversions
@@ -252,7 +252,7 @@ if (Num.isNonZero(value)) {
 
 `ts-data-forge` provides branded number types that enforce specific constraints at the type level.
 
-```typescript
+```tsx
 import {
     asFiniteNumber,
     asInt,
@@ -314,7 +314,7 @@ assert(randomInt16 <= 32767);
 
 The `Arr` object provides a rich set of functions for array manipulation.
 
-```typescript
+```tsx
 import { Arr, expectType, Optional } from 'ts-data-forge';
 
 const numbers: readonly number[] = [1, 2, 3, 4, 5, 2, 3];
@@ -369,7 +369,7 @@ if (Optional.isSome(oldestPerson)) {
 
 Type-safe, immutable data structures.
 
-```typescript
+```tsx
 import { Arr, IMap, ISet, Optional } from 'ts-data-forge';
 
 // IMap usage - immutable operations
@@ -415,7 +415,7 @@ assert(setWithItems.size === 2);
 
 Safe type narrowing with comprehensive type guards.
 
-```typescript
+```tsx
 import { hasKey, isNonNullObject, isRecord } from 'ts-data-forge';
 
 const processData = (data: unknown): string | undefined => {
@@ -448,7 +448,7 @@ assert(processData('not an object') === undefined);
 
 Generate ranges for iteration and array creation.
 
-```typescript
+```tsx
 import { range } from 'ts-data-forge';
 
 // Traditional for loop using range

package/dist/entry-point.d.mts

@@ -0,0 +1,2 @@
+export * from './index.mjs';
+//# sourceMappingURL=entry-point.d.mts.map

package/dist/entry-point.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-point.d.mts","sourceRoot":"","sources":["../src/entry-point.mts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/dist/entry-point.mjs

@@ -0,0 +1,61 @@
+export { Arr } from './array/array-utils.mjs';
+export { IMapMapped } from './collections/imap-mapped.mjs';
+export { IMap } from './collections/imap.mjs';
+export { ISetMapped } from './collections/iset-mapped.mjs';
+export { ISet } from './collections/iset.mjs';
+export { createQueue } from './collections/queue.mjs';
+export { createStack } from './collections/stack.mjs';
+export { expectType } from './expect-type.mjs';
+export { match } from './functional/match.mjs';
+export { Optional } from './functional/optional.mjs';
+export { pipe } from './functional/pipe.mjs';
+export { Result } from './functional/result.mjs';
+export { hasKey } from './guard/has-key.mjs';
+export { isNonEmptyString } from './guard/is-non-empty-string.mjs';
+export { isNonNullObject } from './guard/is-non-null-object.mjs';
+export { isPrimitive } from './guard/is-primitive.mjs';
+export { isRecord } from './guard/is-record.mjs';
+export { isBigint, isBoolean, isNonNullish, isNotBigint, isNotBoolean, isNotNull, isNotNumber, isNotString, isNotSymbol, isNotUndefined, isNull, isNullish, isNumber, isString, isSymbol, isUndefined } from './guard/is-type.mjs';
+export { keyIsIn } from './guard/key-is-in.mjs';
+export { range } from './iterator/range.mjs';
+export { Json } from './json/json.mjs';
+export { FiniteNumber, asFiniteNumber, isFiniteNumber } from './number/branded-types/finite-number.mjs';
+export { Int, asInt, isInt } from './number/branded-types/int.mjs';
+export { Int16, asInt16, isInt16 } from './number/branded-types/int16.mjs';
+export { Int32, asInt32, isInt32 } from './number/branded-types/int32.mjs';
+export { NonNegativeFiniteNumber, asNonNegativeFiniteNumber, isNonNegativeFiniteNumber } from './number/branded-types/non-negative-finite-number.mjs';
+export { NonNegativeInt16, asNonNegativeInt16, isNonNegativeInt16 } from './number/branded-types/non-negative-int16.mjs';
+export { NonNegativeInt32, asNonNegativeInt32, isNonNegativeInt32 } from './number/branded-types/non-negative-int32.mjs';
+export { NonZeroFiniteNumber, asNonZeroFiniteNumber, isNonZeroFiniteNumber } from './number/branded-types/non-zero-finite-number.mjs';
+export { NonZeroInt, asNonZeroInt, isNonZeroInt } from './number/branded-types/non-zero-int.mjs';
+export { NonZeroInt16, asNonZeroInt16, isNonZeroInt16 } from './number/branded-types/non-zero-int16.mjs';
+export { NonZeroInt32, asNonZeroInt32, isNonZeroInt32 } from './number/branded-types/non-zero-int32.mjs';
+export { NonZeroSafeInt, asNonZeroSafeInt, isNonZeroSafeInt } from './number/branded-types/non-zero-safe-int.mjs';
+export { NonZeroUint16, asNonZeroUint16, isNonZeroUint16 } from './number/branded-types/non-zero-uint16.mjs';
+export { NonZeroUint32, asNonZeroUint32, isNonZeroUint32 } from './number/branded-types/non-zero-uint32.mjs';
+export { PositiveFiniteNumber, asPositiveFiniteNumber, isPositiveFiniteNumber } from './number/branded-types/positive-finite-number.mjs';
+export { PositiveInt, asPositiveInt, isPositiveInt } from './number/branded-types/positive-int.mjs';
+export { PositiveInt16, asPositiveInt16, isPositiveInt16 } from './number/branded-types/positive-int16.mjs';
+export { PositiveInt32, asPositiveInt32, isPositiveInt32 } from './number/branded-types/positive-int32.mjs';
+export { PositiveSafeInt, asPositiveSafeInt, isPositiveSafeInt } from './number/branded-types/positive-safe-int.mjs';
+export { PositiveUint16, asPositiveUint16, isPositiveUint16 } from './number/branded-types/positive-uint16.mjs';
+export { PositiveUint32, asPositiveUint32, isPositiveUint32 } from './number/branded-types/positive-uint32.mjs';
+export { SafeInt, asSafeInt, isSafeInt } from './number/branded-types/safe-int.mjs';
+export { SafeUint, asSafeUint, isSafeUint } from './number/branded-types/safe-uint.mjs';
+export { Uint, asUint, isUint } from './number/branded-types/uint.mjs';
+export { Uint16, asUint16, isUint16 } from './number/branded-types/uint16.mjs';
+export { Uint32, asUint32, isUint32 } from './number/branded-types/uint32.mjs';
+export { Int8, asInt8, isInt8 } from './number/enum/int8.mjs';
+export { Uint8, asUint8, isUint8 } from './number/enum/uint8.mjs';
+export { Num } from './number/num.mjs';
+export { TsDataForgeInternals } from './number/refined-number-utils.mjs';
+export { Obj } from './object/object.mjs';
+export { castDeepMutable, castMutable } from './others/cast-mutable.mjs';
+export { castDeepReadonly, castReadonly } from './others/cast-readonly.mjs';
+export { ifThen } from './others/if-then.mjs';
+export { mapNullable } from './others/map-nullable.mjs';
+export { memoizeFunction } from './others/memoize-function.mjs';
+export { tp } from './others/tuple.mjs';
+export { unknownToString } from './others/unknown-to-string.mjs';
+export { createPromise } from './promise/promise.mjs';
+//# sourceMappingURL=entry-point.mjs.map

package/dist/entry-point.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-point.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/others/unknown-to-string.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"unknown-to-string.d.mts","sourceRoot":"","sources":["../../src/others/unknown-to-string.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8IG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,OAAO,EACd,UAAU,OAAO,CAAC,QAAQ,CAAC;IAAE,iBAAiB,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC,KAC1D,MA+BF,CAAC"}
+{"version":3,"file":"unknown-to-string.d.mts","sourceRoot":"","sources":["../../src/others/unknown-to-string.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8IG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,OAAO,EACd,UAAU,OAAO,CAAC,QAAQ,CAAC;IAAE,iBAAiB,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC,KAC1D,MAiCF,CAAC"}

package/dist/others/unknown-to-string.mjs

@@ -147,8 +147,9 @@ const unknownToString = (value, options) => {
     switch (typeof value) {
         case 'string':
             return value;
-        case 'number':
         case 'bigint':
+            return `${value.toString()}n`;
+        case 'number':
         case 'boolean':
         case 'symbol':
         case 'function':

package/dist/others/unknown-to-string.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"unknown-to-string.mjs","sources":["../../src/others/unknown-to-string.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8IG;MACU,eAAe,GAAG,CAC7B,KAAc,EACd,OAA2D,KACjD;IACV,QAAQ,OAAO,KAAK;AAClB,QAAA,KAAK,QAAQ;AACX,YAAA,OAAO,KAAK;AAEd,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,SAAS;AACd,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,UAAU;AACb,YAAA,OAAO,KAAK,CAAC,QAAQ,EAAE;AAEzB,QAAA,KAAK,QAAQ;AACX,YAAA,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE;AACxB,gBAAA,OAAO,MAAM;YACf;AACA,YAAA,IAAI;AACF,gBAAA,MAAM,WAAW,GACf,OAAO,EAAE,iBAAiB,KAAK;sBAC3B,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC;AACpC,sBAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;AAC3B,gBAAA,OAAO,WAAW;YACpB;YAAE,OAAO,KAAK,EAAE;gBACd,OAAO,KAAK,YAAY;sBACpB,KAAK,CAAC;sBACN,gCAAgC;YACtC;AAEF,QAAA,KAAK,WAAW;AACd,YAAA,OAAO,WAAW;;AAExB;;;;"}
+{"version":3,"file":"unknown-to-string.mjs","sources":["../../src/others/unknown-to-string.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8IG;MACU,eAAe,GAAG,CAC7B,KAAc,EACd,OAA2D,KACjD;IACV,QAAQ,OAAO,KAAK;AAClB,QAAA,KAAK,QAAQ;AACX,YAAA,OAAO,KAAK;AAEd,QAAA,KAAK,QAAQ;AACX,YAAA,OAAO,GAAG,KAAK,CAAC,QAAQ,EAAE,GAAG;AAE/B,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,SAAS;AACd,QAAA,KAAK,QAAQ;AACb,QAAA,KAAK,UAAU;AACb,YAAA,OAAO,KAAK,CAAC,QAAQ,EAAE;AAEzB,QAAA,KAAK,QAAQ;AACX,YAAA,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE;AACxB,gBAAA,OAAO,MAAM;YACf;AACA,YAAA,IAAI;AACF,gBAAA,MAAM,WAAW,GACf,OAAO,EAAE,iBAAiB,KAAK;sBAC3B,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC;AACpC,sBAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;AAC3B,gBAAA,OAAO,WAAW;YACpB;YAAE,OAAO,KAAK,EAAE;gBACd,OAAO,KAAK,YAAY;sBACpB,KAAK,CAAC;sBACN,gCAAgC;YACtC;AAEF,QAAA,KAAK,WAAW;AACd,YAAA,OAAO,WAAW;;AAExB;;;;"}

package/dist/types.d.mts

@@ -1,2 +1,2 @@
 import './globals.d.mts';
-export * from './index.mjs';
+export * from './entry-point.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "private": false,
   "keywords": [
     "typescript",
@@ -22,11 +22,11 @@
     ".": {
       "import": {
         "types": "./dist/types.d.mts",
-        "default": "./dist/index.mjs"
+        "default": "./dist/entry-point.mjs"
       }
     }
   },
-  "module": "./dist/index.mjs",
+  "module": "./dist/entry-point.mjs",
   "types": "./dist/types.d.mts",
   "files": [
     "src",
@@ -35,30 +35,26 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsx ./scripts/cmd/build.mjs",
-    "check-all": "tsx ./scripts/cmd/check-all.mjs",
-    "check:ext": "tsx ./scripts/cmd/check-ext.mjs",
+    "build": "tsx ./scripts/cmd/build.mts",
+    "check-all": "tsx ./scripts/cmd/check-all.mts",
+    "check:ext": "tsx ./scripts/cmd/check-ext.mts",
     "cspell": "cspell \"**\" --gitignore --gitignore-root ./ --no-progress",
-    "doc": "tsx ./scripts/cmd/gen-docs.mjs",
+    "doc": "tsx ./scripts/cmd/gen-docs.mts",
+    "doc:embed": "tsx ./scripts/cmd/embed-samples.mts",
     "fmt": "format-diff-from origin/main",
     "fmt:full": "prettier --write .",
-    "gi": "gen-index-ts ./src --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --fmt 'npm run fmt'",
+    "gi": "gen-index-ts ./src --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --exclude entry-point.mts --fmt 'npm run fmt'",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
-    "lint:samples": "eslint ./samples",
     "md": "markdownlint-cli2",
     "test": "npm run z:vitest -- run",
     "test:cov": "npm run z:vitest -- run --coverage",
     "test:cov:ui": "vite preview --outDir ./coverage",
-    "test:samples": "vitest --config ./samples/vitest.config.ts",
     "test:ui": "npm run z:vitest -- --ui",
     "testw": "npm run z:vitest -- watch",
-    "testw:samples": "npm run test:samples -- watch",
     "tsc": "tsc --noEmit",
     "tscw": "tsc --noEmit --watch -p ./tsconfig.json",
-    "tscw:samples": "tsc --noEmit --watch -p ./samples/tsconfig.json",
     "type-check": "tsc --noEmit",
-    "type-check:samples": "tsc --noEmit -p ./samples/tsconfig.json",
     "update-packages": "npx npm-check-updates -u --install always",
     "z:vitest": "vitest --config ./configs/vitest.config.ts"
   },
@@ -68,7 +64,7 @@
   "devDependencies": {
     "@emotion/react": "^11.14.0",
     "@emotion/styled": "^11.14.1",
-    "@eslint/js": "^9.34.0",
+    "@eslint/js": "^9.35.0",
     "@mui/material": "^7.3.1",
     "@rollup/plugin-replace": "^6.0.2",
     "@rollup/plugin-strip": "^3.0.4",
@@ -77,15 +73,15 @@
     "@semantic-release/commit-analyzer": "^13.0.1",
     "@semantic-release/exec": "^7.1.0",
     "@semantic-release/git": "^10.0.1",
-    "@semantic-release/github": "^11.0.4",
+    "@semantic-release/github": "^11.0.6",
     "@semantic-release/npm": "^12.0.2",
     "@semantic-release/release-notes-generator": "^14.0.3",
-    "@types/node": "^24.3.0",
+    "@types/node": "^24.3.1",
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",
     "conventional-changelog-conventionalcommits": "^9.1.0",
-    "cspell": "^9.2.0",
-    "eslint": "^9.34.0",
+    "cspell": "^9.2.1",
+    "eslint": "^9.35.0",
     "eslint-import-resolver-typescript": "4.4.4",
     "eslint-plugin-array-func": "5.0.2",
     "eslint-plugin-functional": "9.0.2",
@@ -93,7 +89,7 @@
     "eslint-plugin-prefer-arrow-functions": "3.6.2",
     "eslint-plugin-promise": "7.2.1",
     "eslint-plugin-security": "3.0.1",
-    "eslint-plugin-unicorn": "60.0.0",
+    "eslint-plugin-unicorn": "61.0.2",
     "eslint-plugin-vitest": "0.5.4",
     "fast-glob": "^3.3.3",
     "immer": "^10.1.1",
@@ -101,15 +97,15 @@
     "prettier": "^3.6.2",
     "prettier-plugin-organize-imports": "^4.2.0",
     "prettier-plugin-packagejson": "^2.5.19",
-    "rollup": "^4.48.0",
+    "rollup": "^4.50.1",
     "semantic-release": "^24.2.7",
-    "ts-repo-utils": "^6.0.3",
+    "ts-repo-utils": "^7.5.0",
     "tslib": "^2.8.1",
-    "tsx": "^4.20.4",
+    "tsx": "^4.20.5",
     "typedoc": "^0.28.10",
     "typedoc-plugin-markdown": "^4.8.1",
     "typescript": "^5.9.2",
-    "typescript-eslint": "^8.40.0",
+    "typescript-eslint": "^8.43.0",
     "vitest": "^3.2.4"
   },
   "peerDependencies": {

package/src/entry-point.mts

@@ -0,0 +1 @@
+export * from './index.mjs';

package/src/guard/is-record.test.mts

@@ -22,7 +22,6 @@ describe('isRecord', () => {
     const unk: unknown = obj;
     const res = isRecord(unk);
 
-    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
     expectType<typeof obj, {}>('=');
     expectType<typeof res, boolean>('=');
 

package/src/others/unknown-to-string.mts

@@ -151,8 +151,10 @@ export const unknownToString = (
     case 'string':
       return value;
 
-    case 'number':
     case 'bigint':
+      return `${value.toString()}n`;
+
+    case 'number':
     case 'boolean':
     case 'symbol':
     case 'function':

package/src/others/unknown-to-string.test.mts

@@ -77,6 +77,6 @@ describe('unknownToString', () => {
 
   test('BigInt value', () => {
     const result = unknownToString(BigInt(123));
-    expect(result).toBe('123');
+    expect(result).toBe('123n');
   });
 });