vasille 1.2.9 → 2.0.3

package/types/models/map-model.d.ts

@@ -0,0 +1,35 @@
+import { Listener } from "./listener";
+import type { IModel } from "./model";
+/**
+ * A Map based memory
+ * @class MapModel
+ * @extends Map
+ * @implements IModel
+ */
+export declare class MapModel<K, T> extends Map<K, T> implements IModel<K, T> {
+    listener: Listener<T, K>;
+    /**
+     * Constructs a map model
+     * @param map {[*, *][]} input data
+     */
+    constructor(map?: [K, T][]);
+    /**
+     * Calls Map.clear and notify abut changes
+     */
+    clear(): void;
+    /**
+     * Calls Map.delete and notify abut changes
+     * @param key {*} key
+     * @return {boolean} true if removed something, otherwise false
+     */
+    delete(key: any): boolean;
+    /**
+     * Calls Map.set and notify abut changes
+     * @param key {*} key
+     * @param value {*} value
+     * @return {MapModel} a pointer to this
+     */
+    set(key: K, value: T): this;
+    enableReactivity(): void;
+    disableReactivity(): void;
+}

package/types/models/model.d.ts

@@ -0,0 +1,19 @@
+import { Listener } from "./listener";
+/**
+ * @interface IModel
+ */
+export interface IModel<K, T> {
+    /**
+     * Enable the reactivity of model
+     */
+    enableReactivity(): void;
+    /**
+     * Disable the reactivity of model
+     */
+    disableReactivity(): void;
+    /**
+     * The listener of model
+     * @type Listener
+     */
+    listener: Listener<T, K>;
+}

package/types/models/object-model.d.ts

@@ -0,0 +1,36 @@
+import { Listener } from "./listener";
+import type { IModel } from "./model";
+/**
+ * Object based model
+ * @extends Object
+ */
+export declare class ObjectModel<T> extends Object implements IModel<string, T> {
+    listener: Listener<T, string>;
+    /**
+     * Constructs a object model
+     * @param obj {Object} input data
+     */
+    constructor(obj?: {
+        [p: string]: T;
+    });
+    /**
+     * Gets a value of a field
+     * @param key {string}
+     * @return {*}
+     */
+    get(key: string): T;
+    /**
+     * Sets an object property value
+     * @param key {string} property name
+     * @param v {*} property value
+     * @return {ObjectModel} a pointer to this
+     */
+    set(key: string, v: T): this;
+    /**
+     * Deletes an object property
+     * @param key {string} property name
+     */
+    delete(key: string): void;
+    enableReactivity(): void;
+    disableReactivity(): void;
+}

package/types/models/set-model.d.ts

@@ -0,0 +1,34 @@
+import { Listener } from "./listener";
+import type { IModel } from "./model";
+/**
+ * A Set based model
+ * @class SetModel
+ * @extends Set
+ * @implements IModel
+ */
+export declare class SetModel<T> extends Set<T> implements IModel<T, T> {
+    listener: Listener<T, T>;
+    /**
+     * Constructs a set model based on a set
+     * @param set {Set} input data
+     */
+    constructor(set?: T[]);
+    /**
+     * Calls Set.add and notify abut changes
+     * @param value {*} value
+     * @return {this} a pointer to this
+     */
+    add(value: T): this;
+    /**
+     * Calls Set.clear and notify abut changes
+     */
+    clear(): void;
+    /**
+     * Calls Set.delete and notify abut changes
+     * @param value {*}
+     * @return {boolean} true if a value was deleted, otherwise false
+     */
+    delete(value: T): boolean;
+    enableReactivity(): void;
+    disableReactivity(): void;
+}

package/types/node/app.d.ts

@@ -0,0 +1,42 @@
+import { Executor } from "../core/executor";
+import { INode } from "./node";
+declare type AppOptions = {
+    debugUi?: boolean;
+    freezeUi?: boolean;
+    executor?: Executor;
+};
+/**
+ * Application Node
+ * @class AppNode
+ * @extends INode
+ */
+export declare class AppNode extends INode {
+    /**
+     * Executor is used to optimize the page creation/update
+     * @type {Executor}
+     */
+    $run: Executor;
+    /**
+     * Enables debug comments
+     */
+    $debugUi: boolean;
+    /**
+     * @param options {Object} Application options
+     */
+    constructor(options?: AppOptions);
+}
+/**
+ * Represents a Vasille.js application
+ * @class App
+ * @extends AppNode
+ */
+export declare class App extends AppNode {
+    /**
+     * Constructs an app node
+     * @param node {Element} The root of application
+     * @param options {Object} Application options
+     */
+    constructor(node: Element, options?: AppOptions);
+    $$appendNode(node: Node): void;
+}
+export {};

package/types/node/interceptor.d.ts

@@ -0,0 +1,50 @@
+import { Fragment } from "./node";
+import { Destroyable } from "../core/destroyable";
+import { Signal } from "../core/signal";
+import { Slot } from "../core/slot";
+/**
+ * Interceptor is designed to connect signals & methods of children elements
+ * @class Interceptor
+ * @extends Destroyable
+ */
+export declare class Interceptor<t1 = void, t2 = void, t3 = void, t4 = void, t5 = void, t6 = void, t7 = void, t8 = void, t9 = void> extends Destroyable {
+    /**
+     * Set of signals
+     * @type Set
+     */
+    signals: Set<Signal<t1, t2, t3, t4, t5, t6, t7, t8, t9>>;
+    /**
+     * Set of handlers
+     * @type Set
+     */
+    handlers: Set<(a1: t1, a2: t2, a3: t3, a4: t4, a5: t5, a6: t6, a7: t7, a8: t8, a9: t9) => void>;
+    /**
+     * Connect a signal or a handler
+     * @param thing {Signal | function}
+     */
+    connect(thing: Signal<t1, t2, t3, t4, t5, t6, t7, t8, t9> | ((a1: t1, a2: t2, a3: t3, a4: t4, a5: t5, a6: t6, a7: t7, a8: t8, a9: t9) => void)): void;
+    /**
+     * Disconnect a handler from signals
+     * @param handler {function}
+     */
+    disconnect(handler: (a1: t1, a2: t2, a3: t3, a4: t4, a5: t5, a6: t6, a7: t7, a8: t8, a9: t9) => void): void;
+    $destroy(): void;
+}
+/**
+ * Interceptor node to implement directly to vasille DOM
+ * @class InterceptorNode
+ * @extends Extension
+ */
+export declare class InterceptorNode<t1 = void, t2 = void, t3 = void, t4 = void, t5 = void, t6 = void, t7 = void, t8 = void, t9 = void> extends Fragment {
+    /**
+     * Internal interceptor
+     * @type Interceptor
+     */
+    interceptor: Interceptor<t1, t2, t3, t4, t5, t6, t7, t8, t9>;
+    /**
+     * The default slot of node
+     * @type Slot
+     */
+    slot: Slot<Fragment, Interceptor<t1, t2, t3, t4, t5, t6, t7, t8, t9>>;
+    $compose(): void;
+}