vasille 1.2.9 → 2.0.3

package/types/bind.d.ts

@@ -1,72 +0,0 @@
-/**
- * Bind some values to one expression
- * @implements IBind
- */
-export class Expression extends IBind implements IBind {
-    /**
-     * Creates a function bounded to N value
-     * @param func {Function} The function to bound
-     * @param values {Array<IValue<*>>} Values to bound to
-     * @param link {Boolean} If true links immediately
-     */
-    constructor(func: Function, values: Array<IValue<any>>, link?: boolean);
-    /**
-     * The array of value which will trigger recalculation
-     * @type {Array<IValue<*>>}
-     */
-    values: Array<IValue<any>>;
-    /**
-     * Cache the values of expression variables
-     * @type {Array<*>}
-     * @version 1.1
-     */
-    valuesCache: Array<any>;
-    /**
-     * The function which will be executed on recalculation
-     * @type {Function}
-     */
-    func: Function;
-    /**
-     * Expression will link different handler for each value of list
-     * @type {Array<Function>}
-     * @version 1.1
-     */
-    linkedFunc: Array<Function>;
-    /**
-     * The current linking state
-     * @type {boolean}
-     */
-    linked: boolean;
-    /**
-     * The buffer to keep the last calculated value
-     * @type {Reference<*>}
-     */
-    sync: any;
-}
-/**
- * Describe a common binding logic
- * @implements IValue
- */
-export class Binding extends IValue implements IValue {
-    /**
-     * Constructs a common binding logic
-     * @param rt {INode} Root component
-     * @param ts {INode} This component
-     * @param name {String} Name of property/attribute
-     * @param func {?Function} A function to run on value change
-     * @param values {Array<IValue>} values array to bind
-     */
-    constructor(rt: any, ts: any, name: string, func: Function | null, ...values: Array<IValue>);
-    binding: IValue;
-    func: any;
-    owner: boolean;
-    /**
-     * Is a virtual function to get the specific bind function
-     * @param name {String} The name of attribute/property
-     * @returns {Function} A function to update attribute/property value
-     * @throws Always trows and must be overloaded in child class
-     */
-    bound(name: string): Function;
-}
-import { IBind } from "./interfaces/ibind.js";
-import { IValue } from "./interfaces/ivalue.js";

package/types/class.d.ts

@@ -1,19 +0,0 @@
-/**
- * Creates a class target 1 to 1 bind
- * @param rt {INode} is the root component
- * @param ts {INode} is the this component
- * @param name {String} is attribute name
- * @param value {?any} is attribute value
- * @param func {?Callable} is attribute value calculation function
- * @returns {AttributeBinding} 1 to 1 bind of attribute
- */
-export function classify(rt: any, ts: any, name: string, value?: any | null, func?: Callable | null): any;
-/**
- * Represents a HTML class binding description
- * @extends Binding
- */
-export class ClassBinding extends Binding {
-    current: any;
-}
-import { Callable } from "./interfaces/idefinition.js";
-import { Binding } from "./bind.js";

package/types/data.d.ts

@@ -1,11 +0,0 @@
-/**
- * Constructs a data field value
- * @param rt {BaseNode} Root component
- * @param ts {BaseNode} This component
- * @param value {?*} The default value of field
- * @param func {?Callable} The function to calc filed value
- * @return {Value} A new generated value
- */
-export function datify(rt: BaseNode, ts: BaseNode, value?: any | null, func?: Callable | null): any;
-import { BaseNode } from "./node";
-import { Callable } from "./interfaces/idefinition";

package/types/event.d.ts

@@ -1,10 +0,0 @@
-/**
- * Covert a event function to a Vasille.js value
- * @param rt {BaseNode} is the root component
- * @param ts {BaseNode} is the this component
- * @param name {String} is the event name
- * @param handler {Function} is the handler function
- * @returns {Value} a Vasille.js value
- */
-export function eventify(rt: BaseNode, ts: BaseNode, name: string, handler: Function): any;
-import { BaseNode } from "./node";

package/types/executor.d.ts

@@ -1,57 +0,0 @@
-/**
- * Represents an executor unit interface
- */
-export class Executor {
-    /**
-     * Adds a CSS class
-     * @param el {HTMLElement} HTML element
-     * @param cl {string}
-     */
-    addClass(el: HTMLElement, cl: string): void;
-    /**
-     * Removes a CSS class
-     * @param el {HTMLElement} HTML element
-     * @param cl {string}
-     */
-    removeClass(el: HTMLElement, cl: string): void;
-    /**
-     * Sets a tag attribute
-     * @param el {HTMLElement} HTML element
-     * @param name {string}
-     * @param value {string}
-     */
-    setAttribute(el: HTMLElement, name: string, value: string): void;
-    /**
-     * Removes a tag attribute
-     * @param el {HTMLElement} HTML element
-     * @param name {string}
-     */
-    removeAttribute(el: HTMLElement, name: string): void;
-    /**
-     * Sets a style attribute
-     * @param el {HTMLElement} HTML element
-     * @param prop {string}
-     * @param value {string}
-     */
-    setStyle(el: HTMLElement, prop: string, value: string): void;
-    /**
-     * Inserts a child
-     * @param el {HTMLElement} HTML element
-     * @param child {HTMLElement | Text | Comment} Child to insert
-     * @param before {HTMLElement | Text | Comment} Child used as position locator
-     */
-    insertBefore(el: HTMLElement, child: HTMLElement | Text | Comment, before: HTMLElement | Text | Comment): void;
-    /**
-     * Appends a child
-     * @param el {HTMLElement} HTML element
-     * @param child {HTMLElement | Text | Comment} Child to append
-     */
-    appendChild(el: HTMLElement, child: HTMLElement | Text | Comment): void;
-    /**
-     * Calls a call-back function
-     * @param cb {Function} call-back function
-     */
-    callCallback(cb: Function): void;
-}
-export class InstantExecutor extends Executor {
-}

package/types/interfaces/core.d.ts

@@ -1,129 +0,0 @@
-/**
- * Destroy all destroyable object fields
- * @param obj {Object<any, any>} Object to be iterated
- */
-export function $destroyObject(obj: any): void;
-/**
- * Represents a Vasille.js node
- * @implements Destroyable
- */
-export class VasilleNodePrivate extends Destroyable implements Destroyable {
-    /**
-     * The encapsulated element
-     * @type {HTMLElement | Text | Comment}
-     * @see VasilleNode#coreEl
-     * @see VasilleNode#el
-     * @see VasilleNode#text
-     * @see VasilleNode#comment
-     */
-    $el: HTMLElement | Text | Comment;
-    /**
-     * The collection of attributes
-     * @type {Object<String, IValue>}
-     * @see VasilleNode#attr
-     */
-    $attrs: any;
-    /**
-     * The collection of style attributes
-     * @type {Object<String, IValue>}
-     * @see VasilleNode#style
-     */
-    $style: any;
-    /**
-     * The root node
-     * @type {INode}
-     */
-    root: any;
-    /**
-     * The this node
-     * @type {INode}
-     */
-    ts: any;
-    /**
-     * The app node
-     * @type {VasilleNode}
-     */
-    app: VasilleNode;
-    /**
-     * A link to a parent node
-     * @type {VasilleNode}
-     */
-    parent: VasilleNode;
-    /**
-     * The next node
-     * @type {?VasilleNode}
-     */
-    next: VasilleNode | null;
-    /**
-     * The previous node
-     * @type {?VasilleNode}
-     */
-    prev: VasilleNode | null;
-    /**
-     * Gets the encapsulated element anyway
-     * @type {HTMLElement | Text | Comment}
-     * @see VasilleNode#$el
-     */
-    get coreEl(): HTMLElement | Text | Comment;
-    /**
-     * Gets the encapsulated element if it is a html element, otherwise undefined
-     * @type {HTMLElement}
-     * @see VasilleNode#$el
-     */
-    get el(): HTMLElement;
-    /**
-     * Gets the encapsulated element if it is a html text node, otherwise undefined
-     * @type {Text}
-     * @see VasilleNode#$el
-     */
-    get text(): Text;
-    /**
-     * Gets the encapsulated element if it is a html comment, otherwise undefined
-     * @type {Comment}
-     * @see VasilleNode#$el
-     */
-    get comment(): Comment;
-    /**
-     * Encapsulate element
-     * @param el {HTMLElement | Text | Comment} element to encapsulate
-     * @private
-     */
-    private encapsulate;
-    /**
-     * Pre-initializes the base of a node
-     * @param app {App} the app node
-     * @param rt {INode} The root node
-     * @param ts {INode} The this node
-     * @param before {?VasilleNode} VasilleNode to paste this after
-     */
-    preinit(app: any, rt: any, ts: any, before: VasilleNode | null): void;
-    /**
-     * Gets the component life attribute value
-     * @param field {string} attribute name
-     * @return {IValue}
-     */
-    attr(field: string): IValue;
-    /**
-     * Gets the component life style attribute
-     * @param field {Object<String, IValue>}
-     * @return {IValue<string>}
-     * @see VasilleNode#$style
-     */
-    style(field: any): any;
-}
-/**
- * This class is symbolic
- */
-export class VasilleNode extends Destroyable {
-    /**
-     * Constructs a Vasille Node
-     * @param $ {VasilleNodePrivate}
-     */
-    constructor($: VasilleNodePrivate);
-    /**
-     * @type {VasilleNodePrivate}
-     */
-    $: VasilleNodePrivate;
-}
-import { Destroyable } from "./destroyable.js";
-import { IValue } from "./ivalue.js";

package/types/interfaces/destroyable.d.ts

@@ -1,11 +0,0 @@
-/**
- * Mark an object which can be destroyed
- * @class
- */
-export class Destroyable {
-    seal(): void;
-    /**
-     * Garbage collector method
-     */
-    $destroy(): void;
-}

package/types/interfaces/errors.d.ts

@@ -1,24 +0,0 @@
-/**
- * @return {string}
- */
-export function notOverwritten(): string;
-/**
- * @return {string}
- */
-export function internalError(msg: any): string;
-/**
- * @return {string}
- */
-export function userError(msg: any, err: any): string;
-/**
- * @return {string}
- */
-export function typeError(msg: any): string;
-/**
- * @return {string}
- */
-export function notFound(msg: any): string;
-/**
- * @return {string}
- */
-export function wrongBinding(msg: any): string;

package/types/interfaces/ibind.d.ts

@@ -1,19 +0,0 @@
-/**
- * Mark an object which can be bound
- * @interface
- */
-export class IBind extends IValue {
-    /**
-     * Ensure the binding to be bound
-     * @return a pointer to this
-     * @throws must be overwritten
-     */
-    link(): void;
-    /**
-     * Ensure the binding to be unbound
-     * @return a pointer to this
-     * @throws must be overwritten
-     */
-    unlink(): void;
-}
-import { IValue } from "./ivalue.js";

package/types/interfaces/idefinition.d.ts

@@ -1,29 +0,0 @@
-/**
- * Check the type of value
- * @param v {*} value
- * @param t {Function} type constructor
- * @return {boolean}
- */
-export function checkType(v: any, t: Function): boolean;
-/**
- * Check if a type is a subtype
- * @param parent {Function} potential superclass
- * @param child {Function} potential subclass
- * @return {boolean}
- */
-export function isSubclassOf(parent: Function, child: Function): boolean;
-/**
- * Represent a function encapsulated to a class
- */
-export class Callable {
-    /**
-     * Encapsulates a function
-     * @param func {Function} function to encapsulate
-     */
-    constructor(func: Function);
-    /**
-     * Function which will resolve value
-     * @type {Function}
-     */
-    func: Function;
-}

package/types/interfaces/ivalue.d.ts

@@ -1,40 +0,0 @@
-/**
- * A interface which describes a value
- * @interface
- * @extends Destroyable
- */
-export class IValue extends Destroyable {
-    /**
-     * Used for strong type checking
-     * @type {?Function}
-     */
-    type: Function | null;
-    /**
-     * Sets the encapsulated value
-     * @param value {*} Reference to encapsulate
-     * @return {IValue} A pointer to this
-     * @throws Must be overwritten
-     */
-    set $(arg: any);
-    /**
-     * Gets the encapsulated value
-     * @return {*} Must return a value
-     * @throws Must be overwritten
-     */
-    get $(): any;
-    /**
-     * Add a new handler to value change
-     * @param handler {Function} The handler to add
-     * @return {IValue} a pointer to this
-     * @throws Must be overwritten
-     */
-    on(handler: Function): IValue;
-    /**
-     * Removes a handler of value change
-     * @param handler {Function} the handler to remove
-     * @return {IValue} a pointer to this
-     * @throws Must be overwritten
-     */
-    off(handler: Function): IValue;
-}
-import { Destroyable } from "./destroyable.js";

package/types/models.d.ts

@@ -1,179 +0,0 @@
-/**
- * Transforms a JS value to a Vasille.js value
- * @param v {*} input value
- * @return {IValue} transformed value
- */
-export function vassilify(v: any): IValue;
-/**
- * Model based on Array class
- * @extends Array<IValue>
- */
-export class ArrayModel extends Array<IValue> {
-    /**
-     * Constructs an array model from an array
-     * @param data {Array<IValue>} input data
-     */
-    constructor(data?: Array<IValue>);
-    /**
-     * Listener of array model
-     * @type {Listener}
-     */
-    listener: Listener;
-    /**
-     * Gets the last value of array and null when it is empty
-     * @return {?IValue}
-     */
-    get last(): IValue;
-    /**
-     * Inserts a value to the end of array
-     * @param v {*} value to insert
-     * @return {this} a pointer to this
-     */
-    append(v: any): this;
-    /**
-     * Clears array
-     * @return {this} a pointer to this
-     */
-    clear(): this;
-    /**
-     * Inserts a value to position <i>index</i>
-     * @param index {number} index to insert value
-     * @param v {*} value to insert
-     * @return {this} a pointer to this
-     */
-    insert(index: number, v: any): this;
-    /**
-     * Inserts a value to the beginning of array
-     * @param v {*} value to insert
-     * @return {this} a pointer to this
-     */
-    prepend(v: any): this;
-    /**
-     * Removes a value from an index
-     * @param index {number} index of value to remove
-     * @return {this} a pointer to this
-     */
-    removeAt(index: number): this;
-    /**
-     * Removes the first value of array
-     * @return {this} a pointer to this
-     */
-    removeFirst(): this;
-    /**
-     * Removes the ast value of array
-     * @return {this} a pointer to this
-     */
-    removeLast(): this;
-    /**
-     * Remove the first occurrence of value
-     * @param v {IValue} value to remove
-     * @return {this}
-     */
-    removeOne(v: IValue): this;
-}
-/**
- * A Object based model
- * @extends Object<String, IValue>
- */
-export class ObjectModel {
-    /**
-     * the listener of object
-     * @type {Listener}
-     */
-    listener: Listener;
-    /**
-     * Gets a value of a field
-     * @param key {string}
-     * @return {IValue<*>}
-     */
-    get(key: string): any;
-    /**
-     * Sets a object property value <b>(use for new properties only)</b>
-     * @param key {string} property name
-     * @param v {*} property value
-     * @return {ObjectModel} a pointer to this
-     */
-    set(key: string, v: any): ObjectModel;
-    /**
-     * Deletes a object property
-     * @param key {string} property name
-     */
-    delete(key: string): void;
-}
-/**
- * A Map based memory
- * @extends Map<*, IValue>
- */
-export class MapModel extends Map<any, IValue> {
-    /**
-     * Constructs a map model based on a map
-     * @param map {Map<*, IValue>} input data
-     */
-    constructor(map?: Map<any, IValue>);
-    /**
-     * listener of map
-     * @type {Listener}
-     */
-    listener: Listener;
-}
-/**
- * A Set based model
- * @extends Set<IValue>
- */
-export class SetModel extends Set<IValue> {
-    /**
-     * Constructs a set model based on a set
-     * @param set {Set<IValue>} input data
-     */
-    constructor(set?: Set<IValue>);
-    listener: any;
-}
-import { IValue } from "./interfaces/ivalue.js";
-/**
- * Represent a listener for a model
- */
-declare class Listener {
-    /**
-     * Functions to run on adding new items
-     * @type {Set<Function>}
-     */
-    onAdded: Set<Function>;
-    /**
-     * Functions to run on item removing
-     * @type {Set<Function>}
-     */
-    onRemoved: Set<Function>;
-    /**
-     * Emits added event to listeners
-     * @param index {number | string | *} index of value
-     * @param value {IValue} value of added item
-     */
-    emitAdded(index: number | string | any, value: IValue): void;
-    /**
-     * Emits removed event to listeners
-     * @param index {number | string | *} index of removed value
-     * @param value {IValue} value of removed item
-     */
-    emitRemoved(index: number | string | any, value: IValue): void;
-    /**
-     * Adds an handler to added event
-     * @param handler {Function} function to run on event emitting
-     */
-    onAdd(handler: Function): void;
-    /**
-     * Adds an handler to removed event
-     * @param handler {Function} function to run on event emitting
-     */
-    onRemove(handler: Function): void;
-    /**
-     * Removes an handler from added event
-     * @param handler {Function} handler to remove
-     */
-    offAdd(handler: Function): void;
-    /**
-     * Removes an handler form removed event
-     * @param handler {Function} handler to remove
-     */
-    offRemove(handler: Function): void;
-}
-export {};