diff --git a/docusaurus.config.js b/docusaurus.config.js index 4deea5f0..e936656f 100644 --- a/docusaurus.config.js +++ b/docusaurus.config.js @@ -48,7 +48,7 @@ const config = { lastVersion: 'current', versions: { current: { - label: '3.0.1', + label: '3.1.0', banner: 'none', }, '2.x': { @@ -109,10 +109,10 @@ const config = { dropdownItemsAfter: [{ to: '/versions', label: 'Versions' }], dropdownActiveClassDisabled: true, }, - { to: '/', label: 'Getting Started', position: 'left' }, + { to: '/', label: 'EZ-Template', position: 'left' }, { to: 'category/tutorials', label: 'Tutorials', position: 'left' }, { to: 'category/docs', label: 'Docs', position: 'left' }, - // { to: '/support', label: 'Support', position: 'left' }, + // { to: 'category/community', label: 'Community', position: 'left' }, // { to: 'versions/', label: 'Versions', position: 'right' }, { href: 'https://www.roboticsisez.com/', label: 'robotics is ez', position: 'right' }, { href: 'https://github.com/EZ-Robotics/EZ-Template', label: 'GitHub', position: 'right' }, @@ -125,7 +125,7 @@ const config = { title: 'Learn', items: [ { - label: 'Getting Started', + label: 'EZ-Template', to: '/', }, { @@ -141,10 +141,10 @@ const config = { { title: 'Community', items: [ - /*{ + { label: 'Discord', - href: 'https://discordapp.com/invite/docusaurus', - },*/ + href: 'https://discord.gg/EHjXBcK2Gy', + }, { label: 'Instagram', href: 'https://www.instagram.com/roboticsisez', diff --git a/ez-template-docs/Introduction.md b/ez-template-docs/Introduction.md index b1a6b2f8..1b0fe64f 100644 --- a/ez-template-docs/Introduction.md +++ b/ez-template-docs/Introduction.md @@ -33,13 +33,16 @@ preview: /img/embed.png - Exposed slew class for gradual speed ramp-up for your other subsystems ## [Discord Server](https://discord.gg/EHjXBcK2Gy) -Need extra assistance using EZ-Template? Feel free to join our [Discord Server](https://discord.gg/EHjXBcK2Gy). +Need extra assistance using EZ-Template? Feel free to join our [Discord Server](https://discord.gg/EHjXBcK2Gy)! -## [Installation and Upgrading](https://ez-robotics.github.io/EZ-Template/tutorials/installation) -Installation and Upgrading tutorials can be foud [here](https://ez-robotics.github.io/EZ-Template/tutorials/installation). +## [Installation](https://ez-robotics.github.io/EZ-Template/tutorials/installation) +Installation tutorials can be found [here](https://ez-robotics.github.io/EZ-Template/tutorials/installation). + +## [Upgrading](https://ez-robotics.github.io/EZ-Template/tutorials/upgrading) +Upgrading tutorials can be found [here](https://ez-robotics.github.io/EZ-Template/tutorials/upgrading). ## [Tutorials](https://ez-robotics.github.io/EZ-Template/category/tutorials) -Tutorials on how to use and install EZ-Template can be found [here](https://ez-robotics.github.io/EZ-Template/category/tutorials). +Tutorials on how to use and install EZ-Template can be found [here](https://ez-robotics.github.io/EZ-Template/category/tutorials). ## [Docs](https://ez-robotics.github.io/EZ-Template/category/docs) Documentation on how to use EZ-Template functions can be found [here](https://ez-robotics.github.io/EZ-Template/category/docs). diff --git a/ez-template-docs/docs/auton_functions.md b/ez-template-docs/docs/auton_functions.md index f8824720..1ae8e78c 100644 --- a/ez-template-docs/docs/auton_functions.md +++ b/ez-template-docs/docs/auton_functions.md @@ -340,7 +340,8 @@ Sets the exit condition constants for driving. This uses the exit conditions fro `p_big_exit_time` time, in okapi units, before exiting `p_big_error` `p_big_error` big error threshold, in okapi length unit `p_velocity_exit_time` time, in okapi units, for velocity to be 0 -`p_mA_timeout` time, in okapi units, for `is_over_current` to be true +`p_mA_timeout` time, in okapi units, for `is_over_current` to be true +`use_imu` boolean, true adds the IMU to velocity timeouts, false only uses the PID sensor. This defaults to `true` ```cpp -void pid_drive_exit_condition_set(okapi::QTime p_small_exit_time, okapi::QLength p_small_error, okapi::QTime p_big_exit_time, okapi::QLength p_big_error, okapi::QTime p_velocity_exit_time, okapi::QTime p_mA_timeout); +void pid_drive_exit_condition_set(okapi::QTime p_small_exit_time, okapi::QLength p_small_error, okapi::QTime p_big_exit_time, okapi::QLength p_big_error, okapi::QTime p_velocity_exit_time, okapi::QTime p_mA_timeout, use_imu = true); ``` @@ -388,7 +389,8 @@ Sets the exit condition constants for turning. This uses the exit conditions fro `p_big_exit_time` time, in okapi units, before exiting `p_big_error` `p_big_error` big error threshold, in okapi angle unit `p_velocity_exit_time` time, in okapi units, for velocity to be 0 -`p_mA_timeout` time, in okapi units, for `is_over_current` to be true +`p_mA_timeout` time, in okapi units, for `is_over_current` to be true +`use_imu` boolean, true adds the IMU to velocity timeouts, false only uses the PID sensor. This defaults to `true` ```cpp -void pid_turn_exit_condition_set(okapi::QTime p_small_exit_time, okapi::QAngle p_small_error, okapi::QTime p_big_exit_time, okapi::QAngle p_big_error, okapi::QTime p_velocity_exit_time, okapi::QTime p_mA_timeout); +void pid_turn_exit_condition_set(okapi::QTime p_small_exit_time, okapi::QAngle p_small_error, okapi::QTime p_big_exit_time, okapi::QAngle p_big_error, okapi::QTime p_velocity_exit_time, okapi::QTime p_mA_timeout, use_imu = true); ``` @@ -434,6 +436,7 @@ Sets the exit condition constants for swing turns. This uses the exit conditions `p_big_error` big error threshold, in okapi angle unit `p_velocity_exit_time` time, in okapi units, for velocity to be 0 `p_mA_timeout` time, in okapi units, for `is_over_current` to be true +`use_imu` boolean, true adds the IMU to velocity timeouts, false only uses the PID sensor. This defaults to `true` ```cpp -void pid_swing_exit_condition_set(okapi::QTime p_small_exit_time, okapi::QAngle p_small_error, okapi::QTime p_big_exit_time, okapi::QAngle p_big_error, okapi::QTime p_velocity_exit_time, okapi::QTime p_mA_timeout); +void pid_swing_exit_condition_set(okapi::QTime p_small_exit_time, okapi::QAngle p_small_error, okapi::QTime p_big_exit_time, okapi::QAngle p_big_error, okapi::QTime p_velocity_exit_time, okapi::QTime p_mA_timeout, use_imu = true); +``` + + + + +### pid_drive_chain_constant_set() +Sets the amount that the PID will overshoot target by to maintain momentum into the next motion when using `pid_wait_quick_chain()` for drive motions. + +`input` okapi length unit + + + +```cpp +void initialize() { + chassis.pid_drive_chain_constant_set(3_in); +} +``` + + + +```cpp +void pid_drive_chain_constant_set(okapi::QLength input); +``` + + + + +### pid_drive_chain_forward_constant_set() +Sets the amount that the PID will overshoot target by to maintain momentum into the next motion when using `pid_wait_quick_chain()` for forward drive motions. + +`input` okapi length unit + + + +```cpp +void initialize() { + chassis.pid_drive_chain_forward_constant_set(3_in); +} +``` + + + +```cpp +void pid_drive_chain_forward_constant_set(okapi::QLength input); +``` + + + + +### pid_drive_chain_backward_constant_set() +Sets the amount that the PID will overshoot target by to maintain momentum into the next motion when using `pid_wait_quick_chain()` for backward drive motions. + +`input` okapi length unit + + + +```cpp +void initialize() { + chassis.pid_drive_chain_backward_constant_set(3_in); +} +``` + + + +```cpp +void pid_drive_chain_backward_constant_set(okapi::QLength input); +``` + + + + +### pid_turn_chain_constant_set() +Sets the amount that the PID will overshoot target by to maintain momentum into the next motion when using `pid_wait_quick_chain()` for turns. + +`input` okapi angle unit + + + +```cpp +void initialize() { + chassis.pid_turn_chain_constant_set(3_deg); +} +``` + + + +```cpp +void pid_turn_chain_constant_set(okapi::QAngle input); +``` + + + + + +### pid_swing_chain_constant_set() +Sets the amount that the PID will overshoot target by to maintain momentum into the next motion when using `pid_wait_quick_chain()` for swings. + +`input` okapi angle unit + + + +```cpp +void initialize() { + chassis.pid_swing_chain_constant_set(5_deg); +} +``` + + + +```cpp +void pid_swing_chain_constant_set(okapi::QAngle input); +``` + + + +### pid_swing_chain_forward_constant_set() +Sets the amount that the PID will overshoot target by to maintain momentum into the next motion when using `pid_wait_quick_chain()` for forward swings. + +`input` okapi angle unit + + + +```cpp +void initialize() { + chassis.pid_swing_chain_forward_constant_set(5_deg); +} +``` + + + +```cpp +void pid_swing_chain_forward_constant_set(okapi::QAngle input); +``` + + + + +### pid_swing_chain_backward_constant_set() +Sets the amount that the PID will overshoot target by to maintain momentum into the next motion when using `pid_wait_quick_chain()` for backward swings. + +`input` okapi angle unit + + + +```cpp +void initialize() { + chassis.pid_swing_chain_backward_constant_set(5_deg); +} ``` + + +```cpp +void pid_swing_chain_backward_constant_set(okapi::QAngle input); +``` + ### pid_wait_until() Locks the code in place until the drive has passed the input parameter. This uses the exit conditions from the PID class. This only works for drive motions. @@ -831,6 +1037,7 @@ This function can also be used without okapi units. `p_big_error` big error threshold, assumed inches `p_velocity_exit_time` time, in ms, for velocity to be 0 `p_mA_timeout` time, in ms, for `is_over_current` to be true +`use_imu` boolean, true adds the IMU to velocity timeouts, false only uses the PID sensor. This defaults to `true` ```cpp -void pid_drive_exit_condition_set(int p_small_exit_time, double p_small_error, int p_big_exit_time, double p_big_error, int p_velocity_exit_time, int p_mA_timeout); +void pid_drive_exit_condition_set(int p_small_exit_time, double p_small_error, int p_big_exit_time, double p_big_error, int p_velocity_exit_time, int p_mA_timeout, use_imu = true); ``` @@ -873,6 +1080,7 @@ This function can also be used without okapi units. `p_big_error` big error threshold, assumed degrees `p_velocity_exit_time` time, in ms, for velocity to be 0 `p_mA_timeout` time, in ms, for `is_over_current` to be true +`use_imu` boolean, true adds the IMU to velocity timeouts, false only uses the PID sensor. This defaults to `true` ```cpp -void pid_turn_exit_condition_set(int p_small_exit_time, double p_small_error, int p_big_exit_time, double p_big_error, int p_velocity_exit_time, int p_mA_timeout); +void pid_turn_exit_condition_set(int p_small_exit_time, double p_small_error, int p_big_exit_time, double p_big_error, int p_velocity_exit_time, int p_mA_timeout, use_imu = true); ``` @@ -914,6 +1122,7 @@ This function can also be used without okapi units. `p_big_error` big error threshold, assumed degrees `p_velocity_exit_time` time, in ms, for velocity to be 0 `p_mA_timeout` time, in ms, for `is_over_current` to be true +`use_imu` boolean, true adds the IMU to velocity timeouts, false only uses the PID sensor. This defaults to `true` ```cpp -void pid_swing_exit_condition_set(int p_small_exit_time, double p_small_error, int p_big_exit_time, double p_big_error, int p_velocity_exit_time, int p_mA_timeout); +void pid_swing_exit_condition_set(int p_small_exit_time, double p_small_error, int p_big_exit_time, double p_big_error, int p_velocity_exit_time, int p_mA_timeout, use_imu = true); ``` @@ -1328,165 +1537,453 @@ void pid_swing_constants_backward_set(double p, double i = 0.0, double d = 0.0, - -### pid_swing_min_set() -Sets the max power of the drive when the robot is within `start_i`. This only enables when `i` is enabled, and when the movement is greater then `start_i`. - -`min` the minimum speed the robot will turn at when integral is being used +### pid_drive_chain_constant_set() +Sets the amount that the PID will overshoot target by to maintain momentum into the next motion when using `pid_wait_quick_chain()` for drive motions. + +`input` double, length in inches - - ```cpp -void autonomous() { - chassis.pid_swing_min_set(30); - - chassis.pid_swing_set(45, 110); - chassis.pid_wait(); +void initialize() { + chassis.pid_drive_chain_constant_set(3); } ``` - - - - ```cpp -void pid_swing_min_set(int min); +void pid_drive_chain_constant_set(double input); ``` - - - - - - - -### pid_turn_min_set() -Sets the max power of the drive when the robot is within `start_i`. This only enables when `i` is enabled, and when the movement is greater then `start_i`. - -`min` the minimum speed the robot will turn at when integral is being used +### pid_drive_chain_forward_constant_set() +Sets the amount that the PID will overshoot target by to maintain momentum into the next motion when using `pid_wait_quick_chain()` for forward drive motions. + +`input` double, length in inches - ```cpp -void autonomous() { - chassis.pid_turn_min_set(30); - - chassis.pid_turn_set(45, 110); - chassis.pid_wait(); +void initialize() { + chassis.pid_drive_chain_forward_constant_set(3); } ``` - - - ```cpp -void pid_turn_min_set(int min); +void pid_drive_chain_forward_constant_set(double input); ``` - - - - - - -### drive_mode_set() -Sets the current mode of the drive. - -`p_mode` the current task running for the drive. accepts `ez::DISABLE`, `ez::SWING`, `ez::TURN`, `ez::DRIVE` +### pid_drive_chain_backward_constant_set() +Sets the amount that the PID will overshoot target by to maintain momentum into the next motion when using `pid_wait_quick_chain()` for backward drive motions. + +`input` double, length in inches - ```cpp -void autonomous() { - chassis.pid_drive_set(12, DRIVE_SPEED); - chassis.pid_wait(); - - chassis.drive_mode_set(ez::DISABLE); // Disable drive - - chassis.drive_set(-127, -127); // Run drive motors myself - pros::delay(2000); - chassis.drive_set(0, 0); +void initialize() { + chassis.pid_drive_chain_backward_constant_set(3); } ``` - - - ```cpp -void drive_mode_set(e_mode p_mode); +void pid_drive_chain_backward_constant_set(double input); ``` - - - -### pid_drive_toggle() -Enables/disables the drive from moving in autonomous. This is useful for debugging and checking PID variables. - -`toggle` true enables the drive, false disables the drive +### pid_turn_chain_constant_set() +Sets the amount that the PID will overshoot target by to maintain momentum into the next motion when using `pid_wait_quick_chain()` for turns. + +`input` double, angle in degrees - ```cpp -void autonomous() { - chassis.pid_drive_set(12, DRIVE_SPEED); - chassis.pid_wait(); - - pid_drive_toggle(false); // Disable drive - - chassis.pid_drive_set(-12, DRIVE_SPEED); - while (true) { - printf(" Left Error: %f Right Error: %f\n", chassis.leftPID.error, chassis.rightPID.error); - pros::delay(ez::util::DELAY_TIME); - } +void initialize() { + chassis.pid_turn_chain_constant_set(3); +} +``` + + + +```cpp +void pid_turn_chain_constant_set(double input); +``` + + + + +### pid_swing_chain_constant_set() +Sets the amount that the PID will overshoot target by to maintain momentum into the next motion when using `pid_wait_quick_chain()` for swings. + +`input` double, angle in degrees + + + +```cpp +void initialize() { + chassis.pid_swing_chain_constant_set(5); +} +``` + + + +```cpp +void pid_swing_chain_constant_set(double input); +``` + + + + +### pid_swing_chain_forward_constant_set() +Sets the amount that the PID will overshoot target by to maintain momentum into the next motion when using `pid_wait_quick_chain()` for forward swings. + +`input` double, angle in degrees + + + +```cpp +void initialize() { + chassis.pid_swing_chain_forward_constant_set(5); +} +``` + + + +```cpp +void pid_swing_chain_forward_constant_set(double input); +``` + + + + +### pid_swing_chain_backward_constant_set() +Sets the amount that the PID will overshoot target by to maintain momentum into the next motion when using `pid_wait_quick_chain()` for backward swings. + +`input` double, angle in degrees + + + +```cpp +void initialize() { + chassis.pid_swing_chain_backward_constant_set(5); +} +``` + + + +```cpp +void pid_swing_chain_backward_constant_set(double input); +``` + + + + +### pid_swing_min_set() +Sets the max power of the drive when the robot is within `start_i`. This only enables when `i` is enabled, and when the movement is greater then `start_i`. + +`min` the minimum speed the robot will turn at when integral is being used + + + + + +```cpp +void autonomous() { + chassis.pid_swing_min_set(30); + + chassis.pid_swing_set(45, 110); + chassis.pid_wait(); +} +``` + + + + + + + +```cpp +void pid_swing_min_set(int min); +``` + + + + + + + + + + + +### pid_turn_min_set() +Sets the max power of the drive when the robot is within `start_i`. This only enables when `i` is enabled, and when the movement is greater then `start_i`. + +`min` the minimum speed the robot will turn at when integral is being used + + + + +```cpp +void autonomous() { + chassis.pid_turn_min_set(30); + + chassis.pid_turn_set(45, 110); + chassis.pid_wait(); +} +``` + + + + + + +```cpp +void pid_turn_min_set(int min); +``` + + + + + + + + + + +### drive_mode_set() +Sets the current mode of the drive. + +`p_mode` the current task running for the drive. accepts `ez::DISABLE`, `ez::SWING`, `ez::TURN`, `ez::DRIVE` + + + + +```cpp +void autonomous() { + chassis.pid_drive_set(12, DRIVE_SPEED); + chassis.pid_wait(); + + chassis.drive_mode_set(ez::DISABLE); // Disable drive + + chassis.drive_set(-127, -127); // Run drive motors myself + pros::delay(2000); + chassis.drive_set(0, 0); +} +``` + + + + + + +```cpp +void drive_mode_set(e_mode p_mode); +``` + + + + + + +### drive_rpm_set() +Sets a new RPM for the drive. This is can be used when a drive has a transmission. + +`rpm` the rpm of the wheel + + + + +```cpp +void drive_example() { + chassis.pid_drive_set(24_in, DRIVE_SPEED); + chassis.pid_wait(); + + chassis.drive_rpm_set(50); // Engage torque rpm + + chassis.pid_drive_set(-24_in, DRIVE_SPEED); + chassis.pid_wait(); + + chassis.drive_rpm_set(343); // Return back to normal rpm +} +``` + + + + + + +```cpp +void drive_rpm_set(double rpm); +``` + + + + + + +### drive_ratio_set() +Sets a new ratio for the drive. This is can be used when a drive has a transmission. This should be `wheel / motor`. + +`ratio` the new of the drive + + + + +```cpp +void drive_example() { + chassis.pid_drive_set(24_in, DRIVE_SPEED); + chassis.pid_wait(); + + chassis.drive_ratio_set(0.083); // Engage torque rpm + + chassis.pid_drive_set(-24_in, DRIVE_SPEED); + chassis.pid_wait(); + + chassis.drive_ratio_set(1.79); // Return back to normal rpm +} +``` + + + + + + +```cpp +void drive_ratio_set(double ratio); +``` + + + + + + + +### pid_drive_toggle() +Enables/disables the drive from moving in autonomous. This is useful for debugging and checking PID variables. + +`toggle` true enables the drive, false disables the drive + + + + +```cpp +void autonomous() { + chassis.pid_drive_set(12, DRIVE_SPEED); + chassis.pid_wait(); + + pid_drive_toggle(false); // Disable drive + + chassis.pid_drive_set(-12, DRIVE_SPEED); + while (true) { + printf(" Left Error: %f Right Error: %f\n", chassis.leftPID.error, chassis.rightPID.error); + pros::delay(ez::util::DELAY_TIME); + } } ``` @@ -1720,7 +2217,145 @@ int pid_turn_min_get(); +### pid_drive_chain_forward_constant_get() +Returns a double that's the amount that the PID will overshoot target by to maintain momentum into the next motion when using `pid_wait_quick_chain()` for forward drive motions. + + + +```cpp +void initialize() { + chassis.pid_drive_chain_constant_set(3_in); + printf("%.2f\n", chassis.pid_drive_chain_forward_constant_get()); +} +``` + + + +```cpp +double pid_drive_chain_forward_constant_get(); +``` + + + + +### pid_drive_chain_backward_constant_get() +Returns a double that's the amount that the PID will overshoot target by to maintain momentum into the next motion when using `pid_wait_quick_chain()` for backward drive motions. + + + +```cpp +void initialize() { + chassis.pid_drive_chain_constant_set(3_in); + printf("%.2f\n", chassis.pid_drive_chain_backward_constant_get()); +} +``` + + + +```cpp +double pid_drive_chain_backward_constant_get(); +``` + + + + + +### pid_turn_chain_constant_get() +Returns a double that's the amount that the PID will overshoot target by to maintain momentum into the next motion when using `pid_wait_quick_chain()` for turns. + + + +```cpp +void initialize() { + chassis.pid_turn_chain_constant_set(3_deg); + printf("%.2f\n", chassis.pid_turn_chain_constant_get()); +} +``` + + + +```cpp +double pid_turn_chain_constant_get(); +``` + + + + +### pid_swing_chain_forward_constant_get() +Returns a double that's the amount that the PID will overshoot target by to maintain momentum into the next motion when using `pid_wait_quick_chain()` for forward swings. + + + +```cpp +void initialize() { + chassis.pid_swing_chain_constant_set(5_deg); + printf("%.2f\n", chassis.pid_swing_chain_forward_constant_get()); +} +``` + + + +```cpp +double pid_swing_chain_forward_constant_get(); +``` + + + + +### pid_swing_chain_backward_constant_get() +Returns a double that's the amount that the PID will overshoot target by to maintain momentum into the next motion when using `pid_wait_quick_chain()` for backward swings. + + + +```cpp +void initialize() { + chassis.pid_swing_chain_constant_set(5_deg); + printf("%.2f\n", chassis.pid_swing_chain_backward_constant_get()); +} +``` + + +```cpp +double pid_swing_chain_backward_constant_get(); +``` + + @@ -1884,6 +2519,93 @@ double drive_tick_per_inch(); +### drive_rpm_get() +Returns RPM for the drive. This is can be used when a drive has a transmission. + + + + +```cpp +void drive_example() { + chassis.pid_drive_set(24_in, DRIVE_SPEED); + chassis.pid_wait(); + + chassis.drive_rpm_set(50); // Engage torque rpm + printf("%.2f\n", chassis.drive_rpm_get()); + + chassis.pid_drive_set(-24_in, DRIVE_SPEED); + chassis.pid_wait(); + + chassis.drive_rpm_set(343); // Return back to normal + printf("%.2f\n", chassis.drive_rpm_get()); +} +``` + + + + + + +```cpp +double drive_rpm_get(); +``` + + + + + + +### drive_ratio_get() +Returns ratio for the drive. This is can be used when a drive has a transmission. This should be `wheel / motor`. + + + + +```cpp +void drive_example() { + chassis.pid_drive_set(24_in, DRIVE_SPEED); + chassis.pid_wait(); + + chassis.drive_ratio_set(0.083); // Engage torque rpm + printf("%.2f\n", chassis.drive_ratio_get()); + + chassis.pid_drive_set(-24_in, DRIVE_SPEED); + chassis.pid_wait(); + + chassis.drive_ratio_set(1.79); // Return back to normal rpm + printf("%.2f\n", chassis.drive_ratio_get()); +} +``` + + + + + + +```cpp +double drive_ratio_get(); +``` + + + + + + + @@ -1934,11 +2656,89 @@ void pid_wait(); +### pid_wait_quick() +Locks the code in place until the drive passes target. This function exits quicker then `pid_wait()`, and is effectively using `pid_wait_until(target)`, where `target` is the most recent targe value that was set. If `target` is not overshot, this will use the normal exit conditions from the PID class. + + + + +```cpp +void autonomous() { + chassis.drive_imu_reset(); + chassis.drive_sensor_reset(); + chassis.drive_brake_set(MOTOR_BRAKE_HOLD); + + chassis.pid_turn_set(90, 110); + chassis.pid_wait_quick(); + + chassis.pid_turn_set(0, 110); + chassis.pid_wait_quick(); +} +``` + + + + + + + +```cpp +void pid_wait_quick(); +``` + + + + + + +### pid_wait_quick_chain() +Locks the code in place until the drive passes target. To ensure that the robot will pass the target, this function will add some amount, such as `pid_turn_chain_constant_set(3_deg);`, to target, then will act as a wrapper for `pid_wait_quick()`. If target is not overshot, this will use the normal exit conditions from the PID class. + +Because this function adds to target, this should **not** be used as a final wait. This should be used between motions. + + + + + +```cpp +void autonomous() { + chassis.drive_imu_reset(); + chassis.drive_sensor_reset(); + chassis.drive_brake_set(MOTOR_BRAKE_HOLD); + + chassis.pid_turn_set(90, 110); + chassis.pid_wait_quick_chain(); + + chassis.pid_turn_set(0, 110); + chassis.pid_wait_quick(); +} +``` + + +```cpp +void pid_wait_quick_chain(); +``` + + \ No newline at end of file diff --git a/ez-template-docs/docs/auton_selector.md b/ez-template-docs/docs/auton_selector.md index d1bc154b..bbacf4ae 100644 --- a/ez-template-docs/docs/auton_selector.md +++ b/ez-template-docs/docs/auton_selector.md @@ -65,8 +65,8 @@ Sets external buttons to increase/decrease the current autonomous page. ```cpp -pros::ADIDigitalIn increase('A'); -pros::ADIDigitalIn decrease('B'); +pros::adi::DigitalIn increase('A'); +pros::adi::DigitalIn decrease('B'); void initialize() { ez::as::initialize(); ez::as::limit_switch_lcd_initialize(&increase, &decrease); @@ -81,7 +81,7 @@ void initialize() { ```cpp -void limit_switch_lcd_initialize(pros::ADIDigitalIn* right_limit, pros::ADIDigitalIn* left_limit = nullptr); +void limit_switch_lcd_initialize(pros::adi::DigitalIn* right_limit, pros::adi::DigitalIn* left_limit = nullptr); ``` diff --git a/ez-template-docs/docs/constructor.md b/ez-template-docs/docs/constructor.md index e52ab317..b0603b03 100644 --- a/ez-template-docs/docs/constructor.md +++ b/ez-template-docs/docs/constructor.md @@ -11,49 +11,56 @@ import TabItem from '@theme/TabItem'; ## Integrated Encoders -This is the standard setup that uses built in motor encoders. - -`left_motor_ports` a vector of left motor ports, negative reverses the port. first motor is used for sensing -`right_motor_ports` a vector of right motor ports, negative reverses the port. first motor is used for sensing -`imu_port` the port an imu is in -`wheel_diameter` diameter of your drive wheel -`ticks` cartridge rpm -`ratio` external ratio of your drive. should be wheel gear / motor gear +This is the standard setup that uses built in motor encoders. + +`left_motor_ports` a vector of left motor ports, negative reverses the port. first motor is used for sensing +`right_motor_ports` a vector of right motor ports, negative reverses the port. first motor is used for sensing +`imu_port` the port an imu is in +`wheel_diameter` diameter of your drive wheel +`ticks` cartridge rpm +`ratio` external ratio of your drive. should be wheel gear / motor gear. this is defaulted to 1.0 -```cpp -ez::Drive chassis ( - // Left Chassis Ports (negative port will reverse it!) - // the first port is the sensored port (when trackers are not used!) - {1, -2, 3} + ```cpp +ez::Drive chassis( + // These are your drive motors, the first motor is used for sensing! + {1, 2, 3}, // Left Chassis Ports (negative port will reverse it!) + {-4, -5, -6}, // Right Chassis Ports (negative port will reverse it!) - // Right Chassis Ports (negative port will reverse it!) - // the first port is the sensored port (when trackers are not used!) - ,{-4, 5, -6} + 7, // IMU Port + 4.125, // Wheel Diameter (Remember, 4" wheels without screw holes are actually 4.125!) + 343); // Wheel RPM +``` - // IMU Port - ,7 + - // Wheel Diameter (Remember, 4" wheels are actually 4.125!) - ,4.125 - // Cartridge RPM - ,600 + - // External Gear Ratio (MUST BE DECIMAL) - // eg. if your drive is 84:36 where the 36t is powered, your RATIO would be 2.333. - // eg. if your drive is 36:60 where the 60t is powered, your RATIO would be 0.6. - ,2.333 -); +```cpp +ez::Drive chassis( + // These are your drive motors, the first motor is used for sensing! + {1, 2, 3}, // Left Chassis Ports (negative port will reverse it!) + {-4, -5, -6}, // Right Chassis Ports (negative port will reverse it!) + + 7, // IMU Port + 4.125, // Wheel Diameter (Remember, 4" wheels without screw holes are actually 4.125!) + 600, // Cartridge RPM + + // External Gear Ratio (MUST BE DECIMAL) This is WHEEL GEAR / MOTOR GEAR + // eg. if your drive is 84:36 where the 36t is powered, your RATIO would be 84/36 which is 2.333 + // eg. if your drive is 36:60 where the 60t is powered, your RATIO would be 36/60 which is 0.6 + 1.43); ``` @@ -78,16 +85,16 @@ double wheel_diameter, double ticks, double ratio); ## ADI Encoders in Brain -Only supports parallel trackers. - -`left_motor_ports` a vector of left motor ports, negative reverses the port -`right_motor_ports` a vector of right motor ports, negative reverses the port -`imu_port` the port an imu is in -`wheel_diameter` diameter of your tracking wheel -`ticks` ticks per rotation of your sensor. 360 if using ADI quadrature encoders -`ratio` external ratio of your tracking wheel. should be wheel gear / motor gear -`left_tracker_ports` vector of left tracker ports, negative will reverse the encoder -`right_tracker_ports` vector of right tracker ports, negative will reverse the encoder +Only supports parallel trackers. + +`left_motor_ports` a vector of left motor ports, negative reverses the port +`right_motor_ports` a vector of right motor ports, negative reverses the port +`imu_port` the port an imu is in +`wheel_diameter` diameter of your tracking wheel +`ticks` ticks per rotation of your sensor. 360 if using ADI quadrature encoders +`ratio` external ratio of your tracking wheel. should be wheel gear / motor gear +`left_tracker_ports` vector of left tracker ports, negative will reverse the encoder +`right_tracker_ports` vector of right tracker ports, negative will reverse the encoder ```cpp -// Chassis constructor -ez::Drive chassis ( - // Left Chassis Ports (negative port will reverse it!) - {1, -2, 3} - - // Right Chassis Ports (negative port will reverse it!) - ,{-4, 5, -6} - - // IMU Port - ,7 - - // Tracking Wheel Diameter (Remember, 4" wheels are actually 4.125!) - ,4.125 - - // Ticks per Rotation of Encoder - ,360 - - // External Gear Ratio of Tracking Wheel (MUST BE DECIMAL) - // eg. if your drive is 84:36 where the 36t is sensored, your RATIO would be 2.333. - // eg. if your drive is 36:60 where the 60t is sensored, your RATIO would be 0.6. - ,1 - - // Left Tracking Wheel Ports (negative port will reverse it!) - ,{1, 2} - - // Right Tracking Wheel Ports (negative port will reverse it!) - ,{-3, -4} -); +ez::Drive chassis( + // These are your drive motors, the first motor is used for sensing! + {1, 2, 3}, // Left Chassis Ports (negative port will reverse it!) + {-4, -5, -6}, // Right Chassis Ports (negative port will reverse it!) + + 7, // IMU Port + 4.125, // Wheel Diameter (Remember, 4" wheels without screw holes are actually 4.125!) + 360, // Ticks per Rotation of Encoder + + // External Gear Ratio (MUST BE DECIMAL) This is WHEEL GEAR / SENSOR GEAR + // eg. if your drive is 84:36 where the 36t is sensored, your RATIO would be 84/36 which is 2.333 + // eg. if your drive is 36:60 where the 60t is sensored, your RATIO would be 36/60 which is 0.6 + 1, + + {1, 2}, // Left Tracking Wheel Ports (negative port will reverse it!) + {-3, -4}); // Right Tracking Wheel Ports (negative port will reverse it!) ``` @@ -153,16 +148,16 @@ std::vector right_tracker_ports); ## ADI Encoders in Expander -Only supports parallel trackers. - -`left_motor_ports` a vector of left motor ports, negative reverses the port -`right_motor_ports` a vector of right motor ports, negative reverses the port -`imu_port` the port an imu is in -`wheel_diameter` diameter of your tracking wheel -`ticks` ticks per rotation of your sensor. 360 if using ADI quadrature encoders -`ratio` external ratio of your tracking wheel. should be wheel gear / motor gear -`left_tracker_ports` vector of left tracker ports, negative will reverse the encoder -`right_tracker_ports` vector of right tracker ports, negative will reverse the encoder +Only supports parallel trackers. + +`left_motor_ports` a vector of left motor ports, negative reverses the port +`right_motor_ports` a vector of right motor ports, negative reverses the port +`imu_port` the port an imu is in +`wheel_diameter` diameter of your tracking wheel +`ticks` ticks per rotation of your sensor. 360 if using ADI quadrature encoders +`ratio` external ratio of your tracking wheel. should be wheel gear / motor gear +`left_tracker_ports` vector of left tracker ports, negative will reverse the encoder +`right_tracker_ports` vector of right tracker ports, negative will reverse the encoder `expander_smart_port` port of the 3 wire expander ```cpp -// Chassis constructor -ez::Drive chassis ( - // Left Chassis Ports (negative port will reverse it!) - {1, -2, 3} - - // Right Chassis Ports (negative port will reverse it!) - ,{-4, 5, -6} - - // IMU Port - ,7 +ez::Drive chassis( + // These are your drive motors, the first motor is used for sensing! + {1, 2, 3}, // Left Chassis Ports (negative port will reverse it!) + {-4, -5, -6}, // Right Chassis Ports (negative port will reverse it!) - // Tracking Wheel Diameter (Remember, 4" wheels are actually 4.125!) - ,4.125 + 7, // IMU Port + 4.125, // Wheel Diameter (Remember, 4" wheels without screw holes are actually 4.125!) + 360, // Ticks per Rotation of Encoder - // Ticks per Rotation of Encoder - ,360 + // External Gear Ratio (MUST BE DECIMAL) This is WHEEL GEAR / SENSOR GEAR + // eg. if your drive is 84:36 where the 36t is sensored, your RATIO would be 84/36 which is 2.333 + // eg. if your drive is 36:60 where the 60t is sensored, your RATIO would be 36/60 which is 0.6 - // External Gear Ratio of Tracking Wheel(MUST BE DECIMAL) - // eg. if your drive is 84:36 where the 36t is sensored, your RATIO would be 2.333. - // eg. if your drive is 36:60 where the 60t is sensored, your RATIO would be 0.6. - ,1 + 1, - // Left Tracking Wheel Ports (negative port will reverse it!) - ,{1, 2} - - // Right Tracking Wheel Ports (negative port will reverse it!) - ,{-3, -4} - - // 3 Wire Port Expander Smart Port - ,9 -); + {1, 2}, // Left Tracking Wheel Ports (negative port will reverse it!) + {-3, -4}, // Right Tracking Wheel Ports (negative port will reverse it!) + 9); // 3 Wire Port Expander Smart Port ``` @@ -233,22 +215,16 @@ std::vector right_tracker_ports, int expander_smart_port); ## Rotation Sensor -:::warning - -Note: smart encoders might not work as intended as of of 2.0.0 - -::: - -Only supports parallel trackers. - -`left_motor_ports` a vector of left motor ports, negative reverses the port -`right_motor_ports` a vector of right motor ports, negative reverses the port -`imu_port` the port an imu is in -`wheel_diameter` diameter of your tracking wheel -`ticks` ticks per rotation of your sensor. 360 if using ADI quadrature encoders -`ratio` external ratio of your tracking wheel. should be wheel gear / motor gear -`left_rotation_port` port for left rotation sensor, negative reverses the port -`right_rotation_port` port for right rotation sensor, negative reverses the port +Only supports parallel trackers. + +`left_motor_ports` a vector of left motor ports, negative reverses the port +`right_motor_ports` a vector of right motor ports, negative reverses the port +`imu_port` the port an imu is in +`wheel_diameter` diameter of your tracking wheel +`ticks` ticks per rotation of your sensor. 360 if using ADI quadrature encoders +`ratio` external ratio of your tracking wheel. should be wheel gear / motor gear +`left_rotation_port` port for left rotation sensor, negative reverses the port +`right_rotation_port` port for right rotation sensor, negative reverses the port ```cpp -// Chassis constructor -ez::Drive chassis ( - // Left Chassis Ports (negative port will reverse it!) - // the first port is the sensored port (when trackers are not used!) - {1, -2, 3} - - // Right Chassis Ports (negative port will reverse it!) - // the first port is the sensored port (when trackers are not used!) - ,{-4, 5, -6} - - // IMU Port - ,7 - - // Wheel Diameter (Remember, 4" wheels are actually 4.125!) - // (or tracking wheel diameter) - ,4.125 - - // External Gear Ratio (MUST BE DECIMAL) - // (or gear ratio of tracking wheel) - // eg. if your drive is 84:36 where the 36t is powered, your RATIO would be 2.333. - // eg. if your drive is 36:60 where the 60t is powered, your RATIO would be 0.6. - ,1 - - // Left Rotation Port (negative port will reverse it!) - ,8 - - // Right Rotation Port (negative port will reverse it!) - ,-9 -); +ez::Drive chassis( + // These are your drive motors, the first motor is used for sensing! + {1, 2, 3}, // Left Chassis Ports (negative port will reverse it!) + {-4, -5, -6}, // Right Chassis Ports (negative port will reverse it!) + + 7, // IMU Port + 4.125, // Wheel Diameter (Remember, 4" wheels without screw holes are actually 4.125!) + + // External Gear Ratio (MUST BE DECIMAL) This is WHEEL GEAR / SENSOR GEAR + // eg. if your drive is 84:36 where the 36t is sensored, your RATIO would be 84/36 which is 2.333 + // eg. if your drive is 36:60 where the 60t is sensored, your RATIO would be 36/60 which is 0.6 + 1, + + 8, // Left Rotation Port (negative port will reverse it!) + -9); // Right Rotation Port (negative port will reverse it!) ``` diff --git a/ez-template-docs/docs/pid.md b/ez-template-docs/docs/pid.md index 88cca2ce..e49a6585 100644 --- a/ez-template-docs/docs/pid.md +++ b/ez-template-docs/docs/pid.md @@ -52,9 +52,117 @@ PID(double p, double i = 0, double d = 0, double start_i = 0, std::string name = - ## Functions + +### compute() +Computes PID. + +`current` the current sensor value for the subsystem + + + + +```cpp +ez::PID liftPID{1, 0.003, 4, 100, "Lift"}; +pros::Motor lift_motor(1); +void opcontrol() { + while (true) { + if (master.get_digital(DIGITAL_L1)) { + liftPID.target_set(500); + } + else if (master.get_digital(DIGITAL_L2)) { + liftPID.target_set(0); + } + lift_motor = liftPID.compute(lift_motor.get_position()); + + pros::delay(ez::util::DELAY_TIME); + } +} +``` + + + + + + + +```cpp +double compute(double current); +``` + + + + + + + + + + +### compute_error() +Computes PID based on error. This function ignores target entirely and the user has to calculate error. + +`error` the target minus current, you calculate this yourself +`current` the current sensor value for the subsystem + + + + +```cpp +ez::PID liftPID{1, 0.003, 4, 100, "Lift"}; +pros::Motor lift_motor(1); +void opcontrol() { + double target = 0.0; + double error = 0.0; + while (true) { + if (master.get_digital(DIGITAL_L1)) { + target = 500.0; + } + else if (master.get_digital(DIGITAL_L2)) { + target = 0.0; + } + error = target - lift_motor.get_position(); + lift_motor = liftPID.compute_error(error, lift_motor.get_position()); + + pros::delay(ez::util::DELAY_TIME); + } +} +``` + + + + + + + +```cpp +double compute_error(double err, double current); +``` + + + + + + + + +## Setters + ### constants_set() Sets PID constants. @@ -202,6 +310,169 @@ void exit_condition_set(int p_small_exit_time, double p_small_error, int p_big_e +### velocity_sensor_secondary_toggle_set() +Enables / disables the use of the second sensor. True enables this and uses the secondary sensor in velocity exits, false disables. + +`toggle` sensor value for the secondary sensor + + + + +```cpp +ez::PID liftPID; +void initialize() { + liftPID.velocity_sensor_secondary_toggle_set(true); // Enable the secondary sensor +} +``` + + + + + + +```cpp +void velocity_sensor_secondary_toggle_set(bool toggle); +``` + + + + + + + + + + +### velocity_sensor_secondary_set() +This sets the sensor value for the secondary sensor. The secondary sensor is used in addition to the main sensor for determining velocity exits, if enabled. + +`secondary_sensor` sensor value for the secondary sensor + + + + +```cpp +... +``` + + + + + + +```cpp +void velocity_sensor_secondary_set(double secondary_sensor); +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + +### velocity_sensor_main_exit_set() +Sets a threshold for the main sensors velocity. The velocity timer will start increasing when the main sensor is within this value. This is defaulted to `0.05`. + +`zero` double, a small threshold + + + + +```cpp +ez::PID liftPID; +void initialize() { + liftPID.velocity_sensor_secondary_toggle_set(true); // Enable the secondary sensor +} +``` + + + + + + +```cpp +void velocity_sensor_main_exit_set(double zero); +``` + + + + + + +### velocity_sensor_secondary_exit_set() +Sets a threshold for the secondary sensors velocity. The velocity timer will start increasing when the secondary sensor is within this value. This is defaulted to `0.1`. This is only used when the secondary sensor is enabled. + +`zero` double, a small threshold + + + + +```cpp +ez::PID liftPID; +void initialize() { + liftPID.velocity_sensor_secondary_toggle_set(true); // Enable the secondary sensor +} +``` + + + + + + +```cpp +void velocity_sensor_secondary_exit_set(double zero); +``` + + + @@ -246,16 +517,16 @@ void name_set(std::string name); - - +## Getters + -### compute() -Computes PID. +### target_set() +Sets PID target. -`current` the current sensor value for the subsystem +`target` the goal position for your subsystem ```cpp -double compute(double current); +double target_set(); ``` @@ -300,7 +573,161 @@ double compute(double current); - +### velocity_sensor_secondary_toggle_get() +Returns the value for the secondary sensor. The secondary sensor is used in addition to the main sensor for determining velocity exits, if enabled. + + + + + +```cpp +ez::PID liftPID; +void initialize() { + printf("%i\n",liftPID.velocity_sensor_secondary_toggle_get()); // This prints 0 + liftPID.velocity_sensor_secondary_toggle_set(true); // Enable the secondary sensor + printf("%i\n",liftPID.velocity_sensor_secondary_toggle_get()); // This prints 1 +} +``` + + + + + + +```cpp +double velocity_sensor_secondary_toggle_get(); +``` + + + + + + + + + + + +### velocity_sensor_main_exit_get() +Gets a threshold for the secondary sensors velocity. The velocity timer will start increasing when the secondary sensor is within this value. This is defaulted to `0.1`. + + + + +```cpp +ez::PID liftPID; +void initialize() { + liftPID.velocity_sensor_secondary_toggle_set(true); // Enable the secondary sensor + printf("%.2f\n",liftPID.velocity_sensor_main_exit_get()); // This prints 0.05 +} +``` + + + + + + +```cpp +double velocity_sensor_main_exit_get(); +``` + + + + + + + + + + + +### velocity_sensor_secondary_exit_get() +Gets a threshold for the secondary sensors velocity. The velocity timer will start increasing when the secondary sensor is within this value. This is defaulted to `0.1`. This is only used when the secondary sensor is enabled. + + + + +```cpp +ez::PID liftPID; +void initialize() { + liftPID.velocity_sensor_secondary_toggle_set(true); // Enable the secondary sensor + printf("%.2f\n",liftPID.velocity_sensor_secondary_exit_get()); // This prints 0.1 +} +``` + + + + + + +```cpp +double velocity_sensor_secondary_exit_get(); +``` + + + + + + + + + +### velocity_sensor_secondary_get() +Returns if the secondary sensor is enabled or disables. True means this is enabled and the secondary sensor is in use, false means disabled. + + + + + +```cpp +ez::PID liftPID; +void initialize() { + liftPID.velocity_sensor_secondary_toggle_set(true); // Enable the secondary sensor +} +``` + + + + + + +```cpp +double velocity_sensor_secondary_get(); +``` + + + + + + @@ -496,3 +923,53 @@ ez::exit_output exit_condition(std::vector sensor, bool print = fal + + + +### timers_reset() +Resets all timers for exit conditions. + + + + +```cpp +ez::PID liftPID{1, 0.003, 4, 100, "Lift"}; +pros::Motor lift_motor(1); +void opcontrol() { + while (true) { + if (master.get_digital(DIGITAL_L1)) { + liftPID.timers_reset(); + liftPID.target_set(500); + } + else if (master.get_digital(DIGITAL_L2)) { + liftPID.timers_reset(); + liftPID.target_set(0); + } + lift_motor = liftPID.compute(lift_motor.get_position()); + + pros::delay(ez::util::DELAY_TIME); + } +} +``` + + + + + + + +```cpp +void timers_reset(); +``` + + + + + \ No newline at end of file diff --git a/ez-template-docs/docs/set_and_get_drive.md b/ez-template-docs/docs/set_and_get_drive.md index 0920258e..6329a413 100644 --- a/ez-template-docs/docs/set_and_get_drive.md +++ b/ez-template-docs/docs/set_and_get_drive.md @@ -133,6 +133,8 @@ void drive_brake_set(pros::motor_brake_mode_e_t brake_type); + + @@ -171,7 +173,50 @@ void drive_current_limit_set(int mA); +### drive_imu_scaler_set() +Sets a scaler for the imu. This number is multiplied by the imu so users can tune what a "degree" is. + +`scaler` a small double + + + + +```cpp +void turn_example() { + chassis.drive_imu_scaler_set(2); + + // This will now turn to 45 real degrees + chassis.pid_turn_set(90_deg, TURN_SPEED); + chassis.pid_wait(); + + // This will turn to 22.5 real degrees + chassis.pid_turn_set(45_deg, TURN_SPEED); + chassis.pid_wait(); + + chassis.pid_turn_set(0_deg, TURN_SPEED); + chassis.pid_wait(); +} +``` + + + + + + +```cpp +void drive_imu_scaler_set(double scaler); +``` + + + @@ -653,9 +698,46 @@ double drive_imu_get(); +### drive_imu_accel_get() +Gets imu x + y acceleration. This is (optionally) used internally as the secondary sensor for velocity exiting. + + + + + +```cpp +void opcontrol() { + while (true) { + chassis.opcontrol_tank(); + + printf("Accel x + y: %f \n", chassis.drive_imu_accel_get()); + + pros::delay(ez::util::DELAY_TIME); + } +} +``` + + + + + + + +```cpp +double drive_imu_accel_get(); +``` + + + - ### drive_imu_calibrate() @@ -692,6 +774,78 @@ bool drive_imu_calibrate(); +### drive_imu_get() +Gets IMU sensor scaler. This number is multiplied by the imu so users can tune what a "degree" means. + + + + + +```cpp +... +``` + + + - \ No newline at end of file + + +```cpp +double drive_imu_scaler_get(); +``` + + + + + +### drive_imu_scaler_get() +Gets the scaler for the imu. This number is multiplied by the imu so users can tune what a "degree" is. + + + + +```cpp +void turn_example() { + chassis.drive_imu_scaler_set(2); + printf("%.2f\n", chassis.drive_imu_scaler_get()); // Prints 2 + + // This will now turn to 45 real degrees + chassis.pid_turn_set(90_deg, TURN_SPEED); + chassis.pid_wait(); + + // This will turn to 22.5 real degrees + chassis.pid_turn_set(45_deg, TURN_SPEED); + chassis.pid_wait(); + + chassis.pid_turn_set(0_deg, TURN_SPEED); + chassis.pid_wait(); +} +``` + + + + + + + +```cpp +double drive_imu_scaler_get(); +``` + + + \ No newline at end of file diff --git a/ez-template-docs/docs/slew.md b/ez-template-docs/docs/slew.md index d6bb5ebc..84530831 100644 --- a/ez-template-docs/docs/slew.md +++ b/ez-template-docs/docs/slew.md @@ -701,3 +701,124 @@ double output(); + + + + +### speed_max_set() +Sets the max speed slew can be. + +`speed` maximum speed the output can be + + + + +```cpp +PID lift_slew; +pros::Motor lift(1); +void initialize() { + lift_slew.constants_set(100, 50); + lift_slew.initialize(true, 127, 500, lift.get_position()); +} + +void autonomous() { + while (lift.get_position() <= 500) { + if (lift.get_position() < 100) + lift_slew.speed_max_set(50); + else + lift_slew.speed_max_set(127); + lift_slew.iterate(lift.get_position(); + lift = lift_slew.output(); + pros::delay(10); + } + lift = 0; +} +``` + + + + + + +```cpp +void speed_max_set(double speed); +``` + + + + + + + + + +### speed_max_set() +Returns the max speed slew can be. + + + + +```cpp +PID lift_slew; +pros::Motor lift(1); +void initialize() { + lift_slew.constants_set(100, 50); + lift_slew.initialize(true, 127, 500, lift.get_position()); +} + +void autonomous() { + while (lift.get_position() <= 500) { + if (lift.get_position() < 100) + lift_slew.speed_max_set(50); + else + lift_slew.speed_max_set(127); + printf("%.2f", lift_slew.speed_max_get()); + + lift_slew.iterate(lift.get_position(); + lift = lift_slew.output(); + pros::delay(10); + } + lift = 0; +} +``` + + + + + + +```cpp +double speed_max_get(); +``` + + + + + + + /** + * Sets the max speed the slew can be + * + * \param speed + * maximum speed + */ + void speed_max_set(double speed); + + /** + * Returns the max speed the slew can be + */ + double speed_max_get(); \ No newline at end of file diff --git a/ez-template-docs/migration.mdx b/ez-template-docs/migration.mdx index 6eb9a9f9..1b18ce24 100644 --- a/ez-template-docs/migration.mdx +++ b/ez-template-docs/migration.mdx @@ -4,7 +4,7 @@ title: 2.x -> 3.x :::danger -3.x has **breaking changes** from 2.x. This document is intended to help migrate your code to a fresh example project. +v3.x has **breaking changes** from v2.x. This document is intended to help migrate your existing v2.x project. ::: @@ -24,7 +24,7 @@ Be sure to check what you're replacing to avoid unintentionally breaking your co -| 2.x Name | 3.x Name | +| v2.x Name | v3.x Name | | --- | --- | | `tank()` | `opcontrol_tank()` | | `arcade_standard()` | `opcontrol_arcade_standard()` | @@ -89,7 +89,7 @@ Be sure to check what you're replacing to avoid unintentionally breaking your co -| 2.x Name | 3.x Name | +| v2.x Name | v3.x Name | | --- | --- | | `set_constants()` | `constants_set()` | | `get_constants()` | `constants_get()` | @@ -108,7 +108,7 @@ Be sure to check what you're replacing to avoid unintentionally breaking your co -| 2.x Name | 3.x Name | +| v2.x Name | v3.x Name | | --- | --- | | `call_selected_auton()` | `selected_auton_call()` | | `print_selected_auton()` | `selected_auton_print()` | diff --git a/src/pages/_support.md b/ez-template-docs/showcase.md similarity index 84% rename from src/pages/_support.md rename to ez-template-docs/showcase.md index 90a0e7b4..61c4b744 100644 --- a/src/pages/_support.md +++ b/ez-template-docs/showcase.md @@ -1,16 +1,18 @@ --- -title: support -unlisted: true +title: Showcase +draft: true +description: cool stuff that's ez --- -On this page we have ez related communities that you can be apart of. +This page various implementations of EZ-Template that are amazing! + +Have a run you want posted here? Ask in our [Discord Server](https://discord.gg/EHjXBcK2Gy) or email me at `jess@roboticsisez.com`. -Before participating in Docusaurus' communities, please read our Code of Conduct. We have adopted the Contributor Covenant and we expect that all community members adhere to the guidelines within. -# Discord +## Discord -# News +## News Follow [@roboticsisez](https://www.instagram.com/roboticsisez) on Instragram for the latest news! Support diff --git a/ez-template-docs/support.md b/ez-template-docs/support.md new file mode 100644 index 00000000..259f855c --- /dev/null +++ b/ez-template-docs/support.md @@ -0,0 +1,20 @@ +--- +title: Support +draft: true +description: ez support +--- + +# Support + +## [Discord Server](https://discord.gg/EHjXBcK2Gy) +Need extra assistance using EZ-Template? Feel free to join our [Discord Server](https://discord.gg/EHjXBcK2Gy)! + +## [Feature Requests](https://github.com/EZ-Robotics/EZ-Template/issues) +Have a cool new feature idea? Open a [GitHub Issue](https://github.com/EZ-Robotics/EZ-Template/issues) describing the feature you'd like and we'll see if we can implement it! Better yet, feel free to open a PR with the implemented feature! + + +## [Instagram](https://www.instagram.com/roboticsisez) +For the latest news about ez, [follow **@roboticsisez** on Instagram](https://www.instagram.com/roboticsisez)! + +## Email +For other inquires, you can email me at `jess@roboticsisez.com`. \ No newline at end of file diff --git a/ez-template-docs/tutorials/activebrake.md b/ez-template-docs/tutorials/activebrake.md index 85a49da6..4a7bca92 100644 --- a/ez-template-docs/tutorials/activebrake.md +++ b/ez-template-docs/tutorials/activebrake.md @@ -3,12 +3,14 @@ title: Active Brake description: Powerful, tunable brake for driver control --- -If you put the motors on brake type hold, a robot can still push the robot a bit, and when you let go of the joysticks the robot just locks in place. Active brake runs a P loop on the drive when you let go of the joysticks. By adjusting the kP, you adjust how hard the robot fights back. If you make it smaller, there will be a larger dead zone and you'll coast a little bit. Active brake vs brake type is personal preference. +By default, the drivetrain is on `coast` where if you let go of the joysticks the robot will continue to move a bit.  Generally, this seems like the preferred way the community likes to control their robots, and people don't really like the feel of driving on `brake` or `hold` (which is a decision that's fully preference-based).   -This is nice to use while the robot's brake mode is set to `coast` so you have full control over how much the robot will fight back when pushed. +Active brake gives you more control than these 3 states.  Active brake will run a P loop when you let go of the joysticks, giving you full control over how aggressive this is.  You can use it along with `coast` and have the `kP` be super low so you still feel like it's on coast but it'll only move so far.   -## Enabling -To adjust the kP, in `src/main.cpp` change `chassis.opcontrol_drive_activebrake_set(0)` to whatever you like! We suggest around `2.0`. - -## Disabling -To disable active brake, in `src/main.cpp` make sure the kP is 0 with `chassis.opcontrol_drive_activebrake_set(0)`. \ No newline at end of file +```cpp +void initialize() { +  // . . . + chassis.opcontrol_drive_activebrake_set(2.0);  // Sets the active brake kP. We recommend ~2.  0 will disable.   +  // . . . +} +``` \ No newline at end of file diff --git a/ez-template-docs/tutorials/autons.md b/ez-template-docs/tutorials/autons.md index be8e907f..0f152426 100644 --- a/ez-template-docs/tutorials/autons.md +++ b/ez-template-docs/tutorials/autons.md @@ -4,58 +4,64 @@ description: Add autonomous routines to the selector --- ## Learn to use Autonomous Functions -Read through `src/autons.cpp` ([or click here](https://ez-robotics.github.io/EZ-Template/tutorials/example_autons)) and learn how to use the autonomous functions by reading through the example routines! +Read through `src/autons.cpp` ([or click here](https://ez-robotics.github.io/EZ-Template/tutorials/example_autons)) and learn how to use the autonomous functions by reading through the example routines!   ## Make the Autonomous Routines -Make a new function in `src/autons.cpp` and name it something that says what the autonomous will do. +Make a new function in `src/autons.cpp` and name it something that says what the autonomous will do.   ```cpp void SoloAWP() { - // . . . - // Autonomous code goes here - // . . . +  // . . . +  // Autonomous code goes here +  // . . . } void ScoreRingsPlatDown() { - // . . . - // Autonomous code goes here - // . . . +  // . . . +  // Autonomous code goes here +  // . . . } void NeutralStealPlatDown() { - // . . . - // Autonomous code goes here - // . . . +  // . . . +  // Autonomous code goes here +  // . . . } void NeutralStealPlatUp() { - // . . . - // Autonomous code goes here - // . . . +  // . . . +  // Autonomous code goes here +  // . . . } ``` ## Add it to `autons.hpp` -In `include/autons.hpp` add the name of your function. +In `include/autons.hpp` add the name of your function.   ```cpp +#pragma once + +#include "EZ-Template/drive/drive.hpp" + +extern Drive chassis; + void SoloAWP(); void ScoreRingsPlatDown(); void NeutralStealPlatDown(); void NeutralStealPlatUp(); ``` ## Add it to the Autonomous Selector -To add the autonomous mode to the on screen selector, in `src/main.cpp` go to `void initialize()` and either replace an existing autonomous mode or add new pages. [Click here](https://ez-robotics.github.io/EZ-Template/tutorials/using_auton_selector) to learn how to use the autonomous selector. +To add the autonomous mode to the on-screen selector, in `src/main.cpp` go to `void initialize()` and either replace an existing autonomous mode or add new pages.  [Click here](https://ez-robotics.github.io/EZ-Template/tutorials/using_auton_selector) to learn how to use the autonomous selector.     ```cpp void initialize() { - . . . + . . . - // Autonomous Selector using LLEMMU - ez::as::auton_selector.autons_add({ - Auton("Solo AWP\n\nStarting Position: Plat Down", SoloAWP), - Auton("Score Rings on Amogo\n\nStarting Position: Plat Down", ScoreRingsPlatDown), - Auton("Neutral Steal\n\nStarting Position: Plat Down", NeutralStealPlatDown), - Auton("Neutral Steal\n\nStarting Position: Plat Up", NeutralStealPlatUp), - }); +  // Autonomous Selector using LLEMMU +  ez::as::auton_selector.autons_add({ +    Auton("Solo AWP\n\nStarting Position: Plat Down", SoloAWP), +    Auton("Score Rings on Amogo\n\nStarting Position: Plat Down", ScoreRingsPlatDown), +    Auton("Neutral Steal\n\nStarting Position: Plat Down", NeutralStealPlatDown), +    Auton("Neutral Steal\n\nStarting Position: Plat Up", NeutralStealPlatUp), + }); - . . . + . . . } ``` \ No newline at end of file diff --git a/ez-template-docs/tutorials/control_schemes.md b/ez-template-docs/tutorials/control_schemes.md new file mode 100644 index 00000000..6c8d481a --- /dev/null +++ b/ez-template-docs/tutorials/control_schemes.md @@ -0,0 +1,90 @@ +--- +title: Control Schemes +description: Examples and explanations of each way of controlling the chassis +--- +import Tabs from '@theme/Tabs'; +import TabItem from '@theme/TabItem'; + +# Control Schemes + +There are multiple ways of controlling your drive, split into two categories; tank and arcade.  EZ-Template supports both and you can pick which one you'd like to use by uncommenting it in the example project.   +```cpp +void opcontrol() { +  // . . . +  while (true) { +    // . . . + + chassis.opcontrol_tank();  // Tank control +    // chassis.opcontrol_arcade_standard(ez::SPLIT);  // Standard split arcade +    // chassis.opcontrol_arcade_standard(ez::SINGLE);  // Standard single arcade +    // chassis.opcontrol_arcade_flipped(ez::SPLIT);  // Flipped split arcade +    // chassis.opcontrol_arcade_flipped(ez::SINGLE);  // Flipped single arcade + +    // . . . +    pros::delay(ez::util::DELAY_TIME);  // This is used for timer calculations!  Keep this ez::util::DELAY_TIME +  } +} +``` + +## Tank +Tank lets you control each side of the drive.  The left stick controls the left side of the drive, and the right stick controls the right side of the drive.  This can be called in EZ-Template with `chassis.opcontrol_tank();`.  This is the default in the example project.   +```cpp +chassis.opcontrol_tank(); +``` + +## Arcade +Arcade drive is where you have control over "forward" and "turning".   + +### Split Arcade +EZ-Template lets you call "standard" arcade or "flipped" arcade.  Standard is where the left stick does fwd/rev and flipped is where the right stick does fwd/rev.  With split arcade, the other joystick is used for turning.   + + + + +```cpp +chassis.opcontrol_arcade_standard(ez::SPLIT); // Standard split arcade +``` + + + + + +```cpp +chassis.opcontrol_arcade_flipped(ez::SPLIT); // Flipped split arcade +``` + + + +### Single Stick Arcade +EZ-Template lets you call "standard" arcade or "flipped" arcade.  Standard is where the left stick does fwd/rev and flipped is where the right stick does fwd/rev.  With single stick arcade, turning is done on the same joystick as fwd/rev.   + + + + +```cpp +chassis.opcontrol_arcade_standard(ez::SINGLE); // Standard split arcade +``` + + + + + +```cpp +chassis.opcontrol_arcade_flipped(ez::SINGLE); // Flipped split arcade +``` + + diff --git a/ez-template-docs/tutorials/example_autons.md b/ez-template-docs/tutorials/example_autons.md index 4dfd9e77..fd508f6d 100644 --- a/ez-template-docs/tutorials/example_autons.md +++ b/ez-template-docs/tutorials/example_autons.md @@ -3,24 +3,25 @@ title: Example Autonomous Routines description: Some examples and test routines --- +Reading documentation can be overwhelming, so EZ-Template has example autonomous routines for you to use and modify on your own to learn by doing.   -## Assumed Constants +## Assumed Constants   These are default speeds that we can use throughout our autonomous routines to make it easier to modify them retroactively. ```cpp const int DRIVE_SPEED = 110; -const int TURN_SPEED = 90; +const int TURN_SPEED  = 90; const int SWING_SPEED = 90; ``` ## Drive -This autonomous routine will have the robot go forwards for 24 inches with slew enabled, come back -12 inches, then come back another -12 inches to where it started. It will do all of this at the predefined `DRIVE_SPEED`. +This autonomous routine will have the robot go forward for 24 inches with slew enabled, come back -12 inches, and then come back another -12 inches to where it started.  It will do all of this at the predefined `DRIVE_SPEED`. ```cpp void drive_example() { // The first parameter is target inches // The second parameter is max speed the robot will drive at // The third parameter is a boolean (true or false) for enabling/disabling a slew at the start of drive motions - // for slew, only enable it when the drive distance is greater then the slew distance + a few inches + // for slew, only enable it when the drive distance is greater than the slew distance + a few inches chassis.pid_drive_set(24_in, DRIVE_SPEED, true); chassis.pid_wait(); @@ -38,10 +39,10 @@ void drive_example() { ## Turn -This autonomous routine will turn 90 degrees, then back 45 degrees, and finally to 0 where it started. It will do all of this at the predefined `TURN_SPEED`. +This autonomous routine will turn 90 degrees, then back 45 degrees, and finally to 0 where it started.  It will do all of this at the predefined `TURN_SPEED`. ```cpp void turn_example() { - // The first parameter is target degrees + // The first parameter is the target in degrees // The second parameter is max speed the robot will drive at chassis.pid_turn_set(90_deg, TURN_SPEED); @@ -85,15 +86,15 @@ void drive_and_turn() { ## Wait Until and Changing Speed -Now we add `pid_wait_until()`. This new function will wait until a specified distance has been traveled and then allow the code to continue. The robot will drive at `DRIVE_SPEED` until the robot has traveled 6 inches, then will lower the max speed to 30. The same thing happens on the return back. +Now we add `pid_wait_until()`.  This new function will wait until a specified distance has been traveled and then allow the code to continue.  The robot will drive at `DRIVE_SPEED` until the robot has traveled 6 inches, then will lower the max speed to 30.  The same thing happens on the return back. ```cpp void wait_until_change_speed() { // pid_wait_until will wait until the robot gets to a desired position - // When the robot gets to 6 inches, the robot will travel the remaining distance at a max speed of 30 - chassis.pid_drive_set(24_in, DRIVE_SPEED, true); + // When the robot gets to 6 inches slowly, the robot will travel the remaining distance at full speed + chassis.pid_drive_set(24_in, 30, true); chassis.pid_wait_until(6_in); - chassis.pid_speed_max_set(30); // After driving 6 inches at DRIVE_SPEED, the robot will go the remaining distance at 30 speed + chassis.pid_speed_max_set(DRIVE_SPEED); // After driving 6 inches at 30 speed, the robot will go the remaining distance at DRIVE_SPEED chassis.pid_wait(); chassis.pid_turn_set(45_deg, TURN_SPEED); @@ -105,10 +106,10 @@ void wait_until_change_speed() { chassis.pid_turn_set(0_deg, TURN_SPEED); chassis.pid_wait(); - // When the robot gets to -6 inches, the robot will travel the remaining distance at a max speed of 30 - chassis.pid_drive_set(-24_in, DRIVE_SPEED, true); + // When the robot gets to -6 inches slowly, the robot will travel the remaining distance at full speed + chassis.pid_drive_set(-24_in, 30, true); chassis.pid_wait_until(-6_in); - chassis.pid_speed_max_set(30); // After driving 6 inches at DRIVE_SPEED, the robot will go the remaining distance at 30 speed + chassis.pid_speed_max_set(DRIVE_SPEED); // After driving 6 inches at 30 speed, the robot will go the remaining distance at DRIVE_SPEED chassis.pid_wait(); } ``` @@ -118,12 +119,12 @@ void wait_until_change_speed() { ## Swing Turns -Swing turns are turns that only use one side of the drive. Left swings use the left side, and right swings use the right side. This will drive in a segmented S curve. +Swing turns are turns that only use one side of the drive.  Left swings use the left side, and right swings use the right side.  This will drive in a segmented S curve.   ```cpp void swing_example() { // The first parameter is ez::LEFT_SWING or ez::RIGHT_SWING - // The second parameter is target degrees - // The third parameter is speed of the moving side of the drive + // The second parameter is the target in degrees + // The third parameter is the speed of the moving side of the drive // The fourth parameter is the speed of the still side of the drive, this allows for wider arcs chassis.pid_swing_set(ez::LEFT_SWING, 45_deg, SWING_SPEED, 45); @@ -137,6 +138,34 @@ void swing_example() { chassis.pid_swing_set(ez::LEFT_SWING, 0_deg, SWING_SPEED, 45); chassis.pid_wait(); +} +``` + + + +## Motion Chaining +Motion Chaining is when you exit a movement while the robot is still moving so you carry momentum into the next movement.   +```cpp +void motion_chaining() { + // Motion chaining is where motions all try to blend together instead of individual movements. + // This works by exiting while the robot is still moving a little bit. + // To use this, replace pid_wait with pid_wait_quick_chain. + chassis.pid_drive_set(24_in, DRIVE_SPEED, true); + chassis.pid_wait(); + + chassis.pid_turn_set(45_deg, TURN_SPEED); + chassis.pid_wait_quick_chain(); + + chassis.pid_turn_set(-45_deg, TURN_SPEED); + chassis.pid_wait_quick_chain(); + + chassis.pid_turn_set(0_deg, TURN_SPEED); + chassis.pid_wait(); + + // Your final motion should still be a normal pid_wait + chassis.pid_drive_set(-24_in, DRIVE_SPEED, true); + chassis.pid_wait(); +} ``` @@ -169,11 +198,11 @@ void combining_movements() { ## Interference -Interference checks if the drive exited in an unintentional way. If the robot stops unintentionally or pulls too many amps this will trigger. This allows you to add fail-safes that stop your robot from burning out. The below function will attempt to "tug" an opponent mobile goal a couple times before giving up. +Interference checks if the drive exited in an unintentional way.  If the robot stops unintentionally or pulls too many amps this will trigger.  This allows you to add fail-safes that stop your robot from burning out.  The below function will attempt to "tug" an opponent's mobile goal a couple of times before giving up. ```cpp void tug(int attempts) { for (int i = 0; i < attempts - 1; i++) { - // Attempt to drive backwards + // Attempt to drive backward printf("i - %i", i); chassis.pid_drive_set(-12_in, 127); chassis.pid_wait(); @@ -184,15 +213,15 @@ void tug(int attempts) { chassis.pid_drive_set(-2_in, 20); pros::delay(1000); } - // If robot successfully drove back, return + // If the robot successfully drove back, return else { return; } } } -// If there is no interference, robot will drive forward and turn 90 degrees. -// If interfered, robot will drive forward and then attempt to drive backwards. +// If there is no interference, the robot will drive forward and turn 90 degrees. +// If interfered, the robot will drive forward and then attempt to drive backward. void interfered_example() { chassis.pid_drive_set(24_in, DRIVE_SPEED, true); chassis.pid_wait(); diff --git a/ez-template-docs/tutorials/images/big_timeout.gif b/ez-template-docs/tutorials/images/big_timeout.gif new file mode 100644 index 00000000..41337eaf Binary files /dev/null and b/ez-template-docs/tutorials/images/big_timeout.gif differ diff --git a/ez-template-docs/tutorials/images/big_timeout_reset_small_timeout.gif b/ez-template-docs/tutorials/images/big_timeout_reset_small_timeout.gif new file mode 100644 index 00000000..896e7574 Binary files /dev/null and b/ez-template-docs/tutorials/images/big_timeout_reset_small_timeout.gif differ diff --git a/ez-template-docs/tutorials/images/finding-main-cpp.png b/ez-template-docs/tutorials/images/finding-main-cpp.png new file mode 100644 index 00000000..9076aca2 Binary files /dev/null and b/ez-template-docs/tutorials/images/finding-main-cpp.png differ diff --git a/ez-template-docs/tutorials/images/pros-icon.png b/ez-template-docs/tutorials/images/pros-icon.png new file mode 100644 index 00000000..3b4de4d8 Binary files /dev/null and b/ez-template-docs/tutorials/images/pros-icon.png differ diff --git a/ez-template-docs/tutorials/images/pros-menu-integrated-terminal.png b/ez-template-docs/tutorials/images/pros-menu-integrated-terminal.png new file mode 100644 index 00000000..a64d5867 Binary files /dev/null and b/ez-template-docs/tutorials/images/pros-menu-integrated-terminal.png differ diff --git a/ez-template-docs/tutorials/images/pros-menu.png b/ez-template-docs/tutorials/images/pros-menu.png new file mode 100644 index 00000000..05c0e9f6 Binary files /dev/null and b/ez-template-docs/tutorials/images/pros-menu.png differ diff --git a/ez-template-docs/tutorials/images/small_timeout.gif b/ez-template-docs/tutorials/images/small_timeout.gif new file mode 100644 index 00000000..17c06c91 Binary files /dev/null and b/ez-template-docs/tutorials/images/small_timeout.gif differ diff --git a/ez-template-docs/tutorials/installation.md b/ez-template-docs/tutorials/installation.md index cea55d91..69e1b733 100644 --- a/ez-template-docs/tutorials/installation.md +++ b/ez-template-docs/tutorials/installation.md @@ -1,26 +1,58 @@ --- -title: Installation and Upgrading -description: How to install and upgrade EZ-Template +title: Installation +description: How to install EZ-Template --- +:::note -## Installation +All versions of EZ-Template require you to use an [IMU](https://www.vexrobotics.com/276-4855.html).  You can find mounting instructions [here](https://kb.vex.com/hc/en-us/articles/360037382272-Using-the-V5-Inertial-Sensor).   -1) Download the latest `Example-Project.zip` [here](https://github.com/EZ-Robotics/EZ-Template/releases/latest). Extract the zip, and open it in PROS. -2) In `src/main.cpp`, configure drive and IMU ports to what they are on your robot. Be sure to read the comments! -3) Configure your wheel size and cartridge. Remember that older 4" omni wheels without mounting holes are actually 4.125! -4) In `src/main.cpp`, at the bottom in `void opcontrol()`, decide how you'd like to control your robot! Any flavor of arcade or tank! -5) Turn the robot on and use it in driver control. Make sure the ports are correct and reversed correctly. -6) To test the test autonomous modes, plug into a competition switch and select the autonomous mode on the brain screen by pressing the left and right buttons. The current page will be the autonomous that runs. For making new autonomous routines, [click here](https://ez-robotics.github.io/EZ-Template/tutorials/example_autons) for examples on how to use the drive functions. +::: -## Upgrading -:::warning +## Download PROS +PROS is an open-source project developed by students at Purdue that gives us functions to interact with our V5 brain and other devices that connect to it.  If you don't have it installed, you can read their [Getting Started page here](https://pros.cs.purdue.edu/v5/getting-started/index.html). -This only works for 2.x and beyond. You cannot upgrade from 1.x to 2.x, or 2.x to 3.x without changing code. +## Download EZ-Template +Download the latest `EZ-Template-Example-Project-x.x.x.zip` [here](https://github.com/EZ-Robotics/EZ-Template/releases/latest) and extract the zip file.  [Click here](https://www.filecenter.com/blog/how-to-unzip-files-mac-iphone-android-windows/) if you're unsure how to extract a zip file.   + +## Open EZ-Template-Example-Project +Add the folder to your workspace.  You can do this by going to `File` -> `Add Folder to Workspace`.  This will bring up a window and you'll have to navigate to where you extracted the example project.  If you're unsure where you extracted it, it's most likely in your `Downloads` folder.   + +## Open `main.cpp` +You'll find `main.cpp` by selecting `EZ-Template-Example-Project` and opening `src`.  `main.cpp` is your main file where you can modify your user control code, the root of your autonomous routines, etc. +![](images/finding-main-cpp.png) + +## Configure the Drive Constructor +Near the top of `main.cpp` you'll see some code that looks like this.  This is your drive constructor, and it gives EZ-Template your chassis motor ports, the IMU port, the size of your wheels, and the rpm your wheels go at.  All of this information is needed so EZ-Template can make sure your robot is going the correct distances.  Configure these numbers to your robot.   +```cpp +// Chassis constructor +ez::Drive chassis( +    // These are your drive motors, the first motor is used for sensing! + {1, 2, 3},     // Left Chassis Ports (negative port will reverse it!) + {-4, -5, -6},  // Right Chassis Ports (negative port will reverse it!) + +    7,      // IMU Port +    4.125,  // Wheel Diameter (Remember, 4" wheels without screw holes are actually 4.125!) +    343);   // Wheel RPM +``` + +## Build and Upload +First, take a micro-USB cable and connect it between your computer and the robot.  You may also connect it to the controller, but only if your controller is already linked to the robot.  If you're unsure if your controller is paired or not, [read this article](https://kb.vex.com/hc/en-us/articles/360035592532-Pairing-the-V5-Controller-with-the-V5-Brain-for-a-Wireless-Connection).   + +At the left of your screen, select this icon. +![](images/pros-icon.png) + +Select `Build and Upload`.  Building your code makes sure you have no errors and sets everything up to upload your code to the robot.  Once this is complete, it will upload code to your robot. +![](images/pros-menu.png) + +## Making Sure the IMU is Detected +Run the program on the brain.  You should see a loading bar come up on the brain.  If this bar goes completely red, you have a problem with your IMU.  You've either used the wrong port in your drive constructor, you have a bad cable, or you have a bad IMU.  You'll have to debug this to find out which one is bad.   + +## Making Sure Drive Ports are Correct +The default drive mode for EZ-Template is tank drive, where the left stick controls the left side of the drive and the right stick controls the right side of the drive.  If all of the ports are set up correctly, the robot will drive!   + +If the motors sound like they're running but they get locked up, you have a motor going in the wrong direction.  I suggest unplugging motors until you find the 1 going the wrong way, find out which port is going the wrong way, and update your drive constructor accordingly.   + +## You're Setup! +🥳🥳You're all set up!  The next page will show you how to run the built-in example autonomous routines.   -::: -1) Download the most recent `EZ-Template@x.x.x.zip` [here](https://github.com/EZ-Robotics/EZ-Template/releases/latest). -2) Move the file to your project. -3) Open terminal or command prompt, and `cd` into your projects directory. -4) Run this command from terminal `pros c fetch EZ-Template@x.x.x.zip` replacing `x.x.x` with the version number of your file. -5) Apply the library to the project `pros c apply EZ-Template`. \ No newline at end of file diff --git a/ez-template-docs/tutorials/intake_control.md b/ez-template-docs/tutorials/intake_control.md new file mode 100644 index 00000000..931951ac --- /dev/null +++ b/ez-template-docs/tutorials/intake_control.md @@ -0,0 +1,144 @@ +--- +title: Intake Control +description: Example implementation of intake control +--- +import Tabs from '@theme/Tabs'; +import TabItem from '@theme/TabItem'; + +:::note + +As of v3.1.0, example projects come with `include/subsystems.hpp`.  If you do not have this, create this file in `include/`.  Now open `include/main.h`, add `#include "subsytems.hpp"`.  You're all caught up and can follow along below!   + +::: + +## Creating the Motor +We want to create a motor and have it accessible by `main.cpp` and `autons.cpp`.  To do this we can create the motor in `include/subsystems.hpp` with the code below.  If we have an intake that has multiple motors, we can create one `MotorGroup` and then treat it like a single motor in code.   + + + + +```cpp +#pragma once + +#include "api.h" + +inline pros::Motor intake(10);  // Make this number negative if you want to reverse the motor + +// Your motors, sensors, etc. should go here.  Below are examples + +// inline pros::Motor intake(1); +// inline pros::adi::DigitalIn limit_switch('A'); +``` + + + + + +```cpp +#pragma once + +#include "api.h" + +inline pros::MotorGroup intake({10, -11});  // Negative port will reverse the motor + +// Your motors, sensors, etc. should go here.  Below are examples + +// inline pros::Motor intake(1); +// inline pros::adi::DigitalIn limit_switch('A'); +``` + + + + +## Button Control +To move a motor we type `motor name = a number between -127 and 127;`.  So to make the intake spin at full speed forward, we would type `intake = 127;`. + +With EZ-Template we can read controller inputs with `master.get_digital(DIGITAL_button)`.  With an if/else statement, we can have the intake go full speed forward when L1 is pressed, and go full speed backward when L2 is pressed.  When neither button is pressed the intake will stop moving.   +```cpp +void opcontrol() { + // This is preference to what you like to drive on + pros::motor_brake_mode_e_t driver_preference_brake = MOTOR_BRAKE_COAST; + + chassis.drive_brake_set(driver_preference_brake); + + while (true) { + // PID Tuner + // After you find values that you're happy with, you'll have to set them in auton.cpp + if (!pros::competition::is_connected()) { + // Enable / Disable PID Tuner + // When enabled: + // * use A and Y to increment / decrement the constants + // * use the arrow keys to navigate the constants + if (master.get_digital_new_press(DIGITAL_X)) + chassis.pid_tuner_toggle(); + + // Trigger the selected autonomous routine + if (master.get_digital(DIGITAL_B) && master.get_digital(DIGITAL_DOWN)) { + autonomous(); + chassis.drive_brake_set(driver_preference_brake); + } + + chassis.pid_tuner_iterate(); // Allow PID Tuner to iterate + } + + chassis.opcontrol_tank(); // Tank control + // chassis.opcontrol_arcade_standard(ez::SPLIT); // Standard split arcade + // chassis.opcontrol_arcade_standard(ez::SINGLE); // Standard single arcade + // chassis.opcontrol_arcade_flipped(ez::SPLIT); // Flipped split arcade + // chassis.opcontrol_arcade_flipped(ez::SINGLE); // Flipped single arcade + + // . . . + // Put more user control code here! + // . . . + + if (master.get_digital(DIGITAL_L1)) { + intake = 127; +    } +    else if (master.get_digital(DIGITAL_L2)) { + intake = -127; +    } +    else { + intake = 0; +    } + + pros::delay(ez::util::DELAY_TIME); // This is used for timer calculations! Keep this ez::util::DELAY_TIME + } +} +``` + +## Using it in Autonomous +Now that the motor is created in `subsystems.hpp` we can access it in our autonomous routines.  It's used the same, where we'll set `intake` equal to something throughout our run.   In the example below, the robot will start to intake after driving 6" and will stop once it's driven 24".  The intake will not spin again until it starts to come back and will outtake until it's back where it started.   +```cpp +void intake_autonomous() { + chassis.pid_drive_set(24_in, DRIVE_SPEED, true); + chassis.pid_wait_until(6_in); + intake = 127; + chassis.pid_wait_quick_chain(); + intake = 0; + + chassis.pid_turn_set(45_deg, TURN_SPEED); + chassis.pid_wait_quick_chain(); + + chassis.pid_turn_set(-45_deg, TURN_SPEED); + chassis.pid_wait_quick_chain(); + + chassis.pid_turn_set(0_deg, TURN_SPEED); + chassis.pid_wait(); + + intake = -127; + chassis.pid_drive_set(-24_in, DRIVE_SPEED, true); + chassis.pid_speed_max_set(DRIVE_SPEED);   + chassis.pid_wait(); + intake = 0; +} +``` + +## More Tutorials +The PROS team has made a tutorial for programming a VEX clawbot.  You can find that [here](https://pros.cs.purdue.edu/v5/tutorials/walkthrough/clawbot.html). \ No newline at end of file diff --git a/ez-template-docs/tutorials/joystick_curve.md b/ez-template-docs/tutorials/joystick_curve.md index 1f3b51ec..4d72064c 100644 --- a/ez-template-docs/tutorials/joystick_curve.md +++ b/ez-template-docs/tutorials/joystick_curve.md @@ -2,50 +2,117 @@ title: Joystick Curves description: Adjusting the joystick's behavior to make it exponential --- +import APITable from '@site/src/components/APITable'; +import Tabs from '@theme/Tabs'; +import TabItem from '@theme/TabItem'; -Using the [5225 curves from 2018](https://www.desmos.com/calculator/7oyvwwpmed), (explained [here](https://www.vexforum.com/t/team-5225a-in-the-zone-code-release-yes-you-read-that-right/63199/10)). The x-axis is the joystick input and the y-axis is the motor output. +## Why? +Typically, moving the joystick halfway means the robot goes half speed. With an input curve, pushing the joystick halfway may only move the robot at 1/4 power. This means more of the joystick movement goes to lower speeds and gives you more control of the robot. -Normally, pushing the joystick half way means the robot goes half speed. With an input curve, pushing the joystick half way may only move the robot at 1/4 power. This means more of the joystick movement goes to lower speeds, giving you more control of the robot. +**This is fully driver preference.** Some drivers will really like curves, some drivers hate them.  I loved them when I started using them, but as I got more used to driving fast robots I would turn them down or off completely.  Because of this, EZ-Template supports very easily adjustable curves fully through the controller.   -[This curve](https://www.desmos.com/calculator/7oyvwwpmed) is adjustable by changing the T value. We can do this live on our controllers, or have it enable during `initialize()`. +## What's the Equation? +EZ-Template uses [this curve](https://www.desmos.com/calculator/7oyvwwpmed) that [5225A](https://www.vexforum.com/t/team-5225a-in-the-zone-code-release-yes-you-read-that-right/63199/10) used during In the Zone.  The x-axis is the joystick input and the y-axis is the motor output. -When the robot is on, tapping/holding the left/right arrows will increase/decrease how large the curve is. When arcade is enabled, each stick will have it's own curve. The y/a buttons will increase/decrease the curve for the right stick. +## Using the Joystick Curves +You can use controller buttons to modify these curves live.  What the buttons do depends on which drive style you're using.  Here's a list of all of them.     -## Enabling -After you find values you like, in `src/main.cpp` set `chassis.opcontrol_curve_default_sets(0, 0)` to whatever you liked! The first parameter is left stick, second is right stick. When using tank, only the left stick value is used. + + +| Drive Type | Left/Right Buttons | Y/A Buttons | +| --- | --- | --- | +| tank | left drive curve | right drive curve | +| left split arcade | fwd/rev curve | turn curve | +| right split arcade | turn curve | fwd/rev curve | +| left single arcade | fwd/rev curve | turn curve | +| right single arcade | turn curve | fwd/rev curve | + + + +The higher the number, the more of the joystick will control lower speeds.  Drive around and play with these values until you find something you like.   + +## Saving Your Values +You've found values you're happy with!  There are two ways of saving them: +- hard code them +- use an SD card + +### Hard Coding +In `main.cpp` you'll find `chassis.opcontrol_curve_default_set();` in `initialize()`.  This function takes 2 variables.  One for the left stick and one for the right stick (this is the same as the chart above).   + + + ```cpp void initialize() { - . . . - chassis.opcontrol_curve_default_set(2.1, 4.3); - . . . +  // . . . + chassis.opcontrol_curve_default_set(2.1);  // Delete this line if you're using an SD card +  // . . . } ``` + + + -In `src/main.cpp`, in `void initialize()`, if `chassis.opcontrol_curve_buttons_toggle(true)` is enabled, by pressing the left/right (or y/a if arcade is enabled), you can live adjust your curve and it will display to your controller! ```cpp void initialize() { - . . . - chassis.opcontrol_curve_buttons_toggle(true); - chassis.opcontrol_curve_default_set(2.1, 4.3); - . . . +  // . . . + chassis.opcontrol_curve_default_set(2.1, 4.3);  // Delete this line if you're using an SD card +  // . . . } ``` + + -If you have an sd card plugged in, after changing the number with your controller, the value will save to the sd card. -:::warning +### SD Card +If you have an SD card installed, you'll actually want to **delete this line of code**.  This will override what the SD card has saved.  And that's all you'll have to do!  When you adjust the numbers live they will automatically save to the SD card and hold for the next time you turn the robot on.   +```cpp +void initialize() { +  // . . . + chassis.opcontrol_curve_default_set(2.1);  // Delete this line if you're using an SD card +  // . . . +} +``` + +## Disabling Modifying Curves Through the Controller +You can disable modifying curves through the controller by calling `chassis.opcontrol_curve_buttons_toggle(false);`.   -You must remove `chassis.opcontrol_curve_default_set(x, x)` from `initialize()` if you have an SD card, otherwise this will overwrite the SD card when you power on the robot! + -::: + -## Disabling -To disable the joystick curve entirely, in `src/main.cpp` make sure these are 0 `chassis.opcontrol_curve_default_sets(0, 0)`. If you don't want to modify the curve with the controller, make sure `chassis.opcontrol_curve_buttons_toggle(false)` is false. ```cpp void initialize() { - . . . - chassis.opcontrol_curve_buttons_toggle(false); - chassis.opcontrol_curve_default_set(0, 0); - . . . +  // . . . + chassis.opcontrol_curve_buttons_toggle(false);  // Disable modifying curves through the controller + chassis.opcontrol_curve_default_set(2.1);  // Delete this line if you're using an SD card +  // . . . } - ``` \ No newline at end of file +``` + + + + +```cpp +void initialize() { +  // . . . + chassis.opcontrol_curve_buttons_toggle(false);  // Disable modifying curves through the controller + chassis.opcontrol_curve_default_set(2.1, 4.3);  // Delete this line if you're using an SD card +  // . . . +} +``` + + \ No newline at end of file diff --git a/ez-template-docs/tutorials/pid.md b/ez-template-docs/tutorials/pid.md index 4480c861..2817a812 100644 --- a/ez-template-docs/tutorials/pid.md +++ b/ez-template-docs/tutorials/pid.md @@ -4,10 +4,10 @@ description: How to add a feedback loop to motors and increase their accuracy --- -PID (proportion, integral, derivative) is a feedback controlled used to move something to a position. The controller slows down as it approaches its target and will correct itself after overshoot occurs. It is a relatively simply controller and can be very consistent with [tuning](https://ez-robotics.github.io/EZ-Template/tutorials/tuning_constants). +PID (proportion, integral, derivative) is a feedback controller used to move something to a position.  The controller slows down as it approaches its target and will correct itself after an overshoot occurs.  It is a relatively simply controller and can be very consistent with [tuning](https://ez-robotics.github.io/EZ-Template/tutorials/tuning_constants).   ## Example 1 - User Control -This code uses a function called `set_lift` to set the power of 2 lift motors in a single function call. After `liftPID` is created, in `opcontrol()` we set the target depending on button presses. To run the PID we have to run `liftPID.compute(sensor value)` repeatedly to make sure our subsystem gets to its target. We reset the lift encoder in `initialize()` to make sure the motor is starting at a known position. +This code uses a function called `set_lift` to set the power of 2 lift motors in a single function call.  After `liftPID` is created, in `opcontrol()` we set the target depending on button presses.  To run the PID we have to run `liftPID.compute(sensor value)` repeatedly to make sure our subsystem gets to its target.  We reset the lift encoder in `initialize()` to make sure the motor is starting at a known position. ```cpp pros::Motor l_lift(17); pros::Motor r_lift(18); @@ -22,42 +22,42 @@ void initialize() { } void opcontrol() { - while (true) { - if (master.get_digital(DIGITAL_L1)) { +  while (true) { +    if (master.get_digital(DIGITAL_L1)) { liftPID.target_set(500); - } - else if (master.get_digital(DIGITAL_L2)) { +    } +    else if (master.get_digital(DIGITAL_L2)) { liftPID.target_set(0); - } - set_lift(liftPID.compute(l_lift.get_position())); +    } +    set_lift(liftPID.compute(l_lift.get_position())); - pros::delay(ez::util::DELAY_TIME); - } +    pros::delay(ez::util::DELAY_TIME); +  } } ``` ## Example 2 - Waiting in Autonomous This code uses the previous example as a base. -We've added a new function called `lift_auto()`. This function takes in a target and locks the code in a while loop until the lift has reached its target. The autonomous routine will bring the lift up to 500, wait for 1 second, and then come back down to 0. +We've added a new function called `lift_auto()`.  This function takes in a target and locks the code in a while loop until the lift has reached its target.  The autonomous routine will bring the lift up to 500, wait for 1 second, and then come back down to 0. ```cpp pros::Motor l_lift(17); pros::Motor r_lift(18); void set_lift(int input) { - l_lift = input; - r_lift = input; + l_lift = input; + r_lift = input; } ez::PID liftPID{0.45, 0, 0, 0, "Lift"}; void lift_auto(double target) { - liftPID.target_set(target); - ez::exit_output exit = ez::RUNNING; - while (liftPID.exit_condition({l_lift, r_lift}, true) == ez::RUNNING) { - double output = liftPID.compute(l_lift.get_position()); - set_lift(output); - pros::delay(ez::util::DELAY_TIME); - } - set_lift(0); + liftPID.target_set(target); +  ez::exit_output exit = ez::RUNNING; +  while (liftPID.exit_condition({l_lift, r_lift}, true) == ez::RUNNING) { +    double output = liftPID.compute(l_lift.get_position()); +    set_lift(output); +    pros::delay(ez::util::DELAY_TIME); +  } +  set_lift(0); } void initialize() { @@ -66,28 +66,28 @@ void initialize() { } void autonomous() { - lift_auto(500); - pros::delay(1000); - lift_auto(0); +  lift_auto(500); +  pros::delay(1000); +  lift_auto(0); } void opcontrol() { - while (true) { - if (master.get_digital(DIGITAL_L1)) { +  while (true) { +    if (master.get_digital(DIGITAL_L1)) { liftPID.target_set(500); - } - else if (master.get_digital(DIGITAL_L2)) { +    } +    else if (master.get_digital(DIGITAL_L2)) { liftPID.target_set(0); - } - set_lift(liftPID.compute(l_lift.get_position())); +    } +    set_lift(liftPID.compute(l_lift.get_position())); - pros::delay(ez::util::DELAY_TIME); - } +    pros::delay(ez::util::DELAY_TIME); +  } } ``` ## Example 3 - Tasks -Example 2 has a problem of not being able to do other things while the lift is running because the code is locked. We can fix this with a task. +Example 2 has a problem of not being able to do other things while the lift is running because the code is locked.  We can fix this with a task. ```cpp pros::Motor l_lift(17); pros::Motor r_lift(18); @@ -99,18 +99,18 @@ ez::PID liftPID{0.45, 0, 0, 0, "Lift"}; void lift_wait() { - while (liftPID.exit_condition({l_lift, r_lift}, true) == ez::RUNNING) { - pros::delay(ez::util::DELAY_TIME); - } +  while (liftPID.exit_condition({l_lift, r_lift}, true) == ez::RUNNING) { +    pros::delay(ez::util::DELAY_TIME); +  } } void lift_task() { - pros::delay(2000); - while (true) { - set_lift(liftPID.compute(l_lift.get_position())); +  pros::delay(2000); +  while (true) { +    set_lift(liftPID.compute(l_lift.get_position())); - pros::delay(ez::util::DELAY_TIME); - } +    pros::delay(ez::util::DELAY_TIME); +  } } pros::Task Lift_Task(lift_task); @@ -121,24 +121,24 @@ void initialize() { void autonomous() { liftPID.target_set(500); - lift_wait(); +  lift_wait(); - pros::delay(1000); +  pros::delay(1000); liftPID.target_set(0); - lift_wait(); +  lift_wait(); } void opcontrol() { - while (true) { - if (master.get_digital(DIGITAL_L1)) { +  while (true) { +    if (master.get_digital(DIGITAL_L1)) { liftPID.target_set(500); - } - else if (master.get_digital(DIGITAL_L2)) { +    } +    else if (master.get_digital(DIGITAL_L2)) { liftPID.target_set(0); - } +    } - pros::delay(ez::util::DELAY_TIME); - } +    pros::delay(ez::util::DELAY_TIME); +  } } ``` \ No newline at end of file diff --git a/ez-template-docs/tutorials/practice_mode.md b/ez-template-docs/tutorials/practice_mode.md index 13297dfd..45cf47a0 100644 --- a/ez-template-docs/tutorials/practice_mode.md +++ b/ez-template-docs/tutorials/practice_mode.md @@ -3,7 +3,7 @@ title: Practice Mode description: How to use Practice Mode to improve your driving --- -New drivers will often flick the joysticks, going full power or no power. Practice mode is a training mode to help drivers use other parts of the joystick by shutting off the drive when the joysticks go full power. +The best drivers are able to use the entire range of the joystick to its fullest extent. New drivers like to treat the joysticks as binary. Practice mode is here to help train binary joystick users by shutting the entire drive off when the joystick is maxed out. ## Enabling Adding `chassis.opcontrol_joystick_practicemode_toggle(true);` to your code will enable practice mode. When practicing, we recommend driving in a figure 8 pattern to force yourself to use more of the joystick. diff --git a/ez-template-docs/tutorials/pto_tutorial.md b/ez-template-docs/tutorials/pto_tutorial.md index f1a6035f..b359a2a4 100644 --- a/ez-template-docs/tutorials/pto_tutorial.md +++ b/ez-template-docs/tutorials/pto_tutorial.md @@ -4,10 +4,10 @@ description: Add or remove drive motors dynamically --- -PTO (power take off) is used to share power between two mechanisms, usually between the drive and something else. For example, a 6 motor drive could pneumatically shift to a 4 motor drive and a 2 motor intake. +PTO (power take off) is used to share power between two mechanisms, usually between the drive and something else.  For example, a 6 motor drive could pneumatically shift to a 4 motor drive and a 2 motor intake.   ## Example 1 - Beginner -The simplest way to control a PTO is to keep track of the piston state and setting motors yourself. In this code, the driver has control over switching the PTO on and off. The intake buttons will only work when the PTO is enabled. +The simplest way to control a PTO is to keep track of the piston state and set the motors yourself.  In this code, the driver has control over switching the PTO on and off.  The intake buttons will only work when the PTO is enabled. The function `pto_toggle_intake()` is in charge of triggering the piston and changing the bool `pto_intake_enabled` to allow or disallow `set_intake()` from setting power to the motors. ```cpp @@ -17,61 +17,61 @@ using namespace ez; #define LEFT_INTAKE 3 #define RIGHT_INTAKE 3 -pros::ADIDigitalOut pto_intake_piston('A'); +pros::adi::DigitalOut pto_intake_piston('A'); bool pto_intake_enabled = false; void pto_toggle_intake(bool toggle) { pto_intake_enabled = toggle; chassis.pto_toggle({chassis.left_motors[LEFT_INTAKE], chassis.right_motors[RIGHT_INTAKE]}, toggle); pto_intake_piston.set_value(toggle); - if (toggle) { +  if (toggle) { chassis.left_motors[LEFT_INTAKE].set_brake_mode(pros::E_MOTOR_BRAKE_COAST); chassis.right_motors[RIGHT_INTAKE].set_brake_mode(pros::E_MOTOR_BRAKE_COAST); - } +  } } void set_intake(int input) { - if (!pto_intake_enabled) return; +  if (!pto_intake_enabled) return; chassis.left_motors[LEFT_INTAKE] = input; chassis.right_motors[RIGHT_INTAKE] = input; } // User control code void intake_control() { - if (master.get_digital_new_press(DIGITAL_DOWN)) { - pto_toggle_intake(!pto_intake_enabled); - } - - if (master.get_digital(DIGITAL_L1)) { - set_intake(127); - } - else if (master.get_digital(DIGITAL_L2)) { - set_intake(-127); - } - else { - set_intake(0); - } +  if (master.get_digital_new_press(DIGITAL_DOWN)) { +    pto_toggle_intake(!pto_intake_enabled); +  } + +  if (master.get_digital(DIGITAL_L1)) { +    set_intake(127); +  } +  else if (master.get_digital(DIGITAL_L2)) { +    set_intake(-127); +  } +  else { +    set_intake(0); +  } } void opcontrol() { - // This is preference to what you like to drive on. +  // This is preference to what you like to drive on. chassis.drive_brake_set(MOTOR_BRAKE_COAST); - while (true) { +  while (true) { chassis.opcontrol_tank(); // Tank control - intake_control(); +    intake_control(); - pros::delay(util::DELAY_TIME); // This is used for timer calculations! Keep this ez::util::DELAY_TIME - } +    pros::delay(util::DELAY_TIME); // This is used for timer calculations!  Keep this ez::util::DELAY_TIME +  } } ``` ## Example 2 - Intermediate -This code is more complex, but the goal with it is to make it feel like there isn't a PTO to the driver and the programmer. +This code is more complex, but the goal with it is to make it feel like there isn't a PTO to the driver and the programmer.   -`set_intake()` is used to trigger the PTO here. If a non 0 number is sent, the PTO will trigger and the motors will disengage from the drive. Once `set_intake(0);` is sent, the PTO will bring those motors back to the drive. This makes autonomous routines and user control code significantly easier. +`set_intake()` is used to trigger the PTO here.  If a non-0 number is sent, the PTO will trigger and the motors will disengage from the drive.  Once `set_intake(0);` is sent, the PTO will bring those motors back to the drive.  This makes autonomous routines and user control code significantly easier. ```cpp using namespace ez; @@ -79,59 +79,59 @@ using namespace ez; #define LEFT_INTAKE 3 #define RIGHT_INTAKE 3 -Piston pto_intake_piston('A'); // PTO piston -bool pto_piston_enabled = false; // Current PTO state +Piston pto_intake_piston('A');    // PTO piston +bool pto_piston_enabled = false;  // Current PTO state // Toggle motors from PTO, toggle piston, switch brake modes void pto_toggle_intake(bool toggle) { pto_piston_enabled = toggle; chassis.pto_toggle({chassis.left_motors[LEFT_INTAKE], chassis.right_motors[RIGHT_INTAKE]}, toggle); pto_intake_piston.set(toggle); - if (toggle) { +  if (toggle) { chassis.left_motors[LEFT_INTAKE].set_brake_mode(pros::E_MOTOR_BRAKE_COAST); chassis.right_motors[RIGHT_INTAKE].set_brake_mode(pros::E_MOTOR_BRAKE_COAST); - } +  } } // Global intake function (for use outside of this file) void set_intake(int input) { - pto_toggle_intake(input == 0 ? false : true); - if (!pto_piston_enabled) return; +  pto_toggle_intake(input == 0 ? false : true); +  if (!pto_piston_enabled) return; chassis.left_motors[LEFT_INTAKE] = -input; chassis.right_motors[RIGHT_INTAKE] = -input; } // User control code void intake_control() { - if (master.get_digital(DIGITAL_L1)) { - set_intake(127); - } - else if (master.get_digital(DIGITAL_L2)) { - set_intake(-127); - } - else { - set_intake(0); - } +  if (master.get_digital(DIGITAL_L1)) { +    set_intake(127); +  } +  else if (master.get_digital(DIGITAL_L2)) { +    set_intake(-127); +  } +  else { +    set_intake(0); +  } } void opcontrol() { - // This is preference to what you like to drive on. +  // This is preference to what you like to drive on. chassis.drive_brake_set(MOTOR_BRAKE_COAST); - while (true) { +  while (true) { chassis.opcontrol_tank(); // Tank control - intake_control(); +    intake_control(); - pros::delay(util::DELAY_TIME); // This is used for timer calculations! Keep this ez::util::DELAY_TIME - } +    pros::delay(util::DELAY_TIME); // This is used for timer calculations!  Keep this ez::util::DELAY_TIME +  } } ``` ## Example 3 - Expert -Using the same concepts from above, this example expands on it and adds an "anti jam" function that will run the intake in the opposite direction for a short amount of time if something gets jammed. Functions like this were incredibly useful during Tipping Point with the odd shape of rings, and this code is from the 21S Tipping Point robot. +Using the same concepts from above, this example expands on it and adds an "anti jam" function that will run the intake in the opposite direction for a short amount of time if something gets jammed.  Functions like this were incredibly useful during Tipping Point with the odd shape of rings, and this code is from the 21S Tipping Point robot. -This code checks the velocity of the motors to check if they are 0. If they are 0, a timer is started. Once the timer passes 250ms, we recognize a jam has happened and set the intake to go full power in the opposite direction for 250ms. 21S has problems when the PTO triggered this code would recognize a jam happening. To prevent this another timer was started, where for 500ms after toggling a jam cannot occur. +This code checks the velocity of the motors to check if they are 0.  If they are 0, a timer is started.  Once the timer passes 250ms, we recognize a jam has happened and set the intake to go full power in the opposite direction for 250ms.  21S has problems when the PTO triggered this code would recognize a jam happening.  To prevent this another timer was started, where for 500ms after toggling a jam cannot occur. ```cpp using namespace ez; @@ -139,115 +139,115 @@ using namespace ez; #define LEFT_INTAKE 3 #define RIGHT_INTAKE 3 -Piston pto_intake_piston('A'); // PTO piston -bool pto_piston_enabled = false; // Current PTO state -int target_speed = 0; // Global target speed +Piston pto_intake_piston('A');    // PTO piston +bool pto_piston_enabled = false;  // Current PTO state +int target_speed = 0;             // Global target speed // Toggle motors from PTO, toggle piston, switch brake modes void pto_toggle_intake(bool toggle) { pto_piston_enabled = toggle; chassis.pto_toggle({chassis.left_motors[LEFT_INTAKE], chassis.right_motors[RIGHT_INTAKE]}, toggle); pto_intake_piston.set(toggle); - if (toggle) { +  if (toggle) { chassis.left_motors[LEFT_INTAKE].set_brake_mode(pros::E_MOTOR_BRAKE_COAST); chassis.right_motors[RIGHT_INTAKE].set_brake_mode(pros::E_MOTOR_BRAKE_COAST); - } +  } } // Raw intake function (intended use in this file only) void raw_set_intake(int input) { - if (!pto_piston_enabled) return; +  if (!pto_piston_enabled) return; chassis.left_motors[LEFT_INTAKE] = -input; chassis.right_motors[RIGHT_INTAKE] = -input; } // Global intake function (for use outside of this file) void set_intake(int input) { - pto_toggle_intake(input == 0 ? false : true); - raw_set_intake(input); - if (pto_piston_enabled) target_speed = input; +  pto_toggle_intake(input == 0 ? false : true); +  raw_set_intake(input); +  if (pto_piston_enabled) target_speed = input; } // Is velocity of motors 0? bool has_intake_stopped() { - if ((chassis.left_motors[LEFT_INTAKE].get_actual_velocity() == 0 || chassis.right_motors[RIGHT_INTAKE].get_actual_velocity() == 0) && pto_piston_enabled) - return true; - return false; +  if ((chassis.left_motors[LEFT_INTAKE].get_actual_velocity() == 0 || chassis.right_motors[RIGHT_INTAKE].get_actual_velocity() == 0) && pto_piston_enabled) +    return true; +  return false; } // Intake task with antijam logic void intake_task() { - const int wait_time = 250, switch_wait_time = 500; - int switch_counter = 0, jam_counter = 0; - bool is_jammed = false, last_pto = false, just_switched = false; +  const int wait_time = 250, switch_wait_time = 500; +  int switch_counter = 0, jam_counter = 0; +  bool is_jammed = false, last_pto = false, just_switched = false; - while (true) { - // Detect the PTO engaging to the intake - if (pto_piston_enabled != last_pto /*&& pto_piston_enabled == true*/) +  while (true) { +    // Detect the PTO engaging to the intake +    if (pto_piston_enabled != last_pto /*&& pto_piston_enabled == true*/) just_switched = true; - // This stops the antijam code from running 500ms after engaging the PTO to the intake - if (just_switched) { +    // This stops the antijam code from running 500ms after engaging the PTO to the intake +    if (just_switched) { switch_counter += util::DELAY_TIME; - if (switch_counter > switch_wait_time) { +      if (switch_counter > switch_wait_time) { just_switched = false; switch_counter = 0; - } - } +      } +    } last_pto = pto_piston_enabled; - // Only run this code when the PTO is engaged to the intake - if (pto_piston_enabled) { - // Run intake full power in opposite direction for 250ms when jammed, then set intake - // back to normal - if (is_jammed) { - raw_set_intake(-127 * util::sgn(target_speed)); +    // Only run this code when the PTO is engaged to the intake +    if (pto_piston_enabled) { +      // Run intake full power in opposite direction for 250ms when jammed, then set intake +      // back to normal +      if (is_jammed) { +        raw_set_intake(-127 * util::sgn(target_speed)); jam_counter += ez::util::DELAY_TIME; - if (jam_counter > wait_time) { +        if (jam_counter > wait_time) { is_jammed = false; jam_counter = 0; - raw_set_intake(target_speed); - } - } +          raw_set_intake(target_speed); +        } +      } - // Detect a jam if velocity is 0 for 250ms - else if (target_speed != 0 && has_intake_stopped() && !just_switched) { +      // Detect a jam if velocity is 0 for 250ms +      else if (target_speed != 0 && has_intake_stopped() && !just_switched) { jam_counter += util::DELAY_TIME; - if (jam_counter > wait_time) { +        if (jam_counter > wait_time) { jam_counter = 0; is_jammed = true; - } - } - } +        } +      } +    } - pros::delay(util::DELAY_TIME); - } +    pros::delay(util::DELAY_TIME); +  } } pros::Task Intake_Task(intake_task); // User control code void intake_control() { - if (master.get_digital(DIGITAL_L1)) { - set_intake(127); - } - else if (master.get_digital(DIGITAL_L2)) { - set_intake(-127); - } - else { - set_intake(0); - } +  if (master.get_digital(DIGITAL_L1)) { +    set_intake(127); +  } +  else if (master.get_digital(DIGITAL_L2)) { +    set_intake(-127); +  } +  else { +    set_intake(0); +  } } void opcontrol() { - // This is preference to what you like to drive on. +  // This is preference to what you like to drive on. chassis.drive_brake_set(MOTOR_BRAKE_COAST); - while (true) { - chassis.opcontrol_tank(); // Tank control +  while (true) { + chassis.opcontrol_tank(); // Tank control - intake_control(); +    intake_control(); - pros::delay(util::DELAY_TIME); // This is used for timer calculations! Keep this ez::util::DELAY_TIME - } +    pros::delay(util::DELAY_TIME); // This is used for timer calculations!  Keep this ez::util::DELAY_TIME +  } } ``` \ No newline at end of file diff --git a/ez-template-docs/tutorials/slew_constants.md b/ez-template-docs/tutorials/slew_constants.md new file mode 100644 index 00000000..a82fd1c0 --- /dev/null +++ b/ez-template-docs/tutorials/slew_constants.md @@ -0,0 +1,71 @@ +--- +title: Slew Constants +description: Ramping up speed so your robot doesn't tip +--- + +:::note + +Most robots will work perfectly fine without slew.  You can visit this page if you start to see the undesired behavior described below.   + +::: + +## What is it? +Slew is when your motors start at a lower speed and build up to a faster speed.  This can be useful if your robot is prone to tipping, can wheelie easily, or is prone to wheel slip at the start of motions.   + +## Tuning Slew +There are 2 parameters to tune with slew in EZ-Template; the distance to slew for and starting speed.  The robot will accelerate very quickly with a low distance to slew for, regardless of the starting speed.   + +I will tune slew by running normal motions but having the robot go slower.  The goal is to find the fastest the robot can go without any of the undesirable behaviors described above.  To enable slew you need the `true` parameter at the end of your `x_pid_set()`.   +```cpp +void tuning_slew() { + chassis.drive_pid_set(24_in, 80, true); +} +``` + +After you've found this number, you can ensure this line is in your `default_constants()` function in `src/autons.cpp`.  This should be near the top.  You can set the second number, speed, to the number you've found in the test above.   +```cpp +void default_constants() { +  // . . . + chassis.slew_drive_constants_set(7_in, 80); +  // . . . +} +``` + +Now you can lower the distance until the robot is able to successfully reach `DRIVE_SPEED` without undesirable behavior!   +```cpp +void tuning_slew() { + chassis.drive_pid_set(24_in, DRIVE_SPEED, true); +} +``` + +## Specifics for Each Motion + +### Driving +Sometimes robots aren't symmetrical and can be tippier in one direction than the other.  This can be solved by choosing one of the following functions to place in `default_constants()`.   +```cpp +chassis.slew_drive_constants_set(7_in, 80);  // This sets forwards and backwards constants +chassis.slew_drive_constants_forward_set(7_in, 80); +chassis.slew_drive_constants_backward_set(7_in, 80); +``` +### Turning +This is the simplest one.  Turning should be symmetrical on your robot, so this is the only function to tune with.   +```cpp +chassis.slew_turn_constants_set(5_deg, 50); +``` + +### Swinging +Swinging is the most complex.  Because of the introduction of arcs, EZ-Template now supports either inches or degrees for tuning slew.  You can also have independent forward and backward constants.  it doesn't matter if you decide to use inches or degrees for tuning, you can change it later.   + +Using degrees, these are your options for setting slew constants. +```cpp +chassis.slew_swing_constants_set(5_deg, 50);  // This sets forwards and backwards constants +chassis.slew_swing_constants_forward_set(5_deg, 50); +chassis.slew_swing_constants_backward_set(5_deg, 50); +``` + +Using inches, these are your options for setting slew constants. +```cpp +chassis.slew_drive_constants_set(7_in, 80);  // This sets forwards and backwards constants +chassis.slew_drive_constants_forward_set(7_in, 80); +chassis.slew_drive_constants_backward_set(7_in, 80); +``` diff --git a/ez-template-docs/tutorials/tuning_constants.md b/ez-template-docs/tutorials/tuning_constants.md index f049460b..a55e2f35 100644 --- a/ez-template-docs/tutorials/tuning_constants.md +++ b/ez-template-docs/tutorials/tuning_constants.md @@ -1,6 +1,6 @@ --- -title: Tuning Constants -description: Tuning the PID system to accurately rotate the desired amount +title: PID Constants +description: Tuning the PID system to accurately move the desired amount --- For more information on how PID controllers work, [reference this document made by George Gillard](http://georgegillard.com/documents/2-introduction-to-pid-controllers). @@ -8,49 +8,44 @@ For more information on how PID controllers work, [reference this document made ## Setup -### Uncommenting Default Constants -In `src/main.cpp`, make sure `default_constants()` is uncommented in `void initialize()`. +### Uncommenting Default Constants   +In `src/main.cpp`, make sure `default_constants()` is uncommented in `void initialize()`.   ```cpp void initialize() { - . . . - default_constants(); - . . . +  // . . . +  default_constants(); +  // . . . } ``` -### Running the Autonomous -You can run one of the example autonomous routines to tune your constants. When you're tuning drive constants, run `drive_example()`. When you're tuning turn constants, run `turn_example()`. +### Running the Autonomous   +You can run one of the example autonomous routines to tune your constants.  When you're tuning drive constants, run `drive_example()`.  When you're tuning turn constants, run `turn_example()`. Look at our [Using Auton Selector tutorial](https://ez-robotics.github.io/EZ-Template/tutorials/using_auton_selector) for how to select autonomous routines! -### Modifying Constants -In `src/autons.cpp`, there is a function called `default_constants()`. This function is where all of your modified PID constants can be set. +### Modifying Constants   +In `src/autons.cpp`, there is a function called `default_constants()`.  This function is where all of your modified PID constants can be set.   ```cpp void default_constants() { - // PID Constants +  // PID Constants chassis.pid_drive_constants_set(10, 0, 100); // Sets forward and backward chassis.pid_heading_constants_set(3, 0, 20); chassis.pid_turn_constants_set(3, 0, 20); chassis.pid_swing_constants_set(5, 0, 30); // Sets forward and backward - - // Swing Constants - chassis.slew_drive_constants_set(7_in, 80); // Sets forward and backward - chassis.slew_turn_constants_set(5_deg, 50); - chassis.slew_swing_constants_set(5_deg, 50); // Sets forward and backward } ``` ### Different Constants -When your robot has huge weight shifts (grabbing a mobile goal, raising a lift, etc), you might want to have different constants for those states. You can have multiple functions with constants for different states and change constants during your autonomous routine. +When your robot has huge weight shifts (grabbing a mobile goal, raising a lift, etc), you might want to have different constants for those states.  You can have multiple functions with constants for different states and change constants during your autonomous routine. ```cpp -void grab_mogo() { +void grab_mogo_constants() { chassis.pid_drive_set(40_in, 110, true); chassis.pid_wait(); - one_mogo_constants(); +  one_mogo_constants(); chassis.pid_drive_set(-40_in, 110, true); chassis.pid_wait(); } @@ -59,38 +54,52 @@ void grab_mogo() { ### Using the PID Tuner -EZ-Template's PID Tuner allows users to tune PID faster. The alternative to using this is to reupload your code every time you want to try new constants. +EZ-Template's PID Tuner allows users to tune PID faster.  The alternative to using this is to reupload your code every time you want to try new constants. -To enable it, we can use `chassis.pid_tuner_toggle();`. In the code below it is only allowed to run when we're not connected to a competition switch or tournament. This is done to avoid accidentally leaving this code in your code while at a competition and running your autonomous during the driver controlled period. +To enable it, we can use `chassis.pid_tuner_toggle();`.  In the code below it is only allowed to run when we're not connected to a competition switch or tournament.  This is done to avoid accidentally leaving this code in your code while at a competition and running your autonomous during the driver-controlled period.   -Once the PID Tuner is enabled we can navigate the menus on the brain screen with the arrow keys on the controller. To increase or decrease the constant we can use A and Y on the controller. +Once the PID Tuner is enabled we can navigate the menus on the brain screen with the arrow keys on the controller.  To increase or decrease the constant we can use A and Y on the controller.   -To select your autonomous routine, navigate the autonomous selector until you find the one you want to run. Then once you switch to the PID Tuner, the last auton page you were on will run when you press B on your controller. +To select your autonomous routine, navigate the autonomous selector until you find the one you want to run.  Then once you switch to the PID Tuner, the last auton page you were on will run when you press B on your controller.   ```cpp void opcontrol() { - // This is preference to what you like to drive on - chassis.drive_brake_set(MOTOR_BRAKE_COAST); - - while (true) { - - // PID Tuner - // After you find values that you're happy with, you'll have to set them in auton.cpp - if (!pros::competition::is_connected()) { - // Enable / Disable PID Tuner - if (master.get_digital_new_press(DIGITAL_X)) +  // This is preference to what you like to drive on +  pros::motor_brake_mode_e_t driver_preference_brake = MOTOR_BRAKE_COAST; + + chassis.drive_brake_set(driver_preference_brake); + +  while (true) { +    // PID Tuner +    // After you find values that you're happy with, you'll have to set them in auton.cpp +    if (!pros::competition::is_connected()) { +      // Enable / Disable PID Tuner +      // When enabled: +      // * use A and Y to increment / decrement the constants +      // * use the arrow keys to navigate the constants +      if (master.get_digital_new_press(DIGITAL_X)) chassis.pid_tuner_toggle(); - - // Trigger the selected autonomous routine - if (master.get_digital_new_press(DIGITAL_B)) - autonomous(); - chassis.pid_tuner_iterate(); // Allow PID Tuner to iterate - } +      // Trigger the selected autonomous routine +      if (master.get_digital(DIGITAL_B) && master.get_digital(DIGITAL_DOWN)) { +        autonomous(); + chassis.drive_brake_set(driver_preference_brake); +      } + + chassis.pid_tuner_iterate();  // Allow PID Tuner to iterate +    } - chassis.opcontrol_tank(); // Tank control + chassis.opcontrol_tank();  // Tank control +    // chassis.opcontrol_arcade_standard(ez::SPLIT);   // Standard split arcade +    // chassis.opcontrol_arcade_standard(ez::SINGLE);  // Standard single arcade +    // chassis.opcontrol_arcade_flipped(ez::SPLIT);    // Flipped split arcade +    // chassis.opcontrol_arcade_flipped(ez::SINGLE);   // Flipped single arcade - pros::delay(ez::util::DELAY_TIME); // This is used for timer calculations! Keep this ez::util::DELAY_TIME - } +    // . . . +    // Put more user control code here! +    // . . . + +    pros::delay(ez::util::DELAY_TIME);  // This is used for timer calculations!  Keep this ez::util::DELAY_TIME +  } } ``` --- @@ -101,156 +110,108 @@ This video is a good visual representation of what each constant does. ### Step 1 - kP -You'll start with kP. Set it to some number, and run your example autonomous. The robot will either undershoot the target (kP too low), or the robot is oscillate around the target (kP too high). +You'll start with kP.  Set it to some number, and run your example autonomous.  The robot will either undershoot the target (kP too low), or the robot is oscillate around the target (kP too high).   -To tune a PD controller, you want the kP to oscillate a little bit, usually a bounce or two. +To tune a PD controller, you want the kP to oscillate a little bit, usually a bounce or two.   ### Step 2 - kD -After finding a kP that oscillates a little, we can tune kD. Increase kD until the oscillation goes away. This movement should look more "snappy" then just a P loop. +After finding a kP that oscillates a little, we can tune kD.  Increase kD until the oscillation goes away.  This movement should look more "snappy" than just a P loop. ### Step 3 - Repeat -Repeat Steps 1 and Steps 2 until kD cannot remove oscillation from the movement. Then go back to the last values that worked. +Repeat Steps 1 and Steps 2 until kD cannot remove oscillation from the movement.  Then go back to the last values that worked. ### Step 4 - kI -Sometimes you need a little extra power to get your robot all the way there. Integral can be a dangerous variable because it grows exponentially. The fourth parameter is what the error needs to be for I to start. For turns, we found around 15 degrees is good. +Sometimes you need a little extra power to get your robot all the way there.  Integral can be a dangerous variable because it grows exponentially.  The fourth parameter is what the error needs to be for I to start.  For turns, we found around 15 degrees is good. -Increase kI until any minor disturbances are accounted for. You might need to adjust kD while tuning kI. +Increase kI until any minor disturbances are accounted for.  You might need to adjust kD while tuning kI.   --- -## Tuning Forward/Backward Constants +## Tuning Forward/Backward Constants   ### Step 1 - Forward/Backwards Constants -Using the steps above, modify your kP, kD, and if you chose to, kI. +Using the steps above, modify your kP, kD, and if you choose to, kI.   -If you see the robot acting differently going forwards and backwards, you can have different constants for each. This is usually only needed when something is off balance on your robot mechanically. -```cpp - chassis.pid_drive_constants_forward_set(10, 0, 100); - chassis.pid_drive_constants_backward_set(10, 0, 100); -``` +Sometimes instead of seeing the robot oscillate around your target, you'll see the robot wheelie really hard or wheel slip.  These are **undesired behaviors** and it means your kP is too high.   -If you don't have problems with differences between forward and backwards, you can use the following instead. +If you see the robot acting differently going forward and backward, you can have different constants for each.  This is usually only needed when something is off balance on your robot mechanically. ```cpp - chassis.pid_drive_constants_set(10, 0, 100); // Sets forward and backward +chassis.pid_drive_constants_forward_set(10, 0, 100); +chassis.pid_drive_constants_backward_set(10, 0, 100); ``` -### Step 2 - Heading Correction -Heading correction tries to keep your robot facing an angle while driving forward. The constants for this are generally higher then other PID controllers because you're only correcting for a few degrees of error. - -The same steps above can be used to tune the heading constants. Increase kP until there's a little oscillation, increase kD until it goes away, repeat. - +If you don't have problems with differences between forward and backward, you can use the following instead.   ```cpp - chassis.pid_heading_constants_set(3, 0, 20); +chassis.pid_drive_constants_set(10, 0, 100); // Sets forward and backward ``` +### Step 2 - Heading Correction +Heading correction tries to keep your robot facing an angle while driving forward.  The constants for this are generally higher than other PID controllers because you're only correcting for a few degrees of error.   -### Step 3 - Slew -Slew ramps the speed of the robot up from the start of the motion to avoid wheelies and wheel slip. -The first parameter is the distance the robot will increase from min power to the max power you set in your autonomous function. -The second parameter is the starting power the robot will use when slewing. - -Minimum power should be as high as it can be without causing the robot to wheelie or cause wheel slip. Slew distance should be as small as it can be without causing the same. - -```cpp - chassis.slew_drive_constants_set(7_in, 80); // This sets forwards and backwards constants -``` +The same steps above can be used to tune the heading constants.  Increase kP until there's a little oscillation, increase kD until it goes away, repeat. -If your robot behaves differently forward and backwards, you can set different slew rates for both. ```cpp - chassis.slew_drive_constants_forward_set(7_in, 80); - chassis.slew_drive_constants_backward_set(7_in, 80); +chassis.pid_heading_constants_set(3, 0, 20); ``` --- -## Tuning Turns +## Tuning Turns   ### Step 1 - Constants Using the same steps as above, set kP to some number and modify it until there is slight oscillation, one or two bounces. -Increase kD until the oscillation is gone. +Increase kD until the oscillation is gone.   -Repeat until kD cannot fix the oscillation. +Repeat until kD cannot fix the oscillation.   ```cpp - chassis.pid_turn_constants_set(3, 0, 20); +chassis.pid_turn_constants_set(3, 0, 20); ``` ### Step 2 - kI -What about when PD isn't enough? +What about when PD isn't enough?   -Sometimes you need a little extra power to get your robot all the way there. Integral can be a dangerous variable because it grows exponentially. The fourth parameter is what the error needs to be for I to start. For turns, we found around 15 degrees is good. +Sometimes you need a little extra power to get your robot all the way there.  Integral can be a dangerous variable because it grows exponentially.  The fourth parameter is what the error needs to be for I to start.  For turns, we found around 15 degrees is good. -Increase kI until any minor disturbances are accounted for. You might need to adjust kD while tuning kI. +Increase kI until any minor disturbances are accounted for.  You might need to adjust kD while tuning kI.   ```cpp - chassis.pid_turn_constants_set(3, 0.003, 20, 15); +chassis.pid_turn_constants_set(3, 0.003, 20, 15); ``` -### Step 3 - Slew -Just like with drive motions, you can use slew with turns. The input distance is an angle instead of a length unit, but it works in the same way. - -The first parameter is the distance the robot will increase from min power to the max power you set in your autonomous function. -The second parameter is the starting power the robot will use when slewing. -```cpp - chassis.slew_turn_constants_set(5_deg, 50); -``` - --- -## Swings +## Swings   -### Forwards and Backwards PID Constants +### Forward and Backward PID Constants Just like with driving, you can have independent forward and backward constants for your swing turns. ```cpp - chassis.pid_swing_constants_forward_set(5, 0, 30); - chassis.pid_swing_constants_forward_set(5, 0, 30); +chassis.pid_swing_constants_forward_set(5, 0, 30); +chassis.pid_swing_constants_forward_set(5, 0, 30); ``` And if this isn't a problem for your robot, you can just use this function. ```cpp - chassis.pid_swing_constants_set(5, 0, 30); // Sets forward and backward -``` - -### Slew with Angle as Target -Swing turns are a middle ground between driving and turns. Because of this, you have two options for how you want to use slew. This option uses angle just like turns do. -```cpp - chassis.slew_swing_constants_set(5_deg, 50); // Sets forward and backward +chassis.pid_swing_constants_set(5, 0, 30); // Sets forward and backward ``` -If your robot is different forwards and backwards, these are the functions you'd want to use. -```cpp - chassis.slew_swing_constants_forward_set(5_deg, 50); - chassis.slew_swing_constants_backward_set(5_deg, 50); -``` - -### Slew with Length as Target -You can use length instead of angle to accomplish the same thing with swing turns. -```cpp - chassis.slew_swing_constants_set(7_in, 50); // Sets forward and backward -``` - -And, big surprise, you can have independent forward and backward control over the constants. -```cpp - chassis.slew_swing_constants_forward_set(7_in, 50); - chassis.slew_swing_constants_backward_set(5_in, 50); -``` --- ## General Tips -### Find Your Maximum -When you're tuning PID, don't increase kP by 0.1 every time you run. If 1.0 isn't high enough, try 10.0. If that's still not high enough, go to 20.0. In this process you'll quickly find a minimum and maximum value that it can be within. +### Quickly Find Your Maximum +When you're tuning PID, don't increase kP by 0.1 every time you run.  If 1.0 isn't high enough, try 10.0.  If that's still not high enough, go to 20.0.  In this process, you'll quickly find a minimum and maximum value that it can be within.   ### Change it Up -Your goal is to make PID constants that generally work on all of your drive motions. If you're tuning constants to a single motion, it's less likely to work on everything you make. +Your goal is to make PID constants that generally work on all of your drive motions.  If you're tuning constants to a single motion, it's less likely to work on everything you make.   -Using the example autons to tune is a good start. But once you're in the ballpark of where you want to be, start slowly making an autonomous routine and you can tune it more as you go. Once that first autonomous routine is done, your constants will be good. \ No newline at end of file +Using the example autons to tune is a good start.  But once you're in the ballpark of where you want to be, start slowly making an autonomous routine and you can tune it more as you go.  Once that first autonomous routine is done, your constants will be good. \ No newline at end of file diff --git a/ez-template-docs/tutorials/tuning_exit_conditions.md b/ez-template-docs/tutorials/tuning_exit_conditions.md new file mode 100644 index 00000000..a5c2be12 --- /dev/null +++ b/ez-template-docs/tutorials/tuning_exit_conditions.md @@ -0,0 +1,137 @@ +--- +title: Exit Condition Constants +description: Making the robot stop moving when we want it to +--- + +# Tuning Exit Conditions + +## What is it? +Exit conditions are how EZ-Template decides it's time to move on from a motion.  This is like putting your code in a while loop until you've reached your target.   +```cpp +chassis.pid_drive_set(24_in, 110); +while (true) { +  if (robot_reaches_target()) { +    break; +  } else { +    // keep running because we're not there yet! +  } +  pros::delay(ez::util::DELAY_TIME); +} +``` + +See [this page](https://ez-robotics.github.io/EZ-Template/tutorials/example_autons) for example autonomous routines to see how exit conditions get implemented.   + +Once the robot has "exited" the PID **does not** stop running.  EZ-Template will constantly run the PID in the background.  "Exiting" just means that the code is free to move on to the next task, which could mean intaking, raising a lift, or continuing onto the next drive motion.   + +## How Does it Work? +### pid_wait() +EZ-Template's exit conditions are a little more special than that though.  We run timers to tell how long the robot has been within X of your target, and then exit once it's reached a threshold you've set.  This is what our exit conditions look like at their simplest. +![](images/small_timeout.gif) + +You can add another layer to this where it'll also check for a larger area.  Now 2 timers will run, one when you're within X of target and one when you're within Y of target. +![](images/big_timeout.gif) + +But when the robot enters the smaller exit zone, the big timer will not continue.  This can be seen here. +![](images/big_timeout_reset_small_timeout.gif) + +There are 2 more timers that you can add on as well.  These are intended to be **failsafes** for when the previous two don't trigger fast enough or don't trigger at all.  One timer will start to increase when the velocity of the robot is 0, so if the robot is still for too long it'll exit.  Another timer will start once the robot sees it's pulling on the motors too hard (ie, you're fighting your opponent for a mobile goal), and if it's doing this for too long it'll exit.   + +`pid_wait()` will be your safest way to exit, but with that, it's also going to be the slowest way to exit.   + +### pid_wait_until() +`pid_wait_until()` is very similar to typing the code below.  This code will exit as soon as the robot has traveled 6 inches.   +```cpp +```cpp +double first_value = chassis.drive_sensor_left(); +chassis.pid_drive_set(24_in, 110); +while (true) { +double distance_traveled = chassis.drive_sensor_left() - first_value; +  if (distance_traveled > 6.0) { +    break; +  } else { +    // keep running because we're not there yet! +  } +  pros::delay(ez::util::DELAY_TIME); +} +``` + +EZ-Template does a little more than just this though.  What if the robot never reaches 6 inches?  All of the normal exit conditions still run underneath `pid_wait_until()`.  So if the robot has 0 velocity for long enough, your robot will not be stuck there.   + +The intended use case for this is if you want to do stuff during drive motions.  Now you can decide exactly when you want to, and after you've traveled 6 inches you can have your intake start spinning!   + +### pid_wait_quick() +`pid_wait_quick()` is exactly the same as writing the code below.  It will `pid_wait_until(target)` but it'll replace `target` with wherever the last target you set was.  This way of exiting has a chance at being faster, because if the robot overshoots at all then the code will exit.  If you undershoot then it'll be as if you ran a normal `pid_wait()`.   +```cpp +chassis.pid_drive_set(24_in, 110); +chassis.pid_wait_until(24); +``` + +### pid_wait_quick_chain() +`pid_wait_quick_chain()` is your fastest way of exiting.  The code below is what happens internally.  You will tell the robot to go 24 inches, internally X will get added to target, and `pid_wait_until()` will get called with the target YOU entered.  While being the fastest way of exiting, this should be used with caution as it can lead to inconsistencies.  Make sure your PID is well-tuned and do enough testing that you're confident your results are consistent.   +```cpp +chassis.pid_drive_set(27_in, 110);  // You really want to go 24in +chassis.pid_wait_until(24); +``` + +## Tuning +Ultimately you're tuning for 2 functions; timers and when to start timing for `pid_wait()`, and how much to add to target for `pid_wait_quick_chain()`.   + +### Tuning pid_wait() +The values to tune are in `default_constants()` in your `src/autons.cpp`.  The parameters are: +* The first number is the amount of time needed to exit when within the second number of your target   +* The third number is the amount of time needed to edit when within the fourth number of your target   +* The fifth number is the amount of time to edit when the velocity of the robot is 0   +* The sixth number is the amount of time to exit when you're pulling too many amps from your motors   +```cpp +void default_constants() { +  // . . . + chassis.pid_turn_exit_condition_set(80_ms, 3_deg, 250_ms, 7_deg, 500_ms, 500_ms); + chassis.pid_swing_exit_condition_set(80_ms, 3_deg, 250_ms, 7_deg, 500_ms, 500_ms); + chassis.pid_drive_exit_condition_set(80_ms, 1_in, 250_ms, 3_in, 500_ms, 500_ms); +  // . . . +} +``` + +I like to use the `drive_and_turn()` example autonomous routine when tuning PID.  You get turns that happen back to back and some drive motions that lead into them.   + +The default constants are already pretty aggressive, you shouldn't have to tune them much.  You can adjust the window that the timers start within and you can adjust the amount the timer has to reach before exiting.  If the window is too large, you'll exit too early.  If the time to wait is too low, you'll exit too early.  This can all be adjusted retroactively while making real autonomous routines + +You should make these numbers as low as you can without causing inconsistencies.  With `pid_wait()` you generally want the robot to be pretty close to stopped before it moves on to the next motion.   + +### Tuning pid_wait_quick_chain() +You can tune the amount added to `target` during chained motions.  If this number is too large, you'll carry too much momentum into the next motion and will cause inconsistencies.  The only downside to this number being too small is potential wasted time as it could turn into a normal `pid_wait()` if you don't overshoot your target.  Generally, I would err on this being smaller.   + + +#### Driving +You have independent control over forward and backward constants for this.  If your robot doesn't have problems with tipping or wheel slip, you should be good with the normal `pid_drive_chain_constant_set()`.   +```cpp +void default_constants() { +  // . . . + chassis.pid_drive_chain_constant_set(3_in);  // This sets forwards and backwards constants + chassis.pid_drive_chain_forward_constant_set(3_in); + chassis.pid_drive_chain_backward_constant_set(3_in); +  // . . . +} +``` + +#### Turning +This is the simple one.  We assume your robot is symmetrical in turning and you only get 1 function to tune.   +```cpp +void default_constants() { +  // . . . + chassis.pid_turn_chain_constant_set(3_deg);   +  // . . . +} +``` + +#### Swinging +You have independent control over forward and backward constants for this.  If your robot doesn't have problems with tipping or wheel slip, you should be good with the normal `pid_swing_chain_constant_set()`.   +```cpp +void default_constants() { +  // . . . + chassis.pid_swing_chain_constant_set(5_deg);  // This sets forwards and backwards constants + chassis.pid_swing_chain_forward_constant_set(5_deg); + chassis.pid_swing_chain_backward_constant_set(5_deg); +  // . . . +} +``` \ No newline at end of file diff --git a/ez-template-docs/tutorials/upgrading.md b/ez-template-docs/tutorials/upgrading.md new file mode 100644 index 00000000..401bfef7 --- /dev/null +++ b/ez-template-docs/tutorials/upgrading.md @@ -0,0 +1,37 @@ +--- +title: Upgrading +description: How to upgrade EZ-Template +--- + +:::warning + +This only works for 2.x and beyond. You cannot upgrade from 1.x to 2.x, or 2.x to 3.x without changing code. See more about migration [here](https://ez-robotics.github.io/EZ-Template/migration). + +::: + +## Download EZ-Template +Download the most recent `EZ-Template@x.x.x.zip` [here](https://github.com/EZ-Robotics/EZ-Template/releases/latest). + +## Bring the File Into Your Project +Bring this file into your project. You can do this through file explorer or by dragging it into VScode. + +## Open Integrated Terminal +### Select the PROS Icon on the Left +![](images/pros-icon.png) +### Select `Integrated Terminal` +![](images/pros-menu-integrated-terminal.png) + +## Fetch the File +Type the text below in the terminal, replacing `x.x.x` with the version of your file. Press Enter. +``` +pros c fetch EZ-Template@x.x.x.zip +``` + +## Apply EZ-Template to Your Project +Apply EZ-Template to your project by typing below, replacing `x.x.x` with the version of your file. Press Enter. +``` +pros c apply EZ-Template@x.x.x +``` + +## You're Done! +That's it! You've now updated to the most recent version of EZ-Template! diff --git a/ez-template-docs/tutorials/using_auton_selector.md b/ez-template-docs/tutorials/using_auton_selector.md index 0387f865..5e43949e 100644 --- a/ez-template-docs/tutorials/using_auton_selector.md +++ b/ez-template-docs/tutorials/using_auton_selector.md @@ -2,49 +2,55 @@ title: Using Autonomous Selector description: How to have multiple autonomous routines in one program --- +import Tabs from '@theme/Tabs'; +import TabItem from '@theme/TabItem'; -## Select and Run your Autonomous -With a competition switch, run your code in disable. Select the autonomous on the screen by pressing the left / right buttons until you're on the page you want. Select `Autonomous` on your competition switch, and set it to `Enable` to run the autonomous. +## Why? +There are two main ways to have multiple autonomous routines: +1. One program loaded with multiple routines. +2. Multiple programs with one routine each. -## Using an SD Card -The SD card will remember the last page you were on before powering the robot off. If you're on page 3 and power off, the next time you power on the selector will start on page 3. +I dislike 2.  If you make a change to a PID constant or make a change to user control code, you now have to redownload multiple times.  I find this tedious and easy to make a mistake while under pressure at a tournament.   -To use an SD card with the brain, just plug it in! +## Selecting the Autonomous Routine +The brain screen has 3 buttons.  With EZ-Template the center button does nothing.  You can navigate through the menus by selecting the left or right button.  Once autonomous mode is enabled, the page that is left open will be the autonomous routine that runs.   + +## Running the Autonomous Routine +### With a Competition Switch +With a competition switch, run your code in disable.  Select the autonomous on the screen.  Change the competition switch to `Autonomous` on your competition switch, and set it to `Enable`.  Your autonomous routine will run! + +### Without a Competition Switch +This code changed in the example project slightly between 3.0.x and 3.1.0, where it now requires multiple buttons to be held to prevent accidental triggers.  But, holding `B` and `DOWN` will run the selected autonomous routine during driver control.   +3.1.0',  value: 'proto', }, + { label: '<3.1.0',  value: 'example', }, +  ] +}> + + -## Testing Autonomous in Opcontrol -During opcontrol you can call your autonomous. In the example below, when the robot isn't connected to a competition switch and B is pressed on the controller, the autonomous will run. To select your autonomous, use the left / right buttons on the brain screen until you're on the page you want, then run the autonomous. ```cpp -void opcontrol() { - // This is preference to what you like to drive on - chassis.drive_brake_set(MOTOR_BRAKE_COAST); - - while (true) { - - // PID Tuner - // After you find values that you're happy with, you'll have to set them in auton.cpp - if (!pros::competition::is_connected()) { - // Enable / Disable PID Tuner - if (master.get_digital_new_press(DIGITAL_X)) - chassis.pid_tuner_toggle(); - - // Trigger the selected autonomous routine - if (master.get_digital_new_press(DIGITAL_B)) - autonomous(); - - chassis.pid_tuner_iterate(); // Allow PID Tuner to iterate - } - - chassis.opcontrol_tank(); // Tank control - // chassis.opcontrol_arcade_standard(ez::SPLIT); // Standard split arcade - // chassis.opcontrol_arcade_standard(ez::SINGLE); // Standard single arcade - // chassis.opcontrol_arcade_flipped(ez::SPLIT); // Flipped split arcade - // chassis.opcontrol_arcade_flipped(ez::SINGLE); // Flipped single arcade - - // . . . - // Put more user control code here! - // . . . - - pros::delay(ez::util::DELAY_TIME); // This is used for timer calculations! Keep this ez::util::DELAY_TIME - } -} -``` \ No newline at end of file +// Trigger the selected autonomous routine +if (master.get_digital_new_press(DIGITAL_B)) +  autonomous(); +``` + + + + + +```cpp +// Trigger the selected autonomous routine +if (master.get_digital(DIGITAL_B) && master.get_digital(DIGITAL_DOWN)) +  autonomous(); +``` + + + +## Micro-SD Card Support +To make things easier at tournaments, having an SD card in your brain will save the last page between cycles.  So if you select page 3 then turn off the brain, the next time you turn the brain on it'll start from page 3.  This means you can select your autonomous routine while queueing for a match and it'll hold when you get to a match.   + +The micro-SD card must be formatted to FAT32.  [Here](https://www.lifewire.com/format-sd-card-to-fat32-6666166) is a tutorial on how to do that. diff --git a/package-lock.json b/package-lock.json index 3c7289d6..42bb62ba 100644 --- a/package-lock.json +++ b/package-lock.json @@ -8,9 +8,9 @@ "name": "my-website", "version": "0.0.0", "dependencies": { - "@docusaurus/core": "^3.2.1", - "@docusaurus/plugin-ideal-image": "^3.2.1", - "@docusaurus/preset-classic": "^3.2.1", + "@docusaurus/core": "^3.4.0", + "@docusaurus/plugin-ideal-image": "^3.4.0", + "@docusaurus/preset-classic": "^3.4.0", "@mdx-js/react": "^3.0.0", "clsx": "^1.2.1", "prism-react-renderer": "^2.1.0", @@ -18,8 +18,8 @@ "react-dom": "^18.0.0" }, "devDependencies": { - "@docusaurus/module-type-aliases": "^3.2.1", - "@docusaurus/types": "^3.2.1" + "@docusaurus/module-type-aliases": "^3.4.0", + "@docusaurus/types": "^3.4.0" }, "engines": { "node": ">=18.0" @@ -67,74 +67,74 @@ } }, "node_modules/@algolia/cache-browser-local-storage": { - "version": "4.23.2", - "resolved": "https://registry.npmjs.org/@algolia/cache-browser-local-storage/-/cache-browser-local-storage-4.23.2.tgz", - "integrity": "sha512-PvRQdCmtiU22dw9ZcTJkrVKgNBVAxKgD0/cfiqyxhA5+PHzA2WDt6jOmZ9QASkeM2BpyzClJb/Wr1yt2/t78Kw==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/cache-browser-local-storage/-/cache-browser-local-storage-4.23.3.tgz", + "integrity": "sha512-vRHXYCpPlTDE7i6UOy2xE03zHF2C8MEFjPN2v7fRbqVpcOvAUQK81x3Kc21xyb5aSIpYCjWCZbYZuz8Glyzyyg==", "dependencies": { - "@algolia/cache-common": "4.23.2" + "@algolia/cache-common": "4.23.3" } }, "node_modules/@algolia/cache-common": { - "version": "4.23.2", - "resolved": "https://registry.npmjs.org/@algolia/cache-common/-/cache-common-4.23.2.tgz", - "integrity": "sha512-OUK/6mqr6CQWxzl/QY0/mwhlGvS6fMtvEPyn/7AHUx96NjqDA4X4+Ju7aXFQKh+m3jW9VPB0B9xvEQgyAnRPNw==" + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/cache-common/-/cache-common-4.23.3.tgz", + "integrity": "sha512-h9XcNI6lxYStaw32pHpB1TMm0RuxphF+Ik4o7tcQiodEdpKK+wKufY6QXtba7t3k8eseirEMVB83uFFF3Nu54A==" }, "node_modules/@algolia/cache-in-memory": { - "version": "4.23.2", - "resolved": "https://registry.npmjs.org/@algolia/cache-in-memory/-/cache-in-memory-4.23.2.tgz", - "integrity": "sha512-rfbi/SnhEa3MmlqQvgYz/9NNJ156NkU6xFxjbxBtLWnHbpj+qnlMoKd+amoiacHRITpajg6zYbLM9dnaD3Bczw==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/cache-in-memory/-/cache-in-memory-4.23.3.tgz", + "integrity": "sha512-yvpbuUXg/+0rbcagxNT7un0eo3czx2Uf0y4eiR4z4SD7SiptwYTpbuS0IHxcLHG3lq22ukx1T6Kjtk/rT+mqNg==", "dependencies": { - "@algolia/cache-common": "4.23.2" + "@algolia/cache-common": "4.23.3" } }, "node_modules/@algolia/client-account": { - "version": "4.23.2", - "resolved": "https://registry.npmjs.org/@algolia/client-account/-/client-account-4.23.2.tgz", - "integrity": "sha512-VbrOCLIN/5I7iIdskSoSw3uOUPF516k4SjDD4Qz3BFwa3of7D9A0lzBMAvQEJJEPHWdVraBJlGgdJq/ttmquJQ==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/client-account/-/client-account-4.23.3.tgz", + "integrity": "sha512-hpa6S5d7iQmretHHF40QGq6hz0anWEHGlULcTIT9tbUssWUriN9AUXIFQ8Ei4w9azD0hc1rUok9/DeQQobhQMA==", "dependencies": { - "@algolia/client-common": "4.23.2", - "@algolia/client-search": "4.23.2", - "@algolia/transporter": "4.23.2" + "@algolia/client-common": "4.23.3", + "@algolia/client-search": "4.23.3", + "@algolia/transporter": "4.23.3" } }, "node_modules/@algolia/client-analytics": { - "version": "4.23.2", - "resolved": "https://registry.npmjs.org/@algolia/client-analytics/-/client-analytics-4.23.2.tgz", - "integrity": "sha512-lLj7irsAztGhMoEx/SwKd1cwLY6Daf1Q5f2AOsZacpppSvuFvuBrmkzT7pap1OD/OePjLKxicJS8wNA0+zKtuw==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/client-analytics/-/client-analytics-4.23.3.tgz", + "integrity": "sha512-LBsEARGS9cj8VkTAVEZphjxTjMVCci+zIIiRhpFun9jGDUlS1XmhCW7CTrnaWeIuCQS/2iPyRqSy1nXPjcBLRA==", "dependencies": { - "@algolia/client-common": "4.23.2", - "@algolia/client-search": "4.23.2", - "@algolia/requester-common": "4.23.2", - "@algolia/transporter": "4.23.2" + "@algolia/client-common": "4.23.3", + "@algolia/client-search": "4.23.3", + "@algolia/requester-common": "4.23.3", + "@algolia/transporter": "4.23.3" } }, "node_modules/@algolia/client-common": { - "version": "4.23.2", - "resolved": "https://registry.npmjs.org/@algolia/client-common/-/client-common-4.23.2.tgz", - "integrity": "sha512-Q2K1FRJBern8kIfZ0EqPvUr3V29ICxCm/q42zInV+VJRjldAD9oTsMGwqUQ26GFMdFYmqkEfCbY4VGAiQhh22g==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/client-common/-/client-common-4.23.3.tgz", + "integrity": "sha512-l6EiPxdAlg8CYhroqS5ybfIczsGUIAC47slLPOMDeKSVXYG1n0qGiz4RjAHLw2aD0xzh2EXZ7aRguPfz7UKDKw==", "dependencies": { - "@algolia/requester-common": "4.23.2", - "@algolia/transporter": "4.23.2" + "@algolia/requester-common": "4.23.3", + "@algolia/transporter": "4.23.3" } }, "node_modules/@algolia/client-personalization": { - "version": "4.23.2", - "resolved": "https://registry.npmjs.org/@algolia/client-personalization/-/client-personalization-4.23.2.tgz", - "integrity": "sha512-vwPsgnCGhUcHhhQG5IM27z8q7dWrN9itjdvgA6uKf2e9r7vB+WXt4OocK0CeoYQt3OGEAExryzsB8DWqdMK5wg==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/client-personalization/-/client-personalization-4.23.3.tgz", + "integrity": "sha512-3E3yF3Ocr1tB/xOZiuC3doHQBQ2zu2MPTYZ0d4lpfWads2WTKG7ZzmGnsHmm63RflvDeLK/UVx7j2b3QuwKQ2g==", "dependencies": { - "@algolia/client-common": "4.23.2", - "@algolia/requester-common": "4.23.2", - "@algolia/transporter": "4.23.2" + "@algolia/client-common": "4.23.3", + "@algolia/requester-common": "4.23.3", + "@algolia/transporter": "4.23.3" } }, "node_modules/@algolia/client-search": { - "version": "4.23.2", - "resolved": "https://registry.npmjs.org/@algolia/client-search/-/client-search-4.23.2.tgz", - "integrity": "sha512-CxSB29OVGSE7l/iyoHvamMonzq7Ev8lnk/OkzleODZ1iBcCs3JC/XgTIKzN/4RSTrJ9QybsnlrN/bYCGufo7qw==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/client-search/-/client-search-4.23.3.tgz", + "integrity": "sha512-P4VAKFHqU0wx9O+q29Q8YVuaowaZ5EM77rxfmGnkHUJggh28useXQdopokgwMeYw2XUht49WX5RcTQ40rZIabw==", "dependencies": { - "@algolia/client-common": "4.23.2", - "@algolia/requester-common": "4.23.2", - "@algolia/transporter": "4.23.2" + "@algolia/client-common": "4.23.3", + "@algolia/requester-common": "4.23.3", + "@algolia/transporter": "4.23.3" } }, "node_modules/@algolia/events": { @@ -143,65 +143,65 @@ "integrity": "sha512-FQzvOCgoFXAbf5Y6mYozw2aj5KCJoA3m4heImceldzPSMbdyS4atVjJzXKMsfX3wnZTFYwkkt8/z8UesLHlSBQ==" }, "node_modules/@algolia/logger-common": { - "version": "4.23.2", - "resolved": "https://registry.npmjs.org/@algolia/logger-common/-/logger-common-4.23.2.tgz", - "integrity": "sha512-jGM49Q7626cXZ7qRAWXn0jDlzvoA1FvN4rKTi1g0hxKsTTSReyYk0i1ADWjChDPl3Q+nSDhJuosM2bBUAay7xw==" + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/logger-common/-/logger-common-4.23.3.tgz", + "integrity": "sha512-y9kBtmJwiZ9ZZ+1Ek66P0M68mHQzKRxkW5kAAXYN/rdzgDN0d2COsViEFufxJ0pb45K4FRcfC7+33YB4BLrZ+g==" }, "node_modules/@algolia/logger-console": { - "version": "4.23.2", - "resolved": "https://registry.npmjs.org/@algolia/logger-console/-/logger-console-4.23.2.tgz", - "integrity": "sha512-oo+lnxxEmlhTBTFZ3fGz1O8PJ+G+8FiAoMY2Qo3Q4w23xocQev6KqDTA1JQAGPDxAewNA2VBwWOsVXeXFjrI/Q==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/logger-console/-/logger-console-4.23.3.tgz", + "integrity": "sha512-8xoiseoWDKuCVnWP8jHthgaeobDLolh00KJAdMe9XPrWPuf1by732jSpgy2BlsLTaT9m32pHI8CRfrOqQzHv3A==", "dependencies": { - "@algolia/logger-common": "4.23.2" + "@algolia/logger-common": "4.23.3" } }, "node_modules/@algolia/recommend": { - "version": "4.23.2", - "resolved": "https://registry.npmjs.org/@algolia/recommend/-/recommend-4.23.2.tgz", - "integrity": "sha512-Q75CjnzRCDzgIlgWfPnkLtrfF4t82JCirhalXkSSwe/c1GH5pWh4xUyDOR3KTMo+YxxX3zTlrL/FjHmUJEWEcg==", - "dependencies": { - "@algolia/cache-browser-local-storage": "4.23.2", - "@algolia/cache-common": "4.23.2", - "@algolia/cache-in-memory": "4.23.2", - "@algolia/client-common": "4.23.2", - "@algolia/client-search": "4.23.2", - "@algolia/logger-common": "4.23.2", - "@algolia/logger-console": "4.23.2", - "@algolia/requester-browser-xhr": "4.23.2", - "@algolia/requester-common": "4.23.2", - "@algolia/requester-node-http": "4.23.2", - "@algolia/transporter": "4.23.2" + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/recommend/-/recommend-4.23.3.tgz", + "integrity": "sha512-9fK4nXZF0bFkdcLBRDexsnGzVmu4TSYZqxdpgBW2tEyfuSSY54D4qSRkLmNkrrz4YFvdh2GM1gA8vSsnZPR73w==", + "dependencies": { + "@algolia/cache-browser-local-storage": "4.23.3", + "@algolia/cache-common": "4.23.3", + "@algolia/cache-in-memory": "4.23.3", + "@algolia/client-common": "4.23.3", + "@algolia/client-search": "4.23.3", + "@algolia/logger-common": "4.23.3", + "@algolia/logger-console": "4.23.3", + "@algolia/requester-browser-xhr": "4.23.3", + "@algolia/requester-common": "4.23.3", + "@algolia/requester-node-http": "4.23.3", + "@algolia/transporter": "4.23.3" } }, "node_modules/@algolia/requester-browser-xhr": { - "version": "4.23.2", - "resolved": "https://registry.npmjs.org/@algolia/requester-browser-xhr/-/requester-browser-xhr-4.23.2.tgz", - "integrity": "sha512-TO9wLlp8+rvW9LnIfyHsu8mNAMYrqNdQ0oLF6eTWFxXfxG3k8F/Bh7nFYGk2rFAYty4Fw4XUtrv/YjeNDtM5og==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/requester-browser-xhr/-/requester-browser-xhr-4.23.3.tgz", + "integrity": "sha512-jDWGIQ96BhXbmONAQsasIpTYWslyjkiGu0Quydjlowe+ciqySpiDUrJHERIRfELE5+wFc7hc1Q5hqjGoV7yghw==", "dependencies": { - "@algolia/requester-common": "4.23.2" + "@algolia/requester-common": "4.23.3" } }, "node_modules/@algolia/requester-common": { - "version": "4.23.2", - "resolved": "https://registry.npmjs.org/@algolia/requester-common/-/requester-common-4.23.2.tgz", - "integrity": "sha512-3EfpBS0Hri0lGDB5H/BocLt7Vkop0bTTLVUBB844HH6tVycwShmsV6bDR7yXbQvFP1uNpgePRD3cdBCjeHmk6Q==" + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/requester-common/-/requester-common-4.23.3.tgz", + "integrity": "sha512-xloIdr/bedtYEGcXCiF2muajyvRhwop4cMZo+K2qzNht0CMzlRkm8YsDdj5IaBhshqfgmBb3rTg4sL4/PpvLYw==" }, "node_modules/@algolia/requester-node-http": { - "version": "4.23.2", - "resolved": "https://registry.npmjs.org/@algolia/requester-node-http/-/requester-node-http-4.23.2.tgz", - "integrity": "sha512-SVzgkZM/malo+2SB0NWDXpnT7nO5IZwuDTaaH6SjLeOHcya1o56LSWXk+3F3rNLz2GVH+I/rpYKiqmHhSOjerw==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/requester-node-http/-/requester-node-http-4.23.3.tgz", + "integrity": "sha512-zgu++8Uj03IWDEJM3fuNl34s746JnZOWn1Uz5taV1dFyJhVM/kTNw9Ik7YJWiUNHJQXcaD8IXD1eCb0nq/aByA==", "dependencies": { - "@algolia/requester-common": "4.23.2" + "@algolia/requester-common": "4.23.3" } }, "node_modules/@algolia/transporter": { - "version": "4.23.2", - "resolved": "https://registry.npmjs.org/@algolia/transporter/-/transporter-4.23.2.tgz", - "integrity": "sha512-GY3aGKBy+8AK4vZh8sfkatDciDVKad5rTY2S10Aefyjh7e7UGBP4zigf42qVXwU8VOPwi7l/L7OACGMOFcjB0Q==", + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/@algolia/transporter/-/transporter-4.23.3.tgz", + "integrity": "sha512-Wjl5gttqnf/gQKJA+dafnD0Y6Yw97yvfY8R9h0dQltX1GXTgNs1zWgvtWW0tHl1EgMdhAyw189uWiZMnL3QebQ==", "dependencies": { - "@algolia/cache-common": "4.23.2", - "@algolia/logger-common": "4.23.2", - "@algolia/requester-common": "4.23.2" + "@algolia/cache-common": "4.23.3", + "@algolia/logger-common": "4.23.3", + "@algolia/requester-common": "4.23.3" } }, "node_modules/@ampproject/remapping": { @@ -548,9 +548,9 @@ } }, "node_modules/@babel/helper-plugin-utils": { - "version": "7.22.5", - "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.22.5.tgz", - "integrity": "sha512-uLls06UVKgFG9QD4OeFYLEGteMIAa5kpTPcFL28yuCIIzsf6ZyKZMllKVOCZFhiZ5ptnwX4mtKdWCBE/uT4amg==", + "version": "7.24.6", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.24.6.tgz", + "integrity": "sha512-MZG/JcWfxybKwsA9N9PmtF2lOSFSEMVCpIRrbxccZFLJPrJciJdG/UhSh5W96GEteJI2ARqm5UAHxISwRDLSNg==", "engines": { "node": ">=6.9.0" } @@ -1610,11 +1610,11 @@ } }, "node_modules/@babel/plugin-transform-react-constant-elements": { - "version": "7.22.5", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-constant-elements/-/plugin-transform-react-constant-elements-7.22.5.tgz", - "integrity": "sha512-BF5SXoO+nX3h5OhlN78XbbDrBOffv+AxPP2ENaJOVqjWCgBDeOY3WcaUcddutGSfoap+5NEQ/q/4I3WZIvgkXA==", + "version": "7.24.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-constant-elements/-/plugin-transform-react-constant-elements-7.24.6.tgz", + "integrity": "sha512-vQfyXRtG/kNIcTYRd/49uJnwvMig9X3R4XsTVXRml2RFupZFY+2RDuK+/ymb+MfX2WuIHAgUZc2xEvQrnI7QCg==", "dependencies": { - "@babel/helper-plugin-utils": "^7.22.5" + "@babel/helper-plugin-utils": "^7.24.6" }, "engines": { "node": ">=6.9.0" @@ -2166,9 +2166,9 @@ } }, "node_modules/@docusaurus/core": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/core/-/core-3.2.1.tgz", - "integrity": "sha512-ZeMAqNvy0eBv2dThEeMuNzzuu+4thqMQakhxsgT5s02A8LqRcdkg+rbcnuNqUIpekQ4GRx3+M5nj0ODJhBXo9w==", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/core/-/core-3.4.0.tgz", + "integrity": "sha512-g+0wwmN2UJsBqy2fQRQ6fhXruoEa62JDeEa5d8IdTJlMoaDaEDfHh7WjwGRn4opuTQWpjAwP/fbcgyHKlE+64w==", "dependencies": { "@babel/core": "^7.23.3", "@babel/generator": "^7.23.3", @@ -2180,14 +2180,12 @@ "@babel/runtime": "^7.22.6", "@babel/runtime-corejs3": "^7.22.6", "@babel/traverse": "^7.22.8", - "@docusaurus/cssnano-preset": "3.2.1", - "@docusaurus/logger": "3.2.1", - "@docusaurus/mdx-loader": "3.2.1", - "@docusaurus/react-loadable": "5.5.2", - "@docusaurus/utils": "3.2.1", - "@docusaurus/utils-common": "3.2.1", - "@docusaurus/utils-validation": "3.2.1", - "@svgr/webpack": "^6.5.1", + "@docusaurus/cssnano-preset": "3.4.0", + "@docusaurus/logger": "3.4.0", + "@docusaurus/mdx-loader": "3.4.0", + "@docusaurus/utils": "3.4.0", + "@docusaurus/utils-common": "3.4.0", + "@docusaurus/utils-validation": "3.4.0", "autoprefixer": "^10.4.14", "babel-loader": "^9.1.3", "babel-plugin-dynamic-import-node": "^2.3.3", @@ -2201,8 +2199,8 @@ "copy-webpack-plugin": "^11.0.0", "core-js": "^3.31.1", "css-loader": "^6.8.1", - "css-minimizer-webpack-plugin": "^4.2.2", - "cssnano": "^5.1.15", + "css-minimizer-webpack-plugin": "^5.0.1", + "cssnano": "^6.1.2", "del": "^6.1.1", "detect-port": "^1.5.1", "escape-html": "^1.0.3", @@ -2222,7 +2220,7 @@ "prompts": "^2.4.2", "react-dev-utils": "^12.0.1", "react-helmet-async": "^1.3.0", - "react-loadable": "npm:@docusaurus/react-loadable@5.5.2", + "react-loadable": "npm:@docusaurus/react-loadable@6.0.0", "react-loadable-ssr-addon-v5-slorber": "^1.0.1", "react-router": "^5.3.4", "react-router-config": "^5.1.1", @@ -2253,13 +2251,13 @@ } }, "node_modules/@docusaurus/cssnano-preset": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/cssnano-preset/-/cssnano-preset-3.2.1.tgz", - "integrity": "sha512-wTL9KuSSbMJjKrfu385HZEzAoamUsbKqwscAQByZw4k6Ja/RWpqgVvt/CbAC+aYEH6inLzOt+MjuRwMOrD3VBA==", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/cssnano-preset/-/cssnano-preset-3.4.0.tgz", + "integrity": "sha512-qwLFSz6v/pZHy/UP32IrprmH5ORce86BGtN0eBtG75PpzQJAzp9gefspox+s8IEOr0oZKuQ/nhzZ3xwyc3jYJQ==", "dependencies": { - "cssnano-preset-advanced": "^5.3.10", - "postcss": "^8.4.26", - "postcss-sort-media-queries": "^4.4.1", + "cssnano-preset-advanced": "^6.1.2", + "postcss": "^8.4.38", + "postcss-sort-media-queries": "^5.2.0", "tslib": "^2.6.0" }, "engines": { @@ -2267,9 +2265,9 @@ } }, "node_modules/@docusaurus/logger": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/logger/-/logger-3.2.1.tgz", - "integrity": "sha512-0voOKJCn9RaM3np6soqEfo7SsVvf2C+CDTWhW+H/1AyBhybASpExtDEz+7ECck9TwPzFQ5tt+I3zVugUJbJWDg==", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/logger/-/logger-3.4.0.tgz", + "integrity": "sha512-bZwkX+9SJ8lB9kVRkXw+xvHYSMGG4bpYHKGXeXFvyVc79NMeeBSGgzd4TQLHH+DYeOJoCdl8flrFJVxlZ0wo/Q==", "dependencies": { "chalk": "^4.1.2", "tslib": "^2.6.0" @@ -2279,11 +2277,11 @@ } }, "node_modules/@docusaurus/lqip-loader": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/lqip-loader/-/lqip-loader-3.2.1.tgz", - "integrity": "sha512-uE4OFsQTs7bwlRAPGaYis+ChI0as/XueC76A8dPbXajUC5f+uYQ1TlxM+NnAfN7dxgtl5OYsciUI/oYIXtob/Q==", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/lqip-loader/-/lqip-loader-3.4.0.tgz", + "integrity": "sha512-F//Gjqcz925zLL1l3Y3XOtQvn927GBIr9ZouvzWF4jHNKuuHBqzOPSADF5O/cT3Vq1ucPWooyhPBxYcvSGF4SA==", "dependencies": { - "@docusaurus/logger": "3.2.1", + "@docusaurus/logger": "3.4.0", "file-loader": "^6.2.0", "lodash": "^4.17.21", "sharp": "^0.32.3", @@ -2294,13 +2292,13 @@ } }, "node_modules/@docusaurus/mdx-loader": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/mdx-loader/-/mdx-loader-3.2.1.tgz", - "integrity": "sha512-Fs8tXhXKZjNkdGaOy1xSLXSwfjCMT73J3Zfrju2U16uGedRFRjgK0ojpK5tiC7TnunsL3tOFgp1BSMBRflX9gw==", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/mdx-loader/-/mdx-loader-3.4.0.tgz", + "integrity": "sha512-kSSbrrk4nTjf4d+wtBA9H+FGauf2gCax89kV8SUSJu3qaTdSIKdWERlngsiHaCFgZ7laTJ8a67UFf+xlFPtuTw==", "dependencies": { - "@docusaurus/logger": "3.2.1", - "@docusaurus/utils": "3.2.1", - "@docusaurus/utils-validation": "3.2.1", + "@docusaurus/logger": "3.4.0", + "@docusaurus/utils": "3.4.0", + "@docusaurus/utils-validation": "3.4.0", "@mdx-js/mdx": "^3.0.0", "@slorber/remark-comment": "^1.0.0", "escape-html": "^1.0.3", @@ -2332,18 +2330,17 @@ } }, "node_modules/@docusaurus/module-type-aliases": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/module-type-aliases/-/module-type-aliases-3.2.1.tgz", - "integrity": "sha512-FyViV5TqhL1vsM7eh29nJ5NtbRE6Ra6LP1PDcPvhwPSlA7eiWGRKAn3jWwMUcmjkos5SYY+sr0/feCdbM3eQHQ==", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/module-type-aliases/-/module-type-aliases-3.4.0.tgz", + "integrity": "sha512-A1AyS8WF5Bkjnb8s+guTDuYmUiwJzNrtchebBHpc0gz0PyHJNMaybUlSrmJjHVcGrya0LKI4YcR3lBDQfXRYLw==", "dependencies": { - "@docusaurus/react-loadable": "5.5.2", - "@docusaurus/types": "3.2.1", + "@docusaurus/types": "3.4.0", "@types/history": "^4.7.11", "@types/react": "*", "@types/react-router-config": "*", "@types/react-router-dom": "*", "react-helmet-async": "*", - "react-loadable": "npm:@docusaurus/react-loadable@5.5.2" + "react-loadable": "npm:@docusaurus/react-loadable@6.0.0" }, "peerDependencies": { "react": "*", @@ -2351,17 +2348,17 @@ } }, "node_modules/@docusaurus/plugin-content-blog": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-blog/-/plugin-content-blog-3.2.1.tgz", - "integrity": "sha512-lOx0JfhlGZoZu6pEJfeEpSISZR5dQbJGGvb42IP13G5YThNHhG9R9uoWuo4IOimPqBC7sHThdLA3VLevk61Fsw==", - "dependencies": { - "@docusaurus/core": "3.2.1", - "@docusaurus/logger": "3.2.1", - "@docusaurus/mdx-loader": "3.2.1", - "@docusaurus/types": "3.2.1", - "@docusaurus/utils": "3.2.1", - "@docusaurus/utils-common": "3.2.1", - "@docusaurus/utils-validation": "3.2.1", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-blog/-/plugin-content-blog-3.4.0.tgz", + "integrity": "sha512-vv6ZAj78ibR5Jh7XBUT4ndIjmlAxkijM3Sx5MAAzC1gyv0vupDQNhzuFg1USQmQVj3P5I6bquk12etPV3LJ+Xw==", + "dependencies": { + "@docusaurus/core": "3.4.0", + "@docusaurus/logger": "3.4.0", + "@docusaurus/mdx-loader": "3.4.0", + "@docusaurus/types": "3.4.0", + "@docusaurus/utils": "3.4.0", + "@docusaurus/utils-common": "3.4.0", + "@docusaurus/utils-validation": "3.4.0", "cheerio": "^1.0.0-rc.12", "feed": "^4.2.2", "fs-extra": "^11.1.1", @@ -2382,18 +2379,18 @@ } }, "node_modules/@docusaurus/plugin-content-docs": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-docs/-/plugin-content-docs-3.2.1.tgz", - "integrity": "sha512-GHe5b/lCskAR8QVbfWAfPAApvRZgqk7FN3sOHgjCtjzQACZxkHmq6QqyqZ8Jp45V7lVck4wt2Xw2IzBJ7Cz3bA==", - "dependencies": { - "@docusaurus/core": "3.2.1", - "@docusaurus/logger": "3.2.1", - "@docusaurus/mdx-loader": "3.2.1", - "@docusaurus/module-type-aliases": "3.2.1", - "@docusaurus/types": "3.2.1", - "@docusaurus/utils": "3.2.1", - "@docusaurus/utils-common": "3.2.1", - "@docusaurus/utils-validation": "3.2.1", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-docs/-/plugin-content-docs-3.4.0.tgz", + "integrity": "sha512-HkUCZffhBo7ocYheD9oZvMcDloRnGhBMOZRyVcAQRFmZPmNqSyISlXA1tQCIxW+r478fty97XXAGjNYzBjpCsg==", + "dependencies": { + "@docusaurus/core": "3.4.0", + "@docusaurus/logger": "3.4.0", + "@docusaurus/mdx-loader": "3.4.0", + "@docusaurus/module-type-aliases": "3.4.0", + "@docusaurus/types": "3.4.0", + "@docusaurus/utils": "3.4.0", + "@docusaurus/utils-common": "3.4.0", + "@docusaurus/utils-validation": "3.4.0", "@types/react-router-config": "^5.0.7", "combine-promises": "^1.1.0", "fs-extra": "^11.1.1", @@ -2412,15 +2409,15 @@ } }, "node_modules/@docusaurus/plugin-content-pages": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-pages/-/plugin-content-pages-3.2.1.tgz", - "integrity": "sha512-TOqVfMVTAHqWNEGM94Drz+PUpHDbwFy6ucHFgyTx9zJY7wPNSG5EN+rd/mU7OvAi26qpOn2o9xTdUmb28QLjEQ==", - "dependencies": { - "@docusaurus/core": "3.2.1", - "@docusaurus/mdx-loader": "3.2.1", - "@docusaurus/types": "3.2.1", - "@docusaurus/utils": "3.2.1", - "@docusaurus/utils-validation": "3.2.1", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-pages/-/plugin-content-pages-3.4.0.tgz", + "integrity": "sha512-h2+VN/0JjpR8fIkDEAoadNjfR3oLzB+v1qSXbIAKjQ46JAHx3X22n9nqS+BWSQnTnp1AjkjSvZyJMekmcwxzxg==", + "dependencies": { + "@docusaurus/core": "3.4.0", + "@docusaurus/mdx-loader": "3.4.0", + "@docusaurus/types": "3.4.0", + "@docusaurus/utils": "3.4.0", + "@docusaurus/utils-validation": "3.4.0", "fs-extra": "^11.1.1", "tslib": "^2.6.0", "webpack": "^5.88.1" @@ -2434,13 +2431,13 @@ } }, "node_modules/@docusaurus/plugin-debug": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/plugin-debug/-/plugin-debug-3.2.1.tgz", - "integrity": "sha512-AMKq8NuUKf2sRpN1m/sIbqbRbnmk+rSA+8mNU1LNxEl9BW9F/Gng8m9HKlzeyMPrf5XidzS1jqkuTLDJ6KIrFw==", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/plugin-debug/-/plugin-debug-3.4.0.tgz", + "integrity": "sha512-uV7FDUNXGyDSD3PwUaf5YijX91T5/H9SX4ErEcshzwgzWwBtK37nUWPU3ZLJfeTavX3fycTOqk9TglpOLaWkCg==", "dependencies": { - "@docusaurus/core": "3.2.1", - "@docusaurus/types": "3.2.1", - "@docusaurus/utils": "3.2.1", + "@docusaurus/core": "3.4.0", + "@docusaurus/types": "3.4.0", + "@docusaurus/utils": "3.4.0", "fs-extra": "^11.1.1", "react-json-view-lite": "^1.2.0", "tslib": "^2.6.0" @@ -2454,13 +2451,13 @@ } }, "node_modules/@docusaurus/plugin-google-analytics": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/plugin-google-analytics/-/plugin-google-analytics-3.2.1.tgz", - "integrity": "sha512-/rJ+9u+Px0eTCiF4TNcNtj3kHf8cp6K1HCwOTdbsSlz6Xn21syZYcy+f1VM9wF6HrvUkXUcbM5TDCvg2IRL6bQ==", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/plugin-google-analytics/-/plugin-google-analytics-3.4.0.tgz", + "integrity": "sha512-mCArluxEGi3cmYHqsgpGGt3IyLCrFBxPsxNZ56Mpur0xSlInnIHoeLDH7FvVVcPJRPSQ9/MfRqLsainRw+BojA==", "dependencies": { - "@docusaurus/core": "3.2.1", - "@docusaurus/types": "3.2.1", - "@docusaurus/utils-validation": "3.2.1", + "@docusaurus/core": "3.4.0", + "@docusaurus/types": "3.4.0", + "@docusaurus/utils-validation": "3.4.0", "tslib": "^2.6.0" }, "engines": { @@ -2472,13 +2469,13 @@ } }, "node_modules/@docusaurus/plugin-google-gtag": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/plugin-google-gtag/-/plugin-google-gtag-3.2.1.tgz", - "integrity": "sha512-XtuJnlMvYfppeVdUyKiDIJAa/gTJKCQU92z8CLZZ9ibJdgVjFOLS10s0hIC0eL5z0U2u2loJz2rZ63HOkNHbBA==", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/plugin-google-gtag/-/plugin-google-gtag-3.4.0.tgz", + "integrity": "sha512-Dsgg6PLAqzZw5wZ4QjUYc8Z2KqJqXxHxq3vIoyoBWiLEEfigIs7wHR+oiWUQy3Zk9MIk6JTYj7tMoQU0Jm3nqA==", "dependencies": { - "@docusaurus/core": "3.2.1", - "@docusaurus/types": "3.2.1", - "@docusaurus/utils-validation": "3.2.1", + "@docusaurus/core": "3.4.0", + "@docusaurus/types": "3.4.0", + "@docusaurus/utils-validation": "3.4.0", "@types/gtag.js": "^0.0.12", "tslib": "^2.6.0" }, @@ -2491,13 +2488,13 @@ } }, "node_modules/@docusaurus/plugin-google-tag-manager": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/plugin-google-tag-manager/-/plugin-google-tag-manager-3.2.1.tgz", - "integrity": "sha512-wiS/kE0Ny5pnjTxVCs8ljRnkL1RVMj59t6jmSsgEX7piDOoaXSMIUaoIt9ogS/v132uO0xEsxHstkRUZHQyPcQ==", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/plugin-google-tag-manager/-/plugin-google-tag-manager-3.4.0.tgz", + "integrity": "sha512-O9tX1BTwxIhgXpOLpFDueYA9DWk69WCbDRrjYoMQtFHSkTyE7RhNgyjSPREUWJb9i+YUg3OrsvrBYRl64FCPCQ==", "dependencies": { - "@docusaurus/core": "3.2.1", - "@docusaurus/types": "3.2.1", - "@docusaurus/utils-validation": "3.2.1", + "@docusaurus/core": "3.4.0", + "@docusaurus/types": "3.4.0", + "@docusaurus/utils-validation": "3.4.0", "tslib": "^2.6.0" }, "engines": { @@ -2509,16 +2506,16 @@ } }, "node_modules/@docusaurus/plugin-ideal-image": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/plugin-ideal-image/-/plugin-ideal-image-3.2.1.tgz", - "integrity": "sha512-Mf/C6jsCuiyC2xME/qBJ73ZwrXN10WaPTBWXI3ZR5d+nqZX+b4bKJJB/0RMt+lgQHELT/nB8Yk+wc10bMX4xJw==", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/plugin-ideal-image/-/plugin-ideal-image-3.4.0.tgz", + "integrity": "sha512-s8N/PRiv1R66UY+WX/2E9a+GjkRooXVcf0VJNEYA3yZ6c24Path15ivjmdMtKaSo/6OXYbejGlA4DJZ5TPLkCQ==", "dependencies": { - "@docusaurus/core": "3.2.1", - "@docusaurus/lqip-loader": "3.2.1", + "@docusaurus/core": "3.4.0", + "@docusaurus/lqip-loader": "3.4.0", "@docusaurus/responsive-loader": "^1.7.0", - "@docusaurus/theme-translations": "3.2.1", - "@docusaurus/types": "3.2.1", - "@docusaurus/utils-validation": "3.2.1", + "@docusaurus/theme-translations": "3.4.0", + "@docusaurus/types": "3.4.0", + "@docusaurus/utils-validation": "3.4.0", "@slorber/react-ideal-image": "^0.0.12", "react-waypoint": "^10.3.0", "sharp": "^0.32.3", @@ -2540,16 +2537,16 @@ } }, "node_modules/@docusaurus/plugin-sitemap": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/plugin-sitemap/-/plugin-sitemap-3.2.1.tgz", - "integrity": "sha512-uWZ7AxzdeaQSTCwD2yZtOiEm9zyKU+wqCmi/Sf25kQQqqFSBZUStXfaQ8OHP9cecnw893ZpZ811rPhB/wfujJw==", - "dependencies": { - "@docusaurus/core": "3.2.1", - "@docusaurus/logger": "3.2.1", - "@docusaurus/types": "3.2.1", - "@docusaurus/utils": "3.2.1", - "@docusaurus/utils-common": "3.2.1", - "@docusaurus/utils-validation": "3.2.1", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/plugin-sitemap/-/plugin-sitemap-3.4.0.tgz", + "integrity": "sha512-+0VDvx9SmNrFNgwPoeoCha+tRoAjopwT0+pYO1xAbyLcewXSemq+eLxEa46Q1/aoOaJQ0qqHELuQM7iS2gp33Q==", + "dependencies": { + "@docusaurus/core": "3.4.0", + "@docusaurus/logger": "3.4.0", + "@docusaurus/types": "3.4.0", + "@docusaurus/utils": "3.4.0", + "@docusaurus/utils-common": "3.4.0", + "@docusaurus/utils-validation": "3.4.0", "fs-extra": "^11.1.1", "sitemap": "^7.1.1", "tslib": "^2.6.0" @@ -2563,23 +2560,23 @@ } }, "node_modules/@docusaurus/preset-classic": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/preset-classic/-/preset-classic-3.2.1.tgz", - "integrity": "sha512-E3OHSmttpEBcSMhfPBq3EJMBxZBM01W1rnaCUTXy9EHvkmB5AwgTfW1PwGAybPAX579ntE03R+2zmXdizWfKnQ==", - "dependencies": { - "@docusaurus/core": "3.2.1", - "@docusaurus/plugin-content-blog": "3.2.1", - "@docusaurus/plugin-content-docs": "3.2.1", - "@docusaurus/plugin-content-pages": "3.2.1", - "@docusaurus/plugin-debug": "3.2.1", - "@docusaurus/plugin-google-analytics": "3.2.1", - "@docusaurus/plugin-google-gtag": "3.2.1", - "@docusaurus/plugin-google-tag-manager": "3.2.1", - "@docusaurus/plugin-sitemap": "3.2.1", - "@docusaurus/theme-classic": "3.2.1", - "@docusaurus/theme-common": "3.2.1", - "@docusaurus/theme-search-algolia": "3.2.1", - "@docusaurus/types": "3.2.1" + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/preset-classic/-/preset-classic-3.4.0.tgz", + "integrity": "sha512-Ohj6KB7siKqZaQhNJVMBBUzT3Nnp6eTKqO+FXO3qu/n1hJl3YLwVKTWBg28LF7MWrKu46UuYavwMRxud0VyqHg==", + "dependencies": { + "@docusaurus/core": "3.4.0", + "@docusaurus/plugin-content-blog": "3.4.0", + "@docusaurus/plugin-content-docs": "3.4.0", + "@docusaurus/plugin-content-pages": "3.4.0", + "@docusaurus/plugin-debug": "3.4.0", + "@docusaurus/plugin-google-analytics": "3.4.0", + "@docusaurus/plugin-google-gtag": "3.4.0", + "@docusaurus/plugin-google-tag-manager": "3.4.0", + "@docusaurus/plugin-sitemap": "3.4.0", + "@docusaurus/theme-classic": "3.4.0", + "@docusaurus/theme-common": "3.4.0", + "@docusaurus/theme-search-algolia": "3.4.0", + "@docusaurus/types": "3.4.0" }, "engines": { "node": ">=18.0" @@ -2589,18 +2586,6 @@ "react-dom": "^18.0.0" } }, - "node_modules/@docusaurus/react-loadable": { - "version": "5.5.2", - "resolved": "https://registry.npmjs.org/@docusaurus/react-loadable/-/react-loadable-5.5.2.tgz", - "integrity": "sha512-A3dYjdBGuy0IGT+wyLIGIKLRE+sAk1iNk0f1HjNDysO7u8lhL4N3VEm+FAubmJbAztn94F7MxBTPmnixbiyFdQ==", - "dependencies": { - "@types/react": "*", - "prop-types": "^15.6.2" - }, - "peerDependencies": { - "react": "*" - } - }, "node_modules/@docusaurus/responsive-loader": { "version": "1.7.0", "resolved": "https://registry.npmjs.org/@docusaurus/responsive-loader/-/responsive-loader-1.7.0.tgz", @@ -2625,22 +2610,22 @@ } }, "node_modules/@docusaurus/theme-classic": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/theme-classic/-/theme-classic-3.2.1.tgz", - "integrity": "sha512-+vSbnQyoWjc6vRZi4vJO2dBU02wqzynsai15KK+FANZudrYaBHtkbLZAQhgmxzBGVpxzi87gRohlMm+5D8f4tA==", - "dependencies": { - "@docusaurus/core": "3.2.1", - "@docusaurus/mdx-loader": "3.2.1", - "@docusaurus/module-type-aliases": "3.2.1", - "@docusaurus/plugin-content-blog": "3.2.1", - "@docusaurus/plugin-content-docs": "3.2.1", - "@docusaurus/plugin-content-pages": "3.2.1", - "@docusaurus/theme-common": "3.2.1", - "@docusaurus/theme-translations": "3.2.1", - "@docusaurus/types": "3.2.1", - "@docusaurus/utils": "3.2.1", - "@docusaurus/utils-common": "3.2.1", - "@docusaurus/utils-validation": "3.2.1", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/theme-classic/-/theme-classic-3.4.0.tgz", + "integrity": "sha512-0IPtmxsBYv2adr1GnZRdMkEQt1YW6tpzrUPj02YxNpvJ5+ju4E13J5tB4nfdaen/tfR1hmpSPlTFPvTf4kwy8Q==", + "dependencies": { + "@docusaurus/core": "3.4.0", + "@docusaurus/mdx-loader": "3.4.0", + "@docusaurus/module-type-aliases": "3.4.0", + "@docusaurus/plugin-content-blog": "3.4.0", + "@docusaurus/plugin-content-docs": "3.4.0", + "@docusaurus/plugin-content-pages": "3.4.0", + "@docusaurus/theme-common": "3.4.0", + "@docusaurus/theme-translations": "3.4.0", + "@docusaurus/types": "3.4.0", + "@docusaurus/utils": "3.4.0", + "@docusaurus/utils-common": "3.4.0", + "@docusaurus/utils-validation": "3.4.0", "@mdx-js/react": "^3.0.0", "clsx": "^2.0.0", "copy-text-to-clipboard": "^3.2.0", @@ -2664,25 +2649,25 @@ } }, "node_modules/@docusaurus/theme-classic/node_modules/clsx": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.0.tgz", - "integrity": "sha512-m3iNNWpd9rl3jvvcBnu70ylMdrXt8Vlq4HYadnU5fwcOtvkSQWPmj7amUcDT2qYI7risszBjI5AUIUox9D16pg==", + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz", + "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==", "engines": { "node": ">=6" } }, "node_modules/@docusaurus/theme-common": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/theme-common/-/theme-common-3.2.1.tgz", - "integrity": "sha512-d+adiD7L9xv6EvfaAwUqdKf4orsM3jqgeqAM+HAjgL/Ux0GkVVnfKr+tsoe+4ow4rHe6NUt+nkkW8/K8dKdilA==", - "dependencies": { - "@docusaurus/mdx-loader": "3.2.1", - "@docusaurus/module-type-aliases": "3.2.1", - "@docusaurus/plugin-content-blog": "3.2.1", - "@docusaurus/plugin-content-docs": "3.2.1", - "@docusaurus/plugin-content-pages": "3.2.1", - "@docusaurus/utils": "3.2.1", - "@docusaurus/utils-common": "3.2.1", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/theme-common/-/theme-common-3.4.0.tgz", + "integrity": "sha512-0A27alXuv7ZdCg28oPE8nH/Iz73/IUejVaCazqu9elS4ypjiLhK3KfzdSQBnL/g7YfHSlymZKdiOHEo8fJ0qMA==", + "dependencies": { + "@docusaurus/mdx-loader": "3.4.0", + "@docusaurus/module-type-aliases": "3.4.0", + "@docusaurus/plugin-content-blog": "3.4.0", + "@docusaurus/plugin-content-docs": "3.4.0", + "@docusaurus/plugin-content-pages": "3.4.0", + "@docusaurus/utils": "3.4.0", + "@docusaurus/utils-common": "3.4.0", "@types/history": "^4.7.11", "@types/react": "*", "@types/react-router-config": "*", @@ -2701,26 +2686,26 @@ } }, "node_modules/@docusaurus/theme-common/node_modules/clsx": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.0.tgz", - "integrity": "sha512-m3iNNWpd9rl3jvvcBnu70ylMdrXt8Vlq4HYadnU5fwcOtvkSQWPmj7amUcDT2qYI7risszBjI5AUIUox9D16pg==", + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz", + "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==", "engines": { "node": ">=6" } }, "node_modules/@docusaurus/theme-search-algolia": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/theme-search-algolia/-/theme-search-algolia-3.2.1.tgz", - "integrity": "sha512-bzhCrpyXBXzeydNUH83II2akvFEGfhsNTPPWsk5N7e+odgQCQwoHhcF+2qILbQXjaoZ6B3c48hrvkyCpeyqGHw==", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/theme-search-algolia/-/theme-search-algolia-3.4.0.tgz", + "integrity": "sha512-aiHFx7OCw4Wck1z6IoShVdUWIjntC8FHCw9c5dR8r3q4Ynh+zkS8y2eFFunN/DL6RXPzpnvKCg3vhLQYJDmT9Q==", "dependencies": { "@docsearch/react": "^3.5.2", - "@docusaurus/core": "3.2.1", - "@docusaurus/logger": "3.2.1", - "@docusaurus/plugin-content-docs": "3.2.1", - "@docusaurus/theme-common": "3.2.1", - "@docusaurus/theme-translations": "3.2.1", - "@docusaurus/utils": "3.2.1", - "@docusaurus/utils-validation": "3.2.1", + "@docusaurus/core": "3.4.0", + "@docusaurus/logger": "3.4.0", + "@docusaurus/plugin-content-docs": "3.4.0", + "@docusaurus/theme-common": "3.4.0", + "@docusaurus/theme-translations": "3.4.0", + "@docusaurus/utils": "3.4.0", + "@docusaurus/utils-validation": "3.4.0", "algoliasearch": "^4.18.0", "algoliasearch-helper": "^3.13.3", "clsx": "^2.0.0", @@ -2739,17 +2724,17 @@ } }, "node_modules/@docusaurus/theme-search-algolia/node_modules/clsx": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.0.tgz", - "integrity": "sha512-m3iNNWpd9rl3jvvcBnu70ylMdrXt8Vlq4HYadnU5fwcOtvkSQWPmj7amUcDT2qYI7risszBjI5AUIUox9D16pg==", + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz", + "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==", "engines": { "node": ">=6" } }, "node_modules/@docusaurus/theme-translations": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/theme-translations/-/theme-translations-3.2.1.tgz", - "integrity": "sha512-jAUMkIkFfY+OAhJhv6mV8zlwY6J4AQxJPTgLdR2l+Otof9+QdJjHNh/ifVEu9q0lp3oSPlJj9l05AaP7Ref+cg==", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/theme-translations/-/theme-translations-3.4.0.tgz", + "integrity": "sha512-zSxCSpmQCCdQU5Q4CnX/ID8CSUUI3fvmq4hU/GNP/XoAWtXo9SAVnM3TzpU8Gb//H3WCsT8mJcTfyOk3d9ftNg==", "dependencies": { "fs-extra": "^11.1.1", "tslib": "^2.6.0" @@ -2759,9 +2744,9 @@ } }, "node_modules/@docusaurus/types": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/types/-/types-3.2.1.tgz", - "integrity": "sha512-n/toxBzL2oxTtRTOFiGKsHypzn/Pm+sXyw+VSk1UbqbXQiHOwHwts55bpKwbcUgA530Is6kix3ELiFOv9GAMfw==", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/types/-/types-3.4.0.tgz", + "integrity": "sha512-4jcDO8kXi5Cf9TcyikB/yKmz14f2RZ2qTRerbHAsS+5InE9ZgSLBNLsewtFTcTOXSVcbU3FoGOzcNWAmU1TR0A==", "dependencies": { "@mdx-js/mdx": "^3.0.0", "@types/history": "^4.7.11", @@ -2779,13 +2764,13 @@ } }, "node_modules/@docusaurus/utils": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/utils/-/utils-3.2.1.tgz", - "integrity": "sha512-DPkIS/EPc+pGAV798PUXgNzJFM3HJouoQXgr0KDZuJVz1EkWbDLOcQwLIz8Qx7liI9ddfkN/TXTRQdsTPZNakw==", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/utils/-/utils-3.4.0.tgz", + "integrity": "sha512-fRwnu3L3nnWaXOgs88BVBmG1yGjcQqZNHG+vInhEa2Sz2oQB+ZjbEMO5Rh9ePFpZ0YDiDUhpaVjwmS+AU2F14g==", "dependencies": { - "@docusaurus/logger": "3.2.1", - "@docusaurus/utils-common": "3.2.1", - "@svgr/webpack": "^6.5.1", + "@docusaurus/logger": "3.4.0", + "@docusaurus/utils-common": "3.4.0", + "@svgr/webpack": "^8.1.0", "escape-string-regexp": "^4.0.0", "file-loader": "^6.2.0", "fs-extra": "^11.1.1", @@ -2801,6 +2786,7 @@ "shelljs": "^0.8.5", "tslib": "^2.6.0", "url-loader": "^4.1.1", + "utility-types": "^3.10.0", "webpack": "^5.88.1" }, "engines": { @@ -2816,9 +2802,9 @@ } }, "node_modules/@docusaurus/utils-common": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/utils-common/-/utils-common-3.2.1.tgz", - "integrity": "sha512-N5vadULnRLiqX2QfTjVEU3u5vo6RG2EZTdyXvJdzDOdrLCGIZAfnf/VkssinFZ922sVfaFfQ4FnStdhn5TWdVg==", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/utils-common/-/utils-common-3.4.0.tgz", + "integrity": "sha512-NVx54Wr4rCEKsjOH5QEVvxIqVvm+9kh7q8aYTU5WzUU9/Hctd6aTrcZ3G0Id4zYJ+AeaG5K5qHA4CY5Kcm2iyQ==", "dependencies": { "tslib": "^2.6.0" }, @@ -2835,15 +2821,17 @@ } }, "node_modules/@docusaurus/utils-validation": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@docusaurus/utils-validation/-/utils-validation-3.2.1.tgz", - "integrity": "sha512-+x7IR9hNMXi62L1YAglwd0s95fR7+EtirjTxSN4kahYRWGqOi3jlQl1EV0az/yTEvKbxVvOPcdYicGu9dk4LJw==", - "dependencies": { - "@docusaurus/logger": "3.2.1", - "@docusaurus/utils": "3.2.1", - "@docusaurus/utils-common": "3.2.1", + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@docusaurus/utils-validation/-/utils-validation-3.4.0.tgz", + "integrity": "sha512-hYQ9fM+AXYVTWxJOT1EuNaRnrR2WGpRdLDQG07O8UOpsvCPWUVOeo26Rbm0JWY2sGLfzAb+tvJ62yF+8F+TV0g==", + "dependencies": { + "@docusaurus/logger": "3.4.0", + "@docusaurus/utils": "3.4.0", + "@docusaurus/utils-common": "3.4.0", + "fs-extra": "^11.2.0", "joi": "^17.9.2", "js-yaml": "^4.1.0", + "lodash": "^4.17.21", "tslib": "^2.6.0" }, "engines": { @@ -3130,11 +3118,11 @@ } }, "node_modules/@svgr/babel-plugin-add-jsx-attribute": { - "version": "6.5.1", - "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-add-jsx-attribute/-/babel-plugin-add-jsx-attribute-6.5.1.tgz", - "integrity": "sha512-9PYGcXrAxitycIjRmZB+Q0JaN07GZIWaTBIGQzfaZv+qr1n8X1XUEJ5rZ/vx6OVD9RRYlrNnXWExQXcmZeD/BQ==", + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-add-jsx-attribute/-/babel-plugin-add-jsx-attribute-8.0.0.tgz", + "integrity": "sha512-b9MIk7yhdS1pMCZM8VeNfUlSKVRhsHZNMl5O9SfaX0l0t5wjdgu4IDzGB8bpnGBBOjGST3rRFVsaaEtI4W6f7g==", "engines": { - "node": ">=10" + "node": ">=14" }, "funding": { "type": "github", @@ -3175,11 +3163,11 @@ } }, "node_modules/@svgr/babel-plugin-replace-jsx-attribute-value": { - "version": "6.5.1", - "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-replace-jsx-attribute-value/-/babel-plugin-replace-jsx-attribute-value-6.5.1.tgz", - "integrity": "sha512-8DPaVVE3fd5JKuIC29dqyMB54sA6mfgki2H2+swh+zNJoynC8pMPzOkidqHOSc6Wj032fhl8Z0TVn1GiPpAiJg==", + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-replace-jsx-attribute-value/-/babel-plugin-replace-jsx-attribute-value-8.0.0.tgz", + "integrity": "sha512-KVQ+PtIjb1BuYT3ht8M5KbzWBhdAjjUPdlMtpuw/VjT8coTrItWX6Qafl9+ji831JaJcu6PJNKCV0bp01lBNzQ==", "engines": { - "node": ">=10" + "node": ">=14" }, "funding": { "type": "github", @@ -3190,11 +3178,11 @@ } }, "node_modules/@svgr/babel-plugin-svg-dynamic-title": { - "version": "6.5.1", - "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-svg-dynamic-title/-/babel-plugin-svg-dynamic-title-6.5.1.tgz", - "integrity": "sha512-FwOEi0Il72iAzlkaHrlemVurgSQRDFbk0OC8dSvD5fSBPHltNh7JtLsxmZUhjYBZo2PpcU/RJvvi6Q0l7O7ogw==", + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-svg-dynamic-title/-/babel-plugin-svg-dynamic-title-8.0.0.tgz", + "integrity": "sha512-omNiKqwjNmOQJ2v6ge4SErBbkooV2aAWwaPFs2vUY7p7GhVkzRkJ00kILXQvRhA6miHnNpXv7MRnnSjdRjK8og==", "engines": { - "node": ">=10" + "node": ">=14" }, "funding": { "type": "github", @@ -3205,11 +3193,11 @@ } }, "node_modules/@svgr/babel-plugin-svg-em-dimensions": { - "version": "6.5.1", - "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-svg-em-dimensions/-/babel-plugin-svg-em-dimensions-6.5.1.tgz", - "integrity": "sha512-gWGsiwjb4tw+ITOJ86ndY/DZZ6cuXMNE/SjcDRg+HLuCmwpcjOktwRF9WgAiycTqJD/QXqL2f8IzE2Rzh7aVXA==", + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-svg-em-dimensions/-/babel-plugin-svg-em-dimensions-8.0.0.tgz", + "integrity": "sha512-mURHYnu6Iw3UBTbhGwE/vsngtCIbHE43xCRK7kCw4t01xyGqb2Pd+WXekRRoFOBIY29ZoOhUCTEweDMdrjfi9g==", "engines": { - "node": ">=10" + "node": ">=14" }, "funding": { "type": "github", @@ -3220,11 +3208,11 @@ } }, "node_modules/@svgr/babel-plugin-transform-react-native-svg": { - "version": "6.5.1", - "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-transform-react-native-svg/-/babel-plugin-transform-react-native-svg-6.5.1.tgz", - "integrity": "sha512-2jT3nTayyYP7kI6aGutkyfJ7UMGtuguD72OjeGLwVNyfPRBD8zQthlvL+fAbAKk5n9ZNcvFkp/b1lZ7VsYqVJg==", + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-transform-react-native-svg/-/babel-plugin-transform-react-native-svg-8.1.0.tgz", + "integrity": "sha512-Tx8T58CHo+7nwJ+EhUwx3LfdNSG9R2OKfaIXXs5soiy5HtgoAEkDay9LIimLOcG8dJQH1wPZp/cnAv6S9CrR1Q==", "engines": { - "node": ">=10" + "node": ">=14" }, "funding": { "type": "github", @@ -3235,9 +3223,9 @@ } }, "node_modules/@svgr/babel-plugin-transform-svg-component": { - "version": "6.5.1", - "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-transform-svg-component/-/babel-plugin-transform-svg-component-6.5.1.tgz", - "integrity": "sha512-a1p6LF5Jt33O3rZoVRBqdxL350oge54iZWHNI6LJB5tQ7EelvD/Mb1mfBiZNAan0dt4i3VArkFRjA4iObuNykQ==", + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-transform-svg-component/-/babel-plugin-transform-svg-component-8.0.0.tgz", + "integrity": "sha512-DFx8xa3cZXTdb/k3kfPeaixecQLgKh5NVBMwD0AQxOzcZawK4oo1Jh9LbrcACUivsCA7TLG8eeWgrDXjTMhRmw==", "engines": { "node": ">=12" }, @@ -3250,21 +3238,21 @@ } }, "node_modules/@svgr/babel-preset": { - "version": "6.5.1", - "resolved": "https://registry.npmjs.org/@svgr/babel-preset/-/babel-preset-6.5.1.tgz", - "integrity": "sha512-6127fvO/FF2oi5EzSQOAjo1LE3OtNVh11R+/8FXa+mHx1ptAaS4cknIjnUA7e6j6fwGGJ17NzaTJFUwOV2zwCw==", + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-preset/-/babel-preset-8.1.0.tgz", + "integrity": "sha512-7EYDbHE7MxHpv4sxvnVPngw5fuR6pw79SkcrILHJ/iMpuKySNCl5W1qcwPEpU+LgyRXOaAFgH0KhwD18wwg6ug==", "dependencies": { - "@svgr/babel-plugin-add-jsx-attribute": "^6.5.1", - "@svgr/babel-plugin-remove-jsx-attribute": "*", - "@svgr/babel-plugin-remove-jsx-empty-expression": "*", - "@svgr/babel-plugin-replace-jsx-attribute-value": "^6.5.1", - "@svgr/babel-plugin-svg-dynamic-title": "^6.5.1", - "@svgr/babel-plugin-svg-em-dimensions": "^6.5.1", - "@svgr/babel-plugin-transform-react-native-svg": "^6.5.1", - "@svgr/babel-plugin-transform-svg-component": "^6.5.1" + "@svgr/babel-plugin-add-jsx-attribute": "8.0.0", + "@svgr/babel-plugin-remove-jsx-attribute": "8.0.0", + "@svgr/babel-plugin-remove-jsx-empty-expression": "8.0.0", + "@svgr/babel-plugin-replace-jsx-attribute-value": "8.0.0", + "@svgr/babel-plugin-svg-dynamic-title": "8.0.0", + "@svgr/babel-plugin-svg-em-dimensions": "8.0.0", + "@svgr/babel-plugin-transform-react-native-svg": "8.1.0", + "@svgr/babel-plugin-transform-svg-component": "8.0.0" }, "engines": { - "node": ">=10" + "node": ">=14" }, "funding": { "type": "github", @@ -3275,18 +3263,18 @@ } }, "node_modules/@svgr/core": { - "version": "6.5.1", - "resolved": "https://registry.npmjs.org/@svgr/core/-/core-6.5.1.tgz", - "integrity": "sha512-/xdLSWxK5QkqG524ONSjvg3V/FkNyCv538OIBdQqPNaAta3AsXj/Bd2FbvR87yMbXO2hFSWiAe/Q6IkVPDw+mw==", + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/@svgr/core/-/core-8.1.0.tgz", + "integrity": "sha512-8QqtOQT5ACVlmsvKOJNEaWmRPmcojMOzCz4Hs2BGG/toAp/K38LcsMRyLp349glq5AzJbCEeimEoxaX6v/fLrA==", "dependencies": { - "@babel/core": "^7.19.6", - "@svgr/babel-preset": "^6.5.1", - "@svgr/plugin-jsx": "^6.5.1", + "@babel/core": "^7.21.3", + "@svgr/babel-preset": "8.1.0", "camelcase": "^6.2.0", - "cosmiconfig": "^7.0.1" + "cosmiconfig": "^8.1.3", + "snake-case": "^3.0.4" }, "engines": { - "node": ">=10" + "node": ">=14" }, "funding": { "type": "github", @@ -3294,15 +3282,15 @@ } }, "node_modules/@svgr/hast-util-to-babel-ast": { - "version": "6.5.1", - "resolved": "https://registry.npmjs.org/@svgr/hast-util-to-babel-ast/-/hast-util-to-babel-ast-6.5.1.tgz", - "integrity": "sha512-1hnUxxjd83EAxbL4a0JDJoD3Dao3hmjvyvyEV8PzWmLK3B9m9NPlW7GKjFyoWE8nM7HnXzPcmmSyOW8yOddSXw==", + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/@svgr/hast-util-to-babel-ast/-/hast-util-to-babel-ast-8.0.0.tgz", + "integrity": "sha512-EbDKwO9GpfWP4jN9sGdYwPBU0kdomaPIL2Eu4YwmgP+sJeXT+L7bMwJUBnhzfH8Q2qMBqZ4fJwpCyYsAN3mt2Q==", "dependencies": { - "@babel/types": "^7.20.0", + "@babel/types": "^7.21.3", "entities": "^4.4.0" }, "engines": { - "node": ">=10" + "node": ">=14" }, "funding": { "type": "github", @@ -3310,37 +3298,37 @@ } }, "node_modules/@svgr/plugin-jsx": { - "version": "6.5.1", - "resolved": "https://registry.npmjs.org/@svgr/plugin-jsx/-/plugin-jsx-6.5.1.tgz", - "integrity": "sha512-+UdQxI3jgtSjCykNSlEMuy1jSRQlGC7pqBCPvkG/2dATdWo082zHTTK3uhnAju2/6XpE6B5mZ3z4Z8Ns01S8Gw==", + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/@svgr/plugin-jsx/-/plugin-jsx-8.1.0.tgz", + "integrity": "sha512-0xiIyBsLlr8quN+WyuxooNW9RJ0Dpr8uOnH/xrCVO8GLUcwHISwj1AG0k+LFzteTkAA0GbX0kj9q6Dk70PTiPA==", "dependencies": { - "@babel/core": "^7.19.6", - "@svgr/babel-preset": "^6.5.1", - "@svgr/hast-util-to-babel-ast": "^6.5.1", + "@babel/core": "^7.21.3", + "@svgr/babel-preset": "8.1.0", + "@svgr/hast-util-to-babel-ast": "8.0.0", "svg-parser": "^2.0.4" }, "engines": { - "node": ">=10" + "node": ">=14" }, "funding": { "type": "github", "url": "https://github.com/sponsors/gregberge" }, "peerDependencies": { - "@svgr/core": "^6.0.0" + "@svgr/core": "*" } }, "node_modules/@svgr/plugin-svgo": { - "version": "6.5.1", - "resolved": "https://registry.npmjs.org/@svgr/plugin-svgo/-/plugin-svgo-6.5.1.tgz", - "integrity": "sha512-omvZKf8ixP9z6GWgwbtmP9qQMPX4ODXi+wzbVZgomNFsUIlHA1sf4fThdwTWSsZGgvGAG6yE+b/F5gWUkcZ/iQ==", + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/@svgr/plugin-svgo/-/plugin-svgo-8.1.0.tgz", + "integrity": "sha512-Ywtl837OGO9pTLIN/onoWLmDQ4zFUycI1g76vuKGEz6evR/ZTJlJuz3G/fIkb6OVBJ2g0o6CGJzaEjfmEo3AHA==", "dependencies": { - "cosmiconfig": "^7.0.1", - "deepmerge": "^4.2.2", - "svgo": "^2.8.0" + "cosmiconfig": "^8.1.3", + "deepmerge": "^4.3.1", + "svgo": "^3.0.2" }, "engines": { - "node": ">=10" + "node": ">=14" }, "funding": { "type": "github", @@ -3351,21 +3339,21 @@ } }, "node_modules/@svgr/webpack": { - "version": "6.5.1", - "resolved": "https://registry.npmjs.org/@svgr/webpack/-/webpack-6.5.1.tgz", - "integrity": "sha512-cQ/AsnBkXPkEK8cLbv4Dm7JGXq2XrumKnL1dRpJD9rIO2fTIlJI9a1uCciYG1F2aUsox/hJQyNGbt3soDxSRkA==", + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/@svgr/webpack/-/webpack-8.1.0.tgz", + "integrity": "sha512-LnhVjMWyMQV9ZmeEy26maJk+8HTIbd59cH4F2MJ439k9DqejRisfFNGAPvRYlKETuh9LrImlS8aKsBgKjMA8WA==", "dependencies": { - "@babel/core": "^7.19.6", - "@babel/plugin-transform-react-constant-elements": "^7.18.12", - "@babel/preset-env": "^7.19.4", + "@babel/core": "^7.21.3", + "@babel/plugin-transform-react-constant-elements": "^7.21.3", + "@babel/preset-env": "^7.20.2", "@babel/preset-react": "^7.18.6", - "@babel/preset-typescript": "^7.18.6", - "@svgr/core": "^6.5.1", - "@svgr/plugin-jsx": "^6.5.1", - "@svgr/plugin-svgo": "^6.5.1" + "@babel/preset-typescript": "^7.21.0", + "@svgr/core": "8.1.0", + "@svgr/plugin-jsx": "8.1.0", + "@svgr/plugin-svgo": "8.1.0" }, "engines": { - "node": ">=10" + "node": ">=14" }, "funding": { "type": "github", @@ -3536,22 +3524,22 @@ } }, "node_modules/@types/istanbul-lib-coverage": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.5.tgz", - "integrity": "sha512-zONci81DZYCZjiLe0r6equvZut0b+dBRPBN5kBDjsONnutYNtJMoWQ9uR2RkL1gLG9NMTzvf+29e5RFfPbeKhQ==" + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz", + "integrity": "sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==" }, "node_modules/@types/istanbul-lib-report": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.2.tgz", - "integrity": "sha512-8toY6FgdltSdONav1XtUHl4LN1yTmLza+EuDazb/fEmRNCwjyqNVIQWs2IfC74IqjHkREs/nQ2FWq5kZU9IC0w==", + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.3.tgz", + "integrity": "sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==", "dependencies": { "@types/istanbul-lib-coverage": "*" } }, "node_modules/@types/istanbul-reports": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/@types/istanbul-reports/-/istanbul-reports-3.0.3.tgz", - "integrity": "sha512-1nESsePMBlf0RPRffLZi5ujYh7IH1BWL4y9pr+Bn3cJBdxz+RTP8bUFljLz9HvzhhOSWKdyBZ4DIivdL6rvgZg==", + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/istanbul-reports/-/istanbul-reports-3.0.4.tgz", + "integrity": "sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==", "dependencies": { "@types/istanbul-lib-report": "*" } @@ -3562,9 +3550,9 @@ "integrity": "sha512-U3PUjAudAdJBeC2pgN8uTIKgxrb4nlDF3SF0++EldXQvQBGkpFZMSnwQiIoDU77tv45VgNkl/L4ouD+rEomujw==" }, "node_modules/@types/mdast": { - "version": "4.0.3", - "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.3.tgz", - "integrity": "sha512-LsjtqsyF+d2/yFOYaN22dHZI1Cpwkrj+g06G8+qtUKlhovPW89YhqSnfKtMbkgmEtYpH2gydRNULd6y8mciAFg==", + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.4.tgz", + "integrity": "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==", "dependencies": { "@types/unist": "*" } @@ -3731,17 +3719,17 @@ } }, "node_modules/@types/yargs": { - "version": "17.0.29", - "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.29.tgz", - "integrity": "sha512-nacjqA3ee9zRF/++a3FUY1suHTFKZeHba2n8WeDw9cCVdmzmHpIxyzOJBcpHvvEmS8E9KqWlSnWHUkOrkhWcvA==", + "version": "17.0.32", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.32.tgz", + "integrity": "sha512-xQ67Yc/laOG5uMfX/093MRlGGCIBzZMarVa+gfNKJxWAIgykYpVGkBdbqEzGDDfCrVUj6Hiff4mTZ5BA6TmAog==", "dependencies": { "@types/yargs-parser": "*" } }, "node_modules/@types/yargs-parser": { - "version": "21.0.2", - "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-21.0.2.tgz", - "integrity": "sha512-5qcvofLPbfjmBfKaLfj/+f+Sbd6pN4zl7w7VSVI5uz7m9QZTuB2aZAa2uo1wHFBNN2x6g/SoTkXmd8mQnQF2Cw==" + "version": "21.0.3", + "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-21.0.3.tgz", + "integrity": "sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==" }, "node_modules/@ungap/structured-clone": { "version": "1.2.0", @@ -4018,31 +4006,31 @@ } }, "node_modules/algoliasearch": { - "version": "4.23.2", - "resolved": "https://registry.npmjs.org/algoliasearch/-/algoliasearch-4.23.2.tgz", - "integrity": "sha512-8aCl055IsokLuPU8BzLjwzXjb7ty9TPcUFFOk0pYOwsE5DMVhE3kwCMFtsCFKcnoPZK7oObm+H5mbnSO/9ioxQ==", - "dependencies": { - "@algolia/cache-browser-local-storage": "4.23.2", - "@algolia/cache-common": "4.23.2", - "@algolia/cache-in-memory": "4.23.2", - "@algolia/client-account": "4.23.2", - "@algolia/client-analytics": "4.23.2", - "@algolia/client-common": "4.23.2", - "@algolia/client-personalization": "4.23.2", - "@algolia/client-search": "4.23.2", - "@algolia/logger-common": "4.23.2", - "@algolia/logger-console": "4.23.2", - "@algolia/recommend": "4.23.2", - "@algolia/requester-browser-xhr": "4.23.2", - "@algolia/requester-common": "4.23.2", - "@algolia/requester-node-http": "4.23.2", - "@algolia/transporter": "4.23.2" + "version": "4.23.3", + "resolved": "https://registry.npmjs.org/algoliasearch/-/algoliasearch-4.23.3.tgz", + "integrity": "sha512-Le/3YgNvjW9zxIQMRhUHuhiUjAlKY/zsdZpfq4dlLqg6mEm0nL6yk+7f2hDOtLpxsgE4jSzDmvHL7nXdBp5feg==", + "dependencies": { + "@algolia/cache-browser-local-storage": "4.23.3", + "@algolia/cache-common": "4.23.3", + "@algolia/cache-in-memory": "4.23.3", + "@algolia/client-account": "4.23.3", + "@algolia/client-analytics": "4.23.3", + "@algolia/client-common": "4.23.3", + "@algolia/client-personalization": "4.23.3", + "@algolia/client-search": "4.23.3", + "@algolia/logger-common": "4.23.3", + "@algolia/logger-console": "4.23.3", + "@algolia/recommend": "4.23.3", + "@algolia/requester-browser-xhr": "4.23.3", + "@algolia/requester-common": "4.23.3", + "@algolia/requester-node-http": "4.23.3", + "@algolia/transporter": "4.23.3" } }, "node_modules/algoliasearch-helper": { - "version": "3.17.0", - "resolved": "https://registry.npmjs.org/algoliasearch-helper/-/algoliasearch-helper-3.17.0.tgz", - "integrity": "sha512-R5422OiQjvjlK3VdpNQ/Qk7KsTIGeM5ACm8civGifOVWdRRV/3SgXuKmeNxe94Dz6fwj/IgpVmXbHutU4mHubg==", + "version": "3.21.0", + "resolved": "https://registry.npmjs.org/algoliasearch-helper/-/algoliasearch-helper-3.21.0.tgz", + "integrity": "sha512-hjVOrL15I3Y3K8xG0icwG1/tWE+MocqBrhW6uVBWpU+/kVEMK0BnM2xdssj6mZM61eJ4iRxHR0djEI3ENOpR8w==", "dependencies": { "@algolia/events": "^4.0.1" }, @@ -5208,18 +5196,28 @@ "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==" }, "node_modules/cosmiconfig": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-7.1.0.tgz", - "integrity": "sha512-AdmX6xUzdNASswsFtmwSt7Vj8po9IuqXm0UXz7QKPuEUmPB4XyjGfaAr2PSuELMwkRMVH1EpIkX5bTZGRB3eCA==", + "version": "8.3.6", + "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-8.3.6.tgz", + "integrity": "sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA==", "dependencies": { - "@types/parse-json": "^4.0.0", - "import-fresh": "^3.2.1", - "parse-json": "^5.0.0", - "path-type": "^4.0.0", - "yaml": "^1.10.0" + "import-fresh": "^3.3.0", + "js-yaml": "^4.1.0", + "parse-json": "^5.2.0", + "path-type": "^4.0.0" }, "engines": { - "node": ">=10" + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/d-fischer" + }, + "peerDependencies": { + "typescript": ">=4.9.5" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } } }, "node_modules/cross-spawn": { @@ -5261,11 +5259,11 @@ } }, "node_modules/css-declaration-sorter": { - "version": "6.4.1", - "resolved": "https://registry.npmjs.org/css-declaration-sorter/-/css-declaration-sorter-6.4.1.tgz", - "integrity": "sha512-rtdthzxKuyq6IzqX6jEcIzQF/YqccluefyCYheovBOLhFT/drQA9zj/UbRAa9J7C0o6EG6u3E6g+vKkay7/k3g==", + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/css-declaration-sorter/-/css-declaration-sorter-7.2.0.tgz", + "integrity": "sha512-h70rUM+3PNFuaBDTLe8wF/cdWu+dOZmb7pJt8Z2sedYbAcQVQV/tEchueg3GWxwqS0cxtbxmaHEdkNACqcvsow==", "engines": { - "node": "^10 || ^12 || >=14" + "node": "^14 || ^16 || >=18" }, "peerDependencies": { "postcss": "^8.0.9" @@ -5297,16 +5295,16 @@ } }, "node_modules/css-minimizer-webpack-plugin": { - "version": "4.2.2", - "resolved": "https://registry.npmjs.org/css-minimizer-webpack-plugin/-/css-minimizer-webpack-plugin-4.2.2.tgz", - "integrity": "sha512-s3Of/4jKfw1Hj9CxEO1E5oXhQAxlayuHO2y/ML+C6I9sQ7FdzfEV6QgMLN3vI+qFsjJGIAFLKtQK7t8BOXAIyA==", + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/css-minimizer-webpack-plugin/-/css-minimizer-webpack-plugin-5.0.1.tgz", + "integrity": "sha512-3caImjKFQkS+ws1TGcFn0V1HyDJFq1Euy589JlD6/3rV2kj+w7r5G9WDMgSHvpvXHNZ2calVypZWuEDQd9wfLg==", "dependencies": { - "cssnano": "^5.1.8", - "jest-worker": "^29.1.2", - "postcss": "^8.4.17", - "schema-utils": "^4.0.0", - "serialize-javascript": "^6.0.0", - "source-map": "^0.6.1" + "@jridgewell/trace-mapping": "^0.3.18", + "cssnano": "^6.0.1", + "jest-worker": "^29.4.3", + "postcss": "^8.4.24", + "schema-utils": "^4.0.1", + "serialize-javascript": "^6.0.1" }, "engines": { "node": ">= 14.15.0" @@ -5339,14 +5337,6 @@ } } }, - "node_modules/css-minimizer-webpack-plugin/node_modules/source-map": { - "version": "0.6.1", - "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", - "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", - "engines": { - "node": ">=0.10.0" - } - }, "node_modules/css-select": { "version": "5.1.0", "resolved": "https://registry.npmjs.org/css-select/-/css-select-5.1.0.tgz", @@ -5363,23 +5353,15 @@ } }, "node_modules/css-tree": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-1.1.3.tgz", - "integrity": "sha512-tRpdppF7TRazZrjJ6v3stzv93qxRcSsFmW6cX0Zm2NVKpxE1WV1HblnghVv9TreireHkqI/VDEsfolRF1p6y7Q==", + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-2.3.1.tgz", + "integrity": "sha512-6Fv1DV/TYw//QF5IzQdqsNDjx/wc8TrMBZsqjL9eW01tWb7R7k/mq+/VXfJCl7SoD5emsJop9cOByJZfs8hYIw==", "dependencies": { - "mdn-data": "2.0.14", - "source-map": "^0.6.1" + "mdn-data": "2.0.30", + "source-map-js": "^1.0.1" }, "engines": { - "node": ">=8.0.0" - } - }, - "node_modules/css-tree/node_modules/source-map": { - "version": "0.6.1", - "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", - "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", - "engines": { - "node": ">=0.10.0" + "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0" } }, "node_modules/css-what": { @@ -5405,108 +5387,128 @@ } }, "node_modules/cssnano": { - "version": "5.1.15", - "resolved": "https://registry.npmjs.org/cssnano/-/cssnano-5.1.15.tgz", - "integrity": "sha512-j+BKgDcLDQA+eDifLx0EO4XSA56b7uut3BQFH+wbSaSTuGLuiyTa/wbRYthUXX8LC9mLg+WWKe8h+qJuwTAbHw==", + "version": "6.1.2", + "resolved": "https://registry.npmjs.org/cssnano/-/cssnano-6.1.2.tgz", + "integrity": "sha512-rYk5UeX7VAM/u0lNqewCdasdtPK81CgX8wJFLEIXHbV2oldWRgJAsZrdhRXkV1NJzA2g850KiFm9mMU2HxNxMA==", "dependencies": { - "cssnano-preset-default": "^5.2.14", - "lilconfig": "^2.0.3", - "yaml": "^1.10.2" + "cssnano-preset-default": "^6.1.2", + "lilconfig": "^3.1.1" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "funding": { "type": "opencollective", "url": "https://opencollective.com/cssnano" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/cssnano-preset-advanced": { - "version": "5.3.10", - "resolved": "https://registry.npmjs.org/cssnano-preset-advanced/-/cssnano-preset-advanced-5.3.10.tgz", - "integrity": "sha512-fnYJyCS9jgMU+cmHO1rPSPf9axbQyD7iUhLO5Df6O4G+fKIOMps+ZbU0PdGFejFBBZ3Pftf18fn1eG7MAPUSWQ==", + "version": "6.1.2", + "resolved": "https://registry.npmjs.org/cssnano-preset-advanced/-/cssnano-preset-advanced-6.1.2.tgz", + "integrity": "sha512-Nhao7eD8ph2DoHolEzQs5CfRpiEP0xa1HBdnFZ82kvqdmbwVBUr2r1QuQ4t1pi+D1ZpqpcO4T+wy/7RxzJ/WPQ==", "dependencies": { - "autoprefixer": "^10.4.12", - "cssnano-preset-default": "^5.2.14", - "postcss-discard-unused": "^5.1.0", - "postcss-merge-idents": "^5.1.1", - "postcss-reduce-idents": "^5.2.0", - "postcss-zindex": "^5.1.0" + "autoprefixer": "^10.4.19", + "browserslist": "^4.23.0", + "cssnano-preset-default": "^6.1.2", + "postcss-discard-unused": "^6.0.5", + "postcss-merge-idents": "^6.0.3", + "postcss-reduce-idents": "^6.0.3", + "postcss-zindex": "^6.0.2" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/cssnano-preset-default": { - "version": "5.2.14", - "resolved": "https://registry.npmjs.org/cssnano-preset-default/-/cssnano-preset-default-5.2.14.tgz", - "integrity": "sha512-t0SFesj/ZV2OTylqQVOrFgEh5uanxbO6ZAdeCrNsUQ6fVuXwYTxJPNAGvGTxHbD68ldIJNec7PyYZDBrfDQ+6A==", - "dependencies": { - "css-declaration-sorter": "^6.3.1", - "cssnano-utils": "^3.1.0", - "postcss-calc": "^8.2.3", - "postcss-colormin": "^5.3.1", - "postcss-convert-values": "^5.1.3", - "postcss-discard-comments": "^5.1.2", - "postcss-discard-duplicates": "^5.1.0", - "postcss-discard-empty": "^5.1.1", - "postcss-discard-overridden": "^5.1.0", - "postcss-merge-longhand": "^5.1.7", - "postcss-merge-rules": "^5.1.4", - "postcss-minify-font-values": "^5.1.0", - "postcss-minify-gradients": "^5.1.1", - "postcss-minify-params": "^5.1.4", - "postcss-minify-selectors": "^5.2.1", - "postcss-normalize-charset": "^5.1.0", - "postcss-normalize-display-values": "^5.1.0", - "postcss-normalize-positions": "^5.1.1", - "postcss-normalize-repeat-style": "^5.1.1", - "postcss-normalize-string": "^5.1.0", - "postcss-normalize-timing-functions": "^5.1.0", - "postcss-normalize-unicode": "^5.1.1", - "postcss-normalize-url": "^5.1.0", - "postcss-normalize-whitespace": "^5.1.1", - "postcss-ordered-values": "^5.1.3", - "postcss-reduce-initial": "^5.1.2", - "postcss-reduce-transforms": "^5.1.0", - "postcss-svgo": "^5.1.0", - "postcss-unique-selectors": "^5.1.1" - }, - "engines": { - "node": "^10 || ^12 || >=14.0" - }, - "peerDependencies": { - "postcss": "^8.2.15" + "version": "6.1.2", + "resolved": "https://registry.npmjs.org/cssnano-preset-default/-/cssnano-preset-default-6.1.2.tgz", + "integrity": "sha512-1C0C+eNaeN8OcHQa193aRgYexyJtU8XwbdieEjClw+J9d94E41LwT6ivKH0WT+fYwYWB0Zp3I3IZ7tI/BbUbrg==", + "dependencies": { + "browserslist": "^4.23.0", + "css-declaration-sorter": "^7.2.0", + "cssnano-utils": "^4.0.2", + "postcss-calc": "^9.0.1", + "postcss-colormin": "^6.1.0", + "postcss-convert-values": "^6.1.0", + "postcss-discard-comments": "^6.0.2", + "postcss-discard-duplicates": "^6.0.3", + "postcss-discard-empty": "^6.0.3", + "postcss-discard-overridden": "^6.0.2", + "postcss-merge-longhand": "^6.0.5", + "postcss-merge-rules": "^6.1.1", + "postcss-minify-font-values": "^6.1.0", + "postcss-minify-gradients": "^6.0.3", + "postcss-minify-params": "^6.1.0", + "postcss-minify-selectors": "^6.0.4", + "postcss-normalize-charset": "^6.0.2", + "postcss-normalize-display-values": "^6.0.2", + "postcss-normalize-positions": "^6.0.2", + "postcss-normalize-repeat-style": "^6.0.2", + "postcss-normalize-string": "^6.0.2", + "postcss-normalize-timing-functions": "^6.0.2", + "postcss-normalize-unicode": "^6.1.0", + "postcss-normalize-url": "^6.0.2", + "postcss-normalize-whitespace": "^6.0.2", + "postcss-ordered-values": "^6.0.2", + "postcss-reduce-initial": "^6.1.0", + "postcss-reduce-transforms": "^6.0.2", + "postcss-svgo": "^6.0.3", + "postcss-unique-selectors": "^6.0.4" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" } }, "node_modules/cssnano-utils": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/cssnano-utils/-/cssnano-utils-3.1.0.tgz", - "integrity": "sha512-JQNR19/YZhz4psLX/rQ9M83e3z2Wf/HdJbryzte4a3NSuafyp9w/I4U+hx5C2S9g41qlstH7DEWnZaaj83OuEA==", + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/cssnano-utils/-/cssnano-utils-4.0.2.tgz", + "integrity": "sha512-ZR1jHg+wZ8o4c3zqf1SIUSTIvm/9mU343FMR6Obe/unskbvpGhZOo1J6d/r8D1pzkRQYuwbcH3hToOuoA2G7oQ==", "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/csso": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/csso/-/csso-4.2.0.tgz", - "integrity": "sha512-wvlcdIbf6pwKEk7vHj8/Bkc0B4ylXZruLvOgs9doS5eOsOpuodOV2zJChSpkp+pRpYQLQMeF04nr3Z68Sta9jA==", + "version": "5.0.5", + "resolved": "https://registry.npmjs.org/csso/-/csso-5.0.5.tgz", + "integrity": "sha512-0LrrStPOdJj+SPCCrGhzryycLjwcgUSHBtxNA8aIDxf0GLsRh1cKYhB00Gd1lDOS4yGH69+SNn13+TWbVHETFQ==", "dependencies": { - "css-tree": "^1.1.2" + "css-tree": "~2.2.0" }, "engines": { - "node": ">=8.0.0" + "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0", + "npm": ">=7.0.0" } }, + "node_modules/csso/node_modules/css-tree": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-2.2.1.tgz", + "integrity": "sha512-OA0mILzGc1kCOCSJerOeqDxDQ4HOh+G8NbOJFOTgOCzpw7fCBubk0fEyxp8AgOL/jvLgYA/uV0cMbe43ElF1JA==", + "dependencies": { + "mdn-data": "2.0.28", + "source-map-js": "^1.0.1" + }, + "engines": { + "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0", + "npm": ">=7.0.0" + } + }, + "node_modules/csso/node_modules/mdn-data": { + "version": "2.0.28", + "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.28.tgz", + "integrity": "sha512-aylIc7Z9y4yzHYAJNuESG3hfhC+0Ibp/MAMiaOZgNv4pmEdFyfZhhhny4MNiAfWdBQ1RQ2mfDWmM1x8SvGyp8g==" + }, "node_modules/csstype": { "version": "3.1.2", "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.2.tgz", @@ -6758,9 +6760,9 @@ "integrity": "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==" }, "node_modules/fs-extra": { - "version": "11.1.1", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.1.1.tgz", - "integrity": "sha512-MGIE4HOvQCeUCzmlHs0vXpih4ysz4wg9qiSAu6cd42lVwPbTM1TjV7RusoyQqMmk/95gdQZX72u+YW+c3eEpFQ==", + "version": "11.2.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.2.0.tgz", + "integrity": "sha512-PmDi3uwK5nFuXh7XDTlVnS17xJS7vW36is2+w3xcv8SVxiB4NyATf4ctkVY5bkSjX0Y4nbvZCq1/EjtEyr9ktw==", "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", @@ -7171,9 +7173,9 @@ } }, "node_modules/hast-util-raw": { - "version": "9.0.2", - "resolved": "https://registry.npmjs.org/hast-util-raw/-/hast-util-raw-9.0.2.tgz", - "integrity": "sha512-PldBy71wO9Uq1kyaMch9AHIghtQvIwxBUkv823pKmkTM3oV1JxtsTNYdevMxvUHqcnOAuO65JKU2+0NOxc2ksA==", + "version": "9.0.3", + "resolved": "https://registry.npmjs.org/hast-util-raw/-/hast-util-raw-9.0.3.tgz", + "integrity": "sha512-ICWvVOF2fq4+7CMmtCPD5CM4QKjPbHpPotE6+8tDooV0ZuyJVUzHsrNX+O5NaRbieTf0F7FfeBOMAwi6Td0+yQ==", "dependencies": { "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", @@ -8107,9 +8109,9 @@ } }, "node_modules/joi": { - "version": "17.12.3", - "resolved": "https://registry.npmjs.org/joi/-/joi-17.12.3.tgz", - "integrity": "sha512-2RRziagf555owrm9IRVtdKynOBeITiDpuZqIpgwqXShPncPKNiRQoiGsl/T8SQdq+8ugRzH2LqY67irr2y/d+g==", + "version": "17.13.1", + "resolved": "https://registry.npmjs.org/joi/-/joi-17.13.1.tgz", + "integrity": "sha512-vaBlIKCyo4FCUtCm7Eu4QZd/q02bWcxfUO6YSXAZOWF6gzcLBeba8kwotUdYJjDLW8Cz8RywsSOqiNJZW0mNvg==", "dependencies": { "@hapi/hoek": "^9.3.0", "@hapi/topo": "^5.1.0", @@ -8238,11 +8240,14 @@ } }, "node_modules/lilconfig": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.1.0.tgz", - "integrity": "sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==", + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.1.tgz", + "integrity": "sha512-O18pf7nyvHTckunPWCV1XUNXU1piu01y2b7ATJ0ppkUkk8ocqVWBrYjJBCwHDjD/ZWcfyrA0P4gKhzWGi5EINQ==", "engines": { - "node": ">=10" + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/antonk52" } }, "node_modules/lines-and-columns": { @@ -8443,9 +8448,9 @@ } }, "node_modules/mdast-util-from-markdown": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-2.0.0.tgz", - "integrity": "sha512-n7MTOr/z+8NAX/wmhhDji8O3bRvPTV/U0oTCaZJkjhPSKTPhS3xufVhKGF8s1pJ7Ox4QgoIU7KHseh09S+9rTA==", + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-2.0.1.tgz", + "integrity": "sha512-aJEUyzZ6TzlsX2s5B4Of7lN7EQtAxvtradMMglCQDyaTFgse6CmtmdJ15ElnVRlCg1vpNyVtbem0PWzlNieZsA==", "dependencies": { "@types/mdast": "^4.0.0", "@types/unist": "^3.0.0", @@ -8776,9 +8781,9 @@ } }, "node_modules/mdn-data": { - "version": "2.0.14", - "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.14.tgz", - "integrity": "sha512-dn6wd0uw5GsdswPFfsgMp5NSB0/aDe6fK94YJV/AJDYXL6HVLWBsxeq7js7Ad+mU2K9LAlwpk6kN2D5mwCPVow==" + "version": "2.0.30", + "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.30.tgz", + "integrity": "sha512-GaqWWShW4kv/G9IEucWScBx9G1/vsFZZJUO+tD26M8J8z3Kw5RDQjaoZe03YAClgeS/SWPOcb4nkFBTEi5DUEA==" }, "node_modules/media-typer": { "version": "0.3.0", @@ -8860,9 +8865,9 @@ } }, "node_modules/micromark-core-commonmark": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/micromark-core-commonmark/-/micromark-core-commonmark-2.0.0.tgz", - "integrity": "sha512-jThOz/pVmAYUtkroV3D5c1osFXAMv9e0ypGDOIZuCeAe91/sD6BoE2Sjzt30yuXtwOYUmySOhMas/PVyh02itA==", + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-core-commonmark/-/micromark-core-commonmark-2.0.1.tgz", + "integrity": "sha512-CUQyKr1e///ZODyD1U3xit6zXwy1a8q2a1S1HKtIlmgvurrEpaw/Y9y6KSIbF8P59cn/NjzHyO+Q2fAyYLQrAA==", "funding": [ { "type": "GitHub Sponsors", @@ -10378,9 +10383,9 @@ ] }, "node_modules/micromark-util-subtokenize": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/micromark-util-subtokenize/-/micromark-util-subtokenize-2.0.0.tgz", - "integrity": "sha512-vc93L1t+gpR3p8jxeVdaYlbV2jTYteDje19rNSS/H5dlhxUYll5Fy6vJ2cDwP8RnsXi818yGty1ayP55y3W6fg==", + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-subtokenize/-/micromark-util-subtokenize-2.0.1.tgz", + "integrity": "sha512-jZNtiFl/1aY73yS3UGQkutD0UbhTt68qnRpw2Pifmz5wV9h8gOVsN70v+Lq/f1rKaU/W8pxRe8y8Q9FX1AOe1Q==", "funding": [ { "type": "GitHub Sponsors", @@ -10630,9 +10635,9 @@ } }, "node_modules/nanoid": { - "version": "3.3.6", - "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.6.tgz", - "integrity": "sha512-BGcqMMJuToF7i1rt+2PWSNVnWIkGCU78jBG3RxO/bZlnZPK2Cmi2QaffxGO/2RvWi9sL+FAiRiXMgsyxQ1DIDA==", + "version": "3.3.7", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.7.tgz", + "integrity": "sha512-eSRppjcPIatRIMC1U6UngP8XFcz8MQWGQdt1MTBQ7NaAmvXDfvNxbvWV3x2y6CdEUciCSsDHDQZbhYaB8QEo2g==", "funding": [ { "type": "github", @@ -10732,17 +10737,6 @@ "node": ">=0.10.0" } }, - "node_modules/normalize-url": { - "version": "6.1.0", - "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-6.1.0.tgz", - "integrity": "sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==", - "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, "node_modules/npm-run-path": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz", @@ -11232,9 +11226,9 @@ } }, "node_modules/postcss": { - "version": "8.4.31", - "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.31.tgz", - "integrity": "sha512-PS08Iboia9mts/2ygV3eLpY5ghnUcfLV/EXTOW1E2qYxJKGGBUtNjN76FYHnMs36RmARn41bC0AZmn+rR0OVpQ==", + "version": "8.4.38", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.38.tgz", + "integrity": "sha512-Wglpdk03BSfXkHoQa3b/oulrotAkwrlLDRSOb9D0bN86FdRyE9lppSp33aHNPgBa0JKCoB+drFLZkQoRRYae5A==", "funding": [ { "type": "opencollective", @@ -11250,114 +11244,117 @@ } ], "dependencies": { - "nanoid": "^3.3.6", + "nanoid": "^3.3.7", "picocolors": "^1.0.0", - "source-map-js": "^1.0.2" + "source-map-js": "^1.2.0" }, "engines": { "node": "^10 || ^12 || >=14" } }, "node_modules/postcss-calc": { - "version": "8.2.4", - "resolved": "https://registry.npmjs.org/postcss-calc/-/postcss-calc-8.2.4.tgz", - "integrity": "sha512-SmWMSJmB8MRnnULldx0lQIyhSNvuDl9HfrZkaqqE/WHAhToYsAvDq+yAsA/kIyINDszOp3Rh0GFoNuH5Ypsm3Q==", + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/postcss-calc/-/postcss-calc-9.0.1.tgz", + "integrity": "sha512-TipgjGyzP5QzEhsOZUaIkeO5mKeMFpebWzRogWG/ysonUlnHcq5aJe0jOjpfzUU8PeSaBQnrE8ehR0QA5vs8PQ==", "dependencies": { - "postcss-selector-parser": "^6.0.9", + "postcss-selector-parser": "^6.0.11", "postcss-value-parser": "^4.2.0" }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, "peerDependencies": { "postcss": "^8.2.2" } }, "node_modules/postcss-colormin": { - "version": "5.3.1", - "resolved": "https://registry.npmjs.org/postcss-colormin/-/postcss-colormin-5.3.1.tgz", - "integrity": "sha512-UsWQG0AqTFQmpBegeLLc1+c3jIqBNB0zlDGRWR+dQ3pRKJL1oeMzyqmH3o2PIfn9MBdNrVPWhDbT769LxCTLJQ==", + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/postcss-colormin/-/postcss-colormin-6.1.0.tgz", + "integrity": "sha512-x9yX7DOxeMAR+BgGVnNSAxmAj98NX/YxEMNFP+SDCEeNLb2r3i6Hh1ksMsnW8Ub5SLCpbescQqn9YEbE9554Sw==", "dependencies": { - "browserslist": "^4.21.4", + "browserslist": "^4.23.0", "caniuse-api": "^3.0.0", - "colord": "^2.9.1", + "colord": "^2.9.3", "postcss-value-parser": "^4.2.0" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-convert-values": { - "version": "5.1.3", - "resolved": "https://registry.npmjs.org/postcss-convert-values/-/postcss-convert-values-5.1.3.tgz", - "integrity": "sha512-82pC1xkJZtcJEfiLw6UXnXVXScgtBrjlO5CBmuDQc+dlb88ZYheFsjTn40+zBVi3DkfF7iezO0nJUPLcJK3pvA==", + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/postcss-convert-values/-/postcss-convert-values-6.1.0.tgz", + "integrity": "sha512-zx8IwP/ts9WvUM6NkVSkiU902QZL1bwPhaVaLynPtCsOTqp+ZKbNi+s6XJg3rfqpKGA/oc7Oxk5t8pOQJcwl/w==", "dependencies": { - "browserslist": "^4.21.4", + "browserslist": "^4.23.0", "postcss-value-parser": "^4.2.0" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-discard-comments": { - "version": "5.1.2", - "resolved": "https://registry.npmjs.org/postcss-discard-comments/-/postcss-discard-comments-5.1.2.tgz", - "integrity": "sha512-+L8208OVbHVF2UQf1iDmRcbdjJkuBF6IS29yBDSiWUIzpYaAhtNl6JYnYm12FnkeCwQqF5LeklOu6rAqgfBZqQ==", + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/postcss-discard-comments/-/postcss-discard-comments-6.0.2.tgz", + "integrity": "sha512-65w/uIqhSBBfQmYnG92FO1mWZjJ4GL5b8atm5Yw2UgrwD7HiNiSSNwJor1eCFGzUgYnN/iIknhNRVqjrrpuglw==", "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-discard-duplicates": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/postcss-discard-duplicates/-/postcss-discard-duplicates-5.1.0.tgz", - "integrity": "sha512-zmX3IoSI2aoenxHV6C7plngHWWhUOV3sP1T8y2ifzxzbtnuhk1EdPwm0S1bIUNaJ2eNbWeGLEwzw8huPD67aQw==", + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/postcss-discard-duplicates/-/postcss-discard-duplicates-6.0.3.tgz", + "integrity": "sha512-+JA0DCvc5XvFAxwx6f/e68gQu/7Z9ud584VLmcgto28eB8FqSFZwtrLwB5Kcp70eIoWP/HXqz4wpo8rD8gpsTw==", "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-discard-empty": { - "version": "5.1.1", - "resolved": "https://registry.npmjs.org/postcss-discard-empty/-/postcss-discard-empty-5.1.1.tgz", - "integrity": "sha512-zPz4WljiSuLWsI0ir4Mcnr4qQQ5e1Ukc3i7UfE2XcrwKK2LIPIqE5jxMRxO6GbI3cv//ztXDsXwEWT3BHOGh3A==", + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/postcss-discard-empty/-/postcss-discard-empty-6.0.3.tgz", + "integrity": "sha512-znyno9cHKQsK6PtxL5D19Fj9uwSzC2mB74cpT66fhgOadEUPyXFkbgwm5tvc3bt3NAy8ltE5MrghxovZRVnOjQ==", "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-discard-overridden": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/postcss-discard-overridden/-/postcss-discard-overridden-5.1.0.tgz", - "integrity": "sha512-21nOL7RqWR1kasIVdKs8HNqQJhFxLsyRfAnUDm4Fe4t4mCWL9OJiHvlHPjcd8zc5Myu89b/7wZDnOSjFgeWRtw==", + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/postcss-discard-overridden/-/postcss-discard-overridden-6.0.2.tgz", + "integrity": "sha512-j87xzI4LUggC5zND7KdjsI25APtyMuynXZSujByMaav2roV6OZX+8AaCUcZSWqckZpjAjRyFDdpqybgjFO0HJQ==", "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-discard-unused": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/postcss-discard-unused/-/postcss-discard-unused-5.1.0.tgz", - "integrity": "sha512-KwLWymI9hbwXmJa0dkrzpRbSJEh0vVUd7r8t0yOGPcfKzyJJxFM8kLyC5Ev9avji6nY95pOp1W6HqIrfT+0VGw==", + "version": "6.0.5", + "resolved": "https://registry.npmjs.org/postcss-discard-unused/-/postcss-discard-unused-6.0.5.tgz", + "integrity": "sha512-wHalBlRHkaNnNwfC8z+ppX57VhvS+HWgjW508esjdaEYr3Mx7Gnn2xA4R/CKf5+Z9S5qsqC+Uzh4ueENWwCVUA==", "dependencies": { - "postcss-selector-parser": "^6.0.5" + "postcss-selector-parser": "^6.0.16" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-loader": { @@ -11381,136 +11378,111 @@ "webpack": "^5.0.0" } }, - "node_modules/postcss-loader/node_modules/cosmiconfig": { - "version": "8.3.6", - "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-8.3.6.tgz", - "integrity": "sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA==", - "dependencies": { - "import-fresh": "^3.3.0", - "js-yaml": "^4.1.0", - "parse-json": "^5.2.0", - "path-type": "^4.0.0" - }, - "engines": { - "node": ">=14" - }, - "funding": { - "url": "https://github.com/sponsors/d-fischer" - }, - "peerDependencies": { - "typescript": ">=4.9.5" - }, - "peerDependenciesMeta": { - "typescript": { - "optional": true - } - } - }, "node_modules/postcss-merge-idents": { - "version": "5.1.1", - "resolved": "https://registry.npmjs.org/postcss-merge-idents/-/postcss-merge-idents-5.1.1.tgz", - "integrity": "sha512-pCijL1TREiCoog5nQp7wUe+TUonA2tC2sQ54UGeMmryK3UFGIYKqDyjnqd6RcuI4znFn9hWSLNN8xKE/vWcUQw==", + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/postcss-merge-idents/-/postcss-merge-idents-6.0.3.tgz", + "integrity": "sha512-1oIoAsODUs6IHQZkLQGO15uGEbK3EAl5wi9SS8hs45VgsxQfMnxvt+L+zIr7ifZFIH14cfAeVe2uCTa+SPRa3g==", "dependencies": { - "cssnano-utils": "^3.1.0", + "cssnano-utils": "^4.0.2", "postcss-value-parser": "^4.2.0" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-merge-longhand": { - "version": "5.1.7", - "resolved": "https://registry.npmjs.org/postcss-merge-longhand/-/postcss-merge-longhand-5.1.7.tgz", - "integrity": "sha512-YCI9gZB+PLNskrK0BB3/2OzPnGhPkBEwmwhfYk1ilBHYVAZB7/tkTHFBAnCrvBBOmeYyMYw3DMjT55SyxMBzjQ==", + "version": "6.0.5", + "resolved": "https://registry.npmjs.org/postcss-merge-longhand/-/postcss-merge-longhand-6.0.5.tgz", + "integrity": "sha512-5LOiordeTfi64QhICp07nzzuTDjNSO8g5Ksdibt44d+uvIIAE1oZdRn8y/W5ZtYgRH/lnLDlvi9F8btZcVzu3w==", "dependencies": { "postcss-value-parser": "^4.2.0", - "stylehacks": "^5.1.1" + "stylehacks": "^6.1.1" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-merge-rules": { - "version": "5.1.4", - "resolved": "https://registry.npmjs.org/postcss-merge-rules/-/postcss-merge-rules-5.1.4.tgz", - "integrity": "sha512-0R2IuYpgU93y9lhVbO/OylTtKMVcHb67zjWIfCiKR9rWL3GUk1677LAqD/BcHizukdZEjT8Ru3oHRoAYoJy44g==", + "version": "6.1.1", + "resolved": "https://registry.npmjs.org/postcss-merge-rules/-/postcss-merge-rules-6.1.1.tgz", + "integrity": "sha512-KOdWF0gju31AQPZiD+2Ar9Qjowz1LTChSjFFbS+e2sFgc4uHOp3ZvVX4sNeTlk0w2O31ecFGgrFzhO0RSWbWwQ==", "dependencies": { - "browserslist": "^4.21.4", + "browserslist": "^4.23.0", "caniuse-api": "^3.0.0", - "cssnano-utils": "^3.1.0", - "postcss-selector-parser": "^6.0.5" + "cssnano-utils": "^4.0.2", + "postcss-selector-parser": "^6.0.16" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-minify-font-values": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/postcss-minify-font-values/-/postcss-minify-font-values-5.1.0.tgz", - "integrity": "sha512-el3mYTgx13ZAPPirSVsHqFzl+BBBDrXvbySvPGFnQcTI4iNslrPaFq4muTkLZmKlGk4gyFAYUBMH30+HurREyA==", + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/postcss-minify-font-values/-/postcss-minify-font-values-6.1.0.tgz", + "integrity": "sha512-gklfI/n+9rTh8nYaSJXlCo3nOKqMNkxuGpTn/Qm0gstL3ywTr9/WRKznE+oy6fvfolH6dF+QM4nCo8yPLdvGJg==", "dependencies": { "postcss-value-parser": "^4.2.0" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-minify-gradients": { - "version": "5.1.1", - "resolved": "https://registry.npmjs.org/postcss-minify-gradients/-/postcss-minify-gradients-5.1.1.tgz", - "integrity": "sha512-VGvXMTpCEo4qHTNSa9A0a3D+dxGFZCYwR6Jokk+/3oB6flu2/PnPXAh2x7x52EkY5xlIHLm+Le8tJxe/7TNhzw==", + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/postcss-minify-gradients/-/postcss-minify-gradients-6.0.3.tgz", + "integrity": "sha512-4KXAHrYlzF0Rr7uc4VrfwDJ2ajrtNEpNEuLxFgwkhFZ56/7gaE4Nr49nLsQDZyUe+ds+kEhf+YAUolJiYXF8+Q==", "dependencies": { - "colord": "^2.9.1", - "cssnano-utils": "^3.1.0", + "colord": "^2.9.3", + "cssnano-utils": "^4.0.2", "postcss-value-parser": "^4.2.0" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-minify-params": { - "version": "5.1.4", - "resolved": "https://registry.npmjs.org/postcss-minify-params/-/postcss-minify-params-5.1.4.tgz", - "integrity": "sha512-+mePA3MgdmVmv6g+30rn57USjOGSAyuxUmkfiWpzalZ8aiBkdPYjXWtHuwJGm1v5Ojy0Z0LaSYhHaLJQB0P8Jw==", + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/postcss-minify-params/-/postcss-minify-params-6.1.0.tgz", + "integrity": "sha512-bmSKnDtyyE8ujHQK0RQJDIKhQ20Jq1LYiez54WiaOoBtcSuflfK3Nm596LvbtlFcpipMjgClQGyGr7GAs+H1uA==", "dependencies": { - "browserslist": "^4.21.4", - "cssnano-utils": "^3.1.0", + "browserslist": "^4.23.0", + "cssnano-utils": "^4.0.2", "postcss-value-parser": "^4.2.0" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-minify-selectors": { - "version": "5.2.1", - "resolved": "https://registry.npmjs.org/postcss-minify-selectors/-/postcss-minify-selectors-5.2.1.tgz", - "integrity": "sha512-nPJu7OjZJTsVUmPdm2TcaiohIwxP+v8ha9NehQ2ye9szv4orirRU3SDdtUmKH+10nzn0bAyOXZ0UEr7OpvLehg==", + "version": "6.0.4", + "resolved": "https://registry.npmjs.org/postcss-minify-selectors/-/postcss-minify-selectors-6.0.4.tgz", + "integrity": "sha512-L8dZSwNLgK7pjTto9PzWRoMbnLq5vsZSTu8+j1P/2GB8qdtGQfn+K1uSvFgYvgh83cbyxT5m43ZZhUMTJDSClQ==", "dependencies": { - "postcss-selector-parser": "^6.0.5" + "postcss-selector-parser": "^6.0.16" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-modules-extract-imports": { @@ -11569,192 +11541,191 @@ } }, "node_modules/postcss-normalize-charset": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/postcss-normalize-charset/-/postcss-normalize-charset-5.1.0.tgz", - "integrity": "sha512-mSgUJ+pd/ldRGVx26p2wz9dNZ7ji6Pn8VWBajMXFf8jk7vUoSrZ2lt/wZR7DtlZYKesmZI680qjr2CeFF2fbUg==", + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/postcss-normalize-charset/-/postcss-normalize-charset-6.0.2.tgz", + "integrity": "sha512-a8N9czmdnrjPHa3DeFlwqst5eaL5W8jYu3EBbTTkI5FHkfMhFZh1EGbku6jhHhIzTA6tquI2P42NtZ59M/H/kQ==", "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-normalize-display-values": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/postcss-normalize-display-values/-/postcss-normalize-display-values-5.1.0.tgz", - "integrity": "sha512-WP4KIM4o2dazQXWmFaqMmcvsKmhdINFblgSeRgn8BJ6vxaMyaJkwAzpPpuvSIoG/rmX3M+IrRZEz2H0glrQNEA==", + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/postcss-normalize-display-values/-/postcss-normalize-display-values-6.0.2.tgz", + "integrity": "sha512-8H04Mxsb82ON/aAkPeq8kcBbAtI5Q2a64X/mnRRfPXBq7XeogoQvReqxEfc0B4WPq1KimjezNC8flUtC3Qz6jg==", "dependencies": { "postcss-value-parser": "^4.2.0" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-normalize-positions": { - "version": "5.1.1", - "resolved": "https://registry.npmjs.org/postcss-normalize-positions/-/postcss-normalize-positions-5.1.1.tgz", - "integrity": "sha512-6UpCb0G4eofTCQLFVuI3EVNZzBNPiIKcA1AKVka+31fTVySphr3VUgAIULBhxZkKgwLImhzMR2Bw1ORK+37INg==", + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/postcss-normalize-positions/-/postcss-normalize-positions-6.0.2.tgz", + "integrity": "sha512-/JFzI441OAB9O7VnLA+RtSNZvQ0NCFZDOtp6QPFo1iIyawyXg0YI3CYM9HBy1WvwCRHnPep/BvI1+dGPKoXx/Q==", "dependencies": { "postcss-value-parser": "^4.2.0" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-normalize-repeat-style": { - "version": "5.1.1", - "resolved": "https://registry.npmjs.org/postcss-normalize-repeat-style/-/postcss-normalize-repeat-style-5.1.1.tgz", - "integrity": "sha512-mFpLspGWkQtBcWIRFLmewo8aC3ImN2i/J3v8YCFUwDnPu3Xz4rLohDO26lGjwNsQxB3YF0KKRwspGzE2JEuS0g==", + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/postcss-normalize-repeat-style/-/postcss-normalize-repeat-style-6.0.2.tgz", + "integrity": "sha512-YdCgsfHkJ2jEXwR4RR3Tm/iOxSfdRt7jplS6XRh9Js9PyCR/aka/FCb6TuHT2U8gQubbm/mPmF6L7FY9d79VwQ==", "dependencies": { "postcss-value-parser": "^4.2.0" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-normalize-string": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/postcss-normalize-string/-/postcss-normalize-string-5.1.0.tgz", - "integrity": "sha512-oYiIJOf4T9T1N4i+abeIc7Vgm/xPCGih4bZz5Nm0/ARVJ7K6xrDlLwvwqOydvyL3RHNf8qZk6vo3aatiw/go3w==", + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/postcss-normalize-string/-/postcss-normalize-string-6.0.2.tgz", + "integrity": "sha512-vQZIivlxlfqqMp4L9PZsFE4YUkWniziKjQWUtsxUiVsSSPelQydwS8Wwcuw0+83ZjPWNTl02oxlIvXsmmG+CiQ==", "dependencies": { "postcss-value-parser": "^4.2.0" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-normalize-timing-functions": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/postcss-normalize-timing-functions/-/postcss-normalize-timing-functions-5.1.0.tgz", - "integrity": "sha512-DOEkzJ4SAXv5xkHl0Wa9cZLF3WCBhF3o1SKVxKQAa+0pYKlueTpCgvkFAHfk+Y64ezX9+nITGrDZeVGgITJXjg==", + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/postcss-normalize-timing-functions/-/postcss-normalize-timing-functions-6.0.2.tgz", + "integrity": "sha512-a+YrtMox4TBtId/AEwbA03VcJgtyW4dGBizPl7e88cTFULYsprgHWTbfyjSLyHeBcK/Q9JhXkt2ZXiwaVHoMzA==", "dependencies": { "postcss-value-parser": "^4.2.0" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-normalize-unicode": { - "version": "5.1.1", - "resolved": "https://registry.npmjs.org/postcss-normalize-unicode/-/postcss-normalize-unicode-5.1.1.tgz", - "integrity": "sha512-qnCL5jzkNUmKVhZoENp1mJiGNPcsJCs1aaRmURmeJGES23Z/ajaln+EPTD+rBeNkSryI+2WTdW+lwcVdOikrpA==", + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-unicode/-/postcss-normalize-unicode-6.1.0.tgz", + "integrity": "sha512-QVC5TQHsVj33otj8/JD869Ndr5Xcc/+fwRh4HAsFsAeygQQXm+0PySrKbr/8tkDKzW+EVT3QkqZMfFrGiossDg==", "dependencies": { - "browserslist": "^4.21.4", + "browserslist": "^4.23.0", "postcss-value-parser": "^4.2.0" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-normalize-url": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/postcss-normalize-url/-/postcss-normalize-url-5.1.0.tgz", - "integrity": "sha512-5upGeDO+PVthOxSmds43ZeMeZfKH+/DKgGRD7TElkkyS46JXAUhMzIKiCa7BabPeIy3AQcTkXwVVN7DbqsiCew==", + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/postcss-normalize-url/-/postcss-normalize-url-6.0.2.tgz", + "integrity": "sha512-kVNcWhCeKAzZ8B4pv/DnrU1wNh458zBNp8dh4y5hhxih5RZQ12QWMuQrDgPRw3LRl8mN9vOVfHl7uhvHYMoXsQ==", "dependencies": { - "normalize-url": "^6.0.1", "postcss-value-parser": "^4.2.0" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-normalize-whitespace": { - "version": "5.1.1", - "resolved": "https://registry.npmjs.org/postcss-normalize-whitespace/-/postcss-normalize-whitespace-5.1.1.tgz", - "integrity": "sha512-83ZJ4t3NUDETIHTa3uEg6asWjSBYL5EdkVB0sDncx9ERzOKBVJIUeDO9RyA9Zwtig8El1d79HBp0JEi8wvGQnA==", + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/postcss-normalize-whitespace/-/postcss-normalize-whitespace-6.0.2.tgz", + "integrity": "sha512-sXZ2Nj1icbJOKmdjXVT9pnyHQKiSAyuNQHSgRCUgThn2388Y9cGVDR+E9J9iAYbSbLHI+UUwLVl1Wzco/zgv0Q==", "dependencies": { "postcss-value-parser": "^4.2.0" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-ordered-values": { - "version": "5.1.3", - "resolved": "https://registry.npmjs.org/postcss-ordered-values/-/postcss-ordered-values-5.1.3.tgz", - "integrity": "sha512-9UO79VUhPwEkzbb3RNpqqghc6lcYej1aveQteWY+4POIwlqkYE21HKWaLDF6lWNuqCobEAyTovVhtI32Rbv2RQ==", + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/postcss-ordered-values/-/postcss-ordered-values-6.0.2.tgz", + "integrity": "sha512-VRZSOB+JU32RsEAQrO94QPkClGPKJEL/Z9PCBImXMhIeK5KAYo6slP/hBYlLgrCjFxyqvn5VC81tycFEDBLG1Q==", "dependencies": { - "cssnano-utils": "^3.1.0", + "cssnano-utils": "^4.0.2", "postcss-value-parser": "^4.2.0" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-reduce-idents": { - "version": "5.2.0", - "resolved": "https://registry.npmjs.org/postcss-reduce-idents/-/postcss-reduce-idents-5.2.0.tgz", - "integrity": "sha512-BTrLjICoSB6gxbc58D5mdBK8OhXRDqud/zodYfdSi52qvDHdMwk+9kB9xsM8yJThH/sZU5A6QVSmMmaN001gIg==", + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/postcss-reduce-idents/-/postcss-reduce-idents-6.0.3.tgz", + "integrity": "sha512-G3yCqZDpsNPoQgbDUy3T0E6hqOQ5xigUtBQyrmq3tn2GxlyiL0yyl7H+T8ulQR6kOcHJ9t7/9H4/R2tv8tJbMA==", "dependencies": { "postcss-value-parser": "^4.2.0" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-reduce-initial": { - "version": "5.1.2", - "resolved": "https://registry.npmjs.org/postcss-reduce-initial/-/postcss-reduce-initial-5.1.2.tgz", - "integrity": "sha512-dE/y2XRaqAi6OvjzD22pjTUQ8eOfc6m/natGHgKFBK9DxFmIm69YmaRVQrGgFlEfc1HePIurY0TmDeROK05rIg==", + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/postcss-reduce-initial/-/postcss-reduce-initial-6.1.0.tgz", + "integrity": "sha512-RarLgBK/CrL1qZags04oKbVbrrVK2wcxhvta3GCxrZO4zveibqbRPmm2VI8sSgCXwoUHEliRSbOfpR0b/VIoiw==", "dependencies": { - "browserslist": "^4.21.4", + "browserslist": "^4.23.0", "caniuse-api": "^3.0.0" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-reduce-transforms": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/postcss-reduce-transforms/-/postcss-reduce-transforms-5.1.0.tgz", - "integrity": "sha512-2fbdbmgir5AvpW9RLtdONx1QoYG2/EtqpNQbFASDlixBbAYuTcJ0dECwlqNqH7VbaUnEnh8SrxOe2sRIn24XyQ==", + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/postcss-reduce-transforms/-/postcss-reduce-transforms-6.0.2.tgz", + "integrity": "sha512-sB+Ya++3Xj1WaT9+5LOOdirAxP7dJZms3GRcYheSPi1PiTMigsxHAdkrbItHxwYHr4kt1zL7mmcHstgMYT+aiA==", "dependencies": { "postcss-value-parser": "^4.2.0" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-selector-parser": { - "version": "6.0.13", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.13.tgz", - "integrity": "sha512-EaV1Gl4mUEV4ddhDnv/xtj7sxwrwxdetHdWUGnT4VJQf+4d05v6lHYZr8N573k5Z0BViss7BDhfWtKS3+sfAqQ==", + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.0.tgz", + "integrity": "sha512-UMz42UD0UY0EApS0ZL9o1XnLhSTtvvvLe5Dc2H2O56fvRZi+KulDyf5ctDhhtYJBGKStV2FL1fy6253cmLgqVQ==", "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" @@ -11764,46 +11735,46 @@ } }, "node_modules/postcss-sort-media-queries": { - "version": "4.4.1", - "resolved": "https://registry.npmjs.org/postcss-sort-media-queries/-/postcss-sort-media-queries-4.4.1.tgz", - "integrity": "sha512-QDESFzDDGKgpiIh4GYXsSy6sek2yAwQx1JASl5AxBtU1Lq2JfKBljIPNdil989NcSKRQX1ToiaKphImtBuhXWw==", + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/postcss-sort-media-queries/-/postcss-sort-media-queries-5.2.0.tgz", + "integrity": "sha512-AZ5fDMLD8SldlAYlvi8NIqo0+Z8xnXU2ia0jxmuhxAU+Lqt9K+AlmLNJ/zWEnE9x+Zx3qL3+1K20ATgNOr3fAA==", "dependencies": { - "sort-css-media-queries": "2.1.0" + "sort-css-media-queries": "2.2.0" }, "engines": { - "node": ">=10.0.0" + "node": ">=14.0.0" }, "peerDependencies": { - "postcss": "^8.4.16" + "postcss": "^8.4.23" } }, "node_modules/postcss-svgo": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/postcss-svgo/-/postcss-svgo-5.1.0.tgz", - "integrity": "sha512-D75KsH1zm5ZrHyxPakAxJWtkyXew5qwS70v56exwvw542d9CRtTo78K0WeFxZB4G7JXKKMbEZtZayTGdIky/eA==", + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/postcss-svgo/-/postcss-svgo-6.0.3.tgz", + "integrity": "sha512-dlrahRmxP22bX6iKEjOM+c8/1p+81asjKT+V5lrgOH944ryx/OHpclnIbGsKVd3uWOXFLYJwCVf0eEkJGvO96g==", "dependencies": { "postcss-value-parser": "^4.2.0", - "svgo": "^2.7.0" + "svgo": "^3.2.0" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >= 18" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-unique-selectors": { - "version": "5.1.1", - "resolved": "https://registry.npmjs.org/postcss-unique-selectors/-/postcss-unique-selectors-5.1.1.tgz", - "integrity": "sha512-5JiODlELrz8L2HwxfPnhOWZYWDxVHWL83ufOv84NrcgipI7TaeRsatAhK4Tr2/ZiYldpK/wBvw5BD3qfaK96GA==", + "version": "6.0.4", + "resolved": "https://registry.npmjs.org/postcss-unique-selectors/-/postcss-unique-selectors-6.0.4.tgz", + "integrity": "sha512-K38OCaIrO8+PzpArzkLKB42dSARtC2tmG6PvD4b1o1Q2E9Os8jzfWFfSy/rixsHwohtsDdFtAWGjFVFUdwYaMg==", "dependencies": { - "postcss-selector-parser": "^6.0.5" + "postcss-selector-parser": "^6.0.16" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/postcss-value-parser": { @@ -11812,14 +11783,14 @@ "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==" }, "node_modules/postcss-zindex": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/postcss-zindex/-/postcss-zindex-5.1.0.tgz", - "integrity": "sha512-fgFMf0OtVSBR1va1JNHYgMxYk73yhn/qb4uQDq1DLGYolz8gHCyr/sesEuGUaYs58E3ZJRcpoGuPVoB7Meiq9A==", + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/postcss-zindex/-/postcss-zindex-6.0.2.tgz", + "integrity": "sha512-5BxW9l1evPB/4ZIc+2GobEBoKC+h8gPGCMi+jxsYvd2x0mjq7wazk6DrP71pStqxE9Foxh5TVnonbWpFZzXaYg==", "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/prebuild-install": { @@ -12297,9 +12268,9 @@ "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==" }, "node_modules/react-json-view-lite": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/react-json-view-lite/-/react-json-view-lite-1.3.0.tgz", - "integrity": "sha512-aN1biKC5v4DQkmQBlZjuMFR09MKZGMPtIg+cut8zEeg2HXd6gl2gRy0n4HMacHf0dznQgo0SVXN7eT8zV3hEuQ==", + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/react-json-view-lite/-/react-json-view-lite-1.4.0.tgz", + "integrity": "sha512-wh6F6uJyYAmQ4fK0e8dSQMEWuvTs2Wr3el3sLD9bambX1+pSWUVXIz1RFaoy3TI1mZ0FqdpKq9YgbgTTgyrmXA==", "engines": { "node": ">=14" }, @@ -12309,12 +12280,11 @@ }, "node_modules/react-loadable": { "name": "@docusaurus/react-loadable", - "version": "5.5.2", - "resolved": "https://registry.npmjs.org/@docusaurus/react-loadable/-/react-loadable-5.5.2.tgz", - "integrity": "sha512-A3dYjdBGuy0IGT+wyLIGIKLRE+sAk1iNk0f1HjNDysO7u8lhL4N3VEm+FAubmJbAztn94F7MxBTPmnixbiyFdQ==", + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/@docusaurus/react-loadable/-/react-loadable-6.0.0.tgz", + "integrity": "sha512-YMMxTUQV/QFSnbgrP3tjDzLHRg7vsbMn8e9HAa8o/1iXoiomo48b7sk/kkmWEuWNDPJVlKSJRB6Y2fHqdJk+SQ==", "dependencies": { - "@types/react": "*", - "prop-types": "^15.6.2" + "@types/react": "*" }, "peerDependencies": { "react": "*" @@ -12946,9 +12916,9 @@ "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==" }, "node_modules/sax": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/sax/-/sax-1.3.0.tgz", - "integrity": "sha512-0s+oAmw9zLl1V1cS9BtZN7JAd0cW5e0QH4W3LWEK6a4LaLEA2OTpGYWDY+6XasBLtz6wkm3u1xRw95mRuJ59WA==" + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/sax/-/sax-1.4.1.tgz", + "integrity": "sha512-+aWOz7yVScEGoKNd4PA10LZ8sk0A/z5+nXQG5giUO5rprX9jgYsTdov9qCchZiPIZezbZH+jRut8nPodFAX4Jg==" }, "node_modules/scheduler": { "version": "0.23.0", @@ -12977,9 +12947,9 @@ } }, "node_modules/search-insights": { - "version": "2.13.0", - "resolved": "https://registry.npmjs.org/search-insights/-/search-insights-2.13.0.tgz", - "integrity": "sha512-Orrsjf9trHHxFRuo9/rzm0KIWmgzE8RMlZMzuhZOJ01Rnz3D0YBAe+V6473t6/H6c7irs6Lt48brULAiRWb3Vw==", + "version": "2.14.0", + "resolved": "https://registry.npmjs.org/search-insights/-/search-insights-2.14.0.tgz", + "integrity": "sha512-OLN6MsPMCghDOqlCtsIsYgtsC0pnwVTyT9Mu6A3ewOj1DxvzZF6COrn2g86E/c05xbktB0XN04m/t1Z+n+fTGw==", "peer": true }, "node_modules/section-matter": { @@ -13415,9 +13385,9 @@ "integrity": "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==" }, "node_modules/sitemap": { - "version": "7.1.1", - "resolved": "https://registry.npmjs.org/sitemap/-/sitemap-7.1.1.tgz", - "integrity": "sha512-mK3aFtjz4VdJN0igpIJrinf3EO8U8mxOPsTBzSsy06UtjZQJ3YY3o3Xa7zSc5nMqcMrRwlChHZ18Kxg0caiPBg==", + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/sitemap/-/sitemap-7.1.2.tgz", + "integrity": "sha512-ARCqzHJ0p4gWt+j7NlU5eDlIO9+Rkr/JhPFZKKQ1l5GCus7rJH4UdrlVAh0xC/gDS/Qir2UMxqYNHtsKr2rpCw==", "dependencies": { "@types/node": "^17.0.5", "@types/sax": "^1.2.1", @@ -13456,6 +13426,15 @@ "node": ">=8" } }, + "node_modules/snake-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/snake-case/-/snake-case-3.0.4.tgz", + "integrity": "sha512-LAOh4z89bGQvl9pFfNF8V146i7o7/CqFPbqzYgP+yYzDIDeS9HaNFtXABamRW+AQzEVODcvE79ljJ+8a9YSdMg==", + "dependencies": { + "dot-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, "node_modules/sockjs": { "version": "0.3.24", "resolved": "https://registry.npmjs.org/sockjs/-/sockjs-0.3.24.tgz", @@ -13467,9 +13446,9 @@ } }, "node_modules/sort-css-media-queries": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/sort-css-media-queries/-/sort-css-media-queries-2.1.0.tgz", - "integrity": "sha512-IeWvo8NkNiY2vVYdPa27MCQiR0MN0M80johAYFVxWWXQ44KU84WNxjslwBHmc/7ZL2ccwkM7/e6S5aiKZXm7jA==", + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/sort-css-media-queries/-/sort-css-media-queries-2.2.0.tgz", + "integrity": "sha512-0xtkGhWCC9MGt/EzgnvbbbKhqWjl1+/rncmhTh5qCpbYguXh6S/qwePfv/JQ8jePXXmqingylxoC49pCkSPIbA==", "engines": { "node": ">= 6.3.0" } @@ -13483,9 +13462,9 @@ } }, "node_modules/source-map-js": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.0.2.tgz", - "integrity": "sha512-R0XvVJ9WusLiqTCEiGCmICCMplcCkIwwR11mOSD9CR5u+IXYdiseeEuXCVAjS54zqwkLcPNnmU4OeJ6tUrWhDw==", + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.0.tgz", + "integrity": "sha512-itJW8lvSA0TXEphiRoawsCksnlf8SyvmFzIhltqAHluXd88pkCd+cXJVHTDwdCr0IzwptSm035IHQktUu1QUMg==", "engines": { "node": ">=0.10.0" } @@ -13560,12 +13539,6 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/stable": { - "version": "0.1.8", - "resolved": "https://registry.npmjs.org/stable/-/stable-0.1.8.tgz", - "integrity": "sha512-ji9qxRnOVfcuLDySj9qzhGSEFVobyt1kIOSkj1qZzYLzq7Tos/oUUWvotUPQLlrsidqsK6tBH89Bc9kL5zHA6w==", - "deprecated": "Modern JS already guarantees Array#sort() is a stable sort, so this library is deprecated. See the compatibility table on MDN: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#browser_compatibility" - }, "node_modules/statuses": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz", @@ -13710,18 +13683,18 @@ } }, "node_modules/stylehacks": { - "version": "5.1.1", - "resolved": "https://registry.npmjs.org/stylehacks/-/stylehacks-5.1.1.tgz", - "integrity": "sha512-sBpcd5Hx7G6seo7b1LkpttvTz7ikD0LlH5RmdcBNb6fFR0Fl7LQwHDFr300q4cwUqi+IYrFGmsIHieMBfnN/Bw==", + "version": "6.1.1", + "resolved": "https://registry.npmjs.org/stylehacks/-/stylehacks-6.1.1.tgz", + "integrity": "sha512-gSTTEQ670cJNoaeIp9KX6lZmm8LJ3jPB5yJmX8Zq/wQxOsAFXV3qjWzHas3YYk1qesuVIyYWWUpZ0vSE/dTSGg==", "dependencies": { - "browserslist": "^4.21.4", - "postcss-selector-parser": "^6.0.4" + "browserslist": "^4.23.0", + "postcss-selector-parser": "^6.0.16" }, "engines": { - "node": "^10 || ^12 || >=14.0" + "node": "^14 || ^16 || >=18.0" }, "peerDependencies": { - "postcss": "^8.2.15" + "postcss": "^8.4.31" } }, "node_modules/supports-color": { @@ -13752,23 +13725,27 @@ "integrity": "sha512-e4hG1hRwoOdRb37cIMSgzNsxyzKfayW6VOflrwvR+/bzrkyxY/31WkbgnQpgtrNp1SdpJvpUAGTa/ZoiPNDuRQ==" }, "node_modules/svgo": { - "version": "2.8.0", - "resolved": "https://registry.npmjs.org/svgo/-/svgo-2.8.0.tgz", - "integrity": "sha512-+N/Q9kV1+F+UeWYoSiULYo4xYSDQlTgb+ayMobAXPwMnLvop7oxKMo9OzIrX5x3eS4L4f2UHhc9axXwY8DpChg==", + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/svgo/-/svgo-3.3.2.tgz", + "integrity": "sha512-OoohrmuUlBs8B8o6MB2Aevn+pRIH9zDALSR+6hhqVfa6fRwG/Qw9VUMSMW9VNg2CFc/MTIfabtdOVl9ODIJjpw==", "dependencies": { "@trysound/sax": "0.2.0", "commander": "^7.2.0", - "css-select": "^4.1.3", - "css-tree": "^1.1.3", - "csso": "^4.2.0", - "picocolors": "^1.0.0", - "stable": "^0.1.8" + "css-select": "^5.1.0", + "css-tree": "^2.3.1", + "css-what": "^6.1.0", + "csso": "^5.0.5", + "picocolors": "^1.0.0" }, "bin": { "svgo": "bin/svgo" }, "engines": { - "node": ">=10.13.0" + "node": ">=14.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/svgo" } }, "node_modules/svgo/node_modules/commander": { @@ -13779,69 +13756,6 @@ "node": ">= 10" } }, - "node_modules/svgo/node_modules/css-select": { - "version": "4.3.0", - "resolved": "https://registry.npmjs.org/css-select/-/css-select-4.3.0.tgz", - "integrity": "sha512-wPpOYtnsVontu2mODhA19JrqWxNsfdatRKd64kmpRbQgh1KtItko5sTnEpPdpSaJszTOhEMlF/RPz28qj4HqhQ==", - "dependencies": { - "boolbase": "^1.0.0", - "css-what": "^6.0.1", - "domhandler": "^4.3.1", - "domutils": "^2.8.0", - "nth-check": "^2.0.1" - }, - "funding": { - "url": "https://github.com/sponsors/fb55" - } - }, - "node_modules/svgo/node_modules/dom-serializer": { - "version": "1.4.1", - "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-1.4.1.tgz", - "integrity": "sha512-VHwB3KfrcOOkelEG2ZOfxqLZdfkil8PtJi4P8N2MMXucZq2yLp75ClViUlOVwyoHEDjYU433Aq+5zWP61+RGag==", - "dependencies": { - "domelementtype": "^2.0.1", - "domhandler": "^4.2.0", - "entities": "^2.0.0" - }, - "funding": { - "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1" - } - }, - "node_modules/svgo/node_modules/domhandler": { - "version": "4.3.1", - "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-4.3.1.tgz", - "integrity": "sha512-GrwoxYN+uWlzO8uhUXRl0P+kHE4GtVPfYzVLcUxPL7KNdHKj66vvlhiweIHqYYXWlw+T8iLMp42Lm67ghw4WMQ==", - "dependencies": { - "domelementtype": "^2.2.0" - }, - "engines": { - "node": ">= 4" - }, - "funding": { - "url": "https://github.com/fb55/domhandler?sponsor=1" - } - }, - "node_modules/svgo/node_modules/domutils": { - "version": "2.8.0", - "resolved": "https://registry.npmjs.org/domutils/-/domutils-2.8.0.tgz", - "integrity": "sha512-w96Cjofp72M5IIhpjgobBimYEfoPjx1Vx0BSX9P30WBdZW2WIKU0T1Bd0kz2eNZ9ikjKgHbEyKx8BB6H1L3h3A==", - "dependencies": { - "dom-serializer": "^1.0.1", - "domelementtype": "^2.2.0", - "domhandler": "^4.2.0" - }, - "funding": { - "url": "https://github.com/fb55/domutils?sponsor=1" - } - }, - "node_modules/svgo/node_modules/entities": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/entities/-/entities-2.2.0.tgz", - "integrity": "sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==", - "funding": { - "url": "https://github.com/fb55/entities?sponsor=1" - } - }, "node_modules/tapable": { "version": "2.2.1", "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.2.1.tgz", diff --git a/package.json b/package.json index 4ae16876..f3601870 100644 --- a/package.json +++ b/package.json @@ -14,9 +14,9 @@ "write-heading-ids": "docusaurus write-heading-ids" }, "dependencies": { - "@docusaurus/core": "^3.2.1", - "@docusaurus/plugin-ideal-image": "^3.2.1", - "@docusaurus/preset-classic": "^3.2.1", + "@docusaurus/core": "^3.4.0", + "@docusaurus/plugin-ideal-image": "^3.4.0", + "@docusaurus/preset-classic": "^3.4.0", "@mdx-js/react": "^3.0.0", "clsx": "^1.2.1", "prism-react-renderer": "^2.1.0", @@ -24,8 +24,8 @@ "react-dom": "^18.0.0" }, "devDependencies": { - "@docusaurus/module-type-aliases": "^3.2.1", - "@docusaurus/types": "^3.2.1" + "@docusaurus/module-type-aliases": "^3.4.0", + "@docusaurus/types": "^3.4.0" }, "browserslist": { "production": [ diff --git a/sidebars-ez-gui.js b/sidebars-ez-gui.js deleted file mode 100644 index fd342f2c..00000000 --- a/sidebars-ez-gui.js +++ /dev/null @@ -1,31 +0,0 @@ -/** - * Creating a sidebar enables you to: - - create an ordered group of docs - - render a sidebar for each doc of that group - - provide next/previous navigation - - The sidebars can be generated from the filesystem, or explicitly defined here. - - Create as many sidebars as you want. - */ - -// @ts-check - -/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */ -const sidebars = { - // By default, Docusaurus generates a sidebar from the docs folder structure - tutorialSidebar: [{type: 'autogenerated', dirName: '.'}], - - // But you can create a sidebar manually - /* - tutorialSidebar: [ - { - type: 'category', - label: 'Tutorial', - items: ['hello'], - }, - ], - */ -}; - -module.exports = sidebars; diff --git a/sidebars.js b/sidebars.js index 76d9971a..47dd7918 100644 --- a/sidebars.js +++ b/sidebars.js @@ -24,17 +24,96 @@ const sidebars = { collapsed: false, collapsible: true, items: [ - 'tutorials/installation', - 'tutorials/using_auton_selector', - 'tutorials/autons', - 'tutorials/example_autons', - 'tutorials/tuning_constants', - 'tutorials/joystick_curve', - 'tutorials/activebrake', - 'tutorials/practice_mode', + + // Getting Started + { + type: 'category', + label: 'Getting Started', + link: { + type: 'generated-index', + }, + collapsed: false, + collapsible: true, + items: [ + 'tutorials/installation', + 'tutorials/upgrading', + 'tutorials/using_auton_selector', + 'tutorials/autons', + 'tutorials/example_autons', + 'tutorials/intake_control' + ], + }, + + // User Control + { + type: 'category', + label: 'User Control', + link: { + type: 'generated-index', + }, + collapsed: true, + collapsible: true, + items: [ + 'tutorials/control_schemes', + 'tutorials/joystick_curve', + 'tutorials/activebrake', + 'tutorials/practice_mode', + ], + }, + + + // Tuning Constants + { + type: 'category', + label: 'Tuning Constants', + link: { + type: 'generated-index', + }, + collapsed: true, + collapsible: true, + items: [ + 'tutorials/slew_constants', + 'tutorials/tuning_constants', + 'tutorials/tuning_exit_conditions', + // gain scheduling? + ], + }, + + /* + // Using EZ PID + { + type: 'category', + label: 'Using EZ PID', + link: { + type: 'generated-index', + }, + collapsed: true, + collapsible: true, + items: [ + 'tutorials/pid', // this needs to get broken up + ], + }, + + // Using a PTO + { + type: 'category', + label: 'Using a PTO', + link: { + type: 'generated-index', + }, + collapsed: true, + collapsible: true, + items: [ + 'tutorials/pto_tutorial', + ], + }, + */ + + // Remove these when above is uncommented 'tutorials/pid', 'tutorials/pto_tutorial', ], + }, { type: 'category', @@ -42,7 +121,7 @@ const sidebars = { link: { type: 'generated-index', }, - collapsed: false, + collapsed: true, collapsible: true, items: [ 'docs/constructor', @@ -56,9 +135,25 @@ const sidebars = { 'docs/slew', 'docs/piston', 'docs/util', + 'migration', + ], + }, + /* + { + type: 'category', + label: 'Community', + link: { + type: 'generated-index', + }, + collapsed: true, + collapsible: true, + items: [ + 'support', + 'showcase', ], }, - 'migration', + */ + ], }; export default sidebars; \ No newline at end of file diff --git a/src/pages/versions.md b/src/pages/versions.md index 0dadc9da..7aa7cb14 100644 --- a/src/pages/versions.md +++ b/src/pages/versions.md @@ -3,6 +3,9 @@ title: versions --- # 3.x +#### [v3.1.0](https://github.com/EZ-Robotics/EZ-Template/releases/tag/v3.1.0) +#### [v3.1.0-RC3](https://github.com/EZ-Robotics/EZ-Template/releases/tag/v3.1.0-RC3) +#### [v3.1.0-RC2](https://github.com/EZ-Robotics/EZ-Template/releases/tag/v3.1.0-RC2) #### [v3.0.1](https://github.com/EZ-Robotics/EZ-Template/releases/tag/v3.0.1) #### [v3.0.0](https://github.com/EZ-Robotics/EZ-Template/releases/tag/v3.0.0) #### [v3.0.0-RC1](https://github.com/EZ-Robotics/EZ-Template/releases/tag/v3.0.0-RC1) diff --git a/versioned_docs/version-2.x/docs/auton_selector.md b/versioned_docs/version-2.x/docs/auton_selector.md index 19de015a..29461f9c 100644 --- a/versioned_docs/version-2.x/docs/auton_selector.md +++ b/versioned_docs/version-2.x/docs/auton_selector.md @@ -65,8 +65,8 @@ Sets external buttons to increase/decrease the current autonomous page. ```cpp -pros::ADIDigitalIn increase('A'); -pros::ADIDigitalIn decrease('B'); +pros::adi::DigitalIn increase('A'); +pros::adi::DigitalIn decrease('B'); void initialize() { ez::as::initialize(); ez::as::limit_switch_lcd_initialize(&increase, &decrease); @@ -81,7 +81,7 @@ void initialize() { ```cpp -void limit_switch_lcd_initialize(pros::ADIDigitalIn* right_limit, pros::ADIDigitalIn* left_limit = nullptr); +void limit_switch_lcd_initialize(pros::adi::DigitalIn* right_limit, pros::adi::DigitalIn* left_limit = nullptr); ``` diff --git a/versioned_docs/version-2.x/tutorials/pto_tutorial.md b/versioned_docs/version-2.x/tutorials/pto_tutorial.md index 29a0a1bd..4c579f92 100644 --- a/versioned_docs/version-2.x/tutorials/pto_tutorial.md +++ b/versioned_docs/version-2.x/tutorials/pto_tutorial.md @@ -18,7 +18,7 @@ using namespace ez; #define LEFT_INTAKE 3 #define RIGHT_INTAKE 3 -pros::ADIDigitalOut pto_intake_piston('A'); +pros::adi::DigitalOut pto_intake_piston('A'); bool pto_intake_enabled = false; void pto_toggle_intake(bool toggle) {