@tempots/dom 9.0.2 → 10.0.0

package/types/svg-attributes.d.ts

@@ -0,0 +1,243 @@
+export type SVGAttributes = {
+    accentHeight: number;
+    accumulate: 'none' | 'sum';
+    additive: 'replace' | 'sum';
+    alignmentBaseline: 'auto' | 'baseline' | 'before-edge' | 'text-before-edge' | 'middle' | 'central' | 'after-edge' | 'text-after-edge' | 'ideographic' | 'alphabetic' | 'hanging' | 'mathematical' | 'inherit';
+    allowReorder: 'no' | 'yes';
+    alphabetic: number;
+    amplitude: number;
+    arabicForm: 'initial' | 'medial' | 'terminal' | 'isolated';
+    ascent: number;
+    attributeName: string;
+    attributeType: string;
+    autoReverse: 'true' | 'false';
+    azimuth: number;
+    baseFrequency: number;
+    baseProfile: string;
+    baselineShift: number;
+    bbox: number;
+    begin: number;
+    bias: number;
+    by: number;
+    calcMode: string;
+    capHeight: number;
+    clip: number;
+    clipPath: string;
+    clipPathUnits: string;
+    clipRule: string;
+    colorInterpolation: string;
+    colorInterpolationFilters: 'auto' | 'sRGB' | 'linearRGB' | 'inherit';
+    colorProfile: string;
+    colorRendering: string;
+    contentScriptType: string;
+    contentStyleType: string;
+    cursor: string;
+    cx: number;
+    cy: number;
+    d: string;
+    decelerate: number;
+    descent: number;
+    diffuseConstant: number;
+    direction: string;
+    display: string;
+    divisor: number;
+    dominantBaseline: string;
+    dur: number;
+    dx: number;
+    dy: number;
+    edgeMode: string;
+    elevation: number;
+    enableBackground: string;
+    end: number;
+    exponent: number;
+    externalResourcesRequired: 'true' | 'false';
+    fill: string;
+    fillOpacity: number;
+    fillRule: string;
+    filter: string;
+    filterRes: number;
+    filterUnits: string;
+    floodColor: string;
+    floodOpacity: number;
+    focusable: 'true' | 'false' | 'auto';
+    fontFamily: string;
+    fontSize: number;
+    fontSizeAdjust: number;
+    fontStretch: string;
+    fontStyle: string;
+    fontVariant: string;
+    fontWeight: string;
+    format: string;
+    from: number;
+    fx: number;
+    fy: number;
+    g1: number;
+    g2: number;
+    glyphName: string;
+    glyphOrientationHorizontal: number;
+    glyphOrientationVertical: number;
+    glyphRef: string;
+    gradientTransform: string;
+    gradientUnits: string;
+    hanging: number;
+    height: number;
+    horizAdvX: number;
+    horizOriginX: number;
+    ideographic: number;
+    imageRendering: string;
+    in: string;
+    in2: string;
+    intercept: number;
+    k: number;
+    k1: number;
+    k2: number;
+    k3: number;
+    k4: number;
+    kernelMatrix: string;
+    kernelUnitLength: number;
+    kerning: number;
+    keyPoints: string;
+    keySplines: string;
+    keyTimes: string;
+    lengthAdjust: string;
+    letterSpacing: number;
+    lightingColor: string;
+    limitingConeAngle: number;
+    local: number;
+    markerEnd: string;
+    markerHeight: number;
+    markerMid: string;
+    markerStart: string;
+    markerUnits: string;
+    markerWidth: number;
+    mask: string;
+    maskContentUnits: string;
+    maskUnits: string;
+    mathematical: number;
+    mode: string;
+    numOctaves: number;
+    offset: number;
+    opacity: number;
+    operator: string;
+    order: number;
+    orient: string;
+    orientation: number;
+    origin: number;
+    overflow: string;
+    overlinePosition: number;
+    overlineThickness: number;
+    paintOrder: string;
+    panose1: number;
+    pathLength: number;
+    patternContentUnits: string;
+    patternTransform: string;
+    patternUnits: string;
+    pointerEvents: string;
+    points: string;
+    pointsAtX: number;
+    pointsAtY: number;
+    pointsAtZ: number;
+    preserveAlpha: 'true' | 'false';
+    preserveAspectRatio: string;
+    primitiveUnits: string;
+    r: number;
+    radius: number;
+    refX: number;
+    refY: number;
+    renderingIntent: string;
+    repeatCount: number;
+    repeatDur: number;
+    requiredExtensions: string;
+    requiredFeatures: string;
+    restart: string;
+    result: string;
+    rotate: number;
+    rx: number;
+    ry: number;
+    scale: number;
+    seed: number;
+    shapeRendering: string;
+    slope: number;
+    spacing: number;
+    specularConstant: number;
+    specularExponent: number;
+    speed: number;
+    spreadMethod: string;
+    startOffset: number;
+    stdDeviation: number;
+    stemh: number;
+    stemv: number;
+    stitchTiles: string;
+    stopColor: string;
+    stopOpacity: number;
+    strikethroughPosition: number;
+    strikethroughThickness: number;
+    string: string;
+    stroke: string;
+    strokeDasharray: string;
+    strokeDashoffset: number;
+    strokeLinecap: string;
+    strokeLinejoin: string;
+    strokeMiterlimit: number;
+    strokeOpacity: number;
+    strokeWidth: number;
+    surfaceScale: number;
+    systemLanguage: string;
+    tableValues: string;
+    targetX: number;
+    targetY: number;
+    textAnchor: string;
+    textDecoration: string;
+    textLength: number;
+    textRendering: string;
+    to: number;
+    transform: string;
+    u1: number;
+    u2: number;
+    underlinePosition: number;
+    underlineThickness: number;
+    unicode: number;
+    unicodeBidi: string;
+    unicodeRange: string;
+    unitsPerEm: number;
+    vAlphabetic: number;
+    values: string;
+    vectorEffect: string;
+    version: string;
+    vertAdvY: number;
+    vertOriginX: number;
+    vertOriginY: number;
+    vHanging: number;
+    vIdeographic: number;
+    viewBox: string;
+    viewTarget: number;
+    visibility: string;
+    vMathematical: number;
+    width: number;
+    widths: number;
+    wordSpacing: number;
+    writingMode: string;
+    x1: number;
+    x2: number;
+    x: number;
+    xChannelSelector: string;
+    xHeight: number;
+    xlinkActuate: string;
+    xlinkArcrole: string;
+    xlinkHref: string;
+    xlinkRole: string;
+    xlinkShow: string;
+    xlinkTitle: string;
+    xlinkType: string;
+    xmlBase: string;
+    xmlLang: string;
+    xmlns: string;
+    xmlnsXlink: string;
+    xmlSpace: string;
+    y1: number;
+    y2: number;
+    y: number;
+    yChannelSelector: string;
+    z: number;
+    zoomAndPan: string;
+};

package/types/svg-tags.d.ts

@@ -0,0 +1,64 @@
+export type SVGTags = {
+    a: SVGAElement;
+    animate: SVGAnimateElement;
+    animateMotion: SVGAnimateMotionElement;
+    animateTransform: SVGAnimateTransformElement;
+    circle: SVGCircleElement;
+    clipPath: SVGClipPathElement;
+    defs: SVGDefsElement;
+    desc: SVGDescElement;
+    ellipse: SVGEllipseElement;
+    feBlend: SVGFEBlendElement;
+    feColorMatrix: SVGFEColorMatrixElement;
+    feComponentTransfer: SVGFEComponentTransferElement;
+    feComposite: SVGFECompositeElement;
+    feConvolveMatrix: SVGFEConvolveMatrixElement;
+    feDiffuseLighting: SVGFEDiffuseLightingElement;
+    feDisplacementMap: SVGFEDisplacementMapElement;
+    feDistantLight: SVGFEDistantLightElement;
+    feDropShadow: SVGFEDropShadowElement;
+    feFlood: SVGFEFloodElement;
+    feFuncA: SVGFEFuncAElement;
+    feFuncB: SVGFEFuncBElement;
+    feFuncG: SVGFEFuncGElement;
+    feFuncR: SVGFEFuncRElement;
+    feGaussianBlur: SVGFEGaussianBlurElement;
+    feImage: SVGFEImageElement;
+    feMerge: SVGFEMergeElement;
+    feMergeNode: SVGFEMergeNodeElement;
+    feMorphology: SVGFEMorphologyElement;
+    feOffset: SVGFEOffsetElement;
+    fePointLight: SVGFEPointLightElement;
+    feSpecularLighting: SVGFESpecularLightingElement;
+    feSpotLight: SVGFESpotLightElement;
+    feTile: SVGFETileElement;
+    feTurbulence: SVGFETurbulenceElement;
+    filter: SVGFilterElement;
+    foreignObject: SVGForeignObjectElement;
+    g: SVGGElement;
+    image: SVGImageElement;
+    line: SVGLineElement;
+    linearGradient: SVGLinearGradientElement;
+    marker: SVGMarkerElement;
+    mask: SVGMaskElement;
+    metadata: SVGMetadataElement;
+    mpath: SVGMPathElement;
+    path: SVGPathElement;
+    pattern: SVGPatternElement;
+    polygon: SVGPolygonElement;
+    polyline: SVGPolylineElement;
+    radialGradient: SVGRadialGradientElement;
+    rect: SVGRectElement;
+    script: SVGScriptElement;
+    set: SVGSetElement;
+    stop: SVGStopElement;
+    style: SVGStyleElement;
+    svg: SVGSVGElement;
+    switch: SVGSwitchElement;
+    symbol: SVGSymbolElement;
+    text: SVGTextElement;
+    textPath: SVGTextPathElement;
+    title: SVGTitleElement;
+    tspan: SVGTSpanElement;
+    use: SVGUseElement;
+};

package/clean.d.ts

@@ -1,2 +0,0 @@
-export type Clear = (removeTree: boolean) => void;
-export type Clean = () => void;

package/clean.js

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

package/components/Attribute.d.ts

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

package/components/Attribute.js

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

package/components/Autofocus.d.ts

@@ -1,2 +0,0 @@
-import { Renderable } from "../renderable";
-export declare function Autofocus(): Renderable;

package/components/Autofocus.js

@@ -1,4 +0,0 @@
-import { Lifecycle } from "./Lifecycle";
-export function Autofocus() {
-    return Lifecycle({ onMount: (el) => setTimeout(() => el && el.focus(), 10) });
-}

package/components/BooleanAttribute.d.ts

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

package/components/BooleanAttribute.js

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

package/components/ClassName.d.ts

@@ -1,13 +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 ClassNameImpl implements Renderable {
-    private readonly cls;
-    constructor(cls: Signal<string> | Signal<string | undefined>);
-    readonly appendTo: (ctx: DOMContext) => Clear;
-}
-export interface ClassNameProps {
-    value: Signal<string> | Signal<string | undefined>;
-}
-export declare function ClassName({ value }: ClassNameProps): Renderable;

package/components/ClassName.js

@@ -1,14 +0,0 @@
-import { subscribeToSignal } from './Text';
-export class ClassNameImpl {
-    cls;
-    constructor(cls) {
-        this.cls = cls;
-    }
-    appendTo = (ctx) => {
-        const [set, clear] = ctx.createClass(this.cls.get() ?? '');
-        return subscribeToSignal(this.cls.map(v => v ?? ''), set, clear);
-    };
-}
-export function ClassName({ value }) {
-    return new ClassNameImpl(value);
-}

package/components/El.d.ts

@@ -1,15 +0,0 @@
-import { type DOMContext } from '../dom-context';
-import { type Clear } from '../clean';
-import { type Renderable } from '../renderable';
-import { type JSX } from '../jsx';
-export declare class ElImpl implements Renderable {
-    private readonly tagName;
-    private readonly children;
-    constructor(tagName: string, children: Renderable[]);
-    readonly appendTo: (ctx: DOMContext) => Clear;
-}
-export interface ElProps {
-    tagName: string;
-    children?: JSX.DOMNode;
-}
-export declare function El({ tagName, children }: ElProps): Renderable;

package/components/El.js

@@ -1,21 +0,0 @@
-import { makeRenderables } from '../jsx-runtime';
-export class ElImpl {
-    tagName;
-    children;
-    constructor(tagName, children) {
-        this.tagName = tagName;
-        this.children = children;
-    }
-    appendTo = (ctx) => {
-        const newCtx = ctx.makeElement(this.tagName);
-        const clears = this.children.map(child => child.appendTo(newCtx));
-        return (removeTree) => {
-            newCtx.requestClear(removeTree, () => {
-                clears.forEach(clear => { clear(false); });
-            });
-        };
-    };
-}
-export function El({ tagName, children }) {
-    return new ElImpl(tagName, makeRenderables(children));
-}

package/components/FadeIn.d.ts

@@ -1,20 +0,0 @@
-import { type Clear } from '../clean';
-import { type DOMContext } from '../dom-context';
-import { type Renderable } from '../renderable';
-import { type Animatable } from './animatable';
-export declare class FadeInImpl implements Renderable {
-    private readonly end;
-    private readonly start;
-    private readonly easing;
-    private readonly duration;
-    private readonly delay;
-    constructor(end: Animatable, start: Animatable | undefined, easing: (t: number) => number, duration: number, delay: number);
-    appendTo(ctx: DOMContext): Clear;
-}
-export interface FadeInProps extends Animatable {
-    start?: Animatable;
-    duration?: number;
-    easing?: (t: number) => number;
-    delay?: number;
-}
-export declare function FadeIn(props: FadeInProps): Renderable;

package/components/FadeIn.js

@@ -1,54 +0,0 @@
-import { getComputedAnimatable, applyInterpolatedAnimatable, applyAnimatable } from './animatable';
-export class FadeInImpl {
-    end;
-    start;
-    easing;
-    duration;
-    delay;
-    constructor(end, start, easing, duration, delay) {
-        this.end = end;
-        this.start = start;
-        this.easing = easing;
-        this.duration = duration;
-        this.delay = delay;
-    }
-    appendTo(ctx) {
-        const el = ctx.getElement();
-        const start = (() => {
-            if (this.start != null) {
-                applyAnimatable(el, this.start);
-                return this.start;
-            }
-            else {
-                return getComputedAnimatable(el, this.end);
-            }
-        })();
-        const startTime = Date.now() + this.delay;
-        const { duration, end, easing } = this;
-        let nextFrameId = null;
-        function frame() {
-            const now = Date.now();
-            if (now < startTime) {
-                nextFrameId = requestAnimationFrame(frame);
-                return;
-            }
-            const progress = Math.min((now - startTime) / duration, 1);
-            applyInterpolatedAnimatable(el, start, end, easing(progress));
-            if (progress < 1) {
-                nextFrameId = requestAnimationFrame(frame);
-            }
-            else {
-                nextFrameId = null;
-            }
-        }
-        frame();
-        return (_) => {
-            if (nextFrameId != null)
-                cancelAnimationFrame(nextFrameId);
-        };
-    }
-}
-export function FadeIn(props) {
-    const { start, duration, easing, delay, ...end } = props;
-    return new FadeInImpl(end, start, easing ?? (v => v), duration ?? 200, delay ?? 0);
-}

package/components/FadeOut.d.ts

@@ -1,16 +0,0 @@
-import { type Clear } from '../clean';
-import { type DOMContext } from '../dom-context';
-import { type Renderable } from '../renderable';
-import { type Animatable } from './animatable';
-export declare class FadeOutImpl implements Renderable {
-    private readonly end;
-    private readonly duration;
-    private readonly delay;
-    constructor(end: Animatable, duration: number, delay: number);
-    appendTo(ctx: DOMContext): Clear;
-}
-export interface FadeOutProps extends Animatable {
-    duration?: number;
-    delay?: number;
-}
-export declare function FadeOut(props: FadeOutProps): Renderable;

package/components/FadeOut.js

@@ -1,39 +0,0 @@
-import { getComputedAnimatable, applyInterpolatedAnimatable } from './animatable';
-export class FadeOutImpl {
-    end;
-    duration;
-    delay;
-    constructor(end, duration, delay) {
-        this.end = end;
-        this.duration = duration;
-        this.delay = delay;
-    }
-    appendTo(ctx) {
-        const el = ctx.getElement();
-        const { duration, end } = this;
-        return ctx.delayClear((removeTree, clear) => {
-            const start = getComputedAnimatable(el, this.end);
-            const startTime = Date.now() + this.delay;
-            function frame() {
-                const now = Date.now();
-                if (now < startTime) {
-                    requestAnimationFrame(frame);
-                    return;
-                }
-                const progress = Math.min((now - startTime) / duration, 1);
-                applyInterpolatedAnimatable(el, start, end, progress);
-                if (progress < 1) {
-                    requestAnimationFrame(frame);
-                }
-                else {
-                    clear();
-                }
-            }
-            requestAnimationFrame(frame);
-        });
-    }
-}
-export function FadeOut(props) {
-    const { duration, delay, ...end } = props;
-    return new FadeOutImpl(end, duration ?? 200, delay ?? 0);
-}

package/components/For.d.ts

@@ -1,18 +0,0 @@
-import { type Signal } from '../prop';
-import { type PositionProps } from './Repeat';
-import { type JSX } from '../jsx-runtime';
-export interface ForProps<T> {
-    of: Signal<T[]>;
-    separator?: (value: Signal<PositionProps>) => JSX.DOMNode;
-    children?: (value: Signal<T>, pos: Signal<PositionProps>) => JSX.DOMNode;
-}
-export declare function For<T>({ of, children: render, separator }: ForProps<T>): JSX.DOMNode;
-export interface ForWithPositionProps<T> {
-    of: Signal<T[]>;
-    separator?: (value: Signal<PositionProps>) => JSX.DOMNode;
-    children?: (data: Signal<{
-        value: T;
-        pos: PositionProps;
-    }>) => JSX.DOMNode;
-}
-export declare function ForWithPosition<T>({ of, children: render, separator }: ForWithPositionProps<T>): JSX.DOMNode;

package/components/For.js

@@ -1,27 +0,0 @@
-import { RepeatImpl } from './Repeat';
-import { makeRenderable } from '../jsx-runtime';
-import { FragmentImpl } from './Fragment';
-import { OnRemove } from './OnRemove';
-// <For of={values} separator={() => ", "}>{(value) => <span>{value}</span>}</For>
-export function For({ of, children: render, separator }) {
-    const times = of.map(v => v.length);
-    return new RepeatImpl(times, (pos) => {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const value = of.combine(pos, (arr, { index }) => arr.at(index));
-        return new FragmentImpl([
-            makeRenderable(render?.(value, pos)),
-            OnRemove({ clear: value.clean })
-        ]);
-    }, separator);
-}
-export function ForWithPosition({ of, children: render, separator }) {
-    const times = of.map(v => v.length);
-    return new RepeatImpl(times, (pos) => {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const value = of.combine(pos, (arr, { index }) => arr.at(index));
-        return new FragmentImpl([
-            makeRenderable(render?.(value.combine(pos, (v, p) => ({ value: v, pos: p })))),
-            OnRemove({ clear: value.clean })
-        ]);
-    }, separator);
-}

package/components/Fragment.d.ts

@@ -1,12 +0,0 @@
-import { type Renderable } from '../renderable';
-import { type Clear } from '../clean';
-import { type DOMContext } from '../dom-context';
-import { type JSX } from '../jsx';
-export declare class FragmentImpl implements Renderable {
-    private readonly children;
-    constructor(children: Renderable[]);
-    readonly appendTo: (ctx: DOMContext) => Clear;
-}
-export declare function Fragment({ children }: {
-    children: JSX.DOMNode;
-}): Renderable;

package/components/Fragment.js

@@ -1,16 +0,0 @@
-import { makeRenderables } from '../jsx-runtime';
-export class FragmentImpl {
-    children;
-    constructor(children) {
-        this.children = children;
-    }
-    appendTo = (ctx) => {
-        const clears = this.children.map(child => child.appendTo(ctx));
-        return (removeTree) => {
-            clears.forEach(clear => { clear(removeTree); });
-        };
-    };
-}
-export function Fragment({ children }) {
-    return new FragmentImpl(makeRenderables(children));
-}

package/components/HiddenWhenEmpty.d.ts

@@ -1,7 +0,0 @@
-import { type Renderable } from '../renderable';
-import { type DOMContext } from '../dom-context';
-import { type Clear } from '../clean';
-export declare class HiddenWhenEmptyImpl implements Renderable {
-    appendTo(ctx: DOMContext): Clear;
-}
-export declare function HiddenWhenEmpty(): HiddenWhenEmptyImpl;