ctrl-fx 0.1.0 → 0.1.2

package/dist/effects.js

@@ -1,1556 +1,111 @@
-import { getJson, } from './net';
-import { parseInternalLocation } from './net/location';
-import {} from './utils/lens';
-import { failure, success } from './utils/result';
-/** Creates a typed TaskId from a plain string. */
-export function taskId(id) {
-    return id;
-}
-/**
- * Creates a factory for effects that call an external library function.
- * Use this when you want to call a library whose logic would be too cumbersome
- * to reimplement using built-in effects. In production `f` is called directly.
- * In tests the `test` callback receives the arguments and a queue of scripted
- * return values (`data`), and must return `{ out, data }` where `data` is the
- * remaining queue after consuming one entry.
- *
- * @param f Production implementation. May return a Promise.
- * @param test Test-time implementation. Receives the scripted data queue and
- *   returns `{ out, data }` — `out` is the value to return, `data` is the
- *   remaining queue. Provide scripted values via `newTestData(queue)`.
- */
-export function customEffect(f, test) {
-    return (args) => ({
-        _type: 'Suspend',
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        operation: { _type: 'CustomEffect', input: { args, f, test } },
-        flatMap(fn) {
-            return flatMap(this, fn);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(fn) {
-            return flatMap(this, out => pure(fn(out)));
-        },
-        as(b) {
-            return flatMap(this, _ => pure(b));
-        },
-        void() {
-            return this.map(_out => { });
-        },
-        apply(fn) {
-            return fn(this);
-        },
-    });
-}
-function flatMap(effect, next) {
-    return {
-        _type: 'FlatMap',
-        effect,
-        next,
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return this.flatMap(b => pure(f(b)));
-        },
-        as(c) {
-            return this.flatMap(_ => pure(c));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/**
- * Wraps a plain value in an Effect that completes immediately without performing any operations.
- * Useful as a base case when building effects conditionally, or to lift a
- * computed value into the Effect chain.
- */
-export function pure(value) {
-    return {
-        _type: 'Return',
-        value,
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, a => pure(f(a)));
-        },
-        as(b) {
-            return flatMap(this, _ => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing a browser alert dialog. */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function alert(message) {
-    return {
-        _type: 'Suspend',
-        operation: {
-            _type: 'Alert',
-            input: message,
-        },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, () => pure(f()));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/**
- * An effect describing a browser confirm dialog.
- * @returns true if confirmed
- */
-export function confirm(message) {
-    return {
-        _type: 'Suspend',
-        operation: { _type: 'Confirm', input: message },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, b => pure(f(b)));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/**
- * An effect describing a browser prompt dialog.
- * @returns the entered string, or null if cancelled
- */
-export function prompt(message, defaultValue) {
-    return {
-        _type: 'Suspend',
-        operation: { _type: 'Prompt', input: { message, default: defaultValue } },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, s => pure(f(s)));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing a clear of the app badge on the browser/OS icon. */
-export function clearAppBadge() {
-    return {
-        _type: 'Suspend',
-        operation: { _type: 'ClearAppBadge', input: undefined },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, () => pure(f()));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing a clipboard text read. */
-export function readClipboard() {
-    return {
-        _type: 'Suspend',
-        operation: { _type: 'ReadClipboard', input: undefined },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, result => pure(f(result)));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing a clipboard write of `text`. */
-export function writeClipboard(text) {
-    return {
-        _type: 'Suspend',
-        operation: { _type: 'WriteClipboard', input: text },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, result => pure(f(result)));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing a `document.title` update. */
-export function setDocumentTitle(title) {
-    return {
-        _type: 'Suspend',
-        operation: { _type: 'SetDocumentTitle', input: title },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, () => pure(f()));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing an app badge count update on the browser/OS icon. */
-export function setAppBadge(count) {
-    return {
-        _type: 'Suspend',
-        operation: { _type: 'SetAppBadge', input: count },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, () => pure(f()));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/**
- * An effect describing fire-and-forget async dispatch of `effect`.
- * The chain continues without waiting for `effect` to complete.
- * Use `scheduleTask` instead if you need cancellation or debounce/repeat behaviour.
- */
-export function async(effect, delayInMillis = 0) {
-    return {
-        _type: 'Suspend',
-        operation: {
-            _type: 'Async',
-            input: { effect, delayInMillis },
-        },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, _ => pure(f()));
-        },
-        as(b) {
-            return flatMap(this, _ => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing the cancellation of a previously scheduled task. */
-export function cancelTask(taskId) {
-    return {
-        _type: 'Suspend',
-        operation: {
-            _type: 'CancelTask',
-            input: taskId,
-        },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, () => pure(f()));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/**
- * An effect describing a typed component event to be delivered to any `onEvent` listener
- * registered by the parent that mounted this component. Has no effect when
- * used in a top-level application (which has no parent).
- */
-export function fireEvent(event) {
-    return {
-        _type: 'Suspend',
-        operation: {
-            _type: 'FireEvent',
-            input: event,
-        },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, () => pure(f()));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing a UUID v4 generation. */
-export function generateUuid() {
-    return {
-        _type: 'Suspend',
-        operation: {
-            _type: 'GenerateUuid',
-            input: undefined,
-        },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, (uuid) => pure(f(uuid)));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing a read of the current time. */
-export function getTime() {
-    return {
-        _type: 'Suspend',
-        operation: {
-            _type: 'GetTime',
-            input: undefined,
-        },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, (date) => pure(f(date)));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing a random number in [0, 1), equivalent to Math.random(). */
-export function getRandom() {
-    return {
-        _type: 'Suspend',
-        operation: {
-            _type: 'GetRandom',
-            input: undefined,
-        },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, n => pure(f(n)));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing a console log of `message`. */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function log(message) {
-    return {
-        _type: 'Suspend',
-        operation: {
-            _type: 'Log',
-            input: message,
-        },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, () => pure(f()));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing an HTTP request. */
-export function makeHttpRequest(request) {
-    return {
-        _type: 'Suspend',
-        operation: {
-            _type: 'MakeHttpRequest',
-            input: request,
-        },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, result => pure(f(result)));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing a read of the current browser location. */
-export function getLocation() {
-    return {
-        _type: 'Suspend',
-        operation: { _type: 'GetLocation', input: undefined },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, loc => pure(f(loc)));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing a read of the current notification permission state. */
-export function getNotificationPermission() {
-    return {
-        _type: 'Suspend',
-        operation: { _type: 'GetNotificationPermission', input: undefined },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, p => pure(f(p)));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing a notification permission request. */
-export function requestNotificationPermission() {
-    return {
-        _type: 'Suspend',
-        operation: { _type: 'RequestNotificationPermission', input: undefined },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, p => pure(f(p)));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/**
- * An effect describing a read of the current application state. Because state updates are
- * themselves effects sequenced in order, the value produced reflects all
- * `updateState` effects that appear earlier in the same effect chain.
- */
-export function getState() {
-    return {
-        _type: 'Suspend',
-        operation: {
-            _type: 'GetState',
-            input: undefined,
-        },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, (state) => pure(f(state)));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/**
- * An effect describing two concurrent sub-effects, returning both results as a tuple `[A, B]`.
- * Both effects share the same initial state snapshot; neither sees state
- * changes made by the other. Use `flatMap` instead when the second effect
- * must observe state updates from the first.
- */
-export function product(effectA, effectB) {
-    return {
-        _type: 'Suspend',
-        operation: {
-            _type: 'Product',
-            input: [effectA, effectB],
-        },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, aAndB => pure(f(aAndB)));
-        },
-        as(c) {
-            return flatMap(this, _ => pure(c));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/**
- * An effect describing the scheduling of `task` to run after `initialDelayInMillis` milliseconds.
- *
- * If `taskId` is provided and a task with that id is already pending, the
- * pending task is cancelled and replaced. This makes `scheduleTask` the
- * idiomatic way to implement debouncing: use the same `taskId` on
- * every keystroke and only the final one will fire.
- *
- * @param repeatIntervalInMillis If provided, the task repeats on this interval
- *   indefinitely after the initial delay. Cancel with `cancelTask`.
- * @param taskId Stable identifier used to cancel-and-reschedule. Create one
- *   with `taskId('name')` and store it as a module-level constant.
- * @returns The TaskId of the newly scheduled task.
- */
-export function scheduleTask(task, initialDelayInMillis, repeatIntervalInMillis, taskId) {
-    return {
-        _type: 'Suspend',
-        operation: {
-            _type: 'ScheduleTask',
-            input: {
-                task,
-                initialDelayInMillis,
-                repeatIntervalInMillis,
-                taskId,
-            },
-        },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, (taskId) => pure(f(taskId)));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing a delay of `delayInMilliseconds` ms before continuing the chain. */
-export function setTimeout(delayInMilliseconds) {
-    return {
-        _type: 'Suspend',
-        operation: {
-            _type: 'SetTimeout',
-            input: delayInMilliseconds,
-        },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, () => pure(f()));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing a state update via `f`. */
-export function updateState(f) {
-    return {
-        _type: 'Suspend',
-        operation: {
-            _type: 'UpdateState',
-            input: f,
-        },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, () => pure(f()));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing an IndexedDB database open (or create), with `setup` applied for schema migrations. */
-export function openDatabase(db, version, setup) {
-    return {
-        _type: 'Suspend',
-        operation: { _type: 'OpenDatabase', input: { db, version, setup } },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, result => pure(f(result)));
-        },
-        as(b) {
-            return flatMap(this, _ => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing an IndexedDB transaction containing `effect`. */
-export function runDbTransaction(db, objectStores, mode, effect) {
-    return {
-        _type: 'Suspend',
-        operation: {
-            _type: 'RunDbTransaction',
-            input: { db, objectStores, mode, effect },
-        },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, result => pure(f(result)));
-        },
-        as(b) {
-            return flatMap(this, _ => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-function storageEffect(storage, key, value, tag) {
-    const input = tag === 'SetStorageItem'
-        ? { storage, key, value: value }
-        : tag === 'ClearStorage'
-            ? { storage }
-            : { storage, key };
-    return {
-        _type: 'Suspend',
-        operation: { _type: tag, input },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(e) {
-            return flatMap(this, _ => e);
-        },
-        map(f) {
-            return flatMap(this, a => pure(f(a)));
-        },
-        as(b) {
-            return flatMap(this, _ => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing a browser history navigation of `delta` steps. */
-export function go(delta) {
-    return {
-        _type: 'Suspend',
-        operation: { _type: 'Go', input: delta },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, () => pure(f()));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing a `history.pushState` to `location`. */
-export function pushState(location) {
-    const loc = typeof location === 'string' ? parseInternalLocation(location) : location;
-    return {
-        _type: 'Suspend',
-        operation: { _type: 'PushState', input: loc },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, () => pure(f()));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing a `history.replaceState` with `location`. */
-export function replaceState(location) {
-    const loc = typeof location === 'string' ? parseInternalLocation(location) : location;
-    return {
-        _type: 'Suspend',
-        operation: { _type: 'ReplaceState', input: loc },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, () => pure(f()));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing a localStorage read for `key`. */
-export function getLocalStorageItem(key) {
-    return storageEffect('local', key, undefined, 'GetStorageItem');
-}
-/** An effect describing a localStorage write of `value` for `key`. */
-export function setLocalStorageItem(key, value) {
-    return storageEffect('local', key, value, 'SetStorageItem');
-}
-/** An effect describing the removal of `key` from localStorage. */
-export function removeLocalStorageItem(key) {
-    return storageEffect('local', key, undefined, 'RemoveStorageItem');
-}
-/** An effect describing a localStorage clear. */
-export function clearLocalStorage() {
-    return storageEffect('local', '', undefined, 'ClearStorage');
-}
-/** An effect describing a sessionStorage read for `key`. */
-export function getSessionStorageItem(key) {
-    return storageEffect('session', key, undefined, 'GetStorageItem');
-}
-/** An effect describing a sessionStorage write of `value` for `key`. */
-export function setSessionStorageItem(key, value) {
-    return storageEffect('session', key, value, 'SetStorageItem');
-}
-/** An effect describing the removal of `key` from sessionStorage. */
-export function removeSessionStorageItem(key) {
-    return storageEffect('session', key, undefined, 'RemoveStorageItem');
-}
-/** An effect describing a sessionStorage clear. */
-export function clearSessionStorage() {
-    return storageEffect('session', '', undefined, 'ClearStorage');
-}
-/**
- * Transforms the `Event` type of an effect by mapping each fired event through `f`.
- * Used when composing components: a child component fires `EventA`, and the
- * parent needs to convert those into its own `EventB` before wiring them up.
- * You rarely need to call this directly — `ComponentElement.onEvent` handles it.
- */
-export function mapEvent(effect, f) {
-    switch (effect._type) {
-        case 'Return': {
-            return pure(effect.value);
-        }
-        case 'FlatMap': {
-            return flatMap(mapEvent(effect.effect, f), x => {
-                return mapEvent(effect.next(x), f);
-            });
-        }
-        case 'Suspend': {
-            switch (effect.operation._type) {
-                case 'Alert':
-                case 'CancelTask':
-                case 'ClearAppBadge':
-                case 'ClearStorage':
-                case 'Confirm':
-                case 'CustomEffect':
-                case 'Download':
-                case 'GenerateUuid':
-                case 'GetLocation':
-                case 'GetNotificationPermission':
-                case 'RequestNotificationPermission':
-                case 'GetState':
-                case 'GetStorageItem':
-                case 'GetTime':
-                case 'GetRandom':
-                case 'Log':
-                case 'PostBroadcastMessage':
-                case 'Prompt':
-                case 'MakeHttpRequest':
-                case 'Go':
-                case 'OpenDatabase':
-                case 'PushState':
-                case 'ReplaceState':
-                case 'RemoveStorageItem':
-                case 'ReadClipboard':
-                case 'RunDbTransaction':
-                case 'ScrollElement':
-                case 'ScrollWindow':
-                case 'SetAppBadge':
-                case 'SetDocumentTitle':
-                case 'SetStorageItem':
-                case 'SetTimeout':
-                case 'UpdateState':
-                case 'WriteClipboard': {
-                    return effect;
-                }
-                case 'SubscribeToBroadcastChannel': {
-                    return subscribeToBroadcastChannel(effect.operation.input.channel, msg => mapEvent(effect.operation.input.handler(msg), f), effect.operation.input.taskId);
-                }
-                case 'ScheduleTask': {
-                    return scheduleTask(mapEvent(effect.operation.input.task, f), effect.operation.input.initialDelayInMillis, effect.operation.input.repeatIntervalInMillis, effect.operation.input.taskId);
-                }
-                case 'Async': {
-                    return async(mapEvent(effect.operation.input.effect, f), effect.operation.input.delayInMillis);
-                }
-                case 'Product': {
-                    return product(mapEvent(effect.operation.input[0], f), mapEvent(effect.operation.input[1], f));
-                }
-                case 'FireEvent':
-                    return fireEvent(f(effect.operation.input));
-            }
-        }
-    }
-}
-/**
- * Adapts an effect written against a sub-state `StateA` so it can run in a
- * parent context with state `StateB`. The lens provides the `get`/`set`
- * functions that translate between the two state shapes.
- * Used when composing components whose effects operate on a slice of a larger state.
- */
-export function mapState(effect, lens) {
-    switch (effect._type) {
-        case 'Return': {
-            return pure(effect.value);
-        }
-        case 'FlatMap': {
-            return flatMap(mapState(effect.effect, lens), x => {
-                return mapState(effect.next(x), lens);
-            });
-        }
-        case 'Suspend': {
-            switch (effect.operation._type) {
-                case 'Alert':
-                case 'CancelTask':
-                case 'ClearAppBadge':
-                case 'ClearStorage':
-                case 'Confirm':
-                case 'CustomEffect':
-                case 'Download':
-                case 'FireEvent':
-                case 'GenerateUuid':
-                case 'GetLocation':
-                case 'GetNotificationPermission':
-                case 'RequestNotificationPermission':
-                case 'PostBroadcastMessage':
-                case 'Prompt':
-                case 'GetStorageItem':
-                case 'GetTime':
-                case 'GetRandom':
-                case 'Log':
-                case 'MakeHttpRequest':
-                case 'Go':
-                case 'OpenDatabase':
-                case 'PushState':
-                case 'ReplaceState':
-                case 'RemoveStorageItem':
-                case 'ReadClipboard':
-                case 'RunDbTransaction':
-                case 'ScrollElement':
-                case 'ScrollWindow':
-                case 'SetAppBadge':
-                case 'SetDocumentTitle':
-                case 'SetStorageItem':
-                case 'SetTimeout':
-                case 'WriteClipboard': {
-                    return effect;
-                }
-                case 'SubscribeToBroadcastChannel': {
-                    return subscribeToBroadcastChannel(effect.operation.input.channel, msg => mapState(effect.operation.input.handler(msg), lens), effect.operation.input.taskId);
-                }
-                case 'Async': {
-                    return async(mapState(effect.operation.input.effect, lens), effect.operation.input.delayInMillis);
-                }
-                case 'ScheduleTask': {
-                    return scheduleTask(mapState(effect.operation.input.task, lens), effect.operation.input.initialDelayInMillis, effect.operation.input.repeatIntervalInMillis, effect.operation.input.taskId);
-                }
-                case 'Product': {
-                    return product(mapState(effect.operation.input[0], lens), mapState(effect.operation.input[1], lens));
-                }
-                case 'UpdateState': {
-                    return updateState((stateB) => {
-                        const stateAUpdate = effect.operation.input;
-                        const stateA = lens.get(stateB);
-                        const updatedStateA = stateAUpdate(stateA);
-                        return lens.set(stateB, updatedStateA);
-                    });
-                }
-                case 'GetState':
-                    return getState().map(b => {
-                        return lens.get(b);
-                    });
-            }
-        }
-    }
-}
-/** Returns true if `value` is an Effect. */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function isEffect(value) {
-    if (value === null || value === undefined) {
-        return false;
-    }
-    if (typeof value !== 'object') {
-        return false;
-    }
-    if (value['_type'] === 'Return') {
-        return Object.prototype.hasOwnProperty.call(value, 'value');
-    }
-    else if (value['_type'] === 'Suspend') {
-        return Object.prototype.hasOwnProperty.call(value, 'operation');
-    }
-    else if (value['_type'] === 'FlatMap') {
-        return Object.prototype.hasOwnProperty.call(value, 'effect');
-    }
-    else {
-        return false;
-    }
-}
-/*
-function interpreter<State, Event, A>(
-  state: State,
-  effect: Effect<State, Event, A>
-): [State, A] {
-  switch (effect._type) {
-    case 'Return':
-      return [state, effect.value]
-    case 'FlatMap':
-      const [state2, result] = interpreter(state, effect.effect)
-      return interpreter(state2, effect.next(result))
-    case 'Suspend':
-      switch (effect.operation._type) {
-        case 'Alert':
-          console.log("ALERT: " + effect.operation.input)
-          return [state, undefined as A]
-        case 'Async': {
-          return todo()
-        }
-        case 'ClearAppBadge': {
-          return todo()
-        }
-        case 'GetState':
-          return [state, state as unknown as A]
-        case 'GetTime':
-          return [state, new Date() as A]
-        case 'FireEvent':
-          console.log("FIRING EVENT " + effect.operation.input)
-          return [state, undefined as A]
-        case 'Log':
-          console.log(effect.operation.input)
-          return [state, undefined as A]
-        case 'MakeHttpRequest': {
-          return todo()
-        }
-        case 'UpdateState':
-          const state2 = effect.operation.input(state)
-          return [state2, undefined as A]
-      }
-  }
-}
-
-export function run<State, Event, A>(
-  state: State,
-  effect: Effect<State, Event, A>
-): A {
-  const [_, a] = interpreter(state, effect)
-  return a
-}
-
-type AppState = {
-  count: number
-}
-
-export const prog1 =
-  getState<AppState, unknown>()
-    .flatMap(state => {
-      const msg = "The count is " + state.count
-      return log(msg)
-    })
-    .and(updateState(s => ({ count: s.count + 1 })))
-    .and(getState())
-    .flatMap(state => {
-      const msg = "The count is now " + state.count
-      return log(msg)
-    })
-
-export const prog2 =
-  getState<AppState, unknown>()
-    .flatMap(state => {
-      const msg = "The count is " + state.count
-      return log(msg)
-    })
-
-
-type OuterState = {
-  newField: boolean
-  appState: AppState
-}
-
-const lens = lensFromProp<OuterState>()('appState')
-
-const changedProg = mapState(prog1, lens)
-
-
-run({ newField: true, appState: { count: 2 } }, changedProg)
-*/
-/** An effect describing a window scroll. */
-export function scrollWindow(options) {
-    return {
-        _type: 'Suspend',
-        operation: { _type: 'ScrollWindow', input: options },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, () => pure(f()));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing a scroll of the element matching `selector`. */
-export function scrollElement(selector, options) {
-    return {
-        _type: 'Suspend',
-        operation: { _type: 'ScrollElement', input: { selector, options } },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, result => pure(f(result)));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing a file download. */
-export function download(filename, content, contentType = 'text/plain') {
-    return {
-        _type: 'Suspend',
-        operation: { _type: 'Download', input: { filename, content, contentType } },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, () => pure(f()));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An effect describing a BroadcastChannel message post. */
-export function postBroadcastMessage(channel, message) {
-    return {
-        _type: 'Suspend',
-        operation: { _type: 'PostBroadcastMessage', input: { channel, message } },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, () => pure(f()));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_b => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/**
- * An effect describing a BroadcastChannel subscription, with `handler` called for each message received.
- * @returns a TaskId that can be used to cancel the subscription
- */
-export function subscribeToBroadcastChannel(channel, handler, taskId = undefined) {
-    return {
-        _type: 'Suspend',
-        operation: {
-            _type: 'SubscribeToBroadcastChannel',
-            input: { channel, handler, taskId },
-        },
-        flatMap(f) {
-            return flatMap(this, f);
-        },
-        and(effect) {
-            return flatMap(this, _ => effect);
-        },
-        map(f) {
-            return flatMap(this, id => pure(f(id)));
-        },
-        as(b) {
-            return flatMap(this, () => pure(b));
-        },
-        void() {
-            return this.map(_id => { });
-        },
-        apply(f) {
-            return f(this);
-        },
-    };
-}
-/** An Effect that does nothing. */
-export function noop() {
-    return pure(undefined);
-}
-/**
- * Returns all built-in effect constructors with `State` and `Event` pre-applied.
- * Call this once per module, passing your application's state and event types,
- * and destructure the effects you need. This removes the need to repeat the
- * type parameters at every call site.
- *
- * ```ts
- * const { updateState, getTime, scheduleTask } = makeEffects<MyState, MyEvent>()
- * ```
- */
-export function makeEffects() {
-    return {
-        alert: (alert),
-        confirm: (confirm),
-        prompt: (prompt),
-        cancelTask: (cancelTask),
-        getLocation: (getLocation),
-        getNotificationPermission: (getNotificationPermission),
-        requestNotificationPermission: (requestNotificationPermission),
-        clearAppBadge: (clearAppBadge),
-        readClipboard: (readClipboard),
-        setAppBadge: (setAppBadge),
-        setDocumentTitle: (setDocumentTitle),
-        writeClipboard: (writeClipboard),
-        fireEvent: (fireEvent),
-        getState: (getState),
-        getTime: (getTime),
-        getRandom: (getRandom),
-        log: (log),
-        makeHttpRequest: (makeHttpRequest),
-        scheduleTask: (scheduleTask),
-        setTimeout: (setTimeout),
-        updateState: (updateState),
-        pure(a) {
-            return pure(a);
-        },
-        noop: (noop),
-        generateUuid: (generateUuid),
-        getJson: (getJson),
-        go: (go),
-        scrollWindow: (scrollWindow),
-        scrollElement: (scrollElement),
-        download: (download),
-        postBroadcastMessage: (postBroadcastMessage),
-        subscribeToBroadcastChannel: (subscribeToBroadcastChannel),
-        pushState: (pushState),
-        replaceState: (replaceState),
-        getLocalStorageItem: (getLocalStorageItem),
-        setLocalStorageItem: (setLocalStorageItem),
-        removeLocalStorageItem: (removeLocalStorageItem),
-        clearLocalStorage: (clearLocalStorage),
-        getSessionStorageItem: (getSessionStorageItem),
-        setSessionStorageItem: (setSessionStorageItem),
-        removeSessionStorageItem: (removeSessionStorageItem),
-        clearSessionStorage: (clearSessionStorage),
-        resultT(effect) {
-            return resultT(effect);
-        },
-    };
-}
-/**
- * Maps each element of `as` to an effect and runs them in sequence, collecting
- * all results into an array. Each effect runs after the previous one completes,
- * so state changes from earlier effects are visible to later ones.
- */
-export function traverse(as, f) {
-    const effects = as.map(f);
-    if (effects.length === 0) {
-        return pure([]);
-    }
-    return effects.reduce((acc, effect) => {
-        return product(acc, effect).map(bsAndB => {
-            return [...bsAndB[0], bsAndB[1]];
-        });
-    }, pure([]));
-}
-/**
- * Wraps an `Effect<State, Event, Result<A, E>>` to allow chaining on the
- * success and error branches without manually unwrapping the `Result` at each
- * step. Methods like `flatMap` and `errorFlatMap` short-circuit on the other
- * branch. Call `.value` to get the underlying effect back.
- */
-export class ResultTransformer {
-    constructor(value) {
-        /** The underlying wrapped effect. */
-        Object.defineProperty(this, "value", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.value = value;
-    }
-    /** Transforms the success value. */
-    map(f) {
-        return new ResultTransformer(this.value.map(res => {
-            return res.map(f);
-        }));
-    }
-    /** Replaces the success value with `b`. */
-    as(b) {
-        return new ResultTransformer(this.value.map(res => {
-            return res.map(_ => b);
-        }));
-    }
-    /** Discards the success value. */
-    void() {
-        return new ResultTransformer(this.value.map(res => {
-            return res.map(_ => { });
-        }));
-    }
-    /** Discards the error value. */
-    errorVoid() {
-        return this.errorMap(_ => { });
-    }
-    /** Chains on success, short-circuits on failure. */
-    flatMap(f) {
-        return new ResultTransformer(this.value.flatMap(res => {
-            switch (res._tag) {
-                case 'failure':
-                    return pure(failure(res.error));
-                case 'success':
-                    return f(res.value);
-            }
-        }));
-    }
-    /** Like `flatMap` but `f` returns an unwrapped Effect rather than an Effect of Result. */
-    semiFlatMap(f) {
-        return new ResultTransformer(this.value.flatMap(res => {
-            switch (res._tag) {
-                case 'failure':
-                    return pure(failure(res.error));
-                case 'success':
-                    return f(res.value).map(b => success(b));
-            }
-        }));
-    }
-    /** Sequences on success, short-circuits on failure. */
-    and(effect) {
-        return new ResultTransformer(this.value.flatMap(res => {
-            switch (res._tag) {
-                case 'failure':
-                    return pure(failure(res.error));
-                case 'success':
-                    return effect;
-            }
-        }));
-    }
-    /** Unwraps the Result, returning either the success value or the error. */
-    merge() {
-        return this.value.map(res => res.merge());
-    }
-    /** Logs the error to the console without changing the Result. */
-    logError() {
-        return this.errorFlatMap(e => log(e).map(_ => e));
-    }
-    /** Logs the error and converts it to void. */
-    logAndDropError() {
-        return this.logError().errorVoid();
-    }
-    /** Transforms the error value. */
-    errorMap(f) {
-        return new ResultTransformer(this.value.map(res => res.errorMap(f)));
-    }
-    /** Chains on failure, short-circuits on success. */
-    errorFlatMap(f) {
-        return new ResultTransformer(this.value.flatMap(res => {
-            switch (res._tag) {
-                case 'failure':
-                    return f(res.error).map(e => failure(e));
-                case 'success':
-                    return pure(success(res.value));
-            }
-        }));
-    }
-}
-/**
- * Lifts an `Effect<State, Event, Result<A, E>>` into a `ResultTransformer` for
- * chaining. Equivalent to `new ResultTransformer(effect)`.
- */
-export function resultT(effect) {
-    return new ResultTransformer(effect);
-}
+import {
+  ResultTransformer,
+  alert,
+  async,
+  cancelTask,
+  clearAppBadge,
+  clearLocalStorage,
+  clearSessionStorage,
+  confirm,
+  customEffect,
+  download,
+  fireEvent,
+  generateUuid,
+  getLocalStorageItem,
+  getLocation,
+  getNotificationPermission,
+  getRandom,
+  getSessionStorageItem,
+  getState,
+  getTime,
+  go,
+  isEffect,
+  log,
+  makeEffects,
+  makeHttpRequest,
+  mapEvent,
+  mapState,
+  noop,
+  openDatabase,
+  postBroadcastMessage,
+  product,
+  prompt,
+  pure,
+  pushState,
+  readClipboard,
+  removeLocalStorageItem,
+  removeSessionStorageItem,
+  replaceState,
+  requestNotificationPermission,
+  resultT,
+  runDbTransaction,
+  scheduleTask,
+  scrollElement,
+  scrollWindow,
+  setAppBadge,
+  setDocumentTitle,
+  setLocalStorageItem,
+  setSessionStorageItem,
+  setTimeout,
+  subscribeToBroadcastChannel,
+  taskId,
+  traverse,
+  updateState,
+  writeClipboard
+} from "./chunk-OSIRHKDB.js";
+import "./chunk-PKBMQBKP.js";
+export {
+  ResultTransformer,
+  alert,
+  async,
+  cancelTask,
+  clearAppBadge,
+  clearLocalStorage,
+  clearSessionStorage,
+  confirm,
+  customEffect,
+  download,
+  fireEvent,
+  generateUuid,
+  getLocalStorageItem,
+  getLocation,
+  getNotificationPermission,
+  getRandom,
+  getSessionStorageItem,
+  getState,
+  getTime,
+  go,
+  isEffect,
+  log,
+  makeEffects,
+  makeHttpRequest,
+  mapEvent,
+  mapState,
+  noop,
+  openDatabase,
+  postBroadcastMessage,
+  product,
+  prompt,
+  pure,
+  pushState,
+  readClipboard,
+  removeLocalStorageItem,
+  removeSessionStorageItem,
+  replaceState,
+  requestNotificationPermission,
+  resultT,
+  runDbTransaction,
+  scheduleTask,
+  scrollElement,
+  scrollWindow,
+  setAppBadge,
+  setDocumentTitle,
+  setLocalStorageItem,
+  setSessionStorageItem,
+  setTimeout,
+  subscribeToBroadcastChannel,
+  taskId,
+  traverse,
+  updateState,
+  writeClipboard
+};