TypeScript inferno-shared.isNumber函数代码示例

// We are assuming here that we come from patchProp routine
// -nextAttrValue cannot be null or undefined
function patchStyle(lastAttrValue, nextAttrValue, dom) {
  const domStyle = dom.style;
  let style;
  let value;

  if (isString(nextAttrValue)) {
    domStyle.cssText = nextAttrValue;
    return;
  }

  if (!isNullOrUndef(lastAttrValue) && !isString(lastAttrValue)) {
    for (style in nextAttrValue) {
      // do not add a hasOwnProperty check here, it affects performance
      value = nextAttrValue[style];
      if (value !== lastAttrValue[style]) {
        domStyle[style] =
          !isNumber(value) || isUnitlessNumber.has(style)
            ? value
            : value + "px";
      }
    }

    for (style in lastAttrValue) {
      if (isNullOrUndef(nextAttrValue[style])) {
        domStyle[style] = "";
      }
    }
  } else {
    for (style in nextAttrValue) {
      value = nextAttrValue[style];
      domStyle[style] =
        !isNumber(value) || isUnitlessNumber.has(style) ? value : value + "px";
    }
  }
}

export function renderAttributes(props): string[] {
  const outputAttrs: string[] = [];
  const propsKeys = (props && Object.keys(props)) || [];

  for (let i = 0, len = propsKeys.length; i < len; i++) {
    const prop = propsKeys[i];

    if (
      prop !== "children" &&
      prop !== "dangerouslySetInnerHTML" &&
      prop !== "style"
    ) {
      const value = props[prop];

      if (isString(value)) {
        outputAttrs.push(prop + '="' + escapeText(value) + '"');
      } else if (isNumber(value)) {
        outputAttrs.push(prop + '="' + value + '"');
      } else if (isTrue(value)) {
        outputAttrs.push(prop);
      }
    }
  }

  return outputAttrs;
}

export function isVNode(instance: any): instance is VNode {
  return (
    Boolean(instance) &&
    isObject(instance) &&
    isNumber((instance as any).flags) &&
    (instance as any).flags > 0
  );
}

function applyKeyIfMissing(key: string | number, vNode: VNode): VNode {
  if (isNumber(key)) {
    key = `.${key}`;
  }
  if (isNull(vNode.key) || vNode.key[0] === ".") {
    return applyKey(key as string, vNode);
  }
  return vNode;
}

export function renderStylesToString(styles: string | object): string {
  if (isString(styles)) {
    return styles;
  } else {
    let renderedString = "";
    for (const styleName in styles) {
      const value = styles[styleName];

      if (isString(value)) {
        renderedString += `${getCssPropertyName(styleName)}${value};`;
      } else if (isNumber(value)) {
        renderedString += `${getCssPropertyName(
          styleName
        )}${value}${internal_isUnitlessNumber.has(styleName) ? "" : "px"};`;
      }
    }
    return renderedString;
  }
}

function renderVNodeToString(
  vNode,
  parent,
  context,
  firstChild
): string | undefined {
  const flags = vNode.flags;
  const type = vNode.type;
  const props = vNode.props || EMPTY_OBJ;
  const children = vNode.children;

  if ((flags & VNodeFlags.Component) > 0) {
    const isClass = flags & VNodeFlags.ComponentClass;

    if (isClass) {
      const instance = new type(props, context);
      instance._blockSetState = false;
      let childContext;
      if (isFunction(instance.getChildContext)) {
        childContext = instance.getChildContext();
      }

      if (isNullOrUndef(childContext)) {
        childContext = context;
      } else {
        childContext = combineFrom(context, childContext);
      }
      if (instance.props === EMPTY_OBJ) {
        instance.props = props;
      }
      instance.context = context;
      instance._unmounted = false;
      if (isFunction(instance.componentWillMount)) {
        instance._blockRender = true;
        instance.componentWillMount();
        if (instance._pendingSetState) {
          const state = instance.state;
          const pending = instance._pendingState;

          if (state === null) {
            instance.state = pending;
          } else {
            for (const key in pending) {
              state[key] = pending[key];
            }
          }
          instance._pendingSetState = false;
          instance._pendingState = null;
        }
        instance._blockRender = false;
      }
      const nextVNode = instance.render(props, instance.state, instance.context);
      // In case render returns invalid stuff
      if (isInvalid(nextVNode)) {
        return "<!--!-->";
      }
      return renderVNodeToString(nextVNode, vNode, childContext, true);
    } else {
      const nextVNode = type(props, context);

      if (isInvalid(nextVNode)) {
        return "<!--!-->";
      }
      return renderVNodeToString(nextVNode, vNode, context, true);
    }
  } else if ((flags & VNodeFlags.Element) > 0) {
    let renderedString = `<${type}`;
    let html;
    const isVoidElement = voidElements.has(type);
    const className = vNode.className;

    if (isString(className)) {
      renderedString += ` class="${escapeText(className)}"`;
    } else if (isNumber(className)) {
      renderedString += ` class="${className}"`;
    }

    if (!isNull(props)) {
      for (const prop in props) {
        const value = props[prop];

        if (prop === "dangerouslySetInnerHTML") {
          html = value.__html;
        } else if (prop === "style") {
          renderedString += ` style="${renderStylesToString(props.style)}"`;
        } else if (prop === "children") {
          // Ignore children as prop.
        } else if (prop === "defaultValue") {
          // Use default values if normal values are not present
          if (!props.value) {
            renderedString += ` value="${isString(value)
              ? escapeText(value)
              : value}"`;
          }
        } else if (prop === "defaultChecked") {
          // Use default values if normal values are not present
          if (!props.checked) {
            renderedString += ` checked="${value}"`;
          }
        } else {
//.........这里部分代码省略.........