@jayesol/jayeson.lib.sports 2.2.7-beta → 2.2.7-beta2

package/lib/data_structure.js

@@ -0,0 +1,208 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TTLWrapper = exports.MergeableWrapper = exports.ConvertedMsg = exports.MessageBeforeTransform = exports.DeltaOutgoingImpl = exports.OutgoingImpl = exports.IndexedSnapshotImpl = exports.Incoming = void 0;
+const Collections = __importStar(require("typescript-collections"));
+const jayeson_lib_record_1 = require("@jayesol/jayeson.lib.record");
+class Incoming {
+    constructor(_msgType, _stream, _data) {
+        this._msgType = _msgType;
+        this._stream = _stream;
+        this._data = _data;
+    }
+    msgType() {
+        return this._msgType;
+    }
+    stream() {
+        return this._stream;
+    }
+    data() {
+        return this._data;
+    }
+}
+exports.Incoming = Incoming;
+class IndexedSnapshotImpl extends jayeson_lib_record_1.Snapshot {
+    constructor(matches = {}, partitions = new Collections.Dictionary()) {
+        super(matches);
+        this.partitions = partitions;
+    }
+    getPartitions() {
+        let keys = new Collections.Set();
+        for (var partition of this.partitions.keys()) {
+            keys.add(partition);
+        }
+        return keys;
+    }
+    //TODO Return Immutable Map/clone??
+    getPartitionMap() {
+        return this.partitions;
+    }
+}
+exports.IndexedSnapshotImpl = IndexedSnapshotImpl;
+IndexedSnapshotImpl.EMPTY_SNAPSHOT = new IndexedSnapshotImpl();
+class OutgoingImpl {
+    constructor(_msgType, _msg) {
+        this._msgType = _msgType;
+        this._msg = _msg;
+    }
+    msgType() {
+        return this._msgType;
+    }
+    msg() {
+        return this._msg;
+    }
+}
+exports.OutgoingImpl = OutgoingImpl;
+class DeltaOutgoingImpl extends OutgoingImpl {
+    constructor(_msgType, _delta, _after, _before) {
+        super(_msgType, _delta);
+        this._delta = _delta;
+        this._after = _after;
+        this._before = _before;
+    }
+    after() {
+        return this._after;
+    }
+    delta() {
+        return this._delta;
+    }
+    before() {
+        return this._before;
+    }
+}
+exports.DeltaOutgoingImpl = DeltaOutgoingImpl;
+class MessageBeforeTransform {
+    constructor() {
+        this.transformEvent = [];
+        this.suppressMatch = [];
+        this.insertMatch = [];
+        this.deleteMatch = [];
+        this.insertEvent = [];
+        this.deleteEvent = [];
+        this.afterSs = IndexedSnapshotImpl.EMPTY_SNAPSHOT;
+        this.beforeSs = IndexedSnapshotImpl.EMPTY_SNAPSHOT;
+    }
+    getTransformEvent() {
+        return this.transformEvent;
+    }
+    setTransformEvent(eventId) {
+        this.transformEvent.push(eventId);
+    }
+    getSuppressMatch() {
+        return this.suppressMatch;
+    }
+    setSuppressMatch(matchId) {
+        this.suppressMatch.push(matchId);
+    }
+    setAfterSs(afterSs) {
+        this.afterSs = afterSs;
+    }
+    getAfterSs() {
+        return this.afterSs;
+    }
+    setBeforeSs(beforeSs) {
+        this.beforeSs = beforeSs;
+    }
+    getBeforeSs() {
+        return this.beforeSs;
+    }
+    setInsertEvent(eventId) {
+        this.insertEvent.push(eventId);
+    }
+    getInsertEvent() {
+        return this.insertEvent;
+    }
+    setDeleteEvent(eventId) {
+        this.deleteEvent.push(eventId);
+    }
+    getDeleteEvent() {
+        return this.deleteEvent;
+    }
+    setInsertMatch(matchId) {
+        this.insertMatch.push(matchId);
+    }
+    getInsertMatch() {
+        return this.insertMatch;
+    }
+    setDeleteMatch(matchId) {
+        this.deleteMatch.push(matchId);
+    }
+    getDeleteMatch() {
+        return this.deleteMatch;
+    }
+}
+exports.MessageBeforeTransform = MessageBeforeTransform;
+var ConvertedMsg;
+(function (ConvertedMsg) {
+    ConvertedMsg[ConvertedMsg["INSERT_EVENT_TO_UPDATE"] = 0] = "INSERT_EVENT_TO_UPDATE";
+    ConvertedMsg[ConvertedMsg["DELETE_EVENT_TO_UPDATE"] = 1] = "DELETE_EVENT_TO_UPDATE";
+    ConvertedMsg[ConvertedMsg["INSERT_MATCH_SUPPRESS"] = 2] = "INSERT_MATCH_SUPPRESS";
+    ConvertedMsg[ConvertedMsg["DELETE_MATCH_SUPPRESS"] = 3] = "DELETE_MATCH_SUPPRESS";
+    ConvertedMsg[ConvertedMsg["ORIGINAL"] = 4] = "ORIGINAL";
+})(ConvertedMsg = exports.ConvertedMsg || (exports.ConvertedMsg = {}));
+class MergeableWrapper {
+    constructor() {
+        this.snap = IndexedSnapshotImpl.EMPTY_SNAPSHOT;
+    }
+    setDeltaOut(out) {
+        this.deltaOut = out;
+    }
+    setAfter(after) {
+        this.snap = after;
+    }
+    getDeltaOut() {
+        return this.deltaOut;
+    }
+    getAfter() {
+        return this.snap;
+    }
+}
+exports.MergeableWrapper = MergeableWrapper;
+class TTLWrapper {
+    _RemovedKey() {
+        this.removedSs = IndexedSnapshotImpl.EMPTY_SNAPSHOT;
+        this.remainingSs = IndexedSnapshotImpl.EMPTY_SNAPSHOT;
+        this.restoredSs = IndexedSnapshotImpl.EMPTY_SNAPSHOT;
+    }
+    setRemovedSs(remove) {
+        this.removedSs = remove;
+    }
+    getRemovedSs() {
+        return this.removedSs;
+    }
+    setRemainingSs(remain) {
+        this.remainingSs = remain;
+    }
+    getRemainingSs() {
+        return this.remainingSs;
+    }
+    getRestoredSs() {
+        return this.restoredSs;
+    }
+    setRestoredSs(restore) {
+        this.restoredSs = restore;
+    }
+}
+exports.TTLWrapper = TTLWrapper;

package/lib/dispatch.d.ts

@@ -0,0 +1,126 @@
+import { DeltaOutgoing, IndexedSnapshot, Outgoing } from "./data_structure";
+import { TTLOutgoing, FSRepo, ISnapshotHandler } from "./core";
+import { SportsFeedMessageGroup } from "./message_class";
+import { InjectionToken } from "injection-js";
+import * as T from 'ts-promise';
+export interface IEndPointGroupManager {
+    registerEPD(epd: IEndPointDispatcher): void;
+    deregisterEPD(epd: IEndPointDispatcher): void;
+}
+export declare const EPGM_IMPL: InjectionToken<IEndPointGroupManager>;
+export interface IEndPointGroup extends ISnapshotHandler {
+    hasEPD(stream: string, id: string): boolean;
+    addEPD(epd: IEndPointDispatcher): void;
+    removeEPD(epd: IEndPointDispatcher): void;
+    isEmpty(): boolean;
+    submitForProcess(process: IDispatchableWrapper): void;
+    getSportsFeedGrp(): SportsFeedMessageGroup;
+    getEPDs(stream: string): IEndPointDispatcher[];
+    getStreams(): string[];
+    startGetingDeltaSnapshot(fsRepo: FSRepo): void;
+    stopGetingDeltaSnapshot(fsRepo: FSRepo): void;
+    generateFull(wrapper: FullSnapshotWrapper): Outgoing[];
+    generatePartial(wrapper: PartialSnapshotWrapper): Outgoing[];
+}
+export interface IDispatchableWrapper {
+    process(): void;
+}
+export declare abstract class WrapperImpl {
+    private __epg;
+    private __stream;
+    constructor(__epg: IEndPointGroup, __stream: string);
+    epg(): IEndPointGroup;
+    stream(): string;
+}
+export declare class FullSnapshotWrapper extends WrapperImpl implements IDispatchableWrapper {
+    private _epg;
+    private _stream;
+    private _epd;
+    fullSnapshot: IndexedSnapshot;
+    constructor(_epg: IEndPointGroup, _stream: string, _epd: IEndPointDispatcher, fullSnapshot: IndexedSnapshot);
+    epg(): IEndPointGroup;
+    stream(): string;
+    epd(): IEndPointDispatcher;
+    process(): void;
+    getFullSnapshot(): IndexedSnapshot;
+    setFullSnapshot(fullSnapshot: IndexedSnapshot): void;
+}
+export declare class PartialSnapshotWrapper extends WrapperImpl implements IDispatchableWrapper {
+    private _delta;
+    private _epg;
+    private _stream;
+    constructor(_delta: DeltaOutgoing, _epg: IEndPointGroup, _stream: string);
+    epg(): IEndPointGroup;
+    stream(): string;
+    delta(): DeltaOutgoing;
+    process(): void;
+}
+export declare class IndicatorWrapper extends WrapperImpl implements IDispatchableWrapper {
+    private _delta;
+    private _epg;
+    private _stream;
+    constructor(_delta: Outgoing, _epg: IEndPointGroup, _stream: string);
+    process(): void;
+}
+export declare class EPDispatcherException extends Error {
+    constructor(message: string);
+}
+export declare class EndPointGroupManager implements IEndPointGroupManager {
+    private _fsRepo;
+    private _grp;
+    relayEPG: RelayEPG;
+    constructor(_fsRepo: FSRepo, _grp: SportsFeedMessageGroup);
+    fsRepo(): FSRepo;
+    grp(): SportsFeedMessageGroup;
+    pushFullSnapshotWrapper(epg: IEndPointGroup, epd: IEndPointDispatcher): void;
+    registerEPD(epd: IEndPointDispatcher): void;
+    deregisterEPD(epd: IEndPointDispatcher): void;
+}
+export interface IEndPointDispatcher {
+    id(): string;
+    stream(): string;
+    submit(out: Outgoing): void;
+    onException(e: Error): void;
+    isInitialized(): T.Promise<Boolean>;
+    readyToDispatch(): void;
+    isReadyToDispatch(): boolean;
+}
+export declare class DispatchersGroup {
+    private streamName;
+    private dispatchers;
+    constructor(streamName: string);
+    addEpd(epd: IEndPointDispatcher): void;
+    removeEpd(epd: IEndPointDispatcher): IEndPointDispatcher;
+    get(id: string): IEndPointDispatcher;
+    getAll(): IEndPointDispatcher[];
+    isEmpty(): boolean;
+}
+export declare abstract class AbstractEPG implements IEndPointGroup {
+    private sportsFeedGroup;
+    private dispatchers;
+    constructor(sportsFeedGroup: SportsFeedMessageGroup);
+    hasEPD(stream: string, id: string): boolean;
+    addEPD(epd: IEndPointDispatcher): void;
+    removeEPD(epd: IEndPointDispatcher): void;
+    isEmpty(): boolean;
+    abstract submitForProcess(process: IDispatchableWrapper): void;
+    getEPDs(stream: string): IEndPointDispatcher[];
+    getStreams(): string[];
+    startGetingDeltaSnapshot(fsRepo: FSRepo): void;
+    stopGetingDeltaSnapshot(fsRepo: FSRepo): void;
+    process(stream: string, snapshot: Outgoing): void;
+    getSportsFeedGrp(): SportsFeedMessageGroup;
+    generateFull(wrapper: FullSnapshotWrapper): Outgoing[];
+    generatePartial(wrapper: PartialSnapshotWrapper): Outgoing[];
+}
+export declare class RelayEPG extends AbstractEPG {
+    private _sportsFeedGroup;
+    constructor(_sportsFeedGroup: SportsFeedMessageGroup);
+    submitForProcess(wrapper: IDispatchableWrapper): void;
+    onException(e: Error): void;
+    generateFull(wrapper: FullSnapshotWrapper): Outgoing[];
+    generatePartial(wrapper: PartialSnapshotWrapper): Outgoing[];
+    generateTtl(outGng: TTLOutgoing): Outgoing[];
+    generateTtlRestore(outGng: TTLOutgoing): Outgoing[];
+    private isSameFormat;
+}

package/lib/dispatch.js

@@ -0,0 +1,324 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelayEPG = exports.AbstractEPG = exports.DispatchersGroup = exports.EndPointGroupManager = exports.EPDispatcherException = exports.IndicatorWrapper = exports.PartialSnapshotWrapper = exports.FullSnapshotWrapper = exports.WrapperImpl = exports.EPGM_IMPL = void 0;
+const data_structure_1 = require("./data_structure");
+const core_1 = require("./core");
+const message_class_1 = require("./message_class");
+const injection_js_1 = require("injection-js");
+exports.EPGM_IMPL = new injection_js_1.InjectionToken('EpgmInstance');
+class WrapperImpl {
+    constructor(__epg, __stream) {
+        this.__epg = __epg;
+        this.__stream = __stream;
+    }
+    epg() {
+        return this.__epg;
+    }
+    stream() {
+        return this.__stream;
+    }
+}
+exports.WrapperImpl = WrapperImpl;
+class FullSnapshotWrapper extends WrapperImpl {
+    constructor(_epg, _stream, _epd, fullSnapshot) {
+        super(_epg, _stream);
+        this._epg = _epg;
+        this._stream = _stream;
+        this._epd = _epd;
+        this.fullSnapshot = fullSnapshot;
+    }
+    epg() {
+        return this._epg;
+    }
+    stream() {
+        return this._stream;
+    }
+    epd() {
+        return this._epd;
+    }
+    process() {
+        this._epd.readyToDispatch();
+        let mwList = this._epg.generateFull(this);
+        if (mwList != null) {
+            for (let i = 0; i < mwList.length; i++) {
+                let mw = mwList[i];
+                this._epd.submit(mw);
+            }
+        }
+    }
+    getFullSnapshot() {
+        return this.fullSnapshot;
+    }
+    setFullSnapshot(fullSnapshot) {
+        this.fullSnapshot = fullSnapshot;
+    }
+}
+exports.FullSnapshotWrapper = FullSnapshotWrapper;
+class PartialSnapshotWrapper extends WrapperImpl {
+    constructor(_delta, _epg, _stream) {
+        super(_epg, _stream);
+        this._delta = _delta;
+        this._epg = _epg;
+        this._stream = _stream;
+    }
+    epg() {
+        return this._epg;
+    }
+    stream() {
+        return this._stream;
+    }
+    delta() {
+        return this._delta;
+    }
+    process() {
+        //console.log("the partial snapshot"+JSON.stringify(this.epg.getEPDs(this.stream))+"out going length: "+this.epg.generatePartial(this).length);
+        let outgoingList = this._epg.generatePartial(this);
+        let epds = this._epg.getEPDs(this._stream);
+        for (let i = 0; i < epds.length; i++) {
+            let epd = epds[i];
+            for (let j = 0; j < outgoingList.length; j++) {
+                if (epd.isReadyToDispatch()) {
+                    let out = outgoingList[j];
+                    epd.submit(out);
+                }
+            }
+        }
+    }
+}
+exports.PartialSnapshotWrapper = PartialSnapshotWrapper;
+class IndicatorWrapper extends WrapperImpl {
+    constructor(_delta, _epg, _stream) {
+        super(_epg, _stream);
+        this._delta = _delta;
+        this._epg = _epg;
+        this._stream = _stream;
+    }
+    process() {
+        let epds = this._epg.getEPDs(this._stream);
+        for (let i = 0; i < epds.length; i++) {
+            let epd = epds[i];
+            epd.submit(this._delta);
+        }
+    }
+}
+exports.IndicatorWrapper = IndicatorWrapper;
+class EPDispatcherException extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.EPDispatcherException = EPDispatcherException;
+let EndPointGroupManager = class EndPointGroupManager {
+    constructor(_fsRepo, _grp) {
+        this._fsRepo = _fsRepo;
+        this._grp = _grp;
+        this.relayEPG = new RelayEPG(_grp);
+        this.relayEPG.startGetingDeltaSnapshot(_fsRepo);
+    }
+    fsRepo() {
+        return this._fsRepo;
+    }
+    grp() {
+        return this._grp;
+    }
+    pushFullSnapshotWrapper(epg, epd) {
+        let stream = epd.stream();
+        epd.isInitialized().then((ready) => {
+            if (ready) {
+                let rawSnapshot = this._fsRepo.getSnapshot(stream);
+                let sw = new FullSnapshotWrapper(epg, stream, epd, rawSnapshot);
+                epg.submitForProcess(sw);
+            }
+        });
+    }
+    registerEPD(epd) {
+        if (this.relayEPG.hasEPD(epd.stream(), epd.id())) {
+            throw new EPDispatcherException("EPD already exists in a group.Id: " + epd.id + " Stream: " + epd.stream);
+        }
+        this.relayEPG.addEPD(epd);
+        this.pushFullSnapshotWrapper(this.relayEPG, epd);
+    }
+    deregisterEPD(epd) {
+        // Clean up EPD
+        this.relayEPG.removeEPD(epd);
+    }
+};
+EndPointGroupManager = __decorate([
+    (0, injection_js_1.Injectable)(),
+    __param(0, (0, injection_js_1.Inject)(core_1.FSREPO_IMPL)),
+    __metadata("design:paramtypes", [Object, message_class_1.SportsFeedMessageGroup])
+], EndPointGroupManager);
+exports.EndPointGroupManager = EndPointGroupManager;
+class DispatchersGroup {
+    constructor(streamName) {
+        this.streamName = streamName;
+        this.dispatchers = {};
+    }
+    addEpd(epd) {
+        this.dispatchers[epd.id()] = epd;
+    }
+    removeEpd(epd) {
+        let current = this.dispatchers[epd.id()];
+        delete this.dispatchers[epd.id()];
+        return current;
+    }
+    get(id) {
+        return this.dispatchers[id];
+    }
+    getAll() {
+        return Object.keys(this.dispatchers).map((k) => {
+            return this.dispatchers[k];
+        });
+    }
+    isEmpty() {
+        return Object.keys(this.dispatchers).length == 0;
+    }
+}
+exports.DispatchersGroup = DispatchersGroup;
+class AbstractEPG {
+    constructor(sportsFeedGroup) {
+        this.sportsFeedGroup = sportsFeedGroup;
+        this.dispatchers = {};
+    }
+    hasEPD(stream, id) {
+        let dGrp = this.dispatchers[stream];
+        if (dGrp !== undefined) {
+            return dGrp.get(id) !== undefined;
+        }
+        else {
+            return false;
+        }
+    }
+    addEPD(epd) {
+        let grp = this.dispatchers[epd.stream()];
+        if (grp === undefined) {
+            this.dispatchers[epd.stream()] = new DispatchersGroup(epd.stream());
+        }
+        this.dispatchers[epd.stream()].addEpd(epd);
+    }
+    removeEPD(epd) {
+        let grp = this.dispatchers[epd.stream()];
+        if (grp !== undefined) {
+            grp.removeEpd(epd);
+            if (grp.isEmpty()) {
+                delete this.dispatchers[epd.stream()];
+            }
+        }
+    }
+    isEmpty() {
+        return Object.keys(this.dispatchers).length == 0;
+    }
+    getEPDs(stream) {
+        let dGrp = this.dispatchers[stream];
+        if (dGrp !== undefined) {
+            return dGrp.getAll();
+        }
+        else {
+            return [];
+        }
+    }
+    getStreams() {
+        return Object.keys(this.dispatchers);
+    }
+    startGetingDeltaSnapshot(fsRepo) {
+        fsRepo.registerSnapshotHandler(this);
+    }
+    stopGetingDeltaSnapshot(fsRepo) {
+        fsRepo.deRegisterSnapshotHandler(this);
+    }
+    process(stream, snapshot) {
+        if (this.sportsFeedGroup.isIndicatorMessage(snapshot.msgType())) {
+            let filterIndicatorWrapper = new IndicatorWrapper(snapshot, this, stream);
+            this.submitForProcess(filterIndicatorWrapper);
+        }
+        else {
+            let partWrapper = new PartialSnapshotWrapper(snapshot, this, stream);
+            this.submitForProcess(partWrapper);
+        }
+    }
+    getSportsFeedGrp() {
+        return this.sportsFeedGroup;
+    }
+    generateFull(wrapper) {
+        throw new Error("Method not implemented.");
+    }
+    generatePartial(wrapper) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.AbstractEPG = AbstractEPG;
+let RelayEPG = class RelayEPG extends AbstractEPG {
+    constructor(_sportsFeedGroup) {
+        super(_sportsFeedGroup);
+        this._sportsFeedGroup = _sportsFeedGroup;
+    }
+    submitForProcess(wrapper) {
+        wrapper.process();
+    }
+    onException(e) {
+        console.error("Exception when dispatching snapshots to EPDs from RelayEPG. ", e);
+        return null;
+    }
+    generateFull(wrapper) {
+        let ss = wrapper.getFullSnapshot();
+        let fssStart = new data_structure_1.OutgoingImpl(this._sportsFeedGroup.FULLSNAPSHOT_START(), new Object());
+        let reset = new data_structure_1.DeltaOutgoingImpl(this._sportsFeedGroup.DATA_RESET(), ss, ss, data_structure_1.IndexedSnapshotImpl.EMPTY_SNAPSHOT);
+        let insertMatch = new data_structure_1.DeltaOutgoingImpl(this._sportsFeedGroup.DATA_INSERT_MATCH(), ss, ss, data_structure_1.IndexedSnapshotImpl.EMPTY_SNAPSHOT);
+        let insertEvent = new data_structure_1.DeltaOutgoingImpl(this._sportsFeedGroup.DATA_INSERT_EVENT(), ss, ss, data_structure_1.IndexedSnapshotImpl.EMPTY_SNAPSHOT);
+        let insertRecord = new data_structure_1.DeltaOutgoingImpl(this._sportsFeedGroup.DATA_INSERT_ODD(), ss, ss, data_structure_1.IndexedSnapshotImpl.EMPTY_SNAPSHOT);
+        let fssEnd = new data_structure_1.OutgoingImpl(this._sportsFeedGroup.FULLSNAPSHOT_END(), new Object());
+        return [fssStart, reset, insertMatch, insertEvent, insertRecord, fssEnd];
+    }
+    generatePartial(wrapper) {
+        let delta = wrapper.delta();
+        if (delta.constructor.name == "TTLOutgoing") {
+            return this.generateTtl(delta);
+        }
+        return [delta];
+    }
+    generateTtl(outGng) {
+        // Return if Message Type is Refresh
+        if (this.isSameFormat(outGng.msgType(), this._sportsFeedGroup.ADMIN_REFRESH())) {
+            return [];
+        }
+        let ttlType = outGng.getTtlType();
+        if (ttlType == core_1.TTLType.REMOVE) {
+            // Process Remove Message as Normal Partial Message
+            return [outGng];
+        }
+        else {
+            return this.generateTtlRestore(outGng);
+        }
+    }
+    generateTtlRestore(outGng) {
+        let insertMatch = new data_structure_1.DeltaOutgoingImpl(this._sportsFeedGroup.DATA_INSERT_MATCH(), outGng.delta(), outGng.delta(), data_structure_1.IndexedSnapshotImpl.EMPTY_SNAPSHOT);
+        let insertEvent = new data_structure_1.DeltaOutgoingImpl(this._sportsFeedGroup.DATA_INSERT_EVENT(), outGng.delta(), outGng.delta(), data_structure_1.IndexedSnapshotImpl.EMPTY_SNAPSHOT);
+        let insertRecord = new data_structure_1.DeltaOutgoingImpl(this._sportsFeedGroup.DATA_INSERT_ODD(), outGng.delta(), outGng.delta(), data_structure_1.IndexedSnapshotImpl.EMPTY_SNAPSHOT);
+        return [insertMatch, insertEvent, insertRecord];
+    }
+    isSameFormat(lhs, messageClass) {
+        if (lhs.instanceClass() == messageClass.instanceClass() && lhs.constructor.name == messageClass.constructor.name) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+};
+RelayEPG = __decorate([
+    (0, injection_js_1.Injectable)(),
+    __metadata("design:paramtypes", [message_class_1.SportsFeedMessageGroup])
+], RelayEPG);
+exports.RelayEPG = RelayEPG;

package/lib/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./basketball_codec";
+export * from "./client";
+export * from "./codec";
+export * from "./core";
+export * from "./data_structure";
+export * from "./dispatch";
+export * from "./message_class";
+export * from "./module";
+export * from "./receive";
+export * from "./soccer_codec";
+export * from "./tennis_codec";

package/lib/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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("./basketball_codec"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./codec"), exports);
+__exportStar(require("./core"), exports);
+__exportStar(require("./data_structure"), exports);
+__exportStar(require("./dispatch"), exports);
+__exportStar(require("./message_class"), exports);
+__exportStar(require("./module"), exports);
+__exportStar(require("./receive"), exports);
+__exportStar(require("./soccer_codec"), exports);
+__exportStar(require("./tennis_codec"), exports);