@tempots/dom 9.0.1 → 10.0.0

package/components/HiddenWhenEmpty.js

@@ -1,13 +0,0 @@
-export class HiddenWhenEmptyImpl {
-    appendTo(ctx) {
-        const initial = ctx.getStyle(':empty');
-        ctx.setStyle(':empty', 'display: none');
-        return (removeTree) => {
-            if (removeTree)
-                ctx.setStyle(':empty', initial);
-        };
-    }
-}
-export function HiddenWhenEmpty() {
-    return new HiddenWhenEmptyImpl();
-}

package/components/If.d.ts

@@ -1,14 +0,0 @@
-import { type JSX } from '../jsx-runtime';
-import { type Signal } from '../prop';
-export interface IfProps {
-    is: Signal<boolean>;
-    then?: () => JSX.DOMNode;
-    otherwise?: () => JSX.DOMNode;
-}
-export declare function If({ is, then, otherwise }: IfProps): JSX.DOMNode;
-export interface WhenProps {
-    is: Signal<boolean>;
-    children?: () => JSX.DOMNode;
-}
-export declare function When({ is, children }: WhenProps): JSX.DOMNode;
-export declare function Unless({ is, children }: WhenProps): JSX.DOMNode;

package/components/If.js

@@ -1,19 +0,0 @@
-import { OneOfImpl } from './OneOf';
-export function If({ is, then, otherwise }) {
-    return new OneOfImpl(is.map(v => v ? { then: true } : { otherwise: false }), {
-        then: then || (() => null),
-        otherwise: otherwise || (() => null)
-    });
-}
-export function When({ is, children }) {
-    return new OneOfImpl(is.map(v => v ? { then: true } : { otherwise: false }), {
-        then: children,
-        otherwise: (() => null)
-    });
-}
-export function Unless({ is, children }) {
-    return new OneOfImpl(is.map(v => v ? { then: true } : { otherwise: false }), {
-        then: (() => null),
-        otherwise: children
-    });
-}

package/components/InnerHTML.d.ts

@@ -1,13 +0,0 @@
-import { type Signal } from '../prop';
-import { type Clear } from '../clean';
-import { type DOMContext } from '../dom-context';
-import { type Renderable } from '../renderable';
-export declare class InnerHTMLImpl implements Renderable {
-    private readonly html;
-    constructor(html: Signal<string> | Signal<string | undefined>);
-    readonly appendTo: (ctx: DOMContext) => Clear;
-}
-export interface InnerHTMLProps {
-    html: Signal<string> | Signal<string | undefined>;
-}
-export declare function InnerHTML({ html }: InnerHTMLProps): InnerHTMLImpl;

package/components/InnerHTML.js

@@ -1,23 +0,0 @@
-export class InnerHTMLImpl {
-    html;
-    constructor(html) {
-        this.html = html;
-    }
-    appendTo = (ctx) => {
-        const el = ctx.getElement();
-        const previous = el.innerHTML;
-        el.innerHTML = this.html.get() ?? '';
-        const cancel = this.html.subscribe(value => {
-            el.innerHTML = value ?? '';
-        });
-        return (removeTree) => {
-            cancel();
-            if (removeTree) {
-                el.innerHTML = previous;
-            }
-        };
-    };
-}
-export function InnerHTML({ html }) {
-    return new InnerHTMLImpl(html);
-}

package/components/Lifecycle.d.ts

@@ -1,14 +0,0 @@
-import { type Clear } from '../clean';
-import { type DOMContext } from '../dom-context';
-import { type Renderable } from '../renderable';
-export declare class LifecycleImpl implements Renderable {
-    private readonly onMount;
-    private readonly onUnmount;
-    constructor(onMount: (el: HTMLElement) => void, onUnmount: (el: HTMLElement, removeTree: boolean) => void);
-    readonly appendTo: (ctx: DOMContext) => Clear;
-}
-export interface LifecycleProps {
-    onMount?: (el: HTMLElement) => void;
-    onUnmount?: (el: HTMLElement, removeTree: boolean) => void;
-}
-export declare function Lifecycle({ onMount, onUnmount }: LifecycleProps): Renderable;

package/components/Lifecycle.js

@@ -1,18 +0,0 @@
-export class LifecycleImpl {
-    onMount;
-    onUnmount;
-    constructor(onMount, onUnmount) {
-        this.onMount = onMount;
-        this.onUnmount = onUnmount;
-    }
-    appendTo = (ctx) => {
-        this.onMount(ctx.getElement());
-        return (removeTree) => {
-            this.onUnmount(ctx.getElement(), removeTree);
-        };
-    };
-}
-export function Lifecycle({ onMount, onUnmount }) {
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    return new LifecycleImpl(onMount ?? (() => { }), onUnmount ?? (() => { }));
-}

package/components/NotEmpty.d.ts

@@ -1,9 +0,0 @@
-/** @jsxImportSource .. */
-import { type Signal } from '../prop';
-import { type JSX } from '../jsx-runtime';
-export interface NotEmptyProps<T> {
-    on: Signal<T>;
-    whenEmpty?: () => JSX.DOMNode;
-    display: () => JSX.DOMNode;
-}
-export declare function NotEmpty<T extends unknown[] | Record<any, unknown>>({ on, display, whenEmpty }: NotEmptyProps<T>): JSX.DOMNode;

package/components/NotEmpty.js

@@ -1,11 +0,0 @@
-import { jsx as _jsx } from "../jsx-runtime";
-import { If } from './If';
-function isEmpty(obj) {
-    return Object.keys(obj).length === 0;
-}
-// <NotEmpty on={maybevalue} whenEmpty={<span>nothing to show</span>}}>{value => value.toText()}</NotEmpty>
-export function NotEmpty({ on, display, whenEmpty }) {
-    return (_jsx(If, { is: on.map((v) => 
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        Array.isArray(v) ? v.length > 0 : v != null && !isEmpty(v)), then: display, otherwise: whenEmpty }));
-}

package/components/On.d.ts

@@ -1,15 +0,0 @@
-import { type Renderable } from '../renderable';
-import { type Clear } from '../clean';
-import { type DOMContext } from '../dom-context';
-export type OnFn<T> = (value: T) => void;
-export declare class OnImpl<T> implements Renderable {
-    private readonly name;
-    private readonly handler;
-    constructor(name: string, handler: OnFn<T>);
-    readonly appendTo: (ctx: DOMContext) => Clear;
-}
-export interface OnProps<T> {
-    name: string;
-    handler: OnFn<T>;
-}
-export declare function On<T>({ name, handler }: OnProps<T>): Renderable;

package/components/On.js

@@ -1,14 +0,0 @@
-export class OnImpl {
-    name;
-    handler;
-    constructor(name, handler) {
-        this.name = name;
-        this.handler = handler;
-    }
-    appendTo = (ctx) => {
-        return ctx.createHandler(this.name, this.handler);
-    };
-}
-export function On({ name, handler }) {
-    return new OnImpl(name, handler);
-}

package/components/OnRemove.d.ts

@@ -1,6 +0,0 @@
-import { type Clear } from '../clean';
-import { LifecycleImpl } from './Lifecycle';
-export interface OnRemoveProps {
-    clear: Clear;
-}
-export declare function OnRemove(props: OnRemoveProps): LifecycleImpl;

package/components/OnRemove.js

@@ -1,4 +0,0 @@
-import { LifecycleImpl } from './Lifecycle';
-export function OnRemove(props) {
-    return new LifecycleImpl(() => { }, (_, removeTree) => { props.clear(removeTree); });
-}

package/components/OneOf.d.ts

@@ -1,62 +0,0 @@
-import { type Signal } from '../prop';
-import { type Clear } from '../clean';
-import { type DOMContext } from '../dom-context';
-import { type Renderable } from '../renderable';
-import { type JSX } from '../jsx';
-export declare class OneOfImpl<T extends Record<string, unknown>> implements Renderable {
-    private readonly match;
-    private readonly cases;
-    constructor(match: Signal<T>, cases: {
-        [KK in keyof T]: (value: Signal<T[KK]>) => JSX.DOMNode;
-    });
-    readonly appendTo: (ctx: DOMContext) => Clear;
-}
-export type OneOfProps<T extends Record<string, unknown>> = {
-    match: Signal<T>;
-} & {
-    [KK in keyof T]: (value: Signal<T[KK]>) => JSX.DOMNode;
-};
-export declare function OneOf<T extends Record<string, unknown>>(props: OneOfProps<T>): JSX.DOMNode;
-export type OneOfLiteralProps<K extends string> = {
-    match: Signal<K>;
-} & {
-    [KK in K]: JSX.DOMNode;
-};
-export declare function OneOfLiteral<K extends string>(props: OneOfLiteralProps<K>): JSX.DOMNode;
-export type OneOfUnionProps<T extends {
-    [_ in K]: string;
-}, K extends string> = {
-    match: Signal<T>;
-    using: K;
-} & {
-    [KK in T[K]]: (value: Signal<T extends {
-        [_ in K]: KK;
-    } ? T : never>) => JSX.DOMNode;
-};
-export declare function OneOfUnion<T extends {
-    [_ in K]: string;
-}, K extends string>(props: OneOfUnionProps<T, K>): JSX.DOMNode;
-export type OneOfUnionTypeProps<T extends {
-    [_ in 'type']: string;
-}> = {
-    match: Signal<T>;
-} & {
-    [KK in T['type']]: (value: Signal<T extends {
-        [_ in 'type']: KK;
-    } ? T : never>) => JSX.DOMNode;
-};
-export declare function OneOfUnionType<T extends {
-    type: string;
-}>(props: OneOfUnionTypeProps<T>): JSX.DOMNode;
-export type OneOfUnionKindProps<T extends {
-    [_ in 'kind']: string;
-}> = {
-    match: Signal<T>;
-} & {
-    [KK in T['kind']]: (value: Signal<T extends {
-        [_ in 'kind']: KK;
-    } ? T : never>) => JSX.DOMNode;
-};
-export declare function OneOfUnionKind<T extends {
-    kind: string;
-}>(props: OneOfUnionKindProps<T>): JSX.DOMNode;

package/components/OneOf.js

@@ -1,68 +0,0 @@
-import { Prop } from '../prop';
-import { makeRenderable } from '../jsx-runtime';
-export class OneOfImpl {
-    match;
-    cases;
-    constructor(match, cases) {
-        this.match = match;
-        this.cases = cases;
-    }
-    appendTo = (ctx) => {
-        const pair = this.match.get();
-        let key = Object.keys(pair)[0];
-        const value = pair[key];
-        let prop = new Prop(value);
-        let newCtx = ctx.makeReference();
-        let clear = makeRenderable(this.cases[key](prop)).appendTo(newCtx);
-        const cancel = this.match.subscribe((newPair) => {
-            const newKey = Object.keys(newPair)[0];
-            const newValue = newPair[newKey];
-            if (newKey !== key) {
-                newCtx.requestClear(true, () => {
-                    newCtx = newCtx.makeReference();
-                    key = newKey;
-                    prop.clean();
-                    prop = new Prop(newValue);
-                    clear(true);
-                    clear = makeRenderable(this.cases[key](prop)).appendTo(newCtx);
-                });
-            }
-            else {
-                prop.set(newValue);
-            }
-        });
-        return (removeTree) => {
-            newCtx.requestClear(removeTree, () => {
-                clear(removeTree);
-                cancel();
-                prop.clean();
-            });
-        };
-    };
-}
-// <OneOf match={counter.map(v => v % 2 == 0 ? {1: "odd"} : {2: "even"})} 1={t => <b>{t}</b>} 2={t => <i>{t}</i>} /
-export function OneOf(props) {
-    return new OneOfImpl(props.match, props);
-}
-export function OneOfLiteral(props) {
-    const { match, ...cases } = props;
-    const keys = Object.keys(cases);
-    const obj = keys.reduce((acc, k) => {
-        acc[k] = () => cases[k];
-        return acc;
-        // eslint-disable-next-line @typescript-eslint/prefer-reduce-type-parameter, @typescript-eslint/consistent-type-assertions
-    }, {});
-    return new OneOfImpl(
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    match.map(k => ({ [k]: null })), obj);
-}
-export function OneOfUnion(props) {
-    const { match, using, ...cases } = props;
-    return new OneOfImpl(match.map(t => ({ [t != null ? t[using] : '']: t })), cases);
-}
-export function OneOfUnionType(props) {
-    return OneOfUnion({ ...props, using: 'type' });
-}
-export function OneOfUnionKind(props) {
-    return OneOfUnion({ ...props, using: 'kind' });
-}

package/components/Portal.d.ts

@@ -1,15 +0,0 @@
-import { type Clear } from '../clean';
-import { type DOMContext } from '../dom-context';
-import { type Renderable } from '../renderable';
-import { type JSX } from '../jsx';
-export declare class PortalImpl implements Renderable {
-    private readonly selector;
-    private readonly children;
-    constructor(selector: string, children: JSX.DOMNode);
-    appendTo(ctx: DOMContext): Clear;
-}
-export interface PortalProps {
-    selector: string;
-    children?: JSX.DOMNode;
-}
-export declare function Portal(props: PortalProps): JSX.DOMNode;

package/components/Portal.js

@@ -1,20 +0,0 @@
-import { render } from '../render';
-import { makeRenderable } from '../jsx-runtime';
-export class PortalImpl {
-    selector;
-    children;
-    constructor(selector, children) {
-        this.selector = selector;
-        this.children = children;
-    }
-    appendTo(ctx) {
-        const element = ctx.getDocument().querySelector(this.selector);
-        if (element === null) {
-            throw new Error(`Cannot find element by selector: ${this.selector}`);
-        }
-        return render(makeRenderable(this.children), element);
-    }
-}
-export function Portal(props) {
-    return new PortalImpl(props.selector, props.children);
-}

package/components/Property.d.ts

@@ -1,15 +0,0 @@
-import { type Signal } from '../prop';
-import { type Renderable } from '../renderable';
-import { type Clear } from '../clean';
-import { type DOMContext } from '../dom-context';
-export declare class PropertyImpl<T> implements Renderable {
-    private readonly name;
-    private readonly value;
-    constructor(name: string, value: Signal<T>);
-    readonly appendTo: (ctx: DOMContext) => Clear;
-}
-export interface PropertyProps<T> {
-    name: string;
-    value: Signal<T>;
-}
-export declare function Property<T>({ name, value }: PropertyProps<T>): Renderable;

package/components/Property.js

@@ -1,16 +0,0 @@
-import { subscribeToSignal } from './Text';
-export class PropertyImpl {
-    name;
-    value;
-    constructor(name, value) {
-        this.name = name;
-        this.value = value;
-    }
-    appendTo = (ctx) => {
-        const [set, clear] = ctx.createProperty(this.name, this.value.get());
-        return subscribeToSignal(this.value, set, clear);
-    };
-}
-export function Property({ name, value }) {
-    return new PropertyImpl(name, value);
-}

package/components/Provider.d.ts

@@ -1,28 +0,0 @@
-import { type Clear } from '../clean';
-import { type DOMContext, type ProviderMark } from '../dom-context';
-import { type Renderable } from '../renderable';
-import { type JSX } from '../jsx';
-export declare class ProviderImpl<T> implements Renderable {
-    private readonly mark;
-    private readonly provider;
-    private readonly children;
-    constructor(mark: ProviderMark<T>, provider: T, children: JSX.DOMNode);
-    readonly appendTo: (ctx: DOMContext) => Clear;
-}
-export interface ProviderProps<T> {
-    mark: ProviderMark<T>;
-    value: T;
-    children?: JSX.DOMNode;
-}
-export declare function Provider<T>({ mark, value, children }: ProviderProps<T>): JSX.DOMNode;
-export declare class ConsumerImpl<T> implements Renderable {
-    private readonly mark;
-    private readonly children;
-    constructor(mark: ProviderMark<T>, children: (provider: T) => JSX.DOMNode);
-    readonly appendTo: (ctx: DOMContext) => Clear;
-}
-export interface ConsumerProps<T> {
-    mark: ProviderMark<T>;
-    children?: (provider: T) => JSX.DOMNode;
-}
-export declare function Consumer<T>({ mark, children }: ConsumerProps<T>): JSX.DOMNode;

package/components/Provider.js

@@ -1,44 +0,0 @@
-import { makeRenderable } from '../jsx-runtime';
-export class ProviderImpl {
-    mark;
-    provider;
-    children;
-    constructor(mark, provider, children) {
-        this.mark = mark;
-        this.provider = provider;
-        this.children = children;
-    }
-    appendTo = (ctx) => {
-        const newCtx = ctx.withProvider(this.mark, this.provider);
-        const clear = makeRenderable(this.children).appendTo(newCtx);
-        return (removeTree) => {
-            newCtx.requestClear(removeTree, () => {
-                clear(removeTree);
-            });
-        };
-    };
-}
-export function Provider({ mark, value, children }) {
-    return new ProviderImpl(mark, value, children);
-}
-export class ConsumerImpl {
-    mark;
-    children;
-    constructor(mark, children) {
-        this.mark = mark;
-        this.children = children;
-    }
-    appendTo = (ctx) => {
-        const provider = ctx.getProvider(this.mark);
-        if (provider == null) {
-            throw new Error('No provider found for mark');
-        }
-        const clear = makeRenderable(this.children(provider)).appendTo(ctx);
-        return (removeTree) => {
-            clear(removeTree);
-        };
-    };
-}
-export function Consumer({ mark, children }) {
-    return new ConsumerImpl(mark, children ?? (() => []));
-}

package/components/Repeat.d.ts

@@ -1,28 +0,0 @@
-/** @jsxImportSource .. */
-import { type Signal } from '../prop';
-import { type Clear } from '../clean';
-import { type DOMContext } from '../dom-context';
-import { type Renderable } from '../renderable';
-import { type JSX } from '../jsx';
-export interface PositionProps {
-    readonly first: boolean;
-    readonly last: boolean;
-    readonly index: number;
-}
-export declare function makePosition(index: number, length: number): PositionProps;
-export declare class RepeatImpl implements Renderable {
-    private readonly times;
-    private readonly children;
-    private readonly separator?;
-    constructor(times: Signal<number>, children: (pos: Signal<PositionProps>) => JSX.DOMNode, separator?: ((sep: Signal<PositionProps>) => JSX.DOMNode) | undefined);
-    readonly appendTo: (ctx: DOMContext) => Clear;
-    readonly appendToWithoutSeparator: (ctx: DOMContext) => Clear;
-    readonly appendToWithSeparator: (ctx: DOMContext, separator: (sep: Signal<PositionProps>) => JSX.DOMNode) => Clear;
-}
-export interface RepeatProps {
-    times: Signal<number>;
-    children?: (pos: Signal<PositionProps>) => JSX.DOMNode;
-    separator?: (sep: Signal<PositionProps>) => JSX.DOMNode;
-}
-export declare function Repeat(props: RepeatProps): Renderable;
-export declare function conjuctions(other: JSX.DOMNode, lastConjunction?: JSX.DOMNode, firstConjunction?: JSX.DOMNode): (sep: Signal<PositionProps>) => JSX.DOMNode;

package/components/Repeat.js

@@ -1,146 +0,0 @@
-import { jsx as _jsx } from "../jsx-runtime";
-/** @jsxImportSource .. */
-import { Prop } from '../prop';
-import { Fragment } from './Fragment';
-import { makeRenderable } from '../jsx-runtime';
-import { OneOf } from './OneOf';
-export function makePosition(index, length) {
-    return {
-        first: index === 0,
-        last: index === length - 1,
-        index
-    };
-}
-export class RepeatImpl {
-    times;
-    children;
-    separator;
-    constructor(times, children, separator) {
-        this.times = times;
-        this.children = children;
-        this.separator = separator;
-    }
-    appendTo = (ctx) => {
-        if (this.separator == null) {
-            return this.appendToWithoutSeparator(ctx);
-        }
-        else {
-            return this.appendToWithSeparator(ctx, this.separator);
-        }
-    };
-    appendToWithoutSeparator = (ctx) => {
-        const newCtx = ctx.makeReference();
-        const count = this.times.get();
-        const clears = new Array(count);
-        const positions = new Array(count);
-        for (let i = 0; i < count; i++) {
-            positions[i] = new Prop(makePosition(i, count));
-            clears[i] = makeRenderable(this.children(positions[i])).appendTo(newCtx);
-        }
-        const cancel = this.times.subscribe((newCount) => {
-            while (newCount < clears.length) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                clears.pop()(true);
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                positions.pop().clean();
-            }
-            for (let i = 0; i < positions.length; i++) {
-                positions[i].set(makePosition(i, newCount));
-            }
-            for (let i = clears.length; i < newCount; i++) {
-                positions[i] = new Prop(makePosition(i, count));
-                clears[i] = makeRenderable(this.children(positions[i])).appendTo(newCtx);
-            }
-        });
-        return (removeTree) => {
-            newCtx.requestClear(removeTree, () => {
-                cancel();
-                clears.forEach(clear => { clear(removeTree); });
-            });
-        };
-    };
-    appendToWithSeparator = (ctx, separator) => {
-        const newCtx = ctx.makeReference();
-        const count = this.times.get();
-        const separatorProps = new Array(Math.max(0, count - 1));
-        const separatorClears = new Array(Math.max(0, count - 1));
-        const clears = new Array(count);
-        const positions = new Array(count);
-        for (let i = 0; i < count; i++) {
-            positions[i] = new Prop(makePosition(i, count));
-            clears[i] = makeRenderable(this.children(positions[i])).appendTo(newCtx);
-            if (i < count - 1) {
-                separatorProps[i] = Prop.of({
-                    first: i === 0,
-                    last: i === count - 2,
-                    index: i
-                });
-                separatorClears[i] = makeRenderable(separator(separatorProps[i])).appendTo(newCtx);
-            }
-        }
-        const cancel = this.times.subscribe((newCount) => {
-            while (newCount < clears.length) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                clears.pop()(true);
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                positions.pop().clean();
-                if (separatorClears.length > 0) {
-                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                    separatorClears.pop()(true);
-                }
-                if (separatorProps.length > 0) {
-                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                    separatorProps.pop().clean();
-                }
-            }
-            for (let i = 0; i < positions.length; i++) {
-                positions[i].set(makePosition(i, newCount));
-            }
-            for (let i = 0; i < separatorProps.length; i++) {
-                separatorProps[i].set({
-                    first: i === 0,
-                    last: i === newCount - 2,
-                    index: i
-                });
-            }
-            for (let i = clears.length; i < newCount; i++) {
-                positions[i] = new Prop(makePosition(i, count));
-                clears[i] = makeRenderable(this.children(positions[i])).appendTo(newCtx);
-                if (i < newCount - 1) {
-                    separatorProps[i] = Prop.of({
-                        first: i === 0,
-                        last: i === newCount - 2,
-                        index: i
-                    });
-                    separatorClears[i] = makeRenderable(separator(separatorProps[i])).appendTo(newCtx);
-                }
-            }
-        });
-        return (removeTree) => {
-            newCtx.requestClear(removeTree, () => {
-                cancel();
-                clears.forEach(clear => { clear(removeTree); });
-                separatorClears.forEach(clear => { clear(removeTree); });
-                separatorProps.forEach(signal => { signal.clean(); });
-            });
-        };
-    };
-}
-export function Repeat(props) {
-    return new RepeatImpl(props.times, props.children ?? (() => Fragment({ children: [] })), props.separator);
-}
-export function conjuctions(other, lastConjunction, firstConjunction) {
-    return (sep) => {
-        return _jsx(OneOf, { match: sep.map(({ first, last }) => {
-                if (last) {
-                    return { last: true };
-                }
-                else if (first) {
-                    return { first: true };
-                }
-                else {
-                    return { other: true };
-                }
-            }), first: () => firstConjunction ?? other, last: () => lastConjunction ?? other, other: () => other });
-    };
-}

package/components/Show.d.ts

@@ -1,15 +0,0 @@
-/** @jsxImportSource .. */
-import { type Signal } from '../prop';
-import { type JSX } from '../jsx';
-import { OneOfImpl } from './OneOf';
-export type Condition<T> = Signal<T | null | undefined> | Signal<T | undefined> | Signal<T | null> | Signal<T>;
-export interface ShowProps<T> {
-    when: Condition<T>;
-    otherwise?: () => JSX.DOMNode;
-    children?: (value: Signal<NonNullable<T>>) => JSX.DOMNode;
-}
-export declare function Show<T>({ when, children, otherwise }: ShowProps<T>): OneOfImpl<{
-    then: NonNullable<T>;
-} | {
-    otherwise: false;
-}>;

package/components/Show.js

@@ -1,8 +0,0 @@
-import { Fragment as _Fragment, jsx as _jsx } from "../jsx-runtime";
-import { OneOfImpl } from './OneOf';
-export function Show({ when, children, otherwise }) {
-    return new OneOfImpl(when.map(v => (v != null ? { then: v } : { otherwise: false })), {
-        then: (v) => ((children && children(v)) || _jsx(_Fragment, {})),
-        otherwise: otherwise || (() => _jsx(_Fragment, {}))
-    });
-}