native-document 1.0.37 → 1.0.39

package/types/observable.d.ts

@@ -4,6 +4,9 @@ export interface ObservableItem<T = any> {
     readonly $previousValue: T;
     readonly $isCleanedUp: boolean;
 
+    $value: T;
+    $memoryId: number | null;
+
     val(): T;
     set(value: T | ((prev: T) => T)): void;
     trigger(operations?: ObservableOperation): void;
@@ -68,6 +71,7 @@ export type ObservableProxy<T extends Record<string, any>> = {
     readonly __isProxy__: true;
     readonly $value: T;
     $clone(): ObservableProxy<T>;
+    $updateWith(values: Partial<T>): void;
 } & {
     [K in keyof T]: T[K] extends (infer U)[]
         ? ObservableArray<U>
@@ -82,24 +86,6 @@ export interface BatchFunction<TArgs extends any[] = any[], TReturn = any> {
 }
 
 export type ValidComputedDependencies = Array<ObservableItem | ObservableArray<any> | ObservableChecker | ObservableProxy<any>>;
-export interface ObservableStatic {
-    <T>(value: T): ObservableItem<T>;
-    array<T>(target: T[]): ObservableArray<T>;
-    init<T extends Record<string, any>>(value: T): ObservableProxy<T>;
-    object<T extends Record<string, any>>(value: T): ObservableProxy<T>;
-    json<T extends Record<string, any>>(value: T): ObservableProxy<T>;
-
-    computed<T>(callback: () => T, dependencies?: ValidComputedDependencies): ObservableItem<T>;
-    computed<T>(callback: () => T, batchFunction?: BatchFunction): ObservableItem<T>;
-
-    batch(callback: Function): BatchFunction;
-    value(data: any): any;
-    update(target: any, data: any): void;
-
-    getById(id: number): ObservableItem | null;
-    cleanup(observable: ObservableItem): void;
-    autoCleanup(enable?: boolean, options?: { interval?: number; threshold?: number }): void;
-}
 
 export interface AutoCleanupOptions {
     interval?: number;
@@ -114,7 +100,7 @@ export interface ObservableStatic {
     object<T extends Record<string, any>>(value: T): ObservableProxy<T>;
     json<T extends Record<string, any>>(value: T): ObservableProxy<T>;
 
-    computed<T>(callback: () => T, dependencies?: ObservableItem[]): ObservableItem<T>;
+    computed<T>(callback: () => T, dependencies?: ValidComputedDependencies | BatchFunction): ObservableItem<T>;
     computed<T>(callback: () => T, batchFunction?: BatchFunction): ObservableItem<T>;
 
     batch<TArgs extends any[], TReturn>(
@@ -127,4 +113,5 @@ export interface ObservableStatic {
     getById(id: number): ObservableItem | null;
     cleanup(observable: ObservableItem): void;
     autoCleanup(enable?: boolean, options?: AutoCleanupOptions): void;
+    arrayOfObject<T extends Record<string, any>>(data: T[]): ObservableProxy<T>[];
 }

package/types/polyfill.d.ts

@@ -10,7 +10,7 @@ export interface Set<T> {
 export interface Map<K, V> {
     clear(): void;
     delete(key: K): boolean;
-    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
+    forEach(callbackFn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
     get(key: K): V | undefined;
     has(key: K): boolean;
     set(key: K, value: V): this;

package/types/template-cloner.ts

@@ -4,7 +4,7 @@ interface BindingData {
     classes?: Record<string, (...data: any[]) => any>;
     styles?: Record<string, (...data: any[]) => any>;
     value?: (...data: any[]) => any;
-    events?: Record<string, (this: Element, event: Event, ...data: any[]) => void>;
+    attach?: (element: Element, ...data: any[]) => void;
 }
 
 interface ProcessedAttributes {
@@ -28,9 +28,14 @@ export declare class TemplateCloner {
 
     style(fn: (...data: any[]) => any): BindingHydrator;
     class(fn: (...data: any[]) => any): BindingHydrator;
-    value(fn: (...data: any[]) => any): BindingHydrator;
+    value(callbackOrProperty: string | ((...data: any[]) => any)): BindingHydrator;
     attr(fn: (...data: any[]) => any): BindingHydrator;
     event(fn: (event: Event, ...data: any[]) => void): BindingHydrator;
+
+    property(propertyName: string): BindingHydrator;
+    property(fn: (...data: any[]) => any): BindingHydrator;
+
+    attach(fn: (element: Element, ...data: any[]) => void): BindingHydrator;
 }
 
 export declare function useCache(fn: TemplateBuilder): CachedTemplateFunction;

package/src/wrappers/NDElementEventPrototypes.js

@@ -1,116 +0,0 @@
-import {EVENTS} from "../utils/events";
-import {NDElement} from "./NDElement";
-import Validator from "../utils/validator";
-
-(function() {
-    const DelegatedEventsCallbackStore = {};
-
-    const addCallbackToCallbacksStore = function(element, eventName, callback) {
-        if(!element) return;
-        if(!DelegatedEventsCallbackStore[eventName]) {
-            const eventStore = new WeakMap();
-            DelegatedEventsCallbackStore[eventName] = eventStore;
-            eventStore.set(element, callback);
-            return;
-        }
-        const eventStore = DelegatedEventsCallbackStore[eventName];
-
-        if(!eventStore.has(element)) {
-            eventStore.set(element, callback);
-            return;
-        }
-        const existingCallbacks = eventStore.get(element);
-        if(!Validator.isArray(existingCallbacks)) {
-            eventStore.set(element, [store[eventName], callback]);
-            return;
-        }
-        existingCallbacks.push(callback);
-    }
-
-    const handleDelegatedCallbacks = function(container, eventName) {
-        container.addEventListener(eventName, (event) => {
-            const eventStore = DelegatedEventsCallbackStore[eventName];
-            if(!eventStore) {
-                return;
-            }
-            let target = event.target;
-            while(target && target !== container) {
-                const callback = eventStore.get(target);
-                if(!callback) {
-                    target = target.parentElement;
-                    continue;
-                }
-
-                if(Validator.isFunction(callback)) {
-                    callback.call(target, event);
-                }
-                else {
-                    for(let i = 0; i < callback.length; i++) {
-                        callback[i].call(target, event);
-                    }
-                }
-                return;
-            }
-        });
-    };
-
-
-    const preventDefaultWrapper = function(element, eventName, callback) {
-        element.addEventListener(eventName, (event) => {
-            event.preventDefault();
-            callback && callback.call(element, event);
-        });
-        return this;
-    }
-    const stopPropagationWrapper = function(element, eventName, callback) {
-        element.addEventListener(eventName, (event) => {
-            event.stopPropagation();
-            callback && callback.call(element, event);
-        });
-        return this;
-    };
-    const preventDefaultAndStopPropagationWrapper = function(element, eventName, callback) {
-        element.addEventListener(eventName, (event) => {
-            event.stopPropagation();
-            event.preventDefault();
-            callback && callback.call(element, event);
-        });
-        return this;
-    };
-    const captureEventWrapper = function(element, eventName, directHandler) {
-        if(directHandler) {
-            element.addEventListener(eventName, directHandler);
-            return this;
-        }
-        handleDelegatedCallbacks(element, eventName);
-        return this;
-    }
-
-    for(const event of EVENTS) {
-        const eventName = event.toLowerCase();
-        NDElement.prototype['on'+event] = function(callback) {
-            this.$element.addEventListener(eventName, callback);
-            return this;
-        };
-        NDElement.prototype['onPrevent'+event] = function(callback) {
-            return preventDefaultWrapper(this.$element, eventName, callback);
-        };
-        NDElement.prototype['onStop'+event] = function(callback) {
-            return stopPropagationWrapper(this.$element, eventName, callback);
-        };
-        NDElement.prototype['onPreventStop'+event] = function(callback) {
-            return preventDefaultAndStopPropagationWrapper(this.$element, eventName, callback);
-        };
-
-        NDElement.prototype['when'+event] = function(callback) {
-            addCallbackToCallbacksStore(this.$element, eventName, callback);
-            return this;
-        };
-
-        NDElement.prototype['capture'+event] = function(directHandler) {
-            captureEventWrapper(this.$element, eventName, directHandler);
-            return this;
-        };
-    };
-
-}())