[ Index ]

PHP Cross Reference of WordPress Trunk (Updated Daily)

Search

title

Body

[close]

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

References: Focusable: - https://www.w3.org/TR/html5/editing.html#focus-management

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

Defines 60 functions

  buildSelector()
  isVisible()
  isValidFocusableArea()
  find()
  getTabIndex()
  isTabbableIndex()
  createStatefulCollapseRadioGroup()
  mapElementToObjectTabbable()
  mapObjectTabbableToElement()
  compareObjectTabbables()
  filterTabbable()
  tabbable_find()
  findPrevious()
  findNext()
  assertIsDefined()
  getRectangleFromRange()
  computeCaretRect()
  documentHasTextSelection()
  isHTMLInputElement()
  isTextField()
  inputFieldHasUncollapsedSelection()
  documentHasUncollapsedSelection()
  documentHasSelection()
  getComputedStyle()
  getScrollContainer()
  getOffsetParent()
  isInputOrTextArea()
  isEntirelySelected()
  isDeepChild()
  isFormElement()
  isRTL()
  getRangeHeight()
  isSelectionForward()
  caretRangeFromPoint()
  hiddenCaretRangeFromPoint()
  scrollIfNoRange()
  isEdge()
  isHorizontalEdge()
  isNumberInput()
  isVerticalEdge()
  getRange()
  placeCaretAtEdge()
  placeCaretAtHorizontalEdge()
  placeCaretAtVerticalEdge()
  insertAfter()
  remove()
  replace()
  unwrap()
  replaceTag()
  wrap()
  safeHTML()
  stripHTML()
  isEmpty()
  getPhrasingContentSchema()
  isPhrasingContent()
  isTextContent()
  isElement()
  cleanNodeList()
  removeInvalidHTML()
  getFilesFromDataTransfer()

Functions
Functions that are not part of a class:

buildSelector(sequential)   X-Ref
Returns a CSS selector used to query for focusable elements.

param: {boolean} sequential If set, only query elements that are sequentially
return: {string} CSS selector.

isVisible(element)   X-Ref
Returns true if the specified element is visible (i.e. neither display: none
nor visibility: hidden).

param: {HTMLElement} element DOM element to test.
return: {boolean} Whether element is visible.

isValidFocusableArea(element)   X-Ref
Returns true if the specified area element is a valid focusable element, or
false otherwise. Area is only focusable if within a map where a named map
referenced by an image somewhere in the document.

param: {HTMLAreaElement} element DOM area element to test.
return: {boolean} Whether area element is valid for focus.

find(context, {sequential = false} = {})   X-Ref
Returns all focusable elements within a given context.

param: {Element} context              Element in which to search.
param: {Object}  options
param: {boolean} [options.sequential] If set, only return elements that are
return: {HTMLElement[]} Focusable elements.

getTabIndex(element)   X-Ref
Returns the tab index of the given element. In contrast with the tabIndex
property, this normalizes the default (0) to avoid browser inconsistencies,
operating under the assumption that this function is only ever called with a
focusable node.

param: {Element} element Element from which to retrieve.
return: {number} Tab index of element (default 0).

isTabbableIndex(element)   X-Ref
Returns true if the specified element is tabbable, or false otherwise.

param: {Element} element Element to test.
return: {boolean} Whether element is tabbable.

createStatefulCollapseRadioGroup()   X-Ref
Returns a stateful reducer function which constructs a filtered array of
tabbable elements, where at most one radio input is selected for a given
name, giving priority to checked input, falling back to the first
encountered.

return: {(acc: MaybeHTMLInputElement[], el: MaybeHTMLInputElement) => MaybeHTMLInputElement[]} Radio group collapse reducer.

mapElementToObjectTabbable(element, index)   X-Ref
An array map callback, returning an object with the element value and its
array index location as properties. This is used to emulate a proper stable
sort where equal tabIndex should be left in order of their occurrence in the
document.

param: {Element} element Element.
param: {number}  index   Array index of element.
return: {{ element: Element, index: number }} Mapped object with element, index.

mapObjectTabbableToElement(object)   X-Ref
An array map callback, returning an element of the given mapped object's
element value.

param: {{ element: Element }} object Mapped object with element.
return: {Element} Mapped object element.

compareObjectTabbables(a, b)   X-Ref
A sort comparator function used in comparing two objects of mapped elements.

param: {{ element: Element, index: number }} a First object to compare.
param: {{ element: Element, index: number }} b Second object to compare.
return: {number} Comparator result.

filterTabbable(focusables)   X-Ref
Givin focusable elements, filters out tabbable element.

param: {Element[]} focusables Focusable elements to filter.
return: {Element[]} Tabbable elements.

tabbable_find(context)   X-Ref

param: {Element} context
return: {Element[]} Tabbable elements within the context.

findPrevious(element)   X-Ref
Given a focusable element, find the preceding tabbable element.

param: {Element} element The focusable element before which to look. Defaults
return: {Element|undefined} Preceding tabbable element.

findNext(element)   X-Ref
Given a focusable element, find the next tabbable element.

param: {Element} element The focusable element after which to look. Defaults
return: {Element|undefined} Next tabbable element.

assertIsDefined(val, name)   X-Ref
No description

getRectangleFromRange(range)   X-Ref
Get the rectangle of a given Range. Returns `null` if no suitable rectangle
can be found.

param: {Range} range The range.
return: {DOMRect?} The rectangle.

computeCaretRect(win)   X-Ref
Get the rectangle for the selection in a container.

param: {Window} win The window of the selection.
return: {DOMRect | null} The rectangle.

documentHasTextSelection(doc)   X-Ref
Check whether the current document has selected text. This applies to ranges
of text in the document, and not selection inside `<input>` and `<textarea>`
elements.

See: https://developer.mozilla.org/en-US/docs/Web/API/Window/getSelection#Related_objects.

param: {Document} doc The document to check.
return: {boolean} True if there is selection, false if not.

isHTMLInputElement(node)   X-Ref

param: {Node} node
return: {node is HTMLInputElement} Whether the node is an HTMLInputElement.

isTextField(node)   X-Ref
Check whether the given element is a text field, where text field is defined
by the ability to select within the input, or that it is contenteditable.

See: https://html.spec.whatwg.org/#textFieldSelection

param: {Node} node The HTML element.
return: {node is HTMLElement} True if the element is an text field, false if not.

inputFieldHasUncollapsedSelection(element)   X-Ref
Check whether the given input field or textarea contains a (uncollapsed)
selection of text.

CAVEAT: Only specific text-based HTML inputs support the selection APIs
needed to determine whether they have a collapsed or uncollapsed selection.
This function defaults to returning `true` when the selection cannot be
inspected, such as with `<input type="time">`. The rationale is that this
should cause the block editor to defer to the browser's native selection
handling (e.g. copying and pasting), thereby reducing friction for the user.

See: https://html.spec.whatwg.org/multipage/input.html#do-not-apply

param: {Element} element The HTML element.
return: {boolean} Whether the input/textareaa element has some "selection".

documentHasUncollapsedSelection(doc)   X-Ref
Check whether the current document has any sort of (uncollapsed) selection.
This includes ranges of text across elements and any selection inside
textual `<input>` and `<textarea>` elements.

param: {Document} doc The document to check.
return: {boolean} Whether there is any recognizable text selection in the document.

documentHasSelection(doc)   X-Ref
Check whether the current document has a selection. This includes focus in
input fields, textareas, and general rich-text selection.

param: {Document} doc The document to check.
return: {boolean} True if there is selection, false if not.

getComputedStyle(element)   X-Ref

param: {Element} element
return: {ReturnType<Window['getComputedStyle']>} The computed style for the element.

getScrollContainer(node, direction = 'vertical')   X-Ref
Given a DOM node, finds the closest scrollable container node or the node
itself, if scrollable.

param: {Element | null} node      Node from which to start.
param: {?string}        direction Direction of scrollable container to search for ('vertical', 'horizontal', 'all').
return: {Element | undefined} Scrollable container node, if found.

getOffsetParent(node)   X-Ref
Returns the closest positioned element, or null under any of the conditions
of the offsetParent specification. Unlike offsetParent, this function is not
limited to HTMLElement and accepts any Node (e.g. Node.TEXT_NODE).

param: {Node} node Node from which to find offset parent.
return: {Node | null} Offset parent.

isInputOrTextArea(element)   X-Ref

param: {Element} element
return: {element is HTMLInputElement | HTMLTextAreaElement} Whether the element is an input or textarea

isEntirelySelected(element)   X-Ref
Check whether the contents of the element have been entirely selected.
Returns true if there is no possibility of selection.

param: {HTMLElement} element The element to check.
return: {boolean} True if entirely selected, false if not.

isDeepChild(query, container, propName)   X-Ref
Check whether the contents of the element have been entirely selected.
Returns true if there is no possibility of selection.

param: {HTMLElement|Node}         query     The element to check.
param: {HTMLElement}              container The container that we suspect "query" may be a first or last child of.
param: {"firstChild"|"lastChild"} propName  "firstChild" or "lastChild"
return: {boolean} True if query is a deep first/last child of container, false otherwise.

isFormElement(element)   X-Ref
Detects if element is a form element.

param: {Element} element The element to check.
return: {boolean} True if form element and false otherwise.

isRTL(element)   X-Ref
Whether the element's text direction is right-to-left.

param: {Element} element The element to check.
return: {boolean} True if rtl, false if ltr.

getRangeHeight(range)   X-Ref
Gets the height of the range without ignoring zero width rectangles, which
some browsers ignore when creating a union.

param: {Range} range The range to check.
return: {number | undefined} Height of the range or undefined if the range has no client rectangles.

isSelectionForward(selection)   X-Ref
Returns true if the given selection object is in the forward direction, or
false otherwise.

param: {Selection} selection Selection object to check.
return: {boolean} Whether the selection is forward.

caretRangeFromPoint(doc, x, y)   X-Ref
Polyfill.
Get a collapsed range for a given point.

param: {DocumentMaybeWithCaretPositionFromPoint} doc The document of the range.
param: {number}                                  x   Horizontal position within the current viewport.
param: {number}                                  y   Vertical position within the current viewport.
return: {Range | null} The best range for the given point.

hiddenCaretRangeFromPoint(doc, x, y, container)   X-Ref
Get a collapsed range for a given point.
Gives the container a temporary high z-index (above any UI).
This is preferred over getting the UI nodes and set styles there.

param: {Document}    doc       The document of the range.
param: {number}      x         Horizontal position within the current viewport.
param: {number}      y         Vertical position within the current viewport.
param: {HTMLElement} container Container in which the range is expected to be found.
return: {?Range} The best range for the given point.

scrollIfNoRange(container, alignToTop, callback)   X-Ref
If no range range can be created or it is outside the container, the element
may be out of view, so scroll it into view and try again.

param: {HTMLElement} container  The container to scroll.
param: {boolean}     alignToTop True to align to top, false to bottom.
param: {Function}    callback   The callback to create the range.
return: {?Range} The range returned by the callback.

isEdge(container, isReverse, onlyVertical = false)   X-Ref
Check whether the selection is at the edge of the container. Checks for
horizontal position by default. Set `onlyVertical` to true to check only
vertically.

param: {HTMLElement} container            Focusable element.
param: {boolean}     isReverse            Set to true to check left, false to check right.
param: {boolean}     [onlyVertical=false] Set to true to check only vertical position.
return: {boolean} True if at the edge, false if not.

isHorizontalEdge(container, isReverse)   X-Ref
Check whether the selection is horizontally at the edge of the container.

param: {HTMLElement} container Focusable element.
param: {boolean}     isReverse Set to true to check left, false for right.
return: {boolean} True if at the horizontal edge, false if not.

isNumberInput(node)   X-Ref
Check whether the given element is an input field of type number.

param: {Node} node The HTML node.
return: {node is HTMLInputElement} True if the node is number input.

isVerticalEdge(container, isReverse)   X-Ref
Check whether the selection is vertically at the edge of the container.

param: {HTMLElement} container Focusable element.
param: {boolean}     isReverse Set to true to check top, false for bottom.
return: {boolean} True if at the vertical edge, false if not.

getRange(container, isReverse, x)   X-Ref
Gets the range to place.

param: {HTMLElement}      container Focusable element.
param: {boolean}          isReverse True for end, false for start.
param: {number|undefined} x         X coordinate to vertically position.
return: {Range|null} The range to place.

placeCaretAtEdge(container, isReverse, x)   X-Ref
Places the caret at start or end of a given element.

param: {HTMLElement}      container Focusable element.
param: {boolean}          isReverse True for end, false for start.
param: {number|undefined} x         X coordinate to vertically position.

placeCaretAtHorizontalEdge(container, isReverse)   X-Ref
Places the caret at start or end of a given element.

param: {HTMLElement} container Focusable element.
param: {boolean}     isReverse True for end, false for start.

placeCaretAtVerticalEdge(container, isReverse, rect)   X-Ref
Places the caret at the top or bottom of a given element.

param: {HTMLElement} container Focusable element.
param: {boolean}     isReverse True for bottom, false for top.
param: {DOMRect}     [rect]    The rectangle to position the caret with.

insertAfter(newNode, referenceNode)   X-Ref
Given two DOM nodes, inserts the former in the DOM as the next sibling of
the latter.

param: {Node} newNode       Node to be inserted.
param: {Node} referenceNode Node after which to perform the insertion.
return: {void}

remove(node)   X-Ref
Given a DOM node, removes it from the DOM.

param: {Node} node Node to be removed.
return: {void}

replace(processedNode, newNode)   X-Ref
Given two DOM nodes, replaces the former with the latter in the DOM.

param: {Element} processedNode Node to be removed.
param: {Element} newNode       Node to be inserted in its place.
return: {void}

unwrap(node)   X-Ref
Unwrap the given node. This means any child nodes are moved to the parent.

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

replaceTag(node, tagName)   X-Ref
Replaces the given node with a new node with the given tag name.

param: {Element} node    The node to replace
param: {string}  tagName The new tag name.
return: {Element} The new node.

wrap(newNode, referenceNode)   X-Ref
Wraps the given node with a new node with the given tag name.

param: {Element} newNode       The node to insert.
param: {Element} referenceNode The node to wrap.

safeHTML(html)   X-Ref
Strips scripts and on* attributes from HTML.

param: {string} html HTML to sanitize.
return: {string} The sanitized HTML.

stripHTML(html)   X-Ref
Removes any HTML tags from the provided string.

param: {string} html The string containing html.
return: {string} The text content with any html removed.

isEmpty(element)   X-Ref
Recursively checks if an element is empty. An element is not empty if it
contains text or contains elements with attributes such as images.

param: {Element} element The element to check.
return: {boolean} Whether or not the element is empty.

getPhrasingContentSchema(context)   X-Ref
Get schema of possible paths for phrasing content.

param: {string} [context] Set to "paste" to exclude invisible elements and
return: {Partial<ContentSchema>} Schema.

isPhrasingContent(node)   X-Ref
Find out whether or not the given node is phrasing content.

param: {Node} node The node to test.
return: {boolean} True if phrasing content, false if not.

isTextContent(node)   X-Ref

param: {Node} node
return: {boolean} Node is text content

isElement(node)   X-Ref

param: {Node | null | undefined} node
return: {node is Element} True if node is an Element node

cleanNodeList(nodeList, doc, schema, inline)   X-Ref
Given a schema, unwraps or removes nodes, attributes and classes on a node
list.

param: {NodeList} nodeList The nodeList to filter.
param: {Document} doc      The document of the nodeList.
param: {Schema}   schema   An array of functions that can mutate with the provided node.
param: {boolean}  inline   Whether to clean for inline mode.

removeInvalidHTML(HTML, schema, inline)   X-Ref
Given a schema, unwraps or removes nodes, attributes and classes on HTML.

param: {string}                             HTML   The HTML to clean up.
param: {import('./clean-node-list').Schema} schema Schema for the HTML.
param: {boolean}                            inline Whether to clean for inline mode.
return: {string} The cleaned up HTML.

getFilesFromDataTransfer(dataTransfer)   X-Ref
Gets all files from a DataTransfer object.

param: {DataTransfer} dataTransfer DataTransfer object to inspect.
return: {File[]} An array containing all files.



Generated : Mon Mar 18 08:20:01 2024 Cross-referenced by PHPXref