Accepts all `<input />` props.
761001
function MediaInput({ wrapperProps = {}, start, end, ...props }) {
  const { getInputProps } = useFieldContext();
  const inputRef = useRef(undefined);

  const { onClick, ...otherWrapperProps } = wrapperProps;

  const onFauxInputClickHandler = composeEventHandlers(onClick, () => {
    inputRef.current && inputRef.current.focus();
  });

  return (
    <FauxInput
      data-garden-id="forms.media_input"
      data-garden-version={PACKAGE_VERSION}
      onClick={onFauxInputClickHandler}
      mediaLayout
      {...otherWrapperProps}
    >
      {start && <StyledTextMediaFigure>{start}</StyledTextMediaFigure>}
      <StyledTextMediaInput
        {...getInputProps({
          innerRef: inputRef,
          ...props
        })}
      />
      {end && <StyledTextMediaFigure>{end}</StyledTextMediaFigure>}
    </FauxInput>
  );
}
566433
function _supportColorProps(props) {
	var p;
	for (p = 0; p < props.length; p += 1) {
		$.fx.step[props[p]] = _animateColor;
	}
}
1333694
function LoginPage(props: Props): React.Node {
  const {
    action,
    method,
    onSubmit,
    onChange,
    onBlur,
    values,
    strings = {},
    errors,
  } = props;

  return (
    <StandaloneFormPage imageURL={"./demo/logo.svg"}>
      <FormCard
        buttonText={strings.buttonText || defaultStrings.buttonText}
        title={strings.title || defaultStrings.title}
        onSubmit={onSubmit}
        action={action}
        method={method}
      >
        <FormTextInput
          name="email"
          label={strings.emailLabel || defaultStrings.emailLabel}
          placeholder={
            strings.emailPlaceholder || defaultStrings.emailPlaceholder
          }
          onChange={onChange}
          onBlur={onBlur}
          value={values && values.email}
          error={errors && errors.email}
        />
        <FormTextInput
          name="password"
          type="password"
          label={strings.passwordLabel || defaultStrings.passwordLabel}
          placeholder={
            strings.passwordPlaceholder || defaultStrings.passwordPlaceholder
          }
          onChange={onChange}
          onBlur={onBlur}
          value={values && values.password}
          error={errors && errors.password}
        />
      </FormCard>
    </StandaloneFormPage>
  );
}
257033
def _validate_props(self):
        """"""
        for key, prop in iteritems(self._props):
            try:
                value = self._get(key)
                err_msg = 'Invalid value for property {}: {}'.format(key, value)
                if value is not None:
                    change = dict(name=key, previous=value, value=value,
                                  mode='validate')
                    self._notify(change)
                    if not prop.equal(value, change['value']):
                        raise utils.ValidationError(err_msg, 'invalid',
                                                    prop.name, self)
                if not prop.assert_valid(self):
                    raise utils.ValidationError(err_msg, 'invalid',
                                                prop.name, self)
            except utils.ValidationError as val_err:
                if getattr(self, '_validation_error_tuples', None) is not None:
                    self._validation_error_tuples += val_err.error_tuples
                else:
                    raise
        return True
1317958
function createInput(props, pref) {
	const inputProps = {
		className: 'input-field',
		dataset: { type: props.type, },
		placeholder: props.placeholder || '',
	};
	let input; switch (props.type) {
		case 'select': case 'menulist': {
			input = createElement('select', inputProps);
			if (typeof props.getOptions === 'function') {
				input.classList.add('dynamic-select');
				setSelectOptions(input, typeof props.getCurrent === 'function' ? [ props.getCurrent(pref), ] : props.getOptions(pref));
			} else if (props.options) {
				setSelectOptions(input, props.options);
			}
		} break;
		case 'text': case 'code': {
			input = createElement('textarea', inputProps);
		} break;
		case 'random': case 'control': {
			Object.assign(inputProps, {
				value: props.label,
				dataset: { id: props.id, type: props.type, },
			});
		} /* falls through */
		default: {
			input = createElement('input', inputProps);
			input.type = ({
				control: 'button',
				random: 'button',
				boolean: 'checkbox',
				boolInt: 'checkbox',
				integer: 'number',
				string: 'text',
				keybordKey: 'text',
				command: 'text',
				color: 'color',
				label: 'hidden',
			})[props.type] || props.type;
		}
	}
	if (props.type === 'number') { input.step = 'any'; }
	if (input.type === 'checkbox') {
		input.className = '';
		input.id = 'l'+ Math.random().toString(32).slice(2);
		input = createElement('div', { className: 'checkbox-wrapper input-field', }, [
			input,
			createElement('label', { htmlFor: input.id, }),
		]);
	}
	input.id = 'i'+ Math.random().toString(32).slice(2);
	propsMap.set(input.id, props);
	return input;
}
361877
function set(name, element, previous, props) {
  if (set.handlers[name]) {
    set.handlers[name](name, element, previous, props);
  } else if (previous[name] !== props[name]) {
    element[name] = props[name];
  }
}
1349274
function extend(src, props) {
		props = props || {};
		var p;
		for (p in src) {
			if (src.hasOwnProperty(p)) {
				if (!props.hasOwnProperty(p)) {
					props[p] = src[p];
				}
			}
		}
		return props;
	}
1119074
function (props, key) {
        if (props[key]) {
            return;
        }
        props[key] = {
            configurable: true,
            enumerable: true,
            writable: true,
            value: function () {
                var error = this[__symbol__('error')];
                var errorMethod = (error && error[key]) || this[key];
                if (errorMethod) {
                    return errorMethod.apply(error, arguments);
                }
            }
        };
    }
1133357
def input(step_property, &value)
      mapping = IOMapping.new
      mapping.property = step_property
      mapping.value = value
      @step.inputs << mapping
      self
    end
1036450
@SuppressWarnings("unchecked")
    public A set(Iterable<Property> props) {
        if (Iterables.isEmpty(props)) {
            return (A) this;
        }
        return copy(delegate.put("data", Property.toArrayNode(props)));
    }
970547
public void setInputs(Collection<String> inputs) {
    List<String> newInputs = new ArrayList<String>();
    if (inputs != null) {
      newInputs.addAll(inputs);
    }
    this.inputs = newInputs;
  }
969689
public static void validateAllOrNone(Props props, String... keys) {
    Objects.requireNonNull(keys);

    boolean allExist = true;
    boolean someExist = false;
    for (String key : keys) {
      Object val = props.get(key);
      allExist &= val != null;
      someExist |= val != null;
    }

    if (someExist && !allExist) {
      throw new IllegalArgumentException(
          "Either all of properties exist or none of them should exist for " + Arrays
              .toString(keys));
    }
  }
53224
protected void processInput(String input) {
        String command = input.trim();
        if (!command.isEmpty()) {
            runCommand(command);
        }
    }
271588
public void addAllToProperties(Properties props) {
		synchronized (this.confData) {
			for (Map.Entry<String, Object> entry : this.confData.entrySet()) {
				props.put(entry.getKey(), entry.getValue());
			}
		}
	}
373483
function MouseInput() {
    this.evEl = MOUSE_ELEMENT_EVENTS;
    this.evWin = MOUSE_WINDOW_EVENTS;

    this.pressed = false; // mousedown state

    Input.apply(this, arguments);
}
546750
function mapInputType(model) {
    const modelName = `${model.modelName}Input`;

    types[modelName] = {
        generated: false,
        name: modelName,
        meta: {
            category: 'TYPE',
            input: true,
            fields: {}
        }
    };

    _.forEach(model.definition.properties, (property, key) => {
        mapProperty(model, property, modelName, key, true);
    });
}
559927
private boolean hasInputWithValue() {

		// Visit all children of the fieldset of type Input
		AbstractVisitorWithResult<Boolean> visitor = new AbstractVisitorWithResult<Boolean>() {
			@Override
			public WComponentTreeVisitor.VisitorResult visit(final WComponent comp) {
				// Check if the component is an Input and has a value
				if (comp instanceof Input && !((Input) comp).isEmpty()) {
					setResult(true);
					return VisitorResult.ABORT;
				}
				return VisitorResult.CONTINUE;
			}
		};
		visitor.setResult(false);

		TreeUtil.traverseVisible(this, visitor);

		return visitor.getResult();
	}