ts-fortress 2.5.0 → 2.6.1

package/README.md

@@ -71,11 +71,9 @@ if (User.is(userData)) {
     console.log(`User: ${userData.name}, Age: ${userData.age}`);
 }
 
-import { Result } from 'ts-data-forge';
-
 // Get validation result with error details
 const result = User.validate(userData);
-if (Result.isOk(result)) {
+if (t.Result.isOk(result)) {
     const user = result.value; // typed as User
 } else {
     console.error('Validation errors:', result.value); // readonly ValidationError[] showing error information
@@ -132,7 +130,7 @@ const completeUser: UserProfile = UserProfile.fill(anyPartialData);
 // The is() and validate() functions can still detect missing keys
 console.log(UserProfile.is(partialData)); // false - missing required keys
 const result = UserProfile.validate(partialData);
-if (Result.isErr(result)) {
+if (t.Result.isErr(result)) {
     console.log(result.value); // ValidationError[] showing missing keys
 }
 ```
@@ -413,7 +411,7 @@ const C = t.partial(
     const UnionBA = t.union([B, A]);
     const result = UnionBA.validate({ A: 1 });
 
-    if (Result.isOk(result)) {
+    if (t.Result.isOk(result)) {
         console.log(result.value); // { A: 1 } <- ✅ Correct! No unexpected fields
         console.log(A.is(result.value)); // true  <- ✅ Correct
         console.log(B.is(result.value)); // false <- ✅ Correct! B requires field B
@@ -425,7 +423,7 @@ const C = t.partial(
     const UnionCA = t.union([C, A]);
     const result = UnionCA.validate({ A: 1 });
 
-    if (Result.isOk(result)) {
+    if (t.Result.isOk(result)) {
         console.log(result.value); // { A: 1 } <- ✅ Correct and consistent
         console.log(A.is(result.value)); // true  <- ✅ Correct
         console.log(C.is(result.value)); // true  <- ✅ Consistent! ts-fortress partial types allow extra fields
@@ -496,7 +494,6 @@ The `validate` method performs comprehensive validation and returns a `Result` t
 
 ```typescript
 import * as t from 'ts-fortress';
-import { Result } from 'ts-data-forge';
 
 const User = t.record({
     name: t.string(''),
@@ -507,7 +504,7 @@ const User = t.record({
 const validData = { name: 'Alice', age: 30 };
 const result = User.validate(validData);
 
-if (Result.isOk(result)) {
+if (t.Result.isOk(result)) {
     console.log(result.value === validData); // true - same reference!
     console.log(result.value); // { name: 'Alice', age: 30 }
 }
@@ -516,7 +513,7 @@ if (Result.isOk(result)) {
 const invalidData = { name: 'Bob', age: 'thirty' };
 const errorResult = User.validate(invalidData);
 
-if (Result.isErr(errorResult)) {
+if (t.Result.isErr(errorResult)) {
     console.log(errorResult.value);
     // [
     //   {
@@ -749,7 +746,7 @@ const UInt16 = t.uint16(0);
 
 // Usage
 const userIdResult = UserId.validate('user_123');
-if (Result.isOk(userIdResult)) {
+if (t.Result.isOk(userIdResult)) {
     const id: UserId = userIdResult.value;
 }
 ```
@@ -815,7 +812,7 @@ const UserType = t.record({
 const invalidData = { name: 123, age: 'not a number' };
 
 const result = UserType.validate(invalidData);
-if (Result.isErr(result)) {
+if (t.Result.isErr(result)) {
     // result.value is an array of ValidationError objects
     for (const error of result.value) {
         console.log('Path:', error.path); // ['name'] or ['age']
@@ -851,7 +848,7 @@ const StrictType = t.record(
 const dataWithExcess = { name: 'John', age: 30, extra: 'not allowed' };
 const strictResult = StrictType.validate(dataWithExcess);
 
-if (Result.isErr(strictResult)) {
+if (t.Result.isErr(strictResult)) {
     console.log(strictResult.value);
     // [{
     //   path: ['extra'],

package/dist/entry-point.d.mts

@@ -0,0 +1,3 @@
+export { FiniteNumber, Int, Int16, Int32, Int8, NonNegativeFiniteNumber, NonNegativeInt16, NonNegativeInt32, NonZeroFiniteNumber, NonZeroInt, NonZeroInt16, NonZeroInt32, NonZeroSafeInt, NonZeroUint16, NonZeroUint32, PositiveFiniteNumber, PositiveInt, PositiveInt16, PositiveInt32, PositiveSafeInt, PositiveUint16, PositiveUint32, Result, SafeInt, SafeUint, Uint, Uint16, Uint32, Uint8, asFiniteNumber, asInt, asInt16, asInt32, asInt8, asNonNegativeFiniteNumber, asNonNegativeInt16, asNonNegativeInt32, asNonZeroFiniteNumber, asNonZeroInt, asNonZeroInt16, asNonZeroInt32, asNonZeroSafeInt, asNonZeroUint16, asNonZeroUint32, asPositiveFiniteNumber, asPositiveInt, asPositiveInt16, asPositiveInt32, asPositiveSafeInt, asPositiveUint16, asPositiveUint32, asSafeInt, asSafeUint, asUint, asUint16, asUint32, asUint8, isBigint, isFiniteNumber, isInt, isInt16, isInt32, isInt8, isNonNegativeFiniteNumber, isNonNegativeInt16, isNonNegativeInt32, isNonZeroFiniteNumber, isNonZeroInt, isNonZeroInt16, isNonZeroInt32, isNonZeroSafeInt, isNonZeroUint16, isNonZeroUint32, isPositiveFiniteNumber, isPositiveInt, isPositiveInt16, isPositiveInt32, isPositiveSafeInt, isPositiveUint16, isPositiveUint32, isSafeInt, isSafeUint, isUint, isUint16, isUint32, isUint8, } from 'ts-data-forge';
+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,OAAO,EACL,YAAY,EACZ,GAAG,EACH,KAAK,EACL,KAAK,EACL,IAAI,EACJ,uBAAuB,EACvB,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EACnB,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,cAAc,EACd,aAAa,EACb,aAAa,EACb,oBAAoB,EACpB,WAAW,EACX,aAAa,EACb,aAAa,EACb,eAAe,EACf,cAAc,EACd,cAAc,EACd,MAAM,EACN,OAAO,EACP,QAAQ,EACR,IAAI,EACJ,MAAM,EACN,MAAM,EACN,KAAK,EACL,cAAc,EACd,KAAK,EACL,OAAO,EACP,OAAO,EACP,MAAM,EACN,yBAAyB,EACzB,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,YAAY,EACZ,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,sBAAsB,EACtB,aAAa,EACb,eAAe,EACf,eAAe,EACf,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,SAAS,EACT,UAAU,EACV,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,cAAc,EACd,KAAK,EACL,OAAO,EACP,OAAO,EACP,MAAM,EACN,yBAAyB,EACzB,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,YAAY,EACZ,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,sBAAsB,EACtB,aAAa,EACb,eAAe,EACf,eAAe,EACf,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,SAAS,EACT,UAAU,EACV,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,OAAO,GACR,MAAM,eAAe,CAAC;AACvB,cAAc,aAAa,CAAC"}

package/dist/entry-point.mjs

@@ -0,0 +1,56 @@
+export { FiniteNumber, Int, Int16, Int32, Int8, NonNegativeFiniteNumber, NonNegativeInt16, NonNegativeInt32, NonZeroFiniteNumber, NonZeroInt, NonZeroInt16, NonZeroInt32, NonZeroSafeInt, NonZeroUint16, NonZeroUint32, PositiveFiniteNumber, PositiveInt, PositiveInt16, PositiveInt32, PositiveSafeInt, PositiveUint16, PositiveUint32, Result, SafeInt, SafeUint, Uint, Uint16, Uint32, Uint8, asFiniteNumber, asInt, asInt16, asInt32, asInt8, asNonNegativeFiniteNumber, asNonNegativeInt16, asNonNegativeInt32, asNonZeroFiniteNumber, asNonZeroInt, asNonZeroInt16, asNonZeroInt32, asNonZeroSafeInt, asNonZeroUint16, asNonZeroUint32, asPositiveFiniteNumber, asPositiveInt, asPositiveInt16, asPositiveInt32, asPositiveSafeInt, asPositiveUint16, asPositiveUint32, asSafeInt, asSafeUint, asUint, asUint16, asUint32, asUint8, isBigint, isFiniteNumber, isInt, isInt16, isInt32, isInt8, isNonNegativeFiniteNumber, isNonNegativeInt16, isNonNegativeInt32, isNonZeroFiniteNumber, isNonZeroInt, isNonZeroInt16, isNonZeroInt32, isNonZeroSafeInt, isNonZeroUint16, isNonZeroUint32, isPositiveFiniteNumber, isPositiveInt, isPositiveInt16, isPositiveInt32, isPositiveSafeInt, isPositiveUint16, isPositiveUint32, isSafeInt, isSafeUint, isUint, isUint16, isUint32, isUint8 } from 'ts-data-forge';
+export { arrayOfLength } from './array/array-of-length.mjs';
+export { array } from './array/array.mjs';
+export { nonEmptyArray } from './array/non-empty-array.mjs';
+export { tuple } from './array/tuple.mjs';
+export { brand } from './branded/brand.mjs';
+export { finiteNumber } from './branded/number/finite-number.mjs';
+export { int } from './branded/number/int.mjs';
+export { int16 } from './branded/number/int16.mjs';
+export { int32 } from './branded/number/int32.mjs';
+export { nonNegativeFiniteNumber } from './branded/number/non-negative-finite-number.mjs';
+export { nonZeroFiniteNumber } from './branded/number/non-zero-finite-number.mjs';
+export { nonZeroInt } from './branded/number/non-zero-int.mjs';
+export { nonZeroSafeInt } from './branded/number/non-zero-safe-int.mjs';
+export { positiveFiniteNumber } from './branded/number/positive-finite-number.mjs';
+export { positiveInt } from './branded/number/positive-int.mjs';
+export { positiveSafeInt } from './branded/number/positive-safe-int.mjs';
+export { safeInt } from './branded/number/safe-int.mjs';
+export { safeUint } from './branded/number/safe-uint.mjs';
+export { uint } from './branded/number/uint.mjs';
+export { uint16 } from './branded/number/uint16.mjs';
+export { uint32 } from './branded/number/uint32.mjs';
+export { simpleBrandedNumber } from './branded/simple-branded-number.mjs';
+export { simpleBrandedString } from './branded/simple-branded-string.mjs';
+export { intersection } from './compose/intersection.mjs';
+export { mergeRecords } from './compose/merge-records.mjs';
+export { recursion } from './compose/recursion.mjs';
+export { union } from './compose/union.mjs';
+export { enumType } from './enum/enum.mjs';
+export { intRange } from './enum/int-range.mjs';
+export { uintRange } from './enum/uint-range.mjs';
+export { int8 } from './predefined/int8.mjs';
+export { JsonObject, JsonPrimitive, JsonValue } from './predefined/json.mjs';
+export { uint8 } from './predefined/uint8.mjs';
+export { bigint, bigintLiteral } from './primitives/bigint.mjs';
+export { boolean, booleanLiteral } from './primitives/boolean.mjs';
+export { nullType } from './primitives/null.mjs';
+export { number, numberLiteral } from './primitives/number.mjs';
+export { string, stringLiteral } from './primitives/string.mjs';
+export { symbol } from './primitives/symbol.mjs';
+export { undefinedType } from './primitives/undefined.mjs';
+export { keyValueRecord } from './record/key-value-record.mjs';
+export { keyof } from './record/keyof.mjs';
+export { omit } from './record/omit.mjs';
+export { isOptionalProperty, optional } from './record/optional.mjs';
+export { partial } from './record/partial.mjs';
+export { pick } from './record/pick.mjs';
+export { record, strictRecord } from './record/record.mjs';
+export { unknown } from './unknown.mjs';
+export { createAssertFn } from './utils/create-assert-fn.mjs';
+export { createCastFn } from './utils/create-cast-fn.mjs';
+export { createIsFn } from './utils/create-is-fn.mjs';
+export { createPrimitiveType } from './utils/create-primitive-type.mjs';
+export { createType } from './utils/create-type.mjs';
+export { createPrimitiveValidationError, prependIndexToValidationErrors, prependPathToValidationErrors, validationErrorToMessage, validationErrorsToMessages } from './utils/validation-error.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/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-fortress",
-  "version": "2.5.0",
+  "version": "2.6.1",
   "private": false,
   "keywords": [
     "typescript"
@@ -17,11 +17,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",
@@ -37,7 +37,7 @@
     "doc": "tsx ./scripts/cmd/gen-docs.mjs",
     "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",
     "md": "markdownlint-cli2",

package/src/entry-point.mts

@@ -0,0 +1,89 @@
+export {
+  FiniteNumber,
+  Int,
+  Int16,
+  Int32,
+  Int8,
+  NonNegativeFiniteNumber,
+  NonNegativeInt16,
+  NonNegativeInt32,
+  NonZeroFiniteNumber,
+  NonZeroInt,
+  NonZeroInt16,
+  NonZeroInt32,
+  NonZeroSafeInt,
+  NonZeroUint16,
+  NonZeroUint32,
+  PositiveFiniteNumber,
+  PositiveInt,
+  PositiveInt16,
+  PositiveInt32,
+  PositiveSafeInt,
+  PositiveUint16,
+  PositiveUint32,
+  Result,
+  SafeInt,
+  SafeUint,
+  Uint,
+  Uint16,
+  Uint32,
+  Uint8,
+  asFiniteNumber,
+  asInt,
+  asInt16,
+  asInt32,
+  asInt8,
+  asNonNegativeFiniteNumber,
+  asNonNegativeInt16,
+  asNonNegativeInt32,
+  asNonZeroFiniteNumber,
+  asNonZeroInt,
+  asNonZeroInt16,
+  asNonZeroInt32,
+  asNonZeroSafeInt,
+  asNonZeroUint16,
+  asNonZeroUint32,
+  asPositiveFiniteNumber,
+  asPositiveInt,
+  asPositiveInt16,
+  asPositiveInt32,
+  asPositiveSafeInt,
+  asPositiveUint16,
+  asPositiveUint32,
+  asSafeInt,
+  asSafeUint,
+  asUint,
+  asUint16,
+  asUint32,
+  asUint8,
+  isBigint,
+  isFiniteNumber,
+  isInt,
+  isInt16,
+  isInt32,
+  isInt8,
+  isNonNegativeFiniteNumber,
+  isNonNegativeInt16,
+  isNonNegativeInt32,
+  isNonZeroFiniteNumber,
+  isNonZeroInt,
+  isNonZeroInt16,
+  isNonZeroInt32,
+  isNonZeroSafeInt,
+  isNonZeroUint16,
+  isNonZeroUint32,
+  isPositiveFiniteNumber,
+  isPositiveInt,
+  isPositiveInt16,
+  isPositiveInt32,
+  isPositiveSafeInt,
+  isPositiveUint16,
+  isPositiveUint32,
+  isSafeInt,
+  isSafeUint,
+  isUint,
+  isUint16,
+  isUint32,
+  isUint8,
+} from 'ts-data-forge';
+export * from './index.mjs';