@lexriver/dome 2.0.2 → 2.0.4

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.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/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/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/index.d.mts

@@ -1,11 +1,15 @@
 export * from '@lexriver/async';
+export { Async, Lock } from '@lexriver/async';
 export * from '@lexriver/data-types';
+export { DataTypes } from '@lexriver/data-types';
 export * from '@lexriver/observable';
+export { ObservableArray, ObservableLocalStorageArray, ObservableLocalStorageVariable, ObservableMap, ObservableVariable, ObservableVariable as ObservableValue, checkIfObservable, createObservable } from '@lexriver/observable';
 export * from '@lexriver/type-event';
+export { TypeEvent } from '@lexriver/type-event';
 export * from './AnimatedArray.mjs';
 export * from './AnimatedTable.mjs';
 export * from './AnimatedText.mjs';
 export * from './Dome.mjs';
 export * from './DomeComponent.mjs';
 export * from './DomeManipulator.mjs';
-export * from './DomeRouter.console-test.mjs';
+export * from './DomeRouter.mjs';

package/out/src/index.d.ts

@@ -0,0 +1,15 @@
+export * from '@lexriver/async';
+export { Async, Lock } from '@lexriver/async';
+export * from '@lexriver/data-types';
+export { DataTypes } from '@lexriver/data-types';
+export * from '@lexriver/observable';
+export { ObservableArray, ObservableLocalStorageArray, ObservableLocalStorageVariable, ObservableMap, ObservableVariable, ObservableVariable as ObservableValue, checkIfObservable, createObservable } from '@lexriver/observable';
+export * from '@lexriver/type-event';
+export { TypeEvent } 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';

package/out/src/index.mjs

@@ -1,11 +1,15 @@
 export * from '@lexriver/async';
+export { Async, Lock } from '@lexriver/async';
 export * from '@lexriver/data-types';
+export { DataTypes } from '@lexriver/data-types';
 export * from '@lexriver/observable';
+export { ObservableArray, ObservableLocalStorageArray, ObservableLocalStorageVariable, ObservableMap, ObservableVariable, ObservableVariable as ObservableValue, checkIfObservable, createObservable } from '@lexriver/observable';
 export * from '@lexriver/type-event';
+export { TypeEvent } from '@lexriver/type-event';
 export * from './AnimatedArray.mjs';
 export * from './AnimatedTable.mjs';
 export * from './AnimatedText.mjs';
 export * from './Dome.mjs';
 export * from './DomeComponent.mjs';
 export * from './DomeManipulator.mjs';
-export * from './DomeRouter.console-test.mjs';
+export * from './DomeRouter.mjs';

package/package.json

@@ -1,13 +1,29 @@
 {
     "sideEffects": false,
     "name": "@lexriver/dome",
-    "version": "2.0.2",
+    "version": "2.0.4",
     "description": "DOM manipulator",
     "type": "module",
-    "exports": "./out/src/index.mjs",
+    "types": "./out/src/index.d.ts",
+    "main": "./out/index.cjs",
+    "module": "./out/index.mjs",
+    "exports": {
+        ".": {
+            "types": "./out/src/index.d.mts",
+            "import": "./out/src/index.mjs",
+            "require": "./out/index.cjs",
+            "default": "./out/src/index.mjs"
+        }
+    },
+    "files": [
+        "out",
+        "README.md"
+    ],
     "scripts": {
         "test": "vitest",
-        "build": "rimraf out && tsc"
+        "build": "rimraf out && tsc && node scripts/build-compat.mjs",
+        "test:api-compat": "npm run build && node scripts/test-api-compat.mjs",
+        "test:compat": "npm run build && node scripts/test-api-compat.mjs && npm --prefix compatibility/ts39-webpack4 install && npm --prefix compatibility/ts39-webpack4 run build"
     },
     "keywords": [
         "typescript",
@@ -24,6 +40,7 @@
     "license": "MIT",
     "devDependencies": {
         "@types/node": "^22.7.0",
+        "esbuild": "^0.21.5",
         "rimraf": "^6.0.1",
         "typescript": "^5.6.2",
         "vitest": "^2.1.1"
@@ -32,6 +49,7 @@
         "@lexriver/async": "^3.0.1",
         "@lexriver/data-types": "^3.0.5",
         "@lexriver/observable": "^3.0.0",
+        "@lexriver/type-event": "^2.0.0",
         "svg-tag-names": "^3.0.1",
         "ts-debounce": "^4.0.0"
     }

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

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

package/out/src/DomeRouter.console-test.mjs

@@ -1,44 +0,0 @@
-// //import { DomeRouter } from "./DomeRouter"
-// function getRouteSlices(route:string){
-//     return route.split('/').filter(x => x.length>0)
-// }
-export {};
-// function checkUrlMatchRouteAndGetParameters(url:string, route:string, exactMatch:boolean = true):Map<string,string>|undefined{
-//     // this function is purely for export
-//     const urlSlices = getRouteSlices(url)
-//     const routeSlices = getRouteSlices(route)
-//     if(exactMatch && routeSlices.length !== urlSlices.length) return undefined
-//     // all routeSlices must match for !exactMatch
-//     const extractedParameters = new Map<string,string>()
-//     for(let i=0;i<routeSlices.length;i++){
-//         let cRouteSlice = routeSlices[i]
-//         let cUrlSlice = urlSlices[i] // could be undefined
-//         //console.info('\t\t cRouteSlice=', cRouteSlice, 'cUrlSlice=', cUrlSlice)
-//         if(cRouteSlice.startsWith(':')){
-//             // we have a param name
-//             if(cUrlSlice === undefined){
-//                 return undefined
-//             }
-//             // we have some variable, save it
-//             extractedParameters.set(cRouteSlice.substring(1), cUrlSlice)
-//         } else {
-//             // no param name
-//             if(cRouteSlice !== cUrlSlice){
-//                 return undefined
-//             }
-//         }
-//     }
-//     return extractedParameters
-// }
-// DomeRouter.onRoute('/', true, ()=>{ console.log('exact /')})
-// DomeRouter.onRoute('/', false, ()=>{ console.log('notexact /')})
-// DomeRouter.onRoute('/test', true, ()=>{ console.log('exact /test')})
-// DomeRouter.onRoute('/test/:id', true, (p)=>{ console.log('exact /test/:id', 'params=', p)})    
-// DomeRouter.onRoute('/test/:id', false, (p)=>{ console.log('notexact /test/:id', 'params=', p)})    
-// DomeRouter.onRoute('/test', false, ()=>{ console.log('notexact /test')})    
-// DomeRouter.onRoute('/test/:id/:id2', true, (p)=>{ console.log('exact /test/:id/:id2', 'params=', p)})    
-// let testRoute = '//test/34/st'
-// console.log('** testing route:', testRoute)
-// DomeRouter.execute(testRoute)
-// //expect(!true).toBeTruthy()
-//console.log(checkUrlMatchRouteAndGetParameters('/get-product/123', '/get-product/:id/:id2', false))

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

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

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

@@ -1,203 +0,0 @@
-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/temp-test.d.mts

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

package/out/src/temp-test.mjs

@@ -1,20 +0,0 @@
-import { LongestCommonSubsequence } from "./LongestCommonSubsequence.mjs";
-let oldArray = "ABCD".split('');
-let newArray = "AXYZBCD345".split('');
-const countOfOperations = LongestCommonSubsequence.getPatchOrdered({
-    oldArray: [...oldArray],
-    newArray: newArray,
-    onRemove: (index, item) => {
-        console.log('-', item, index);
-        oldArray.splice(index, 1);
-    },
-    onAdd: (index, item) => {
-        console.log('+', item, index);
-        oldArray.splice(index, 0, item);
-    }
-});
-console.log('expecting equal', oldArray, newArray);
-console.log('countOfOperations=', countOfOperations);
-//expect(oldArray).toEqual(newArray)
-// console.log('result oldArray=', oldArray)
-// console.log('result nweArray=', newArray)

package/out/vitest.config.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("vite").UserConfig;
-export default _default;