this maps values from redux store to props of this component
761799
function mapStateToProps(state) {
    return {
        clicker: state.clicker,
        repoUser: state.repoUser,
        repositories: state.repositories,
        errors: state.errors
    };
}
218611
function PropRep(props) {
  const Grip = require("./grip");
  const { Rep } = require("./rep");

  let { name, mode, equal, suppressQuotes } = props;

  let key;
  // The key can be a simple string, for plain objects,
  // or another object for maps and weakmaps.
  if (typeof name === "string") {
    if (!suppressQuotes) {
      name = maybeEscapePropertyName(name);
    }
    key = span({ className: "nodeName" }, name);
  } else {
    key = Rep({
      ...props,
      className: "nodeName",
      object: name,
      mode: mode || MODE.TINY,
      defaultRep: Grip
    });
  }

  return [
    key,
    span(
      {
        className: "objectEqual"
      },
      equal
    ),
    Rep({ ...props })
  ];
}
746037
function(component) {
    if (options.reduxStoreInitiator && isFunction(options.reduxStoreInitiator)) {
      var initStore = options.reduxStoreInitiator;
      if (initStore.default) {
        initStore = initStore.default;
      }
      var store = initStore(props);
      var Provider = require('react-redux').Provider;
      return React.createElement(Provider, { store: store }, component);
    } else {
      return component;
    }
  }
584156
function map(obj, cb, ctx)
{
    var result = {};
    forEach(obj, function(key, val){
        result[key] = cb.call(ctx, key, val);
    }, ctx);
    return result;
}
735339
public void createRelationFieldMap(Props props)
   {
      byte[] fieldMapData = null;
      for (Integer key : RELATION_KEYS)
      {
         fieldMapData = props.getByteArray(key);
         if (fieldMapData != null)
         {
            break;
         }
      }

      if (fieldMapData == null)
      {
         populateDefaultData(getDefaultRelationData());
      }
      else
      {
         createFieldMap(fieldMapData);
      }
   }
637566
private void convertPrivateDataValue(
            final Map<String, String> data,
            final DataContext privateDataContext,
            final String name,
            final String propValue,
            final Map<String, Object> renderingOptions
    ) throws ConfigurationException
    {
        boolean clearValue = isValueConversionFailureRemove(renderingOptions);
        String[] prop = propValue.split("\\.", 2);
        if (prop.length < 2 || prop[0].length() < 1 || prop[1].length() < 1) {

            throw new ConfigurationException(
                    "Unable to load '" +
                    name +
                    "' configuration value: Expected 'option.name' format, but saw: " +
                    propValue
            );
        }
        String newvalue = privateDataContext.resolve(prop[0], prop[1]);

        if (null == newvalue) {
            if(clearValue) {
                data.remove(name);
            }
            return;
        }
        data.put(name, newvalue);
    }
786658
function basePick(object, props) {
        object = Object(object);
        return arrayReduce(props, function (result, key) {
          if (key in object) {
            result[key] = object[key];
          }
          return result;
        }, {});
      }
1077356
function computedReduxProperty(key, getProps) {
  return computed({
    get: () => getProps()[key],
    set: () => { assert(`Cannot set redux property "${key}". Try dispatching a redux action instead.`); }
  });
}
125526
function buildRefValues (indexes, data) {
  let v
  const ret = {}
  for (v in indexes) {
    if (indexes.hasOwnProperty(v)) {
      const path = indexes[v].path
      const name = indexes[v].name
      const indexType = indexes[v].indexType

      let value = null
      if (indexes[v].compound) {
        value = _.map(path, p => processValue(mpath.get(p, data)))
        value = expandValues(value)
        value = _.compact(value)

        const containsNested = _.some(value, _.isArray)
        if (containsNested) {
          value = _.map(value, v => v.join('_'))
        } else {
          value = value.join('_')
        }
      } else {
        value = processValue(mpath.get(path, data))
      }

      if (indexes[v].refKeyCase === REF_KEY_CASE.UPPER) {
        value = value.toUpperCase()
      } else if (indexes[v].refKeyCase === REF_KEY_CASE.LOWER) {
        value = value.toLowerCase()
      }

      ret[name] = {
        path,
        value,
        name,
        indexType
      }
    }
  }

  return ret
}
127998
private static Map<Integer, AdvancedExternalizer<?>> getExternalizersFromProps(StoreProperties props) {
      Map<Integer, AdvancedExternalizer<?>> map = new HashMap<>();
      String externalizers = props.get(MARSHALLER, EXTERNALIZERS);
      if (externalizers != null) {
         for (String ext : externalizers.split(",")) {
            String[] extArray = ext.split(":");
            String className = extArray.length > 1 ? extArray[1] : extArray[0];
            AdvancedExternalizer<?> instance = Util.getInstance(className, SerializationConfigUtil.class.getClassLoader());
            int id = extArray.length > 1 ? new Integer(extArray[0]) : instance.getId();
            map.put(id, instance);
         }
      }
      return map;
   }
334029
function getProperties(props) {
    var re = [];

    $.each(props, function(key) {
      key = $.camelCase(key); // Convert "text-align" => "textAlign"
      key = $.transit.propertyMap[key] || $.cssProps[key] || key;
      key = uncamel(key); // Convert back to dasherized

      if ($.inArray(key, re) === -1) { re.push(key); }
    });

    return re;
  }
875450
function Dropdown(props) {
  const {
    children,
    isOpen,
    selectedItem,
    selectedItems,
    highlightedIndex,
    inputValue,
    onSelect,
    onStateChange,
    downshiftProps
  } = props;
  // Refs used to handle custom Garden keyboard nav
  const itemIndexRef = useRef(0);
  const previousItemRef = useRef(undefined);
  const previousIndexRef = useRef(undefined);
  const nextItemsHashRef = useRef({});

  // Used to inform Menu (Popper) that a full-width menu is needed
  const popperReferenceElementRef = useRef(null);

  /**
   * Add additional keyboard nav to the basics provided by Downshift
   **/
  const customGetInputProps = ({ onKeyDown, ...other }, downshift, rtl) => {
    return {
      onKeyDown: composeEventHandlers(onKeyDown, e => {
        const PREVIOUS_KEY = rtl ? KEY_CODES.RIGHT : KEY_CODES.LEFT;
        const NEXT_KEY = rtl ? KEY_CODES.LEFT : KEY_CODES.RIGHT;

        if (downshift.isOpen) {
          // Select highlighted item on TAB
          if (e.keyCode === KEY_CODES.TAB) {
            e.preventDefault();
            e.stopPropagation();

            downshift.selectHighlightedItem();
          }

          // Select previous item if available
          if (
            e.keyCode === PREVIOUS_KEY &&
            previousIndexRef.current !== null &&
            !downshift.inputValue
          ) {
            e.preventDefault();
            e.stopPropagation();

            downshift.selectItemAtIndex(previousIndexRef.current);
          }

          // Select current next item if available
          if (e.keyCode === NEXT_KEY) {
            const nextItemIndexes = Object.values(nextItemsHashRef.current);

            if (nextItemIndexes.includes(downshift.highlightedIndex)) {
              e.preventDefault();
              e.stopPropagation();

              downshift.selectItemAtIndex(downshift.highlightedIndex);
            }
          }
        } else if (
          (e.keyCode === KEY_CODES.ENTER || e.keyCode === KEY_CODES.SPACE) &&
          !downshift.isOpen
        ) {
          e.preventDefault();
          e.stopPropagation();

          downshift.openMenu();
        }
      }),
      ...other
    };
  };

  const transformDownshift = ({ getInputProps, getToggleButtonProps, ...downshift }) => {
    return {
      getInputProps: p => getInputProps(customGetInputProps(p, downshift, isRtl(props))),
      // The default aria-label provided by Downshift is invalid due to our DOM structure
      getToggleButtonProps: p => getToggleButtonProps({ 'aria-label': undefined, ...p }),
      ...downshift
    };
  };

  return (
    <Manager>
      <Downshift
        suppressRefError // https://github.com/downshift-js/downshift/issues/529 Allows us to provide props through context
        isOpen={isOpen}
        highlightedIndex={highlightedIndex}
        selectedItem={selectedItem || null} // Ensures that selectedItem never becomes controlled internally by Downshift
        inputValue={inputValue}
        onStateChange={(changes, stateAndHelpers) => {
          if (
            Object.prototype.hasOwnProperty.call(changes, 'selectedItem') &&
            changes.selectedItem !== null
          ) {
            if (selectedItems) {
              const { itemToString } = stateAndHelpers;
              const existingItemIndex = selectedItems.findIndex(item => {
                return itemToString(item) === itemToString(changes.selectedItem);
              });
              const updatedSelectedItems = Array.from(selectedItems);

              if (existingItemIndex === -1) {
                updatedSelectedItems.splice(updatedSelectedItems.length, 0, changes.selectedItem);
              } else {
                updatedSelectedItems.splice(existingItemIndex, 1);
              }

              /**
               * Customize the changes returned from `onStateChange` as
               * Downshift has no concept of a "multiselect".
               **/
              changes.selectedItems = updatedSelectedItems;
              delete changes.selectedItem;

              onSelect && onSelect(updatedSelectedItems, stateAndHelpers);
            } else {
              onSelect && onSelect(changes.selectedItem, stateAndHelpers);
            }
          }

          onStateChange && onStateChange(changes, stateAndHelpers);
        }}
        stateReducer={(_state, changes) => {
          /**
           * Set inputValue to an empty string during any event that updates the inputValue
           */
          switch (changes.type) {
            case Downshift.stateChangeTypes.controlledPropUpdatedSelectedItem:
            case Downshift.stateChangeTypes.mouseUp:
            case Downshift.stateChangeTypes.keyDownEnter:
            case Downshift.stateChangeTypes.clickItem:
            case Downshift.stateChangeTypes.clickButton:
            case Downshift.stateChangeTypes.keyDownSpaceButton:
            case Downshift.stateChangeTypes.blurButton:
              return {
                ...changes,
                inputValue: ''
              };
            default:
              return changes;
          }
        }}
        {...downshiftProps}
      >
        {downshift => (
          <DropdownContext.Provider
            value={{
              itemIndexRef,
              previousItemRef,
              previousIndexRef,
              nextItemsHashRef,
              popperReferenceElementRef,
              selectedItems,
              downshift: transformDownshift(downshift)
            }}
          >
            {children}
          </DropdownContext.Provider>
        )}
      </Downshift>
    </Manager>
  );
}
929552
def produce(cls, mapped_props, aggregated, value_type, visitor):
        
        kwargs = {} if not mapped_props else dict(
            (k.name, v) for k, v in mapped_props
        )
        if issubclass(value_type, Collection):
            kwargs['values'] = aggregated
        return value_type(**kwargs)
541770
function connectStore(modules) {
  var mapStateToProps = function mapStateToProps(state, props) {
    var finalState = {};
    Object.keys(modules).forEach(function (key) {
      var moduleInstance = modules[key];
      var module_name = moduleInstance.module && moduleInstance.module.name || moduleInstance.name;
      var stateObj = state[module_name];
      if (moduleInstance.get) {
        var filter_array = moduleInstance.get.split(",");
        stateObj = (0, _helpers.pluck)(stateObj, filter_array);
      }
      stateObj = attachModuleSelectors(moduleInstance, stateObj, state, props);
      finalState[key] = stateObj;
    });
    return finalState;
  };

  var mapDispatchToProps = function mapDispatchToProps(dispatch) {
    var finalProps = {};
    Object.keys(modules).forEach(function (key) {
      var moduleInstance = modules[key];
      var actions_obj = {};
      var module_actions = moduleInstance.module && moduleInstance.module.actions || moduleInstance.actions;
      if (module_actions) {
        Object.keys(module_actions).forEach(function (action_key) {
          var action = module_actions[action_key];
          actions_obj[action_key] = function () {
            return dispatch(action.apply(undefined, arguments));
          };
        });
        finalProps[key] = actions_obj;
      }
    });
    return finalProps;
  };
  var mergeProps = function mergeProps(state, actions, ownProps) {
    var finalModule = {};
    Object.keys(state).forEach(function (key) {
      var module_state = state[key];
      var module_actions = actions[key];
      finalModule[key] = Object.assign({}, module_state, module_actions);
    });
    return Object.assign({}, finalModule, ownProps);
  };
  return (0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps, mergeProps, {
    pure: true,
    areStatePropsEqual: function areStatePropsEqual(a, b) {
      return (0, _helpers.areSame)(a, b);
    }
  });
}
318676
function map(subject, field, sendTarget) {
  const omitKey = !field || !!subject.customPayload;
  const composeSetter = () =>
    sendTarget ?
      omitKey ?
        function (value) {
          subject.dispatcher.call(this, this.$store, value, targetGetter.call(this));
        } :
        function (value) {
          subject.dispatcher.call(this, this.$store, value, field, targetGetter.call(this));
        } :
      omitKey ?
        function (value) {
          subject.dispatcher.call(this, this.$store, value);
        } :
        function (value) {
          subject.dispatcher.call(this, this.$store, value, field);
        };
  const fieldGetter = function () {
    return dot(this, subject.path + '.' + field);
  };
  const targetGetter = function () {
    return dot(this, subject.path);
  };
  const resultGetter = field ? fieldGetter : targetGetter;
  const result = {
    get: subject.getterGate ? subject.getterGate(field, resultGetter) : resultGetter
  };
  const method = !!subject.action ? 'dispatch' : !!subject.mutation ? 'commit' : null;
  const storeAction = !!subject.action ? subject.action : !!subject.mutation ? subject.mutation : null;
  if (!!method) subject.hook(
    sendTarget ?
      omitKey ?
        (store, payload, target) => store[method](storeAction, { target, payload }) :
        (store, value, key, target) => store[method](storeAction, { target, key, value }) :
      omitKey ?
        (store, value) => store[method](storeAction, value) :
        (store, value, key) => store[method](storeAction, { key, value }));
  if (subject.dispatcher) result.set = subject.gate ? subject.gate(field, composeSetter()) : composeSetter();
  return result;
}
720317
private Map<String, Object> extractOptions(Map<String, Object> props) {
        List<Map<String, Object>> optionsList = Nester.nest("options", props);
        if (!optionsList.isEmpty()) {
            Map<String, Object> options = new HashMap<String, Object>(optionsList.get(0).size());
            for (Map.Entry<String, Object> option : optionsList.get(0).entrySet()) {
                String key = option.getKey();
                if (key.startsWith(".")
                    || key.startsWith("config.")
                    || key.startsWith("service.")
                    || key.equals("id")) {
                    continue;
                }
                options.put(key, option.getValue());

            }
            return options;
        }
        return new HashMap<String, Object>(2);

    }
1257468
function map(data) {
    var result = {}
      , i = this.properties.length;

    while (i--) result[this.properties[i]] = data[i];
    return result;
  }