ZeroPromise

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

import { ZeroPromise, Get } 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 / asyncAction pass { zero } into fetchers
async function load({ zero }: { zero: ZeroPromise }) {
  const res = await fetch('/api/data', { signal: zero.signal });
  return res.json();
}

Overview

ZeroPromise<T> is a Promise-compatible wrapper with explicit lifecycle: active → resolved | rejected | cancelled. It exposes .signal (AbortSignal) and .cancel() so fetchers and UI can abort in-flight work.

Mates HTTP helpers return ZeroPromise. asyncAtom / asyncAction inject the current run as { zero } so you can pass zero.signal into fetch or call zero.cancel().

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'));

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.