v1.0.1 build

.gitignore

@@ -1,5 +1 @@
-node_modules
-amd
-dts
-es
-lib
+node_modules

amd/EventSourceContext.js

@@ -0,0 +1,29 @@
+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 __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.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+define(["require", "exports", "react"], function (require, exports, React) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    React = __importStar(React);
+    var EventSourceContext = React.createContext({
+        createConnection: function () { return undefined; },
+        getConnection: function () { return undefined; },
+    });
+    exports.default = EventSourceContext;
+});

amd/EventSourceProvider.js

@@ -0,0 +1,45 @@
+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 __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.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+define(["require", "exports", "react", "react", "./EventSourceContext"], function (require, exports, React, react_1, EventSourceContext_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    React = __importStar(React);
+    EventSourceContext_1 = __importDefault(EventSourceContext_1);
+    var EventSourceProvider = function (_a) {
+        var eventSource = _a.eventSource, children = _a.children;
+        var _b = react_1.useState({}), connections = _b[0], setConnections = _b[1];
+        var createConnection = function (url, options) {
+            var _a;
+            if (options === void 0) { options = {}; }
+            var connection = new eventSource(url, options);
+            setConnections(Object.assign({}, connections, (_a = {}, _a[url] = connection, _a)));
+            return connection;
+        };
+        var getConnection = function (url) { return connections[url]; };
+        return (React.createElement(EventSourceContext_1.default.Provider, { value: {
+                createConnection: createConnection,
+                getConnection: getConnection,
+            } }, children));
+    };
+    exports.default = EventSourceProvider;
+});

amd/index.js

@@ -0,0 +1,16 @@
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+define(["require", "exports", "./EventSourceProvider", "./EventSourceContext", "./useEventSource", "./useEventSourceListener"], function (require, exports, EventSourceProvider_1, EventSourceContext_1, useEventSource_1, useEventSourceListener_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.useEventSourceListener = exports.useEventSource = exports.EventSourceContext = exports.EventSourceProvider = void 0;
+    EventSourceProvider_1 = __importDefault(EventSourceProvider_1);
+    EventSourceContext_1 = __importDefault(EventSourceContext_1);
+    useEventSource_1 = __importDefault(useEventSource_1);
+    useEventSourceListener_1 = __importDefault(useEventSourceListener_1);
+    exports.EventSourceProvider = EventSourceProvider_1.default;
+    exports.EventSourceContext = EventSourceContext_1.default;
+    exports.useEventSource = useEventSource_1.default;
+    exports.useEventSourceListener = useEventSourceListener_1.default;
+});

amd/types.js

@@ -0,0 +1,4 @@
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

amd/useEventSource.js

@@ -0,0 +1,38 @@
+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 __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.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+define(["require", "exports", "react", "./EventSourceContext"], function (require, exports, React, EventSourceContext_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    React = __importStar(React);
+    EventSourceContext_1 = __importDefault(EventSourceContext_1);
+    var useEventSource = function (_a) {
+        var source = _a.source, options = _a.options;
+        var eventSourceContext = React.useContext(EventSourceContext_1.default);
+        var existingConnection = eventSourceContext.getConnection(source);
+        if (!existingConnection) {
+            return eventSourceContext.createConnection(source, options);
+        }
+        return existingConnection;
+    };
+    exports.default = useEventSource;
+});

amd/useEventSourceListener.js

@@ -0,0 +1,65 @@
+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 __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.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+define(["require", "exports", "react"], function (require, exports, React) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    React = __importStar(React);
+    var useEventSourceListener = function (_a, dependencies) {
+        var source = _a.source, event = _a.event, startOnInit = _a.startOnInit;
+        if (dependencies === void 0) { dependencies = []; }
+        var _b = React.useState(true), wasInit = _b[0], setInitState = _b[1];
+        var name = event.name, listener = event.listener, options = event.options;
+        var callback = function (event) {
+            var parsedData = undefined;
+            try {
+                parsedData = JSON.parse(event.data);
+            }
+            catch (e) { }
+            listener({ data: parsedData, event: event });
+        };
+        var createListener = function (source) {
+            removeListener(source);
+            source.addEventListener(name, callback, options);
+            !wasInit && setInitState(false);
+        };
+        var removeListener = function (source) {
+            source.removeEventListener(name, callback, options);
+        };
+        React.useEffect(function () {
+            if (source && (wasInit || startOnInit)) {
+                createListener(source);
+                return function () {
+                    removeListener(source);
+                };
+            }
+        }, __spreadArrays([source], dependencies));
+        var startListening = React.useCallback(function () { return createListener(source); }, __spreadArrays([source], dependencies));
+        var stopListening = React.useCallback(function () { return removeListener(source); }, __spreadArrays([source], dependencies));
+        return { startListening: startListening, stopListening: stopListening };
+    };
+    exports.default = useEventSourceListener;
+});

dts/EventSourceContext.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { EventSourceContextInterface } from './types';
+declare const EventSourceContext: React.Context<EventSourceContextInterface<any>>;
+export default EventSourceContext;

dts/EventSourceProvider.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { EventSourceProviderProps } from './types';
+declare const EventSourceProvider: ({ eventSource, children }: React.PropsWithChildren<EventSourceProviderProps>) => JSX.Element;
+export default EventSourceProvider;

dts/index.d.ts

@@ -0,0 +1,5 @@
+import EventSourceProvider from './EventSourceProvider';
+import EventSourceContext from './EventSourceContext';
+import useEventSource from './useEventSource';
+import useEventSourceListener from './useEventSourceListener';
+export { EventSourceProvider, EventSourceContext, useEventSource, useEventSourceListener, };

dts/types.d.ts

@@ -0,0 +1,28 @@
+export declare type EventSourceURL = string;
+export declare type EventSourceConnection = EventSource;
+export declare type CreateConnectionFunc<T extends EventSource> = (url: string, options: EventSourceInit | undefined) => T | undefined;
+export declare type GetConnectionFunc<T extends EventSource> = (url: EventSourceURL) => T | undefined;
+export declare type EventSourceContextInterface<T extends EventSource> = {
+    createConnection: CreateConnectionFunc<T>;
+    getConnection: GetConnectionFunc<T>;
+};
+export declare type EventSourceProviderProps = {
+    eventSource: typeof EventSource;
+};
+export declare type EventSourceEvent<T> = {
+    name: string;
+    listener: (event: {
+        data: T | undefined;
+        event: Event;
+    }) => void;
+    options?: boolean | AddEventListenerOptions | EventListenerOptions;
+};
+export declare type UseEventSource<I> = {
+    source: EventSourceURL;
+    options?: EventSourceInit & I;
+};
+export declare type UseEventSourceListener<T> = {
+    source: EventSourceConnection;
+    event: EventSourceEvent<T>;
+    startOnInit?: boolean;
+};

dts/useEventSource.d.ts

@@ -0,0 +1,3 @@
+import { UseEventSource } from './types';
+declare const useEventSource: <I extends Record<string, any>, T extends EventSource = EventSource>({ source, options }: UseEventSource<I>) => T | undefined;
+export default useEventSource;

dts/useEventSourceListener.d.ts

@@ -0,0 +1,6 @@
+import { UseEventSourceListener } from './types';
+declare const useEventSourceListener: <T>({ source, event, startOnInit }: UseEventSourceListener<T>, dependencies?: any[]) => {
+    startListening: () => void;
+    stopListening: () => void;
+};
+export default useEventSourceListener;

es/EventSourceContext.js

@@ -0,0 +1,6 @@
+import * as React from 'react';
+var EventSourceContext = React.createContext({
+    createConnection: function () { return undefined; },
+    getConnection: function () { return undefined; },
+});
+export default EventSourceContext;

es/EventSourceProvider.js

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { useState } from 'react';
+import EventSourceContext from './EventSourceContext';
+var EventSourceProvider = function (_a) {
+    var eventSource = _a.eventSource, children = _a.children;
+    var _b = useState({}), connections = _b[0], setConnections = _b[1];
+    var createConnection = function (url, options) {
+        var _a;
+        if (options === void 0) { options = {}; }
+        var connection = new eventSource(url, options);
+        setConnections(Object.assign({}, connections, (_a = {}, _a[url] = connection, _a)));
+        return connection;
+    };
+    var getConnection = function (url) { return connections[url]; };
+    return (React.createElement(EventSourceContext.Provider, { value: {
+            createConnection: createConnection,
+            getConnection: getConnection,
+        } }, children));
+};
+export default EventSourceProvider;

es/index.js

@@ -0,0 +1,5 @@
+import EventSourceProvider from './EventSourceProvider';
+import EventSourceContext from './EventSourceContext';
+import useEventSource from './useEventSource';
+import useEventSourceListener from './useEventSourceListener';
+export { EventSourceProvider, EventSourceContext, useEventSource, useEventSourceListener, };

es/useEventSource.js

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import EventSourceContext from './EventSourceContext';
+var useEventSource = function (_a) {
+    var source = _a.source, options = _a.options;
+    var eventSourceContext = React.useContext(EventSourceContext);
+    var existingConnection = eventSourceContext.getConnection(source);
+    if (!existingConnection) {
+        return eventSourceContext.createConnection(source, options);
+    }
+    return existingConnection;
+};
+export default useEventSource;

es/useEventSourceListener.js

@@ -0,0 +1,42 @@
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+import * as React from 'react';
+var useEventSourceListener = function (_a, dependencies) {
+    var source = _a.source, event = _a.event, startOnInit = _a.startOnInit;
+    if (dependencies === void 0) { dependencies = []; }
+    var _b = React.useState(true), wasInit = _b[0], setInitState = _b[1];
+    var name = event.name, listener = event.listener, options = event.options;
+    var callback = function (event) {
+        var parsedData = undefined;
+        try {
+            parsedData = JSON.parse(event.data);
+        }
+        catch (e) { }
+        listener({ data: parsedData, event: event });
+    };
+    var createListener = function (source) {
+        removeListener(source);
+        source.addEventListener(name, callback, options);
+        !wasInit && setInitState(false);
+    };
+    var removeListener = function (source) {
+        source.removeEventListener(name, callback, options);
+    };
+    React.useEffect(function () {
+        if (source && (wasInit || startOnInit)) {
+            createListener(source);
+            return function () {
+                removeListener(source);
+            };
+        }
+    }, __spreadArrays([source], dependencies));
+    var startListening = React.useCallback(function () { return createListener(source); }, __spreadArrays([source], dependencies));
+    var stopListening = React.useCallback(function () { return removeListener(source); }, __spreadArrays([source], dependencies));
+    return { startListening: startListening, stopListening: stopListening };
+};
+export default useEventSourceListener;

lib/EventSourceContext.js

@@ -0,0 +1,27 @@
+"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 __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.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var React = __importStar(require("react"));
+var EventSourceContext = React.createContext({
+    createConnection: function () { return undefined; },
+    getConnection: function () { return undefined; },
+});
+exports.default = EventSourceContext;