jpf 5.0.3 → 5.0.7

package/dist/framework/event.d.ts

@@ -1,80 +1,80 @@
-import * as leaflet from "leaflet";
-export declare const mouseEvents: {
-    click: boolean;
-    contextmenu: boolean;
-    mousedown: boolean;
-    mouseenter: boolean;
-    mouseleave: boolean;
-    mousemove: boolean;
-    mouseout: boolean;
-    mouseover: boolean;
-    mouseup: boolean;
-};
-export declare const touchEvents: {
-    touchcancel: boolean;
-    touchend: boolean;
-    touchmove: boolean;
-    touchstart: boolean;
-    longtap: boolean;
-    swipeleft: boolean;
-    swiperight: boolean;
-    swipeup: boolean;
-    swipedown: boolean;
-};
-export declare function isGlobalEvent(event: keyof UiElementEventMap): boolean;
-export interface UiElementEventMap extends HTMLElementEventMap {
-    "tap": Event;
-    "dbltap": Event;
-    "longtap": Event;
-    "swipeleft": Event;
-    "swiperight": Event;
-    "swipeup": Event;
-    "swipedown": Event;
-    "textInput": Event;
-}
-export interface IMouseEventListener extends IEventListener {
-    listener: (event: MouseEvent) => void;
-}
-export interface IFocusEventListener extends IEventListener {
-    listener: (event: FocusEvent) => void;
-}
-export interface IContextMenuEventListener extends IEventListener {
-    listener: (event: PointerEvent) => void;
-}
-export interface ILeafletEventListener extends IEventListener {
-    listener: (event: leaflet.LeafletEvent) => void;
-}
-export interface IGenericEventListener extends IEventListener {
-    listener: (event: Event) => void;
-}
-export interface IEventListener {
-    options?: IEventListenerOptions;
-}
-export interface MouseEventListeners {
-    click?: IMouseEventListener;
-}
-export interface FocusEventListeners {
-    focusout?: IFocusEventListener;
-}
-export interface ContextMenuEventListeners {
-    contextMenu?: IContextMenuEventListener;
-}
-export interface LeafletEventListeners {
-    zoomend?: ILeafletEventListener;
-    moveend?: ILeafletEventListener;
-}
-export interface EventListeners extends MouseEventListeners, FocusEventListeners, ContextMenuEventListeners, LeafletEventListeners {
-    change?: IGenericEventListener;
-    load?: IGenericEventListener;
-}
-type EventKey = "Enter" | "ArrowDown" | "ArrowUp" | "ArrowLeft" | "ArrowRight";
-export interface IEventListenerOptions extends AddEventListenerOptions {
-    eventKey?: EventKey;
-    altKey?: boolean;
-    shiftKey?: boolean;
-    ctrlKey?: boolean;
-    mouseLeft?: boolean;
-    mouseMiddle?: boolean;
-    mouseRight?: boolean;
-}
-export {};
+import * as leaflet from "leaflet";
+export declare const mouseEvents: {
+    click: boolean;
+    contextmenu: boolean;
+    mousedown: boolean;
+    mouseenter: boolean;
+    mouseleave: boolean;
+    mousemove: boolean;
+    mouseout: boolean;
+    mouseover: boolean;
+    mouseup: boolean;
+};
+export declare const touchEvents: {
+    touchcancel: boolean;
+    touchend: boolean;
+    touchmove: boolean;
+    touchstart: boolean;
+    longtap: boolean;
+    swipeleft: boolean;
+    swiperight: boolean;
+    swipeup: boolean;
+    swipedown: boolean;
+};
+export declare function isGlobalEvent(event: keyof IUiElementEventMap): boolean;
+export interface IUiElementEventMap extends HTMLElementEventMap {
+    "tap": Event;
+    "dbltap": Event;
+    "longtap": Event;
+    "swipeleft": Event;
+    "swiperight": Event;
+    "swipeup": Event;
+    "swipedown": Event;
+    "textInput": Event;
+}
+export interface IMouseEventListener extends IEventListener {
+    listener: (event: MouseEvent) => void;
+}
+export interface IFocusEventListener extends IEventListener {
+    listener: (event: FocusEvent) => void;
+}
+export interface IContextMenuEventListener extends IEventListener {
+    listener: (event: PointerEvent) => void;
+}
+export interface ILeafletEventListener extends IEventListener {
+    listener: (event: leaflet.LeafletEvent) => void;
+}
+export interface IGenericEventListener extends IEventListener {
+    listener: (event: Event) => void;
+}
+export interface IEventListener {
+    options?: IEventListenerOptions;
+}
+export interface IMouseEventListeners {
+    click?: IMouseEventListener;
+}
+export interface IFocusEventListeners {
+    focusout?: IFocusEventListener;
+}
+export interface IContextMenuEventListeners {
+    contextMenu?: IContextMenuEventListener;
+}
+export interface ILeafletEventListeners {
+    zoomend?: ILeafletEventListener;
+    moveend?: ILeafletEventListener;
+}
+export interface IEventListeners extends IMouseEventListeners, IFocusEventListeners, IContextMenuEventListeners, ILeafletEventListeners {
+    change?: IGenericEventListener;
+    load?: IGenericEventListener;
+}
+type EventKey = "Enter" | "ArrowDown" | "ArrowUp" | "ArrowLeft" | "ArrowRight";
+export interface IEventListenerOptions extends AddEventListenerOptions {
+    eventKey?: EventKey;
+    altKey?: boolean;
+    shiftKey?: boolean;
+    ctrlKey?: boolean;
+    mouseLeft?: boolean;
+    mouseMiddle?: boolean;
+    mouseRight?: boolean;
+}
+export {};

package/dist/framework/event.js

@@ -1,26 +1,26 @@
-export const mouseEvents = {
-    click: true,
-    contextmenu: true,
-    mousedown: true,
-    mouseenter: true,
-    mouseleave: true,
-    mousemove: true,
-    mouseout: true,
-    mouseover: true,
-    mouseup: true
-};
-export const touchEvents = {
-    touchcancel: true,
-    touchend: true,
-    touchmove: true,
-    touchstart: true,
-    longtap: true,
-    swipeleft: true,
-    swiperight: true,
-    swipeup: true,
-    swipedown: true
-};
-export function isGlobalEvent(event) {
-    return !(mouseEvents[event] || touchEvents[event]);
-}
+export const mouseEvents = {
+    click: true,
+    contextmenu: true,
+    mousedown: true,
+    mouseenter: true,
+    mouseleave: true,
+    mousemove: true,
+    mouseout: true,
+    mouseover: true,
+    mouseup: true
+};
+export const touchEvents = {
+    touchcancel: true,
+    touchend: true,
+    touchmove: true,
+    touchstart: true,
+    longtap: true,
+    swipeleft: true,
+    swiperight: true,
+    swipeup: true,
+    swipedown: true
+};
+export function isGlobalEvent(event) {
+    return !(mouseEvents[event] || touchEvents[event]);
+}
 //# sourceMappingURL=event.js.map

package/dist/framework/event.js.map

@@ -1 +1 @@
-{"version":3,"file":"event.js","sourceRoot":"","sources":["../../src/framework/event.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,WAAW,GAAG;IACvB,KAAK,EAAE,IAAI;IACX,WAAW,EAAE,IAAI;IACjB,SAAS,EAAE,IAAI;IACf,UAAU,EAAE,IAAI;IAChB,UAAU,EAAE,IAAI;IAChB,SAAS,EAAE,IAAI;IACf,QAAQ,EAAE,IAAI;IACd,SAAS,EAAE,IAAI;IACf,OAAO,EAAE,IAAI;CAChB,CAAC;AAEF,MAAM,CAAC,MAAM,WAAW,GAAG;IACvB,WAAW,EAAE,IAAI;IACjB,QAAQ,EAAE,IAAI;IACd,SAAS,EAAE,IAAI;IACf,UAAU,EAAE,IAAI;IAChB,OAAO,EAAE,IAAI;IACb,SAAS,EAAE,IAAI;IACf,UAAU,EAAE,IAAI;IAChB,OAAO,EAAE,IAAI;IACb,SAAS,EAAE,IAAI;CAClB,CAAC;AAEF,MAAM,UAAU,aAAa,CAAC,KAA8B;IACxD,OAAO,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;AACvD,CAAC"}
+{"version":3,"file":"event.js","sourceRoot":"","sources":["../../src/framework/event.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,WAAW,GAAG;IACvB,KAAK,EAAE,IAAI;IACX,WAAW,EAAE,IAAI;IACjB,SAAS,EAAE,IAAI;IACf,UAAU,EAAE,IAAI;IAChB,UAAU,EAAE,IAAI;IAChB,SAAS,EAAE,IAAI;IACf,QAAQ,EAAE,IAAI;IACd,SAAS,EAAE,IAAI;IACf,OAAO,EAAE,IAAI;CAChB,CAAC;AAEF,MAAM,CAAC,MAAM,WAAW,GAAG;IACvB,WAAW,EAAE,IAAI;IACjB,QAAQ,EAAE,IAAI;IACd,SAAS,EAAE,IAAI;IACf,UAAU,EAAE,IAAI;IAChB,OAAO,EAAE,IAAI;IACb,SAAS,EAAE,IAAI;IACf,UAAU,EAAE,IAAI;IAChB,OAAO,EAAE,IAAI;IACb,SAAS,EAAE,IAAI;CAClB,CAAC;AAEF,MAAM,UAAU,aAAa,CAAC,KAA+B;IACzD,OAAO,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;AACvD,CAAC"}

package/dist/framework/observable.d.ts

@@ -1,12 +1,37 @@
-import { Subscribable, ObservableArray, Observable } from "knockout";
-export interface ObservableProperty<TValue = any, TSetter = TValue> extends Subscribable<TValue> {
-    (): TValue;
-    set: (value: TSetter | null, triggerSetter?: boolean) => void;
-}
-export declare function isObservableProperty<T = any>(instance: any): instance is ObservableProperty<T>;
-export declare function observableProperty<TValue, TSetter = TValue>(value?: TValue | Observable<TValue>, setter?: (value: TSetter, internalProperty: Observable<TValue>) => void, notifyAlways?: boolean): ObservableProperty<TValue, TSetter>;
-export interface ObservableArrayProperty<TItem = any, TSetter = Array<TItem>> extends ObservableArray<TItem> {
-    set: (items: TSetter, triggerSetter?: boolean) => void;
-    map<TResult>(callbackfn: (value: TItem, index: number, array: TItem[]) => TResult, thisArg?: any): TResult[];
-}
-export declare function observableArrayProperty<TItem, TSetter = Array<TItem>>(items?: Array<TItem> | ObservableArray<TItem>, setter?: (items: TSetter, internalProperty: ObservableArray<TItem>) => void): ObservableArrayProperty<TItem, TSetter>;
+export interface IDisposer {
+    (): void;
+}
+export interface ISubscribable<TValue> {
+    subscribe(handler: (arg: TValue, prev: TValue) => void): IDisposer;
+}
+export interface IObservableValue<TValue = any, TSetter = TValue> extends ISubscribable<TValue> {
+    (): TValue;
+    setValue(value: TSetter | null): void;
+    setValueInAction(value: TSetter | null): void;
+    setInternal(value: TValue | null): void;
+}
+export interface IObservableArray<TItem = any, TSetter = Array<TItem>> extends Array<TItem>, ISubscribable<Array<TItem>> {
+    get(): Array<TItem>;
+    setItems(items: TSetter | null, triggerSetter?: boolean): void;
+    setInternal(items: Array<TItem> | null): void;
+}
+export interface IComputed<TValue> extends ISubscribable<TValue> {
+    (): TValue;
+}
+export interface IObservableMap<TKey, TValue> {
+}
+export interface IObservableSet<TItem> {
+}
+export declare function observableValue<TValue, TSetter = TValue>(value?: TValue | null, setter?: (value: TSetter, observableValue: IObservableValue<TValue, TSetter>) => void): IObservableValue<TValue, TSetter>;
+export declare function observableArray<TItem = any, TSetter = Array<TItem>>(initialValues?: Array<TItem> | null, setter?: (value: TSetter, observableArray: IObservableArray<TItem, TSetter>) => void): IObservableArray<TItem, TSetter>;
+export declare function observableMap<TKey = any, TItem = any>(): void;
+export declare function observableSet<TItem = any>(): void;
+export declare function computed<TComputed>(func: () => TComputed): IComputed<TComputed>;
+export declare function unwrap<TValue>(value: TValue | ISubscribable<TValue>): TValue;
+export declare function isComputed(value: any): value is IComputed<any>;
+export declare function isObservableValue(value: any): value is IObservableValue;
+export declare function isObservableArray(value: any): value is IObservableArray;
+export declare function isObservableMap<TKey, TItem>(value: any): value is IObservableMap<TKey, TItem>;
+export declare function isObservableSet<TItem>(value: any): value is IObservableSet<TItem>;
+export declare function isSubscribable<TValue>(value: any): value is ISubscribable<TValue>;
+export declare function executeHandlerOnObject(handler: (object: any) => void, object: object): void;

package/dist/framework/observable.js

@@ -1,59 +1,67 @@
-import { isObservable, observable, observableArray, pureComputed } from "knockout";
-export function isObservableProperty(instance) {
-    return instance && !!instance.set;
-}
-export function observableProperty(value, setter, notifyAlways = false) {
-    let internalProperty;
-    if (value === undefined) {
-        value = null;
-    }
-    if (isObservable(value)) {
-        internalProperty = value;
-    }
-    else {
-        internalProperty = observable(value);
-    }
-    if (notifyAlways) {
-        internalProperty.extend({ notify: "always" });
-    }
-    const computed = pureComputed({ read: internalProperty }).extend({ notify: "always" });
-    computed.set = (newValue, triggerSetter = true) => {
-        if (setter && triggerSetter) {
-            setter(newValue, internalProperty);
-        }
-        else {
-            internalProperty(newValue);
-        }
-    };
-    return computed;
-}
-export function observableArrayProperty(items, setter) {
-    let internalProperty;
-    if (!items) {
-        items = [];
-    }
-    if (isObservable(items)) {
-        internalProperty = items;
-    }
-    else {
-        internalProperty = observableArray(items);
-    }
-    const computed = pureComputed({ read: internalProperty }).extend({ notify: "always" });
-    computed.set = (value, triggerSetter = true) => {
-        if (setter && triggerSetter) {
-            setter(value, internalProperty);
-        }
-        else {
-            internalProperty(value);
-        }
-    };
-    computed.push = (...itemsToPush) => {
-        internalProperty.push(...itemsToPush);
-        return itemsToPush.length;
-    };
-    computed.map = (callBack, thisArg) => {
-        return internalProperty().map(callBack, thisArg);
-    };
-    return computed;
-}
+export function observableValue(value, setter) {
+    throw "observableValue is not implemented";
+}
+export function observableArray(initialValues, setter) {
+    throw "observableArray is not implemented";
+}
+export function observableMap() {
+    throw "observableMap is not implemented";
+}
+export function observableSet() {
+    throw "observableSet is not implemented";
+}
+export function computed(func) {
+    throw "computed is not implementd";
+}
+export function unwrap(value) {
+    throw "Unwrap is not implemented";
+}
+export function isComputed(value) {
+    throw "isComputed is not implemented";
+}
+export function isObservableValue(value) {
+    throw "isObservableValue is not implemented";
+}
+export function isObservableArray(value) {
+    throw "isObservableArray is not implemented";
+}
+export function isObservableMap(value) {
+    throw "isObservableMap is not implemented";
+}
+export function isObservableSet(value) {
+    throw "isObservableSet is not implemented";
+}
+export function isSubscribable(value) {
+    return isComputed(value)
+        || isObservableValue(value)
+        || isObservableArray(value)
+        || isObservableMap(value)
+        || isObservableSet(value);
+}
+export function executeHandlerOnObject(handler, object) {
+    if (object.constructor === Array) {
+        for (const arrayEntry of object) {
+            if (typeof arrayEntry === "object") {
+                executeHandlerOnObject(handler, arrayEntry);
+            }
+        }
+    }
+    else {
+        if (isSubscribable(object)) {
+            const unwrapped = unwrap(object);
+            if (typeof unwrapped === "object") {
+                executeHandlerOnObject(handler, unwrapped);
+            }
+        }
+        else {
+            handler(object);
+            for (const key in Object.keys(object)) {
+                const property = object[key];
+                if (property && typeof property === "object") {
+                    executeHandlerOnObject(handler, property);
+                }
+            }
+        }
+    }
+}
 //# sourceMappingURL=observable.js.map

package/dist/framework/observable.js.map

@@ -1 +1 @@
-{"version":3,"file":"observable.js","sourceRoot":"","sources":["../../src/framework/observable.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6C,YAAY,EAAE,UAAU,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAO9H,MAAM,UAAU,oBAAoB,CAAU,QAAa;IACvD,OAAO,QAAQ,IAAI,CAAC,CAAE,QAAkC,CAAC,GAAG,CAAC;AACjE,CAAC;AAED,MAAM,UAAU,kBAAkB,CAA2B,KAAmC,EAAE,MAAuE,EAAE,eAAwB,KAAK;IACpM,IAAI,gBAAoC,CAAC;IACzC,IAAI,KAAK,KAAK,SAAS,EAAE;QACrB,KAAK,GAAG,IAAI,CAAC;KAChB;IACD,IAAI,YAAY,CAAC,KAAK,CAAC,EAAE;QACrB,gBAAgB,GAAG,KAAK,CAAC;KAC5B;SAAM;QACH,gBAAgB,GAAG,UAAU,CAAS,KAAK,CAAC,CAAC;KAChD;IAED,IAAI,YAAY,EAAE;QACd,gBAAgB,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;KACjD;IAGD,MAAM,QAAQ,GAAG,YAAY,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,CAA+C,CAAC;IAErI,QAAQ,CAAC,GAAG,GAAG,CAAC,QAAa,EAAE,gBAAyB,IAAI,EAAE,EAAE;QAC5D,IAAI,MAAM,IAAI,aAAa,EAAE;YACzB,MAAM,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC;SACtC;aAAM;YACH,gBAAgB,CAAC,QAAQ,CAAC,CAAC;SAC9B;IACL,CAAC,CAAC;IAEF,OAAO,QAAQ,CAAC;AACpB,CAAC;AAOD,MAAM,UAAU,uBAAuB,CAAgC,KAA6C,EAAE,MAA2E;IAE7L,IAAI,gBAAwC,CAAC;IAC7C,IAAI,CAAC,KAAK,EAAE;QACR,KAAK,GAAG,EAAE,CAAC;KACd;IACD,IAAI,YAAY,CAAC,KAAK,CAAC,EAAE;QACrB,gBAAgB,GAAG,KAAK,CAAC;KAC5B;SAAM;QACH,gBAAgB,GAAG,eAAe,CAAQ,KAAK,CAAC,CAAC;KACpD;IAGD,MAAM,QAAQ,GAAG,YAAY,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAmD,CAAC;IAEzI,QAAQ,CAAC,GAAG,GAAG,CAAC,KAAU,EAAE,gBAAyB,IAAI,EAAE,EAAE;QACzD,IAAI,MAAM,IAAI,aAAa,EAAE;YACzB,MAAM,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC;SACnC;aAAM;YACH,gBAAgB,CAAC,KAAK,CAAC,CAAC;SAC3B;IACL,CAAC,CAAC;IAEF,QAAQ,CAAC,IAAI,GAAG,CAAC,GAAG,WAAW,EAAE,EAAE;QAC/B,gBAAgB,CAAC,IAAI,CAAC,GAAG,WAAW,CAAC,CAAC;QACtC,OAAO,WAAW,CAAC,MAAM,CAAC;IAC9B,CAAC,CAAA;IAED,QAAQ,CAAC,GAAG,GAAG,CAAC,QAA8D,EAAE,OAAa,EAAE,EAAE;QAE7F,OAAO,gBAAgB,EAAE,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IACrD,CAAC,CAAA;IAED,OAAO,QAAQ,CAAC;AACpB,CAAC"}
+{"version":3,"file":"observable.js","sourceRoot":"","sources":["../../src/framework/observable.ts"],"names":[],"mappings":"AAiCA,MAAM,UAAU,eAAe,CAA2B,KAAqB,EAAE,MAAqF;IAClK,MAAM,oCAAoC,CAAC;AAC/C,CAAC;AAED,MAAM,UAAU,eAAe,CAAsC,aAAmC,EAAE,MAAoF;IAC1L,MAAM,oCAAoC,CAAC;AAC/C,CAAC;AAED,MAAM,UAAU,aAAa;IACzB,MAAM,kCAAkC,CAAC;AAC7C,CAAC;AAED,MAAM,UAAU,aAAa;IACzB,MAAM,kCAAkC,CAAC;AAC7C,CAAC;AAED,MAAM,UAAU,QAAQ,CAAY,IAAqB;IACrD,MAAM,4BAA4B,CAAC;AACvC,CAAC;AAED,MAAM,UAAU,MAAM,CAAS,KAAqC;IAChE,MAAM,2BAA2B,CAAC;AACtC,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,KAAK;IAC5B,MAAM,+BAA+B,CAAC;AAC1C,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,KAAK;IACnC,MAAM,sCAAsC,CAAC;AACjD,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,KAAK;IACnC,MAAM,sCAAsC,CAAC;AACjD,CAAC;AAED,MAAM,UAAU,eAAe,CAAc,KAAK;IAC9C,MAAM,oCAAoC,CAAC;AAC/C,CAAC;AAED,MAAM,UAAU,eAAe,CAAQ,KAAK;IACxC,MAAM,oCAAoC,CAAC;AAC/C,CAAC;AAED,MAAM,UAAU,cAAc,CAAS,KAAU;IAC7C,OAAO,UAAU,CAAC,KAAK,CAAC;WACjB,iBAAiB,CAAC,KAAK,CAAC;WACxB,iBAAiB,CAAC,KAAK,CAAC;WACxB,eAAe,CAAC,KAAK,CAAC;WACtB,eAAe,CAAC,KAAK,CAAC,CAAC;AAClC,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,OAAyB,EAAE,MAAc;IAE5E,IAAI,MAAM,CAAC,WAAW,KAAK,KAAK,EAAE,CAAC;QAC/B,KAAK,MAAM,UAAU,IAAI,MAAoB,EAAE,CAAC;YAC5C,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;gBACjC,sBAAsB,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;YAChD,CAAC;QACL,CAAC;IACL,CAAC;SAAM,CAAC;QACJ,IAAI,cAAc,CAAC,MAAM,CAAC,EAAE,CAAC;YACzB,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;YACjC,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;gBAChC,sBAAsB,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;YAC/C,CAAC;QACL,CAAC;aAAM,CAAC;YAEJ,OAAO,CAAC,MAAM,CAAC,CAAC;YAGhB,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;gBACpC,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;gBAC7B,IAAI,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;oBAC3C,sBAAsB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;gBAC9C,CAAC;YACL,CAAC;QACL,CAAC;IACL,CAAC;AACL,CAAC"}

package/dist/framework/properties.d.ts

@@ -0,0 +1,40 @@
+import { IEventListeners } from "./event";
+import { IAttributes, IAttributesSubscribable } from "./attributes";
+import { IStyle as Style, IStyleSubscribable as StyleSubscribable } from "./style";
+import { IDisposer, ISubscribable } from "./observable";
+export interface IWebSocketMessageHandler {
+    handleWebSocketMessage: (message: any) => void;
+}
+export interface IProperties {
+    attributes?: IAttributes | IAttributesSubscribable;
+    classNames?: Array<string> | ISubscribable<Array<string>>;
+    style?: Style | StyleSubscribable;
+    visible?: boolean | ISubscribable<boolean>;
+    disabled?: boolean | ISubscribable<boolean>;
+    innerHtml?: any | ISubscribable<any>;
+    textContent?: string | ISubscribable<string>;
+    addViewModelToDataObject?: boolean;
+    userSelectable?: boolean;
+    eventListeners?: IEventListeners;
+    elementType?: string;
+    focused?: boolean | ISubscribable<boolean>;
+}
+export declare abstract class Properties implements IProperties {
+    protected setProperties<TProperties>(object: object, properties?: TProperties): void;
+    attributes?: IAttributes | IAttributesSubscribable;
+    classNames?: Array<string> | ISubscribable<Array<string>>;
+    style?: Style | StyleSubscribable;
+    visible?: boolean | ISubscribable<boolean>;
+    disabled?: boolean | ISubscribable<boolean>;
+    innerHtml?: any | ISubscribable<any>;
+    textContent?: string | ISubscribable<string>;
+    addViewModelToDataObject?: boolean;
+    userSelectable?: boolean;
+    eventListeners?: IEventListeners;
+    elementType?: string;
+    focused?: boolean | ISubscribable<boolean>;
+}
+export declare function handleWebSocketMessage(object: object, message: any): void;
+export declare function isNullOrUndefined(value: any): boolean;
+export declare function extendProperties<TTarget = IProperties, TOverwritingProperties = TTarget, TPreserveExistingProperties = TTarget>(target: TTarget, preserveExisting: TPreserveExistingProperties, overWriteExisting?: TOverwritingProperties): TTarget;
+export declare function applyBindings(properties: IProperties, element: HTMLElement, disposers: Array<IDisposer>): void;