jpf 4.2.15 → 4.2.17

package/src/framework/event.ts

@@ -0,0 +1,98 @@
+import * as leaflet from "leaflet";
+
+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: keyof UiElementEventMap): boolean {
+    return !(mouseEvents[event] || touchEvents[event]);
+}
+
+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;
+}

package/src/framework/observable.ts

@@ -0,0 +1,80 @@
+import { Subscribable, ObservableArray, Observable, isObservable, observable, observableArray, pureComputed } from "knockout";
+
+export interface ObservableProperty<TValue = any, TSetter = TValue> extends Subscribable<TValue> {
+    (): TValue;
+    set: (value: TSetter | null, triggerSetter?: boolean) => void;
+}
+
+export function isObservableProperty<T = any>(instance: any): instance is ObservableProperty<T> {
+    return instance && !!(instance as ObservableProperty<T>).set;
+}
+
+export function observableProperty<TValue, TSetter = TValue>(value?: TValue | Observable<TValue>, setter?: (value: TSetter, internalProperty: Observable<TValue>) => void, notifyAlways: boolean = false): ObservableProperty<TValue, TSetter> {
+    let internalProperty: Observable<TValue>;
+    if (value === undefined) {
+        value = null;
+    }
+    if (isObservable(value)) {
+        internalProperty = value;
+    } else {
+        internalProperty = observable<TValue>(value);
+    }
+
+    if (notifyAlways) {
+        internalProperty.extend({ notify: "always" });
+    }
+
+    //Wrap the internal property in a computed so the property becomes readonly
+    const computed = pureComputed({ read: internalProperty }).extend({ notify: "always" }) as any as ObservableProperty<TValue, TSetter>;
+
+    computed.set = (newValue: any, triggerSetter: boolean = true) => {
+        if (setter && triggerSetter) {
+            setter(newValue, internalProperty);
+        } else {
+            internalProperty(newValue);
+        }
+    };
+
+    return computed;
+}
+
+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 function observableArrayProperty<TItem, TSetter = Array<TItem>>(items?: Array<TItem> | ObservableArray<TItem>, setter?: (items: TSetter, internalProperty: ObservableArray<TItem>) => void): ObservableArrayProperty<TItem, TSetter> {
+    //Create an ObservableArray to hold the Items.
+    let internalProperty: ObservableArray<TItem>;
+    if (!items) {
+        items = [];
+    }
+    if (isObservable(items)) {
+        internalProperty = items;
+    } else {
+        internalProperty = observableArray<TItem>(items);
+    }
+
+    //Wrap the ObservableArray in a computed so the property becomes readonly
+    const computed = pureComputed({ read: internalProperty }).extend({ notify: "always" }) as any as ObservableArrayProperty<TItem, TSetter>;
+
+    computed.set = (value: any, triggerSetter: boolean = true) => {
+        if (setter && triggerSetter) {
+            setter(value, internalProperty);
+        } else {
+            internalProperty(value);
+        }
+    };
+
+    computed.push = (...itemsToPush) => {
+        internalProperty.push(...itemsToPush);
+        return itemsToPush.length;
+    }
+
+    computed.map = (callBack: (value: TItem, index: number, array: TItem[]) => any, thisArg?: any) => {
+        //Call the map function on the underlying array
+        return internalProperty().map(callBack, thisArg);
+    }
+
+    return computed;
+}