How to lazy load menu?

[BerQin]

Every time the page is refreshed, all subsets of the menu are updated

And the subset of the subset is obtained through the load function

How can lazy loading be implemented？

When clicked, the subset list is requested？

You can see more than 3000 requests！

code:

`

import api from '../request/api';

export default function Plugin (Roots) {
const objectProvider = {
get: async function(identifier) {
const obj = await api.getObject(identifier);
if(!obj.name){
console.error(the field name is NOT exist!);
return;
}
return obj;
}
};

const compositionProvider = {
appliesTo: function (domainObject) {
return (domainObject.identifier.namespace.startsWith('skywalker.'))&&
(domainObject.type === 'folder');
},
load: function(domainObject) {
return api.getLoadComposition({
key:domainObject.identifier.key,
namespace:domainObject.identifier.namespace
});
}
};

return function install(openmct) {
if (Roots && Roots.length) {
Roots.forEach((rootNS) => {
openmct.objects.addRoot({
namespace: rootNS,
key: 'tm_root'
});
openmct.objects.addProvider(rootNS, objectProvider);
});
openmct.composition.addProvider(compositionProvider);
}
};
}
`

[jvigliotta]

Hi @BerQin this is most likely due to search indexing on load. You can disable it by commenting out these lines: https://github.com/nasa/openmct/blob/master/platform/search/src/services/GenericSearchProvider.js#L63-L67 Keep in mind, this will return no search results anytime you perform a search. This issue is on our radar, but we haven't settled on a solution as of yet. Hope this helps!

If this doesn't solve the problem, then I would look at the api.getLoadComposition function from your code example, it's possible there's some unnecessary recursion going on in there.

[akhenry]

@BerQin The object tree is lazy-loaded, so as @jvigliotta mentioned it's probably the search indexer that you're seeing.

Object providers can optionally define a search(searchTerms) function if server-side search is supported. For eg our Couch DB provider implements this. In the event that an object provider does not define a search function, Open MCT will build an in-memory index of all of the objects provided by that object provider via an exhaustive tree traversal, hence all of the gets.

So, there are a couple of potential mitigations here:

1. If your server has an API for searching objects by name, you could add a search(searchTerms) function to your object provider, and Open MCT will stop trying to build an in-memory index.
2. If your server doesn't support search, but it does support batch querying, you could use a debounced function to batch the get requests that the in-memory search indexer issues, reducing the number of gets to the backend.
3. If your backend does not support search or batching, and you don't really care about search, you could implement a search() function on your object provider that is noop, and just returns Promise.resolve([]). You could then hide the search button altogether with some CSS.

We should consider making search configurable so that it can be trivially disabled, and so that developers can choose between an "on load" and an "on demand" strategy for the in-memory indexer.