beansflight-json-form/packages/components/tinyEditor/tinymce/plugins/directionality/plugin.js

> **版本号:verison 0.23.17**

/**
 * TinyMCE version 6.1.0 (2022-06-29)
 */

;(function () {
  'use strict'

  var global = tinymce.util.Tools.resolve('tinymce.PluginManager')

  const hasProto = (v, constructor, predicate) => {
    var _a
    if (predicate(v, constructor.prototype)) {
      return true
    } else {
      return (
        ((_a = v.constructor) === null || _a === void 0 ? void 0 : _a.name) ===
        constructor.name
      )
    }
  }
  const typeOf = x => {
    const t = typeof x
    if (x === null) {
      return 'null'
    } else if (t === 'object' && Array.isArray(x)) {
      return 'array'
    } else if (
      t === 'object' &&
      hasProto(x, String, (o, proto) => proto.isPrototypeOf(o))
    ) {
      return 'string'
    } else {
      return t
    }
  }
  const isType$1 = type => value => typeOf(value) === type
  const isSimpleType = type => value => typeof value === type
  const isString = isType$1('string')
  const isBoolean = isSimpleType('boolean')
  const isNullable = a => a === null || a === undefined
  const isNonNullable = a => !isNullable(a)
  const isFunction = isSimpleType('function')
  const isNumber = isSimpleType('number')

  const compose1 = (fbc, fab) => a => fbc(fab(a))
  const constant = value => {
    return () => {
      return value
    }
  }
  const never = constant(false)

  class Optional {
    constructor(tag, value) {
      this.tag = tag
      this.value = value
    }
    static some(value) {
      return new Optional(true, value)
    }
    static none() {
      return Optional.singletonNone
    }
    fold(onNone, onSome) {
      if (this.tag) {
        return onSome(this.value)
      } else {
        return onNone()
      }
    }
    isSome() {
      return this.tag
    }
    isNone() {
      return !this.tag
    }
    map(mapper) {
      if (this.tag) {
        return Optional.some(mapper(this.value))
      } else {
        return Optional.none()
      }
    }
    bind(binder) {
      if (this.tag) {
        return binder(this.value)
      } else {
        return Optional.none()
      }
    }
    exists(predicate) {
      return this.tag && predicate(this.value)
    }
    forall(predicate) {
      return !this.tag || predicate(this.value)
    }
    filter(predicate) {
      if (!this.tag || predicate(this.value)) {
        return this
      } else {
        return Optional.none()
      }
    }
    getOr(replacement) {
      return this.tag ? this.value : replacement
    }
    or(replacement) {
      return this.tag ? this : replacement
    }
    getOrThunk(thunk) {
      return this.tag ? this.value : thunk()
    }
    orThunk(thunk) {
      return this.tag ? this : thunk()
    }
    getOrDie(message) {
      if (!this.tag) {
        throw new Error(
          message !== null && message !== void 0
            ? message
            : 'Called getOrDie on None'
        )
      } else {
        return this.value
      }
    }
    static from(value) {
      return isNonNullable(value) ? Optional.some(value) : Optional.none()
    }
    getOrNull() {
      return this.tag ? this.value : null
    }
    getOrUndefined() {
      return this.value
    }
    each(worker) {
      if (this.tag) {
        worker(this.value)
      }
    }
    toArray() {
      return this.tag ? [this.value] : []
    }
    toString() {
      return this.tag ? `some(${this.value})` : 'none()'
    }
  }
  Optional.singletonNone = new Optional(false)

  const map = (xs, f) => {
    const len = xs.length
    const r = new Array(len)
    for (let i = 0; i < len; i++) {
      const x = xs[i]
      r[i] = f(x, i)
    }
    return r
  }
  const each = (xs, f) => {
    for (let i = 0, len = xs.length; i < len; i++) {
      const x = xs[i]
      f(x, i)
    }
  }
  const filter = (xs, pred) => {
    const r = []
    for (let i = 0, len = xs.length; i < len; i++) {
      const x = xs[i]
      if (pred(x, i)) {
        r.push(x)
      }
    }
    return r
  }

  const DOCUMENT = 9
  const DOCUMENT_FRAGMENT = 11
  const ELEMENT = 1
  const TEXT = 3

  const fromHtml = (html, scope) => {
    const doc = scope || document
    const div = doc.createElement('div')
    div.innerHTML = html
    if (!div.hasChildNodes() || div.childNodes.length > 1) {
      const message = 'HTML does not have a single root node'
      console.error(message, html)
      throw new Error(message)
    }
    return fromDom(div.childNodes[0])
  }
  const fromTag = (tag, scope) => {
    const doc = scope || document
    const node = doc.createElement(tag)
    return fromDom(node)
  }
  const fromText = (text, scope) => {
    const doc = scope || document
    const node = doc.createTextNode(text)
    return fromDom(node)
  }
  const fromDom = node => {
    if (node === null || node === undefined) {
      throw new Error('Node cannot be null or undefined')
    }
    return { dom: node }
  }
  const fromPoint = (docElm, x, y) =>
    Optional.from(docElm.dom.elementFromPoint(x, y)).map(fromDom)
  const SugarElement = {
    fromHtml,
    fromTag,
    fromText,
    fromDom,
    fromPoint
  }

  const is = (element, selector) => {
    const dom = element.dom
    if (dom.nodeType !== ELEMENT) {
      return false
    } else {
      const elem = dom
      if (elem.matches !== undefined) {
        return elem.matches(selector)
      } else if (elem.msMatchesSelector !== undefined) {
        return elem.msMatchesSelector(selector)
      } else if (elem.webkitMatchesSelector !== undefined) {
        return elem.webkitMatchesSelector(selector)
      } else if (elem.mozMatchesSelector !== undefined) {
        return elem.mozMatchesSelector(selector)
      } else {
        throw new Error('Browser lacks native selectors')
      }
    }
  }

  typeof window !== 'undefined' ? window : Function('return this;')()

  const name = element => {
    const r = element.dom.nodeName
    return r.toLowerCase()
  }
  const type = element => element.dom.nodeType
  const isType = t => element => type(element) === t
  const isElement = isType(ELEMENT)
  const isText = isType(TEXT)
  const isDocument = isType(DOCUMENT)
  const isDocumentFragment = isType(DOCUMENT_FRAGMENT)
  const isTag = tag => e => isElement(e) && name(e) === tag

  const owner = element => SugarElement.fromDom(element.dom.ownerDocument)
  const documentOrOwner = dos => (isDocument(dos) ? dos : owner(dos))
  const parent = element =>
    Optional.from(element.dom.parentNode).map(SugarElement.fromDom)
  const children$2 = element =>
    map(element.dom.childNodes, SugarElement.fromDom)

  const rawSet = (dom, key, value) => {
    if (isString(value) || isBoolean(value) || isNumber(value)) {
      dom.setAttribute(key, value + '')
    } else {
      console.error(
        'Invalid call to Attribute.set. Key ',
        key,
        ':: Value ',
        value,
        ':: Element ',
        dom
      )
      throw new Error('Attribute value was not simple')
    }
  }
  const set = (element, key, value) => {
    rawSet(element.dom, key, value)
  }
  const remove = (element, key) => {
    element.dom.removeAttribute(key)
  }

  const isShadowRoot = dos =>
    isDocumentFragment(dos) && isNonNullable(dos.dom.host)
  const supported =
    isFunction(Element.prototype.attachShadow) &&
    isFunction(Node.prototype.getRootNode)
  const getRootNode = supported
    ? e => SugarElement.fromDom(e.dom.getRootNode())
    : documentOrOwner
  const getShadowRoot = e => {
    const r = getRootNode(e)
    return isShadowRoot(r) ? Optional.some(r) : Optional.none()
  }
  const getShadowHost = e => SugarElement.fromDom(e.dom.host)

  const inBody = element => {
    const dom = isText(element) ? element.dom.parentNode : element.dom
    if (dom === undefined || dom === null || dom.ownerDocument === null) {
      return false
    }
    const doc = dom.ownerDocument
    return getShadowRoot(SugarElement.fromDom(dom)).fold(
      () => doc.body.contains(dom),
      compose1(inBody, getShadowHost)
    )
  }

  const ancestor$1 = (scope, predicate, isRoot) => {
    let element = scope.dom
    const stop = isFunction(isRoot) ? isRoot : never
    while (element.parentNode) {
      element = element.parentNode
      const el = SugarElement.fromDom(element)
      if (predicate(el)) {
        return Optional.some(el)
      } else if (stop(el)) {
        break
      }
    }
    return Optional.none()
  }

  const ancestor = (scope, selector, isRoot) =>
    ancestor$1(scope, e => is(e, selector), isRoot)

  const isSupported = dom =>
    dom.style !== undefined && isFunction(dom.style.getPropertyValue)

  const get = (element, property) => {
    const dom = element.dom
    const styles = window.getComputedStyle(dom)
    const r = styles.getPropertyValue(property)
    return r === '' && !inBody(element) ? getUnsafeProperty(dom, property) : r
  }
  const getUnsafeProperty = (dom, property) =>
    isSupported(dom) ? dom.style.getPropertyValue(property) : ''

  const getDirection = element =>
    get(element, 'direction') === 'rtl' ? 'rtl' : 'ltr'

  const children$1 = (scope, predicate) => filter(children$2(scope), predicate)

  const children = (scope, selector) => children$1(scope, e => is(e, selector))

  const getParentElement = element => parent(element).filter(isElement)
  const getNormalizedBlock = (element, isListItem) => {
    const normalizedElement = isListItem
      ? ancestor(element, 'ol,ul')
      : Optional.some(element)
    return normalizedElement.getOr(element)
  }
  const isListItem = isTag('li')
  const setDir = (editor, dir) => {
    const selectedBlocks = editor.selection.getSelectedBlocks()
    if (selectedBlocks.length > 0) {
      each(selectedBlocks, block => {
        const blockElement = SugarElement.fromDom(block)
        const isBlockElementListItem = isListItem(blockElement)
        const normalizedBlock = getNormalizedBlock(
          blockElement,
          isBlockElementListItem
        )
        const normalizedBlockParent = getParentElement(normalizedBlock)
        normalizedBlockParent.each(parent => {
          const parentDirection = getDirection(parent)
          if (parentDirection !== dir) {
            set(normalizedBlock, 'dir', dir)
          } else if (getDirection(normalizedBlock) !== dir) {
            remove(normalizedBlock, 'dir')
          }
          if (isBlockElementListItem) {
            const listItems = children(normalizedBlock, 'li[dir]')
            each(listItems, listItem => remove(listItem, 'dir'))
          }
        })
      })
      editor.nodeChanged()
    }
  }

  const register$1 = editor => {
    editor.addCommand('mceDirectionLTR', () => {
      setDir(editor, 'ltr')
    })
    editor.addCommand('mceDirectionRTL', () => {
      setDir(editor, 'rtl')
    })
  }

  const getNodeChangeHandler = (editor, dir) => api => {
    const nodeChangeHandler = e => {
      const element = SugarElement.fromDom(e.element)
      api.setActive(getDirection(element) === dir)
    }
    editor.on('NodeChange', nodeChangeHandler)
    return () => editor.off('NodeChange', nodeChangeHandler)
  }
  const register = editor => {
    editor.ui.registry.addToggleButton('ltr', {
      tooltip: 'Left to right',
      icon: 'ltr',
      onAction: () => editor.execCommand('mceDirectionLTR'),
      onSetup: getNodeChangeHandler(editor, 'ltr')
    })
    editor.ui.registry.addToggleButton('rtl', {
      tooltip: 'Right to left',
      icon: 'rtl',
      onAction: () => editor.execCommand('mceDirectionRTL'),
      onSetup: getNodeChangeHandler(editor, 'rtl')
    })
  }

  var Plugin = () => {
    global.add('directionality', editor => {
      register$1(editor)
      register(editor)
    })
  }

  Plugin()
})()