Drovp is a cross-platform desktop application whose purpose is to create drop zones into which you can drop files and let plugins run operations on them without the need to fill configuration forms for every single input.
Plugins can accept anything, not just files. If plugin accepts them, you can also drop or paste urls, text, or image data.
Queueing and parallelization controls are built in. Dropping folders will recursively create operations for each file that plugin accepts.
Drovp on its own does nothing. It needs plugins that extend it with processors. The whole point of Drop is than to provide an interface between user dropping items, and processors processing them.
To get a processor, head over to Registry section, search for plugins that have what you need, and click Install.
Once you have a processor, you can start creating profiles (drop zones) for it. Go to processors section, and click on the Profile button.
Newly created profile needs a name and a configuration. Options section is where you tell the processor how to process items dropped into this profile.
When you drop an item into this profile, it'll be sent to the associated processor along with these options telling it how it needs to be processed.
You can also configure parallelization limits here (max operations of this processor's load type to run at the same time).
Once the profile is ready and configured, you can start dropping items into it. Depending on a processor, profile can accept files, URLs, binary blobs, or strings. Strings, URLs, and blobs can also be pasted in with ctrl+v or via profile's context menu.
Drovp provides an easy way to export and share profiles with others. All you need to do is either right-click any profile, and choose one of the Export options available, and share it with others.
All anyone has to do to import a shared profile is to either click the import link, or enter the import code into Profile importer, click a couple buttons, and they'll have a 1:1 copy of the profile ready to be used.
Have you ever wanted to create a simple script to do something to a file, URL, string, or an image blob in a clipboard, but the thought of creating a configurable CLI interface, or god forbid a UI, was just too much? Creating it as a Drovp plugin takes care of all of that and more.
You get drag & drop interface, options schema, drop zones, operations queue, parallelization, history, logs, debugging, publishing and distribution, and tons of other things, all taken care of for you by Drovp.
Plugins are just simple node modules with a drovpplugin keyword. All you need to do is register and configure a processor, define its options schema, and you can move on to write your actual processing logic. If you want to share it with others, just publish to npm.
Go to Settings and check Developer mode. This enables a variety of development related features around the app. The main one being the New plugin section in registry.
But first, configure the Edit command which is now visible right below the Developer mode checkbox. This is what Drovp will use to open plugins in your editor of choice.
In the now accessible Plugins New section, configure your new plugin boilerplate and press Create. This will create and place the new plugin into a directory from which Drovp loads plugins, load it, and open its page.
There you can just click the Edit button and start coding.
// index.js
module.exports = (plugin) => {
plugin.registerProcessor('name', {
main: 'processor.js',
description: 'Does something to jpg files',
accepts: {
files: ['jpg']
},
// Quick `option: default` map
options: {
verbose: true
},
});
}Once in editor, navigate to the main plugin file index.js/ts, and register your processor.
Read the Documentation to see all the available options and features.
// processor.js
module.exports = async (payload, utils) => {
const {input, options} = payload;
const {progress, output} = utils;
// Logs are displayed in operation's logs history
if (options.verbose) {
console.log(input.kind); // 'file'
console.log(input.type); // 'jpg'
console.log(input.path);
}
// Do something to the input
await processFile(input.path);
// Inform Drovp about progress
progress(0.2, 1);
progress({completed: 0.2, total: 1});
progress.total = 1;
progress.completed = 0.2;
// Emit one or multiple outputs
output.file('/path/to/new.file');
output.directory('/path/to/new/directory');
output.url('https://example.com');
output.message('someTokenOrSomething');
output.warning('Careful!');
output.error('Oh no!');
// Or throw
throw new Error('Oh no!');
}Processor is just an async Node.js function that accepts operation payload as its 1st, ProcessorUtils as its 2nd argument, and resolves after it has done it's thing.
Payload consists of a single or multiple input items (depending on processor configuration), and options object with configuration of a profile into which the item(s) were dropped into. The options structure is controlled by processor's options schema.
ProcessorUtils than allow your processor to report progress, emit files, directories, URLs, or strings, which will then show up in global, and profile's Outputs drawers.
If you need to log stuff, just use Node.js's `console.*` methods. These logs can be viewed in each operation's Logs section.
List of things that need to be done before app leaves beta.
Features on a wishlist once out of beta.
plugin.registerLocale() API for localizing both app and plugins.The current plan is to provide a free personal, and $19.95 pro commercial tiers of the app.
Free version will have the same functionality, but restricted number of profiles and profile tabs that can be created.