@denevads/dnv-smo 1.0.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./";

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./"), exports);

package/dist/interfaces/callbacks.d.ts

@@ -0,0 +1,31 @@
+export interface setDatasource {
+    xml: string;
+}
+export interface variable {
+    variable: string;
+    valor: string;
+}
+export interface location {
+    top: string;
+    left: string;
+    width: string;
+    height: string;
+}
+export interface Slide {
+    codigo: string;
+    idioma: string;
+    denominacion: string;
+    hash: string;
+}
+export interface DataSalida {
+    dataKey: string;
+    data: Slide[];
+}
+export interface ExecFunction {
+    funcion: string;
+    params: string;
+}
+export interface Notify {
+    destion: string;
+    value: any;
+}

package/dist/interfaces/callbacks.js

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

package/dist/smo.d.ts

@@ -0,0 +1,82 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { setDatasource, variable, location, DataSalida, ExecFunction, Notify } from "./interfaces/callbacks";
+export declare class SMO extends EventEmitter {
+    vars: any;
+    id: string;
+    smoCallBacks: smoCallBacks;
+    utils: Utils;
+    constructor();
+    init(): void;
+    initOnMessage(): void;
+    start(): void;
+    setDatasource(datasource: setDatasource): void;
+    getVariable(variable: variable): void;
+    setCurrentStream(stream: string): void;
+    infoCurrentLocation(location: location): void;
+    setSalidaData(data: DataSalida): void;
+    updatefromsalida(data: any): void;
+}
+declare class smoCallBacks {
+    smo: SMO;
+    constructor(_smo: SMO);
+    onSmoLoad(): void;
+    onSmoReady(): void;
+    smoLog(msn: string, level: LogLevel): void;
+    smoAlarma(msn: string, level: AlarmaLevel): void;
+    reiniciarDispositivo(msn: string): void;
+    urlNext(): void;
+    exitInteractivity(): void;
+    showBrowser(): void;
+    closeBrowser(): void;
+    urlNextDirectamente(): void;
+    setVariable(variable: string, valor: string): void;
+    getVariable(variable: string): void;
+    getFile(file: string): void;
+    setLocalData(variable: string, valor: string): void;
+    getLocalData(variable: string): void;
+    getCurrentStream(): void;
+    finAviso(id: string): void;
+    refreshDatasource(codigo: string): void;
+    getLocation(): void;
+    getSalidaData(data: string): void;
+    ejecutaFuncion(data: ExecFunction): void;
+    addObserver(data: string): void;
+    notify(data: Notify): void;
+    playOnceChannelByTrigger(trigger: string): void;
+    stopPlayOnceChannelByTrigger(): void;
+    playOnceChannel(codigoCanal: string): void;
+    stopPlayChannel(): void;
+}
+declare class Utils {
+    smo: SMO;
+    smoCallBacks: smoCallBacks;
+    constructor(_smo: SMO, _smoCallBacks: smoCallBacks);
+    dataToJSON(data: setDatasource): any;
+    getDatasource(): void;
+    startCheckDatasource(): void;
+}
+export declare enum SMO_EVENT_TYPE {
+    start = "start",
+    setDatasource = "setDatasource",
+    getVariable = "getVariable",
+    setCurrentStream = "setCurrentStream",
+    infoCurrentLocation = "infoCurrentLocation",
+    setSalidaData = "setSalidaData",
+    updatefromsalida = "updatefromsalida"
+}
+export declare enum LogLevel {
+    Debug = 0,
+    Info = 1,
+    Warning = 2,
+    Error = 3
+}
+export declare enum AlarmaLevel {
+    Ok_off = 0,
+    Ok = 1,
+    Scanning = 2,
+    Timeout = 3,
+    Warning = 4,
+    Error = 5
+}
+export {};

package/dist/smo.js

@@ -0,0 +1,423 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlarmaLevel = exports.LogLevel = exports.SMO_EVENT_TYPE = exports.SMO = void 0;
+var events_1 = require("events");
+var SMO = /** @class */ (function (_super) {
+    __extends(SMO, _super);
+    function SMO() {
+        var _this = _super.call(this) || this;
+        _this.vars = {};
+        _this.id = "";
+        _this.init();
+        _this.initOnMessage();
+        _this.smoCallBacks = new smoCallBacks(_this);
+        _this.utils = new Utils(_this, _this.smoCallBacks);
+        return _this;
+    }
+    SMO.prototype.init = function () {
+        var match, pl = /\+/g, search = /([^&=]+)=?([^&]*)/g, decode = function (s) {
+            return decodeURIComponent(s.replace(pl, " "));
+        }, query = window.location.search.substring(1);
+        while (match = search.exec(query)) {
+            this.vars[decode(match[1])] = decode(match[2]);
+        }
+        if (this.vars.idSmo) {
+            this.id = this.vars.idSmo;
+            return;
+        }
+        console.warn("No idSmo found in URL");
+    };
+    SMO.prototype.initOnMessage = function () {
+        var selft = this;
+        window.onmessage = function (e) {
+            if (e.data.target) {
+                var targets = e.data.target.split('.');
+                var func = targets[targets.length - 1];
+                if (func == SMO_EVENT_TYPE.start) {
+                    selft.start();
+                    return;
+                }
+                if (func == SMO_EVENT_TYPE.setDatasource) {
+                    selft.setDatasource(e.data.objData);
+                    return;
+                }
+                if (func == SMO_EVENT_TYPE.getVariable) {
+                    selft.getVariable(e.data.objData);
+                    return;
+                }
+                if (func == SMO_EVENT_TYPE.setCurrentStream) {
+                    selft.setCurrentStream(e.data.objData);
+                    return;
+                }
+                if (func == SMO_EVENT_TYPE.infoCurrentLocation) {
+                    selft.infoCurrentLocation(e.data.objData);
+                    return;
+                }
+                if (func == SMO_EVENT_TYPE.setSalidaData) {
+                    selft.setSalidaData(e.data.objData);
+                    return;
+                }
+                if (func == SMO_EVENT_TYPE.updatefromsalida) {
+                    selft.updatefromsalida(e.data.objdata);
+                    return;
+                }
+                console.warn("message not implemented!!" + func);
+                /* try {
+                    var targets = e.data.target.split('.');
+                    var fn = window;
+                    var obj = window;
+                    for (var i = 0; i < targets.length; i++) {
+                        obj = fn;
+                        fn = obj[targets[i]];
+                    }
+                    fn.call(obj, e.data.objData); // conservamos el valor de this
+                } catch (ex) {
+                    //Si no ha podido llamar es porque no existe el entorno
+
+                }*/
+            }
+        };
+    };
+    SMO.prototype.start = function () {
+        this.emit(SMO_EVENT_TYPE.start);
+    };
+    SMO.prototype.setDatasource = function (datasource) {
+        this.emit(SMO_EVENT_TYPE.setDatasource, datasource);
+    };
+    SMO.prototype.getVariable = function (variable) {
+        this.emit(SMO_EVENT_TYPE.getVariable, variable);
+    };
+    SMO.prototype.setCurrentStream = function (stream) {
+        this.emit(SMO_EVENT_TYPE.setCurrentStream, stream);
+    };
+    SMO.prototype.infoCurrentLocation = function (location) {
+        this.emit(SMO_EVENT_TYPE.infoCurrentLocation, location);
+    };
+    SMO.prototype.setSalidaData = function (data) {
+        this.emit(SMO_EVENT_TYPE.setSalidaData, data);
+    };
+    SMO.prototype.updatefromsalida = function (data) {
+        this.emit(SMO_EVENT_TYPE.updatefromsalida, data);
+    };
+    return SMO;
+}(events_1.EventEmitter));
+exports.SMO = SMO;
+var smoCallBacks = /** @class */ (function () {
+    function smoCallBacks(_smo) {
+        this.smo = _smo;
+    }
+    smoCallBacks.prototype.onSmoLoad = function () {
+        window.parent.postMessage({
+            target: "Dnv.smoCallbacks.onSmoLoad",
+            objData: undefined,
+            idSmo: this.smo.id
+        }, "*");
+    };
+    smoCallBacks.prototype.onSmoReady = function () {
+        window.parent.postMessage({
+            target: "Dnv.smoCallbacks.onSmoReady",
+            objData: undefined,
+            idSmo: this.smo.id
+        }, "*");
+    };
+    smoCallBacks.prototype.smoLog = function (msn, level) {
+        if (level == undefined) {
+            level = LogLevel.Info;
+        }
+        //level = Dnv.LogLevel.Debug...
+        if (level == LogLevel.Debug) {
+            console.debug(msn);
+        }
+        if (level == LogLevel.Info) {
+            console.log(msn);
+        }
+        if (level == LogLevel.Warning) {
+            console.warn(msn);
+        }
+        if (level == LogLevel.Error) {
+            console.error(msn);
+        }
+        if (window.parent != window) {
+            window.parent.postMessage({
+                target: "Dnv.smoCallbacks.smoLog",
+                objData: {
+                    level: level,
+                    txt: msn
+                },
+                idSmo: this.smo.id
+            }, "*");
+        }
+    };
+    smoCallBacks.prototype.smoAlarma = function (msn, level) {
+        window.parent.postMessage({
+            target: "Dnv.smoCallbacks.smoAlarma",
+            objData: {
+                level: level,
+                txt: msn
+            },
+            idSmo: this.smo.id
+        }, "*");
+    };
+    smoCallBacks.prototype.reiniciarDispositivo = function (msn) {
+        //Permite reiniciar el player, proporcionando una razón para el reinicio. Solo Player HTML5
+        window.parent.postMessage({
+            target: "Dnv.smoCallbacks.reiniciarDispositivo",
+            objData: {
+                txt: msn // Razón del reinicio 
+            },
+            idSmo: this.smo.id
+        }, "*");
+    };
+    smoCallBacks.prototype.urlNext = function () {
+        //Permite avanzar plantilla. Solo si Reloj Maestro activado.
+        window.parent.postMessage({
+            target: "Dnv.smoCallbacks.urlNext",
+            objData: undefined,
+            idSmo: this.smo.id
+        }, "*");
+    };
+    smoCallBacks.prototype.exitInteractivity = function () {
+        //Para canales interactivos, vuelve al canal de reposo. Solo Android y Player PC.
+        window.parent.postMessage({
+            target: "Dnv.smoCallbacks.exitInteractivity",
+            objData: undefined,
+            idSmo: this.smo.id
+        }, "*");
+    };
+    smoCallBacks.prototype.showBrowser = function () {
+        /* DEPRECATED NOT IMPLEMENTED */
+    };
+    smoCallBacks.prototype.closeBrowser = function () {
+        /* DEPRECATED NOT IMPLEMENTED */
+    };
+    smoCallBacks.prototype.urlNextDirectamente = function () {
+        /* NOT IMPLEMENTED */
+    };
+    smoCallBacks.prototype.setVariable = function (variable, valor) {
+        window.parent.postMessage({
+            target: "Dnv.smoCallbacks.setVariable",
+            objData: {
+                variable: variable,
+                valor: valor
+            },
+            idSmo: this.smo.id
+        }, "*");
+    };
+    smoCallBacks.prototype.getVariable = function (variable) {
+        window.parent.postMessage({
+            target: "Dnv.smoCallbacks.getVariable",
+            objData: {
+                variable: variable
+            },
+            idSmo: this.smo.id
+        }, "*");
+        /* MIRAR SMO.getVariable */
+    };
+    smoCallBacks.prototype.getFile = function (file) {
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.getFile",
+            objData: file,
+            idSmo: this.smo.id
+        }, "*");
+    };
+    smoCallBacks.prototype.setLocalData = function (variable, valor) {
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.setLocalData",
+            objData: {
+                nameData: variable,
+                data: valor
+            },
+            idSmo: this.smo.id
+        }, "*");
+    };
+    smoCallBacks.prototype.getLocalData = function (variable) {
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.getLocalData",
+            objData: variable,
+            idSmo: this.smo.id
+        }, "*");
+        /* MIRAR SMO.setDatasource */
+    };
+    smoCallBacks.prototype.getCurrentStream = function () {
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.getCurrentStream",
+            objData: undefined,
+            idSmo: this.smo.id
+        }, "*");
+        /* MIRAR SMO.setCurrentStream' */
+    };
+    smoCallBacks.prototype.finAviso = function (id) {
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.finAviso",
+            objData: id,
+            idSmo: this.smo.id
+        }, "*");
+    };
+    smoCallBacks.prototype.refreshDatasource = function (codigo) {
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.refreshDatasource",
+            objData: codigo,
+            idSmo: this.smo.id
+        }, "*");
+    };
+    smoCallBacks.prototype.getLocation = function () {
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.getLocation",
+            objData: undefined,
+            idSmo: this.smo.id
+        }, "*");
+        /* MIRAR SMO.infoCurrentLocation   */
+    };
+    smoCallBacks.prototype.getSalidaData = function (data) {
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.getSalidaData",
+            objData: data,
+            idSmo: this.smo.id
+        }, "*");
+        /* MIRAR SMO.setSalidaData */
+    };
+    smoCallBacks.prototype.ejecutaFuncion = function (data) {
+        /*data ={
+                funcion: "", // Nombre de la función que se debe ejecutar
+                params: "" // Parámetros que debemos enviarle a la funcion. sin separadores ni nada, un string y se usa como tal. Solo esta implementada en un caso y se usa como tal sin parsear ni nada
+            } */
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.ejecutaFuncion",
+            objData: data,
+            idSmo: this.smo.id
+        }, "*");
+    };
+    smoCallBacks.prototype.addObserver = function (data) {
+        /*data ="fruta"
+         */
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.addObserver",
+            objData: data,
+            idSmo: this.smo.id
+        }, "*");
+    };
+    smoCallBacks.prototype.notify = function (data) {
+        /*data ={
+                destino: "fruta",
+                value: "{'fruta':'manzana', 'color':'roja'}"
+            } */
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.notify",
+            objData: data,
+            idSmo: this.smo.id
+        }, "*");
+    };
+    smoCallBacks.prototype.playOnceChannelByTrigger = function (trigger) {
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.playOnceChannelByTrigger",
+            objData: { triggerCanal: trigger },
+            idSmo: this.smo.id
+        }, "*");
+    };
+    smoCallBacks.prototype.stopPlayOnceChannelByTrigger = function () {
+        parent.postMessage({ target: "Dnv.smoCallbacks.stopPlayOnceChannelByTrigger", objData: {}, idSmo: this.smo.id }, "*");
+    };
+    smoCallBacks.prototype.playOnceChannel = function (codigoCanal) {
+        parent.postMessage({ target: "Dnv.smoCallbacks.playOnceChannel", objData: { codigoCanal: codigoCanal, params: "PLAYONCE_CHANNEL|" + codigoCanal }, idSmo: this.smo.id }, "*");
+    };
+    smoCallBacks.prototype.stopPlayChannel = function () {
+        parent.postMessage({ target: "Dnv.smoCallbacks.stopPlayOnceChannel", objData: {}, idSmo: this.smo.id }, "*");
+    };
+    return smoCallBacks;
+}());
+var Utils = /** @class */ (function () {
+    function Utils(_smo, _smoCallBacks) {
+        this.smo = _smo;
+        this.smoCallBacks = _smoCallBacks;
+    }
+    Utils.prototype.dataToJSON = function (data) {
+        try {
+            var parser = new DOMParser();
+            var xmlDoc = parser.parseFromString(data.xml, "text/xml");
+            var dataForJSON = xmlDoc.getElementsByTagName("item")[0].innerHTML;
+            dataForJSON = dataForJSON.replace(/{'/g, '{"').replace(/'}/g, '"}').replace(/:'/g, ':"').replace(/':/g, '":').replace(/,'/g, ',"').replace(/',/g, '",').replace(/\['/g, '["').replace(/'\]/g, '"]').replace(/(\r\n|\n|\r)/gm, "");
+            return JSON.parse(dataForJSON);
+        }
+        catch (error) {
+            return {};
+        }
+    };
+    Utils.prototype.getDatasource = function () {
+        if (this.smo.vars.url == undefined) {
+            this.smoCallBacks.getFile(this.smo.vars.LocalData);
+            return;
+        }
+        this.smoCallBacks.getFile(this.smo.vars.url);
+    };
+    Utils.prototype.startCheckDatasource = function () {
+        this.getDatasource();
+        var self = this;
+        setInterval(function () {
+            self.getDatasource();
+        }, 10000);
+    };
+    return Utils;
+}());
+var SMO_EVENT_TYPE;
+(function (SMO_EVENT_TYPE) {
+    SMO_EVENT_TYPE["start"] = "start";
+    SMO_EVENT_TYPE["setDatasource"] = "setDatasource";
+    SMO_EVENT_TYPE["getVariable"] = "getVariable";
+    SMO_EVENT_TYPE["setCurrentStream"] = "setCurrentStream";
+    SMO_EVENT_TYPE["infoCurrentLocation"] = "infoCurrentLocation";
+    SMO_EVENT_TYPE["setSalidaData"] = "setSalidaData";
+    SMO_EVENT_TYPE["updatefromsalida"] = "updatefromsalida";
+})(SMO_EVENT_TYPE = exports.SMO_EVENT_TYPE || (exports.SMO_EVENT_TYPE = {}));
+/*         start():void{
+        this.emit("start");
+    }
+    setDatasource(datasource:setDatasource):void {
+        this.emit("setDatasource",datasource);
+    }
+    getVariable(variable:variable):void{
+        this.emit("getVariable",variable);
+    }
+    setCurrentStream(stream:string):void{
+    this.emit("setCurrentStream",stream);
+    }
+    infoCurrentLocation(location:location):void{
+        this.emit("infoCurrentLocation",location);
+    }
+    setSalidaData(data:DataSalida):void{
+    this.emit("setSalidaData",data);
+    }
+    
+    updatefromsalida(data:any):void{
+        this.emit("updatefromsalida",data);
+    } */
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["Debug"] = 0] = "Debug";
+    LogLevel[LogLevel["Info"] = 1] = "Info";
+    LogLevel[LogLevel["Warning"] = 2] = "Warning";
+    LogLevel[LogLevel["Error"] = 3] = "Error";
+})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));
+var AlarmaLevel;
+(function (AlarmaLevel) {
+    AlarmaLevel[AlarmaLevel["Ok_off"] = 0] = "Ok_off";
+    AlarmaLevel[AlarmaLevel["Ok"] = 1] = "Ok";
+    AlarmaLevel[AlarmaLevel["Scanning"] = 2] = "Scanning";
+    AlarmaLevel[AlarmaLevel["Timeout"] = 3] = "Timeout";
+    AlarmaLevel[AlarmaLevel["Warning"] = 4] = "Warning";
+    AlarmaLevel[AlarmaLevel["Error"] = 5] = "Error";
+})(AlarmaLevel = exports.AlarmaLevel || (exports.AlarmaLevel = {}));

package/package.json

@@ -0,0 +1,20 @@
+{
+    "name": "@denevads/dnv-smo",
+    "version": "1.0.0",
+    "description": "SMO module",
+    "main": "./src/index.js",
+    "types": "./src/index.d.ts",
+    "scripts": {
+        "build": "tsc"
+    },
+    "compilerOptions": {
+        "outDir": "./dist",
+        "types": []
+    },
+    "keywords": [],
+    "author": "Xavier",
+    "license": "MIT",
+    "devDependencies": {
+        "@types/node": "^17.0.42"
+    }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./";

package/src/interfaces/callbacks.ts

@@ -0,0 +1,33 @@
+
+export  interface setDatasource{
+    xml:string
+}
+export interface variable{
+    variable:string,
+    valor:string
+}
+export interface location{
+    top:string,
+    left:string,
+    width:string,
+    height:string
+}
+export interface Slide {
+    codigo: string;
+    idioma: string;
+    denominacion: string;
+    hash: string;
+}
+
+export interface DataSalida {
+    dataKey: string;
+    data: Slide[];
+}
+export interface ExecFunction{
+    funcion:string,
+    params:string
+}
+export interface Notify{
+    destion:string,
+    value:any
+}

package/src/smo.ts

@@ -0,0 +1,414 @@
+import {EventEmitter} from 'events';
+import { setDatasource,variable,location,DataSalida, ExecFunction, Notify } from "./interfaces/callbacks";
+
+export  class SMO extends EventEmitter{
+   public  vars:any = {};
+   public id:string ="";
+   public smoCallBacks:smoCallBacks;
+   public utils:Utils;
+    constructor(){
+        super();
+        this.init();
+        this.initOnMessage();
+        this.smoCallBacks = new smoCallBacks(this);
+        this.utils = new Utils(this,this.smoCallBacks);
+    }
+    public init():void{
+        let match,
+            pl = /\+/g,
+            search = /([^&=]+)=?([^&]*)/g,
+            decode = function(s:string) {
+                return decodeURIComponent(s.replace(pl, " "));
+            },
+            query = window.location.search.substring(1);
+        while (match = search.exec(query)) {
+            this.vars[decode(match[1])] = decode(match[2]);
+        }
+
+        if (this.vars.idSmo) {
+            this.id = this.vars.idSmo;
+            return;
+        }
+        console.warn("No idSmo found in URL");
+    }
+    initOnMessage():void{
+        let selft = this;
+        window.onmessage = function(e) {
+           if (e.data.target) {
+            var targets = e.data.target.split('.');
+            var func = targets[targets.length-1];
+            if(func == SMO_EVENT_TYPE.start){
+                selft.start();
+                return;
+            }
+            if(func == SMO_EVENT_TYPE.setDatasource){
+                selft.setDatasource(e.data.objData);
+                return;
+            }
+            if(func == SMO_EVENT_TYPE.getVariable){
+                selft.getVariable(e.data.objData);
+                return;
+            }
+            if(func ==SMO_EVENT_TYPE.setCurrentStream){
+               selft.setCurrentStream(e.data.objData);
+               return;     
+            }
+            if(func==SMO_EVENT_TYPE.infoCurrentLocation){
+                selft.infoCurrentLocation(e.data.objData);
+                return;
+            }
+            if(func==SMO_EVENT_TYPE.setSalidaData){
+                selft.setSalidaData(e.data.objData);
+                return;
+            }
+            if(func ==SMO_EVENT_TYPE.updatefromsalida){
+                selft.updatefromsalida(e.data.objdata);
+                return;
+            }
+            console.warn("message not implemented!!" +func);
+                /* try {
+                    var targets = e.data.target.split('.');
+                    var fn = window;
+                    var obj = window;
+                    for (var i = 0; i < targets.length; i++) {
+                        obj = fn;
+                        fn = obj[targets[i]];
+                    }
+                    fn.call(obj, e.data.objData); // conservamos el valor de this
+                } catch (ex) {
+                    //Si no ha podido llamar es porque no existe el entorno
+
+                }*/
+            }
+        }
+    }
+    start():void{
+        this.emit(SMO_EVENT_TYPE.start);
+    }
+    setDatasource(datasource:setDatasource):void {
+        this.emit(SMO_EVENT_TYPE.setDatasource,datasource);
+    }
+    getVariable(variable:variable):void{
+        this.emit(SMO_EVENT_TYPE.getVariable,variable);
+    }
+    setCurrentStream(stream:string):void{
+    this.emit(SMO_EVENT_TYPE.setCurrentStream,stream);
+    }
+    infoCurrentLocation(location:location):void{
+        this.emit(SMO_EVENT_TYPE.infoCurrentLocation,location);
+    }
+    setSalidaData(data:DataSalida):void{
+    this.emit(SMO_EVENT_TYPE.setSalidaData,data);
+    }
+    
+    updatefromsalida(data:any):void{
+        this.emit(SMO_EVENT_TYPE.updatefromsalida,data);
+    }
+    
+}
+class smoCallBacks{
+    smo:SMO;
+     constructor(_smo:SMO){
+        this.smo =_smo;
+     }
+    public onSmoLoad():void {
+        
+        window.parent.postMessage({
+            target: "Dnv.smoCallbacks.onSmoLoad",
+            objData: undefined,
+            idSmo: this.smo.id
+        }, "*");
+    }
+    public onSmoReady():void {
+        window.parent.postMessage({
+            target: "Dnv.smoCallbacks.onSmoReady",
+            objData: undefined,
+            idSmo: this.smo.id
+        }, "*");
+    }
+    public smoLog(msn:string, level:LogLevel):void {
+        if (level == undefined) {
+            level = LogLevel.Info;
+        }
+        //level = Dnv.LogLevel.Debug...
+        if (level == LogLevel.Debug) {
+            console.debug(msn);
+        }
+        if (level == LogLevel.Info) {
+            console.log(msn);
+        }
+        if (level == LogLevel.Warning) {
+            console.warn(msn);
+        }
+        if (level == LogLevel.Error) {
+            console.error(msn);
+        }
+        if (window.parent != window) {
+            window.parent.postMessage({
+                target: "Dnv.smoCallbacks.smoLog",
+                objData: {
+                    level: level,
+                    txt: msn
+                },
+                idSmo: this.smo.id
+            }, "*");
+        }
+
+    }
+    public smoAlarma(msn:string, level:AlarmaLevel):void {
+        window.parent.postMessage({
+            target: "Dnv.smoCallbacks.smoAlarma",
+            objData: {
+                level: level,
+                txt: msn
+            },
+            idSmo: this.smo.id
+        }, "*");
+    }
+    public reiniciarDispositivo(msn:string):void {
+        //Permite reiniciar el player, proporcionando una razón para el reinicio. Solo Player HTML5
+        window.parent.postMessage({
+            target: "Dnv.smoCallbacks.reiniciarDispositivo",
+            objData: {
+                txt: msn // Razón del reinicio 
+            },
+            idSmo: this.smo.id
+        }, "*");
+    }
+    urlNext():void {
+        //Permite avanzar plantilla. Solo si Reloj Maestro activado.
+        window.parent.postMessage({
+            target: "Dnv.smoCallbacks.urlNext",
+            objData: undefined,
+            idSmo: this.smo.id
+        }, "*");
+    }
+    exitInteractivity():void {
+        //Para canales interactivos, vuelve al canal de reposo. Solo Android y Player PC.
+        window.parent.postMessage({
+            target: "Dnv.smoCallbacks.exitInteractivity",
+            objData: undefined,
+            idSmo: this.smo.id
+        }, "*");
+    }
+    showBrowser():void {
+        /* DEPRECATED NOT IMPLEMENTED */
+    }
+    closeBrowser():void {
+        /* DEPRECATED NOT IMPLEMENTED */
+    }
+    urlNextDirectamente():void {
+        /* NOT IMPLEMENTED */
+    }
+    setVariable(variable:string, valor:string) {
+        window.parent.postMessage({
+            target: "Dnv.smoCallbacks.setVariable",
+            objData: {
+                variable: variable,
+                valor: valor
+            },
+            idSmo: this.smo.id
+        }, "*");
+    }
+    getVariable(variable:string):void {
+        window.parent.postMessage({
+            target: "Dnv.smoCallbacks.getVariable",
+            objData: {
+                variable: variable
+            },
+            idSmo: this.smo.id
+        }, "*");
+        /* MIRAR SMO.getVariable */
+    }
+    getFile(file:string):void {
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.getFile",
+            objData: file,
+            idSmo: this.smo.id
+        }, "*");
+    }
+    setLocalData(variable:string, valor:string):void {
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.setLocalData",
+            objData: {
+                nameData: variable,
+                data: valor
+            },
+            idSmo: this.smo.id
+        }, "*");
+    }
+    getLocalData(variable:string):void {
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.getLocalData",
+            objData: variable, // nameData 
+            idSmo: this.smo.id
+        }, "*");
+        /* MIRAR SMO.setDatasource */
+    }
+    getCurrentStream():void {
+
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.getCurrentStream",
+            objData: undefined,
+            idSmo: this.smo.id
+        }, "*");
+        /* MIRAR SMO.setCurrentStream' */
+    }
+    finAviso(id:string):void {
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.finAviso",
+            objData: id, // id del aviso 
+            idSmo: this.smo.id
+        }, "*");
+    }
+    refreshDatasource(codigo:string):void {
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.refreshDatasource",
+            objData: codigo, // Codigo del datasource 
+            idSmo: this.smo.id
+        }, "*");
+    }
+    getLocation():void {
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.getLocation",
+            objData: undefined,
+            idSmo: this.smo.id
+        }, "*");
+        /* MIRAR SMO.infoCurrentLocation   */
+    }
+    getSalidaData(data:string):void {
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.getSalidaData",
+            objData: data, // Nombre del "data" que solicita. El player recibe ese string y hace un select case del mismo para devolver un json con datos al smo\html5 que le ha invocado.  
+            idSmo: this.smo.id
+        }, "*");
+        /* MIRAR SMO.setSalidaData */
+    }
+    ejecutaFuncion(data:ExecFunction):void {
+        /*data ={
+                funcion: "", // Nombre de la función que se debe ejecutar  
+                params: "" // Parámetros que debemos enviarle a la funcion. sin separadores ni nada, un string y se usa como tal. Solo esta implementada en un caso y se usa como tal sin parsear ni nada 
+            } */
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.ejecutaFuncion",
+            objData: data,
+            idSmo: this.smo.id
+        }, "*");
+    }
+    addObserver(data:string):void {
+        /*data ="fruta"
+         */
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.addObserver",
+            objData: data,
+            idSmo: this.smo.id
+        }, "*");
+    }
+    notify(data:Notify):void {
+        /*data ={
+                destino: "fruta",
+                value: "{'fruta':'manzana', 'color':'roja'}"
+            } */
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.notify",
+            objData: data,
+            idSmo: this.smo.id
+
+        }, "*");
+    }
+    playOnceChannelByTrigger(trigger:string):void {
+        parent.postMessage({
+            target: "Dnv.smoCallbacks.playOnceChannelByTrigger",
+            objData: { triggerCanal: trigger },
+            idSmo: this.smo.id
+        }, "*");
+    }
+    stopPlayOnceChannelByTrigger():void {
+        parent.postMessage({ target: "Dnv.smoCallbacks.stopPlayOnceChannelByTrigger", objData: {}, idSmo: this.smo.id }, "*");
+    }
+    playOnceChannel(codigoCanal:string):void {
+        parent.postMessage({ target: "Dnv.smoCallbacks.playOnceChannel", objData: { codigoCanal: codigoCanal, params: "PLAYONCE_CHANNEL|" + codigoCanal }, idSmo: this.smo.id }, "*");
+    }
+    stopPlayChannel():void {
+        parent.postMessage({ target: "Dnv.smoCallbacks.stopPlayOnceChannel", objData: {}, idSmo: this.smo.id }, "*");
+    }
+}
+class Utils{
+    smo:SMO;
+    smoCallBacks:smoCallBacks;
+    constructor(_smo:SMO,_smoCallBacks:smoCallBacks){
+    this.smo = _smo;
+    this.smoCallBacks =_smoCallBacks;
+    }
+    dataToJSON(data:setDatasource):any {
+        try {
+            var parser = new DOMParser();
+            var xmlDoc = parser.parseFromString(data.xml, "text/xml");
+            var dataForJSON = xmlDoc.getElementsByTagName("item")[0].innerHTML;
+            dataForJSON = dataForJSON.replace(/{'/g, '{"').replace(/'}/g, '"}').replace(/:'/g, ':"').replace(/':/g, '":').replace(/,'/g, ',"').replace(/',/g, '",').replace(/\['/g, '["').replace(/'\]/g, '"]').replace(/(\r\n|\n|\r)/gm, "");
+            return JSON.parse(dataForJSON);
+        } catch (error) {
+            return {};
+        }
+    }
+    getDatasource():void{
+        if(this.smo.vars.url == undefined){
+            this.smoCallBacks.getFile(this.smo.vars.LocalData);
+            return;
+        }
+        this.smoCallBacks.getFile(this.smo.vars.url);
+        
+    }
+    startCheckDatasource():void{
+        this.getDatasource();
+        let self = this;
+        setInterval(function() {
+            self.getDatasource();
+        }, 10000);
+    }
+}
+export enum SMO_EVENT_TYPE{
+    start = "start",
+    setDatasource = "setDatasource",
+    getVariable = "getVariable",
+    setCurrentStream = "setCurrentStream",
+    infoCurrentLocation = "infoCurrentLocation",
+    setSalidaData ="setSalidaData",
+    updatefromsalida = "updatefromsalida"
+}
+/*         start():void{
+        this.emit("start");
+    }
+    setDatasource(datasource:setDatasource):void {
+        this.emit("setDatasource",datasource);
+    }
+    getVariable(variable:variable):void{
+        this.emit("getVariable",variable);
+    }
+    setCurrentStream(stream:string):void{
+    this.emit("setCurrentStream",stream);
+    }
+    infoCurrentLocation(location:location):void{
+        this.emit("infoCurrentLocation",location);
+    }
+    setSalidaData(data:DataSalida):void{
+    this.emit("setSalidaData",data);
+    }
+    
+    updatefromsalida(data:any):void{
+        this.emit("updatefromsalida",data);
+    } */
+export enum LogLevel {
+    Debug= 0,
+    Info= 1,
+    Warning= 2,
+    Error= 3
+}
+export enum AlarmaLevel {
+Ok_off= 0,
+Ok= 1,
+Scanning= 2,
+Timeout= 3,
+Warning= 4,
+Error= 5
+}

package/tsconfig.json

@@ -0,0 +1,106 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Enable incremental compilation */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./",                          /* Specify the folder for .tsbuildinfo incremental compilation files. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+    "declaration": true,
+    /* Language and Environment */
+    "target": "es5",                                     /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h' */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using `jsx: react-jsx*`.` */
+    // "reactNamespace": "",                             /* Specify the object invoked for `createElement`. This only applies when targeting `react` JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+   
+    /* Modules */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like `./node_modules/@types`. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files */
+    // "noResolve": true,                                /* Disallow `import`s, `require`s or `<reference>`s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the `checkJS` option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from `node_modules`. Only applicable with `allowJs`. */
+
+    /* Emit */
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If `declaration` is true, also designates a file that bundles all .d.ts output. */
+     "outDir": "./dist",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have `@internal` in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like `__extends` in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing `const enum` declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables `allowSyntheticDefaultImports` for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied `any` type.. */
+    // "strictNullChecks": true,                         /* When type checking, take into account `null` and `undefined`. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for `bind`, `call`, and `apply` methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when `this` is given the type `any`. */
+    // "useUnknownInCatchVariables": true,               /* Type catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when a local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Include 'undefined' in index signature results */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": false                                 /* Skip type checking all .d.ts files. */
+  },
+  "include": [
+    "./src/**/*",
+  ],
+  "exclude":[
+    "node_modules"
+  ]
+}