michielbdejong/solid-ui

View on GitHub

Showing 270 of 337 total issues

Function loadPrevious has a Cognitive Complexity of 30 (exceeds 5 allowed). Consider refactoring.
Open

  async loadPrevious (date, backwards) {
    const thisDateFolder = this
    async function previousPeriod (file, level) {
      function younger (x) {
        if (backwards ? x.uri >= file.uri : x.uri <= file.uri) return false // later than we want or same -- looking for different
Severity: Minor
Found in src/chat/dateFolder.js - About 4 hrs to fix

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 selectWorkspace has a Cognitive Complexity of 29 (exceeds 5 allowed). Consider refactoring.
Open

export function selectWorkspace (
  dom: HTMLDocument,
  appDetails: AppDetails,
  callbackWS: (workspace: string | null, newBase: string) => void
): HTMLElement {
Severity: Minor
Found in src/authn/authn.ts - About 4 hrs to fix

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 makeNewAppInstance has 106 lines of code (exceeds 25 allowed). Consider refactoring.
Open

  function makeNewAppInstance (options) {
    return new Promise(function (resolve, reject) {
      var selectUI // , selectUIParent
      function callbackWS (ws, newBase) {
        UI.authn.logInLoadProfile(createContext).then(
Severity: Major
Found in src/create.js - About 4 hrs to fix

    Function cameraCaptureControl has 105 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    module.exports.cameraCaptureControl = function cameraCaptureControl (
      dom,
      store,
      getImageDoc,
      doneCallback
    Severity: Major
    Found in src/media-capture.js - About 4 hrs to fix

      Function loginStatusBox has a Cognitive Complexity of 28 (exceeds 5 allowed). Consider refactoring.
      Open

      export function loginStatusBox (
        dom: HTMLDocument,
        listener: ((uri: string | null) => void) | null = null,
        options: {
          buttonStyle?: string
      Severity: Minor
      Found in src/authn/authn.ts - About 4 hrs to fix

      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 uploadFiles has a Cognitive Complexity of 27 (exceeds 5 allowed). Consider refactoring.
      Open

      function uploadFiles (fetcher, files, fileBase, imageBase, successHandler) {
        for (var i = 0; files[i]; i++) {
          const f = files[i]
          console.log(
            ' dropped: Filename: ' +
      Severity: Minor
      Found in src/widgets/dragAndDrop.js - About 3 hrs to fix

      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 makeDropTarget has 93 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      function makeDropTarget (ele, droppedURIHandler, droppedFileHandler) {
        var dragoverListener = function (e) {
          e.preventDefault() // Neeed else drop does not work [sic]
          e.dataTransfer.dropEffect = 'copy'
        }
      Severity: Major
      Found in src/widgets/dragAndDrop.js - About 3 hrs to fix

        File thread.js has 321 lines of code (exceeds 250 allowed). Consider refactoring.
        Open

        /* global $rdf */
        //  Common code for a discussion are a of messages about something
        //
        var UI = {
          authn: require('../authn/authn'),
        Severity: Minor
        Found in src/chat/thread.js - About 3 hrs to fix

          File messageArea.js has 321 lines of code (exceeds 250 allowed). Consider refactoring.
          Open

          /* global $rdf */
          //  Common code for a discussion are a of messages about something
          //
          var UI = {
            authn: require('./authn/authn'),
          Severity: Minor
          Found in src/messageArea.js - About 3 hrs to fix

            Function newMessageForm has 91 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

              var newMessageForm = function () {
                var form = dom.createElement('tr')
                var lhs = dom.createElement('td')
                var middle = dom.createElement('td')
                var rhs = dom.createElement('td')
            Severity: Major
            Found in src/messageArea.js - About 3 hrs to fix

              Function newMessageForm has 91 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                var newMessageForm = function () {
                  var form = dom.createElement('tr')
                  var lhs = dom.createElement('td')
                  var middle = dom.createElement('td')
                  var rhs = dom.createElement('td')
              Severity: Major
              Found in src/chat/thread.js - About 3 hrs to fix

                Function renderMessage has a Cognitive Complexity of 25 (exceeds 5 allowed). Consider refactoring.
                Open

                export function renderMessage (
                  messageTable,
                  bindings,
                  fresh,
                  options,
                Severity: Minor
                Found in src/chat/message.js - About 3 hrs to fix

                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 Column has 85 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                  function Column () {
                    this.useCount = 0
                
                    // Have we checked any values for this column yet?
                
                
                Severity: Major
                Found in src/table.js - About 3 hrs to fix

                  Function renderItem has 85 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                    function renderItem (object) {
                      async function deleteThisItem () {
                        if (ordered) {
                          console.log('pre delete: ' + debugString(list.elements))
                          for (let i = 0; i < list.elements.length; i++) {
                  Severity: Major
                  Found in src/widgets/forms.js - About 3 hrs to fix

                    Function getACLorDefault has 85 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                    export function getACLorDefault (
                      doc: $rdf.NamedNode,
                      callbackFunction: (
                        a: boolean,
                        b: boolean,
                    Severity: Major
                    Found in src/acl/acl.ts - About 3 hrs to fix

                      Function loginStatusBox has 83 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                      export function loginStatusBox (
                        dom: HTMLDocument,
                        listener: ((uri: string | null) => void) | null = null,
                        options: {
                          buttonStyle?: string
                      Severity: Major
                      Found in src/authn/authn.ts - About 3 hrs to fix

                        Function wrapper has 82 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                        var wrapper = function () {
                          var logger = {}
                        
                          // ///////////////////////  Logging
                          //
                        Severity: Major
                        Found in src/log.js - About 3 hrs to fix

                          Function ensureOneTypeIndex has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring.
                          Open

                          async function ensureOneTypeIndex (context: AuthenticationContext, isPublic: boolean): Promise<AuthenticationContext | void> {
                            async function makeIndexIfNecessary (context, isPublic) {
                              const relevant = isPublic ? context.publicProfile : context.preferencesFile
                              const visibility = isPublic ? 'public' : 'private'
                          
                          
                          Severity: Minor
                          Found in src/authn/authn.ts - About 3 hrs to fix

                          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 onChange has 79 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                            var onChange = function (_e) {
                              select.disabled = true // until data written back - gives user feedback too
                              var ds = []
                              var is = []
                              var removeValue = function (t) {
                          Severity: Major
                          Found in src/widgets/forms.js - About 3 hrs to fix

                            Function makeDescription has 79 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                            forms.makeDescription = function (
                              dom,
                              kb,
                              subject,
                              predicate,
                            Severity: Major
                            Found in src/widgets/forms.js - About 3 hrs to fix
                              Severity
                              Category
                              Status
                              Source
                              Language