@wordpress/element 5.15.0 → 5.17.0

package/build-module/serialize.js

@@ -30,17 +30,18 @@
  */
 import { isPlainObject } from 'is-plain-object';
 import { paramCase as kebabCase } from 'change-case';
+
 /**
  * WordPress dependencies
  */
-
 import { escapeHTML, escapeAttribute, isValidAttributeName } from '@wordpress/escape-html';
+
 /**
  * Internal dependencies
  */
-
 import { createContext, Fragment, StrictMode, forwardRef } from './react';
 import RawHTML from './raw-html';
+
 /** @typedef {import('./react').WPElement} WPElement */
 
 const {
@@ -50,20 +51,21 @@ const {
 const ForwardRef = forwardRef(() => {
   return null;
 });
+
 /**
  * Valid attribute types.
  *
  * @type {Set<string>}
  */
-
 const ATTRIBUTES_TYPES = new Set(['string', 'boolean', 'number']);
+
 /**
  * Element tags which can be self-closing.
  *
  * @type {Set<string>}
  */
-
 const SELF_CLOSING_TAGS = new Set(['area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
+
 /**
  * Boolean attributes are attributes whose presence as being assigned is
  * meaningful, even if only empty.
@@ -79,8 +81,8 @@ const SELF_CLOSING_TAGS = new Set(['area', 'base', 'br', 'col', 'command', 'embe
  *
  * @type {Set<string>}
  */
-
 const BOOLEAN_ATTRIBUTES = new Set(['allowfullscreen', 'allowpaymentrequest', 'allowusermedia', 'async', 'autofocus', 'autoplay', 'checked', 'controls', 'default', 'defer', 'disabled', 'download', 'formnovalidate', 'hidden', 'ismap', 'itemscope', 'loop', 'multiple', 'muted', 'nomodule', 'novalidate', 'open', 'playsinline', 'readonly', 'required', 'reversed', 'selected', 'typemustmatch']);
+
 /**
  * Enumerated attributes are attributes which must be of a specific value form.
  * Like boolean attributes, these are meaningful if specified, even if not of a
@@ -101,8 +103,8 @@ const BOOLEAN_ATTRIBUTES = new Set(['allowfullscreen', 'allowpaymentrequest', 'a
  *
  * @type {Set<string>}
  */
-
 const ENUMERATED_ATTRIBUTES = new Set(['autocapitalize', 'autocomplete', 'charset', 'contenteditable', 'crossorigin', 'decoding', 'dir', 'draggable', 'enctype', 'formenctype', 'formmethod', 'http-equiv', 'inputmode', 'kind', 'method', 'preload', 'scope', 'shape', 'spellcheck', 'translate', 'type', 'wrap']);
+
 /**
  * Set of CSS style properties which support assignment of unitless numbers.
  * Used in rendering of style properties, where `px` unit is assumed unless
@@ -121,8 +123,8 @@ const ENUMERATED_ATTRIBUTES = new Set(['autocapitalize', 'autocomplete', 'charse
  *
  * @type {Set<string>}
  */
-
 const CSS_PROPERTIES_SUPPORTS_UNITLESS = new Set(['animation', 'animationIterationCount', 'baselineShift', 'borderImageOutset', 'borderImageSlice', 'borderImageWidth', 'columnCount', 'cx', 'cy', 'fillOpacity', 'flexGrow', 'flexShrink', 'floodOpacity', 'fontWeight', 'gridColumnEnd', 'gridColumnStart', 'gridRowEnd', 'gridRowStart', 'lineHeight', 'opacity', 'order', 'orphans', 'r', 'rx', 'ry', 'shapeImageThreshold', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'tabSize', 'widows', 'x', 'y', 'zIndex', 'zoom']);
+
 /**
  * Returns true if the specified string is prefixed by one of an array of
  * possible prefixes.
@@ -132,10 +134,10 @@ const CSS_PROPERTIES_SUPPORTS_UNITLESS = new Set(['animation', 'animationIterati
  *
  * @return {boolean} Whether string has prefix.
  */
-
 export function hasPrefix(string, prefixes) {
   return prefixes.some(prefix => string.indexOf(prefix) === 0);
 }
+
 /**
  * Returns true if the given prop name should be ignored in attributes
  * serialization, or false otherwise.
@@ -144,10 +146,10 @@ export function hasPrefix(string, prefixes) {
  *
  * @return {boolean} Whether attribute should be ignored.
  */
-
 function isInternalAttribute(attribute) {
   return 'key' === attribute || 'children' === attribute;
 }
+
 /**
  * Returns the normal form of the element's attribute value for HTML.
  *
@@ -156,14 +158,11 @@ function isInternalAttribute(attribute) {
  *
  * @return {*} Normalized attribute value.
  */
-
-
 function getNormalAttributeValue(attribute, value) {
   switch (attribute) {
     case 'style':
       return renderStyle(value);
   }
-
   return value;
 }
 /**
@@ -172,34 +171,33 @@ function getNormalAttributeValue(attribute, value) {
  *
  * List from: https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute.
  */
-
-
 const SVG_ATTRIBUTE_WITH_DASHES_LIST = ['accentHeight', 'alignmentBaseline', 'arabicForm', 'baselineShift', 'capHeight', 'clipPath', 'clipRule', 'colorInterpolation', 'colorInterpolationFilters', 'colorProfile', 'colorRendering', 'dominantBaseline', 'enableBackground', 'fillOpacity', 'fillRule', 'floodColor', 'floodOpacity', 'fontFamily', 'fontSize', 'fontSizeAdjust', 'fontStretch', 'fontStyle', 'fontVariant', 'fontWeight', 'glyphName', 'glyphOrientationHorizontal', 'glyphOrientationVertical', 'horizAdvX', 'horizOriginX', 'imageRendering', 'letterSpacing', 'lightingColor', 'markerEnd', 'markerMid', 'markerStart', 'overlinePosition', 'overlineThickness', 'paintOrder', 'panose1', 'pointerEvents', 'renderingIntent', 'shapeRendering', 'stopColor', 'stopOpacity', 'strikethroughPosition', 'strikethroughThickness', 'strokeDasharray', 'strokeDashoffset', 'strokeLinecap', 'strokeLinejoin', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'textAnchor', 'textDecoration', 'textRendering', 'underlinePosition', 'underlineThickness', 'unicodeBidi', 'unicodeRange', 'unitsPerEm', 'vAlphabetic', 'vHanging', 'vIdeographic', 'vMathematical', 'vectorEffect', 'vertAdvY', 'vertOriginX', 'vertOriginY', 'wordSpacing', 'writingMode', 'xmlnsXlink', 'xHeight'].reduce((map, attribute) => {
   // The keys are lower-cased for more robust lookup.
   map[attribute.toLowerCase()] = attribute;
   return map;
 }, {});
+
 /**
  * This is a map of all case-sensitive SVG attributes. Map(lowercase key => proper case attribute).
  * The keys are lower-cased for more robust lookup.
  * Note that this list only contains attributes that contain at least one capital letter.
  * Lowercase attributes don't need mapping, since we lowercase all attributes by default.
  */
-
 const CASE_SENSITIVE_SVG_ATTRIBUTES = ['allowReorder', 'attributeName', 'attributeType', 'autoReverse', 'baseFrequency', 'baseProfile', 'calcMode', 'clipPathUnits', 'contentScriptType', 'contentStyleType', 'diffuseConstant', 'edgeMode', 'externalResourcesRequired', 'filterRes', 'filterUnits', 'glyphRef', 'gradientTransform', 'gradientUnits', 'kernelMatrix', 'kernelUnitLength', 'keyPoints', 'keySplines', 'keyTimes', 'lengthAdjust', 'limitingConeAngle', 'markerHeight', 'markerUnits', 'markerWidth', 'maskContentUnits', 'maskUnits', 'numOctaves', 'pathLength', 'patternContentUnits', 'patternTransform', 'patternUnits', 'pointsAtX', 'pointsAtY', 'pointsAtZ', 'preserveAlpha', 'preserveAspectRatio', 'primitiveUnits', 'refX', 'refY', 'repeatCount', 'repeatDur', 'requiredExtensions', 'requiredFeatures', 'specularConstant', 'specularExponent', 'spreadMethod', 'startOffset', 'stdDeviation', 'stitchTiles', 'suppressContentEditableWarning', 'suppressHydrationWarning', 'surfaceScale', 'systemLanguage', 'tableValues', 'targetX', 'targetY', 'textLength', 'viewBox', 'viewTarget', 'xChannelSelector', 'yChannelSelector'].reduce((map, attribute) => {
   // The keys are lower-cased for more robust lookup.
   map[attribute.toLowerCase()] = attribute;
   return map;
 }, {});
+
 /**
  * This is a map of all SVG attributes that have colons.
  * Keys are lower-cased and stripped of their colons for more robust lookup.
  */
-
 const SVG_ATTRIBUTES_WITH_COLONS = ['xlink:actuate', 'xlink:arcrole', 'xlink:href', 'xlink:role', 'xlink:show', 'xlink:title', 'xlink:type', 'xml:base', 'xml:lang', 'xml:space', 'xmlns:xlink'].reduce((map, attribute) => {
   map[attribute.replace(':', '').toLowerCase()] = attribute;
   return map;
 }, {});
+
 /**
  * Returns the normal form of the element's attribute name for HTML.
  *
@@ -207,18 +205,14 @@ const SVG_ATTRIBUTES_WITH_COLONS = ['xlink:actuate', 'xlink:arcrole', 'xlink:hre
  *
  * @return {string} Normalized attribute name.
  */
-
 function getNormalAttributeName(attribute) {
   switch (attribute) {
     case 'htmlFor':
       return 'for';
-
     case 'className':
       return 'class';
   }
-
   const attributeLowerCase = attribute.toLowerCase();
-
   if (CASE_SENSITIVE_SVG_ATTRIBUTES[attributeLowerCase]) {
     return CASE_SENSITIVE_SVG_ATTRIBUTES[attributeLowerCase];
   } else if (SVG_ATTRIBUTE_WITH_DASHES_LIST[attributeLowerCase]) {
@@ -226,9 +220,9 @@ function getNormalAttributeName(attribute) {
   } else if (SVG_ATTRIBUTES_WITH_COLONS[attributeLowerCase]) {
     return SVG_ATTRIBUTES_WITH_COLONS[attributeLowerCase];
   }
-
   return attributeLowerCase;
 }
+
 /**
  * Returns the normal form of the style property name for HTML.
  *
@@ -240,19 +234,16 @@ function getNormalAttributeName(attribute) {
  *
  * @return {string} Normalized property name.
  */
-
-
 function getNormalStylePropertyName(property) {
   if (property.startsWith('--')) {
     return property;
   }
-
   if (hasPrefix(property, ['ms', 'O', 'Moz', 'Webkit'])) {
     return '-' + kebabCase(property);
   }
-
   return kebabCase(property);
 }
+
 /**
  * Returns the normal form of the style property value for HTML. Appends a
  * default pixel unit if numeric, not a unitless property, and not zero.
@@ -262,15 +253,13 @@ function getNormalStylePropertyName(property) {
  *
  * @return {*} Normalized property value.
  */
-
-
 function getNormalStylePropertyValue(property, value) {
   if (typeof value === 'number' && 0 !== value && !CSS_PROPERTIES_SUPPORTS_UNITLESS.has(property)) {
     return value + 'px';
   }
-
   return value;
 }
+
 /**
  * Serializes a React element to string.
  *
@@ -280,74 +269,60 @@ function getNormalStylePropertyValue(property, value) {
  *
  * @return {string} Serialized element.
  */
-
-
 export function renderElement(element, context, legacyContext = {}) {
   if (null === element || undefined === element || false === element) {
     return '';
   }
-
   if (Array.isArray(element)) {
     return renderChildren(element, context, legacyContext);
   }
-
   switch (typeof element) {
     case 'string':
       return escapeHTML(element);
-
     case 'number':
       return element.toString();
   }
-
   const {
     type,
     props
-  } =
-  /** @type {{type?: any, props?: any}} */
+  } = /** @type {{type?: any, props?: any}} */
   element;
-
   switch (type) {
     case StrictMode:
     case Fragment:
       return renderChildren(props.children, context, legacyContext);
-
     case RawHTML:
       const {
         children,
         ...wrapperProps
       } = props;
-      return renderNativeComponent(!Object.keys(wrapperProps).length ? null : 'div', { ...wrapperProps,
+      return renderNativeComponent(!Object.keys(wrapperProps).length ? null : 'div', {
+        ...wrapperProps,
         dangerouslySetInnerHTML: {
           __html: children
         }
       }, context, legacyContext);
   }
-
   switch (typeof type) {
     case 'string':
       return renderNativeComponent(type, props, context, legacyContext);
-
     case 'function':
       if (type.prototype && typeof type.prototype.render === 'function') {
         return renderComponent(type, props, context, legacyContext);
       }
-
       return renderElement(type(props, legacyContext), context, legacyContext);
   }
-
   switch (type && type.$$typeof) {
     case Provider.$$typeof:
       return renderChildren(props.children, props.value, legacyContext);
-
     case Consumer.$$typeof:
       return renderElement(props.children(context || type._currentValue), context, legacyContext);
-
     case ForwardRef.$$typeof:
       return renderElement(type.render(props), context, legacyContext);
   }
-
   return '';
 }
+
 /**
  * Serializes a native component type to string.
  *
@@ -359,10 +334,8 @@ export function renderElement(element, context, legacyContext = {}) {
  *
  * @return {string} Serialized element.
  */
-
 export function renderNativeComponent(type, props, context, legacyContext = {}) {
   let content = '';
-
   if (type === 'textarea' && props.hasOwnProperty('value')) {
     // Textarea children can be assigned as value prop. If it is, render in
     // place of children. Ensure to omit so it is not assigned as attribute
@@ -379,19 +352,16 @@ export function renderNativeComponent(type, props, context, legacyContext = {})
   } else if (typeof props.children !== 'undefined') {
     content = renderChildren(props.children, context, legacyContext);
   }
-
   if (!type) {
     return content;
   }
-
   const attributes = renderAttributes(props);
-
   if (SELF_CLOSING_TAGS.has(type)) {
     return '<' + type + attributes + '/>';
   }
-
   return '<' + type + attributes + '>' + content + '</' + type + '>';
 }
+
 /** @typedef {import('./react').WPComponent} WPComponent */
 
 /**
@@ -404,25 +374,20 @@ export function renderNativeComponent(type, props, context, legacyContext = {})
  *
  * @return {string} Serialized element
  */
-
 export function renderComponent(Component, props, context, legacyContext = {}) {
-  const instance = new
-  /** @type {import('react').ComponentClass} */
+  const instance = new /** @type {import('react').ComponentClass} */
   Component(props, legacyContext);
-
-  if (typeof // Ignore reason: Current prettier reformats parens and mangles type assertion
+  if (typeof
+  // Ignore reason: Current prettier reformats parens and mangles type assertion
   // prettier-ignore
-
   /** @type {{getChildContext?: () => unknown}} */
   instance.getChildContext === 'function') {
-    Object.assign(legacyContext,
-    /** @type {{getChildContext?: () => unknown}} */
-    instance.getChildContext());
+    Object.assign(legacyContext, /** @type {{getChildContext?: () => unknown}} */instance.getChildContext());
   }
-
   const html = renderElement(instance.render(), context, legacyContext);
   return html;
 }
+
 /**
  * Serializes an array of children to string.
  *
@@ -432,18 +397,16 @@ export function renderComponent(Component, props, context, legacyContext = {}) {
  *
  * @return {string} Serialized children.
  */
-
 function renderChildren(children, context, legacyContext = {}) {
   let result = '';
   children = Array.isArray(children) ? children : [children];
-
   for (let i = 0; i < children.length; i++) {
     const child = children[i];
     result += renderElement(child, context, legacyContext);
   }
-
   return result;
 }
+
 /**
  * Renders a props object as a string of HTML attributes.
  *
@@ -451,57 +414,51 @@ function renderChildren(children, context, legacyContext = {}) {
  *
  * @return {string} Attributes string.
  */
-
-
 export function renderAttributes(props) {
   let result = '';
-
   for (const key in props) {
     const attribute = getNormalAttributeName(key);
-
     if (!isValidAttributeName(attribute)) {
       continue;
     }
+    let value = getNormalAttributeValue(key, props[key]);
 
-    let value = getNormalAttributeValue(key, props[key]); // If value is not of serializeable type, skip.
-
+    // If value is not of serializeable type, skip.
     if (!ATTRIBUTES_TYPES.has(typeof value)) {
       continue;
-    } // Don't render internal attribute names.
-
+    }
 
+    // Don't render internal attribute names.
     if (isInternalAttribute(key)) {
       continue;
     }
+    const isBooleanAttribute = BOOLEAN_ATTRIBUTES.has(attribute);
 
-    const isBooleanAttribute = BOOLEAN_ATTRIBUTES.has(attribute); // Boolean attribute should be omitted outright if its value is false.
-
+    // Boolean attribute should be omitted outright if its value is false.
     if (isBooleanAttribute && value === false) {
       continue;
     }
+    const isMeaningfulAttribute = isBooleanAttribute || hasPrefix(key, ['data-', 'aria-']) || ENUMERATED_ATTRIBUTES.has(attribute);
 
-    const isMeaningfulAttribute = isBooleanAttribute || hasPrefix(key, ['data-', 'aria-']) || ENUMERATED_ATTRIBUTES.has(attribute); // Only write boolean value as attribute if meaningful.
-
+    // Only write boolean value as attribute if meaningful.
     if (typeof value === 'boolean' && !isMeaningfulAttribute) {
       continue;
     }
+    result += ' ' + attribute;
 
-    result += ' ' + attribute; // Boolean attributes should write attribute name, but without value.
+    // Boolean attributes should write attribute name, but without value.
     // Mere presence of attribute name is effective truthiness.
-
     if (isBooleanAttribute) {
       continue;
     }
-
     if (typeof value === 'string') {
       value = escapeAttribute(value);
     }
-
     result += '="' + value + '"';
   }
-
   return result;
 }
+
 /**
  * Renders a style object as a string attribute value.
  *
@@ -509,33 +466,26 @@ export function renderAttributes(props) {
  *
  * @return {string} Style attribute value.
  */
-
 export function renderStyle(style) {
   // Only generate from object, e.g. tolerate string value.
   if (!isPlainObject(style)) {
     return style;
   }
-
   let result;
-
   for (const property in style) {
     const value = style[property];
-
     if (null === value || undefined === value) {
       continue;
     }
-
     if (result) {
       result += ';';
     } else {
       result = '';
     }
-
     const normalName = getNormalStylePropertyName(property);
     const normalValue = getNormalStylePropertyValue(property, value);
     result += normalName + ':' + normalValue;
   }
-
   return result;
 }
 export default renderElement;