Order in element-types settings

[budarin]

I have such folder structure

src/
├── app/
│   └── ...
│
├── core/
│   ├── domain/
│   │   └── ...
│   ├── use-cases/
│   │   └── ...
│   └── ...
│
├── services/
│   └── ...
│
├── ui/
│   ├── assets/
│   │   └── ...
│   ├── components/
│   │   └── ...
│   ├── containers/
│   │   ├── ...
│   │   └── uic.ts
│   └── ...
│
├── main.tsx
├── contracts.ts
└── vite-env.d.ts

I have described elements

'boundaries/elements': [
    { type: 'app', pattern: 'src/app/**' },
    { type: 'core', pattern: 'src/core/**' },
    { type: 'domain', pattern: 'src/core/domain/**' },
    { type: 'use-cases', pattern: 'src/core/use-cases/**' },
    { type: 'services', pattern: 'src/services/**' },
    { type: 'ui', pattern: 'src/ui/**' },
    { type: 'ui-assets', pattern: 'src/ui/assets/**' },
    { type: 'ui-components', pattern: 'src/ui/components/**' },
    { type: 'ui-containers', pattern: 'src/ui/containers/**' },
    {
        type: 'uic',
        pattern: 'src/ui/containers/uic.ts',
        mode: 'file',
    },
    { type: 'main', pattern: 'src/main.tsx', mode: 'file' },
    {
        type: 'contracts',
        pattern: 'src/contracts.ts',
        mode: 'file',
    },
],

and try to describe the rules

rules: {
    'boundaries/element-types': [
        2,
        {
            default: 'disallow',
            rules: [
                // main
                {
                    from: 'main',
                    allow: ['app', 'ui', 'contracts'],
                },

                // app
                {
                    from: 'app',
                    allow: ['*'],
                },

                // core
                { from: 'core', allow: ['contracts', 'core'] },
                { from: 'domain', allow: ['domain'] },
                {
                    from: 'use-cases',
                    allow: ['domain', 'contracts', 'use-cases'],
                },

                // services
                {
                    from: 'services',
                    allow: ['contracts', 'services'],
                },

                // ui
                {
                    from: 'ui',
                    allow: ['contracts', 'ui'],
                },
                {
                    from: 'ui-components',
                    allow: ['ui', 'contracts'],
                    disallow: ['uic'],            // <- not work !!!!
                },
                {
                    from: 'ui-containers',
                    allow: ['ui', 'contracts'],
                },

                // contracts
                {
                    from: 'contracts',
                    allow: ['*'],
                },
            ],
        },
    ],
},

Everything seems to be working fine, but only one rule is not working: the component cannot import src/ui/containers/uic.ts

I defined the rule: disallow: ['uic'], but it doesn't work!

What am I doing wrong?

[javierbrea]

Hi @budarin

It’s possible that your uic element is being categorized as ui-containers, since the pattern for that type also matches the src/ui/containers/uic.ts path.
As mentioned in the documentation:

“The assigned element type will be the first matching pattern, in the order they are defined in the array. You should list the most specific patterns before the more general ones.”

So, you might be able to fix this by moving the uic definition above the ui-containers one.

That said, I’m not 100% sure — I’d recommend enabling the debug mode to confirm which types are actually being assigned by the plugin.
You can enable it and run ESLint only on that specific file to keep the logs manageable.

Hope that helps! 🙂

[budarin]

Thanks! It helped.

I understand that your processing algorithm determines the interface of interaction with the plugin.
But what if we don't be afraid and make the interface more understandable to humanoids, and sort everything in the code in reverse order and process the elements the way the algorithm needs it? IMHO :)

[javierbrea]

It’s not really an algorithmic constraint — it’s a human decision, and as such, a subjective one. I’m also a "humanoid", and to me it felt more natural that rules defined earlier would have higher priority.

I think both approaches are equally valid, but since this behavior is already established, changing it now would introduce a breaking change.
That said, we could consider adding an option to invert the order if there’s enough interest — I just don’t see it as a high priority right now.

Of course, PRs are always welcome! 🚀