aberdeen 0.4.0 → 0.5.0

package/dist-min/aberdeen.d.ts

@@ -1,601 +0,0 @@
-/**
- * Normally, changes to `Store`s are reacted to asynchronously, in an (optimized)
- * batch, after a timeout of 0s. Calling `runQueue()` will do so immediately
- * and synchronously. Doing so may be helpful in cases where you need some DOM
- * modification to be done synchronously.
- *
- * This function is re-entrant, meaning it is safe to call `runQueue` from a
- * function that is called due to another (automatic) invocation of `runQueue`.
- */
-export declare function runQueue(): void;
-/**
- * A promise-like object that you can `await`. It will resolve *after* the current batch
- * of DOM-write operations has completed. This is the best time to retrieve DOM properties
- * that dependent on a layout being completed, such as `offsetHeight`.
- *
- * By batching DOM reads separately from DOM writes, this prevents the browser from
- * interleaving layout reads and writes, which can force additional layout recalculations.
- * This helps reduce visual glitches and flashes by ensuring the browser doesn't render
- * intermediate DOM states during updates.
- *
- * Unlike `setTimeout` or `requestAnimationFrame`, this mechanism ensures that DOM read
- * operations happen before any DOM writes in the same queue cycle, minimizing layout thrashing.
- *
- * See `transitions.js` for some examples.
- */
-export declare const DOM_READ_PHASE: {
-    then: (fulfilled: () => void) => any;
-};
-/**
- * A promise-like object that you can `await`. It will resolve *after* the current
- * DOM_READ_PHASE has completed (if any) and after any DOM triggered by Aberdeen
- * have completed. This is a good time to do little manual DOM tweaks that depend
- * on a *read phase* first, like triggering transitions.
- *
- * By batching DOM writes separately from DOM reads, this prevents the browser from
- * interleaving layout reads and writes, which can force additional layout recalculations.
- * This helps reduce visual glitches and flashes by ensuring the browser doesn't render
- * intermediate DOM states during updates.
- *
- * Unlike `setTimeout` or `requestAnimationFrame`, this mechanism ensures that DOM write
- * operations happen after all DOM reads in the same queue cycle, minimizing layout thrashing.
- *
- * See `transitions.js` for some examples.
- */
-export declare const DOM_WRITE_PHASE: {
-    then: (fulfilled: () => void) => any;
-};
-export interface Store {
-    /**
-     * Return a `Store` deeper within the tree by resolving the given `path`,
-     * subscribing to every level.
-     * In case `undefined` is encountered while resolving the path, a newly
-     * created `Store` containing `undefined` is returned. In that case, the
-     * `Store`'s [[`isDetached`]] method will return `true`.
-     * In case something other than a collection is encountered, an error is thrown.
-     */
-    (...path: any[]): Store;
-}
-export declare class Store {
-    /**
-     * Create a new `Store` with `undefined` as its initial value.
-     */
-    constructor();
-    /**
-     * Create a new `Store`.
-     * @param value The initial value. Plain objects, arrays and `Map`s, are converted
-     * into a tree of nested `Store`s. When another `Store` is included somewhere in that
-     * input tree, a reference is made.
-     */
-    constructor(value: any);
-    /**
-     * @returns The index for this Store within its parent collection. This will be a `number`
-     * when the parent collection is an array, a `string` when it's an object, or any data type
-     * when it's a `Map`.
-     *
-     * @example
-     * ```
-     * let store = new Store({x: 123})
-     * let subStore = store.ref('x')
-     * subStore.get() // 123
-     * subStore.index() // 'x'
-     * ```
-     */
-    index(): any;
-    /**
-     * Retrieve the value for store, subscribing the observe scope to changes.
-     *
-     * @param depth Limit the depth of the retrieved data structure to this positive integer.
-     *    When `depth` is `1`, only a single level of the value at `path` is unpacked. This
-     *    makes no difference for primitive values (like strings), but for objects, maps and
-     *    arrays, it means that each *value* in the resulting data structure will be a
-     *    reference to the `Store` for that value.
-     *
-     * @returns The resulting value (or `undefined` if the `Store` does not exist).
-     */
-    get(depth?: number): any;
-    /**
-     * Exactly like {@link Store.get}, except that when executed from an observe scope,
-     * we will not subscribe to changes in the data retrieved data.
-     */
-    peek(depth?: number): any;
-    /**
-     * Like {@link Store.get}, but with return type checking.
-     *
-     * @param expectType A string specifying what type the.get is expected to return. Options are:
-     *    "undefined", "null", "boolean", "number", "string", "function", "array", "map"
-     *    and "object". If the store holds a different type of value, a `TypeError`
-     *    exception is thrown.
-     * @returns
-     */
-    getTyped(expectType: String, depth?: number): any;
-    /**
-     * @returns Like {@link Store.get}, but throws a `TypeError` if the resulting value is not of type `number`.
-     * Using this instead of just {@link Store.get} is especially useful from within TypeScript.
-     */
-    getNumber(): number;
-    /**
-     * @returns Like {@link Store.get}, but throws a `TypeError` if the resulting value is not of type `string`.
-     * Using this instead of just {@link Store.get} is especially useful from within TypeScript.
-     */
-    getString(): string;
-    /**
-     * @returns Like {@link Store.get}, but throws a `TypeError` if the resulting value is not of type `boolean`.
-     * Using this instead of just {@link Store.get} is especially useful from within TypeScript.
-     */
-    getBoolean(): boolean;
-    /**
-     * @returns Like {@link Store.get}, but throws a `TypeError` if the resulting value is not of type `function`.
-     * Using this instead of just {@link Store.get} is especially useful from within TypeScript.
-     */
-    getFunction(): (Function);
-    /**
-     * @returns Like {@link Store.get}, but throws a `TypeError` if the resulting value is not of type `array`.
-     * Using this instead of just {@link Store.get} is especially useful from within TypeScript.
-     */
-    getArray(depth?: number): any[];
-    /**
-     * @returns Like {@link Store.get}, but throws a `TypeError` if the resulting value is not of type `object`.
-     * Using this instead of just {@link Store.get} is especially useful from within TypeScript.
-     */
-    getObject(depth?: number): object;
-    /**
-     * @returns Like {@link Store.get}, but throws a `TypeError` if the resulting value is not of type `map`.
-     * Using this instead of just {@link Store.get} is especially useful from within TypeScript.
-     */
-    getMap(depth?: number): Map<any, any>;
-    /**
-     * Like {@link Store.get}, but with a default value (returned when the Store
-     * contains `undefined`). This default value is also used to determine the expected type,
-     * and to throw otherwise.
-     *
-     * @example
-     * ```
-     * let store = new Store({x: 42})
-     * store('x').getOr(99) // 42
-     * store('y').getOr(99) // 99
-     * store('x').getOr('hello') // throws TypeError (because 42 is not a string)
-     * ```
-     */
-    getOr<T>(defaultValue: T): T;
-    /**
-     * Checks if the collection held in `Store` is empty, and subscribes the current scope to changes of the emptiness of this collection.
-     *
-     * @returns When the collection is not empty `true` is returned. If it is empty or if the value is undefined, `false` is returned.
-     * @throws When the value is not a collection and not undefined, an Error will be thrown.
-     */
-    isEmpty(): boolean;
-    /**
-     * Returns the number of items in the collection held in Store, and subscribes the current scope to changes in this count.
-     *
-     * @returns The number of items contained in the collection, or 0 if the value is undefined.
-     * @throws When the value is not a collection and not undefined, an Error will be thrown.
-     */
-    count(): number;
-    /**
-     * Returns a strings describing the type of the `Store` value, subscribing to changes of this type.
-     * Note: this currently also subscribes to changes of primitive values, so changing a value from 3 to 4
-     * would cause the scope to be rerun. This is not great, and may change in the future. This caveat does
-     * not apply to changes made *inside* an object, `Array` or `Map`.
-     *
-     * @returns Possible options: "undefined", "null", "boolean", "number", "string", "function", "array", "map" or "object".
-     */
-    getType(): string;
-    /**
-     * Returns a new `Store` that will always hold either the value of `whenTrue` or the value
-     * of `whenFalse` depending on whether the original `Store` is truthy or not.
-     *
-     * @param whenTrue The value set to the return-`Store` while `this` is truthy. This can be
-     *     any type of value. If it's a `Store`, the return-`Store` will reference the same
-     *     data (so *no* deep copy will be made).
-     * @param whenFalse Like `whenTrue`, but for falsy values (false, undefined, null, 0, "").
-     * @returns A store holding the result value. The value will keep getting updated while
-     * the observe context from which `if()` was called remains active.
-     */
-    if(whenTrue: any[], whenFalse?: any[]): Store;
-    /**
-     * Sets the `Store` value to the given argument.
-     *
-     * When a `Store` is passed in as the value, its value will be copied (subscribing to changes). In
-     * case the value is an object, an `Array` or a `Map`, a *reference* to that data structure will
-     * be created, so that changes made through one `Store` will be reflected through the other. Be
-     * carefull not to create loops in your `Store` tree that way, as that would cause any future
-     * call to {@link Store.get} to throw a `RangeError` (Maximum call stack size exceeded.)
-     *
-     * If you intent to make a copy instead of a reference, call {@link Store.get} on the origin `Store`.
-     *
-     * @returns The `Store` itself, for chaining other methods.
-     *
-     * @example
-     * ```
-     * let store = new Store() // Value is `undefined`
-     *
-     * store.set(6)
-     * store.get() // 6
-     *
-     * store.set({}) // Change  value to an empty object
-     * store('a', 'b', 'c').set('d') // Create parent path as objects
-     * store.get() // {x: 6, a: {b: {c: 'd'}}}
-     *
-     * store.set(42) // Overwrites all of the above
-     * store.get() // 42
-     *
-     * store('x').set(6) // Throw Error (42 is not a collection)
-     * ```
-     */
-    set(newValue: any): Store;
-    /**
-     * Sets the `Store` to the given `mergeValue`, but without deleting any pre-existing
-     * items when a collection overwrites a similarly typed collection. This results in
-     * a deep merge.
-     *
-     * @returns The `Store` itself, for chaining other methods.
-     *
-     * @example
-     * ```
-     * let store = new Store({a: {x: 1}})
-     * store.merge({a: {y: 2}, b: 3})
-     * store.get() // {a: {x: 1, y: 2}, b: 3}
-     * ```
-     */
-    merge(mergeValue: any): Store;
-    /**
-     * Sets the value for the store to `undefined`, which causes it to be omitted from the map (or array, if it's at the end)
-     *
-     * @returns The `Store` itself, for chaining other methods.
-     *
-     * @example
-     * ```
-     * let store = new Store({a: 1, b: 2})
-     * store('a').delete()
-     * store.get() // {b: 2}
-     *
-     * store = new Store(['a','b','c'])
-     * store(1).delete()
-     * store.get() // ['a', undefined, 'c']
-     * store(2).delete()
-     * store.get() // ['a']
-     * store.delete()
-     * store.get() // undefined
-     * ```
-     */
-    delete(): Store;
-    /**
-     * Pushes a value to the end of the Array that is at the specified path in the store.
-     * If that store path is `undefined`, an Array is created first.
-     * The last argument is the value to be added, any earlier arguments indicate the path.
-     *
-     * @returns The index at which the item was appended.
-     * @throws TypeError when the store contains a primitive data type.
-     *
-     * @example
-     * ```
-     * let store = new Store()
-     * store.push(3) // Creates the array
-     * store.push(6)
-     * store.get() // [3,6]
-     *
-     * store = new Store({myArray: [1,2]})
-     * store('myArray').push(3)
-     * store.get() // {myArray: [1,2,3]}
-     * ```
-     */
-    push(newValue: any): number;
-    /**
-     * {@link Store.peek} the current value, pass it through `func`, and {@link Store.set} the resulting
-     * value.
-     * @param func The function transforming the value.
-     * @returns The `Store` itself, for chaining other methods.
-     */
-    modify(func: (value: any) => any): Store;
-    /**
-     * Iterate the specified collection (Array, Map or object), running the given code block for each item.
-     * When items are added to the collection at some later point, the code block will be ran for them as well.
-     * When an item is removed, the {@link Store.clean} handlers left by its code block are executed.
-     *
-     * @param renderer The function to be called for each item. It receives the item's `Store` object as its only argument.
-     * @param makeSortKey An optional function that, given an items `Store` object, returns a value to be sorted on.
-     *   This value can be a number, a string, or an array containing a combination of both. When undefined is returned,
-     *   the item is *not* rendered. If `makeSortKey` is not specified, the output will be sorted by `index()`.
-     */
-    onEach(renderer: (store: Store) => void, makeSortKey?: (store: Store) => any): void;
-    /**
-     * Derive a new `Store` from this `Store`, by reactively passing its value
-     * through the specified function.
-     * @param func Your function. It should accept a the input store's value, and return
-     *   a result to be reactively set to the output store.
-     * @returns The output `Store`.
-     * @example
-     * ```javascript
-     * const store = new Store(21)
-     * const double = store.derive(v => v*2)
-     * double.get() // 42
-     *
-     * store.set(100)
-     * runQueue() // Or after a setTimeout 0, due to batching
-     * double.get() // 200
-     * ```
-     */
-    derive(func: (value: any) => any): Store;
-    /**
-     * Applies a filter/map function on each item within the `Store`'s collection,
-     * and reactively manages the returned `Map` `Store` to hold any results.
-     *
-     * @param func - Function that transform the given store into an output value or
-     * `undefined` in case this value should be skipped:
-     *
-     * @returns - A array/map/object `Store` with the values returned by `func` and the
-     * corresponding keys from the original map, array or object `Store`.
-     *
-     * When items disappear from the `Store` or are changed in a way that `func` depends
-     * upon, the resulting items are removed from the output `Store` as well. When multiple
-     * input items produce the same output keys, this may lead to unexpected results.
-     */
-    map(func: (store: Store) => any): Store;
-    /**
-     * Applies a filter/map function on each item within the `Store`'s collection,
-     * each of which can deliver any number of key/value pairs, and reactively manages the
-     * returned map `Store` to hold any results.
-     *
-     * @param func - Function that transform the given store into output values
-     * that can take one of the following forms:
-     * - an `Object` or a `Map`: Each key/value pair will be added to the output `Store`.
-     * - anything else: No key/value pairs are added to the output `Store`.
-     *
-     * @returns - A map `Store` with the key/value pairs returned by all `func` invocations.
-     *
-     * When items disappear from the `Store` or are changed in a way that `func` depends
-     * upon, the resulting items are removed from the output `Store` as well. When multiple
-     * input items produce the same output keys, this may lead to unexpected results.
-     */
-    multiMap(func: (store: Store) => any): Store;
-    /**
-    * Dump a live view of the `Store` tree as HTML text, `ul` and `li` nodes at
-    * the current mount position. Meant for debugging purposes.
-    * @returns The `Store` itself, for chaining other methods.
-    */
-    dump(): Store;
-}
-/**
- * Modifies the *parent* DOM element in the current reactive scope, or adds
- * new DOM elements to it.
- *
- * @param args - Arguments that define how to modify/create elements.
- *
- * ### String arguments
- * Create new elements with optional classes and text content:
- * ```js
- * $('div.myClass')              // <div class="myClass"></div>
- * $('span.c1.c2:Hello')         // <span class="c1 c2">Hello</span>
- * $('p:Some text')              // <p>Some text</p>
- * $('.my-thing')                // <div class="my-thing"></div>
- * $('div', 'span', 'p.cls')     // <div><span<p class="cls"></p></span></div>
- * $(':Just some text!')		 // Just some text! (No new element, just a text node)
- * ```
- *
- * ### Object arguments
- * Set properties, attributes, events and special features:
- * ```js
- * // Classes (dot prefix)
- * $('div', {'.active': true})           // Add class
- * $('div', {'.hidden': false})          // Remove (or don't add) class
- * $('div', {'.selected': myStore})      // Reactively add/remove class
- *
- * // Styles (dollar prefixed and camel-cased CSS properties)
- * $('div', {$color: 'red'})             // style.color = 'red'
- * $('div', {$marginTop: '10px'})        // style.marginTop = '10px'
- * $('div', {$color: myColorStore})      // Reactively change color
- *
- * // Events (function values)
- * $('button', {click: () => alert()})   // Add click handler
- *
- * // Properties (boolean values, `selectedIndex`, `value`)
- * $('input', {disabled: true})          // el.disabled = true
- * $('input', {value: 'test'})           // el.value = 'test'
- * $('select', {selectedIndex: 2})       // el.selectedIndex = 2
- *
- * // Transitions
- * $('div', {create: 'fade-in'})         // Add class on create
- * $('div', {create: el => {...}})       // Run function on create
- * $('div', {destroy: 'fade-out'})       // Add class before remove
- * $('div', {destroy: el => {...}})      // Run function before remove
- *
- * // Content
- * $('div', {html: '<b>Bold</b>'})       // Set innerHTML
- * $('div', {text: 'Plain text'})        // Add text node
- * const myElement = document.createElement('video')
- * $('div', {element: myElement})        // Add existing DOM element
- *
- * // Regular attributes (everything else)
- * $('div', {title: 'Info'})             // el.setAttribute('title', 'info')
- * ```
- *
- * When a `Store` is passed as a value, a seperate observe-scope will
- * be created for it, such that when the `Store` changes, only *that*
- * UI property will need to be updated.
- * So in the following example, when `colorStore` changes, only the
- * `color` CSS property will be updated.
- * ```js
- * $('div', {
- *   '.active': activeStore,             // Reactive class
- *   $color: colorStore,                 // Reactive style
- *   text: textStore                     // Reactive text
- * })
- * ```
- *
- * ### Two-way input binding
- * Set the initial value of an <input> <textarea> or <select> to that
- * of a `Store`, and then start reflecting user changes to the former
- * in the latter.
- * ```js
- * $('input', {bind: myStore})           // Binds input.value
- * ```
- * This is a special case, as changes to the `Store` will *not* be
- * reflected in the UI.
- *
- * ### Function arguments
- * Create child scopes that re-run on observed `Store` changes:
- * ```js
- * $('div', () => {
- *   $(myStore.get() ? 'span' : 'p')     // Reactive element type
- * })
- * ```
- * When *only* a function is given, `$` behaves exactly like {@link Store.observe},
- * except that it will only work when we're inside a `mount`.
- *
- * @throws {ScopeError} If called outside an observable scope.
- * @throws {Error} If invalid arguments are provided.
- */
-export declare function $(...args: (string | (() => void) | false | null | undefined | {
-    [key: string]: any;
-})[]): void;
-/**
- * Set a custome error handling function, thast is called when an error occurs during rendering
- * while in a reactive scope. The default implementation logs the error to the console, and then
- * just returns `true`, which causes an 'Error' message to be displayed in the UI. When this function
- * returns `false`, the error is suppressed. This mechanism exists because rendering errors can occur
- * at any time, not just synchronous when making a call to Aberdeen, thus normal exception handling
- * is not always possible.
- *
- * @param handler The handler function, getting an `Error` as its argument, and returning `false`
- *    if it does *not* want an error message to be added to the DOM.
- *    When `handler is `undefined`, the default error handling will be reinstated.
- *
- * @example
- * ```javascript
- * //
- * setErrorHandler(error => {
- *    // Tell our developers about the problem.
- * 	  fancyErrorLogger(error)
- *    // Add custom error message to the DOM.
- *    try {
- *        $('.error:Sorry, something went wrong!')
- *    } catch() {} // In case there is no parent element.
- *    // Don't add default error message to the DOM.
- * 	  return false
- * })
- * ```
- */
-export declare function setErrorHandler(handler?: (error: Error) => boolean | undefined): void;
-/**
- * Return the browser Element that nodes would be rendered to at this point.
- * NOTE: Manually changing the DOM is not recommended in most cases. There is
- * usually a better, declarative way. Although there are no hard guarantees on
- * how your changes interact with Aberdeen, in most cases results will not be
- * terribly surprising. Be careful within the parent element of onEach() though.
- */
-export declare function getParentElement(): Element;
-/**
- * Register a function that is to be executed right before the current reactive scope
- * disappears or redraws.
- * @param clean - The function to be executed.
- */
-export declare function clean(clean: () => void): void;
-/**
- * Reactively run a function, meaning the function will rerun when any `Store` that was read
- * during its execution is updated.
- * Calls to `observe` can be nested, such that changes to `Store`s read by the inner function do
- * no cause the outer function to rerun.
- *
- * @param func - The function to be (repeatedly) executed.
- * @returns The mount id (usable for `unmount`) if this is a top-level observe.
- * @example
- * ```
- * let number = new Store(0)
- * let doubled = new Store()
- * setInterval(() => number.set(0|Math.random()*100)), 1000)
- *
- * observe(() => {
- *   doubled.set(number.get() * 2)
- * })
- *
- * observe(() => {
- *   console.log(doubled.get())
- * })
- */
-export declare function observe(func: () => void): number | undefined;
-/**
- * Like `observe`, but instead of deferring running the observer function until
- * a setTimeout 0, run it immediately and synchronously when a change to one of
- * the observed  `Store`s is made. Use this sparingly, as this prevents Aberdeen
- * from doing the usual batching and smart ordering of observers, leading to
- * performance problems and observing of 'weird' partial states.
- * @param func The function to be (repeatedly) executed.
- * @returns The mount id (usable for `unmount`) if this is a top-level observe.
- */
-export declare function immediateObserve(func: () => void): number | undefined;
-/**
- * Reactively run the function, adding any DOM-elements created using {@link $} to the given parent element.
-
- * @param func - The function to be (repeatedly) executed, possibly adding DOM elements to `parentElement`.
- * @param parentElement - A DOM element that will be used as the parent element for calls to `$`.
- * @returns The mount id (usable for `unmount`) if this is a top-level mount.
- *
- * @example
- * ```
- * let store = new Store(0)
- * setInterval(() => store.modify(v => v+1), 1000)
- *
- * mount(document.body, () => {
- * 	   $(`h2:${store.get()} seconds have passed`)
- * })
- * ```
- *
- * An example nesting {@link Store.observe} within `mount`:
- * ```
- * let selected = new Store(0)
- * let colors = new Store(new Map())
- *
- * mount(document.body, () => {
- *   // This function will never rerun (as it does not read any `Store`s)
- *   $('button:<<', {click: () => selected.modify(n => n-1)})
- *   $('button:>>', {click: () => selected.modify(n => n+1)})
- *
- *   observe(() => {
- *     // This will rerun whenever `selected` changes, recreating the <h2> and <input>.
- *     $('h2', {text: '#' + selected.get()})
- *     $('input', {type: 'color', value: '#ffffff' bind: colors(selected.get())})
- *   })
- *
- *   observe(() => {
- *     // This function will rerun when `selected` or the selected color changes.
- *     // It will change the <body> background-color.
- *     $({$backgroundColor: colors.get(selected.get()) || 'white'})
- *   })
- * })
- * ```
-*/
-export declare function mount(parentElement: Element, func: () => void): number | undefined;
-/**
- * Unmount one specific or all top-level mounts or observes, meaning those that were created outside of the scope
- * of any other mount or observe.
- * @param id Optional mount number (as returned by `mount`, `observe` or `immediateObserve`). If `undefined`, unmount all.
- */
-export declare function unmount(id?: number): void;
-/** Runs the given function, while not subscribing the current scope when reading {@link Store.Store} values.
- *
- * @param func Function to be executed immediately.
- * @returns Whatever `func()` returns.
- * @example
- * ```
- * import {Store, peek, text} from aberdeen
- *
- * let store = new Store(['a', 'b', 'c'])
- *
- * mount(document.body, () => {
- *     // Prevent rerender when store changes
- *     let msg = peek(() => `Store has ${store.count()} elements, and the first is ${store.get(0)}`))
- *     text(msg)
- * })
- * ```
- *
- * In the above example `store.get(0)` could be replaced with `store.peek(0)` to achieve the
- * same result without `peek()` wrapping everything. There is no non-subscribing equivalent
- * for `count()` however.
- */
-export declare function peek<T>(func: () => T): T;
-declare global {
-    interface String {
-        replaceAll(from: string, to: string): string;
-    }
-}

package/dist-min/prediction.d.ts

@@ -1,29 +0,0 @@
-type ObsCollection = any;
-type Patch = Map<ObsCollection, Map<any, [any, any]>>;
-/**
- * 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 declare function applyPrediction(predictFunc: () => void): 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 declare function applyCanon(canonFunc?: (() => void), dropPredictions?: Array<Patch>): void;
-export {};

package/dist-min/route.d.ts

@@ -1,30 +0,0 @@
-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 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;
-/**
- * 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 declare function persistScroll(name?: string): void;

package/dist-min/transitions.d.ts

@@ -1,18 +0,0 @@
-/** Do a grow transition for the given element. This is meant to be used as a
-* handler for the `create` property.
-*
-* @param el The element to transition.
-*
-* The transition doesn't look great for table elements, and may have problems
-* for other specific cases as well.
-*/
-export declare function grow(el: HTMLElement): Promise<void>;
-/** Do a shrink transition for the given element, and remove it from the DOM
-* afterwards. This is meant to be used as a handler for the `destroy` property.
-*
-* @param el The element to transition and remove.
-*
-* The transition doesn't look great for table elements, and may have problems
-* for other specific cases as well.
-*/
-export declare function shrink(el: HTMLElement): Promise<void>;