tinytick
v1.2.8TypeScript
A tiny but very useful JavaScript task orchestrator.
1.8K/weekUpdated 8 months agoMITUnpacked: 152.1 KB
Published by jamesgpearce
npm install tinytickA tiny but very useful JavaScript task orchestrator.
The one with reactivity - and React!
Task management is hard.
Background tasks like fetching, syncing, and cache eviction are common in intelligent web applications. Yet managing them - with scheduling, failure handling, retries, and so on - can be a pain.
So make it easy.
Specify your tasks imperatively, ahead of time, and then configure their schedules, timeouts, and retry sequences - and let TinyTick take care of everything for you. Oh and it's only 2.8kB.
Create and start a Manager object.
This is the main entry point for the TinyTick API.
``js`
import {createManager} from 'tinytick';
const manager = createManager().start();
A TinyTick task is simply an asynchronous function that can take an optional string argument (and a few other things, as you'll see later!). Simply register it with a string Register a
Task.Id.
`js`
const ping = async (url) => await fetch(url);
manager.setTask('ping', ping);
By default, TinyTask schedules the task to start as soon as possible. And it will generate a unique Schedule it to run.
Id for each 'task run' so you can track its progress.
`js`
const taskRunId = manager.scheduleTaskRun(
'ping',
'https://example.com',
);
The Keep up with what is going on.
Manager object exposes plenty of accessors to let you inspect the tasks you have registered and the state of the task runs you've scheduled.
`js yolo`
console.log(manager.getTaskIds());
// -> ['ping']
console.log(manager.getTaskRunInfo(taskRunId));
// -> {taskId: 'ping', arg: 'https://example.com', ...}
Subscribe to listeners that fire whenever critical things happen, like when a task starts, finishes, or fails. It uses the same API as TinyBase, so if you are familiar with listeners in that library, you'll feel right at home!TinyTick is reactive.
`js`
const listenerId1 = manager.addTaskRunRunningListener(
'ping',
null,
() => console.log('A ping started'),
);
const listenerId2 = manager.addTaskRunFailedListener(
'ping',
null,
() => console.log('A ping failed'),
);
// ...
manager.delListener(listenerId1);
manager.delListener(listenerId2);
Tasks (or individual task runs) can have a timeout set, and they will be aborted if they run over. Configure timeouts for your tasks.
Task functions are passed an AbortSignal parameter so you can handle the timeout. You can pass this straight on to the fetch call, for example.
`js`
manager.setTask(
'ping',
async (url, signal) => await fetch(url, {signal}),
undefined,
{maxDuration: 100}, // milliseconds
);
If a task run fails (for taking too long, or throwing an exception), you can indicate that you want it to retry, and even configure a backoff strategy.Orchestrate retries.
`js`
manager.setTask(
'ping',
async (url, signal) => await fetch(url, {signal}),
undefined, // we'll explain this argument in a moment!
{maxRetries: 3, retryDelay: '1000, 5000, 10000'},
);
A Create configuration categories.
Task can be assigned a category, which can have its own configuration for duration, retries, and retry delays. But of course, individual properties can still be overridden per task or per task run.
`js`
manager.setCategory('network', {
maxDuration: 100,
maxRetries: 3,
retryDelay: '1000, 5000, 10000',
});
manager.setTask('ping', ping, 'network', {
maxRetries: 5,
});
The optional Integrates with React.
Provider component and a set of hooks in the ui-react module make it easy to integrate TinyTick into your React application so that you can start tasks or visualize their progress.
`jsx yolo
import {
Provider,
useCreateManager,
useScheduleTaskRunCallback,
useSetTask,
} from 'tinytick/ui-react';
const App = () => (
);
const Panel = () => {
useSetTask(
'ping',
async () => await fetch('https://example.org'),
);
return ;
};
const Button = () => {
const callback = useScheduleTaskRunCallback('ping');
return ;
};
`
We are building up a set of Example Use Cases guides to show you how to use TinyTick in practice. If you're trying to access relational- or graph-like data over a network, for example, take a look at the Paginated And Nested Data guide for a start!See some worked examples.
`js yolo``
manager.scheduleTaskRun('fetchParents');
// -> 'Fetching https://api.org/parents?page=1'
// -> 'Storing parent A'
// -> 'Storing parent B'
// -> 'Fetching https://api.org/children?parentId=A&page=1'
// -> 'Fetching https://api.org/children?parentId=B&page=1'
// -> 'Fetching https://api.org/parents?page=2'
If you chose to install TinyTick in your app, you'll only add a gzipped 2.8kB to your app. Life is easy when you have zero dependencies! TinyBase has 100.0% test coverage, including the code throughout the documentation - even on this page. The guides, demos, and API examples are designed to make things as easy as possible.Tiny, tested, and documented.
| Total | Tested | Coverage | |
|---|---|---|---|
| Lines | 434 | 434 | 100.0% |
| Statements | 487 | 487 | 100.0% |
| Functions | 190 | 190 | 100.0% |
| Branches | 173 | 173 | 100.0% |
| Tests | 187 | ||
| Assertions | 673 | ||
Meet the family
TinyTick is part of a group of small libraries designed to help make rich client and local-first apps easier to build. Check out the others!
TinyBase
A reactive data store and sync engine.
TinyWidgets
A collection of tiny, reusable, UI components.
TinyTick
A tiny but very useful task orchestrator.