0.2.0 - Mid migration

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

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

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

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _universalCookie = _interopRequireDefault(require("universal-cookie"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var _default = _universalCookie["default"];
+exports["default"] = _default;
+module.exports = exports.default;

web/node_modules/react-cookie/cjs/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/cjs/CookiesContext.js

@@ -0,0 +1,26 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.Consumer = exports.Provider = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _Cookies = _interopRequireDefault(require("./Cookies"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var CookiesContext = /*#__PURE__*/React.createContext(new _Cookies["default"]());
+var Provider = CookiesContext.Provider,
+    Consumer = CookiesContext.Consumer;
+exports.Consumer = Consumer;
+exports.Provider = Provider;
+var _default = CookiesContext;
+exports["default"] = _default;

web/node_modules/react-cookie/cjs/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/cjs/CookiesProvider.js

@@ -0,0 +1,74 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _universalCookie = _interopRequireDefault(require("universal-cookie"));
+
+var _CookiesContext = require("./CookiesContext");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var __extends = void 0 && (void 0).__extends || function () {
+  var _extendStatics = function extendStatics(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 CookiesProvider = 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 _universalCookie["default"]();
+    }
+
+    return _this;
+  }
+
+  CookiesProvider.prototype.render = function () {
+    return /*#__PURE__*/React.createElement(_CookiesContext.Provider, {
+      value: this.cookies
+    }, this.props.children);
+  };
+
+  return CookiesProvider;
+}(React.Component);
+
+var _default = CookiesProvider;
+exports["default"] = _default;
+module.exports = exports.default;

web/node_modules/react-cookie/cjs/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/cjs/index.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  Cookies: true,
+  CookiesProvider: true,
+  withCookies: true,
+  useCookies: true
+};
+Object.defineProperty(exports, "Cookies", {
+  enumerable: true,
+  get: function get() {
+    return _Cookies["default"];
+  }
+});
+Object.defineProperty(exports, "CookiesProvider", {
+  enumerable: true,
+  get: function get() {
+    return _CookiesProvider["default"];
+  }
+});
+Object.defineProperty(exports, "withCookies", {
+  enumerable: true,
+  get: function get() {
+    return _withCookies["default"];
+  }
+});
+Object.defineProperty(exports, "useCookies", {
+  enumerable: true,
+  get: function get() {
+    return _useCookies["default"];
+  }
+});
+
+var _Cookies = _interopRequireDefault(require("./Cookies"));
+
+var _CookiesProvider = _interopRequireDefault(require("./CookiesProvider"));
+
+var _withCookies = _interopRequireDefault(require("./withCookies"));
+
+var _useCookies = _interopRequireDefault(require("./useCookies"));
+
+var _types = require("./types");
+
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _types[key];
+    }
+  });
+});
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

web/node_modules/react-cookie/cjs/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/cjs/types.js

@@ -0,0 +1 @@
+"use strict";

web/node_modules/react-cookie/cjs/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/cjs/useCookies.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = useCookies;
+
+var _react = require("react");
+
+var _CookiesContext = _interopRequireDefault(require("./CookiesContext"));
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function useCookies(dependencies) {
+  var cookies = (0, _react.useContext)(_CookiesContext["default"]);
+
+  if (!cookies) {
+    throw new Error('Missing <CookiesProvider>');
+  }
+
+  var initialCookies = cookies.getAll();
+
+  var _a = (0, _react.useState)(initialCookies),
+      allCookies = _a[0],
+      setCookies = _a[1];
+
+  var previousCookiesRef = (0, _react.useRef)(allCookies);
+
+  if ((0, _utils.isInBrowser)()) {
+    (0, _react.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 = (0, _react.useMemo)(function () {
+    return cookies.set.bind(cookies);
+  }, [cookies]);
+  var removeCookie = (0, _react.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;
+}
+
+module.exports = exports.default;

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

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

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

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isInBrowser = isInBrowser;
+
+function isInBrowser() {
+  return typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined';
+}

web/node_modules/react-cookie/cjs/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/cjs/withCookies.js

@@ -0,0 +1,151 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = withCookies;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _hoistNonReactStatics = _interopRequireDefault(require("hoist-non-react-statics"));
+
+var _CookiesContext = require("./CookiesContext");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var __extends = void 0 && (void 0).__extends || function () {
+  var _extendStatics = function extendStatics(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 = void 0 && (void 0).__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 = void 0 && (void 0).__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;
+};
+
+function withCookies(WrappedComponent) {
+  // @ts-ignore
+  var name = WrappedComponent.displayName || WrappedComponent.name;
+
+  var CookieWrapper = 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 /*#__PURE__*/React.createElement(WrappedComponent, __assign({}, restProps, {
+        ref: forwardedRef,
+        cookies: cookies,
+        allCookies: allCookies
+      }));
+    };
+
+    CookieWrapper.displayName = "withCookies(" + name + ")";
+    CookieWrapper.WrappedComponent = WrappedComponent;
+    return CookieWrapper;
+  }(React.Component);
+
+  var ForwardedComponent = /*#__PURE__*/React.forwardRef(function (props, ref) {
+    return /*#__PURE__*/React.createElement(_CookiesContext.Consumer, null, function (cookies) {
+      return /*#__PURE__*/React.createElement(CookieWrapper, __assign({
+        cookies: cookies
+      }, props, {
+        forwardedRef: ref
+      }));
+    });
+  });
+  ForwardedComponent.displayName = CookieWrapper.displayName;
+  ForwardedComponent.WrappedComponent = CookieWrapper.WrappedComponent;
+  return (0, _hoistNonReactStatics["default"])(ForwardedComponent, WrappedComponent);
+}
+
+module.exports = exports.default;