vasille 2.3.8 → 3.0.0

package/types/node/node.d.ts

@@ -1,83 +1,17 @@
-import { Reactive, ReactivePrivate } from "../core/core";
+import { Reactive } from "../core/core";
 import { IValue } from "../core/ivalue";
-import type { AppNode } from "./app";
-import { FragmentOptions, TagOptions } from "../functional/options";
-import { AcceptedTagsMap } from "../spec/react";
-/**
- * Represents a Vasille.js node
- * @class FragmentPrivate
- * @extends ReactivePrivate
- */
-export declare class FragmentPrivate extends ReactivePrivate {
-    /**
-     * The app node
-     * @type {AppNode}
-     */
-    app: AppNode;
-    /**
-     * Parent node
-     * @type {Fragment}
-     */
-    parent: Fragment;
-    /**
-     * Next node
-     * @type {?Fragment}
-     */
-    next?: Fragment;
-    /**
-     * Previous node
-     * @type {?Fragment}
-     */
-    prev?: Fragment;
-    constructor();
-    /**
-     * Pre-initializes the base of a fragment
-     * @param app {App} the app node
-     * @param parent {Fragment} the parent node
-     */
-    preinit(app: AppNode, parent: Fragment): void;
-    /**
-     * Unlinks all bindings
-     */
-    $destroy(): void;
-}
+import { AttrType, TagOptions } from "../functional/options";
 /**
  * This class is symbolic
  * @extends Reactive
  */
-export declare class Fragment<T extends FragmentOptions = FragmentOptions> extends Reactive {
-    /**
-     * Private part
-     * @protected
-     */
-    protected $: FragmentPrivate;
+export declare abstract class Root<T extends object = object> extends Reactive<T> {
     /**
      * The children list
      * @type Array
      */
     children: Set<Fragment>;
-    lastChild: Fragment | null;
-    /**
-     * Constructs a Vasille Node
-     * @param input
-     * @param $ {FragmentPrivate}
-     */
-    constructor(input: T, $?: FragmentPrivate);
-    /**
-     * Gets the app of node
-     */
-    get app(): AppNode;
-    /**
-     * Prepare to init fragment
-     * @param app {AppNode} app of node
-     * @param parent {Fragment} parent of node
-     * @param data {*} additional data
-     */
-    preinit(app: AppNode, parent: Fragment, data?: unknown): void;
-    init(): T['return'];
-    protected compose(input: T): T['return'];
-    /** To be overloaded: ready event handler */
-    ready(): void;
+    lastChild: Fragment | undefined;
     /**
      * Pushes a node to children immediately
      * @param node {Fragment} A node to push
@@ -85,58 +19,53 @@ export declare class Fragment<T extends FragmentOptions = FragmentOptions> exten
      */
     protected pushNode(node: Fragment): void;
     /**
-     * Find first node in element if so exists
+     * Find the first node in the element if so exists
      * @return {?Element}
      * @protected
      */
-    protected findFirstChild(): Node;
+    protected findFirstChild(): Node | undefined;
     /**
      * Append a node to end of element
      * @param node {Node} node to insert
      */
-    appendNode(node: Node): void;
-    /**
-     * Insert a node as a sibling of this
-     * @param node {Node} node to insert
-     */
-    insertAdjacent(node: Node): void;
+    abstract appendNode(node: Node): void;
     /**
      * Defines a text fragment
      * @param text {String | IValue} A text fragment string
      * @param cb {function (TextNode)} Callback if previous is slot name
      */
-    text(text: string | IValue<string>, cb?: (text: TextNode) => void): void;
-    debug(text: IValue<string>): void;
+    text(text: unknown): void;
+    debug(text: IValue<unknown>): void;
     /**
      * Defines a tag element
      * @param tagName {String} the tag name
      * @param input
      * @param cb {function(Tag, *)} callback
      */
-    tag<K extends keyof AcceptedTagsMap>(tagName: K, input: TagOptionsWithSlot<K>, cb?: (node: Tag<K>) => void): (HTMLElementTagNameMap & SVGElementTagNameMap)[K];
+    tag(tagName: string, input: TagOptionsWithSlot, cb?: (ctx: Tag) => void): void;
     /**
      * Defines a custom element
      * @param node {Fragment} vasille element to insert
      * @param callback {function($ : *)}
      */
-    create<T extends Fragment>(node: T, callback?: T['input']['slot']): T['input']['return'];
+    create<T extends Fragment>(node: T, callback?: (ctx: T) => void): void;
     /**
      * Defines an if node
      * @param cond {IValue} condition
      * @param cb {function(Fragment)} callback to run on true
      * @return {this}
      */
-    if(cond: IValue<boolean>, cb: (node: Fragment) => void): void;
+    if(cond: IValue<unknown>, cb: (node: Fragment) => void): void;
     else(cb: (node: Fragment) => void): void;
-    elif(cond: IValue<boolean>, cb: (node: Fragment) => void): void;
+    elif(cond: IValue<unknown>, cb: (node: Fragment) => void): void;
     /**
      * Create a case for switch
      * @param cond {IValue<boolean>}
      * @param cb {function(Fragment) : void}
      * @return {{cond : IValue, cb : (function(Fragment) : void)}}
      */
-    case(cond: IValue<boolean>, cb: (node: Fragment) => void): {
-        cond: IValue<boolean>;
+    case(cond: IValue<unknown>, cb: (node: Fragment) => void): {
+        cond: IValue<unknown>;
         cb: (node: Fragment) => void;
     };
     /**
@@ -147,230 +76,203 @@ export declare class Fragment<T extends FragmentOptions = FragmentOptions> exten
         cond: IValue<boolean>;
         cb: (node: Fragment) => void;
     };
-    insertBefore(node: Fragment): void;
-    insertAfter(node: Fragment): void;
-    remove(): void;
-    $destroy(): void;
+    destroy(): void;
 }
-/**
- * The private part of a text node
- * @class TextNodePrivate
- * @extends FragmentPrivate
- */
-export declare class TextNodePrivate extends FragmentPrivate {
-    node: Text;
-    constructor();
+export declare class Fragment<T extends object = object> extends Root<T> {
+    readonly name?: string;
+    parent: Root;
+    constructor(input: T, name?: string);
     /**
-     * Pre-initializes a text node
-     * @param app {AppNode} the app node
-     * @param parent
-     * @param text {IValue}
+     * Next node
+     * @type {?Fragment}
      */
-    preinitText(app: AppNode, parent: Fragment, text: IValue<string> | string): void;
+    protected next?: Fragment;
     /**
-     * Clear node data
+     * Previous node
+     * @type {?Fragment}
      */
-    $destroy(): void;
+    protected prev?: Fragment;
+    /**
+     * Pushes a node to children immediately
+     * @param node {Fragment} A node to push
+     * @protected
+     */
+    protected pushNode(node: Fragment): void;
+    /**
+     * Append a node to end of element
+     * @param node {Node} node to insert
+     */
+    appendNode(node: Node): void;
+    /**
+     * Insert a node as a sibling of this
+     * @param node {Node} node to insert
+     */
+    insertAdjacent(node: Node): void;
+    compose(): void;
+    insertBefore(node: Fragment): void;
+    insertAfter(node: Fragment): void;
+    remove(): void;
+    destroy(): void;
+}
+interface TextProps {
+    text: unknown;
 }
 /**
  * Represents a text node
  * @class TextNode
  * @extends Fragment
  */
-export declare class TextNode extends Fragment {
-    protected $: TextNodePrivate;
-    constructor($?: TextNodePrivate);
-    preinit(app: AppNode, parent: Fragment, text?: IValue<string> | string): void;
+export declare class TextNode extends Fragment<TextProps> {
+    private node;
+    constructor(input: TextProps);
+    compose(): void;
     protected findFirstChild(): Node;
-    $destroy(): void;
+    destroy(): void;
 }
 /**
- * The private part of a base node
- * @class INodePrivate
- * @extends FragmentPrivate
+ * Vasille node which can manipulate an element node
+ * @class INode
+ * @extends Fragment
  */
-export declare class INodePrivate extends FragmentPrivate {
+export declare class INode<T extends TagOptions = TagOptions> extends Fragment<T> {
     /**
      * Defines if node is unmounted
      * @type {boolean}
      */
-    unmounted: boolean;
+    protected unmounted: boolean;
     /**
      * The element of vasille node
      * @type Element
      */
-    node: Element;
-    constructor();
-    $destroy(): void;
-}
-/**
- * Vasille node which can manipulate an element node
- * @class INode
- * @extends Fragment
- */
-export declare class INode<T extends TagOptions<any> = TagOptions<any>> extends Fragment<T> {
-    protected $: INodePrivate;
-    /**
-     * Constructs a base node
-     * @param input
-     * @param $ {?INodePrivate}
-     */
-    constructor(input: T, $?: INodePrivate);
-    /**
-     * Get the bound node
-     */
-    get node(): Element;
+    protected node: Element;
+    get element(): Element;
     /**
      * Bind attribute value
      * @param name {String} name of attribute
      * @param value {IValue} value
      */
-    attr(name: string, value: IValue<string | number | boolean>): void;
+    attr(name: string, value: IValue<string | number | boolean | null | undefined>): void;
     /**
      * Set attribute value
      * @param name {string} name of attribute
      * @param value {string} value
      */
-    setAttr(name: string, value: string | number | boolean): this;
+    setAttr(name: string, value: string | number | boolean | null | undefined): this;
     /**
      * Adds a CSS class
      * @param cl {string} Class name
      */
-    addClass(cl: string): this;
+    addClass(cl: string): void;
     /**
      * Adds some CSS classes
-     * @param cls {...string} classes names
+     * @param cl {string} classes names
      */
-    removeClasse(cl: string): this;
+    removeClass(cl: string): void;
     /**
      * Bind a CSS class
      * @param className {IValue}
      */
-    bindClass(className: IValue<string>): this;
+    bindClass(className: IValue<string>): void;
     /**
      * Bind a floating class name
      * @param cond {IValue} condition
      * @param className {string} class name
      */
-    floatingClass(cond: IValue<boolean>, className: string): this;
+    floatingClass(cond: IValue<boolean>, className: string): void;
     /**
      * Defines a style attribute
      * @param name {String} name of style attribute
      * @param value {IValue} value
      */
-    style(name: string, value: IValue<string>): this;
+    style(name: string, value: IValue<string | number | number[]>): void;
     /**
      * Sets a style property value
      * @param prop {string} Property name
      * @param value {string} Property value
      */
-    setStyle(prop: string, value: string): this;
+    setStyle(prop: string, value: string | number | number[]): this;
     /**
      * Add a listener for an event
      * @param name {string} Event name
      * @param handler {function (Event)} Event handler
      * @param options {Object | boolean} addEventListener options
      */
-    listen(name: string, handler: (ev: Event) => void, options?: boolean | AddEventListenerOptions): this;
+    listen(name: string, handler: (ev: Event) => void, options?: boolean | AddEventListenerOptions): void;
     insertAdjacent(node: Node): void;
     /**
      * A v-show & ngShow alternative
      * @param cond {IValue} show condition
      */
-    bindShow(cond: IValue<boolean>): this;
+    bindShow(cond: IValue<unknown>): void;
     /**
      * bind HTML
      * @param value {IValue}
      */
     bindDomApi(name: string, value: IValue<string>): void;
+    protected applyAttrs(attrs: Record<string, AttrType<number | boolean>>): void;
+    protected applyStyle(style: Record<string, string | number | number[] | IValue<string | number | number[]>>): void;
+    protected applyBind(bind: Record<string, any>): void;
     protected applyOptions(options: T): void;
 }
-export interface TagOptionsWithSlot<K extends keyof AcceptedTagsMap> extends TagOptions<K> {
-    slot?: (tag: Tag<K>) => void;
+export interface TagOptionsWithSlot extends TagOptions {
+    slot?: (ctx: Tag) => void;
+    callback?: (node: Element) => void;
 }
 /**
  * Represents an Vasille.js HTML element node
  * @class Tag
  * @extends INode
  */
-export declare class Tag<K extends keyof AcceptedTagsMap> extends INode<TagOptionsWithSlot<K>> {
-    constructor(input: TagOptionsWithSlot<K>);
-    preinit(app: AppNode, parent: Fragment, tagName?: string): void;
-    protected compose(input: TagOptionsWithSlot<K>): TagOptionsWithSlot<K>['return'];
-    protected findFirstChild(): Node;
+export declare class Tag extends INode<TagOptionsWithSlot> {
+    constructor(input: TagOptionsWithSlot, tagName: string);
+    compose(): void;
+    protected findFirstChild(): Node | undefined;
     insertAdjacent(node: Node): void;
     appendNode(node: Node): void;
+    extent(options: TagOptions): void;
     /**
      * Mount/Unmount a node
      * @param cond {IValue} show condition
      */
-    bindMount(cond: IValue<boolean>): void;
+    bindMount(cond: IValue<unknown>): void;
     /**
      * Runs GC
      */
-    $destroy(): void;
+    destroy(): void;
 }
 /**
  * Represents a vasille extension node
  * @class Extension
  * @extends INode
  */
-export declare class Extension<T extends TagOptions<any> = TagOptions<any>> extends INode<T> {
-    preinit(app: AppNode, parent: Fragment): void;
-    extend(options: T): void;
-    $destroy(): void;
+export declare class Extension extends Fragment {
+    tag(tagName: string, input: TagOptionsWithSlot): void;
 }
 /**
- * Node which cas has just a child
- * @class Component
- * @extends Extension
+ * Defines a node which can switch its children conditionally
  */
-export declare class Component<T extends TagOptions<any>> extends Extension<T> {
-    init(): T['return'];
-    ready(): void;
-    preinit(app: AppNode, parent: Fragment): void;
-}
-/**
- * Private part of switch node
- * @class SwitchedNodePrivate
- * @extends INodePrivate
- */
-export declare class SwitchedNodePrivate extends FragmentPrivate {
+export declare class SwitchedNode extends Fragment {
     /**
      * Index of current true condition
      * @type number
      */
-    index: number;
+    private index;
     /**
      * Array of possible cases
-     * @type {Array<{cond : IValue<boolean>, cb : function(Fragment)}>}
+     * @type {Array<{cond : IValue<unknown>, cb : function(Fragment)}>}
      */
-    cases: {
-        cond: IValue<boolean>;
-        cb: (node: Fragment) => void;
-    }[];
+    private cases;
     /**
-     * A function which sync index and content, will be bounded to each condition
+     * A function that syncs index and content will be bounded to each condition
      * @type {Function}
      */
-    sync: () => void;
-    constructor();
-    /**
-     * Runs GC
-     */
-    $destroy(): void;
-}
-/**
- * Defines a node witch can switch its children conditionally
- */
-export declare class SwitchedNode extends Fragment {
-    protected $: SwitchedNodePrivate;
+    private sync;
     /**
      * Constructs a switch node and define a sync function
      */
     constructor();
     addCase(case_: {
-        cond: IValue<boolean>;
+        cond: IValue<unknown>;
         cb: (node: Fragment) => void;
     }): void;
     /**
@@ -378,42 +280,23 @@ export declare class SwitchedNode extends Fragment {
      * @param cb {function(Fragment)} Call-back
      */
     createChild(cb: (node: Fragment) => void): void;
-    ready(): void;
-    $destroy(): void;
+    destroy(): void;
 }
-/**
- * The private part of a text node
- */
-export declare class DebugPrivate extends FragmentPrivate {
-    node: Comment;
-    constructor();
-    /**
-     * Pre-initializes a text node
-     * @param app {App} the app node
-     * @param parent {Fragment} parent node
-     * @param text {String | IValue}
-     */
-    preinitComment(app: AppNode, parent: Fragment, text: IValue<string>): void;
-    /**
-     * Clear node data
-     */
-    $destroy(): void;
+interface DebugProps {
+    text: IValue<unknown>;
 }
 /**
  * Represents a debug node
  * @class DebugNode
  * @extends Fragment
  */
-export declare class DebugNode extends Fragment {
-    /**
-     * private data
-     * @type {DebugNode}
-     */
-    protected $: DebugPrivate;
-    constructor();
-    preinit(app: AppNode, parent: Fragment, text?: IValue<string>): void;
+export declare class DebugNode extends Fragment<DebugProps> {
+    private node;
+    constructor(input: DebugProps);
+    compose(): void;
     /**
      * Runs garbage collector
      */
-    $destroy(): void;
+    destroy(): void;
 }
+export {};

package/types/node/watch.d.ts

@@ -1,9 +1,8 @@
 import { Fragment } from "./node";
 import { IValue } from "../core/ivalue";
-import { FragmentOptions } from "../functional/options";
-interface WatchOptions<T> extends FragmentOptions {
+interface WatchOptions<T> {
     model: IValue<T>;
-    slot?: (node: Fragment, value: T) => void;
+    slot?: (ctx: Fragment, value: T) => void;
 }
 /**
  * Watch Node
@@ -11,7 +10,7 @@ interface WatchOptions<T> extends FragmentOptions {
  * @extends Fragment
  */
 export declare class Watch<T> extends Fragment<WatchOptions<T>> {
-    input: WatchOptions<T>;
-    compose(input: WatchOptions<T>): WatchOptions<T>['return'];
+    constructor(input: WatchOptions<T>);
+    compose(): void;
 }
 export {};