@ambarltd/core 0.1.17

package/README.md

@@ -0,0 +1,10 @@
+# Ambar Core
+
+Shared utilities for Ambar projects.
+
+## Notes
+
+- Core shared modules: Maybe, Future, Result, List, etc.
+- Backend-only: router
+- Frontend-only: RemoteData
+- No Express dependency, only @types/express"

package/dist/callable.d.ts

@@ -0,0 +1 @@
+export default function Callable<T extends new (...args: any[]) => any>(classname: T): T & ((...args: ConstructorParameters<T>) => InstanceType<T>);

package/dist/callable.js

@@ -0,0 +1,6 @@
+export default function Callable(classname) {
+    function apply(target, _, argumentsList) {
+        return new target(...argumentsList);
+    }
+    return new Proxy(classname, { apply });
+}

package/dist/future.d.ts

@@ -0,0 +1,102 @@
+import * as F from "fluture";
+import { Result } from "./result";
+import { FutureInstance } from "fluture";
+type Cancel = () => void;
+type Fut<E, C> = {
+    [K in keyof C]: Future<E, C[K]>;
+};
+/**
+ * A lazy asynchronous computation that produces either a rejection value
+ * of type `E` or a success value of type `T`.
+ *
+ * Unlike Promises, Futures are not executed until explicitly forked and
+ * can be safely cancelled. This is a thin wrapper around Fluture.
+ */
+declare class Future<E, T> {
+    readonly inner: FutureInstance<E, T>;
+    /**
+     * Build a cancellable `Future` from an imperative body. Return a cancel
+     * function from `f` to clean up resources (timers, subscriptions, etc.).
+     *
+     * ```ts
+     * const f = Future.create<never, number>((reject, resolve) => {
+     *   const id = setTimeout(() => resolve(42), 1000);
+     *   return () => clearTimeout(id);
+     * });
+     * ```
+     */
+    static create<E, T>(f: (r: F.RejectFunction<E>, a: F.ResolveFunction<T>) => Cancel | void): Future<E, T>;
+    /** For inherently uncancellable operations. Prefer `create` when a cancel path exists. */
+    static createUncancellable<E, T>(f: (r: F.RejectFunction<E>, a: F.ResolveFunction<T>) => void): Future<E, T>;
+    /** Lift a value into an already-resolved `Future`. */
+    static resolve<E, T>(x: T): Future<E, T>;
+    /** Lift a value into an already-rejected `Future`. */
+    static reject<E, T>(x: E): Future<E, T>;
+    /**
+     * Wrap a `Promise` producer. Always produces `Future<Error, T>` — use
+     * `.mapRej()` to narrow the error type. Loses cancellation; use
+     * `Future.create` for operations that must be cancellable.
+     *
+     * Don't double-wrap: pass `() => fn()`, not `async () => { const r = await fn(); return r; }`.
+     */
+    static attemptP<T>(f: () => Promise<T>): Future<Error, T>;
+    /**
+     * Guaranteed resource cleanup. `release` runs whether `consume` succeeds or
+     * fails — use for locks, connections, file descriptors.
+     */
+    static bracket<E, A, B, C>(acquire: Future<E, A>, release: (_: A) => Future<E, C>, consume: (_: A) => Future<E, B>): Future<E, B>;
+    /** Run `xs` with at most `n` in flight concurrently; results are collected in order. */
+    static parallel<E, T>(n: number, xs: Array<Future<E, T>>): Future<E, Array<T>>;
+    /**
+     * Run a named map of futures concurrently and collect results under the same keys.
+     *
+     * ```ts
+     * Future.concurrently({ user: fetchUser(id), posts: fetchPosts(id) })
+     *   .fork(handleError, ({ user, posts }) => render(user, posts));
+     * ```
+     */
+    static concurrently<E, C extends {
+        [k: string]: any;
+    }>(obj: Fut<E, C>): Future<E, C>;
+    /** Map `xs` with `f` and run the resulting futures with unbounded concurrency. */
+    static mapConcurrently<A, E, T>(f: (_: A) => Future<E, T>, xs: Array<A>): Future<E, Array<T>>;
+    /** Run two futures in parallel and pair their results. */
+    static both<E, A, B>(x: Future<E, A>, y: Future<E, B>): Future<E, [A, B]>;
+    /** First to settle wins — useful for timeouts: `Future.race(request, timeout)`. */
+    static race<E, T>(x: Future<E, T>, y: Future<E, T>): Future<E, T>;
+    /** Sequential traversal. Use `parallel` or `mapConcurrently` when order doesn't matter. */
+    static traverse<A, E, T>(f: (_: A) => Future<E, T>, xs: Array<A>): Future<E, Array<T>>;
+    /** Resolve with `value` after `milliseconds`. The timer is cleared if cancelled. */
+    static resolveAfter<E, T>(milliseconds: number, value: T): Future<E, T>;
+    constructor(inner: FutureInstance<E, T>);
+    /** Transform the success value. */
+    map<W>(f: (_: T) => W): Future<E, W>;
+    /** Transform the error value; the future stays rejected. */
+    mapRej<W>(f: (_: E) => W): Future<W, T>;
+    /** Transform both branches in one call. */
+    bimap<F, W>(f: (_: E) => F, g: (_: T) => W): Future<F, W>;
+    /**
+     * Sequential async composition. Short-circuits on rejection.
+     *
+     * ```ts
+     * fetchUser(id).chain(u => fetchPosts(u.id).map(posts => ({ u, posts })));
+     * ```
+     */
+    chain<W>(f: (_: T) => Future<E, W>): Future<E, W>;
+    /** Recover from rejection by returning a new `Future`. */
+    chainRej<F>(f: (_: E) => Future<F, T>): Future<F, T>;
+    /** Branch on both rejected and resolved paths into a single continuation. */
+    bichain<F, W>(f: (_: E) => Future<F, W>, g: (_: T) => Future<F, W>): Future<F, W>;
+    /** Run `act` for its effects regardless of whether `this` settled with success or failure. */
+    finally(act: Future<E, void>): Future<E, T>;
+    /**
+     * Execute the future. Nothing runs until `fork` is called. Returns a `Cancel`
+     * function — store it if cancellation is needed.
+     */
+    fork(f: (_: E) => void, g: (_: T) => void): Cancel;
+    /** Convert to a native `Promise`, mapping the error branch through `f` to an `Error`. */
+    promise(f: (_: E) => Error): Promise<T>;
+    /** Convert to `Promise<Result<E, T>>` — the returned Promise never rejects. */
+    promiseR(): Promise<Result<E, T>>;
+}
+export { Future, type Cancel };

package/dist/future.js

@@ -0,0 +1,164 @@
+import * as F from "fluture";
+import { Success, Failure } from "./result";
+/**
+ * A lazy asynchronous computation that produces either a rejection value
+ * of type `E` or a success value of type `T`.
+ *
+ * Unlike Promises, Futures are not executed until explicitly forked and
+ * can be safely cancelled. This is a thin wrapper around Fluture.
+ */
+class Future {
+    inner;
+    /**
+     * Build a cancellable `Future` from an imperative body. Return a cancel
+     * function from `f` to clean up resources (timers, subscriptions, etc.).
+     *
+     * ```ts
+     * const f = Future.create<never, number>((reject, resolve) => {
+     *   const id = setTimeout(() => resolve(42), 1000);
+     *   return () => clearTimeout(id);
+     * });
+     * ```
+     */
+    static create(f) {
+        return new Future(F.Future((r, a) => {
+            const cancel = f(r, a);
+            return cancel === undefined ? () => { } : cancel;
+        }));
+    }
+    /** For inherently uncancellable operations. Prefer `create` when a cancel path exists. */
+    static createUncancellable(f) {
+        return new Future(F.Future((r, a) => {
+            f(r, a);
+            return () => { }; // No-op cancel function
+        }));
+    }
+    /** Lift a value into an already-resolved `Future`. */
+    static resolve(x) {
+        return new Future(F.resolve(x));
+    }
+    /** Lift a value into an already-rejected `Future`. */
+    static reject(x) {
+        return new Future(F.reject(x));
+    }
+    /**
+     * Wrap a `Promise` producer. Always produces `Future<Error, T>` — use
+     * `.mapRej()` to narrow the error type. Loses cancellation; use
+     * `Future.create` for operations that must be cancellable.
+     *
+     * Don't double-wrap: pass `() => fn()`, not `async () => { const r = await fn(); return r; }`.
+     */
+    static attemptP(f) {
+        return new Future(F.attemptP(f));
+    }
+    /**
+     * Guaranteed resource cleanup. `release` runs whether `consume` succeeds or
+     * fails — use for locks, connections, file descriptors.
+     */
+    static bracket(acquire, release, consume) {
+        return new Future(F.hook(acquire.inner)(x => release(x).inner)(x => consume(x).inner));
+    }
+    /** Run `xs` with at most `n` in flight concurrently; results are collected in order. */
+    static parallel(n, xs) {
+        return new Future(F.parallel(n)(xs.map(f => f.inner)));
+    }
+    /**
+     * Run a named map of futures concurrently and collect results under the same keys.
+     *
+     * ```ts
+     * Future.concurrently({ user: fetchUser(id), posts: fetchPosts(id) })
+     *   .fork(handleError, ({ user, posts }) => render(user, posts));
+     * ```
+     */
+    static concurrently(obj) {
+        const futures = [];
+        Object.keys(obj).forEach((key) => {
+            const fut = obj[key];
+            futures.push(fut.map(value => ({ [key]: value })));
+        });
+        return Future.parallel(Infinity, futures).map(results => results.reduce((acc, x) => Object.assign(acc, x), {}));
+    }
+    /** Map `xs` with `f` and run the resulting futures with unbounded concurrency. */
+    static mapConcurrently(f, xs) {
+        return Future.parallel(Infinity, xs.map(f));
+    }
+    /** Run two futures in parallel and pair their results. */
+    static both(x, y) {
+        return new Future(F.both(x.inner)(y.inner));
+    }
+    /** First to settle wins — useful for timeouts: `Future.race(request, timeout)`. */
+    static race(x, y) {
+        return new Future(F.race(x.inner)(y.inner));
+    }
+    /** Sequential traversal. Use `parallel` or `mapConcurrently` when order doesn't matter. */
+    static traverse(f, xs) {
+        return xs.reduce((acc, x) => acc.chain(ys => f(x).map(y => [...ys, y])), Future.resolve([]));
+    }
+    /** Resolve with `value` after `milliseconds`. The timer is cleared if cancelled. */
+    static resolveAfter(milliseconds, value) {
+        return Future.create((_, res) => {
+            const timer = setTimeout(() => res(value), milliseconds);
+            return function cancel() {
+                clearTimeout(timer);
+            };
+        });
+    }
+    constructor(inner) {
+        this.inner = inner;
+    }
+    /** Transform the success value. */
+    map(f) {
+        return new Future(F.map(f)(this.inner));
+    }
+    /** Transform the error value; the future stays rejected. */
+    mapRej(f) {
+        return new Future(F.mapRej(f)(this.inner));
+    }
+    /** Transform both branches in one call. */
+    bimap(f, g) {
+        return this.map(g).mapRej(f);
+    }
+    /**
+     * Sequential async composition. Short-circuits on rejection.
+     *
+     * ```ts
+     * fetchUser(id).chain(u => fetchPosts(u.id).map(posts => ({ u, posts })));
+     * ```
+     */
+    chain(f) {
+        const g = (x) => f(x).inner;
+        return new Future(F.chain(g)(this.inner));
+    }
+    /** Recover from rejection by returning a new `Future`. */
+    chainRej(f) {
+        const g = (x) => f(x).inner;
+        return new Future(F.chainRej(g)(this.inner));
+    }
+    /** Branch on both rejected and resolved paths into a single continuation. */
+    bichain(f, g) {
+        const h = (x) => f(x).inner;
+        const i = (x) => g(x).inner;
+        return new Future(F.bichain(h)(i)(this.inner));
+    }
+    /** Run `act` for its effects regardless of whether `this` settled with success or failure. */
+    finally(act) {
+        return new Future(F.lastly(act.inner)(this.inner));
+    }
+    /**
+     * Execute the future. Nothing runs until `fork` is called. Returns a `Cancel`
+     * function — store it if cancellation is needed.
+     */
+    fork(f, g) {
+        return F.fork(f)(g)(this.inner);
+    }
+    /** Convert to a native `Promise`, mapping the error branch through `f` to an `Error`. */
+    promise(f) {
+        return F.promise(this.mapRej(f).inner);
+    }
+    /** Convert to `Promise<Result<E, T>>` — the returned Promise never rejects. */
+    promiseR() {
+        const f = this.map(Success).chainRej(e => Future.resolve(Failure(e)));
+        return F.promise(f.inner);
+    }
+}
+export { Future };

package/dist/helpers/object.d.ts

@@ -0,0 +1,9 @@
+export { filterKeys, filterMap, mapValues };
+declare function filterKeys<O extends object, K extends keyof O>(obj: O, pred: <KK extends K>(key: KK, value: O[KK]) => boolean): Partial<O>;
+/** Filter keys and transform values at the same time. */
+declare function filterMap<O extends object, R>(obj: O, fn: <K extends keyof O>(key: K, value: O[K]) => R | undefined): Partial<{
+    [K in keyof O]: R;
+}>;
+declare function mapValues<T extends object, R>(obj: T, fn: <K extends keyof T>(key: K, value: T[K]) => R): {
+    [K in keyof T]: R;
+};

package/dist/helpers/object.js

@@ -0,0 +1,31 @@
+export { filterKeys, filterMap, mapValues };
+function filterKeys(obj, pred) {
+    const result = {};
+    const keys = Object.keys(obj);
+    for (const key of keys) {
+        if (pred(key, obj[key])) {
+            result[key] = obj[key];
+        }
+    }
+    return result;
+}
+/** Filter keys and transform values at the same time. */
+function filterMap(obj, fn) {
+    const result = {};
+    const keys = Object.keys(obj);
+    for (const key of keys) {
+        const mapped = fn(key, obj[key]);
+        if (mapped !== undefined) {
+            result[key] = mapped;
+        }
+    }
+    return result;
+}
+function mapValues(obj, fn) {
+    const out = {};
+    const keys = Object.keys(obj);
+    for (const k of keys) {
+        out[k] = fn(k, obj[k]);
+    }
+    return out;
+}

package/dist/json/decoder.d.ts

@@ -0,0 +1,99 @@
+import { Result } from "../result";
+import { Maybe, Nullable } from "../maybe";
+import { List } from "../list";
+import { Json } from "./types";
+/** Infer the type from a decoder definition. */
+type Infer<A extends Decoder<unknown>> = A extends Decoder<infer B> ? B : never;
+/** A type that can be decoded from JSON. */
+interface FromJSON<T> {
+    decoder(): Decoder<T>;
+}
+/**
+ * A type-safe monadic decoder combinator.
+ *
+ * Use like this:
+ *
+ * ```ts
+ * import * as Decoder from "@ambarltd/core/json/decoder";
+ *
+ * type Test = {
+ *   one: number,
+ *   two: boolean,
+ *   three: {
+ *     inner: string
+ *   }
+ * };
+ *
+ * const testDecoder: Decoder<Test> = object({
+ *   one: Decoder.number,
+ *   two: Decoder.boolean,
+ *   three: Decoder.object({
+ *     inner: Decoder.string
+ *   })
+ * });
+ *
+ * const decodeJSON = (s: string) => Decoder.decode(JSON.parse(s), testDecoder);
+ * ```
+ */
+declare class Decoder<T> {
+    readonly run: (input: unknown) => DecodeResult<T>;
+    constructor(run: (input: unknown) => DecodeResult<T>);
+    chain<W>(f: (v: T) => Decoder<W>): Decoder<W>;
+    map<W>(f: (v: T) => W): Decoder<W>;
+}
+declare function decode<T>(input: unknown, decoder: Decoder<T>): Result<string, T>;
+type DecodeResult<T> = Result<[Path, string], T>;
+type Path = List<string>;
+declare const failure: <T>(msg: string) => DecodeResult<T>;
+declare const fail: <T>(msg: string) => Decoder<T>;
+declare const always: <T>(v: T) => Decoder<T>;
+declare const succeed: <T>(v: T) => Decoder<T>;
+declare const any: Decoder<unknown>;
+/** Use two decoders on the same input. */
+declare const both: <T, U>(left: Decoder<T>, right: Decoder<U>) => Decoder<[T, U]>;
+declare const string: Decoder<string>;
+declare const number: Decoder<number>;
+declare const stringNumber: Decoder<number>;
+declare const boolean: Decoder<boolean>;
+declare const array: <V>(decodeValue: Decoder<V>) => Decoder<Array<V>>;
+type DecoderDef<A> = {
+    [P in keyof A]: Decoder<A[P]> | DecoderOptional<A[P]>;
+};
+/** Ignores extra properties. */
+declare const object: <A>(decoders: DecoderDef<A>) => Decoder<A>;
+type ObjectMap<A> = {
+    [x: string]: A;
+};
+declare const objectMap: <A>(decoder: Decoder<A>) => Decoder<ObjectMap<A>>;
+declare const pair: <L, R>(ldecode: Decoder<L>, rdecode: Decoder<R>) => Decoder<[L, R]>;
+declare const triple: <A, B, C>(pA: Decoder<A>, pB: Decoder<B>, pC: Decoder<C>) => Decoder<[A, B, C]>;
+declare const oneOf: <T extends Decoder<any>[]>(decoders: T) => T[number];
+declare const maybe: <V>(decoder: Decoder<V>) => Decoder<Maybe<V>>;
+declare const nullable: <V>(decoder: Decoder<V>) => Decoder<Nullable<V>>;
+declare const nullP: Decoder<null>;
+declare const undefinedP: Decoder<undefined>;
+/** Useful for parsing tag names in discriminated unions. */
+declare const stringLiteral: <T extends string>(str: T) => Decoder<T>;
+/**
+ * Decoder for a field that may not be present.
+ * If it is absent it will be decoded as `Nothing()`.
+ */
+declare class DecoderOptional<A> {
+    readonly decoder: Decoder<A>;
+    private constructor();
+    static from<A>(d: Decoder<A>): DecoderOptional<Maybe<A>>;
+    map<W>(f: (v: A) => W): DecoderOptional<W>;
+}
+declare const optionalMaybe: <V>(decoder: Decoder<V>) => DecoderOptional<Maybe<V>>;
+declare const optionalNullable: <V>(decoder: Decoder<NonNullable<V>>) => DecoderOptional<Nullable<V>>;
+/** An object field that may be absent. */
+declare const optional: <V>(decoder: Decoder<V>) => DecoderOptional<V | undefined>;
+/** If the field is absent, the default value will be used. */
+declare const optionalDefault: <V>(def: V, decoder: Decoder<V>) => DecoderOptional<V>;
+/** Define a recursive decoder. */
+declare function recursive<A>(f: (p: Decoder<A>) => Decoder<A>): Decoder<A>;
+declare const json: Decoder<Json>;
+declare const stringEnum: <const T extends string[]>(strs: T) => Decoder<T[number]>;
+/** Decode a value from a string by treating the string as a stringified JSON value. */
+declare const stringified: <T>(inner: Decoder<T>) => Decoder<T>;
+export { type FromJSON, type Infer, Decoder, type DecoderOptional, type DecoderDef, type DecodeResult, decode, object, objectMap, pair, array, string, number, boolean, any, json, nullP, stringNumber, undefinedP, oneOf, maybe, nullable, stringLiteral, stringEnum, triple, always, fail, failure, succeed, both, optional, optionalNullable, optionalMaybe, optionalDefault, stringified, recursive, };

package/dist/json/decoder.js

@@ -0,0 +1,213 @@
+import { Success, Failure, traverse } from "../result";
+import { Just, Nothing } from "../maybe";
+import { List } from "../list";
+/**
+ * A type-safe monadic decoder combinator.
+ *
+ * Use like this:
+ *
+ * ```ts
+ * import * as Decoder from "@ambarltd/core/json/decoder";
+ *
+ * type Test = {
+ *   one: number,
+ *   two: boolean,
+ *   three: {
+ *     inner: string
+ *   }
+ * };
+ *
+ * const testDecoder: Decoder<Test> = object({
+ *   one: Decoder.number,
+ *   two: Decoder.boolean,
+ *   three: Decoder.object({
+ *     inner: Decoder.string
+ *   })
+ * });
+ *
+ * const decodeJSON = (s: string) => Decoder.decode(JSON.parse(s), testDecoder);
+ * ```
+ */
+class Decoder {
+    run;
+    constructor(run) {
+        this.run = run;
+    }
+    chain(f) {
+        return new Decoder(u => this.run(u).chain(v => f(v).run(u)));
+    }
+    map(f) {
+        return new Decoder(v => this.run(v).map(f));
+    }
+}
+function decode(input, decoder) {
+    return decoder.run(input).mapFailure(showPath);
+}
+function showPath([path, error]) {
+    return error + ". When parsing: " + Array.from(path).join(".");
+}
+const failure = (msg) => Failure([List.empty(), msg]);
+const fail = (msg) => new Decoder(_ => Failure([List.empty(), msg]));
+const always = (v) => new Decoder(_ => Success(v));
+const succeed = always;
+const any = new Decoder(v => Success(v));
+/** Use two decoders on the same input. */
+const both = (left, right) => new Decoder(u => {
+    const l = left.run(u);
+    if (l instanceof Failure) {
+        return new Failure(l.error);
+    }
+    const r = right.run(u);
+    if (r instanceof Failure) {
+        return new Failure(r.error);
+    }
+    return Success([l.value, r.value]);
+});
+const string = new Decoder(v => typeof v === "string" ? Success(v) : failure("expected string but found " + typeof v));
+const number = new Decoder(v => typeof v === "number" ? Success(v) : failure("expected number but found " + typeof v));
+const stringNumber = string.chain(s => {
+    const v = parseInt(s, 10);
+    return isNaN(v) ? fail("not a valid number: " + s) : succeed(v);
+});
+const boolean = new Decoder(v => typeof v === "boolean" ? Success(v) : failure("expected boolean but found " + typeof v));
+const array = (decodeValue) => new Decoder(input => {
+    if (!Array.isArray(input)) {
+        return failure("expected array but found " + typeof input);
+    }
+    return traverse(List.from(input), decodeValue.run).map(list => Array.from(list));
+});
+/** Ignores extra properties. */
+const object = (decoders) => new Decoder(input => {
+    if (typeof input !== "object" || input === null) {
+        return failure("expected object but found " + typeof input);
+    }
+    const obj = input;
+    const result = {};
+    for (const field in decoders) {
+        const decoder = decoders[field];
+        const decoded = decoder instanceof DecoderOptional ?
+            obj[field] === undefined ?
+                decoder.decoder.run({ nothing: {} })
+                : decoder.decoder.run({ just: obj[field] })
+            : decoder.run(obj[field]);
+        switch (true) {
+            case decoded instanceof Success:
+                result[field] = decoded.value;
+                break;
+            case decoded instanceof Failure: {
+                const [path, msg] = decoded.error;
+                return Failure([List.cons(field, path), msg]);
+            }
+            default:
+                return decoded;
+        }
+    }
+    return Success(result);
+});
+const objectMap = (decoder) => new Decoder(input => {
+    if (typeof input !== "object" || input === null) {
+        return failure("expected object but found " + typeof input);
+    }
+    // object without a prototype or built-in functions.
+    const result = Object.create(null);
+    for (const field in input) {
+        // @ts-ignore
+        const decoded = decoder.run(input[field]);
+        switch (true) {
+            case decoded instanceof Success:
+                result[field] = decoded.value;
+                break;
+            case decoded instanceof Failure: {
+                const [path, msg] = decoded.error;
+                return Failure([List.cons(field, path), msg]);
+            }
+            default:
+                return decoded;
+        }
+    }
+    return Success(result);
+});
+const pair = (ldecode, rdecode) => new Decoder(input => {
+    if (!Array.isArray(input)) {
+        return failure("expected array but found " + typeof input);
+    }
+    if (input.length !== 2) {
+        return failure("expected array with 2 elements but it found " + input.length);
+    }
+    const [l, r] = input;
+    return ldecode.run(l).chain(left => rdecode.run(r).chain(right => Success([left, right])));
+});
+const triple = (pA, pB, pC) => new Decoder(input => {
+    if (!Array.isArray(input)) {
+        return failure("expected array but found " + typeof input);
+    }
+    if (input.length !== 3) {
+        return failure("expected array with 3 elements but it found " + input.length);
+    }
+    const [ia, ib, ic] = input;
+    return pA.run(ia).chain(a => pB.run(ib).chain(b => pC.run(ic).chain(c => Success([a, b, c]))));
+});
+const oneOf = (decoders) => new Decoder(input => {
+    let decoded = failure("no decoders");
+    const errors = [];
+    for (const decoder of decoders) {
+        decoded = decoder.run(input);
+        if (decoded instanceof Success) {
+            return decoded;
+        }
+        errors.push(decoded.error);
+    }
+    return Failure([List.empty(), errors.map(showPath).join("\n")]);
+});
+const maybe = (decoder) => oneOf([object({ nothing: object({}) }).map(_ => Nothing()), object({ just: decoder }).map(v => Just(v.just))]);
+const nullable = (decoder) => oneOf([nullP, decoder]);
+const nullP = new Decoder(v => v === null ? Success(null) : failure("expected null but found " + typeof v));
+const undefinedP = new Decoder(v => v === undefined ? Success(undefined) : failure("expected `undefined` " + typeof v));
+/** Useful for parsing tag names in discriminated unions. */
+const stringLiteral = (str) => new Decoder(v => (v === str ? Success(v) : failure(`expected '${str}' but found '${v}'`)));
+/**
+ * Decoder for a field that may not be present.
+ * If it is absent it will be decoded as `Nothing()`.
+ */
+class DecoderOptional {
+    decoder;
+    constructor(decoder) {
+        this.decoder = decoder;
+    }
+    static from(d) {
+        return new DecoderOptional(maybe(d));
+    }
+    map(f) {
+        return new DecoderOptional(this.decoder.map(f));
+    }
+}
+const optionalMaybe = (decoder) => DecoderOptional.from(decoder);
+const optionalNullable = (decoder) => optionalMaybe(decoder).map(v => v.asNullable());
+/** An object field that may be absent. */
+const optional = (decoder) => optionalMaybe(decoder).map(v => (v instanceof Nothing ? undefined : v.value));
+/** If the field is absent, the default value will be used. */
+const optionalDefault = (def, decoder) => {
+    return optionalMaybe(decoder).map(v => v.withDefault(def));
+};
+/** Define a recursive decoder. */
+function recursive(f) {
+    const base = fail("A recursive decoder cannot immediately call itself.");
+    const top = f(base);
+    // @ts-expect-error will complain that 'run' is readonly. But we are doing this on purpose here.
+    base.run = top.run;
+    return top;
+}
+const json = recursive(json => oneOf([nullP, string, number, boolean, array(json), objectMap(json)]));
+const stringEnum = (strs) => oneOf(strs.map(stringLiteral));
+/** Decode a value from a string by treating the string as a stringified JSON value. */
+const stringified = (inner) => string
+    .chain(str => {
+    try {
+        return succeed(JSON.parse(str));
+    }
+    catch {
+        return fail("Invalid JSON string");
+    }
+})
+    .chain(json => new Decoder(_ => inner.run(json)));
+export { Decoder, decode, object, objectMap, pair, array, string, number, boolean, any, json, nullP, stringNumber, undefinedP, oneOf, maybe, nullable, stringLiteral, stringEnum, triple, always, fail, failure, succeed, both, optional, optionalNullable, optionalMaybe, optionalDefault, stringified, recursive, };