@photon-os/sdk 0.5.0-beta1 → 0.5.1-beta1

package/lib/SystemEvents/LifecycleEvents.js

@@ -1,19 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const events_1 = require("events");
-const __1 = require("..");
-class LifecycleEvents extends events_1.EventEmitter {
-    static on(eventName, handler) {
-        switch (eventName) {
-            case 'willEnterBackground':
-                __1.EventManager.defaultEventManager.on('os_Launcher_WillEnterBackground', handler);
-                break;
-            case 'willEnterForeground':
-                __1.EventManager.defaultEventManager.on('os_Launcher_WillEnterForeground', handler);
-                break;
-            default:
-                throw new Error('Invalid Lifecycle Event: ' + eventName);
-        }
-    }
-}
-exports.default = LifecycleEvents;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const __1 = require("..");
+class LifecycleEvents {
+    static on(eventName, handler) {
+        switch (eventName) {
+            case "willEnterBackground":
+                __1.EventManager.defaultEventManager.on("os_Launcher_WillEnterBackground", handler);
+                break;
+            case "willEnterForeground":
+                __1.EventManager.defaultEventManager.on("os_Launcher_WillEnterForeground", handler);
+                break;
+            default:
+                throw new Error("Invalid Lifecycle Event: " + eventName);
+        }
+    }
+}
+exports.default = LifecycleEvents;

package/lib/SystemMessaging/BrowserMessageListener.d.ts

@@ -1,11 +1,10 @@
-/// <reference types="node" />
-import IMessageListener from "./IMessageListener";
-import MessageBroker from "./MessageBroker";
-import { EventEmitter } from "events";
-declare class BrowserMessageListener extends EventEmitter implements IMessageListener {
-    id: string;
-    subscribe(broker: MessageBroker): void;
-    unsubscribe(broker: MessageBroker): void;
-    private messageEventHandler;
-}
-export default BrowserMessageListener;
+import IMessageListener from "./IMessageListener";
+import MessageBroker from "./MessageBroker";
+import EventEmitter from "eventemitter3";
+declare class BrowserMessageListener extends EventEmitter implements IMessageListener {
+    id: string;
+    subscribe(broker: MessageBroker): void;
+    unsubscribe(broker: MessageBroker): void;
+    private messageEventHandler;
+}
+export default BrowserMessageListener;

package/lib/SystemMessaging/BrowserMessageListener.js

@@ -1,21 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const events_1 = require("events");
-const BrowserMessagingTarget_1 = require("./BrowserMessagingTarget");
-class BrowserMessageListener extends events_1.EventEmitter {
-    constructor() {
-        super(...arguments);
-        this.id = "browser";
-    }
-    subscribe(broker) {
-        window.addEventListener("message", this.messageEventHandler.bind(this));
-    }
-    unsubscribe(broker) {
-        window.removeEventListener("message", this.messageEventHandler.bind(this));
-    }
-    messageEventHandler(e) {
-        const source = new BrowserMessagingTarget_1.default("randomid", e.source);
-        this.emit("message", { source, data: e.data });
-    }
-}
-exports.default = BrowserMessageListener;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const BrowserMessagingTarget_1 = require("./BrowserMessagingTarget");
+const eventemitter3_1 = require("eventemitter3");
+class BrowserMessageListener extends eventemitter3_1.default {
+    constructor() {
+        super(...arguments);
+        this.id = "browser";
+    }
+    subscribe(broker) {
+        window.addEventListener("message", this.messageEventHandler.bind(this));
+    }
+    unsubscribe(broker) {
+        window.removeEventListener("message", this.messageEventHandler.bind(this));
+    }
+    messageEventHandler(e) {
+        const source = new BrowserMessagingTarget_1.default("randomid", e.source);
+        this.emit("message", { source, data: e.data });
+    }
+}
+exports.default = BrowserMessageListener;

package/lib/SystemMessaging/BrowserMessagingTarget.d.ts

@@ -1,9 +1,9 @@
-import IMessagingTarget from './IMessagingTarget';
-declare class BrowserMessagingTarget implements IMessagingTarget {
-    id: string;
-    target: Window;
-    origin: string;
-    constructor(id: string, target: Window, origin?: string);
-    postMessage(message: any): void;
-}
-export default BrowserMessagingTarget;
+import IMessagingTarget from './IMessagingTarget';
+declare class BrowserMessagingTarget implements IMessagingTarget {
+    id: string;
+    target: Window;
+    origin: string;
+    constructor(id: string, target: Window, origin?: string);
+    postMessage(message: any): void;
+}
+export default BrowserMessagingTarget;

package/lib/SystemMessaging/BrowserMessagingTarget.js

@@ -1,13 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class BrowserMessagingTarget {
-    constructor(id, target, origin = '*') {
-        this.id = id;
-        this.target = target;
-        this.origin = origin;
-    }
-    postMessage(message) {
-        this.target.postMessage(message, this.origin);
-    }
-}
-exports.default = BrowserMessagingTarget;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class BrowserMessagingTarget {
+    constructor(id, target, origin = '*') {
+        this.id = id;
+        this.target = target;
+        this.origin = origin;
+    }
+    postMessage(message) {
+        this.target.postMessage(message, this.origin);
+    }
+}
+exports.default = BrowserMessagingTarget;

package/lib/SystemMessaging/IMessage.d.ts

@@ -1,6 +1,6 @@
-import IMessagingTarget from "./IMessagingTarget";
-interface IMessage {
-    source: IMessagingTarget;
-    data: any;
-}
-export default IMessage;
+import IMessagingTarget from "./IMessagingTarget";
+interface IMessage {
+    source: IMessagingTarget;
+    data: any;
+}
+export default IMessage;

package/lib/SystemMessaging/IMessage.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/SystemMessaging/IMessageListener.d.ts

@@ -1,9 +1,8 @@
-/// <reference types="node" />
-import MessageBroker from "./MessageBroker";
-import { EventEmitter } from "events";
-interface IMessageListener extends EventEmitter {
-    id: string;
-    subscribe(broker: MessageBroker): void;
-    unsubscribe(broker: MessageBroker): void;
-}
-export default IMessageListener;
+import EventEmitter from "eventemitter3";
+import MessageBroker from "./MessageBroker";
+interface IMessageListener extends EventEmitter {
+    id: string;
+    subscribe(broker: MessageBroker): void;
+    unsubscribe(broker: MessageBroker): void;
+}
+export default IMessageListener;

package/lib/SystemMessaging/IMessageListener.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/SystemMessaging/IMessagingTarget.d.ts

@@ -1,5 +1,5 @@
-interface IMessagingTarget {
-    id: string;
-    postMessage(message: any): void;
-}
-export default IMessagingTarget;
+interface IMessagingTarget {
+    id: string;
+    postMessage(message: any): void;
+}
+export default IMessagingTarget;

package/lib/SystemMessaging/IMessagingTarget.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/SystemMessaging/MessageBroker.d.ts

@@ -1,30 +1,30 @@
-import IMessagingTarget from "./IMessagingTarget";
-import IMessageListener from "./IMessageListener";
-declare class MessageBroker {
-    static defaultMessageBroker: MessageBroker;
-    targets: IMessagingTarget[];
-    services: any[];
-    listeners: IMessageListener[];
-    returnHandlers: any;
-    constructor();
-    static setDefault(defaultMessageBroker: MessageBroker): void;
-    registerTarget(target: IMessagingTarget): void;
-    unregisterTarget(targetId: string): void;
-    getTargetById(targetId: string): IMessagingTarget;
-    hasTarget(targetId: string): boolean;
-    invoke(target: IMessagingTarget, serviceId: string, methodName: string, methodArgs?: any[]): Promise<any>;
-    invokeEverywhere(serviceId: string, methodName: string, methodArgs?: any[]): void;
-    private registerReturnHandler;
-    private unregisterReturnHandler;
-    private handleReturn;
-    registerService(serviceId: string, service: any): void;
-    unregisterService(serviceId: string): void;
-    getServiceById(serviceId: string): any;
-    registerListener(listener: IMessageListener): void;
-    unregisterListener(listenerId: string): void;
-    getListenerByid(listenerId: string): IMessageListener | undefined;
-    private handleMessageEvent;
-    private handleInvoke;
-    private sendReturnValue;
-}
-export default MessageBroker;
+import IMessagingTarget from "./IMessagingTarget";
+import IMessageListener from "./IMessageListener";
+declare class MessageBroker {
+    static defaultMessageBroker: MessageBroker;
+    targets: IMessagingTarget[];
+    services: any[];
+    listeners: IMessageListener[];
+    returnHandlers: any;
+    constructor();
+    static setDefault(defaultMessageBroker: MessageBroker): void;
+    registerTarget(target: IMessagingTarget): void;
+    unregisterTarget(targetId: string): void;
+    getTargetById(targetId: string): IMessagingTarget;
+    hasTarget(targetId: string): boolean;
+    invoke(target: IMessagingTarget, serviceId: string, methodName: string, methodArgs?: any[]): Promise<any>;
+    invokeEverywhere(serviceId: string, methodName: string, methodArgs?: any[]): void;
+    private registerReturnHandler;
+    private unregisterReturnHandler;
+    private handleReturn;
+    registerService(serviceId: string, service: any): void;
+    unregisterService(serviceId: string): void;
+    getServiceById(serviceId: string): any;
+    registerListener(listener: IMessageListener): void;
+    unregisterListener(listenerId: string): void;
+    getListenerByid(listenerId: string): IMessageListener | undefined;
+    private handleMessageEvent;
+    private handleInvoke;
+    private sendReturnValue;
+}
+export default MessageBroker;

package/lib/SystemMessaging/MessageBroker.js

@@ -1,147 +1,147 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const VoidMessagingTarget_1 = require("./VoidMessagingTarget");
-const uuid_1 = require("uuid");
-class MessageBroker {
-    constructor() {
-        this.targets = [];
-        this.services = [];
-        this.listeners = [];
-        this.returnHandlers = {};
-    }
-    static setDefault(defaultMessageBroker) {
-        MessageBroker.defaultMessageBroker = defaultMessageBroker;
-    }
-    registerTarget(target) {
-        if (this.hasTarget(target.id)) {
-            console.warn(`Attempted to register duplicate target: ${target.id}`);
-            return;
-        }
-        this.targets.push(target);
-    }
-    unregisterTarget(targetId) {
-        this.targets = this.targets.filter((t) => t.id !== targetId);
-    }
-    getTargetById(targetId) {
-        const matchingTarget = this.targets.find((t) => t.id === targetId);
-        return matchingTarget || new VoidMessagingTarget_1.default(targetId);
-    }
-    hasTarget(targetId) {
-        return this.targets.find((t) => t.id === targetId) !== undefined;
-    }
-    invoke(target, serviceId, methodName, methodArgs) {
-        return new Promise((resolve) => {
-            const returnId = `${methodName}_${uuid_1.v4()}`;
-            this.registerReturnHandler(returnId, resolve);
-            target.postMessage({
-                __type: "invoke",
-                serviceId,
-                methodName,
-                methodArgs,
-                returnId,
-            });
-        });
-    }
-    invokeEverywhere(serviceId, methodName, methodArgs) {
-        this.targets.forEach((target) => this.invoke(target, serviceId, methodName, methodArgs));
-    }
-    registerReturnHandler(returnId, callback) {
-        this.returnHandlers[returnId] = callback;
-    }
-    unregisterReturnHandler(returnId) {
-        delete this.returnHandlers[returnId];
-    }
-    handleReturn(message) {
-        const { returnId, returnValue } = message.data;
-        const returnHandler = this.returnHandlers[returnId];
-        if (returnHandler === undefined) {
-            console.warn(`Attempted to invoke unknown return handler: ${returnId}`);
-            return;
-        }
-        returnHandler(returnValue);
-        this.unregisterReturnHandler(returnId);
-    }
-    registerService(serviceId, service) {
-        const existingService = this.getServiceById(serviceId);
-        if (existingService !== undefined) {
-            console.warn(`Attempted to regsiter duplciate service: ${serviceId}`);
-            return;
-        }
-        this.services.push({ id: serviceId, methods: service });
-    }
-    unregisterService(serviceId) {
-        this.services = this.services.filter((s) => s.id !== serviceId);
-    }
-    getServiceById(serviceId) {
-        return this.services.find((s) => s.id === serviceId);
-    }
-    registerListener(listener) {
-        const existingListener = this.getListenerByid(listener.id);
-        if (existingListener !== undefined) {
-            console.warn(`Attempted to register duplicate listener: ${listener.id}`);
-            return;
-        }
-        this.listeners.push(listener);
-        listener.on("message", this.handleMessageEvent.bind(this));
-        listener.subscribe(this);
-    }
-    unregisterListener(listenerId) {
-        const existingListener = this.getListenerByid(listenerId);
-        this.listeners = this.listeners.filter((l) => l.id !== listenerId);
-        if (existingListener !== undefined) {
-            existingListener.off("message", this.handleMessageEvent.bind(this));
-            existingListener.unsubscribe(this);
-        }
-    }
-    getListenerByid(listenerId) {
-        return this.listeners.find((l) => l.id === listenerId);
-    }
-    handleMessageEvent(message) {
-        if (message.data.__type === undefined)
-            return;
-        switch (message.data.__type) {
-            case "invoke":
-                this.handleInvoke(message);
-                break;
-            case "return":
-                this.handleReturn(message);
-                break;
-            default:
-                return;
-        }
-    }
-    handleInvoke(message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { serviceId, methodName, methodArgs, returnId } = message.data;
-            const matchingService = this.getServiceById(serviceId);
-            if (matchingService === undefined) {
-                console.error(`Attempted to invoke unknown service: ${serviceId}`);
-                return;
-            }
-            const matchingMethod = matchingService.methods[methodName];
-            if (matchingMethod === undefined) {
-                console.error(`Attepted to invoke unknown method: ${serviceId}.${methodName}`);
-                return;
-            }
-            const returnValue = yield matchingMethod(...(methodArgs || []));
-            this.sendReturnValue(message.source, returnId, returnValue);
-        });
-    }
-    sendReturnValue(target, returnId, returnValue) {
-        target.postMessage({
-            __type: "return",
-            returnId,
-            returnValue,
-        });
-    }
-}
-exports.default = MessageBroker;
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const VoidMessagingTarget_1 = require("./VoidMessagingTarget");
+const uuid_1 = require("uuid");
+class MessageBroker {
+    constructor() {
+        this.targets = [];
+        this.services = [];
+        this.listeners = [];
+        this.returnHandlers = {};
+    }
+    static setDefault(defaultMessageBroker) {
+        MessageBroker.defaultMessageBroker = defaultMessageBroker;
+    }
+    registerTarget(target) {
+        if (this.hasTarget(target.id)) {
+            console.warn(`Attempted to register duplicate target: ${target.id}`);
+            return;
+        }
+        this.targets.push(target);
+    }
+    unregisterTarget(targetId) {
+        this.targets = this.targets.filter((t) => t.id !== targetId);
+    }
+    getTargetById(targetId) {
+        const matchingTarget = this.targets.find((t) => t.id === targetId);
+        return matchingTarget || new VoidMessagingTarget_1.default(targetId);
+    }
+    hasTarget(targetId) {
+        return this.targets.find((t) => t.id === targetId) !== undefined;
+    }
+    invoke(target, serviceId, methodName, methodArgs) {
+        return new Promise((resolve) => {
+            const returnId = `${methodName}_${uuid_1.v4()}`;
+            this.registerReturnHandler(returnId, resolve);
+            target.postMessage({
+                __type: "invoke",
+                serviceId,
+                methodName,
+                methodArgs,
+                returnId,
+            });
+        });
+    }
+    invokeEverywhere(serviceId, methodName, methodArgs) {
+        this.targets.forEach((target) => this.invoke(target, serviceId, methodName, methodArgs));
+    }
+    registerReturnHandler(returnId, callback) {
+        this.returnHandlers[returnId] = callback;
+    }
+    unregisterReturnHandler(returnId) {
+        delete this.returnHandlers[returnId];
+    }
+    handleReturn(message) {
+        const { returnId, returnValue } = message.data;
+        const returnHandler = this.returnHandlers[returnId];
+        if (returnHandler === undefined) {
+            console.warn(`Attempted to invoke unknown return handler: ${returnId}`);
+            return;
+        }
+        returnHandler(returnValue);
+        this.unregisterReturnHandler(returnId);
+    }
+    registerService(serviceId, service) {
+        const existingService = this.getServiceById(serviceId);
+        if (existingService !== undefined) {
+            console.warn(`Attempted to regsiter duplciate service: ${serviceId}`);
+            return;
+        }
+        this.services.push({ id: serviceId, methods: service });
+    }
+    unregisterService(serviceId) {
+        this.services = this.services.filter((s) => s.id !== serviceId);
+    }
+    getServiceById(serviceId) {
+        return this.services.find((s) => s.id === serviceId);
+    }
+    registerListener(listener) {
+        const existingListener = this.getListenerByid(listener.id);
+        if (existingListener !== undefined) {
+            console.warn(`Attempted to register duplicate listener: ${listener.id}`);
+            return;
+        }
+        this.listeners.push(listener);
+        listener.on("message", this.handleMessageEvent.bind(this));
+        listener.subscribe(this);
+    }
+    unregisterListener(listenerId) {
+        const existingListener = this.getListenerByid(listenerId);
+        this.listeners = this.listeners.filter((l) => l.id !== listenerId);
+        if (existingListener !== undefined) {
+            existingListener.off("message", this.handleMessageEvent.bind(this));
+            existingListener.unsubscribe(this);
+        }
+    }
+    getListenerByid(listenerId) {
+        return this.listeners.find((l) => l.id === listenerId);
+    }
+    handleMessageEvent(message) {
+        if (message.data.__type === undefined)
+            return;
+        switch (message.data.__type) {
+            case "invoke":
+                this.handleInvoke(message);
+                break;
+            case "return":
+                this.handleReturn(message);
+                break;
+            default:
+                return;
+        }
+    }
+    handleInvoke(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { serviceId, methodName, methodArgs, returnId } = message.data;
+            const matchingService = this.getServiceById(serviceId);
+            if (matchingService === undefined) {
+                console.error(`Attempted to invoke unknown service: ${serviceId}`);
+                return;
+            }
+            const matchingMethod = matchingService.methods[methodName];
+            if (matchingMethod === undefined) {
+                console.error(`Attepted to invoke unknown method: ${serviceId}.${methodName}`);
+                return;
+            }
+            const returnValue = yield matchingMethod(...(methodArgs || []));
+            this.sendReturnValue(message.source, returnId, returnValue);
+        });
+    }
+    sendReturnValue(target, returnId, returnValue) {
+        target.postMessage({
+            __type: "return",
+            returnId,
+            returnValue,
+        });
+    }
+}
+exports.default = MessageBroker;

package/lib/SystemMessaging/SecondLIfeMessagingListener.d.ts

@@ -1,14 +1,13 @@
-/// <reference types="node" />
-import IMessageListener from "./IMessageListener";
-import MessageBroker from "./MessageBroker";
-import { EventEmitter } from "events";
-declare class SecondLifeMessagingListener extends EventEmitter implements IMessageListener {
-    id: string;
-    senderId: string;
-    socket: any;
-    constructor(senderId: string, socket: any);
-    subscribe(broker: MessageBroker): void;
-    unsubscribe(broker: MessageBroker): void;
-    private messageEventHandler;
-}
-export default SecondLifeMessagingListener;
+import IMessageListener from "./IMessageListener";
+import MessageBroker from "./MessageBroker";
+import EventEmitter from "eventemitter3";
+declare class SecondLifeMessagingListener extends EventEmitter implements IMessageListener {
+    id: string;
+    senderId: string;
+    socket: any;
+    constructor(senderId: string, socket: any);
+    subscribe(broker: MessageBroker): void;
+    unsubscribe(broker: MessageBroker): void;
+    private messageEventHandler;
+}
+export default SecondLifeMessagingListener;