@tempots/dom 9.0.2 → 10.0.1

package/std/signal.d.ts

@@ -0,0 +1,120 @@
+declare const $isSignal: unique symbol;
+declare const $isProp: unique symbol;
+declare const $isComputed: unique symbol;
+export declare class Signal<T> {
+    readonly equals: (a: T, b: T) => boolean;
+    static ofPromise<T>(promise: Promise<T>, init: T, recover?: (error: unknown) => T, equals?: (a: T, b: T) => boolean): Signal<T>;
+    static is<T = unknown>(value: unknown): value is Signal<T>;
+    static wrap<T>(value: T | Signal<T>, equals?: (a: T, b: T) => boolean): Signal<T>;
+    static maybeWrap<T>(value: T | Signal<T> | null | undefined): Signal<T> | undefined | null;
+    static unwrap<T>(value: Signal<T> | T): T;
+    static map<T, U>(value: Value<T>, fn: (value: T) => U): Value<U>;
+    protected readonly [$isSignal] = true;
+    protected _value: T;
+    protected readonly _derivatives: Array<Computed<unknown>>;
+    protected readonly _onValueListeners: Array<(value: T) => void>;
+    protected readonly _onDisposeListeners: Array<() => void>;
+    constructor(value: T, equals: (a: T, b: T) => boolean);
+    readonly get: () => T;
+    get value(): T;
+    readonly hasListeners: () => boolean;
+    readonly on: (listener: (value: T) => void) => () => void;
+    protected readonly _setAndNotify: (newV: T, forceNotifications: boolean) => void;
+    protected _disposed: boolean;
+    readonly isDisposed: () => boolean;
+    readonly onDispose: (listener: () => void) => void;
+    readonly dispose: () => void;
+    readonly map: <U>(fn: (value: T) => U, equals?: (a: U, b: U) => boolean) => Computed<U>;
+    readonly flatMap: <U>(fn: (value: T) => Signal<U>, equals?: (a: U, b: U) => boolean) => Computed<U>;
+    readonly tap: (fn: (value: T) => void) => Computed<T>;
+    readonly at: <K extends keyof T>(key: K) => Signal<T[K]>;
+    readonly filter: (fn: (value: T) => boolean, startValue?: T) => Computed<T>;
+    readonly filterMap: <U>(fn: (value: T) => U | undefined | null, startValue: U, equals?: (a: U, b: U) => boolean) => Computed<U>;
+    readonly mapAsync: <U>(fn: (value: T) => Promise<U>, alt: U, recover?: (error: unknown) => U, equals?: (a: U, b: U) => boolean) => Prop<U>;
+    readonly mapMaybe: <U>(fn: (value: T) => U | undefined | null, alt: U) => Computed<U>;
+    readonly feedProp: (prop: Prop<T>, autoDisposeProp?: boolean) => Prop<T>;
+    readonly deriveProp: (autoDisposeProp?: boolean) => Prop<T>;
+    readonly count: () => Computed<number>;
+    readonly setDerivative: <U>(computed: Computed<U>) => void;
+}
+export declare class Computed<T> extends Signal<T> {
+    private readonly _fn;
+    static is<T = unknown>(value: unknown): value is Computed<T>;
+    protected readonly [$isComputed] = true;
+    protected _isDirty: boolean;
+    constructor(_fn: () => T, equals: (a: T, b: T) => boolean);
+    readonly setDirty: () => void;
+    protected _scheduleCount: number;
+    protected readonly scheduleNotify: () => void;
+    readonly get: () => T;
+    get value(): T;
+}
+export declare class Prop<T> extends Signal<T> {
+    static is<T = unknown>(value: unknown): value is Prop<T>;
+    protected readonly [$isProp] = true;
+    readonly set: (value: T) => void;
+    readonly update: (fn: (value: T) => T) => void;
+    readonly reducer: <U>(fn: (acc: T, value: U) => T) => (action: U) => void;
+    readonly iso: <U>(to: (value: T) => U, from: (value: U) => T, equals?: (a: U, b: U) => boolean) => Prop<U>;
+    readonly atProp: <K extends keyof T>(key: K) => Prop<T[K]>;
+    get value(): T;
+    set value(value: T);
+}
+export declare function computed<T>(fn: () => T, signals: Array<Signal<any>>, equals?: (a: T, b: T) => boolean): Computed<T>;
+export declare function effect(fn: () => void, signals: Array<Signal<any>>): () => void;
+export declare function prop<T>(value: T, equals?: (a: T, b: T) => boolean): Prop<T>;
+export declare function signal<T>(value: T, equals?: (a: T, b: T) => boolean): Signal<T>;
+export declare class MemoryStore {
+    private readonly _store;
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => void;
+}
+export declare function propOfStorage<T>({ key, defaultValue, store, serialize, deserialize, equals, onLoad, }: {
+    key: string;
+    defaultValue: T | (() => T);
+    store: {
+        getItem: (key: string) => string | null;
+        setItem: (key: string, value: string) => void;
+    };
+    serialize?: (v: T) => string;
+    deserialize?: (v: string) => T;
+    equals?: (a: T, b: T) => boolean;
+    onLoad?: (value: T) => T;
+}): Prop<T>;
+export declare function propOfLocalStorage<T>(options: {
+    key: string;
+    defaultValue: T | (() => T);
+    serialize?: (v: T) => string;
+    deserialize?: (v: string) => T;
+    equals?: (a: T, b: T) => boolean;
+    onLoad?: (value: T) => T;
+}): Prop<T>;
+export declare function propOfSessionStorage<T>(options: {
+    key: string;
+    defaultValue: T | (() => T);
+    serialize?: (v: T) => string;
+    deserialize?: (v: string) => T;
+    equals?: (a: T, b: T) => boolean;
+    onLoad?: (value: T) => T;
+}): Prop<T>;
+export declare function animate<T>(initialValue: T, fn: () => T, signals: Array<Signal<any>>, options?: {
+    interpolate?: (start: T, end: T, delta: number) => T;
+    duration?: Value<number>;
+    easing?: (t: number) => number;
+    equals?: (a: T, b: T) => boolean;
+}): Prop<T>;
+export declare function animateOne<T>(signal: Signal<T>, options?: {
+    initialValue?: T;
+    interpolate?: (start: T, end: T, delta: number) => T;
+    duration?: number;
+    easing?: (t: number) => number;
+    equals?: (a: T, b: T) => boolean;
+}): Prop<T>;
+export type Value<T> = Signal<T> | T;
+export type NValue<T> = Value<T> | Value<T | null> | Value<T | undefined> | Value<T | null | undefined> | null | undefined;
+export type GetValueType<T> = T extends Signal<infer V> ? V : T;
+export type RemoveSignals<T extends Record<string | number | symbol, Value<unknown>>, K extends (string | number | symbol) & keyof T = keyof T> = {
+    [k in K]: GetValueType<T[k]>;
+};
+export declare function computedRecord<T extends Record<string, Value<unknown>>, U>(record: T, fn: (value: RemoveSignals<T>) => U): Computed<U>;
+export {};

package/types/aria-attributes.d.ts

@@ -0,0 +1,50 @@
+export type AriaAttributes = {
+    activedescendant: string;
+    atomic: boolean;
+    autocomplete: 'none' | 'inline' | 'list' | 'both';
+    busy: boolean;
+    checked: boolean | 'mixed' | 'false' | 'true';
+    colcount: number;
+    colindex: number;
+    colspan: number;
+    controls: string;
+    current: string;
+    describedby: string;
+    details: string;
+    disabled: boolean;
+    dropeffect: 'none' | 'copy' | 'execute' | 'link' | 'move' | 'popup';
+    errormessage: string;
+    expanded: boolean | 'false' | 'true';
+    flowto: string;
+    grabbed: boolean | 'false' | 'true';
+    haspopup: boolean;
+    hidden: boolean;
+    invalid: boolean | 'grammar' | 'false' | 'spelling' | 'true';
+    keyshortcuts: string;
+    label: string;
+    labelledby: string;
+    level: number;
+    live: 'off' | 'assertive' | 'polite';
+    modal: boolean;
+    multiline: boolean;
+    multiselectable: boolean;
+    orientation: 'horizontal' | 'vertical';
+    owns: string;
+    placeholder: string;
+    posinset: number;
+    pressed: boolean | 'mixed' | 'false' | 'true';
+    readonly: boolean;
+    relevant: 'additions' | 'removals' | 'text' | 'all';
+    required: boolean;
+    roledescription: string;
+    rowcount: number;
+    rowindex: number;
+    rowspan: number;
+    selected: boolean;
+    setsize: number;
+    sort: 'none' | 'ascending' | 'descending' | 'other';
+    valuemax: number;
+    valuemin: number;
+    valuenow: number;
+    valuetext: string;
+};

package/types/css-styles.d.ts

@@ -0,0 +1,3 @@
+type ExcludeFromStyle = 'getPropertyPriority' | 'getPropertyValue' | 'item' | 'removeProperty' | 'setProperty' | 'parentRule' | 'length' | 'name' | number;
+export type CSSStyles = Omit<CSSStyleDeclaration, ExcludeFromStyle>;
+export {};

package/types/domain.d.ts

@@ -0,0 +1,14 @@
+import { DOMContext } from '../dom/dom-context';
+import { Value } from '../std/signal';
+
+export type Mountable = (ctx: DOMContext) => Clear;
+export type Child = Mountable | Value<string> | undefined | null | Mountable[];
+export type Clear = (removeTree: boolean) => void;
+export type ProviderMark<T> = symbol & {
+    readonly __type: T;
+};
+export type Providers = Record<ProviderMark<unknown>, unknown>;
+export interface Size {
+    readonly width: number;
+    readonly height: number;
+}

package/types/html-attributes.d.ts

@@ -0,0 +1,115 @@
+export type HTMLAttributes = {
+    accept: string;
+    'accept-charset': string;
+    accesskey: string;
+    action: string;
+    align: string;
+    alt: string;
+    async: boolean;
+    autocomplete: string;
+    autofocus: boolean;
+    autoplay: boolean;
+    bgcolor: string;
+    border: string;
+    charset: string;
+    checked: boolean;
+    cite: string;
+    class: string;
+    color: string;
+    cols: number;
+    colspan: number;
+    content: string;
+    contenteditable: boolean;
+    controls: string;
+    coords: string;
+    data: string;
+    datetime: string;
+    default: string;
+    defer: string;
+    dir: string;
+    dirname: string;
+    disabled: boolean;
+    download: string;
+    draggable: string;
+    dropzone: string;
+    enctype: string;
+    for: string;
+    form: string;
+    formaction: string;
+    headers: string;
+    height: string;
+    hidden: string;
+    high: string;
+    href: string;
+    hreflang: string;
+    'http-equiv': string;
+    icon: string;
+    id: string;
+    ismap: string;
+    itemprop: string;
+    keytype: string;
+    kind: string;
+    label: string;
+    lang: string;
+    language: string;
+    list: string;
+    loop: string;
+    low: string;
+    manifest: string;
+    max: number;
+    maxlength: number;
+    media: string;
+    method: string;
+    min: number;
+    minlength: number;
+    multiple: boolean;
+    name: string;
+    novalidate: string;
+    open: string;
+    optimum: string;
+    pattern: string;
+    ping: string;
+    placeholder: string;
+    poster: string;
+    preload: string;
+    radiogroup: string;
+    readonly: boolean;
+    rel: string;
+    required: string;
+    reversed: string;
+    rows: number;
+    rowspan: number;
+    sandbox: string;
+    scope: string;
+    scoped: string;
+    seamless: string;
+    selected: boolean;
+    shape: string;
+    size: number;
+    sizes: string;
+    span: string;
+    spellcheck: string;
+    src: string;
+    srcdoc: string;
+    srclang: string;
+    srcset: string;
+    start: string;
+    step: number;
+    style: string;
+    tabindex: number;
+    target: string;
+    title: string;
+    translate: string;
+    type: InputTypes;
+    usemap: string;
+    value: string;
+    valueAsNumber: number;
+    valueAsDate: Date;
+    width: string;
+    wrap: string;
+    textContent: string;
+    innerText: string;
+    innerHTML: string;
+    outerHTML: string;
+};
+export type InputTypes = 'text' | 'number' | 'checkbox' | 'radio' | 'file' | 'password' | 'button' | 'submit' | 'reset' | 'date' | 'range' | 'color' | 'hidden' | 'image' | 'month' | 'time' | 'week' | 'email' | 'tel' | 'url' | 'search' | 'datetime-local';

package/types/html-events.d.ts

@@ -0,0 +1,89 @@
+export type HTMLEvents = {
+    abort: Event;
+    animationcancel: AnimationEvent;
+    animationend: AnimationEvent;
+    animationiteration: AnimationEvent;
+    animationstart: AnimationEvent;
+    auxclick: MouseEvent;
+    blur: FocusEvent;
+    cancel: Event;
+    canplay: Event;
+    canplaythrough: Event;
+    change: Event;
+    click: MouseEvent;
+    close: Event;
+    contextmenu: MouseEvent;
+    cuechange: Event;
+    dblclick: MouseEvent;
+    drag: DragEvent;
+    dragend: DragEvent;
+    dragenter: DragEvent;
+    dragexit: Event;
+    dragleave: DragEvent;
+    dragover: DragEvent;
+    dragstart: DragEvent;
+    drop: DragEvent;
+    durationchange: Event;
+    emptied: Event;
+    ended: Event;
+    error: ErrorEvent;
+    focus: FocusEvent;
+    focusin: FocusEvent;
+    focusout: FocusEvent;
+    gotpointercapture: PointerEvent;
+    input: Event;
+    invalid: Event;
+    keydown: KeyboardEvent;
+    keypress: KeyboardEvent;
+    keyup: KeyboardEvent;
+    load: Event;
+    loadeddata: Event;
+    loadedmetadata: Event;
+    loadend: ProgressEvent;
+    loadstart: ProgressEvent;
+    lostpointercapture: PointerEvent;
+    mousedown: MouseEvent;
+    mouseenter: MouseEvent;
+    mouseleave: MouseEvent;
+    mousemove: MouseEvent;
+    mouseout: MouseEvent;
+    mouseover: MouseEvent;
+    mouseup: MouseEvent;
+    pause: Event;
+    play: Event;
+    playing: Event;
+    pointercancel: PointerEvent;
+    pointerdown: PointerEvent;
+    pointerenter: PointerEvent;
+    pointerleave: PointerEvent;
+    pointermove: PointerEvent;
+    pointerout: PointerEvent;
+    pointerover: PointerEvent;
+    pointerup: PointerEvent;
+    progress: ProgressEvent;
+    ratechange: Event;
+    reset: Event;
+    resize: UIEvent;
+    scroll: Event;
+    securitypolicyviolation: SecurityPolicyViolationEvent;
+    seeked: Event;
+    seeking: Event;
+    select: Event;
+    selectionchange: Event;
+    selectstart: Event;
+    stalled: Event;
+    submit: Event;
+    suspend: Event;
+    timeupdate: Event;
+    toggle: Event;
+    touchcancel: TouchEvent;
+    touchend: TouchEvent;
+    touchmove: TouchEvent;
+    touchstart: TouchEvent;
+    transitioncancel: TransitionEvent;
+    transitionend: TransitionEvent;
+    transitionrun: TransitionEvent;
+    transitionstart: TransitionEvent;
+    volumechange: Event;
+    waiting: Event;
+};

package/types/html-tags.d.ts

@@ -0,0 +1,113 @@
+export type HTMLTags = {
+    a: HTMLAnchorElement;
+    abbr: HTMLElement;
+    address: HTMLElement;
+    area: HTMLAreaElement;
+    article: HTMLElement;
+    aside: HTMLElement;
+    audio: HTMLAudioElement;
+    b: HTMLElement;
+    base: HTMLBaseElement;
+    bdi: HTMLElement;
+    bdo: HTMLElement;
+    blockquote: HTMLQuoteElement;
+    body: HTMLBodyElement;
+    br: HTMLBRElement;
+    button: HTMLButtonElement;
+    canvas: HTMLCanvasElement;
+    caption: HTMLElement;
+    cite: HTMLElement;
+    code: HTMLElement;
+    col: HTMLTableColElement;
+    colgroup: HTMLTableColElement;
+    data: HTMLDataElement;
+    datalist: HTMLDataListElement;
+    dd: HTMLElement;
+    del: HTMLModElement;
+    details: HTMLDetailsElement;
+    dfn: HTMLElement;
+    dialog: HTMLDialogElement;
+    div: HTMLDivElement;
+    dl: HTMLDListElement;
+    dt: HTMLElement;
+    em: HTMLElement;
+    embed: HTMLEmbedElement;
+    fieldset: HTMLFieldSetElement;
+    figcaption: HTMLElement;
+    figure: HTMLElement;
+    footer: HTMLElement;
+    form: HTMLFormElement;
+    h1: HTMLHeadingElement;
+    h2: HTMLHeadingElement;
+    h3: HTMLHeadingElement;
+    h4: HTMLHeadingElement;
+    h5: HTMLHeadingElement;
+    h6: HTMLHeadingElement;
+    head: HTMLHeadElement;
+    header: HTMLElement;
+    hgroup: HTMLElement;
+    hr: HTMLHRElement;
+    html: HTMLHtmlElement;
+    i: HTMLElement;
+    iframe: HTMLIFrameElement;
+    img: HTMLImageElement;
+    input: HTMLInputElement;
+    ins: HTMLModElement;
+    kbd: HTMLElement;
+    label: HTMLLabelElement;
+    legend: HTMLLegendElement;
+    li: HTMLLIElement;
+    link: HTMLLinkElement;
+    main: HTMLElement;
+    map: HTMLMapElement;
+    mark: HTMLElement;
+    meta: HTMLMetaElement;
+    meter: HTMLMeterElement;
+    nav: HTMLElement;
+    noscript: HTMLElement;
+    object: HTMLObjectElement;
+    ol: HTMLOListElement;
+    optgroup: HTMLOptGroupElement;
+    option: HTMLOptionElement;
+    output: HTMLOutputElement;
+    p: HTMLParagraphElement;
+    param: HTMLParamElement;
+    picture: HTMLPictureElement;
+    pre: HTMLPreElement;
+    progress: HTMLProgressElement;
+    q: HTMLQuoteElement;
+    rp: HTMLElement;
+    rt: HTMLElement;
+    ruby: HTMLElement;
+    s: HTMLElement;
+    samp: HTMLElement;
+    script: HTMLScriptElement;
+    section: HTMLElement;
+    select: HTMLSelectElement;
+    slot: HTMLSlotElement;
+    small: HTMLElement;
+    source: HTMLSourceElement;
+    span: HTMLSpanElement;
+    strong: HTMLElement;
+    style: HTMLStyleElement;
+    sub: HTMLElement;
+    summary: HTMLElement;
+    sup: HTMLElement;
+    table: HTMLTableElement;
+    tbody: HTMLTableSectionElement;
+    td: HTMLTableCellElement;
+    template: HTMLTemplateElement;
+    textarea: HTMLTextAreaElement;
+    tfoot: HTMLTableSectionElement;
+    th: HTMLTableCellElement;
+    thead: HTMLTableSectionElement;
+    time: HTMLTimeElement;
+    title: HTMLTitleElement;
+    tr: HTMLTableRowElement;
+    track: HTMLTrackElement;
+    u: HTMLElement;
+    ul: HTMLUListElement;
+    var: HTMLElement;
+    video: HTMLVideoElement;
+    wbr: HTMLElement;
+};

package/types/mathml-attributes.d.ts

@@ -0,0 +1,50 @@
+export type MathMLAttributes = {
+    accent: string;
+    accentunder: string;
+    align: string;
+    bevelled: string;
+    close: string;
+    columnalign: string;
+    columnlines: string;
+    columnspacing: string;
+    columnspan: string;
+    columnwidth: string;
+    crossout: string;
+    depth: string;
+    dir: string;
+    display: string;
+    displaystyle: string;
+    edge: string;
+    equalcolumns: string;
+    equalrows: string;
+    fence: string;
+    fontstyle: string;
+    fontweight: string;
+    frame: string;
+    height: string;
+    linethickness: string;
+    lspace: string;
+    mathbackground: string;
+    mathcolor: string;
+    mathsize: string;
+    mathvariant: string;
+    maxsize: string;
+    minsize: string;
+    movablelimits: string;
+    notation: string;
+    numalign: string;
+    open: string;
+    rowalign: string;
+    rowlines: string;
+    rowspacing: string;
+    rowspan: string;
+    rspace: string;
+    selection: string;
+    separator: string;
+    stretchy: string;
+    subscriptshift: string;
+    superscriptshift: string;
+    symmetric: string;
+    voffset: string;
+    width: string;
+};

package/types/mathml-tags.d.ts

@@ -0,0 +1,30 @@
+export type MathMLTags = {
+    maction: MathMLElement;
+    math: MathMLElement;
+    merror: MathMLElement;
+    mfenced: MathMLElement;
+    mfrac: MathMLElement;
+    mi: MathMLElement;
+    mmultiscripts: MathMLElement;
+    mn: MathMLElement;
+    mo: MathMLElement;
+    mover: MathMLElement;
+    mpadded: MathMLElement;
+    mphantom: MathMLElement;
+    mroot: MathMLElement;
+    mrow: MathMLElement;
+    ms: MathMLElement;
+    mspace: MathMLElement;
+    msqrt: MathMLElement;
+    mstyle: MathMLElement;
+    msub: MathMLElement;
+    msubsup: MathMLElement;
+    msup: MathMLElement;
+    mtable: MathMLElement;
+    mtd: MathMLElement;
+    mtext: MathMLElement;
+    mtr: MathMLElement;
+    munder: MathMLElement;
+    munderover: MathMLElement;
+    semantics: MathMLElement;
+};