@esportsplus/ui 0.56.3 → 0.57.0

package/build/shared/fuzzy.js

@@ -0,0 +1,153 @@
+const BOUNDARY = 8;
+const CAMEL = 7;
+const CONSECUTIVE = 4;
+const EXTENDED = 2;
+const FIRST = 2;
+const GAP_EXTEND = -0.25;
+const GAP_START = -3;
+const JOINED = 1;
+const LEADING = 0.02;
+const LENGTH = 0.01;
+const MATCH = 16;
+let bonuses = new Int32Array(64), folds = new Uint16Array(65536), lowers = new Uint16Array(64), matched = new Float64Array(256), runs = new Int32Array(256), skipped = new Float64Array(256), starts = new Int32Array(16), steps = new Uint8Array(256), texts = new Uint16Array(64);
+function fold(code) {
+    if (code < 128) {
+        return code >= 65 && code <= 90 ? code + 32 : code;
+    }
+    let known = folds[code];
+    if (known === 0) {
+        let lower = String.fromCharCode(code).toLowerCase();
+        known = folds[code] = lower.length === 1 ? lower.charCodeAt(0) : code;
+    }
+    return known;
+}
+function kind(code) {
+    if (code >= 97 && code <= 122) {
+        return 1;
+    }
+    if (code >= 65 && code <= 90) {
+        return 2;
+    }
+    if (code >= 48 && code <= 57) {
+        return 3;
+    }
+    if (code < 128) {
+        return 0;
+    }
+    return fold(code) === code ? 1 : 2;
+}
+export default (query, text) => {
+    let m = query.length, n = text.length;
+    if (m === 0) {
+        return { indices: [], score: 0 };
+    }
+    if (m > n) {
+        return null;
+    }
+    if (m > starts.length) {
+        starts = new Int32Array(m * 2);
+    }
+    if (n > texts.length) {
+        bonuses = new Int32Array(n * 2);
+        lowers = new Uint16Array(n * 2);
+        texts = new Uint16Array(n * 2);
+    }
+    for (let i = 0, j = 0; i < m; i++, j++) {
+        let q = query.charCodeAt(i), lower = fold(q), exact = lower !== q;
+        while (j < n) {
+            let t = text.charCodeAt(j);
+            if (exact ? t === q : fold(t) === lower) {
+                break;
+            }
+            j++;
+        }
+        if (j === n) {
+            return null;
+        }
+        starts[i] = j;
+    }
+    for (let j = 0, previous = 0; j < n; j++) {
+        let code = text.charCodeAt(j), current = kind(code);
+        bonuses[j] = j === 0 || (previous === 0 && current !== 0)
+            ? BOUNDARY
+            : (previous === 1 && current === 2) || (previous !== 3 && current === 3)
+                ? CAMEL
+                : 0;
+        lowers[j] = fold(code);
+        previous = current;
+        texts[j] = code;
+    }
+    if (m * n > matched.length) {
+        matched = new Float64Array(m * n * 2);
+        runs = new Int32Array(m * n * 2);
+        skipped = new Float64Array(m * n * 2);
+        steps = new Uint8Array(m * n * 2);
+    }
+    for (let i = 0; i < m; i++) {
+        let q = query.charCodeAt(i), lower = fold(q), exact = lower !== q, end = n - m + i, row = i * n, up = row - n;
+        for (let j = starts[i]; j <= end; j++) {
+            let cell = row + j, run = 0, score = -Infinity, step = 0;
+            if (j === starts[i]) {
+                skipped[cell] = -Infinity;
+            }
+            else {
+                let extend = skipped[cell - 1] + GAP_EXTEND, open = matched[cell - 1] + GAP_START;
+                if (extend > open) {
+                    skipped[cell] = extend;
+                    step = EXTENDED;
+                }
+                else {
+                    skipped[cell] = open;
+                }
+            }
+            if (exact ? texts[j] === q : lowers[j] === lower) {
+                let bonus = bonuses[j];
+                if (i === 0) {
+                    run = 1;
+                    score = MATCH + bonus * FIRST;
+                }
+                else {
+                    let before = runs[up + j - 1], joined = -Infinity, length = before + 1;
+                    if (before > 0) {
+                        let head = bonuses[j - before], carried = bonus;
+                        if (bonus >= BOUNDARY && bonus > head) {
+                            length = 1;
+                        }
+                        else {
+                            carried = Math.max(bonus, head, CONSECUTIVE);
+                        }
+                        joined = matched[up + j - 1] + MATCH + carried;
+                    }
+                    score = skipped[up + j - 1] + MATCH + bonus;
+                    run = 1;
+                    if (joined >= score) {
+                        run = length;
+                        score = joined;
+                        step |= JOINED;
+                    }
+                }
+            }
+            matched[cell] = score;
+            runs[cell] = run;
+            steps[cell] = step;
+        }
+    }
+    let best = -Infinity, last = n - 1, row = (m - 1) * n;
+    for (let j = starts[m - 1]; j < n; j++) {
+        if (matched[row + j] > best) {
+            best = matched[row + j];
+            last = j;
+        }
+    }
+    let indices = new Array(m);
+    for (let i = m - 1, j = last, skipping = false; i >= 0; j--) {
+        let step = steps[i * n + j];
+        if (skipping) {
+            skipping = (step & EXTENDED) !== 0;
+            continue;
+        }
+        indices[i--] = j;
+        skipping = (step & JOINED) === 0;
+    }
+    return { indices, score: best - indices[0] * LEADING - (n - m) * LENGTH };
+};

package/build/shared/keystep.d.ts

@@ -0,0 +1,2 @@
+declare const keystep: (e: KeyboardEvent, step: number) => number | null;
+export { keystep };

package/build/shared/keystep.js

@@ -0,0 +1,21 @@
+const keystep = (e, step) => {
+    let big = step * 10, unit = e.shiftKey ? big : step;
+    switch (e.key) {
+        case 'ArrowRight':
+        case 'ArrowUp':
+            return unit;
+        case 'ArrowDown':
+        case 'ArrowLeft':
+            return -unit;
+        case 'End':
+            return Infinity;
+        case 'Home':
+            return -Infinity;
+        case 'PageDown':
+            return -big;
+        case 'PageUp':
+            return big;
+    }
+    return null;
+};
+export { keystep };

package/build/shared/platform.d.ts

@@ -0,0 +1,2 @@
+declare const mac: () => boolean;
+export { mac };

package/build/shared/platform.js

@@ -0,0 +1,3 @@
+const APPLE_PLATFORM = /mac|iphone|ipad/i;
+const mac = () => APPLE_PLATFORM.test(navigator.userAgentData?.platform || navigator.platform);
+export { mac };

package/build/shared/press.d.ts

@@ -0,0 +1,15 @@
+import type { Attributes } from '@esportsplus/template';
+type Handlers = {
+    end: (e: PointerEvent | null, started: boolean) => void;
+    move: (e: PointerEvent) => void;
+    start: VoidFunction;
+};
+export default _default;
+declare function _default(delay: number): {
+    attributes: Attributes;
+    begin: (e: PointerEvent, handlers: Handlers) => void;
+    busy: () => boolean;
+    cancel: () => void;
+};
+declare const swallow: () => void;
+export { swallow };

package/build/shared/press.js

@@ -0,0 +1,83 @@
+const THRESHOLD = 4;
+function stop(e) {
+    e.preventDefault();
+    e.stopPropagation();
+}
+export default (delay) => {
+    let session = null;
+    function finish(e) {
+        let current = session;
+        session = null;
+        clearTimeout(current.timer);
+        current.listening?.abort();
+        if (current.started && e) {
+            swallow();
+        }
+        current.end(e, current.started);
+    }
+    function prevent(e) {
+        if (session) {
+            e.preventDefault();
+        }
+    }
+    function release(e) {
+        if (session && e.pointerId === session.pointer) {
+            finish(e);
+        }
+    }
+    function scroll(e) {
+        if (session?.started) {
+            e.preventDefault();
+        }
+    }
+    function start() {
+        let current = session;
+        clearTimeout(current.timer);
+        current.started = true;
+        getSelection()?.removeAllRanges();
+        current.start();
+    }
+    return {
+        attributes: {
+            ondocumentcontextmenu: prevent,
+            ondocumentdragstart: prevent,
+            ondocumentpointercancel: release,
+            ondocumentpointermove: (e) => {
+                if (!session || e.pointerId !== session.pointer) {
+                    return;
+                }
+                session.move(e);
+                if (session.started || Math.hypot(e.clientX - session.originX, e.clientY - session.originY) < THRESHOLD) {
+                    return;
+                }
+                if (session.target) {
+                    finish(null);
+                }
+                else {
+                    start();
+                }
+            },
+            ondocumentpointerup: release,
+            ondocumentselectstart: prevent
+        },
+        begin: (e, handlers) => {
+            let target = e.pointerType === 'touch' ? e.target : null, listening = target && new AbortController();
+            session = { ...handlers, listening, originX: e.clientX, originY: e.clientY, pointer: e.pointerId, started: false, target };
+            if (target && listening) {
+                document.addEventListener('touchmove', scroll, { passive: false, signal: listening.signal });
+                target.addEventListener('touchmove', scroll, { passive: false, signal: listening.signal });
+                session.timer = setTimeout(start, delay);
+            }
+        },
+        busy: () => session !== null,
+        cancel: () => {
+            if (session) {
+                finish(null);
+            }
+        }
+    };
+};
+const swallow = () => {
+    addEventListener('click', stop, { capture: true, once: true, signal: AbortSignal.timeout(0) });
+};
+export { swallow };

package/build/shared/resize.d.ts

@@ -0,0 +1,18 @@
+type Handler = (entries: ResizeObserverEntry[]) => void;
+type Observer = {
+    disconnect: VoidFunction;
+    observe: (element: Element, options?: ResizeObserverOptions) => void;
+    unobserve: (element: Element) => void;
+};
+type Size = {
+    height: number;
+    width: number;
+};
+declare const observe: (element: Element, handler: Handler, options?: ResizeObserverOptions) => () => void;
+declare const observer: (handler: Handler) => Observer;
+declare const observeSize: (change: (size: Size, element: HTMLElement) => void) => {
+    onconnect: (element: HTMLElement) => void;
+    ondisconnect: () => void;
+};
+export { observe, observer, observeSize };
+export type { Observer, Size };

package/build/shared/resize.js

@@ -0,0 +1,137 @@
+let connecting = new Set(), frame = 0, handlers = new WeakMap(), queued = new Set(), shared;
+function dispatch(entries) {
+    let batches = new Map();
+    for (let i = 0, n = entries.length; i < n; i++) {
+        let entry = entries[i], listeners = handlers.get(entry.target);
+        if (!listeners) {
+            continue;
+        }
+        for (let handler of listeners) {
+            let batch = batches.get(handler);
+            if (batch) {
+                batch.push(entry);
+            }
+            else {
+                batches.set(handler, [entry]);
+            }
+        }
+    }
+    for (let [handler, batch] of batches) {
+        let live = batch.filter((entry) => handlers.get(entry.target)?.has(handler));
+        if (live.length) {
+            handler(live);
+        }
+    }
+}
+function equal(a, b) {
+    return a?.height === b?.height && a?.width === b?.width;
+}
+function flush() {
+    let observations = [...connecting], sizes = observations.map(({ element }) => measure(element));
+    connecting.clear();
+    for (let i = 0, n = observations.length; i < n; i++) {
+        let { height, vertical, width } = sizes[i], observation = observations[i];
+        observation.applied = { height, width };
+        observation.vertical = vertical;
+        if (height || width) {
+            observation.change(observation.applied, observation.element);
+        }
+    }
+}
+function measure(element) {
+    let height = element.offsetHeight, rect = element.getBoundingClientRect(), vertical = getComputedStyle(element).writingMode !== 'horizontal-tb', width = element.offsetWidth;
+    if (Math.abs(rect.height - height) < 1 && Math.abs(rect.width - width) < 1) {
+        return { height: rect.height, vertical, width: rect.width };
+    }
+    return { height, vertical, width };
+}
+function render() {
+    let observations = [...queued];
+    frame = 0;
+    queued.clear();
+    for (let i = 0, n = observations.length; i < n; i++) {
+        let observation = observations[i], size = observation.pending;
+        if (size && !equal(size, observation.applied)) {
+            observation.applied = size;
+            observation.change(size, observation.element);
+        }
+    }
+}
+const observe = (element, handler, options) => {
+    let listeners = handlers.get(element);
+    if (!listeners) {
+        handlers.set(element, listeners = new Set());
+    }
+    listeners.add(handler);
+    (shared ??= new ResizeObserver(dispatch)).observe(element, options);
+    return () => unobserve(element, handler);
+};
+const observer = (handler) => {
+    let elements = new Set();
+    return {
+        disconnect: () => {
+            for (let element of elements) {
+                unobserve(element, handler);
+            }
+            elements.clear();
+        },
+        observe: (element, options) => {
+            elements.add(element);
+            observe(element, handler, options);
+        },
+        unobserve: (element) => {
+            elements.delete(element);
+            unobserve(element, handler);
+        }
+    };
+};
+const observeSize = (change) => {
+    let current, release;
+    function disconnect() {
+        if (current) {
+            connecting.delete(current);
+            queued.delete(current);
+            current = undefined;
+        }
+        release?.();
+        release = undefined;
+    }
+    return {
+        onconnect: (element) => {
+            disconnect();
+            let observation = current = { change, element, vertical: false };
+            if (!connecting.size) {
+                queueMicrotask(flush);
+            }
+            connecting.add(observation);
+            release = observe(element, ([entry]) => {
+                if (!entry || connecting.has(observation)) {
+                    return;
+                }
+                let box = entry.borderBoxSize[0], vertical = observation.vertical, size = {
+                    height: vertical ? box.inlineSize : box.blockSize,
+                    width: vertical ? box.blockSize : box.inlineSize
+                };
+                observation.pending = size;
+                if (equal(size, observation.applied)) {
+                    queued.delete(observation);
+                    return;
+                }
+                queued.add(observation);
+                frame ||= requestAnimationFrame(render);
+            }, { box: 'border-box' });
+        },
+        ondisconnect: disconnect
+    };
+};
+const unobserve = (element, handler) => {
+    let listeners = handlers.get(element);
+    if (!listeners?.delete(handler)) {
+        return;
+    }
+    if (!listeners.size) {
+        handlers.delete(element);
+        shared?.unobserve(element);
+    }
+};
+export { observe, observer, observeSize };

package/build/shared/subscribe.d.ts

@@ -0,0 +1,3 @@
+import type { ReactiveArray } from '@esportsplus/reactivity';
+export default _default;
+declare function _default<T>(data: ReactiveArray<T>, listener: VoidFunction): () => void;

package/build/shared/subscribe.js

@@ -0,0 +1,12 @@
+const EVENTS = ['clear', 'concat', 'pop', 'push', 'reverse', 'set', 'shift', 'sort', 'splice', 'unshift'];
+export default (data, listener) => {
+    let unsubscribe = [];
+    for (let i = 0, n = EVENTS.length; i < n; i++) {
+        unsubscribe.push(data.on(EVENTS[i], listener));
+    }
+    return () => {
+        for (let i = 0, n = unsubscribe.length; i < n; i++) {
+            unsubscribe[i]();
+        }
+    };
+};

package/build/shared/ticker.d.ts

@@ -0,0 +1,3 @@
+type Tick = (now: number) => void;
+declare const ticker: (tick: Tick) => () => void;
+export { ticker };

package/build/shared/ticker.js

@@ -0,0 +1,34 @@
+let frame = 0, snapshot = [], ticks = new Set();
+function run(now) {
+    frame = 0;
+    for (let tick of ticks) {
+        snapshot.push(tick);
+    }
+    for (let i = 0, n = snapshot.length; i < n; i++) {
+        let tick = snapshot[i];
+        if (!ticks.has(tick)) {
+            continue;
+        }
+        try {
+            tick(now);
+        }
+        catch (error) {
+            reportError(error);
+        }
+    }
+    snapshot.length = 0;
+    if (ticks.size) {
+        frame ||= requestAnimationFrame(run);
+    }
+}
+const ticker = (tick) => {
+    ticks.add(tick);
+    frame ||= requestAnimationFrame(run);
+    return () => {
+        if (ticks.delete(tick) && !ticks.size && frame) {
+            cancelAnimationFrame(frame);
+            frame = 0;
+        }
+    };
+};
+export { ticker };

package/build/shared/transition.d.ts

@@ -0,0 +1,11 @@
+declare const trackTransition: (property: string, change: (running: boolean, element?: HTMLElement) => void) => {
+    settle: () => void;
+    attributes: {
+        onconnect: (target: HTMLElement) => void;
+        ondisconnect: () => void;
+        ontransitioncancel: (event: TransitionEvent) => void;
+        ontransitionend: (event: TransitionEvent) => void;
+        ontransitionrun: (event: TransitionEvent) => void;
+    };
+};
+export { trackTransition };

package/build/shared/transition.js

@@ -0,0 +1,49 @@
+const trackTransition = (property, change) => {
+    let element, frame;
+    function settle() {
+        if (frame !== undefined) {
+            cancelAnimationFrame(frame);
+        }
+        frame = requestAnimationFrame(() => {
+            frame = undefined;
+            change(!!element?.getAnimations().some(animation => 'transitionProperty' in animation && animation.transitionProperty === property &&
+                animation.playState !== 'finished' && animation.playState !== 'idle'), element);
+        });
+    }
+    function incoming(event) {
+        return event.target === element && !event.pseudoElement && event.propertyName === property;
+    }
+    return {
+        settle,
+        attributes: {
+            onconnect: (target) => {
+                element = target;
+                settle();
+            },
+            ondisconnect: () => {
+                if (frame !== undefined) {
+                    cancelAnimationFrame(frame);
+                    frame = undefined;
+                }
+                element = undefined;
+                change(false);
+            },
+            ontransitioncancel: (event) => {
+                if (incoming(event)) {
+                    settle();
+                }
+            },
+            ontransitionend: (event) => {
+                if (incoming(event)) {
+                    settle();
+                }
+            },
+            ontransitionrun: (event) => {
+                if (incoming(event)) {
+                    change(true, element);
+                }
+            }
+        }
+    };
+};
+export { trackTransition };

package/build/shared/viewport.d.ts

@@ -0,0 +1,7 @@
+declare const fit: (start: number, size: number, extent: number, margin: number) => number;
+declare const flip: (start: number, size: number, extent: number, margin: number) => number;
+declare const viewport: () => {
+    height: number;
+    width: number;
+};
+export { fit, flip, viewport };

package/build/shared/viewport.js

@@ -0,0 +1,11 @@
+const fit = (start, size, extent, margin) => {
+    return Math.max(margin, Math.min(start, extent - margin - size));
+};
+const flip = (start, size, extent, margin) => {
+    return Math.max(margin, start + size > extent - margin ? start - size : start);
+};
+const viewport = () => {
+    let root = document.documentElement;
+    return { height: root.clientHeight, width: root.clientWidth };
+};
+export { fit, flip, viewport };

package/build/shared/visible.d.ts

@@ -0,0 +1,8 @@
+type Handler = (entries: IntersectionObserverEntry[]) => void;
+type Options = Omit<IntersectionObserverInit, 'root'>;
+declare const observeIntersection: (element: Element, handler: Handler, options?: Options) => () => void;
+declare const onceVisible: (show: VoidFunction, options?: Options) => {
+    onconnect: (element: HTMLElement) => void;
+    ondisconnect: () => void;
+};
+export { observeIntersection, onceVisible };

package/build/shared/visible.js

@@ -0,0 +1,79 @@
+let shared = new Map();
+function dispatch(handlers, entries) {
+    let batches = new Map();
+    for (let i = 0, n = entries.length; i < n; i++) {
+        let entry = entries[i], listeners = handlers.get(entry.target);
+        if (!listeners) {
+            continue;
+        }
+        for (let handler of listeners) {
+            let batch = batches.get(handler);
+            if (batch) {
+                batch.push(entry);
+            }
+            else {
+                batches.set(handler, [entry]);
+            }
+        }
+    }
+    for (let [handler, batch] of batches) {
+        let live = batch.filter((entry) => handlers.get(entry.target)?.has(handler));
+        if (live.length) {
+            handler(live);
+        }
+    }
+}
+function key({ rootMargin = '0px', threshold = 0 }) {
+    return `${rootMargin}|${typeof threshold === 'number' ? threshold : threshold.join(',')}`;
+}
+const observeIntersection = (element, handler, options = {}) => {
+    let id = key(options), group = shared.get(id);
+    if (!group) {
+        let handlers = new Map();
+        shared.set(id, group = {
+            handlers,
+            observer: new IntersectionObserver((entries) => dispatch(handlers, entries), options)
+        });
+    }
+    let { handlers, observer } = group, listeners = handlers.get(element);
+    if (listeners) {
+        observer.unobserve(element);
+    }
+    else {
+        handlers.set(element, listeners = new Set());
+    }
+    listeners.add(handler);
+    observer.observe(element);
+    return () => {
+        if (!listeners.delete(handler) || listeners.size) {
+            return;
+        }
+        handlers.delete(element);
+        observer.unobserve(element);
+        if (!handlers.size) {
+            observer.disconnect();
+            shared.delete(id);
+        }
+    };
+};
+const onceVisible = (show, options) => {
+    let release;
+    function stop() {
+        release?.();
+        release = undefined;
+    }
+    return {
+        onconnect: (element) => {
+            stop();
+            release = observeIntersection(element, (entries) => {
+                if (!entries.some((entry) => entry.isIntersecting)) {
+                    return;
+                }
+                stop();
+                show();
+            }, options);
+        },
+        ondisconnect: stop
+    };
+};
+export { observeIntersection, onceVisible };