vasille-web 4.3.2 → 5.0.1

package/README.md

@@ -1,19 +1,32 @@
-# Vasille
+# Steel Frame
 
-![Vasille.js logo](https://raw.githubusercontent.com/vasille-js/vasille-js/refs/heads/v4/doc/img/logo.png)
+![Vasille.js logo](https://raw.githubusercontent.com/vasille-js/vasille-js/refs/heads/v5/doc/img/logo.png)
 
-`Vasille Web` is a front-end framework, which is developed to provide bulletproof frontends.
+`SteelFrameKit` is a front-end development kit, which is developed to provide fault tolerant web applications.
 
-[![npm](https://img.shields.io/npm/v/vasille?style=flat-square)](https://www.npmjs.com/package/vasille)
+[![npm](https://img.shields.io/npm/v/steel-frame?style=flat-square)](https://www.npmjs.com/package/steel-frame)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/vasille-js/steel-frame)
+[![Coverage Status](https://coveralls.io/repos/github/vasille-js/steel-frame/badge.svg?branch=v5)](https://coveralls.io/github/vasille-js/steel-frame?branch=v5)
 
 ## Table of content
 
-* [Installation](#installation)
-* [How to use Vasille](#how-to-use-vasille)
-* [How SAFE is Vasille](#how-safe-is-vasille)
-* [How INTUITIVE is Vasille](#how-intuitive-is-vasille)
-* [How POWERFUL is Vasille](#how-powerful-is-vasille)
-* [Road Map](#road-map)
+- [Steel Frame](#steel-frame)
+  - [Table of content](#table-of-content)
+  - [Installation](#installation)
+  - [How to use SteelFramekit](#how-to-use-steelframekit)
+    - [Full documentation:](#full-documentation)
+    - [Examples](#examples)
+  - [How SAFE is SteelFrameKit](#how-safe-is-steelframekit)
+  - [How INTUITIVE is SteelFrameKit](#how-intuitive-is-steelframekit)
+  - [How POWERFUL is SteelFrameKit](#how-powerful-is-steelframekit)
+  - [Road map](#road-map)
+  - [Change log](#change-log)
+    - [5.0](#50)
+    - [4.0 - 4.3](#40---43)
+    - [3.0 - 3.2](#30---32)
+    - [2.0 - 2.3](#20---23)
+    - [1.0 - 1.2](#10---12)
+  - [Questions](#questions)
 
 
 <hr>
@@ -21,21 +34,22 @@
 ## Installation
 
 ```
-npm install vasille-web --save
+npm install steel-frame --save
 ```
 
-## How to use Vasille
+## How to use SteelFramekit
 
 Create an app from a template
 
 ```bash
-$ npm create vasille
+$ npm create steel-frame
 ```
 
 ### Full documentation:
-* [Learn `Vasille` in 5 minutes](https://github.com/vasille-js/vasille-js/blob/v4/doc/V4-API.md)
-* [Vasille Router Documentation](https://github.com/vasille-js/vasille-js/blob/v4/doc/Router-API.md)
-* [Vasille Compostion function](https://github.com/vasille-js/vasille-js/blob/v4/doc/Compositions.md)
+* [Learn `SteelFrameKit` in 5 minutes](https://github.com/vasille-js/vasille-js/blob/v5/doc/V4-API.md)
+* [Router Documentation](https://github.com/vasille-js/vasille-js/blob/v5/doc/Router-API.md)
+* [Compostion functions](https://github.com/vasille-js/vasille-js/blob/v5/doc/Compositions.md)
+* [Dependency injection](https://github.com/vasille-js/vasille-js/blob/v5/doc/Context.md)
 
 ### Examples
 * [TypeScript Example](https://github.com/vasille-js/example-typescript)
@@ -43,14 +57,14 @@ $ npm create vasille
 
 <hr>
 
-## How SAFE is Vasille
+## How SAFE is SteelFrameKit
 
 The safe of your application is ensured by
 * `100%` coverage of code by unit tests.
   Each function, each branch is working as designed.
 * OOP, DRY, KISS and SOLID principles are applied.
 * `strong typing` makes your javascript/typescript code safe as C++ code.
-All entities of `vasille` core library are strongly typed, including:
+All entities of `SteelFrameKit` core library are strongly typed, including:
   * data fields & properties.
   * computed properties (function parameters and result).
   * methods.
@@ -60,11 +74,11 @@ All entities of `vasille` core library are strongly typed, including:
   * references to children.
 * No asynchronous code, when the line of code is executed, the DOM and reactive things are already synced.
 
-## How INTUITIVE is Vasille
+## How INTUITIVE is SteelFrameKit
 
 There is the "Hello World":
 ```typescript jsx
-import { compose, mount } from "vasille-dx";
+import { compose, mount } from "steel-frame";
 
 const App = compose(() => {
   <p>Hello world</p>;
@@ -73,60 +87,76 @@ const App = compose(() => {
 mount(document.body, App, {});
 ```
 
-## How POWERFUL is Vasille
+## How POWERFUL is SteelFrameKit
 
 All of these are supported:
 * Components.
 * Reactive values (observables).
 * Inline computed values.
 * Multiline computed values.
-* HTML & SVG tags.
+* HTML tags.
 * Component custom slots.
 * 2-way data binding in components.
 * Logic block (if, else).
 * Loops (array, map, set).
+* Dependency injection.
 
 <hr>
 
 ## Road map
 
-* [x] Update the `Vasille Core` library to version 3.0.
 * [x] `100%` Test Coverage for core Library v3.
-* [x] Develop the `Vasille JSX` library.
+* [x] Develop the `JSX` library.
 * [x] `100%` Test Coverage for the JSX library.
-* [x] Develop the `Vasille Babel Plugin`.
+* [x] Develop the `Babel Plugin`.
 * [x] `100%` Test Coverage fot babel plugin.
 * [x] Add CSS support (define styles in components).
 * [x] Add router.
 * [x] Add SSG (static site generation).
+* [ ] Develop tools extension for debugging (WIP).
 * [ ] Add SSR (server side rendering).
-* [ ] Develop tools extension for debugging.
 
 ## Change log
 
-### 4.3.0
+We respect semantic versioning:
+- Major version is increased when we make incompatible API changes.
+- Minor version is increased when we add functionality.
+- Patch version is increased when we fix bugs.
 
-Add new function `safe` which make functions safe, errors are reported automatically.
+### 5.0
 
-### 4.2.0
+- Add support for context and dependencies injection.
+- New developement direction: `fault tolerant`.
+- Renamed to `steel-frame`. **[API change]**
+- Removed `forward` and `backward` functions. **[API change]**
+- Removed `Debug` component. **[API change]**
 
-Add support for inlined conditions in JSX, binary `&&` and ternary `?:` operator.
+### 4.0 - 4.3
 
-### 4.1.0
+- Initial version of the framework with file based routing and building scripts (`web dev` and `web build spa`).
+- Reactive values naming switched to `$` prefix. **[API change]**
+- `4.1` Added SSG (static site generation) as build option `web build static`.
+- `4.2` Add support for inlined conditions in JSX, binary `&&` and ternary `?:` operator.
+- `4.3` Add new function `safe` which make functions safe, errors are reported automatically.
 
-Added SSG (static site generation) as build option `vasille-web build static`.
+### 3.0 - 3.2
 
-### 4.0.0
+- Switch to a babel plugin to compile components code. **[API change]**
+- 100% of code has been covered with unit tests.
+- New developement direction: `keep it simple`.
 
-Initial version of the framework with file based routing and building scripts (`vasille-web dev` and `vasille-web build spa`).
+### 2.0 - 2.3
+
+- Introduces components compilation via a typescript plugin. **[API change]**
+- New developement direction: `write less, do more`.
+
+### 1.0 - 1.2
+
+- Initial version of core library.
+- Developemnt direction: `performance-first`.
 
 ## Questions
 
 If you have questions, feel free to contact the maintainer of the project:
 
 * [Author's Email](mailto:vas.lixcode@gmail.com)
-* [Author's Telegram](https://t.me/lixcode)
-
-<hr>
-
-**Made in Moldova** 🇲🇩

package/lib/index.js

@@ -1,25 +1,25 @@
 import { Portal, reportError } from "vasille";
 import { Runner } from "vasille/web-runner";
 import { mount as coreMount } from "vasille-jsx";
-import { styleSheet as coreStyleSheet } from "vasille-css";
 import { routeApp as coreRouteApp } from "vasille-router/web-router";
+export { styleSheet } from "vasille-css";
 export { safe } from "vasille";
-export { view, view as component, view as compose, forward, backward, ensure, ref, expr, expr as bind, expr as calculate, expr as watch, set, Debug, Delay, For, Slot, Watch, awaited, store, model, setModel, mapModel, arrayModel, Switch, setErrorHandler, match, extract, } from "vasille-jsx";
+export { view, view as component, view as compose, ensure, ref, expr, expr as bind, expr as calculate, expr as watch, set, Delay, For, Slot, Watch, awaited, store, model, setModel, mapModel, arrayModel, Switch, setErrorHandler, match, } from "vasille-jsx";
 export { screen, screen as page, } from "vasille-router";
-export { Router, routeApp } from "vasille-router/web-router";
+export { Router } from "vasille-router/web-router";
 export { setMobileMaxWidth, setTabletMaxWidth, setLaptopMaxWidth } from "vasille-css";
-export const styleSheet = coreStyleSheet;
+export { context, impute, receive, share } from "vasille-context";
 function createPortal(node) {
     const portal = new Portal({ node: document.body }, node.runner);
     node.create(portal);
     return portal;
 }
-export function modal(modal) {
+export function modal(modal, create = createPortal) {
     return function (props, node) {
         if (!node) {
             throw new Error("Vasille: Modal context is missing");
         }
-        const portal = createPortal(node);
+        const portal = create(node);
         try {
             modal(portal, props);
         }
@@ -28,10 +28,10 @@ export function modal(modal) {
         }
     };
 }
-export function prompt(modal) {
+export function prompt(modal, create = createPortal) {
     return function (node, input, timeout) {
         return new Promise((resolve, reject) => {
-            const portal = createPortal(node);
+            const portal = create(node);
             const timer = timeout &&
                 setTimeout(() => {
                     destroy();
@@ -61,9 +61,9 @@ export function prompt(modal) {
         });
     };
 }
-export function mount(element, component, input, debugUi) {
-    return coreMount(element, component, new Runner(debugUi ?? false, window.document), input);
+export function mount(element, component, input) {
+    return coreMount(element, component, new Runner(window.document), input);
 }
-export function routerApp(init, element, debugUi) {
-    return coreRouteApp(element ?? document.body, window, window.location, init, debugUi);
+export function routerApp(init, element) {
+    return coreRouteApp(element ?? document.body, window, window.location, init);
 }

package/package.json

@@ -1,15 +1,12 @@
 {
   "name": "vasille-web",
-  "version": "4.3.2",
+  "version": "5.0.1",
   "description": "The same framework which is designed to build bulletproof frontends.",
   "main": "index.js",
   "types": "./index.d.ts",
-  "bin": {
-    "vasille-web": "./lib/bin.js"
-  },
   "exports": {
     ".": {
-      "types": "./fake-types/index.d.ts",
+      "types": "./types/index.d.ts",
       "import": "./lib/index.js",
       "browser": "./lib/index.js",
       "node": "./lib/index.js"
@@ -19,13 +16,19 @@
       "import": "./lib/jsx-runtime.js",
       "browser": "./lib/jsx-runtime.js",
       "node": "./lib/jsx-runtime.js"
+    },
+    "./dev": {
+      "types": "./types/dev.d.ts",
+      "import": "./lib/dev.js",
+      "browser": "./lib/dev.js",
+      "node": "./lib/dev.js"
     }
   },
   "scripts": {
     "prepack": "cp -f ../README.md ./README.md",
-    "prettier": "prettier src fake-types --write",
-    "build": "tsc --build tsconfig.json",
-    "check-types": "tsc --noEmit --lib es2020 --types web --moduleResolution Node16 --module Node16 ./fake-types/index.d.ts"
+    "prettier": "prettier src --write",
+    "prebuild": "rm -rf lib types",
+    "build": "tsc --build tsconfig.json"
   },
   "type": "module",
   "repository": {
@@ -47,10 +50,11 @@
   "homepage": "https://github.com/vasille-js/vasille-js#readme",
   "dependencies": {
     "csstype": "^3.1.3",
-    "vasille": "^4.3.1",
-    "vasille-css": "^4.1.0",
-    "vasille-jsx": "^4.3.4",
-    "vasille-router": "^4.0.0"
+    "vasille": "^5.0.0",
+    "vasille-context": "^5.0.0",
+    "vasille-css": "^5.0.0",
+    "vasille-jsx": "^5.0.0",
+    "vasille-router": "^5.0.0"
   },
   "devDependencies": {
     "@types/node": "^24.3.0",

package/types/dev.d.ts

@@ -3,7 +3,7 @@ import { TagOptions } from "vasille/web-runner";
 import { IDevRunner, Inspector, StaticPosition } from "vasille/dev";
 import { PromptProps } from "./index.js";
 import { WebRouterInitialization } from "vasille-router/web-router";
-export declare function devModal<T extends object>(modalFn: (node: Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>, input: T) => void, declaration: StaticPosition, name: string): (input: T, node: Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>, usage: StaticPosition | undefined) => void;
+export declare function devModal<T extends object>(modalFn: (node: Fragment<Node, Element, TagOptions>, input: T) => void, declaration: StaticPosition, name: string): (input: T, node: Fragment<Node, Element, TagOptions>, usage: StaticPosition | undefined) => void;
 export declare function devPrompt<T extends PromptProps>(modal: (node: Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>, input: T) => void, declaration: StaticPosition, name: string): (node: Fragment<Node, Element, TagOptions, IDevRunner<Node, Element, TagOptions>>, input: T, timeout: number | undefined, usage: StaticPosition | undefined) => Promise<unknown>;
 export declare function devMount<T>(element: Element, component: ($: T) => void, input: T, inspector: Inspector): import("vasille").App<Node, Element, import("vasille/dev").DevTagOptions, import("vasille").Runner<Node, Element, import("vasille/dev").DevTagOptions>>;
 export declare function devRouterApp<Routes extends string>(init: WebRouterInitialization<Routes>, element: Element, inspector: Inspector): import("vasille").App<Node, Element, import("vasille/dev").DevTagOptions, import("vasille").Runner<Node, Element, import("vasille/dev").DevTagOptions>>;

package/types/index.d.ts

@@ -1,27 +1,20 @@
-import { Fragment } from "vasille";
-import { StyleProps } from "../spec/css.js";
+import { App, Fragment, Portal } from "vasille";
 import { TagOptions } from "vasille/web-runner";
 import { WebRouterInitialization } from "vasille-router/web-router";
-export type { RawStyleProps as StyleProps } from "../spec/css.js";
+export { styleSheet } from "vasille-css";
+export type { RawStyleProps as StyleProps, StyleSheetProps } from "./spec/css.js";
 export type { ClassItem } from "./jsx-runtime.js";
 export { safe } from "vasille";
-export { view, view as component, view as compose, forward, backward, ensure, ref, expr, expr as bind, expr as calculate, expr as watch, set, Debug, Delay, For, Slot, Watch, awaited, store, model, setModel, mapModel, arrayModel, Switch, setErrorHandler, match, extract, } from "vasille-jsx";
+export { view, view as component, view as compose, ensure, ref, expr, expr as bind, expr as calculate, expr as watch, set, Delay, For, Slot, Watch, awaited, store, model, setModel, mapModel, arrayModel, Switch, setErrorHandler, match, } from "vasille-jsx";
 export { type QueryParams, type ScreenProps, type RouteParameters, screen, screen as page, type FallbackScreenProps, type ErrorScreenProps, } from "vasille-router";
-export { Router, type WebRouterInitialization, type NavigationMode, routeApp } from "vasille-router/web-router";
+export { Router, type WebRouterInitialization, type NavigationMode } from "vasille-router/web-router";
 export { setMobileMaxWidth, setTabletMaxWidth, setLaptopMaxWidth } from "vasille-css";
-export declare const styleSheet: <T extends {
-    [className: string]: {
-        [media: `@${string}`]: {
-            [state: `:${string}`]: StyleProps;
-        } & StyleProps;
-        [state: `:${string}`]: StyleProps;
-    } & StyleProps;
-}>(input: T) => { [K in keyof T]: string; };
-export declare function modal<T extends object>(modal: (node: Fragment<Node, Element, TagOptions>, input: T) => void): (input: T, node: Fragment<Node, Element, TagOptions>) => void;
+export { context, impute, receive, share } from "vasille-context";
+export declare function modal<T extends object>(modal: (node: Fragment<Node, Element, TagOptions>, input: T) => void, create?: (node: Fragment<Node, Element, TagOptions>) => Portal<Node, Element, TagOptions>): (input: T, node: Fragment<Node, Element, TagOptions>) => void;
 export interface PromptProps {
     resolve(data: unknown): void;
     reject(err: unknown): void;
 }
-export declare function prompt<T extends PromptProps>(modal: (node: Fragment<Node, Element, TagOptions>, input: T) => void): (node: Fragment<Node, Element, TagOptions>, input: T, timeout?: number) => Promise<unknown>;
-export declare function mount<T>(element: Element, component: ($: T) => void, input: T, debugUi?: boolean): import("vasille").App<Node, Element, TagOptions, object>;
-export declare function routerApp<Routes extends string>(init: WebRouterInitialization<Routes>, element?: Element, debugUi?: boolean): import("vasille").App<Node, Element, TagOptions, object>;
+export declare function prompt<T extends PromptProps>(modal: (node: Fragment<Node, Element, TagOptions>, input: T) => void, create?: (node: Fragment<Node, Element, TagOptions>) => Portal<Node, Element, TagOptions>): (node: Fragment<Node, Element, TagOptions>, input: T, timeout?: number) => Promise<unknown>;
+export declare function mount<T>(element: Element, component: ($: T) => void, input: T): App<Node, Element, TagOptions>;
+export declare function routerApp<Routes extends string>(init: WebRouterInitialization<Routes>, element?: Element): App<Node, Element, TagOptions>;

package/types/jsx-runtime.d.ts

@@ -1,9 +1,10 @@
-import type { RawStyleProps } from "../spec/css.d.ts";
-import type { HtmlTagMap } from "../spec/html.d.ts";
-type prefixedObject<T, P extends string> = {
+import type { RawStyleProps } from "./spec/css.ts";
+import type { HtmlTagMap } from "./spec/html.ts";
+export type { TagEvents, TagAttrs, TagProps } from "./spec/html.ts";
+export type prefixedObject<T, P extends string> = {
     [K in keyof T as K extends string ? `${P}${K}` : never]?: T[K];
 };
-type EventHandlers<T> = {
+export type EventHandlers<T> = {
     [K in keyof T]: T[K] | [T[K], boolean | AddEventListenerOptions];
 };
 export type ClassItem = string | Record<string, boolean> | false;
@@ -21,7 +22,7 @@ export declare namespace JSX {
         slot: unknown;
     }
     interface IntrinsicElements {
-        a2: HtmlInput<"a">;
+        a: HtmlInput<"a">;
         abbr: HtmlInput<"abbr">;
         address: HtmlInput<"address">;
         area: HtmlInput<"area">;
@@ -133,4 +134,3 @@ export declare namespace JSX {
         wbr: HtmlInput<"wbr">;
     }
 }
-export {};

package/types/spec/html.d.ts

@@ -4,10 +4,10 @@ export interface Tag<Attrs, Events, Props> {
     events: Events;
     props: Props;
 }
-type TagEvents<Target> = {
+export type TagEvents<Target> = {
     [K in keyof HTMLElementEventMap]: EventHandler<HTMLElementEventMap[K], Target> | undefined;
 };
-interface TagAttrs {
+export interface TagAttrs {
     id: string;
     accesskey: string;
     autocapitalize: "off" | "none" | "on" | "sentences" | "words" | "characters";
@@ -27,6 +27,8 @@ interface TagAttrs {
     itemtype: string;
     lang: string;
     nonce: string;
+    part: string;
+    slot: string;
     spellcheck: "true" | "false" | "" | boolean;
     tabindex: number;
     title: string;
@@ -97,6 +99,7 @@ interface AAttrs extends TagAttrs {
     hreflang: string;
     type: string;
     referrerpolicy: string;
+    rel: string;
 }
 interface QAttrs extends TagAttrs {
     cite: string;
@@ -520,7 +523,7 @@ export interface TagEventsProps<T extends Element> {
     onwaiting?: ((this: T, ev: Event) => any) | null;
     onwheel?: ((this: T, ev: WheelEvent) => any) | null;
 }
-interface TagProps<T extends Element> extends TagEventsProps<T> {
+export interface TagProps<T extends Element> extends TagEventsProps<T> {
     autofocus?: boolean;
     className?: string;
     nonce?: string | undefined;

package/fake-types/index.d.ts

@@ -1,213 +0,0 @@
-import { App, Destroyable } from "vasille";
-import type { TagOptions } from "vasille/web-runner";
-import type { StyleProps } from "../spec/css.d.ts";
-import type { ScreenProps } from "vasille-router";
-import type { Router } from "vasille-router/web-router";
-
-export type { RawStyleProps as StyleProps } from "../spec/css.d.ts";
-export type ClassItem = string | Record<string, boolean> | false;
-export type { FallbackScreenProps, ErrorScreenProps } from "vasille-router";
-export { safe } from "vasille";
-
-/** Set a handler for component errors */
-export declare function setErrorHandler(handler: (e: unknown) => void): void;
-
-declare interface Params {
-    slot(...args: unknown[]): unknown;
-}
-
-declare type Composed<In extends object, Out> = (
-    $: (Required<In> extends Params ? Omit<In, "slot"> & { slot?: unknown } : In) & {
-        callback?(data: Out): void;
-    },
-) => void;
-declare type ComposedNoCallback<In extends object, Out> = (
-    $: Required<In> extends Params ? Omit<In, "slot"> & { slot?: unknown } : In,
-) => void;
-
-/** Composes a component (v3), which can receive external reactive values via props */
-export declare function compose<In extends object, Out extends NonNullable<unknown>>(
-    renderer: (input: In) => Out,
-): Composed<In, Out>;
-export declare function compose<In extends object>(renderer: (input: In) => void): ComposedNoCallback<In, void>;
-
-/** Composes a component (v4), which can receive external reactive values via props */
-export declare function component<In extends object, Out extends NonNullable<unknown>>(
-    renderer: (input: In) => Out,
-): Composed<In, Out>;
-export declare function component<In extends object>(renderer: (input: In) => void): ComposedNoCallback<In, void>;
-
-/** Composes a view, which can receive external reactive values via props */
-export declare function view<Out extends NonNullable<unknown>>(
-    renderer: () => Out,
-): Composed<NonNullable<unknown>, Out>;
-export declare function view<In extends object, Out extends NonNullable<unknown>>(
-    renderer: (input: In) => Out,
-): Composed<In, Out>;
-export declare function view(renderer: () => void): ComposedNoCallback<NonNullable<unknown>, void>;
-export declare function view<In extends object>(renderer: (input: In) => void): ComposedNoCallback<In, void>;
-
-/** A Vasille.JS App screen */
-type Screen<Route extends string> = (input: ScreenProps<Route>) => Promise<void>;
-
-/** Composes a screen, the router navigates between screens */
-export declare function screen<Route extends string>(renderer: Screen<Route>): Screen<Route>;
-/** Composes a page, the file-based router navigates between pages (used for tests only) */
-export declare function page<Route extends string>(renderer: Screen<Route>): Screen<Route>;
-
-/** Returns the raw value of expression */
-export declare function raw<T>(v: T): T;
-/** Returns a reactive value of expression */
-export declare function ref<T>(v: T): T;
-/** Returns a reactive-computed form of expression */
-export declare function bind<T>(v: T): T;
-/** Returns a reactive-computed form of returned value */
-export declare function calculate<T>(fn: () => T): T;
-/** Runs the function each time when a dependency is changed */
-export declare function watch(f: () => void): void;
-/** Returns a view-model bind, which send data only forward */
-export declare function forward<T>(v: T): T;
-/** Returns a view-model bind, which send data only backward */
-export declare function backward<T>(v: T): T;
-/** Returns an array model of the array */
-export declare function arrayModel<T>(v?: T[]): T[];
-/** Returns a set model of array values */
-export declare function setModel<T>(v?: T[]): Set<T>;
-/** Returns a map model of map data */
-export declare function mapModel<K, T>(v?: [K, T][]): Map<K, T>;
-
-/** Awaits async data in a sync component */
-export declare function awaited<T>(target: Promise<T>): [unknown, T | undefined, () => void];
-export declare function awaited<T>(target: () => Promise<T>): [unknown, T | undefined, () => void];
-
-/** Mounts a slot parameter of the component */
-export declare function Slot(options: { model?: () => void; slot?: () => void }): void;
-export declare function Slot<Props extends object>(
-    options: {
-        model?: (props: Props) => void;
-        slot?: () => void;
-    } & Props,
-): void;
-
-/** Renders content conditionally */
-export declare function If(props: { $condition: unknown; slot?: unknown }): void;
-
-/** Renders content conditionally, use strict after `<If/>` */
-export declare function ElseIf(props: { $condition: unknown; slot?: unknown }): void;
-
-/** Renders content conditionally, use strict after `<If/>` or `<ElseIf/>` */
-export declare function Else(props: { slot?: unknown }): void;
-
-/** Renders content several times using a model (array, map or set) */
-export declare function For<T>(props: { of: readonly T[]; slot?: (value: T) => void }): void;
-export declare function For<T>(props: { of: ReadonlySet<T>; slot?: (value: T) => void }): void;
-export declare function For<K, T>(props: { of: ReadonlyMap<K, T>; slot?: (value: T, index: K) => void }): void;
-
-/** Refresh the content each time then the reactive model is updated */
-export declare function Watch<T>(props: { $model: T; slot?: (value: T) => void }): void;
-
-/** Create a debug comment in DOM */
-export declare function Debug(props: { $model: unknown }): void;
-
-/** Render content after a while */
-export declare function Delay(props: { time?: number; slot?: unknown }): void;
-
-/** Stores a singleton state to memory */
-export declare function store<Return extends object>(fn: () => Return): Return;
-
-/** Creates a model (state) constructor */
-export declare function model<Return extends object>(fn: () => Return): () => Return & Destroyable;
-export declare function model<Input extends object, Return extends object>(
-    fn: (input: Input) => Return,
-): (input: Input) => Return & Destroyable;
-
-export { QueryParams, ScreenProps, RouteParameters } from "vasille-router";
-export { Router, NavigationMode } from "vasille-router/web-router";
-
-/** Applies the value to theme `name` */
-export declare function theme<T>(name: string, value: T): T;
-/** Applies the value to dark theme */
-export declare function dark<T>($: T): T;
-/** Applies the value to mobile devices */
-export declare function mobile<T>($: T): T;
-/** Applies the value to tablet devices */
-export declare function tablet<T>($: T): T;
-/** Applies the value to laptop devices */
-export declare function laptop<T>($: T): T;
-/** Applies the value when user prefers dark theme */
-export declare function prefersDark<T>($: T): T;
-/** Applies the value when user prefers light theme */
-export declare function prefersLight<T>($: T): T;
-
-export { setMobileMaxWidth, setTabletMaxWidth, setLaptopMaxWidth } from "vasille-css";
-
-/** Creates a local style sheet */
-export declare const styleSheet: <
-    T extends {
-        [className: string]: {
-            [media: `@${string}`]: {
-                [state: `:${string}`]: StyleProps;
-            } & StyleProps;
-            [state: `:${string}`]: StyleProps;
-        } & StyleProps;
-    },
->(
-    input: T,
-) => { [K in keyof T]: string };
-
-/** Mounts a Vasille.JS component to page */
-export declare function mount<T>(
-    element: Element,
-    component: ($: T) => void,
-    $: T,
-    debugUi?: boolean,
-): App<Node, Element, TagOptions>;
-
-interface RouterInitialization<Routes extends string> {
-    routes: {
-        [K in Routes]: {
-            screen: Screen<K>;
-            minAccessLevel?: number;
-        };
-    };
-    getAccessLevel?(): Promise<number>;
-    fallbackScreen?(arg: { cause: "not-found" | "no-access" }): void;
-    errorScreen?(data: { error: unknown }): void;
-    loadingScreen?(props: object): void;
-    loadingOverlay?(props: object): void;
-}
-
-/** Starts a route app */
-export declare function routerApp<Routes extends string>(
-    init: RouterInitialization<Routes>,
-    element?: Element,
-    debugUi?: boolean,
-): App<Node, Element, TagOptions>;
-
-/** Run a function before component mount */
-export declare function beforeMount(fn: () => void): void;
-export declare function beforeMount(fn: () => Promise<void>): void;
-
-/** Run a function after component mount */
-export declare function afterMount(fn: () => void): void;
-export declare function afterMount(fn: () => Promise<void>): void;
-
-/** Run a function before component destroy */
-export declare function beforeDestroy(fn: () => void): void;
-
-/** Returns the current used router */
-export declare function router(): Router<string> | undefined;
-
-/** Composes a modal window (v4+) */
-export declare function modal<T extends object>(modal: (input: T) => void): (input: T) => void;
-
-/** Describes properties of a prompt window */
-export interface PromptProps<T> {
-    resolve(data: T): void;
-    reject(err: unknown): void;
-}
-
-/** Composes a function which will show a prompt on call */
-export declare function prompt<T, Input extends PromptProps<T> = PromptProps<T>>(
-    modal: (input: Input) => void,
-): (input: Omit<Input, keyof PromptProps<unknown>>, timeout?: number) => Promise<T>;