ZeroPromise

Cancellable promise with AbortSignal — used by Fetch, asyncAtom, and asyncAction.

import { ZeroPromise, Get, Post, asyncAction } from 'mates';

// Manual ZeroPromise — resolve / reject / cancel
const zp = new ZeroPromise<string>();
zp.signal;           // AbortSignal
zp.isActive();       // true until settled
zp.resolve('ok');    // or zp.reject(err) / zp.cancel()
await zp;            // Promise-compatible (.then / .catch / .finally)

// Fetch helpers return ZeroPromise — cancel aborts the request
const req = Get<{ id: number }>('/api/item/1');
req.cancel();        // AbortError

// asyncAtom passes the current run as { zero }
async function load({ zero }) {
  const res = await fetch('/api/data', { signal: zero.signal });
  return res.json();
}

// asyncAction / taskAction cancel a ZeroPromise you return
const save = asyncAction(() => Post({ url: '/api/save', body: { name: 'Ada' } }));
save.cancel();

Overview

ZeroPromise<T> is a Promise you can cancel. It starts active, then settles to resolved, rejected, or cancelled. .signal is an AbortSignal. await, .then, .catch, and .finally work like a normal Promise.

Get, Post, Put, Patch, Delete, and Fetch return a ZeroPromise. Call .cancel() on that handle to abort the request.

asyncAtom passes the current run as { zero }. Pass zero.signal into fetch. asyncAction and taskAction watch a ZeroPromise you return: their cancel() / stop() call .cancel() on it. They recognize it by __isZeroPromise__.

ZeroPromise vs Promise

API	Cancel	State
`Promise`	No built-in cancel	Settles once; no AbortSignal.
`ZeroPromise`	`.cancel()` + `.signal`	`isActive / isResolved / isRejected / isCancelled`.

Resolve vs cancel

Start a 2s ZeroPromise, then cancel before it resolves. Status tracks active / resolved / cancelled.

import { html, atom, ZeroPromise, renderApp } from 'mates';

const App = () => {

const status = atom('idle');

const result = atom('');

let current = null;

const start = () => {

current = new ZeroPromise();

status.set('active');

result.set('');

const timer = setTimeout(() => {

if (current && current.isActive()) {

current.resolve('finished after 2s');

}

}, 2000);

current

.then((v) => { status.set('resolved'); result.set(v); })

.catch((e) => {

clearTimeout(timer);

status.set(e.name === 'AbortError' ? 'cancelled' : 'rejected');

result.set(e.message || String(e));

});

};

const cancel = () => { current?.cancel(); };

return () => html`

Start 2s work

</button>

Cancel

</button>

AbortSignal + fetch

Pass zero.signal into fetch. Cancel aborts the network request.

import { html, atom, ZeroPromise, renderApp } from 'mates';

const App = () => {

const note = atom('Idle');

let current = null;

const run = () => {

current = new ZeroPromise();

note.set('fetching…');

fetch('https://jsonplaceholder.typicode.com/todos/1', {

signal: current.signal,

})

.then((r) => r.json())

.then((todo) => {

current.resolve(todo.title);

note.set(todo.title);

})

.catch((e) => {

if (e.name === 'AbortError') note.set('aborted');

else note.set(e.message);

current.reject(e);

});

};

return () => html`

<button class="btn-primary" @click=${run}>Fetch with signal</button>

<button class="btn-danger" @click=${() => current?.cancel()}>Abort</button>

</div>

</div>

};

renderApp(App, document.getElementById('app'));

Cancel a Get()

HTTP helpers already return a ZeroPromise. cancel() aborts that request with AbortError.

import { html, atom, Get, renderApp } from 'mates';

const App = () => {

const note = atom('idle');

let req = null;

const load = () => {

note.set('loading');

req = Get('https://jsonplaceholder.typicode.com/todos/1');

req

.then((todo) => note.set(todo.title))

.catch((e) => note.set(e.name === 'AbortError' ? 'cancelled' : e.message));

};

return () => html`

<button class="btn-danger" @click=${() => req?.cancel()}>Cancel</button>

</div>

</div>

};

renderApp(App, document.getElementById('app'));

API — ZeroPromise

import { ZeroPromise } from 'mates'

Prop / Option	Type	Default	Description
`new ZeroPromise<T>()`	`ZeroPromise`	—	Starts in active state with a fresh AbortController.
`.signal`	`AbortSignal`	—	Pass to fetch / AbortController consumers.
`.resolve(value) / .reject(error)`	`void`	—	Settle while active; no-ops afterward.
`.cancel(reason?)`	`void`	—	Abort signal; reject with AbortError.
`.isActive / .isResolved / .isRejected / .isCancelled`	`() => boolean`	—	State predicates.
`.toActive()`	`this`	—	Reset to a new active promise (advanced reuse).
`.then / .catch / .finally`	`Promise methods`	—	Delegates to the underlying Promise — await works.
`.__isZeroPromise__`	`true`	—	Runtime discriminator used by asyncAction / asyncAtom.