0.2.0 - Mid migration

web/node_modules/react-cookie/es6/Cookies.d.ts

@@ -0,0 +1,2 @@
+import Cookies from 'universal-cookie';
+export default Cookies;

web/node_modules/react-cookie/es6/Cookies.js

@@ -0,0 +1,2 @@
+import Cookies from 'universal-cookie';
+export default Cookies;

web/node_modules/react-cookie/es6/CookiesContext.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import Cookies from './Cookies';
+declare const CookiesContext: React.Context<Cookies>;
+export declare const Provider: React.Provider<Cookies>, Consumer: React.Consumer<Cookies>;
+export default CookiesContext;

web/node_modules/react-cookie/es6/CookiesContext.js

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import Cookies from './Cookies';
+var CookiesContext = React.createContext(new Cookies());
+export var Provider = CookiesContext.Provider, Consumer = CookiesContext.Consumer;
+export default CookiesContext;

web/node_modules/react-cookie/es6/CookiesProvider.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import Cookies from 'universal-cookie';
+import { ReactCookieProps } from './types';
+export default class CookiesProvider extends React.Component<ReactCookieProps, any> {
+    cookies: Cookies;
+    constructor(props: ReactCookieProps);
+    render(): JSX.Element;
+}

web/node_modules/react-cookie/es6/CookiesProvider.js

@@ -0,0 +1,34 @@
+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 (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import * as React from 'react';
+import Cookies from 'universal-cookie';
+import { Provider } from './CookiesContext';
+var CookiesProvider = /** @class */ (function (_super) {
+    __extends(CookiesProvider, _super);
+    function CookiesProvider(props) {
+        var _this = _super.call(this, props) || this;
+        if (props.cookies) {
+            _this.cookies = props.cookies;
+        }
+        else {
+            _this.cookies = new Cookies();
+        }
+        return _this;
+    }
+    CookiesProvider.prototype.render = function () {
+        return React.createElement(Provider, { value: this.cookies }, this.props.children);
+    };
+    return CookiesProvider;
+}(React.Component));
+export default CookiesProvider;

web/node_modules/react-cookie/es6/index.d.ts

@@ -0,0 +1,5 @@
+export { default as Cookies } from './Cookies';
+export { default as CookiesProvider } from './CookiesProvider';
+export { default as withCookies } from './withCookies';
+export { default as useCookies } from './useCookies';
+export * from './types';

web/node_modules/react-cookie/es6/index.js

@@ -0,0 +1,5 @@
+export { default as Cookies } from './Cookies';
+export { default as CookiesProvider } from './CookiesProvider';
+export { default as withCookies } from './withCookies';
+export { default as useCookies } from './useCookies';
+export * from './types';

web/node_modules/react-cookie/es6/types.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import Cookies, { Cookie } from 'universal-cookie';
+export declare type ReactCookieProps = {
+    cookies?: Cookies;
+    allCookies?: {
+        [name: string]: Cookie;
+    };
+    children?: any;
+    ref?: React.RefObject<{}>;
+};

web/node_modules/react-cookie/es6/useCookies.d.ts

@@ -0,0 +1,4 @@
+import { Cookie, CookieSetOptions } from 'universal-cookie';
+export default function useCookies<T extends string, U = {
+    [K in T]?: any;
+}>(dependencies?: T[]): [U, (name: T, value: Cookie, options?: CookieSetOptions) => void, (name: T, options?: CookieSetOptions) => void];

web/node_modules/react-cookie/es6/useCookies.js

@@ -0,0 +1,42 @@
+import { useContext, useLayoutEffect, useState, useRef, useMemo } from 'react';
+import CookiesContext from './CookiesContext';
+import { isInBrowser } from './utils';
+export default function useCookies(dependencies) {
+    var cookies = useContext(CookiesContext);
+    if (!cookies) {
+        throw new Error('Missing <CookiesProvider>');
+    }
+    var initialCookies = cookies.getAll();
+    var _a = useState(initialCookies), allCookies = _a[0], setCookies = _a[1];
+    var previousCookiesRef = useRef(allCookies);
+    if (isInBrowser()) {
+        useLayoutEffect(function () {
+            function onChange() {
+                var newCookies = cookies.getAll();
+                if (shouldUpdate(dependencies || null, newCookies, previousCookiesRef.current)) {
+                    setCookies(newCookies);
+                }
+                previousCookiesRef.current = newCookies;
+            }
+            cookies.addChangeListener(onChange);
+            return function () {
+                cookies.removeChangeListener(onChange);
+            };
+        }, [cookies]);
+    }
+    var setCookie = useMemo(function () { return cookies.set.bind(cookies); }, [cookies]);
+    var removeCookie = useMemo(function () { return cookies.remove.bind(cookies); }, [cookies]);
+    return [allCookies, setCookie, removeCookie];
+}
+function shouldUpdate(dependencies, newCookies, oldCookies) {
+    if (!dependencies) {
+        return true;
+    }
+    for (var _i = 0, dependencies_1 = dependencies; _i < dependencies_1.length; _i++) {
+        var dependency = dependencies_1[_i];
+        if (newCookies[dependency] !== oldCookies[dependency]) {
+            return true;
+        }
+    }
+    return false;
+}

web/node_modules/react-cookie/es6/utils.d.ts

@@ -0,0 +1 @@
+export declare function isInBrowser(): boolean;

web/node_modules/react-cookie/es6/utils.js

@@ -0,0 +1,5 @@
+export function isInBrowser() {
+    return (typeof window !== 'undefined' &&
+        typeof window.document !== 'undefined' &&
+        typeof window.document.createElement !== 'undefined');
+}

web/node_modules/react-cookie/es6/withCookies.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import { ReactCookieProps } from './types';
+declare type Diff<T, U> = T extends U ? never : T;
+declare type Omit<T, K extends keyof T> = Pick<T, Diff<keyof T, K>>;
+export default function withCookies<T extends ReactCookieProps>(WrappedComponent: React.ComponentType<T>): React.ComponentType<Omit<T, keyof ReactCookieProps>>;
+export {};

web/node_modules/react-cookie/es6/withCookies.js

@@ -0,0 +1,85 @@
+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 (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import * as React from 'react';
+import hoistStatics from 'hoist-non-react-statics';
+import { Consumer } from './CookiesContext';
+export default function withCookies(WrappedComponent) {
+    // @ts-ignore
+    var name = WrappedComponent.displayName || WrappedComponent.name;
+    var CookieWrapper = /** @class */ (function (_super) {
+        __extends(CookieWrapper, _super);
+        function CookieWrapper() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.onChange = function () {
+                // Make sure to update children with new values
+                _this.forceUpdate();
+            };
+            return _this;
+        }
+        CookieWrapper.prototype.listen = function () {
+            this.props.cookies.addChangeListener(this.onChange);
+        };
+        CookieWrapper.prototype.unlisten = function (cookies) {
+            (cookies || this.props.cookies).removeChangeListener(this.onChange);
+        };
+        CookieWrapper.prototype.componentDidMount = function () {
+            this.listen();
+        };
+        CookieWrapper.prototype.componentDidUpdate = function (prevProps) {
+            if (prevProps.cookies !== this.props.cookies) {
+                this.unlisten(prevProps.cookies);
+                this.listen();
+            }
+        };
+        CookieWrapper.prototype.componentWillUnmount = function () {
+            this.unlisten();
+        };
+        CookieWrapper.prototype.render = function () {
+            var _a = this.props, forwardedRef = _a.forwardedRef, cookies = _a.cookies, restProps = __rest(_a, ["forwardedRef", "cookies"]);
+            var allCookies = cookies.getAll();
+            return (React.createElement(WrappedComponent, __assign({}, restProps, { ref: forwardedRef, cookies: cookies, allCookies: allCookies })));
+        };
+        CookieWrapper.displayName = "withCookies(" + name + ")";
+        CookieWrapper.WrappedComponent = WrappedComponent;
+        return CookieWrapper;
+    }(React.Component));
+    var ForwardedComponent = React.forwardRef(function (props, ref) {
+        return (React.createElement(Consumer, null, function (cookies) { return (React.createElement(CookieWrapper, __assign({ cookies: cookies }, props, { forwardedRef: ref }))); }));
+    });
+    ForwardedComponent.displayName = CookieWrapper.displayName;
+    ForwardedComponent.WrappedComponent = CookieWrapper.WrappedComponent;
+    return hoistStatics(ForwardedComponent, WrappedComponent);
+}