aberdeen 0.4.0 → 0.5.0

package/dist/prediction.js

@@ -1,110 +1,94 @@
-import { withEmitHandler } from './aberdeen.js';
+// src/prediction.ts
+import { withEmitHandler, defaultEmitHandler } from "./aberdeen.js";
 function recordPatch(func) {
-    const recordingPatch = new Map();
-    withEmitHandler(function (index, newData, oldData) {
-        addToPatch(recordingPatch, this, index, newData, oldData);
-    }, func);
-    return recordingPatch;
+  const recordingPatch = new Map;
+  withEmitHandler(function(target, index, newData, oldData) {
+    addToPatch(recordingPatch, target, index, newData, oldData);
+  }, func);
+  return recordingPatch;
 }
 function addToPatch(patch, collection, index, newData, oldData) {
-    let collectionMap = patch.get(collection);
-    if (!collectionMap) {
-        collectionMap = new Map();
-        patch.set(collection, collectionMap);
-    }
-    let prev = collectionMap.get(index);
-    if (prev)
-        oldData = prev[1];
-    if (newData === oldData)
-        collectionMap.delete(index);
-    else
-        collectionMap.set(index, [newData, oldData]);
+  let collectionMap = patch.get(collection);
+  if (!collectionMap) {
+    collectionMap = new Map;
+    patch.set(collection, collectionMap);
+  }
+  let prev = collectionMap.get(index);
+  if (prev)
+    oldData = prev[1];
+  if (newData === oldData)
+    collectionMap.delete(index);
+  else
+    collectionMap.set(index, [newData, oldData]);
 }
 function emitPatch(patch) {
-    for (let [collection, collectionMap] of patch) {
-        for (let [index, [newData, oldData]] of collectionMap) {
-            collection.emitChange(index, newData, oldData);
-        }
+  for (let [collection, collectionMap] of patch) {
+    for (let [index, [newData, oldData]] of collectionMap) {
+      defaultEmitHandler(collection, index, newData, oldData);
     }
+  }
 }
 function mergePatch(target, source, reverse = false) {
-    for (let [collection, collectionMap] of source) {
-        for (let [index, [newData, oldData]] of collectionMap) {
-            addToPatch(target, collection, index, reverse ? oldData : newData, reverse ? newData : oldData);
-        }
+  for (let [collection, collectionMap] of source) {
+    for (let [index, [newData, oldData]] of collectionMap) {
+      addToPatch(target, collection, index, reverse ? oldData : newData, reverse ? newData : oldData);
     }
+  }
 }
 function silentlyApplyPatch(patch, force = false) {
-    for (let [collection, collectionMap] of patch) {
-        for (let [index, [newData, oldData]] of collectionMap) {
-            let actualData = collection.rawGet(index);
-            if (actualData !== oldData) {
-                if (force)
-                    setTimeout(() => { throw new Error(`Applying invalid patch: data ${actualData} is unequal to expected old data ${oldData} for index ${index}`); }, 0);
-                else
-                    return false;
-            }
-        }
+  for (let [collection, collectionMap] of patch) {
+    for (let [index, [newData, oldData]] of collectionMap) {
+      let actualData = collection[index];
+      if (actualData !== oldData) {
+        if (force)
+          setTimeout(() => {
+            throw new Error(`Applying invalid patch: data ${actualData} is unequal to expected old data ${oldData} for index ${index}`);
+          }, 0);
+        else
+          return false;
+      }
     }
-    for (let [collection, collectionMap] of patch) {
-        for (let [index, [newData, oldData]] of collectionMap) {
-            collection.rawSet(index, newData);
-        }
+  }
+  for (let [collection, collectionMap] of patch) {
+    for (let [index, [newData, oldData]] of collectionMap) {
+      collection[index] = newData;
     }
-    return true;
+  }
+  return true;
 }
-const appliedPredictions = [];
-/**
- * Run the provided function, while treating all changes to Observables as predictions,
- * meaning they will be reverted when changes come back from the server (or some other
- * async source).
- * @param predictFunc The function to run. It will generally modify some Observables
- * 	to immediately reflect state (as closely as possible) that we expect the server
- *  to communicate back to us later on.
- * @returns A `Patch` object. Don't modify it. This is only meant to be passed to `applyCanon`.
- */
-export function applyPrediction(predictFunc) {
-    let patch = recordPatch(predictFunc);
-    appliedPredictions.push(patch);
-    emitPatch(patch);
-    return patch;
+var appliedPredictions = [];
+function applyPrediction(predictFunc) {
+  let patch = recordPatch(predictFunc);
+  appliedPredictions.push(patch);
+  emitPatch(patch);
+  return patch;
 }
-/**
- * Temporarily revert all outstanding predictions, optionally run the provided function
- * (which will generally make authoritative changes to the data based on a server response),
- * and then attempt to reapply the predictions on top of the new canonical state, dropping
- * any predictions that can no longer be applied cleanly (the data has been modified) or
- * that were specified in `dropPredictions`.
- *
- * All of this is done such that redraws are only triggered if the overall effect is an
- * actual change to an `Observable`.
- * @param canonFunc The function to run without any predictions applied. This will typically
- *  make authoritative changes to the data, based on a server response.
- * @param dropPredictions An optional list of predictions (as returned by `applyPrediction`)
- *  to undo. Typically, when a server response for a certain request is being handled,
- *  you'd want to drop the prediction that was done for that request.
- */
-export function applyCanon(canonFunc, dropPredictions = []) {
-    let resultPatch = new Map();
-    for (let prediction of appliedPredictions)
-        mergePatch(resultPatch, prediction, true);
-    silentlyApplyPatch(resultPatch, true);
-    for (let prediction of dropPredictions) {
-        let pos = appliedPredictions.indexOf(prediction);
-        if (pos >= 0)
-            appliedPredictions.splice(pos, 1);
-    }
-    if (canonFunc)
-        mergePatch(resultPatch, recordPatch(canonFunc));
-    for (let idx = 0; idx < appliedPredictions.length; idx++) {
-        if (silentlyApplyPatch(appliedPredictions[idx])) {
-            mergePatch(resultPatch, appliedPredictions[idx]);
-        }
-        else {
-            appliedPredictions.splice(idx, 1);
-            idx--;
-        }
+function applyCanon(canonFunc, dropPredictions = []) {
+  let resultPatch = new Map;
+  for (let prediction of appliedPredictions)
+    mergePatch(resultPatch, prediction, true);
+  silentlyApplyPatch(resultPatch, true);
+  for (let prediction of dropPredictions) {
+    let pos = appliedPredictions.indexOf(prediction);
+    if (pos >= 0)
+      appliedPredictions.splice(pos, 1);
+  }
+  if (canonFunc)
+    mergePatch(resultPatch, recordPatch(canonFunc));
+  for (let idx = 0;idx < appliedPredictions.length; idx++) {
+    if (silentlyApplyPatch(appliedPredictions[idx])) {
+      mergePatch(resultPatch, appliedPredictions[idx]);
+    } else {
+      appliedPredictions.splice(idx, 1);
+      idx--;
     }
-    emitPatch(resultPatch);
+  }
+  emitPatch(resultPatch);
 }
-//# sourceMappingURL=prediction.js.map
+export {
+  applyPrediction,
+  applyCanon
+};
+
+//# debugId=64BCD82AC2BC0BA664756E2164756E21
+//# sourceMappingURL=prediction.js.map

package/dist/prediction.js.map

@@ -1 +1,10 @@
-{"version":3,"file":"prediction.js","sourceRoot":"","sources":["../src/prediction.ts"],"names":[],"mappings":"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"}
+{
+  "version": 3,
+  "sources": ["../src/prediction.ts"],
+  "sourcesContent": [
+    "import {withEmitHandler, defaultEmitHandler} from './aberdeen.js'\nimport type { DatumType, TargetType } from './aberdeen.js';\n\n/** \n * Represents a set of changes that can be applied to proxied objects.\n * This is an opaque type - its internal structure is not part of the public API.\n * @private\n */\nexport type Patch = Map<TargetType, Map<any, [DatumType, DatumType]>>;\n\n\nfunction recordPatch(func: () => void): Patch {\n\tconst recordingPatch = new Map()\n\twithEmitHandler(function(target, index, newData, oldData) {\n\t\taddToPatch(recordingPatch, target, index, newData, oldData)\n\t}, func)\n\treturn recordingPatch\n}\n\nfunction addToPatch(patch: Patch, collection: TargetType, index: any, newData: DatumType, oldData: DatumType) {\n\tlet collectionMap = patch.get(collection)\n\tif (!collectionMap) {\n\t\tcollectionMap = new Map()\n\t\tpatch.set(collection, collectionMap)\n\t}\n\tlet prev = collectionMap.get(index)\n\tif (prev) oldData = prev[1]\n\tif (newData === oldData) collectionMap.delete(index)\n\telse collectionMap.set(index, [newData, oldData])\n}\n\nfunction emitPatch(patch: Patch) {\n\tfor(let [collection, collectionMap] of patch) {\n\t\tfor(let [index, [newData, oldData]] of collectionMap) {\n\t\t\tdefaultEmitHandler(collection, index, newData, oldData);\n\t\t}\n\t}\n}\n\nfunction mergePatch(target: Patch, source: Patch, reverse: boolean = false) {\n\tfor(let [collection, collectionMap] of source) {\n\t\tfor(let [index, [newData, oldData]] of collectionMap) {\n\t\t\taddToPatch(target, collection, index, reverse ? oldData : newData, reverse ? newData : oldData)\n\t\t}\n\t}\n}\n\nfunction silentlyApplyPatch(patch: Patch, force: boolean = false): boolean {\n\tfor(let [collection, collectionMap] of patch) {\n\t\tfor(let [index, [newData, oldData]] of collectionMap) {\n\t\t\tlet actualData = (collection as any)[index]\n\t\t\tif (actualData !== oldData) {\n\t\t\t\tif (force) setTimeout(() => { throw new Error(`Applying invalid patch: data ${actualData} is unequal to expected old data ${oldData} for index ${index}`)}, 0)\n\t\t\t\telse return false\n\t\t\t}\n\t\t}\n\t}\n\tfor(let [collection, collectionMap] of patch) {\n\t\tfor(let [index, [newData, oldData]] of collectionMap) {\n\t\t\t(collection as any)[index] = newData\n\t\t}\n\t}\n\treturn true\n}\n\n\nconst appliedPredictions: Array<Patch> = []\n\n/**\n * Run the provided function, while treating all changes to Observables as predictions,\n * meaning they will be reverted when changes come back from the server (or some other\n * async source).\n * @param predictFunc The function to run. It will generally modify some Observables\n * \tto immediately reflect state (as closely as possible) that we expect the server\n *  to communicate back to us later on.\n * @returns A `Patch` object. Don't modify it. This is only meant to be passed to `applyCanon`.\n */\nexport function applyPrediction(predictFunc: () => void): Patch {\n\tlet patch = recordPatch(predictFunc)\n\tappliedPredictions.push(patch)\n\temitPatch(patch)\n\treturn patch\n}\n\n/**\n * Temporarily revert all outstanding predictions, optionally run the provided function\n * (which will generally make authoritative changes to the data based on a server response),\n * and then attempt to reapply the predictions on top of the new canonical state, dropping \n * any predictions that can no longer be applied cleanly (the data has been modified) or\n * that were specified in `dropPredictions`.\n * \n * All of this is done such that redraws are only triggered if the overall effect is an\n * actual change to an `Observable`.\n * @param canonFunc The function to run without any predictions applied. This will typically\n *  make authoritative changes to the data, based on a server response.\n * @param dropPredictions An optional list of predictions (as returned by `applyPrediction`)\n *  to undo. Typically, when a server response for a certain request is being handled,\n *  you'd want to drop the prediction that was done for that request.\n */\nexport function applyCanon(canonFunc?: (() => void), dropPredictions: Array<Patch> = []) {\n\t\n\tlet resultPatch = new Map()\n\tfor(let prediction of appliedPredictions) mergePatch(resultPatch, prediction, true)\n\tsilentlyApplyPatch(resultPatch, true)\n\n\tfor(let prediction of dropPredictions) {\n\t\tlet pos = appliedPredictions.indexOf(prediction)\n\t\tif (pos >= 0) appliedPredictions.splice(pos, 1)\n\t}\n\tif (canonFunc) mergePatch(resultPatch, recordPatch(canonFunc))\n\n\tfor(let idx=0; idx<appliedPredictions.length; idx++) {\n\t\tif (silentlyApplyPatch(appliedPredictions[idx])) {\n\t\t\tmergePatch(resultPatch, appliedPredictions[idx])\n\t\t} else {\n\t\t\tappliedPredictions.splice(idx, 1)\n\t\t\tidx--\n\t\t}\n\t}\n\n\temitPatch(resultPatch)\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "64BCD82AC2BC0BA664756E2164756E21",
+  "names": []
+}

package/dist/route.d.ts

@@ -1,30 +1,47 @@
-import { Store } from './aberdeen.js';
 /**
- * A `Store` object that holds the following keys:
- * - `path`: The current path of the URL split into components. For instance `/` or `/users/123/feed`. Updates will be reflected in the URL and will *push* a new entry to the browser history.
- * - `p`: Array containing the path segments. For instance `[]` or `['users', 123, 'feed']`. Updates will be reflected in the URL and will *push* a new entry to the browser history. Also, the values of `p` and `path` will be synced.
- * - `search`: An observable object containing search parameters (a split up query string). For instance `{order: "date", title: "something"}` or just `{}`. By default, updates will be reflected in the URL, replacing the current history state.
- * - `hash`: The document hash part of the URL. For instance `"#section-title"`. It can also be an empty string. Updates will be reflected in the URL, modifying the current history state.
- * - `id`: A part of the browser history *state* that is considered part of the page *identify*, meaning changes will (by default) cause a history push, and when going *back*, it must match.
- * - `aux`: The auxiliary part of the browser history *state*, not considered part of the page *identity*. Changes will be reflected in the browser history using a replace.
- * - `depth`: The navigation depth of the current session. Starts at 1. Writing to this property has no effect.
- * - `nav`: The navigation action that got us to this page. Writing to this property has no effect.
- *    - `"load"`: An initial page load.
- *    - `"back"` or `"forward"`: When we navigated backwards or forwards in the stack.
- *    - `"push"`: When we added a new page on top of the stack.
+ * The class for the singleton `route` object.
  *
- * The following key may also be written to `route` but will be immediately and silently removed:
- * - `mode`: As described above, this library takes a best guess about whether pushing an item to the browser history makes sense or not. When `mode` is...
- * 	  	- `"push"`: Force creation of a new browser history entry.
- * 	  	- `"replace"`: Update the current history entry, even when updates to other keys would normally cause a *push*.
- * 		- `"back"`: Unwind the history (like repeatedly pressing the *back* button) until we find a page that matches the given `path` and `id`, and then *replace* that state by the full given state.
  */
-export declare const route: Store;
+export declare class Route {
+    /** The current path of the URL split into components. For instance `/` or `/users/123/feed`. Updates will be reflected in the URL and will *push* a new entry to the browser history. */
+    path: string;
+    /** Array containing the path segments. For instance `[]` or `['users', 123, 'feed']`. Updates will be reflected in the URL and will *push* a new entry to the browser history. Also, the values of `p` and `path` will be synced. */
+    p: string[];
+    /** An observable object containing search parameters (a split up query string). For instance `{order: "date", title: "something"}` or just `{}`. By default, updates will be reflected in the URL, replacing the current history state. */
+    hash: string;
+    /** A part of the browser history *state* that is considered part of the page *identify*, meaning changes will (by default) cause a history push, and when going *back*, it must match. */
+    search: Record<string, string>;
+    /** The `hash` interpreted as search parameters. So `"a=x&b=y"` becomes `{a: "x", b: "y"}`. */
+    id: Record<string, any>;
+    /** The auxiliary part of the browser history *state*, not considered part of the page *identity*. Changes will be reflected in the browser history using a replace. */
+    aux: Record<string, any>;
+    /** The navigation depth of the current session. Starts at 1. Writing to this property has no effect. */
+    depth: number;
+    /** The navigation action that got us to this page. Writing to this property has no effect.
+        - `"load"`: An initial page load.
+        - `"back"` or `"forward"`: When we navigated backwards or forwards in the stack.
+        - `"push"`: When we added a new page on top of the stack.
+    */
+    nav: 'load' | 'back' | 'forward' | 'push';
+    /** As described above, this library takes a best guess about whether pushing an item to the browser history makes sense or not. When `mode` is...
+        - `"push"`: Force creation of a new browser history entry.
+        - `"replace"`: Update the current history entry, even when updates to other keys would normally cause a *push*.
+        - `"back"`: Unwind the history (like repeatedly pressing the *back* button) until we find a page that matches the given `path` and `id` (or that is the first page in our stack), and then *replace* that state by the full given state.
+        The `mode` key can be written to `route` but will be immediately and silently removed.
+    */
+    mode: 'push' | 'replace' | 'back' | undefined;
+}
+/**
+ * The singleton {@link Route} object reflecting the current URL and browser history state. You can make changes to it to affect the URL and browser history. See {@link Route} for details.
+ */
+export declare const route: Route;
 /**
  * Restore and store the vertical and horizontal scroll position for
  * the parent element to the page state.
  *
  * @param {string} name - A unique (within this page) name for this
  * scrollable element. Defaults to 'main'.
+ *
+ * The scroll position will be persisted in `route.aux.scroll.<name>`.
  */
 export declare function persistScroll(name?: string): void;

package/dist/route.js

@@ -1,182 +1,155 @@
-import { Store, observe, immediateObserve, runQueue, getParentElement, clean } from './aberdeen.js';
-/**
- * A `Store` object that holds the following keys:
- * - `path`: The current path of the URL split into components. For instance `/` or `/users/123/feed`. Updates will be reflected in the URL and will *push* a new entry to the browser history.
- * - `p`: Array containing the path segments. For instance `[]` or `['users', 123, 'feed']`. Updates will be reflected in the URL and will *push* a new entry to the browser history. Also, the values of `p` and `path` will be synced.
- * - `search`: An observable object containing search parameters (a split up query string). For instance `{order: "date", title: "something"}` or just `{}`. By default, updates will be reflected in the URL, replacing the current history state.
- * - `hash`: The document hash part of the URL. For instance `"#section-title"`. It can also be an empty string. Updates will be reflected in the URL, modifying the current history state.
- * - `id`: A part of the browser history *state* that is considered part of the page *identify*, meaning changes will (by default) cause a history push, and when going *back*, it must match.
- * - `aux`: The auxiliary part of the browser history *state*, not considered part of the page *identity*. Changes will be reflected in the browser history using a replace.
- * - `depth`: The navigation depth of the current session. Starts at 1. Writing to this property has no effect.
- * - `nav`: The navigation action that got us to this page. Writing to this property has no effect.
- *    - `"load"`: An initial page load.
- *    - `"back"` or `"forward"`: When we navigated backwards or forwards in the stack.
- *    - `"push"`: When we added a new page on top of the stack.
- *
- * The following key may also be written to `route` but will be immediately and silently removed:
- * - `mode`: As described above, this library takes a best guess about whether pushing an item to the browser history makes sense or not. When `mode` is...
- * 	  	- `"push"`: Force creation of a new browser history entry.
- * 	  	- `"replace"`: Update the current history entry, even when updates to other keys would normally cause a *push*.
- * 		- `"back"`: Unwind the history (like repeatedly pressing the *back* button) until we find a page that matches the given `path` and `id`, and then *replace* that state by the full given state.
- */
-// Idea: split `state` into `pstate` (primary) and `astate` (auxilary). The former is used to determine if new pages should be pushed and if, when moving back, a page matches.
-// Moving back is done by just doing history.back() while depth > 1, and repeating in handleLocationUpdate until matching page is found (or overriding base page).
-export const route = new Store();
-let stateRoute = {
-    nonce: -1,
-    depth: 0,
+// src/route.ts
+import { getParentElement, runQueue, clean, proxy, observe, immediateObserve, unproxy, clone } from "./aberdeen.js";
+
+class Route {
+  path;
+  p;
+  hash;
+  search;
+  id;
+  aux;
+  depth = 1;
+  nav = "load";
+  mode;
+}
+var route = proxy(new Route);
+var stateRoute = {
+  nonce: -1,
+  depth: 0
 };
-// Reflect changes to the browser URL (back/forward navigation) in the `route` and `stack`.
 function handleLocationUpdate(event) {
-    var _a;
-    let state = (event === null || event === void 0 ? void 0 : event.state) || {};
-    let nav = 'load';
-    if (((_a = state.route) === null || _a === void 0 ? void 0 : _a.nonce) == null) {
-        state.route = {
-            nonce: Math.floor(Math.random() * Number.MAX_SAFE_INTEGER),
-            depth: 1,
-        };
-        history.replaceState(state, '');
-    }
-    else if (stateRoute.nonce === state.route.nonce) {
-        nav = state.route.depth > stateRoute.depth ? 'forward' : 'back';
-    }
-    stateRoute = state.route;
-    if (route('mode').peek() === 'back') {
-        route('depth').set(stateRoute.depth);
-        // We are still in the process of searching for a page in our navigation history..
-        updateHistory();
-        return;
-    }
-    const search = {};
-    for (let [k, v] of new URLSearchParams(location.search)) {
-        search[k] = v;
-    }
-    route.set({
-        path: location.pathname,
-        p: location.pathname.slice(1).split('/'),
-        search: search,
-        hash: location.hash,
-        id: state.id,
-        aux: state.aux,
-        depth: stateRoute.depth,
-        nav,
-    });
-    // Forward or back event. Redraw synchronously, because we can!
-    if (event)
-        runQueue();
+  let state = event?.state || {};
+  let nav = "load";
+  if (state.route?.nonce == null) {
+    state.route = {
+      nonce: Math.floor(Math.random() * Number.MAX_SAFE_INTEGER),
+      depth: 1
+    };
+    history.replaceState(state, "");
+  } else if (stateRoute.nonce === state.route.nonce) {
+    nav = state.route.depth > stateRoute.depth ? "forward" : "back";
+  }
+  stateRoute = state.route;
+  if (unproxy(route).mode === "back") {
+    route.depth = stateRoute.depth;
+    updateHistory();
+    return;
+  }
+  const search = {};
+  for (let [k, v] of new URLSearchParams(location.search)) {
+    search[k] = v;
+  }
+  route.path = location.pathname;
+  route.p = location.pathname.slice(1).split("/");
+  route.search = search;
+  route.hash = location.hash;
+  route.id = state.id;
+  route.aux = state.aux;
+  route.depth = stateRoute.depth;
+  route.nav = nav;
+  if (event)
+    runQueue();
 }
 handleLocationUpdate();
 window.addEventListener("popstate", handleLocationUpdate);
-// These immediate-mode observers will rewrite the data in `route` to its canonical form.
-// We want to to this immediately, so that user-code running immediately after a user-code
-// initiated `set` will see the canonical form (instead of doing a rerender shortly after,
-// or crashing due to non-canonical data).
 function updatePath() {
-    let path = route('path').get();
-    if (path == null && route('p').peek()) {
-        return updateP();
-    }
-    path = '' + path;
-    if (!path.startsWith('/'))
-        path = '/' + path;
-    route('path').set(path);
-    route('p').set(path.slice(1).split('/'));
+  let path = route.path;
+  if (path == null && unproxy(route).p) {
+    return updateP();
+  }
+  path = "" + (path || "/");
+  if (!path.startsWith("/"))
+    path = "/" + path;
+  route.path = path;
+  route.p = path.slice(1).split("/");
 }
 immediateObserve(updatePath);
 function updateP() {
-    const p = route('p').get();
-    if (p == null && route('path').peek()) {
-        return updatePath();
-    }
-    if (!(p instanceof Array)) {
-        console.error(`aberdeen route: 'p' must be a non-empty array, not ${JSON.stringify(p)}`);
-        route('p').set(['']); // This will cause a recursive call this observer.
-    }
-    else if (p.length == 0) {
-        route('p').set(['']); // This will cause a recursive call this observer.
-    }
-    else {
-        route('path').set('/' + p.join('/'));
-    }
+  const p = route.p;
+  if (p == null && unproxy(route).path) {
+    return updatePath();
+  }
+  if (!(p instanceof Array)) {
+    console.error(`aberdeen route: 'p' must be a non-empty array, not ${JSON.stringify(p)}`);
+    route.p = [""];
+  } else if (p.length == 0) {
+    route.p = [""];
+  } else {
+    route.path = "/" + p.join("/");
+  }
 }
 immediateObserve(updateP);
 immediateObserve(() => {
-    if (route('search').getType() !== 'object')
-        route('search').set({});
+  if (!route.search || typeof route.search !== "object")
+    route.search = {};
+});
+immediateObserve(() => {
+  if (!route.id || typeof route.id !== "object")
+    route.id = {};
 });
 immediateObserve(() => {
-    if (route('state').getType() !== 'object')
-        route('state').set({});
+  if (!route.aux || typeof route.aux !== "object")
+    route.aux = {};
 });
 immediateObserve(() => {
-    let hash = '' + (route('hash').get() || '');
-    if (hash && !hash.startsWith('#'))
-        hash = '#' + hash;
-    route('hash').set(hash);
+  let hash = "" + (route.hash || "");
+  if (hash && !hash.startsWith("#"))
+    hash = "#" + hash;
+  route.hash = hash;
 });
 function isSamePage(path, state) {
-    return location.pathname === path && JSON.stringify(history.state.id) === JSON.stringify(state.id);
+  return location.pathname === path && JSON.stringify(history.state.id) === JSON.stringify(state.id);
 }
 function updateHistory() {
-    var _a;
-    // Get and delete mode without triggering anything.
-    let mode = route('mode').get();
-    const state = {
-        id: route('id').get(),
-        aux: route('aux').get(),
-        route: stateRoute,
-    };
-    // Construct the URL.
-    const path = route('path').get();
-    // Change browser state, according to `mode`.
-    if (mode === 'back') {
-        route('nav').set('back');
-        if (!isSamePage(path, state) && (((_a = history.state.route) === null || _a === void 0 ? void 0 : _a.depth) || 0) > 1) {
-            history.back();
-            return;
-        }
-        mode = 'replace';
-        // We'll replace the state async, to give the history.go the time to take affect first.
-        //setTimeout(() => history.replaceState(state, '', url), 0)
-    }
-    if (mode)
-        route('mode').delete();
-    const search = new URLSearchParams(route('search').get()).toString();
-    const url = (search ? path + '?' + search : path) + route('hash').get();
-    if (mode === 'push' || (!mode && !isSamePage(path, state))) {
-        stateRoute.depth++; // stateRoute === state.route
-        history.pushState(state, '', url);
-        route.merge({
-            nav: 'push',
-            depth: stateRoute.depth
-        });
-    }
-    else {
-        // Default to `push` when the URL changed or top-level state keys changed.
-        history.replaceState(state, '', url);
+  let mode = route.mode;
+  const state = {
+    id: clone(route.id),
+    aux: clone(route.aux),
+    route: stateRoute
+  };
+  const path = route.path;
+  if (mode === "back") {
+    route.nav = "back";
+    if (!isSamePage(path, state) && (history.state.route?.depth || 0) > 1) {
+      history.back();
+      return;
     }
+    mode = "replace";
+  }
+  if (mode)
+    route.mode = undefined;
+  const search = new URLSearchParams(route.search).toString();
+  const url = (search ? path + "?" + search : path) + route.hash;
+  if (mode === "push" || !mode && !isSamePage(path, state)) {
+    stateRoute.depth++;
+    history.pushState(state, "", url);
+    route.nav = "push";
+    route.depth = stateRoute.depth;
+  } else {
+    history.replaceState(state, "", url);
+  }
 }
-// This deferred-mode observer will update the URL and history based on `route` changes.
 observe(updateHistory);
-/**
- * Restore and store the vertical and horizontal scroll position for
- * the parent element to the page state.
- *
- * @param {string} name - A unique (within this page) name for this
- * scrollable element. Defaults to 'main'.
- */
-export function persistScroll(name = 'main') {
-    const el = getParentElement();
-    el.addEventListener('scroll', onScroll);
-    clean(() => el.removeEventListener('scroll', onScroll));
-    let restore = route('state', 'scroll', name).peek();
-    if (restore) {
-        Object.assign(el, restore);
-    }
-    function onScroll() {
-        route('mode').set('replace');
-        route('state', 'scroll', name).set({ scrollTop: el.scrollTop, scrollLeft: el.scrollLeft });
-    }
+function persistScroll(name = "main") {
+  const el = getParentElement();
+  el.addEventListener("scroll", onScroll);
+  clean(() => el.removeEventListener("scroll", onScroll));
+  let restore = unproxy(route).aux.scroll?.name;
+  if (restore) {
+    Object.assign(el, restore);
+  }
+  function onScroll() {
+    route.mode = "replace";
+    if (!route.aux.scroll)
+      route.aux.scroll = {};
+    route.aux.scroll[name] = { scrollTop: el.scrollTop, scrollLeft: el.scrollLeft };
+  }
 }
-//# sourceMappingURL=route.js.map
+export {
+  route,
+  persistScroll,
+  Route
+};
+
+//# debugId=917712AC1764DFEF64756E2164756E21
+//# sourceMappingURL=route.js.map