@lexriver/dome 2.0.3 → 2.0.5

package/README.md

@@ -1507,9 +1507,9 @@ Parameters:
 Where `RouteAction` type is:
 ```typescript
 export type RouteAction = (
-    params:{[key:string]:string|number}, // parameters from url path
-    url:string, // url path without query string
-    scrollToPreviousPositionAsync:()=>Promise<void>, // this function can be called to scroll to previous page position
+    params:{[key:string]:string}, // unannotated parameters from the URL path
+    url:string, // URL path without query string
+    scrollToPreviousPositionAsync:()=>Promise<void>, // call this to scroll to the previous page position
     query:{[key:string]:string} // query parameters from window.location.search
     ) => void|Promise<void>
 ```
@@ -1529,28 +1529,23 @@ DomeRouter.onRoute('/product/:productId', true, (params, url) => {
 })
 ```
 
-A type of parameter can be added, for example :
+For numeric parameters, use `onTypedRoute`. This opt-in API types route values as `string | number`, because TypeScript 3.9 cannot infer parameter types from route-string annotations.
+
 ```typescript
-DomeRouter.onRoute('/product/:productId<number>', true, (params, url) => {
-    // for example for '/product/456' the output will be
-    // 'productId=', 456, number
-    console.log('productId=', params.productId, typeof params.productId) 
+DomeRouter.onTypedRoute('/product/:productId<number>', true, (params, url) => {
+    // For '/product/456', productId is 456 at runtime.
+    if(typeof params.productId === 'number') {
+        console.log('productId=', params.productId)
+    }
 })
 ```
 
-A possible types are:
+The supported numeric annotations are:
 * `int` - uses `parseInt(p)` internally
 * `float` - uses `parseFloat(p)` internally
-* `number` - uses `Number(p)` intrenally
-But there is no validation for paramters, so the result of specified function will be returned.
+* `number` - uses `Number(p)` internally
 
-```typescript
-DomeRouter.onRoute('/product/:productId<int>', true, (params, url) => {
-    // for example for '/product/456' the output will be
-    // 'productId=', 456, number
-    console.log('productId=', params.productId, typeof params.productId) 
-})
-```
+There is no numeric validation, so the result of the corresponding conversion function is returned. Existing unannotated routes should continue using `onRoute`; their parameters remain strings without casts.
 
 <br/>
 

package/out/index.cjs

@@ -26,16 +26,33 @@ __export(src_exports, {
   AnimatedArray: () => AnimatedArray,
   AnimatedTable: () => AnimatedTable,
   AnimatedText: () => AnimatedText,
+  Async: () => import_async2.Async,
+  DataTypes: () => import_data_types3.DataTypes,
   DomeComponent: () => DomeComponent,
   DomeManipulator: () => DomeManipulator,
+  DomeRouter: () => DomeRouter,
+  Lock: () => import_async2.Lock,
+  ObservableArray: () => import_observable3.ObservableArray,
+  ObservableLocalStorageArray: () => import_observable3.ObservableLocalStorageArray,
+  ObservableLocalStorageVariable: () => import_observable3.ObservableLocalStorageVariable,
+  ObservableMap: () => import_observable3.ObservableMap,
+  ObservableValue: () => import_observable3.ObservableVariable,
+  ObservableVariable: () => import_observable3.ObservableVariable,
   React: () => React,
+  TypeEvent: () => import_type_event.TypeEvent,
+  checkIfObservable: () => import_observable3.checkIfObservable,
+  createObservable: () => import_observable3.createObservable,
   h: () => h
 });
 module.exports = __toCommonJS(src_exports);
 __reExport(src_exports, require("@lexriver/async"), module.exports);
+var import_async2 = require("@lexriver/async");
 __reExport(src_exports, require("@lexriver/data-types"), module.exports);
+var import_data_types3 = require("@lexriver/data-types");
 __reExport(src_exports, require("@lexriver/observable"), module.exports);
+var import_observable3 = require("@lexriver/observable");
 __reExport(src_exports, require("@lexriver/type-event"), module.exports);
+var import_type_event = require("@lexriver/type-event");
 
 // src/DomeManipulator.mts
 var import_async = require("@lexriver/async");
@@ -800,3 +817,185 @@ var React = {
   Fragment: typeof DocumentFragment === "function" ? DocumentFragment : () => {
   }
 };
+
+// src/DomeRouter.mts
+var DomeRouter;
+((DomeRouter2) => {
+  const historyUrls = [];
+  const scrollPositionByUrl = /* @__PURE__ */ new Map();
+  DomeRouter2.maxHistoryUrlsCount = 20;
+  const allRoutes = [];
+  let onNotFoundAction = void 0;
+  window.addEventListener("popstate", async (e) => {
+    const url = window.location.pathname;
+    await executeAsync(url, getScrollPositionForUrl(url));
+    await DomeManipulator.scrollToAsync({
+      pxFromTop: getScrollPositionForUrl(window.location.pathname)
+    });
+  });
+  function getScrollPositionForUrl(url) {
+    var _a;
+    return (_a = scrollPositionByUrl.get(url)) != null ? _a : 0;
+  }
+  function saveScrollPositionForUrl(url) {
+    scrollPositionByUrl.set(url, DomeManipulator.getCurrentScrollPosition());
+  }
+  function saveScrollPositionForCurrentUrl() {
+    scrollPositionByUrl.set(getCurrentUrl(), DomeManipulator.getCurrentScrollPosition());
+  }
+  function navigate(url) {
+    addUrlToHistory(getCurrentUrl());
+    saveScrollPositionForCurrentUrl();
+    window.history.pushState(null, "", url);
+    executeAsync(url, 0);
+    DomeManipulator.scrollToTop();
+  }
+  DomeRouter2.navigate = navigate;
+  function goBack() {
+    window.history.go(-1);
+  }
+  DomeRouter2.goBack = goBack;
+  function goForward() {
+    window.history.go(1);
+  }
+  DomeRouter2.goForward = goForward;
+  function changeUrl(url) {
+    window.history.replaceState(null, "", url);
+  }
+  DomeRouter2.changeUrl = changeUrl;
+  function addUrlToHistory(url) {
+    historyUrls.push({ url, scroll: 0 });
+    while (historyUrls.length > DomeRouter2.maxHistoryUrlsCount) {
+      historyUrls.shift();
+    }
+    if (historyUrls.length > 1) {
+      historyUrls[historyUrls.length - 2].scroll = DomeManipulator.getCurrentScrollPosition();
+    }
+  }
+  function getCurrentUrl() {
+    return window.location.pathname;
+  }
+  DomeRouter2.getCurrentUrl = getCurrentUrl;
+  function getPreviousPageUrl(previousPageIndex = 0) {
+    let index = historyUrls.length - 2 - previousPageIndex;
+    if (index >= 0 && index < historyUrls.length) return historyUrls[index].url;
+    return void 0;
+  }
+  DomeRouter2.getPreviousPageUrl = getPreviousPageUrl;
+  function resolveUrl(url = window.location.pathname, addToHistory = true) {
+    if (addToHistory) addUrlToHistory(window.location.pathname);
+    executeAsync(url, getScrollPositionForUrl(url));
+  }
+  DomeRouter2.resolveUrl = resolveUrl;
+  function addRoute(route, exactMatch, action) {
+    if (route[0] !== "/") throw new Error("Please provide correct route. route=" + route);
+    const routeSlices = getRouteSlices(route);
+    allRoutes.push({ routeSlices, exactMatch, action });
+  }
+  function onRoute(route, exactMatch, action) {
+    addRoute(route, exactMatch, action);
+  }
+  DomeRouter2.onRoute = onRoute;
+  function onTypedRoute(route, exactMatch, action) {
+    addRoute(route, exactMatch, action);
+  }
+  DomeRouter2.onTypedRoute = onTypedRoute;
+  function getRouteSlices(route) {
+    return route.split("/").map((x) => decodeURIComponent(x));
+  }
+  function onNotFound(action) {
+    onNotFoundAction = action;
+  }
+  DomeRouter2.onNotFound = onNotFound;
+  function checkUrlMatchRouteAndGetParameters(url, route, exactMatch = true) {
+    const urlSlices = getRouteSlices(url);
+    const routeSlices = getRouteSlices(route);
+    if (exactMatch && routeSlices.length !== urlSlices.length) return void 0;
+    const extractedParameters = {};
+    for (let i = 0; i < routeSlices.length; i++) {
+      let cRouteSlice = routeSlices[i];
+      let cUrlSlice = urlSlices[i];
+      if (cRouteSlice.startsWith(":")) {
+        if (cUrlSlice === void 0) {
+          return void 0;
+        }
+        const [name, value] = parseToNameAndValue(cRouteSlice, cUrlSlice);
+        extractedParameters[name] = value;
+      } else {
+        if (cRouteSlice !== cUrlSlice) {
+          return void 0;
+        }
+      }
+    }
+    return extractedParameters;
+  }
+  DomeRouter2.checkUrlMatchRouteAndGetParameters = checkUrlMatchRouteAndGetParameters;
+  function parseToNameAndValue(name, value) {
+    if (!name) throw new Error("no name");
+    const haveMatch = name.match(/:(.+)<(.+)>/);
+    if (haveMatch) {
+      const paramName = haveMatch[1];
+      const paramType = haveMatch[2].toLowerCase();
+      if (paramType == "int") {
+        return [paramName, parseInt(value)];
+      } else if (paramType == "float") {
+        return [paramName, parseFloat(value)];
+      } else if (paramType == "number") {
+        return [paramName, Number(value)];
+      } else {
+        return [paramName, value];
+      }
+    } else {
+      return [name.substring(1), value];
+    }
+  }
+  function parseQueryString(search) {
+    const query = {};
+    if (!search || search[0] !== "?") return query;
+    const params = new URLSearchParams(search.substring(1));
+    for (const [key, value] of params.entries()) {
+      query[key] = value;
+    }
+    return query;
+  }
+  async function executeAsync(url = window.location.pathname, scrollToPosition) {
+    const queryString = window.location.search;
+    const query = parseQueryString(queryString);
+    url = url.split("?")[0];
+    const urlSlices = getRouteSlices(url);
+    let countOfFoundRoutes = 0;
+    for (let route of allRoutes) {
+      if (route.exactMatch && route.routeSlices.length != urlSlices.length) continue;
+      let matched = true;
+      const extractedParameters = {};
+      for (let i = 0; i < route.routeSlices.length; i++) {
+        let cRouteSlice = route.routeSlices[i];
+        let cUrlSlice = urlSlices[i];
+        if (cRouteSlice && typeof cRouteSlice === "string" && cRouteSlice.startsWith(":")) {
+          if (cUrlSlice === void 0) {
+            matched = false;
+            continue;
+          }
+          const [name, value] = parseToNameAndValue(cRouteSlice, cUrlSlice);
+          extractedParameters[name] = value;
+        } else {
+          if (cRouteSlice !== cUrlSlice) {
+            matched = false;
+            continue;
+          }
+        }
+      }
+      if (matched) {
+        countOfFoundRoutes++;
+        await route.action(extractedParameters, url, async () => {
+          await DomeManipulator.scrollToAsync({
+            pxFromTop: scrollToPosition
+          });
+        }, query);
+      }
+    }
+    if (countOfFoundRoutes == 0 && onNotFoundAction) {
+      onNotFoundAction();
+    }
+  }
+})(DomeRouter || (DomeRouter = {}));

package/out/index.mjs

@@ -1965,6 +1965,188 @@ var React = {
   Fragment: typeof DocumentFragment === "function" ? DocumentFragment : () => {
   }
 };
+
+// src/DomeRouter.mts
+var DomeRouter;
+((DomeRouter2) => {
+  const historyUrls = [];
+  const scrollPositionByUrl = /* @__PURE__ */ new Map();
+  DomeRouter2.maxHistoryUrlsCount = 20;
+  const allRoutes = [];
+  let onNotFoundAction = void 0;
+  window.addEventListener("popstate", async (e) => {
+    const url = window.location.pathname;
+    await executeAsync(url, getScrollPositionForUrl(url));
+    await DomeManipulator.scrollToAsync({
+      pxFromTop: getScrollPositionForUrl(window.location.pathname)
+    });
+  });
+  function getScrollPositionForUrl(url) {
+    var _a;
+    return (_a = scrollPositionByUrl.get(url)) != null ? _a : 0;
+  }
+  function saveScrollPositionForUrl(url) {
+    scrollPositionByUrl.set(url, DomeManipulator.getCurrentScrollPosition());
+  }
+  function saveScrollPositionForCurrentUrl() {
+    scrollPositionByUrl.set(getCurrentUrl(), DomeManipulator.getCurrentScrollPosition());
+  }
+  function navigate(url) {
+    addUrlToHistory(getCurrentUrl());
+    saveScrollPositionForCurrentUrl();
+    window.history.pushState(null, "", url);
+    executeAsync(url, 0);
+    DomeManipulator.scrollToTop();
+  }
+  DomeRouter2.navigate = navigate;
+  function goBack() {
+    window.history.go(-1);
+  }
+  DomeRouter2.goBack = goBack;
+  function goForward() {
+    window.history.go(1);
+  }
+  DomeRouter2.goForward = goForward;
+  function changeUrl(url) {
+    window.history.replaceState(null, "", url);
+  }
+  DomeRouter2.changeUrl = changeUrl;
+  function addUrlToHistory(url) {
+    historyUrls.push({ url, scroll: 0 });
+    while (historyUrls.length > DomeRouter2.maxHistoryUrlsCount) {
+      historyUrls.shift();
+    }
+    if (historyUrls.length > 1) {
+      historyUrls[historyUrls.length - 2].scroll = DomeManipulator.getCurrentScrollPosition();
+    }
+  }
+  function getCurrentUrl() {
+    return window.location.pathname;
+  }
+  DomeRouter2.getCurrentUrl = getCurrentUrl;
+  function getPreviousPageUrl(previousPageIndex = 0) {
+    let index = historyUrls.length - 2 - previousPageIndex;
+    if (index >= 0 && index < historyUrls.length) return historyUrls[index].url;
+    return void 0;
+  }
+  DomeRouter2.getPreviousPageUrl = getPreviousPageUrl;
+  function resolveUrl(url = window.location.pathname, addToHistory = true) {
+    if (addToHistory) addUrlToHistory(window.location.pathname);
+    executeAsync(url, getScrollPositionForUrl(url));
+  }
+  DomeRouter2.resolveUrl = resolveUrl;
+  function addRoute(route, exactMatch, action) {
+    if (route[0] !== "/") throw new Error("Please provide correct route. route=" + route);
+    const routeSlices = getRouteSlices(route);
+    allRoutes.push({ routeSlices, exactMatch, action });
+  }
+  function onRoute(route, exactMatch, action) {
+    addRoute(route, exactMatch, action);
+  }
+  DomeRouter2.onRoute = onRoute;
+  function onTypedRoute(route, exactMatch, action) {
+    addRoute(route, exactMatch, action);
+  }
+  DomeRouter2.onTypedRoute = onTypedRoute;
+  function getRouteSlices(route) {
+    return route.split("/").map((x) => decodeURIComponent(x));
+  }
+  function onNotFound(action) {
+    onNotFoundAction = action;
+  }
+  DomeRouter2.onNotFound = onNotFound;
+  function checkUrlMatchRouteAndGetParameters(url, route, exactMatch = true) {
+    const urlSlices = getRouteSlices(url);
+    const routeSlices = getRouteSlices(route);
+    if (exactMatch && routeSlices.length !== urlSlices.length) return void 0;
+    const extractedParameters = {};
+    for (let i = 0; i < routeSlices.length; i++) {
+      let cRouteSlice = routeSlices[i];
+      let cUrlSlice = urlSlices[i];
+      if (cRouteSlice.startsWith(":")) {
+        if (cUrlSlice === void 0) {
+          return void 0;
+        }
+        const [name, value] = parseToNameAndValue(cRouteSlice, cUrlSlice);
+        extractedParameters[name] = value;
+      } else {
+        if (cRouteSlice !== cUrlSlice) {
+          return void 0;
+        }
+      }
+    }
+    return extractedParameters;
+  }
+  DomeRouter2.checkUrlMatchRouteAndGetParameters = checkUrlMatchRouteAndGetParameters;
+  function parseToNameAndValue(name, value) {
+    if (!name) throw new Error("no name");
+    const haveMatch = name.match(/:(.+)<(.+)>/);
+    if (haveMatch) {
+      const paramName = haveMatch[1];
+      const paramType = haveMatch[2].toLowerCase();
+      if (paramType == "int") {
+        return [paramName, parseInt(value)];
+      } else if (paramType == "float") {
+        return [paramName, parseFloat(value)];
+      } else if (paramType == "number") {
+        return [paramName, Number(value)];
+      } else {
+        return [paramName, value];
+      }
+    } else {
+      return [name.substring(1), value];
+    }
+  }
+  function parseQueryString(search) {
+    const query = {};
+    if (!search || search[0] !== "?") return query;
+    const params = new URLSearchParams(search.substring(1));
+    for (const [key, value] of params.entries()) {
+      query[key] = value;
+    }
+    return query;
+  }
+  async function executeAsync(url = window.location.pathname, scrollToPosition) {
+    const queryString = window.location.search;
+    const query = parseQueryString(queryString);
+    url = url.split("?")[0];
+    const urlSlices = getRouteSlices(url);
+    let countOfFoundRoutes = 0;
+    for (let route of allRoutes) {
+      if (route.exactMatch && route.routeSlices.length != urlSlices.length) continue;
+      let matched = true;
+      const extractedParameters = {};
+      for (let i = 0; i < route.routeSlices.length; i++) {
+        let cRouteSlice = route.routeSlices[i];
+        let cUrlSlice = urlSlices[i];
+        if (cRouteSlice && typeof cRouteSlice === "string" && cRouteSlice.startsWith(":")) {
+          if (cUrlSlice === void 0) {
+            matched = false;
+            continue;
+          }
+          const [name, value] = parseToNameAndValue(cRouteSlice, cUrlSlice);
+          extractedParameters[name] = value;
+        } else {
+          if (cRouteSlice !== cUrlSlice) {
+            matched = false;
+            continue;
+          }
+        }
+      }
+      if (matched) {
+        countOfFoundRoutes++;
+        await route.action(extractedParameters, url, async () => {
+          await DomeManipulator.scrollToAsync({
+            pxFromTop: scrollToPosition
+          });
+        }, query);
+      }
+    }
+    if (countOfFoundRoutes == 0 && onNotFoundAction) {
+      onNotFoundAction();
+    }
+  }
+})(DomeRouter || (DomeRouter = {}));
 export {
   AnimatedArray,
   AnimatedTable,
@@ -1973,11 +2155,13 @@ export {
   DataTypes,
   DomeComponent,
   DomeManipulator,
+  DomeRouter,
   Lock,
   ObservableArray,
   ObservableLocalStorageArray,
   ObservableLocalStorageVariable,
   ObservableMap,
+  ObservableVariable as ObservableValue,
   ObservableVariable,
   React,
   TypeEvent,

package/out/src/DomeRouter.d.mts

@@ -1,8 +1,14 @@
-export type RouteAction = (params: {
+export type RouteParameters = {
+    [key: string]: string;
+};
+export type TypedRouteParameters = {
     [key: string]: string | number;
-}, url: string, scrollToPreviousPositionAsync: () => Promise<void>, query: {
+};
+type RouteCallback<Parameters> = (params: Parameters, url: string, scrollToPreviousPositionAsync: () => Promise<void>, query: {
     [key: string]: string;
 }) => void | Promise<void>;
+export type RouteAction = RouteCallback<RouteParameters>;
+export type TypedRouteAction = RouteCallback<TypedRouteParameters>;
 export declare namespace DomeRouter {
     let maxHistoryUrlsCount: number;
     function navigate(url: string): void;
@@ -16,7 +22,10 @@ export declare namespace DomeRouter {
      */
     function getPreviousPageUrl(previousPageIndex?: number): string | undefined;
     function resolveUrl(url?: string, addToHistory?: boolean): void;
+    /** Register a route whose unannotated parameters are strings. */
     function onRoute(route: string, exactMatch: boolean, action: RouteAction): void;
+    /** Register a route using <int>, <float>, or <number> parameter annotations. */
+    function onTypedRoute(route: string, exactMatch: boolean, action: TypedRouteAction): void;
     function onNotFound(action: () => void): void;
     /**
      * Check if url matched route.
@@ -30,3 +39,4 @@ export declare namespace DomeRouter {
      */
     function checkUrlMatchRouteAndGetParameters(url: string, route: string, exactMatch?: boolean): Object | undefined;
 }
+export {};

package/out/src/DomeRouter.d.ts

@@ -1,8 +1,14 @@
-export type RouteAction = (params: {
+export type RouteParameters = {
+    [key: string]: string;
+};
+export type TypedRouteParameters = {
     [key: string]: string | number;
-}, url: string, scrollToPreviousPositionAsync: () => Promise<void>, query: {
+};
+type RouteCallback<Parameters> = (params: Parameters, url: string, scrollToPreviousPositionAsync: () => Promise<void>, query: {
     [key: string]: string;
 }) => void | Promise<void>;
+export type RouteAction = RouteCallback<RouteParameters>;
+export type TypedRouteAction = RouteCallback<TypedRouteParameters>;
 export declare namespace DomeRouter {
     let maxHistoryUrlsCount: number;
     function navigate(url: string): void;
@@ -16,7 +22,10 @@ export declare namespace DomeRouter {
      */
     function getPreviousPageUrl(previousPageIndex?: number): string | undefined;
     function resolveUrl(url?: string, addToHistory?: boolean): void;
+    /** Register a route whose unannotated parameters are strings. */
     function onRoute(route: string, exactMatch: boolean, action: RouteAction): void;
+    /** Register a route using <int>, <float>, or <number> parameter annotations. */
+    function onTypedRoute(route: string, exactMatch: boolean, action: TypedRouteAction): void;
     function onNotFound(action: () => void): void;
     /**
      * Check if url matched route.
@@ -30,3 +39,4 @@ export declare namespace DomeRouter {
      */
     function checkUrlMatchRouteAndGetParameters(url: string, route: string, exactMatch?: boolean): Object | undefined;
 }
+export {};

package/out/src/DomeRouter.mjs

@@ -88,13 +88,22 @@ export var DomeRouter;
         executeAsync(url, getScrollPositionForUrl(url));
     }
     DomeRouter.resolveUrl = resolveUrl;
-    function onRoute(route, exactMatch, action) {
+    function addRoute(route, exactMatch, action) {
         if (route[0] !== '/')
             throw new Error('Please provide correct route. route=' + route);
-        let routeSlices = getRouteSlices(route);
+        const routeSlices = getRouteSlices(route);
         allRoutes.push({ routeSlices, exactMatch, action });
     }
+    /** Register a route whose unannotated parameters are strings. */
+    function onRoute(route, exactMatch, action) {
+        addRoute(route, exactMatch, action);
+    }
     DomeRouter.onRoute = onRoute;
+    /** Register a route using <int>, <float>, or <number> parameter annotations. */
+    function onTypedRoute(route, exactMatch, action) {
+        addRoute(route, exactMatch, action);
+    }
+    DomeRouter.onTypedRoute = onTypedRoute;
     function getRouteSlices(route) {
         //return route.split('/').filter(x => x.length>0).map(x => decodeURIComponent(x))
         return route.split('/').map(x => decodeURIComponent(x));

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

@@ -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';
 export * from './AnimatedTable';
 export * from './AnimatedText';
 export * from './Dome';
 export * from './DomeComponent';
 export * from './DomeManipulator';
-export * from './DomeRouter.console-test';
+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,7 +1,7 @@
 {
     "sideEffects": false,
     "name": "@lexriver/dome",
-    "version": "2.0.3",
+    "version": "2.0.5",
     "description": "DOM manipulator",
     "type": "module",
     "types": "./out/src/index.d.ts",
@@ -22,7 +22,8 @@
     "scripts": {
         "test": "vitest",
         "build": "rimraf out && tsc && node scripts/build-compat.mjs",
-        "test:compat": "npm run build && npm --prefix compatibility/ts39-webpack4 install && npm --prefix compatibility/ts39-webpack4 run build"
+        "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",

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

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

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

@@ -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.d.ts

@@ -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.d.ts

@@ -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)