This has been made because no developer will likely ever require this API.
The current API assumes you already have an instance of the component, which means you can likely already patch that component instance itself.
The API can be made more powerful by taking any string names, and comparing it to the component's type name, type displayName, name, displayName, etc., but it will introduce performance bottlenecks.
Plugins
- Settings: Plugins page is now semi-functional
- No Track: Added new plugin
- Developer Settings: Clean up properly
- Logging: Log in preInit stage
- Staff Settings: Add ReloadRequired flags when late-running
@revenge-mod/init
- Moved to the top-level src/index.ts instead
@revenge-mod/modules
- Switch `exports` and `id` parameters in finders APIs
- Lookups now return an array of exports and ID instead of just exports
- Lookup ID APIs have been removed
- Add `finders.get` helper, a new alternative for `finders.find`
- Corrected documentation for subscription APIs
@revenge-mod/plugins
- Added new APIs for plugins to allow running during pre-init stages
- Added `unscoped.modules.finders.get*`
- Added `unscoped.react.native`
@revenge-mod/react
- native: Added `onRunApplication` and `onRunApplicationFinished`
@revenge-mod/utils
- callbacks: Add `noopFalse`
- promises: Fix `allSettled`
- promises: Add `sleep`
- `find` APIs are merely a wrapper for `wait` and `lookup` APIs. I think the developer should already know whether the module they're trying to get is initialized already or not by the time their plugin runs.
In the `init` phase, most important packages such as React, React Native, React JSX Runtime, Native modules, etc. are already initialized. So, the `lookup` APIs can be used here instead.
- While I am not sure what exactly gets initialized after `init` until `start`, you can simply do trial and error to see if the module is initialized or not. If it is not, you can use `wait` API to wait for it to be initialized.
- `lookup` can also be used inside `wait` if you know a certain module would be initialized after another module.
With all the above reasons, I think the `find*` APIs are redundant and should be removed.
- Separated plugin flags for statuses
- Disallow access to internal plugin flags in plugin APIs
- await `handleError` when plugin throws an error
- Added safe guards to prevent initing/starting a plugin twice or when it is not enabled
- Call GC after plugin stops
- Await plugin init and start before stopping
