Showing 125 of 211 total issues
Function render
has 49 lines of code (exceeds 25 allowed). Consider refactoring. Open
public render() {
const divStyle: React.CSSProperties = {
background: this.props.isSelected ? Colors.Azure : Colors.White,
};
const primary = (
Function ParseStudentHtmlToRawSlot_v2
has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring. Open
export default function ParseStudentHtmlToRawSlot_v2(html: string): RawSlot[] {
const result = new Array<RawSlot>();
const htmlDoc = new DOMParser().parseFromString(html, "text/html");
// @ts-ignore
const tableRows = Array.from(
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function moveElementAwayFromCollision
has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring. Open
function moveElementAwayFromCollision(layout, collidesWith, itemToMove, isUserAction, compactType, cols) {
var compactH = compactType === 'horizontal';
var compactV = compactType === 'vertical';
var preventCollision = false; // we're already colliding
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function render
has 47 lines of code (exceeds 25 allowed). Consider refactoring. Open
public render() {
if (this.state.redirect) {
return <Redirect push={true} to="/login" />;
}
Function render
has 45 lines of code (exceeds 25 allowed). Consider refactoring. Open
public render() {
const menuButton = (
<IconButton onClick={this.handleOpenDrawer}>
<MenuIcon />
</IconButton>
Function LoadSlotsFromUrl
has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring. Open
export const LoadSlotsFromUrl = (
downloadUrl: string,
fileType: string,
started: () => void,
successed: (loadedSlots: IRawSlot[]) => void,
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function GeneralizeSlot
has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring. Open
export function GeneralizeSlot(originalSlots: RawSlot[]): RawSlot[] {
const slots = originalSlots.map(clone) as IRawSlot[];
const results = new Array<RawSlot>();
results.push(slots[0]);
let generalized: boolean;
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function render
has 43 lines of code (exceeds 25 allowed). Consider refactoring. Open
public render() {
const getListItem = (text: string, icon: any, handler: any) => {
return (
<ListItem button={true} onClick={handler}>
<ListItemIcon>{icon}</ListItemIcon>
Function plotPartition
has 42 lines of code (exceeds 25 allowed). Consider refactoring. Open
public plotPartition(partition: T[][], partitionHeadings: string[]): void {
// calculate full search path count
this.fullSearchPathCount = this.setPartitionCount(
partition.map((x) => x.length)
);
Function GenerateErrorLabels
has 42 lines of code (exceeds 25 allowed). Consider refactoring. Open
function GenerateErrorLabels(diffReports: DiffReport[] | null) {
const errorStyle: React.CSSProperties = {
color: Colors.Red,
};
if (!diffReports) {
Function Report
has 41 lines of code (exceeds 25 allowed). Consider refactoring. Open
const Report = (props: {
numberOfRemovedTimetables: number;
numberOfRemainingTimetables: number;
}) => {
const style: React.CSSProperties = {
Function GenerateStateViews
has 41 lines of code (exceeds 25 allowed). Consider refactoring. Open
export function GenerateStateViews(
states: STCBox[],
handleSetTimeContraintAt: (state: STCBox) => void,
handleDesetTimeConstraintAt: (state: STCBox) => void
): ISkeleton {
Function GenerateSlotViewsAndDayColumn
has 40 lines of code (exceeds 25 allowed). Consider refactoring. Open
export function GenerateSlotViewsAndDayColumn(
slots: ISlotViewModel[],
selectSlotChoiceHandler: (slotUid: number, newSlotChoice: number) => void,
goToThisAlternativeSlotHandler: (
sourceSlotUid: number,
Function GenerateNewState
has 40 lines of code (exceeds 25 allowed). Consider refactoring. Open
protected GenerateNewState(state: IMasterState): IMasterState {
if (
state.TimetableListState.ShowingAlternateSlotOf &&
this.slot.Uid !== state.TimetableListState.ShowingAlternateSlotOf.Uid
) {
Function ParseStudentHtmlToRawSlot
has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring. Open
export default function ParseStudentHtmlToRawSlot(html: string): RawSlot[] {
const result = new Array<RawSlot>();
const htmlDoc = new DOMParser().parseFromString(html, "text/html");
// @ts-ignore
const tableRows = htmlDoc
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function ResponsiveReactGridLayout
has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring. Open
var ResponsiveReactGridLayout = function (_React$Component) {
_inherits(ResponsiveReactGridLayout, _React$Component);
function ResponsiveReactGridLayout() {
var _temp, _this, _ret;
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function ParseFgoHtmlToRawSlot_v2
has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring. Open
export function ParseFgoHtmlToRawSlot_v2(html: string): RawSlot[] {
const result = new Array<RawSlot>();
const htmlDoc = new DOMParser().parseFromString(html, "text/html");
const tableRows = htmlDoc
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function ParseFgoHtmlToRawSlot_v1
has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring. Open
export function ParseFgoHtmlToRawSlot_v1(html: string): RawSlot[] {
const result = new Array<RawSlot>();
const htmlDoc = new DOMParser().parseFromString(html, "text/html");
const tableRows = htmlDoc
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function render
has 39 lines of code (exceeds 25 allowed). Consider refactoring. Open
public render() {
if (!this.props.slots) {
return false;
}
const subjectSummaries = new TimetableSummary(this.props.slots)
Function WidthProvider
has 38 lines of code (exceeds 25 allowed). Consider refactoring. Open
var WidthProvider = function WidthProvider(ComposedComponent) {
var _class, _temp2;
return _temp2 = _class = function (_React$Component) {
_inherits(_class, _React$Component);