jaxs 0.4.0 → 0.4.3

package/dist/jaxs.d.ts

@@ -13,112 +13,229 @@ declare module "state/equality" {
     export const areEqual: (oldValue: any, newValue: any) => any;
 }
 declare module "state/store-updater" {
-    import type { JaxsStore, JaxsStoreUpdateValue, JaxsStoreUpdaterFunction, JaxStoreUpdatersCollection } from "state/store";
-    export class JaxsStoreUpdater<T> {
-        store: JaxsStore<T>;
-        constructor(store: JaxsStore<T>);
-        update(updater: JaxsStoreUpdateValue<T>): void;
+    import type { Store, StoreUpdaterOrValue, StoreUpdaterFunction, StoreUpdatersCollection } from "types";
+    export class StoreUpdaterBase<T> {
+        store: Store<T>;
+        constructor(store: Store<T>);
+        update(updater: StoreUpdaterOrValue<T>): void;
         reset(): void;
         get value(): T;
-        addUpdaterFunction(name: string, updater: JaxsStoreUpdaterFunction<T>): void;
-        addUpdaterFunctions(updaters: JaxStoreUpdatersCollection<T>): void;
+        addUpdaterFunction(name: string, updater: StoreUpdaterFunction<T>): void;
+        addUpdaterFunctions(updaters: StoreUpdatersCollection<T>): void;
     }
 }
 declare module "state/updaters/list" {
-    import { JaxsStoreUpdater } from "state/store-updater";
-    export type JaxsStoreListSorter<T> = (left: T, right: T) => number;
-    export class ListUpdater<T> extends JaxsStoreUpdater<T[]> {
+    import { StoreListSorterFunction, StoreUpdaterFunction } from "types";
+    import { StoreUpdaterBase } from "state/store-updater";
+    export class StoreUpdaterList<T> extends StoreUpdaterBase<T[]> {
+        addUpdaterFunction(name: string, updater: StoreUpdaterFunction<T[]>): void;
         push(element: T): void;
         pop(): T;
         unshift(element: T): void;
         shift(): T;
-        addSorter(name: string, sorter: JaxsStoreListSorter<T>): void;
-        sortBy(sorter: JaxsStoreListSorter<T>): void;
+        addSorter(name: string, sorter: StoreListSorterFunction<T>): void;
+        sortBy(sorter: StoreListSorterFunction<T>): void;
         insertAt(index: number, item: T): void;
     }
 }
 declare module "state/store" {
-    import type { JaxsState, JaxsStoreName } from "state/index";
-    import { JaxsStoreUpdater } from "state/store-updater";
-    import { JaxsStoreListSorter } from "state/updaters/list";
-    type JaxsStoreInitializationOptions<T> = {
-        name: JaxsStoreName;
-        parent: JaxsState;
-        value: T;
-    };
-    type JaxsStoreDataUpdater<T> = (originalValue: T) => T;
-    export type JaxsStoreUpdateValue<T> = T | JaxsStoreDataUpdater<T>;
-    export type JaxsStoreUpdaterFunction<T> = (value: T, ...args: any[]) => T;
-    export type JaxStoreUpdatersCollection<T> = Record<string, JaxsStoreUpdaterFunction<T>>;
-    export class JaxsStore<T> {
-        parent: JaxsState;
-        name: JaxsStoreName;
-        updater: JaxsStoreUpdater<T>;
+    import type { State, StoreDataUpdater, StoreInitializationOptions, StoreListSorterFunction, StoreUpdaterFunction, StoreUpdaterOrValue, StoreUpdatersCollection, StoreUpdater } from "types";
+    export class Store<T> {
+        parent: State;
+        name: string;
+        updater: StoreUpdater<T>;
         _value: T;
         initialState: T;
-        constructor(options: JaxsStoreInitializationOptions<T>);
+        constructor(options: StoreInitializationOptions<T>);
         get ['value'](): T;
         set ['value'](value: T);
-        update(updater: JaxsStoreUpdateValue<T>): void;
+        update(updater: StoreUpdaterOrValue<T>): void;
         updateValue(newValue: T): void;
-        getUpdatedValue(updater: JaxsStoreDataUpdater<T>): T;
-        addUpdaters(updaters: JaxStoreUpdatersCollection<T>): void;
-        addUpdater(name: string, updater: JaxsStoreUpdaterFunction<T>): void;
-        addSorter(name: string, sorter: JaxsStoreListSorter<T>): void;
+        getUpdatedValue(updater: StoreDataUpdater<T>): T;
+        addUpdaters(updaters: StoreUpdatersCollection<any>): void;
+        addUpdater(name: string, updater: StoreUpdaterFunction<any>): void;
+        addSorter(name: string, sorter: StoreListSorterFunction<T>): void;
     }
 }
 declare module "state/updaters/boolean" {
-    import { JaxsStoreUpdater } from "state/store-updater";
-    export class BooleanUpdater extends JaxsStoreUpdater<boolean> {
+    import { StoreUpdaterFunction } from "types";
+    import { StoreUpdaterBase } from "state/store-updater";
+    export class StoreUpdaterBoolean extends StoreUpdaterBase<boolean> {
         toggle(): void;
         setTrue(): void;
         setFalse(): void;
+        addUpdaterFunction(name: string, updater: StoreUpdaterFunction<boolean>): void;
     }
 }
 declare module "state/updaters/object" {
-    import { JaxsStoreUpdater } from "state/store-updater";
-    export class ObjectUpdater<T> extends JaxsStoreUpdater<T> {
+    import { StoreUpdaterFunction } from "types";
+    import { StoreUpdaterBase } from "state/store-updater";
+    export class StoreUpdaterObject<T> extends StoreUpdaterBase<T> {
+        addUpdaterFunction(name: string, updater: StoreUpdaterFunction<T>): void;
         updateAttribute(name: keyof T, value: T[keyof T]): void;
     }
 }
 declare module "state/index" {
-    import { JaxsStore } from "state/store";
-    import { BooleanUpdater } from "state/updaters/boolean";
-    import { ListUpdater } from "state/updaters/list";
-    import { ObjectUpdater } from "state/updaters/object";
-    import type { StoreValue } from "types";
-    export { JaxsStoreUpdater } from "state/store-updater";
-    export type JaxsStatePublisher = (event: string, payload: any) => void;
-    export type JaxsStateTransactionUpdater = (collection: JaxsStoresCollection) => void;
-    export type JaxsStoreName = string;
-    type JaxsStoresCollection = Record<string, JaxsStore<any>>;
+    import { Store } from "state/store";
+    import { StoreUpdaterBoolean } from "state/updaters/boolean";
+    import { StoreUpdaterList } from "state/updaters/list";
+    import { StoreUpdaterObject } from "state/updaters/object";
+    import type { StatePublisher, StateTransactionUpdater, StoresCollection, StoreValue } from "types";
     export const eventName = "state";
-    export class JaxsState {
-        publisher: JaxsStatePublisher;
-        stores: JaxsStoresCollection;
+    export class State {
+        publisher: StatePublisher;
+        stores: StoresCollection;
         eventNamePrefix: string;
-        notifications: Set<JaxsStoreName>;
+        notifications: Set<string>;
         inTransaction: boolean;
-        constructor(publisher: JaxsStatePublisher);
-        create<T>(name: JaxsStoreName, initialState: T): JaxsStore<T>;
-        createBoolean(name: JaxsStoreName, initialState: boolean): JaxsStore<boolean>;
-        createRecord<T>(name: JaxsStoreName, initialState: T): JaxsStore<T>;
-        createList<T>(name: JaxsStoreName, initialState: T[]): JaxsStore<T[]>;
-        store(name: JaxsStoreName): JaxsStore<any>;
-        get(name: JaxsStoreName): StoreValue;
-        getAll(names: JaxsStoreName[]): {};
-        notify(name: JaxsStoreName): void;
-        update(name: JaxsStoreName, newValue: any): void;
-        transaction(updater: JaxsStateTransactionUpdater): void;
+        constructor(publisher: StatePublisher);
+        create<T>(name: string, initialState: T): Store<T>;
+        createBoolean(name: string, initialState: boolean): Store<boolean>;
+        createRecord<T>(name: string, initialState: T): Store<T>;
+        createList<T>(name: string, initialState: T[]): Store<T[]>;
+        store(name: string): Store<any>;
+        get(name: string): StoreValue;
+        getAll(names: string[]): {};
+        notify(name: string): void;
+        update(name: string, newValue: any): void;
+        transaction(updater: StateTransactionUpdater): void;
         publishAll(): void;
-        publish(name: JaxsStoreName): void;
-        event(name: JaxsStoreName): string;
+        publish(name: string): void;
+        event(name: string): string;
+    }
+    export const createState: (publisher: StatePublisher) => State;
+    export { Store, StoreUpdaterBoolean, StoreUpdaterList, StoreUpdaterObject };
+}
+declare module "bus/exact-subscriptions" {
+    import { ExactSubscriptionData, BusListener, Unsubscribe } from "types";
+    export class ExactSubscriptions {
+        lookup: Record<string, ExactSubscriptionData<any>[]>;
+        constructor();
+        add<T>(matcher: string, listener: BusListener<T>, index: number): Unsubscribe;
+        remove<T>(subscription: ExactSubscriptionData<T>): void;
+        matches(event: string): ExactSubscriptionData<any>[];
+        ensureArrayFor(matcher: string): void;
+    }
+}
+declare module "bus/fuzzy-subscriptions" {
+    import { FuzzySubscriptionData, BusListener, Unsubscribe } from "types";
+    export class FuzzySubscriptions {
+        lookup: FuzzySubscriptionData<any>[];
+        constructor();
+        add<T>(matcher: RegExp, listener: BusListener<T>, index: number): Unsubscribe;
+        remove<T>(subscription: FuzzySubscriptionData<T>): void;
+        matches(event: string): FuzzySubscriptionData<any>[];
+    }
+}
+declare module "bus/index" {
+    import { BusEventMatcher, BusListener, Unsubscribe, AppAdditionListenerOptions, BusOptions } from "types";
+    import { ExactSubscriptions } from "bus/exact-subscriptions";
+    import { FuzzySubscriptions } from "bus/fuzzy-subscriptions";
+    class JaxsBus {
+        options?: AppAdditionListenerOptions;
+        exactSubscriptions: ExactSubscriptions;
+        fuzzySubscriptions: FuzzySubscriptions;
+        currentIndex: number;
+        constructor();
+        subscribe<T>(matcher: BusEventMatcher, listener: BusListener<T>): Unsubscribe;
+        publish<T>(event: string, payload: T): void;
+        addListenerOptions(options: AppAdditionListenerOptions): void;
+        listenerOptions(event: string): BusOptions;
+    }
+    const createBus: () => {
+        bus: JaxsBus;
+        publish: (event: string, payload: any) => void;
+        subscribe: (matcher: BusEventMatcher, listener: BusListener<any>) => Unsubscribe;
+    };
+    export { createBus, JaxsBus, ExactSubscriptions, FuzzySubscriptions };
+}
+declare module "rendering/templates/root" {
+    import type { JaxsElement, JaxsNodes, RenderKit, Renderable, JaxsNode } from "types";
+    export class Root {
+        template: Renderable;
+        selector: string;
+        renderKit: RenderKit;
+        dom: JaxsNodes;
+        parentElement?: JaxsElement | null;
+        constructor(template: Renderable, selector: string, renderKit: RenderKit);
+        renderAndAttach(renderKit: RenderKit): void;
+        render(renderKit: RenderKit): JaxsNode[];
+        attach(): void;
+        getParentElement(): Element;
+    }
+    export const render: (template: Renderable, selector: string, renderKit: RenderKit) => Root;
+}
+declare module "navigation/events" {
+    export const linkNavigationEvent = "go-to-href";
+    export const locationChangeEvent = "navigation:location-change";
+    export const routeChangeEvent = "navigation:route-change";
+}
+declare module "navigation/route-state" {
+    import { State } from "state/index";
+    export const createRouteState: (state: State) => void;
+}
+declare module "navigation/find-href" {
+    export const findHref: (node: HTMLElement) => string;
+}
+declare module "navigation/navigate" {
+    import { BusOptions } from "types";
+    export const navigate: (path: string, { publish, window }: BusOptions) => void;
+}
+declare module "navigation/on-link-click" {
+    import { BusOptions } from "types";
+    export const onLinkClick: (domEvent: MouseEvent, options: BusOptions) => void;
+}
+declare module "navigation/extract-query-params" {
+    export const extractQueryParams: (queryString: string) => {};
+}
+declare module "navigation/on-location-change" {
+    import { BusOptions } from "types";
+    export const onLocationChange: (_: null, listenerOptions: BusOptions) => void;
+}
+declare module "navigation/start" {
+    import type { App } from "app/index";
+    export const subscribeToNavigation: (app: App) => void;
+    export const subscribeToHistoryChange: (app: App) => void;
+    export const publishLocation: (app: App) => void;
+    export const startNavigation: (app: App) => void;
+}
+declare module "app/index" {
+    import type { Renderable, RenderKit, Subscribe, PublishFunction } from "types";
+    import type { State } from "state/index";
+    import type { JaxsBus } from "bus/index";
+    import { Root } from "rendering/templates/root";
+    export class App {
+        window: Window;
+        document: Document;
+        publish: PublishFunction<any>;
+        subscribe: Subscribe;
+        bus: JaxsBus;
+        state: State;
+        renderKit: RenderKit;
+        roots: Root[];
+        constructor({ window, document, publish, subscribe, bus, state, renderKit }: {
+            window: any;
+            document: any;
+            publish: any;
+            subscribe: any;
+            bus: any;
+            state: any;
+            renderKit: any;
+        });
+        render(template: Renderable, selector: string): Root;
+        startNavigation(): void;
     }
-    export const createState: (publisher: JaxsStatePublisher) => JaxsState;
-    export { JaxsStore, BooleanUpdater, ListUpdater, ObjectUpdater };
 }
 declare module "types" {
-    import { JaxsState } from "state/index";
+    import type { State } from "state/index";
+    import type { Store } from "state/store";
+    import type { StoreUpdaterBase } from "state/store-updater";
+    import type { StoreUpdaterBoolean } from "state/updaters/boolean";
+    import type { StoreUpdaterList } from "state/updaters/list";
+    import type { StoreUpdaterObject } from "state/updaters/object";
+    export type { App } from "app/index";
+    export { State, Store, StoreUpdaterBase, StoreUpdaterBoolean, StoreUpdaterList, StoreUpdaterObject, };
+    export type StoreUpdater<T> = StoreUpdaterBase<T> | StoreUpdaterObject<T> | StoreUpdaterBoolean | StoreUpdaterList<T>;
     export type TextValue = string | number;
     export interface JsxIded {
         __jsx?: string;
@@ -132,9 +249,9 @@ declare module "types" {
         busEvent: string;
         listener: EventListener;
     };
-    export type TagEventMaps = Record<string, EventMap>;
+    export type EventMaps = Record<string, EventMap>;
     interface JsxEventMapped {
-        eventMaps: TagEventMaps;
+        eventMaps: EventMaps;
     }
     export type JaxsElement = Element & JsxIded & JsxEventMapped;
     export type JaxsText = Text & JsxIded;
@@ -163,22 +280,21 @@ declare module "types" {
         events: TagEventAttributes;
     };
     export type DomPublish = (eventName: string, domEvent: Event) => void;
-    export type Subscribe = (matcher: JaxsBusEventMatcher, listener: JaxsBusListener<any>) => void;
+    export type Subscribe = (matcher: BusEventMatcher, listener: BusListener<any>) => void;
     export type RenderKit = {
         document: Document;
         window: Window;
         publish: DomPublish;
         subscribe: Subscribe;
-        state: JaxsState;
+        state: State;
         parent?: JaxsNode | null;
     };
     export interface Renderable {
         render: (renderKit: RenderKit, parentElement?: JaxsElement) => JaxsNode[];
-        isSvg: boolean;
     }
     export type StaticTemplate = () => Renderable;
     export type TypedTemplate<T> = (props: Props<T>) => Renderable;
-    export type JaxsTemplate<T> = StaticTemplate | TypedTemplate<T>;
+    export type Template<T> = StaticTemplate | TypedTemplate<T>;
     export type JsxCollection = (Renderable | TextValue)[];
     export enum ChangeInstructionTypes {
         removeNode = 0,
@@ -215,8 +331,8 @@ declare module "types" {
         parent: JaxsElement;
         index: number;
     };
-    type NullData = Record<string, never>;
-    export type InstructionData = RemoveInstructionData | AttributeInstructionData | EventInstructionData | UpdateEventInstructionData | InsertNodeData | NullData;
+    type NullInstructionData = Record<string, never>;
+    export type InstructionData = RemoveInstructionData | AttributeInstructionData | EventInstructionData | UpdateEventInstructionData | InsertNodeData | NullInstructionData;
     export type ChangeInstruction = {
         source: JaxsNode;
         target: JaxsNode;
@@ -224,44 +340,75 @@ declare module "types" {
         data: InstructionData;
     };
     export type ChangeInstructions = Array<ChangeInstruction>;
-    export type Updater = (instruction: ChangeInstruction) => void;
+    export type InstructionsUpdater = (instruction: ChangeInstruction) => void;
     export type StoreValue = string | number | boolean | null | StoreValue[] | {
         [key: string]: StoreValue;
     };
     export type StoreMap = {
         [key: string]: StoreValue;
     };
-    export type JaxsViewModel<ATTRIBUTES, STORE_MAP> = (storeMap: STORE_MAP) => Partial<ATTRIBUTES>;
+    export type ViewModel<ATTRIBUTES, STORE_MAP> = (storeMap: STORE_MAP) => Partial<ATTRIBUTES>;
     export type BindSubscriptionList = string[];
     export type BindParams<T, U> = {
-        Template: JaxsTemplate<T>;
-        viewModel?: JaxsViewModel<T, U>;
+        Template: Template<T>;
+        viewModel?: ViewModel<T, U>;
         subscriptions?: BindSubscriptionList;
     };
     export type AppAdditionListenerOptions = {
-        state: JaxsState;
+        state: State;
         document: Document;
         window: Window;
     };
     export type DefaultBusListenerOptions<T> = {
-        publish: JaxsPublishFunction<T>;
+        publish: PublishFunction<T>;
         eventName: string;
     };
-    export type JaxsBusOptions = AppAdditionListenerOptions & DefaultBusListenerOptions<any>;
-    export type JaxsPublishFunction<T> = (event: string, payload: T) => void;
-    export type JaxsBusListener<T> = (payload: T, listenerKit: JaxsBusOptions) => void;
-    export type JaxsBusEventMatcher = string | RegExp;
+    export type BusOptions = AppAdditionListenerOptions & DefaultBusListenerOptions<any>;
+    export type PublishFunction<T> = (event: string, payload: T) => void;
+    export type BusListener<T> = (payload: T, listenerKit: BusOptions) => void;
+    export type BusEventMatcher = string | RegExp;
     export type ExactSubscriptionData<T> = {
-        listener: JaxsBusListener<T>;
+        listener: BusListener<T>;
         index: number;
         matcher: string;
     };
     export type FuzzySubscriptionData<T> = {
-        listener: JaxsBusListener<T>;
+        listener: BusListener<T>;
         index: number;
         matcher: RegExp;
     };
     export type Unsubscribe = () => void;
+    export type CreateAppBuilderArguments = {
+        window?: Window;
+        document?: Document;
+    };
+    export type RouteState = {
+        host: string;
+        path: string;
+        query: Record<string, string>;
+    };
+    export type AttributesWithChildren<T> = Props<T> & {
+        children?: JsxCollection;
+    };
+    export type DiffPair = {
+        source: JaxsNode;
+        target: JaxsNode;
+    };
+    export type CompileChildren = (sourceList: JaxsNodes, targetList: JaxsNodes, parent: JaxsElement) => ChangeInstructions;
+    export type StatePublisher = (event: string, payload: any) => void;
+    export type StateTransactionUpdater = (collection: StoresCollection) => void;
+    export type StoresCollection = Record<string, Store<any>>;
+    export type StoreInitializationOptions<T> = {
+        name: string;
+        parent: State;
+        value: T;
+    };
+    export type StoreDataUpdater<T> = (originalValue: T) => T;
+    export type UpdaterValue<T> = boolean | T | T[];
+    export type StoreUpdaterOrValue<T> = UpdaterValue<T> | StoreDataUpdater<T>;
+    export type StoreUpdaterFunction<T> = (value: UpdaterValue<T>, ...args: any[]) => T;
+    export type StoreUpdatersCollection<T> = Record<string, StoreUpdaterFunction<T>>;
+    export type StoreListSorterFunction<T> = (left: T, right: T) => number;
 }
 declare module "rendering/dom/tag" {
     import type { JaxsElement, TagAttributes, TagEventAttributes, DomPublish, RenderKit } from "types";
@@ -273,7 +420,7 @@ declare module "rendering/dom/tag" {
 declare module "rendering/dom/svg" {
     import type { TagAttributes, JaxsElement } from "types";
     export const namespace = "http://www.w3.org/2000/svg";
-    export const isSvgTag: (tagType: string) => tagType is "svg";
+    export const isSvgTag: (tagType: string, attributeNamespace?: string) => boolean;
     export const createSvgNode: (type: string, attributes: TagAttributes, document: Document) => JaxsElement;
     export const elementIsSvg: (element: JaxsElement) => boolean;
 }
@@ -284,7 +431,6 @@ declare module "rendering/templates/text" {
     import { Renderable, TextValue, RenderKit } from "types";
     export class TextTemplate implements Renderable {
         value: string;
-        isSvg: boolean;
         constructor(content: TextValue);
         render(renderKit: RenderKit): Text[];
     }
@@ -296,17 +442,10 @@ declare module "rendering/templates/children/text" {
     export const textNode: (content: TextValue) => TextTemplate;
     export const replaceTextNodes: (child: TextValue | Renderable) => Renderable | TextTemplate;
 }
-declare module "rendering/templates/children/svg" {
-    import { Renderable } from "types";
-    export const withSvgFlag: (isSvg: boolean) => (template: Renderable) => Renderable;
-}
 declare module "rendering/templates/children/normalize" {
-    import { JsxCollection, Renderable, Props } from "types";
-    export const normalizeJsxChildren: (jsxChildren: JsxCollection, isSvg: boolean) => Renderable[];
+    import { JsxCollection, AttributesWithChildren } from "types";
+    export const normalizeJsxChildren: (jsxChildren: JsxCollection) => (import("types").Renderable | import("rendering/templates/text").TextTemplate)[];
     export const normalizeToArray: <T>(children: T | T[]) => T[];
-    type AttributesWithChildren<T> = Props<T> & {
-        children?: JsxCollection;
-    };
     export const ensureJsxChildrenArray: <T>(maybeChildren?: JsxCollection, attributes?: AttributesWithChildren<T>) => JsxCollection;
 }
 declare module "rendering/templates/tag/attributes-and-events" {
@@ -323,8 +462,7 @@ declare module "rendering/templates/children" {
     export class Children implements Renderable {
         collection: Renderable[];
         parentElement?: JaxsElement;
-        isSvg: boolean;
-        constructor(jsxChildren: JsxCollection, isSvg?: boolean);
+        constructor(jsxChildren: JsxCollection);
         render(renderKit: RenderKit, parentElement: JaxsElement | undefined): JaxsNode[];
         generateDom(renderKit: RenderKit): JaxsNode[];
         attachToParent(dom: JaxsNodes): void;
@@ -351,7 +489,7 @@ declare module "rendering/templates/tag" {
         props: Props<T>;
         children: Children;
         isSvg: boolean;
-        constructor(tagType: string, props: Props<T>, children?: JsxCollection, isSvg?: boolean);
+        constructor(tagType: string, props: Props<T>, children?: JsxCollection);
         render(renderKit: RenderKit): JaxsNode[];
         generateDom(renderKit: RenderKit): import("types").JaxsElement;
         generateHtmlDom(renderKit: RenderKit): import("types").JaxsElement;
@@ -360,155 +498,26 @@ declare module "rendering/templates/tag" {
     }
 }
 declare module "rendering/jsx" {
-    import type { JsxCollection, Props, JaxsTemplate, Renderable } from "types";
+    import type { JsxCollection, Props, Template, Renderable } from "types";
     import { Children } from "rendering/templates/children";
     const jsx: {
-        <T>(type: string | JaxsTemplate<T>, attributes: Props<T>, ...children: JsxCollection): Renderable;
+        <T>(type: string | Template<T>, attributes: Props<T>, ...children: JsxCollection): Renderable;
         fragment<T>(attributes: Props<T>, maybeChildren: JsxCollection): Children;
     };
     export { jsx };
 }
-declare module "bus/exact-subscriptions" {
-    import { ExactSubscriptionData, JaxsBusListener, Unsubscribe } from "types";
-    export class ExactSubscriptions {
-        lookup: Record<string, ExactSubscriptionData<any>[]>;
-        constructor();
-        add<T>(matcher: string, listener: JaxsBusListener<T>, index: number): Unsubscribe;
-        remove<T>(subscription: ExactSubscriptionData<T>): void;
-        matches(event: string): ExactSubscriptionData<any>[];
-        ensureArrayFor(matcher: string): void;
-    }
-}
-declare module "bus/fuzzy-subscriptions" {
-    import { FuzzySubscriptionData, JaxsBusListener, Unsubscribe } from "types";
-    export class FuzzySubscriptions {
-        lookup: FuzzySubscriptionData<any>[];
-        constructor();
-        add<T>(matcher: RegExp, listener: JaxsBusListener<T>, index: number): Unsubscribe;
-        remove<T>(subscription: FuzzySubscriptionData<T>): void;
-        matches(event: string): FuzzySubscriptionData<any>[];
-    }
-}
-declare module "bus/index" {
-    import { JaxsBusEventMatcher, JaxsBusListener, Unsubscribe, AppAdditionListenerOptions, JaxsBusOptions } from "types";
-    import { ExactSubscriptions } from "bus/exact-subscriptions";
-    import { FuzzySubscriptions } from "bus/fuzzy-subscriptions";
-    class JaxsBus {
-        options?: AppAdditionListenerOptions;
-        exactSubscriptions: ExactSubscriptions;
-        fuzzySubscriptions: FuzzySubscriptions;
-        currentIndex: number;
-        constructor();
-        subscribe<T>(matcher: JaxsBusEventMatcher, listener: JaxsBusListener<T>): Unsubscribe;
-        publish<T>(event: string, payload: T): void;
-        addListenerOptions(options: AppAdditionListenerOptions): void;
-        listenerOptions(event: string): JaxsBusOptions;
-    }
-    const createBus: () => {
-        bus: JaxsBus;
-        publish: (event: string, payload: any) => void;
-        subscribe: (matcher: JaxsBusEventMatcher, listener: JaxsBusListener<any>) => Unsubscribe;
-    };
-    export { createBus, JaxsBus, ExactSubscriptions, FuzzySubscriptions };
-}
-declare module "rendering/templates/root" {
-    import type { JaxsElement, JaxsNodes, RenderKit, Renderable, JaxsNode } from "types";
-    export class Root {
-        template: Renderable;
-        selector: string;
-        renderKit: RenderKit;
-        dom: JaxsNodes;
-        parentElement?: JaxsElement | null;
-        constructor(template: Renderable, selector: string, renderKit: RenderKit);
-        renderAndAttach(renderKit: RenderKit): void;
-        render(renderKit: RenderKit): JaxsNode[];
-        attach(): void;
-        getParentElement(): Element;
-    }
-    export const render: (template: Renderable, selector: string, renderKit: RenderKit) => Root;
-}
-declare module "navigation/events" {
-    export const linkNavigationEvent = "go-to-href";
-    export const locationChangeEvent = "navigation:location-change";
-    export const routeChangeEvent = "navigation:route-change";
-}
-declare module "navigation/route-state" {
-    import { JaxsState } from "state/index";
-    export type RouteState = {
-        host: string;
-        path: string;
-        query: Record<string, string>;
-    };
-    export const createRouteState: (state: JaxsState) => void;
-}
-declare module "navigation/find-href" {
-    export const findHref: (node: HTMLElement) => string;
-}
-declare module "navigation/navigate" {
-    import { JaxsBusOptions } from "types";
-    export const navigate: (path: string, { publish, window }: JaxsBusOptions) => void;
-}
-declare module "navigation/on-link-click" {
-    import { JaxsBusOptions } from "types";
-    export const onLinkClick: (domEvent: MouseEvent, options: JaxsBusOptions) => void;
-}
-declare module "navigation/extract-query-params" {
-    export const extractQueryParams: (queryString: string) => {};
-}
-declare module "navigation/on-location-change" {
-    import { JaxsBusOptions } from "types";
-    export const onLocationChange: (_: null, listenerOptions: JaxsBusOptions) => void;
-}
-declare module "navigation/start" {
-    import type { App } from "app/index";
-    export const subscribeToNavigation: (app: App) => void;
-    export const subscribeToHistoryChange: (app: App) => void;
-    export const publishLocation: (app: App) => void;
-    export const startNavigation: (app: App) => void;
-}
-declare module "app/index" {
-    import type { Renderable, RenderKit, Subscribe, JaxsPublishFunction } from "types";
-    import type { JaxsState } from "state/index";
-    import type { JaxsBus } from "bus/index";
-    import { Root } from "rendering/templates/root";
-    export class App {
-        window: Window;
-        document: Document;
-        publish: JaxsPublishFunction<any>;
-        subscribe: Subscribe;
-        bus: JaxsBus;
-        state: JaxsState;
-        renderKit: RenderKit;
-        roots: Root[];
-        constructor({ window, document, publish, subscribe, bus, state, renderKit }: {
-            window: any;
-            document: any;
-            publish: any;
-            subscribe: any;
-            bus: any;
-            state: any;
-            renderKit: any;
-        });
-        render(template: Renderable, selector: string): Root;
-        startNavigation(): void;
-    }
-}
 declare module "app/builder" {
     import { App } from "app/index";
     import { JaxsBus } from "bus/index";
-    import { JaxsState } from "state/index";
-    import { JaxsPublishFunction, Subscribe, RenderKit } from "types";
-    type CreateAppBuilderArguments = {
-        window?: Window;
-        document?: Document;
-    };
+    import { State } from "state/index";
+    import { PublishFunction, Subscribe, RenderKit, CreateAppBuilderArguments } from "types";
     class AppBuilder {
         window: Window;
         document: Document;
-        publish: JaxsPublishFunction<any>;
+        publish: PublishFunction<any>;
         subscribe: Subscribe;
         bus: JaxsBus;
-        state: JaxsState;
+        state: State;
         renderKit: RenderKit;
         constructor(domEnvironment: CreateAppBuilderArguments);
         setup(): App;
@@ -574,8 +583,7 @@ declare module "rendering/update/instructions/nodes/text" {
     export const compileForText: (source: Text, target: Text) => ChangeInstructions;
 }
 declare module "rendering/update/instructions/node" {
-    import type { JaxsElement, JaxsNode, JaxsNodes, ChangeInstructions } from "types";
-    type CompileChildren = (sourceList: JaxsNodes, targetList: JaxsNodes, parent: JaxsElement) => ChangeInstructions;
+    import type { JaxsNode, ChangeInstructions, CompileChildren } from "types";
     export const compileForNode: (source: JaxsNode, target: JaxsNode, compileChildren: CompileChildren) => ChangeInstructions;
 }
 declare module "rendering/update/instructions/collection" {
@@ -587,10 +595,10 @@ declare module "rendering/update/perform-change" {
     export const performChange: (source: JaxsNodes, target: JaxsNodes, parent: JaxsElement) => void;
 }
 declare module "rendering/templates/bound" {
-    import { JaxsElement, JaxsNodes, Props, JaxsTemplate, RenderKit, JaxsViewModel, BindParams, BindSubscriptionList } from "types";
+    import { JaxsElement, JaxsNodes, Props, Template, RenderKit, ViewModel, BindParams, BindSubscriptionList } from "types";
     export class Bound<ATTRIBUTES, STATE_MAP> {
-        Template: JaxsTemplate<ATTRIBUTES>;
-        viewModel: JaxsViewModel<ATTRIBUTES, STATE_MAP>;
+        Template: Template<ATTRIBUTES>;
+        viewModel: ViewModel<ATTRIBUTES, STATE_MAP>;
         attributes: Partial<Props<ATTRIBUTES>>;
         subscriptions: BindSubscriptionList;
         dom: JaxsNodes;
@@ -619,7 +627,6 @@ declare module "navigation/index" {
     import { onLocationChange } from "navigation/on-location-change";
     import { createRouteState } from "navigation/route-state";
     import * as start from "navigation/start";
-    export type { RouteState } from "navigation/route-state";
     export { events, extractQueryParams, findHref, navigate, onLinkClick, onLocationChange, createRouteState, start, };
 }
 declare module "jaxs" {