Top 7 Examples of "svg-tags in functional component" in JavaScript

}

      // Else try to import it as a node module.
      try {
        // npm modules are required via relative paths to support working with a locally linked idyll.
        resolved = slash(resolve.sync(name, { basedir: this.paths.INPUT_DIR }));
      } catch (err) {
        // Import errors are silently discarded.
        return;
      }
    });

    if (!resolved) {
      if (
        htmlTags.indexOf(name) > -1 ||
        svgTags.indexOf(name) > -1 ||
        name === 'root'
      ) {
        // It is a valid HTML component, but should not be added to the map.
        return;
      } else {
        if (['fullwidth', 'textcontainer'].indexOf(name) > -1) {
          throw new errors.OutOfDateError(name);
        }
        throw new errors.InvalidComponentError(name);
      }
    }

    debug(`Resolved component ${name} to ${resolved}`);
    return resolved;
  }

const getTag = (t, path) => {
  const namePath = path.get('name')
  if (t.isJSXIdentifier(namePath)) {
    const name = namePath.get('name').node
    if (path.scope.hasBinding(name) && !htmlTags.includes(name) && !svgTags.includes(name)) {
      return t.identifier(name)
    } else {
      return t.stringLiteral(name)
    }
  }

  /* istanbul ignore else */
  if (t.isJSXMemberExpression(namePath)) {
    return transformJSXMemberExpression(t, namePath)
  }
  /* istanbul ignore next */
  throw new Error(`getTag: ${namePath.type} is not supported`)
}

module.exports = function(selector /*: string*/) /*: boolean*/ {
	if (!/^[a-z]/.test(selector)) {
		return false;
	}

	if (selector.indexOf('-') === -1) {
		return false;
	}

	const selectorLowerCase = selector.toLowerCase();

	if (selectorLowerCase !== selector) {
		return false;
	}

	if (svgTags.indexOf(selectorLowerCase) !== -1) {
		return false;
	}

	if (htmlTags.indexOf(selectorLowerCase) !== -1) {
		return false;
	}

	if (keywordSets.nonStandardHtmlTags.has(selectorLowerCase)) {
		return false;
	}

	if (mathMLTags.indexOf(selectorLowerCase) !== -1) {
		return false;
	}

	return true;

}

					if (optionsMatches(options, 'ignoreNamespaces', tagNode.namespace)) {
						return;
					}

					if (optionsMatches(options, 'ignoreTypes', tagNode.value)) {
						return;
					}

					const tagName = tagNode.value;
					const tagNameLowerCase = tagName.toLowerCase();

					if (
						htmlTags.indexOf(tagNameLowerCase) !== -1 ||
						svgTags.indexOf(tagNameLowerCase) !== -1 ||
						keywordSets.nonStandardHtmlTags.has(tagNameLowerCase) ||
						mathMLTags.indexOf(tagNameLowerCase) !== -1
					) {
						return;
					}

					report({
						message: messages.rejected(tagName),
						node: rule,
						index: tagNode.sourceIndex,
						ruleName,
						result,
					});
				});
			});

var isReservedTag = function isReservedTag(tag) {
  return ~htmlTags.indexOf(tag) || ~svgTags.indexOf(tag)
}

selectorTree.walkTags(tagNode => {
          if (!isStandardSyntaxTypeSelector(tagNode)) { return }

          if (optionsMatches(options, "ignoreTypes", tagNode.value)) { return }

          const tagName = tagNode.value
          const tagNameLowerCase = tagName.toLowerCase()

          if (htmlTags.indexOf(tagNameLowerCase) !== -1
            || svgTags.indexOf(tagNameLowerCase) !== -1
            || nonStandardHtmlTags.has(tagNameLowerCase)
          ) { return }

          report({
            message: messages.rejected(tagName),
            node: rule,
            index: tagNode.sourceIndex,
            ruleName,
            result,
          })
        })
      })

const isComponent = (t, path) => {
  const name = path.get('name')
  if (t.isJSXMemberExpression(name)) {
    return true
  }

  const tag = name.get('name').node

  return !htmlTags.includes(tag) && !svgTags.includes(tag)
}