PHPXRef 0.7.1 : WordPress : Detail view of blocks.js

Class: DecodeEntityParser - X-Ref

Subsitute EntityParser class for `simple-html-tokenizer` which uses the
implementation of `decodeEntities` from `html-entities`, in order to avoid
bundling a massive named character reference.

getTextPiecesSplitOnWhitespace(text) X-Ref

Given a specified string, returns an array of strings split by consecutive
whitespace, ignoring leading or trailing whitespace.

return: {string[]} Text pieces split on whitespace.
param: {string} text Original text.

getTextWithCollapsedWhitespace(text) X-Ref

Given a specified string, returns a new trimmed string where all consecutive
whitespace is collapsed to a single space.

return: {string} Trimmed text with consecutive whitespace collapsed.
param: {string} text Original text.

getMeaningfulAttributePairs(token) X-Ref

Returns attribute pairs of the given StartTag token, including only pairs
where the value is non-empty or the attribute is a boolean attribute, an
enumerated attribute, or a custom data- attribute.

return: {Array[]} Attribute pairs.
param: {Object} token StartTag token.

isEquivalentTextTokens(actual, expected) X-Ref

Returns true if two text tokens (with `chars` property) are equivalent, or
false otherwise.

return: {boolean} Whether two text tokens are equivalent.
param: {Object} actual Actual token.
param: {Object} expected Expected token.
param: {Object} logger Validation logger object.

getNormalizedLength(value) X-Ref

Given a CSS length value, returns a normalized CSS length value for strict equality
comparison.

return: {string} Normalized CSS length value.
param: {string} value CSS length value.

getNormalizedStyleValue(value) X-Ref

Given a style value, returns a normalized style value for strict equality
comparison.

return: {string} Normalized style value.
param: {string} value Style value.

getStyleProperties(text) X-Ref

Given a style attribute string, returns an object of style properties.

return: {Object} Style properties.
param: {string} text Style attribute.

isEqualTagAttributePairs(actual, expected) X-Ref

Given two sets of attribute tuples, returns true if the attribute sets are
equivalent.

return: {boolean} Whether attributes are equivalent.
param: {Array[]} actual Actual attributes tuples.
param: {Array[]} expected Expected attributes tuples.
param: {Object} logger Validation logger object.

getNextNonWhitespaceToken(tokens) X-Ref

Given an array of tokens, returns the first token which is not purely
whitespace.

Mutates the tokens array.

return: {Object} Next non-whitespace token.
param: {Object[]} tokens Set of tokens to search.

getHTMLTokens(html) X-Ref

Tokenize an HTML string, gracefully handling any errors thrown during
underlying tokenization.

return: {Object[]|null} Array of valid tokenized HTML elements, or null on error
param: {string} html HTML string to tokenize.
param: {Object} logger Validation logger object.

isClosedByToken(currentToken, nextToken) X-Ref

Returns true if the next HTML token closes the current token.

return: {boolean} true if `nextToken` closes `currentToken`, false otherwise
param: {Object} currentToken Current token to compare with.
param: {Object|undefined} nextToken Next token to compare against.

isEquivalentHTML(actual, expected) X-Ref

Returns true if the given HTML strings are effectively equivalent, or
false otherwise. Invalid HTML is not considered equivalent, even if the
strings directly match.

return: {boolean} Whether HTML strings are equivalent.
param: {string} actual Actual HTML string.
param: {string} expected Expected HTML string.
param: {Object} logger Validation logger object.

validateBlock(block) X-Ref

Returns an object with `isValid` property set to `true` if the parsed block
is valid given the input content. A block is considered valid if, when serialized
with assumed attributes, the content matches the original value. If block is
invalid, this function returns all validations issues as well.

return: {[boolean,Array<LoggerItem>]} validation results.
param: {WPBlock} block block object.
param: {WPBlockType|string} [blockTypeOrName = block.name] Block type or name, inferred from block if not given.

isValidBlockContent(blockTypeOrName, attributes, originalBlockContent) X-Ref

Returns true if the parsed block is valid given the input content. A block
is considered valid if, when serialized with assumed attributes, the content
matches the original value.

Logs to console in development environments when invalid.

return: {boolean} Whether block is valid.
param: {string|Object} blockTypeOrName      Block type.
param: {Object}        attributes           Parsed block attributes.
param: {string}        originalBlockContent Original block content.

convertLegacyBlockNameAndAttributes(name, attributes) X-Ref

Convert legacy blocks to their canonical form. This function is used
both in the parser level for previous content and to convert such blocks
used in Custom Post Types templates.

return: {[string, Object]} The block's name and attributes, changed accordingly if a match was found
param: {string} name The block's name
param: {Object} attributes The block's attributes

getPath(object, path) X-Ref

Given object and string of dot-delimited path segments, returns value at
path or undefined if path cannot be resolved.

return: {?*} Resolved value
param: {Object} object Lookup object
param: {string} path Path to resolve

parse(source, matchers) X-Ref

Given a markup string or DOM element, creates an object aligning with the
shape of the matchers object, or the value returned by the matcher.

return: {(Object|*)} Matched value(s), shaped by object
param: {(string|Element)} source Source content
param: {(Object|Function)} matchers Matcher function or object of matchers

prop(selector, name) X-Ref

Generates a function which matches node of type selector, returning an
attribute by property if the attribute exists. If no selector is passed,
returns property of the query element.

return: {*} Property value
param: {?string} selector Optional selector
param: {string} name Property name

attr(selector, name) X-Ref

Generates a function which matches node of type selector, returning an
attribute by name if the attribute exists. If no selector is passed,
returns attribute of the query element.

return: {?string} Attribute value
param: {?string} selector Optional selector
param: {string} name Attribute name

html(selector) X-Ref

Convenience for `prop( selector, 'innerHTML' )`.

return: {string} Inner HTML
param: {?string} selector Optional selector

es_text(selector) X-Ref

Convenience for `prop( selector, 'textContent' )`.

return: {string} Text content
param: {?string} selector Optional selector

query(selector, matchers) X-Ref

Creates a new matching context by first finding elements matching selector
using querySelectorAll before then running another `parse` on `matchers`
scoped to the matched elements.

return: {Array.<*,Object>} Array of matched value(s)
param: {string} selector Selector to match
param: {(Object|Function)} matchers Matcher function or object of matchers

matchers_html(selector, multilineTag) X-Ref

No description

isNodeOfType(node, type) X-Ref

Given a single node and a node type (e.g. `'br'`), returns true if the node
corresponds to that type, false otherwise.

return: {boolean} Whether node is of intended type.
param: {WPBlockNode} node Block node to test
param: {string} type Node to type to test against.

getNamedNodeMapAsObject(nodeMap) X-Ref

Given an object implementing the NamedNodeMap interface, returns a plain
object equivalent value of name, value key-value pairs.

return: {Object} Object equivalent value of NamedNodeMap.
param: {NamedNodeMap} nodeMap NamedNodeMap to convert to object.

fromDOM(domNode) X-Ref

Given a DOM Element or Text node, returns an equivalent block node. Throws
if passed any node type other than element or text.

return: {WPBlockNode} Block node equivalent to DOM node.
param: {Node} domNode DOM node to convert.

toHTML(node) X-Ref

Given a block node, returns its HTML string representation.

return: {string} String HTML representation of block node.
param: {WPBlockNode} node Block node to convert to string.

node_matcher(selector) X-Ref

Given a selector, returns an hpq matcher generating a WPBlockNode value
matching the selector result.

return: {Function} hpq matcher.
param: {string} selector DOM selector.

getSerializeCapableElement(children) X-Ref

Given block children, returns a serialize-capable WordPress element.

return: {WPElement} A serialize-capable element.
param: {WPBlockChildren} children Block children object to convert.

getChildrenArray(children) X-Ref

Given block children, returns an array of block nodes.

return: {Array<WPBlockNode>} An array of individual block nodes.
param: {WPBlockChildren} children Block children object to convert.

concat() X-Ref

Given two or more block nodes, returns a new block node representing a
concatenation of its values.

return: {WPBlockChildren} Concatenated block node.
param: {...WPBlockChildren} blockNodes Block nodes to concatenate.

children_fromDOM(domNodes) X-Ref

Given an iterable set of DOM nodes, returns equivalent block children.
Ignores any non-element/text nodes included in set.

return: {WPBlockChildren} Block children equivalent to DOM nodes.
param: {Iterable.<Node>} domNodes Iterable set of DOM nodes to convert.

children_toHTML(children) X-Ref

Given a block node, returns its HTML string representation.

return: {string} String HTML representation of block node.
param: {WPBlockChildren} children Block node(s) to convert to string.

children_matcher(selector) X-Ref

Given a selector, returns an hpq matcher generating a WPBlockChildren value
matching the selector result.

return: {Function} hpq matcher.
param: {string} selector DOM selector.

isOfType(value, type) X-Ref

Returns true if value is of the given JSON schema type, or false otherwise.

return: {boolean} Whether value is of type.
param: {*} value Value to test.
param: {string} type Type to test.

isOfTypes(value, types) X-Ref

Returns true if value is of an array of given JSON schema types, or false
otherwise.

return: {boolean} Whether value is of types.
param: {*} value Value to test.
param: {string[]} types Types to test.

getBlockAttribute(attributeKey, attributeSchema, innerHTML, commentAttributes) X-Ref

Given an attribute key, an attribute's schema, a block's raw content and the
commentAttributes returns the attribute value depending on its source
definition of the given attribute key.

return: {*} Attribute value.
param: {string}      attributeKey      Attribute key.
param: {Object}      attributeSchema   Attribute's schema.
param: {string|Node} innerHTML         Block's raw content.
param: {Object}      commentAttributes Block's comment attributes.

isValidByType(value, type) X-Ref

Returns true if value is valid per the given block attribute schema type
definition, or false otherwise.

return: {boolean} Whether value is valid.
param: {*} value Value to test.
param: {?(Array<string>|string)} type Block attribute schema type.

isValidByEnum(value, enumSet) X-Ref

Returns true if value is valid per the given block attribute schema enum
definition, or false otherwise.

return: {boolean} Whether value is valid.
param: {*} value Value to test.
param: {?Array} enumSet Block attribute schema enum.

parseHtml(innerHTML) X-Ref

Parse a HTML string into DOM tree.

return: {Node} Parsed DOM node.
param: {string|Node} innerHTML HTML string or already parsed DOM node.

parseWithAttributeSchema(innerHTML, attributeSchema) X-Ref

Given a block's raw content and an attribute's schema returns the attribute's
value depending on its source.

return: {*} Attribute value.
param: {string|Node} innerHTML Block's raw content.
param: {Object} attributeSchema Attribute's schema.

getBlockAttributes(blockTypeOrName, innerHTML) X-Ref

Returns the block attributes of a registered block node given its type.

return: {Object} All block attributes.
param: {string|Object} blockTypeOrName Block type or name.
param: {string|Node} innerHTML Raw block content.
param: {?Object} attributes Known block attributes (from delimiters).

getHTMLRootElementClasses(innerHTML) X-Ref

Given an HTML string, returns an array of class names assigned to the root
element in the markup.

return: {string[]} Array of class names assigned to the root element.
param: {string} innerHTML Markup string from which to extract classes.

fixCustomClassname(blockAttributes, blockType, innerHTML) X-Ref

Given a parsed set of block attributes, if the block supports custom class
names and an unknown class (per the block's serialization behavior) is
found, the unknown classes are treated as custom classes. This prevents the
block from being considered as invalid.

return: {Object} Filtered block attributes.
param: {Object} blockAttributes Original block attributes.
param: {Object} blockType Block type settings.
param: {string} innerHTML Original block markup.

applyBuiltInValidationFixes(block, blockType) X-Ref

Attempts to fix block invalidation by applying build-in validation fixes
like moving all extra classNames to the className attribute.

return: {WPBlock} Fixed block object
param: {WPBlock} block block object.
param: {import('../registration').WPBlockType} blockType Block type. This is normalize not necessary and

applyBlockDeprecatedVersions(block, rawBlock, blockType) X-Ref

Given a block object, returns a new copy of the block with any applicable
deprecated migrations applied, or the original block if it was both valid
and no eligible migrations exist.

return: {import(".").WPBlock} Migrated block object.
param: {import(".").WPBlock} block Parsed and invalid block object.
param: {import(".").WPRawBlock} rawBlock Raw block object.
param: {import('../registration').WPBlockType} blockType Block type. This is normalize not necessary and

convertLegacyBlocks(rawBlock) X-Ref

Convert legacy blocks to their canonical form. This function is used
both in the parser level for previous content and to convert such blocks
used in Custom Post Types templates.

return: {WPRawBlock} The block's name and attributes, changed accordingly if a match was found
param: {WPRawBlock} rawBlock

normalizeRawBlock(rawBlock) X-Ref

Normalize the raw block by applying the fallback block name if none given,
sanitize the parsed HTML...

return: {WPRawBlock} The normalized block object.
param: {WPRawBlock} rawBlock The raw block object.

createMissingBlockType(rawBlock) X-Ref

Uses the "unregistered blockType" to create a block object.

return: {WPRawBlock} The unregistered block object.
param: {WPRawBlock} rawBlock block.

applyBlockValidation(unvalidatedBlock, blockType) X-Ref

Validates a block and wraps with validation meta.

The name here is regrettable but `validateBlock` is already taken.

return: {WPBlock} validated block, with auto-fixes if initially invalid
param: {WPBlock} unvalidatedBlock
param: {import('../registration').WPBlockType} blockType

parseRawBlock(rawBlock, options) X-Ref

Given a raw block returned by grammar parsing, returns a fully parsed block.

return: {WPBlock} Fully parsed block.
param: {WPRawBlock} rawBlock The raw block object.
param: {ParseOptions} options Extra options for handling block parsing.

parser_parse(content, options) X-Ref

Utilizes an optimized token-driven parser based on the Gutenberg grammar spec
defined through a parsing expression grammar to take advantage of the regular
cadence provided by block delimiters -- composed syntactically through HTML
comments -- which, given a general HTML document as an input, returns a block
list array representation.

This is a recursive-descent parser that scans linearly once through the input
document. Instead of directly recursing it utilizes a trampoline mechanism to
prevent stack overflow. This initial pass is mainly interested in separating
and isolating the blocks serialized in the document and manifestly not in the
content within the blocks.

return: {Array} Block list.
param: {string} content The post content.
param: {ParseOptions} options Extra options for handling block parsing.

getRawTransforms() X-Ref

Internal dependencies

htmlToBlocks(html) X-Ref

Converts HTML directly to blocks. Looks for a matching transform for each
top-level tag. The HTML should be filtered to not have any text between
top-level tags and formatted in a way that blocks can handle the HTML.

return: {Array} An array of blocks.
param: {string} html HTML to convert.

normaliseBlocks(HTML) X-Ref

WordPress dependencies

specialCommentConverter(node, doc) X-Ref

Looks for `` and `` comments, as well as the
`` variant and its `` companion,
and replaces them with a custom element representing a future block.

The custom element is a way to bypass the rest of the `raw-handling`
transforms, which would eliminate other kinds of node with which to carry
``'s data: nodes with `data` attributes, empty paragraphs, etc.

The custom element is then expected to be recognized by any registered
block's `raw` transform.

return: {void}
param: {Node} node The node to be processed.
param: {Document} doc The document of the node.

createMore(customText, noTeaser, doc) X-Ref

No description

createNextpage(doc) X-Ref

No description

isList(node) X-Ref

WordPress dependencies

shallowTextContent(element) X-Ref

No description

listReducer(node) X-Ref

No description

blockquoteNormaliser(node) X-Ref

Internal dependencies

isFigureContent(node, schema) X-Ref

Whether or not the given node is figure content.

return: {boolean} True if figure content, false if not.
param: {Node} node The node to check.
param: {Object} schema The schema to use.

canHaveAnchor(node, schema) X-Ref

Whether or not the given node can have an anchor.

return: {boolean} True if it can, false if not.
param: {Node} node The node to check.
param: {Object} schema The schema to use.

wrapFigureContent(element) X-Ref

Wraps the given element in a figure element.

param: {Element} element The element to wrap.
param: {Element} beforeElement The element before which to place the figure.

figureContentReducer(node, doc, schema) X-Ref

This filter takes figure content out of paragraphs, wraps it in a figure
element, and moves any anchors with it if needed.

return: {void}
param: {Node}     node   The node to filter.
param: {Document} doc    The document of the node.
param: {Object}   schema The schema to use.

segmentHTMLToShortcodeBlock(HTML) X-Ref

No description

getBlockContentSchemaFromTransforms(transforms, context) X-Ref

No description

getBlockContentSchema(context) X-Ref

Gets the block content schema, which is extracted and merged from all
registered blocks with raw transfroms.

return: {Object} A complete block content schema.
param: {string} context Set to "paste" when in paste context, where the

isPlain(HTML) X-Ref

Checks whether HTML can be considered plain text. That is, it does not contain
any elements that are not line breaks.

return: {boolean} Whether the HTML can be considered plain text.
param: {string} HTML The HTML to check.

deepFilterNodeList(nodeList, filters, doc, schema) X-Ref

Given node filters, deeply filters and mutates a NodeList.

param: {NodeList} nodeList The nodeList to filter.
param: {Array}    filters  An array of functions that can mutate with the provided node.
param: {Document} doc      The document of the nodeList.
param: {Object}   schema   The schema to use.

deepFilterHTML(HTML) X-Ref

Given node filters, deeply filters HTML tags.
Filters from the deepest nodes to the top.

return: {string} The filtered HTML.
param: {string} HTML    The HTML to filter.
param: {Array}  filters An array of functions that can mutate with the provided node.
param: {Object} schema  The schema to use.

getSibling(node, which) X-Ref

Gets a sibling within text-level context.

param: {Element} node The subject node.
param: {string} which "next" or "previous".

deprecatedGetPhrasingContentSchema(context) X-Ref

No description

rawHandler(_ref) X-Ref

Converts an HTML string to known blocks.

return: {Array} A list of blocks.
param: {Object} $1
param: {string} $1.HTML The HTML to convert.

commentRemover(node) X-Ref

Looks for comments, and removes them.

return: {void}
param: {Node} node The node to be processed.

isInline(node, contextTag) X-Ref

Checks if the given node should be considered inline content, optionally
depending on a context tag.

return: {boolean} True if the node is inline content, false if nohe.
param: {Node} node Node name.
param: {string} contextTag Tag name.

deepCheck(nodes, contextTag) X-Ref

No description

isDoubleBR(node) X-Ref

No description

isInlineContent(HTML, contextTag) X-Ref

No description

phrasingContentReducer(node, doc) X-Ref

WordPress dependencies

headRemover(node) X-Ref

No description

ms_list_converter_isList(node) X-Ref

No description

msListConverter(node, doc) X-Ref

No description

imageCorrector(node) X-Ref

No description

divNormaliser(node) X-Ref

Internal dependencies

slackMarkdownVariantCorrector(text) X-Ref

Corrects the Slack Markdown variant of the code block.
If uncorrected, it will be converted to inline code.

return: {string} The corrected Markdown.
param: {string} text The potential Markdown text to correct.

markdownConverter(text) X-Ref

Converts a piece of text into HTML based on any Markdown present.
Also decodes any encoded HTML.

return: {string} HTML.
param: {string} text The plain text to convert.

iframeRemover(node) X-Ref

Removes iframes.

return: {void}
param: {Node} node The node to check.

googleDocsUIdRemover(node) X-Ref

WordPress dependencies

isFormattingSpace(character) X-Ref

Internal dependencies

htmlFormattingRemover(node) X-Ref

Removes spacing that formats HTML.

return: {void}
param: {Node} node The node to be processed.

brRemover(node) X-Ref

Removes trailing br elements from text-level content.

param: {Element} node Node to check.

emptyParagraphRemover(node) X-Ref

Removes empty paragraph elements.

param: {Element} node Node to check.

filterInlineHTML(HTML, preserveWhiteSpace) X-Ref

Filters HTML to only contain phrasing content.

return: {string} HTML only containing phrasing content.
param: {string} HTML The HTML to filter.
param: {boolean} preserveWhiteSpace Whether or not to preserve consequent white space.

pasteHandler(_ref) X-Ref

Converts an HTML string to known blocks. Strips everything else.

return: {Array|string} A list of blocks or a string, depending on `handlerMode`.
param: {Object}  options
param: {string}  [options.HTML]               The HTML to convert.
param: {string}  [options.plainText]          Plain text version.
param: {string}  [options.mode]               Handle content as blocks or inline content.
param: {Array}   [options.tagName]            The tag into which content will be inserted.
param: {boolean} [options.preserveWhiteSpace] Whether or not to preserve consequent white space.

categories_getCategories() X-Ref

Returns all the block categories.

return: {WPBlockCategory[]} Block categories.

categories_setCategories(categories) X-Ref

Sets the block categories.

param: {WPBlockCategory[]} categories Block categories.

categories_updateCategory(slug, category) X-Ref

Updates a category.

param: {string} slug Block category slug.
param: {WPBlockCategory} category Object containing the category properties

doBlocksMatchTemplate() X-Ref

Checks whether a list of blocks matches a template by comparing the block names.

return: {boolean} Whether the list of blocks matches a templates.
param: {Array} blocks Block list.
param: {Array} template Block template.

synchronizeBlocksWithTemplate() X-Ref

Synchronize a block list with a block template.

Synchronizing a block list with a block template means that we loop over the blocks
keep the block as is if it matches the block at the same position in the template
(If it has the same name) and if doesn't match, we create a new block based on the template.
Extra blocks not present in the template are removed.

return: {Array} Updated Block list.
param: {Array} blocks Block list.
param: {Array} template Block template.

_extends() X-Ref

No description

Functions

Functions that are not part of a class:

memize( fn, options ) X-Ref

Accepts a function to be memoized, and returns a new memoized function, with
optional options.

return: {F & MemizeMemoizedFunction} Memoized function.
param: {F} fn Function to memoize.
param: {MemizeOptions} [options] Options object.

memoized( ) X-Ref

No description

getDefaultOpts(simple) X-Ref

Created by Tivie on 13-07-2015.

allOptionsOn() X-Ref

No description

validate(extension, name) X-Ref

Validate extension

param: {array} extension
param: {string} name
returns: {{valid: boolean, error: string}}

escapeCharactersCallback(wholeMatch, m1) X-Ref

No description

_constructor() X-Ref

No description

_parseExtension(ext, name) X-Ref

Parse extension

param: {*} ext
param: {string} [name='']

legacyExtensionLoading(ext, name) X-Ref

LEGACY_SUPPORT

param: {*} ext
param: {string} name

listen(name, callback) X-Ref

Listen to an event

param: {string} name
param: {function} callback

rTrimInputText(text) X-Ref

No description

clean(node) X-Ref

No description

substitutePreCodeTags(doc) X-Ref

No description

hashHTMLSpan(html) X-Ref

No description

headerId(m) X-Ref

No description

writeImageTagBase64(wholeMatch, altText, linkId, url, width, height, m5, title) X-Ref

No description

writeImageTag(wholeMatch, altText, linkId, url, width, height, m5, title) X-Ref

No description

parseInside(txt, left, right) X-Ref

No description

processListItems(listStr, trimTrailing) X-Ref

Process the contents of a single ordered or unordered list, splitting it
into individual list items.

param: {string} listStr
param: {boolean} trimTrailing
returns: {string}

styleStartNumber(list, listType) X-Ref

No description

parseConsecutiveLists(list, listType, trimTrailing) X-Ref

Check and parse consecutive lists (better fix for issue #142)

param: {string} list
param: {string} listType
param: {boolean} trimTrailing
returns: {string}

parseMetadataContents(content) X-Ref

No description

parseInside(txt) X-Ref

No description

parseStyles(sLine) X-Ref

No description

parseHeaders(header, style) X-Ref

No description

parseCells(cell, style) X-Ref

No description

buildTable(headers, cells) X-Ref

No description

parseTable(rawTable) X-Ref

No description

__webpack_require__(moduleId) X-Ref

No description

unprocessedBlockTypes() X-Ref

No description

blockTypes() X-Ref

Reducer managing the processed block types with all filters applied.
The state is derived from the `unprocessedBlockTypes` reducer.

return: {Object} Updated state.
param: {Object} state Current state.
param: {Object} action Dispatched action.

blockStyles() X-Ref

Reducer managing the block style variations.

return: {Object} Updated state.
param: {Object} state Current state.
param: {Object} action Dispatched action.

blockVariations() X-Ref

Reducer managing the block variations.

return: {Object} Updated state.
param: {Object} state Current state.
param: {Object} action Dispatched action.

createBlockNameSetterReducer(setActionType) X-Ref

Higher-order Reducer creating a reducer keeping track of given block name.

return: {Function} Reducer.
param: {string} setActionType Action type.

categories() X-Ref

Reducer managing the categories

return: {WPBlockCategory[]} Updated state.
param: {WPBlockCategory[]} state Current state.
param: {Object} action Dispatched action.

collections() X-Ref

No description

arrayOf( value ) X-Ref

Returns the first argument as the sole entry in an array.

return: {Array} Value returned as entry in array.
param: {*} value Value to return.

isObjectLike( value ) X-Ref

Returns true if the value passed is object-like, or false otherwise. A value
is object-like if it can support property assignment, e.g. object or array.

return: {boolean} Whether value is object-like.
param: {*} value Value to test.

createCache() X-Ref

Creates and returns a new cache object.

return: {Object} Cache object.

isShallowEqual( a, b, fromIndex ) X-Ref

Returns true if entries within the two arrays are strictly equal by
reference from a starting index.

return: {boolean} Whether arrays are shallowly equal.
param: {Array} a First array.
param: {Array} b Second array.
param: {number} fromIndex Index from which to start comparison.

rememo(selector, getDependants ) X-Ref

Returns a memoized selector function. The getDependants function argument is
called before the memoized selector and is expected to return an immutable
reference or array of references on which the selector depends for computing
its own return value. The memoize cache is preserved only as long as those
dependant references remain the same. If getDependants returns a different
reference(s), the cache is cleared and the selector value regenerated.

return: {Function} Memoized selector.
param: {Function} selector Selector function.
param: {Function} getDependants Dependant getter returning an immutable

getRootCache() X-Ref

Returns the root cache. If WeakMap is supported, this is assigned to the
root WeakMap cache set, otherwise it is a shared instance of the default
cache object.

return: {(WeakMap|Object)} Root cache object.

getWeakMapCache( dependants ) X-Ref

Returns the cache for a given dependants array. When possible, a WeakMap
will be used to create a unique cache for each set of dependants. This
is feasible due to the nature of WeakMap in allowing garbage collection
to occur on entries where the key object is no longer referenced. Since
WeakMap requires the key to be an object, this is only possible when the
dependant is object-like. The root cache is created as a hierarchy where
each top-level key is the first entry in a dependants set, the value a
WeakMap where each key is the next dependant, and so on. This continues
so long as the dependants are object-like. If no dependants are object-
like, then the cache is shared across all invocations.

return: {Object} Cache object.
param: {Array} dependants Selector dependants.

clear() X-Ref

Resets root memoization cache.

callSelector( ) X-Ref

The augmented selector call, considering first whether dependants have
changed before passing it to underlying memoize function.

return: {*} Selector result.
param: {Object} source Source object for derivation.
param: {...*} extraArgs Additional arguments to pass to selector.

__experimentalGetUnprocessedBlockTypes(state) X-Ref

Returns all the unprocessed block types as passed during the registration.

return: {Array} Unprocessed block types.
param: {Object} state Data state.

getBlockType(state, name) X-Ref

Returns a block type by name.

return: {Object?} Block Type.
param: {Object} state Data state.
param: {string} name Block type name.

getBlockStyles(state, name) X-Ref

Returns block styles by block name.

return: {Array?} Block Styles.
param: {Object} state Data state.
param: {string} name Block type name.

getActiveBlockVariation(state, blockName, attributes, scope) X-Ref

Returns the active block variation for a given block based on its attributes.
Variations are determined by their `isActive` property.
Which is either an array of block attribute keys or a function.

In case of an array of block attribute keys, the `attributes` are compared
to the variation's attributes using strict equality check.

In case of function type, the function should accept a block's attributes
and the variation's attributes and determines if a variation is active.
A function that accepts a block's attributes and the variation's attributes and determines if a variation is active.

return: {(WPBlockVariation|undefined)} Active block variation.
param: {Object}                state      Data state.
param: {string}                blockName  Name of block (example: “core/columns”).
param: {Object}                attributes Block attributes used to determine active variation.
param: {WPBlockVariationScope} [scope]    Block variation scope name.

getDefaultBlockVariation(state, blockName, scope) X-Ref

Returns the default block variation for the given block type.
When there are multiple variations annotated as the default one,
the last added item is picked. This simplifies registering overrides.
When there is no default variation set, it returns the first item.

return: {?WPBlockVariation} The default block variation.
param: {Object}                state     Data state.
param: {string}                blockName Block type name.
param: {WPBlockVariationScope} [scope]   Block variation scope name.

getCategories(state) X-Ref

Returns all the available categories.

return: {WPBlockCategory[]} Categories list.
param: {Object} state Data state.

getCollections(state) X-Ref

Returns all the available collections.

return: {Object} Collections list.
param: {Object} state Data state.

getDefaultBlockName(state) X-Ref

Returns the name of the default block name.

return: {string?} Default block name.
param: {Object} state Data state.

getFreeformFallbackBlockName(state) X-Ref

Returns the name of the block for handling non-block content.

return: {string?} Name of the block for handling non-block content.
param: {Object} state Data state.

getUnregisteredFallbackBlockName(state) X-Ref

Returns the name of the block for handling unregistered blocks.

return: {string?} Name of the block for handling unregistered blocks.
param: {Object} state Data state.

getGroupingBlockName(state) X-Ref

Returns the name of the block for handling unregistered blocks.

return: {string?} Name of the block for handling unregistered blocks.
param: {Object} state Data state.

hasBlockSupport(state, nameOrType, feature, defaultSupports) X-Ref

Returns true if the block defines support for a feature, or false otherwise.

return: {boolean} Whether block supports feature.
param: {Object}          state           Data state.
param: {(string|Object)} nameOrType      Block name or type object.
param: {string}          feature         Feature to test.
param: {boolean}         defaultSupports Whether feature is supported by

isMatchingSearchTerm(state, nameOrType, searchTerm) X-Ref

Returns true if the block type by the given name or object value matches a
search term, or false otherwise.

return: {Object[]} Whether block type matches search term.
param: {Object} state Blocks state.
param: {(string|Object)} nameOrType Block name or type object.
param: {string} searchTerm Search term by which to filter.

names(e,f) X-Ref

No description

unstable__bootstrapServerSideBlockDefinitions(definitions) X-Ref

Sets the server side block definition of blocks.

param: {Object} definitions Server-side block definitions

getBlockSettingsFromMetadata(_ref) X-Ref

Gets block settings from metadata loaded from `block.json` file.

return: {Object} Block settings.
param: {Object} metadata Block metadata loaded from `block.json`.
param: {string} metadata.textdomain Textdomain to use with translations.

registerBlockType(blockNameOrMetadata, settings) X-Ref

Registers a new block provided a unique name and an object defining its
behavior. Once registered, the block is made available as an option to any
editor interface where blocks are implemented.

return: {?WPBlockType} The block, if it has been successfully registered;
param: {string|Object} blockNameOrMetadata Block type name or its metadata.
param: {Object} settings Block settings.

translateBlockSettingUsingI18nSchema(i18nSchema, settingValue, textdomain) X-Ref

Translates block settings provided with metadata using the i18n schema.

return: {string|string[]|Object[]} Translated setting.
param: {string|string[]|Object[]} i18nSchema I18n schema for the block setting.
param: {string|string[]|Object[]} settingValue Value for the block setting.
param: {string} textdomain Textdomain to use with translations.

registerBlockCollection(namespace, _ref2) X-Ref

Registers a new block collection to group blocks in the same namespace in the inserter.

param: {string} namespace       The namespace to group blocks by in the inserter; corresponds to the block namespace.
param: {Object} settings        The block collection settings.
param: {string} settings.title  The title to display in the block inserter.
param: {Object} [settings.icon] The icon to display in the block inserter.

unregisterBlockCollection(namespace) X-Ref

Unregisters a block collection

param: {string} namespace The namespace to group blocks by in the inserter; corresponds to the block namespace

unregisterBlockType(name) X-Ref

Unregisters a block.

return: {?WPBlockType} The previous block value, if it has been successfully
param: {string} name Block name.

setFreeformContentHandlerName(blockName) X-Ref

Assigns name of block for handling non-block content.

param: {string} blockName Block name.

getFreeformContentHandlerName() X-Ref

Retrieves name of block handling non-block content, or undefined if no
handler has been defined.

return: {?string} Block name.

registration_getGroupingBlockName() X-Ref

Retrieves name of block used for handling grouping interactions.

return: {?string} Block name.

setUnregisteredTypeHandlerName(blockName) X-Ref

Assigns name of block handling unregistered block types.

param: {string} blockName Block name.

getUnregisteredTypeHandlerName() X-Ref

Retrieves name of block handling unregistered block types, or undefined if no
handler has been defined.

return: {?string} Block name.

setDefaultBlockName(name) X-Ref

Assigns the default block name.

param: {string} name Block name.

setGroupingBlockName(name) X-Ref

Assigns name of block for handling block grouping interactions.

param: {string} name Block name.

registration_getDefaultBlockName() X-Ref

Retrieves the default block name.

return: {?string} Block name.

registration_getBlockType(name) X-Ref

Returns a registered block type.

return: {?Object} Block type.
param: {string} name Block name.

registration_getBlockTypes() X-Ref

Returns all registered blocks.

return: {Array} Block settings.

registration_getBlockSupport(nameOrType, feature, defaultSupports) X-Ref

Returns the block support value for a feature, if defined.

return: {?*} Block support value
param: {(string|Object)} nameOrType      Block name or type object
param: {string}          feature         Feature to retrieve
param: {*}               defaultSupports Default value to return if not

registration_hasBlockSupport(nameOrType, feature, defaultSupports) X-Ref

Returns true if the block defines support for a feature, or false otherwise.

return: {boolean} Whether block supports feature.
param: {(string|Object)} nameOrType      Block name or type object.
param: {string}          feature         Feature to test.
param: {boolean}         defaultSupports Whether feature is supported by

isReusableBlock(blockOrType) X-Ref

Determines whether or not the given block is a reusable block. This is a
special block type that is used to point to a global block stored via the
API.

return: {boolean} Whether the given block is a reusable block.
param: {Object} blockOrType Block or Block Type to test.

isTemplatePart(blockOrType) X-Ref

Determines whether or not the given block is a template part. This is a
special block type that allows composing a page template out of reusable
design elements.

return: {boolean} Whether the given block is a template part.
param: {Object} blockOrType Block or Block Type to test.

rng() X-Ref

No description

validate(uuid) X-Ref

No description

stringify(arr) X-Ref

No description

v4(options, buf, offset) X-Ref

No description

createBlock(name) X-Ref

Returns a block object given its type and attributes.

return: {Object} Block object.
param: {string} name Block name.
param: {Object} attributes Block attributes.
param: {?Array} innerBlocks Nested blocks.

createBlocksFromInnerBlocksTemplate() X-Ref

Given an array of InnerBlocks templates or Block Objects,
returns an array of created Blocks from them.
It handles the case of having InnerBlocks as Blocks by
converting them to the proper format to continue recursively.

return: {Object[]} Array of Block objects.
param: {Array} innerBlocksOrTemplate Nested blocks or InnerBlocks templates.

__experimentalCloneSanitizedBlock(block) X-Ref

Given a block object, returns a copy of the block object while sanitizing its attributes,
optionally merging new attributes and/or replacing its inner blocks.

return: {Object} A cloned block.
param: {Object} block Block instance.
param: {Object} mergeAttributes Block attributes.
param: {?Array} newInnerBlocks Nested blocks.

cloneBlock(block) X-Ref

Given a block object, returns a copy of the block object,
optionally merging new attributes and/or replacing its inner blocks.

return: {Object} A cloned block.
param: {Object} block Block instance.
param: {Object} mergeAttributes Block attributes.
param: {?Array} newInnerBlocks Nested blocks.

getPossibleBlockTransformations(blocks) X-Ref

Returns an array of block types that the set of blocks received as argument
can be transformed into.

return: {Array} Block types that the blocks argument can be transformed to.
param: {Array} blocks Blocks array.

findTransform(transforms, predicate) X-Ref

Given an array of transforms, returns the highest-priority transform where
the predicate function returns a truthy value. A higher-priority transform
is one with a lower priority value (i.e. first in priority order). Returns
null if the transforms set is empty or the predicate function returns a
falsey value for all entries.

return: {?Object} Highest-priority transform candidate.
param: {Object[]} transforms Transforms to search.
param: {Function} predicate Function returning true on matching transform.

getBlockTransforms(direction, blockTypeOrName) X-Ref

Returns normal block transforms for a given transform direction, optionally
for a specific block by name, or an empty array if there are no transforms.
If no block name is provided, returns transforms for all blocks. A normal
transform object includes `blockName` as a property.

return: {Array} Block transforms for direction.
param: {string} direction Transform direction ("to", "from").
param: {string|Object} blockTypeOrName Block type or name.

switchToBlockType(blocks, name) X-Ref

Switch one or more blocks into one or more blocks of the new block type.

return: {?Array} Array of blocks or null.
param: {Array|Object} blocks Blocks array or block object.
param: {string} name Block name.

isUnmodifiedDefaultBlock(block) X-Ref

Determines whether the block is a default block
and its attributes are equal to the default attributes
which means the block is unmodified.

return: {boolean} Whether the block is an unmodified default block
param: {WPBlock} block Block Object

isValidIcon(icon) X-Ref

Function that checks if the parameter is a valid icon.

return: {boolean} True if the parameter is a valid icon and false otherwise.
param: {*} icon Parameter to be checked.

normalizeIconObject(icon) X-Ref

Function that receives an icon as set by the blocks during the registration
and returns a new icon object that is normalized so we can rely on just on possible icon structure
in the codebase.

return: {WPBlockTypeIconDescriptor} Object describing the icon.
param: {WPBlockTypeIconRender} icon Render behavior of a block type icon;

normalizeBlockType(blockTypeOrName) X-Ref

Normalizes block type passed as param. When string is passed then
it converts it to the matching block type object.
It passes the original object otherwise.

return: {?Object} Block type.
param: {string|Object} blockTypeOrName Block type or name.

getBlockLabel(blockType, attributes) X-Ref

Get the label for the block, usually this is either the block title,
or the value of the block's `label` function when that's specified.

return: {string} The block label.
param: {Object} blockType The block type.
param: {Object} attributes The values of the block's attributes.
param: {Object} context The intended use for the label.

getAccessibleBlockLabel(blockType, attributes, position) X-Ref

Get a label for the block for use by screenreaders, this is more descriptive
than the visual label and includes the block title and the value of the
`getLabel` function if it's specified.

return: {string} The block label.
param: {Object}  blockType              The block type.
param: {Object}  attributes             The values of the block's attributes.
param: {?number} position               The position of the block in the block list.
param: {string}  [direction='vertical'] The direction of the block layout.

__experimentalSanitizeBlockAttributes(name, attributes) X-Ref

Ensure attributes contains only values defined by block type, and merge
default values for missing attributes.

return: {Object} The sanitized attributes.
param: {string} name The block's name.
param: {Object} attributes The block's attributes.

__experimentalGetBlockAttributesNamesByRole(name, role) X-Ref

Filter block attributes by `role` and return their names.

return: {string[]} The attribute names that have the provided role.
param: {string} name Block attribute's name.
param: {string} role The role of a block attribute.

addBlockTypes(blockTypes) X-Ref

Returns an action object used in signalling that block types have been added.

return: {Object} Action object.
param: {Array|Object} blockTypes Block types received.

removeBlockTypes(names) X-Ref

Returns an action object used to remove a registered block type.

return: {Object} Action object.
param: {string|Array} names Block name.

addBlockStyles(blockName, styles) X-Ref

Returns an action object used in signalling that new block styles have been added.

return: {Object} Action object.
param: {string} blockName Block name.
param: {Array|Object} styles Block styles.

removeBlockStyles(blockName, styleNames) X-Ref

Returns an action object used in signalling that block styles have been removed.

return: {Object} Action object.
param: {string} blockName Block name.
param: {Array|string} styleNames Block style names.

addBlockVariations(blockName, variations) X-Ref

Returns an action object used in signalling that new block variations have been added.

return: {Object} Action object.
param: {string} blockName Block name.
param: {WPBlockVariation|WPBlockVariation[]} variations Block variations.

removeBlockVariations(blockName, variationNames) X-Ref

Returns an action object used in signalling that block variations have been removed.

return: {Object} Action object.
param: {string} blockName Block name.
param: {string|string[]} variationNames Block variation names.

actions_setDefaultBlockName(name) X-Ref

Returns an action object used to set the default block name.

return: {Object} Action object.
param: {string} name Block name.

setFreeformFallbackBlockName(name) X-Ref

Returns an action object used to set the name of the block used as a fallback
for non-block content.

return: {Object} Action object.
param: {string} name Block name.

setUnregisteredFallbackBlockName(name) X-Ref

Returns an action object used to set the name of the block used as a fallback
for unregistered blocks.

return: {Object} Action object.
param: {string} name Block name.

actions_setGroupingBlockName(name) X-Ref

Returns an action object used to set the name of the block used
when grouping other blocks
eg: in "Group/Ungroup" interactions

return: {Object} Action object.
param: {string} name Block name.

setCategories(categories) X-Ref

Returns an action object used to set block categories.

return: {Object} Action object.
param: {Object[]} categories Block categories.

updateCategory(slug, category) X-Ref

Returns an action object used to update a category.

return: {Object} Action object.
param: {string} slug Block category slug.
param: {Object} category Object containing the category properties that should be updated.

addBlockCollection(namespace, title, icon) X-Ref

Returns an action object used to add block collections

return: {Object} Action object.
param: {string} namespace The namespace of the blocks to put in the collection
param: {string} title The title to display in the block inserter
param: {Object} icon (optional) The icon to display in the block inserter

removeBlockCollection(namespace) X-Ref

Returns an action object used to remove block collections

return: {Object} Action object.
param: {string} namespace The namespace of the blocks to put in the collection

serializeRawBlock(rawBlock) X-Ref

Serializes a block node into the native HTML-comment-powered block format.
CAVEAT: This function is intended for re-serializing blocks as parsed by
valid parsers and skips any validation steps. This is NOT a generic
serialization function for in-memory blocks. For most purposes, see the
following functions available in the `@wordpress/blocks` package:

return: {string} An HTML string representing a block.
param: {WPRawBlock} rawBlock A block node as returned by a valid parser.
param: {Options} [options={}] Serialization options.

getBlockDefaultClassName(blockName) X-Ref

Returns the block's default classname from its name.

return: {string} The block's default class.
param: {string} blockName The block name.

getBlockMenuDefaultClassName(blockName) X-Ref

Returns the block's default menu item classname from its name.

return: {string} The block's default menu item class.
param: {string} blockName The block name.

getBlockProps() X-Ref

Call within a save function to get the props for the block wrapper.

param: {Object} props Optional. Props to pass to the element.

getInnerBlocksProps() X-Ref

Call within a save function to get the props for the inner blocks wrapper.

param: {Object} props Optional. Props to pass to the element.

getSaveElement(blockTypeOrName, attributes) X-Ref

Given a block type containing a save render implementation and attributes, returns the
enhanced element to be saved or string when raw HTML expected.

return: {Object|string} Save element or raw HTML string.
param: {string|Object} blockTypeOrName Block type or name.
param: {Object} attributes Block attributes.
param: {?Array} innerBlocks Nested blocks.

getSaveContent(blockTypeOrName, attributes, innerBlocks) X-Ref

Given a block type containing a save render implementation and attributes, returns the
static markup to be saved.

return: {string} Save content.
param: {string|Object} blockTypeOrName Block type or name.
param: {Object} attributes Block attributes.
param: {?Array} innerBlocks Nested blocks.

getCommentAttributes(blockType, attributes) X-Ref

Returns attributes which are to be saved and serialized into the block
comment delimiter.

When a block exists in memory it contains as its attributes both those
parsed the block comment delimiter _and_ those which matched from the
contents of the block.

This function returns only those attributes which are needed to persist and
which cannot be matched from the block content.

return: {Object<string,*>} Subset of attributes for comment serialization.
param: {Object<string,*>} blockType Block type.
param: {Object<string,*>} attributes Attributes from in-memory block data.

serializeAttributes(attributes) X-Ref

Given an attributes object, returns a string in the serialized attributes
format prepared for post content.

return: {string} Serialized attributes.
param: {Object} attributes Attributes object.

getBlockInnerHTML(block) X-Ref

Given a block object, returns the Block's Inner HTML markup.

return: {string} HTML.
param: {Object} block Block instance.

getCommentDelimitedContent(rawBlockName, attributes, content) X-Ref

Returns the content of a block, including comment delimiters.

return: {string} Comment-delimited block content.
param: {string} rawBlockName Block name.
param: {Object} attributes Block attributes.
param: {string} content Block save content.

serializeBlock(block) X-Ref

Returns the content of a block, including comment delimiters, determining
serialized attributes and content form from the current state of the block.

return: {string} Serialized block.
param: {WPBlock} block Block instance.
param: {WPBlockSerializationOptions} options Serialization options.

__unstableSerializeAndClean(blocks) X-Ref

No description

serializer_serialize(blocks, options) X-Ref

Takes a block or set of blocks and returns the serialized post content.

return: {string} The post content.
param: {Array} blocks Block(s) to serialize.
param: {WPBlockSerializationOptions} options Serialization options.

EntityParser(named) X-Ref

No description

isSpace(char) X-Ref

No description

isAlpha(char) X-Ref

No description

preprocessInput(input) X-Ref

No description

EventedTokenizer(delegate, entityParser, mode) X-Ref

No description

Tokenizer(entityParser, options) X-Ref

No description

tokenize(input, options) X-Ref

No description

createLogger() X-Ref

createLogHandler(logger) X-Ref

Creates a log handler with block validation prefix.

return: {Function} Augmented logger function.
param: {Function} logger Original logger function.

createQueuedLogger() X-Ref

No description

isValidCharacterReference(text) X-Ref

Returns true if the given string is a valid character reference segment, or
false otherwise. The text should be stripped of `&` and `;` demarcations.

return: {boolean} Whether text is valid character reference.
param: {string} text Text to test.

File Size:	13467 lines (486 kb)
Included or required:	0 times
Referenced:	0 times
Includes or requires:	0 files

PHP Cross Reference of WordPress

/wp-includes/js/dist/ -> blocks.js (summary)

Defines 1 class

Defines 102 functions