vasille 2.3.9 → 3.0.2

package/types/core/core.d.ts

@@ -1,100 +1,46 @@
 import { Destroyable } from "./destroyable.js";
-import { IValue, Switchable } from "./ivalue.js";
-import { Expression, KindOfIValue } from "../value/expression";
+import { IValue } from "./ivalue.js";
+import { KindOfIValue } from "../value/expression";
 import { Pointer } from "../value/pointer";
-import { Mirror } from "../value/mirror";
-import { IModel } from "../models/model";
-import { FragmentOptions } from "../functional/options";
-export declare let current: Reactive | null;
-export declare function stack(node: Reactive): void;
-export declare function unstack(): void;
 /**
- * Private stuff of a reactive object
- * @class ReactivePrivate
+ * A reactive object
+ * @class Reactive
  * @extends Destroyable
  */
-export declare class ReactivePrivate extends Destroyable {
+export declare class Reactive<T extends object = object> extends Destroyable {
     /**
      * A list of user-defined values
      * @type {Set}
      */
-    watch: Set<Switchable>;
+    private _watch;
     /**
      * A list of user-defined bindings
      * @type {Set}
      */
-    bindings: Set<Destroyable>;
-    /**
-     * A list of user defined models
-     */
-    models: Set<IModel>;
-    /**
-     * Reactivity switch state
-     * @type {boolean}
-     */
-    enabled: boolean;
-    /**
-     * The frozen state of object
-     * @type {boolean}
-     */
-    frozen: boolean;
-    /**
-     * An expression which will freeze/unfreeze the object
-     * @type {IValue<void>}
-     */
-    freezeExpr: Expression<void, [boolean]>;
-    /**
-     * Parent node
-     * @type {Reactive}
-     */
-    parent: Reactive;
-    onDestroy?: () => void;
-    constructor();
-    $destroy(): void;
-}
-/**
- * A reactive object
- * @class Reactive
- * @extends Destroyable
- */
-export declare class Reactive<T extends FragmentOptions = FragmentOptions> extends Destroyable {
-    /**
-     * Private stuff
-     * @protected
-     */
-    protected $: ReactivePrivate;
-    input: T;
-    constructor(input: T, $?: ReactivePrivate);
-    /**
-     * Get parent node
-     */
-    get parent(): Reactive;
+    private bindings;
+    private onDestroy?;
+    readonly input: T;
+    constructor(input: T);
     /**
      * Create a reference
      * @param value {*} value to reference
      */
     ref<T>(value: T): IValue<T>;
     /**
-     * Create a mirror
-     * @param value {IValue} value to mirror
+     * Create a forward-only pointer
+     * @param value {IValue} value to point
      */
-    mirror<T>(value: IValue<T>): Mirror<T>;
-    /**
-     * Create a forward-only mirror
-     * @param value {IValue} value to mirror
-     */
-    forward<T>(value: IValue<T>): Mirror<T>;
+    forward<T>(value: IValue<T>): IValue<T>;
     /**
      * Creates a pointer
      * @param value {*} default value to point
-     * @param forwardOnly {boolean} forward only sync
      */
-    point<T>(value: IValue<T>, forwardOnly?: boolean): Pointer<T>;
+    own<T>(value: IValue<T>): Pointer<T>;
     /**
-     * Register a model
-     * @param model
+     * Register a model/dependency
      */
-    register<T extends IModel>(model: T): T;
+    register<T extends Destroyable>(data: T): T;
+    release(data: Destroyable): void;
     /**
      * Creates a watcher
      * @param func {function} function to run on any argument change
@@ -108,27 +54,6 @@ export declare class Reactive<T extends FragmentOptions = FragmentOptions> exten
      * @return {IValue} the created ivalue
      */
     expr<T, Args extends unknown[]>(func: (...args: Args) => T, ...values: KindOfIValue<Args>): IValue<T>;
-    /**
-     * Enable reactivity of fields
-     */
-    enable(): void;
-    /**
-     * Disable reactivity of fields
-     */
-    disable(): void;
-    /**
-     * Disable/Enable reactivity of object fields with feedback
-     * @param cond {IValue} show condition
-     * @param onOff {function} on show feedback
-     * @param onOn {function} on hide feedback
-     */
-    bindAlive(cond: IValue<boolean>, onOff?: () => void, onOn?: () => void): this;
-    init(): T['return'];
-    protected applyOptions(input: T): void;
-    protected applyOptionsNow(): void;
-    protected compose(input: T): T['return'];
-    protected composeNow(): T['return'];
-    runFunctional<F extends (...args: any) => any>(f: F, ...args: Parameters<F>): ReturnType<F>;
     runOnDestroy(func: () => void): void;
-    $destroy(): void;
+    destroy(): void;
 }

package/types/core/destroyable.d.ts

@@ -1,15 +1,20 @@
 /**
  * Mark an object which can be destroyed
- * @class Destroyable
+ * @interface IDestroyable
  */
-export declare class Destroyable {
+export interface IDestroyable {
     /**
-     * Make object fields non configurable
-     * @protected
+     * Garbage collector method
      */
-    protected $seal(): void;
+    destroy(): void;
+}
+/**
+ * Mark an object which can be destroyed
+ * @class Destroyable
+ */
+export declare class Destroyable implements IDestroyable {
     /**
      * Garbage collector method
      */
-    $destroy(): void;
+    destroy(): void;
 }

package/types/core/ivalue.d.ts

@@ -1,47 +1,30 @@
 import { Destroyable } from "./destroyable.js";
-export declare class Switchable extends Destroyable {
-    /**
-     * Enable update handlers triggering
-     */
-    $enable(): void;
-    /**
-     * disable update handlers triggering
-     */
-    $disable(): void;
-}
 /**
  * Interface which describes a value
  * @class IValue
  * @extends Destroyable
  */
-export declare class IValue<T> extends Switchable {
-    /**
-     * Is enabled state flag
-     * @protected
-     */
-    protected isEnabled: boolean;
-    /**
-     * @param isEnabled {boolean} initial is enabled state
-     */
-    constructor(isEnabled: boolean);
+export declare abstract class IValue<T> extends Destroyable {
     /**
      * Get the encapsulated value
      * @return {*} the encapsulated value
      */
-    get $(): T;
+    abstract get $(): T;
     /**
      * Sets the encapsulated value
      * @param value {*} value to encapsulate
      */
-    set $(value: T);
+    abstract set $(value: T);
     /**
      * Add a new handler to value change
      * @param handler {function(value : *)} the handler to add
      */
-    $on(handler: (value: T) => void): void;
+    abstract on(handler: (value: T) => void): void;
     /**
      * Removes a handler of value change
      * @param handler {function(value : *)} the handler to remove
      */
-    $off(handler: (value: T) => void): void;
+    abstract off(handler: (value: T) => void): void;
+    toJSON(): T;
+    toString(): string;
 }

package/types/functional/options.d.ts

@@ -1,25 +1,10 @@
 import type { IValue } from "../core/ivalue";
-import { AcceptedTagsMap, AcceptedTagsSpec } from "../spec/react";
-import type { Fragment } from "../node/node";
-export interface FragmentOptions {
-    "v:is"?: Record<string, IValue<any>>;
-    return?: {
-        [key: string]: any;
-    };
-    slot?: (node: Fragment, ...args: any[]) => void;
-}
 export type AttrType<T> = IValue<T | string | null> | T | string | null | undefined;
-export interface TagOptions<T extends keyof AcceptedTagsMap> extends FragmentOptions {
-    "v:attr"?: {
-        [K in keyof AcceptedTagsSpec[T]['attrs']]?: AttrType<AcceptedTagsSpec[T]['attrs'][K]>;
-    } & Record<string, AttrType<number | boolean>>;
-    class?: (string | IValue<string> | Record<string, boolean | IValue<boolean>>)[] | ({
-        $: IValue<string>[];
-    } & Record<string, boolean | IValue<boolean>>);
-    style?: Record<string, string | IValue<string> | [number | string | IValue<number | string>, string]>;
-    "v:events"?: Partial<AcceptedTagsSpec[T]['events']>;
-    "v:set"?: Partial<AcceptedTagsMap[T]> & Record<string, any>;
-    "v:bind"?: {
-        [K in keyof AcceptedTagsMap[T]]?: IValue<AcceptedTagsMap[T][K]>;
-    } & Record<string, IValue<any>>;
+export type StyleType<T> = T | number | number[] | IValue<string | number | number[]>;
+export interface TagOptions {
+    attr?: Record<string, AttrType<number | boolean>>;
+    class?: (string | IValue<string> | Record<string, boolean | IValue<boolean>>)[];
+    style?: Record<string, StyleType<string>>;
+    events?: Record<string, (...args: unknown[]) => unknown>;
+    bind?: Record<string, any>;
 }

package/types/functional/safety.d.ts

@@ -0,0 +1,2 @@
+export declare let reportError: (e: unknown) => void;
+export declare function setErrorHandler(handler: (e: unknown) => void): void;

package/types/index.d.ts

@@ -1,26 +1,24 @@
+import { config } from "./core/config";
 import { Destroyable } from "./core/destroyable";
-import { current, Reactive, stack, unstack } from "./core/core";
+import { Reactive } from "./core/core";
 import { IValue } from "./core/ivalue";
-import { ArrayModel } from "./models/array-model";
+import { reportError, setErrorHandler } from "./functional/safety";
+import { ArrayModel, proxyArrayModel } from "./models/array-model";
 import { Listener } from "./models/listener";
 import { MapModel } from "./models/map-model";
-import { ObjectModel } from "./models/object-model";
 import { SetModel } from "./models/set-model";
-import { App, AppNode, AppOptions, Portal } from "./node/app";
-import { Component, Extension, Fragment, INode, Tag, TagOptionsWithSlot } from "./node/node";
+import { App, Portal } from "./node/app";
+import { Extension, Fragment, INode, Tag, TagOptionsWithSlot } from "./node/node";
 import { Expression, KindOfIValue } from "./value/expression";
-import { Mirror } from "./value/mirror";
 import { Pointer } from "./value/pointer";
 import { Reference } from "./value/reference";
 import { ArrayView } from "./views/array-view";
 import { BaseView } from "./views/base-view";
 import { MapView } from "./views/map-view";
-import { ObjectView } from "./views/object-view";
 import { SetView } from "./views/set-view";
 import { Binding } from "./binding/binding";
-import { FragmentOptions, TagOptions } from "./functional/options";
-import { AcceptedTagsMap, AcceptedTagsSpec } from "./spec/react";
+import { TagOptions } from "./functional/options";
 import { userError } from "./core/errors";
 import { ListenableModel } from "./models/model";
 import { Watch } from "./node/watch";
-export { Destroyable, IValue, Reference, Mirror, Pointer, ArrayModel, MapModel, ObjectModel, SetModel, BaseView, Listener, ArrayView, MapView, ObjectView, SetView, Fragment, INode, Tag, Component, Extension, AppNode, App, Portal, Expression, Binding, Reactive, Watch, FragmentOptions, TagOptions, AppOptions, AcceptedTagsSpec, AcceptedTagsMap, KindOfIValue, ListenableModel, TagOptionsWithSlot, stack, unstack, userError, current, };
+export { Destroyable, IValue, Reference, Pointer, ArrayModel, proxyArrayModel, MapModel, SetModel, BaseView, Listener, ArrayView, MapView, SetView, Fragment, INode, Tag, Extension, App, Portal, Expression, Binding, Reactive, Watch, TagOptions, KindOfIValue, ListenableModel, TagOptionsWithSlot, userError, config, setErrorHandler, reportError, };

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

@@ -7,15 +7,11 @@ import { ListenableModel } from "./model";
  */
 export declare class ArrayModel<T> extends Array<T> implements ListenableModel<T, T> {
     listener: Listener<T, T>;
+    passive: boolean;
     /**
      * @param data {Array} input data
      */
-    constructor(data?: Array<T>);
-    /**
-     * Gets the last item of array
-     * @return {*} the last item of array
-     */
-    get last(): T;
+    constructor(data?: Array<T> | number);
     /**
      * Calls Array.fill and notify about changes
      * @param value {*} value to fill with
@@ -27,7 +23,7 @@ export declare class ArrayModel<T> extends Array<T> implements ListenableModel<T
      * Calls Array.pop and notify about changes
      * @return {*} removed value
      */
-    pop(): T;
+    pop(): T | undefined;
     /**
      * Calls Array.push and notify about changes
      * @param items {...*} values to push
@@ -38,7 +34,7 @@ export declare class ArrayModel<T> extends Array<T> implements ListenableModel<T
      * Calls Array.shift and notify about changed
      * @return {*} the shifted value
      */
-    shift(): T;
+    shift(): T | undefined;
     /**
      * Calls Array.splice and notify about changed
      * @param start {number} start index
@@ -53,52 +49,7 @@ export declare class ArrayModel<T> extends Array<T> implements ListenableModel<T
      * @return {number} the length after prepend
      */
     unshift(...items: Array<T>): number;
-    /**
-     * Inserts a value to the end of array
-     * @param v {*} value to insert
-     */
-    append(v: T): this;
-    /**
-     * Clears array
-     * @return {this} a pointer to this
-     */
-    clear(): this;
-    /**
-     * Inserts a value to position `index`
-     * @param index {number} index to insert value
-     * @param v {*} value to insert
-     * @return {this} a pointer to this
-     */
-    insert(index: number, v: T): this;
-    /**
-     * Inserts a value to the beginning of array
-     * @param v {*} value to insert
-     * @return {this} a pointer to this
-     */
-    prepend(v: T): 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 {*} value to remove
-     * @return {this}
-     */
-    removeOne(v: T): this;
     replace(at: number, with_: T): this;
-    enableReactivity(): void;
-    disableReactivity(): void;
+    destroy(): void;
 }
+export declare function proxyArrayModel<T>(arr: ArrayModel<T>): ArrayModel<T>;

package/types/models/listener.d.ts

@@ -13,24 +13,6 @@ export declare class Listener<ValueT, IndexT = string | number> {
      * @type Set
      */
     private readonly onRemoved;
-    /**
-     * Describe the frozen state of model
-     * @type boolean
-     * @private
-     */
-    private frozen;
-    /**
-     * The queue of operations in frozen state
-     * @type Object[]
-     * @private
-     */
-    private readonly queue;
-    constructor();
-    /**
-     * Exclude the repeated operation in queue
-     * @private
-     */
-    private excludeRepeat;
     /**
      * Emits added event to listeners
      * @param index {*} index of value
@@ -63,12 +45,4 @@ export declare class Listener<ValueT, IndexT = string | number> {
      * @param handler {function} handler to remove
      */
     offRemove(handler: (index: IndexT, value: ValueT) => void): void;
-    /**
-     * Run all queued operation and enable reactivity
-     */
-    enableReactivity(): void;
-    /**
-     * Disable the reactivity and enable the queue
-     */
-    disableReactivity(): void;
 }

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

@@ -14,7 +14,7 @@ export declare class MapModel<K, T> extends Map<K, T> implements ListenableModel
      */
     constructor(map?: [K, T][]);
     /**
-     * Calls Map.clear and notify abut changes
+     * Calls Map.clear and notify about changes
      */
     clear(): void;
     /**
@@ -22,7 +22,7 @@ export declare class MapModel<K, T> extends Map<K, T> implements ListenableModel
      * @param key {*} key
      * @return {boolean} true if removed something, otherwise false
      */
-    delete(key: any): boolean;
+    delete(key: K): boolean;
     /**
      * Calls Map.set and notify abut changes
      * @param key {*} key
@@ -30,6 +30,5 @@ export declare class MapModel<K, T> extends Map<K, T> implements ListenableModel
      * @return {MapModel} a pointer to this
      */
     set(key: K, value: T): this;
-    enableReactivity(): void;
-    disableReactivity(): void;
+    destroy(): void;
 }

package/types/models/model.d.ts

@@ -1,16 +1,9 @@
+import { IDestroyable } from "../core/destroyable";
 import { Listener } from "./listener";
 /**
  * @interface IModel
  */
-export interface IModel {
-    /**
-     * Enable the reactivity of model
-     */
-    enableReactivity(): void;
-    /**
-     * Disable the reactivity of model
-     */
-    disableReactivity(): void;
+export interface IModel extends IDestroyable {
 }
 export interface ListenableModel<K, T> extends IModel {
     /**

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

@@ -29,6 +29,5 @@ export declare class SetModel<T> extends Set<T> implements ListenableModel<T, T>
      * @return {boolean} true if a value was deleted, otherwise false
      */
     delete(value: T): boolean;
-    enableReactivity(): void;
-    disableReactivity(): void;
+    destroy(): void;
 }

package/types/node/app.d.ts

@@ -1,30 +1,11 @@
-import { Fragment, INode } from "./node";
-import { TagOptions } from "../functional/options";
-import { AcceptedTagsMap } from "../spec/react";
-export interface AppOptions<K extends keyof AcceptedTagsMap> extends TagOptions<K> {
-    debugUi?: boolean;
-}
-/**
- * Application Node
- * @class AppNode
- * @extends INode
- */
-export declare class AppNode<T extends AppOptions<any> = AppOptions<any>> extends INode<T> {
-    /**
-     * Enables debug comments
-     */
-    debugUi: boolean;
-    /**
-     * @param input
-     */
-    constructor(input: T);
-}
+import { Fragment, Root } from "./node";
 /**
  * Represents a Vasille.js application
  * @class App
  * @extends AppNode
  */
-export declare class App<T extends AppOptions<any> = AppOptions<any>> extends AppNode<T> {
+export declare class App<T extends object = object> extends Root<T> {
+    private node;
     /**
      * Constructs an app node
      * @param node {Element} The root of application
@@ -33,11 +14,12 @@ export declare class App<T extends AppOptions<any> = AppOptions<any>> extends Ap
     constructor(node: Element, input: T);
     appendNode(node: Node): void;
 }
-interface PortalOptions extends AppOptions<'div'> {
+interface PortalOptions {
     node: Element;
-    slot?: (node: Fragment) => void;
+    slot?: (ctx: Fragment) => void;
 }
-export declare class Portal extends AppNode<PortalOptions> {
+export declare class Portal extends Fragment {
+    private node;
     constructor(input: PortalOptions);
     appendNode(node: Node): void;
 }