diff --git a/app/lint-baseline.xml b/app/lint-baseline.xml index 7ed167d8d5..6182bd1cd4 100644 --- a/app/lint-baseline.xml +++ b/app/lint-baseline.xml @@ -1,5 +1,12 @@ - + + + + + @@ -47,73 +54,18 @@ - - - - - - - - - - - - - - - - - - - - + message="A newer version of androidx.test:runner than 1.5.0 is available: 1.5.2" + errorLine1="androidx-test = "1.5.0"" + errorLine2=" ~~~~~~~"> + line="17" + column="17"/> + + + + - - - - - - - - - - - - - - - - @@ -1373,193 +1292,6 @@ column="27"/> - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -4559,17 +4291,6 @@ column="1"/> - - - - @@ -8621,7 +8342,7 @@ errorLine2=" ~~~~~~~~~~~~"> @@ -8632,7 +8353,7 @@ errorLine2=" ~~~~~~~~~~~~~~"> @@ -8643,7 +8364,7 @@ errorLine2=" ~~~~~~~~~~~~~~~~~~~~~~~~~~~"> @@ -8654,7 +8375,7 @@ errorLine2=" ~~~~~~~~~~~~~~~~~~"> @@ -8665,7 +8386,7 @@ errorLine2=" ~~~~~~~~~~~~~~~~~~"> @@ -8676,7 +8397,7 @@ errorLine2=" ~~~~~~~~~~~~~"> @@ -8687,7 +8408,7 @@ errorLine2=" ~~~~~~~~~~~~~"> @@ -8698,7 +8419,7 @@ errorLine2=" ~~~~~~~~~~~~~~~~~~~~~~~"> @@ -8709,7 +8430,7 @@ errorLine2=" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"> @@ -8720,7 +8441,7 @@ errorLine2=" ~~~~~~~~~~~~~~~~~~~~~"> @@ -8731,7 +8452,7 @@ errorLine2=" ~~~~~~~~~~~~~~~~~~~~"> @@ -8742,7 +8463,7 @@ errorLine2=" ~~~~~~~~~~~~~~~~~~~"> @@ -8753,7 +8474,7 @@ errorLine2=" ~~~~~~~~~~~~~~~~~~"> @@ -8764,7 +8485,7 @@ errorLine2=" ~~~~~~~~~~~~~~~~~~~"> @@ -8775,7 +8496,7 @@ errorLine2=" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"> @@ -8786,7 +8507,7 @@ errorLine2=" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"> @@ -8797,7 +8518,7 @@ errorLine2=" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"> @@ -8808,7 +8529,7 @@ errorLine2=" ~~~~~~~~~~~~~~~~~~~~"> @@ -8819,7 +8540,7 @@ errorLine2=" ~~~~~~~~~~~~~~~~~~~~~~~~"> @@ -8830,7 +8551,7 @@ errorLine2=" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"> @@ -8841,7 +8562,7 @@ errorLine2=" ~~~~~~~~~~~~~~~~~~~~~"> @@ -8852,7 +8573,7 @@ errorLine2=" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"> @@ -8863,7 +8584,7 @@ errorLine2=" ~~~~~~~~~~~~~~~~~~~"> @@ -8874,7 +8595,7 @@ errorLine2=" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~"> @@ -8901,47 +8622,25 @@ - - - - - - - - + id="TypographyEllipsis" + message="Replace "..." with ellipsis character (…, &#8230;) ?" + errorLine1=" <string name="exporting_data_description">Proszę czekać, eksportuję dane...</string>" + errorLine2=" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"> + file="src/main/res/values-pl/strings.xml" + line="261" + column="47"/> + id="TypographyEllipsis" + message="Replace "..." with ellipsis character (…, &#8230;) ?" + errorLine1=" <string name="generating_report">Generowanie raportu...</string>" + errorLine2=" ~~~~~~~~~~~~~~~~~~~~~~"> + file="src/main/res/values-pl/strings.xml" + line="432" + column="38"/> - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + message="Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [, id: UUID = UUID.randomUUID(), keyword: String, visible: Boolean, dismiss: () -> Unit, onKeywordChanged: (String) -> Unit] but should be [, keyword: String, visible: Boolean, dismiss: () -> Unit, id: UUID = UUID.randomUUID(), onKeywordChanged: (String) -> Unit]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun BoxWithConstraintsScope.AddKeywordModal(" + errorLine2=" ^"> + line="31" + column="44"/> + errorLine1="fun AmountKeyboard(" + errorLine2=" ^"> + line="300" + column="19"/> + message="Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [, bottomInset: Dp = navigationBarInset().toDensityDp(), onBack: () -> Unit, PrimaryAction: @Composable () -> Unit] but should be [, onBack: () -> Unit, bottomInset: Dp = navigationBarInset().toDensityDp(), PrimaryAction: @Composable () -> Unit]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun BoxWithConstraintsScope.BackBottomBar(" + errorLine2=" ^"> + line="22" + column="42"/> + message="Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [modifier: Modifier = Modifier, currency: String, expenses: Double, budget: Double, backgroundNotFilled: Color = UI.colors.pure, onClick: (() -> Unit)? = null] but should be [currency: String, expenses: Double, budget: Double, modifier: Modifier = Modifier, backgroundNotFilled: Color = UI.colors.pure, onClick: (() -> Unit)? = null]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun BudgetBattery(" + errorLine2=" ^"> + file="src/main/java/com/ivy/legacy/legacy/ui/theme/components/BudgetBattery.kt" + line="42" + column="18"/> + message="Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [modifier: Modifier = Modifier, buffer: Double, balance: Double, currency: String, backgroundNotFilled: Color = UI.colors.pure, onClick: (() -> Unit)? = null] but should be [buffer: Double, balance: Double, currency: String, modifier: Modifier = Modifier, backgroundNotFilled: Color = UI.colors.pure, onClick: (() -> Unit)? = null]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun BufferBattery(" + errorLine2=" ^"> + file="src/main/java/com/ivy/legacy/legacy/ui/theme/components/BufferBattery.kt" + line="40" + column="18"/> + message=" Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [modifier: Modifier = Modifier, text: String, background: Background = Background.Solid( color = UI.colors.primary, shape = UI.shapes.rFull, padding = padding( horizontal = 24.dp, vertical = 12.dp ) ), textStyle: TextStyle = UI.typo.b2.style( color = White, textAlign = TextAlign.Center ), onClick: () -> Unit] but should be [text: String, modifier: Modifier = Modifier, background: Background = Background.Solid( color = UI.colors.primary, shape = UI.shapes.rFull, padding = padding( horizontal = 24.dp, vertical = 12.dp ) ), textStyle: TextStyle = UI.typo.b2.style( color = White, textAlign = TextAlign.Center ), onClick: () -> Unit]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun Button(" + errorLine2=" ^"> - - - - - - - - - - - - - - - - + file="src/main/java/com/ivy/design/l2_components/Button.kt" + line="25" + column="11"/> + errorLine1="fun Button(" + errorLine2=" ^"> + line="34" + column="11"/> + message="Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [, id: UUID = UUID.randomUUID(), initialAmount: Double?, visible: Boolean, currency: String, dismiss: () -> Unit, onCalculation: (Double) -> Unit] but should be [, initialAmount: Double?, visible: Boolean, currency: String, dismiss: () -> Unit, id: UUID = UUID.randomUUID(), onCalculation: (Double) -> Unit]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun BoxWithConstraintsScope.CalculatorModal(" + errorLine2=" ^"> - - - - - - - - + line="41" + column="44"/> + message="Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [, title: String = stringResource(R.string.set_transaction_type), visible: Boolean, includeTransferType: Boolean, initialType: TransactionType, id: UUID = UUID.randomUUID(), dismiss: () -> Unit, onTransactionTypeChanged: (TransactionType) -> Unit] but should be [, visible: Boolean, includeTransferType: Boolean, initialType: TransactionType, dismiss: () -> Unit, title: String = stringResource(R.string.set_transaction_type), id: UUID = UUID.randomUUID(), onTransactionTypeChanged: (TransactionType) -> Unit]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun BoxWithConstraintsScope.ChangeTransactionTypeModal(" + errorLine2=" ^"> + line="44" + column="55"/> + errorLine1="fun Checkbox(" + errorLine2=" ^"> + line="29" + column="13"/> + errorLine1="fun CheckboxWithText(" + errorLine2=" ^"> + line="51" + column="21"/> + message="Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [, id: UUID = UUID.randomUUID(), visible: Boolean, initialCategory: Category?, categories: List<Category>, showCategoryModal: (Category?) -> Unit, onCategoryChanged: (Category?) -> Unit, dismiss: () -> Unit] but should be [, visible: Boolean, initialCategory: Category?, categories: List<Category>, showCategoryModal: (Category?) -> Unit, onCategoryChanged: (Category?) -> Unit, id: UUID = UUID.randomUUID(), dismiss: () -> Unit]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun BoxWithConstraintsScope.ChooseCategoryModal(" + errorLine2=" ^"> + line="58" + column="48"/> + message="Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [, visible: Boolean, initialIcon: String?, color: Color, id: UUID = UUID.randomUUID(), dismiss: () -> Unit, onIconChosen: (String?) -> Unit] but should be [, visible: Boolean, initialIcon: String?, color: Color, dismiss: () -> Unit, id: UUID = UUID.randomUUID(), onIconChosen: (String?) -> Unit]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun BoxWithConstraintsScope.ChooseIconModal(" + errorLine2=" ^"> + line="51" + column="44"/> + errorLine1="private fun MonthButton(" + errorLine2=" ^"> + line="252" + column="24"/> + message="Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [, id: UUID = UUID.randomUUID(), visible: Boolean, selectedStartDateOfMonth: Int, dismiss: () -> Unit, onStartDateOfMonthSelected: (Int) -> Unit] but should be [, visible: Boolean, selectedStartDateOfMonth: Int, dismiss: () -> Unit, id: UUID = UUID.randomUUID(), onStartDateOfMonthSelected: (Int) -> Unit]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun BoxWithConstraintsScope.ChooseStartDateOfMonthModal(" + errorLine2=" ^"> + line="36" + column="56"/> + errorLine1="fun CircleButton(" + errorLine2=" ^"> + line="39" + column="17"/> + errorLine1="fun CircleButtonFilled(" + errorLine2=" ^"> + line="63" + column="23"/> + errorLine1="fun CircleButtonFilledGradient(" + errorLine2=" ^"> + line="86" + column="31"/> + errorLine1="fun CurrencyPicker(" + errorLine2=" ^"> + line="66" + column="19"/> + errorLine1="fun CustomExchangeRateCard(" + errorLine2=" ^"> + line="31" + column="27"/> + message="Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [, id: UUID = UUID.randomUUID(), title: String, description: String, visible: Boolean, buttonText: String = stringResource(R.string.delete), iconStart: Int = R.drawable.ic_delete, dismiss: () -> Unit, onDelete: () -> Unit] but should be [, title: String, description: String, visible: Boolean, dismiss: () -> Unit, id: UUID = UUID.randomUUID(), buttonText: String = stringResource(R.string.delete), iconStart: Int = R.drawable.ic_delete, onDelete: () -> Unit]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun BoxWithConstraintsScope.DeleteModal(" + errorLine2=" ^"> + line="34" + column="40"/> + message="Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [, id: UUID = UUID.randomUUID(), title: String, description: String, accountName: TextFieldValue, hint: String = stringResource(id = R.string.account_name), visible: Boolean, enableDeletionButton: Boolean, buttonText: String = stringResource(R.string.delete), iconStart: Int = R.drawable.ic_delete, onAccountNameChange: (String) -> Unit, dismiss: () -> Unit, onDelete: () -> Unit] but should be [, title: String, description: String, accountName: TextFieldValue, visible: Boolean, enableDeletionButton: Boolean, onAccountNameChange: (String) -> Unit, dismiss: () -> Unit, id: UUID = UUID.randomUUID(), hint: String = stringResource(id = R.string.account_name), buttonText: String = stringResource(R.string.delete), iconStart: Int = R.drawable.ic_delete, onDelete: () -> Unit]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun BoxWithConstraintsScope.DeleteConfirmationModal(" + errorLine2=" ^"> + line="84" + column="52"/> + message="Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [, id: UUID = UUID.randomUUID(), visible: Boolean, description: String?, onDescriptionChanged: (String?) -> Unit, dismiss: () -> Unit] but should be [, visible: Boolean, description: String?, onDescriptionChanged: (String?) -> Unit, id: UUID = UUID.randomUUID(), dismiss: () -> Unit]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun BoxWithConstraintsScope.DescriptionModal(" + errorLine2=" ^"> - - - - - - - - - - - - - - - - - - - - + line="44" + column="45"/> + errorLine1="private fun TypeFilterCheckbox(" + errorLine2=" ^"> + line="409" + column="31"/> + errorLine1="fun IconButton(" + errorLine2=" ^"> + line="23" + column="15"/> + errorLine1="fun InstructionButton(" + errorLine2=" ^"> + line="201" + column="22"/> + errorLine1="fun ItemIconL(" + errorLine2=" ^"> + line="25" + column="14"/> + errorLine1="fun ItemIconMDefaultIcon(" + errorLine2=" ^"> + line="45" + column="25"/> + errorLine1="fun ItemIconM(" + errorLine2=" ^"> + line="68" + column="14"/> + errorLine1="fun ItemIconSDefaultIcon(" + errorLine2=" ^"> + line="88" + column="25"/> + errorLine1="fun ItemIconS(" + errorLine2=" ^"> + line="111" + column="14"/> + errorLine1="private fun ItemIcon(" + errorLine2=" ^"> + line="131" + column="21"/> + errorLine1="fun IvyBasicTextField(" + errorLine2=" ^"> + line="32" + column="22"/> + errorLine1="fun IvyBorderButton(" + errorLine2=" ^"> + line="32" + column="20"/> + errorLine1="fun IvyButton(" + errorLine2=" ^"> + line="39" + column="14"/> + errorLine1="fun IvyCheckbox(" + errorLine2=" ^"> + line="30" + column="16"/> + errorLine1="fun IvyCheckboxWithText(" + errorLine2=" ^"> + line="54" + column="24"/> + errorLine1="fun IvyChecklistTextField(" + errorLine2=" ^"> + line="38" + column="26"/> + errorLine1="fun IvyCircleButton(" + errorLine2=" ^"> + line="27" + column="20"/> + errorLine1="fun IvyDescriptionTextField(" + errorLine2=" ^"> + line="34" + column="28"/> + errorLine1="fun IvyIcon(" + errorLine2=" ^"> + line="13" + column="12"/> + errorLine1="fun IvyIcon(" + errorLine2=" ^"> + line="22" + column="12"/> + errorLine1="fun IvyIconScaled(" + errorLine2=" ^"> + line="38" + column="18"/> + errorLine1="fun IvyLineChart(" + errorLine2=" ^"> + line="290" + column="17"/> + message="Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [, id: UUID?, visible: Boolean, dismiss: () -> Unit, SecondaryActions: (@Composable () -> Unit)? = null, PrimaryAction: @Composable () -> Unit, scrollState: ScrollState? = rememberScrollState(), shiftIfKeyboardShown: Boolean = true, includeActionsRowPadding: Boolean = true, Content: @Composable ColumnScope.() -> Unit] but should be [, id: UUID?, visible: Boolean, dismiss: () -> Unit, PrimaryAction: @Composable () -> Unit, SecondaryActions: (@Composable () -> Unit)? = null, scrollState: ScrollState? = rememberScrollState(), shiftIfKeyboardShown: Boolean = true, includeActionsRowPadding: Boolean = true, Content: @Composable ColumnScope.() -> Unit]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun BoxScope.IvyModal(" + errorLine2=" ^"> + line="71" + column="22"/> + errorLine1="fun ModalDynamicPrimaryAction(" + errorLine2=" ^"> + line="25" + column="30"/> + errorLine1="fun ModalCheck(" + errorLine2=" ^"> + line="83" + column="15"/> + errorLine1="fun ModalPositiveButton(" + errorLine2=" ^"> + line="169" + column="24"/> + errorLine1="fun IvyNameTextField(" + errorLine2=" ^"> + line="40" + column="21"/> + errorLine1="fun IvyNumberTextField(" + errorLine2=" ^"> + line="31" + column="23"/> + errorLine1="fun IvyOutlinedButton(" + errorLine2=" ^"> + line="33" + column="22"/> + errorLine1="fun IvyOutlinedButtonFillMaxWidth(" + errorLine2=" ^"> + line="88" + column="34"/> + errorLine1="fun IvyOutlinedTextField(" + errorLine2=" ^"> + line="35" + column="25"/> + errorLine1="fun IvySwitch(" + errorLine2=" ^"> + line="24" + column="14"/> + errorLine1="fun IvyText(" + errorLine2=" ^"> + line="13" + column="12"/> + message=" Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [, modifier: Modifier = Modifier, dividerModifier: Modifier = Modifier, value: TextFieldValue, textColor: Color = UI.colors.pureInverse, hint: String?, visualTransformation: VisualTransformation = VisualTransformation.None, keyboardOptions: KeyboardOptions = KeyboardOptions( autoCorrect = true, keyboardType = KeyboardType.Text, imeAction = ImeAction.Done, capitalization = KeyboardCapitalization.Sentences ), keyboardActions: KeyboardActions? = null, onValueChanged: (TextFieldValue) -> Unit] but should be [, value: TextFieldValue, hint: String?, modifier: Modifier = Modifier, dividerModifier: Modifier = Modifier, textColor: Color = UI.colors.pureInverse, visualTransformation: VisualTransformation = VisualTransformation.None, keyboardOptions: KeyboardOptions = KeyboardOptions( autoCorrect = true, keyboardType = KeyboardType.Text, imeAction = ImeAction.Done, capitalization = KeyboardCapitalization.Sentences ), keyboardActions: KeyboardActions? = null, onValueChanged: (TextFieldValue) -> Unit]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun ColumnScope.IvyTitleTextField(" + errorLine2=" ^"> - - - - + line="40" + column="34"/> + errorLine1="private fun Header(" + errorLine2=" ^"> + line="234" + column="19"/> + message="Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [, accounts: List<Account> = emptyList(), onCreateAccount: (CreateAccountData) -> Unit = {}, modal: LoanModalData?, onCreateLoan: (CreateLoanData) -> Unit, onEditLoan: (Loan, Boolean) -> Unit, onPerformCalculations: () -> Unit = {}, dismiss: () -> Unit] but should be [, modal: LoanModalData?, onCreateLoan: (CreateLoanData) -> Unit, onEditLoan: (Loan, Boolean) -> Unit, accounts: List<Account> = emptyList(), onCreateAccount: (CreateAccountData) -> Unit = {}, onPerformCalculations: () -> Unit = {}, dismiss: () -> Unit]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun BoxWithConstraintsScope.LoanModal(" + errorLine2=" ^"> + line="86" + column="38"/> + errorLine1="private fun AccountsRow(" + errorLine2=" ^"> + line="352" + column="24"/> + message="Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [, modal: LoanRecordModalData?, accounts: List<Account> = emptyList(), onCreateAccount: (CreateAccountData) -> Unit = {}, onCreate: (CreateLoanRecordData) -> Unit, onEdit: (EditLoanRecordData) -> Unit, onDelete: (LoanRecord) -> Unit, dismiss: () -> Unit] but should be [, modal: LoanRecordModalData?, onCreate: (CreateLoanRecordData) -> Unit, onEdit: (EditLoanRecordData) -> Unit, onDelete: (LoanRecord) -> Unit, accounts: List<Account> = emptyList(), onCreateAccount: (CreateAccountData) -> Unit = {}, dismiss: () -> Unit]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun BoxWithConstraintsScope.LoanRecordModal(" + errorLine2=" ^"> + line="74" + column="44"/> + errorLine1="private fun AccountsRow(" + errorLine2=" ^"> - - - - + line="399" + column="24"/> + message="Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [, id: UUID = UUID.randomUUID(), initialDate: LocalDate, visible: Boolean, dismiss: () -> Unit, onMonthSelected: (Int) -> Unit] but should be [, initialDate: LocalDate, visible: Boolean, dismiss: () -> Unit, id: UUID = UUID.randomUUID(), onMonthSelected: (Int) -> Unit]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun BoxWithConstraintsScope.MonthPickerModal(" + errorLine2=" ^"> + line="42" + column="45"/> + errorLine1="fun OnboardingButton(" + errorLine2=" ^"> + line="33" + column="21"/> + errorLine1="fun OnboardingProgressSlider(" + errorLine2=" ^"> + line="17" + column="29"/> + errorLine1="fun PeriodSelector(" + errorLine2=" ^"> + line="34" + column="19"/> + message="Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [, bottomInset: Dp = navigationBarInset().toDensityDp(), onClose: () -> Unit, onAdd: () -> Unit] but should be [, onClose: () -> Unit, bottomInset: Dp = navigationBarInset().toDensityDp(), onAdd: () -> Unit]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun BoxWithConstraintsScope.PlannedPaymentsBottomBar(" + errorLine2=" ^"> + file="src/main/java/com/ivy/planned/list/PlannedPaymentsBottomBar.kt" + line="26" + column="53"/> + message="Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [theme: Theme = Theme.LIGHT, design: IvyDesign, Content: @Composable BoxWithConstraintsScope.() -> Unit] but should be [design: IvyDesign, theme: Theme = Theme.LIGHT, Content: @Composable BoxWithConstraintsScope.() -> Unit]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun IvyPreview(" + errorLine2=" ^"> + file="src/main/java/com/ivy/design/utils/Preview.kt" + line="42" + column="15"/> + message="Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [@DrawableRes icon: Int, title: String, TitleRowExtra: (@Composable RowScope.() -> Unit)? = null, onClick: () -> Unit, Content: @Composable ColumnScope.() -> Unit] but should be [@DrawableRes icon: Int, title: String, onClick: () -> Unit, TitleRowExtra: (@Composable RowScope.() -> Unit)? = null, Content: @Composable ColumnScope.() -> Unit]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun PrimaryAttributeColumn(" + errorLine2=" ^"> + file="src/main/java/com/ivy/legacy/ui/component/edit/PrimaryAttributeColumn.kt" + line="33" + column="27"/> + message="Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [modifier: Modifier = Modifier, notFilledColor: Color = UI.colors.pure, positiveProgress: Boolean = true, percent: Double] but should be [percent: Double, modifier: Modifier = Modifier, notFilledColor: Color = UI.colors.pure, positiveProgress: Boolean = true]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun ProgressBar(" + errorLine2=" ^"> + file="src/main/java/com/ivy/legacy/legacy/ui/theme/components/ProgressBar.kt" + line="21" + column="16"/> + message="Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [, id: UUID = UUID.randomUUID(), title: String, description: String, visible: Boolean, color: Color = UI.colors.orange, dismiss: () -> Unit = {}] but should be [, title: String, description: String, visible: Boolean, id: UUID = UUID.randomUUID(), color: Color = UI.colors.orange, dismiss: () -> Unit = {}]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun BoxWithConstraintsScope.ProgressModal(" + errorLine2=" ^"> + file="src/main/java/com/ivy/legacy/legacy/ui/theme/modal/ProgressModal.kt" + line="23" + column="42"/> - - - - - - - - - - - - + message=" Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [, visible: Boolean, id: UUID = UUID.randomUUID(), TitleContent: @Composable ColumnScope.() -> Unit = { Text( modifier = Modifier.padding(start = 32.dp), text = stringResource(R.string.reorder), style = UI.typo.b1.style( UI.colors.pureInverse, FontWeight.ExtraBold ) ) }, initialItems: List<T>, dismiss: () -> Unit, onUpdateItemOrderNum: (item: T, newOrderNum: Double) -> Unit = { _, _ -> }, onReordered: ((List<T>) -> Unit)? = null, ItemContent: @Composable (Int, T) -> Unit] but should be [, visible: Boolean, initialItems: List<T>, dismiss: () -> Unit, id: UUID = UUID.randomUUID(), TitleContent: @Composable ColumnScope.() -> Unit = { Text( modifier = Modifier.padding(start = 32.dp), text = stringResource(R.string.reorder), style = UI.typo.b1.style( UI.colors.pureInverse, FontWeight.ExtraBold ) ) }, onUpdateItemOrderNum: (item: T, newOrderNum: Double) -> Unit = { _, _ -> }, onReordered: ((List<T>) -> Unit)? = null, ItemContent: @Composable (Int, T) -> Unit]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun <T : Reorderable> BoxScope.ReorderModalSingleType(" + errorLine2=" ^"> + line="39" + column="54"/> + message=" Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [, visible: Boolean, id: UUID = UUID.randomUUID(), TitleContent: @Composable ColumnScope.() -> Unit = { Text( modifier = Modifier.padding(start = 32.dp), text = stringResource(R.string.reorder), style = UI.typo.b1.style( UI.colors.pureInverse, FontWeight.ExtraBold ) ) }, initialItems: List<Any>, dismiss: () -> Unit, onUpdateItemOrderNum: ( itemsInNewOrder: List<Any>, item: T, newOrderNum: Double ) -> Unit = { _, _, _ -> }, onReordered: ((List<Any>) -> Unit)? = null, ItemContent: @Composable RowScope.(Int, Any) -> Unit] but should be [, visible: Boolean, initialItems: List<Any>, dismiss: () -> Unit, id: UUID = UUID.randomUUID(), TitleContent: @Composable ColumnScope.() -> Unit = { Text( modifier = Modifier.padding(start = 32.dp), text = stringResource(R.string.reorder), style = UI.typo.b1.style( UI.colors.pureInverse, FontWeight.ExtraBold ) ) }, onUpdateItemOrderNum: ( itemsInNewOrder: List<Any>, item: T, newOrderNum: Double ) -> Unit = { _, _, _ -> }, onReordered: ((List<Any>) -> Unit)? = null, ItemContent: @Composable RowScope.(Int, Any) -> Unit]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun <T : Reorderable> BoxScope.ReorderModal(" + errorLine2=" ^"> + line="80" + column="44"/> + errorLine1="fun ScreenTitle(" + errorLine2=" ^"> + line="48" + column="16"/> + errorLine1="fun Shape(" + errorLine2=" ^"> + line="19" + column="10"/> + errorLine1="fun ShapeOutlined(" + errorLine2=" ^"> + line="37" + column="18"/> + errorLine1="fun Switch(" + errorLine2=" ^"> + line="26" + column="11"/> + message="Parameters in a composable function should be ordered following this pattern: params without defaults, modifiers, params with defaults and optionally, a trailing function that might not have a default param. Current params are: [, type: TransactionType, titleFocus: FocusRequester, initialTransactionId: UUID?, titleTextFieldValue: TextFieldValue, setTitleTextFieldValue: (TextFieldValue) -> Unit, suggestions: Set<String>, scrollState: ScrollState? = null, onTitleChanged: (String?) -> Unit, onNext: () -> Unit] but should be [, type: TransactionType, titleFocus: FocusRequester, initialTransactionId: UUID?, titleTextFieldValue: TextFieldValue, setTitleTextFieldValue: (TextFieldValue) -> Unit, suggestions: Set<String>, onTitleChanged: (String?) -> Unit, scrollState: ScrollState? = null, onNext: () -> Unit]. See https://slackhq.github.io/compose-lints/rules/#ordering-composable-parameters-properly for more information." + errorLine1="fun ColumnScope.Title(" + errorLine2=" ^"> + line="40" + column="22"/> + errorLine1="fun <T> WrapContentRow(" + errorLine2=" ^"> + line="27" + column="23"/> @@ -12599,43 +12001,10 @@ errorLine2=" ~~~~~~~~~~"> - - - - - - - - - - - - @@ -12720,7 +12089,7 @@ errorLine2=" ~~~~~~~~~~~~~"> @@ -12731,7 +12100,7 @@ errorLine2=" ~~~~~~~~~~~~~"> @@ -12742,62 +12111,7 @@ errorLine2=" ~~~~~~~~~~~~~"> - - - - - - - - - - - - - - - - - - - - @@ -12889,28 +12203,6 @@ column="16"/> - - - - - - - - @@ -12929,7 +12221,7 @@ errorLine2=" ~~~~~~~~~~~~~"> @@ -12940,7 +12232,7 @@ errorLine2=" ~~~~~~~~~~~~~"> @@ -12951,7 +12243,7 @@ errorLine2=" ~~~~~~~~~~~~~"> @@ -13023,57 +12315,68 @@ + message="The Compose Compiler cannot infer the stability of a parameter if a List<CategoryAmount> is used in it, even if the item type is stable. You should use Kotlinx Immutable Collections instead: `categoryAmounts: ImmutableList<CategoryAmount>` or create an `@Immutable` wrapper for this class: `@Immutable data class CategoryAmountsList(val items: List<CategoryAmount>)` See https://slackhq.github.io/compose-lints/rules/#avoid-using-unstable-collections for more information." + errorLine1=" categoryAmounts: List<CategoryAmount>," + errorLine2=" ~~~~~~~~~~~~~~~~~~~~"> + file="src/main/java/com/ivy/piechart/PieChart.kt" + line="41" + column="22"/> + message="The Compose Compiler cannot infer the stability of a parameter if a List<T> is used in it, even if the item type is stable. You should use Kotlinx Immutable Collections instead: `initialItems: ImmutableList<T>` or create an `@Immutable` wrapper for this class: `@Immutable data class InitialItemsList(val items: List<T>)` See https://slackhq.github.io/compose-lints/rules/#avoid-using-unstable-collections for more information." + errorLine1=" initialItems: List<T>," + errorLine2=" ~~~~~~~"> + file="src/main/java/com/ivy/legacy/legacy/ui/theme/components/ReorderModal.kt" + line="52" + column="19"/> + message="The Compose Compiler cannot infer the stability of a parameter if a List<Any> is used in it, even if the item type is stable. You should use Kotlinx Immutable Collections instead: `initialItems: ImmutableList<Any>` or create an `@Immutable` wrapper for this class: `@Immutable data class InitialItemsList(val items: List<Any>)` See https://slackhq.github.io/compose-lints/rules/#avoid-using-unstable-collections for more information." + errorLine1=" initialItems: List<Any>," + errorLine2=" ~~~~~~~~~"> + file="src/main/java/com/ivy/legacy/legacy/ui/theme/components/ReorderModal.kt" + line="93" + column="19"/> + message="The Compose Compiler cannot infer the stability of a parameter if a List<Any> is used in it, even if the item type is stable. You should use Kotlinx Immutable Collections instead: `suggestions: ImmutableList<Any>` or create an `@Immutable` wrapper for this class: `@Immutable data class SuggestionsList(val items: List<Any>)` See https://slackhq.github.io/compose-lints/rules/#avoid-using-unstable-collections for more information." + errorLine1=" suggestions: List<Any>," + errorLine2=" ~~~~~~~~~"> + file="src/main/java/com/ivy/onboarding/components/Suggestions.kt" + line="36" + column="18"/> + message="The Compose Compiler cannot infer the stability of a parameter if a Set<String> is used in it, even if the item type is stable. You should use Kotlinx Immutable Collections instead: `suggestions: ImmutableSet<String>` or create an `@Immutable` wrapper for this class: `@Immutable data class SuggestionsSet(val items: Set<String>)` See https://slackhq.github.io/compose-lints/rules/#avoid-using-unstable-collections for more information." + errorLine1=" suggestions: Set<String>," + errorLine2=" ~~~~~~~~~~~"> + file="src/main/java/com/ivy/legacy/ui/component/edit/core/Title.kt" + line="47" + column="18"/> + + + + - - - - + message="The Compose Compiler cannot infer the stability of a parameter if a List<T> is used in it, even if the item type is stable. You should use Kotlinx Immutable Collections instead: `items: ImmutableList<T>` or create an `@Immutable` wrapper for this class: `@Immutable data class ItemsList(val items: List<T>)` See https://slackhq.github.io/compose-lints/rules/#avoid-using-unstable-collections for more information." + errorLine1=" items: List<T>," + errorLine2=" ~~~~~~~"> + file="src/main/java/com/ivy/legacy/legacy/ui/theme/components/WrapContentRow.kt" + line="29" + column="12"/> + id="ComposeUnstableReceiver" + message="Instance composable functions on non-stable classes will always be recomposed. If possible, make the receiver type stable or refactor this function if that isn't possible. See https://slackhq.github.io/compose-lints/rules/#unstable-receivers for more information." + errorLine1=" override fun uiState(): AccountsState {" + errorLine2=" ~~~~~~~"> + file="src/main/java/com/ivy/accounts/AccountsViewModel.kt" + line="65" + column="18"/> + id="ComposeUnstableReceiver" + message="Instance composable functions on non-stable classes will always be recomposed. If possible, make the receiver type stable or refactor this function if that isn't possible. See https://slackhq.github.io/compose-lints/rules/#unstable-receivers for more information." + errorLine1=" private fun getBaseCurrency(): String {" + errorLine2=" ~~~~~~~~~~~~~~~"> + id="ComposeUnstableReceiver" + message="Instance composable functions on non-stable classes will always be recomposed. If possible, make the receiver type stable or refactor this function if that isn't possible. See https://slackhq.github.io/compose-lints/rules/#unstable-receivers for more information." + errorLine1=" private fun getAccountsData(): ImmutableList<AccountData> {" + errorLine2=" ~~~~~~~~~~~~~~~"> + file="src/main/java/com/ivy/accounts/AccountsViewModel.kt" + line="87" + column="17"/> + id="ComposeUnstableReceiver" + message="Instance composable functions on non-stable classes will always be recomposed. If possible, make the receiver type stable or refactor this function if that isn't possible. See https://slackhq.github.io/compose-lints/rules/#unstable-receivers for more information." + errorLine1=" private fun getTotalBalanceWithExcluded(): String {" + errorLine2=" ~~~~~~~~~~~~~~~~~~~~~~~~~~~"> + file="src/main/java/com/ivy/accounts/AccountsViewModel.kt" + line="92" + column="17"/> + id="ComposeUnstableReceiver" + message="Instance composable functions on non-stable classes will always be recomposed. If possible, make the receiver type stable or refactor this function if that isn't possible. See https://slackhq.github.io/compose-lints/rules/#unstable-receivers for more information." + errorLine1=" private fun getTotalBalanceWithExcludedText(): String {" + errorLine2=" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"> + file="src/main/java/com/ivy/accounts/AccountsViewModel.kt" + line="97" + column="17"/> + id="ComposeUnstableReceiver" + message="Instance composable functions on non-stable classes will always be recomposed. If possible, make the receiver type stable or refactor this function if that isn't possible. See https://slackhq.github.io/compose-lints/rules/#unstable-receivers for more information." + errorLine1=" private fun getTotalBalanceWithoutExcluded(): String {" + errorLine2=" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"> + file="src/main/java/com/ivy/accounts/AccountsViewModel.kt" + line="102" + column="17"/> + id="ComposeUnstableReceiver" + message="Instance composable functions on non-stable classes will always be recomposed. If possible, make the receiver type stable or refactor this function if that isn't possible. See https://slackhq.github.io/compose-lints/rules/#unstable-receivers for more information." + errorLine1=" private fun getTotalBalanceWithoutExcludedText(): String {" + errorLine2=" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"> + file="src/main/java/com/ivy/accounts/AccountsViewModel.kt" + line="107" + column="17"/> + id="ComposeUnstableReceiver" + message="Instance composable functions on non-stable classes will always be recomposed. If possible, make the receiver type stable or refactor this function if that isn't possible. See https://slackhq.github.io/compose-lints/rules/#unstable-receivers for more information." + errorLine1=" private fun getReorderVisible(): Boolean {" + errorLine2=" ~~~~~~~~~~~~~~~~~"> + + + + + id="ComposeUnstableReceiver" + message="Instance composable functions on non-stable classes will always be recomposed. If possible, make the receiver type stable or refactor this function if that isn't possible. See https://slackhq.github.io/compose-lints/rules/#unstable-receivers for more information." + errorLine1=" override fun uiState(): BalanceState {" + errorLine2=" ~~~~~~~"> + id="ComposeUnstableReceiver" + message="Instance composable functions on non-stable classes will always be recomposed. If possible, make the receiver type stable or refactor this function if that isn't possible. See https://slackhq.github.io/compose-lints/rules/#unstable-receivers for more information." + errorLine1=" override fun uiState(): BudgetScreenState {" + errorLine2=" ~~~~~~~"> + id="ComposeUnstableReceiver" + message="Instance composable functions on non-stable classes will always be recomposed. If possible, make the receiver type stable or refactor this function if that isn't possible. See https://slackhq.github.io/compose-lints/rules/#unstable-receivers for more information." + errorLine1=" private fun getBaseCurrency(): String {" + errorLine2=" ~~~~~~~~~~~~~~~"> + id="ComposeUnstableReceiver" + message="Instance composable functions on non-stable classes will always be recomposed. If possible, make the receiver type stable or refactor this function if that isn't possible. See https://slackhq.github.io/compose-lints/rules/#unstable-receivers for more information." + errorLine1=" private fun getTimeRange(): FromToTimeRange? {" + errorLine2=" ~~~~~~~~~~~~"> + file="src/main/java/com/ivy/budgets/BudgetViewModel.kt" + line="87" + column="17"/> + id="ComposeUnstableReceiver" + message="Instance composable functions on non-stable classes will always be recomposed. If possible, make the receiver type stable or refactor this function if that isn't possible. See https://slackhq.github.io/compose-lints/rules/#unstable-receivers for more information." + errorLine1=" private fun getCategories(): ImmutableList<Category> {" + errorLine2=" ~~~~~~~~~~~~~"> + file="src/main/java/com/ivy/budgets/BudgetViewModel.kt" + line="92" + column="17"/> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + id="ComposeUnstableReceiver" + message="Instance composable functions on non-stable classes will always be recomposed. If possible, make the receiver type stable or refactor this function if that isn't possible. See https://slackhq.github.io/compose-lints/rules/#unstable-receivers for more information." + errorLine1=" private fun optionalFields(sampleCSV: List<CSVRow>?): OptionalFields? {" + errorLine2=" ~~~~~~~~~~~~~~"> + file="src/main/java/com/ivy/importdata/csv/CSVViewModel.kt" + line="300" + column="17"/> + id="ComposeUnstableReceiver" + message="Instance composable functions on non-stable classes will always be recomposed. If possible, make the receiver type stable or refactor this function if that isn't possible. See https://slackhq.github.io/compose-lints/rules/#unstable-receivers for more information." + errorLine1=" override fun uiState(): CategoriesScreenState {" + errorLine2=" ~~~~~~~"> + file="src/main/java/com/ivy/categories/CategoriesViewModel.kt" + line="57" + column="18"/> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +