@lexriver/dome 2.0.1 → 2.0.3

package/out/src/AnimatedArray.d.ts

@@ -0,0 +1,29 @@
+import { Animation } from './Animation';
+interface KeyToElementPair {
+    key: string;
+    element: HTMLElement;
+}
+export declare class AnimatedArray<T> {
+    protected params: {
+        parentElement?: HTMLElement;
+        array?: T[];
+        getKey: (o: T) => string;
+        getHtmlElement: (o: T) => HTMLElement;
+        animationShow?: Animation;
+        animationHide?: Animation;
+        emptyList?: HTMLElement;
+    };
+    arrayOfKeyToElement: KeyToElementPair[];
+    constructor(params: {
+        parentElement?: HTMLElement;
+        array?: T[];
+        getKey: (o: T) => string;
+        getHtmlElement: (o: T) => HTMLElement;
+        animationShow?: Animation;
+        animationHide?: Animation;
+        emptyList?: HTMLElement;
+    });
+    get size(): number;
+    update(array: T[], parentElement?: HTMLElement | Element): void;
+}
+export {};

package/out/src/AnimatedTable.d.mts

@@ -1,6 +1,7 @@
 import { ObservableVariable } from '@lexriver/observable';
 import { Animation } from './Animation.mjs';
-import { AnimatedArray, DomeComponent } from "./index.mjs";
+import { AnimatedArray } from "./AnimatedArray.mjs";
+import { DomeComponent } from "./DomeComponent.mjs";
 interface Attrs<T> {
     isLoadingO?: ObservableVariable<boolean>;
     itemsO: ObservableVariable<T[]>;

package/out/src/AnimatedTable.d.ts

@@ -0,0 +1,39 @@
+import { ObservableVariable } from '@lexriver/observable';
+import { Animation } from './Animation';
+import { AnimatedArray } from "./AnimatedArray";
+import { DomeComponent } from "./DomeComponent";
+interface Attrs<T> {
+    isLoadingO?: ObservableVariable<boolean>;
+    itemsO: ObservableVariable<T[]>;
+    animationShowRow: Animation;
+    animationHideRow: Animation;
+    animationHideTable?: Animation;
+    animationShowTable?: Animation;
+    animationHideEmptyList?: Animation;
+    animationShowEmptyList?: Animation;
+    animationShowLoading?: Animation;
+    animationHideLoading?: Animation;
+    getKey: (item: T) => string;
+    rootElement?: HTMLElement;
+    tableElement?: HTMLElement;
+    tableBody?: HTMLElement;
+    renderTableHead?: (items: T[]) => HTMLElement;
+    renderTableRow: (item: T) => HTMLElement;
+    renderTableFooter?: (items: T[]) => HTMLElement;
+    renderEmptyList: () => HTMLElement;
+    renderLoading?: () => HTMLElement;
+}
+export declare class AnimatedTable<T> extends DomeComponent<Attrs<T>> {
+    refRoot: HTMLElement;
+    refTable: HTMLElement;
+    refTableHead: Element;
+    refTableBody: HTMLElement;
+    refTableFooter: Element;
+    refEmptyList: Element;
+    refLoading: Element;
+    animatedArray: AnimatedArray<T>;
+    render(): HTMLElement;
+    afterRender(): void;
+    updateAsync(): Promise<void>;
+}
+export {};

package/out/src/AnimatedTable.mjs

@@ -1,5 +1,6 @@
 import { DomeManipulator } from "./DomeManipulator.mjs";
-import { AnimatedArray, DomeComponent } from "./index.mjs";
+import { AnimatedArray } from "./AnimatedArray.mjs";
+import { DomeComponent } from "./DomeComponent.mjs";
 export class AnimatedTable extends DomeComponent {
     // rootElement
     //   table

package/out/src/AnimatedText.d.mts

@@ -1,6 +1,6 @@
 import { ObservableVariable } from "@lexriver/observable";
 import { CssClass } from "./DomeManipulator.mjs";
-import { DomeComponent } from "./index.mjs";
+import { DomeComponent } from "./DomeComponent.mjs";
 interface Attrs {
     textO: ObservableVariable<string>;
     tag?: string;

package/out/src/AnimatedText.d.ts

@@ -0,0 +1,13 @@
+import { ObservableVariable } from "@lexriver/observable";
+import { CssClass } from "./DomeManipulator";
+import { DomeComponent } from "./DomeComponent";
+interface Attrs {
+    textO: ObservableVariable<string>;
+    tag?: string;
+    class?: CssClass;
+}
+export declare class AnimatedText extends DomeComponent<Attrs> {
+    render(): HTMLElement;
+    updateAsync(): Promise<void>;
+}
+export {};

package/out/src/AnimatedText.mjs

@@ -1,5 +1,5 @@
 import { DomeManipulator } from "./DomeManipulator.mjs";
-import { DomeComponent } from "./index.mjs";
+import { DomeComponent } from "./DomeComponent.mjs";
 export class AnimatedText extends DomeComponent {
     render() {
         //const result = this.attrs.tag ? document.createElement(this.attrs.tag) : document.createElement('span')

package/out/src/Animation.d.ts

@@ -0,0 +1,4 @@
+export interface Animation {
+    cssClassName: string;
+    timeMs: number;
+}

package/out/src/Dome.d.ts

@@ -0,0 +1,9 @@
+export declare function h(tagName: any, attrs: any, ...childrenArgs: any[]): any;
+export declare const React: {
+    createElement: typeof h;
+    Fragment: {
+        new (): DocumentFragment;
+        prototype: DocumentFragment;
+    } | (() => void);
+};
+export default React;

package/out/src/Dome.mjs

@@ -1,5 +1,5 @@
 // inspiration: https://github.com/vadimdemedes/dom-chef/blob/master/index.js
-const svgTagNames = require('svg-tag-names');
+import { svgTagNames } from 'svg-tag-names';
 import { DataTypes } from '@lexriver/data-types';
 import { checkIfObservable } from '@lexriver/observable';
 import { DomeManipulator } from './DomeManipulator.mjs';

package/out/src/DomeComponent.d.mts

@@ -8,13 +8,16 @@ export declare abstract class DomeComponent<Attrs> {
     attrs: Attrs & InternalAttrs;
     children: any;
     rootElement: Element | HTMLElement;
+    private updateInProgress;
+    private updateRequested;
     constructor(attrs: Attrs & InternalAttrs, children: any);
     protected init(): void;
     protected abstract render(): HTMLElement;
     protected afterRender(): void;
     updateAsync(): Promise<void>;
+    private runScheduledUpdateAsync;
     scheduleUpdate: {
-        (this: unknown, ...args: [] & any[]): Promise<void>;
+        (this: unknown, ...args: [] & any[]): Promise<Promise<void>>;
         cancel: (reason?: any) => void;
     };
     protected afterUpdate(): void;

package/out/src/DomeComponent.d.ts

@@ -0,0 +1,25 @@
+import { Animation } from './Animation';
+interface InternalAttrs {
+    ref?: (ref: any) => void;
+    onShowAnimation?: Animation;
+    onHideAnimation?: Animation;
+}
+export declare abstract class DomeComponent<Attrs> {
+    attrs: Attrs & InternalAttrs;
+    children: any;
+    rootElement: Element | HTMLElement;
+    private updateInProgress;
+    private updateRequested;
+    constructor(attrs: Attrs & InternalAttrs, children: any);
+    protected init(): void;
+    protected abstract render(): HTMLElement;
+    protected afterRender(): void;
+    updateAsync(): Promise<void>;
+    private runScheduledUpdateAsync;
+    scheduleUpdate: {
+        (this: unknown, ...args: [] & any[]): Promise<Promise<void>>;
+        cancel: (reason?: any) => void;
+    };
+    protected afterUpdate(): void;
+}
+export {};

package/out/src/DomeComponent.mjs

@@ -4,6 +4,8 @@ export class DomeComponent {
     attrs;
     children;
     rootElement;
+    updateInProgress = false;
+    updateRequested = false;
     constructor(attrs, children) {
         //this.init()
         this.attrs = attrs;
@@ -35,9 +37,28 @@ export class DomeComponent {
         //console.timeEnd('browser')
         this.afterUpdate();
     }
-    scheduleUpdate = debounce(() => {
-        this.updateAsync();
-    }, 5);
+    async runScheduledUpdateAsync() {
+        if (this.updateInProgress) {
+            this.updateRequested = true;
+            return;
+        }
+        this.updateInProgress = true;
+        try {
+            do {
+                this.updateRequested = false;
+                try {
+                    await this.updateAsync();
+                }
+                catch (error) {
+                    console.error('DomeComponent: scheduled update failed', error);
+                }
+            } while (this.updateRequested);
+        }
+        finally {
+            this.updateInProgress = false;
+        }
+    }
+    scheduleUpdate = debounce(() => this.runScheduledUpdateAsync(), 5);
     afterUpdate() {
     }
 }

package/out/src/DomeManipulator.d.mts

@@ -16,6 +16,10 @@ export declare namespace DomeManipulator {
     function removeAllChildrenAsync(element: Element, animation?: Animation): Promise<void>;
     function appendChildAsync(containerElement: Element, child: Element, animation?: Animation): Promise<void>;
     function appendChildrenAsync(containerElement: Element, children: Element | Element[] | DocumentFragment | Text | string | null | undefined, animation?: Animation): Promise<void>;
+    /**
+     * Replacements for the same container run in call order. A rejected replacement does
+     * not block the queue, and replacements for different containers remain independent.
+     */
     function replaceAllChildrenAsync(containerElement: Element, childrenToInsert: Element | Element[] | DocumentFragment | Text | string | null | undefined, animationForHide?: Animation, animationForShow?: Animation): Promise<void>;
     function isInDom(el: Element | undefined): boolean;
     function isOnScreen(el: Element | undefined): boolean;

package/out/src/DomeManipulator.d.ts

@@ -0,0 +1,52 @@
+import { ObservableVariable } from "@lexriver/observable";
+import { Animation } from './Animation';
+export type CssClass = {
+    [key: string]: boolean | ObservableVariable<boolean>;
+} | string[] | string;
+export declare namespace DomeManipulator {
+    function hideElementAsync(element: Element, animation?: Animation): Promise<void>;
+    function unhideElementAsync(element: Element, animation?: Animation): Promise<void>;
+    function insertAsFirstChildAsync(elementToInsert: Element, parentElement: Element | DocumentFragment, animation?: Animation): Promise<void>;
+    function insertBeforeAsync(elementToInsert: Element, refElement: Element | null, parentElement: Element | DocumentFragment, animation?: Animation): Promise<void>;
+    function insertAfterAsync(elementToInsert: Element, refElement: Element | null | undefined, parentElement: Element | DocumentFragment, animation?: Animation): Promise<void>;
+    function insertByIndexAsync(elementToInsert: Element, index: number, parentElement: Element | DocumentFragment, animation?: Animation): Promise<void>;
+    function replaceAsync(oldElement: Element, newElement: Element, animationHide?: Animation, animationShow?: Animation): Promise<Element>;
+    function removeElementAsync(element: Element, animation?: Animation): Promise<void>;
+    function forEachChildrenOf(element: Element, action: (child: ChildNode) => void): void;
+    function removeAllChildrenAsync(element: Element, animation?: Animation): Promise<void>;
+    function appendChildAsync(containerElement: Element, child: Element, animation?: Animation): Promise<void>;
+    function appendChildrenAsync(containerElement: Element, children: Element | Element[] | DocumentFragment | Text | string | null | undefined, animation?: Animation): Promise<void>;
+    /**
+     * Replacements for the same container run in call order. A rejected replacement does
+     * not block the queue, and replacements for different containers remain independent.
+     */
+    function replaceAllChildrenAsync(containerElement: Element, childrenToInsert: Element | Element[] | DocumentFragment | Text | string | null | undefined, animationForHide?: Animation, animationForShow?: Animation): Promise<void>;
+    function isInDom(el: Element | undefined): boolean;
+    function isOnScreen(el: Element | undefined): boolean;
+    function addCssClassAsync(element: Element, cssClassName: string, removeAfterMs?: number): Promise<void>;
+    function addCssClassesAsync(element: Element, cssClassNames: string[], removeAfterMs?: number): Promise<void>;
+    function removeCssClass(element: Element, cssClassName: string): void;
+    function removeCssClasses(element: Element, cssClassNames: string[]): void;
+    /**
+     * set css classes by array ['class1', 'class2'] or
+     * by object {class1:true, class2:false} or
+     * by Observable<boolean> {class1:true, class2:myVarO} or
+     * by string
+     * this function will replace class attribute so all classes that are not in params will be removed
+     * @param value
+     * @param element
+     */
+    function setCssClasses(element: Element, value: CssClass): void;
+    function setAttribute(element: Element, name: string, value: any): void;
+    function hasFocus(el: Element): boolean;
+    function scrollIntoView(element: Element, paddingFromTop?: number): void;
+    const scrollToTop: () => void;
+    function getCurrentScrollPosition(): number;
+    function scrollToAsync(p: {
+        pxFromTop?: number;
+        pxFromLeft?: number;
+        smooth?: boolean;
+        msStep?: number;
+        maxMsToWait?: number;
+    }): Promise<void>;
+}

package/out/src/DomeManipulator.mjs

@@ -1,6 +1,7 @@
 import { Async } from "@lexriver/async";
 import { DataTypes } from "@lexriver/data-types";
 import { checkIfObservable } from "@lexriver/observable";
+const replacementPromiseByElement = new WeakMap();
 export var DomeManipulator;
 (function (DomeManipulator) {
     async function hideElementAsync(element, animation) {
@@ -121,8 +122,8 @@ export var DomeManipulator;
             forEachChildrenOf(element, (child) => child.nodeType == Node.ELEMENT_NODE && child.classList.add(animation.cssClassName));
             //console.log('##', 'wait ms', animation.timeMs)
             await Async.waitMsAsync(animation.timeMs);
-            //console.log('##', 'removing children', element.childNodes)
-            forEachChildrenOf(element, (child) => child.remove());
+            // Take a snapshot because childNodes is live and shrinks as nodes are removed.
+            Array.from(element.childNodes).forEach(child => child.remove());
             //console.log('##', 'done')
         }
         // if(element.children.length>0) {
@@ -152,19 +153,29 @@ export var DomeManipulator;
         }
     }
     DomeManipulator.appendChildrenAsync = appendChildrenAsync;
+    /**
+     * Replacements for the same container run in call order. A rejected replacement does
+     * not block the queue, and replacements for different containers remain independent.
+     */
     async function replaceAllChildrenAsync(containerElement, childrenToInsert, animationForHide, animationForShow) {
-        //await removeAllChildrenAsync(containerElement, animationForHide)
-        if (containerElement.childNodes.length > 0) {
-            await removeAllChildrenAsync(containerElement, animationForHide);
+        const previousReplacement = replacementPromiseByElement.get(containerElement);
+        const replacement = (previousReplacement ?? Promise.resolve())
+            .catch(() => undefined)
+            .then(async () => {
+            if (containerElement.childNodes.length > 0) {
+                await removeAllChildrenAsync(containerElement, animationForHide);
+            }
+            await appendChildrenAsync(containerElement, childrenToInsert, animationForShow);
+        });
+        replacementPromiseByElement.set(containerElement, replacement);
+        try {
+            await replacement;
+        }
+        finally {
+            if (replacementPromiseByElement.get(containerElement) === replacement) {
+                replacementPromiseByElement.delete(containerElement);
+            }
         }
-        // while(containerElement.childNodes.length>0){
-        //     await removeAllChildrenAsync(containerElement, animationForHide) // can be executed more than once! TODO: why?
-        // }
-        // if(containerElement.children.length>0) {
-        //     console.error('DomeManipulator: replaceAllChildenrAsync() failed:', 'containerElement.children.length=', containerElement.children.length, 'children=', containerElement.children, 'containerElement=', containerElement, 'animationForHide=', animationForHide)
-        //     throw new Error()
-        // }
-        await appendChildrenAsync(containerElement, childrenToInsert, animationForShow);
     }
     DomeManipulator.replaceAllChildrenAsync = replaceAllChildrenAsync;
     function isInDom(el) {

package/out/src/DomeRouter.console-test.d.ts

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

package/out/src/DomeRouter.d.ts

@@ -0,0 +1,32 @@
+export type RouteAction = (params: {
+    [key: string]: string | number;
+}, url: string, scrollToPreviousPositionAsync: () => Promise<void>, query: {
+    [key: string]: string;
+}) => void | Promise<void>;
+export declare namespace DomeRouter {
+    let maxHistoryUrlsCount: number;
+    function navigate(url: string): void;
+    function goBack(): void;
+    function goForward(): void;
+    function changeUrl(url: string): void;
+    function getCurrentUrl(): string;
+    /**
+     * get previous page url navigated by router
+     * @param previousPageIndex 0=previousPage, 1=previousPage-1, etc
+     */
+    function getPreviousPageUrl(previousPageIndex?: number): string | undefined;
+    function resolveUrl(url?: string, addToHistory?: boolean): void;
+    function onRoute(route: string, exactMatch: boolean, action: RouteAction): void;
+    function onNotFound(action: () => void): void;
+    /**
+     * Check if url matched route.
+     *   example: /get-product/445345, /get-product/:productId, true ==> Map([productId:445345])
+     *   example: /get-product/123, /another-route, true ==> undefined
+     *   example: /articles, /articles, true ==> Map()
+     *   example: /articles/some-article, /articles, false ==> Map()
+     * @param url
+     * @param route
+     * @param exactMatch
+     */
+    function checkUrlMatchRouteAndGetParameters(url: string, route: string, exactMatch?: boolean): Object | undefined;
+}

package/out/src/LongestCommonSubsequence.d.ts

@@ -0,0 +1,15 @@
+export declare namespace LongestCommonSubsequence {
+    function getLongestCommonSubsequence(set1: string[], set2: string[]): string[];
+    function getPatch({ oldArray, newArray, onRemove, onAdd }: {
+        oldArray: string[];
+        newArray: string[];
+        onRemove: (index: number, item: string) => void;
+        onAdd: (index: number, item: string) => void;
+    }): number;
+    function getPatchOrdered({ oldArray, newArray, onRemove, onAdd }: {
+        oldArray: string[];
+        newArray: string[];
+        onRemove: (index: number, item: string) => void;
+        onAdd: (index: number, item: string) => void;
+    }): number;
+}

package/out/src/concurrent-updates.test.d.mts

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

package/out/src/concurrent-updates.test.d.ts

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

package/out/src/concurrent-updates.test.mjs

@@ -0,0 +1,203 @@
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
+import { DomeComponent } from './DomeComponent.mjs';
+import { DomeManipulator } from './DomeManipulator.mjs';
+class FakeElement {
+    nodeType = 1;
+    childNodes = [];
+    classList = {
+        values: new Set(),
+        add: (name) => this.classList.values.add(name),
+        remove: (name) => this.classList.values.delete(name)
+    };
+    parentNode = null;
+    throwOnAppend = false;
+    get firstChild() {
+        return this.childNodes[0] ?? null;
+    }
+    appendChild(child) {
+        if (child.throwOnAppend) {
+            throw new Error('append failed');
+        }
+        child.parentNode = this;
+        this.childNodes.push(child);
+        return child;
+    }
+    remove() {
+        if (!this.parentNode)
+            return;
+        const index = this.parentNode.childNodes.indexOf(this);
+        if (index >= 0) {
+            this.parentNode.childNodes.splice(index, 1);
+        }
+        this.parentNode = null;
+    }
+}
+const asElement = (element) => element;
+const animation = (name) => ({ cssClassName: name, timeMs: 5 });
+const waitAsync = (timeMs) => new Promise(resolve => setTimeout(resolve, timeMs));
+async function waitForAsync(condition) {
+    const timeoutAt = Date.now() + 500;
+    while (!condition()) {
+        if (Date.now() >= timeoutAt) {
+            throw new Error('Timed out waiting for condition');
+        }
+        await waitAsync(1);
+    }
+}
+function deferred() {
+    let resolve;
+    const promise = new Promise(resolvePromise => {
+        resolve = resolvePromise;
+    });
+    return { promise, resolve };
+}
+const originalNode = Object.getOwnPropertyDescriptor(globalThis, 'Node');
+beforeAll(() => {
+    Object.defineProperty(globalThis, 'Node', {
+        configurable: true,
+        value: { ELEMENT_NODE: 1 }
+    });
+});
+afterAll(() => {
+    if (originalNode) {
+        Object.defineProperty(globalThis, 'Node', originalNode);
+    }
+    else {
+        delete globalThis.Node;
+    }
+});
+describe('DomeManipulator.replaceAllChildrenAsync', () => {
+    async function expectLastQueuedReplacement(animationForHide, animationForShow) {
+        const container = new FakeElement();
+        const existing = new FakeElement();
+        const first = new FakeElement();
+        const second = new FakeElement();
+        container.appendChild(existing);
+        await Promise.all([
+            DomeManipulator.replaceAllChildrenAsync(asElement(container), asElement(first), animationForHide, animationForShow),
+            DomeManipulator.replaceAllChildrenAsync(asElement(container), asElement(second), animationForHide, animationForShow)
+        ]);
+        expect(container.childNodes).toEqual([second]);
+    }
+    it('serializes two concurrent replacements without animations', async () => {
+        await expectLastQueuedReplacement();
+    });
+    it('serializes concurrent replacements with a hide animation', async () => {
+        await expectLastQueuedReplacement(animation('hide'));
+    });
+    it('serializes concurrent replacements with a show animation', async () => {
+        await expectLastQueuedReplacement(undefined, animation('show'));
+    });
+    it('serializes concurrent replacements with hide and show animations', async () => {
+        await expectLastQueuedReplacement(animation('hide'), animation('show'));
+    });
+    it('runs replacements on different containers independently', async () => {
+        const slowContainer = new FakeElement();
+        const fastContainer = new FakeElement();
+        const oldSlowChild = new FakeElement();
+        const slowChild = new FakeElement();
+        const fastChild = new FakeElement();
+        slowContainer.appendChild(oldSlowChild);
+        let slowReplacementFinished = false;
+        const slowReplacement = DomeManipulator.replaceAllChildrenAsync(asElement(slowContainer), asElement(slowChild), { cssClassName: 'hide', timeMs: 30 }).then(() => {
+            slowReplacementFinished = true;
+        });
+        await waitAsync(1);
+        await DomeManipulator.replaceAllChildrenAsync(asElement(fastContainer), asElement(fastChild));
+        expect(fastContainer.childNodes).toEqual([fastChild]);
+        expect(slowReplacementFinished).toBe(false);
+        expect(slowContainer.childNodes).toEqual([oldSlowChild]);
+        await slowReplacement;
+    });
+    it('does not let a failed replacement block a later replacement', async () => {
+        const container = new FakeElement();
+        const failingChild = new FakeElement();
+        const successfulChild = new FakeElement();
+        failingChild.throwOnAppend = true;
+        const failedReplacement = DomeManipulator.replaceAllChildrenAsync(asElement(container), asElement(failingChild));
+        const queuedReplacement = DomeManipulator.replaceAllChildrenAsync(asElement(container), asElement(successfulChild));
+        await expect(failedReplacement).rejects.toThrow('append failed');
+        await queuedReplacement;
+        expect(container.childNodes).toEqual([successfulChild]);
+    });
+});
+class ScheduledTestComponent extends DomeComponent {
+    updateCount = 0;
+    activeUpdates = 0;
+    maximumActiveUpdates = 0;
+    updateBehavior = async () => undefined;
+    render() {
+        return {};
+    }
+    async updateAsync() {
+        this.updateCount++;
+        this.activeUpdates++;
+        this.maximumActiveUpdates = Math.max(this.maximumActiveUpdates, this.activeUpdates);
+        try {
+            await this.updateBehavior();
+        }
+        finally {
+            this.activeUpdates--;
+        }
+    }
+}
+describe('DomeComponent.scheduleUpdate', () => {
+    it('debounces repeated requests made before an update starts', async () => {
+        const component = new ScheduledTestComponent({}, null);
+        await Promise.all([
+            component.scheduleUpdate(),
+            component.scheduleUpdate(),
+            component.scheduleUpdate()
+        ]);
+        expect(component.updateCount).toBe(1);
+    });
+    it('coalesces requests during an update into exactly one follow-up update', async () => {
+        const component = new ScheduledTestComponent({}, null);
+        const firstUpdate = deferred();
+        component.updateBehavior = () => component.updateCount === 1
+            ? firstUpdate.promise
+            : Promise.resolve();
+        const initialSchedule = component.scheduleUpdate();
+        await waitForAsync(() => component.updateCount === 1);
+        component.scheduleUpdate();
+        component.scheduleUpdate();
+        component.scheduleUpdate();
+        await waitAsync(10);
+        firstUpdate.resolve();
+        await initialSchedule;
+        expect(component.updateCount).toBe(2);
+    });
+    it('never runs scheduled updates concurrently for one component', async () => {
+        const component = new ScheduledTestComponent({}, null);
+        const firstUpdate = deferred();
+        component.updateBehavior = () => component.updateCount === 1
+            ? firstUpdate.promise
+            : Promise.resolve();
+        const initialSchedule = component.scheduleUpdate();
+        await waitForAsync(() => component.updateCount === 1);
+        component.scheduleUpdate();
+        await waitAsync(10);
+        expect(component.maximumActiveUpdates).toBe(1);
+        firstUpdate.resolve();
+        await initialSchedule;
+        expect(component.maximumActiveUpdates).toBe(1);
+    });
+    it('allows subsequent scheduled updates after updateAsync rejects', async () => {
+        const component = new ScheduledTestComponent({}, null);
+        const consoleError = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        component.updateBehavior = async () => {
+            if (component.updateCount === 1) {
+                throw new Error('update failed');
+            }
+        };
+        try {
+            await component.scheduleUpdate();
+            await component.scheduleUpdate();
+        }
+        finally {
+            consoleError.mockRestore();
+        }
+        expect(component.updateCount).toBe(2);
+        expect(component.maximumActiveUpdates).toBe(1);
+    });
+});

package/out/src/index.d.ts

@@ -0,0 +1,11 @@
+export * from '@lexriver/async';
+export * from '@lexriver/data-types';
+export * from '@lexriver/observable';
+export * from '@lexriver/type-event';
+export * from './AnimatedArray';
+export * from './AnimatedTable';
+export * from './AnimatedText';
+export * from './Dome';
+export * from './DomeComponent';
+export * from './DomeManipulator';
+export * from './DomeRouter.console-test';

package/out/src/temp-test.d.ts

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