beansflight-json-form
Version:
> **版本号:verison 0.23.17**
802 lines (779 loc) • 21.8 kB
JavaScript
/**
* TinyMCE version 6.1.0 (2022-06-29)
*/
;(function () {
'use strict'
var global$1 = tinymce.util.Tools.resolve('tinymce.PluginManager')
const fireInsertCustomChar = (editor, chr) => {
return editor.dispatch('insertCustomChar', { chr })
}
const insertChar = (editor, chr) => {
const evtChr = fireInsertCustomChar(editor, chr).chr
editor.execCommand('mceInsertContent', false, evtChr)
}
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 = type => value => typeOf(value) === type
const isSimpleType = type => value => typeof value === type
const eq = t => a => t === a
const isArray$1 = isType('array')
const isNull = eq(null)
const isNullable = a => a === null || a === undefined
const isNonNullable = a => !isNullable(a)
const isFunction = isSimpleType('function')
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 nativePush = Array.prototype.push
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 findUntil = (xs, pred, until) => {
for (let i = 0, len = xs.length; i < len; i++) {
const x = xs[i]
if (pred(x, i)) {
return Optional.some(x)
} else if (until(x, i)) {
break
}
}
return Optional.none()
}
const find = (xs, pred) => {
return findUntil(xs, pred, never)
}
const flatten = xs => {
const r = []
for (let i = 0, len = xs.length; i < len; ++i) {
if (!isArray$1(xs[i])) {
throw new Error(
'Arr.flatten item ' + i + ' was not an array, input: ' + xs
)
}
nativePush.apply(r, xs[i])
}
return r
}
const bind = (xs, f) => flatten(map(xs, f))
var global = tinymce.util.Tools.resolve('tinymce.util.Tools')
const option = name => editor => editor.options.get(name)
const register$2 = editor => {
const registerOption = editor.options.register
const charMapProcessor = value => isFunction(value) || isArray$1(value)
registerOption('charmap', { processor: charMapProcessor })
registerOption('charmap_append', { processor: charMapProcessor })
}
const getCharMap$1 = option('charmap')
const getCharMapAppend = option('charmap_append')
const isArray = global.isArray
const UserDefined = 'User Defined'
const getDefaultCharMap = () => {
return [
{
name: 'Currency',
characters: [
[36, 'dollar sign'],
[162, 'cent sign'],
[8364, 'euro sign'],
[163, 'pound sign'],
[165, 'yen sign'],
[164, 'currency sign'],
[8352, 'euro-currency sign'],
[8353, 'colon sign'],
[8354, 'cruzeiro sign'],
[8355, 'french franc sign'],
[8356, 'lira sign'],
[8357, 'mill sign'],
[8358, 'naira sign'],
[8359, 'peseta sign'],
[8360, 'rupee sign'],
[8361, 'won sign'],
[8362, 'new sheqel sign'],
[8363, 'dong sign'],
[8365, 'kip sign'],
[8366, 'tugrik sign'],
[8367, 'drachma sign'],
[8368, 'german penny symbol'],
[8369, 'peso sign'],
[8370, 'guarani sign'],
[8371, 'austral sign'],
[8372, 'hryvnia sign'],
[8373, 'cedi sign'],
[8374, 'livre tournois sign'],
[8375, 'spesmilo sign'],
[8376, 'tenge sign'],
[8377, 'indian rupee sign'],
[8378, 'turkish lira sign'],
[8379, 'nordic mark sign'],
[8380, 'manat sign'],
[8381, 'ruble sign'],
[20870, 'yen character'],
[20803, 'yuan character'],
[22291, 'yuan character, in hong kong and taiwan'],
[22278, 'yen/yuan character variant one']
]
},
{
name: 'Text',
characters: [
[169, 'copyright sign'],
[174, 'registered sign'],
[8482, 'trade mark sign'],
[8240, 'per mille sign'],
[181, 'micro sign'],
[183, 'middle dot'],
[8226, 'bullet'],
[8230, 'three dot leader'],
[8242, 'minutes / feet'],
[8243, 'seconds / inches'],
[167, 'section sign'],
[182, 'paragraph sign'],
[223, 'sharp s / ess-zed']
]
},
{
name: 'Quotations',
characters: [
[8249, 'single left-pointing angle quotation mark'],
[8250, 'single right-pointing angle quotation mark'],
[171, 'left pointing guillemet'],
[187, 'right pointing guillemet'],
[8216, 'left single quotation mark'],
[8217, 'right single quotation mark'],
[8220, 'left double quotation mark'],
[8221, 'right double quotation mark'],
[8218, 'single low-9 quotation mark'],
[8222, 'double low-9 quotation mark'],
[60, 'less-than sign'],
[62, 'greater-than sign'],
[8804, 'less-than or equal to'],
[8805, 'greater-than or equal to'],
[8211, 'en dash'],
[8212, 'em dash'],
[175, 'macron'],
[8254, 'overline'],
[164, 'currency sign'],
[166, 'broken bar'],
[168, 'diaeresis'],
[161, 'inverted exclamation mark'],
[191, 'turned question mark'],
[710, 'circumflex accent'],
[732, 'small tilde'],
[176, 'degree sign'],
[8722, 'minus sign'],
[177, 'plus-minus sign'],
[247, 'division sign'],
[8260, 'fraction slash'],
[215, 'multiplication sign'],
[185, 'superscript one'],
[178, 'superscript two'],
[179, 'superscript three'],
[188, 'fraction one quarter'],
[189, 'fraction one half'],
[190, 'fraction three quarters']
]
},
{
name: 'Mathematical',
characters: [
[402, 'function / florin'],
[8747, 'integral'],
[8721, 'n-ary sumation'],
[8734, 'infinity'],
[8730, 'square root'],
[8764, 'similar to'],
[8773, 'approximately equal to'],
[8776, 'almost equal to'],
[8800, 'not equal to'],
[8801, 'identical to'],
[8712, 'element of'],
[8713, 'not an element of'],
[8715, 'contains as member'],
[8719, 'n-ary product'],
[8743, 'logical and'],
[8744, 'logical or'],
[172, 'not sign'],
[8745, 'intersection'],
[8746, 'union'],
[8706, 'partial differential'],
[8704, 'for all'],
[8707, 'there exists'],
[8709, 'diameter'],
[8711, 'backward difference'],
[8727, 'asterisk operator'],
[8733, 'proportional to'],
[8736, 'angle']
]
},
{
name: 'Extended Latin',
characters: [
[192, 'A - grave'],
[193, 'A - acute'],
[194, 'A - circumflex'],
[195, 'A - tilde'],
[196, 'A - diaeresis'],
[197, 'A - ring above'],
[256, 'A - macron'],
[198, 'ligature AE'],
[199, 'C - cedilla'],
[200, 'E - grave'],
[201, 'E - acute'],
[202, 'E - circumflex'],
[203, 'E - diaeresis'],
[274, 'E - macron'],
[204, 'I - grave'],
[205, 'I - acute'],
[206, 'I - circumflex'],
[207, 'I - diaeresis'],
[298, 'I - macron'],
[208, 'ETH'],
[209, 'N - tilde'],
[210, 'O - grave'],
[211, 'O - acute'],
[212, 'O - circumflex'],
[213, 'O - tilde'],
[214, 'O - diaeresis'],
[216, 'O - slash'],
[332, 'O - macron'],
[338, 'ligature OE'],
[352, 'S - caron'],
[217, 'U - grave'],
[218, 'U - acute'],
[219, 'U - circumflex'],
[220, 'U - diaeresis'],
[362, 'U - macron'],
[221, 'Y - acute'],
[376, 'Y - diaeresis'],
[562, 'Y - macron'],
[222, 'THORN'],
[224, 'a - grave'],
[225, 'a - acute'],
[226, 'a - circumflex'],
[227, 'a - tilde'],
[228, 'a - diaeresis'],
[229, 'a - ring above'],
[257, 'a - macron'],
[230, 'ligature ae'],
[231, 'c - cedilla'],
[232, 'e - grave'],
[233, 'e - acute'],
[234, 'e - circumflex'],
[235, 'e - diaeresis'],
[275, 'e - macron'],
[236, 'i - grave'],
[237, 'i - acute'],
[238, 'i - circumflex'],
[239, 'i - diaeresis'],
[299, 'i - macron'],
[240, 'eth'],
[241, 'n - tilde'],
[242, 'o - grave'],
[243, 'o - acute'],
[244, 'o - circumflex'],
[245, 'o - tilde'],
[246, 'o - diaeresis'],
[248, 'o slash'],
[333, 'o macron'],
[339, 'ligature oe'],
[353, 's - caron'],
[249, 'u - grave'],
[250, 'u - acute'],
[251, 'u - circumflex'],
[252, 'u - diaeresis'],
[363, 'u - macron'],
[253, 'y - acute'],
[254, 'thorn'],
[255, 'y - diaeresis'],
[563, 'y - macron'],
[913, 'Alpha'],
[914, 'Beta'],
[915, 'Gamma'],
[916, 'Delta'],
[917, 'Epsilon'],
[918, 'Zeta'],
[919, 'Eta'],
[920, 'Theta'],
[921, 'Iota'],
[922, 'Kappa'],
[923, 'Lambda'],
[924, 'Mu'],
[925, 'Nu'],
[926, 'Xi'],
[927, 'Omicron'],
[928, 'Pi'],
[929, 'Rho'],
[931, 'Sigma'],
[932, 'Tau'],
[933, 'Upsilon'],
[934, 'Phi'],
[935, 'Chi'],
[936, 'Psi'],
[937, 'Omega'],
[945, 'alpha'],
[946, 'beta'],
[947, 'gamma'],
[948, 'delta'],
[949, 'epsilon'],
[950, 'zeta'],
[951, 'eta'],
[952, 'theta'],
[953, 'iota'],
[954, 'kappa'],
[955, 'lambda'],
[956, 'mu'],
[957, 'nu'],
[958, 'xi'],
[959, 'omicron'],
[960, 'pi'],
[961, 'rho'],
[962, 'final sigma'],
[963, 'sigma'],
[964, 'tau'],
[965, 'upsilon'],
[966, 'phi'],
[967, 'chi'],
[968, 'psi'],
[969, 'omega']
]
},
{
name: 'Symbols',
characters: [
[8501, 'alef symbol'],
[982, 'pi symbol'],
[8476, 'real part symbol'],
[978, 'upsilon - hook symbol'],
[8472, 'Weierstrass p'],
[8465, 'imaginary part']
]
},
{
name: 'Arrows',
characters: [
[8592, 'leftwards arrow'],
[8593, 'upwards arrow'],
[8594, 'rightwards arrow'],
[8595, 'downwards arrow'],
[8596, 'left right arrow'],
[8629, 'carriage return'],
[8656, 'leftwards double arrow'],
[8657, 'upwards double arrow'],
[8658, 'rightwards double arrow'],
[8659, 'downwards double arrow'],
[8660, 'left right double arrow'],
[8756, 'therefore'],
[8834, 'subset of'],
[8835, 'superset of'],
[8836, 'not a subset of'],
[8838, 'subset of or equal to'],
[8839, 'superset of or equal to'],
[8853, 'circled plus'],
[8855, 'circled times'],
[8869, 'perpendicular'],
[8901, 'dot operator'],
[8968, 'left ceiling'],
[8969, 'right ceiling'],
[8970, 'left floor'],
[8971, 'right floor'],
[9001, 'left-pointing angle bracket'],
[9002, 'right-pointing angle bracket'],
[9674, 'lozenge'],
[9824, 'black spade suit'],
[9827, 'black club suit'],
[9829, 'black heart suit'],
[9830, 'black diamond suit'],
[8194, 'en space'],
[8195, 'em space'],
[8201, 'thin space'],
[8204, 'zero width non-joiner'],
[8205, 'zero width joiner'],
[8206, 'left-to-right mark'],
[8207, 'right-to-left mark']
]
}
]
}
const charmapFilter = charmap => {
return global.grep(charmap, item => {
return isArray(item) && item.length === 2
})
}
const getCharsFromOption = optionValue => {
if (isArray(optionValue)) {
return charmapFilter(optionValue)
}
if (typeof optionValue === 'function') {
return optionValue()
}
return []
}
const extendCharMap = (editor, charmap) => {
const userCharMap = getCharMap$1(editor)
if (userCharMap) {
charmap = [
{
name: UserDefined,
characters: getCharsFromOption(userCharMap)
}
]
}
const userCharMapAppend = getCharMapAppend(editor)
if (userCharMapAppend) {
const userDefinedGroup = global.grep(
charmap,
cg => cg.name === UserDefined
)
if (userDefinedGroup.length) {
userDefinedGroup[0].characters = []
.concat(userDefinedGroup[0].characters)
.concat(getCharsFromOption(userCharMapAppend))
return charmap
}
return charmap.concat({
name: UserDefined,
characters: getCharsFromOption(userCharMapAppend)
})
}
return charmap
}
const getCharMap = editor => {
const groups = extendCharMap(editor, getDefaultCharMap())
return groups.length > 1
? [
{
name: 'All',
characters: bind(groups, g => g.characters)
}
].concat(groups)
: groups
}
const get = editor => {
const getCharMap$1 = () => {
return getCharMap(editor)
}
const insertChar$1 = chr => {
insertChar(editor, chr)
}
return {
getCharMap: getCharMap$1,
insertChar: insertChar$1
}
}
const Cell = initial => {
let value = initial
const get = () => {
return value
}
const set = v => {
value = v
}
return {
get,
set
}
}
const last = (fn, rate) => {
let timer = null
const cancel = () => {
if (!isNull(timer)) {
clearTimeout(timer)
timer = null
}
}
const throttle = (...args) => {
cancel()
timer = setTimeout(() => {
timer = null
fn.apply(null, args)
}, rate)
}
return {
cancel,
throttle
}
}
const contains = (str, substr) => {
return str.indexOf(substr) !== -1
}
const fromCodePoint = String.fromCodePoint
const charMatches = (charCode, name, lowerCasePattern) => {
if (contains(fromCodePoint(charCode).toLowerCase(), lowerCasePattern)) {
return true
} else {
return (
contains(name.toLowerCase(), lowerCasePattern) ||
contains(name.toLowerCase().replace(/\s+/g, ''), lowerCasePattern)
)
}
}
const scan = (group, pattern) => {
const matches = []
const lowerCasePattern = pattern.toLowerCase()
each(group.characters, g => {
if (charMatches(g[0], g[1], lowerCasePattern)) {
matches.push(g)
}
})
return map(matches, m => ({
text: m[1],
value: fromCodePoint(m[0]),
icon: fromCodePoint(m[0])
}))
}
const patternName = 'pattern'
const open = (editor, charMap) => {
const makeGroupItems = () => [
{
label: 'Search',
type: 'input',
name: patternName
},
{
type: 'collection',
name: 'results'
}
]
const makeTabs = () =>
map(charMap, charGroup => ({
title: charGroup.name,
name: charGroup.name,
items: makeGroupItems()
}))
const makePanel = () => ({
type: 'panel',
items: makeGroupItems()
})
const makeTabPanel = () => ({
type: 'tabpanel',
tabs: makeTabs()
})
const currentTab = charMap.length === 1 ? Cell(UserDefined) : Cell('All')
const scanAndSet = (dialogApi, pattern) => {
find(charMap, group => group.name === currentTab.get()).each(f => {
const items = scan(f, pattern)
dialogApi.setData({ results: items })
})
}
const SEARCH_DELAY = 40
const updateFilter = last(dialogApi => {
const pattern = dialogApi.getData().pattern
scanAndSet(dialogApi, pattern)
}, SEARCH_DELAY)
const body = charMap.length === 1 ? makePanel() : makeTabPanel()
const initialData = {
pattern: '',
results: scan(charMap[0], '')
}
const bridgeSpec = {
title: 'Special Character',
size: 'normal',
body,
buttons: [
{
type: 'cancel',
name: 'close',
text: 'Close',
primary: true
}
],
initialData,
onAction: (api, details) => {
if (details.name === 'results') {
insertChar(editor, details.value)
api.close()
}
},
onTabChange: (dialogApi, details) => {
currentTab.set(details.newTabName)
updateFilter.throttle(dialogApi)
},
onChange: (dialogApi, changeData) => {
if (changeData.name === patternName) {
updateFilter.throttle(dialogApi)
}
}
}
const dialogApi = editor.windowManager.open(bridgeSpec)
dialogApi.focus(patternName)
}
const register$1 = (editor, charMap) => {
editor.addCommand('mceShowCharmap', () => {
open(editor, charMap)
})
}
const init = (editor, all) => {
editor.ui.registry.addAutocompleter('charmap', {
ch: ':',
columns: 'auto',
minChars: 2,
fetch: (pattern, _maxResults) =>
new Promise((resolve, _reject) => {
resolve(scan(all, pattern))
}),
onAction: (autocompleteApi, rng, value) => {
editor.selection.setRng(rng)
editor.insertContent(value)
autocompleteApi.hide()
}
})
}
const register = editor => {
editor.ui.registry.addButton('charmap', {
icon: 'insert-character',
tooltip: 'Special character',
onAction: () => editor.execCommand('mceShowCharmap')
})
editor.ui.registry.addMenuItem('charmap', {
icon: 'insert-character',
text: 'Special character...',
onAction: () => editor.execCommand('mceShowCharmap')
})
}
var Plugin = () => {
global$1.add('charmap', editor => {
register$2(editor)
const charMap = getCharMap(editor)
register$1(editor, charMap)
register(editor)
init(editor, charMap[0])
return get(editor)
})
}
Plugin()
})()