536 lines
22 KiB
JavaScript
536 lines
22 KiB
JavaScript
exports.__esModule = true;
|
|
exports.warn = exports.requestAnimationFrame = exports.reducePropsToState = exports.mapStateOnServer = exports.handleClientStateChange = exports.convertReactPropstoHtmlAttributes = undefined;
|
|
|
|
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
|
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
|
|
|
|
var _react = require("react");
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _objectAssign = require("object-assign");
|
|
|
|
var _objectAssign2 = _interopRequireDefault(_objectAssign);
|
|
|
|
var _HelmetConstants = require("./HelmetConstants.js");
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var encodeSpecialCharacters = function encodeSpecialCharacters(str) {
|
|
var encode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
|
|
|
|
if (encode === false) {
|
|
return String(str);
|
|
}
|
|
|
|
return String(str).replace(/&/g, "&").replace(/</g, "<").replace(/>/g, ">").replace(/"/g, """).replace(/'/g, "'");
|
|
};
|
|
|
|
var getTitleFromPropsList = function getTitleFromPropsList(propsList) {
|
|
var innermostTitle = getInnermostProperty(propsList, _HelmetConstants.TAG_NAMES.TITLE);
|
|
var innermostTemplate = getInnermostProperty(propsList, _HelmetConstants.HELMET_PROPS.TITLE_TEMPLATE);
|
|
|
|
if (innermostTemplate && innermostTitle) {
|
|
// use function arg to avoid need to escape $ characters
|
|
return innermostTemplate.replace(/%s/g, function () {
|
|
return innermostTitle;
|
|
});
|
|
}
|
|
|
|
var innermostDefaultTitle = getInnermostProperty(propsList, _HelmetConstants.HELMET_PROPS.DEFAULT_TITLE);
|
|
|
|
return innermostTitle || innermostDefaultTitle || undefined;
|
|
};
|
|
|
|
var getOnChangeClientState = function getOnChangeClientState(propsList) {
|
|
return getInnermostProperty(propsList, _HelmetConstants.HELMET_PROPS.ON_CHANGE_CLIENT_STATE) || function () {};
|
|
};
|
|
|
|
var getAttributesFromPropsList = function getAttributesFromPropsList(tagType, propsList) {
|
|
return propsList.filter(function (props) {
|
|
return typeof props[tagType] !== "undefined";
|
|
}).map(function (props) {
|
|
return props[tagType];
|
|
}).reduce(function (tagAttrs, current) {
|
|
return _extends({}, tagAttrs, current);
|
|
}, {});
|
|
};
|
|
|
|
var getBaseTagFromPropsList = function getBaseTagFromPropsList(primaryAttributes, propsList) {
|
|
return propsList.filter(function (props) {
|
|
return typeof props[_HelmetConstants.TAG_NAMES.BASE] !== "undefined";
|
|
}).map(function (props) {
|
|
return props[_HelmetConstants.TAG_NAMES.BASE];
|
|
}).reverse().reduce(function (innermostBaseTag, tag) {
|
|
if (!innermostBaseTag.length) {
|
|
var keys = Object.keys(tag);
|
|
|
|
for (var i = 0; i < keys.length; i++) {
|
|
var attributeKey = keys[i];
|
|
var lowerCaseAttributeKey = attributeKey.toLowerCase();
|
|
|
|
if (primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 && tag[lowerCaseAttributeKey]) {
|
|
return innermostBaseTag.concat(tag);
|
|
}
|
|
}
|
|
}
|
|
|
|
return innermostBaseTag;
|
|
}, []);
|
|
};
|
|
|
|
var getTagsFromPropsList = function getTagsFromPropsList(tagName, primaryAttributes, propsList) {
|
|
// Calculate list of tags, giving priority innermost component (end of the propslist)
|
|
var approvedSeenTags = {};
|
|
|
|
return propsList.filter(function (props) {
|
|
if (Array.isArray(props[tagName])) {
|
|
return true;
|
|
}
|
|
if (typeof props[tagName] !== "undefined") {
|
|
warn("Helmet: " + tagName + " should be of type \"Array\". Instead found type \"" + _typeof(props[tagName]) + "\"");
|
|
}
|
|
return false;
|
|
}).map(function (props) {
|
|
return props[tagName];
|
|
}).reverse().reduce(function (approvedTags, instanceTags) {
|
|
var instanceSeenTags = {};
|
|
|
|
instanceTags.filter(function (tag) {
|
|
var primaryAttributeKey = void 0;
|
|
var keys = Object.keys(tag);
|
|
for (var i = 0; i < keys.length; i++) {
|
|
var attributeKey = keys[i];
|
|
var lowerCaseAttributeKey = attributeKey.toLowerCase();
|
|
|
|
// Special rule with link tags, since rel and href are both primary tags, rel takes priority
|
|
if (primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 && !(primaryAttributeKey === _HelmetConstants.TAG_PROPERTIES.REL && tag[primaryAttributeKey].toLowerCase() === "canonical") && !(lowerCaseAttributeKey === _HelmetConstants.TAG_PROPERTIES.REL && tag[lowerCaseAttributeKey].toLowerCase() === "stylesheet")) {
|
|
primaryAttributeKey = lowerCaseAttributeKey;
|
|
}
|
|
// Special case for innerHTML which doesn't work lowercased
|
|
if (primaryAttributes.indexOf(attributeKey) !== -1 && (attributeKey === _HelmetConstants.TAG_PROPERTIES.INNER_HTML || attributeKey === _HelmetConstants.TAG_PROPERTIES.CSS_TEXT || attributeKey === _HelmetConstants.TAG_PROPERTIES.ITEM_PROP)) {
|
|
primaryAttributeKey = attributeKey;
|
|
}
|
|
}
|
|
|
|
if (!primaryAttributeKey || !tag[primaryAttributeKey]) {
|
|
return false;
|
|
}
|
|
|
|
var value = tag[primaryAttributeKey].toLowerCase();
|
|
|
|
if (!approvedSeenTags[primaryAttributeKey]) {
|
|
approvedSeenTags[primaryAttributeKey] = {};
|
|
}
|
|
|
|
if (!instanceSeenTags[primaryAttributeKey]) {
|
|
instanceSeenTags[primaryAttributeKey] = {};
|
|
}
|
|
|
|
if (!approvedSeenTags[primaryAttributeKey][value]) {
|
|
instanceSeenTags[primaryAttributeKey][value] = true;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}).reverse().forEach(function (tag) {
|
|
return approvedTags.push(tag);
|
|
});
|
|
|
|
// Update seen tags with tags from this instance
|
|
var keys = Object.keys(instanceSeenTags);
|
|
for (var i = 0; i < keys.length; i++) {
|
|
var attributeKey = keys[i];
|
|
var tagUnion = (0, _objectAssign2.default)({}, approvedSeenTags[attributeKey], instanceSeenTags[attributeKey]);
|
|
|
|
approvedSeenTags[attributeKey] = tagUnion;
|
|
}
|
|
|
|
return approvedTags;
|
|
}, []).reverse();
|
|
};
|
|
|
|
var getInnermostProperty = function getInnermostProperty(propsList, property) {
|
|
for (var i = propsList.length - 1; i >= 0; i--) {
|
|
var props = propsList[i];
|
|
|
|
if (props.hasOwnProperty(property)) {
|
|
return props[property];
|
|
}
|
|
}
|
|
|
|
return null;
|
|
};
|
|
|
|
var reducePropsToState = function reducePropsToState(propsList) {
|
|
return {
|
|
baseTag: getBaseTagFromPropsList([_HelmetConstants.TAG_PROPERTIES.HREF], propsList),
|
|
bodyAttributes: getAttributesFromPropsList(_HelmetConstants.ATTRIBUTE_NAMES.BODY, propsList),
|
|
defer: getInnermostProperty(propsList, _HelmetConstants.HELMET_PROPS.DEFER),
|
|
encode: getInnermostProperty(propsList, _HelmetConstants.HELMET_PROPS.ENCODE_SPECIAL_CHARACTERS),
|
|
htmlAttributes: getAttributesFromPropsList(_HelmetConstants.ATTRIBUTE_NAMES.HTML, propsList),
|
|
linkTags: getTagsFromPropsList(_HelmetConstants.TAG_NAMES.LINK, [_HelmetConstants.TAG_PROPERTIES.REL, _HelmetConstants.TAG_PROPERTIES.HREF], propsList),
|
|
metaTags: getTagsFromPropsList(_HelmetConstants.TAG_NAMES.META, [_HelmetConstants.TAG_PROPERTIES.NAME, _HelmetConstants.TAG_PROPERTIES.CHARSET, _HelmetConstants.TAG_PROPERTIES.HTTPEQUIV, _HelmetConstants.TAG_PROPERTIES.PROPERTY, _HelmetConstants.TAG_PROPERTIES.ITEM_PROP], propsList),
|
|
noscriptTags: getTagsFromPropsList(_HelmetConstants.TAG_NAMES.NOSCRIPT, [_HelmetConstants.TAG_PROPERTIES.INNER_HTML], propsList),
|
|
onChangeClientState: getOnChangeClientState(propsList),
|
|
scriptTags: getTagsFromPropsList(_HelmetConstants.TAG_NAMES.SCRIPT, [_HelmetConstants.TAG_PROPERTIES.SRC, _HelmetConstants.TAG_PROPERTIES.INNER_HTML], propsList),
|
|
styleTags: getTagsFromPropsList(_HelmetConstants.TAG_NAMES.STYLE, [_HelmetConstants.TAG_PROPERTIES.CSS_TEXT], propsList),
|
|
title: getTitleFromPropsList(propsList),
|
|
titleAttributes: getAttributesFromPropsList(_HelmetConstants.ATTRIBUTE_NAMES.TITLE, propsList)
|
|
};
|
|
};
|
|
|
|
var rafPolyfill = function () {
|
|
var clock = Date.now();
|
|
|
|
return function (callback) {
|
|
var currentTime = Date.now();
|
|
|
|
if (currentTime - clock > 16) {
|
|
clock = currentTime;
|
|
callback(currentTime);
|
|
} else {
|
|
setTimeout(function () {
|
|
rafPolyfill(callback);
|
|
}, 0);
|
|
}
|
|
};
|
|
}();
|
|
|
|
var cafPolyfill = function cafPolyfill(id) {
|
|
return clearTimeout(id);
|
|
};
|
|
|
|
var requestAnimationFrame = typeof window !== "undefined" ? window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || rafPolyfill : global.requestAnimationFrame || rafPolyfill;
|
|
|
|
var cancelAnimationFrame = typeof window !== "undefined" ? window.cancelAnimationFrame || window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || cafPolyfill : global.cancelAnimationFrame || cafPolyfill;
|
|
|
|
var warn = function warn(msg) {
|
|
return console && typeof console.warn === "function" && console.warn(msg);
|
|
};
|
|
|
|
var _helmetCallback = null;
|
|
|
|
var handleClientStateChange = function handleClientStateChange(newState) {
|
|
if (_helmetCallback) {
|
|
cancelAnimationFrame(_helmetCallback);
|
|
}
|
|
|
|
if (newState.defer) {
|
|
_helmetCallback = requestAnimationFrame(function () {
|
|
commitTagChanges(newState, function () {
|
|
_helmetCallback = null;
|
|
});
|
|
});
|
|
} else {
|
|
commitTagChanges(newState);
|
|
_helmetCallback = null;
|
|
}
|
|
};
|
|
|
|
var commitTagChanges = function commitTagChanges(newState, cb) {
|
|
var baseTag = newState.baseTag,
|
|
bodyAttributes = newState.bodyAttributes,
|
|
htmlAttributes = newState.htmlAttributes,
|
|
linkTags = newState.linkTags,
|
|
metaTags = newState.metaTags,
|
|
noscriptTags = newState.noscriptTags,
|
|
onChangeClientState = newState.onChangeClientState,
|
|
scriptTags = newState.scriptTags,
|
|
styleTags = newState.styleTags,
|
|
title = newState.title,
|
|
titleAttributes = newState.titleAttributes;
|
|
|
|
updateAttributes(_HelmetConstants.TAG_NAMES.BODY, bodyAttributes);
|
|
updateAttributes(_HelmetConstants.TAG_NAMES.HTML, htmlAttributes);
|
|
|
|
updateTitle(title, titleAttributes);
|
|
|
|
var tagUpdates = {
|
|
baseTag: updateTags(_HelmetConstants.TAG_NAMES.BASE, baseTag),
|
|
linkTags: updateTags(_HelmetConstants.TAG_NAMES.LINK, linkTags),
|
|
metaTags: updateTags(_HelmetConstants.TAG_NAMES.META, metaTags),
|
|
noscriptTags: updateTags(_HelmetConstants.TAG_NAMES.NOSCRIPT, noscriptTags),
|
|
scriptTags: updateTags(_HelmetConstants.TAG_NAMES.SCRIPT, scriptTags),
|
|
styleTags: updateTags(_HelmetConstants.TAG_NAMES.STYLE, styleTags)
|
|
};
|
|
|
|
var addedTags = {};
|
|
var removedTags = {};
|
|
|
|
Object.keys(tagUpdates).forEach(function (tagType) {
|
|
var _tagUpdates$tagType = tagUpdates[tagType],
|
|
newTags = _tagUpdates$tagType.newTags,
|
|
oldTags = _tagUpdates$tagType.oldTags;
|
|
|
|
|
|
if (newTags.length) {
|
|
addedTags[tagType] = newTags;
|
|
}
|
|
if (oldTags.length) {
|
|
removedTags[tagType] = tagUpdates[tagType].oldTags;
|
|
}
|
|
});
|
|
|
|
cb && cb();
|
|
|
|
onChangeClientState(newState, addedTags, removedTags);
|
|
};
|
|
|
|
var flattenArray = function flattenArray(possibleArray) {
|
|
return Array.isArray(possibleArray) ? possibleArray.join("") : possibleArray;
|
|
};
|
|
|
|
var updateTitle = function updateTitle(title, attributes) {
|
|
if (typeof title !== "undefined" && document.title !== title) {
|
|
document.title = flattenArray(title);
|
|
}
|
|
|
|
updateAttributes(_HelmetConstants.TAG_NAMES.TITLE, attributes);
|
|
};
|
|
|
|
var updateAttributes = function updateAttributes(tagName, attributes) {
|
|
var elementTag = document.getElementsByTagName(tagName)[0];
|
|
|
|
if (!elementTag) {
|
|
return;
|
|
}
|
|
|
|
var helmetAttributeString = elementTag.getAttribute(_HelmetConstants.HELMET_ATTRIBUTE);
|
|
var helmetAttributes = helmetAttributeString ? helmetAttributeString.split(",") : [];
|
|
var attributesToRemove = [].concat(helmetAttributes);
|
|
var attributeKeys = Object.keys(attributes);
|
|
|
|
for (var i = 0; i < attributeKeys.length; i++) {
|
|
var attribute = attributeKeys[i];
|
|
var value = attributes[attribute] || "";
|
|
|
|
if (elementTag.getAttribute(attribute) !== value) {
|
|
elementTag.setAttribute(attribute, value);
|
|
}
|
|
|
|
if (helmetAttributes.indexOf(attribute) === -1) {
|
|
helmetAttributes.push(attribute);
|
|
}
|
|
|
|
var indexToSave = attributesToRemove.indexOf(attribute);
|
|
if (indexToSave !== -1) {
|
|
attributesToRemove.splice(indexToSave, 1);
|
|
}
|
|
}
|
|
|
|
for (var _i = attributesToRemove.length - 1; _i >= 0; _i--) {
|
|
elementTag.removeAttribute(attributesToRemove[_i]);
|
|
}
|
|
|
|
if (helmetAttributes.length === attributesToRemove.length) {
|
|
elementTag.removeAttribute(_HelmetConstants.HELMET_ATTRIBUTE);
|
|
} else if (elementTag.getAttribute(_HelmetConstants.HELMET_ATTRIBUTE) !== attributeKeys.join(",")) {
|
|
elementTag.setAttribute(_HelmetConstants.HELMET_ATTRIBUTE, attributeKeys.join(","));
|
|
}
|
|
};
|
|
|
|
var updateTags = function updateTags(type, tags) {
|
|
var headElement = document.head || document.querySelector(_HelmetConstants.TAG_NAMES.HEAD);
|
|
var tagNodes = headElement.querySelectorAll(type + "[" + _HelmetConstants.HELMET_ATTRIBUTE + "]");
|
|
var oldTags = Array.prototype.slice.call(tagNodes);
|
|
var newTags = [];
|
|
var indexToDelete = void 0;
|
|
|
|
if (tags && tags.length) {
|
|
tags.forEach(function (tag) {
|
|
var newElement = document.createElement(type);
|
|
|
|
for (var attribute in tag) {
|
|
if (tag.hasOwnProperty(attribute)) {
|
|
if (attribute === _HelmetConstants.TAG_PROPERTIES.INNER_HTML) {
|
|
newElement.innerHTML = tag.innerHTML;
|
|
} else if (attribute === _HelmetConstants.TAG_PROPERTIES.CSS_TEXT) {
|
|
if (newElement.styleSheet) {
|
|
newElement.styleSheet.cssText = tag.cssText;
|
|
} else {
|
|
newElement.appendChild(document.createTextNode(tag.cssText));
|
|
}
|
|
} else {
|
|
var value = typeof tag[attribute] === "undefined" ? "" : tag[attribute];
|
|
newElement.setAttribute(attribute, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
newElement.setAttribute(_HelmetConstants.HELMET_ATTRIBUTE, "true");
|
|
|
|
// Remove a duplicate tag from domTagstoRemove, so it isn't cleared.
|
|
if (oldTags.some(function (existingTag, index) {
|
|
indexToDelete = index;
|
|
return newElement.isEqualNode(existingTag);
|
|
})) {
|
|
oldTags.splice(indexToDelete, 1);
|
|
} else {
|
|
newTags.push(newElement);
|
|
}
|
|
});
|
|
}
|
|
|
|
oldTags.forEach(function (tag) {
|
|
return tag.parentNode.removeChild(tag);
|
|
});
|
|
newTags.forEach(function (tag) {
|
|
return headElement.appendChild(tag);
|
|
});
|
|
|
|
return {
|
|
oldTags: oldTags,
|
|
newTags: newTags
|
|
};
|
|
};
|
|
|
|
var generateElementAttributesAsString = function generateElementAttributesAsString(attributes) {
|
|
return Object.keys(attributes).reduce(function (str, key) {
|
|
var attr = typeof attributes[key] !== "undefined" ? key + "=\"" + attributes[key] + "\"" : "" + key;
|
|
return str ? str + " " + attr : attr;
|
|
}, "");
|
|
};
|
|
|
|
var generateTitleAsString = function generateTitleAsString(type, title, attributes, encode) {
|
|
var attributeString = generateElementAttributesAsString(attributes);
|
|
var flattenedTitle = flattenArray(title);
|
|
return attributeString ? "<" + type + " " + _HelmetConstants.HELMET_ATTRIBUTE + "=\"true\" " + attributeString + ">" + encodeSpecialCharacters(flattenedTitle, encode) + "</" + type + ">" : "<" + type + " " + _HelmetConstants.HELMET_ATTRIBUTE + "=\"true\">" + encodeSpecialCharacters(flattenedTitle, encode) + "</" + type + ">";
|
|
};
|
|
|
|
var generateTagsAsString = function generateTagsAsString(type, tags, encode) {
|
|
return tags.reduce(function (str, tag) {
|
|
var attributeHtml = Object.keys(tag).filter(function (attribute) {
|
|
return !(attribute === _HelmetConstants.TAG_PROPERTIES.INNER_HTML || attribute === _HelmetConstants.TAG_PROPERTIES.CSS_TEXT);
|
|
}).reduce(function (string, attribute) {
|
|
var attr = typeof tag[attribute] === "undefined" ? attribute : attribute + "=\"" + encodeSpecialCharacters(tag[attribute], encode) + "\"";
|
|
return string ? string + " " + attr : attr;
|
|
}, "");
|
|
|
|
var tagContent = tag.innerHTML || tag.cssText || "";
|
|
|
|
var isSelfClosing = _HelmetConstants.SELF_CLOSING_TAGS.indexOf(type) === -1;
|
|
|
|
return str + "<" + type + " " + _HelmetConstants.HELMET_ATTRIBUTE + "=\"true\" " + attributeHtml + (isSelfClosing ? "/>" : ">" + tagContent + "</" + type + ">");
|
|
}, "");
|
|
};
|
|
|
|
var convertElementAttributestoReactProps = function convertElementAttributestoReactProps(attributes) {
|
|
var initProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
|
|
return Object.keys(attributes).reduce(function (obj, key) {
|
|
obj[_HelmetConstants.REACT_TAG_MAP[key] || key] = attributes[key];
|
|
return obj;
|
|
}, initProps);
|
|
};
|
|
|
|
var convertReactPropstoHtmlAttributes = function convertReactPropstoHtmlAttributes(props) {
|
|
var initAttributes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
|
|
return Object.keys(props).reduce(function (obj, key) {
|
|
obj[_HelmetConstants.HTML_TAG_MAP[key] || key] = props[key];
|
|
return obj;
|
|
}, initAttributes);
|
|
};
|
|
|
|
var generateTitleAsReactComponent = function generateTitleAsReactComponent(type, title, attributes) {
|
|
var _initProps;
|
|
|
|
// assigning into an array to define toString function on it
|
|
var initProps = (_initProps = {
|
|
key: title
|
|
}, _initProps[_HelmetConstants.HELMET_ATTRIBUTE] = true, _initProps);
|
|
var props = convertElementAttributestoReactProps(attributes, initProps);
|
|
|
|
return [_react2.default.createElement(_HelmetConstants.TAG_NAMES.TITLE, props, title)];
|
|
};
|
|
|
|
var generateTagsAsReactComponent = function generateTagsAsReactComponent(type, tags) {
|
|
return tags.map(function (tag, i) {
|
|
var _mappedTag;
|
|
|
|
var mappedTag = (_mappedTag = {
|
|
key: i
|
|
}, _mappedTag[_HelmetConstants.HELMET_ATTRIBUTE] = true, _mappedTag);
|
|
|
|
Object.keys(tag).forEach(function (attribute) {
|
|
var mappedAttribute = _HelmetConstants.REACT_TAG_MAP[attribute] || attribute;
|
|
|
|
if (mappedAttribute === _HelmetConstants.TAG_PROPERTIES.INNER_HTML || mappedAttribute === _HelmetConstants.TAG_PROPERTIES.CSS_TEXT) {
|
|
var content = tag.innerHTML || tag.cssText;
|
|
mappedTag.dangerouslySetInnerHTML = { __html: content };
|
|
} else {
|
|
mappedTag[mappedAttribute] = tag[attribute];
|
|
}
|
|
});
|
|
|
|
return _react2.default.createElement(type, mappedTag);
|
|
});
|
|
};
|
|
|
|
var getMethodsForTag = function getMethodsForTag(type, tags, encode) {
|
|
switch (type) {
|
|
case _HelmetConstants.TAG_NAMES.TITLE:
|
|
return {
|
|
toComponent: function toComponent() {
|
|
return generateTitleAsReactComponent(type, tags.title, tags.titleAttributes, encode);
|
|
},
|
|
toString: function toString() {
|
|
return generateTitleAsString(type, tags.title, tags.titleAttributes, encode);
|
|
}
|
|
};
|
|
case _HelmetConstants.ATTRIBUTE_NAMES.BODY:
|
|
case _HelmetConstants.ATTRIBUTE_NAMES.HTML:
|
|
return {
|
|
toComponent: function toComponent() {
|
|
return convertElementAttributestoReactProps(tags);
|
|
},
|
|
toString: function toString() {
|
|
return generateElementAttributesAsString(tags);
|
|
}
|
|
};
|
|
default:
|
|
return {
|
|
toComponent: function toComponent() {
|
|
return generateTagsAsReactComponent(type, tags);
|
|
},
|
|
toString: function toString() {
|
|
return generateTagsAsString(type, tags, encode);
|
|
}
|
|
};
|
|
}
|
|
};
|
|
|
|
var mapStateOnServer = function mapStateOnServer(_ref) {
|
|
var baseTag = _ref.baseTag,
|
|
bodyAttributes = _ref.bodyAttributes,
|
|
encode = _ref.encode,
|
|
htmlAttributes = _ref.htmlAttributes,
|
|
linkTags = _ref.linkTags,
|
|
metaTags = _ref.metaTags,
|
|
noscriptTags = _ref.noscriptTags,
|
|
scriptTags = _ref.scriptTags,
|
|
styleTags = _ref.styleTags,
|
|
_ref$title = _ref.title,
|
|
title = _ref$title === undefined ? "" : _ref$title,
|
|
titleAttributes = _ref.titleAttributes;
|
|
return {
|
|
base: getMethodsForTag(_HelmetConstants.TAG_NAMES.BASE, baseTag, encode),
|
|
bodyAttributes: getMethodsForTag(_HelmetConstants.ATTRIBUTE_NAMES.BODY, bodyAttributes, encode),
|
|
htmlAttributes: getMethodsForTag(_HelmetConstants.ATTRIBUTE_NAMES.HTML, htmlAttributes, encode),
|
|
link: getMethodsForTag(_HelmetConstants.TAG_NAMES.LINK, linkTags, encode),
|
|
meta: getMethodsForTag(_HelmetConstants.TAG_NAMES.META, metaTags, encode),
|
|
noscript: getMethodsForTag(_HelmetConstants.TAG_NAMES.NOSCRIPT, noscriptTags, encode),
|
|
script: getMethodsForTag(_HelmetConstants.TAG_NAMES.SCRIPT, scriptTags, encode),
|
|
style: getMethodsForTag(_HelmetConstants.TAG_NAMES.STYLE, styleTags, encode),
|
|
title: getMethodsForTag(_HelmetConstants.TAG_NAMES.TITLE, { title: title, titleAttributes: titleAttributes }, encode)
|
|
};
|
|
};
|
|
|
|
exports.convertReactPropstoHtmlAttributes = convertReactPropstoHtmlAttributes;
|
|
exports.handleClientStateChange = handleClientStateChange;
|
|
exports.mapStateOnServer = mapStateOnServer;
|
|
exports.reducePropsToState = reducePropsToState;
|
|
exports.requestAnimationFrame = requestAnimationFrame;
|
|
exports.warn = warn; |