jpf 5.0.61 → 5.0.63

package/src/index.ts

@@ -4,8 +4,7 @@ import * as utilities from "./utilities/index";
 import * as attributes from "./framework/attributes";
 import * as element from "./framework/element";
 import * as event from "./framework/event";
-import * as observableInterfaces from "./framework/observableInterfaces";
-import * as observableImplementations from "./framework/observablelmplementations";
+import * as observable from "./framework/observable";
 import * as properties from "./framework/properties";
 import * as root from "./framework/root";
 import * as style from "./framework/style";
@@ -16,8 +15,7 @@ export { utilities };
 
 export { attributes };
 export { element };
-export { observableInterfaces };
-export { observableImplementations };
+export { observable };
 export { event };
 export { properties };
 export { root };

package/src/utilities/object/object.ts

@@ -0,0 +1,56 @@
+import { observable } from "../../framework/observable.js";
+export interface IWebSocketMessageHandler {
+    handleWebSocketMessage: (message: unknown) => void;
+}
+
+export function handleWebSocketMessage(context: object, message: unknown) {
+    executeHandlerOnContext(
+        context,
+        (context) => {
+            const webSocketMessageHandler = context as IWebSocketMessageHandler;
+            if (webSocketMessageHandler.handleWebSocketMessage && typeof webSocketMessageHandler.handleWebSocketMessage === "function") {
+                //Call the handleWebSocketMessage method
+                webSocketMessageHandler.handleWebSocketMessage(message);
+            }
+        }
+    );
+}
+export function executeHandlerOnContext(context: object, handler: (context) => void, alreadyProcessedContexts?: Set<object>) {
+    if (!alreadyProcessedContexts) {
+        alreadyProcessedContexts = new Set();
+    }
+
+    if (!context || typeof context !== "object" || alreadyProcessedContexts.has(context)) {
+        return;
+    }
+
+    //Add the context to the alreadyProcessedContext to prevent processing the same object twice.
+    alreadyProcessedContexts.add(context);
+
+    //Find out if the object is an array
+    if (Array.isArray(context)) {
+        for (const arrayEntry of context as Array<unknown>) {
+            if (typeof arrayEntry === "object") {
+                executeHandlerOnContext(arrayEntry, handler, alreadyProcessedContexts);
+            }
+        }
+    } else {
+        if (observable.isSubscribable(context)) {
+            const unwrapped = observable.unwrap(context);
+            if (typeof unwrapped === "object") {
+                executeHandlerOnContext(unwrapped, handler, alreadyProcessedContexts);
+            }
+        } else {
+            //Call the handler on the object.
+            handler(context);
+
+            //Find out if the object has properties of type object
+            for (const key of Object.keys(context)) {
+                const property = context[key];
+                if (property && typeof property === "object") {
+                    executeHandlerOnContext(property, handler, alreadyProcessedContexts);
+                }
+            }
+        }
+    }
+}

package/src/utilities/value/value.ts

@@ -0,0 +1,3 @@
+export function isNullOrUndefined(value): boolean {
+    return value === null || typeof value === "undefined";
+}

package/src/framework/observableInterfaces.ts

@@ -1,39 +0,0 @@
-export interface IDisposer {
-    (): void;
-}
-
-export interface ISubscribable<TValue> {
-    subscribe(handler: (arg: TValue, prev: TValue) => void): IDisposer;
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export interface IObservableValue<TValue = any, TSetter = TValue> extends ISubscribable<TValue> {
-    get(): TValue;
-    setValue(value: TSetter | null): void;
-    setValueInAction(value: TSetter | null): void;
-    setInternal(value: TValue | null): void;
-    setInternalInAction(value: TValue | null): void;
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export interface IObservableArray<TItem = any, TSetter = Array<TItem>> extends Array<TItem>, ISubscribable<Array<TItem>> {
-    get(): Array<TItem>;
-    setItems(items: TSetter | null, triggerSetter?: boolean): void;
-    setItemsInAction(items: TSetter | null): void;
-    setInternal(items: Array<TItem> | null): void;
-    setInternalInAction(items: Array<TItem> | null): void;
-}
-
-export interface IComputed<TValue> extends ISubscribable<TValue> {
-    get(): TValue;
-}
-
-// eslint-disable-next-line @typescript-eslint/no-empty-object-type, @typescript-eslint/no-unused-vars
-export interface IObservableMap<TKey, TValue> {
-
-}
-
-// eslint-disable-next-line @typescript-eslint/no-empty-object-type, @typescript-eslint/no-unused-vars
-export interface IObservableSet<TItem> {
-
-}