Chore: Updated most packages to the latest versions

Author: heath-freenome

package-lock.json

@@ -31,60 +31,60 @@
   "license": "Apache-2.0",
   "homepage": "https://github.com/rjsf-team/react-jsonschema-form",
   "devDependencies": {
-    "@babel/cli": "7.27.0",
-    "@babel/core": "^7.23.9",
-    "@babel/eslint-parser": "7.27.0",
+    "@babel/cli": "7.28.0",
+    "@babel/core": "7.28.0",
+    "@babel/eslint-parser": "7.28.0",
     "@babel/plugin-proposal-class-properties": "^7.18.6",
     "@babel/plugin-proposal-optional-chaining": "^7.21.0",
-    "@babel/preset-env": "^7.23.9",
+    "@babel/plugin-transform-class-static-block": "^7.26.0",
+    "@babel/preset-env": "7.28.0",
     "@babel/preset-react": "^7.23.3",
     "@babel/preset-typescript": "^7.23.3",
-    "@babel/plugin-transform-class-static-block": "^7.26.0",
-    "@nx/js": "^20.8.1",
+    "@nx/js": "21.3.11",
     "@swc-node/register": "^1.10.10",
-    "@swc/core": "^1.11.24",
+    "@swc/core": "1.13.3",
     "@swc/helpers": "^0.5.17",
-    "@swc/jest": "^0.2.38",
-    "@testing-library/jest-dom": "^6.4.2",
-    "@testing-library/react": "^14.2.1",
-    "@types/estree": "^1.0.7",
-    "@types/jest": "^29.5.14",
-    "@types/lodash": "^4.14.202",
+    "@swc/jest": "0.2.39",
+    "@testing-library/jest-dom": "6.6.4",
+    "@testing-library/react": "16.3.0",
+    "@types/estree": "1.0.8",
+    "@types/jest": "30.0.0",
+    "@types/lodash": "4.17.20",
     "@types/node": "^22.15.3",
     "@types/prettier": "^3.0.0",
     "@types/react": "^18.2.58",
     "@types/react-dom": "^18.2.19",
     "@types/react-test-renderer": "^18.0.7",
-    "@typescript-eslint/eslint-plugin": "^8.31.1",
-    "@typescript-eslint/parser": "^8.31.1",
-    "babel-jest": "^29.7.0",
-    "cross-env": "^7.0.3",
-    "esbuild": "^0.25.3",
+    "@typescript-eslint/eslint-plugin": "8.39.1",
+    "@typescript-eslint/parser": "8.39.1",
+    "babel-jest": "30.0.5",
+    "cross-env": "10.0.0",
+    "esbuild": "0.25.8",
     "eslint": "^8.56.0",
-    "eslint-config-prettier": "10.1.2",
-    "eslint-plugin-import": "^2.31.0",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-import": "2.32.0",
     "eslint-plugin-jsx-a11y": "^6.10.2",
-    "eslint-plugin-prettier": "^5.2.6",
+    "eslint-plugin-prettier": "5.5.4",
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-hooks": "^5.2.0",
     "husky": "^9.1.7",
-    "jest": "^29.7.0",
-    "jest-environment-jsdom": "^29.7.0",
-    "jest-watch-typeahead": "^2.2.2",
-    "lint-staged": "^15.5.1",
+    "jest": "30.0.5",
+    "jest-environment-jsdom": "30.0.5",
+    "jest-watch-typeahead": "3.0.1",
+    "lint-staged": "16.1.5",
     "move-file-cli": "^3.0.0",
-    "nx": "^20.8.1",
-    "prettier": "^3.5.3",
+    "nx": "21.3.11",
+    "prettier": "3.6.2",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "react-test-renderer": "^18.2.0",
     "rimraf": "^6.0.1",
-    "rollup": "^4.34.8",
-    "ts-jest": "^29.3.4",
+    "rollup": "4.46.2",
+    "ts-jest": "29.4.1",
     "tsc-alias": "^1.8.13",
     "tslib": "^2.6.2",
-    "tsx": "^4.19.4",
-    "typescript": "^5.8.3"
+    "tsx": "4.20.4",
+    "typescript": "5.9.2"
   },
   "workspaces": [
     "packages/antd",

package.json

@@ -62,7 +62,7 @@ describe('dateRangeOptions()', () => {
     expect(dateRangeOptions(0, 0)).toEqual([{ value: startYear, label: `${startYear}` }]);
   });
   it('throws when start and stop are different signs', () => {
-    expect(() => dateRangeOptions(1, -1)).toThrowError(
+    expect(() => dateRangeOptions(1, -1)).toThrow(
       new Error(`Both start (${1}) and stop (${-1}) must both be <= 0 or > 0, got one of each`),
     );
   });

packages/utils/test/dateRangeOptions.test.ts

@@ -144,15 +144,15 @@ const EXTRA_EXPECTED = { type: 'string', title: 'foo' };
 
 describe('findSchemaDefinition()', () => {
   it('throws error when ref is missing', () => {
-    expect(() => findSchemaDefinition()).toThrowError('Could not find a definition for undefined');
+    expect(() => findSchemaDefinition()).toThrow('Could not find a definition for undefined');
   });
   it('throws error when ref is malformed', () => {
-    expect(() => findSchemaDefinition('definitions/missing')).toThrowError(
+    expect(() => findSchemaDefinition('definitions/missing')).toThrow(
       'Could not find a definition for definitions/missing',
     );
   });
   it('throws error when ref does not exist', () => {
-    expect(() => findSchemaDefinition('#/definitions/missing', schema)).toThrowError(
+    expect(() => findSchemaDefinition('#/definitions/missing', schema)).toThrow(
       'Could not find a definition for #/definitions/missing',
     );
   });
@@ -166,22 +166,22 @@ describe('findSchemaDefinition()', () => {
     expect(findSchemaDefinition('#/definitions/extraNestedRef', schema)).toEqual(EXTRA_EXPECTED);
   });
   it('throws error when ref is a circular reference', () => {
-    expect(() => findSchemaDefinition('#/definitions/badCircularNestedRef', schema)).toThrowError(
+    expect(() => findSchemaDefinition('#/definitions/badCircularNestedRef', schema)).toThrow(
       'Definition for #/definitions/badCircularNestedRef is a circular reference',
     );
   });
   it('throws error when ref is a deep circular reference', () => {
-    expect(() => findSchemaDefinition('#/definitions/badCircularDeepNestedRef', schema)).toThrowError(
+    expect(() => findSchemaDefinition('#/definitions/badCircularDeepNestedRef', schema)).toThrow(
       'Definition for #/definitions/badCircularDeepNestedRef contains a circular reference through #/definitions/badCircularDeeperNestedRef -> #/definitions/badCircularDeepestNestedRef -> #/definitions/badCircularDeepNestedRef',
     );
   });
   it('throws error when bundled ref are not part of JSON Schema Draft 2020-12', () => {
-    expect(() => findSchemaDefinition('#/definitions/bundledRef', schema)).toThrowError(
+    expect(() => findSchemaDefinition('#/definitions/bundledRef', schema)).toThrow(
       'Could not find a definition for /bundled.ref.json',
     );
   });
   it('throws error when bundled ref with explicit baseURI are not part of JSON Schema Draft 2020-12', () => {
-    expect(() => findSchemaDefinition('#/properties/num', schema, 'https://example.com/bundled.ref.json')).toThrowError(
+    expect(() => findSchemaDefinition('#/properties/num', schema, 'https://example.com/bundled.ref.json')).toThrow(
       'Could not find a definition for #/properties/num',
     );
   });
@@ -224,43 +224,43 @@ describe('findSchemaDefinition()', () => {
     );
   });
   it('throws error when relative ref is undefined in a bundled JSON Schema', () => {
-    expect(() => findSchemaDefinition('#/$defs/undefinedRef', bundledSchema)).toThrowError(
+    expect(() => findSchemaDefinition('#/$defs/undefinedRef', bundledSchema)).toThrow(
       'Could not find a definition for /undefined.ref.json',
     );
   });
   it('throws error when relative ref with anchor is undefined in a bundled JSON Schema', () => {
-    expect(() => findSchemaDefinition('#/$defs/undefinedRefWithAnchor', bundledSchema)).toThrowError(
+    expect(() => findSchemaDefinition('#/$defs/undefinedRefWithAnchor', bundledSchema)).toThrow(
       'Could not find a definition for #/$defs/undefined',
     );
   });
   it('throws error when local ref is undefined in a bundled JSON Schema with explicit base URI', () => {
     expect(() =>
       findSchemaDefinition('#/properties/undefined', bundledSchema, 'https://example.com/bundled.ref.json'),
-    ).toThrowError('Could not find a definition for #/properties/undefined');
+    ).toThrow('Could not find a definition for #/properties/undefined');
   });
   it('throws error when explicit base URI is undefined in a bundled JSON Schema', () => {
     expect(() =>
       findSchemaDefinition('#/properties/undefined', bundledSchema, 'https://example.com/undefined.ref.json'),
-    ).toThrowError('Could not find a definition for #/properties/undefined');
+    ).toThrow('Could not find a definition for #/properties/undefined');
   });
   it('throws error when ref is a deep circular reference in a bundled JSON Schema', () => {
-    expect(() => findSchemaDefinition('#/$defs/circularRef', bundledSchema)).toThrowError(
+    expect(() => findSchemaDefinition('#/$defs/circularRef', bundledSchema)).toThrow(
       'Definition for #/$defs/circularRef contains a circular reference through /bundled.ref.json/#/$defs/circularRef -> /bundled.schema.json/#/$defs/circularRef -> #/$defs/circularRef',
     );
   });
 });
 
 describe('findSchemaDefinitionRecursive()', () => {
   it('throws error when ref is missing', () => {
-    expect(() => findSchemaDefinitionRecursive()).toThrowError('Could not find a definition for undefined');
+    expect(() => findSchemaDefinitionRecursive()).toThrow('Could not find a definition for undefined');
   });
   it('throws error when ref is malformed', () => {
-    expect(() => findSchemaDefinitionRecursive('definitions/missing')).toThrowError(
+    expect(() => findSchemaDefinitionRecursive('definitions/missing')).toThrow(
       'Could not find a definition for definitions/missing',
     );
   });
   it('throws error when ref does not exist', () => {
-    expect(() => findSchemaDefinitionRecursive('#/definitions/missing', schema)).toThrowError(
+    expect(() => findSchemaDefinitionRecursive('#/definitions/missing', schema)).toThrow(
       'Could not find a definition for #/definitions/missing',
     );
   });
@@ -274,24 +274,24 @@ describe('findSchemaDefinitionRecursive()', () => {
     expect(findSchemaDefinitionRecursive('#/definitions/extraNestedRef', schema)).toEqual(EXTRA_EXPECTED);
   });
   it('throws error when ref is a circular reference', () => {
-    expect(() => findSchemaDefinitionRecursive('#/definitions/badCircularNestedRef', schema)).toThrowError(
+    expect(() => findSchemaDefinitionRecursive('#/definitions/badCircularNestedRef', schema)).toThrow(
       'Definition for #/definitions/badCircularNestedRef is a circular reference',
     );
   });
   it('throws error when ref is a deep circular reference', () => {
-    expect(() => findSchemaDefinitionRecursive('#/definitions/badCircularDeepNestedRef', schema)).toThrowError(
+    expect(() => findSchemaDefinitionRecursive('#/definitions/badCircularDeepNestedRef', schema)).toThrow(
       'Definition for #/definitions/badCircularDeepNestedRef contains a circular reference through #/definitions/badCircularDeeperNestedRef -> #/definitions/badCircularDeepestNestedRef -> #/definitions/badCircularDeepNestedRef',
     );
   });
   it('throws error when bundled ref are not part of JSON Schema Draft 2020-12', () => {
-    expect(() => findSchemaDefinitionRecursive('#/definitions/bundledRef', schema)).toThrowError(
+    expect(() => findSchemaDefinitionRecursive('#/definitions/bundledRef', schema)).toThrow(
       'Could not find a definition for /bundled.ref.json',
     );
   });
   it('throws error when bundled ref with explicit baseURI are not part of JSON Schema Draft 2020-12', () => {
     expect(() =>
       findSchemaDefinitionRecursive('#/properties/num', schema, [], 'https://example.com/bundled.ref.json'),
-    ).toThrowError('Could not find a definition for #/properties/num');
+    ).toThrow('Could not find a definition for #/properties/num');
   });
   it('correctly resolves absolute bundled refs within a JSON Schema Draft 2020-12', () => {
     expect(findSchemaDefinitionRecursive('#/$defs/bundledAbsoluteRef', bundledSchema)).toStrictEqual(internalSchema);
@@ -334,12 +334,12 @@ describe('findSchemaDefinitionRecursive()', () => {
     ).toBe(internalSchema.properties!.num);
   });
   it('throws error when relative ref is undefined in a bundled JSON Schema', () => {
-    expect(() => findSchemaDefinitionRecursive('#/$defs/undefinedRef', bundledSchema)).toThrowError(
+    expect(() => findSchemaDefinitionRecursive('#/$defs/undefinedRef', bundledSchema)).toThrow(
       'Could not find a definition for /undefined.ref.json',
     );
   });
   it('throws error when relative ref with anchor is undefined in a bundled JSON Schema', () => {
-    expect(() => findSchemaDefinitionRecursive('#/$defs/undefinedRefWithAnchor', bundledSchema)).toThrowError(
+    expect(() => findSchemaDefinitionRecursive('#/$defs/undefinedRefWithAnchor', bundledSchema)).toThrow(
       'Could not find a definition for #/$defs/undefined',
     );
   });
@@ -351,15 +351,15 @@ describe('findSchemaDefinitionRecursive()', () => {
         [],
         'https://example.com/bundled.ref.json',
       ),
-    ).toThrowError('Could not find a definition for #/properties/undefined');
+    ).toThrow('Could not find a definition for #/properties/undefined');
   });
   it('throws error when explicit base URI is undefined in a bundled JSON Schema', () => {
     expect(() =>
       findSchemaDefinition('#/properties/undefined', bundledSchema, 'https://example.com/undefined.ref.json'),
-    ).toThrowError('Could not find a definition for #/properties/undefined');
+    ).toThrow('Could not find a definition for #/properties/undefined');
   });
   it('throws error when ref is a deep circular reference in a bundled JSON Schema', () => {
-    expect(() => findSchemaDefinitionRecursive('#/$defs/circularRef', bundledSchema, [])).toThrowError(
+    expect(() => findSchemaDefinitionRecursive('#/$defs/circularRef', bundledSchema, [])).toThrow(
       'Definition for #/$defs/circularRef contains a circular reference through /bundled.ref.json/#/$defs/circularRef -> /bundled.schema.json/#/$defs/circularRef -> #/$defs/circularRef',
     );
   });

packages/utils/test/findSchemaDefinition.test.ts

@@ -88,19 +88,19 @@ const widgetProps: WidgetProps = {
 
 describe('getWidget()', () => {
   it('should fail if widget has incorrect type', () => {
-    expect(() => getWidget(schema)).toThrowError('Unsupported widget definition: undefined');
+    expect(() => getWidget(schema)).toThrow('Unsupported widget definition: undefined');
   });
 
   it('should fail if widget has no type property', () => {
-    expect(() => getWidget(schema, 'blabla')).toThrowError(`No widget for type 'object'`);
+    expect(() => getWidget(schema, 'blabla')).toThrow(`No widget for type 'object'`);
   });
 
   it('should fail if schema `type` has no widget property', () => {
-    expect(() => getWidget(subschema, 'blabla')).toThrowError(`No widget 'blabla' for type 'boolean'`);
+    expect(() => getWidget(subschema, 'blabla')).toThrow(`No widget 'blabla' for type 'boolean'`);
   });
 
   it('should fail if schema has no type property', () => {
-    expect(() => getWidget({}, 'blabla')).toThrowError(`No widget 'blabla' for type 'undefined'`);
+    expect(() => getWidget({}, 'blabla')).toThrow(`No widget 'blabla' for type 'undefined'`);
   });
 
   it('should return widget if in registered widgets', () => {

packages/utils/test/getWidget.test.tsx

@@ -28,7 +28,7 @@ describe('hasWidget()', () => {
     expect(hasWidget(schema, 'foo')).toBe(false);
   });
   it('rethrows error', () => {
-    expect(() => hasWidget({ type: 'null' }, 'foo', { TextWidget: {} as Widget })).toThrowError(TypeError);
+    expect(() => hasWidget({ type: 'null' }, 'foo', { TextWidget: {} as Widget })).toThrow(TypeError);
   });
   it('returns true when widget is available', () => {
     expect(hasWidget(schema, 'text')).toBe(true);

packages/utils/test/hasWidget.test.ts

@@ -32,21 +32,19 @@ describe('orderProperties()', () => {
   it('throws error when * is missing and there is one more prop than ordered', () => {
     const properties = ['foo', 'bar', 'baz'];
     const order = ['foo', 'baz'];
-    expect(() => orderProperties(properties, order)).toThrowError(
-      "uiSchema order list does not contain property 'bar'",
-    );
+    expect(() => orderProperties(properties, order)).toThrow("uiSchema order list does not contain property 'bar'");
   });
   it('throws error when * is missing and there are a few more props than ordered', () => {
     const properties = ['foo', 'bar', 'baz'];
     const order = ['foo'];
-    expect(() => orderProperties(properties, order)).toThrowError(
+    expect(() => orderProperties(properties, order)).toThrow(
       "uiSchema order list does not contain properties 'bar', 'baz'",
     );
   });
   it('throws error when there are multiple *s in order', () => {
     const properties = ['foo', 'bar', 'baz'];
     const order = ['*', 'foo', '*'];
-    expect(() => orderProperties(properties, order)).toThrowError(
+    expect(() => orderProperties(properties, order)).toThrow(
       'uiSchema order list contains more than one wildcard item',
     );
   });

packages/utils/test/orderProperties.test.ts

@@ -2,7 +2,7 @@ import { parseDateString } from '../src';
 
 describe('parseDateString()', () => {
   it('should raise on invalid JSON datetime', () => {
-    expect(() => parseDateString('plop')).toThrowError('Unable to parse');
+    expect(() => parseDateString('plop')).toThrow('Unable to parse');
   });
 
   it('should return a default object when no datetime is passed', () => {

packages/utils/test/parseDateString.test.ts

@@ -34,22 +34,22 @@ describe('ParserValidator', () => {
     });
   });
   it('isValid() throws error when rootSchema differs', () => {
-    expect(() => validator.isValid(TINY_SCHEMA, undefined, ID_SCHEMA)).toThrowError(
+    expect(() => validator.isValid(TINY_SCHEMA, undefined, ID_SCHEMA)).toThrow(
       new Error('Unexpectedly calling isValid() with a rootSchema that differs from the construction rootSchema'),
     );
   });
   it('rawValidation() throws error when called', () => {
-    expect(() => validator.rawValidation(TINY_SCHEMA, undefined)).toThrowError(
+    expect(() => validator.rawValidation(TINY_SCHEMA, undefined)).toThrow(
       new Error('Unexpectedly calling the `rawValidation()` method during schema parsing'),
     );
   });
   it('toErrorList() throws error when called', () => {
-    expect(() => validator.toErrorList({})).toThrowError(
+    expect(() => validator.toErrorList({})).toThrow(
       new Error('Unexpectedly calling the `toErrorList()` method during schema parsing'),
     );
   });
   it('validateFormData() throws error when called', () => {
-    expect(() => validator.validateFormData({}, TINY_SCHEMA)).toThrowError(
+    expect(() => validator.validateFormData({}, TINY_SCHEMA)).toThrow(
       new Error('Unexpectedly calling the `validateFormData()` method during schema parsing'),
     );
   });
@@ -78,7 +78,7 @@ describe('ParserValidator', () => {
   it('calling isValid() with a schema that has a matching key throws error', () => {
     // Force the error condition
     validator.schemaMap[DUPLICATE_HASH] = TINY_SCHEMA;
-    expect(() => validator.isValid(DUPLICATE_SCHEMA, undefined, RECURSIVE_REF)).toThrowError(
+    expect(() => validator.isValid(DUPLICATE_SCHEMA, undefined, RECURSIVE_REF)).toThrow(
       new Error(
         `Two different schemas exist with the same key ${DUPLICATE_HASH}! What a bad coincidence. If possible, try adding an $id to one of the schemas`,
       ),

packages/utils/test/parser/ParserValidator.test.ts

@@ -22,7 +22,7 @@ export default function getDefaultFormStateTest(testValidator: TestValidatorType
       consoleWarnSpy.mockRestore();
     });
     it('throws error when schema is not an object', () => {
-      expect(() => getDefaultFormState(testValidator, null as unknown as RJSFSchema)).toThrowError('Invalid schema:');
+      expect(() => getDefaultFormState(testValidator, null as unknown as RJSFSchema)).toThrow('Invalid schema:');
     });
 
     describe('object schemas', () => {