@tempots/dom 9.0.1 → 10.0.0

package/jsx.js

@@ -1 +0,0 @@
-export {};

package/prop.d.ts

@@ -1,58 +0,0 @@
-export type ArgsToSignals<T extends [...unknown[]]> = T extends [] ? [] : T extends [infer U, ...infer V] ? [Signal<U>, ...ArgsToSignals<V>] : [];
-declare const $isSignal: unique symbol;
-declare const $isProp: unique symbol;
-export type Value<T> = T | Signal<T>;
-export declare class Signal<T> {
-    protected _value: T;
-    static of<T>(value: T): Signal<T>;
-    static ofValue<T>(value: Value<T> | null | undefined): Signal<T> | undefined;
-    static wrap<T>(value: T | Signal<T>): Signal<T>;
-    static isSignal<T = unknown>(x: unknown): x is Signal<T>;
-    static unwrap<T>(value: Value<T>): T;
-    /**
-     * Combines many into one using a merging function
-     */
-    static combine<Args extends [...unknown[]], Out>(signals: ArgsToSignals<Args>, f: (...args: Args) => Out): Signal<Out>;
-    readonly [$isSignal] = true;
-    protected readonly _listeners: Array<(value: T) => void>;
-    constructor(_value: T);
-    readonly get: () => T;
-    readonly subscribe: (listener: (value: T) => void) => () => void;
-    readonly map: <V>(f: (value: T) => V) => Signal<V>;
-    readonly flatMap: <V>(f: (value: T) => Signal<V>) => Signal<V>;
-    readonly flatMapProp: <V>(f: (value: T) => Prop<V>) => Prop<V>;
-    readonly tap: (f: (value: T) => void) => this;
-    readonly at: <K extends keyof T>(key: K) => Signal<T[K]>;
-    readonly filter: (predicate: (value: T) => boolean) => Signal<T>;
-    readonly distinct: (equality: (a: T, b: T) => boolean) => Signal<T>;
-    readonly mapAsync: <V>(f: (value: T) => Promise<V>, alt: V) => Signal<V>;
-    readonly mapMaybe: <V>(f: (value: T) => V | null | undefined, alt: V) => Signal<V>;
-    readonly combine: <V, Z>(other: Signal<V>, f: (a: T, b: V) => Z) => Signal<Z>;
-    readonly feed: (prop: Prop<T>) => () => void;
-    readonly deriveProp: () => Prop<T>;
-    readonly clean: () => void;
-    readonly count: () => Signal<number>;
-    readonly animate: (duration: number, interpolate: (start: T, end: T, delta: number) => T, initialValue?: T | null, easing?: (t: number) => number) => Signal<T>;
-    readonly equals: (other: Signal<T>, equality?: ((a: T, b: T) => boolean) | undefined) => Signal<boolean>;
-    readonly isNull: () => Signal<boolean>;
-    readonly isNotNull: () => Signal<boolean>;
-    readonly isEmpty: () => Signal<boolean>;
-    readonly isNotEmpty: () => Signal<boolean>;
-}
-export declare class Prop<T> extends Signal<T> {
-    static isProp<T = unknown>(x: unknown): x is Prop<T>;
-    static of<T>(value: T): Prop<T>;
-    static ofStorage<T>(key: string, defaultValue: T, store: {
-        getItem: (key: string) => string | null;
-        setItem: (key: string, value: string) => void;
-    }, serialize?: (v: T) => string, deserilize?: (v: string) => T): Prop<T>;
-    static ofLocalStorage<T>(key: string, defaultValue: T, serialize?: (v: T) => string, deserilize?: (v: string) => T): Prop<T>;
-    static ofSessionStorage<T>(key: string, defaultValue: T, serialize?: (v: T) => string, deserilize?: (v: string) => T): Prop<T>;
-    readonly [$isProp] = true;
-    readonly set: (value: T) => void;
-    readonly update: (f: (value: T) => T) => void;
-    readonly atLens: <K extends keyof T>(key: K) => Prop<T[K]>;
-    readonly reducer: <V>(f: (state: T, action: V) => T) => (action: V) => void;
-    readonly iso: <V>(map: (value: T) => V, reverse: (value: V) => T) => Prop<V>;
-}
-export {};

package/prop.js

@@ -1,256 +0,0 @@
-const $isSignal = Symbol('isSignal');
-const $isProp = Symbol('isProp');
-export class Signal {
-    _value;
-    static of(value) {
-        return new Signal(value);
-    }
-    static ofValue(value) {
-        return value == null ? undefined : Signal.wrap(value);
-    }
-    static wrap(value) {
-        return Signal.isSignal(value) ? value : new Signal(value);
-    }
-    static isSignal(x) {
-        const s = x;
-        return s != null && typeof s.get === 'function' && typeof s.subscribe === 'function';
-    }
-    static unwrap(value) {
-        return (Signal.isSignal(value) ? value.get() : value);
-    }
-    /**
-     * Combines many into one using a merging function
-     */
-    static combine(signals, f) {
-        function getValues(others) {
-            return others.map(other => other.get());
-        }
-        const prop = new Prop(f(...getValues(signals)));
-        signals.forEach((other) => {
-            other.subscribe(() => {
-                prop.set(f(...getValues(signals)));
-            });
-        });
-        return prop;
-    }
-    [$isSignal] = true;
-    _listeners = [];
-    constructor(_value) {
-        this._value = _value;
-    }
-    get = () => {
-        return this._value;
-    };
-    subscribe = (listener) => {
-        this._listeners.push(listener);
-        return () => {
-            const index = this._listeners.indexOf(listener);
-            if (index >= 0) {
-                this._listeners.splice(index, 1);
-            }
-        };
-    };
-    map = (f) => {
-        const prop = new Prop(f(this._value));
-        this.subscribe(value => { prop.set(f(value)); });
-        return prop;
-    };
-    flatMap = (f) => {
-        let signal = f(this._value);
-        const prop = new Prop(signal.get());
-        this.subscribe(value => {
-            signal.clean();
-            signal = f(value);
-            signal.subscribe(value => { prop.set(value); });
-        });
-        return prop;
-    };
-    flatMapProp = (f) => {
-        let tprop = f(this._value);
-        const prop = Prop.of(tprop.get());
-        let cancel = prop.feed(tprop);
-        this.subscribe(value => {
-            cancel();
-            tprop = f(value);
-            prop.set(tprop.get());
-            cancel = prop.feed(tprop);
-        });
-        return prop;
-    };
-    tap = (f) => {
-        f(this._value);
-        this.subscribe(f);
-        return this;
-    };
-    at = (key) => {
-        return this.map(value => value[key]);
-    };
-    filter = (predicate) => {
-        const prop = new Prop(this._value);
-        this.subscribe(value => {
-            if (predicate(value)) {
-                prop.set(value);
-            }
-        });
-        return prop;
-    };
-    distinct = (equality) => {
-        let lastValue = this._value;
-        return this.filter(value => {
-            const result = !equality(value, lastValue);
-            lastValue = value;
-            return result;
-        });
-    };
-    mapAsync = (f, alt) => {
-        let counter = 0;
-        const prop = new Prop(alt);
-        f(this._value)
-            .then(value => {
-            if (counter === 0)
-                prop.set(value);
-        })
-            .catch(e => {
-            throw e;
-        });
-        this.subscribe(value => {
-            const matchCounter = ++counter;
-            f(value)
-                .then(value => {
-                if (matchCounter === counter) {
-                    prop.set(value);
-                }
-            })
-                .catch(e => {
-                throw e;
-            });
-        });
-        return prop;
-    };
-    mapMaybe = (f, alt) => {
-        const prop = new Prop(f(this._value) ?? alt);
-        this.subscribe(value => {
-            const newValue = f(value);
-            if (newValue != null)
-                prop.set(newValue);
-        });
-        return prop;
-    };
-    combine = (other, f) => {
-        const prop = new Prop(f(this._value, other.get()));
-        this.subscribe(value => { prop.set(f(value, other.get())); });
-        other.subscribe(value => { prop.set(f(this._value, value)); });
-        return prop;
-    };
-    feed = (prop) => {
-        return this.subscribe(value => { prop.set(value); });
-    };
-    deriveProp = () => {
-        const prop = new Prop(this._value);
-        this.feed(prop);
-        return prop;
-    };
-    clean = () => {
-        this._listeners.length = 0;
-    };
-    count = () => {
-        let count = 0;
-        return this.map(() => ++count);
-    };
-    animate = (duration, interpolate, initialValue = null, easing = t => t) => {
-        let startValue = initialValue ?? this.get();
-        let endValue = this.get();
-        const prop = new Prop(startValue);
-        let startTime = 0;
-        let endTime = 0;
-        let animationFrame = null;
-        const animate = (time) => {
-            if (this._listeners.length === 0) {
-                animationFrame = null;
-                return;
-            }
-            if (time < endTime) {
-                const delta = (time - startTime) / (endTime - startTime);
-                prop.set(interpolate(startValue, endValue, easing(delta)));
-                animationFrame = requestAnimationFrame(animate);
-            }
-            else {
-                prop.set(endValue);
-                animationFrame = null;
-            }
-        };
-        this.subscribe(value => {
-            if (animationFrame != null)
-                cancelAnimationFrame(animationFrame);
-            if (this._listeners.length === 0) {
-                animationFrame = null;
-                return;
-            }
-            startValue = prop.get();
-            endValue = value;
-            startTime = performance.now();
-            endTime = startTime + duration;
-            animationFrame = requestAnimationFrame(animate);
-        });
-        return prop;
-    };
-    equals = (other, equality) => {
-        return this.combine(other, (a, b) => {
-            if (equality != null)
-                return equality(a, b);
-            return a === b;
-        });
-    };
-    isNull = () => this.map(value => value == null);
-    isNotNull = () => this.map(value => value != null);
-    isEmpty = () => this.map(value => value == null || (Reflect.has(value, 'length') && Reflect.get(value, 'length') === 0));
-    isNotEmpty = () => this.map(value => value != null && (!Reflect.has(value, 'length') || Reflect.get(value, 'length') !== 0));
-}
-export class Prop extends Signal {
-    static isProp(x) {
-        const p = x;
-        return Signal.isSignal(x) && typeof p.set === 'function';
-        // return x != null && (x as Prop<T>)[$isProp] === true
-    }
-    static of(value) {
-        return new Prop(value);
-    }
-    static ofStorage(key, defaultValue, store, serialize = JSON.stringify, deserilize = JSON.parse) {
-        const initialValue = store.getItem(key);
-        const prop = new Prop(initialValue !== null ? deserilize(initialValue) : defaultValue);
-        prop.subscribe((value) => {
-            store.setItem(key, serialize(value));
-        });
-        return prop;
-    }
-    static ofLocalStorage(key, defaultValue, serialize = JSON.stringify, deserilize = JSON.parse) {
-        return Prop.ofStorage(key, defaultValue, window.localStorage, serialize, deserilize);
-    }
-    static ofSessionStorage(key, defaultValue, serialize = JSON.stringify, deserilize = JSON.parse) {
-        return Prop.ofStorage(key, defaultValue, window.sessionStorage, serialize, deserilize);
-    }
-    [$isProp] = true;
-    set = (value) => {
-        if (this._value === value)
-            return;
-        this._value = value;
-        this._listeners.forEach(listener => { listener(value); });
-    };
-    update = (f) => {
-        this.set(f(this._value));
-    };
-    atLens = (key) => {
-        return this.iso(value => value[key], value => ({ ...this._value, [key]: value }));
-    };
-    reducer = (f) => {
-        return (action) => {
-            this.set(f(this._value, action));
-        };
-    };
-    iso = (map, reverse) => {
-        const prop = new Prop(map(this._value));
-        this.subscribe(value => { prop.set(map(value)); });
-        prop.subscribe(value => { this.set(reverse(value)); });
-        return prop;
-    };
-}

package/render.d.ts

@@ -1,3 +0,0 @@
-import { type JSX } from './jsx-runtime';
-import { type Clean } from './clean';
-export declare function render(renderable: JSX.DOMNode, element: HTMLElement): Clean;

package/render.js

@@ -1,7 +0,0 @@
-import { DOMContext } from './dom-context';
-import { makeRenderable } from './jsx-runtime';
-export function render(renderable, element) {
-    const ctx = DOMContext.of(element);
-    const clear = makeRenderable(renderable).appendTo(ctx);
-    return () => { clear(true); };
-}

package/renderable.d.ts

@@ -1,5 +0,0 @@
-import { type DOMContext } from './dom-context';
-import { type Clear } from './clean';
-export interface Renderable {
-    appendTo: (ctx: DOMContext) => Clear;
-}

package/renderable.js

@@ -1 +0,0 @@
-export {};