graycoreio/daffodil

View on GitHub

Showing 122 of 124 total issues

Function canActivate has 27 lines of code (exceeds 25 allowed). Consider refactoring.
Open

  canActivate(
    next: ActivatedRouteSnapshot,
    state: RouterStateSnapshot,
  ): Observable<UrlTree | boolean> {
    return this.driver.resolve(this.urlNormalizer.normalize(state.url)).pipe(
Severity: Minor
Found in libs/external-router/routing/src/guard/existence.guard.ts - About 1 hr to fix

    Function addItem has 27 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

      private addItem(reqInfo: RequestInfo): DaffCart {
        const cart = this.getCart(reqInfo);
        const cartIndex = reqInfo.collection.findIndex(c => c.id === reqInfo.id);
        const itemInput = reqInfo.utils.getJsonBody(reqInfo.req);
        const existingCartItemIndex = cart.items.findIndex(item => item.product_id === itemInput.productId);

      Function daffSearchCreateSearchSelectors has 27 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      export const daffSearchCreateSearchSelectors = <T extends DaffSearchResult = DaffSearchResult, R extends DaffSearchStateRootSlice<T> = DaffSearchStateRootSlice<T>>(
        stateSelector: MemoizedSelector<R, DaffSearchReducerState<T>>,
      ) => {
        const selectSearchLoading = createSelector(
          stateSelector,
      Severity: Minor
      Found in libs/search/state/src/selectors/search.selector.ts - About 1 hr to fix

        Function createTotals has 27 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

          private createTotals(): DaffOrderTotal[] {
            return [
              this.totalFactory.create({
                label: 'Grand Total',
                type: DaffOrderTotalTypeEnum.GrandTotal,
        Severity: Minor
        Found in libs/order/testing/src/factories/order.factory.ts - About 1 hr to fix

          Function forRoot has 27 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

            static forRoot(): ModuleWithProviders<DaffRelatedProductsMagentoDriverModule> {
              return {
                ngModule: DaffRelatedProductsMagentoDriverModule,
                providers: [
                  {

            Function list has 27 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

              list(cartId?: DaffCart['id']): Observable<DaffOrderCollection> {
                return this.apollo.query<MagentoGetGuestOrdersResponse>({
                  query: getGuestOrders(this.extraOrderFragments),
                  variables: {
                    cartId,
            Severity: Minor
            Found in libs/order/driver/magento/2-4-1/src/order.service.ts - About 1 hr to fix

              Function forRoot has 27 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                static forRoot(): ModuleWithProviders<DaffUpsellProductsMagentoDriverModule> {
                  return {
                    ngModule: DaffUpsellProductsMagentoDriverModule,
                    providers: [
                      {
              Severity: Minor
              Found in libs/upsell-products/driver/magento/src/magento.module.ts - About 1 hr to fix

                Function list has 27 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                  list(cartId?: DaffCart['id']): Observable<DaffOrderCollection> {
                    return this.apollo.query<MagentoGetGuestOrdersResponse>({
                      query: getGuestOrders(this.extraOrderFragments),
                      variables: {
                        cartId,
                Severity: Minor
                Found in libs/order/driver/magento/2-4-0/src/order.service.ts - About 1 hr to fix

                  Function cartResolveReducer has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                  export function cartResolveReducer<T extends DaffCart = DaffCart>(
                    state = daffCartReducerInitialState,
                    action: ActionTypes<T>,
                  ): DaffCartReducerState<T> {
                    switch (action.type) {
                  Severity: Minor
                  Found in libs/cart/state/src/reducers/cart-resolve/cart-resolve.reducer.ts - About 1 hr to fix

                    Function forRoot has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                      static forRoot(): ModuleWithProviders<DaffCompositeProductMagentoDriverModule> {
                        return {
                          ngModule: DaffCompositeProductMagentoDriverModule,
                          providers: [
                            ...daffProvideProductMagentoExtraProductFragments(magentoBundledProductFragment),

                      Function daffCustomerReducer has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                      export const daffCustomerReducer = <T extends DaffCustomer = DaffCustomer>(
                        state = daffCustomerInitialState,
                        action: DaffCustomerActions<T> | DaffCustomerAddressActions,
                      ): DaffCustomerReducerState<T> => {
                        switch (action.type) {
                      Severity: Minor
                      Found in libs/customer/state/src/reducers/customer/reducer.ts - About 1 hr to fix

                        Function daffSearchProductCollectionReducer has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                        export const daffSearchProductCollectionReducer = (
                          state: DaffCollectionMetadata = daffCollectionReducerInitialState,
                          action: DaffSearchActions | DaffSearchProductCollectionActions,
                        ): DaffCollectionMetadata => {
                          switch (action.type) {
                        Severity: Minor
                        Found in libs/search-product/state/src/reducers/collection/reducer.ts - About 1 hr to fix

                          Function getAnimationState has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                          Open

                          export const getAnimationState = (open: boolean, mode: DaffSidebarMode): DaffSidebarAnimationState => {
                            if(mode === 'side') {
                              return 'none';
                            }
                          
                          
                          Severity: Minor
                          Found in libs/design/sidebar/src/animation/sidebar-animation-state.ts - About 55 mins 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 daffSizeMixin has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                          Open

                          export function
                          daffSizeMixin<V extends DaffSizeAllType, T extends Constructor<HasElementRef> = Constructor<HasElementRef>>(Base: T, defaultSize?: V) {
                            class DaffSizeMixinClass extends Base {
                              //TODO move this back to private in Typescript 3.1
                              _size: V;
                          Severity: Minor
                          Found in libs/design/src/core/sizable/sizable-mixin.ts - About 55 mins 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 onAnimationComplete has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                          Open

                            @HostListener('@transformSidebar.done', ['$event']) onAnimationComplete(e: AnimationEvent) {
                              if(isOpening(<DaffSidebarAnimationState>e.fromState, <DaffSidebarAnimationState>e.toState)) {
                                this._focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement);
                          
                                const focusableChild = (<HTMLElement>this._elementRef.nativeElement.querySelector(daffFocusableElementsSelector));
                          Severity: Minor
                          Found in libs/design/sidebar/src/sidebar/sidebar.component.ts - About 55 mins 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 create has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                          Open

                            create(address?: DaffPersonalAddress): DemoCheckoutAddressFormGroup {
                              return this.fb.group({
                                firstname: [address ? address.firstname : '', Validators.required],
                                lastname: [address ? address.lastname : '', Validators.required],
                                street: [address ? address.street : '', Validators.required],

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

                            constructor(
                              private cartFacade: DaffCartFacade,
                            ) {
                              this.currentStep$ = combineLatest([
                                this._currentStep$,
                          Severity: Minor
                          Found in apps/demo/src/app/checkout/step/step.service.ts - About 35 mins 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 locationOf has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                          Open

                          const locationOf = <T>(element: T, array: T[], comparer, start = 0, end = array.length) => {
                          
                            if (array.length === 0) {
                              return -1;
                            }

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

                          export function
                          daffTextAlignmentMixin<T extends Constructor<HasElementRef>>(Base: T, defaultTextAlignment?: DaffTextAlignment) {
                            class DaffTextAlignableMixin extends Base {
                              // TODO move this back to private in Typescript 3.1
                              _textAlignment: DaffTextAlignment;
                          Severity: Minor
                          Found in libs/design/src/core/text-alignable/text-alignable-mixin.ts - About 35 mins 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 transformMagentoCartGraphQlError has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                          Open

                          export function transformMagentoCartGraphQlError(error: GraphQLError, requestPayload?: unknown): DaffError {
                            // TODO: readdress this when we move to eslint
                            // eslint-disable-next-line
                            for (const code in DaffCartMagentoErrorMessageRegexMap) {
                              const matchIndex = error.message.search(DaffCartMagentoErrorMessageRegexMap[code]);
                          Severity: Minor
                          Found in libs/cart/driver/magento/src/errors/transform.ts - About 35 mins 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

                          Severity
                          Category
                          Status
                          Source
                          Language